📒 [ TIL ] 2022.07.18_63일차 # 최종 프로젝트 (5)

# 'DATETIME_FORMAT' 추가 
REST_FRAMEWORK = {
    'DATETIME_FORMAT': "%Y/%m/%d %H:%M",
    'DEFAULT_PERMISSION_CLASSES': [ # 기본적인 view 접근 권한 지정
        'rest_framework.permissions.AllowAny'
    ],
    'DEFAULT_AUTHENTICATION_CLASSES': [ # session 혹은 token을 인증 할 클래스 설정
        'rest_framework.authentication.TokenAuthentication',
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework_simplejwt.authentication.JWTAuthentication',
    ],
    'DEFAULT_PARSER_CLASSES': [ # request.data 속성에 액세스 할 때 사용되는 파서 지정
        'rest_framework.parsers.JSONParser',
        'rest_framework.parsers.FormParser',
        'rest_framework.parsers.MultiPartParser'
    ],
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE':2,
    
}

models.py

from django.db import models
from user.models import User


class ArticleLike(models.Model):
    like_category = models.CharField("공감종류", max_length=50, default="")

class CommentLike(models.Model):
    like_category = models.CharField("공감종류", max_length=50, default="") 
class Vote(models.Model):
    category = models.CharField("공감종류", max_length=50, default="") 
class Article(models.Model):
    article_author = models.ForeignKey('user.User', verbose_name="작성자", on_delete=models.CASCADE)
    board = models.ForeignKey('Board', verbose_name="해당 게시판", on_delete=models.CASCADE)
    article_category = models.ForeignKey('Category', verbose_name="카테고리 종류", on_delete=models.CASCADE, null=True)
    article_title = models.CharField('게시물 제옥', max_length=50)
    article_contents = models.TextField('게시물 내용', max_length=500)
    article_image = models.ImageField('이미지', upload_to="", blank=True)
    article_post_date = models.DateField('게시 일자', auto_now_add=True)
    article_exposure_date = models.DateField('게시 만료 일자', blank=True)
    article_like = models.ManyToManyField(ArticleLike, through='ArticleLikeBridge')
    article_vote = models.ManyToManyField(Vote, through='ArticleVoteBridge')

    def __str__(self):
        return f"{self.article_author.username} 님이 {self.board}에 {self.article_category}태그로 작성한 글입니다."

class Comment(models.Model):
    comment_author = models.ForeignKey('user.User', verbose_name="사용자", on_delete=models.CASCADE)
    article = models.ForeignKey(Article, verbose_name="게시글", on_delete=models.CASCADE)
    comment_contents = models.TextField("내용", max_length=100)
    comment_created_at = models.DateTimeField("생성시간", auto_now_add=True,)
    comment_updated_at = models.DateTimeField("수정시간",auto_now = True,)
    comment_like = models.ManyToManyField(CommentLike, through='CommentLikeBridge')

    def __str__(self):
       return f"{self.comment_author.username} 님이 작성하신 댓글입니다."

class Board(models.Model):
    name = models.CharField("게시판 이름", max_length=50, default="")

    def __str__(self):
       return f"{self.name}"

class Category(models.Model):
    name = models.CharField("게시글 카테고리 이름", max_length=50, default="")

    def __str__(self):
       return f"{self.name}"

