gold eggs backend

core/apps/eggs/views/__init__.py

@@ -0,0 +1,24 @@
+from .add_courier import *  # noqa
+from .add_debt import *  # noqa
+from .add_market import *  # noqa
+from .additional_cost import *  # noqa
+from .all_history import *  # noqa
+from .benefit import *  # noqa
+from .broken import *  # noqa
+from .courier import *  # noqa
+from .courier_history import *  # noqa
+from .courier_product import *  # noqa
+from .debt import *  # noqa
+from .debt_list import *  # noqa
+from .delete_account import *  # noqa
+from .group import *  # noqa
+from .history import *  # noqa
+from .market import *  # noqa
+from .monitoring import *  # noqa
+from .order import *  # noqa
+from .party import *  # noqa
+from .product import *  # noqa
+from .sklad import *  # noqa
+from .top_couriers import *  # noqa
+from .top_products import *  # noqa
+from .daily_cost import *  # noqa

core/apps/eggs/views/add_courier.py

@@ -0,0 +1,20 @@
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticated
+
+from core.apps.eggs.models import User
+from core.apps.eggs.serializers.add_courier import (
+    AddCourierSerializer,
+    CouriersListSerializer,
+)
+from core.http.permissions import IsRole
+
+
+class AddCourierViewSet(viewsets.ModelViewSet):
+    permission_classes = [IsAuthenticated, IsRole(["admin"])]
+    queryset = User.objects.filter(role="courier")
+
+    def get_serializer_class(self):
+        if self.request.method == "GET":
+            return CouriersListSerializer
+        else:
+            return AddCourierSerializer

core/apps/eggs/views/add_debt.py

