LilSchool/api/v1/serializers/payment.py

from rest_framework import serializers

from apps.payment.models import (
    AuthorBalance, Payment,
    CoursePayment, SchoolPayment,
    GiftCertificatePayment, UserBonus,)
from .user import UserSerializer
from .course import CourseSerializer

BASE_PAYMENT_FIELDS = (
    'id',
    'user',
    'amount',
    'status',
    'data',
    'is_deliverable',
    'created_at',
    'update_at',
)


class AuthorBalanceCreateSerializer(serializers.ModelSerializer):

    class Meta:
        model = AuthorBalance
        fields = (
            'id',
            'author',
            'type',
            'amount',
            'commission',
            'status',
            'payment',
            'card',
            'cause',
        )

        read_only_fields = (
            'id',
            'author',
            'type',
            'payment',
        )

    def to_representation(self, instance):
        return AuthorBalanceSerializer(instance, context=self.context).to_representation(instance)


class AuthorBalanceSerializer(serializers.ModelSerializer):
    author = UserSerializer()
    payment = serializers.SerializerMethodField()

    class Meta:
        model = AuthorBalance
        fields = (
            'id',
            'author',
            'type',
            'amount',
            'commission',
            'status',
            'payment',
            'card',
            'cause',
            'created_at',
        )

        read_only_fields = (
            'id',
            'author',
            'type',
            'payment',
            'created_at',
        )

    def get_payment(self, instance):
        try:
            p = instance.payment
        except Exception:
            return None
        if not p:
            return None
        data = {
            'id': p.id,
            'created_at': p.created_at,
            'amount': p.amount,
            'data': p.data,
            'status': p.status,
        }
        if isinstance(instance.payment, CoursePayment):
            data['course'] = {
                'id': p.course.id,
                'title': p.course.title,
            }
        return data


class PaymentSerializer(serializers.ModelSerializer):
    user = UserSerializer()

    class Meta:
        model = Payment
        fields = BASE_PAYMENT_FIELDS
        read_only_fields = (
            'id',
            'user',
            'data',
            'created_at',
            'update_at',
        )

    def to_representation(self, instance):
        if isinstance(instance, CoursePayment):
            return CoursePaymentSerializer(instance, context=self.context).to_representation(instance)
        elif isinstance(instance, SchoolPayment):
            return SchoolPaymentSerializer(instance, context=self.context).to_representation(instance)
        elif isinstance(instance, GiftCertificatePayment):
            return GiftCertificatePaymentSerializer(instance, context=self.context).to_representation(instance)


class CoursePaymentCreateSerializer(serializers.ModelSerializer):

    class Meta:
        model = CoursePayment
        fields = BASE_PAYMENT_FIELDS + ('course',)
        read_only_fields = (
            'id',
            'user',
            'course',
            'created_at',
            'update_at',
        )


class CoursePaymentSerializer(serializers.ModelSerializer):
    user = UserSerializer()
    course = CourseSerializer()

    class Meta:
        model = CoursePayment
        fields = BASE_PAYMENT_FIELDS + ('course',)
        read_only_fields = (
            'id',
            'user',
            'course',
            'created_at',
            'update_at',
        )


class SchoolPaymentCreateSerializer(serializers.ModelSerializer):

    class Meta:
        model = SchoolPayment
        fields = BASE_PAYMENT_FIELDS + (
            'weekdays',
            'date_start',
            'date_end',
        )
        read_only_fields = (
            'id',
            'user',
            'course',
            'created_at',
            'update_at',
        )


class SchoolPaymentSerializer(serializers.ModelSerializer):
    user = UserSerializer()

    class Meta:
        model = SchoolPayment
        fields = BASE_PAYMENT_FIELDS + (
            'weekdays',
            'date_start',
            'date_end',
        )
        read_only_fields = (
            'id',
            'user',
            'course',
            'created_at',
            'update_at',
        )


class GiftCertificatePaymentSerializer(serializers.ModelSerializer):
    user = UserSerializer()

    class Meta:
        model = GiftCertificatePayment
        fields = BASE_PAYMENT_FIELDS + (
            'gift_certificate',
        )
        read_only_fields = (
            'id',
            'user',
            'course',
            'created_at',
            'update_at',
        )


class UserBonusCreateSerializer(serializers.ModelSerializer):
    class Meta:
        model = UserBonus
        fields = (
            'user', 'amount', 'payment', 'referral', 'created_at', 'is_service', 'action_name',
        )
        read_only_fields = (
            'id',
            'created_at',
        )

    def to_representation(self, instance):
        return UserBonusSerializer(instance, context=self.context).to_representation(instance)


class UserBonusSerializer(serializers.ModelSerializer):
    user = UserSerializer()
    payment = serializers.SerializerMethodField()
    referral = serializers.SerializerMethodField()

    class Meta:
        model = UserBonus
        fields = (
            'user', 'amount', 'payment', 'referral', 'created_at', 'is_service', 'action_name',
        )
        read_only_fields = (
            'id',
            'user',
            'created_at',
        )

    def get_payment(self, instance):
        try:
            p = instance.payment
        except Exception:
            return None
        if not p:
            return None
        data = {
            'id': p.id,
            'created_at': p.created_at,
            'amount': p.amount,
            'data': p.data,
            'status': p.status,
        }
        if isinstance(instance.payment, CoursePayment):
            data['course'] = {
                'id': p.course.id,
                'title': p.course.title,
            }
        return data

    def get_referral(self, instance):
        try:
            r = instance.referral
        except Exception:
            return None
        if not r:
            return None
        return {
            'id': r.id,
            'referral': UserSerializer(instance=r.referral).data,
        }