gold eggs backend

core/apps/eggs/serializers/__init__.py

@@ -0,0 +1,19 @@
+from .all_history import *  # noqa
+from .broken import *  # noqa
+from .courier_history import *  # noqa
+from .courier_product import *  # noqa
+from .courier import *  # noqa
+from .debt import *  # noqa
+from .group import *  # noqa
+from .history import *  # noqa
+from .invoice import *  # noqa
+from .location import *  # noqa
+from .order import *  # noqa
+from .order_item import *  # noqa
+from .party import *  # noqa
+from .product import *  # noqa
+from .market import *  # noqa
+from .additional_cost import *  # noqa
+from .sklad import *  # noqa
+from .delete_account import *  # noqa
+from .daily_cost import *  # noqa

core/apps/eggs/serializers/add_courier.py

@@ -0,0 +1,83 @@
+from django.core import exceptions
+from rest_framework import serializers
+
+from core.http.models import User
+from core.apps.eggs import models
+from core.apps.eggs.serializers import CourierHistorySerializer
+
+
+class AddCourierSerializer(serializers.ModelSerializer):
+    courier_id = serializers.SerializerMethodField()
+
+    class Meta:
+        model = User
+        fields = (
+            "courier_id",
+            "id",
+            "first_name",
+            "last_name",
+            "phone",
+            "username",
+            "role",
+            "avatar",
+            "password",
+        )
+
+    def create(self, validated_data):
+        validated_data["role"] = "courier"
+        user = User.objects.create_user(**validated_data)
+        courier = models.Courier.objects.create(user_id=user)
+
+        request_user = self.context["request"].user
+        created_who = f"{request_user.first_name} {request_user.last_name}"
+
+        models.History.objects.create(
+            content_object=courier,
+            action="courier_created",
+            created_who=created_who,
+            user_id=user,
+            created_by=f"{user.first_name} {user.last_name}",
+            reason="Kuryer qo'shildi",
+            avatar=user.avatar if user.avatar else None,
+        )
+
+        return user
+
+    def get_courier_id(self, obj):
+        courier = models.Courier.objects.filter(user_id=obj.id).first()
+        return courier.id if courier else None
+
+
+class CouriersListSerializer(serializers.ModelSerializer):
+    courier_history = serializers.SerializerMethodField()
+    avatar = serializers.SerializerMethodField()
+
+    class Meta:
+        model = User
+        fields = (
+            "id",
+            "first_name",
+            "last_name",
+            "phone",
+            "username",
+            "avatar",
+            "role",
+            "courier_history",
+            "avatar",
+        )
+
+    def get_courier_history(self, obj):
+        try:
+            user = User.objects.get(id=obj.id, role="courier")
+            courier = models.Courier.objects.get(user_id=user.id)
+            courier_history = models.CourierHistory.objects.filter(
+                courier_id=courier.id
+            )  # noqa
+            return CourierHistorySerializer(courier_history, many=True).data
+        except exceptions.ObjectDoesNotExist:
+            return []
+
+    def get_avatar(self, obj):
+        if obj.avatar:
+            return obj.avatar.url
+        return None

core/apps/eggs/serializers/add_market.py

@@ -0,0 +1,72 @@
+from rest_framework import serializers
+
+from core.apps.eggs import models
+from core.http.models import User
+
+
+class MarketLocationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.Location
+        fields = ("label", "long", "lat")
+
+
+class MarketUserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = User
+        fields = (
+            "id",
+            "first_name",
+            "last_name",
+            "phone",
+            "password",
+            "role",
+            "avatar",
+        )
+
+
+class AddMarketSerializer(serializers.ModelSerializer):
+    user_id = MarketUserSerializer()
+    location_id = MarketLocationSerializer()
+
+    class Meta:
+        model = models.Market
+        fields = (
+            "name",
+            "company_name",
+            "avatar",
+            "phone",
+            "user_id",
+            "location_id",
+        )
+
+    def create(self, validated_data):
+        user_data = validated_data.pop("user_id")
+        location_data = validated_data.pop("location_id")
+        password = user_data.pop("password", None)
+        user_data.pop("role", None)  # remove 'role' from user_data
+
+        user = User.objects.create(role="market", **user_data)
+        if password:
+            user.set_password(password)
+            user.save()
+
+        location = models.Location.objects.create(**location_data)
+
+        market = models.Market.objects.create(
+            user_id=user, location_id=location, **validated_data
+        )
+
+        request_user = self.context["request"].user
+        created_who = f"{request_user.first_name} {request_user.last_name}"
+
+        models.History.objects.create(
+            content_object=market,
+            action="market_created",
+            user_id=user,
+            created_who=created_who,
+            created_by=market.company_name,
+            reason="Market qo'shildi",
+            avatar=market.avatar if market.avatar else None,
+        )
+
+        return market

