Dovodi_Backend/apps/hadis/serializers/serializers_admin.py

from rest_framework import serializers
from ..models import (
    Hadis, HadisCategory, HadisStatus, HadisTag, HadisCorrection, HadisInterpretation, HadisSect,
    BookReference, BookReferenceImage, BookReferenceDocument, BookAuthor, BookAttribute, BookSubjectArea, BookType,
    Transmitters, TransmitterReliability
)
from .category import LocalizedField


class AdminHadisCategorySerializer(serializers.ModelSerializer):
    sect_type = serializers.CharField(source='sect.sect_type', read_only=True)
    title = LocalizedField()
    description = LocalizedField()

    class Meta:
        model = HadisCategory
        fields = [
            "id",
            "title",
            "slug",
            "source_type",
            "order",
            "sect",
            "sect_type",
            "description",
        ]


class AdminHadisStatusSerializer(serializers.ModelSerializer):
    title = LocalizedField()
    description = LocalizedField()

    class Meta:
        model = HadisStatus
        fields = ["id", "title", "slug", "color", "order", "description"]


class AdminHadisTagSerializer(serializers.ModelSerializer):
    title = LocalizedField()

    class Meta:
        model = HadisTag
        fields = ["id", "title", "status"]


class AdminHadisListSerializer(serializers.ModelSerializer):
    category_detail = AdminHadisCategorySerializer(source="category", read_only=True)
    hadis_status_detail = AdminHadisStatusSerializer(source="hadis_status", read_only=True)
    title = LocalizedField()
    title_narrator = LocalizedField()
    translation = LocalizedField()

    class Meta:
        model = Hadis
        fields = [
            "id",
            "number",
            "slug",
            "title",
            "title_narrator",
            "text",
            "translation",
            "status",
            "category",
            "category_detail",
            "hadis_status",
            "hadis_status_detail",
            "created_at",
            "updated_at",
        ]
        read_only_fields = ["id", "slug", "created_at", "updated_at"]


class AdminHadisDetailSerializer(serializers.ModelSerializer):
    category_detail = AdminHadisCategorySerializer(source="category", read_only=True)
    hadis_status_detail = AdminHadisStatusSerializer(source="hadis_status", read_only=True)
    tags_detail = AdminHadisTagSerializer(source="tags", many=True, read_only=True)

    category = serializers.PrimaryKeyRelatedField(
        queryset=HadisCategory.objects.all(),
        required=False,
        allow_null=True,
    )
    hadis_status = serializers.PrimaryKeyRelatedField(
        queryset=HadisStatus.objects.all(),
        required=False,
        allow_null=True,
    )
    tags = serializers.PrimaryKeyRelatedField(
        queryset=HadisTag.objects.all(),
        many=True,
        required=False,
    )

    class Meta:
        model = Hadis
        fields = [
            "id",
            "number",
            "slug",
            "category",
            "category_detail",
            "title_narrator",
            "title",
            "description",
            "text",
            "translation",
            "status",
            "hadis_status",
            "hadis_status_detail",
            "hadis_status_text",
            "address",
            "links",
            "tags",
            "tags_detail",
            "share_link",
            "explanation",
            "created_at",
            "updated_at",
            "embedded_in",
        ]
        read_only_fields = ["id", "slug", "share_link", "created_at", "updated_at"]

    def create(self, validated_data):
        tags = validated_data.pop("tags", [])
        hadis = super().create(validated_data)
        if tags:
            hadis.tags.set(tags)
        return hadis

    def update(self, instance, validated_data):
        tags = validated_data.pop("tags", None)
        hadis = super().update(instance, validated_data)
        if tags is not None:
            hadis.tags.set(tags)
        return hadis


class AdminHadisCorrectionSerializer(serializers.ModelSerializer):
    class Meta:
        model = HadisCorrection
        fields = [
            "id",
            "hadis",
            "title",
            "slug",
            "text",
            "translation",
            "priority",
            "created_at",
            "updated_at",
        ]
        read_only_fields = ["id", "slug", "created_at", "updated_at"]


class AdminHadisInterpretationSerializer(serializers.ModelSerializer):
    class Meta:
        model = HadisInterpretation
        fields = [
            "id",
            "category",
            "title",
            "text",
            "translation",
            "priority",
            "created_at",
            "updated_at",
        ]
        read_only_fields = ["id", "created_at", "updated_at"]


class AbsoluteImageField(serializers.ImageField):
    def to_representation(self, value):
        if not value:
            return None
        request = self.context.get("request")
        url = value.url if hasattr(value, "url") else str(value)
        if request:
            return request.build_absolute_uri(url)
        return url


class AbsoluteFileField(serializers.FileField):
    def to_representation(self, value):
        if not value:
            return None
        request = self.context.get("request")
        url = value.url if hasattr(value, "url") else str(value)
        if request:
            return request.build_absolute_uri(url)
        return url


class AdminTransmitterReliabilitySerializer(serializers.ModelSerializer):
    class Meta:
        model = TransmitterReliability
        fields = ["id", "title", "slug", "color", "main_color_code"]


