Coverage for polar/transaction/service/payout.py: 31%

1from collections.abc import Iterable 

2 

3from polar.enums import AccountType 

4from polar.kit.utils import generate_uuid 

5from polar.models import Payout, Transaction 

6from polar.models.transaction import Processor, TransactionType 

7from polar.postgres import AsyncSession 

8 

9from ..repository import BalanceTransactionRepository, PayoutTransactionRepository 

10from .base import BaseTransactionService, BaseTransactionServiceError 

11 

12 

13class PayoutTransactionError(BaseTransactionServiceError): ... 13 ↛ 16line 13 didn't jump to line 16 because

14 

15 

16class PayoutTransactionService(BaseTransactionService): 

17 async def create( 

18 self, 

19 session: AsyncSession, 

20 payout: Payout, 

21 fees_balances: Iterable[tuple[Transaction, Transaction]], 

22 ) -> Transaction: 

23 account = payout.account 

24 transaction = Transaction( 

25 id=generate_uuid(), 

26 type=TransactionType.payout, 

27 processor=Processor.stripe, 

28 currency=payout.currency, 

29 amount=-payout.amount, 

30 account_currency=payout.account_currency, 

31 account_amount=-payout.account_amount, 

32 tax_amount=0, 

33 account=account, 

34 pledge=None, 

35 issue_reward=None, 

36 order=None, 

37 paid_transactions=[], 

38 incurred_transactions=[], 

39 account_incurred_transactions=[], 

40 payout=payout, 

41 ) 

42 

43 balance_transaction_repository = BalanceTransactionRepository.from_session( 

44 session 

45 ) 

46 unpaid_balance_transactions = ( 

47 await balance_transaction_repository.get_all_unpaid_by_account(account.id) 

48 ) 

49 

50 if account.account_type == AccountType.stripe: 

51 transaction.processor = Processor.stripe 

52 elif account.account_type == AccountType.open_collective: 

53 transaction.processor = Processor.open_collective 

54 elif account.account_type == AccountType.manual: 

55 transaction.processor = Processor.manual 

56 

57 for balance_transaction in unpaid_balance_transactions: 

58 transaction.paid_transactions.append(balance_transaction) 

59 

60 for outgoing, incoming in fees_balances: 

61 transaction.incurred_transactions.append(outgoing) 

62 transaction.account_incurred_transactions.append(outgoing) 

63 transaction.incurred_transactions.append(incoming) 

64 

65 repository = PayoutTransactionRepository.from_session(session) 

66 return await repository.create(transaction, flush=True) 

67 

68 

69payout_transaction = PayoutTransactionService(Transaction)