def make_gl_entries(self):
gl_entries = []
net_pl_balance = 0
pl_accounts = self.get_pl_balances()
for acc in pl_accounts:
if flt(acc.balance_in_company_currency):
gl_entries.append(self.get_gl_dict({
"account": acc.account,
"cost_center": acc.cost_center,
"account_currency": acc.account_currency,
"debit_in_account_currency": abs(flt(acc.balance_in_account_currency)) \
if flt(acc.balance_in_account_currency) < 0 else 0,
"debit": abs(flt(acc.balance_in_company_currency)) \
if flt(acc.balance_in_company_currency) < 0 else 0,
"credit_in_account_currency": abs(flt(acc.balance_in_account_currency)) \
if flt(acc.balance_in_account_currency) > 0 else 0,
"credit": abs(flt(acc.balance_in_company_currency)) \
if flt(acc.balance_in_company_currency) > 0 else 0
}))
net_pl_balance += flt(acc.balance_in_company_currency)
if net_pl_balance:
gl_entries.append(self.get_gl_dict({
"account": self.closing_account_head,
"debit_in_account_currency": abs(net_pl_balance) if net_pl_balance > 0 else 0,
"debit": abs(net_pl_balance) if net_pl_balance > 0 else 0,
"credit_in_account_currency": abs(net_pl_balance) if net_pl_balance < 0 else 0,
"credit": abs(net_pl_balance) if net_pl_balance < 0 else 0
}))
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries)
def make_gl_entries(self, repost_future_gle=True):
gl_entries = self.get_gl_entries()
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
# if POS and amount is written off, there's no outstanding and hence no need to update it
update_outstanding = cint(self.is_pos) and self.write_off_account \
and 'No' or 'Yes'
make_gl_entries(gl_entries, cancel=(self.docstatus == 2),
update_outstanding=update_outstanding, merge_entries=False)
if update_outstanding == "No":
from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
update_outstanding_amt(self.debit_to, "Customer", self.customer, self.doctype, self.name)
if repost_future_gle and cint(self.update_stock) \
and cint(frappe.defaults.get_global_default("auto_accounting_for_stock")):
items, warehouses = self.get_items_and_warehouses()
update_gl_entries_after(self.posting_date, self.posting_time, warehouses, items)
elif self.docstatus == 2 and cint(self.update_stock) \
and cint(frappe.defaults.get_global_default("auto_accounting_for_stock")):
from erpnext.accounts.general_ledger import delete_gl_entries
delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
def make_gl_entries(self, cancel=0, adv_adj=0):
from erpnext.accounts.general_ledger import make_gl_entries
gl_map = []
for d in self.get("accounts"):
if d.debit or d.credit:
gl_map.append(
self.get_gl_dict({
"account": d.account,
"party_type": d.party_type,
"party": d.party,
"against": d.against_account,
"debit": flt(d.debit, self.precision("debit", "accounts")),
"credit": flt(d.credit, self.precision("credit", "accounts")),
"against_voucher_type": (("Purchase Invoice" if d.against_voucher else None)
or ("Sales Invoice" if d.against_invoice else None)
or ("Journal Entry" if d.against_jv else None)
or ("Sales Order" if d.against_sales_order else None)
or ("Purchase Order" if d.against_purchase_order else None)),
"against_voucher": d.against_voucher or d.against_invoice or d.against_jv
or d.against_sales_order or d.against_purchase_order,
"remarks": self.remark,
"cost_center": d.cost_center
})
)
if gl_map:
make_gl_entries(gl_map, cancel=cancel, adv_adj=adv_adj)
def make_gl_entries(self, repost_future_gle=True):
if not self.grand_total:
return
gl_entries = self.get_gl_entries()
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
# if POS and amount is written off, updating outstanding amt after posting all gl entries
update_outstanding = "No" if (cint(self.is_pos) or self.write_off_account) else "Yes"
make_gl_entries(gl_entries, cancel=(self.docstatus == 2),
update_outstanding=update_outstanding, merge_entries=False)
if update_outstanding == "No":
from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
update_outstanding_amt(self.debit_to, "Customer", self.customer,
self.doctype, self.return_against if cint(self.is_return) else self.name)
if repost_future_gle and cint(self.update_stock) \
and cint(frappe.defaults.get_global_default("auto_accounting_for_stock")):
items, warehouses = self.get_items_and_warehouses()
update_gl_entries_after(self.posting_date, self.posting_time, warehouses, items)
elif self.docstatus == 2 and cint(self.update_stock) \
and cint(frappe.defaults.get_global_default("auto_accounting_for_stock")):
from erpnext.accounts.general_ledger import delete_gl_entries
delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
def make_adjustment_entry(self, expected_gle, voucher_obj):
from erpnext.accounts.utils import get_stock_and_account_difference
account_list = [d.account for d in expected_gle]
acc_diff = get_stock_and_account_difference(account_list, expected_gle[0].posting_date)
cost_center = self.get_company_default("cost_center")
stock_adjustment_account = self.get_company_default("stock_adjustment_account")
gl_entries = []
for account, diff in acc_diff.items():
if diff:
gl_entries.append([
# stock in hand account
voucher_obj.get_gl_dict({
"account": account,
"against": stock_adjustment_account,
"debit": diff,
"remarks": "Adjustment Accounting Entry for Stock",
}),
# account against stock in hand
voucher_obj.get_gl_dict({
"account": stock_adjustment_account,
"against": account,
"credit": diff,
"cost_center": cost_center or None,
"remarks": "Adjustment Accounting Entry for Stock",
}),
])
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries)
def make_gl_entries(self, cancel=0, adv_adj=0): gl_entries = [] self.add_party_gl_entries(gl_entries) self.add_bank_gl_entries(gl_entries) self.add_deductions_gl_entries(gl_entries) make_gl_entries(gl_entries, cancel=cancel, adv_adj=adv_adj)
def make_gl_entries(self, cancel=0, adv_adj=0):
from erpnext.accounts.general_ledger import make_gl_entries
gl_map = []
for d in self.get("accounts"):
if d.debit or d.credit:
gl_map.append(
self.get_gl_dict({
"account": d.account,
"party_type": d.party_type,
"party": d.party,
"against": d.against_account,
"debit": flt(d.debit, d.precision("debit")),
"credit": flt(d.credit, d.precision("credit")),
"account_currency": d.account_currency,
"debit_in_account_currency": flt(d.debit_in_account_currency, d.precision("debit_in_account_currency")),
"credit_in_account_currency": flt(d.credit_in_account_currency, d.precision("credit_in_account_currency")),
"against_voucher_type": d.reference_type,
"against_voucher": d.reference_name,
"remarks": self.remark,
"cost_center": d.cost_center,
"project": d.project
})
)
if gl_map:
make_gl_entries(gl_map, cancel=cancel, adv_adj=adv_adj)
def make_gl_entries(self):
gl_entries = []
if ((self.purchase_receipt or (self.purchase_invoice and
frappe.db.get_value('Purchase Invoice', self.purchase_invoice, 'update_stock')))
and self.purchase_receipt_amount and self.available_for_use_date <= nowdate()):
fixed_aseet_account = get_asset_category_account(self.name, 'fixed_asset_account',
asset_category = self.asset_category, company = self.company)
cwip_account = get_asset_account("capital_work_in_progress_account",
self.name, self.asset_category, self.company)
gl_entries.append(self.get_gl_dict({
"account": cwip_account,
"against": fixed_aseet_account,
"remarks": self.get("remarks") or _("Accounting Entry for Asset"),
"posting_date": self.available_for_use_date,
"credit": self.purchase_receipt_amount,
"credit_in_account_currency": self.purchase_receipt_amount
}))
gl_entries.append(self.get_gl_dict({
"account": fixed_aseet_account,
"against": cwip_account,
"remarks": self.get("remarks") or _("Accounting Entry for Asset"),
"posting_date": self.available_for_use_date,
"debit": self.purchase_receipt_amount,
"debit_in_account_currency": self.purchase_receipt_amount
}))
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries)
self.db_set('booked_fixed_asset', 1)
def make_gl_entries(self):
gl_entries = []
net_pl_balance = 0
pl_accounts = self.get_pl_balances()
for acc in pl_accounts:
if flt(acc.balance):
gl_entries.append(
self.get_gl_dict(
{
"account": acc.account,
"debit": abs(flt(acc.balance)) if flt(acc.balance) < 0 else 0,
"credit": abs(flt(acc.balance)) if flt(acc.balance) > 0 else 0,
}
)
)
net_pl_balance += flt(acc.balance)
if net_pl_balance:
gl_entries.append(
self.get_gl_dict(
{
"account": self.closing_account_head,
"debit": abs(net_pl_balance) if net_pl_balance > 0 else 0,
"credit": abs(net_pl_balance) if net_pl_balance < 0 else 0,
}
)
)
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries)
def make_gl_entries(self, cancel=0, adv_adj=0):
if self.payment_type in ("Receive", "Pay") and not self.get("party_account_field"):
self.setup_party_account_field()
gl_entries = []
self.add_party_gl_entries(gl_entries)
self.add_bank_gl_entries(gl_entries)
self.add_deductions_gl_entries(gl_entries)
make_gl_entries(gl_entries, cancel=cancel, adv_adj=adv_adj)
def on_submit(self):
assets=frappe.db.sql("""select name,asset_value,book_value,deprecation_value,counter,against,account,cost_center from `tabAsset` where counter>0 and last_deprecated<="{0}" and docstatus=1 """.format(self.posting_date),as_list=1)
#frappe.throw(assets)
for asset in assets:
new_value=flt(asset[2])-flt(asset[3])
if new_value<0:
new_value=0
#frappe.throw("""update `tabAsset` set counter=counter-1 and book_value='{0}' and last_deprecated="{1}" where name = '{2}' """.format(new_value,self.posting_date,asset[0]))
asset_record=frappe.get_doc({
"doctype":"Asset Depreciation Record",
"parent":self.name,
"asset_depreciation":self.name,
"posting_date":self.posting_date,
"last_book_value":asset[2],
"depreciation_value":asset[3],
"new_book_value":new_value,
"asset":asset[0]
})
asset_record.insert()
data=[{"debit":asset[3],"credit":0,"account":asset[6],"against_account":asset[5],"name":asset[0]},
{"debit":0,"credit":asset[3],"account":asset[5],"against_account":asset[6],"name":asset[0]}]
from erpnext.accounts.general_ledger import make_gl_entries
gl_map = []
for d in data:
if d.get("debit") or d.get("credit"):
gl_map.append(
frappe._dict({
'company': self.company,
'posting_date': self.posting_date,
'transaction_date': self.posting_date,
'voucher_type': self.doctype,
'voucher_no': self.name,
'aging_date': self.get("aging_date") or self.posting_date,
'remarks': asset[0],
'fiscal_year': self.fiscal_year,
'debit': 0,
'credit': 0,
'cost_center':asset[7],
'is_opening': self.get("is_opening") or "No",
"account": d.get("account"),
"against": d.get("against_account"),
"debit": flt(d.get("debit")),
"credit": flt(d.get("credit"))
})
)
if gl_map:
make_gl_entries(gl_map, 0,0)
asset_record.submit()
frappe.db.sql("""update `tabAsset` set counter=counter-1 , book_value='{0}' , last_deprecated="{1}" where name = '{2}' """.format(new_value,self.posting_date,asset[0]))
def make_gl_entries(self, repost_future_gle=True):
if self.docstatus == 2:
delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
if cint(frappe.defaults.get_global_default("auto_accounting_for_stock")):
warehouse_account = get_warehouse_account()
if self.docstatus == 1:
gl_entries = self.get_gl_entries(warehouse_account)
make_gl_entries(gl_entries)
if repost_future_gle:
items, warehouses = self.get_items_and_warehouses()
update_gl_entries_after(self.posting_date, self.posting_time, warehouses, items, warehouse_account)
def make_gl_entries(self, repost_future_gle=True):
if not self.grand_total:
return
self.auto_accounting_for_stock = \
cint(frappe.defaults.get_global_default("auto_accounting_for_stock"))
self.stock_received_but_not_billed = self.get_company_default(
"stock_received_but_not_billed")
self.expenses_included_in_valuation = self.get_company_default(
"expenses_included_in_valuation")
self.negative_expense_to_be_booked = 0.0
gl_entries = []
self.make_supplier_gl_entry(gl_entries)
self.make_item_gl_entries(gl_entries)
self.make_tax_gl_entries(gl_entries)
gl_entries = merge_similar_entries(gl_entries)
self.make_payment_gl_entries(gl_entries)
self.make_write_off_gl_entry(gl_entries)
if gl_entries:
update_outstanding = "No" if (cint(self.is_paid)
or self.write_off_account) else "Yes"
make_gl_entries(gl_entries,
cancel=(self.docstatus == 2),
update_outstanding=update_outstanding,
merge_entries=False)
if update_outstanding == "No":
update_outstanding_amt(
self.credit_to, "Supplier", self.supplier, self.doctype,
self.return_against if cint(self.is_return) else self.name)
if repost_future_gle and cint(
self.update_stock) and self.auto_accounting_for_stock:
from erpnext.controllers.stock_controller import update_gl_entries_after
items, warehouses = self.get_items_and_warehouses()
update_gl_entries_after(self.posting_date, self.posting_time,
warehouses, items)
elif self.docstatus == 2 and cint(
self.update_stock) and self.auto_accounting_for_stock:
delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
def make_gl_entries(self, repost_future_gle=True):
if self.docstatus == 2:
delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
if cint(frappe.defaults.get_global_default(
"auto_accounting_for_stock")):
warehouse_account = get_warehouse_account()
if self.docstatus == 1:
gl_entries = self.get_gl_entries(warehouse_account)
make_gl_entries(gl_entries)
if repost_future_gle:
items, warehouses = self.get_items_and_warehouses()
update_gl_entries_after(self.posting_date, self.posting_time,
warehouses, items, warehouse_account)
def make_gl_entries(self, cancel=0):
payment_account = get_bank_cash_account(
self.mode_of_payment, self.company
)
gl_entries = [
self.get_gl_dict({
'account': self.loan_account,
'debit': self.principal,
}),
self.get_gl_dict({
'account': payment_account.get('account'),
'credit': self.principal,
'against': self.customer,
})
]
make_gl_entries(gl_entries, cancel=cancel, adv_adj=0)
def make_gl_entries(self, update_gl_entries_after=True):
gl_entries = self.get_gl_entries()
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
update_outstanding = cint(self.doc.is_pos) and self.doc.write_off_account \
and 'No' or 'Yes'
make_gl_entries(gl_entries,
cancel=(self.doc.docstatus == 2),
update_outstanding=update_outstanding,
merge_entries=False)
if update_gl_entries_after and cint(self.doc.update_stock) \
and cint(frappe.defaults.get_global_default("auto_accounting_for_stock")):
self.update_gl_entries_after()
def execute():
for name in frappe.db.sql("""
SELECT name
FROM `tabIndent Invoice`
WHERE docstatus = 1;
"""):
name = name[0]
if cint(name) < 1000:
continue
invoice = frappe.get_doc("Indent Invoice", name)
gl_entries = invoice.get_gl_entries()
delete_gl_entries(voucher_type="Indent Invoice", voucher_no=name)
make_gl_entries(gl_entries)
def make_gl_entries(self, gl_entries=None, repost_future_gle=True, from_repost=False): if self.docstatus == 2: delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name) if cint(erpnext.is_perpetual_inventory_enabled(self.company)): warehouse_account = get_warehouse_account_map() if self.docstatus==1: if not gl_entries: gl_entries = self.get_gl_entries(warehouse_account) make_gl_entries(gl_entries, from_repost=from_repost) if repost_future_gle: items, warehouses = self.get_items_and_warehouses() update_gl_entries_after(self.posting_date, self.posting_time, warehouses, items, warehouse_account)
def make_gl_entries(self, gl_entries=None): if self.docstatus == 2: make_reverse_gl_entries(voucher_type=self.doctype, voucher_no=self.name) if cint(erpnext.is_perpetual_inventory_enabled(self.company)): warehouse_account = get_warehouse_account_map(self.company) if self.docstatus==1: if not gl_entries: gl_entries = self.get_gl_entries(warehouse_account) make_gl_entries(gl_entries) elif self.doctype in ['Purchase Receipt', 'Purchase Invoice'] and self.docstatus == 1: gl_entries = [] gl_entries = self.get_asset_gl_entry(gl_entries) make_gl_entries(gl_entries)
def make_gl_entries(doc, credit_account, debit_account, against, amount,
base_amount, posting_date, project, account_currency,
cost_center, voucher_detail_no):
# GL Entry for crediting the amount in the deferred expense
from erpnext.accounts.general_ledger import make_gl_entries
gl_entries = []
gl_entries.append(
doc.get_gl_dict(
{
"account": credit_account,
"against": against,
"credit": base_amount,
"credit_in_account_currency": amount,
"cost_center": cost_center,
"voucher_detail_no": voucher_detail_no,
'posting_date': posting_date,
'project': project
}, account_currency))
# GL Entry to debit the amount from the expense
gl_entries.append(
doc.get_gl_dict(
{
"account": debit_account,
"against": against,
"debit": base_amount,
"debit_in_account_currency": amount,
"cost_center": cost_center,
"voucher_detail_no": voucher_detail_no,
'posting_date': posting_date,
'project': project
}, account_currency))
if gl_entries:
try:
make_gl_entries(gl_entries,
cancel=(doc.docstatus == 2),
merge_entries=True)
frappe.db.commit()
except:
frappe.db.rollback()
title = _(
"Error while processing deferred accounting for {0}").format(
doc.name)
traceback = frappe.get_traceback()
frappe.log_error(message=traceback, title=title)
sendmail_to_system_managers(title, traceback)
def make_gl_entry(self):
settings = frappe.get_single("Wire Transfer Settings")
sign = -1 if self.workflow_action in [RETURN, REVERSE] else 1
if self.workflow_action in [ACCEPT, RETURN]:
make_gl_entries(
mapr(
self.get_gl_dict,
[
{
"account": self.cash_account,
"against": self.account,
"debit": self.total * sign,
},
{
"account": settings.income_account,
"against": self.account,
"credit": self.fees * sign,
"cost_center": settings.cost_center,
},
{
"account": settings.transit_account,
"party": self.account,
"credit": self.amount * sign,
},
],
)
)
elif self.workflow_action in [TRANSFER, REVERSE]:
make_gl_entries(
mapr(
self.get_gl_dict,
[
{
"account": self.bank_account,
"against": self.account,
"credit": self.amount * sign,
"remarks": self._get_remarks(),
},
{
"account": settings.transit_account,
"against": self.bank_account,
"debit": self.amount * sign,
},
],
)
)
def make_gl_entries(self, cancel=False, adv_adj=False):
from erpnext.accounts.general_ledger import make_gl_entries
from erpnext.accounts.utils import get_company_default
loan_doc = frappe.get_doc(
self.meta.get_field("loan").options, self.loan)
income_account = get_company_default(loan_doc.company,
"default_income_account")
gl_map = loan_doc.get_double_matched_entry(self.total_amount,
income_account)
make_gl_entries(gl_map,
cancel=cancel,
adv_adj=adv_adj,
merge_entries=False)
def make_gl_entries(self, cancel=0):
payment_account = get_bank_cash_account(
self.mode_of_payment, self.company
)
gl_entries = map(self.get_gl_dict, [
{
'account': self.loan_account,
'debit': self.principal,
},
{
'account': payment_account.get('account'),
'credit': self.principal,
'against': self.customer,
'remarks': 'Loan disbursed',
},
])
make_gl_entries(gl_entries, cancel=cancel, adv_adj=0)
def make_gl_entries(self, cancel=False, adv_adj=False):
from erpnext.accounts.general_ledger import make_gl_entries
# amount that was disbursed from the bank account
lent_amount = self.get_lent_amount()
gl_map = self.get_double_matched_entry(lent_amount,
self.disbursement_account)
gl_map += self.get_double_matched_entry(self.legal_expenses_amount,
self.income_account)
gl_map += self.get_double_matched_entry(self.total_interest_amount,
self.income_account)
make_gl_entries(gl_map,
cancel=cancel,
adv_adj=adv_adj,
merge_entries=False)
def make_gl_entries(company, posting_date, fiscal_year):
gl_entries = []
net_pl_balance = 0
from erpnext.accounts.utils import get_fiscal_year, validate_fiscal_year
year_start_date = get_fiscal_year(posting_date, fiscal_year, company)[1]
pl_accounts = get_pl_balances(company, posting_date, year_start_date)
for acc in pl_accounts:
if flt(acc.balance_in_company_currency):
gl_entries.append(get_gl_dict(company,posting_date,fiscal_year,{
"account": acc.account,
"cost_center": acc.cost_center,
"account_currency": acc.account_currency,
"debit_in_account_currency": abs(flt(acc.balance_in_account_currency)) \
if flt(acc.balance_in_account_currency) < 0 else 0,
"debit": abs(flt(acc.balance_in_company_currency)) \
if flt(acc.balance_in_company_currency) < 0 else 0,
"credit_in_account_currency": abs(flt(acc.balance_in_account_currency)) \
if flt(acc.balance_in_account_currency) > 0 else 0,
"credit": abs(flt(acc.balance_in_company_currency)) \
if flt(acc.balance_in_company_currency) > 0 else 0
}))
net_pl_balance += flt(acc.balance_in_company_currency)
if net_pl_balance:
gl_entries.append(
get_gl_dict(
company, posting_date, fiscal_year, {
"account":
"رأس المال - SPO",
"debit_in_account_currency":
abs(net_pl_balance) if net_pl_balance > 0 else 0,
"debit":
abs(net_pl_balance) if net_pl_balance > 0 else 0,
"credit_in_account_currency":
abs(net_pl_balance) if net_pl_balance < 0 else 0,
"credit":
abs(net_pl_balance) if net_pl_balance < 0 else 0
}))
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries)
def make_gl_entries(self):
gl_entries = []
purchase_document = self.get_purchase_document()
fixed_asset_account, cwip_account = self.get_fixed_asset_account(), self.get_cwip_account()
if (
purchase_document and self.purchase_receipt_amount and self.available_for_use_date <= nowdate()
):
gl_entries.append(
self.get_gl_dict(
{
"account": cwip_account,
"against": fixed_asset_account,
"remarks": self.get("remarks") or _("Accounting Entry for Asset"),
"posting_date": self.available_for_use_date,
"credit": self.purchase_receipt_amount,
"credit_in_account_currency": self.purchase_receipt_amount,
"cost_center": self.cost_center,
},
item=self,
)
)
gl_entries.append(
self.get_gl_dict(
{
"account": fixed_asset_account,
"against": cwip_account,
"remarks": self.get("remarks") or _("Accounting Entry for Asset"),
"posting_date": self.available_for_use_date,
"debit": self.purchase_receipt_amount,
"debit_in_account_currency": self.purchase_receipt_amount,
"cost_center": self.cost_center,
},
item=self,
)
)
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries)
self.db_set("booked_fixed_asset", 1)
def make_gl_entries(self):
company_currency = frappe.get_cached_value('Company', self.company, "default_currency")
gl_entries = []
invoice_fields = ["debit_to", "party_account_currency", "conversion_rate", "cost_center"]
accounting_dimensions = get_accounting_dimensions()
invoice_fields.extend(accounting_dimensions)
for d in self.invoices:
inv = frappe.db.get_value("Sales Invoice", d.sales_invoice, invoice_fields, as_dict=1)
if d.outstanding_amount:
outstanding_in_company_currency = flt(d.outstanding_amount * inv.conversion_rate,
d.precision("outstanding_amount"))
ar_credit_account_currency = frappe.get_cached_value("Account", self.accounts_receivable_credit, "currency")
gl_entries.append(self.get_gl_dict({
"account": inv.debit_to,
"party_type": "Customer",
"party": d.customer,
"against": self.accounts_receivable_credit,
"credit": outstanding_in_company_currency,
"credit_in_account_currency": outstanding_in_company_currency \
if inv.party_account_currency==company_currency else d.outstanding_amount,
"cost_center": inv.cost_center,
"against_voucher": d.sales_invoice,
"against_voucher_type": "Sales Invoice"
}, inv.party_account_currency, item=inv))
gl_entries.append(self.get_gl_dict({
"account": self.accounts_receivable_credit,
"party_type": "Customer",
"party": d.customer,
"against": inv.debit_to,
"debit": outstanding_in_company_currency,
"debit_in_account_currency": outstanding_in_company_currency \
if ar_credit_account_currency==company_currency else d.outstanding_amount,
"cost_center": inv.cost_center,
"against_voucher": d.sales_invoice,
"against_voucher_type": "Sales Invoice"
}, ar_credit_account_currency, item=inv))
make_gl_entries(gl_entries, cancel=(self.docstatus == 2), update_outstanding='No')
def make_gl_entries(self, cancel=0, adv_adj=0):
gl_entries = []
if self.billing_period:
unbilled = self.get_unbilled()
if unbilled:
self.add_billing_gl_entries(gl_entries, unbilled)
if self.interest:
self.add_party_gl_entries(gl_entries)
if self.principal:
self.add_loan_gl_entries(gl_entries)
if len(self.loan_charges) > 0:
self.add_charges_gl_entries(gl_entries)
make_gl_entries(gl_entries,
cancel=cancel,
adv_adj=adv_adj,
merge_entries=False)
def make_gl_entries(self, gl_entries=None): if not gl_entries: gl_entries = self.get_gl_entries() if gl_entries: update_outstanding = "No" if (cint(self.is_paid) or self.write_off_account) else "Yes" if self.docstatus == 1: make_gl_entries(gl_entries, update_outstanding=update_outstanding, merge_entries=False) elif self.docstatus == 2: make_reverse_gl_entries(voucher_type=self.doctype, voucher_no=self.name) if update_outstanding == "No": update_outstanding_amt(self.credit_to, "Supplier", self.supplier, self.doctype, self.return_against if cint(self.is_return) and self.return_against else self.name) elif self.docstatus == 2 and cint(self.update_stock) and self.auto_accounting_for_stock: make_reverse_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
def make_gl_entries(self, cancel=0, adv_adj=0):
gle_map = []
if self.interest_amount:
gle_map.append(
self.get_gl_dict(
{
"account": self.loan_account,
"party_type": self.applicant_type,
"party": self.applicant,
"against": self.interest_income_account,
"debit": self.interest_amount,
"debit_in_account_currency": self.interest_amount,
"against_voucher_type": "Loan",
"against_voucher": self.loan,
"remarks": _("Interest accrued from {0} to {1} against loan: {2}").format(
self.last_accrual_date, self.posting_date, self.loan
),
"cost_center": erpnext.get_default_cost_center(self.company),
"posting_date": self.posting_date,
}
)
)
gle_map.append(
self.get_gl_dict(
{
"account": self.interest_income_account,
"against": self.loan_account,
"credit": self.interest_amount,
"credit_in_account_currency": self.interest_amount,
"against_voucher_type": "Loan",
"against_voucher": self.loan,
"remarks": ("Interest accrued from {0} to {1} against loan: {2}").format(
self.last_accrual_date, self.posting_date, self.loan
),
"cost_center": erpnext.get_default_cost_center(self.company),
"posting_date": self.posting_date,
}
)
)
if gle_map:
make_gl_entries(gle_map, cancel=cancel, adv_adj=adv_adj)
def make_gl_entries(self, cancel=0, adv_adj=0):
from erpnext.accounts.general_ledger import make_gl_entries
gl_map = []
for d in self.get("accounts"):
if d.debit or d.credit:
gl_map.append(
self.get_gl_dict({
"account":
d.account,
"party_type":
d.party_type,
"party":
d.party,
"against":
d.against_account,
"debit":
flt(d.debit, d.precision("debit")),
"credit":
flt(d.credit, d.precision("credit")),
"account_currency":
d.account_currency,
"debit_in_account_currency":
flt(d.debit_in_account_currency,
d.precision("debit_in_account_currency")),
"credit_in_account_currency":
flt(d.credit_in_account_currency,
d.precision("credit_in_account_currency")),
"against_voucher_type":
d.reference_type,
"against_voucher":
d.reference_name,
"remarks":
self.remark,
"cost_center":
d.cost_center,
"project":
d.project,
"narration":
d.narration
}))
if gl_map:
make_gl_entries(gl_map, cancel=cancel, adv_adj=adv_adj)
def make_gl_entries(self):
if not self.dunning_amount:
return
gl_entries = []
invoice_fields = ["project", "cost_center", "debit_to",
"party_account_currency", "conversion_rate", "cost_center"]
inv = frappe.db.get_value(
"Sales Invoice", self.sales_invoice, invoice_fields, as_dict=1)
accounting_dimensions = get_accounting_dimensions()
invoice_fields.extend(accounting_dimensions)
dunning_in_company_currency = flt(
self.dunning_amount * inv.conversion_rate)
default_cost_center = frappe.get_cached_value(
'Company', self.company, 'cost_center')
gl_entries.append(
self.get_gl_dict({
"account": inv.debit_to,
"party_type": "Customer",
"party": self.customer,
"due_date": self.due_date,
"against": self.income_account,
"debit": dunning_in_company_currency,
"debit_in_account_currency": self.dunning_amount,
"against_voucher": self.name,
"against_voucher_type": "Dunning",
"cost_center": inv.cost_center or default_cost_center,
"project": inv.project
}, inv.party_account_currency, item=inv)
)
gl_entries.append(
self.get_gl_dict({
"account": self.income_account,
"against": self.customer,
"credit": dunning_in_company_currency,
"cost_center": inv.cost_center or default_cost_center,
"credit_in_account_currency": self.dunning_amount,
"project": inv.project
}, item=inv)
)
make_gl_entries(gl_entries, cancel=(self.docstatus == 2),
update_outstanding="No", merge_entries=False)
def make_gl_entries(self):
gl_entries = []
net_pl_balance = 0
pl_accounts = self.get_pl_balances()
for acc in pl_accounts:
if flt(acc.balance_in_company_currency):
gl_entries.append(self.get_gl_dict({
"account": acc.account,
"cost_center": acc.cost_center,
"account_currency": acc.account_currency,
"debit_in_account_currency": abs(flt(acc.balance_in_account_currency)) \
if flt(acc.balance_in_account_currency) < 0 else 0,
"debit": abs(flt(acc.balance_in_company_currency)) \
if flt(acc.balance_in_company_currency) < 0 else 0,
"credit_in_account_currency": abs(flt(acc.balance_in_account_currency)) \
if flt(acc.balance_in_account_currency) > 0 else 0,
"credit": abs(flt(acc.balance_in_company_currency)) \
if flt(acc.balance_in_company_currency) > 0 else 0
}))
net_pl_balance += flt(acc.balance_in_company_currency)
if net_pl_balance:
cost_center = frappe.db.get_value("Company", self.company,
"cost_center")
gl_entries.append(
self.get_gl_dict({
"account":
self.closing_account_head,
"debit_in_account_currency":
abs(net_pl_balance) if net_pl_balance > 0 else 0,
"debit":
abs(net_pl_balance) if net_pl_balance > 0 else 0,
"credit_in_account_currency":
abs(net_pl_balance) if net_pl_balance < 0 else 0,
"credit":
abs(net_pl_balance) if net_pl_balance < 0 else 0,
"cost_center":
cost_center
}))
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries)
def make_adjustment_entry(self, expected_gle, voucher_obj):
from erpnext.accounts.utils import get_stock_and_account_difference
account_list = [d.account for d in expected_gle]
acc_diff = get_stock_and_account_difference(
account_list, expected_gle[0].posting_date)
cost_center = self.get_company_default("cost_center")
stock_adjustment_account = self.get_company_default(
"stock_adjustment_account")
gl_entries = []
for account, diff in acc_diff.items():
if diff:
gl_entries.append([
# stock in hand account
voucher_obj.get_gl_dict({
"account":
account,
"against":
stock_adjustment_account,
"debit":
diff,
"remarks":
"Adjustment Accounting Entry for Stock",
}),
# account against stock in hand
voucher_obj.get_gl_dict({
"account":
stock_adjustment_account,
"against":
account,
"credit":
diff,
"cost_center":
cost_center or None,
"remarks":
"Adjustment Accounting Entry for Stock",
}),
])
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries)
def update_gl(self):
buyer_account = get_party_account(self.company, self.to_customer,
"Customer")
seller_account = get_party_account(self.company, self.from_customer,
"Customer")
gl_entries = []
remark = "Sale of {} {} from {} to {}".format(self.qty, self.item,
self.from_customer,
self.to_customer)
gl_entries.append(
self.get_gl_dict({
"account": buyer_account,
"debit": self.sale_amount,
"remarks": remark
}))
gl_entries.append(
self.get_gl_dict({
"account": seller_account,
"credit": self.purchase_amount,
"remarks": remark
}))
income = self.sale_amount - self.purchase_amount
if income != 0:
adjustment_gl_entry = self.get_gl_dict({
"account": "Sales - AL",
"remarks": remark,
"cost_center": "Main - AL"
})
adjustment_gl_entry['credit' if income else 'debit'] = income
gl_entries.append(adjustment_gl_entry)
make_gl_entries(gl_entries,
cancel=(self.docstatus == 2),
update_outstanding='Yes',
merge_entries=False)
def make_gl_entries(self, repost_future_gle=True):
gl_entries = self.get_gl_entries()
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
update_outstanding = cint(self.is_pos) and self.write_off_account \
and 'No' or 'Yes'
make_gl_entries(gl_entries, cancel=(self.docstatus == 2),
update_outstanding=update_outstanding, merge_entries=False)
if update_outstanding == "No":
from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
update_outstanding_amt(self.debit_to, self.doctype, self.name)
if repost_future_gle and cint(self.update_stock) \
and cint(frappe.defaults.get_global_default("auto_accounting_for_stock")):
items, warehouses = self.get_items_and_warehouses()
update_gl_entries_after(self.posting_date, self.posting_time, warehouses, items)
def make_gl_entries(self, repost_future_gle=True, allow_negative_stock=False):
gl_entries = self.get_gl_entries(allow_negative_stock=allow_negative_stock)
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
update_outstanding = cint(self.is_pos) and self.write_off_account \
and 'No' or 'Yes'
make_gl_entries(gl_entries, cancel=(self.docstatus == 2),
update_outstanding=update_outstanding, merge_entries=False)
if update_outstanding == "No":
from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
update_outstanding_amt(self.debit_to, self.doctype, self.name)
if repost_future_gle and cint(self.update_stock) \
and cint(frappe.defaults.get_global_default("auto_accounting_for_stock")):
items, warehouses = self.get_items_and_warehouses()
update_gl_entries_after(self.posting_date, self.posting_time, warehouses, items)
def make_gl_entries(self,
gl_entries=None,
repost_future_gle=True,
from_repost=False):
if self.docstatus == 2:
delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
if cint(erpnext.is_perpetual_inventory_enabled(self.company)):
warehouse_account = get_warehouse_account_map()
if self.docstatus == 1:
if not gl_entries:
gl_entries = self.get_gl_entries(warehouse_account)
make_gl_entries(gl_entries, from_repost=from_repost)
if repost_future_gle:
items, warehouses = self.get_items_and_warehouses()
update_gl_entries_after(self.posting_date, self.posting_time,
warehouses, items, warehouse_account)
def make_gl_entries(doc, credit_account, debit_account, against,
amount, base_amount, posting_date, project, account_currency, cost_center, voucher_detail_no):
# GL Entry for crediting the amount in the deferred expense
from erpnext.accounts.general_ledger import make_gl_entries
gl_entries = []
gl_entries.append(
doc.get_gl_dict({
"account": credit_account,
"against": against,
"credit": base_amount,
"credit_in_account_currency": amount,
"cost_center": cost_center,
"voucher_detail_no": voucher_detail_no,
'posting_date': posting_date,
'project': project
}, account_currency)
)
# GL Entry to debit the amount from the expense
gl_entries.append(
doc.get_gl_dict({
"account": debit_account,
"against": against,
"debit": base_amount,
"debit_in_account_currency": amount,
"cost_center": cost_center,
"voucher_detail_no": voucher_detail_no,
'posting_date': posting_date,
'project': project
}, account_currency)
)
if gl_entries:
try:
make_gl_entries(gl_entries, cancel=(doc.docstatus == 2), merge_entries=True)
frappe.db.commit()
except:
frappe.db.rollback()
title = _("Error while processing deferred accounting for {0}").format(doc.name)
traceback = frappe.get_traceback()
frappe.log_error(message=traceback , title=title)
sendmail_to_system_managers(title, traceback)
def make_gl_entries(self, cancel=0, adv_adj=0):
cost_center, write_off_account = frappe.db.get_value(
"Microfinance Loan Settings", None,
["cost_center", "write_off_account"])
gl_entries = [
self.get_gl_dict({
"account": self.loan_account,
"credit": self.amount
}),
self.get_gl_dict({
"account": write_off_account,
"debit": self.amount,
"cost_center": cost_center,
"remarks": self.reason,
}),
]
make_gl_entries(gl_entries,
cancel=cancel,
adv_adj=adv_adj,
merge_entries=False)
def make_gl_entries(self, gl_entries=None, repost_future_gle=True, from_repost=False): if self.docstatus == 2: delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name) if cint(erpnext.is_perpetual_inventory_enabled(self.company)): warehouse_account = get_warehouse_account_map(self.company) if self.docstatus==1: if not gl_entries: gl_entries = self.get_gl_entries(warehouse_account) make_gl_entries(gl_entries, from_repost=from_repost) if (repost_future_gle or self.flags.repost_future_gle): items, warehouses = self.get_items_and_warehouses() update_gl_entries_after(self.posting_date, self.posting_time, warehouses, items, warehouse_account, company=self.company) elif self.doctype in ['Purchase Receipt', 'Purchase Invoice'] and self.docstatus == 1: gl_entries = [] gl_entries = self.get_asset_gl_entry(gl_entries) make_gl_entries(gl_entries, from_repost=from_repost)
def make_interest(self, posting_date, amount, cancel=0, adv_adj=0):
# does nothin reqd for FiscalYearError
self.posting_date = posting_date
periods = get_billing_periods(self.name, posting_date, 1)
if len(periods) != 1:
return None
if amount:
billing_period = periods[0].get('as_text')
# check whether entries to recvble are already present
owed_amount = self.get_owed(billing_period)
if not amount - owed_amount > 0:
return None
gl_entries = [
self.get_gl_dict({
'posting_date': posting_date,
'account': self.interest_receivable_account,
'debit': amount - owed_amount,
'party_type': 'Customer',
'party': self.customer,
'against': self.interest_income_account,
'period': billing_period,
}),
self.get_gl_dict({
'posting_date':
posting_date,
'account':
self.interest_income_account,
'credit':
amount - owed_amount,
'against':
self.customer,
'cost_center':
frappe.db.get_value('Loan Settings', None, 'cost_center'),
'remarks':
'Interest for period: {}'.format(
humanify_period(billing_period)),
})
]
make_gl_entries(gl_entries, cancel=cancel, adv_adj=adv_adj)
def on_submit(self):
gl_map = []
fiscal_years = get_fiscal_years(self.posting_date, company='RIGPL')
if len(fiscal_years) > 1:
frappe.throw(_("Multiple fiscal years exist for the date {0}. \
Please set company in Fiscal Year").format(formatdate(self.posting_date)))
else:
fiscal_year = fiscal_years[0][0]
for emp in self.employee_loan_detail:
if emp.loan_amount:
gl_dict = frappe._dict({
'company': 'RIGPL',
'posting_date' : self.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Employee Advance',
'voucher_no': self.name,
'account': self.debit_account,
'debit': flt(emp.loan_amount),
'debit_in_account_currency': flt(emp.loan_amount),
'party_type': 'Employee',
'party': emp.employee,
'against': self.credit_account
})
gl_map.append(gl_dict)
if gl_map:
gl_dict = frappe._dict({
'company': 'RIGPL',
'posting_date' : self.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Employee Advance',
'voucher_no': self.name,
'account': self.credit_account,
'debit': 0,
'credit': flt(self.total_loan),
'credit_in_account_currency' : flt(self.total_loan),
'debit_in_account_currency': 0,
'against': self.debit_account
})
gl_map.append(gl_dict)
make_gl_entries(gl_map, cancel=0, adv_adj=0)
def make_gl_entries(self,
gl_entries=None,
repost_future_gle=True,
from_repost=False):
auto_accounting_for_stock = erpnext.is_perpetual_inventory_enabled(
self.company)
if not self.grand_total:
return
if not gl_entries:
gl_entries = self.get_gl_entries()
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
# if POS and amount is written off, updating outstanding amt after posting all gl entries
update_outstanding = "No" if (cint(self.is_pos)
or self.write_off_account) else "Yes"
make_gl_entries(gl_entries,
cancel=(self.docstatus == 2),
update_outstanding=update_outstanding,
merge_entries=False)
if update_outstanding == "No":
from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
update_outstanding_amt(
self.debit_to, "Customer", self.customer, self.doctype,
self.return_against if cint(self.is_return) else self.name)
if repost_future_gle and cint(self.update_stock) \
and cint(auto_accounting_for_stock):
items, warehouses = self.get_items_and_warehouses()
update_gl_entries_after(self.posting_date, self.posting_time,
warehouses, items)
elif self.docstatus == 2 and cint(self.update_stock) \
and cint(auto_accounting_for_stock):
from erpnext.accounts.general_ledger import delete_gl_entries
delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
def make_gl_entries(self, repost_future_gle=True):
if not self.grand_total:
return
self.auto_accounting_for_stock = \
cint(frappe.defaults.get_global_default("auto_accounting_for_stock"))
self.stock_received_but_not_billed = self.get_company_default("stock_received_but_not_billed")
self.expenses_included_in_valuation = self.get_company_default("expenses_included_in_valuation")
self.negative_expense_to_be_booked = 0.0
gl_entries = []
self.make_supplier_gl_entry(gl_entries)
self.make_item_gl_entries(gl_entries)
self.make_tax_gl_entries(gl_entries)
gl_entries = merge_similar_entries(gl_entries)
self.make_payment_gl_entries(gl_entries)
self.make_write_off_gl_entry(gl_entries)
if gl_entries:
update_outstanding = "No" if (cint(self.is_paid) or self.write_off_account) else "Yes"
make_gl_entries(gl_entries, cancel=(self.docstatus == 2),
update_outstanding=update_outstanding, merge_entries=False)
if update_outstanding == "No":
update_outstanding_amt(self.credit_to, "Supplier", self.supplier,
self.doctype, self.return_against if cint(self.is_return) else self.name)
if repost_future_gle and cint(self.update_stock) and self.auto_accounting_for_stock:
from erpnext.controllers.stock_controller import update_gl_entries_after
items, warehouses = self.get_items_and_warehouses()
update_gl_entries_after(self.posting_date, self.posting_time, warehouses, items)
elif self.docstatus == 2 and cint(self.update_stock) and self.auto_accounting_for_stock:
delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
def make_gl_entries(self, cancel=0, adv_adj=0):
from erpnext.accounts.general_ledger import make_gl_entries
gl_map = []
for d in self.get("entries"):
if d.debit or d.credit:
gl_map.append(
self.get_gl_dict({
"account": d.account,
"against": d.against_account,
"debit": flt(d.debit, self.precision("debit", "entries")),
"credit": flt(d.credit, self.precision("credit", "entries")),
"against_voucher_type": ((d.against_voucher and "Purchase Invoice")
or (d.against_invoice and "Sales Invoice")
or (d.against_jv and "Journal Voucher")),
"against_voucher": d.against_voucher or d.against_invoice or d.against_jv,
"remarks": self.remark,
"cost_center": d.cost_center
})
)
if gl_map:
make_gl_entries(gl_map, cancel=cancel, adv_adj=adv_adj)
def make_gl_entries(self, amount, posting_date=None, remarks=""):
self.company = frappe.get_value("Microfinance Loan", self.loan, "company")
if posting_date:
self.posting_date = posting_date
interest_income_account, loan_account = frappe.get_value(
"Microfinance Loan", self.loan, ["interest_income_account", "loan_account"]
)
cost_center = frappe.db.get_value(
"Microfinance Loan Settings", None, "cost_center"
)
gl_entries = [
self.get_gl_dict({"account": loan_account, "debit": amount}),
self.get_gl_dict(
{
"account": interest_income_account,
"credit": amount,
"cost_center": cost_center,
"remarks": remarks,
}
),
]
make_gl_entries(gl_entries, merge_entries=False)
def make_gl_entries(self):
if not self.grand_total:
return
student_gl_entries = self.get_gl_dict({
"account": self.receivable_account,
"party_type": "Student",
"party": self.student,
"against": self.income_account,
"debit": self.grand_total,
"debit_in_account_currency": self.grand_total,
"against_voucher": self.name,
"against_voucher_type": self.doctype
})
fee_gl_entry = self.get_gl_dict({
"account": self.income_account,
"against": self.student,
"credit": self.grand_total,
"credit_in_account_currency": self.grand_total,
"cost_center": self.cost_center
})
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries([student_gl_entries, fee_gl_entry], cancel=(self.docstatus == 2),
update_outstanding="Yes", merge_entries=False)
def _book_deferred_revenue_or_expense(item): start_date, end_date, last_gl_entry = get_booking_dates(doc, item, posting_date=posting_date) if not (start_date and end_date): return account_currency = get_account_currency(item.expense_account) if doc.doctype == "Sales Invoice": against, project = doc.customer, doc.project credit_account, debit_account = item.income_account, item.deferred_revenue_account else: against, project = doc.supplier, item.project credit_account, debit_account = item.deferred_expense_account, item.expense_account total_days = date_diff(item.service_end_date, item.service_start_date) + 1 total_booking_days = date_diff(end_date, start_date) + 1 amount, base_amount = calculate_amount(doc, item, last_gl_entry, total_days, total_booking_days, account_currency) make_gl_entries(doc, credit_account, debit_account, against, amount, base_amount, end_date, project, account_currency, item.cost_center, item.name) if getdate(end_date) < getdate(posting_date) and not last_gl_entry: _book_deferred_revenue_or_expense(item)
def make_gl_entries(self, gl_entries=None, repost_future_gle=True, from_repost=False): if not self.grand_total: return if not gl_entries: gl_entries = self.get_gl_entries() if gl_entries: update_outstanding = "No" if (cint(self.is_paid) or self.write_off_account) else "Yes" make_gl_entries(gl_entries, cancel=(self.docstatus == 2), update_outstanding=update_outstanding, merge_entries=False) if update_outstanding == "No": update_outstanding_amt(self.credit_to, "Supplier", self.supplier, self.doctype, self.return_against if cint(self.is_return) else self.name) if repost_future_gle and cint(self.update_stock) and self.auto_accounting_for_stock: from erpnext.controllers.stock_controller import update_gl_entries_after items, warehouses = self.get_items_and_warehouses() update_gl_entries_after(self.posting_date, self.posting_time, warehouses, items) elif self.docstatus == 2 and cint(self.update_stock) and self.auto_accounting_for_stock: delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
def make_gl_entries(self, cancel=0, adv_adj=0):
from erpnext.accounts.general_ledger import make_gl_entries
gl_map = []
for d in self.get("accounts"):
if d.debit or d.credit:
account_report_type = frappe.db.get_value("Account", d.account, "report_type")
if account_report_type == "Profit and Loss":
project_name=d.project_name
support_ticket=d.support_ticket
else:
project_name=''
support_ticket=''
gl_map.append(
self.get_gl_dict({
"account": d.account,
"party_type": d.party_type,
"party": d.party,
"against": d.against_account,
"debit": flt(d.debit, d.precision("debit")),
"credit": flt(d.credit, d.precision("credit")),
"account_currency": d.account_currency,
"debit_in_account_currency": flt(d.debit_in_account_currency, d.precision("debit_in_account_currency")),
"credit_in_account_currency": flt(d.credit_in_account_currency, d.precision("credit_in_account_currency")),
"against_voucher_type": d.reference_type,
"against_voucher": d.reference_name,
"remarks": self.remark,
"cost_center": d.cost_center,
"project_name": project_name,
"support_ticket": support_ticket
})
)
if gl_map:
make_gl_entries(gl_map, cancel=cancel, adv_adj=adv_adj)
def make_gl_entries(self):
auto_accounting_for_stock = \
cint(frappe.defaults.get_global_default("auto_accounting_for_stock"))
stock_received_but_not_billed = self.get_company_default("stock_received_but_not_billed")
expenses_included_in_valuation = self.get_company_default("expenses_included_in_valuation")
gl_entries = []
# parent's gl entry
if self.base_grand_total:
gl_entries.append(
self.get_gl_dict({
"account": self.credit_to,
"party_type": "Supplier",
"party": self.supplier,
"against": self.against_expense_account,
"credit": self.total_amount_to_pay,
"remarks": self.remarks,
"against_voucher": self.name,
"against_voucher_type": self.doctype,
})
)
# tax table gl entries
valuation_tax = {}
for tax in self.get("taxes"):
if tax.category in ("Total", "Valuation and Total") and flt(tax.base_tax_amount_after_discount_amount):
gl_entries.append(
self.get_gl_dict({
"account": tax.account_head,
"against": self.credit_to,
"debit": tax.add_deduct_tax == "Add" and tax.base_tax_amount_after_discount_amount or 0,
"credit": tax.add_deduct_tax == "Deduct" and tax.base_tax_amount_after_discount_amount or 0,
"remarks": self.remarks,
"cost_center": tax.cost_center
})
)
# accumulate valuation tax
if self.is_opening == "No" and tax.category in ("Valuation", "Valuation and Total") and flt(tax.base_tax_amount_after_discount_amount):
if auto_accounting_for_stock and not tax.cost_center:
frappe.throw(_("Cost Center is required in row {0} in Taxes table for type {1}").format(tax.idx, _(tax.category)))
valuation_tax.setdefault(tax.cost_center, 0)
valuation_tax[tax.cost_center] += \
(tax.add_deduct_tax == "Add" and 1 or -1) * flt(tax.base_tax_amount_after_discount_amount)
# item gl entries
negative_expense_to_be_booked = 0.0
stock_items = self.get_stock_items()
for item in self.get("items"):
if flt(item.base_net_amount):
gl_entries.append(
self.get_gl_dict({
"account": item.expense_account,
"against": self.credit_to,
"debit": item.base_net_amount,
"remarks": self.remarks,
"cost_center": item.cost_center
})
)
if auto_accounting_for_stock and self.is_opening == "No" and \
item.item_code in stock_items and item.item_tax_amount:
# Post reverse entry for Stock-Received-But-Not-Billed if it is booked in Purchase Receipt
negative_expense_booked_in_pi = None
if item.purchase_receipt:
negative_expense_booked_in_pi = frappe.db.sql("""select name from `tabGL Entry`
where voucher_type='Purchase Receipt' and voucher_no=%s and account=%s""",
(item.purchase_receipt, expenses_included_in_valuation))
if not negative_expense_booked_in_pi:
gl_entries.append(
self.get_gl_dict({
"account": stock_received_but_not_billed,
"against": self.credit_to,
"debit": flt(item.item_tax_amount, self.precision("item_tax_amount", item)),
"remarks": self.remarks or "Accounting Entry for Stock"
})
)
negative_expense_to_be_booked += flt(item.item_tax_amount, self.precision("item_tax_amount", item))
if self.is_opening == "No" and negative_expense_to_be_booked and valuation_tax:
# credit valuation tax amount in "Expenses Included In Valuation"
# this will balance out valuation amount included in cost of goods sold
total_valuation_amount = sum(valuation_tax.values())
amount_including_divisional_loss = negative_expense_to_be_booked
i = 1
for cost_center, amount in valuation_tax.items():
if i == len(valuation_tax):
applicable_amount = amount_including_divisional_loss
else:
applicable_amount = negative_expense_to_be_booked * (amount / total_valuation_amount)
amount_including_divisional_loss -= applicable_amount
gl_entries.append(
self.get_gl_dict({
"account": expenses_included_in_valuation,
"cost_center": cost_center,
"against": self.credit_to,
"credit": applicable_amount,
"remarks": self.remarks or "Accounting Entry for Stock"
})
)
i += 1
# writeoff account includes petty difference in the invoice amount
# and the amount that is paid
if self.write_off_account and flt(self.write_off_amount):
gl_entries.append(
self.get_gl_dict({
"account": self.write_off_account,
"against": self.credit_to,
"credit": flt(self.write_off_amount),
"remarks": self.remarks,
"cost_center": self.write_off_cost_center
})
)
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries, cancel=(self.docstatus == 2))
def make_gl(self, account_currency=None):
from erpnext.accounts.general_ledger import make_gl_entries
gl_map = []
ds_settings = get_drop_ship_settings(self.company)
ia = ds_settings["income_account"]
ra = ds_settings["receivable_account"]
pa = ds_settings["payable_account"]
cc = ds_settings["cost_center"]
gl_dict = frappe._dict({
'company': self.company,
'posting_date': self.posting_date,
'voucher_type': self.doctype,
'voucher_no': self.name,
'remarks': self.get("remarks"),
'fiscal_year': self.fiscal_year,
'account': ia,
'cost_center': cc,
'debit': flt(0),
'credit': flt(flt(self.total_commission) - flt(self.purchase_tax_total)), # if self.purchase_tax_total else flt(self.total_commission)
'debit_in_account_currency': 0,
'credit_in_account_currency': 0,
'is_opening': "No", # or self.get("is_opening")
'party_type': "Supplier",
'party': self.supplier
})
if not account_currency:
account_currency = get_account_currency(gl_dict.account)
set_balance_in_account_currency(gl_dict, account_currency, self.conversion_rate, self.company_currency)
gl_map.append(gl_dict)
gl_dict = frappe._dict({
'company': self.company,
'posting_date': self.posting_date,
'voucher_type': self.doctype,
'voucher_no': self.name,
'remarks': self.get("remarks"),
'fiscal_year': self.fiscal_year,
'account': ra,
'debit': flt(self.total),
'credit': flt(0),
'debit_in_account_currency': 0,
'credit_in_account_currency': 0,
'is_opening': "No", # or self.get("is_opening")
'party_type': "Customer",
'party': self.customer
})
if not account_currency:
account_currency = get_account_currency(gl_dict.account)
set_balance_in_account_currency(gl_dict, account_currency, self.conversion_rate, self.company_currency)
gl_map.append(gl_dict)
gl_dict = frappe._dict({
'company': self.company,
'posting_date': self.posting_date,
'voucher_type': self.doctype,
'voucher_no': self.name,
'remarks': self.get("remarks"),
'fiscal_year': self.fiscal_year,
'account': pa,
'debit': flt(0),
'credit': flt(flt(self.purchase_total) + flt(self.purchase_tax_total)), # if self.purchase_tax_total else flt(self.purchase_total),
'debit_in_account_currency': 0,
'credit_in_account_currency': 0,
'is_opening': "No", # or self.get("is_opening")
'party_type': "Supplier",
'party': self.supplier
})
if not account_currency:
account_currency = get_account_currency(gl_dict.account)
set_balance_in_account_currency(gl_dict, account_currency, self.conversion_rate, self.company_currency)
gl_map.append(gl_dict)
if gl_map:
make_gl_entries(gl_map, cancel=0, adv_adj=0)
def post_gl_entry(doc):
comp_doc = frappe.get_doc("Company", doc.company)
gl_map = []
fiscal_year = get_fy(doc)
ec_ded = 0
for earn in doc.earnings:
earn_doc = frappe.get_doc("Salary Component", earn.salary_component)
if earn.amount != 0 and earn.expense_claim is None and earn_doc.only_for_deductions != 1:
#Condition for Earning Posting which is actually paid and not just for calculation
gl_dict = frappe._dict({
'company': doc.company,
'posting_date' : doc.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Salary Slip',
'voucher_no': doc.name,
'account': earn_doc.account,
'cost_center': comp_doc.cost_center,
'debit': flt(earn.amount),
'debit_in_account_currency': flt(earn.amount),
'against': comp_doc.default_payroll_payable_account
})
gl_map.append(gl_dict)
elif earn.expense_claim and earn.amount > 0:
ec_gl_map = []
ec_ded += earn.amount
#Check if the expense claim is already posted if not then post the expense claim
#separately
ec_posted = frappe.db.sql("""SELECT name FROM `tabGL Entry` WHERE docstatus =1 AND
voucher_type = 'Expense Claim' AND voucher_no = '%s'
"""%(earn.expense_claim), as_list=1)
if not ec_posted:
#Post the Expense Claim Separately.
ec_doc = frappe.get_doc("Expense Claim", earn.expense_claim)
for exp in ec_doc.expenses:
ecfy = get_fy(ec_doc)
ec_gl_dict = frappe._dict({
'company': ec_doc.company,
'posting_date' : ec_doc.posting_date,
'fiscal_year': ecfy,
'voucher_type': 'Expense Claim',
'voucher_no': ec_doc.name,
'account': exp.default_account,
'cost_center': comp_doc.cost_center,
'debit': flt(exp.sanctioned_amount),
'debit_in_account_currency': flt(exp.sanctioned_amount),
'against': ec_doc.employee
})
ec_gl_map.append(ec_gl_dict)
ec_gl_dict = frappe._dict({
'company': ec_doc.company,
'posting_date' : ec_doc.posting_date,
'fiscal_year': ecfy,
'voucher_type': 'Expense Claim',
'voucher_no': ec_doc.name,
'account': (ec_doc.payable_account or comp_doc.default_payroll_payable_account),
'cost_center': (ec_doc.cost_center or comp_doc.cost_center),
'party_type': 'Employee',
'party': ec_doc.employee,
'credit': flt(ec_doc.total_sanctioned_amount),
'credit_in_account_currency': flt(ec_doc.total_sanctioned_amount)
})
ec_gl_map.append(ec_gl_dict)
make_gl_entries(ec_gl_map, cancel=0, adv_adj=0)
frappe.msgprint(("Posted Expense Claim # {0}").format(earn.expense_claim))
for ded in doc.deductions:
ded_doc = frappe.get_doc("Salary Component", ded.salary_component)
if flt(ded.amount) > 0 and ded.employee_loan is None:
gl_dict = frappe._dict({
'company': doc.company,
'posting_date' : doc.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Salary Slip',
'voucher_no': doc.name,
'account': ded_doc.account,
'credit': flt(ded.amount),
'credit_in_account_currency': flt(ded.amount),
'against': comp_doc.default_payroll_payable_account
})
gl_map.append(gl_dict)
elif flt(ded.amount) > 0 and ded.employee_loan is not None:
gl_dict = frappe._dict({
'company': doc.company,
'posting_date' : doc.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Salary Slip',
'voucher_no': doc.name,
'account': ded_doc.account,
'credit': flt(ded.amount),
'credit_in_account_currency': flt(ded.amount),
'party_type': 'Employee',
'party': doc.employee,
'against': ded.employee_loan
})
gl_map.append(gl_dict)
if gl_map:
gl_dict = frappe._dict({
'company': doc.company,
'posting_date' : doc.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Salary Slip',
'voucher_no': doc.name,
'account': comp_doc.default_payroll_payable_account,
'credit': flt(doc.rounded_total - ec_ded),
'credit_in_account_currency': flt(doc.rounded_total - ec_ded),
'party_type': 'Employee',
'party': doc.employee,
'against': comp_doc.default_payroll_payable_account
})
gl_map.append(gl_dict)
gl_dict = frappe._dict({
'company': doc.company,
'posting_date' : doc.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Salary Slip',
'voucher_no': doc.name,
'account': comp_doc.round_off_account,
'cost_center': comp_doc.round_off_cost_center,
'debit': flt(doc.rounded_total - doc.net_pay),
'debit_in_account_currency': flt(doc.rounded_total - doc.net_pay),
'against': comp_doc.default_payroll_payable_account
})
gl_map.append(gl_dict)
for cont in doc.contributions:
if cont.amount > 0:
cont_doc = frappe.get_doc("Salary Component", cont.salary_component)
gl_dict = frappe._dict({
'company': doc.company,
'posting_date' : doc.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Salary Slip',
'voucher_no': doc.name,
'account': cont_doc.account,
'cost_center': comp_doc.cost_center,
'debit': flt(cont.amount),
'debit_in_account_currency': flt(cont.amount),
'against': cont_doc.liability_account
})
gl_map.append(gl_dict)
gl_dict = frappe._dict({
'company': doc.company,
'posting_date' : doc.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Salary Slip',
'voucher_no': doc.name,
'account': cont_doc.liability_account,
'credit': flt(cont.amount),
'credit_in_account_currency': flt(cont.amount),
'against': cont_doc.account
})
gl_map.append(gl_dict)
make_gl_entries(gl_map, cancel=0, adv_adj=0)
def execute():
'''
This patch is to cancel the JV associated with Employee Loan and Employee Advance and
then repost the Employee Advance in GL Entry
'''
gl_adv_list = frappe.db.sql("""SELECT name, voucher_no, against_voucher FROM `tabGL Entry`
WHERE docstatus = 1 AND (against_voucher_type = 'Employee Loan' OR
against_voucher_type = 'Employee Advance') AND voucher_type = 'Journal Entry'
GROUP BY voucher_no""", as_list=1)
for jv in gl_adv_list:
jv_doc = frappe.get_doc("Journal Entry", jv[1])
jv_doc.cancel()
print ("Journal Entry #" + jv[1] + " Cancelled.")
#Check and post the employee advance directly into the GL
from erpnext.accounts.general_ledger import make_gl_entries
from erpnext.accounts.utils import get_fiscal_years, validate_fiscal_year, get_account_currency
#Check if emp_adv_doc already posted into the GL or NOT
gl_entry_adv = frappe.db.sql("""SELECT name FROM `tabGL Entry` WHERE
docstatus = 1 AND voucher_type = 'Employee Advance'
AND voucher_no = '%s'""" % (jv[2]), as_list=1)
if gl_entry_adv:
pass
#donot post gl if already exists
else:
emp_adv_doc = frappe.get_doc("Employee Advance", jv[2])
gl_map = []
fiscal_years = get_fiscal_years(emp_adv_doc.posting_date, company='RIGPL')
if len(fiscal_years) > 1:
frappe.throw(_("Multiple fiscal years exist for the date {0}. \
Please set company in Fiscal Year").format(formatdate(self.posting_date)))
else:
fiscal_year = fiscal_years[0][0]
for emp in emp_adv_doc.employee_loan_detail:
if emp.loan_amount:
gl_dict = frappe._dict({
'company': 'RIGPL',
'posting_date' : emp_adv_doc.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Employee Advance',
'voucher_no': emp_adv_doc.name,
'account': emp_adv_doc.debit_account,
'debit': flt(emp.loan_amount),
'debit_in_account_currency': flt(emp.loan_amount),
'party_type': 'Employee',
'party': emp.employee,
'against': emp_adv_doc.credit_account
})
gl_map.append(gl_dict)
if gl_map:
gl_dict = frappe._dict({
'company': 'RIGPL',
'posting_date' : emp_adv_doc.posting_date,
'fiscal_year': fiscal_year,
'voucher_type': 'Employee Advance',
'voucher_no': emp_adv_doc.name,
'account': emp_adv_doc.credit_account,
'debit': 0,
'credit': flt(emp_adv_doc.total_loan),
'credit_in_account_currency' : flt(emp_adv_doc.total_loan),
'debit_in_account_currency': 0,
'against': emp_adv_doc.debit_account
})
gl_map.append(gl_dict)
make_gl_entries(gl_map, cancel=0, adv_adj=0)
print ("Employee Advance #" + emp_adv_doc.name + " Posted to GL Entry")
def make_gl_entries(self, cancel = False): if flt(self.total_sanctioned_amount) > 0: gl_entries = self.get_gl_entries() make_gl_entries(gl_entries, cancel)
def make_gl_entries(self):
auto_accounting_for_stock = \
cint(frappe.defaults.get_global_default("auto_accounting_for_stock"))
gl_entries = []
# parent's gl entry
if self.grand_total:
gl_entries.append(
self.get_gl_dict({
"account": self.credit_to,
"against": self.against_expense_account,
"credit": self.total_amount_to_pay,
"remarks": self.remarks,
"against_voucher": self.name,
"against_voucher_type": self.doctype,
})
)
# tax table gl entries
valuation_tax = {}
for tax in self.get("other_charges"):
if tax.category in ("Total", "Valuation and Total") and flt(tax.tax_amount):
gl_entries.append(
self.get_gl_dict({
"account": tax.account_head,
"against": self.credit_to,
"debit": tax.add_deduct_tax == "Add" and tax.tax_amount or 0,
"credit": tax.add_deduct_tax == "Deduct" and tax.tax_amount or 0,
"remarks": self.remarks,
"cost_center": tax.cost_center
})
)
# accumulate valuation tax
if tax.category in ("Valuation", "Valuation and Total") and flt(tax.tax_amount):
if auto_accounting_for_stock and not tax.cost_center:
frappe.throw(_("Cost Center is required in row {0} in Taxes table for type {1}").format(tax.idx, _(tax.category)))
valuation_tax.setdefault(tax.cost_center, 0)
valuation_tax[tax.cost_center] += \
(tax.add_deduct_tax == "Add" and 1 or -1) * flt(tax.tax_amount)
# item gl entries
stock_item_and_auto_accounting_for_stock = False
stock_items = self.get_stock_items()
for item in self.get("entries"):
if auto_accounting_for_stock and item.item_code in stock_items:
if flt(item.valuation_rate):
# if auto inventory accounting enabled and stock item,
# then do stock related gl entries
# expense will be booked in sales invoice
stock_item_and_auto_accounting_for_stock = True
valuation_amt = flt(item.base_amount + item.item_tax_amount,
self.precision("base_amount", item))
gl_entries.append(
self.get_gl_dict({
"account": item.expense_account,
"against": self.credit_to,
"debit": valuation_amt,
"remarks": self.remarks or "Accounting Entry for Stock"
})
)
elif flt(item.base_amount):
# if not a stock item or auto inventory accounting disabled, book the expense
gl_entries.append(
self.get_gl_dict({
"account": item.expense_account,
"against": self.credit_to,
"debit": item.base_amount,
"remarks": self.remarks,
"cost_center": item.cost_center
})
)
if stock_item_and_auto_accounting_for_stock and valuation_tax:
# credit valuation tax amount in "Expenses Included In Valuation"
# this will balance out valuation amount included in cost of goods sold
expenses_included_in_valuation = \
self.get_company_default("expenses_included_in_valuation")
for cost_center, amount in valuation_tax.items():
gl_entries.append(
self.get_gl_dict({
"account": expenses_included_in_valuation,
"cost_center": cost_center,
"against": self.credit_to,
"credit": amount,
"remarks": self.remarks or "Accounting Entry for Stock"
})
)
# writeoff account includes petty difference in the invoice amount
# and the amount that is paid
if self.write_off_account and flt(self.write_off_amount):
gl_entries.append(
self.get_gl_dict({
"account": self.write_off_account,
"against": self.credit_to,
"credit": flt(self.write_off_amount),
"remarks": self.remarks,
"cost_center": self.write_off_cost_center
})
)
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries, cancel=(self.docstatus == 2))
