Brunobrno
2a26edac80
Introduced a full-featured analytics module for e-commerce business intelligence, including sales, product, customer, shipping, and review analytics, with API endpoints for dashboard and custom reports. Added VAT rate management: new VATRate model, admin interface, serializer, and API endpoints, and integrated VAT logic into Product and pricing calculations. Refactored configuration and admin code to support VAT rates, improved email notification tasks, and updated related serializers, views, and URLs for unified configuration and VAT management.
1097 lines
37 KiB
Python
1097 lines
37 KiB
Python
from rest_framework.views import APIView
|
|
from rest_framework.permissions import AllowAny
|
|
from rest_framework.response import Response
|
|
from rest_framework import status
|
|
import base64
|
|
from datetime import datetime
|
|
from django.utils.dateparse import parse_datetime
|
|
|
|
from .models import Refund, Review
|
|
from .serializers import RefundCreatePublicSerializer, ReviewSerializerPublic
|
|
from .analytics import (
|
|
SalesAnalytics, ProductAnalytics, CustomerAnalytics,
|
|
ShippingAnalytics, ReviewAnalytics, AnalyticsAggregator,
|
|
get_predefined_date_ranges
|
|
)
|
|
|
|
|
|
from django.db import transaction
|
|
from rest_framework import viewsets, mixins, status
|
|
from rest_framework.permissions import AllowAny, IsAdminUser, SAFE_METHODS
|
|
from rest_framework.decorators import action
|
|
from rest_framework.response import Response
|
|
from drf_spectacular.utils import extend_schema, extend_schema_view, OpenApiExample
|
|
from rest_framework import filters, permissions
|
|
from django_filters.rest_framework import DjangoFilterBackend
|
|
|
|
from account.permissions import AdminWriteOnlyOrReadOnly, AdminOnlyForPatchOtherwisePublic
|
|
|
|
from .models import (
|
|
Order,
|
|
OrderItem,
|
|
Carrier,
|
|
Payment,
|
|
Product,
|
|
DiscountCode,
|
|
Category,
|
|
ProductImage,
|
|
Refund,
|
|
Cart,
|
|
CartItem,
|
|
Wishlist,
|
|
)
|
|
from .serializers import (
|
|
OrderReadSerializer,
|
|
OrderMiniSerializer,
|
|
OrderCreateSerializer,
|
|
OrderItemReadSerializer,
|
|
|
|
CarrierReadSerializer,
|
|
PaymentReadSerializer,
|
|
ProductSerializer,
|
|
CategorySerializer,
|
|
ProductImageSerializer,
|
|
DiscountCodeSerializer,
|
|
RefundSerializer,
|
|
|
|
CartSerializer,
|
|
CartItemSerializer,
|
|
CartItemCreateSerializer,
|
|
WishlistSerializer,
|
|
WishlistProductActionSerializer,
|
|
)
|
|
|
|
#FIXME: uravit view na nový order serializer
|
|
@extend_schema_view(
|
|
list=extend_schema(tags=["commerce", "public"], summary="List Orders (public)"),
|
|
retrieve=extend_schema(tags=["commerce", "public"], summary="Retrieve Order (public)"),
|
|
)
|
|
class OrderViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet):
|
|
queryset = Order.objects.select_related("carrier", "payment").prefetch_related(
|
|
"items__product", "discount"
|
|
).order_by("-created_at")
|
|
permission_classes = [AllowAny]
|
|
|
|
def get_serializer_class(self):
|
|
if self.action == "mini":
|
|
return OrderMiniSerializer
|
|
if self.action in ["list", "retrieve"]:
|
|
return OrderReadSerializer
|
|
if self.action == "create":
|
|
return OrderCreateSerializer
|
|
return OrderReadSerializer
|
|
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="Create Order (public)",
|
|
request=OrderCreateSerializer,
|
|
responses={201: OrderReadSerializer},
|
|
examples=[
|
|
OpenApiExample(
|
|
"Create order",
|
|
value={
|
|
"first_name": "Jan",
|
|
"last_name": "Novak",
|
|
"email": "jan@example.com",
|
|
"phone": "+420123456789",
|
|
"address": "Ulice 1",
|
|
"city": "Praha",
|
|
"postal_code": "11000",
|
|
"country": "Czech Republic",
|
|
"note": "Prosím doručit odpoledne",
|
|
"items": [
|
|
{"product_id": 1, "quantity": 2},
|
|
{"product_id": 7, "quantity": 1},
|
|
],
|
|
"carrier": {"shipping_method": "store"},
|
|
"payment": {"payment_method": "stripe"},
|
|
"discount_codes": ["WELCOME10"],
|
|
},
|
|
)
|
|
],
|
|
)
|
|
def create(self, request, *args, **kwargs):
|
|
serializer = OrderCreateSerializer(data=request.data, context={"request": request})
|
|
serializer.is_valid(raise_exception=True)
|
|
order = serializer.save()
|
|
out = OrderReadSerializer(order)
|
|
return Response(out.data, status=status.HTTP_201_CREATED)
|
|
|
|
# -- List mini orders -- (public) --
|
|
@action(detail=False, methods=["get"], url_path="detail")
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="List mini orders (public)",
|
|
responses={200: OrderMiniSerializer(many=True)},
|
|
)
|
|
def mini(self, request, *args, **kwargs):
|
|
qs = self.get_queryset()
|
|
page = self.paginate_queryset(qs)
|
|
|
|
if page is not None:
|
|
ser = OrderMiniSerializer(page, many=True)
|
|
return self.get_paginated_response(ser.data)
|
|
|
|
ser = OrderMiniSerializer(qs, many=True)
|
|
return Response(ser.data)
|
|
|
|
# -- Get order items -- (public) --
|
|
@action(detail=True, methods=["get"], url_path="items")
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="List order items (public)",
|
|
responses={200: OrderItemReadSerializer(many=True)},
|
|
)
|
|
def items(self, request, pk=None):
|
|
order = self.get_object()
|
|
qs = order.items.select_related("product").all()
|
|
ser = OrderItemReadSerializer(qs, many=True)
|
|
return Response(ser.data)
|
|
|
|
# -- Get order carrier -- (public) --
|
|
@action(detail=True, methods=["get"], url_path="carrier")
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="Get order carrier (public)",
|
|
responses={200: CarrierReadSerializer},
|
|
)
|
|
def carrier_detail(self, request, pk=None):
|
|
order = self.get_object()
|
|
ser = CarrierReadSerializer(order.carrier)
|
|
return Response(ser.data)
|
|
|
|
# -- Get order payment -- (public) --
|
|
@action(detail=True, methods=["get"], url_path="payment")
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="Get order payment (public)",
|
|
responses={200: PaymentReadSerializer},
|
|
)
|
|
def payment_detail(self, request, pk=None):
|
|
order = self.get_object()
|
|
ser = PaymentReadSerializer(order.payment)
|
|
return Response(ser.data)
|
|
|
|
# -- Mark carrier ready to pickup(store) (admin) --
|
|
@action(
|
|
detail=True,
|
|
methods=["patch"],
|
|
url_path="carrier/ready-to-pickup",
|
|
permission_classes=[IsAdminUser],
|
|
)
|
|
@extend_schema(
|
|
tags=["commerce"],
|
|
summary="Mark carrier ready to pickup (admin)",
|
|
request=None,
|
|
responses={200: CarrierReadSerializer},
|
|
)
|
|
def carrier_ready_to_pickup(self, request, pk=None):
|
|
order = self.get_object()
|
|
if not order.carrier:
|
|
return Response({"detail": "Carrier not set."}, status=400)
|
|
order.carrier.ready_to_pickup()
|
|
order.carrier.refresh_from_db()
|
|
ser = CarrierReadSerializer(order.carrier)
|
|
return Response(ser.data)
|
|
|
|
# -- Start ordering shipping (admin) --
|
|
@action(
|
|
detail=True,
|
|
methods=["patch"],
|
|
url_path="carrier/start-ordering-shipping",
|
|
permission_classes=[IsAdminUser],
|
|
)
|
|
@extend_schema(
|
|
tags=["commerce"],
|
|
summary="Start ordering shipping (admin)",
|
|
request=None,
|
|
responses={200: CarrierReadSerializer},
|
|
)
|
|
def carrier_start_ordering_shipping(self, request, pk=None):
|
|
order = self.get_object()
|
|
if not order.carrier:
|
|
return Response({"detail": "Carrier not set."}, status=400)
|
|
order.carrier.start_ordering_shipping()
|
|
order.carrier.refresh_from_db()
|
|
ser = CarrierReadSerializer(order.carrier)
|
|
return Response(ser.data)
|
|
|
|
# -- Get user's own orders (authenticated) --
|
|
@action(detail=False, methods=['get'], permission_classes=[permissions.IsAuthenticated])
|
|
@extend_schema(
|
|
tags=["commerce"],
|
|
summary="Get authenticated user's orders",
|
|
responses={200: OrderMiniSerializer(many=True)},
|
|
)
|
|
def my_orders(self, request):
|
|
orders = Order.objects.filter(user=request.user).order_by('-created_at')
|
|
page = self.paginate_queryset(orders)
|
|
if page:
|
|
serializer = OrderMiniSerializer(page, many=True)
|
|
return self.get_paginated_response(serializer.data)
|
|
serializer = OrderMiniSerializer(orders, many=True)
|
|
return Response(serializer.data)
|
|
|
|
# -- Cancel order (authenticated) --
|
|
@action(detail=True, methods=['post'], permission_classes=[permissions.IsAuthenticated])
|
|
@extend_schema(
|
|
tags=["commerce"],
|
|
summary="Cancel order (authenticated user)",
|
|
responses={200: {"type": "object", "properties": {"status": {"type": "string"}}}},
|
|
)
|
|
def cancel(self, request, pk=None):
|
|
order = self.get_object()
|
|
|
|
# Check if user owns order
|
|
if order.user != request.user:
|
|
return Response({'detail': 'Not authorized'}, status=403)
|
|
|
|
# Can only cancel if not shipped
|
|
if order.carrier and order.carrier.state != Carrier.STATE.PREPARING:
|
|
return Response({'detail': 'Cannot cancel shipped order'}, status=400)
|
|
|
|
order.status = Order.OrderStatus.CANCELLED
|
|
order.save()
|
|
|
|
# Restore stock
|
|
for item in order.items.all():
|
|
item.product.stock += item.quantity
|
|
item.product.save()
|
|
|
|
return Response({'status': 'cancelled'})
|
|
|
|
# -- Verify payment (public) --
|
|
@action(detail=True, methods=['post'], url_path='payment/verify')
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="Verify payment status (public)",
|
|
responses={200: {"type": "object", "properties": {
|
|
"order_id": {"type": "integer"},
|
|
"payment_status": {"type": "string"}
|
|
}}},
|
|
)
|
|
def verify_payment(self, request, pk=None):
|
|
order = self.get_object()
|
|
if order.payment and order.payment.payment_method == Payment.PAYMENT.STRIPE:
|
|
if order.payment.stripe:
|
|
return Response({
|
|
'order_id': order.id,
|
|
'payment_status': order.payment.stripe.status
|
|
})
|
|
return Response({
|
|
'order_id': order.id,
|
|
'payment_status': 'unknown'
|
|
})
|
|
|
|
# -- Download invoice (public) --
|
|
@action(detail=True, methods=['get'], url_path='invoice')
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="Download invoice PDF (public)",
|
|
responses={200: "PDF File"},
|
|
)
|
|
def download_invoice(self, request, pk=None):
|
|
from django.http import FileResponse
|
|
order = self.get_object()
|
|
if not order.invoice or not order.invoice.pdf_file:
|
|
return Response({'detail': 'Invoice not available'}, status=404)
|
|
|
|
return FileResponse(
|
|
order.invoice.pdf_file.open('rb'),
|
|
content_type='application/pdf',
|
|
as_attachment=True,
|
|
filename=f'invoice_{order.invoice.invoice_number}.pdf'
|
|
)
|
|
|
|
def retrieve(self, request, *args, **kwargs):
|
|
"""Override retrieve to filter by user if authenticated and not admin"""
|
|
order = self.get_object()
|
|
|
|
# If user is authenticated and not admin, check if they own the order
|
|
if request.user.is_authenticated and not request.user.is_staff:
|
|
if order.user and order.user != request.user:
|
|
return Response({'detail': 'Not found.'}, status=404)
|
|
# Also check by email for anonymous orders
|
|
elif not order.user and order.email != request.user.email:
|
|
return Response({'detail': 'Not found.'}, status=404)
|
|
|
|
serializer = self.get_serializer(order)
|
|
return Response(serializer.data)
|
|
|
|
|
|
# ---------- Public/admin viewsets ----------
|
|
|
|
@extend_schema_view(
|
|
list=extend_schema(tags=["commerce", "public"], summary="List products (public)"),
|
|
retrieve=extend_schema(tags=["commerce", "public"], summary="Retrieve product (public)"),
|
|
create=extend_schema(tags=["commerce"], summary="Create product (auth required)"),
|
|
partial_update=extend_schema(tags=["commerce"], summary="Update product (auth required)"),
|
|
update=extend_schema(tags=["commerce"], summary="Replace product (auth required)"),
|
|
destroy=extend_schema(tags=["commerce"], summary="Delete product (auth required)"),
|
|
)
|
|
class ProductViewSet(viewsets.ModelViewSet):
|
|
queryset = Product.objects.all()
|
|
serializer_class = ProductSerializer
|
|
permission_classes = [permissions.IsAuthenticatedOrReadOnly]
|
|
filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
|
|
filterset_fields = ['category', 'is_active', 'stock', 'price', 'created_at', 'updated_at', 'limited_to']
|
|
search_fields = ["name", "code", "description"]
|
|
ordering_fields = ["price", "name", "created_at", "updated_at", "stock"]
|
|
ordering = ["price"]
|
|
|
|
@action(detail=True, methods=['get'], url_path='availability')
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="Check product availability (public)",
|
|
responses={200: {"type": "object", "properties": {
|
|
"product_id": {"type": "integer"},
|
|
"available": {"type": "boolean"},
|
|
"stock": {"type": "integer"},
|
|
"is_active": {"type": "boolean"}
|
|
}}},
|
|
)
|
|
def check_availability(self, request, pk=None):
|
|
product = self.get_object()
|
|
return Response({
|
|
'product_id': product.id,
|
|
'available': product.available,
|
|
'stock': product.stock,
|
|
'is_active': product.is_active
|
|
})
|
|
|
|
@action(detail=True, methods=['get'], url_path='rating')
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="Get product rating summary (public)",
|
|
responses={200: {"type": "object", "properties": {
|
|
"product_id": {"type": "integer"},
|
|
"average_rating": {"type": "number"},
|
|
"review_count": {"type": "integer"}
|
|
}}},
|
|
)
|
|
def rating_summary(self, request, pk=None):
|
|
from django.db.models import Avg, Count
|
|
product = self.get_object()
|
|
stats = product.reviews.aggregate(
|
|
average=Avg('rating'),
|
|
count=Count('id')
|
|
)
|
|
return Response({
|
|
'product_id': product.id,
|
|
'average_rating': round(stats['average'], 2) if stats['average'] else 0,
|
|
'review_count': stats['count']
|
|
})
|
|
|
|
|
|
@extend_schema_view(
|
|
list=extend_schema(tags=["commerce", "public"], summary="List categories (public)"),
|
|
retrieve=extend_schema(tags=["commerce", "public"], summary="Retrieve category (public)"),
|
|
create=extend_schema(tags=["commerce"], summary="Create category (auth required)"),
|
|
partial_update=extend_schema(tags=["commerce"], summary="Update category (auth required)"),
|
|
update=extend_schema(tags=["commerce"], summary="Replace category (auth required)"),
|
|
destroy=extend_schema(tags=["commerce"], summary="Delete category (auth required)"),
|
|
)
|
|
class CategoryViewSet(viewsets.ModelViewSet):
|
|
queryset = Category.objects.all()
|
|
serializer_class = CategorySerializer
|
|
permission_classes = [permissions.IsAuthenticatedOrReadOnly]
|
|
filter_backends = [filters.SearchFilter, filters.OrderingFilter]
|
|
search_fields = ["name", "description"]
|
|
ordering_fields = ["name", "id"]
|
|
ordering = ["name"]
|
|
|
|
|
|
@extend_schema_view(
|
|
list=extend_schema(tags=["commerce", "public"], summary="List product images (public)"),
|
|
retrieve=extend_schema(tags=["commerce", "public"], summary="Retrieve product image (public)"),
|
|
create=extend_schema(tags=["commerce"], summary="Create product image (auth required)"),
|
|
partial_update=extend_schema(tags=["commerce"], summary="Update product image (auth required)"),
|
|
update=extend_schema(tags=["commerce"], summary="Replace product image (auth required)"),
|
|
destroy=extend_schema(tags=["commerce"], summary="Delete product image (auth required)"),
|
|
)
|
|
class ProductImageViewSet(viewsets.ModelViewSet):
|
|
queryset = ProductImage.objects.all()
|
|
serializer_class = ProductImageSerializer
|
|
permission_classes = [permissions.IsAuthenticatedOrReadOnly]
|
|
filter_backends = [filters.SearchFilter, filters.OrderingFilter]
|
|
search_fields = ["alt_text", "product__name"]
|
|
ordering_fields = ["id", "product__name"]
|
|
ordering = ["-id"]
|
|
|
|
|
|
@extend_schema_view(
|
|
list=extend_schema(tags=["commerce", "public"], summary="List discount codes (public)"),
|
|
retrieve=extend_schema(tags=["commerce", "public"], summary="Retrieve discount code (public)"),
|
|
create=extend_schema(tags=["commerce"], summary="Create discount code (auth required)"),
|
|
partial_update=extend_schema(tags=["commerce"], summary="Update discount code (auth required)"),
|
|
update=extend_schema(tags=["commerce"], summary="Replace discount code (auth required)"),
|
|
destroy=extend_schema(tags=["commerce"], summary="Delete discount code (auth required)"),
|
|
)
|
|
class DiscountCodeViewSet(viewsets.ModelViewSet):
|
|
queryset = DiscountCode.objects.all()
|
|
serializer_class = DiscountCodeSerializer
|
|
permission_classes = [permissions.IsAuthenticatedOrReadOnly]
|
|
filter_backends = [filters.SearchFilter, filters.OrderingFilter]
|
|
search_fields = ["code", "description"]
|
|
ordering_fields = ["percent", "amount", "valid_from", "valid_to"]
|
|
ordering = ["-valid_from"]
|
|
|
|
|
|
# -- Refund (Admin only) --
|
|
@extend_schema_view(
|
|
list=extend_schema(tags=["commerce"], summary="List refunds (admin)"),
|
|
retrieve=extend_schema(tags=["commerce"], summary="Retrieve refund (admin)"),
|
|
create=extend_schema(tags=["commerce"], summary="Create refund (admin)"),
|
|
partial_update=extend_schema(tags=["commerce"], summary="Update refund (admin)"),
|
|
update=extend_schema(tags=["commerce"], summary="Replace refund (admin)"),
|
|
destroy=extend_schema(tags=["commerce"], summary="Delete refund (admin)"),
|
|
)
|
|
class RefundViewSet(viewsets.ModelViewSet):
|
|
queryset = Refund.objects.select_related("order").all().order_by("-created_at")
|
|
serializer_class = RefundSerializer
|
|
permission_classes = [IsAdminUser]
|
|
|
|
|
|
|
|
|
|
|
|
class RefundPublicView(APIView):
|
|
"""Public endpoint to create and fetch refund objects.
|
|
|
|
POST: Create a refund given email and invoice_number or order_id.
|
|
Returns JSON with refund info, order items, and a base64 PDF payload.
|
|
GET: Return a refund object by id (query param `id`).
|
|
"""
|
|
|
|
permission_classes = [AllowAny]
|
|
|
|
def get(self, request):
|
|
rid = request.query_params.get("id")
|
|
if not rid:
|
|
return Response({"detail": "Missing 'id' query parameter."}, status=status.HTTP_400_BAD_REQUEST)
|
|
try:
|
|
refund = Refund.objects.select_related("order").get(id=rid)
|
|
except Refund.DoesNotExist:
|
|
return Response({"detail": "Refund not found."}, status=status.HTTP_404_NOT_FOUND)
|
|
|
|
order = refund.order
|
|
items = []
|
|
for it in order.items.select_related('product').all():
|
|
items.append({
|
|
"product_name": getattr(it.product, "name", "Item"),
|
|
"sku": getattr(it.product, "code", None),
|
|
"quantity": it.quantity,
|
|
})
|
|
|
|
data = {
|
|
"refund": {
|
|
"id": refund.id,
|
|
"order_id": order.id,
|
|
"reason_choice": refund.reason_choice,
|
|
"reason_text": refund.reason_text,
|
|
"verified": refund.verified,
|
|
"created_at": refund.created_at,
|
|
},
|
|
"order": {
|
|
"id": order.id,
|
|
"email": order.email,
|
|
"created_at": order.created_at,
|
|
"items": items,
|
|
},
|
|
}
|
|
return Response(data)
|
|
|
|
def post(self, request):
|
|
serializer = RefundCreatePublicSerializer(data=request.data)
|
|
if not serializer.is_valid():
|
|
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
refund = serializer.save()
|
|
order = refund.order
|
|
|
|
# Build items list for response
|
|
items = []
|
|
for it in order.items.select_related('product').all():
|
|
items.append({
|
|
"product_name": getattr(it.product, "name", "Item"),
|
|
"sku": getattr(it.product, "code", None),
|
|
"quantity": it.quantity,
|
|
})
|
|
|
|
# Generate PDF bytes using model helper
|
|
pdf_bytes = refund.generate_refund_pdf_for_customer()
|
|
pdf_b64 = base64.b64encode(pdf_bytes).decode('ascii')
|
|
|
|
resp = {
|
|
"refund": {
|
|
"id": refund.id,
|
|
"order_id": order.id,
|
|
"reason_choice": refund.reason_choice,
|
|
"reason_text": refund.reason_text,
|
|
"verified": refund.verified,
|
|
"created_at": refund.created_at,
|
|
},
|
|
"order": {
|
|
"id": order.id,
|
|
"email": order.email,
|
|
"created_at": order.created_at,
|
|
"items": items,
|
|
},
|
|
"pdf": {
|
|
"filename": f"refund_{refund.id}.pdf",
|
|
"content_type": "application/pdf",
|
|
"base64": pdf_b64,
|
|
},
|
|
}
|
|
return Response(resp, status=status.HTTP_201_CREATED)
|
|
|
|
|
|
class ReviewPostPublicView(APIView):
|
|
"""Public endpoint to create a review for a product."""
|
|
|
|
permission_classes = [permissions.IsAuthenticated]
|
|
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="Create a product review (public)",
|
|
request=ReviewSerializerPublic,
|
|
responses={201: ReviewSerializerPublic},
|
|
)
|
|
def post(self, request):
|
|
serializer = ReviewSerializerPublic(data=request.data)
|
|
if not serializer.is_valid():
|
|
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
review = serializer.save()
|
|
out = ReviewSerializerPublic(review)
|
|
return Response(out.data, status=status.HTTP_201_CREATED)
|
|
|
|
|
|
# readonly public reviews, admin can patch
|
|
class ReviewPublicViewSet(viewsets.ModelViewSet):
|
|
queryset = Review.objects.all()
|
|
serializer_class = ReviewSerializerPublic
|
|
permission_classes = [AdminOnlyForPatchOtherwisePublic]
|
|
filter_backends = [filters.SearchFilter, filters.OrderingFilter]
|
|
search_fields = ["product__name", "user__username", "comment"]
|
|
ordering_fields = ["rating", "created_at"]
|
|
ordering = ["-created_at"]
|
|
|
|
@action(detail=False, methods=['get'], url_path='product/(?P<product_id>[^/.]+)')
|
|
@extend_schema(
|
|
tags=["commerce", "public"],
|
|
summary="Get reviews for specific product (public)",
|
|
responses={200: ReviewSerializerPublic(many=True)},
|
|
)
|
|
def by_product(self, request, product_id=None):
|
|
reviews = self.get_queryset().filter(product_id=product_id)
|
|
page = self.paginate_queryset(reviews)
|
|
if page:
|
|
serializer = self.get_serializer(page, many=True)
|
|
return self.get_paginated_response(serializer.data)
|
|
serializer = self.get_serializer(reviews, many=True)
|
|
return Response(serializer.data)
|
|
|
|
|
|
# ---------- CART MANAGEMENT ----------
|
|
|
|
@extend_schema_view(
|
|
list=extend_schema(tags=["commerce", "cart"], summary="Get current cart (public)"),
|
|
retrieve=extend_schema(tags=["commerce", "cart"], summary="Get cart by ID (public)"),
|
|
)
|
|
class CartViewSet(viewsets.GenericViewSet):
|
|
"""
|
|
Shopping cart management for authenticated and anonymous users.
|
|
Anonymous users use session_key, authenticated users use their user account.
|
|
"""
|
|
queryset = Cart.objects.prefetch_related('items__product')
|
|
serializer_class = CartSerializer
|
|
permission_classes = [AllowAny]
|
|
|
|
def get_or_create_cart(self, request):
|
|
"""Get or create cart for current user/session"""
|
|
if request.user.is_authenticated:
|
|
cart, _ = Cart.objects.get_or_create(user=request.user)
|
|
else:
|
|
# Use session for anonymous users
|
|
session_key = request.session.session_key
|
|
if not session_key:
|
|
request.session.create()
|
|
session_key = request.session.session_key
|
|
cart, _ = Cart.objects.get_or_create(session_key=session_key)
|
|
return cart
|
|
|
|
@action(detail=False, methods=['get'], url_path='current')
|
|
@extend_schema(
|
|
tags=["commerce", "cart"],
|
|
summary="Get current user's cart",
|
|
responses={200: CartSerializer},
|
|
)
|
|
def current(self, request):
|
|
"""Get the current user's cart"""
|
|
cart = self.get_or_create_cart(request)
|
|
serializer = CartSerializer(cart)
|
|
return Response(serializer.data)
|
|
|
|
@action(detail=False, methods=['post'], url_path='add')
|
|
@extend_schema(
|
|
tags=["commerce", "cart"],
|
|
summary="Add item to cart",
|
|
request=CartItemCreateSerializer,
|
|
responses={200: CartSerializer},
|
|
)
|
|
def add_item(self, request):
|
|
"""Add a product to the cart or update quantity if already exists"""
|
|
serializer = CartItemCreateSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
cart = self.get_or_create_cart(request)
|
|
product_id = serializer.validated_data['product_id']
|
|
quantity = serializer.validated_data['quantity']
|
|
|
|
product = Product.objects.get(pk=product_id)
|
|
|
|
# Check if item already in cart
|
|
cart_item, created = CartItem.objects.get_or_create(
|
|
cart=cart,
|
|
product=product,
|
|
defaults={'quantity': quantity}
|
|
)
|
|
|
|
if not created:
|
|
# Update quantity if item already exists
|
|
cart_item.quantity += quantity
|
|
cart_item.save()
|
|
|
|
cart.refresh_from_db()
|
|
return Response(CartSerializer(cart).data)
|
|
|
|
@action(detail=False, methods=['patch'], url_path='items/(?P<item_id>[^/.]+)')
|
|
@extend_schema(
|
|
tags=["commerce", "cart"],
|
|
summary="Update cart item quantity",
|
|
request={"type": "object", "properties": {"quantity": {"type": "integer"}}},
|
|
responses={200: CartSerializer},
|
|
)
|
|
def update_item(self, request, item_id=None):
|
|
"""Update quantity of a cart item"""
|
|
cart = self.get_or_create_cart(request)
|
|
|
|
try:
|
|
cart_item = CartItem.objects.get(pk=item_id, cart=cart)
|
|
except CartItem.DoesNotExist:
|
|
return Response({'detail': 'Cart item not found'}, status=404)
|
|
|
|
quantity = request.data.get('quantity')
|
|
if quantity is None:
|
|
return Response({'detail': 'Quantity is required'}, status=400)
|
|
|
|
try:
|
|
quantity = int(quantity)
|
|
if quantity < 1:
|
|
return Response({'detail': 'Quantity must be at least 1'}, status=400)
|
|
except ValueError:
|
|
return Response({'detail': 'Invalid quantity'}, status=400)
|
|
|
|
cart_item.quantity = quantity
|
|
cart_item.save()
|
|
|
|
cart.refresh_from_db()
|
|
return Response(CartSerializer(cart).data)
|
|
|
|
@action(detail=False, methods=['delete'], url_path='items/(?P<item_id>[^/.]+)')
|
|
@extend_schema(
|
|
tags=["commerce", "cart"],
|
|
summary="Remove item from cart",
|
|
responses={200: CartSerializer},
|
|
)
|
|
def remove_item(self, request, item_id=None):
|
|
"""Remove an item from the cart"""
|
|
cart = self.get_or_create_cart(request)
|
|
|
|
try:
|
|
cart_item = CartItem.objects.get(pk=item_id, cart=cart)
|
|
cart_item.delete()
|
|
except CartItem.DoesNotExist:
|
|
return Response({'detail': 'Cart item not found'}, status=404)
|
|
|
|
cart.refresh_from_db()
|
|
return Response(CartSerializer(cart).data)
|
|
|
|
@action(detail=False, methods=['post'], url_path='clear')
|
|
@extend_schema(
|
|
tags=["commerce", "cart"],
|
|
summary="Clear all items from cart",
|
|
responses={200: CartSerializer},
|
|
)
|
|
def clear(self, request):
|
|
"""Remove all items from the cart"""
|
|
cart = self.get_or_create_cart(request)
|
|
cart.items.all().delete()
|
|
cart.refresh_from_db()
|
|
return Response(CartSerializer(cart).data)
|
|
|
|
|
|
# ---------- WISHLIST MANAGEMENT ----------
|
|
|
|
@extend_schema_view(
|
|
list=extend_schema(tags=["commerce", "wishlist"], summary="Get current user's wishlist (authenticated)"),
|
|
retrieve=extend_schema(tags=["commerce", "wishlist"], summary="Get wishlist by ID (authenticated)"),
|
|
)
|
|
class WishlistViewSet(viewsets.GenericViewSet):
|
|
"""
|
|
User wishlist management - users can only access their own wishlist
|
|
"""
|
|
queryset = Wishlist.objects.prefetch_related('products')
|
|
serializer_class = WishlistSerializer
|
|
permission_classes = [permissions.IsAuthenticated]
|
|
|
|
def get_queryset(self):
|
|
"""Filter to current user's wishlist only"""
|
|
return self.queryset.filter(user=self.request.user)
|
|
|
|
def get_or_create_wishlist(self):
|
|
"""Get or create wishlist for current user"""
|
|
wishlist, _ = Wishlist.objects.get_or_create(user=self.request.user)
|
|
return wishlist
|
|
|
|
@action(detail=False, methods=['get'], url_path='current')
|
|
@extend_schema(
|
|
tags=["commerce", "wishlist"],
|
|
summary="Get current user's wishlist",
|
|
responses={200: WishlistSerializer},
|
|
)
|
|
def current(self, request):
|
|
"""Get the current user's wishlist"""
|
|
wishlist = self.get_or_create_wishlist()
|
|
serializer = WishlistSerializer(wishlist)
|
|
return Response(serializer.data)
|
|
|
|
@action(detail=False, methods=['post'], url_path='add')
|
|
@extend_schema(
|
|
tags=["commerce", "wishlist"],
|
|
summary="Add product to wishlist",
|
|
request=WishlistProductActionSerializer,
|
|
responses={200: WishlistSerializer},
|
|
)
|
|
def add_product(self, request):
|
|
"""Add a product to the user's wishlist"""
|
|
serializer = WishlistProductActionSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
wishlist = self.get_or_create_wishlist()
|
|
product_id = serializer.validated_data['product_id']
|
|
product = Product.objects.get(pk=product_id)
|
|
|
|
wishlist.add_product(product)
|
|
wishlist.refresh_from_db()
|
|
return Response(WishlistSerializer(wishlist).data)
|
|
|
|
@action(detail=False, methods=['post'], url_path='remove')
|
|
@extend_schema(
|
|
tags=["commerce", "wishlist"],
|
|
summary="Remove product from wishlist",
|
|
request=WishlistProductActionSerializer,
|
|
responses={200: WishlistSerializer},
|
|
)
|
|
def remove_product(self, request):
|
|
"""Remove a product from the user's wishlist"""
|
|
serializer = WishlistProductActionSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
wishlist = self.get_or_create_wishlist()
|
|
product_id = serializer.validated_data['product_id']
|
|
|
|
try:
|
|
product = Product.objects.get(pk=product_id)
|
|
wishlist.remove_product(product)
|
|
except Product.DoesNotExist:
|
|
return Response({'detail': 'Product not found'}, status=404)
|
|
|
|
wishlist.refresh_from_db()
|
|
return Response(WishlistSerializer(wishlist).data)
|
|
|
|
@action(detail=False, methods=['post'], url_path='clear')
|
|
@extend_schema(
|
|
tags=["commerce", "wishlist"],
|
|
summary="Clear all products from wishlist",
|
|
responses={200: WishlistSerializer},
|
|
)
|
|
def clear(self, request):
|
|
"""Remove all products from the user's wishlist"""
|
|
wishlist = self.get_or_create_wishlist()
|
|
wishlist.products.clear()
|
|
wishlist.refresh_from_db()
|
|
return Response(WishlistSerializer(wishlist).data)
|
|
|
|
@action(detail=False, methods=['get'], url_path='check/(?P<product_id>[^/.]+)')
|
|
@extend_schema(
|
|
tags=["commerce", "wishlist"],
|
|
summary="Check if product is in wishlist",
|
|
responses={200: {"type": "object", "properties": {"in_wishlist": {"type": "boolean"}}}},
|
|
)
|
|
def check_product(self, request, product_id=None):
|
|
"""Check if a product is in user's wishlist"""
|
|
wishlist = self.get_or_create_wishlist()
|
|
try:
|
|
product = Product.objects.get(pk=product_id)
|
|
in_wishlist = wishlist.has_product(product)
|
|
return Response({'in_wishlist': in_wishlist})
|
|
except Product.DoesNotExist:
|
|
return Response({'detail': 'Product not found'}, status=404)
|
|
|
|
|
|
@extend_schema_view(
|
|
list=extend_schema(tags=["commerce", "admin"], summary="List all wishlists (admin)"),
|
|
retrieve=extend_schema(tags=["commerce", "admin"], summary="Get wishlist by ID (admin)"),
|
|
update=extend_schema(tags=["commerce", "admin"], summary="Update wishlist (admin)"),
|
|
partial_update=extend_schema(tags=["commerce", "admin"], summary="Partially update wishlist (admin)"),
|
|
destroy=extend_schema(tags=["commerce", "admin"], summary="Delete wishlist (admin)"),
|
|
)
|
|
class AdminWishlistViewSet(viewsets.ModelViewSet):
|
|
"""
|
|
Admin-only wishlist management - can view and modify any user's wishlist
|
|
"""
|
|
queryset = Wishlist.objects.prefetch_related('products').select_related('user')
|
|
serializer_class = WishlistSerializer
|
|
permission_classes = [AdminOnlyForPatchOtherwisePublic]
|
|
filter_backends = [filters.SearchFilter, filters.OrderingFilter]
|
|
search_fields = ["user__email", "user__first_name", "user__last_name"]
|
|
ordering_fields = ["created_at", "updated_at"]
|
|
ordering = ["-updated_at"]
|
|
|
|
|
|
# ---------- ANALYTICS SYSTEM ----------
|
|
|
|
class AnalyticsView(APIView):
|
|
"""
|
|
Comprehensive analytics and reporting API for business intelligence.
|
|
Supports configurable date ranges and various analytics modules.
|
|
|
|
GET /analytics/ - Complete dashboard overview
|
|
GET /analytics/?type=sales - Sales analytics
|
|
GET /analytics/?type=products - Product analytics
|
|
GET /analytics/?type=customers - Customer analytics
|
|
GET /analytics/?type=shipping - Shipping analytics
|
|
GET /analytics/?type=reviews - Review analytics
|
|
GET /analytics/?type=inventory - Inventory analytics
|
|
GET /analytics/?type=ranges - Available date ranges
|
|
POST /analytics/ - Generate custom analytics reports
|
|
"""
|
|
permission_classes = [permissions.IsAdminUser]
|
|
|
|
def _parse_date_params(self, request):
|
|
"""Parse date parameters from request"""
|
|
start_date = request.query_params.get('start_date')
|
|
end_date = request.query_params.get('end_date')
|
|
period = request.query_params.get('period', 'last_30_days')
|
|
|
|
if start_date:
|
|
start_date = parse_datetime(start_date)
|
|
if end_date:
|
|
end_date = parse_datetime(end_date)
|
|
|
|
# If no dates provided, use predefined period
|
|
if not start_date or not end_date:
|
|
predefined_ranges = get_predefined_date_ranges()
|
|
if period in predefined_ranges:
|
|
date_range = predefined_ranges[period]
|
|
start_date = start_date or date_range['start']
|
|
end_date = end_date or date_range['end']
|
|
|
|
return start_date, end_date, period
|
|
|
|
@extend_schema(
|
|
tags=["commerce", "analytics"],
|
|
summary="Get analytics data",
|
|
description="Get various analytics based on type parameter",
|
|
parameters=[
|
|
{"name": "type", "in": "query", "schema": {"type": "string", "enum": ["dashboard", "sales", "products", "customers", "shipping", "reviews", "inventory", "ranges"]}, "description": "Type of analytics to retrieve"},
|
|
{"name": "start_date", "in": "query", "schema": {"type": "string", "format": "date-time"}},
|
|
{"name": "end_date", "in": "query", "schema": {"type": "string", "format": "date-time"}},
|
|
{"name": "period", "in": "query", "schema": {"type": "string", "enum": ["today", "yesterday", "last_7_days", "last_30_days", "last_90_days", "this_month", "last_month", "this_year", "last_year"]}},
|
|
{"name": "limit", "in": "query", "schema": {"type": "integer", "minimum": 1, "maximum": 100}, "description": "Limit for product analytics"}
|
|
]
|
|
)
|
|
def get(self, request):
|
|
"""Get analytics data based on type parameter"""
|
|
analytics_type = request.query_params.get('type', 'dashboard')
|
|
start_date, end_date, period = self._parse_date_params(request)
|
|
|
|
if analytics_type == 'dashboard':
|
|
return self._get_dashboard_analytics(start_date, end_date, period)
|
|
elif analytics_type == 'sales':
|
|
return self._get_sales_analytics(start_date, end_date, period)
|
|
elif analytics_type == 'products':
|
|
return self._get_product_analytics(request, start_date, end_date)
|
|
elif analytics_type == 'customers':
|
|
return self._get_customer_analytics(start_date, end_date)
|
|
elif analytics_type == 'shipping':
|
|
return self._get_shipping_analytics(start_date, end_date)
|
|
elif analytics_type == 'reviews':
|
|
return self._get_review_analytics(start_date, end_date)
|
|
elif analytics_type == 'inventory':
|
|
return self._get_inventory_analytics()
|
|
elif analytics_type == 'ranges':
|
|
return self._get_date_ranges()
|
|
else:
|
|
return Response({'error': 'Invalid analytics type'}, status=400)
|
|
|
|
def _get_dashboard_analytics(self, start_date, end_date, period):
|
|
"""Get complete analytics dashboard overview"""
|
|
dashboard_data = AnalyticsAggregator.dashboard_overview(start_date, end_date)
|
|
dashboard_data['query_params'] = {
|
|
'start_date': start_date.isoformat() if start_date else None,
|
|
'end_date': end_date.isoformat() if end_date else None,
|
|
'period': period
|
|
}
|
|
return Response(dashboard_data)
|
|
|
|
def _get_sales_analytics(self, start_date, end_date, period):
|
|
"""Get detailed sales and revenue analytics"""
|
|
sales_data = SalesAnalytics.revenue_overview(start_date, end_date, period)
|
|
payment_data = SalesAnalytics.payment_methods_breakdown(start_date, end_date)
|
|
|
|
# Calculate percentages for payment methods
|
|
total_revenue = sum(item['revenue'] for item in payment_data)
|
|
for item in payment_data:
|
|
item['percentage'] = round(
|
|
(item['revenue'] / total_revenue * 100) if total_revenue > 0 else 0, 2
|
|
)
|
|
|
|
return Response({
|
|
'sales': sales_data,
|
|
'payment_methods': payment_data
|
|
})
|
|
|
|
def _get_product_analytics(self, request, start_date, end_date):
|
|
"""Get product performance analytics"""
|
|
limit = int(request.query_params.get('limit', 20))
|
|
|
|
top_products = ProductAnalytics.top_selling_products(start_date, end_date, limit)
|
|
category_performance = ProductAnalytics.category_performance(start_date, end_date)
|
|
|
|
return Response({
|
|
'top_products': top_products,
|
|
'category_performance': category_performance
|
|
})
|
|
|
|
def _get_customer_analytics(self, start_date, end_date):
|
|
"""Get customer behavior analytics"""
|
|
customer_overview = CustomerAnalytics.customer_overview(start_date, end_date)
|
|
cart_analysis = CustomerAnalytics.cart_abandonment_analysis()
|
|
|
|
return Response({
|
|
'customer_overview': customer_overview,
|
|
'cart_abandonment': cart_analysis
|
|
})
|
|
|
|
def _get_shipping_analytics(self, start_date, end_date):
|
|
"""Get shipping methods and Deutsche Post analytics"""
|
|
shipping_methods = ShippingAnalytics.shipping_methods_breakdown(start_date, end_date)
|
|
deutsche_post_data = ShippingAnalytics.deutsche_post_analytics()
|
|
|
|
return Response({
|
|
'shipping_methods': shipping_methods,
|
|
'deutsche_post': deutsche_post_data
|
|
})
|
|
|
|
def _get_review_analytics(self, start_date, end_date):
|
|
"""Get review and rating analytics"""
|
|
review_data = ReviewAnalytics.review_overview(start_date, end_date)
|
|
return Response(review_data)
|
|
|
|
def _get_inventory_analytics(self):
|
|
"""Get comprehensive inventory analytics"""
|
|
inventory_data = ProductAnalytics.inventory_analysis()
|
|
return Response(inventory_data)
|
|
|
|
def _get_date_ranges(self):
|
|
"""Get available predefined date ranges"""
|
|
ranges = get_predefined_date_ranges()
|
|
return Response({
|
|
'available_ranges': list(ranges.keys()),
|
|
'ranges': {
|
|
key: {
|
|
'start': value['start'].isoformat(),
|
|
'end': value['end'].isoformat(),
|
|
'display_name': key.replace('_', ' ').title()
|
|
}
|
|
for key, value in ranges.items()
|
|
}
|
|
})
|
|
|
|
@extend_schema(
|
|
tags=["commerce", "analytics"],
|
|
summary="Generate custom analytics report",
|
|
description="Generate custom analytics based on specified modules and parameters",
|
|
request={
|
|
"type": "object",
|
|
"properties": {
|
|
"modules": {"type": "array", "items": {"type": "string", "enum": ["sales", "products", "customers", "shipping", "reviews"]}},
|
|
"start_date": {"type": "string", "format": "date-time"},
|
|
"end_date": {"type": "string", "format": "date-time"},
|
|
"period": {"type": "string", "enum": ["daily", "weekly", "monthly"]},
|
|
"options": {"type": "object"}
|
|
}
|
|
}
|
|
)
|
|
def post(self, request):
|
|
"""Generate custom analytics report based on specified modules"""
|
|
modules = request.data.get('modules', ['sales', 'products'])
|
|
start_date = request.data.get('start_date')
|
|
end_date = request.data.get('end_date')
|
|
period = request.data.get('period', 'daily')
|
|
options = request.data.get('options', {})
|
|
|
|
if start_date:
|
|
start_date = parse_datetime(start_date)
|
|
if end_date:
|
|
end_date = parse_datetime(end_date)
|
|
|
|
# If no dates provided, default to last 30 days
|
|
if not start_date or not end_date:
|
|
predefined_ranges = get_predefined_date_ranges()
|
|
date_range = predefined_ranges.get('last_30_days')
|
|
start_date = start_date or date_range['start']
|
|
end_date = end_date or date_range['end']
|
|
|
|
report_data = {}
|
|
|
|
if 'sales' in modules:
|
|
report_data['sales'] = {
|
|
'revenue': SalesAnalytics.revenue_overview(start_date, end_date, period),
|
|
'payment_methods': SalesAnalytics.payment_methods_breakdown(start_date, end_date)
|
|
}
|
|
|
|
if 'products' in modules:
|
|
limit = options.get('product_limit', 20)
|
|
report_data['products'] = {
|
|
'top_selling': ProductAnalytics.top_selling_products(start_date, end_date, limit),
|
|
'categories': ProductAnalytics.category_performance(start_date, end_date)
|
|
}
|
|
|
|
if 'customers' in modules:
|
|
report_data['customers'] = CustomerAnalytics.customer_overview(start_date, end_date)
|
|
|
|
if 'shipping' in modules:
|
|
report_data['shipping'] = {
|
|
'methods': ShippingAnalytics.shipping_methods_breakdown(start_date, end_date),
|
|
'deutsche_post': ShippingAnalytics.deutsche_post_analytics()
|
|
}
|
|
|
|
if 'reviews' in modules:
|
|
report_data['reviews'] = ReviewAnalytics.review_overview(start_date, end_date)
|
|
|
|
return Response({
|
|
'report': report_data,
|
|
'parameters': {
|
|
'modules': modules,
|
|
'start_date': start_date.isoformat(),
|
|
'end_date': end_date.isoformat(),
|
|
'period': period,
|
|
'generated_at': datetime.now().isoformat()
|
|
}
|
|
})
|
|
|
|
|