인프런 커뮤니티 질문&답변

안녕하세요. 쓰신 코드처럼 create 를 직접 구현하셔서 처리를 해보실 수 있으실텐데, validated_data에는 "file"이 없죠. 왜냐하면 "file" 이름의 시리얼라이저 필드가 없기 때문입니다. 디버거를 활용해서 validated_data 값을 확인해보시면 좋구요.

그러면 파일 데이터는 어떻게 참조할 수 있느냐면. request 객체를 통해서 Raw 파일 데이터를 참조하실 수 있습니다.

아래와 같이 코드를 써볼 수 있습니다. 모델은 다르지만 주석으로 설명도 써뒀으니 참고해보세요. 이미지만 새창으로 열어서 보시면 코드를 보시는 것이 보다 수월하실 겁니다.

화이팅입니다. :-)

안녕하세요.

1:N 관계를 외래키로 지정할 수 있습니다. 이 관계는 1측이 아니라 N측에 세팅을 하여, 어떤 1에 속하는 지를 저장하여야 합니다. 그것이 외래키 관계인 것이죠.

그러니 장고에서는 외래키 관계는 1번 방법은 맞지 않으며, 2번 방법을 써야만 합니다.

화이팅입니다.

덕분에 원하는 기능을 구현했어요

한개의 게시물이 있고 

게시물에는 원하는대로 첨부파일을 넣을수  있는거죠

그리고  원하는대로 삭제하거나 중간만 업데이트 하거나 등등..

근데 이게 업데이트 할때랑 create할때랑 좀 로직이 바뀌어야되는거같아요

 DRF 강력하긴 한데, 너무 강력해서 이게 커스터마이징하는데 투자시간이 너무 많이 드네요 ㅠ

from rest_framework import serializers
from rest_framework.serializers import raise_errors_on_nested_writes
from rest_framework.utils import model_meta

from .models import NoticeBoard, NoticeBoardFile, NoticeBoardComment


class NoticeBoardFileSerializers(serializers.ModelSerializer):
    file = serializers.FileField(use_url=True)

    class Meta:
        model = NoticeBoardFile
        fields = '__all__'

    def to_internal_value(self, data):
        data['name'] = data['file'].name

        return super().to_internal_value(data)

    def to_representation(self, instance):
        representation = super().to_representation(instance)
        representation.update(
            {
                "size": instance.file.size,
            }
        )
        return representation


class NoticeBoardListSerializers(serializers.ModelSerializer):
    author = serializers.CharField(source='author.fullname')

    class Meta:
        model = NoticeBoard
        fields = ['id', 'title', 'is_public', 'updated_at', 'author', 'views']


class NoticeBoardRetrieveSerializers(serializers.ModelSerializer):
    author = serializers.CharField(source='author.fullname')
    noticeboardfile_set = NoticeBoardFileSerializers(many=True)

    class Meta:
        model = NoticeBoard
        fields = '__all__'

    def validate(self, attrs):
        attrs = super().validate(attrs)
        request = self.context['request']
        uploaded_files = []
        if request.data.getlist('file'):
            for uploaded_file in request.data.getlist('file'):
                print(type(uploaded_file))
                # print(uploaded_file.name)
                # serializer = NoticeBoardFileSerializers(data={'file': uploaded_file})
                # serializer.is_valid(raise_exception=True)
                uploaded_files.append(uploaded_file)
                attrs['file'] = uploaded_files
                print(attrs)
            return attrs
        else:
            return attrs

    def update(self, instance, validated_data):
        raise_errors_on_nested_writes('update', self, validated_data)
        info = model_meta.get_field_info(instance)

        uploaded_files = []
        file_object_list = []
        str_list = []
        already_uploaded_file_list = []
        already_uploaded_file_list_temp = NoticeBoardFile.objects.filter(post=instance).values_list('id', flat=True)
        for temp in already_uploaded_file_list_temp:
            already_uploaded_file_list.append(temp)

        print('start', already_uploaded_file_list)
        if 'file' in validated_data:
            uploaded_files = validated_data.pop('file')

        if len(uploaded_files) > 0:
            for uploaded_file in uploaded_files:
                print(uploaded_file, type(uploaded_file))
                if type(uploaded_file) == str:
                    str_list.append(uploaded_file)
                    continue
                else:
                    file_object_list.append(
                        NoticeBoardFile(post=instance, file=uploaded_file, name=uploaded_file.name))
            NoticeBoardFile.objects.bulk_create(file_object_list)
        else:
            NoticeBoardFile.objects.filter(post=instance).delete()

        print(str_list, 'str_list')
        print('already_uploaded_file_list', already_uploaded_file_list)
        for already_uploaded_file in already_uploaded_file_list:
            print(already_uploaded_file)
            if str(already_uploaded_file) in str_list:
                continue
            if not str(already_uploaded_file) in str_list:
                print(already_uploaded_file, '는 없다.')
                NoticeBoardFile.objects.get(id=already_uploaded_file).delete()

        # Simply set each attribute on the instance, and then save it.
        # Note that unlike `.create()` we don't need to treat many-to-many
        # relationships as being a special case. During updates we already
        # have an instance pk for the relationships to be associated with.
        m2m_fields = []
        for attr, value in validated_data.items():
            if attr in info.relations and info.relations[attr].to_many:
                m2m_fields.append((attr, value))
            else:
                setattr(instance, attr, value)

        instance.save()

        # Note that many-to-many fields are set after updating instance.
        # Setting m2m fields triggers signals which could potentially change
        # updated instance and we do not want it to collide with .update()
        for attr, value in m2m_fields:
            field = getattr(instance, attr)
            field.set(value)

        return instance


