feat: QR 코드 조회용 라우트 추가 및 코드 정리

Author: MU-Software

app/admin_api/views/shop/order_notifications.py

@@ -8,7 +8,6 @@
     OrderSendNotificationPreviewResponseSerializer,
     OrderSendNotificationSerializer,
 )
-from admin_api.views.shop.orders import REFUNDABLE_STATUSES
 from core.authz import IsSuperUser
 from core.const.tag import OpenAPITag
 from core.viewset.json_schema_viewset import JsonSchemaViewSet
@@ -17,7 +16,7 @@
 from rest_framework import request, response, status, viewsets
 from rest_framework.decorators import action
 from shop.order.models import Order, OrderProductOptionRelation, OrderProductRelation
-from shop.payment_history.models import PaymentHistory
+from shop.payment_history.models import REFUNDABLE_STATUSES, PaymentHistory
 
 ACTION_METHODS = ["preview", "send"]
 

app/admin_api/views/shop/orders.py

@@ -20,13 +20,12 @@
 from rest_framework.decorators import action
 from shop.order import exports, imports
 from shop.order.models import Order, OrderProductOptionRelation, OrderProductRelation
-from shop.payment_history.models import PaymentHistory, PaymentHistoryStatus
+from shop.payment_history.models import PURCHASED_STATUSES, REFUNDABLE_STATUSES, PaymentHistory
 from shop.product.models import Product
 from shop.serializers.refund import OrderTotalRefundSerializer
 
 logger = getLogger(__name__)
 
-REFUNDABLE_STATUSES = {PaymentHistoryStatus.completed, PaymentHistoryStatus.partial_refunded}
 ADMIN_METHODS = ["list", "retrieve"]
 
 
@@ -164,7 +163,7 @@ def export(self, request: request.Request) -> StreamingHttpResponse:
         product_ids = req.validated_data["product_ids"]
         include_refunded = req.validated_data["include_refunded"]
 
