fields.py

from datetime import datetime

import pytz
from django.conf import settings
from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from rest_framework.fields import empty
from rest_framework.utils import html

from src.accounts.enums import (
    UserDateFormat,
)
from src.accounts.models import Account
from src.processes.models.templates.template import Template
from src.generics.messages import (
    MSG_GE_0002,
    MSG_GE_0007,
    MSG_GE_0020,
)


class AccountQstMixin:

    def _get_account(self) -> Account:
        account = self.context.get('account')
        if account is None:
            request = self.context.get('request')
            if request:
                account = request.user.account
        if not account:
            raise Exception(
                'Account not provided for AccountQstMixin',
            )
        return account


class TemplateQstMixin:

    def _get_template(self) -> Template:
        template = self.context.get('template')
        if not template:
            raise Exception(
                'Template not provided for TemplateQstMixin',
            )
        return template


class AccountPrimaryKeyRelatedField(
    AccountQstMixin,
    serializers.PrimaryKeyRelatedField,
):

    def get_queryset(self):
        queryset = super().get_queryset()
        account = self._get_account()
        if queryset is None:
            raise Exception(MSG_GE_0002)
        return queryset.filter(account=account)

    def to_internal_value(self, data):
        # When create_or_update_related passes already-validated data
        # (e.g. from a parent serializer's validated_data), the value
        # may already be a model instance rather than a raw PK.
        # In that case, verify it belongs to the correct account and
        # return it directly, avoiding a redundant DB lookup.
        queryset = self.get_queryset()
        if queryset is not None and isinstance(data, queryset.model):
            if not queryset.filter(pk=data.pk).exists():
                self.fail('does_not_exist', pk_value=data.pk)
            return data
        return super().to_internal_value(data)


class RelatedApiNameField(
    AccountQstMixin,
    TemplateQstMixin,
    serializers.SlugRelatedField,
):

    def __init__(self, **kwargs):
        super().__init__(slug_field='api_name', **kwargs)

    def get_queryset(self):
        queryset = super().get_queryset()
        account = self._get_account()
        template = self._get_template()
        if queryset is None:
            raise Exception(MSG_GE_0002)
        return queryset.filter(account=account, template=template)

    def to_internal_value(self, data):

        """Convert api_name -> to object before saving """

        return super().to_internal_value(data)


class AnyField(serializers.Field):

    def to_internal_value(self, data):
        return data

    def to_representation(self, value):
        return value


class RelatedListField(serializers.ListField):

    def to_representation(self, objects):

        """ List of objects -> List of objects ids """

        return [
            self.child.to_representation(item.id)
            for item in objects.all()
        ]


class RelatedApiNameListField(serializers.ListField):

    child = serializers.CharField()

    def to_representation(self, data):

        """ List of objects -> List of objects api_name's """

        if hasattr(data, 'all'):
            return [field.api_name for field in data.all()]
        return [field.api_name for field in data if hasattr(field, 'api_name')]


class CommaSeparatedListField(serializers.ListField):

    def get_value(self, dictionary):
        if (
            self.field_name not in dictionary
            and getattr(self.root, 'partial', False)
        ):
            return empty
        if html.is_html_input(dictionary):
            val = dictionary.get(self.field_name, '')
            # Split result by comma
            val = val.split(',') if val else []
            if len(val) > 0:
                return val
            return html.parse_html_list(
                dictionary,
                prefix=self.field_name,
                default=empty,
            )
        return dictionary.get(self.field_name, empty)


class TimeStampField(serializers.DateTimeField):

    def to_representation(self, value):
        if not value:
            return None
        return value.timestamp()

    def to_internal_value(self, value: float):
        if isinstance(value, str):
            try:
                value = float(value)
            except ValueError as ex:
                raise ValidationError(detail=MSG_GE_0007) from ex
        elif not isinstance(value, int) and not isinstance(value, float):
            raise ValidationError(detail=MSG_GE_0007)
        tz = pytz.timezone(settings.TIME_ZONE)
        try:
            return datetime.fromtimestamp(value, tz=tz)
        except (OverflowError, OSError, ValueError) as ex:
            raise ValidationError(detail=MSG_GE_0020) from ex


class DateFormatField(serializers.ChoiceField):

    def __init__(self, **kwargs):
        super().__init__(
            choices=UserDateFormat.API_CHOICES,
            **kwargs,
        )

    def to_internal_value(self, data):
        value = super().to_internal_value(data)
        return UserDateFormat.MAP_TO_PYTHON[value]

    def to_representation(self, value):
        value = str(value)
        return UserDateFormat.MAP_TO_API[value]