from rest_framework import serializers
from .models import *
from django.db.models import *
from mama_care_api.settings import languageKey
from mama_care_api.settings import MEDIA_ROOT
from common.common import getLanguage

# Token Type


class TokenTypeSerializer(serializers.ModelSerializer):
    class Meta:
        model = TokenType
        fields = [
            "id",
            "keyName",
            "tokenTypeLen",
            "createdDate",
            "updatedDate",
        ]


# Device OS Type


class DeviceOSTypeSerializer(serializers.ModelSerializer):
    class Meta:
        model = DeviceOSType
        fields = [
            "id",
            "keyName",
            "createdDate",
            "updatedDate",
        ]


# Language


class LanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = Language
        fields = [
            "id",
            "name",
            "countryCode",
            "isEnabled",
            "languageCode",
            "createdDate",
            "updatedDate",
        ]


# Gender


class GenderSerializer(serializers.ModelSerializer):
    name = serializers.SerializerMethodField()

    class Meta:
        model = Gender
        fields = ["id", "keyName", "name"]

    def get_name(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            genderLanguageList = GenderLanguage.objects.filter(
                genderId=str(instance.id)
            ).filter(languageId=languageId)
            if genderLanguageList.__len__() > 0:
                return genderLanguageList[0].name


class GenderLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = GenderLanguage
        fields = ["id", "name", "genderId", languageKey]


# Child Type
class ChildTypeSerializer(serializers.ModelSerializer):
    name = serializers.SerializerMethodField()

    class Meta:
        model = ChildType
        fields = ["id", "keyName", "name"]

    def get_name(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            childTypeLanguageList = ChildTypeLanguage.objects.filter(
                childTypeId=str(instance.id)
            ).filter(languageId=languageId)
            if childTypeLanguageList.__len__() > 0:
                return childTypeLanguageList[0].name


class ChildTypeLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = ChildTypeLanguage
        fields = ["id", "name", "childTypeId", languageKey]


# Symptom Type
class SymptomTypeSerializer(serializers.ModelSerializer):
    name = serializers.SerializerMethodField()

    class Meta:
        model = SymptomType
        fields = [
            "id",
            "keyName",
            "image",
            "createdDate",
            "updatedDate",
            "name",
        ]

    def get_name(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            symptomTypeLanguageList = SymptomTypeLanguage.objects.filter(
                symptomTypeId=str(instance.id)
            ).filter(languageId=languageId)
            if symptomTypeLanguageList.__len__() > 0:
                return symptomTypeLanguageList[0].name


class SymptomTypeLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = SymptomTypeLanguage
        fields = [
            "id",
            "name",
            "symptomTypeId",
            languageKey,
        ]


# Kick Tracker Status
class KickTrackerStatusSerializer(serializers.ModelSerializer):
    name = serializers.SerializerMethodField()

    class Meta:
        model = KickTrackerStatus
        fields = [
            "id",
            "keyName",
            "count",
            "color",
            "createdDate",
            "updatedDate",
            "name",
        ]

    def get_name(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            kickTrackerStatusLanguageList = KickTrackerStatusLanguage.objects.filter(
                kickTrackerStatusId=str(instance.id)
            ).filter(languageId=languageId)
            if kickTrackerStatusLanguageList.__len__() > 0:
                return kickTrackerStatusLanguageList[0].name


class KickTrackerStatusLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = KickTrackerStatusLanguage
        fields = [
            "id",
            "name",
            "description",
            "kickTrackerStatusId",
            languageKey,
        ]


# BMI Cases
class BMICaseTypeSerializer(serializers.ModelSerializer):
    name = serializers.SerializerMethodField()
    caseList = serializers.SerializerMethodField()

    class Meta:
        model = BMICaseType
        fields = [
            "id",
            "keyName",
            "createdDate",
            "updatedDate",
            "name",
            "caseList",
        ]

    def get_name(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            BMICaseTypeLanguageList = BMICaseTypeLanguage.objects.filter(
                bmiCaseTypeId=str(instance.id)
            ).filter(languageId=languageId)
            if BMICaseTypeLanguageList.__len__() > 0:
                return BMICaseTypeLanguageList[0].name

    def get_caseList(self, instance):
        languageId = getLanguage(self)
        bmiCaseList = BMICase.objects.filter(bmiCaseTypeId=instance.id)
        return BMICaseSerializer(
            bmiCaseList, context={languageKey: languageId}, many=True
        ).data


class BMICaseTypeLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = BMICaseTypeLanguage
        fields = [
            "id",
            "name",
            "bmiCaseTypeId",
            languageKey,
        ]


class BMICaseSerializer(serializers.ModelSerializer):
    name = serializers.SerializerMethodField()
    rangeType = serializers.SerializerMethodField()
    weightGainList = serializers.SerializerMethodField()

    class Meta:
        model = BMICase
        fields = [
            "id",
            "keyName",
            "min",
            "max",
            "createdDate",
            "updatedDate",
            "bmiCaseTypeId",
            "name",
            "rangeType",
            "weightGainList",
        ]

    def get_name(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            BMICaseLanguageList = BMICaseLanguage.objects.filter(
                bmiCaseId=str(instance.id)
            ).filter(languageId=languageId)
            if BMICaseLanguageList.__len__() > 0:
                return BMICaseLanguageList[0].name

    def get_rangeType(self, instance):
        val = 0
        if instance.min == 0:
            val = 1
        elif instance.max == 0:
            val = 2
        return val

    def get_weightGainList(self, instance):
        weightGainList = BMICaseWeightGain.objects.filter(bmiCaseId=instance.id)
        return BMICaseWeightGainSerializer(weightGainList, many=True).data


class BMICaseLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = BMICaseLanguage
        fields = [
            "id",
            "name",
            "bmiCaseId",
            languageKey,
        ]


class BMICaseWeightGainSerializer(serializers.ModelSerializer):
    class Meta:
        model = BMICaseWeightGain
        fields = [
            "id",
            "min",
            "max",
            "bmiCaseId",
            "createdDate",
            "updatedDate",
        ]


class CalculationMethodSerializer(serializers.ModelSerializer):
    name = serializers.SerializerMethodField()

    class Meta:
        model = CalculationMethod
        fields = [
            "id",
            "keyName",
            "createdDate",
            "updatedDate",
            "name",
        ]

    def get_name(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            calculationMethodLanguageList = CalculationMethodLanguage.objects.filter(
                calculationMethodId=str(instance.id)
            ).filter(languageId=languageId)
            if calculationMethodLanguageList.__len__() > 0:
                return calculationMethodLanguageList[0].name


class CalculationMethodLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = CalculationMethodLanguage
        fields = [
            "id",
            "name",
            "calculationMethodId",
            languageKey,
        ]


# Pregnancy Week


class PregnancyWeekBasicSerializer(serializers.ModelSerializer):
    fetalDevelopment = serializers.SerializerMethodField()
    babySize = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyWeek
        fields = [
            "id",
            "image",
            "fetalDevelopment",
            "babySize",
        ]

    def get_fetalDevelopment(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            pregnancyWeekLanguageList = PregnancyWeekLanguage.objects.filter(
                pregnancyWeekId=str(instance.id)
            ).filter(languageId=languageId)
            if pregnancyWeekLanguageList.__len__() > 0:
                return pregnancyWeekLanguageList[0].fetalDevelopment

    def get_babySize(self, instance):
        languageId = getLanguage(self)
        dataList = PregnancyBabySize.objects.filter(pregnancyWeekId=instance.id)
        if dataList.__len__() > 0:
            return PregnancyBabySizeBasicSerializer(
                dataList[0], context={languageKey: languageId}
            ).data
        return None


class PregnancyWeekDetailSerializer(serializers.ModelSerializer):
    fetalDevelopment = serializers.SerializerMethodField()
    babySize = serializers.SerializerMethodField()
    symptomList = serializers.SerializerMethodField()
    checkList = serializers.SerializerMethodField()
    nutritionList = serializers.SerializerMethodField()
    monthlyTip = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyWeek
        fields = [
            "id",
            "keyName",
            "weekNumber",
            "trimester",
            "image",
            "createdDate",
            "updatedDate",
            "fetalDevelopment",
            "babySize",
            "symptomList",
            "checkList",
            "nutritionList",
            "monthlyTip",
        ]

    def get_fetalDevelopment(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            pregnancyWeekLanguageList = PregnancyWeekLanguage.objects.filter(
                pregnancyWeekId=str(instance.id)
            ).filter(languageId=languageId)
            if pregnancyWeekLanguageList.__len__() > 0:
                return pregnancyWeekLanguageList[0].fetalDevelopment

    def get_babySize(self, instance):
        languageId = getLanguage(self)
        dataList = PregnancyBabySize.objects.filter(pregnancyWeekId=instance.id)
        if dataList.__len__() > 0:
            return PregnancyBabySizeDetailSerializer(
                dataList[0], context={languageKey: languageId}
            ).data
        return None

    def get_symptomList(self, instance):
        languageId = getLanguage(self)
        dataList = PregnancySymptom.objects.filter(pregnancyWeekId=instance.id)
        return PregnancySymptomSerializer(
            dataList, context={languageKey: languageId}, many=True
        ).data

    def get_checkList(self, instance):
        languageId = getLanguage(self)
        dataList = PregnancyCheckList.objects.filter(pregnancyWeekId=instance.id)
        return PregnancyCheckListSerializer(
            dataList, context={languageKey: languageId}, many=True
        ).data

    def get_nutritionList(self, instance):
        languageId = getLanguage(self)
        dataList = PregnancyNutrition.objects.filter(pregnancyWeekId=instance.id)
        return PregnancyNutritionSerializer(
            dataList, context={languageKey: languageId}, many=True
        ).data

    def get_monthlyTip(self, instance):
        languageId = getLanguage(self)
        month = 0
        if instance.weekNumber <= 4:
            month = 1
        elif instance.weekNumber <= 8:
            month = 2
        elif instance.weekNumber <= 13:
            month = 3
        elif instance.weekNumber <= 17:
            month = 4
        elif instance.weekNumber <= 22:
            month = 5
        elif instance.weekNumber <= 27:
            month = 6
        elif instance.weekNumber <= 31:
            month = 7
        elif instance.weekNumber <= 35:
            month = 8
        else:
            month = 9

        selected = MonthlyTip.objects.filter(monthNumber=month)
        if selected.__len__() > 0:
            return MonthlyTipSerializer(
                selected[0], context={languageKey: languageId}
            ).data
        return None


class PregnancyWeekLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = PregnancyWeekLanguage
        fields = [
            "id",
            "fetalDevelopment",
            "createdDate",
            "updatedDate",
            "pregnancyWeekId",
            languageKey,
        ]


# Pregnancy Baby Size


class PregnancyBabySizeBasicSerializer(serializers.ModelSerializer):
    description = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyBabySize
        fields = [
            "image",
            "description",
        ]

    def get_description(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            pregnancyBabySizeLanguage = PregnancyBabySizeLanguage.objects.filter(
                pregnancyBabySizeId=str(instance.id)
            ).filter(languageId=languageId)
            if pregnancyBabySizeLanguage.__len__() > 0:
                return pregnancyBabySizeLanguage[0].description


class PregnancyBabySizeDetailSerializer(serializers.ModelSerializer):
    description = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyBabySize
        fields = [
            "id",
            "keyName",
            "image",
            "createdDate",
            "updatedDate",
            "pregnancyWeekId",
            "description",
        ]

    def get_description(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            pregnancyBabySizeLanguage = PregnancyBabySizeLanguage.objects.filter(
                pregnancyBabySizeId=str(instance.id)
            ).filter(languageId=languageId)
            if pregnancyBabySizeLanguage.__len__() > 0:
                return pregnancyBabySizeLanguage[0].description


class PregnancyBabySizeLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = PregnancyBabySizeLanguage
        fields = [
            "id",
            "description",
            "createdDate",
            "updatedDate",
            "pregnancyBabySizeId",
            languageKey,
        ]


# Pregnancy Symptom


class PregnancySymptomSerializer(serializers.ModelSerializer):
    description = serializers.SerializerMethodField()

    class Meta:
        model = PregnancySymptom
        fields = [
            "id",
            "createdDate",
            "updatedDate",
            "pregnancyWeekId",
            "description",
        ]

    def get_description(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            pregnancySymptomLanguage = PregnancySymptomLanguage.objects.filter(
                pregnancySymptomId=str(instance.id)
            ).filter(languageId=languageId)
            if pregnancySymptomLanguage.__len__() > 0:
                return pregnancySymptomLanguage[0].description


class PregnancySymptomLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = PregnancySymptomLanguage
        fields = [
            "id",
            "description",
            "createdDate",
            "updatedDate",
            "pregnancySymptomId",
            languageKey,
        ]


# Pregnancy Checklist


class PregnancyCheckListSerializer(serializers.ModelSerializer):
    description = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyCheckList
        fields = [
            "id",
            "createdDate",
            "updatedDate",
            "pregnancyWeekId",
            "description",
        ]

    def get_description(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            pregnancyCheckListLanguage = PregnancyCheckListLanguage.objects.filter(
                pregnancyCheckListId=str(instance.id)
            ).filter(languageId=languageId)
            if pregnancyCheckListLanguage.__len__() > 0:
                return pregnancyCheckListLanguage[0].description


class PregnancyCheckListLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = PregnancyCheckListLanguage
        fields = [
            "id",
            "description",
            "createdDate",
            "updatedDate",
            "pregnancyCheckListId",
            languageKey,
        ]


# Pregnancy Nutrition


class PregnancyNutritionSerializer(serializers.ModelSerializer):
    description = serializers.SerializerMethodField()

    class Meta:
        model = PregnancyNutrition
        fields = [
            "id",
            "pregnancyWeekId",
            "createdDate",
            "updatedDate",
            "description",
        ]

    def get_description(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            pregnancyNutritionLanguage = PregnancyNutritionLanguage.objects.filter(
                pregnancyNutritionId=str(instance.id)
            ).filter(languageId=languageId)
            if pregnancyNutritionLanguage.__len__() > 0:
                return pregnancyNutritionLanguage[0].description


class PregnancyNutritionLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = PregnancyNutritionLanguage
        fields = [
            "id",
            "description",
            "createdDate",
            "updatedDate",
            "pregnancyNutritionId",
            languageKey,
        ]


# Monthly Tips


class MonthlyTipSerializer(serializers.ModelSerializer):
    title = serializers.SerializerMethodField()
    description = serializers.SerializerMethodField()
    inspiration = serializers.SerializerMethodField()
    tipList = serializers.SerializerMethodField()

    class Meta:
        model = MonthlyTip
        fields = [
            "id",
            "monthNumber",
            "createdDate",
            "updatedDate",
            "title",
            "description",
            "inspiration",
            "tipList",
        ]

    def get_title(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            monthlyTipLanguage = MonthlyTipLanguage.objects.filter(
                monthlyTipId=str(instance.id)
            ).filter(languageId=languageId)
            if monthlyTipLanguage.__len__() > 0:
                return monthlyTipLanguage[0].title

    def get_description(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            monthlyTipLanguage = MonthlyTipLanguage.objects.filter(
                monthlyTipId=str(instance.id)
            ).filter(languageId=languageId)
            if monthlyTipLanguage.__len__() > 0:
                return monthlyTipLanguage[0].description

    def get_inspiration(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            monthlyTipLanguage = MonthlyTipLanguage.objects.filter(
                monthlyTipId=str(instance.id)
            ).filter(languageId=languageId)
            if monthlyTipLanguage.__len__() > 0:
                return monthlyTipLanguage[0].inspiration

    def get_tipList(self, instance):
        languageId = getLanguage(self)
        selectedList = Tip.objects.filter(monthlyTipId=instance.id).filter(
            tip_tiplanguage__languageId=languageId
        )
        return TipSerializer(
            selectedList, many=True, context={languageKey: languageId}
        ).data


class MonthlyTipLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = MonthlyTipLanguage
        fields = [
            "id",
            "title",
            "description",
            "inspiration",
            "createdDate",
            "updatedDate",
            "monthlyTipId",
            languageKey,
        ]


# Tip
class TipSerializer(serializers.ModelSerializer):
    description = serializers.SerializerMethodField()

    class Meta:
        model = Tip
        fields = ["id", "monthlyTipId", "createdDate", "updatedDate", "description"]

    def get_description(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            tipLanguageList = TipLanguage.objects.filter(tipId=str(instance.id)).filter(
                languageId=languageId
            )
            if tipLanguageList.__len__() > 0:
                return tipLanguageList[0].description


class TipLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = TipLanguage
        fields = [
            "id",
            "description",
            "createdDate",
            "updatedDate",
            "tipId",
            languageKey,
        ]


# FAQ


class FAQCategorySerializer(serializers.ModelSerializer):
    title = serializers.SerializerMethodField()
    faqList = serializers.SerializerMethodField()

    class Meta:
        model = FAQCategory
        fields = ["id", "createdDate", "updatedDate", "title", "faqList"]

    def get_title(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            faqCategoryLanguageList = FAQCategoryLanguage.objects.filter(
                faqCategoryId=str(instance.id)
            ).filter(languageId=languageId)
            if faqCategoryLanguageList.__len__() > 0:
                return faqCategoryLanguageList[0].title

    def get_faqList(self, instance):
        languageId = getLanguage(self)
        dataList = FAQ.objects.filter(faqCategoryId=instance.id)
        return FAQSerializer(
            dataList, context={languageKey: languageId}, many=True
        ).data


class FAQCategoryLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = FAQCategoryLanguage
        fields = [
            "id",
            "title",
            "createdDate",
            "updatedDate",
            "faqCategoryId",
            languageKey,
        ]


class FAQSerializer(serializers.ModelSerializer):
    question = serializers.SerializerMethodField()
    answer = serializers.SerializerMethodField()

    class Meta:
        model = FAQ
        fields = [
            "id",
            "createdDate",
            "updatedDate",
            "faqCategoryId",
            "question",
            "answer",
        ]

    def get_question(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            faqLanguageList = FAQLanguage.objects.filter(faqId=str(instance.id)).filter(
                languageId=languageId
            )
            if faqLanguageList.__len__() > 0:
                return faqLanguageList[0].question

    def get_answer(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            faqLanguageList = FAQLanguage.objects.filter(faqId=str(instance.id)).filter(
                languageId=languageId
            )
            if faqLanguageList.__len__() > 0:
                return faqLanguageList[0].answer


class FAQLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = FAQLanguage
        fields = [
            "id",
            "question",
            "answer",
            "createdDate",
            "updatedDate",
            "faqId",
            languageKey,
        ]


# Checkup Status


class CheckUpStatusSerializer(serializers.ModelSerializer):
    class Meta:
        model = CheckUpStatus
        fields = [
            "id",
            "level",
            "minSystolic",
            "maxSystolic",
            "minBPM",
            "maxBPM",
            "minMGDL",
            "maxMGDL",
            "bloodSugarType",
            "flag",
            "createdDate",
            "updatedDate",
        ]


class CheckUpStatusLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = CheckUpStatusLanguage
        fields = [
            "id",
            "title",
            "description",
            "createdDate",
            "updatedDate",
            "checkUpStatusId",
            languageKey,
        ]




# Subscription Plan


class SubscriptionPlanBasicSerializer(serializers.ModelSerializer):
    title = serializers.SerializerMethodField()
    description = serializers.SerializerMethodField()
    subscriptionPLanDetailList = serializers.SerializerMethodField()

    class Meta:
        model = SubscriptionPlan
        fields = [
            "id",
            "keyName",
            "isRecommended",
            "price",
            "title",
            "description",
            "subscriptionPLanDetailList",
        ]

    def get_title(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            subscriptionPlanLanguageList = SubscriptionPlanLanguage.objects.filter(
                subscriptionPlanId=str(instance.id)
            ).filter(languageId=languageId)
            if subscriptionPlanLanguageList.__len__() > 0:
                return subscriptionPlanLanguageList[0].title

        return None

    def get_description(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            subscriptionPlanLanguageList = SubscriptionPlanLanguage.objects.filter(
                subscriptionPlanId=str(instance.id)
            ).filter(languageId=languageId)
            if subscriptionPlanLanguageList.__len__() > 0:
                return subscriptionPlanLanguageList[0].description
        return None

    def get_subscriptionPLanDetailList(self, instance):
        languageId = getLanguage(self)
        dataList = SubscriptionPlanDetail.objects.filter(subscriptionPlanId=instance.id)
        return SubscriptionPlanDetailSerializer(
            dataList, context={"languageId": languageId}, many=True
        ).data


class SubscriptionPlanSerializer(serializers.ModelSerializer):
    title = serializers.SerializerMethodField()
    description = serializers.SerializerMethodField()

    class Meta:
        model = SubscriptionPlan
        fields = [
            "id",
            "keyName",
            "price",
            "isRecommended",
            "isUnLimited",
            "isAllowAdding",
            "addingRecordCount",
            "isAllowEditing",
            "isAllowDeleting",
            "isAllowReading",
            "isAllowPaging",
            "isAllowAIAssist",
            "isDefault",
            "createdDate",
            "updatedDate",
            "title",
            "description",
        ]

    def get_title(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            subscriptionPlanLanguageList = SubscriptionPlanLanguage.objects.filter(
                subscriptionPlanId=str(instance.id)
            ).filter(languageId=languageId)
            if subscriptionPlanLanguageList.__len__() > 0:
                return subscriptionPlanLanguageList[0].title

    def get_description(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            subscriptionPlanLanguageList = SubscriptionPlanLanguage.objects.filter(
                subscriptionPlanId=str(instance.id)
            ).filter(languageId=languageId)
            if subscriptionPlanLanguageList.__len__() > 0:
                return subscriptionPlanLanguageList[0].description


class SubscriptionPlanLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = SubscriptionPlanLanguage
        fields = [
            "id",
            "title",
            "description",
            "createdDate",
            "updatedDate",
            "subscriptionPlanId",
            languageKey,
        ]


# Subscription Plan Detail


class SubscriptionPlanDetailSerializer(serializers.ModelSerializer):
    description = serializers.SerializerMethodField()

    class Meta:
        model = SubscriptionPlanDetail
        fields = [
            "id",
            "subscriptionPlanId",
            "createdDate",
            "updatedDate",
            "description",
        ]

    def get_description(self, instance):
        languageId = getLanguage(self)
        if languageId is not None:
            subscriptionPlanDetailLanguageList = (
                SubscriptionPlanDetailLanguage.objects.filter(
                    subscriptionPlanDetailId=str(instance.id)
                ).filter(languageId=languageId)
            )
            if subscriptionPlanDetailLanguageList.__len__() > 0:
                return subscriptionPlanDetailLanguageList[0].description


class SubscriptionPlanDetailLanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = SubscriptionPlanDetailLanguage
        fields = [
            "id",
            "description",
            "createdDate",
            "updatedDate",
            "subscriptionPlanDetailId",
            languageKey,
        ]