backend-v1/core/apps/evaluation/serializers/request/EvaluationRequest.py

import re

from django.contrib.auth import get_user_model

from rest_framework import serializers

from core.apps.evaluation.models import EvaluationrequestModel, ReferenceitemModel, EvaluationRequestOwnerModel, EvaluationRequestCustomerModel
from core.apps.evaluation.serializers.reference import ListReferenceitemSerializer
from core.apps.evaluation.serializers.request.owner import EvaluationRequestOwnerSerializer
from core.apps.evaluation.serializers.request.customer import EvaluationRequestCustomerSerializer



User = get_user_model()


class BaseEvaluationrequestSerializer(serializers.ModelSerializer):
    rate_type_display = serializers.CharField(
        source="get_rate_type_display", read_only=True
    )
    object_type_display = serializers.CharField(
        source="get_object_type_display", read_only=True, default=None
    )
    status_display = serializers.CharField(
        source="get_status_display", read_only=True
    )
    location = serializers.SerializerMethodField()

    location_name = serializers.CharField(required=False)
    value_determined = ListReferenceitemSerializer(read_only=True)
    rate_goal = ListReferenceitemSerializer(read_only=True)
    property_rights = ListReferenceitemSerializer(read_only=True)
    form_ownership = ListReferenceitemSerializer(read_only=True)
    user = serializers.SerializerMethodField(method_name="get_user")
    customer = EvaluationRequestCustomerSerializer(read_only=True)
    owner = EvaluationRequestOwnerSerializer(read_only=True)

    class Meta:
        model = EvaluationrequestModel
        fields = [
            "id",
            "rate_type",
            "rate_type_display",
            "object_type",
            "object_type_display",
            "customer_inn_number",
            "owner_inn_number",
            "tex_passport",
            "value_determined",
            "rate_goal",
            "property_rights",
            "form_ownership",
            "worked_hours",
            "chassi",
            "need_delivering",
            "location",
            "location_name",
            "status",
            "status_display",
            "user",
            "created_at",
            "updated_at",
            "is_archive",
            "customer",
            "owner",
        ]

    def get_location(self, obj):
        if obj.location_lat is not None and obj.location_lng is not None:
            return {
                "lat": float(obj.location_lat),
                "lng": float(obj.location_lng),
                "name": obj.location_name
            }
        return None

    def get_user(self, obj):
        request = self.context.get('request')
        return {
            "id": obj.user.id,
            "phone": obj.user.phone,
            "first_name": obj.user.first_name,
            "last_name": obj.user.last_name,
            "role": obj.user.role,
            "avatar": request.build_absolute_uri(obj.user.avatar.url) if obj.user.avatar else None
        }


class ListEvaluationrequestSerializer(BaseEvaluationrequestSerializer):
    class Meta(BaseEvaluationrequestSerializer.Meta):
        pass


class RetrieveEvaluationrequestSerializer(BaseEvaluationrequestSerializer):
    class Meta(BaseEvaluationrequestSerializer.Meta):
        pass


class CreateEvaluationrequestSerializer(serializers.ModelSerializer):
    location = serializers.DictField(required=False, allow_empty=True)

    locationName = serializers.CharField(
        write_only=True,
        required=False,
        allow_null=True,
        allow_blank=True,
    )

    worked_hours = serializers.IntegerField(
        required=False,
        allow_null=True,
    )
    chassi = serializers.CharField(
        required=False,
        allow_null=True,
        allow_blank=True,
    )

    value_determined = serializers.PrimaryKeyRelatedField(required=False, queryset=ReferenceitemModel.objects.all())
    rate_goal = serializers.PrimaryKeyRelatedField(required=False, queryset=ReferenceitemModel.objects.all())
    property_rights = serializers.PrimaryKeyRelatedField(required=False, queryset=ReferenceitemModel.objects.all())
    form_ownership = serializers.PrimaryKeyRelatedField(required=False, queryset=ReferenceitemModel.objects.all())
    customer = EvaluationRequestCustomerSerializer()
    owner = EvaluationRequestOwnerSerializer()

    class Meta:
        model = EvaluationrequestModel
        fields = [
            "value_determined",
            "rate_goal",
            "property_rights",
            "form_ownership",
            "rate_type",
            "object_type",
            "customer_inn_number",
            "owner_inn_number",
            "tex_passport",
            "worked_hours",
            "chassi",
            "need_delivering",
            "location",
            "locationName",
            "customer",
            "owner",
            "customer_and_owner_same",
            "distance_covered",
            "gov_number"
        ]

    def validate_tex_passport(self, value):
        if value and not re.match(r"^[A-Z]{2}\s?\d{7}$", value):
            raise serializers.ValidationError(
                "Format: AA 1234567 (2 harf + 7 raqam)"
            )
        return value

    def validate(self, attrs):
        rate_type = attrs.get("rate_type")
        object_type = attrs.get("object_type")

        if rate_type == "auto" and not object_type:
            raise serializers.ValidationError(
                {"object_type": "rate_type 'auto' bo'lganda object_type majburiy."}
            )

        if rate_type == "auto" and not attrs.get("tex_passport"):
            raise serializers.ValidationError(
                {"tex_passport": "rate_type 'auto' bo'lganda tex_passport majburiy."}
            )

        if object_type == "truck_car":
            if attrs.get("worked_hours") is None:
                raise serializers.ValidationError(
                    {"worked_hours": "Yuk avtomobil uchun ishlagan soati majburiy."}
                )
            if not attrs.get("chassi"):
                raise serializers.ValidationError(
                    {"chassi": "Yuk avtomobil uchun shassi raqami majburiy."}
                )

        return attrs

    def create(self, validated_data):
        location = validated_data.pop("location", None)
        location_name = validated_data.pop("locationName", None)

        if location:
            validated_data["location_lat"] = location.get("lat")
            validated_data["location_lng"] = location.get("lng")
            if not location_name:
                location_name = location.get("name") or location.get("locationName")

        if location_name:
            validated_data["location_name"] = str(location_name)
        validated_data["user"] = self.context["request"].user

        instance = super().create(validated_data)

        customer = validated_data.pop("customer", None)
        owner = validated_data.pop("owner", None)
        EvaluationRequestCustomerModel.objects.create(
            evaluation_request=instance,
            type=customer.get("type"),
            jshshir=customer.get("jshshir")
        )
        if not instance.customer_and_owner_same:
            EvaluationRequestOwnerModel.objects.create(
                evaluation_request=instance,
                type=owner.get("type"),
                jshshir=owner.get("jshshir")
            )
        else:
            EvaluationRequestOwnerModel.objects.create(
                evaluation_request=instance,
                type=customer.get("type"),
                jshshir=customer.get("jshshir")
            )

        return instance


class ArchiveEvaluationrequestSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=True)
    is_archive = serializers.BooleanField(required=True)