core/apps/eggs/serializers/additional_cost.py

@@ -0,0 +1,54 @@
+from django.db.models import Sum
+from rest_framework import serializers
+
+from core.apps.eggs.models import AdditionalCost, History
+from core.apps.eggs.models.monitoring import Monitoring
+from core.http.serializers import UserSerializer
+
+
+class AdditionalCostSerializer(serializers.ModelSerializer):
+    user = UserSerializer(read_only=True)
+    total_price = serializers.SerializerMethodField()
+
+    class Meta:
+        model = AdditionalCost
+        fields = ["id", "user", "reason", "price", "created_at", "total_price"]
+        read_only_fields = ["created_at", "total_price"]
+        extra_kwargs = {
+            "user": {"required": False},
+        }
+
+    def create(self, validated_data):
+        additional_cost = AdditionalCost.objects.create(**validated_data)
+        user = self.context["request"].user
+        if user is not None:
+            additional_cost.user = user
+            additional_cost.save()
+            History.objects.create(
+                content_object=additional_cost,
+                action="additional_cost_created",
+                user_id=user,
+                created_who=f"{user.first_name} {user.last_name}",
+                created_by=f"{user.first_name} {user.last_name}",
+                reason=f"Qo'shimcha xarajat qo'shildi {additional_cost.price} so'm",
+                comment=additional_cost.reason,
+                avatar=user.avatar if user.avatar else None,
+            )
+            Monitoring.objects.create(
+                content_object=additional_cost,
+                action="additional_cost_created",
+                user_id=user,
+                created_who=f"{user.first_name} {user.last_name}",
+                created_by=f"{user.first_name} {user.last_name}",
+                reason=f"Qo'shimcha xarajat qo'shildi {additional_cost.price} so'm",
+                comment="Chiqim",
+                price=additional_cost.price,
+            )
+            return additional_cost
+        else:
+            raise serializers.ValidationError("User is not authenticated")
+
+    def get_total_price(self, obj):
+        return AdditionalCost.objects.aggregate(total_price=Sum("price"))[
+            "total_price"
+        ]

core/apps/eggs/serializers/all_history.py

@@ -0,0 +1,27 @@
+from rest_framework import serializers
+from core.apps.eggs.models.all_history import AllHistory
+
+
+class AllHistorySerializer(serializers.ModelSerializer):
+    action = serializers.SerializerMethodField()
+
+    class Meta:
+        model = AllHistory
+        fields = [
+            "id",
+            "object_id",
+            "action",
+            "timestamp",
+            "created_by",
+            "created_who",
+            "reason",
+        ]
+
+    def get_action(self, obj):
+        return obj.action
+
+    def to_representation(self, instance):
+        representation = super().to_representation(instance)
+        if instance.action != "created":
+            return {}
+        return representation

core/apps/eggs/serializers/broken.py

@@ -0,0 +1,50 @@
+from rest_framework import serializers
+
+from core.apps.eggs.models import Broken, Group, History
+from core.apps.eggs.models.monitoring import Monitoring
+from core.http.models.user import User
+
+
+class BrokenSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Broken
+        fields = ["comment", "quantity", "group", "price"]
+
+    def validate(self, data):
+        group = Group.objects.get(id=data["group"].id)
+        if data["quantity"] > group.quantity:
+            raise serializers.ValidationError(
+                "Miqdori guruh miqdoridan ko'p bo'lishi mumkin emas"
+            )
+        return data
+
+    def create(self, validated_data):
+        request = self.context.get("request")
+        if request and hasattr(request, "user"):
+            user = User.objects.get(id=request.user.id)
+            validated_data["user_id"] = user
+        instance = Broken.objects.create(**validated_data)
+
+        History.objects.create(
+            content_object=instance,
+            action="broken_created",
+            user_id=instance.user_id,
+            created_who=f"{instance.user_id.first_name} {instance.user_id.last_name}",
+            created_by=instance.group.name,
+            reason=f"Singan tuxum qo'shildi: {instance.quantity} ta",
+            avatar=(
+                instance.user_id.avatar if instance.user_id.avatar else None
+            ),
+        )
+        Monitoring.objects.create(
+            content_object=instance,
+            action="broken_created",
+            user_id=instance.user_id,
+            created_who=f"{instance.user_id.first_name} {instance.user_id.last_name}",
+            created_by=instance.group.name,
+            reason=f"Singan tuxum qo'shildi: {instance.quantity} ta",
+            comment="Chiqim",
+            price=instance.price,
+        )
+
+        return instance

