[refactor/WS-12] apiview -> viewset

G-D4R3 · G-D4R3 · commit 24a99f679f90 · 2024-10-01T15:36:51.000+09:00
diff --git a/WAKe_server/settings/base.py b/WAKe_server/settings/base.py
@@ -47,6 +47,7 @@
     "rest_framework",
     "rest_framework_simplejwt",
     "rest_framework_simplejwt.token_blacklist",
+    'drf_spectacular',
     "drf_yasg",
     "storages",
 ]
@@ -162,6 +163,7 @@
     'DEFAULT_PERMISSION_CLASSES': (
         'rest_framework.permissions.AllowAny',  # 누구나 접근
     ),
+    "DEFAULT_SCHEMA_CLASS": "drf_spectacular.openapi.AutoSchema",
 }
 
 #rest auth
diff --git a/records/serializer.py b/records/serializer.py
@@ -25,7 +25,12 @@ class RecordListSerializer(serializers.Serializer):
     records = RecordSerializer(many=True)
 
 
-class RecordCreateSerializer(serializers.Serializer):
+class CreateRecordSerializer(serializers.Serializer):
+    content_id = serializers.IntegerField()
+    text = serializers.CharField(max_length=100, allow_blank=True, allow_null=True)
+
+
+class RecordCreateSerializer(serializers.Serializer):  # todo: deprecated
     content_id = serializers.IntegerField()
     username = serializers.CharField(max_length=20)
     text = serializers.CharField(max_length=100, allow_blank=True, allow_null=True)
diff --git a/records/urls.py b/records/urls.py
@@ -1,16 +1,18 @@
 from django.urls import path
 from rest_framework.routers import SimpleRouter
 
-from records.views import RecordListAPIView, RecordCreateAPIView, ContentViewSet
+from records.views import RecordListAPIView, RecordCreateAPIView, ContentViewSet, RecordViewSet, RandomContentAPIView
 
 app_name = 'records'
 
 router = SimpleRouter()
+router.register("", RecordViewSet, basename="record")
 router.register("content", ContentViewSet, basename="content")
 
 urlpatterns = router.urls
 
 urlpatterns += [
     path("records/list/", RecordListAPIView.as_view(), name="record_list"),
     path("records/create/", RecordCreateAPIView.as_view(), name="record_create"),
+    path("contents/random/", RandomContentAPIView.as_view(), name="content_random"),
 ]
diff --git a/records/views.py b/records/views.py
@@ -4,7 +4,7 @@
 from django.db.models.functions import TruncDate
 from drf_spectacular.utils import extend_schema, OpenApiParameter
 from drf_yasg.utils import swagger_auto_schema
-from rest_framework import viewsets, status
+from rest_framework import viewsets, status, mixins
 from rest_framework.decorators import action
 from rest_framework.generics import ListAPIView, GenericAPIView, CreateAPIView
 from rest_framework.permissions import IsAuthenticated
@@ -13,12 +13,13 @@
 
 from records.models import Record, Content
 from records.serializer import RecordSerializer, ContentSerializer, RecordCreateSerializer, RecordListQuerySerializer, \
-    RandomContentQuerySerializer, RecordListSerializer
+    RandomContentQuerySerializer, RecordListSerializer, CreateRecordSerializer
 from accounts.models import CommonProfile
 from utils.time import KST
 
 
 class ContentViewSet(viewsets.GenericViewSet):
+    model = Record
     serializer_class = ContentSerializer
     permission_classes = [IsAuthenticated]
 
@@ -45,11 +46,138 @@ def random(self, request, *args, **kwargs):
         return Response(serializer.data)
 
 
