wallet/apps/wallet/models.py

import datetime
import uuid

from django.core.validators import MinValueValidator
from django.db import models
from django.db import transaction
from django.db.models import F
from django.utils.translation import gettext_lazy as _
from rest_framework.exceptions import APIException, ValidationError
from django.conf import settings
from oauth2_provider import settings as oauth2_settings

from gooyal_accounts_client.models import PublicUser
from utils.accounts_client import get_user_details, get_application_details
from .constans import StateChoices, TypeChoices
from apps.users.models import User
from ..gooyal_oauth2.models import Application


# TODO: move DRF functionalities to view or serializers
# class TransactionManager(models.Manager):
#     def create_transaction(
#             self,
#             amount,
#             payee_id,
#             payee_type,
#             payer_id=None,
#             payer_type=None,
#             delay=0,
#             detail=None,
#             application=None,
#             uuid=None
#     ):
#         tr = self.model(
#             uuid=uuid,
#             payer_id=payer_id,
#             payer_type=payer_type,
#             payee_id=payee_id,
#             payee_type=payee_type,
#             amount=amount,
#             delay=delay,
#             application=application,
#             detail=detail
#         )
#
#         tr.save()
#         return tr


class Transaction(models.Model):
    uuid = models.UUIDField(primary_key=True, editable=True, default=uuid.uuid4, unique=True,
                            db_index=True)  # reserve_code
    amount = models.PositiveBigIntegerField(_('amount'), blank=False, validators=[MinValueValidator(1)])
    delay = models.PositiveIntegerField(default=0, blank=True)  # number of days for delayed payments
    payer_id = models.UUIDField(blank=True, null=True)
    payer_type = models.IntegerField(choices=TypeChoices.choices, blank=True, null=True)
    payee_id = models.UUIDField()
    payee_type = models.IntegerField(choices=TypeChoices.choices, blank=True, null=True)
    state = models.IntegerField(choices=StateChoices.choices, default=StateChoices.CREATED)
    created_at = models.DateTimeField(auto_now_add=True, null=True, db_index=True)
    updated_at = models.DateTimeField(auto_now=True, null=True, db_index=True)
    application = models.ForeignKey(oauth2_settings.APPLICATION_MODEL, on_delete=models.PROTECT,
                                    related_name='transactions', null=True)
    details = models.JSONField(null=True, blank=True, default=dict)


    # detail = {'payer_name', 'payee_name', 'description', 'application_name', 'payer_avatar_url', 'payee_avatar_url',
    #           'reference_id', 'application_details_url'}

    # objects = TransactionManager()

    class Meta:
        ordering = ['-created_at']
    #     unique_together = ('application', 'detail_id',)

    def withdraw_from_payer_balance(self):
        payer = self.get_payer()
        payer_is_allowed_negative_balance = self.payer_type==TypeChoices.APPLICATION.value and str(self.payer_id) in settings.ALLOWED_NEGATIVE_BALANCE_APPLICATIONS
        if self.amount > payer.balance and not payer_is_allowed_negative_balance :
            raise APIException('not enough balance')
        payer.balance = F('balance') - self.amount
        payer.save(update_fields=['balance'])

    def deposit_to_payee_balance(self):
        payee = self.get_payee()
        payee.balance = F('balance') + self.amount
        payee.save(update_fields=['balance'])

    def get_pay_entity(self, entity_id, entity_type):
        if entity_type == TypeChoices.APPLICATION:
            entity: Application = Application.objects.get(pk=entity_id)
        else:
            entity: User = User.objects.get(pk=entity_id)

        return entity

    def get_payer(self):
        return self.get_pay_entity(self.payer_id, self.payer_type)

    def get_payee(self):
        return self.get_pay_entity(self.payee_id, self.payee_type)

    def change_state(self, from_state, to_state, error_message=None, **data):
        if self.state == from_state:
            updated = Transaction.objects.filter(pk=self.pk, state=from_state).update(
                state=to_state,
                **data
            )
            if updated:  # double check in db level
                self.state = to_state
            else:
                raise APIException(error_message)
        else:
            raise APIException(error_message)

    def pay(self, payer_id=None, payer_type=None):
        if not self.payer_id and not (payer_id and payer_type):
            raise APIException('payer identification error')

        if self.payer_id and payer_id and not (self.payer_id == payer_id and self.payer_type == payer_type):
            raise APIException('payer identification error')

        if not self.state == StateChoices.CREATED:
            raise APIException('this transaction is not ready to pay')

        if not self.payer_id:
            self.payer_id = payer_id
            self.payer_type = payer_type

        payer = self.get_payer()

        if payer.balance < self.amount:
            raise APIException('not enough balance')

        with transaction.atomic():
            if self.delay:
                self.change_state(
                    StateChoices.CREATED,
                    StateChoices.DELAYED,
                    error_message='this transaction is not ready to pay',
                    payer_id=payer_id,
                    payer_type=payer_type
                )

            else:
                self.change_state(
                    StateChoices.CREATED,
                    StateChoices.SUCCESS,
                    error_message='this transaction is not ready to pay',
                    payer_id=payer_id,
                    payer_type=payer_type
                )
                self.deposit_to_payee_balance()

            self.withdraw_from_payer_balance()
        return self

    def receipt(self):
        if not self.state == StateChoices.DELAYED:
            raise APIException('this transaction is not delayed')

        with transaction.atomic():
            self.change_state(
                StateChoices.DELAYED,
                StateChoices.SUCCESS,
                error_message='this transaction is not delayed'
            )
            self.deposit_to_payee_balance()
        return self

    def submit(self):
        payer = self.get_payer()
        payee = self.get_payee()

        if not payer:
            raise APIException('payer identification error')

        if not payee:
            raise APIException('payee identification error')

        if not self.state == StateChoices.CREATED:
            raise APIException('this transaction is not ready to pay')

        with transaction.atomic():
            self.withdraw_from_payer_balance()
            self.change_state(
                StateChoices.CREATED,
                StateChoices.PENDING,
                error_message='this transaction is not ready to pay'
            )
        return self

    def verify(self):
        if not self.state == StateChoices.PENDING:
            raise APIException('this transaction is not pending')

        with transaction.atomic():
            self.deposit_to_payee_balance()
            self.change_state(
                StateChoices.PENDING,
                StateChoices.SUCCESS,
                error_message='this transaction is not pending'
            )
        return self

    def get_role(self, entity):

        if self.payer_id == entity.uuid:
            return 1
        elif self.payee_id == entity.uuid:
            return 2
        else:
            return 0

    def update_details(self, force_update=False):
        if not isinstance(self.details, dict):
            self.details = {}
        self.save()
        # detail = {'payer_name', 'payee_name', 'application_name', 'payer_avatar_url', 'payee_avatar_url', 'application_avatar_url'}
        is_updated = False
        if not self.details.get('payer_name'):
            if self.payer_type == TypeChoices.USER.value:
                payer_details: PublicUser = get_user_details(self.payer_id)
                self.details['payer_name'] = payer_details.first_name + payer_details.last_name
                self.details['payer_avatar_url'] = payer_details.avatar
            else:
                payer_details = get_application_details(self.payer_id)
                self.details['payer_name'] = payer_details.name
                #TODO: get avatar from details

            is_updated = True

        if not self.details.get('payee_name'):
            if self.payee_type == TypeChoices.USER.value:
                payee_details: PublicUser = get_user_details(self.payee_id)
                self.details['payee_name'] = payee_details.first_name + payee_details.last_name
                self.details['payee_avatar_url'] = payee_details.avatar
            else:
                payee_details = get_application_details(self.payee_id)
                self.details['payee_name'] = payee_details.name
                #TODO: get avatar from details

            is_updated = True

        if not self.details.get('application_name'):
            application_details = get_application_details(self.application_id)
            try:
                self.details['application_name'] = application_details.name
            # TODO: get avatar from details

                is_updated = True
            except Exception as e:
                pass

        if is_updated:
            self.save()


    def __str__(self):
        try:
            return f"{self.get_payer()} -> {self.get_payee()} ({self.uuid}): {self.amount} - {self.get_state_display()}"
        except:
            return str(self.uuid)