@@ -0,0 +1,113 @@
+from decimal import Decimal
+
+from core.apps.eggs.models.debt import Debt, DebtTypeEnum
+from drf_yasg import openapi
+from drf_yasg.utils import swagger_auto_schema
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from core.apps.eggs.models import History, Monitoring, Notification
+from core.apps.eggs.models.market import Market
+from core.http.models import User
+from core.apps.eggs.tasks.send_sms import send_sms_msg
+
+
+class AddDebtView(APIView):
+    @swagger_auto_schema(
+        request_body=openapi.Schema(
+            type=openapi.TYPE_OBJECT,
+            properties={
+                "market_id": openapi.Schema(
+                    type=openapi.TYPE_INTEGER,
+                    description="Market ID",
+                ),
+                "price": openapi.Schema(
+                    type=openapi.TYPE_NUMBER,
+                    description="Price",
+                ),
+            },
+        ),
+        responses={
+            200: openapi.Schema(
+                type=openapi.TYPE_OBJECT,
+                properties={
+                    "message": openapi.Schema(
+                        type=openapi.TYPE_STRING,
+                        description="Debt added successfully.",
+                    ),
+                },
+            ),
+            400: openapi.Schema(
+                type=openapi.TYPE_OBJECT,
+                properties={
+                    "error": openapi.Schema(
+                        type=openapi.TYPE_STRING,
+                        description="Detailed error message when the request fails with a 400 status code.",
+                    ),
+                },
+            ),
+            404: openapi.Schema(
+                type=openapi.TYPE_OBJECT,
+                properties={
+                    "error": openapi.Schema(
+                        type=openapi.TYPE_STRING,
+                        description="Detailed error message when the request fails with a 404 status code.",
+                    ),
+                },
+            ),
+        },
+    )
+    def post(self, request, *args, **kwargs):
+        market_id = request.data.get("market_id")
+        price = Decimal(request.data.get("price"))
+
+        if not all([market_id, price]):
+            return Response(
+                {"error": "Both market_id and price are required."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        try:
+            market = Market.objects.get(pk=market_id)
+        except Market.DoesNotExist:
+            return Response(
+                {"error": "Market with given id does not exist."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        Debt.objects.create(
+            market=market, debt_price=price, debt_type=DebtTypeEnum.ADDED.value
+        )
+
+        History.objects.create(
+            content_object=market,
+            action="add_debt_created",
+            user_id=request.user,
+            comment=f"Qarz qo'shildi: {price}",
+            avatar=market.avatar,
+            reason=f"Qarz qo'shildi: {price}",
+            created_by=market.name,
+            created_who=f"{request.user.first_name} {request.user.last_name}",
+        )
+        notification_users = User.objects.filter(role="admin")
+        for user in notification_users:
+            Notification.objects.create(
+                user=user,
+                title=f"Qarz muvaffaqiyatli qo'shildi {price} so'm",
+                body=f"Qarz muvaffaqiyatli qo'shildi {market.name} ga {price} so'm",
+            )
+
+        message = f"Hurmatli {market.user_id.first_name} {market.user_id.last_name}, Sizning  Gold-eggs.uz tuxum yetkazib berish xizmati ilovasidagi xaridingizga {price} so'm qarz qo'shib qo'yildi Umumiy balans: {market.debt_unpaid} so'm Batafsil: +998914249515"
+
+        send_sms_msg.delay(market.user_id.phone, message)
+
+        return Response(
+            {
+                "message": "Qarz muvaffaqiyatli qo'shildi.",
+                "debt_unpaid": f"{market.debt_unpaid}",
+                "market_name": f"{market.name}",
+                "market_company": f"{market.company_name}",
+            },
+            status=status.HTTP_200_OK,
+        )

core/apps/eggs/views/add_market.py

@@ -0,0 +1,13 @@
+from rest_framework import viewsets
+from core.apps.eggs.models import Market
+from core.apps.eggs.serializers.add_market import AddMarketSerializer
+from core.http.permissions import IsRole
+
+
+class AddMarketView(viewsets.ModelViewSet):
+    queryset = Market.objects.all()
+    serializer_class = AddMarketSerializer
+    permission_classes = [IsRole(["admin"])]
+
+    def perform_create(self, serializer):
+        serializer.save()

core/apps/eggs/views/additional_cost.py

@@ -0,0 +1,76 @@
+from rest_framework import generics, status, permissions
+from rest_framework.response import Response
+
+from core.apps.eggs.models import AdditionalCost
+from core.apps.eggs.serializers import AdditionalCostSerializer
+
+
+class AdditionalCostView(generics.GenericAPIView):
+    queryset = AdditionalCost.objects.all()
+    serializer_class = AdditionalCostSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get(self, request, *args, **kwargs):
+        queryset = self.get_queryset()
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)
+
+    def post(self, request, *args, **kwargs):
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
+        return Response(
+            {
+                "message": "Qo'shimcha xarajat muvaffaqiyatli kiritildi.",
+                "data": serializer.data,
+            },
+            status=status.HTTP_201_CREATED,
+        )
+
+
+# from collections import defaultdict
+# from datetime import datetime
+# from rest_framework import generics, status, permissions
+# from rest_framework.response import Response
+#
+# from core.apps.eggs.models import AdditionalCost
+# from core.apps.eggs.serializers import AdditionalCostSerializer
+#
+#
+# class AdditionalCostView(generics.GenericAPIView):
+#     queryset = AdditionalCost.objects.all()
+#     serializer_class = AdditionalCostSerializer
+#     permission_classes = [permissions.IsAuthenticated]
+#
+#     def get(self, request, *args, **kwargs):
+#         queryset = self.get_queryset()
+#         grouped_data = defaultdict(lambda: {"total_price": 0, "additional_costs": []})
+#
+#         for cost in queryset:
+#             month_year = cost.created_at.strftime("%m-%Y")
+#             grouped_data[month_year]["total_price"] += cost.price
+#             grouped_data[month_year]["additional_costs"].append(cost)
+#
+#         response_data = []
+#         for month_year, data in grouped_data.items():
+#             month, year = month_year.split("-")
+#             response_data.append({
+#                 "month": month,
+#                 "year": year,
+#                 "total_price": data["total_price"],
+#                 "additional_costs": AdditionalCostSerializer(data["additional_costs"], many=True).data
+#             })
+#
+#         return Response(response_data)
+#
+#     def post(self, request, *args, **kwargs):
+#         serializer = self.get_serializer(data=request.data)
+#         serializer.is_valid(raise_exception=True)
+#         serializer.save()
+#         return Response(
+#             {
+#                 "message": "Qo'shimcha xarajat muvaffaqiyatli kiritildi.",
+#                 "data": serializer.data,
+#             },
+#             status=status.HTTP_201_CREATED,
+#         )

core/apps/eggs/views/all_history.py

@@ -0,0 +1,11 @@
+from rest_framework import viewsets
+from core.apps.eggs.models.all_history import AllHistory
+from core.apps.eggs.serializers.all_history import AllHistorySerializer
+from core.http.permissions import IsRole
+
+
+class AllHistoryViewSet(viewsets.ModelViewSet):
+    queryset = AllHistory.objects.all()
+    serializer_class = AllHistorySerializer
+    permission_classes = [IsRole(["admin"])]
+    http_method_names = ["get"]

core/apps/eggs/views/benefit.py

@@ -0,0 +1,11 @@
+from django.http import JsonResponse
+from rest_framework.views import APIView
+
+from core.apps.eggs.models import Party
+
+
+class MonthlyBenefitView(APIView):
+
+    def get(self, request, *args, **kwargs):
+        monthly_benefit = Party.get_total_benefit()
+        return JsonResponse(list(monthly_benefit), safe=False)

core/apps/eggs/views/broken.py

@@ -0,0 +1,11 @@
+from rest_framework import viewsets
+from core.apps.eggs.models import Broken
+from core.apps.eggs.serializers import BrokenSerializer
+from core.http.permissions import IsRole
+
+
+class BrokenViewSet(viewsets.ModelViewSet):
+    queryset = Broken.objects.all()
+    serializer_class = BrokenSerializer
+    http_method_names = ["get", "post", "put", "patch", "delete"]
+    permission_classes = [IsRole(["admin", "sklad", "courier"])]

core/apps/eggs/views/courier.py

@@ -0,0 +1,16 @@
+"""
+Courier view
+"""
+
+from rest_framework import viewsets
+
+from core.apps.eggs import models
+from core.apps.eggs import serializers
+from core.http.permissions import IsRole
+
+
+class CourierViewSet(viewsets.ModelViewSet):
+    queryset = models.Courier.objects.all()
+    serializer_class = serializers.CourierSerializer
+    http_method_names = ["get", "post", "put", "patch", "delete"]
+    permission_classes = [IsRole(["courier", "admin"])]

core/apps/eggs/views/courier_history.py

@@ -0,0 +1,25 @@
+"""
+Courier History view
+"""
+
+from rest_framework import viewsets
+
+from core.apps.eggs import models
+from core.apps.eggs import serializers
+from core.http.permissions import IsRole
+
+
+class CourierHistoryViewSet(viewsets.ModelViewSet):
+    serializer_class = serializers.CourierHistorySerializer
+    http_method_names = ["get"]
+    permission_classes = [IsRole(["admin", "courier"])]
+
+    def get_queryset(self):
+        """
+        This view should return a list of all the courier history
+        for the currently authenticated user.
+        """
+        user = self.request.user
+        if user.role == "courier":
+            return models.CourierHistory.objects.filter(courier_id=user.id)
+        return models.CourierHistory.objects.all()

core/apps/eggs/views/courier_product.py

@@ -0,0 +1,58 @@
+"""
+Courier Product view
+"""
+
+from rest_framework import response, status, viewsets
+
+from core.apps.eggs import models, serializers
+from core.http.permissions import IsRole
+
+
+class CourierProductViewSet(viewsets.ModelViewSet):
+    http_method_names = ["get", "post", "put", "patch", "delete"]
+    permission_classes = [IsRole(["courier"])]
+
+    def get_queryset(self):
+        user = self.request.user
+        return models.CourierProduct.objects.filter(
+            courier_id__user_id=user.id
+        )
+
+    def get_serializer_class(self):
+        if self.request.method == "GET":
+            return serializers.CourierProductSerializer
+        return serializers.CourierProductReturnSerializer
+
+
+class ReturnEggsViewSet(viewsets.ViewSet):
+    permission_classes = [IsRole(["courier"])]
+
+    def update(self, request, pk=None):
+        courier_products = models.CourierProduct.objects.filter(
+            courier_id__user_id=request.user.id
+        )
+
+        if not courier_products.exists():
+            return response.Response(
+                {"error": "No products found for this courier."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        for courier_product in courier_products:
+            courier_product.group_id.quantity += courier_product.count
+            courier_product.group_id.party_id.courier_eggs -= (
+                courier_product.count
+            )
+            courier_product.group_id.party_id.remaining_count += (
+                courier_product.count
+            )
+            courier_product.return_eggs = courier_product.count
+            courier_product.count = 0
+            courier_product.save()
+            courier_product.group_id.save()
+            courier_product.group_id.party_id.save()
+            courier_product.delete()
+
+        return response.Response(
+            data={"status": "success"}, status=status.HTTP_200_OK
+        )

core/apps/eggs/views/daily_cost.py

@@ -0,0 +1,13 @@
+from rest_framework import viewsets
+from rest_framework.response import Response
+
+from core.apps.eggs.models import DailyCost
+from core.apps.eggs.serializers import DailyCostSerializer
+
+
+class DailyCostViewSet(viewsets.ModelViewSet):
+    queryset = DailyCost.objects.all()
+    serializer_class = DailyCostSerializer
+
+    def get_queryset(self):
+        return DailyCost.objects.all().order_by("-id")[:1]

core/apps/eggs/views/debt.py

@@ -0,0 +1,11 @@
+from rest_framework import viewsets
+from core.apps.eggs.models import Debt
+from core.apps.eggs.serializers import DebtSerializer
+from core.http.permissions import IsRole
+
+
+class DebtViewSet(viewsets.ModelViewSet):
+    queryset = Debt.objects.all()
+    serializer_class = DebtSerializer
+    permission_classes = [IsRole(["admin", "courier"])]
+    http_method_names = ["post", "get"]

core/apps/eggs/views/debt_list.py

@@ -0,0 +1,20 @@
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from core.apps.eggs.models import Debt
+from core.apps.eggs.serializers import DebtSerializer
+
+
+class UserDebtsAPIView(APIView):
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request, id=None):
+        if id:
+            user_debts = Debt.objects.filter(market_id=id).order_by('-created_at')
+        else:
+            user_debts = Debt.objects.none()
+
+        serializer = DebtSerializer(user_debts, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)

core/apps/eggs/views/delete_account.py

@@ -0,0 +1,26 @@
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from core.apps.eggs.serializers import DeleteAccountSerializer
+
+
+class DeleteAccountView(APIView):
+    permission_classes = [IsAuthenticated]
+
+    def delete(self, request, *args, **kwargs):
+        serializer = DeleteAccountSerializer(
+            data=request.data, context={"request": request}
+        )
+        if serializer.is_valid():
+            user = request.user
+            user.delete()
+            return Response(
+                {
+                    "status": "success",
+                    "message": "Akkaunt muvaffaqiyatli o'chirildi.",
+                },
+                status=status.HTTP_204_NO_CONTENT,
+            )
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

core/apps/eggs/views/group.py

@@ -0,0 +1,16 @@
+"""
+Group view
+"""
+
+from rest_framework import viewsets
+
+from core.apps.eggs import models
+from core.apps.eggs import serializers
+from core.http.permissions import IsRole
+
+
+class GroupViewSet(viewsets.ModelViewSet):
+    queryset = models.Group.objects.all()
+    serializer_class = serializers.GroupSerializer
+    http_method_names = ["get", "post", "put", "patch", "delete"]
+    permission_classes = [IsRole(["admin", "sklad", "courier", "market"])]

core/apps/eggs/views/history.py

@@ -0,0 +1,25 @@
+from rest_framework import viewsets
+
+from core.apps.eggs.models import History
+from core.apps.eggs.serializers import HistorySerializer
+from core.http.permissions import IsRole
+
+
+class HistoryViewSet(viewsets.ModelViewSet):
+    serializer_class = HistorySerializer
+    http_method_names = ["get"]
+    permission_classes = [IsRole(["admin", "sklad", "courier", "market"])]
+
+    def get_queryset(self):
+        user = self.request.user
+        action_param = self.request.query_params.get("action", None)
+
+        if user.role == "admin":
+            queryset = History.objects.all()
+        else:
+            queryset = History.objects.filter(user_id=user.id)
+
+        if action_param:
+            queryset = queryset.filter(action=action_param)
+
+        return queryset

core/apps/eggs/views/market.py

@@ -0,0 +1,40 @@
+"""
+Market view
+"""
+
+from rest_framework import viewsets
+
+from core.apps.eggs import models
+from core.apps.eggs import serializers
+from core.http.permissions import IsRole
+
+
+class MarketViewSet(viewsets.ModelViewSet):
+    queryset = models.Market.objects.all()
+    serializer_class = serializers.MarketSerializer
+    http_method_names = ["get", "post", "put", "patch", "delete"]
+    permission_classes = [IsRole(["sklad", "admin", "courier", "market"])]
+
+    def get_queryset(self):
+        user = self.request.user
+        if user.role in ["admin", "sklad", "courier"]:
+            return models.Market.objects.all()
+        elif user.role == "market":
+            return models.Market.objects.filter(user_id=user.id)
+        return None
+
+
+class MarketHistoryViewSet(viewsets.ModelViewSet):
+    queryset = models.Market.objects.all()
+    serializer_class = serializers.MarketHistorySerializer
+    http_method_names = ["get"]
+    permission_classes = [IsRole(["sklad", "admin", "courier", "market"])]
+
+    def get_queryset(self):
+        user = self.request.user
+        if user.role in ["admin", "sklad", "courier"]:
+            return models.Market.objects.all().order_by("-debts__created_at")
+        elif user.role == "market":
+            return models.Market.objects.filter(user_id=user.id).order_by("-debts__created_at")
+        return None
+    

core/apps/eggs/views/monitoring.py

@@ -0,0 +1,112 @@
+from datetime import datetime
+from datetime import timedelta
+
+from django.db.models import Sum
+from rest_framework import serializers
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from core.apps.eggs.models import Monitoring
+
+
+class MonitoringSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Monitoring
+        fields = [
+            "id",
+            "content_type",
+            "object_id",
+            "action",
+            "timestamp",
+            "created_by",
+            "created_who",
+            "reason",
+            "comment",
+            "price",
+        ]
+
+
+class MonitoringSummarySerializer(serializers.Serializer):
+    from_date = serializers.CharField()
+    end_date = serializers.CharField()
+    enter_price = serializers.DecimalField(max_digits=30, decimal_places=2)
+    exit_price = serializers.DecimalField(max_digits=30, decimal_places=2)
+    profit = serializers.DecimalField(max_digits=30, decimal_places=2)
+    results = MonitoringSerializer(many=True)
+
+
+class MonitoringSummaryView(APIView):
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request, *args, **kwargs):
+        from_date = request.query_params.get("from_date")
+        end_date = request.query_params.get("end_date")
+
+        if from_date and end_date:
+            start_date = datetime.strptime(from_date, "%Y-%m-%d")
+            end_date = datetime.strptime(end_date, "%Y-%m-%d") + timedelta(
+                days=1
+            )
+        else:
+            start_date = None
+            end_date = None
+
+        enter_actions = ["Kirim", "debt_created", "order_created"]
+        exit_actions = [
+            "Chiqim",
+            "additional_cost_created",
+            "broken_created",
+            "party_created",
+        ]
+
+        if start_date and end_date:
+            enter_price = (
+                Monitoring.objects.filter(
+                    action__in=enter_actions,
+                    timestamp__range=[start_date, end_date],
+                ).aggregate(total=Sum("price"))["total"]
+                or 0
+            )
+
+            exit_price = (
+                Monitoring.objects.filter(
+                    action__in=exit_actions,
+                    timestamp__range=[start_date, end_date],
+                ).aggregate(total=Sum("price"))["total"]
+                or 0
+            )
+
+            results = Monitoring.objects.filter(
+                timestamp__range=[start_date, end_date]
+            )
+        else:
+            enter_price = (
+                Monitoring.objects.filter(action__in=enter_actions).aggregate(
+                    total=Sum("price")
+                )["total"]
+                or 0
+            )
+
+            exit_price = (
+                Monitoring.objects.filter(action__in=exit_actions).aggregate(
+                    total=Sum("price")
+                )["total"]
+                or 0
+            )
+
+            results = Monitoring.objects.all()
+
+        profit = enter_price - exit_price
+
+        data = {
+            "from_date": from_date,
+            "end_date": end_date,
+            "enter_price": enter_price,
+            "exit_price": exit_price,
+            "profit": profit,
+            "results": results,
+        }
+
+        serializer = MonitoringSummarySerializer(data)
+        return Response(serializer.data)

core/apps/eggs/views/order.py

@@ -0,0 +1,32 @@
+"""
+Order view
+"""
+
+from django.core.exceptions import PermissionDenied
+from rest_framework import viewsets
+
+from core.apps.eggs import models, serializers
+from core.http.permissions import IsRole
+
+
+class OrderViewSet(viewsets.ModelViewSet):
+    http_method_names = ["get", "post", "put", "patch", "delete"]
+    permission_classes = [IsRole(["courier", "admin", "sklad", "market"])]
+
+    def get_queryset(self):
+        user = self.request.user
+        if user.role == "market":
+            try:
+                market_instance = models.Market.objects.get(user_id=user.id)
+                return models.Order.objects.filter(
+                    market_id=market_instance.id
+                )
+            except models.Market.DoesNotExist:
+                raise PermissionDenied("Bunday Market mavjud emas.")
+        return models.Order.objects.all()
+
+    def get_serializer_class(self):
+        if self.request.method == "GET":
+            return serializers.OrderSerializer
+        else:
+            return serializers.OrderCreateSerializer

core/apps/eggs/views/party.py

@@ -0,0 +1,45 @@
+"""
+Party view
+"""
+
+from django.db.models import Q
+from rest_framework import viewsets
+from rest_framework.decorators import action
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+
+from core.apps.eggs import models
+from core.apps.eggs import serializers
+from core.http.permissions import IsRole
+
+
+class PartViewSet(viewsets.ModelViewSet):
+    queryset = models.Party.objects.all()
+    http_method_names = ["get", "post", "put", "patch", "delete"]
+    permission_classes = [IsAuthenticated, IsRole(["admin", "sklad", "courier"])]
+
+    def get_serializer_class(self):
+        if self.request.method == "GET":
+            return serializers.PartySerializer
+        else:
+            return serializers.PartyCreateSerializer
+
+    @action(detail=False, methods=["get"])
+    def search(self, request):
+        search_query = request.query_params.get("query", "")
+        results = self.queryset.filter(
+            Q(user_id__username__icontains=search_query)
+            | Q(count__icontains=search_query)
+            | Q(price__icontains=search_query)
+            | Q(sold__icontains=search_query)
+            | Q(sold_price__icontains=search_query)
+            | Q(invoices__name__icontains=search_query)
+            | Q(groups__product_id__name__icontains=search_query)
+            | Q(groups__entry_price__icontains=search_query)
+            | Q(groups__unit_price__icontains=search_query)
+            | Q(groups__wholesale_price__icontains=search_query)
+            | Q(groups__quantity__icontains=search_query)
+            | Q(groups__broken_eggs__icontains=search_query)
+        ).distinct()
+        serializer = self.get_serializer(results, many=True)
+        return Response()

core/apps/eggs/views/product.py

@@ -0,0 +1,16 @@
+"""
+Product view
+"""
+
+from rest_framework import viewsets
+
+from core.apps.eggs import models
+from core.apps.eggs import serializers
+from core.http.permissions import IsRole
+
+
+class ProductViewSet(viewsets.ModelViewSet):
+    queryset = models.Product.objects.all()
+    serializer_class = serializers.ProductSerializer
+    http_method_names = ["get", "post", "put", "patch", "delete"]
+    permission_classes = [IsRole(["admin", "sklad", "market", "courier"])]

core/apps/eggs/views/sklad.py

@@ -0,0 +1,21 @@
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticated
+
+from core.apps.eggs.models import User
+from core.apps.eggs.serializers import (
+    AddSkladSerializer,
+    SkladListSerializer,
+)
+from core.http.permissions import IsRole
+
+
+class AddSkladViewSet(viewsets.ModelViewSet):
+    permission_classes = [IsAuthenticated, IsRole(["admin"])]
+    queryset = User.objects.filter(role="sklad")
+    http_method_names = ["get", "post"]
+
+    def get_serializer_class(self):
+        if self.request.method == "GET":
+            return SkladListSerializer
+        else:
+            return AddSkladSerializer

core/apps/eggs/views/top_couriers.py

@@ -0,0 +1,81 @@
+from itertools import groupby
+
+from django.db.models import F, Func, Sum, Value
+from django.db.models.functions import Concat, TruncDay, TruncMonth, TruncYear
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from core.apps.eggs.models import Order
+from core.http.permissions import IsRole
+
+
+class WeekOfMonth(Func):
+    function = "EXTRACT"
+    template = "(%(function)s('day' from %(expressions)s) - 1) / 7 + 1"
+
+    def as_postgresql(self, compiler, connection):
+        self.template = (
+            "ROUND((EXTRACT('day' from %(expressions)s) - 1) / 7 + 1)"
+        )
+        return super().as_sql(compiler, connection)
+
+
+class DayName(Func):
+    function = "to_char"
+    template = "%(function)s(%(expressions)s, 'Day')"
+
+
+class TopCourierView(APIView):
+    permission_classes = [IsRole(["admin"])]
+
+    def get(self, request):
+        top_couriers = (
+            Order.objects.annotate(
+                year=TruncYear("created_at"),
+                month=TruncMonth("created_at"),
+                day=TruncDay("created_at"),
+                day_name=DayName("created_at"),
+                full_name=Concat(
+                    F("courier_id__user_id__first_name"),
+                    Value(" "),
+                    F("courier_id__user_id__last_name"),
+                ),
+            )
+            .values(
+                "year",
+                "month",
+                "day",
+                "day_name",
+                "full_name",
+            )
+            .annotate(value=Sum("order_items__count"))
+            .order_by("year", "month", "day", "-value")
+        )[:3]
+
+        data = []
+        for year, year_data in groupby(top_couriers, key=lambda x: x["year"]):
+            year_dict = {"Year": year.year, "Months": []}
+            for month, month_data in groupby(
+                year_data, key=lambda x: x["month"]
+            ):
+                month_dict = {"month": month.strftime("%B"), "days": []}
+                for day, day_data in groupby(
+                    month_data, key=lambda x: x["day"]
+                ):
+                    day_data_list = list(day_data)
+                    people_list = [
+                        {
+                            "full_name": person["full_name"],
+                            "value": person["value"],
+                        }
+                        for person in day_data_list
+                    ]
+                    day_dict = {
+                        "day": day.day,
+                        "day_name": day_data_list[0]["day_name"].strip(),
+                        "people": people_list,
+                    }
+                    month_dict["days"].append(day_dict)
+                year_dict["Months"].append(month_dict)
+            data.append(year_dict)
+        return Response(data)

core/apps/eggs/views/top_products.py

@@ -0,0 +1,32 @@
+from django.db.models import Sum
+from django.shortcuts import get_object_or_404
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from core.apps.eggs.models import OrderItems, Product
+from core.http.permissions import IsRole
+
+
+class TopProductsView(APIView):
+    permission_classes = [IsRole(["admin"]), IsAuthenticated]
+
+    def get(self, request):
+        top_products = (
+            OrderItems.objects.filter(order_id__status__in=["done", "success"])
+            .values("courier_product_id__group_id__product_id")
+            .annotate(product_count=Sum("count"))
+            .order_by("-product_count")
+        )
+        response_data = []
+        for item in top_products:
+            product = get_object_or_404(
+                Product, id=item["courier_product_id__group_id__product_id"]
+            )
+            response_data.append(
+                {
+                    "product_name": product.name,
+                    "product_count": item["product_count"],
+                }
+            )
+        return Response(response_data)