def _apply_routing_slips_to_pending_invoices(cls, routing_slip: RoutingSlipModel) -> float: """Apply the routing slips again, when routing slip is linked to an NSF parent.""" current_app.logger.info(f'Starting NSF recovery process for {routing_slip.number}') routing_slip_payment_account: PaymentAccountModel = PaymentAccountModel.find_by_id( routing_slip.payment_account_id) # apply invoice to the active CFS_ACCOUNT which will be the parent routing slip active_cfs_account = CfsAccountModel.find_effective_by_account_id(routing_slip_payment_account.id) invoices: List[InvoiceModel] = db.session.query(InvoiceModel) \ .filter(InvoiceModel.routing_slip == routing_slip.number, InvoiceModel.invoice_status_code.in_([InvoiceStatus.CREATED.value, InvoiceStatus.APPROVED.value])) \ .all() current_app.logger.info(f'Found {len(invoices)} to apply receipt') applied_amount = 0 for inv in invoices: inv_ref: InvoiceReferenceModel = InvoiceReferenceModel.find_reference_by_invoice_id_and_status( inv.id, InvoiceReferenceStatus.ACTIVE.value ) cls.apply_routing_slips_to_invoice( routing_slip_payment_account, active_cfs_account, routing_slip, inv, inv_ref.invoice_number ) # IF invoice balance is zero, then update records. if CFSService.get_invoice(cfs_account=active_cfs_account, inv_number=inv_ref.invoice_number) \ .get('amount_due') == 0: applied_amount += inv.total inv_ref.status_code = InvoiceReferenceStatus.COMPLETED.value inv.invoice_status_code = InvoiceStatus.PAID.value return applied_amount
def _publish_to_mailer(cls, invoice): """Construct message and send to mailer queue.""" receipt: ReceiptModel = ReceiptModel.find_by_invoice_id_and_receipt_number( invoice_id=invoice.id) invoice_ref: InvoiceReferenceModel = InvoiceReferenceModel.find_reference_by_invoice_id_and_status( invoice_id=invoice.id, status_code=InvoiceReferenceStatus.COMPLETED.value) payment_transaction: PaymentTransactionModel = PaymentTransactionModel.find_recent_completed_by_invoice_id( invoice_id=invoice.id) q_payload = dict( specversion='1.x-wip', type='bc.registry.payment.refundRequest', source= f'https://api.pay.bcregistry.gov.bc.ca/v1/invoices/{invoice.id}', id=invoice.id, datacontenttype='application/json', data=dict(identifier=invoice.business_identifier, orderNumber=receipt.receipt_number, transactionDateTime=get_local_formatted_date_time( payment_transaction.transaction_end_time), transactionAmount=receipt.receipt_amount, transactionId=invoice_ref.invoice_number)) current_app.logger.debug( 'Publishing payment refund request to mailer ') current_app.logger.debug(q_payload) publish_response( payload=q_payload, client_name=current_app.config.get('NATS_MAILER_CLIENT_NAME'), subject=current_app.config.get('NATS_MAILER_SUBJECT'))
def find_completed_reference_by_invoice_id(inv_id: int): """Find invoice reference by invoice id.""" ref_dao = ReferenceModel.find_reference_by_invoice_id_and_status(inv_id, InvoiceReferenceStatus.COMPLETED.value) invoice_reference = InvoiceReference() invoice_reference._dao = ref_dao # pylint: disable=protected-access current_app.logger.debug('>find_reference_by_invoice_id') return invoice_reference
def _publish_refund_to_mailer(invoice: InvoiceModel): """Construct message and send to mailer queue.""" from .payment_transaction import publish_response # pylint:disable=import-outside-toplevel,cyclic-import receipt: ReceiptModel = ReceiptModel.find_by_invoice_id_and_receipt_number( invoice_id=invoice.id) invoice_ref: InvoiceReferenceModel = InvoiceReferenceModel.find_reference_by_invoice_id_and_status( invoice_id=invoice.id, status_code=InvoiceReferenceStatus.COMPLETED.value) payment_transaction: PaymentTransactionModel = PaymentTransactionModel.find_recent_completed_by_invoice_id( invoice_id=invoice.id) message_type: str = f'bc.registry.payment.{invoice.payment_method_code.lower()}.refundRequest' transaction_date_time = receipt.receipt_date if invoice.payment_method_code == PaymentMethod.DRAWDOWN.value \ else payment_transaction.transaction_end_time filing_description = '' for line_item in invoice.payment_line_items: if filing_description: filing_description += ',' filing_description += line_item.description q_payload = dict( specversion='1.x-wip', type=message_type, source= f'https://api.pay.bcregistry.gov.bc.ca/v1/invoices/{invoice.id}', id=invoice.id, datacontenttype='application/json', data=dict(identifier=invoice.business_identifier, orderNumber=receipt.receipt_number, transactionDateTime=get_local_formatted_date_time( transaction_date_time), transactionAmount=receipt.receipt_amount, transactionId=invoice_ref.invoice_number, refundDate=get_local_formatted_date_time( datetime.now(), '%Y%m%d'), filingDescription=filing_description)) if invoice.payment_method_code == PaymentMethod.DRAWDOWN.value: payment_account: PaymentAccountModel = PaymentAccountModel.find_by_id( invoice.payment_account_id) q_payload['data'].update( dict(bcolAccount=invoice.bcol_account, bcolUser=payment_account.bcol_user_id)) current_app.logger.debug( f'Publishing payment refund request to mailer for {invoice.id} : {q_payload}' ) publish_response( payload=q_payload, client_name=current_app.config.get('NATS_MAILER_CLIENT_NAME'), subject=current_app.config.get('NATS_MAILER_SUBJECT'))
def _refund_and_create_credit_memo(invoice: InvoiceModel): # Create credit memo in CFS if the invoice status is PAID. # Don't do anything is the status is APPROVED. current_app.logger.info( f'Creating credit memo for invoice : {invoice.id}, {invoice.invoice_status_code}' ) if invoice.invoice_status_code == InvoiceStatus.APPROVED.value \ and InvoiceReferenceModel.find_reference_by_invoice_id_and_status( invoice.id, InvoiceReferenceStatus.ACTIVE.value) is None: return cfs_account: CfsAccountModel = CfsAccountModel.find_effective_by_account_id( invoice.payment_account_id) line_items: List[PaymentLineItemModel] = [] for line_item in invoice.payment_line_items: line_items.append(PaymentLineItemModel.find_by_id(line_item.id)) cms_response = CFSService.create_cms(line_items=line_items, cfs_account=cfs_account) # TODO Create a payment record for this to show up on transactions, when the ticket comes. # Create a credit with CM identifier as CMs are not reported in payment interface file # until invoice is applied. CreditModel(cfs_identifier=cms_response.get('credit_memo_number'), is_credit_memo=True, amount=invoice.total, remaining_amount=invoice.total, account_id=invoice.payment_account_id).flush() # Add up the credit amount and update payment account table. payment_account: PaymentAccountModel = PaymentAccountModel.find_by_id( invoice.payment_account_id) payment_account.credit = (payment_account.credit or 0) + invoice.total current_app.logger.info( f'Updating credit amount to {payment_account.credit} for account {payment_account.auth_account_id}' ) payment_account.flush()
def process_nsf(cls): """Process NSF routing slips. Steps: 1. Find all routing slips with NSF status. 2. Reverse the receipt for the NSF routing slips. 3. Add an invoice for NSF fees. """ routing_slips: List[RoutingSlipModel] = db.session.query(RoutingSlipModel) \ .join(PaymentAccountModel, PaymentAccountModel.id == RoutingSlipModel.payment_account_id) \ .join(CfsAccountModel, CfsAccountModel.account_id == PaymentAccountModel.id) \ .filter(RoutingSlipModel.status == RoutingSlipStatus.NSF.value) \ .filter(CfsAccountModel.status == CfsAccountStatus.ACTIVE.value).all() current_app.logger.info(f'Found {len(routing_slips)} to process NSF.') for routing_slip in routing_slips: # 1. Reverse the routing slip receipt. # 2. Reverse all the child receipts. # 3. Change the CFS Account status to FREEZE. try: current_app.logger.debug(f'Reverse receipt {routing_slip.number}') payment_account: PaymentAccountModel = PaymentAccountModel.find_by_id(routing_slip.payment_account_id) cfs_account: CfsAccountModel = CfsAccountModel.find_effective_by_account_id(payment_account.id) # Find all child routing slip and reverse it, as all linked routing slips are also considered as NSF. child_routing_slips: List[RoutingSlipModel] = RoutingSlipModel.find_children(routing_slip.number) for rs in (routing_slip, *child_routing_slips): receipt_number = rs.number if rs.parent_number: receipt_number = f'{receipt_number}L' CFSService.reverse_rs_receipt_in_cfs(cfs_account, receipt_number, is_nsf=True) for payment in db.session.query(PaymentModel) \ .filter(PaymentModel.receipt_number == receipt_number).all(): payment.payment_status_code = PaymentStatus.FAILED.value # Update the CFS Account status to FREEZE. cfs_account.status = CfsAccountStatus.FREEZE.value # Update all invoice status to CREATED. invoices: List[InvoiceModel] = db.session.query(InvoiceModel) \ .filter(InvoiceModel.routing_slip == routing_slip.number) \ .filter(InvoiceModel.invoice_status_code == InvoiceStatus.PAID.value) \ .all() for inv in invoices: # Reset the statuses inv.invoice_status_code = InvoiceStatus.CREATED.value inv_ref = InvoiceReferenceModel.find_reference_by_invoice_id_and_status( inv.id, InvoiceReferenceStatus.COMPLETED.value ) inv_ref.status_code = InvoiceReferenceStatus.ACTIVE.value # Delete receipts as receipts are reversed in CFS. for receipt in ReceiptModel.find_all_receipts_for_invoice(inv.id): db.session.delete(receipt) inv = cls._create_nsf_invoice(cfs_account, routing_slip.number, payment_account) # Reduce the NSF fee from remaining amount. routing_slip.remaining_amount = float(routing_slip.remaining_amount) - inv.total routing_slip.save() except Exception as e: # NOQA # pylint: disable=broad-except capture_message( f'Error on Processing NSF for :={routing_slip.number}, ' f'routing slip : {routing_slip.id}, ERROR : {str(e)}', level='error') current_app.logger.error(e) continue
def test_process_nsf(session): """Test process NSF.""" # 1. Link 2 child routing slips with parent. # 2. Mark the parent as NSF and run job. child_1 = '123456789' child_2 = '987654321' parent = '111111111' factory_routing_slip_account(number=child_1, status=CfsAccountStatus.ACTIVE.value, total=10) factory_routing_slip_account(number=child_2, status=CfsAccountStatus.ACTIVE.value, total=10) pay_account = factory_routing_slip_account( number=parent, status=CfsAccountStatus.ACTIVE.value, total=10) child_1_rs = RoutingSlipModel.find_by_number(child_1) child_2_rs = RoutingSlipModel.find_by_number(child_2) parent_rs = RoutingSlipModel.find_by_number(parent) # Do Link for child in (child_2_rs, child_1_rs): child.status = RoutingSlipStatus.LINKED.value child.parent_number = parent_rs.number child.save() RoutingSlipTask.link_routing_slips() # Now mark the parent as NSF parent_rs.remaining_amount = -30 parent_rs.status = RoutingSlipStatus.NSF.value parent_rs.save() # Create an invoice record against this routing slip. invoice = factory_invoice(payment_account=pay_account, total=30, status_code=InvoiceStatus.PAID.value, payment_method_code=PaymentMethod.INTERNAL.value, routing_slip=parent_rs.number) fee_schedule = FeeScheduleModel.find_by_filing_type_and_corp_type( 'CP', 'OTANN') line = factory_payment_line_item( invoice.id, fee_schedule_id=fee_schedule.fee_schedule_id) line.save() # Create a distribution for NSF -> As this is a manual step once in each env. nsf_fee_schedule = FeeScheduleModel.find_by_filing_type_and_corp_type( 'BCR', 'NSF') distribution = factory_distribution('NSF') factory_distribution_link(distribution.distribution_code_id, nsf_fee_schedule.fee_schedule_id) # Create invoice factory_invoice_reference( invoice.id, status_code=InvoiceReferenceStatus.COMPLETED.value) # Create receipts for the invoices factory_receipt(invoice.id, parent_rs.number) factory_receipt(invoice.id, child_1_rs.number) factory_receipt(invoice.id, child_2_rs.number) with patch('pay_api.services.CFSService.reverse_rs_receipt_in_cfs' ) as mock_cfs_reverse: RoutingSlipTask.process_nsf() mock_cfs_reverse.assert_called() # Assert the records. invoice: InvoiceModel = InvoiceModel.find_by_id(invoice.id) assert invoice.invoice_status_code == InvoiceStatus.CREATED.value assert InvoiceReferenceModel.find_reference_by_invoice_id_and_status( invoice.id, status_code=InvoiceReferenceStatus.ACTIVE.value) assert not ReceiptModel.find_all_receipts_for_invoice(invoice.id) assert float( RoutingSlipModel.find_by_number( parent_rs.number).remaining_amount) == -60 # Including NSF Fee with patch('pay_api.services.CFSService.reverse_rs_receipt_in_cfs' ) as mock_cfs_reverse_2: RoutingSlipTask.process_nsf() mock_cfs_reverse_2.assert_not_called()
async def _process_jv_details_feedback(ejv_file, has_errors, line, receipt_number): # pylint:disable=too-many-locals journal_name: str = line[7:17] # {ministry}{ejv_header_model.id:0>8} ejv_header_model_id = int(journal_name[2:]) invoice_id = int(line[205:315]) invoice: InvoiceModel = InvoiceModel.find_by_id(invoice_id) invoice_link: EjvInvoiceLinkModel = db.session.query( EjvInvoiceLinkModel).filter( EjvInvoiceLinkModel.ejv_header_id == ejv_header_model_id).filter( EjvInvoiceLinkModel.invoice_id == invoice_id).one_or_none() invoice_return_code = line[315:319] invoice_return_message = line[319:469] # If the JV process failed, then mark the GL code against the invoice to be stopped # for further JV process for the credit GL. if line[104:105] == 'C' and ejv_file.is_distribution: invoice_link.disbursement_status_code = _get_disbursement_status( invoice_return_code) invoice_link.message = invoice_return_message invoice.disbursement_status_code = _get_disbursement_status( invoice_return_code) if invoice_link.disbursement_status_code == DisbursementStatus.ERRORED.value: has_errors = True line_items: List[PaymentLineItemModel] = invoice.payment_line_items for line_item in line_items: # Line debit distribution debit_distribution: DistributionCodeModel = DistributionCodeModel \ .find_by_id(line_item.fee_distribution_id) credit_distribution: DistributionCodeModel = DistributionCodeModel \ .find_by_id(debit_distribution.disbursement_distribution_code_id) credit_distribution.stop_ejv = True elif line[104:105] == 'D' and not ejv_file.is_distribution: # This is for gov account payment JV. invoice_link.disbursement_status_code = _get_disbursement_status( invoice_return_code) invoice_link.message = invoice_return_message inv_ref: InvoiceReferenceModel = InvoiceReferenceModel.find_reference_by_invoice_id_and_status( invoice_id, InvoiceReferenceStatus.ACTIVE.value) if invoice_link.disbursement_status_code == DisbursementStatus.ERRORED.value: has_errors = True # Cancel the invoice reference. inv_ref.status_code = InvoiceReferenceStatus.CANCELLED.value # Find the distribution code and set the stop_ejv flag to TRUE dist_code: DistributionCodeModel = DistributionCodeModel.find_by_active_for_account( invoice.payment_account_id) dist_code.stop_ejv = True elif invoice_link.disbursement_status_code == DisbursementStatus.COMPLETED.value: # Set the invoice status as PAID. Mark the invoice reference as COMPLETED, create a receipt invoice.invoice_status_code = InvoiceStatus.PAID.value if inv_ref: inv_ref.status_code = InvoiceReferenceStatus.COMPLETED.value # Find receipt and add total to it, as single invoice can be multiple rows in the file receipt = ReceiptModel.find_by_invoice_id_and_receipt_number( invoice_id=invoice_id, receipt_number=receipt_number) if receipt: receipt.receipt_amount += float(line[89:104]) else: ReceiptModel(invoice_id=invoice_id, receipt_number=receipt_number, receipt_date=datetime.now(), receipt_amount=float(line[89:104])).flush() return has_errors
async def test_failed_payment_ejv_reconciliations(session, app, stan_server, event_loop, client_id, events_stan, future, mock_publish): """Test Reconciliations worker.""" # Call back for the subscription from reconciliations.worker import cb_subscription_handler # Create a Credit Card Payment # register the handler to test it await subscribe_to_queue( events_stan, current_app.config.get('SUBSCRIPTION_OPTIONS').get('subject'), current_app.config.get('SUBSCRIPTION_OPTIONS').get('queue'), current_app.config.get('SUBSCRIPTION_OPTIONS').get('durable_name'), cb_subscription_handler) # 1. Create EJV payment accounts # 2. Create invoice and related records # 3. Create a feedback file and assert status corp_type = 'BEN' filing_type = 'BCINC' # Find fee schedule which have service fees. fee_schedule: FeeScheduleModel = FeeScheduleModel.find_by_filing_type_and_corp_type( corp_type, filing_type) # Create a service fee distribution code service_fee_dist_code = factory_distribution(name='service fee', client='112', reps_centre='99999', service_line='99999', stob='9999', project_code='9999999') service_fee_dist_code.save() dist_code: DistributionCodeModel = DistributionCodeModel.find_by_active_for_fee_schedule( fee_schedule.fee_schedule_id) # Update fee dist code to match the requirement. dist_code.client = '112' dist_code.responsibility_centre = '22222' dist_code.service_line = '33333' dist_code.stob = '4444' dist_code.project_code = '5555555' dist_code.service_fee_distribution_code_id = service_fee_dist_code.distribution_code_id dist_code.save() # GA jv_account_1 = factory_create_ejv_account(auth_account_id='1') jv_account_2 = factory_create_ejv_account(auth_account_id='2') # GI jv_account_3 = factory_create_ejv_account(auth_account_id='3', client='111') jv_account_4 = factory_create_ejv_account(auth_account_id='4', client='111') # Now create JV records. # Create EJV File model file_ref = f'INBOX.{datetime.now()}' ejv_file: EjvFileModel = EjvFileModel( file_ref=file_ref, disbursement_status_code=DisbursementStatus.UPLOADED.value, is_distribution=False).save() ejv_file_id = ejv_file.id feedback_content = f'..BG...........00000000{ejv_file_id}...\n' \ f'..BH...0000.................................................................................' \ f'.....................................................................CGI\n' jv_accounts = [jv_account_1, jv_account_2, jv_account_3, jv_account_4] inv_ids = [] jv_account_ids = [] inv_total_amount = 101.5 for jv_acc in jv_accounts: jv_account_ids.append(jv_acc.id) inv = factory_invoice(payment_account=jv_acc, corp_type_code=corp_type, total=inv_total_amount, status_code=InvoiceStatus.APPROVED.value, payment_method_code=None) factory_invoice_reference(inv.id) line: PaymentLineItemModel = factory_payment_line_item( invoice_id=inv.id, fee_schedule_id=fee_schedule.fee_schedule_id, filing_fees=100, total=100, service_fees=1.5, fee_dist_id=dist_code.distribution_code_id) inv_ids.append(inv.id) ejv_header: EjvHeaderModel = EjvHeaderModel( disbursement_status_code=DisbursementStatus.UPLOADED.value, ejv_file_id=ejv_file.id, payment_account_id=jv_acc.id).save() EjvInvoiceLinkModel( invoice_id=inv.id, ejv_header_id=ejv_header.id, disbursement_status_code=DisbursementStatus.UPLOADED.value).save() inv_total = f'{inv.total:.2f}'.zfill(15) pay_line_amount = f'{line.total:.2f}'.zfill(15) service_fee_amount = f'{line.service_fees:.2f}'.zfill(15) jh_and_jd = f'..JH...FI0000000{ejv_header.id}.........................{inv_total}.....................' \ f'............................................................................................' \ f'............................................................................................' \ f'.........1111ERROR..........................................................................' \ f'.......................................................................CGI\n' \ f'..JD...FI0000000{ejv_header.id}00001........................................................' \ f'...........{pay_line_amount}D.................................................................' \ f'...................................{inv.id} ' \ f' 1111ERROR...................' \ f'............................................................................................' \ f'..................................CGI\n' \ f'..JD...FI0000000{ejv_header.id}00002........................................................' \ f'...........{pay_line_amount}C.................................................................' \ f'...................................{inv.id} ' \ f' 1111ERROR...................' \ f'............................................................................................' \ f'..................................CGI\n' \ f'..JD...FI0000000{ejv_header.id}00003...........................................................' \ f'........{service_fee_amount}D.................................................................' \ f'...................................{inv.id} ' \ f' 1111ERROR...................' \ f'............................................................................................' \ f'..................................CGI\n' \ f'..JD...FI0000000{ejv_header.id}00004........................................................' \ f'...........{service_fee_amount}C..............................................................' \ f'......................................{inv.id} ' \ f' 1111ERROR...................' \ f'............................................................................................' \ f'..................................CGI\n' feedback_content = feedback_content + jh_and_jd feedback_content = feedback_content + f'..BT.......FI0000000{ejv_header.id}000000000000002{inv_total}0000.......' \ f'.........................................................................' \ f'......................................................................CGI' ack_file_name = f'ACK.{file_ref}' with open(ack_file_name, 'a+') as jv_file: jv_file.write('') jv_file.close() # Now upload the ACK file to minio and publish message. upload_to_minio(file_name=ack_file_name, value_as_bytes=str.encode('')) await helper_add_ejv_event_to_queue(events_stan, file_name=ack_file_name) # Query EJV File and assert the status is changed ejv_file = EjvFileModel.find_by_id(ejv_file_id) assert ejv_file.disbursement_status_code == DisbursementStatus.ACKNOWLEDGED.value feedback_file_name = f'FEEDBACK.{file_ref}' with open(feedback_file_name, 'a+') as jv_file: jv_file.write(feedback_content) jv_file.close() # Now upload the ACK file to minio and publish message. with open(feedback_file_name, 'rb') as f: upload_to_minio(f.read(), feedback_file_name) await helper_add_ejv_event_to_queue(events_stan, file_name=feedback_file_name, message_type='FEEDBACKReceived') # Query EJV File and assert the status is changed ejv_file = EjvFileModel.find_by_id(ejv_file_id) assert ejv_file.disbursement_status_code == DisbursementStatus.COMPLETED.value # Assert invoice and receipt records for inv_id in inv_ids: invoice: InvoiceModel = InvoiceModel.find_by_id(inv_id) assert invoice.disbursement_status_code is None assert invoice.invoice_status_code == InvoiceStatus.APPROVED.value # Will stay as original status invoice_ref: InvoiceReferenceModel = InvoiceReferenceModel.find_reference_by_invoice_id_and_status( inv_id, InvoiceReferenceStatus.COMPLETED.value) assert invoice_ref is None # No completed inv ref receipt = ReceiptModel.find_by_invoice_id_and_receipt_number( invoice_id=inv_id) assert receipt is None # NO receipt # Assert payment records for jv_account_id in jv_account_ids: account = PaymentAccountModel.find_by_id(jv_account_id) payment: PaymentModel = PaymentModel.search_account_payments( auth_account_id=account.auth_account_id, payment_status=PaymentStatus.COMPLETED.value, page=1, limit=100)[0] assert len(payment) == 0
def test_payments_for_gov_accounts(session, monkeypatch): """Test payments for gov accounts. Steps: 1) Update a distribution code with client code 112. 2) Create multiple gov accounts for GA - 112 3) Create multiple gov accounts for GI - NOT 112 4) Create some transactions for these accounts 5) Run the job and assert results. """ monkeypatch.setattr('pysftp.Connection.put', lambda *args, **kwargs: None) corp_type = 'BEN' filing_type = 'BCINC' # Find fee schedule which have service fees. fee_schedule: FeeSchedule = FeeSchedule.find_by_filing_type_and_corp_type(corp_type, filing_type) # Create a service fee distribution code service_fee_dist_code = factory_distribution(name='service fee', client='112', reps_centre='99999', service_line='99999', stob='9999', project_code='9999999') service_fee_dist_code.save() dist_code: DistributionCode = DistributionCode.find_by_active_for_fee_schedule(fee_schedule.fee_schedule_id) # Update fee dist code to match the requirement. dist_code.client = '112' dist_code.responsibility_centre = '22222' dist_code.service_line = '33333' dist_code.stob = '4444' dist_code.project_code = '5555555' dist_code.service_fee_distribution_code_id = service_fee_dist_code.distribution_code_id dist_code.save() # GA jv_account_1 = factory_create_ejv_account(auth_account_id='1') jv_account_2 = factory_create_ejv_account(auth_account_id='2') # GI jv_account_3 = factory_create_ejv_account(auth_account_id='3', client='111') jv_account_4 = factory_create_ejv_account(auth_account_id='4', client='111') jv_accounts = [jv_account_1, jv_account_2, jv_account_3, jv_account_4] inv_ids = [] for jv_acc in jv_accounts: inv = factory_invoice(payment_account=jv_acc, corp_type_code=corp_type, total=101.5, status_code=InvoiceStatus.APPROVED.value, payment_method_code=None) factory_payment_line_item(invoice_id=inv.id, fee_schedule_id=fee_schedule.fee_schedule_id, filing_fees=100, total=100, service_fees=1.5, fee_dist_id=dist_code.distribution_code_id) inv_ids.append(inv.id) EjvPaymentTask.create_ejv_file() # Lookup invoice and assert invoice status for inv_id in inv_ids: invoice_ref = InvoiceReference.find_reference_by_invoice_id_and_status(inv_id, InvoiceReferenceStatus.ACTIVE.value) assert invoice_ref ejv_inv_link = db.session.query(EjvInvoiceLink).filter(EjvInvoiceLink.invoice_id == inv_id).first() assert ejv_inv_link ejv_header = db.session.query(EjvHeader).filter(EjvHeader.id == ejv_inv_link.ejv_header_id).first() assert ejv_header.disbursement_status_code == DisbursementStatus.UPLOADED.value assert ejv_header ejv_file: EjvFile = EjvFile.find_by_id(ejv_header.ejv_file_id) assert ejv_file assert ejv_file.disbursement_status_code == DisbursementStatus.UPLOADED.value assert not ejv_file.is_distribution