294 lines
11 KiB
Python
Executable file
294 lines
11 KiB
Python
Executable file
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, NotAcceptable
|
|
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 utils.models import BaseModel
|
|
from .constans import StateChoices, TypeChoices
|
|
from apps.users.models import User
|
|
from ..gooyal_oauth2.models import Application
|
|
|
|
|
|
class WalletQuerySet(models.QuerySet):
|
|
pass
|
|
|
|
class Wallet(BaseModel):
|
|
owner_uuid = models.UUIDField(db_index=True, null=False)
|
|
category = models.ForeignKey('Category', on_delete=models.PROTECT, null=True)
|
|
owner_type = models.IntegerField(choices=TypeChoices.choices, db_index=True)
|
|
balance = models.BigIntegerField(_('balance'), default=0)
|
|
|
|
objects = WalletQuerySet.as_manager()
|
|
|
|
def get_owner(self):
|
|
if self.owner_type == TypeChoices.APPLICATION:
|
|
owner: Application = Application.objects.get(pk=self.owner_uuid)
|
|
else:
|
|
owner: User = User.objects.get(pk=self.owner_uuid)
|
|
|
|
return owner
|
|
|
|
|
|
class CategoryQuerySet(models.QuerySet):
|
|
pass
|
|
|
|
class Category(BaseModel):
|
|
application = models.ForeignKey(oauth2_settings.APPLICATION_MODEL, on_delete=models.PROTECT, null=True)
|
|
|
|
label = models.CharField(_('label'), max_length=255)
|
|
|
|
objects = CategoryQuerySet.as_manager()
|
|
|
|
|
|
# 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 TransactionQuerySet(models.QuerySet):
|
|
pass
|
|
|
|
|
|
class Transaction(BaseModel):
|
|
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(null=True)
|
|
payee_type = models.IntegerField(choices=TypeChoices.choices, blank=True, null=True)
|
|
state = models.IntegerField(choices=StateChoices.choices, default=StateChoices.CREATED)
|
|
application = models.ForeignKey(oauth2_settings.APPLICATION_MODEL, on_delete=models.PROTECT,
|
|
related_name='transactions', null=True)
|
|
payer_wallet = models.ForeignKey(Wallet, on_delete=models.PROTECT, null=True,
|
|
related_name='payer_wallet_transactions',
|
|
db_index=True)
|
|
payee_wallet = models.ForeignKey(Wallet, on_delete=models.PROTECT, null=True,
|
|
related_name='payee_wallet_transactions',
|
|
db_index=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 = TransactionQuerySet.as_manager()
|
|
|
|
class Meta:
|
|
ordering = ['-created_at']
|
|
|
|
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)
|
|
|
|
# unique_together = ('application', 'detail_id',)
|
|
|
|
def get_payer(self):
|
|
return self.payer_wallet.get_owner()
|
|
|
|
def get_payee(self):
|
|
return self.payee_wallet.get_owner()
|
|
|
|
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)
|
|
|
|
######################## category
|
|
def category_withdraw_from_payer_balance(self):
|
|
payer_is_allowed_negative_balance = self.payer_wallet.owner_type == TypeChoices.APPLICATION.value and str(
|
|
self.payer_wallet.owner_uuid) in settings.ALLOWED_NEGATIVE_BALANCE_APPLICATIONS
|
|
if self.amount > self.payer_wallet.balance and not payer_is_allowed_negative_balance:
|
|
raise APIException('not enough balance')
|
|
self.payer_wallet.balance = F('balance') - self.amount
|
|
self.payer_wallet.save(update_fields=['balance'])
|
|
|
|
def category_deposit_to_payee_balance(self):
|
|
self.payee_wallet.balance = F('balance') + self.amount
|
|
self.payee_wallet.save(update_fields=['balance'])
|
|
|
|
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.category_deposit_to_payee_balance()
|
|
|
|
self.category_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.category_deposit_to_payee_balance()
|
|
return self
|
|
|
|
def category_submit(self):
|
|
if not self.payer_wallet:
|
|
raise APIException('payer identification error')
|
|
|
|
if not self.payee_wallet:
|
|
raise APIException('payee identification error')
|
|
|
|
if not self.state == StateChoices.CREATED:
|
|
raise APIException('this transaction is not ready to pay')
|
|
|
|
with transaction.atomic():
|
|
self.category_withdraw_from_payer_balance()
|
|
self.change_state(
|
|
StateChoices.CREATED,
|
|
StateChoices.PENDING,
|
|
error_message=_('this transaction is not ready to pay')
|
|
)
|
|
return self
|
|
|
|
def category_verify(self):
|
|
if not self.state == StateChoices.PENDING:
|
|
raise APIException('this transaction is not pending')
|
|
|
|
with transaction.atomic():
|
|
self.category_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_wallet.owner_uuid == entity.uuid:
|
|
return 1
|
|
elif self.payee_wallet.owner_uuid == 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'):
|
|
print('update payer')
|
|
if self.payer_wallet.owner_type == TypeChoices.USER:
|
|
payer_details: PublicUser = get_user_details(self.payer_wallet.owner_uuid)
|
|
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
|
|
print("payer_details:", payer_details)
|
|
print("is_updated:", is_updated)
|
|
|
|
if not self.details.get('payee_name'):
|
|
print('update payee')
|
|
if self.payee_wallet.owner_type == TypeChoices.USER:
|
|
payee_details: PublicUser = get_user_details(self.payee_wallet.owner_uuid)
|
|
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
|
|
print("payee_details:", payee_details)
|
|
print("is_updated:", is_updated)
|
|
|
|
if not self.details.get('application_name'):
|
|
print('update application')
|
|
application_details = get_application_details(self.application_id)
|
|
print('application_details:', application_details)
|
|
try:
|
|
self.details['application_name'] = application_details.name
|
|
# TODO: get avatar from details
|
|
|
|
is_updated = True
|
|
except Exception as e:
|
|
print("something went wrong")
|
|
print(e)
|
|
|
|
if is_updated:
|
|
print('update details')
|
|
self.save()
|