core/apps/eggs/serializers/courier.py

@@ -0,0 +1,24 @@
+"""
+Courier serializer
+"""
+
+from rest_framework import serializers
+
+from core.apps.eggs import models
+from core.http.serializers import user
+
+
+class CourierSerializer(serializers.ModelSerializer):
+    user = user.UserSerializer(read_only=True, source="user_id")
+
+    class Meta:
+        model = models.Courier
+        fields = (
+            "id",
+            "user_id",
+            "user",
+        )
+
+        extra_kwargs = {
+            "user_id": {"write_only": True},
+        }

core/apps/eggs/serializers/courier_history.py

@@ -0,0 +1,31 @@
+"""
+Courier History serializer
+"""
+
+from rest_framework import serializers
+
+from core.apps.eggs import models
+
+
+class CourierHistorySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.CourierHistory
+        fields = (
+            "id",
+            "courier_id",
+            "group_id",
+            "get_eggs",
+            "return_eggs",
+            "broken_eggs",
+            "date",
+        )
+
+    def update(self, instance, validated_data):
+        return_eggs = validated_data.get("return_eggs", 0)
+        broken_eggs = validated_data.get("broken_eggs", 0)
+
+        instance.return_eggs += return_eggs
+        instance.broken_eggs += broken_eggs
+        instance.save()
+
+        return instance

core/apps/eggs/serializers/courier_product.py

@@ -0,0 +1,106 @@
+"""
+Courier Product serializer
+"""
+
+from rest_framework import serializers
+
+from core.apps.eggs import models
+from core.apps.eggs.serializers import group
+from core.apps.eggs.serializers import courier
+from core.apps.eggs.models import History
+from django.utils.translation import gettext as _
+from django.contrib.auth import get_user_model
+
+
+class CourierProductSerializer(serializers.ModelSerializer):
+    courier = courier.CourierSerializer(read_only=True, source="courier_id")
+    group = group.GroupSerializer(read_only=True, source="group_id")
+
+    class Meta:
+        model = models.CourierProduct
+        fields = ("id", "group", "count", "courier")
+
+    def list(self, request):
+        user_id = request.user.id
+        courier_product = models.CourierProduct.objects.filter(
+            courier_id=user_id, count__gt=0
+        )
+
+        return courier_product
+
+
+User = get_user_model()
+
+
+class CourierProductCreateSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.CourierProduct
+        fields = ("count", "group_id")
+
+    def validate(self, data):
+        group = models.Group.objects.get(id=data["group_id"].id)
+
+        if data["count"] > group.quantity:
+            raise serializers.ValidationError(
+                "Guruh sonidan ko'p bo'lishi mumkin emas."
+            )
+
+        return data
+
+    def create(self, validated_data):
+        user_id = self.context["request"].user.id
+        courier = models.Courier.objects.get(user_id=user_id)
+        courier_product = models.CourierProduct.objects.create(
+            courier_id=courier, **validated_data
+        )
+
+        user = User.objects.get(id=user_id)
+
+        History.objects.create(
+            user_id=user,
+            action="courier_product_created",
+            created_who=f"{courier.user_id.first_name} {courier.user_id.last_name}",
+            created_by=courier_product.group_id.name,
+            object_id=courier_product.id,
+            content_object=courier_product,
+            reason=_(f"Kuryer mahsulot oldi {courier_product.count} ta"),
+            avatar=user.avatar if user.avatar else None,
+        )
+
+        return courier_product
+
+
+class CourierProductReturnSerializer(serializers.ModelSerializer):
+    data = CourierProductCreateSerializer(many=True)
+
+    class Meta:
+        model = models.CourierProduct
+        fields = ("data",)
+
+    def create(self, validated_data):
+        data = validated_data.pop("data", [])
+        courier_products = []
+        for item in data:
+            courier_product = CourierProductCreateSerializer(
+                context=self.context
+            ).create(item)
+            courier_product.save()
+            courier_products.append(courier_product)
+
+        return {"data": courier_products}
+
+    def to_representation(self, instance):
+        data = instance.get("data", [])
+        return {
+            "data": [
+                {
+                    "id": product.id,
+                    "group": group.GroupSerializer(product.group_id).data,
+                    "count": product.count,
+                    "courier": courier.CourierSerializer(
+                        product.courier_id
+                    ).data,  # noqa
+                }
+                for product in data
+            ]
+        }

core/apps/eggs/serializers/daily_cost.py

@@ -0,0 +1,9 @@
+from rest_framework import serializers
+
+from core.apps.eggs.models import DailyCost
+
+
+class DailyCostSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = DailyCost
+        fields = ["id", "first_cost", "second_cost", "third_cost", "created_at"]

core/apps/eggs/serializers/debt.py

@@ -0,0 +1,73 @@
+from rest_framework import serializers
+
+from core.apps.eggs.models import Debt, Market, History, Notification
+from core.apps.eggs.models.debt import DebtTypeEnum
+from core.apps.eggs.models.monitoring import Monitoring
+from core.http.models import User
+from core.apps.eggs.tasks.send_sms import send_sms_msg
+
+
+class DebtSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Debt
+        fields = [
+            "market",
+            "debt_price",
+            "debt_type",
+            "created_at",
+            "updated_at",
+        ]
+
+    def validate(self, data):
+        market = Market.objects.get(id=data["market"].id)
+        if (
+            data["debt_price"] > market.debt_unpaid
+            and data.get("debt_type", None) == DebtTypeEnum.LOST.value
+        ):
+            raise serializers.ValidationError(
+                {
+                    "debt_price": "Qarz narxi to'lanmagan qarzdan yuqori bo'lishi mumkin emas."
+                }
+            )
+        return data
+
+    def create(self, validated_data):
+        instance = Debt.objects.create(**validated_data)
+
+        request = self.context.get("request")
+        request_user = request.user
+
+        full_name = f"{request_user.first_name} {request_user.last_name}"
+
+        History.objects.create(
+            content_object=instance,
+            action="debt_created",
+            user_id=request_user,
+            created_who=full_name,
+            created_by=instance.market.name,
+            avatar=instance.market.avatar,
+            reason=f"Qarz yechildi {instance.debt_price}",
+            comment=f"Qarz yechildi {instance.debt_price}",
+        )
+        Monitoring.objects.create(
+            content_object=instance,
+            action="debt_created",
+            user_id=request_user,
+            created_who=full_name,
+            created_by=instance.market.name,
+            reason=f"Qarz yechildi {instance.debt_price}",
+            comment="Kirim",
+            price=instance.debt_price,
+        )
+        notification_users = User.objects.filter(role="admin")
+        for user in notification_users:
+            Notification.objects.create(
+                user=user,
+                title=f"Qarz muvaffaqiyatli yechildi {instance.debt_price} so'm",
+                body=f"Qarz muvaffaqiyatli yechildi {instance.market.name} dan {instance.debt_price} so'm",
+            )
+
+        message = f"Hurmatli {instance.market.user_id.first_name} {instance.market.user_id.last_name} , Sizning  Gold-eggs.uz tuxum yetkazib berish xizmati ilovasidagi xaridingizga {instance.debt_price} so'm qarz  yechildi Umumiy balans: {instance.market.debt_unpaid} so'm Batafsil: +998914249515"
+
+        send_sms_msg.delay(instance.market.user_id.phone, message)
+        return instance

core/apps/eggs/serializers/delete_account.py

@@ -0,0 +1,27 @@
+from django.contrib.auth import authenticate
+from rest_framework import serializers
+
+
+class DeleteAccountSerializer(serializers.Serializer):
+    phone = serializers.CharField()
+    password = serializers.CharField(write_only=True)
+
+    def validate(self, data):
+        phone = data.get("phone")
+        password = data.get("password")
+        user = authenticate(phone=phone, password=password)
+
+        if user is None:
+            raise serializers.ValidationError(
+                "Telefon raqam yoki parol noto'g'ri."
+            )
+
+        if user != self.context["request"].user:
+            raise serializers.ValidationError("Telefon raqam noto'g'ri.")
+
+        return data
+
+    def delete(self):
+        user = self.context["request"].user
+        user.delete()
+        return user

core/apps/eggs/serializers/group.py

@@ -0,0 +1,77 @@
+"""
+Group serializer
+"""
+
+from rest_framework import serializers
+
+from core.apps.eggs import models
+from core.apps.eggs.serializers import product
+
+
+class GroupUserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.User
+        fields = (
+            "id",
+            "first_name",
+            "last_name",
+            "phone",
+        )
+
+
+class GroupPartySerializer(serializers.ModelSerializer):
+    user = GroupUserSerializer(read_only=True, many=False, source="user_id")
+
+    class Meta:
+        model = models.Party
+        fields = (
+            "id",
+            "user",
+            "count",
+            "sold_count",
+            "remaining_count",
+            "benefit",
+            "cost",
+            "total_cost",
+        )
+
+
+class GroupSerializer(serializers.ModelSerializer):
+    party = GroupPartySerializer(read_only=True, many=False, source="party_id")
+    product = product.ProductSerializer(
+        read_only=True, many=False, source="product_id"
+    )
+
+    class Meta:
+        model = models.Group
+        fields = (
+            "id",
+            "name",
+            "date",
+            "entry_price",
+            "unit_price",
+            "wholesale_price",
+            "quantity",
+            "broken_eggs",
+            "product",
+            "party",
+        )
+
+    def update(self, instance, validated_data):
+        instance.name = validated_data.get("name", instance.name)
+        instance.date = validated_data.get("date", instance.date)
+        instance.entry_price = validated_data.get(
+            "entry_price", instance.entry_price
+        )
+        instance.unit_price = validated_data.get(
+            "unit_price", instance.unit_price
+        )
+        instance.wholesale_price = validated_data.get(
+            "wholesale_price", instance.wholesale_price
+        )
+        instance.quantity = validated_data.get("quantity", instance.quantity)
+        instance.broken_eggs = validated_data.get(
+            "broken_eggs", instance.broken_eggs
+        )
+        instance.save()
+        return instance

core/apps/eggs/serializers/history.py

@@ -0,0 +1,26 @@
+from rest_framework import serializers
+from core.apps.eggs.models import History
+
+
+class HistorySerializer(serializers.ModelSerializer):
+    avatar = serializers.SerializerMethodField()
+
+    class Meta:
+        model = History
+        fields = [
+            "id",
+            "content_type",
+            "object_id",
+            "action",
+            "avatar",
+            "timestamp",
+            "created_by",
+            "created_who",
+            "comment",
+            "reason",
+        ]
+
+    def get_avatar(self, obj):
+        if obj.avatar and hasattr(obj.avatar, "url"):
+            return obj.avatar.url
+        return None

core/apps/eggs/serializers/invoice.py

@@ -0,0 +1,13 @@
+"""
+Invoice serializer
+"""
+
+from rest_framework import serializers
+
+from core.apps.eggs import models
+
+
+class InvoiceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.Invoice
+        fields = ("name", "price")

core/apps/eggs/serializers/location.py

@@ -0,0 +1,13 @@
+"""
+Location serializer
+"""
+
+from rest_framework import serializers
+
+from core.apps.eggs import models
+
+
+class LocationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.Location
+        fields = ("id", "long", "lat", "label")

core/apps/eggs/serializers/market.py

@@ -0,0 +1,87 @@
+"""
+Market serializer
+"""
+
+from rest_framework import serializers
+
+from core.apps.eggs import models
+from core.apps.eggs.serializers import location, order
+from core.http.serializers import user
+
+
+class MarketSerializer(serializers.ModelSerializer):
+    user = user.UserSerializer(source="user_id", read_only=True)
+    location = location.LocationSerializer(source="location_id")
+
+    class Meta:
+        model = models.Market
+        fields = (
+            "id",
+            "name",
+            "company_name",
+            "user_id",
+            "avatar",
+            "user",
+            "phone",
+            "location",
+            "debt_paid",
+            "debt_unpaid",
+        )
+        extra_kwargs = {
+            "user_id": {"write_only": True},
+        }
+
+    def create(self, validated_data):
+        user_id = validated_data.pop("user_id")
+        location_data = validated_data.pop("location_id")
+
+        location = models.Location.objects.create(**location_data)
+
+        market = models.Market.objects.create(
+            user_id=user_id, location_id=location, **validated_data
+        )
+
+        return market
+
+    def update(self, instance, validated_data):
+        location_data = validated_data.pop("location_id", None)
+
+        if location_data:
+            for attr, value in location_data.items():
+                setattr(instance.location_id, attr, value)
+            instance.location_id.save()
+
+        for attr, value in validated_data.items():
+            setattr(instance, attr, value)
+
+        instance.save()
+        return instance
+
+
+class MarketHistorySerializer(serializers.ModelSerializer):
+    user = user.UserSerializer(read_only=True, source="user_id")
+    location = location.LocationSerializer(
+        read_only=True, source="location_id"
+    )
+    orders = serializers.SerializerMethodField()
+
+    class Meta:
+        model = models.Market
+        fields = (
+            "id",
+            "name",
+            "company_name",
+            "user_id",
+            "avatar",
+            "user",
+            "phone",
+            "location",
+            "orders",
+            "debt_paid",
+            "debt_unpaid",
+        )
+
+    def get_orders(self, obj):
+        orders = models.Order.objects.filter(market_id=obj.id)
+        serializer = order.OrderSerializer(orders, many=True)
+        return serializer.data