class NoticeBoardCreateSerializers(serializers.ModelSerializer):
    class Meta:
        model = NoticeBoard
        fields = ['title', 'content', 'author']

    def validate(self, attrs):
        attrs = super().validate(attrs)
        request = self.context['request']
        uploaded_files = []
        if request.data.getlist('file'):
            for uploaded_file in request.data.getlist('file'):
                print(type(uploaded_file))
                print(uploaded_file.name)
                # serializer = NoticeBoardFileSerializers(data={'file': uploaded_file})
                # serializer.is_valid(raise_exception=True)
                uploaded_files.append(uploaded_file)
                attrs['file'] = uploaded_files
            return attrs
        else:
            return attrs

    def create(self, validated_data):
        uploaded_files = []
        file_object_list = []

        if 'file' in validated_data:
            uploaded_files = validated_data.pop('file')

        post = super().create(validated_data)

        if len(uploaded_files) > 0:
            for uploaded_file in uploaded_files:
                file_object_list.append(NoticeBoardFile(post=post, file=uploaded_file, name=uploaded_file.name))
            NoticeBoardFile.objects.bulk_create(file_object_list)

        return post

    def to_representation(self, instance):
        representation = super().to_representation(instance)
        representation.update(
            {
                "id": instance.id,
            }
        )
        return representation

답변 감사합니다.

원하는대로 구현했는데 문제가 있습니다.

model.py

class NoticeBoard(models.Model):
    title = models.CharField(verbose_name='제목', max_length=512)
    content = models.TextField(verbose_name='내용')
    views = models.PositiveIntegerField(default=0, verbose_name='조회수')
    author = models.ForeignKey(AUTH_USER_MODEL, on_delete=models.PROTECT)
    is_public = models.BooleanField(verbose_name='공개 여부', default=True)
    created_at = models.DateTimeField(verbose_name='작성일자', auto_now_add=True)
    updated_at = models.DateTimeField(verbose_name='변경일자', auto_now=True)

    def __str__(self):
        return f'{self.title}'


class NoticeBoardFile(models.Model):
    post = models.ForeignKey(NoticeBoard, on_delete=models.CASCADE)
    filename = models.CharField(verbose_name='파일명', max_length=128, blank=True)
    file = models.FileField(upload_to='files/%Y/%m/%d', blank=True)

    def delete(self, *args, **kwargs):
        if self.file:
            os.remove(os.path.join(settings.MEDIA_ROOT, self.file.path))
        super(NoticeBoardFile, self).delete(*args, **kwargs)

serializers.py

class NoticeBoardFileSerializers(serializers.ModelSerializer):
    file = serializers.FileField(use_url=True)

    class Meta:
        model = NoticeBoardFile
        fields = '__all__'

    def to_internal_value(self, data):
        data['filename'] = data['file'].name

        return super().to_internal_value(data)

    def to_representation(self, instance):
        representation = super().to_representation(instance)
        representation.update(
            {
                "size": instance.file.size,
            }
        )
        return representation

class NoticeBoardCreateSerializers(serializers.ModelSerializer):
    class Meta:
        model = NoticeBoard
        fields = ['title', 'content', 'author']

    def validate(self, attrs):
        attrs = super().validate(attrs)
        request = self.context['request']
        uploaded_files = []
        if request.data.getlist('file'):
            for uploaded_file in request.data.getlist('file'):
                print(type(uploaded_file))
                print(uploaded_file.name)
                # serializer = NoticeBoardFileSerializers(data={'file': uploaded_file})
                # serializer.is_valid(raise_exception=True)
                uploaded_files.append(uploaded_file)
                attrs['file'] = uploaded_files
            return attrs
        else:
            return attrs

    def create(self, validated_data):
        uploaded_files = []
        file_object_list = []

        if 'file' in validated_data:
            uploaded_files = validated_data.pop('file')

        post = super().create(validated_data)

        if len(uploaded_files) > 0:
            for uploaded_file in uploaded_files:
                file_object_list.append(NoticeBoardFile(post=post, file=uploaded_file))
            NoticeBoardFile.objects.bulk_create(file_object_list)

        return post