+@extend_schema(tags=["Record Domain"])
+class RecordViewSet(
+    viewsets.GenericViewSet,
+    mixins.ListModelMixin,
+    mixins.CreateModelMixin):
+    model = Record
+    serializer_class = RecordListSerializer
+    permission_classes = [IsAuthenticated]
+
+    def get_target_dates(self) -> (datetime.date, datetime.date):
+        q_target_date = self.request.query_params.get('target_date')
+        if q_target_date:
+            target_date_end = datetime.datetime.strptime(q_target_date, '%Y-%m-%d').date()
+        else:
+            target_date_end = datetime.datetime.today().astimezone(tz=KST).date()
+        target_date_st = target_date_end - datetime.timedelta(days=6)
+        return target_date_st, target_date_end
+
+    def get_queryset(self):
+        target_date_st, target_date_end = self.get_target_dates()
+
+        queryset = Record.objects.filter(
+            profile__user=self.request.user
+        ).annotate(
+            record_date=TruncDate('created_at', tzinfo=KST)
+        ).filter(
+            record_date__gte=target_date_st,
+            record_date__lte=target_date_end
+        ).select_related(
+            'content'
+        ).order_by(
+            'created_at'
+        )
+
+        return queryset
+
+    @extend_schema(
+        request=RecordCreateSerializer,
+        summary="기록 조회 API",
+        description="기록을 조회합니다.",
+        responses={status.HTTP_200_OK: RecordListSerializer(many=True)},
+    )
+    @swagger_auto_schema(  # todo: extend_schema 적용
+        operation_summary="기록 조회 API",
+        query_serializer=RecordListQuerySerializer,
+        responses={status.HTTP_200_OK: RecordListSerializer(many=True)}
+    )
+    def list(self, request, *args, **kwargs):
+        target_date_st, target_date_end = self.get_target_dates()
+        queryset = self.filter_queryset(self.get_queryset())
+
+        serializer = RecordSerializer(queryset, many=True)
+        records = serializer.data
+
+        results = []
+        while target_date_st <= target_date_end:
+            results.append(dict(
+                date=target_date_st.strftime('%Y-%m-%d'),
+                records=list(filter(
+                    lambda x: datetime.datetime.fromisoformat(x.get('created_at')).astimezone(
+                        KST).date() == target_date_st,
+                    records
+                ))
+            ))
+            target_date_st += datetime.timedelta(days=1)
+        return Response(results)
+
+    @extend_schema(
+        request=RecordCreateSerializer,
+        summary="기록 생성 API",
+        description="기록을 생성합니다.",
+        responses={status.HTTP_201_CREATED: RecordSerializer},
+        exclude=True
+    )
+    @swagger_auto_schema(  # todo: extend_schema 적용
+        operation_summary="기록 생성 API",
+        request_body=CreateRecordSerializer,
+        responses={status.HTTP_201_CREATED: RecordSerializer(many=True)}
+    )
+    def create(self, request, *args, **kwargs):
+        serializer: CreateRecordSerializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        content_id = serializer.validated_data.get('content_id')
+        text = serializer.validated_data.get('text')
+
+        profile = request.user.common_profile
+
+        record = Record.objects.create(
+            content_id=content_id,
+            profile=profile,
+            text=text
+        )
+
+        record_serializer = RecordSerializer(record)
+
+        return Response(record_serializer.data)
+
+
+# deprecated under
+
+
+class RandomContentAPIView(GenericAPIView):
+    serializer_class = ContentSerializer
+
+    def get_prev_filter(self) -> Q:
+        prev = self.request.query_params.get('prev')
+        if not prev:
+            return Q()
+        return ~Q(id=int(prev))
+
+    @swagger_auto_schema(deprecated=True, operation_description="to [GET] api/records/content/random/")
+    def get(self, request: Request):
+        prev_filter = self.get_prev_filter()
+        queryset = Content.objects.filter(
+            prev_filter
+        ).order_by(
+            '?'
+        ).first()
+
+        serializer = self.get_serializer(queryset)
+        return Response(serializer.data)
+
 
 class RecordCreateAPIView(CreateAPIView):
     serializer_class = RecordCreateSerializer
     permission_classes = [IsAuthenticated]
 
+    @swagger_auto_schema(
+        deprecated=True,
+        operation_description="to [POST] api/records/"
+    )
     def post(self, request: Request, *args, **kwargs):
         serializer: RecordCreateSerializer = self.get_serializer(data=request.data)
         serializer.is_valid(raise_exception=True)
@@ -114,13 +242,18 @@ def list(self, request, *args, **kwargs):
             results.append(dict(
                 date=target_date_st.strftime('%Y-%m-%d'),
                 records=list(filter(
-                    lambda x: datetime.datetime.fromisoformat(x.get('created_at')).astimezone(KST).date() == target_date_st,
+                    lambda x: datetime.datetime.fromisoformat(x.get('created_at')).astimezone(
+                        KST).date() == target_date_st,
                     records
                 ))
             ))
             target_date_st += datetime.timedelta(days=1)
         return Response(results)
 
-    @swagger_auto_schema(query_serializer=RecordListQuerySerializer)
+    @swagger_auto_schema(
+        deprecated=True,
+        operation_description="to [GET] api/records/",
+        query_serializer=RecordListQuerySerializer
+    )
     def get(self, request, *args, **kwargs):
         return self.list(request, *args, **kwargs)

Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,7 @@`
`47`	`47`	`"rest_framework",`
`48`	`48`	`"rest_framework_simplejwt",`
`49`	`49`	`"rest_framework_simplejwt.token_blacklist",`
	`50`	`+ 'drf_spectacular',`
`50`	`51`	`"drf_yasg",`
`51`	`52`	`"storages",`
`52`	`53`	`]`
`@@ -162,6 +163,7 @@`
`162`	`163`	`'DEFAULT_PERMISSION_CLASSES': (`
`163`	`164`	`'rest_framework.permissions.AllowAny', # 누구나 접근`
`164`	`165`	`),`
	`166`	`+ "DEFAULT_SCHEMA_CLASS": "drf_spectacular.openapi.AutoSchema",`
`165`	`167`	`}`
`166`	`168`
`167`	`169`	`#rest auth`