core/apps/eggs/serializers/order.py

@@ -0,0 +1,205 @@
+"""
+Order serializer
+"""
+
+# import decimal
+
+from django.db.models import Q
+from django.utils.translation import gettext as _
+from rest_framework import serializers
+from rest_framework.exceptions import PermissionDenied
+
+from core.apps.eggs import models
+from core.apps.eggs.models import Market, History, Notification
+from core.apps.eggs.serializers import courier, location, market
+from core.apps.eggs.serializers.order_item import OrderItemsSerializer
+from core.http.models import User
+from core.http.serializers import user
+
+
+class OrderCourierSerializer(serializers.ModelSerializer):
+    user_id = user.UserSerializer()
+
+    class Meta:
+        model = models.Courier
+        fields = (
+            "id",
+            "user_id",
+        )
+
+
+class OrderSerializer(serializers.ModelSerializer):
+    market = market.MarketSerializer(read_only=True, source="market_id")
+    location = location.LocationSerializer(
+        read_only=True, source="location_id"
+    )
+    courier = courier.CourierSerializer(read_only=True, source="courier_id")
+    order_items = OrderItemsSerializer(many=True, read_only=True)
+
+    class Meta:
+        model = models.Order
+        fields = (
+            "id",
+            "courier",
+            "market",
+            "location",
+            "price",
+            "price_paid",
+            "debt",
+            "status",
+            "comment",
+            "data",
+            "count",
+            "order_items",
+        )
+
+    def to_representation(self, instance):
+        representation = super().to_representation(instance)
+        for field in ["price", "price_paid", "debt"]:
+            try:
+                representation[field] = str(
+                    round(float(representation[field]), 2)
+                )
+            except (TypeError, ValueError):
+                representation[field] = "Invalid value"
+        return representation
+
+
+class OrderCreateSerializer(serializers.ModelSerializer):
+    location = location.LocationSerializer(source="location_id", required=True)
+    market = market.MarketSerializer(source="market_id", read_only=True)
+    order_items = OrderItemsSerializer(many=True, required=False)
+
+    class Meta:
+        model = models.Order
+        fields = (
+            "id",
+            "market_id",
+            "market",
+            "comment",
+            "price",
+            "price_paid",
+            "debt",
+            "location",
+            "status",
+            "count",
+            "order_items",
+        )
+
+    def validate_price(self, value):
+        try:
+            return round(float(value), 2)
+        except (TypeError, ValueError):
+            raise serializers.ValidationError("Invalid price value.")
+
+    def create(self, validated_data):
+        order_items_data = validated_data.pop("order_items", [])
+        location_data = validated_data.pop("location_id", None)
+        request = self.context.get("request")
+        if request and request.user.role == "market":
+            try:
+                market_instance = Market.objects.get(user_id=request.user.id)
+                validated_data["market_id"] = market_instance
+            except Market.DoesNotExist:
+                raise PermissionDenied(
+                    "Bu foydalanuvchi uchun Market mavjud emas"
+                )
+        if request and request.user.role == "courier":
+            courier_instance = models.Courier.objects.get(
+                user_id=request.user.id
+            )
+            validated_data["courier_id"] = courier_instance
+
+        if location_data:
+            location = models.Location.objects.create(**location_data)
+            validated_data["location_id"] = location
+
+        # validated_data["price"] = self.validate_price(
+        #     validated_data.get("price", 0.00)
+        # )
+        # validated_data["price_paid"] = self.validate_price(
+        #     validated_data.get("price_paid", 0.00)
+        # )
+        # validated_data["debt"] = self.validate_price(
+        #     validated_data.get("debt", 0.00)
+        # )
+
+        order_pk = super().create(validated_data).pk
+        order = models.Order.objects.get(pk=order_pk)
+
+        for order_item_data in order_items_data:
+            models.OrderItems.objects.create(order_id=order, **order_item_data)
+
+        created_who = ""
+        if request:
+            if request.user.role == "market" and order.market_id is not None:
+                created_who = f"{order.market_id.user_id.first_name} {order.market_id.user_id.last_name}"
+            elif (
+                request.user.role == "courier" and order.courier_id is not None
+            ):
+                created_who = f"{order.courier_id.user_id.first_name} {order.courier_id.user_id.last_name}"
+            elif request.user.role == "admin":
+                created_who = (
+                    f"{request.user.first_name} {request.user.last_name}"
+                )
+
+        History.objects.create(
+            content_object=order,
+            action="order_created",
+            created_who=created_who,
+            user_id=request.user,
+            created_by=order.market_id.name,
+            comment=order.comment,
+            reason=_(f"Buyurtma: {order.price}"),
+            avatar=(
+                order.market_id.avatar if order.market_id.avatar else None
+            ),
+        )
+
+        notification_user = User.objects.filter(
+            Q(role="admin") | Q(role="courier")
+        )
+        for user in notification_user:
+            Notification.objects.create(
+                user=user,
+                title=f"Yangi buyurtma: {order.price}",
+                body=f"Yangi buyurtma: {order.market_id.name} {order.price}",
+            )
+
+        return order
+
+    def to_representation(self, instance):
+        serializer = OrderSerializer(instance)
+        return serializer.data
+
+    def update(self, instance, validated_data):
+        order_items_data = validated_data.pop("order_items", [])
+        location_data = validated_data.pop("location_id", None)
+        request = self.context.get("request")
+
+        if request and request.user.role == "courier":
+            courier_instance = models.Courier.objects.get(
+                user_id=request.user.id
+            )
+            instance.courier_id = courier_instance
+
+        for attr, value in validated_data.items():
+            if attr in ["price", "price_paid", "debt"]:
+                value = self.validate_price(value)
+            setattr(instance, attr, value)
+        instance.save()
+
+        for order_item_data in order_items_data:
+            models.OrderItems.objects.update_or_create(
+                order_id=instance, defaults=order_item_data
+            )
+
+        if location_data:
+            location, created = models.Location.objects.update_or_create(
+                id=instance.location_id.id if instance.location_id else None,
+                defaults=location_data,
+            )
+            instance.location_id = location
+            instance.save()
+
+        return instance