-        statuses = REFUNDABLE_STATUSES | {PaymentHistoryStatus.refunded} if include_refunded else REFUNDABLE_STATUSES
+        statuses = PURCHASED_STATUSES if include_refunded else REFUNDABLE_STATUSES
 
         order_qs = (
             Order.objects.annotate(current_status=PaymentHistory.objects.latest_per_order_field("status"))

app/core/scancode_mixin.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from base64 import urlsafe_b64encode
+from contextlib import suppress
+from functools import cached_property
+from hashlib import sha256
+from hmac import new as hmac_new
+from typing import ClassVar, Self
+from uuid import UUID
+
+from django.conf import settings
+from rest_framework.reverse import reverse
+from shortuuid import decode, encode
+
+
+class ScanCodeMixin:
+    scancode_prefix: ClassVar[str]
+    scancode_uuid_field: ClassVar[str] = "id"
+
+    @property
+    def _scancode_uuid(self) -> UUID:
+        return getattr(self, self.scancode_uuid_field)
+
+    @cached_property
+    def short_id(self) -> str:
+        return encode(self._scancode_uuid)
+
+    @cached_property
+    def salt(self) -> str:
+        hmac_result = hmac_new(settings.SHOP.order_scancode_salt.encode(), self._scancode_uuid.bytes, sha256).digest()
+        return urlsafe_b64encode(hmac_result).decode("utf-8").rstrip("=")
+
+    @cached_property
+    def scancode_token(self) -> str:
+        return f"{self.scancode_prefix}:{self.short_id}:{self.salt}"
+
+    @cached_property
+    def scancode_path(self) -> str:
+        return f"{reverse('v1:scancode-list')}?token={self.scancode_token}"
+
+    @classmethod
+    def from_short_id(cls, short_id: str) -> Self | None:
+        with suppress(ValueError):
+            return cls.objects.filter(**{cls.scancode_uuid_field: decode(short_id)}).first()
+        return None
+
+    @classmethod
+    def from_scancode_token(cls, scancode_token: str) -> Self | None:
+        parts = scancode_token.split(":")
+        if len(parts) != 3:
+            return None
+        prefix, short_id, salt = parts
+        if prefix != cls.scancode_prefix or not (short_id and salt):
+            return None
+        if (instance := cls.from_short_id(short_id)) and instance.salt == salt:
+            return instance
+        return None

app/internal_api/views.py

@@ -58,10 +58,12 @@ class DeskSupportViewSet(
             models.Prefetch(
                 lookup="products",
                 queryset=(
-                    OrderProductRelation.objects.select_related("product").prefetch_related(
+                    OrderProductRelation.objects.filter_active()
+                    .select_related("product")
+                    .prefetch_related(
                         models.Prefetch(
                             lookup="options",
-                            queryset=OrderProductOptionRelation.objects.select_related(
+                            queryset=OrderProductOptionRelation.objects.filter_active().select_related(
                                 "product_option_group", "product_option"
                             ),
                         )
@@ -70,7 +72,7 @@ class DeskSupportViewSet(
             ),
             models.Prefetch(
                 "payment_histories",
-                queryset=PaymentHistory.objects.order_by("-created_at"),
+                queryset=PaymentHistory.objects.filter_active().order_by("-created_at"),
                 to_attr="_payment_histories_by_latest",
             ),
         )

app/shop/order/models.py

@@ -1,23 +1,16 @@
 from __future__ import annotations
 
-import base64
-import contextlib
 import datetime
 import functools
-import hashlib
-import hmac
 import typing
 
 from core.const.shop_error_messages import NotRefundableErrorMessages
 from core.models import BaseAbstractModel, BaseAbstractModelQuerySet
-from core.util.strutil import uuid_to_b64
-from django.conf import settings
+from core.scancode_mixin import ScanCodeMixin
 from django.contrib.auth import get_user_model
 from django.db import models
 from django.db.models.manager import BaseManager
-from rest_framework.reverse import reverse
-from shop.payment_history.models import PaymentHistory
-from shortuuid import decode, encode
+from shop.payment_history.models import PURCHASED_STATUSES, PaymentHistory
 from simple_history.models import HistoricalRecords
 
 UserModel = get_user_model()
@@ -30,8 +23,50 @@ def filter_has_payment_histories(self) -> models.QuerySet[Order]:
     def filter_has_no_payment_histories(self) -> models.QuerySet[Order]:
         return self.filter_active().filter(~models.Exists(PaymentHistory.objects.filter(order=models.OuterRef("id"))))
 
+    def filter_purchased_by(self, user: UserModel) -> models.QuerySet[Order]:
+        """결제 완료/부분환불/환불된 (terminal status) 주문을 user 별로 필터."""
+        return (
+            self.filter_active()
+            .select_related("customer_info")
+            .prefetch_related(
+                models.Prefetch(
+                    lookup="products",
+                    queryset=OrderProductRelation.objects.filter_active()
+                    .select_related("product")
+                    .prefetch_related(
+                        models.Prefetch(
+                            lookup="options",
+                            queryset=OrderProductOptionRelation.objects.filter_active().select_related(
+                                "product_option_group",
+                                "product_option",
+                            ),
+                        ),
+                    ),
+                ),
+                models.Prefetch(
+                    "payment_histories",
+                    queryset=PaymentHistory.objects.filter_active().order_by("-created_at"),
+                    to_attr="_payment_histories_by_latest",
+                ),
+            )
+            .annotate(
+                current_status=(
+                    PaymentHistory.objects.filter(order_id=models.OuterRef("id"), status__in=PURCHASED_STATUSES)
+                    .order_by("-created_at")
+                    .values_list("status", flat=True)[:1]
+                ),
+            )
+            .filter(user=user, current_status__in=PURCHASED_STATUSES)
+            .order_by("-created_at")
+        )
+
+    def filter_in_last_six_months(self) -> models.QuerySet[Order]:
+        return self.filter(created_at__gte=datetime.date.today() - datetime.timedelta(days=183))
+
+
+class Order(ScanCodeMixin, BaseAbstractModel):
+    scancode_prefix = "order"
 
-class Order(BaseAbstractModel):
     user = models.ForeignKey(UserModel, on_delete=models.PROTECT)
     name = models.TextField()
 
@@ -42,7 +77,7 @@ class Order(BaseAbstractModel):
     prefetchs = {
         "_payment_histories_by_latest": models.Prefetch(
             "payment_histories",
-            queryset=PaymentHistory.objects.order_by("-created_at"),
+            queryset=PaymentHistory.objects.filter_active().order_by("-created_at"),
             to_attr="_payment_histories_by_latest",
         ),
     }
@@ -103,24 +138,6 @@ def is_cart(self) -> bool:
 
         return self.current_status == PaymentHistoryStatus.pending
 
-    @property
-    def short_id(self) -> str:
-        """
-        주문 ID를 base64로 인코딩한 문자열을 반환. QR 코드 생성에 사용됩니다.
-        (주문 ID의 길이를 줄여 QR 코드를 단순화하기 위함 - 길이가 길면 QR 코드가 복잡해짐)
-        """
-        return uuid_to_b64(self.id)
-
-    @property
-    def scancode_token(self) -> str:
-        salted_order_id = f"{self.id}{settings.SHOP.order_scancode_salt}".encode()
-        return hashlib.sha256(salted_order_id).hexdigest()
-
-    @property
-    def scancode_path(self) -> str:
-        base_path = reverse("v1:orders-retrieve-scancode", kwargs={"order_id": self.id})
-        return f"{base_path}?token={self.scancode_token}"
-
     @property
     def not_fully_refundable_reason(self) -> str | None:
         """
@@ -173,7 +190,9 @@ def not_fully_refundable_reason(self) -> str | None:
         return None
 
 
-class OrderProductRelation(BaseAbstractModel):
+class OrderProductRelation(ScanCodeMixin, BaseAbstractModel):
+    scancode_prefix = "opr"
+
     class OrderProductStatus(models.TextChoices):
         pending = "pending", "결제 대기 중"
         paid = "paid", "결제 완료"
@@ -197,48 +216,6 @@ class OrderProductStatus(models.TextChoices):
     def __str__(self) -> str:
         return f"[{self.order}] {self.product} ({self.get_status_display()})"
 
-    @functools.cached_property
-    def short_id(self) -> str:
-        return encode(self.id)
-
-    @functools.cached_property
-    def salt(self) -> str:
-        hmac_result = hmac.new(settings.SHOP.order_scancode_salt.encode(), self.id.bytes, hashlib.sha256).digest()
-        return base64.urlsafe_b64encode(hmac_result).decode("utf-8").rstrip("=")
-
-    @functools.cached_property
-    def scancode_token(self) -> str:
-        return f"opr:{self.short_id}:{self.salt}"
-
-    @functools.cached_property
-    def scancode_path(self) -> str:
-        return f"{reverse('v1:order-products-scancode-list')}?token={self.scancode_token}"
-
-    @classmethod
-    def from_short_id(cls, short_id: str) -> OrderProductRelation | None:
-        with contextlib.suppress(ValueError):
-            return cls.objects.filter(id=decode(short_id)).first()
-
-        return None
-
-    @classmethod
-    def from_scancode_token(cls, scancode_token: str) -> OrderProductRelation | None:
-        splitted_token = scancode_token.split(":")
-        if len(splitted_token) != 3:
-            return None
-
-        prefix, short_id, salt = splitted_token
-        if prefix != "opr":
-            return None
-
-        if not (short_id and salt):
-            return None
-
-        if (opr := cls.from_short_id(short_id)) and opr.salt == salt:
-            return opr
-
-        return None
-
     @property
     def not_refundable_reason(self) -> str | None:
         """

app/shop/order/serializers/dto.py

@@ -1,4 +1,3 @@
-from typing import cast
 from urllib.parse import urljoin
 
 from django.conf import settings
@@ -127,43 +126,3 @@ class Meta:
             "customer_info",
         )
         model = SingleProductCart
-
-
-class OrderProductScanCodeDto(serializers.ModelSerializer):
-    class SimpleOrderDto(serializers.ModelSerializer):
-        class Meta:
-            fields = ("id", "first_paid_at")
-            model = Order
-
-    class SimpleProductDto(serializers.ModelSerializer):
-        class Meta:
-            fields = ("id", "name")
-            model = Product
-
-    class SimpleOptionDto(serializers.ModelSerializer):
-        name = serializers.CharField(source="product_option_group.name")
-        value = serializers.SerializerMethodField()
-
-        class Meta:
-            model = OrderProductOptionRelation
-            fields = ("name", "value")
-
-        def get_value(self, obj: OrderProductOptionRelation) -> str:
-            if obj.product_option_group.is_custom_response:
-                return obj.custom_response or "-"
-
-            if option := cast(Option, obj.product_option):
-                result = option.name
-                if option.additional_price > 0:
-                    result += f" (+{option.additional_price}원)"
-                return result
-
-            return "-"
-
-    order = SimpleOrderDto()
-    product = SimpleProductDto()
-    options = SimpleOptionDto(many=True)
-
-    class Meta:
-        fields = ("id", "order", "product", "options")
-        model = OrderProductRelation