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