class AdminTransmitterListSerializer(serializers.ModelSerializer):
    reliability_detail = AdminTransmitterReliabilitySerializer(source="reliability", read_only=True)
    full_name = serializers.JSONField()
    known_as = serializers.JSONField()
    nickname = serializers.JSONField()
    thumbnail = AbsoluteImageField(required=False, allow_null=True)
    share_link = serializers.CharField(read_only=True)

    class Meta:
        model = Transmitters
        fields = [
            "id",
            "full_name",
            "slug",
            "birth_year_hijri",
            "death_year_hijri",
            "known_as",
            "nickname",
            "reliability",
            "reliability_detail",
            "madhhab",
            "generation",
            "thumbnail",
            "share_link",
            "created_at",
            "updated_at",
        ]
        read_only_fields = ["id", "slug", "share_link", "created_at", "updated_at"]


class AdminTransmitterDetailSerializer(serializers.ModelSerializer):
    reliability_detail = AdminTransmitterReliabilitySerializer(source="reliability", read_only=True)
    full_name = serializers.JSONField()
    kunya = serializers.JSONField()
    known_as = serializers.JSONField()
    nickname = serializers.JSONField()
    origin = serializers.JSONField()
    lived_in = serializers.JSONField()
    died_in = serializers.JSONField()
    description = serializers.JSONField()
    thumbnail = AbsoluteImageField(required=False, allow_null=True)
    reliability = serializers.PrimaryKeyRelatedField(
        queryset=TransmitterReliability.objects.all(),
        required=False,
    )
    share_link = serializers.CharField(read_only=True)

    class Meta:
        model = Transmitters
        fields = [
            "id",
            "full_name",
            "kunya",
            "known_as",
            "nickname",
            "slug",
            "legacy_number",
            "legacy_id",
            "birth_year_hijri",
            "death_year_hijri",
            "age_at_death",
            "generation",
            "reliability",
            "reliability_detail",
            "madhhab",
            "in_sahih_muslim",
            "in_sahih_bukhari",
            "origin",
            "lived_in",
            "died_in",
            "description",
            "thumbnail",
            "share_link",
            "created_at",
            "updated_at",
        ]
        read_only_fields = ["id", "slug", "share_link", "created_at", "updated_at", "reliability_detail"]


class AdminBookSubjectAreaSerializer(serializers.ModelSerializer):
    class Meta:
        model = BookSubjectArea
        fields = ["id", "title"]


class AdminBookTypeSerializer(serializers.ModelSerializer):
    class Meta:
        model = BookType
        fields = ["id", "title"]


class AdminBookAuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = BookAuthor
        fields = ["id", "name", "birth_year_hijri", "death_year_hijri", "birth_year_miladi", "death_year_miladi"]


class AdminBookAttributeSerializer(serializers.ModelSerializer):
    class Meta:
        model = BookAttribute
        fields = ["id", "book_reference", "title", "value"]


class AdminBookReferenceImageSerializer(serializers.ModelSerializer):
    image = AbsoluteImageField(required=True)

    class Meta:
        model = BookReferenceImage
        fields = ["id", "book_reference", "image", "volume", "order", "description"]


class AdminBookReferenceDocumentSerializer(serializers.ModelSerializer):
    file = AbsoluteFileField(required=True)

    class Meta:
        model = BookReferenceDocument
        fields = ["id", "book_reference", "file", "volume", "title", "order"]


class AdminBookReferenceListSerializer(serializers.ModelSerializer):
    class Meta:
        model = BookReference
        fields = [
            "id",
            "title",
            "slug",
            "volume",
            "publisher",
            "year_of_publication",
            "rate",
            "created_at",
        ]


class AdminBookReferenceDetailSerializer(serializers.ModelSerializer):
    subject_area_detail = AdminBookSubjectAreaSerializer(source="subject_area", many=True, read_only=True)
    type_detail = AdminBookTypeSerializer(source="type", read_only=True)
    authors_detail = AdminBookAuthorSerializer(source="authors", many=True, read_only=True)

    subject_area = serializers.PrimaryKeyRelatedField(
        queryset=BookSubjectArea.objects.all(),
        many=True,
        required=False,
    )
    type = serializers.PrimaryKeyRelatedField(
        queryset=BookType.objects.all(),
        required=False,
        allow_null=True,
    )
    authors = serializers.PrimaryKeyRelatedField(
        queryset=BookAuthor.objects.all(),
        many=True,
        required=False,
    )

    class Meta:
        model = BookReference
        fields = [
            "id",
            "legacy_id",
            "source_url",
            "title",
            "description",
            "language",
            "isbn",
            "volume",
            "number_of_volumes",
            "year_of_publication",
            "number_page",
            "slug",
            "publisher",
            "subject_area",
            "subject_area_detail",
            "type",
            "type_detail",
            "order",
            "researcher",
            "city_of_publication",
            "country_of_publication",
            "edition_number",
            "rate",
            "authors",
            "authors_detail",
            "created_at",
            "updated_at",
            "share_link",
        ]
        read_only_fields = ["id", "slug", "created_at", "updated_at", "share_link"]

    def create(self, validated_data):
        subject_area = validated_data.pop("subject_area", [])
        authors = validated_data.pop("authors", [])
        book = super().create(validated_data)
        if subject_area:
            book.subject_area.set(subject_area)
        if authors:
            book.authors.set(authors)
        return book

    def update(self, instance, validated_data):
        subject_area = validated_data.pop("subject_area", None)
        authors = validated_data.pop("authors", None)
        book = super().update(instance, validated_data)
        if subject_area is not None:
            book.subject_area.set(subject_area)
        if authors is not None:
            book.authors.set(authors)
        return book