def test_payment_against_negative_sales_invoice(self): pe1 = dataent.new_doc("Payment Entry") pe1.payment_type = "Pay" pe1.company = "_Test Company" pe1.party_type = "Customer" pe1.party = "_Test Customer" pe1.paid_from = "_Test Cash - _TC" pe1.paid_amount = 100 pe1.received_amount = 100 self.assertRaises(InvalidPaymentEntry, pe1.validate) si1 = create_sales_invoice() # create full payment entry against si1 pe2 = get_payment_entry("Sales Invoice", si1.name, bank_account="_Test Cash - _TC") pe2.insert() pe2.submit() # create return entry against si1 create_sales_invoice(is_return=1, return_against=si1.name, qty=-1) si1_outstanding = dataent.db.get_value("Sales Invoice", si1.name, "outstanding_amount") self.assertEqual(si1_outstanding, -100) # pay more than outstanding against si1 pe3 = get_payment_entry("Sales Invoice", si1.name, bank_account="_Test Cash - _TC") pe3.paid_amount = pe3.received_amount = 300 self.assertRaises(InvalidPaymentEntry, pe3.validate) # pay negative outstanding against si1 pe3.paid_to = "Debtors - _TC" pe3.paid_amount = pe3.received_amount = 100 pe3.insert() pe3.submit() expected_gle = dict((d[0], d) for d in [ ["Debtors - _TC", 100, 0, si1.name], ["_Test Cash - _TC", 0, 100, None] ]) self.validate_gl_entries(pe3.name, expected_gle) outstanding_amount = flt(dataent.db.get_value("Sales Invoice", si1.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0) pe3.cancel() self.assertFalse(self.get_gle(pe3.name)) outstanding_amount = flt(dataent.db.get_value("Sales Invoice", si1.name, "outstanding_amount")) self.assertEqual(outstanding_amount, -100)
def test_payment_entry_exchange_gain_loss(self): si = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank USD - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.target_exchange_rate = 55 pe.append("deductions", { "account": "_Test Exchange Gain/Loss - _TC", "cost_center": "_Test Cost Center - _TC", "amount": -500 }) pe.save() self.assertEqual(pe.unallocated_amount, 0) self.assertEqual(pe.difference_amount, 0) pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 5000, si.name], ["_Test Bank USD - _TC", 5500, 0, None], ["_Test Exchange Gain/Loss - _TC", 0, 500, None], ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(dataent.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0)
def test_payment_entry_write_off_difference(self): si = create_sales_invoice() pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Cash - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.received_amount = pe.paid_amount = 110 pe.insert() self.assertEqual(pe.unallocated_amount, 10) pe.received_amount = pe.paid_amount = 95 pe.append("deductions", { "account": "_Test Write Off - _TC", "cost_center": "_Test Cost Center - _TC", "amount": 5 }) pe.save() self.assertEqual(pe.unallocated_amount, 0) self.assertEqual(pe.difference_amount, 0) pe.submit() expected_gle = dict((d[0], d) for d in [ ["Debtors - _TC", 0, 100, si.name], ["_Test Cash - _TC", 95, 0, None], ["_Test Write Off - _TC", 5, 0, None] ]) self.validate_gl_entries(pe.name, expected_gle)
def test_payment_entry_against_si_usd_to_inr(self): si = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Sales Invoice", si.name, party_amount=20, bank_account="_Test Bank - _TC", bank_amount=900) pe.reference_no = "1" pe.reference_date = "2016-01-01" self.assertEqual(pe.difference_amount, 100) pe.append("deductions", { "account": "_Test Exchange Gain/Loss - _TC", "cost_center": "_Test Cost Center - _TC", "amount": 100 }) pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 1000, si.name], ["_Test Bank - _TC", 900, 0, None], ["_Test Exchange Gain/Loss - _TC", 100.0, 0, None], ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(dataent.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 80)
def test_payment_entry_against_si_usd_to_usd(self): si = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank USD - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.target_exchange_rate = 50 pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 5000, si.name], ["_Test Bank USD - _TC", 5000.0, 0, None] ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(dataent.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0) pe.cancel() self.assertFalse(self.get_gle(pe.name)) outstanding_amount = flt(dataent.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 100)
def make_payament_entry_against_sales_invoice(doc, shopify_settings): from epaas.accounts.doctype.payment_entry.payment_entry import get_payment_entry payemnt_entry = get_payment_entry( doc.doctype, doc.name, bank_account=shopify_settings.cash_bank_account) payemnt_entry.flags.ignore_mandatory = True payemnt_entry.reference_no = doc.name payemnt_entry.reference_date = nowdate() payemnt_entry.submit()
def test_purchase_invoice_temporary_blocked(self): pi = make_purchase_invoice(do_not_save=True) pi.release_date = add_days(nowdate(), 10) pi.save() pi.submit() pe = get_payment_entry('Purchase Invoice', dn=pi.name, bank_account="_Test Bank - _TC") self.assertRaises(dataent.ValidationError, pe.save)
def create_payment_entry(self, submit=True): """create entry""" dataent.flags.ignore_account_permission = True ref_doc = dataent.get_doc(self.reference_doctype, self.reference_name) if self.reference_doctype == "Sales Invoice": party_account = ref_doc.debit_to elif self.reference_doctype == "Purchase Invoice": party_account = ref_doc.credit_to else: party_account = get_party_account("Customer", ref_doc.get("customer"), ref_doc.company) party_account_currency = ref_doc.get( "party_account_currency") or get_account_currency(party_account) bank_amount = self.grand_total if party_account_currency == ref_doc.company_currency and party_account_currency != self.currency: party_amount = ref_doc.base_grand_total else: party_amount = self.grand_total payment_entry = get_payment_entry(self.reference_doctype, self.reference_name, party_amount=party_amount, bank_account=self.payment_account, bank_amount=bank_amount) payment_entry.update({ "reference_no": self.name, "reference_date": nowdate(), "remarks": "Payment Entry against {0} {1} via Payment Request {2}".format( self.reference_doctype, self.reference_name, self.name) }) if payment_entry.difference_amount: company_details = get_company_defaults(ref_doc.company) payment_entry.append( "deductions", { "account": company_details.exchange_gain_loss_account, "cost_center": company_details.cost_center, "amount": payment_entry.difference_amount }) if submit: payment_entry.insert(ignore_permissions=True) payment_entry.submit() return payment_entry
def test_payment_entry_for_blocked_supplier_payments_past_date(self): # this test is meant to fail only if something fails in the try block with self.assertRaises(Exception): try: supplier = dataent.get_doc('Supplier', '_Test Supplier') supplier.on_hold = 1 supplier.hold_type = 'Payments' supplier.release_date = '2018-03-01' supplier.save() pi = make_purchase_invoice() get_payment_entry('Purchase Invoice', pi.name, bank_account="_Test Bank - _TC") supplier.on_hold = 0 supplier.save() except: pass else: raise Exception
def test_get_mode_of_payments_details(self): filters = get_filters() for dummy in range(2): si = create_sales_invoice_record() si.insert() si.submit() if int(si.name[-3:]) % 2 == 0: bank_account = "_Test Cash - _TC" mode_of_payment = "Cash" else: bank_account = "_Test Bank - _TC" mode_of_payment = "Credit Card" pe = get_payment_entry("Sales Invoice", si.name, bank_account=bank_account) pe.reference_no = "_Test" pe.reference_date = today() pe.mode_of_payment = mode_of_payment pe.insert() pe.submit() mopd = get_mode_of_payment_details(filters) mopd_values = list(mopd.values())[0] for mopd_value in mopd_values: if mopd_value[0] == "Credit Card": cc_init_amount = mopd_value[1] # Cancel one Credit Card Payment Entry and check that it is not fetched in mode of payment details. payment_entries = dataent.get_all("Payment Entry", filters={ "mode_of_payment": "Credit Card", "docstatus": 1 }, fields=["name", "docstatus"]) for payment_entry in payment_entries[:1]: pe = dataent.get_doc("Payment Entry", payment_entry.name) pe.cancel() mopd = get_mode_of_payment_details(filters) mopd_values = list(mopd.values())[0] for mopd_value in mopd_values: if mopd_value[0] == "Credit Card": cc_final_amount = mopd_value[1] self.assertTrue(cc_init_amount > cc_final_amount)
def test_payment_entry_against_pi(self): pi = make_purchase_invoice(supplier="_Test Supplier USD", debit_to="_Test Payable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank USD - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.source_exchange_rate = 50 pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Payable USD - _TC", 12500, 0, pi.name], ["_Test Bank USD - _TC", 0, 12500, None] ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(dataent.db.get_value("Sales Invoice", pi.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0)
def test_get_mode_of_payments(self): filters = get_filters() for dummy in range(2): si = create_sales_invoice_record() si.insert() si.submit() if int(si.name[-3:]) % 2 == 0: bank_account = "_Test Cash - _TC" mode_of_payment = "Cash" else: bank_account = "_Test Bank - _TC" mode_of_payment = "Credit Card" pe = get_payment_entry("Sales Invoice", si.name, bank_account=bank_account) pe.reference_no = "_Test" pe.reference_date = today() pe.mode_of_payment = mode_of_payment pe.insert() pe.submit() mop = get_mode_of_payments(filters) self.assertTrue('Credit Card' in list(mop.values())[0]) self.assertTrue('Cash' in list(mop.values())[0]) # Cancel all Cash payment entry and check if this mode of payment is still fetched. payment_entries = dataent.get_all("Payment Entry", filters={ "mode_of_payment": "Cash", "docstatus": 1 }, fields=["name", "docstatus"]) for payment_entry in payment_entries: pe = dataent.get_doc("Payment Entry", payment_entry.name) pe.cancel() mop = get_mode_of_payments(filters) self.assertTrue('Credit Card' in list(mop.values())[0]) self.assertTrue('Cash' not in list(mop.values())[0])
def test_payment_entry_unlink_against_purchase_invoice(self): from epaas.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry unlink_payment_on_cancel_of_invoice(0) pi_doc = make_purchase_invoice() pe = get_payment_entry("Purchase Invoice", pi_doc.name, bank_account="_Test Bank - _TC") pe.reference_no = "1" pe.reference_date = nowdate() pe.paid_from_account_currency = pi_doc.currency pe.paid_to_account_currency = pi_doc.currency pe.source_exchange_rate = 1 pe.target_exchange_rate = 1 pe.paid_amount = pi_doc.grand_total pe.save(ignore_permissions=True) pe.submit() pi_doc = dataent.get_doc('Purchase Invoice', pi_doc.name) self.assertRaises(dataent.LinkExistsError, pi_doc.cancel)
def test_payment_entry_against_purchase_invoice_for_enable_allow_cost_center_in_entry_of_bs_account(self): from epaas.accounts.doctype.cost_center.test_cost_center import create_cost_center accounts_settings = dataent.get_doc('Accounts Settings', 'Accounts Settings') accounts_settings.allow_cost_center_in_entry_of_bs_account = 1 accounts_settings.save() cost_center = "_Test Cost Center for BS Account - _TC" create_cost_center(cost_center_name="_Test Cost Center for BS Account", company="_Test Company") pi = make_purchase_invoice_against_cost_center(cost_center=cost_center, credit_to="Creditors - _TC") pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") self.assertEqual(pe.cost_center, pi.cost_center) pe.reference_no = "112222-1" pe.reference_date = nowdate() pe.paid_from = "_Test Bank - _TC" pe.paid_amount = pi.grand_total pe.insert() pe.submit() expected_values = { "_Test Bank - _TC": { "cost_center": cost_center }, "Creditors - _TC": { "cost_center": cost_center } } gl_entries = dataent.db.sql("""select account, cost_center, account_currency, debit, credit, debit_in_account_currency, credit_in_account_currency from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s order by account asc""", pe.name, as_dict=1) self.assertTrue(gl_entries) for gle in gl_entries: self.assertEqual(expected_values[gle.account]["cost_center"], gle.cost_center) accounts_settings.allow_cost_center_in_entry_of_bs_account = 0 accounts_settings.save()
def test_payment_entry_against_ec(self): payable = dataent.get_cached_value('Company', "_Test Company", 'default_payable_account') ec = make_expense_claim(payable, 300, 300, "_Test Company", "Travel Expenses - _TC") pe = get_payment_entry("Expense Claim", ec.name, bank_account="_Test Bank USD - _TC", bank_amount=300) pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.source_exchange_rate = 1 pe.paid_to = payable pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ [payable, 300, 0, ec.name], ["_Test Bank USD - _TC", 0, 300, None] ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(dataent.db.get_value("Expense Claim", ec.name, "total_sanctioned_amount")) - \ flt(dataent.db.get_value("Expense Claim", ec.name, "total_amount_reimbursed")) self.assertEqual(outstanding_amount, 0)
def test_payment_entry_account_and_party_balance_for_enable_allow_cost_center_in_entry_of_bs_account(self): from epaas.accounts.doctype.cost_center.test_cost_center import create_cost_center from epaas.accounts.utils import get_balance_on accounts_settings = dataent.get_doc('Accounts Settings', 'Accounts Settings') accounts_settings.allow_cost_center_in_entry_of_bs_account = 1 accounts_settings.save() cost_center = "_Test Cost Center for BS Account - _TC" create_cost_center(cost_center_name="_Test Cost Center for BS Account", company="_Test Company") si = create_sales_invoice_against_cost_center(cost_center=cost_center, debit_to="Debtors - _TC") account_balance = get_balance_on(account="_Test Bank - _TC", cost_center=si.cost_center) party_balance = get_balance_on(party_type="Customer", party=si.customer, cost_center=si.cost_center) party_account_balance = get_balance_on(si.debit_to, cost_center=si.cost_center) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC") pe.reference_no = "112211-1" pe.reference_date = nowdate() pe.paid_to = "_Test Bank - _TC" pe.paid_amount = si.grand_total pe.insert() pe.submit() expected_account_balance = account_balance + si.grand_total expected_party_balance = party_balance - si.grand_total expected_party_account_balance = party_account_balance - si.grand_total account_balance = get_balance_on(account=pe.paid_to, cost_center=pe.cost_center) party_balance = get_balance_on(party_type="Customer", party=pe.party, cost_center=pe.cost_center) party_account_balance = get_balance_on(account=pe.paid_from, cost_center=pe.cost_center) self.assertEqual(pe.cost_center, si.cost_center) self.assertEqual(expected_account_balance, account_balance) self.assertEqual(expected_party_balance, party_balance) self.assertEqual(expected_party_account_balance, party_account_balance) accounts_settings.allow_cost_center_in_entry_of_bs_account = 0 accounts_settings.save()
def test_payment_entry_against_order(self): so = make_sales_order() pe = get_payment_entry("Sales Order", so.name, bank_account="_Test Cash - _TC") pe.paid_from = "Debtors - _TC" pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ ["Debtors - _TC", 0, 1000, so.name], ["_Test Cash - _TC", 1000.0, 0, None] ]) self.validate_gl_entries(pe.name, expected_gle) so_advance_paid = dataent.db.get_value("Sales Order", so.name, "advance_paid") self.assertEqual(so_advance_paid, 1000) pe.cancel() self.assertFalse(self.get_gle(pe.name)) so_advance_paid = dataent.db.get_value("Sales Order", so.name, "advance_paid") self.assertEqual(so_advance_paid, 0)
def make_payment_entries(ref_doctype, report): outstanding_invoices = list(set([r[3] for r in query_report.run(report, {"report_date": dataent.flags.current_date })["result"] if r[2]==ref_doctype])) # make Payment Entry for inv in outstanding_invoices[:random.randint(1, 2)]: pe = get_payment_entry(ref_doctype, inv) pe.posting_date = dataent.flags.current_date pe.reference_no = random_string(6) pe.reference_date = dataent.flags.current_date pe.insert() pe.submit() dataent.db.commit() outstanding_invoices.remove(inv) # make payment via JV for inv in outstanding_invoices[:1]: jv = dataent.get_doc(get_payment_entry_against_invoice(ref_doctype, inv)) jv.posting_date = dataent.flags.current_date jv.cheque_no = random_string(6) jv.cheque_date = dataent.flags.current_date jv.insert() jv.submit() dataent.db.commit()
def test_debit_note(self): from epaas.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry from epaas.accounts.doctype.sales_invoice.test_sales_invoice import get_outstanding_amount pi = make_purchase_invoice(item_code = "_Test Item", qty = (5 * -1), rate=500, is_return = 1) outstanding_amount = get_outstanding_amount(pi.doctype, pi.name, "Creditors - _TC", pi.supplier, "Supplier") self.assertEqual(pi.outstanding_amount, outstanding_amount) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "1" pe.reference_date = nowdate() pe.paid_from_account_currency = pi.currency pe.paid_to_account_currency = pi.currency pe.source_exchange_rate = 1 pe.target_exchange_rate = 1 pe.paid_amount = pi.grand_total * -1 pe.insert() pe.submit() pi_doc = dataent.get_doc('Purchase Invoice', pi.name) self.assertEqual(pi_doc.outstanding_amount, 0)
def test_payment_entry_against_purchase_invoice_for_disable_allow_cost_center_in_entry_of_bs_account(self): accounts_settings = dataent.get_doc('Accounts Settings', 'Accounts Settings') accounts_settings.allow_cost_center_in_entry_of_bs_account = 0 accounts_settings.save() pi = make_purchase_invoice(credit_to="Creditors - _TC") pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "112222-2" pe.reference_date = nowdate() pe.paid_from = "_Test Bank - _TC" pe.paid_amount = pi.grand_total pe.insert() pe.submit() gl_entries = dataent.db.sql("""select account, cost_center, account_currency, debit, credit, debit_in_account_currency, credit_in_account_currency from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s order by account asc""", pe.name, as_dict=1) self.assertTrue(gl_entries) for gle in gl_entries: self.assertEqual(gle.cost_center, None)
def make_payment(docname): pe = get_payment_entry("Sales Invoice", docname, bank_account="Cash - _TC2", party_amount=30) pe.paid_from = "Debtors - _TC2" pe.insert() pe.submit()