마지막 시리얼라이즈에서 

 # serializer = NoticeBoardFileSerializers(data={'file': uploaded_file})
 # serializer.is_valid(raise_exception=True)

이 부분을 주석처리 해제하면 에러가 뜨는데 도저히 해결책을 모르겠어요

원하는 기능은 구현했는데 이럴 때 뭐가 문제인지 궁금합니다.

장고 시리얼라이즈 너무 어려워요 ㅠㅠㅠㅠㅠㅠㅠㅠ

아울러 프론트엔드에서 보낼 때는 

fileList를 보내면 str값으로 보내져서

그냥 

formData.append('title', title_value)
formData.append('content', value)
formData.append('author', '0000')
if(files.length > 0){
    files.forEach(file => {
        formData.append('file', file)
    })
}

이런 식으로 보내야되는거 같아요 

def validate(self, attrs):
    attrs = super().validate(attrs)
    

질문 1 

이 validate는 상속받아서 구현하는건 알겠는데

attrs = super().validate(attrs)

이부분은 왜 하는걸까요? ㅠ 진짜 파이썬에 대해서 하나도 모른다는걸 실감하네요 ㅠ

질문 2

self.context['request']

이 부분인데 의미를 더 알고 싶습니다. self.context 이부분이요

질문 3

그럼 로직이 일단 시리얼라이즈가 뷰에서 호출되면 

validate 함수가 발동이 되면서 이걸 호출해서 검증을 해주면 되고 

이 attrs 결과가 validated_data로 들어가는거죠?

질문4

drf에 

serializers.ImageField가 있는데 모델에서 이미지필드가 있다면 따로 적용안해도 되는부분인가요.??

models.py

class NoticeBoard(models.Model):
    title = models.CharField(verbose_name='제목', max_length=512)
    content = models.TextField(verbose_name='내용')
    author = models.ForeignKey(AUTH_USER_MODEL, on_delete=models.PROTECT)
    is_public = models.BooleanField(verbose_name='공개 여부', default=True)
    created_at = models.DateTimeField(verbose_name='작성일자', auto_now_add=True)
    updated_at = models.DateTimeField(verbose_name='변경일자', auto_now=True)

    def __str__(self):
        return f'{self.title}'


class NoticeBoardFile(models.Model):
    post = models.ForeignKey(NoticeBoard, on_delete=models.CASCADE, related_name='noticeboardfile')
    file = models.FileField(upload_to='files/%Y/%m/%d')

serializers.py

class NoticeBoardFileSerializers(serializers.HyperlinkedModelSerializer):
    file = serializers.FileField(use_url=True)

    class Meta:
        model = NoticeBoardFile
        fields = ['post', 'file']


class NoticeBoardSerializers(serializers.ModelSerializer):
    noticeboardfile = NoticeBoardFileSerializers(many=True)

    class Meta:
        model = NoticeBoard
        fields = ['title', 'content', 'author', 'is_public', 'created_at', 'updated_at', 'noticeboardfile']

    def create(self, validated_data):
        files_data = validated_data.pop('file')
        noticeboard = NoticeBoardFile.objects.create(**validated_data)
        for file_data in files_data:
            NoticeBoardFile.objects.create(post_id=noticeboard, **file_data)
        return noticeboard

현재 이렇게 직렬화를 해서 성공은 했는데(모델은 본문의 2와 동일합니다.)

생각해보니 게시판에 게시글을 이렇게 올릴 때 

게시글이 만들어지고나서, 게시글에 첨부파일들을 넣어줘야 되는데

drf로 구현할려니 어렵네요.

프론트엔드에서

사용자가 게시글 1개와 게시글1에 대해 첨부파일 5개를 넣어서 작성버튼을 누르면

백엔드에 요청보낼 때는 NoticeBoard모델에 대해 요청을 보내서

백엔드에서 NoticeBoard모델에 대한 객체를 만들고 응답값으로 NoticeBoard의 주소를 보내주면

다시 프론트엔드에서 NoticeBoard주소 + 파일 데이터(파일 5개)에 대해서 요청을 다시 보내줘야되는가요?

동시에 보내면 파일데이터는 참조할 수 있는 모델이 없기 때문에 처리가 안될거같은데요

제가 생각하는 방식이 맞는지 아니면 동시에 보낼 수 있는지 궁금하네요 보통 어떻게 처리하는지도 궁금하구요 ㅠ

감사합니다. (__)