class ArticleLikeBridge(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    article = models.ForeignKey(Article, on_delete=models.CASCADE)
    like = models.ForeignKey(ArticleLike, on_delete=models.CASCADE, null=True)
    category = models.CharField("게시글 공감 카테고리 이름", max_length=50, default="")
    

class ArticleVoteBridge(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    article = models.ForeignKey(Article, on_delete=models.CASCADE)
    vote = models.ForeignKey(Vote, on_delete=models.CASCADE, null=True)
    category = models.CharField("게시글 투표 카테고리 이름", max_length=50, default="")

class CommentLikeBridge(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    comment = models.ForeignKey(Comment, on_delete=models.CASCADE)
    like = models.ForeignKey(CommentLike, on_delete=models.CASCADE, null=True)
    category = models.CharField("코멘트 공감 카테고리 이름", max_length=50, default="")

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()

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

    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', 'comment_created_at', 'comment_contents', 'comments_related_article', 'count']

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

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

    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','article_title','category','article_image', 'board', 'vote',
        'article_contents','article_post_date',
        'article_exposure_date','comment_set'
        ]

views.py

from unicodedata import category
from rest_framework.pagination import LimitOffsetPagination
from rest_framework import status
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import permissions

from rest_framework.permissions import IsAuthenticated
from rest_framework.decorators import permission_classes
from rest_framework_simplejwt.authentication import JWTAuthentication


from article.models import (
    Article as ArticleModel,
    Comment as CommentModel,
    Board as BoardModel,
    Category as CategoryModel,
    ArticleLike,
    CommentLike,
    CommentLikeBridge,
    ArticleLikeBridge,
    ArticleVoteBridge,
    Vote as VoteModel
)
from article.serializers import (
    ArticleSerializer,
    CommentSerializer,
)

# 게시글 페이지네이션 리스팅
class ArticlePagination(APIView, LimitOffsetPagination):
    def get(self, request, format=None):
        articles = ArticleModel.objects.all()
        results = self.paginate_queryset(articles, request, view=self)
        serializer = ArticleSerializer(results, many=True)
        return self.get_paginated_response(serializer.data)

# 댓글 페이지네이션 리스팅
class CommentPagination(APIView, LimitOffsetPagination):
    def get(self, request, format=None):
        comments = CommentModel.objects.all()
        results = self.paginate_queryset(comments, request, view=self)
        serializer = CommentSerializer(results, many=True)
        return self.get_paginated_response(serializer.data)

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

    # 모든 게시글 리스팅
    def get(self, request):
        articles = list(ArticleModel.objects.all().order_by("-id"))
        result = ArticleSerializer(articles, many=True).data
        return Response(result) 

    # 게시글 작성
    def post(self, request):
        if request.user.is_anonymous:
            return Response({"error":"글 작성을 위해 로그인을 해주세요."})
        else:
            board = BoardModel.objects.get(name=request.data.get('board'))
            category = CategoryModel.objects.get(name=request.data.get('article_category'))
            article = ArticleModel.objects.create(
                article_author = request.user,
                article_title = request.data.get('article_title',''),
                article_contents = request.data.get('article_contents',''),
                article_image = request.FILES,
                article_exposure_date = request.data.get('article_exposure_date',''),
                board = board,
                article_category = category,
            )
            if len(request.data.get('article_title','')) <= 1 :
                return Response({"error":"title이 1자 이하라면 게시글을 작성할 수 없습니다."})
            elif len(request.data.get('article_contents','')) <= 10 :
                return Response({"error":"contents가 10자 이하라면 게시글을 작성할 수 없습니다."}) 
            else:
                article.save()
                return Response({"message":"게시물 작성 완료!!"})

    # 게시물 업데이트
    def put(self, request, obj_id):
        article = ArticleModel.objects.get(id=obj_id)

        if request.user == article.article_author or request.user.is_admin:
            article_serializer = ArticleSerializer(article, data=request.data, partial=True, context={"request": request})
            if article_serializer.is_valid():
                article_serializer.save()
                return Response(article_serializer.data, status=status.HTTP_200_OK)
            else:
                return Response(article_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        else:
            return Response({"message":"게시글 수정은 게시글 작성자만 할 수 있습니다."})

    # 게시물 삭제
    def delete(self, request, obj_id):
        article = ArticleModel.objects.get(id=obj_id)
        title = article.article_title 
        user = article.article_author
        if request.user == article.article_author or request.user.is_admin:
            ArticleModel.objects.get(id=obj_id).delete()
            return Response({'message': f'{user}님의 {title} 게시글이 삭제되었습니다.'})
        else:
            return Response({"message":"게시글 삭제는 게시글 작성자만 할 수 있습니다."})

# article detail 페이지 article/<obj_id>/detail/
class ArticleDetailView(APIView):

    def get(self, request, obj_id):      
        article = ArticleModel.objects.get(id=obj_id)
        return Response(ArticleSerializer(article).data)
class CommentView(APIView):

    def get(self, request, obj_id):
        return Response(CommentSerializer(obj_id).data)

    # 댓글 작성
    def post(self, request, obj_id):
        if request.user.is_anonymous:
            return Response({"error":"댓글 작성을 위해 로그인을 해주세요."})
        else:
            user = request.user
            request.data['article'] = ArticleModel.objects.get(id=obj_id)
            contents = request.data.get('comment_contents','')

            comment = CommentModel(
                article = request.data['article'],
                comment_author = user,
                comment_contents = contents,
            )
            comment.save()
            return Response({"message":"댓글 작성 완료!"})

    # 댓글 업데이트
    def put(self, request, obj_id):
        data = request.data
        comment = CommentModel.objects.get(id=obj_id)

        if request.user == comment.comment_author or request.user.is_admin:
            comment_serializer = CommentSerializer(comment, data, partial=True, context={"request": request})
            if comment_serializer.is_valid():
                comment_serializer.save()
                return Response(comment_serializer.data, status=status.HTTP_200_OK)
        else:
            return Response({"error":"댓글 수정은 댓글 작성자만 가능합니다."})

    # 댓글 삭제
    def delete(self, request, obj_id):
        comment = CommentModel.objects.get(id=obj_id)
        comment_author = comment.comment_author
        article_author = comment.article.article_author
        if request.user == comment.comment_author or request.user.is_admin or request.user == article_author:
            CommentModel.objects.get(id=obj_id).delete()
            return Response({'message': f'{comment_author}님의 댓글이 삭제되었습니다.'})
        else:
            return Response({'error': '댓글 삭제 권한이 없습니다'})

# 게시글 공감
class ArticleLikeView(APIView):
    authentication_classes = [JWTAuthentication]

    def post(self, request, article_id):
        like = ArticleLike.objects.create()
        article_title = ArticleModel.objects.get(id=article_id)
        all = list(ArticleLikeBridge.objects.all().values())
        print(all)
        all_id = []
        for obj in all:
            all_id.append(obj['user_id'])

        if request.user.id in all_id:
            article_like = ArticleLikeBridge.objects.get(user_id=request.user.id)
            article_like.delete()
            return Response({'message': f'{request.user}님께서 {article_title.article_title}에 공감을 취소하셨습니다.'})
        else:
            article_like = ArticleLikeBridge(
                article_id = article_id,
                user_id = request.user.id,
                like_id = like.id,
                category = request.data.get('category')
        )
            article_like.save()
            return Response({'message': f'{request.user}님께서 {article_title.article_title}에 {article_like.category}하셨습니다.'})

# 게시글 투표
class ArticleVoteBridgeView(APIView):
    authentication_classes = [JWTAuthentication]

    # 게시글 투표 카운트
    def get(self, request, article_id):
        votes = ArticleVoteBridge.objects.filter(article_id=article_id)
        votes = list(votes.values())
        count = dict(fox=0, green=0, miss=0)
        for vote in votes:
            if vote['category'] == '폭스입니다':
                count['fox'] += 1
            elif vote['category'] == '그린라이트':
                count['green'] += 1
            else:
                count['miss'] += 1
        return Response(count)

    def post(self, request, article_id):
        vote = VoteModel.objects.create()
        article_title = ArticleModel.objects.get(id=article_id)
        all = list(ArticleVoteBridge.objects.all().values())
        
        all_id = []
        for obj in all:
            all_id.append(obj['user_id'])
        if request.user.id in all_id:
            article_vote = ArticleVoteBridge.objects.get(user_id=request.user.id)
            article_vote.delete()
            return Response({'message': f'{article_vote.category} 투표 취소..'})
        else:
            article_vote = ArticleVoteBridge(
                article_id = article_id,
                user_id = request.user.id,
                vote_id = vote.id,
                category = request.data.get('category',"")
        )
            article_vote.save()
            return Response({'message': f'{article_vote.category}에 한표!'})

# 댓글 공감
class CommentLikeView(APIView):
    authentication_classes = [JWTAuthentication]

    # 댓글 공감 카운트
    def get(self, request, comment_id):
        like_count = CommentLikeBridge.objects.filter(comment_id=comment_id).count()
        return Response(like_count)

    def post(self, request, comment_id):
        like = CommentLike.objects.create()
        comment = CommentModel.objects.get(id=comment_id)
        contents = comment.comment_contents
        all = list(CommentLikeBridge.objects.all().values())
        all_id = []
        for obj in all:
            all_id.append(obj['user_id'])
        

        if request.user.id in all_id:
            # for i in all:
            #     id = i['comment_id']                
            try:
                CommentLikeBridge.objects.get(comment_id=comment_id)
                comment_like = CommentLikeBridge.objects.get(comment_id=comment_id)
                if comment_like.user_id == request.user.id:
                    comment_like.delete()
                    return Response({'message': f'{request.user}님께서 {contents[0:10]}...댓글에 공감을 취소하셨습니다.'})
            except:
                comment_like = CommentLikeBridge(
                    comment_id = comment_id,
                    user_id = request.user.id,
                    like_id = like.id,
                    category = request.data.get('category')
            )
                comment_like.save()
                return Response({'message': f'{request.user}님께서 {contents[0:10]}...댓글에 {comment_like.category}하셨습니다.'})
        else:
            comment_like = CommentLikeBridge(
                comment_id = comment_id,
                user_id = request.user.id,
                like_id = like.id,
                category = request.data.get('category')
            )
            comment_like.save()
            return Response({'message': f'{request.user}님께서 {contents[0:10]}...댓글에 {comment_like.category}하셨습니다.'})


# 공감순 게시글 탑3 리스팅
class MostLikedArticleView(APIView):
    def get(self, request):
        articles = list(ArticleModel.objects.all().values())
        articles_id = []
        for article in articles:
            articles_id.append(article['id'])
        like_counts = []
        for id in articles_id:
            like_count = ArticleLikeBridge.objects.filter(article_id=id).count()
            like_counts.append(like_count)
        count_list = { name:value for name, value in zip(articles_id, like_counts)}
        like_rank = sorted(count_list.items(), key=lambda x: x[1], reverse=True)[:3]
        first = like_rank[0][0]
        second = like_rank[1][0]
        third = like_rank[2][0]
        ranking = [first, second, third]
        article_rank = ArticleModel.objects.filter(id__in = ranking)
        return Response(ArticleSerializer(article_rank, many=True).data)

# 공감순 댓글 탑3 리스팅
class MostLikedCommentView(APIView):
    def get(self, request):
        comments = list(CommentModel.objects.all().values())
        comments_id = []
        for comment in comments:
            comments_id.append(comment['id'])
        like_counts = []
        for id in comments_id:
            like_count = CommentLikeBridge.objects.filter(comment_id=id).count()
            like_counts.append(like_count)
        count_list = { name:value for name, value in zip(comments_id, like_counts)}
        like_rank = sorted(count_list.items(), key=lambda x: x[1], reverse=True)[:3]
        first = like_rank[0][0]
        second = like_rank[1][0]
        third = like_rank[2][0]
        forth = like_rank[3][0]
        fifth = like_rank[4][0]
        sixth = like_rank[5][0]
        ranking = [first, second, third, forth, fifth, sixth]
        comment_rank = CommentModel.objects.filter(id__in = ranking)
        return Response(CommentSerializer(comment_rank, many=True).data)

# 투표순 탑3 리스팅
class MostVotedArticleView(APIView):
    def get(self, request):
        articles = list(ArticleModel.objects.all().values())
        articles_id = []
        for article in articles:
            articles_id.append(article['id'])
        vote_counts = []
        for id in articles_id:
            vote_count = ArticleVoteBridge.objects.filter(article_id=id).count()
            vote_counts.append(vote_count)
        count_list = { name:value for name, value in zip(articles_id, vote_counts)}
        vote_rank = sorted(count_list.items(), key=lambda x: x[1], reverse=True)[:3]
        first = vote_rank[0][0]
        second = vote_rank[1][0]
        third = vote_rank[2][0]
        ranking = [first, second, third]
        article_rank = ArticleModel.objects.filter(id__in = ranking)
        return Response(ArticleSerializer(article_rank, many=True).data)

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

    # 검색 결과 리스팅
    def post(self, request):
        keywords = request.data.get('search')
        type= request.data.get('type')
        # 내용 검색
        if type == '내용':
            searched_contents = ArticleModel.objects.filter(article_contents__contains=keywords)
            result = ArticleSerializer(searched_contents, many=True).data
            return Response(result) 
        # 작성자 검색
        elif type == '작성자':
            searched_authors = ArticleModel.objects.filter(article_author__username=keywords)
            result = ArticleSerializer(searched_authors, many=True).data
            return Response(result) 
        # 제목 + 내용 검색
        elif type == '제목+내용':
            searched_contents = ArticleModel.objects.filter(article_contents__contains=keywords)
            searched_titles = ArticleModel.objects.filter(article_title__contains=keywords)
            searched = searched_contents.union(searched_titles) 
            result = ArticleSerializer(searched, many=True).data
            return Response(result) 
        # 제목 검색
        else:
            searched_titles = ArticleModel.objects.filter(article_title__contains=keywords)
            result = ArticleSerializer(searched_titles, many=True).data
            return Response(result) 


# 게시판별 아티클 리스팅
class ArticleByBoard(APIView):

    def get(self, request):
        boards = request.query_params.getlist('boards', '')
        results = []
        for board in boards:
            articles = ArticleModel.objects.filter(board=board).order_by("-id")[:5]
            result = ArticleSerializer(articles, many=True).data
            results_data = {
                f"{board}" : result
            }
            results.append(results_data)
        return Response(results)

문명주

하루 한걸음씩 꾸준히 나아가는 개발자🙆‍♀️ https://github.com/Moonmooj

이전 포스트

📒 [ TIL ] 2022.07.15_62일차 # 최종 프로젝트 (4)

다음 포스트

📒 [ TIL ] 2022.07.18_63일차 # 최종 프로젝트 (5)

스파르타코딩클럽-AI웹개발-2회차

[ 2022-07-18 (월) 오늘의 TIL ]

[ Today Project ]

[ Today Learn ]

✏️ 내가 배운것, 얻은것

📒 [ TIL ] 2022.07.15_62일차 # 최종 프로젝트 (4)

📒 [ TIL ] 2022.07.19_64일차 # 최종 프로젝트 (6)

0개의 댓글

관련 채용 정보