addwin/wallet
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(wallet): adapt submit and verify process to new wallet, account concept

Browse source 
adapt submit and verify process to new wallet, account concept
notice: add WALLET_RIAL_CATEGORY to .env
This commit is contained in:
Haydar Ghasemi 2025-10-26 17:44:59 +03:30
parent a84d93a25c
commit db798dd348
7 changed files with 203 additions and 217 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
apps/wallet/models.py
View file

@ -237,7 +237,7 @@ class Transaction(BaseModel):
if not self.payee_account:
raise APIException('payee identification error')
if not self.payer_wallet == self.payee_wallet:
if not self.payer_account.wallet.currency == self.payee_account.wallet.currency:
self.change_state(from_state=self.state, to_state=StateChoices.FAILED)
raise APIException('payer and payee account currency not equal')

10
apps/wallet/serializers.py
View file

@ -13,8 +13,8 @@ from ..users.models import User
class TransactionSerializer(serializers.ModelSerializer):
payee = serializers.UUIDField(read_only=True)
payee_type = serializers.IntegerField(read_only=True)
# payee_wallet = serializers.UUIDField(source='payee_wallet_category', read_only=True)
# payer_wallet = serializers.UUIDField(source='payer_wallet_category', read_only=True)
# payee_wallet = serializers.UUIDField(source='payee_wallet', read_only=True)
# payer_wallet = serializers.UUIDField(source='payer_wallet', read_only=True)
role = serializers.SerializerMethodField()
class Meta:
@ -170,8 +170,8 @@ class ApplicationDepositSerializer(serializers.ModelSerializer):
uuid = serializers.UUIDField(required=False, validators=[])
payee = serializers.UUIDField(required=True)
payee_type = serializers.IntegerField(required=True)
# payee_wallet = serializers.UUIDField(source='payee_wallet', required=False) # TODO: required True
# payer_wallet = serializers.UUIDField(source='payer_wallet', read_only=True)
payee_wallet = serializers.UUIDField(required=True)
payer_wallet = serializers.UUIDField(read_only=True)
amount = serializers.IntegerField(required=True, validators=[MinValueValidator(1)])
# TODO: details as fields
@ -193,7 +193,7 @@ class ApplicationDepositSerializer(serializers.ModelSerializer):
'details',
)
read_only_fields = ['updated_at', 'state', 'created_at', 'payer_id', 'payer_type', 'payer_wallet']
read_only_fields = ['updated_at', 'state', 'created_at', 'payer', 'payer_type', 'payer_wallet']
class ApplicationWithdrawSerializer(serializers.ModelSerializer):

234
apps/wallet/tests/application.py
View file

