def make_bank_entry(docname): from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account expense_claim = frappe.get_doc("Expense Claim", docname) default_bank_cash_account = get_default_bank_cash_account(expense_claim.company, "Bank") if not default_bank_cash_account: default_bank_cash_account = get_default_bank_cash_account(expense_claim.company, "Cash") je = frappe.new_doc("Journal Entry") je.voucher_type = 'Bank Entry' je.company = expense_claim.company je.remark = 'Payment against Expense Claim: ' + docname; je.append("accounts", { "account": expense_claim.payable_account, "debit_in_account_currency": flt(expense_claim.total_sanctioned_amount - expense_claim.total_amount_reimbursed), "reference_type": "Expense Claim", "party_type": "Employee", "party": expense_claim.employee, "reference_name": expense_claim.name }) je.append("accounts", { "account": default_bank_cash_account.account, "credit_in_account_currency": flt(expense_claim.total_sanctioned_amount - expense_claim.total_amount_reimbursed), "reference_type": "Expense Claim", "reference_name": expense_claim.name, "balance": default_bank_cash_account.balance, "account_currency": default_bank_cash_account.account_currency, "account_type": default_bank_cash_account.account_type }) return je.as_dict()
def make_bank_entry(dt, dn): from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account expense_claim = frappe.get_doc(dt, dn) default_bank_cash_account = get_default_bank_cash_account(expense_claim.company, "Bank") if not default_bank_cash_account: default_bank_cash_account = get_default_bank_cash_account(expense_claim.company, "Cash") je = frappe.new_doc("Journal Entry") je.voucher_type = 'Bank Entry' je.company = expense_claim.company je.remark = 'Payment against Expense Claim: ' + dn; je.append("accounts", { "account": expense_claim.payable_account, "debit_in_account_currency": flt(expense_claim.total_sanctioned_amount - expense_claim.total_amount_reimbursed), "reference_type": "Expense Claim", "party_type": "Employee", "party": expense_claim.employee, "reference_name": expense_claim.name }) je.append("accounts", { "account": default_bank_cash_account.account, "credit_in_account_currency": flt(expense_claim.total_sanctioned_amount - expense_claim.total_amount_reimbursed), "reference_type": "Expense Claim", "reference_name": expense_claim.name, "balance": default_bank_cash_account.balance, "account_currency": default_bank_cash_account.account_currency, "account_type": default_bank_cash_account.account_type }) return je.as_dict()
def make_bank_entry(dt, dn): from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account requisition = frappe.get_doc(dt, dn) default_bank_cash_account = get_default_bank_cash_account( requisition.company, "Bank") if not default_bank_cash_account: default_bank_cash_account = get_default_bank_cash_account( requisition.company, "Cash") je = frappe.new_doc("Journal Entry") je.voucher_type = 'Bank Entry' je.company = requisition.company je.remark = 'Payment against Requisition: ' + dn je.append( "accounts", { "account": requisition.receivable_account, "debit_in_account_currency": flt(requisition.total_sanctioned_amount - requisition.total_amount_retired), "reference_type": dt, "party_type": "Employee", "party": requisition.employee, "reference_name": requisition.name }) je.append( "accounts", { "account": default_bank_cash_account.account, "credit_in_account_currency": flt(requisition.total_sanctioned_amount - requisition.total_amount_retired), "reference_type": "Expense Claim", "reference_name": requisition.name, "balance": default_bank_cash_account.balance, "account_currency": default_bank_cash_account.account_currency, "account_type": default_bank_cash_account.account_type }) return je.as_dict()
def get_bank_cash_account(company, mode_of_payment, bank_account=None): bank = get_default_bank_cash_account(company, "Bank", mode_of_payment=mode_of_payment, account=bank_account) if not bank: bank = get_default_bank_cash_account(company, "Cash", mode_of_payment=mode_of_payment, account=bank_account) return bank
def execute(): frappe.reload_doc('accounts', 'doctype', 'sales_invoice') for company in frappe.db.sql("""select company from `tabSales Invoice` where change_amount <> 0 and account_for_change_amount is null group by company""", as_list = 1): cash_account = get_default_bank_cash_account(company[0], 'Cash').get('account') if not cash_account: bank_account = get_default_bank_cash_account(company[0], 'Bank').get('account') cash_account = bank_account if cash_account: frappe.db.sql("""update `tabSales Invoice` set account_for_change_amount = %(cash_account)s where change_amount <> 0 and company = %(company)s and account_for_change_amount is null""", {'cash_account': cash_account, 'company': company[0]})
def make_return_entry(employee, company, employee_advance_name, return_amount, advance_account, mode_of_payment=None): return_account = get_default_bank_cash_account(company, account_type='Cash', mode_of_payment = mode_of_payment) je = frappe.new_doc('Journal Entry') je.posting_date = nowdate() je.voucher_type = 'Bank Entry' je.company = company je.remark = 'Return against Employee Advance: ' + employee_advance_name je.append('accounts', { 'account': advance_account, 'credit_in_account_currency': return_amount, 'reference_type': 'Employee Advance', 'reference_name': employee_advance_name, 'party_type': 'Employee', 'party': employee, 'is_advance': 'Yes' }) je.append("accounts", { "account": return_account.account, "debit_in_account_currency": return_amount, "account_currency": return_account.account_currency, "account_type": return_account.account_type }) return je.as_dict()
def make_return_entry(employee, company, employee_advance_name, return_amount, advance_account, mode_of_payment=None): return_account = get_default_bank_cash_account(company, account_type='Cash', mode_of_payment = mode_of_payment) mode_of_payment_type = '' if mode_of_payment: mode_of_payment_type = frappe.get_cached_value('Mode of Payment', mode_of_payment, 'type') if mode_of_payment_type not in ["Cash", "Bank"]: # if mode of payment is General then it unset the type mode_of_payment_type = None je = frappe.new_doc('Journal Entry') je.posting_date = nowdate() # if mode of payment is Bank then voucher type is Bank Entry je.voucher_type = '{} Entry'.format(mode_of_payment_type) if mode_of_payment_type else 'Cash Entry' je.company = company je.remark = 'Return against Employee Advance: ' + employee_advance_name je.append('accounts', { 'account': advance_account, 'credit_in_account_currency': return_amount, 'reference_type': 'Employee Advance', 'reference_name': employee_advance_name, 'party_type': 'Employee', 'party': employee, 'is_advance': 'Yes' }) je.append("accounts", { "account": return_account.account, "debit_in_account_currency": return_amount, "account_currency": return_account.account_currency, "account_type": return_account.account_type }) return je.as_dict()
def make_bank_entry(docname): from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account expense_claim = frappe.get_doc("Expense Claim", docname) default_bank_cash_account = get_default_bank_cash_account( expense_claim.company, "Bank") je = frappe.new_doc("Journal Entry") je.voucher_type = 'Bank Entry' je.company = expense_claim.company je.remark = 'Payment against Expense Claim: ' + docname for expense in expense_claim.expenses: je.append( "accounts", { "account": expense.default_account, "debit_in_account_currency": expense.sanctioned_amount, "reference_type": "Expense Claim", "reference_name": expense_claim.name }) je.append( "accounts", { "account": default_bank_cash_account.account, "credit_in_account_currency": expense_claim.total_sanctioned_amount, "reference_type": "Expense Claim", "reference_name": expense_claim.name, "balance": default_bank_cash_account.balance, "account_currency": default_bank_cash_account.account_currency, "account_type": default_bank_cash_account.account_type }) return je.as_dict()
def make_bank_entry(dt, dn): from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account doc = frappe.get_doc(dt, dn) payment_account = get_default_bank_cash_account( doc.company, account_type="Cash", mode_of_payment=doc.mode_of_payment) je = frappe.new_doc("Journal Entry") je.posting_date = nowdate() je.voucher_type = 'Bank Entry' je.company = doc.company je.remark = 'Payment against Employee Advance: ' + dn + '\n' + doc.purpose je.append( "accounts", { "account": doc.advance_account, "debit_in_account_currency": flt(doc.advance_amount), "reference_type": "Employee Advance", "reference_name": doc.name, "party_type": "Employee", "party": doc.employee, "is_advance": "Yes" }) je.append( "accounts", { "account": payment_account.account, "credit_in_account_currency": flt(doc.advance_amount), "account_currency": payment_account.account_currency, "account_type": payment_account.account_type }) return je.as_dict()
def make_bank_entry(docname): from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account expense_claim = frappe.get_doc("Expense Claim", docname) default_bank_cash_account = get_default_bank_cash_account(expense_claim.company, "Bank") je = frappe.new_doc("Journal Entry") je.voucher_type = 'Bank Entry' je.company = expense_claim.company je.remark = 'Payment against Expense Claim: ' + docname; for expense in expense_claim.expenses: je.append("accounts", { "account": expense.default_account, "debit_in_account_currency": expense.sanctioned_amount, "reference_type": "Expense Claim", "reference_name": expense_claim.name }) je.append("accounts", { "account": default_bank_cash_account.account, "credit_in_account_currency": expense_claim.total_sanctioned_amount, "reference_type": "Expense Claim", "reference_name": expense_claim.name, "balance": default_bank_cash_account.balance, "account_currency": default_bank_cash_account.account_currency, "account_type": default_bank_cash_account.account_type }) return je.as_dict()
def make_bank_entry(dt, dn): from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account doc = frappe.get_doc(dt, dn) payment_account = get_default_bank_cash_account(doc.company, account_type="Cash", mode_of_payment=doc.mode_of_payment) je = frappe.new_doc("Journal Entry") je.posting_date = nowdate() je.voucher_type = 'Bank Entry' je.company = doc.company je.remark = 'Payment against Employee Advance: ' + dn + '\n' + doc.purpose je.append("accounts", { "account": doc.advance_account, "debit_in_account_currency": flt(doc.advance_amount), "reference_type": "Employee Advance", "reference_name": doc.name, "party_type": "Employee", "party": doc.employee, "is_advance": "Yes" }) je.append("accounts", { "account": payment_account.account, "credit_in_account_currency": flt(doc.advance_amount), "account_currency": payment_account.account_currency, "account_type": payment_account.account_type }) return je.as_dict()
def make_bank_entry(dt, dn): from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account expense_claim = frappe.get_doc(dt, dn) default_bank_cash_account = get_default_bank_cash_account(expense_claim.company, "Bank") if not default_bank_cash_account: default_bank_cash_account = get_default_bank_cash_account(expense_claim.company, "Cash") payable_amount = ( flt(expense_claim.total_sanctioned_amount) - flt(expense_claim.total_amount_reimbursed) - flt(expense_claim.total_advance_amount) ) je = frappe.new_doc("Journal Entry") je.voucher_type = "Bank Entry" je.company = expense_claim.company je.remark = "Payment against Expense Claim: " + dn je.append( "accounts", { "account": expense_claim.payable_account, "debit_in_account_currency": payable_amount, "reference_type": "Expense Claim", "party_type": "Employee", "party": expense_claim.employee, "cost_center": erpnext.get_default_cost_center(expense_claim.company), "reference_name": expense_claim.name, }, ) je.append( "accounts", { "account": default_bank_cash_account.account, "credit_in_account_currency": payable_amount, "reference_type": "Expense Claim", "reference_name": expense_claim.name, "balance": default_bank_cash_account.balance, "account_currency": default_bank_cash_account.account_currency, "cost_center": erpnext.get_default_cost_center(expense_claim.company), "account_type": default_bank_cash_account.account_type, }, ) return je.as_dict()
def make_bank_entry(dt, dn): doc = frappe.get_doc(dt, dn) payment_account = get_default_bank_cash_account( doc.company, account_type="Cash", mode_of_payment=doc.mode_of_payment) if not payment_account: frappe.throw( _("Please set a Default Cash Account in Company defaults")) advance_account_currency = frappe.db.get_value("Account", doc.advance_account, "account_currency") advance_amount, advance_exchange_rate = get_advance_amount_advance_exchange_rate( advance_account_currency, doc) paying_amount, paying_exchange_rate = get_paying_amount_paying_exchange_rate( payment_account, doc) je = frappe.new_doc("Journal Entry") je.posting_date = nowdate() je.voucher_type = "Bank Entry" je.company = doc.company je.remark = "Payment against Employee Advance: " + dn + "\n" + doc.purpose je.multi_currency = 1 if advance_account_currency != payment_account.account_currency else 0 je.append( "accounts", { "account": doc.advance_account, "account_currency": advance_account_currency, "exchange_rate": flt(advance_exchange_rate), "debit_in_account_currency": flt(advance_amount), "reference_type": "Employee Advance", "reference_name": doc.name, "party_type": "Employee", "cost_center": erpnext.get_default_cost_center(doc.company), "party": doc.employee, "is_advance": "Yes", }, ) je.append( "accounts", { "account": payment_account.account, "cost_center": erpnext.get_default_cost_center(doc.company), "credit_in_account_currency": flt(paying_amount), "account_currency": payment_account.account_currency, "account_type": payment_account.account_type, "exchange_rate": flt(paying_exchange_rate), }, ) return je.as_dict()
def add_bank_accounts(response, bank, company): try: response = json.loads(response) except TypeError: pass bank = json.loads(bank) result = [] default_gl_account = get_default_bank_cash_account(company, "Bank") if not default_gl_account: frappe.throw( _("Please setup a default bank account for company {0}").format(company)) for account in response["accounts"]: acc_type = frappe.db.get_value("Bank Account Type", account["type"]) if not acc_type: add_account_type(account["type"]) acc_subtype = frappe.db.get_value( "Bank Account Subtype", account["subtype"]) if not acc_subtype: add_account_subtype(account["subtype"]) if not frappe.db.exists("Bank Account", dict(integration_id=account["id"])): try: new_account = frappe.get_doc({ "doctype": "Bank Account", "bank": bank["bank_name"], "account": default_gl_account.account, "account_name": account["name"], "account_type": account["type"] or "", "account_subtype": account["subtype"] or "", "mask": account["mask"] or "", "integration_id": account["id"], "is_company_account": 1, "company": company }) new_account.insert() result.append(new_account.name) except frappe.UniqueValidationError: frappe.msgprint( _("Bank account {0} already exists and could not be created again").format(account["name"])) except Exception: frappe.throw(frappe.get_traceback()) else: result.append(frappe.db.get_value("Bank Account", dict(integration_id=account["id"]), "name")) return result
def _get_empty_payment_entry(customer): company = frappe.defaults.get_user_default("company") mode_of_payment = "Cash" company_account = get_default_bank_cash_account( company, "Cash", mode_of_payment=mode_of_payment, ) party_account = get_party_account("Customer", customer, company) party_account_currency = get_account_currency(party_account) pe = frappe.new_doc("Payment Entry") pe.update({ "doctype": "Payment Entry", "payment_type": "Receive", "company": company, "cost_center": frappe.get_cached_value("Company", company, "cost_center"), "posting_date": frappe.utils.nowdate(), "mode_of_payment": mode_of_payment, "party_type": "Customer", "party": customer, "paid_from": party_account, "paid_to": company_account.account, "paid_from_account_currency": party_account_currency, "paid_to_account_currency": company_account.account_currency, "paid_amount": 0, "received_amount": 0, }) pe.setup_party_account_field() pe.set_missing_values() if party_account and company_account: pe.set_exchange_rate() pe.set_amounts() return pe
def add_bank_accounts(response, bank, company): response = json.loads(response) if not "accounts" in response else response bank = json.loads(bank) result = [] default_gl_account = get_default_bank_cash_account(company, "Bank") if not default_gl_account: frappe.throw(_("Please setup a default bank account for company {0}".format(company))) for account in response["accounts"]: acc_type = frappe.db.get_value("Account Type", account["type"]) if not acc_type: add_account_type(account["type"]) acc_subtype = frappe.db.get_value("Account Subtype", account["subtype"]) if not acc_subtype: add_account_subtype(account["subtype"]) if not frappe.db.exists("Bank Account", dict(integration_id=account["id"])): try: new_account = frappe.get_doc({ "doctype": "Bank Account", "bank": bank["bank_name"], "account": default_gl_account.account, "account_name": account["name"], "account_type": account["type"] or "", "account_subtype": account["subtype"] or "", "mask": account["mask"] or "", "integration_id": account["id"], "is_company_account": 1, "company": company }) new_account.insert() result.append(new_account.name) except frappe.UniqueValidationError: frappe.msgprint(_("Bank account {0} already exists and could not be created again").format(new_account.account_name)) except Exception: frappe.throw(frappe.get_traceback()) else: result.append(frappe.db.get_value("Bank Account", dict(integration_id=account["id"]), "name")) return result
def make_bank_entry(dt, dn): doc = frappe.get_doc(dt, dn) company = erpnext.get_default_company() payment_account = get_default_bank_cash_account( company, account_type="Cash", mode_of_payment=doc.mode_of_payment) je = frappe.new_doc("Journal Entry") je.posting_date = nowdate() je.voucher_type = 'Bank Entry' je.company = company je.remark = 'Payment against Cash Advance Request: ' + dn + '\n' + doc.description if doc.description else "" je.mode_of_payment = doc.mode_of_payment cost_center = doc.cost_center if doc.cost_center else erpnext.get_default_cost_center( doc.company) je.append( "accounts", { "account": doc.advance_account, "debit_in_account_currency": flt(doc.credit_in_account_currency), "reference_type": "Cash Advance Request", "reference_name": doc.name, "party_type": "Employee", "cost_center": cost_center, "party": doc.employee, "is_advance": "Yes" }) je.append( "accounts", { "account": payment_account.account, "cost_center": cost_center, "credit_in_account_currency": flt(doc.credit_in_account_currency), "account_currency": payment_account.account_currency, "account_type": payment_account.account_type }) return je.as_dict()
def get_payment_entry(dt, dn, party_amount=None, bank_account=None, bank_amount=None): doc = frappe.get_doc(dt, dn) if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) > 0: frappe.throw(_("Can only make payment against unbilled {0}").format(dt)) party_type = "Customer" if dt in ("Sales Invoice", "Sales Order") else "Supplier" # party account if dt == "Sales Invoice": party_account = doc.debit_to elif dt == "Purchase Invoice": party_account = doc.credit_to else: party_account = get_party_account(party_type, doc.get(party_type.lower()), doc.company) party_account_currency = doc.get("party_account_currency") or get_account_currency(party_account) # payment type if (dt == "Sales Order" or (dt=="Sales Invoice" and doc.outstanding_amount > 0)) \ or (dt=="Purchase Invoice" and doc.outstanding_amount < 0): payment_type = "Receive" else: payment_type = "Pay" # amounts grand_total = outstanding_amount = 0 if party_amount: grand_total = outstanding_amount = party_amount elif dt in ("Sales Invoice", "Purchase Invoice"): grand_total = doc.grand_total outstanding_amount = doc.outstanding_amount else: total_field = "base_grand_total" if party_account_currency == doc.company_currency else "grand_total" grand_total = flt(doc.get(total_field)) outstanding_amount = grand_total - flt(doc.advance_paid) # bank or cash bank = get_default_bank_cash_account(doc.company, "Bank", mode_of_payment=doc.get("mode_of_payment"), account=bank_account) paid_amount = received_amount = 0 if party_account_currency == bank.account_currency: paid_amount = received_amount = abs(outstanding_amount) elif payment_type == "Receive": paid_amount = abs(outstanding_amount) if bank_amount: received_amount = bank_amount else: received_amount = abs(outstanding_amount) if bank_amount: paid_amount = bank_amount pe = frappe.new_doc("Payment Entry") pe.payment_type = payment_type pe.company = doc.company pe.posting_date = nowdate() pe.mode_of_payment = doc.get("mode_of_payment") pe.party_type = party_type pe.party = doc.get(scrub(party_type)) pe.paid_from = party_account if payment_type=="Receive" else bank.account pe.paid_to = party_account if payment_type=="Pay" else bank.account pe.paid_from_account_currency = party_account_currency \ if payment_type=="Receive" else bank.account_currency pe.paid_to_account_currency = party_account_currency if payment_type=="Pay" else bank.account_currency pe.paid_amount = paid_amount pe.received_amount = received_amount pe.allocate_payment_amount = 1 pe.append("references", { "reference_doctype": dt, "reference_name": dn, "due_date": doc.get("due_date"), "total_amount": grand_total, "outstanding_amount": outstanding_amount, "allocated_amount": outstanding_amount }) pe.setup_party_account_field() pe.set_missing_values() if party_account and bank: pe.set_exchange_rate() pe.set_amounts() return pe
def test_new_transaction(self): if not frappe.db.exists("Bank", "Citi"): frappe.get_doc({"doctype": "Bank", "bank_name": "Citi"}).insert() bank_accounts = { 'account': { 'subtype': 'checking', 'mask': '0000', 'type': 'depository', 'id': '6GbM6RRQgdfy3lAqGz4JUnpmR948WZFg8DjQK', 'name': 'Plaid Checking' }, 'account_id': '6GbM6RRQgdfy3lAqGz4JUnpmR948WZFg8DjQK', 'link_session_id': 'db673d75-61aa-442a-864f-9b3f174f3725', 'accounts': [{ 'type': 'depository', 'subtype': 'checking', 'mask': '0000', 'id': '6GbM6RRQgdfy3lAqGz4JUnpmR948WZFg8DjQK', 'name': 'Plaid Checking' }], 'institution': { 'institution_id': 'ins_6', 'name': 'Citi' } } bank = json.dumps(frappe.get_doc("Bank", "Citi").as_dict(), default=json_handler) company = frappe.db.get_single_value('Global Defaults', 'default_company') if frappe.db.get_value("Company", company, "default_bank_account") is None: frappe.db.set_value( "Company", company, "default_bank_account", get_default_bank_cash_account(company, "Cash").get("account")) add_bank_accounts(bank_accounts, bank, company) transactions = { 'account_owner': None, 'category': ['Food and Drink', 'Restaurants'], 'account_id': 'b4Jkp1LJDZiPgojpr1ansXJrj5Q6w9fVmv6ov', 'pending_transaction_id': None, 'transaction_id': 'x374xPa7DvUewqlR5mjNIeGK8r8rl3Sn647LM', 'unofficial_currency_code': None, 'name': 'INTRST PYMNT', 'transaction_type': 'place', 'amount': -4.22, 'location': { 'city': None, 'zip': None, 'store_number': None, 'lon': None, 'state': None, 'address': None, 'lat': None }, 'payment_meta': { 'reference_number': None, 'payer': None, 'payment_method': None, 'reason': None, 'payee': None, 'ppd_id': None, 'payment_processor': None, 'by_order_of': None }, 'date': '2017-12-22', 'category_id': '13005000', 'pending': False, 'iso_currency_code': 'USD' } new_bank_transaction(transactions) self.assertTrue(len(frappe.get_all("Bank Transaction")) == 1)
def get_payment_entry(dt, dn, party_amount=None, bank_account=None, bank_amount=None): doc = frappe.get_doc(dt, dn) if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) > 0: frappe.throw(_("Can only make payment against unbilled {0}").format(dt)) if dt in ("Sales Invoice", "Sales Order"): party_type = "Customer" elif dt in ("Purchase Invoice", "Purchase Order"): party_type = "Supplier" elif dt in ("Expense Claim", "Employee Advance"): party_type = "Employee" elif dt in ("Fees"): party_type = "Student" # party account if dt == "Sales Invoice": party_account = doc.debit_to elif dt == "Purchase Invoice": party_account = doc.credit_to elif dt == "Fees": party_account = doc.receivable_account elif dt == "Employee Advance": party_account = doc.advance_account else: party_account = get_party_account(party_type, doc.get(party_type.lower()), doc.company) party_account_currency = doc.get("party_account_currency") or get_account_currency(party_account) # payment type if (dt == "Sales Order" or (dt in ("Sales Invoice", "Fees") and doc.outstanding_amount > 0)) \ or (dt=="Purchase Invoice" and doc.outstanding_amount < 0): payment_type = "Receive" else: payment_type = "Pay" # amounts grand_total = outstanding_amount = 0 if party_amount: grand_total = outstanding_amount = party_amount elif dt in ("Sales Invoice", "Purchase Invoice"): if party_account_currency == doc.company_currency: grand_total = doc.base_rounded_total or doc.base_grand_total else: grand_total = doc.rounded_total or doc.grand_total outstanding_amount = doc.outstanding_amount elif dt in ("Expense Claim"): grand_total = doc.total_sanctioned_amount outstanding_amount = doc.total_sanctioned_amount \ - doc.total_amount_reimbursed - flt(doc.total_advance_amount) elif dt == "Employee Advance": grand_total = doc.advance_amount outstanding_amount = flt(doc.advance_amount) - flt(doc.paid_amount) elif dt == "Fees": grand_total = doc.grand_total outstanding_amount = doc.outstanding_amount else: if party_account_currency == doc.company_currency: grand_total = flt(doc.get("base_rounded_total") or doc.base_grand_total) else: grand_total = flt(doc.get("rounded_total") or doc.grand_total) outstanding_amount = grand_total - flt(doc.advance_paid) # bank or cash bank = get_default_bank_cash_account(doc.company, "Bank", mode_of_payment=doc.get("mode_of_payment"), account=bank_account) paid_amount = received_amount = 0 if party_account_currency == bank.account_currency: paid_amount = received_amount = abs(outstanding_amount) elif payment_type == "Receive": paid_amount = abs(outstanding_amount) if bank_amount: received_amount = bank_amount else: received_amount = abs(outstanding_amount) if bank_amount: paid_amount = bank_amount pe = frappe.new_doc("Payment Entry") pe.payment_type = payment_type pe.company = doc.company pe.posting_date = nowdate() pe.mode_of_payment = doc.get("mode_of_payment") pe.party_type = party_type pe.party = doc.get(scrub(party_type)) pe.paid_from = party_account if payment_type=="Receive" else bank.account pe.paid_to = party_account if payment_type=="Pay" else bank.account pe.paid_from_account_currency = party_account_currency \ if payment_type=="Receive" else bank.account_currency pe.paid_to_account_currency = party_account_currency if payment_type=="Pay" else bank.account_currency pe.paid_amount = paid_amount pe.received_amount = received_amount pe.allocate_payment_amount = 1 pe.letter_head = doc.get("letter_head") pe.append("references", { 'reference_doctype': dt, 'reference_name': dn, "bill_no": doc.get("bill_no"), "due_date": doc.get("due_date"), 'total_amount': grand_total, 'outstanding_amount': outstanding_amount, 'allocated_amount': outstanding_amount }) pe.setup_party_account_field() pe.set_missing_values() if party_account and bank: pe.set_exchange_rate() pe.set_amounts() return pe
def post_accounts_entry(self): employee = frappe.get_doc("Employee", self.employee) default_bank_cash_account = get_default_bank_cash_account(employee.company, "Bank") sal_struc_name = self.get_salary_structure() #le = get_le_settings(["expense_account", "tax_account"]) le = get_le_settings() if sal_struc_name: sal_struc= frappe.get_doc("Salary Structure",sal_struc_name) for d in sal_struc.earnings: if d.salary_component == 'Basic Pay': basic_pay = flt(d.amount) else: frappe.throw(_("No Active salary structure found.")) if basic_pay: salary_tax = get_salary_tax(basic_pay) salary_tax = flt(salary_tax) if salary_tax else 0.00 je = frappe.new_doc("Journal Entry") je.flags.ignore_permissions = 1 je.title = 'Leave Encashment - '+str(employee.employee_name) je.voucher_type = 'Bank Entry' je.naming_series = 'Bank Payment Voucher' je.company = employee.company je.remark = 'Payment against Leave Encashment: ' + self.name; je.posting_date = self.application_date je.total_amount_in_words = money_in_words(flt(basic_pay)-flt(salary_tax)) je.append("accounts", { "account": le.expense_account, "debit_in_account_currency": flt(basic_pay), "reference_type": "Leave Encashment", "reference_name": self.name, #"party_type": "Employee", #"party": self.employee, "cost_center": self.cost_center, "party_check": 0 }) je.append("accounts", { "account": le.tax_account, "credit_in_account_currency": flt(salary_tax), "reference_type": "Leave Encashment", "reference_name": self.name, #"party_type": "Employee", #"party": self.employee, "cost_center": self.cost_center, "party_check": 0 }) je.append("accounts", { "account": "Sundry Creditors - Employee - SMCL", "debit_in_account_currency": flt(basic_pay), "reference_type": "Leave Encashment", "reference_name": self.name, "party_type": "Employee", "party": self.employee, "cost_center": self.cost_center, "party_check": 0 }) je.append("accounts", { "account": "Sundry Creditors - Employee - SMCL", "credit_in_account_currency": flt(basic_pay), "reference_type": "Leave Encashment", "reference_name": self.name, "party_type": "Employee", "party": self.employee, "cost_center": self.cost_center, "party_check": 0 }) je.append("accounts", { "account": default_bank_cash_account.account, "credit_in_account_currency": (flt(basic_pay)-flt(salary_tax)), "reference_type": "Leave Encashment", "reference_name": self.name, "balance": default_bank_cash_account.balance, "account_currency": default_bank_cash_account.account_currency, "account_type": default_bank_cash_account.account_type, "cost_center": self.cost_center }) je.insert() self.db_set("encash_journal", je.name) self.db_set("encashment_amount", flt(basic_pay)) self.db_set("tax_amount", flt(salary_tax))
def test_new_transaction(self): if not frappe.db.exists("Bank", "Citi"): frappe.get_doc({"doctype": "Bank", "bank_name": "Citi"}).insert() bank_accounts = { "account": { "subtype": "checking", "mask": "0000", "type": "depository", "id": "6GbM6RRQgdfy3lAqGz4JUnpmR948WZFg8DjQK", "name": "Plaid Checking", }, "account_id": "6GbM6RRQgdfy3lAqGz4JUnpmR948WZFg8DjQK", "link_session_id": "db673d75-61aa-442a-864f-9b3f174f3725", "accounts": [ { "type": "depository", "subtype": "checking", "mask": "0000", "id": "6GbM6RRQgdfy3lAqGz4JUnpmR948WZFg8DjQK", "name": "Plaid Checking", } ], "institution": {"institution_id": "ins_6", "name": "Citi"}, } bank = json.dumps(frappe.get_doc("Bank", "Citi").as_dict(), default=json_handler) company = frappe.db.get_single_value("Global Defaults", "default_company") if frappe.db.get_value("Company", company, "default_bank_account") is None: frappe.db.set_value( "Company", company, "default_bank_account", get_default_bank_cash_account(company, "Cash").get("account"), ) add_bank_accounts(bank_accounts, bank, company) transactions = { "account_owner": None, "category": ["Food and Drink", "Restaurants"], "account_id": "b4Jkp1LJDZiPgojpr1ansXJrj5Q6w9fVmv6ov", "pending_transaction_id": None, "transaction_id": "x374xPa7DvUewqlR5mjNIeGK8r8rl3Sn647LM", "unofficial_currency_code": None, "name": "INTRST PYMNT", "transaction_type": "place", "amount": -4.22, "location": { "city": None, "zip": None, "store_number": None, "lon": None, "state": None, "address": None, "lat": None, }, "payment_meta": { "reference_number": None, "payer": None, "payment_method": None, "reason": None, "payee": None, "ppd_id": None, "payment_processor": None, "by_order_of": None, }, "date": "2017-12-22", "category_id": "13005000", "pending": False, "iso_currency_code": "USD", } new_bank_transaction(transactions) self.assertTrue(len(frappe.get_all("Bank Transaction")) == 1)
def test_new_transaction(self): if not frappe.db.exists("Bank", "Citi"): frappe.get_doc({ "doctype": "Bank", "bank_name": "Citi" }).insert() bank_accounts = { 'account': { 'subtype': 'checking', 'mask': '0000', 'type': 'depository', 'id': '6GbM6RRQgdfy3lAqGz4JUnpmR948WZFg8DjQK', 'name': 'Plaid Checking' }, 'account_id': '6GbM6RRQgdfy3lAqGz4JUnpmR948WZFg8DjQK', 'link_session_id': 'db673d75-61aa-442a-864f-9b3f174f3725', 'accounts': [{ 'type': 'depository', 'subtype': 'checking', 'mask': '0000', 'id': '6GbM6RRQgdfy3lAqGz4JUnpmR948WZFg8DjQK', 'name': 'Plaid Checking' }], 'institution': { 'institution_id': 'ins_6', 'name': 'Citi' } } bank = json.dumps(frappe.get_doc("Bank", "Citi").as_dict(), default=json_handler) company = frappe.db.get_single_value('Global Defaults', 'default_company') if frappe.db.get_value("Company", company, "default_bank_account") is None: frappe.db.set_value("Company", company, "default_bank_account", get_default_bank_cash_account(company, "Cash").get("account")) add_bank_accounts(bank_accounts, bank, company) transactions = { 'account_owner': None, 'category': ['Food and Drink', 'Restaurants'], 'account_id': 'b4Jkp1LJDZiPgojpr1ansXJrj5Q6w9fVmv6ov', 'pending_transaction_id': None, 'transaction_id': 'x374xPa7DvUewqlR5mjNIeGK8r8rl3Sn647LM', 'unofficial_currency_code': None, 'name': 'INTRST PYMNT', 'transaction_type': 'place', 'amount': -4.22, 'location': { 'city': None, 'zip': None, 'store_number': None, 'lon': None, 'state': None, 'address': None, 'lat': None }, 'payment_meta': { 'reference_number': None, 'payer': None, 'payment_method': None, 'reason': None, 'payee': None, 'ppd_id': None, 'payment_processor': None, 'by_order_of': None }, 'date': '2017-12-22', 'category_id': '13005000', 'pending': False, 'iso_currency_code': 'USD' } new_bank_transaction(transactions) self.assertTrue(len(frappe.get_all("Bank Transaction")) == 1)
def get_payment_entry(dt, dn, party_amount=None, bank_account=None, bank_amount=None): doc = frappe.get_doc(dt, dn) if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) > 0: frappe.throw(_("Can only make payment against unbilled {0}").format(dt)) if dt in ("Sales Invoice", "Sales Order"): party_type = "Customer" elif dt in ("Purchase Invoice", "Purchase Order"): party_type = "Supplier" elif dt in ("Expense Claim", "Employee Advance"): party_type = "Employee" elif dt in ("Fees"): party_type = "Student" # party account if dt == "Sales Invoice": party_account = get_party_account_based_on_invoice_discounting(dn) or doc.debit_to elif dt == "Purchase Invoice": party_account = doc.credit_to elif dt == "Fees": party_account = doc.receivable_account elif dt == "Employee Advance": party_account = doc.advance_account elif dt == "Expense Claim": party_account = doc.payable_account else: party_account = get_party_account(party_type, doc.get(party_type.lower()), doc.company) if dt not in ("Sales Invoice", "Purchase Invoice"): party_account_currency = get_account_currency(party_account) else: party_account_currency = doc.get("party_account_currency") or get_account_currency(party_account) # payment type if (dt == "Sales Order" or (dt in ("Sales Invoice", "Fees") and doc.outstanding_amount > 0)) \ or (dt=="Purchase Invoice" and doc.outstanding_amount < 0): payment_type = "Receive" else: payment_type = "Pay" # amounts grand_total = outstanding_amount = exchange_rate = 0 if party_amount: grand_total = outstanding_amount = party_amount elif dt in ("Sales Invoice", "Purchase Invoice"): if party_account_currency == doc.company_currency: grand_total = doc.base_rounded_total or doc.base_grand_total else: grand_total = doc.rounded_total or doc.grand_total outstanding_amount = doc.outstanding_amount elif dt in ("Expense Claim"): grand_total = doc.total_sanctioned_amount + doc.total_taxes_and_charges outstanding_amount = doc.grand_total \ - doc.total_amount_reimbursed elif dt == "Employee Advance": grand_total = doc.advance_amount outstanding_amount = flt(doc.advance_amount) - flt(doc.paid_amount) elif dt == "Fees": grand_total = doc.grand_total outstanding_amount = doc.outstanding_amount else: if party_account_currency == doc.company_currency: grand_total = flt(doc.get("base_rounded_total") or doc.base_grand_total) else: grand_total = flt(doc.get("rounded_total") or doc.grand_total) outstanding_amount = grand_total - flt(doc.advance_paid) # bank or cash bank = get_default_bank_cash_account(doc.company, "Bank", mode_of_payment=doc.get("mode_of_payment"), account=bank_account) if not bank: bank = get_default_bank_cash_account(doc.company, "Cash", mode_of_payment=doc.get("mode_of_payment"), account=bank_account) paid_amount = received_amount = 0 if party_account_currency == bank.account_currency: paid_amount = received_amount = abs(outstanding_amount) elif payment_type == "Receive": paid_amount = abs(outstanding_amount) if bank_amount: received_amount = bank_amount else: received_amount = paid_amount * doc.conversion_rate else: received_amount = abs(outstanding_amount) if bank_amount: paid_amount = bank_amount else: # if party account currency and bank currency is different then populate paid amount as well paid_amount = received_amount / doc.conversion_rate exchange_rate = doc.conversion_rate pe = frappe.new_doc("Payment Entry") pe.payment_type = payment_type pe.company = doc.company pe.cost_center = doc.get("cost_center") pe.posting_date = nowdate() pe.mode_of_payment = doc.get("mode_of_payment") pe.party_type = party_type pe.party = doc.get(scrub(party_type)) pe.contact_person = doc.get("contact_person") pe.contact_email = doc.get("contact_email") pe.ensure_supplier_is_not_blocked() pe.paid_from = party_account if payment_type=="Receive" else bank.account pe.paid_to = party_account if payment_type=="Pay" else bank.account pe.paid_from_account_currency = party_account_currency \ if payment_type=="Receive" else bank.account_currency pe.paid_to_account_currency = party_account_currency if payment_type=="Pay" else bank.account_currency pe.paid_amount = paid_amount pe.received_amount = received_amount pe.letter_head = doc.get("letter_head") if payment_type=='Pay' and exchange_rate != 0: pe.source_exchange_rate = exchange_rate if pe.party_type in ["Customer", "Supplier"]: bank_account = get_party_bank_account(pe.party_type, pe.party) pe.set("bank_account", bank_account) pe.set_bank_account_data() # only Purchase Invoice can be blocked individually if doc.doctype == "Purchase Invoice" and doc.invoice_is_blocked(): frappe.msgprint(_('{0} is on hold till {1}'.format(doc.name, doc.release_date))) else: if (doc.doctype in ('Sales Invoice', 'Purchase Invoice') and frappe.get_value('Payment Terms Template', {'name': doc.payment_terms_template}, 'allocate_payment_based_on_payment_terms')): for reference in get_reference_as_per_payment_terms(doc.payment_schedule, dt, dn, doc, grand_total, outstanding_amount): pe.append('references', reference) else: pe.append("references", { 'reference_doctype': dt, 'reference_name': dn, "bill_no": doc.get("bill_no"), "due_date": doc.get("due_date"), 'total_amount': grand_total, 'outstanding_amount': outstanding_amount, 'allocated_amount': outstanding_amount }) pe.setup_party_account_field() pe.set_missing_values() if party_account and bank: pe.set_exchange_rate() pe.set_amounts() return pe
def make_return_entry( employee, company, employee_advance_name, return_amount, advance_account, currency, exchange_rate, mode_of_payment=None, ): bank_cash_account = get_default_bank_cash_account( company, account_type="Cash", mode_of_payment=mode_of_payment) if not bank_cash_account: frappe.throw( _("Please set a Default Cash Account in Company defaults")) advance_account_currency = frappe.db.get_value("Account", advance_account, "account_currency") je = frappe.new_doc("Journal Entry") je.posting_date = nowdate() je.voucher_type = get_voucher_type(mode_of_payment) je.company = company je.remark = "Return against Employee Advance: " + employee_advance_name je.multi_currency = 1 if advance_account_currency != bank_cash_account.account_currency else 0 advance_account_amount = (flt(return_amount) if advance_account_currency == currency else flt(return_amount) * flt(exchange_rate)) je.append( "accounts", { "account": advance_account, "credit_in_account_currency": advance_account_amount, "account_currency": advance_account_currency, "exchange_rate": flt(exchange_rate) if advance_account_currency == currency else 1, "reference_type": "Employee Advance", "reference_name": employee_advance_name, "party_type": "Employee", "party": employee, "is_advance": "Yes", "cost_center": erpnext.get_default_cost_center(company), }, ) bank_amount = (flt(return_amount) if bank_cash_account.account_currency == currency else flt(return_amount) * flt(exchange_rate)) je.append( "accounts", { "account": bank_cash_account.account, "debit_in_account_currency": bank_amount, "account_currency": bank_cash_account.account_currency, "account_type": bank_cash_account.account_type, "exchange_rate": flt(exchange_rate) if bank_cash_account.account_currency == currency else 1, "cost_center": erpnext.get_default_cost_center(company), }, ) return je.as_dict()
def make_return_entry(employee, company, employee_advance_name, return_amount, advance_account, currency, exchange_rate, mode_of_payment=None): bank_cash_account = get_default_bank_cash_account( company, account_type='Cash', mode_of_payment=mode_of_payment) if not bank_cash_account: frappe.throw( _("Please set a Default Cash Account in Company defaults")) advance_account_currency = frappe.db.get_value('Account', advance_account, 'account_currency') je = frappe.new_doc('Journal Entry') je.posting_date = nowdate() je.voucher_type = get_voucher_type(mode_of_payment) je.company = company je.remark = 'Return against Employee Advance: ' + employee_advance_name je.multi_currency = 1 if advance_account_currency != bank_cash_account.account_currency else 0 advance_account_amount = flt(return_amount) if advance_account_currency==currency \ else flt(return_amount) * flt(exchange_rate) je.append( 'accounts', { 'account': advance_account, 'credit_in_account_currency': advance_account_amount, 'account_currency': advance_account_currency, 'exchange_rate': flt(exchange_rate) if advance_account_currency == currency else 1, 'reference_type': 'Employee Advance', 'reference_name': employee_advance_name, 'party_type': 'Employee', 'party': employee, 'is_advance': 'Yes' }) bank_amount = flt(return_amount) if bank_cash_account.account_currency==currency \ else flt(return_amount) * flt(exchange_rate) je.append( "accounts", { "account": bank_cash_account.account, "debit_in_account_currency": bank_amount, "account_currency": bank_cash_account.account_currency, "account_type": bank_cash_account.account_type, "exchange_rate": flt(exchange_rate) if bank_cash_account.account_currency == currency else 1 }) return je.as_dict()
def get_payment_entry(dt, dn, party_amount=None, bank_account=None, bank_amount=None): doc = frappe.get_doc(dt, dn) if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) > 0: frappe.throw( _("Can only make payment against unbilled {0}").format(dt)) party_type = "Customer" if dt in ("Sales Invoice", "Sales Order") else "Supplier" # party account if dt == "Sales Invoice": party_account = doc.debit_to elif dt == "Purchase Invoice": party_account = doc.credit_to else: party_account = get_party_account(party_type, doc.get(party_type.lower()), doc.company) party_account_currency = doc.get( "party_account_currency") or get_account_currency(party_account) # payment type if (dt == "Sales Order" or (dt=="Sales Invoice" and doc.outstanding_amount > 0)) \ or (dt=="Purchase Invoice" and doc.outstanding_amount < 0): payment_type = "Receive" else: payment_type = "Pay" # amounts grand_total = outstanding_amount = 0 if party_amount: grand_total = outstanding_amount = party_amount elif dt in ("Sales Invoice", "Purchase Invoice"): grand_total = doc.grand_total outstanding_amount = doc.outstanding_amount else: total_field = "base_grand_total" if party_account_currency == doc.company_currency else "grand_total" grand_total = flt(doc.get(total_field)) outstanding_amount = grand_total - flt(doc.advance_paid) # bank or cash bank = get_default_bank_cash_account( doc.company, "Bank", mode_of_payment=doc.get("mode_of_payment"), account=bank_account) paid_amount = received_amount = 0 if party_account_currency == bank.account_currency: paid_amount = received_amount = abs(outstanding_amount) elif payment_type == "Receive": paid_amount = abs(outstanding_amount) if bank_amount: received_amount = bank_amount else: received_amount = abs(outstanding_amount) if bank_amount: paid_amount = bank_amount pe = frappe.new_doc("Payment Entry") pe.payment_type = payment_type pe.company = doc.company pe.posting_date = nowdate() pe.mode_of_payment = doc.get("mode_of_payment") pe.party_type = party_type pe.party = doc.get(scrub(party_type)) pe.paid_from = party_account if payment_type == "Receive" else bank.account pe.paid_to = party_account if payment_type == "Pay" else bank.account pe.paid_from_account_currency = party_account_currency \ if payment_type=="Receive" else bank.account_currency pe.paid_to_account_currency = party_account_currency if payment_type == "Pay" else bank.account_currency pe.paid_amount = paid_amount pe.received_amount = received_amount pe.allocate_payment_amount = 1 pe.append( "references", { "reference_doctype": dt, "reference_name": dn, "due_date": doc.get("due_date"), "total_amount": grand_total, "outstanding_amount": outstanding_amount, "allocated_amount": outstanding_amount }) pe.setup_party_account_field() pe.set_missing_values() if party_account and bank: pe.set_exchange_rate() pe.set_amounts() return pe
def make_bank_entry(docname): from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account expense_claim = frappe.get_doc("Expense Claim", docname) default_bank_cash_account = get_default_bank_cash_account(expense_claim.company, "Bank") # Ver 1.0 by SSK on 10/08/2016, fetching cost_center for the employee #msgprint(expense_claim.employee) cost_center = frappe.db.sql(""" select t2.cost_center from `tabEmployee` t1, `tabDivision` t2 where t2.name = t1.division and t2.dpt_name = t1.department and t2.branch = t1.branch and t1.name = '%s' """ % (expense_claim.employee)) # Ver 1.0 Ends, by SSK on 10/08/2016 je = frappe.new_doc("Journal Entry") je.title = 'Travel Claims - '+str(expense_claim.employee)+' '+str(expense_claim.employee_name) je.voucher_type = 'Bank Entry' je.naming_series = 'Bank Payment Voucher' je.company = expense_claim.company je.remark = 'Payment against Expense Claim: ' + docname; #je.posting_date = nowdate() je.posting_date = expense_claim.expense_date je.total_amount_in_words = money_in_words(expense_claim.total_sanctioned_amount) # Ver 1.0 Begins, added by SSK on 09/09/2016 # Following code is commented and the equivalet is passed ''' for expense in expense_claim.expenses: je.append("accounts", { "account": expense.default_account, "debit_in_account_currency": expense.sanctioned_amount, "reference_type": "Expense Claim", "reference_name": expense_claim.name, "party_type": "Employee", "party": expense_claim.employee, "cost_center": cost_center[0][0], "party_check": 0 }) ''' default_accounts = frappe.db.sql(""" select default_account, sum(ifnull(sanctioned_amount,0)) sanctioned_amount, sum(ifnull(advance_total_amount,0)) advance_amount from `tabExpense Claim Detail` where parent = '%s' group by default_account """ % (expense_claim.name), as_dict=True) for da in default_accounts: if flt(da.sanctioned_amount if da.sanctioned_amount else 0.00) > 0.00: je.append("accounts", { "account": da.default_account, "debit_in_account_currency": da.sanctioned_amount, "reference_type": "Expense Claim", "reference_name": expense_claim.name, "cost_center": cost_center[0][0], "party_check": 0 }) # Ver 1.0 Ends if flt(expense_claim.total_advance_amount if expense_claim.total_advance_amount else 0.00) > 0.00: je.append("accounts", { "account": "Advance to Employee-Travel - SMCL", "credit_in_account_currency": flt(expense_claim.total_advance_amount), "reference_type": "Expense Claim", "reference_name": expense_claim.name, "party_type": "Employee", "party": expense_claim.employee, "cost_center": cost_center[0][0], "party_check": 0 }) if flt(expense_claim.total_sanctioned_amount if expense_claim.total_sanctioned_amount else 0.00) > 0.00: je.append("accounts", { "account": "Sundry Creditors - Employee - SMCL", "debit_in_account_currency": expense_claim.total_sanctioned_amount, "reference_type": "Expense Claim", "reference_name": expense_claim.name, "party_type": "Employee", "party": expense_claim.employee, "cost_center": cost_center[0][0], "party_check": 0 }) je.append("accounts", { "account": "Sundry Creditors - Employee - SMCL", "credit_in_account_currency": expense_claim.total_sanctioned_amount, "reference_type": "Expense Claim", "reference_name": expense_claim.name, "party_type": "Employee", "party": expense_claim.employee, "cost_center": cost_center[0][0], "party_check": 0 }) je.append("accounts", { "account": default_bank_cash_account.account, "credit_in_account_currency": expense_claim.total_sanctioned_amount, "reference_type": "Expense Claim", "reference_name": expense_claim.name, "balance": default_bank_cash_account.balance, "account_currency": default_bank_cash_account.account_currency, "account_type": default_bank_cash_account.account_type, "cost_center": "Corporate Head Office - SMCL" }) je.insert() msgprint(_("Posting to Accounts Successful..."))
def post_accounts_entry(self): employee = frappe.get_doc("Employee", self.employee) default_bank_cash_account = get_default_bank_cash_account( employee.company, "Bank") sal_struc_name = self.get_salary_structure() #le = get_le_settings(["expense_account", "tax_account"]) le = get_le_settings() if sal_struc_name: sal_struc = frappe.get_doc("Salary Structure", sal_struc_name) for d in sal_struc.earnings: if d.salary_component == 'Basic Pay': basic_pay = flt(d.amount) else: frappe.throw(_("No Active salary structure found.")) if basic_pay: salary_tax = get_salary_tax(basic_pay) salary_tax = flt(salary_tax) if salary_tax else 0.00 je = frappe.new_doc("Journal Entry") je.flags.ignore_permissions = 1 je.title = 'Leave Encashment - ' + str(employee.employee_name) je.voucher_type = 'Bank Entry' je.naming_series = 'Bank Payment Voucher' je.company = employee.company je.remark = 'Payment against Leave Encashment: ' + self.name je.posting_date = self.application_date je.total_amount_in_words = money_in_words( flt(basic_pay) - flt(salary_tax)) je.append( "accounts", { "account": le.expense_account, "debit_in_account_currency": flt(basic_pay), "reference_type": "Leave Encashment", "reference_name": self.name, #"party_type": "Employee", #"party": self.employee, "cost_center": self.cost_center, "party_check": 0 }) je.append( "accounts", { "account": le.tax_account, "credit_in_account_currency": flt(salary_tax), "reference_type": "Leave Encashment", "reference_name": self.name, #"party_type": "Employee", #"party": self.employee, "cost_center": self.cost_center, "party_check": 0 }) je.append( "accounts", { "account": "Sundry Creditors - Employee - SMCL", "debit_in_account_currency": flt(basic_pay), "reference_type": "Leave Encashment", "reference_name": self.name, "party_type": "Employee", "party": self.employee, "cost_center": self.cost_center, "party_check": 0 }) je.append( "accounts", { "account": "Sundry Creditors - Employee - SMCL", "credit_in_account_currency": flt(basic_pay), "reference_type": "Leave Encashment", "reference_name": self.name, "party_type": "Employee", "party": self.employee, "cost_center": self.cost_center, "party_check": 0 }) je.append( "accounts", { "account": default_bank_cash_account.account, "credit_in_account_currency": (flt(basic_pay) - flt(salary_tax)), "reference_type": "Leave Encashment", "reference_name": self.name, "balance": default_bank_cash_account.balance, "account_currency": default_bank_cash_account.account_currency, "account_type": default_bank_cash_account.account_type, "cost_center": self.cost_center }) je.insert() self.db_set("encash_journal", je.name) self.db_set("encashment_amount", flt(basic_pay)) self.db_set("tax_amount", flt(salary_tax))
def get_payment_entry(dt, dn, party_amount=None, bank_account=None, bank_amount=None): doc = frappe.get_doc(dt, dn) if flt(doc.per_billed, 2) > 0: frappe.throw( _("Can only make payment against unbilled {0}").format(dt)) party_type = "Customer" # party account party_account = get_party_account(party_type, doc.get(party_type.lower()), doc.company) party_account_currency = doc.get( "party_account_currency") or get_account_currency(party_account) # payment type payment_type = "Receive" # amounts grand_total = outstanding_amount = 0 if party_amount: grand_total = outstanding_amount = party_amount else: if party_account_currency == doc.company_currency: grand_total = flt( doc.get("base_rounded_total") or doc.base_grand_total) else: grand_total = flt(doc.get("rounded_total") or doc.grand_total) outstanding_amount = grand_total - flt(doc.advance_paid) # bank or cash bank = get_default_bank_cash_account( doc.company, "Bank", mode_of_payment=doc.get("mode_of_payment"), account=bank_account) if not bank: bank = get_default_bank_cash_account( doc.company, "Cash", mode_of_payment=doc.get("mode_of_payment"), account=bank_account) paid_amount = received_amount = 0 if party_account_currency == bank.account_currency: paid_amount = received_amount = abs(outstanding_amount) elif payment_type == "Receive": paid_amount = abs(outstanding_amount) if bank_amount: received_amount = bank_amount else: received_amount = paid_amount * doc.get('conversion_rate', 1) else: received_amount = abs(outstanding_amount) if bank_amount: paid_amount = bank_amount else: # if party account currency and bank currency is different then populate paid amount as well paid_amount = received_amount * doc.get('conversion_rate', 1) pe = frappe.new_doc("Payment Entry") pe.payment_type = payment_type pe.company = doc.company pe.cost_center = doc.get("cost_center") pe.posting_date = nowdate() pe.mode_of_payment = doc.get("mode_of_payment") pe.party_type = party_type pe.party = doc.get(scrub(party_type)) pe.contact_person = doc.get("contact_person") pe.contact_email = doc.get("contact_email") pe.ensure_supplier_is_not_blocked() pe.paid_from = party_account if payment_type == "Receive" else bank.account pe.paid_to = party_account if payment_type == "Pay" else bank.account pe.paid_from_account_currency = party_account_currency \ if payment_type=="Receive" else bank.account_currency pe.paid_to_account_currency = party_account_currency if payment_type == "Pay" else bank.account_currency pe.paid_amount = paid_amount pe.received_amount = received_amount pe.letter_head = doc.get("letter_head") if pe.party_type in ["Customer", "Supplier"]: bank_account = get_party_bank_account(pe.party_type, pe.party) pe.set("bank_account", bank_account) pe.set_bank_account_data() # only Purchase Invoice can be blocked individually pe.append( "references", { 'reference_doctype': dt, 'reference_name': dn, "bill_no": doc.get("bill_no"), "due_date": doc.get("due_date"), 'total_amount': grand_total, 'outstanding_amount': outstanding_amount, 'allocated_amount': outstanding_amount }) pe.setup_party_account_field() pe.set_missing_values() if party_account and bank: pe.set_exchange_rate() pe.set_amounts() return pe
def get_payment_entry(dt, dn, party_amount=None, bank_account=None, bank_amount=None): doc = frappe.get_doc(dt, dn) if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) > 0: frappe.throw( _("Can only make payment against unbilled {0}").format(dt)) if dt in ("Sales Invoice", "Sales Order"): party_type = "Customer" elif dt in ("Purchase Invoice", "Purchase Order"): party_type = "Supplier" elif dt in ("Expense Claim", "Employee Advance"): party_type = "Employee" elif dt in ("Fees"): party_type = "Student" # party account if dt == "Sales Invoice": party_account = doc.debit_to elif dt == "Purchase Invoice": party_account = doc.credit_to elif dt == "Fees": party_account = doc.receivable_account elif dt == "Employee Advance": party_account = doc.advance_account elif dt == "Expense Claim": party_account = doc.payable_account else: party_account = get_party_account(party_type, doc.get(party_type.lower()), doc.company) party_account_currency = doc.get( "party_account_currency") or get_account_currency(party_account) # payment type if (dt == "Sales Order" or (dt in ("Sales Invoice", "Fees") and doc.outstanding_amount > 0)) \ or (dt=="Purchase Invoice" and doc.outstanding_amount < 0): payment_type = "Receive" else: payment_type = "Pay" # amounts grand_total = outstanding_amount = 0 if party_amount: grand_total = outstanding_amount = party_amount elif dt in ("Sales Invoice", "Purchase Invoice"): if party_account_currency == doc.company_currency: grand_total = doc.base_rounded_total or doc.base_grand_total else: grand_total = doc.rounded_total or doc.grand_total outstanding_amount = doc.outstanding_amount elif dt in ("Expense Claim"): grand_total = doc.total_sanctioned_amount outstanding_amount = doc.total_sanctioned_amount \ - doc.total_amount_reimbursed - flt(doc.total_advance_amount) elif dt == "Employee Advance": grand_total = doc.advance_amount outstanding_amount = flt(doc.advance_amount) - flt(doc.paid_amount) elif dt == "Fees": grand_total = doc.grand_total outstanding_amount = doc.outstanding_amount else: if party_account_currency == doc.company_currency: grand_total = flt( doc.get("base_rounded_total") or doc.base_grand_total) else: grand_total = flt(doc.get("rounded_total") or doc.grand_total) outstanding_amount = grand_total - flt(doc.advance_paid) # bank or cash bank = get_default_bank_cash_account( doc.company, "Bank", mode_of_payment=doc.get("mode_of_payment"), account=bank_account) paid_amount = received_amount = 0 if party_account_currency == bank.account_currency: paid_amount = received_amount = abs(outstanding_amount) elif payment_type == "Receive": paid_amount = abs(outstanding_amount) if bank_amount: received_amount = bank_amount else: received_amount = abs(outstanding_amount) if bank_amount: paid_amount = bank_amount pe = frappe.new_doc("Payment Entry") pe.payment_type = payment_type pe.company = doc.company pe.posting_date = nowdate() pe.mode_of_payment = doc.get("mode_of_payment") pe.party_type = party_type pe.party = doc.get(scrub(party_type)) pe.ensure_supplier_is_not_blocked() pe.paid_from = party_account if payment_type == "Receive" else bank.account pe.paid_to = party_account if payment_type == "Pay" else bank.account pe.paid_from_account_currency = party_account_currency \ if payment_type=="Receive" else bank.account_currency pe.paid_to_account_currency = party_account_currency if payment_type == "Pay" else bank.account_currency pe.paid_amount = paid_amount pe.received_amount = received_amount pe.allocate_payment_amount = 1 pe.letter_head = doc.get("letter_head") # only Purchase Invoice can be blocked individually if doc.doctype == "Purchase Invoice" and doc.invoice_is_blocked(): frappe.msgprint( _('{0} is on hold till {1}'.format(doc.name, doc.release_date))) else: pe.append( "references", { 'reference_doctype': dt, 'reference_name': dn, "bill_no": doc.get("bill_no"), "due_date": doc.get("due_date"), 'total_amount': grand_total, 'outstanding_amount': outstanding_amount, 'allocated_amount': outstanding_amount }) pe.setup_party_account_field() pe.set_missing_values() if party_account and bank: pe.set_exchange_rate() pe.set_amounts() return pe
def add_bank_accounts(response, bank, company): try: response = json.loads(response) except TypeError: pass bank = json.loads(bank) result = [] default_gl_account = get_default_bank_cash_account(company, "Bank") if not default_gl_account: frappe.throw( _("Please setup a default bank account for company {0}").format( company)) for account in response["accounts"]: acc_type = frappe.db.get_value("Bank Account Type", account["type"]) if not acc_type: add_account_type(account["type"]) acc_subtype = frappe.db.get_value("Bank Account Subtype", account["subtype"]) if not acc_subtype: add_account_subtype(account["subtype"]) bank_account_name = "{} - {}".format(account["name"], bank["bank_name"]) existing_bank_account = frappe.db.exists("Bank Account", bank_account_name) if not existing_bank_account: try: new_account = frappe.get_doc({ "doctype": "Bank Account", "bank": bank["bank_name"], "account": default_gl_account.account, "account_name": account["name"], "account_type": account.get("type", ""), "account_subtype": account.get("subtype", ""), "mask": account.get("mask", ""), "integration_id": account["id"], "is_company_account": 1, "company": company, }) new_account.insert() result.append(new_account.name) except frappe.UniqueValidationError: frappe.msgprint( _("Bank account {0} already exists and could not be created again" ).format(account["name"])) except Exception: frappe.log_error(frappe.get_traceback(), title=_("Plaid Link Error")) frappe.throw( _("There was an error creating Bank Account while linking with Plaid." ), title=_("Plaid Link Failed"), ) else: try: existing_account = frappe.get_doc("Bank Account", existing_bank_account) existing_account.update({ "bank": bank["bank_name"], "account_name": account["name"], "account_type": account.get("type", ""), "account_subtype": account.get("subtype", ""), "mask": account.get("mask", ""), "integration_id": account["id"], }) existing_account.save() result.append(existing_bank_account) except Exception: frappe.log_error(frappe.get_traceback(), title=_("Plaid Link Error")) frappe.throw( _("There was an error updating Bank Account {} while linking with Plaid." ).format(existing_bank_account), title=_("Plaid Link Failed"), ) return result