core/apps/eggs/serializers/order_item.py

@@ -0,0 +1,33 @@
+"""
+Order Items serializer
+"""
+
+from rest_framework import serializers
+
+from core.apps.eggs import models
+from core.apps.eggs.models import Group
+from core.apps.eggs.serializers import courier_product, GroupSerializer
+
+
+class OrderItemsSerializer(serializers.ModelSerializer):
+    courier_product = courier_product.CourierProductSerializer(
+        read_only=True, source="courier_product_id"
+    )
+    group = GroupSerializer(read_only=True, source="group_id")
+    group_id = serializers.PrimaryKeyRelatedField(
+        queryset=Group.objects.all(), required=True
+    )
+
+    class Meta:
+        model = models.OrderItems
+        fields = (
+            "id",
+            "group",
+            "group_id",
+            "count",
+            "discount",
+            "courier_product",
+            "courier_product_id",
+            "sale_type",
+        )
+        extra_kwargs = {"courier_product_id": {"write_only": True}}

core/apps/eggs/serializers/party.py

@@ -0,0 +1,130 @@
+"""
+Party serializer
+"""
+
+from django.utils.translation import gettext as _
+from rest_framework import serializers
+
+from core.apps.eggs import models
+from core.apps.eggs.serializers import group
+from core.apps.eggs.serializers import group as group_serializer
+from core.apps.eggs.serializers import invoice
+from core.http.serializers import user
+
+
+class PartySerializer(serializers.ModelSerializer):
+    invoices = invoice.InvoiceSerializer(many=True)
+    groups = group.GroupSerializer(many=True)
+    user = user.UserSerializer(read_only=True, source="user_id")
+
+    class Meta:
+        model = models.Party
+        fields = (
+            "id",
+            "user",
+            "count",
+            "sold_count",
+            "remaining_count",
+            "profit",
+            "benefit",
+            "cost",
+            "total_cost",
+            "created_at",
+            "invoices",
+            "groups",
+            "broken_eggs",
+            "courier_eggs",
+        )
+
+    def create(self, validated_data):
+        invoices_data = validated_data.pop("invoices", [])
+        groups_data = validated_data.pop("groups", [])
+        party = models.Party.objects.create(**validated_data)
+
+        for invoice_data in invoices_data:
+            invoice_data["party_id"] = party
+            models.Invoice.objects.create(**invoice_data)
+
+        for group_data in groups_data:
+            group_data["party_id"] = party
+            models.Group.objects.create(**group_data)
+
+        return party
+
+
+class PartyGroupSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.Group
+        fields = (
+            "id",
+            "name",
+            "entry_price",
+            "unit_price",
+            "wholesale_price",
+            "quantity",
+            "broken_eggs",
+            "product_id",
+        )
+
+
+class PartyCreateSerializer(serializers.ModelSerializer):
+    invoices = invoice.InvoiceSerializer(many=True)
+    groups = PartyGroupSerializer(many=True)
+
+    class Meta:
+        model = models.Party
+        fields = (
+            "invoices",
+            "groups",
+        )
+
+    def create(self, validated_data):
+        user = self.context["request"].user
+        invoices_data = validated_data.pop("invoices", [])
+        groups_data = validated_data.pop("groups", [])
+        party = models.Party.objects.create(user_id=user, **validated_data)
+
+        for invoice_data in invoices_data:
+            invoice_data["party_id"] = party
+            models.Invoice.objects.create(**invoice_data)
+
+        created_groups = []
+        for group_data in groups_data:
+            group_data["party_id"] = party
+            created_group = models.Group.objects.create(**group_data)
+            created_groups.append(created_group)
+
+        party.groups.set(created_groups)
+
+        full_name = f"{user.first_name} {user.last_name}"
+
+        models.History.objects.create(
+            content_object=party,
+            action="party_created",
+            user_id=user,
+            created_who=full_name,
+            created_by=party.groups.name,
+            reason=_(f"Partiya yaratildi: {party.total_cost}"),
+            comment=_(f"Partiya yaratildi: {party.total_cost}"),
+            avatar=user.avatar if user.avatar else None,
+        )
+        models.Monitoring.objects.create(
+            content_object=party,
+            action="party_created",
+            user_id=user,
+            created_who=full_name,
+            created_by=party.groups.name,
+            reason=_(f"Partiya yaratildi: {party.total_cost}"),
+            comment="Chiqim",
+            price=party.total_cost,
+        )
+
+        return party
+
+    def to_representation(self, instance):
+        representation = super().to_representation(instance)
+        representation["groups"] = group_serializer.GroupSerializer(
+            instance.groups.all(), many=True
+        ).data
+
+        return representation