@ -9,7 +9,7 @@ from rest_framework.test import APITestCase, override_settings
from apps.users.models import User
from apps.wallet.constans import TypeChoices
from apps.wallet.models import Account
from apps.wallet.models import Category
from apps.wallet.models import Wallet
AccessToken = get_access_token_model()
Application = get_application_model()
@ -22,8 +22,9 @@ class ApplicationApiFlowsTests(APITestCase):
payer_access_token = '24naVsdKCbKNOhnElPyXcrwSnqqFbm'
payer_uuid = uuid.UUID('b14e8b86-8f4a-44d9-b29d-badceb470051')
payee_uuid = uuid.UUID('b14e8b86-8f4a-44d9-b29d-badceb470052')
wallet_category1_uuid = uuid.UUID('114e8b86-8f4a-44d9-b29d-badceb470051')
wallet_category2_uuid = uuid.UUID('214e8b86-8f4a-44d9-b29d-badceb470051')
# wallet_rial_uuid = uuid.UUID('114e8b86-8f4a-44d9-b29d-badceb470051')
wallet_rial_uuid = uuid.UUID('114e8b86-8f4a-44d9-b29d-badceb470051')
wallet_reward_uuid = uuid.UUID('214e8b86-8f4a-44d9-b29d-badceb470051')
# application, _ = Application.objects.get_or_create(client_id=client_id, uuid=application_uuid)
scopes = [
@ -41,9 +42,9 @@ class ApplicationApiFlowsTests(APITestCase):
def setUp(self):
self.application_user, _ = User.objects.get_or_create(pk=self.application_uuid)
self.payer_user, _ = User.objects.get_or_create(pk=self.payer_uuid)
self.application_wallet, _ = Account.objects.get_or_create(owner_uuid=self.application_uuid, owner_type=TypeChoices.APPLICATION, balance=300)
self.payee_wallet, _ = Account.objects.get_or_create(owner_uuid=self.payee_uuid, owner_type=TypeChoices.USER)
self.payer_wallet, _ = Account.objects.get_or_create(owner_uuid=self.payer_uuid, owner_type=TypeChoices.USER, balance=300)
self.application_account, _ = Account.objects.get_or_create(owner_uuid=self.application_uuid, owner_type=TypeChoices.APPLICATION, balance=300)
self.payee_account, _ = Account.objects.get_or_create(owner_uuid=self.payee_uuid, owner_type=TypeChoices.USER)
self.payer_account, _ = Account.objects.get_or_create(owner_uuid=self.payer_uuid, owner_type=TypeChoices.USER, balance=300)
expire_datetime = timezone.now() + timedelta(seconds=3600)
expire_datetime.isoformat()
@ -75,14 +76,14 @@ class ApplicationApiFlowsTests(APITestCase):
client_id=self.client_id,
uuid=self.application_uuid,
)
self.wallet_category1, _ = Category.objects.get_or_create(application=self.application, uuid=self.wallet_category1_uuid)
self.wallet_category2, _ = Category.objects.get_or_create(application=self.application, uuid=self.wallet_category2_uuid)
self.application_wallet1, _ = Account.objects.get_or_create(owner_uuid=self.application_uuid, owner_type=TypeChoices.APPLICATION, balance=300, category=self.wallet_category1)
self.application_wallet2, _ = Account.objects.get_or_create(owner_uuid=self.application_uuid, owner_type=TypeChoices.APPLICATION, balance=300, category=self.wallet_category2)
self.payee_wallet1, _ = Account.objects.get_or_create(owner_uuid=self.payee_uuid, owner_type=TypeChoices.USER, category=self.wallet_category1)
self.payee_wallet2, _ = Account.objects.get_or_create(owner_uuid=self.payee_uuid, owner_type=TypeChoices.USER, category=self.wallet_category2)
self.payer_wallet1, _ = Account.objects.get_or_create(owner_uuid=self.payer_uuid, owner_type=TypeChoices.USER, balance=300, category=self.wallet_category1)
self.payer_wallet2, _ = Account.objects.get_or_create(owner_uuid=self.payer_uuid, owner_type=TypeChoices.USER, balance=300, category=self.wallet_category2)
self.wallet_rial, _ = Wallet.objects.get_or_create(application=self.application, uuid=self.wallet_rial_uuid)
self.wallet_reward, _ = Wallet.objects.get_or_create(application=self.application, uuid=self.wallet_reward_uuid)
self.application_account1, _ = Account.objects.get_or_create(owner_uuid=self.application_uuid, owner_type=TypeChoices.APPLICATION, balance=300, wallet=self.wallet_rial)
self.application_account2, _ = Account.objects.get_or_create(owner_uuid=self.application_uuid, owner_type=TypeChoices.APPLICATION, balance=300, wallet=self.wallet_reward)
self.payee_account1, _ = Account.objects.get_or_create(owner_uuid=self.payee_uuid, owner_type=TypeChoices.USER, wallet=self.wallet_rial)
self.payee_account2, _ = Account.objects.get_or_create(owner_uuid=self.payee_uuid, owner_type=TypeChoices.USER, wallet=self.wallet_reward)
self.payer_account1, _ = Account.objects.get_or_create(owner_uuid=self.payer_uuid, owner_type=TypeChoices.USER, balance=300, wallet=self.wallet_rial)
self.payer_account2, _ = Account.objects.get_or_create(owner_uuid=self.payer_uuid, owner_type=TypeChoices.USER, balance=300, wallet=self.wallet_reward)
def tearDown(self):
super().tearDown()
@ -122,67 +123,70 @@ class ApplicationApiFlowsTests(APITestCase):
auth = self._create_authorization_header(self.application_access_token.token)
# Checking wallets initials values(application balance = 300 and payee balance = zero)
response = self.client.get(reverse('wallet:application_wallet_balance_api'), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 300)
wallets = [self.wallet_rial_uuid.hex, self.wallet_reward_uuid.hex]
response = self.client.get(reverse('wallet:application_account_balance_api'), query_params={'wallet': ','.join(wallets)}, HTTP_AUTHORIZATION=auth)
self.assertGreater(response.json()['count'], 1)
from_wallet = response.json()['results'][0]
self.assertEqual(from_wallet['balance'], 300)
params = {
'uuid': self.payee_uuid,
'category_uuid': self.wallet_category1_uuid,
'user': self.payee_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=params), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 0)
response = self.client.get(reverse('wallet:application_user_account_api', kwargs=params), query_params={'wallet': ','.join(wallets)}, HTTP_AUTHORIZATION=auth)
self.assertGreater(response.json()['count'], 1)
to_wallet = response.json()['results'][0]
self.assertEqual(to_wallet['balance'], 0)
# Deposit process
data = {
'amount': 100,
'payee': self.payee_uuid,
'payee_type': TypeChoices.USER,
'payee_wallet': self.wallet_category1_uuid,
'payee_wallet': self.wallet_rial_uuid,
}
kwargs_category_uuid_payee_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_payer_wallet = {
'payer_wallet': self.wallet_rial_uuid,
}
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_category_uuid_payee_uuid), data=data, HTTP_AUTHORIZATION=auth)
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_payer_wallet), data=data, HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 201)
json_response = response.json()
params = {
kwargs_verify = {
'uuid': json_response['uuid'],
'category_uuid': self.wallet_category1_uuid,
'payer_wallet': self.wallet_rial_uuid,
}
response = self.client.get(reverse('wallet:application_deposit_verify_api', kwargs=params), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_deposit_verify_api', kwargs=kwargs_verify), HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['state'], 5)
# Desired results
response = self.client.get(reverse('wallet:application_wallet_balance_api', kwargs=kwargs_category_uuid_payee_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 200)
response = self.client.get(reverse('wallet:application_account_balance_api'), query_params={'wallet': ','.join(wallets)}, HTTP_AUTHORIZATION=auth)
self.assertGreater(response.json()['count'], 1)
from_wallet = response.json()['results'][0]
self.assertEqual(from_wallet['balance'], 200)
params = {
'uuid': self.payee_uuid,
'category_uuid': self.wallet_category1_uuid,
'user': self.payee_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=params), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 100)
response = self.client.get(reverse('wallet:application_user_account_api', kwargs=params), query_params={'wallet': ','.join(wallets)}, HTTP_AUTHORIZATION=auth)
self.assertGreater(response.json()['count'], 1)
to_wallet = response.json()['results'][0]
self.assertEqual(to_wallet['balance'], 100)
def test_deposit_flow_category_success(self):
def test_deposit_flow_wallet_success(self):
auth = self._create_authorization_header(self.application_access_token.token)
# Checking wallets initials values(application balance = 300 and payee balance = zero)
kwargs_category_uuid = {
'category_uuid': self.wallet_category1_uuid
kwargs_wallet_uuid = {
'wallet_uuid': self.wallet_rial_uuid
}
response = self.client.get(reverse('wallet:application_wallet_balance_api', kwargs=kwargs_category_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_account_balance_api', kwargs=kwargs_wallet_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 300)
kwargs_category_uuid_payee_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid_payee_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
'uuid': self.payee_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=kwargs_category_uuid_payee_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=kwargs_wallet_uuid_payee_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 0)
@ -191,47 +195,49 @@ class ApplicationApiFlowsTests(APITestCase):
'amount': 100,
'payee': self.payee_uuid,
'payee_type': TypeChoices.USER,
'payee_wallet': self.wallet_category1_uuid
'payee_account': self.wallet_rial_uuid
}
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_category_uuid), data=data, HTTP_AUTHORIZATION=auth)
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_wallet_uuid), data=data, HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 201)
json_response = response.json()
kwargs_category_uuid_transaction_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid_transaction_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
'uuid': json_response['uuid'],
}
response = self.client.get(reverse('wallet:application_deposit_verify_api', kwargs=kwargs_category_uuid_transaction_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_deposit_verify_api', kwargs=kwargs_wallet_uuid_transaction_uuid), HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['state'], 5)
# Desired results
response = self.client.get(reverse('wallet:application_wallet_balance_api', kwargs=kwargs_category_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_account_balance_api', kwargs=kwargs_wallet_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 200)
kwargs_category_uuid_payee_uuid = {
'category_uuid': self.wallet_category2_uuid,
kwargs_wallet_uuid_payee_uuid = {
'wallet_uuid': self.wallet_reward_uuid,
'uuid': self.payee_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=kwargs_category_uuid_payee_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 0)
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=kwargs_wallet_uuid_payee_uuid), HTTP_AUTHORIZATION=auth)
self.assertGreater(response.json()['count'], 1)
to_wallet = response.json()['results'][0]
self.assertEqual(to_wallet['balance'], 100)
def test_deposit_flow_insufficient_balance(self):
auth = self._create_authorization_header(self.application_access_token.token)
# Checking wallets initials values(application balance = 300 and payee balance = zero)
response = self.client.get(reverse('wallet:application_wallet_balance_api'), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_account_balance_api'), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 300)
params = {
'uuid': self.payee_uuid,
}
kwargs_category_uuid_payee_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid_payee_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=params), HTTP_AUTHORIZATION=auth)
@ -243,9 +249,9 @@ class ApplicationApiFlowsTests(APITestCase):
'amount': 500,
'payee': self.payee_uuid,
'payee_type': TypeChoices.USER,
'payee_wallet': self.wallet_category1_uuid
'payee_account': self.wallet_rial_uuid
}
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_category_uuid_payee_uuid), data=data, HTTP_AUTHORIZATION=auth)
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_wallet_uuid_payee_uuid), data=data, HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 422)
@override_settings(ALLOWED_NEGATIVE_BALANCE_APPLICATIONS=['b14e8b86-8f4a-44d9-b29d-badceb470053'])
@ -253,12 +259,12 @@ class ApplicationApiFlowsTests(APITestCase):
auth = self._create_authorization_header(self.application_access_token.token)
# Checking wallets initials values(application balance = 300 and payee balance = zero)
response = self.client.get(reverse('wallet:application_wallet_balance_api'), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_account_balance_api'), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 300)
params = {
'uuid': self.payee_uuid,
'category_uuid': self.wallet_category1_uuid,
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=params), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
@ -269,18 +275,18 @@ class ApplicationApiFlowsTests(APITestCase):
'amount': 500,
'payee': self.payee_uuid,
'payee_type': TypeChoices.USER,
'payee_wallet': self.wallet_category1_uuid,
'payee_account': self.wallet_rial_uuid,
}
kwargs_category_uuid_payee_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid_payee_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_category_uuid_payee_uuid), data=data, HTTP_AUTHORIZATION=auth)
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_wallet_uuid_payee_uuid), data=data, HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 201)
def test_deposit_flow_zero_amount(self):
# TODO: category
# TODO: wallet
auth = self._create_authorization_header(self.application_access_token.token)
# Deposit process
@ -293,7 +299,7 @@ class ApplicationApiFlowsTests(APITestCase):
self.assertEqual(response.status_code, 400)
def test_deposit_flow_negative_amount(self):
# TODO: category
# TODO: wallet
auth = self._create_authorization_header(self.application_access_token.token)
# Deposit process
@ -310,12 +316,12 @@ class ApplicationApiFlowsTests(APITestCase):
auth = self._create_authorization_header(self.application_access_token.token)
# Checking wallets initials values(application balance = 300 and payee balance = zero)
response = self.client.get(reverse('wallet:application_wallet_balance_api'), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_account_balance_api'), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 300)
params = {
'uuid': self.payee_uuid,
'category_uuid': self.wallet_category1_uuid,
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=params), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
@ -327,17 +333,17 @@ class ApplicationApiFlowsTests(APITestCase):
'amount': 200,
'payee': self.payee_uuid,
'payee_type': TypeChoices.USER,
'payee_wallet': self.wallet_category1_uuid,
'payee_account': self.wallet_rial_uuid,
}
kwargs_category_uuid_payee_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid_payee_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_category_uuid_payee_uuid), data=data, HTTP_AUTHORIZATION=auth)
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_wallet_uuid_payee_uuid), data=data, HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 201)
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_category_uuid_payee_uuid), data=data, HTTP_AUTHORIZATION=auth)
response = self.client.post(reverse('wallet:application_deposit_submit_api', kwargs=kwargs_wallet_uuid_payee_uuid), data=data, HTTP_AUTHORIZATION=auth)
# self.assertEqual(response.status_code, 422)
self.assertEqual(response.status_code, 201)
@ -345,12 +351,12 @@ class ApplicationApiFlowsTests(APITestCase):
auth = self._create_authorization_header(self.payer_access_token.token)
# Checking wallets initials values(application balance = 300 and payee balance = zero)
response = self.client.get(reverse('wallet:application_wallet_balance_api'), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_account_balance_api'), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 300)
params = {
'uuid': self.payer_uuid,
'category_uuid': self.wallet_category1_uuid,
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=params), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
@ -361,53 +367,53 @@ class ApplicationApiFlowsTests(APITestCase):
'amount': 100,
'payer': self.payer_uuid,
'payer_type': TypeChoices.USER,
'payer_wallet': self.wallet_category1_uuid,
'payer_account': self.wallet_rial_uuid,
}
kwargs_category_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.post(reverse('wallet:application_withdraw_submit_api', kwargs=kwargs_category_uuid), data=data, HTTP_AUTHORIZATION=auth)
response = self.client.post(reverse('wallet:application_withdraw_submit_api', kwargs=kwargs_wallet_uuid), data=data, HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 201)
json_response = response.json()
params = {
'uuid': json_response['uuid'],
'category_uuid': self.wallet_category1_uuid,
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.get(reverse('wallet:application_withdraw_verify_api', kwargs=params), HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['state'], 5)
# Desired results
response = self.client.get(reverse('wallet:application_wallet_balance_api', kwargs=kwargs_category_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_account_balance_api', kwargs=kwargs_wallet_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 400)
params = {
'uuid': self.payer_uuid,
'category_uuid': self.wallet_category1_uuid,
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=params), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 200)
def test_withdraw_flow_category_success(self):
def test_withdraw_flow_wallet_success(self):
auth = self._create_authorization_header(self.payer_access_token.token)
# Checking wallets initials values(application balance = 300 and payee balance = zero)
kwargs_category_uuid = {
'category_uuid': self.wallet_category1_uuid
kwargs_wallet_uuid = {
'wallet_uuid': self.wallet_rial_uuid
}
response = self.client.get(reverse('wallet:application_wallet_balance_api', kwargs=kwargs_category_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_account_balance_api', kwargs=kwargs_wallet_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 300)
kwargs_category_uuid_payer_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid_payer_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
'uuid': self.payer_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=kwargs_category_uuid_payer_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=kwargs_wallet_uuid_payer_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 300)
@ -416,35 +422,35 @@ class ApplicationApiFlowsTests(APITestCase):
'amount': 100,
'payer': self.payer_uuid,
'payer_type': TypeChoices.USER,
'payer_wallet': self.wallet_category1_uuid,
'payer_account': self.wallet_rial_uuid,
}
response = self.client.post(reverse('wallet:application_withdraw_submit_api', kwargs=kwargs_category_uuid), data=data, HTTP_AUTHORIZATION=auth)
response = self.client.post(reverse('wallet:application_withdraw_submit_api', kwargs=kwargs_wallet_uuid), data=data, HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 201)
json_response = response.json()
kwargs_category_uuid_transaction_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid_transaction_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
'uuid': json_response['uuid'],
}
response = self.client.get(reverse('wallet:application_withdraw_verify_api', kwargs=kwargs_category_uuid_transaction_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_withdraw_verify_api', kwargs=kwargs_wallet_uuid_transaction_uuid), HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['state'], 5)
# Desired results
response = self.client.get(reverse('wallet:application_wallet_balance_api', kwargs=kwargs_category_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_account_balance_api', kwargs=kwargs_wallet_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 400)
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=kwargs_category_uuid_payer_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=kwargs_wallet_uuid_payer_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 200)
kwargs_category_uuid_payer_uuid = {
'category_uuid': self.wallet_category2_uuid,
kwargs_wallet_uuid_payer_uuid = {
'wallet_uuid': self.wallet_reward_uuid,
'uuid': self.payer_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=kwargs_category_uuid_payer_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=kwargs_wallet_uuid_payer_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 300)
@ -456,12 +462,12 @@ class ApplicationApiFlowsTests(APITestCase):
'amount': 0,
'payer': self.payer_uuid,
'payer_type': TypeChoices.USER,
'payer_wallet': self.wallet_category1_uuid,
'payer_account': self.wallet_rial_uuid,
}
kwargs_category_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.post(reverse('wallet:application_withdraw_submit_api', kwargs=kwargs_category_uuid), data=data,
response = self.client.post(reverse('wallet:application_withdraw_submit_api', kwargs=kwargs_wallet_uuid), data=data,
HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 400)
@ -481,16 +487,16 @@ class ApplicationApiFlowsTests(APITestCase):
def test_withdraw_flow_prevent_double_spending(self):
auth = self._create_authorization_header(self.payer_access_token.token)
kwargs_category_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
}
# Checking wallets initials values(application balance = 300 and payee balance = zero)
response = self.client.get(reverse('wallet:application_wallet_balance_api', kwargs=kwargs_category_uuid), HTTP_AUTHORIZATION=auth)
response = self.client.get(reverse('wallet:application_account_balance_api', kwargs=kwargs_wallet_uuid), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
self.assertEqual(response.json()['balance'], 300)
params = {
'uuid': self.payer_uuid,
'category_uuid': self.wallet_category1_uuid,
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.get(reverse('wallet:application_user_wallet_balance_api', kwargs=params), HTTP_AUTHORIZATION=auth)
self.assertContains(response, 'balance')
@ -502,16 +508,16 @@ class ApplicationApiFlowsTests(APITestCase):
'amount': 200,
'payer': self.payer_uuid,
'payer_type': TypeChoices.USER,
'payer_wallet': self.wallet_category1_uuid,
'payer_account': self.wallet_rial_uuid,
}
kwargs_category_uuid = {
'category_uuid': self.wallet_category1_uuid,
kwargs_wallet_uuid = {
'wallet_uuid': self.wallet_rial_uuid,
}
response = self.client.post(reverse('wallet:application_withdraw_submit_api', kwargs=kwargs_category_uuid), data=data, HTTP_AUTHORIZATION=auth)
response = self.client.post(reverse('wallet:application_withdraw_submit_api', kwargs=kwargs_wallet_uuid), data=data, HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 201)
response = self.client.post(reverse('wallet:application_withdraw_submit_api', kwargs=kwargs_category_uuid), data=data, HTTP_AUTHORIZATION=auth)
response = self.client.post(reverse('wallet:application_withdraw_submit_api', kwargs=kwargs_wallet_uuid), data=data, HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 201)

24
apps/wallet/urls.py
View file

@ -11,29 +11,29 @@ user_urlpatterns = [
# path('api/wallet/balance', user_views.WalletMyAccountBalanceView.as_view(), name='user_wallet_balance_api'),
path('api/transactions/', user_views.TransactionListAPIView.as_view(), name='transaction_list_api'),
# path('api/user/<category_uuid>/balance', user_views.WalletMyAccountBalanceView.as_view(), name='user_wallet_balance_api'),
path('api/user/<category_uuid>/transactions/', user_views.CategoryTransactionListView.as_view(), name='transaction_list_api'),
# path('api/user/<wallet_uuid>/balance', user_views.WalletMyAccountBalanceView.as_view(), name='user_wallet_balance_api'),
path('api/user/<wallet_uuid>/transactions/', user_views.WalletTransactionListView.as_view(), name='transaction_list_api'),
]
application_urlpatterns = [
path('api/application/accounts/', application_views.AccountListAPIView.as_view(), name='application_accounts_balance_api'),
path('api/application/user/<user_uuid>/accounts/', application_views.UserAccountListAPIView.as_view(), name='application_user_account_api'),
path('api/application/accounts/', application_views.AccountListAPIView.as_view(), name='application_account_balance_api'),
path('api/application/user/<user>/accounts/', application_views.UserAccountListAPIView.as_view(), name='application_user_account_api'),
# path('api/application/', application_views.TransactionListAPIView.as_view(), name='application_transaction_list_api'),
# path('api/application/<uuid>/', application_views.TransactionDetailAPIView.as_view(), name='application_transaction_detail'),
# path('api/application/<category_uuid>/wallet', application_views.BalanceAPIView.as_view(), name='application_wallet_balance_api'),
# path('api/application/<category_uuid>/user/<user_uuid>/wallet', application_views.UserBalanceAPIView.as_view(), name='application_user_wallet_balance_api'),
# path('api/application/<wallet_uuid>/wallet', application_views.BalanceAPIView.as_view(), name='application_wallet_balance_api'),
# path('api/application/<wallet_uuid>/user/<user_uuid>/wallet', application_views.UserBalanceAPIView.as_view(), name='application_user_wallet_balance_api'),
path('api/application/<category_uuid>/deposit/', application_views.DepositSubmitAPIView.as_view(), name='application_deposit_submit_api'),
path('api/application/<category_uuid>/deposit/<uuid>/verify', application_views.DepositVerifyAPIView.as_view(), name='application_deposit_verify_api'),
path('api/application/<payer_wallet>/deposit/', application_views.DepositSubmitAPIView.as_view(), name='application_deposit_submit_api'),
path('api/application/<payer_wallet>/deposit/<uuid>/verify', application_views.DepositVerifyAPIView.as_view(), name='application_deposit_verify_api'),
path('api/application/<category_uuid>/withdraw/', application_views.WithdrawSubmitAPIView.as_view(), name='application_withdraw_submit_api'),
path('api/application/<category_uuid>/withdraw/<uuid>/verify', application_views.WithdrawVerifyAPIView.as_view(), name='application_withdraw_verify_api'),
path('api/application/<wallet_uuid>/withdraw/', application_views.WithdrawSubmitAPIView.as_view(), name='application_withdraw_submit_api'),
path('api/application/<wallet_uuid>/withdraw/<uuid>/verify', application_views.WithdrawVerifyAPIView.as_view(), name='application_withdraw_verify_api'),
path('api/application/<category_uuid>/', application_views.CategoryTransactionListAPIView.as_view(), name='application_transaction_list_api'),
path('api/application/<category_uuid>/<uuid>/', application_views.CategoryTransactionDetailAPIView.as_view(), name='application_transaction_detail'),
path('api/application/<wallet_uuid>/', application_views.WalletTransactionListAPIView.as_view(), name='application_transaction_list_api'),
path('api/application/<wallet_uuid>/<uuid>/', application_views.WalletTransactionDetailAPIView.as_view(), name='application_transaction_detail'),
]

124
apps/wallet/views/application.py
View file

@ -40,26 +40,19 @@ class AccountListAPIView(generics.ListAPIView):
required_scopes = ['wallet.application:get_balance']
def get_object(self):
category_uuid = self.kwargs.get('category_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
wallet_uuid = self.kwargs.get('wallet')
if wallet_uuid:
wallet = get_object_or_404(Wallet.objects.all(), uuid=wallet_uuid)
else:
category = None
wallet = None
application = get_application(self.request)
account, created = Account.objects.get_or_create(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION,
category=category)
wallet=wallet)
return account
def get_queryset(self):
category_uuid = self.kwargs.get('category_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
else:
category = None
application = get_application(self.request)
wallet, created = Account.objects.get_or_create(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION,
category=category)
return Account.objects.filter(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION).all()
@ -77,15 +70,8 @@ class UserAccountListAPIView(generics.ListAPIView):
def get_queryset(self):
qs = super().get_queryset()
category_uuid = self.kwargs.get('category_uuid')
user_uuid = self.kwargs.get('user_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
else:
category = None
user_uuid = self.kwargs.get('user')
user, created = User.objects.get_or_create(uuid=self.kwargs.get('uuid'))
wallet, created = Account.objects.get_or_create(owner_uuid=user_uuid, owner_type=TypeChoices.USER,
category=category)
return qs.filter(owner_uuid=user_uuid, owner_type=TypeChoices.USER).all()
@ -133,7 +119,7 @@ class TransactionListAPIView(generics.ListAPIView):
)
).all()
class CategoryTransactionDetailAPIView(generics.RetrieveAPIView):
class WalletTransactionDetailAPIView(generics.RetrieveAPIView):
permission_classes = [TokenHasScope]
serializer_class = TransactionSerializer
lookup_field = 'uuid'
@ -143,24 +129,24 @@ class CategoryTransactionDetailAPIView(generics.RetrieveAPIView):
def get_queryset(self):
qs = super().get_queryset()
category_uuid = self.kwargs.get('category_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
wallet_uuid = self.kwargs.get('wallet_uuid')
if wallet_uuid:
wallet = get_object_or_404(Wallet.objects.all(), uuid=wallet_uuid)
else:
category = None
wallet = None
application = get_application(self.request)
return Transaction.objects.filter(Q(application=application) |
Q(payer_account__owner_uuid=application.pk,
payer_account__owner_type=TypeChoices.APPLICATION,
payer_account__category=category) |
payer_account__wallet=wallet) |
Q(payee_account__owner_uuid=application.pk,
payee_account__owner_type=TypeChoices.APPLICATION,
payee_account__category=category)
payee_account__wallet=wallet)
).all()
class CategoryTransactionListAPIView(generics.ListAPIView):
class WalletTransactionListAPIView(generics.ListAPIView):
permission_classes = [TokenHasScope]
serializer_class = TransactionSerializer
lookup_field = 'uuid'
@ -170,20 +156,20 @@ class CategoryTransactionListAPIView(generics.ListAPIView):
def get_queryset(self):
qs = super().get_queryset()
category_uuid = self.kwargs.get('category_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
wallet_uuid = self.kwargs.get('wallet_uuid')
if wallet_uuid:
wallet = get_object_or_404(Wallet.objects.all(), uuid=wallet_uuid)
else:
category = None
wallet = None
application = get_application(self.request)
return qs.filter(Q(application=application) |
Q(payer_account__owner_uuid=application.pk,
payer_account__owner_type=TypeChoices.APPLICATION,
payer_account__category=category) |
payer_account__wallet=wallet) |
Q(payee_account__owner_uuid=application.pk,
payee_account__owner_type=TypeChoices.APPLICATION,
payee_account__category=category)
payee_account__wallet=wallet)
).all()
@ -195,14 +181,14 @@ class DepositSubmitAPIView(generics.CreateAPIView):
required_scopes = ['wallet.application.deposit:submit']
def get_queryset(self):
category_uuid = self.kwargs.get('category_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
wallet_uuid = self.kwargs.get('wallet_uuid')
if wallet_uuid:
wallet = get_object_or_404(Wallet.objects.all(), uuid=wallet_uuid)
else:
category = None
wallet = None
application = get_application(self.request)
payer_account, created = Account.objects.get_or_create(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION,
category=category)
wallet=wallet)
return Transaction.objects.filter(application=application, payer_account=payer_account).all()
def perform_create(self, serializer):
@ -211,29 +197,23 @@ class DepositSubmitAPIView(generics.CreateAPIView):
logger.info("Starting perform_create for Transaction")
application = get_application(self.request)
logger.debug(f"Application UUID: {application.uuid}")
payee_wallet_uuid = serializer.validated_data.pop('payee_wallet')
payee_wallet_uuid = payee_wallet_uuid and str(payee_wallet_uuid)
payer_wallet_uuid = self.kwargs.get('wallet_uuid')
payer_wallet_uuid = self.kwargs.get('payer_wallet')
if payer_wallet_uuid:
payer_wallet = get_object_or_404(Category.objects.all(), uuid=payer_wallet_uuid)
payer_wallet = get_object_or_404(Wallet.objects.all(), uuid=payer_wallet_uuid)
else:
payer_wallet = None
payee_wallet = get_object_or_404(Category.objects.all(), uuid=payee_wallet_uuid)
payee_wallet_uuid = serializer.validated_data.pop('payee_wallet')
payee_wallet_uuid = payee_wallet_uuid and str(payee_wallet_uuid)
payee_wallet = get_object_or_404(Wallet.objects.all(), uuid=payee_wallet_uuid)
if not (payee_wallet and payee_wallet.currency == payer_wallet.currency):
raise UnprocessableEntity('payer and payee wallet currency not equal')
payee_id = serializer.validated_data.pop('payee')
payee_type = serializer.validated_data.pop('payee_type')
payer_account, _ = Account.objects.get_or_create(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION,
category=payer_wallet)
wallet=payer_wallet)
logger.debug(f"Payer account: {payer_account.uuid}")
payee_account, _ = Account.objects.get_or_create(owner_uuid=payee_id, owner_type=payee_type,
category=payee_wallet)
wallet=payee_wallet)
logger.debug(f"Payee account: {payee_account.uuid}")
uuid = serializer.validated_data.pop('uuid', None)
@ -278,12 +258,12 @@ class DepositVerifyAPIView(generics.RetrieveAPIView):
def get_queryset(self):
application = get_application(self.request)
category_uuid = self.kwargs.get('category_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
payer_wallet_uuid = self.kwargs.get('payer_wallet')
if payer_wallet_uuid:
wallet = get_object_or_404(Wallet.objects.all(), uuid=payer_wallet_uuid)
else:
category = None
account = Account.objects.get(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION, category=category)
wallet = None
account = Account.objects.get(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION, wallet=wallet)
return Transaction.objects.filter(application=application, payer_account=account).all()
def retrieve(self, request, *args, **kwargs):
@ -302,14 +282,14 @@ class WithdrawSubmitAPIView(generics.CreateAPIView):
required_scopes = ['wallet.application.withdraw:submit']
def get_queryset(self):
category_uuid = self.kwargs.get('category_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
wallet_uuid = self.kwargs.get('wallet_uuid')
if wallet_uuid:
wallet = get_object_or_404(Wallet.objects.all(), uuid=wallet_uuid)
else:
category = None
wallet = None
application = get_application(self.request)
payee_account, created = Account.objects.get_or_create(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION,
category=category)
wallet=wallet)
return Transaction.objects.filter(application=application, payee_account=payee_account).all()
def perform_create(self, serializer):
@ -322,14 +302,14 @@ class WithdrawSubmitAPIView(generics.CreateAPIView):
payer_wallet_uuid = serializer.validated_data.pop('payer_wallet')
payer_wallet_uuid = payer_wallet_uuid and str(payer_wallet_uuid)
payee_wallet_uuid = self.kwargs.get('category_uuid')
payee_wallet_uuid = self.kwargs.get('wallet_uuid')
if payee_wallet_uuid:
payee_wallet = get_object_or_404(Category.objects.all(), uuid=payee_wallet_uuid)
payee_wallet = get_object_or_404(Wallet.objects.all(), uuid=payee_wallet_uuid)
else:
payee_wallet = None
payer_wallet = get_object_or_404(Category.objects.all(), uuid=payer_wallet_uuid)
payer_wallet = get_object_or_404(Wallet.objects.all(), uuid=payer_wallet_uuid)
if not (payer_wallet and payer_wallet.currency == payee_wallet.currency):
raise UnprocessableEntity('payer and payee wallet currency not equal')
@ -337,10 +317,10 @@ class WithdrawSubmitAPIView(generics.CreateAPIView):
payer_id = serializer.validated_data.pop('payer')
payer_type = serializer.validated_data.pop('payer_type')
payee_account, _ = Account.objects.get_or_create(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION,
category=payee_wallet)
wallet=payee_wallet)
logger.debug(f"Payee account: {payee_account.uuid}")
payer_account, _ = Account.objects.get_or_create(owner_uuid=payer_id, owner_type=payer_type,
category=payer_wallet)
wallet=payer_wallet)
logger.debug(f"Payer account: {payer_account.uuid}")
uuid = serializer.validated_data.pop('uuid', None)
@ -388,12 +368,12 @@ class WithdrawVerifyAPIView(generics.RetrieveAPIView):
def get_queryset(self):
application = get_application(self.request)
category_uuid = self.kwargs.get('category_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
wallet_uuid = self.kwargs.get('wallet_uuid')
if wallet_uuid:
wallet = get_object_or_404(Wallet.objects.all(), uuid=wallet_uuid)
else:
category = None
payee_account = Account.objects.get(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION, category=category)
wallet = None
payee_account = Account.objects.get(owner_uuid=application.uuid, owner_type=TypeChoices.APPLICATION, wallet=wallet)
return Transaction.objects.filter(application=application, payee_wallet=payee_account).all()
def retrieve(self, request, *args, **kwargs):

24
apps/wallet/views/user.py
View file

@ -227,7 +227,7 @@ class TransactionDetailView(UpdateView):
class CategoryMyAccountBalanceView(generics.RetrieveAPIView):
class WalletMyAccountBalanceView(generics.RetrieveAPIView):
'''
API for getting authenticated user balance.
'''
@ -237,14 +237,14 @@ class CategoryMyAccountBalanceView(generics.RetrieveAPIView):
def get_object(self):
user = self.request.user
category_uuid = self.kwargs.get('category_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
wallet_uuid = self.kwargs.get('wallet_uuid')
if wallet_uuid:
wallet = get_object_or_404(Wallet.objects.all(), uuid=wallet_uuid)
else:
category = None
wallet = None
wallet, created = Account.objects.get_or_create(owner_uuid=user.uuid, owner_type=TypeChoices.USER,
category=category)
wallet=wallet)
return wallet
@ -275,7 +275,7 @@ class TransactionListAPIView(generics.ListAPIView):
Q(payer_wallet__owner_uuid=user.uuid)).all()
class CategoryTransactionListView(generics.ListAPIView):
class WalletTransactionListView(generics.ListAPIView):
'''
GET: API for getting list of transactions for authenticated user
POST: API for creating transaction for transferring funds from authenticated user to application owner. (deprecated)
@ -295,14 +295,14 @@ class CategoryTransactionListView(generics.ListAPIView):
def get_queryset(self):
user = self.request.user
category_uuid = self.kwargs.get('category_uuid')
if category_uuid:
category = get_object_or_404(Category.objects.all(), uuid=category_uuid)
wallet_uuid = self.kwargs.get('wallet_uuid')
if wallet_uuid:
wallet = get_object_or_404(Wallet.objects.all(), uuid=wallet_uuid)
else:
category = None
wallet = None
wallet, created = Account.objects.get_or_create(owner_uuid=user.uuid, owner_type=TypeChoices.USER,
category=category)
wallet=wallet)
return Transaction.objects.filter(Q(payee_wallet=wallet) |
Q(payer_wallet=wallet)).all()

2
static/admin/js/vendor/jquery/jquery.js vendored
View file

@ -1031,7 +1031,7 @@ function createDisabledPseudo( disabled ) {
// Check for inherited disabledness on relevant non-disabled elements:
// * listed form-associated elements in a disabled fieldset
// https://html.spec.whatwg.org/multipage/forms.html#category-listed
// https://html.spec.whatwg.org/multipage/forms.html#wallet-listed
// https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
// * option elements in a disabled optgroup
// https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled