📒 [ TIL ] 2022.07.26_69일차 # 최종 프로젝트 (11)

[ 2022-07-26 (화) 오늘의 TIL ]

[ Today Project ]

drf 백엔드개발 + 프론트개발
: 이번 프로젝트는 팀프로젝트로 시작합니다.

[ Today Learn ]

• 마이페이지 오류 수정
• 아이디 및 모달창 활동 닉네임으로 변경

✏️ 내가 배운것, 얻은것

serializers.py

from rest_framework import serializers
from article.models import (
    Article as ArticleModel,
    Comment as CommentModel,
    CommentLikeBridge,
    ArticleVoteBridge,
)
from user.models import User as User
from user.serializers import UserSerializer

class CommentSerializer(serializers.ModelSerializer):
    comments_related_article = serializers.SerializerMethodField()
    author = serializers.SerializerMethodField()
    count = serializers.SerializerMethodField()
    nickname = serializers.SerializerMethodField()

    def get_comments_related_article(self,obj):
        return obj.article.id

    def get_author(self,obj):
        return obj.comment_author.username

    def get_nickname(self,obj):
        return obj.comment_author.nickname

    def get_count(self,obj):
        like_count = CommentLikeBridge.objects.filter(comment_id=obj.id).count()
        return like_count

    # custum update
    def update(self, instance, validated_data):
        for key, value in validated_data.items():
            if key == "comment_author":
                instance.user(value)
                continue
            setattr(instance, key, value)
        instance.save()
        return instance
    class Meta :
        model = CommentModel
        fields = ['id', 'article', 'author','nickname', 'comment_created_at', 'comment_contents', 'comments_related_article', 'count']

class ArticleSerializer(serializers.ModelSerializer):
    comment_set = CommentSerializer(many=True)
    author = serializers.SerializerMethodField()
    vote = serializers.SerializerMethodField()
    nickname = serializers.SerializerMethodField()


    def get_author(self,obj):
        return obj.article_author.username

    def get_nickname(self,obj):
        return obj.article_author.nickname

    def get_vote(self,obj):
        votes = ArticleVoteBridge.objects.filter(article_id=obj.id)
        votes = list(votes.values())
        vote_count = dict(fox=0, green=0, miss=0)
        for vote in votes:
            if vote['category'] == '폭스입니다':
                vote_count['fox'] += 1
            elif vote['category'] == '그린라이트':
                vote_count['green'] += 1
            else:
                vote_count['miss'] += 1
        return vote_count

    # custum update
    def update(self, instance, validated_data):
        for key, value in validated_data.items():
            if key == "article_author":
                instance.set_author(value)
                continue
            setattr(instance, key, value)
        instance.save()
        return instance
    class Meta:
        model = ArticleModel
        fields = ['id','author','nickname','article_title','article_image', 'board', 'vote',
        'article_contents','article_post_date',
        'article_exposure_date','comment_set', 
        ]

views.py

from rest_framework import permissions, status
from rest_framework.views import APIView
from rest_framework.response import Response
from django.contrib.auth import login, logout, authenticate
from rest_framework_simplejwt.authentication import JWTAuthentication
from user.jwt_claim_serializer import TokenObtainPairSerializer
from rest_framework_simplejwt.views import TokenObtainPairView

from user.models import (
    User as UserModel,
)
from user.serializers import (
    UserSerializer,
)

class UserView(APIView):
    # permission_classes = [permissions.AllowAny]

    def get(self, request):
        user = request.user
        return Response(UserSerializer(user).data)

    # 회원가입
    def post(self, request):
        username = request.data.get("username")
        password = request.data.pop("password")
        password2 = request.data.pop("password2")

        if password == password2:
            user = UserModel(**request.data)
            user.set_password(password)
            user.save()
            return Response({"message": "회원가입 완료!!"}, status=status.HTTP_200_OK)
        elif UserModel.objects.get(username=username):
            return Response({"message":"중복된 아이디입니다."}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
        else:
            return Response({"error": "비밀번호가 일치하지 않습니다."})

    def put(self, request):
        user = UserModel.objects.get(username=request.user)
        if UserModel.objects.filter(nickname=request.data.get("nickname")) == True :
            return Response({"error":"중복된 닉네임입니다."})
        else:
            pass
        password = request.data.pop("password")
        user.password = ""
        user.set_password(password)
        user_serializer = UserSerializer(user, data=request.data, partial=True, context={"request": request})

        if user_serializer.is_valid():
            user_serializer.save()
            return Response(user_serializer.data, status=status.HTTP_200_OK)
        return Response(user_serializer.errors, status=status.HTTP_400_BAD_REQUEST)



        # original_username = request.user
        # username = request.data.get("username")
        # password = request.data.pop("password")
        # nickname = request.data.get("nickname")
        # gender = request.data.get("gender")

        # user = UserModel(**request.data)
        # user.set_password(password)

        # return Response({'message': 'put method!!'})


    def delete(self, request):
        return Response({'message': 'delete method!!'})



class UserApiView(APIView):
    # permission_classes = [permissions.AllowAny]

    # 로그인
    def post(self, request):
        username = request.data.get('username', '')
        password = request.data.get('password', '')
        user = authenticate(request, username=username, password=password)
        if not user:
            return Response({"error": "존재하지 않는 계정이거나 패스워드가 일치하지 않습니다."}, status=status.HTTP_401_UNAUTHORIZED)
        else:
            login(request, user)
            return Response({"message": "로그인 성공!!"}, status=status.HTTP_200_OK)

    # 로그아웃
    def delete(self, request):
        logout(request)
        return Response({"message": "로그아웃 성공!!"}, status=status.HTTP_200_OK)


# jwt 토큰
class TokenObtainPairView(TokenObtainPairView):
    serializer_class = TokenObtainPairSerializer

# 인가된 사용자만 접근할 수 있는 View 생성
class OnlyAuthenticatedUserView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    # JWT 인증방식 클래스 지정하기
    authentication_classes = [JWTAuthentication]

    def get(self, request):
        user = request.user
        print(f"user 정보 : {user}")
        if not user:
            return Response({"error": "접근 권한이 없습니다."}, status=status.HTTP_401_UNAUTHORIZED)            
        return Response(UserSerializer(user).data)