core/apps/eggs/serializers/product.py

@@ -0,0 +1,13 @@
+"""
+Product serializer
+"""
+
+from rest_framework import serializers
+
+from core.apps.eggs import models
+
+
+class ProductSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.Product
+        fields = ("id", "name")

core/apps/eggs/serializers/sklad.py

@@ -0,0 +1,66 @@
+from rest_framework import serializers
+
+from core.apps.eggs import models
+from core.http.models import User
+
+
+class AddSkladSerializer(serializers.ModelSerializer):
+    sklad_id = serializers.SerializerMethodField()
+
+    class Meta:
+        model = User
+        fields = (
+            "sklad_id",
+            "id",
+            "first_name",
+            "last_name",
+            "phone",
+            "username",
+            "role",
+            "avatar",
+            "password",
+        )
+
+    def create(self, validated_data):
+        validated_data["role"] = "sklad"
+        user = User.objects.create_user(**validated_data)
+        sklad = models.Sklad.objects.create(user_id=user)
+
+        request_user = self.context["request"].user
+        created_who = f"{request_user.first_name} {request_user.last_name}"
+
+        models.History.objects.create(
+            content_object=sklad,
+            action="sklad_created",
+            user_id=user,
+            created_who=created_who,
+            created_by=f"{user.first_name} {user.last_name}",
+            reason="Omborxona qo'shildi",
+            avatar=user.avatar if user.avatar else None,
+        )
+
+        return user
+
+    def get_sklad_id(self, obj):
+        sklad = models.Sklad.objects.filter(user_id=obj.id).first()
+        return sklad.id if sklad else None
+
+
+class SkladListSerializer(serializers.ModelSerializer):
+    avatar = serializers.SerializerMethodField()
+
+    class Meta:
+        model = User
+        fields = (
+            "id",
+            "first_name",
+            "last_name",
+            "phone",
+            "username",
+            "avatar",
+            "role",
+            "avatar",
+        )
+
+    def get_avatar(self, obj):
+        return obj.avatar.url if obj.avatar else None