mirror of
https://github.com/frappe/erpnext.git
synced 2026-08-29 22:58:25 +00:00
13d06e77b4
Pure MariaDB-identical conversion (raw frappe.db.sql -> frappe.qb / portable functions) for Postgres compatibility. Split out of #56082. general_ledger, gl_entry, gl_validator, period_closing_voucher, deferred_revenue, process_payment_reconciliation + their tests. No behaviour change on MariaDB; verified equivalent and the suites pass on both engines. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
738 lines
22 KiB
Python
738 lines
22 KiB
Python
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
|
|
# License: GNU General Public License v3. See license.txt
|
|
|
|
|
|
import copy
|
|
|
|
import frappe
|
|
from frappe import _
|
|
from frappe.model.meta import get_field_precision
|
|
from frappe.utils import cint, flt, get_link_to_form, getdate, now
|
|
from frappe.utils.caching import request_cache
|
|
|
|
import erpnext
|
|
from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
|
|
get_accounting_dimensions,
|
|
get_checks_for_pl_and_bs_accounts,
|
|
)
|
|
from erpnext.accounts.doctype.accounting_dimension_filter.accounting_dimension_filter import (
|
|
get_dimension_filter_map,
|
|
)
|
|
from erpnext.accounts.doctype.budget.budget import validate_expense_against_budget
|
|
from erpnext.accounts.services.gl_validator import (
|
|
check_freezing_date,
|
|
validate_accounting_period,
|
|
validate_against_pcv,
|
|
validate_allowed_dimensions,
|
|
validate_cwip_accounts,
|
|
validate_disabled_accounts,
|
|
)
|
|
from erpnext.accounts.utils import create_payment_ledger_entry, is_immutable_ledger_enabled
|
|
from erpnext.controllers.budget_controller import BudgetValidation
|
|
|
|
|
|
def make_gl_entries(
|
|
gl_map,
|
|
cancel=False,
|
|
adv_adj=False,
|
|
merge_entries=True,
|
|
update_outstanding="Yes",
|
|
from_repost=False,
|
|
):
|
|
if gl_map:
|
|
if (
|
|
not cancel
|
|
and not cint(frappe.get_single_value("Accounts Settings", "use_legacy_budget_controller"))
|
|
and gl_map[0].voucher_type != "Period Closing Voucher"
|
|
):
|
|
bud_val = BudgetValidation(gl_map=gl_map)
|
|
bud_val.validate()
|
|
|
|
if not cancel:
|
|
make_acc_dimensions_offsetting_entry(gl_map)
|
|
validate_accounting_period(gl_map)
|
|
validate_disabled_accounts(gl_map)
|
|
gl_map = process_gl_map(gl_map, merge_entries, from_repost=from_repost)
|
|
if gl_map and len(gl_map) > 1:
|
|
if gl_map[0].voucher_type != "Period Closing Voucher":
|
|
create_payment_ledger_entry(
|
|
gl_map,
|
|
cancel=0,
|
|
adv_adj=adv_adj,
|
|
update_outstanding=update_outstanding,
|
|
from_repost=from_repost,
|
|
)
|
|
save_entries(gl_map, adv_adj, update_outstanding, from_repost)
|
|
# Post GL Map process there may no be any GL Entries
|
|
elif gl_map:
|
|
frappe.throw(
|
|
_(
|
|
"Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction."
|
|
)
|
|
)
|
|
else:
|
|
make_reverse_gl_entries(gl_map, adv_adj=adv_adj, update_outstanding=update_outstanding)
|
|
|
|
|
|
def make_acc_dimensions_offsetting_entry(gl_map):
|
|
accounting_dimensions_to_offset = get_accounting_dimensions_for_offsetting_entry(
|
|
gl_map, gl_map[0].company
|
|
)
|
|
no_of_dimensions = len(accounting_dimensions_to_offset)
|
|
if no_of_dimensions == 0:
|
|
return
|
|
|
|
offsetting_entries = []
|
|
|
|
for gle in gl_map:
|
|
for dimension in accounting_dimensions_to_offset:
|
|
offsetting_entry = gle.copy()
|
|
debit = flt(gle.credit) / no_of_dimensions if gle.credit != 0 else 0
|
|
credit = flt(gle.debit) / no_of_dimensions if gle.debit != 0 else 0
|
|
offsetting_entry.update(
|
|
{
|
|
"account": dimension.offsetting_account,
|
|
"debit": debit,
|
|
"credit": credit,
|
|
"debit_in_account_currency": debit,
|
|
"credit_in_account_currency": credit,
|
|
"remarks": _("Offsetting for Accounting Dimension") + f" - {dimension.name}",
|
|
"against_voucher": None,
|
|
"account_currency": dimension.account_currency,
|
|
# Party Type and Party are restricted to Receivable and Payable accounts
|
|
"party_type": None,
|
|
"party": None,
|
|
}
|
|
)
|
|
offsetting_entry["against_voucher_type"] = None
|
|
offsetting_entries.append(offsetting_entry)
|
|
|
|
gl_map += offsetting_entries
|
|
|
|
|
|
def get_accounting_dimensions_for_offsetting_entry(gl_map, company):
|
|
acc_dimension = frappe.qb.DocType("Accounting Dimension")
|
|
dimension_detail = frappe.qb.DocType("Accounting Dimension Detail")
|
|
|
|
acc_dimensions = (
|
|
frappe.qb.from_(acc_dimension)
|
|
.inner_join(dimension_detail)
|
|
.on(acc_dimension.name == dimension_detail.parent)
|
|
.select(acc_dimension.fieldname, acc_dimension.name, dimension_detail.offsetting_account)
|
|
.where(
|
|
(acc_dimension.disabled == 0)
|
|
& (dimension_detail.company == company)
|
|
& (dimension_detail.automatically_post_balancing_accounting_entry == 1)
|
|
)
|
|
).run(as_dict=True)
|
|
|
|
accounting_dimensions_to_offset = []
|
|
for acc_dimension in acc_dimensions:
|
|
values = set([entry.get(acc_dimension.fieldname) for entry in gl_map])
|
|
acc_dimension.account_currency = frappe.get_cached_value(
|
|
"Account", acc_dimension.offsetting_account, "account_currency"
|
|
)
|
|
if len(values) > 1:
|
|
accounting_dimensions_to_offset.append(acc_dimension)
|
|
|
|
return accounting_dimensions_to_offset
|
|
|
|
|
|
def process_gl_map(gl_map, merge_entries=True, precision=None, from_repost=False):
|
|
if not gl_map:
|
|
return []
|
|
|
|
if gl_map[0].voucher_type != "Period Closing Voucher":
|
|
gl_map = distribute_gl_based_on_cost_center_allocation(gl_map, precision, from_repost)
|
|
|
|
if merge_entries:
|
|
gl_map = merge_similar_entries(gl_map, precision)
|
|
|
|
gl_map = toggle_debit_credit_if_negative(gl_map)
|
|
|
|
return gl_map
|
|
|
|
|
|
def distribute_gl_based_on_cost_center_allocation(gl_map, precision=None, from_repost=False):
|
|
round_off_account, default_currency = frappe.get_cached_value(
|
|
"Company", gl_map[0].company, ["round_off_account", "default_currency"]
|
|
)
|
|
if not precision:
|
|
precision = get_field_precision(
|
|
frappe.get_meta("GL Entry").get_field("debit"),
|
|
currency=default_currency,
|
|
)
|
|
|
|
new_gl_map = []
|
|
for d in gl_map:
|
|
cost_center = d.get("cost_center")
|
|
|
|
cost_center_allocation = get_cost_center_allocation_data(
|
|
gl_map[0]["company"], gl_map[0]["posting_date"], cost_center
|
|
)
|
|
|
|
if not cost_center_allocation:
|
|
new_gl_map.append(d)
|
|
continue
|
|
|
|
# Validate budget against main cost center
|
|
if not from_repost:
|
|
validate_expense_against_budget(
|
|
d, expense_amount=flt(d.debit, precision) - flt(d.credit, precision)
|
|
)
|
|
|
|
if d.account == round_off_account:
|
|
d.cost_center = cost_center_allocation[0][0]
|
|
new_gl_map.append(d)
|
|
continue
|
|
|
|
for sub_cost_center, percentage in cost_center_allocation:
|
|
gle = copy.deepcopy(d)
|
|
gle.cost_center = sub_cost_center
|
|
for field in ("debit", "credit", "debit_in_account_currency", "credit_in_account_currency"):
|
|
gle[field] = flt(flt(d.get(field)) * percentage / 100, precision)
|
|
new_gl_map.append(gle)
|
|
|
|
return new_gl_map
|
|
|
|
|
|
@request_cache
|
|
def get_cost_center_allocation_data(company, posting_date, cost_center):
|
|
cost_center_allocation = frappe.db.get_value(
|
|
"Cost Center Allocation",
|
|
{
|
|
"docstatus": 1,
|
|
"company": company,
|
|
"valid_from": ("<=", posting_date),
|
|
"main_cost_center": cost_center,
|
|
},
|
|
pluck=True,
|
|
order_by="valid_from desc",
|
|
)
|
|
|
|
if not cost_center_allocation:
|
|
return []
|
|
|
|
records = frappe.db.get_all(
|
|
"Cost Center Allocation Percentage",
|
|
{"parent": cost_center_allocation},
|
|
["cost_center", "percentage"],
|
|
as_list=True,
|
|
)
|
|
|
|
return records
|
|
|
|
|
|
def merge_similar_entries(gl_map, precision=None):
|
|
merged_gl_map = []
|
|
accounting_dimensions = get_accounting_dimensions()
|
|
merge_properties = get_merge_properties(accounting_dimensions)
|
|
|
|
for entry in gl_map:
|
|
if entry._skip_merge:
|
|
merged_gl_map.append(entry)
|
|
continue
|
|
|
|
entry.merge_key = get_merge_key(entry, merge_properties)
|
|
# if there is already an entry in this account then just add it
|
|
# to that entry
|
|
same_head = check_if_in_list(entry, merged_gl_map)
|
|
if same_head:
|
|
same_head.debit = flt(same_head.debit) + flt(entry.debit)
|
|
same_head.debit_in_account_currency = flt(same_head.debit_in_account_currency) + flt(
|
|
entry.debit_in_account_currency
|
|
)
|
|
same_head.debit_in_transaction_currency = flt(same_head.debit_in_transaction_currency) + flt(
|
|
entry.debit_in_transaction_currency
|
|
)
|
|
same_head.credit = flt(same_head.credit) + flt(entry.credit)
|
|
same_head.credit_in_account_currency = flt(same_head.credit_in_account_currency) + flt(
|
|
entry.credit_in_account_currency
|
|
)
|
|
same_head.credit_in_transaction_currency = flt(same_head.credit_in_transaction_currency) + flt(
|
|
entry.credit_in_transaction_currency
|
|
)
|
|
else:
|
|
merged_gl_map.append(entry)
|
|
|
|
company = gl_map[0].company if gl_map else erpnext.get_default_company()
|
|
company_currency = erpnext.get_company_currency(company)
|
|
|
|
if not precision:
|
|
precision = get_field_precision(
|
|
frappe.get_meta("GL Entry").get_field("debit"), currency=company_currency
|
|
)
|
|
|
|
# filter zero debit and credit entries
|
|
merged_gl_map = filter(
|
|
lambda x: flt(x.debit, precision) != 0
|
|
or flt(x.credit, precision) != 0
|
|
or (
|
|
x.voucher_type == "Journal Entry"
|
|
and frappe.get_cached_value("Journal Entry", x.voucher_no, "voucher_type")
|
|
== "Exchange Gain Or Loss"
|
|
),
|
|
merged_gl_map,
|
|
)
|
|
merged_gl_map = list(merged_gl_map)
|
|
|
|
return merged_gl_map
|
|
|
|
|
|
def get_merge_properties(dimensions=None):
|
|
merge_properties = [
|
|
"account",
|
|
"cost_center",
|
|
"party",
|
|
"party_type",
|
|
"voucher_detail_no",
|
|
"against_voucher",
|
|
"against_voucher_type",
|
|
"project",
|
|
"finance_book",
|
|
"voucher_no",
|
|
"advance_voucher_type",
|
|
"advance_voucher_no",
|
|
]
|
|
if dimensions:
|
|
merge_properties.extend(dimensions)
|
|
return merge_properties
|
|
|
|
|
|
def get_merge_key(entry, merge_properties):
|
|
merge_key = []
|
|
for fieldname in merge_properties:
|
|
merge_key.append(entry.get(fieldname, ""))
|
|
|
|
return tuple(merge_key)
|
|
|
|
|
|
def check_if_in_list(gle, gl_map):
|
|
for e in gl_map:
|
|
if e.merge_key == gle.merge_key:
|
|
return e
|
|
|
|
|
|
def toggle_debit_credit_if_negative(gl_map):
|
|
debit_credit_field_map = {
|
|
"debit": "credit",
|
|
"debit_in_account_currency": "credit_in_account_currency",
|
|
"debit_in_transaction_currency": "credit_in_transaction_currency",
|
|
}
|
|
|
|
for entry in gl_map:
|
|
# toggle debit, credit if negative entry
|
|
for debit_field, credit_field in debit_credit_field_map.items():
|
|
debit = flt(entry.get(debit_field))
|
|
credit = flt(entry.get(credit_field))
|
|
|
|
if debit < 0 and credit < 0 and debit == credit:
|
|
debit *= -1
|
|
credit *= -1
|
|
|
|
if debit < 0:
|
|
credit = credit - debit
|
|
debit = 0.0
|
|
|
|
if credit < 0:
|
|
debit = debit - credit
|
|
credit = 0.0
|
|
|
|
# update net values
|
|
# In some scenarios net value needs to be shown in the ledger
|
|
# This method updates net values as debit or credit
|
|
if entry.post_net_value and debit and credit:
|
|
if debit > credit:
|
|
debit = debit - credit
|
|
credit = 0.0
|
|
|
|
else:
|
|
credit = credit - debit
|
|
debit = 0.0
|
|
|
|
entry[debit_field] = debit
|
|
entry[credit_field] = credit
|
|
|
|
return gl_map
|
|
|
|
|
|
def save_entries(gl_map, adv_adj, update_outstanding, from_repost=False):
|
|
if not from_repost:
|
|
validate_cwip_accounts(gl_map)
|
|
|
|
process_debit_credit_difference(gl_map)
|
|
|
|
dimension_filter_map = get_dimension_filter_map()
|
|
if gl_map:
|
|
check_freezing_date(gl_map[0]["posting_date"], gl_map[0]["company"], adv_adj)
|
|
is_opening = any(d.get("is_opening") == "Yes" for d in gl_map)
|
|
if gl_map[0]["voucher_type"] != "Period Closing Voucher":
|
|
validate_against_pcv(is_opening, gl_map[0]["posting_date"], gl_map[0]["company"])
|
|
|
|
for entry in gl_map:
|
|
validate_allowed_dimensions(entry, dimension_filter_map)
|
|
make_entry(entry, adv_adj, update_outstanding, from_repost)
|
|
|
|
|
|
def make_entry(args, adv_adj, update_outstanding, from_repost=False):
|
|
gle = frappe.new_doc("GL Entry")
|
|
gle.update(args)
|
|
gle.flags.ignore_permissions = 1
|
|
gle.flags.from_repost = from_repost
|
|
gle.flags.adv_adj = adv_adj
|
|
gle.flags.update_outstanding = update_outstanding or "Yes"
|
|
gle.flags.notify_update = False
|
|
if gle.is_cancelled or is_immutable_ledger_enabled():
|
|
gle.flags.ignore_links = True
|
|
gle.submit()
|
|
|
|
if (
|
|
not from_repost
|
|
and gle.voucher_type != "Period Closing Voucher"
|
|
and (gle.is_cancelled == 0 or gle.voucher_type == "Journal Entry")
|
|
):
|
|
validate_expense_against_budget(args)
|
|
|
|
|
|
def process_debit_credit_difference(gl_map):
|
|
precision = get_field_precision(
|
|
frappe.get_meta("GL Entry").get_field("debit"),
|
|
currency=frappe.get_cached_value("Company", gl_map[0].company, "default_currency"),
|
|
)
|
|
|
|
voucher_type = gl_map[0].voucher_type
|
|
voucher_no = gl_map[0].voucher_no
|
|
allowance = get_debit_credit_allowance(voucher_type, precision)
|
|
|
|
debit_credit_diff, trx_cur_debit_credit_diff = get_debit_credit_difference(gl_map, precision)
|
|
|
|
if abs(debit_credit_diff) > allowance:
|
|
if not (
|
|
voucher_type == "Journal Entry"
|
|
and frappe.get_cached_value("Journal Entry", voucher_no, "voucher_type")
|
|
== "Exchange Gain Or Loss"
|
|
):
|
|
raise_debit_credit_not_equal_error(debit_credit_diff, voucher_type, voucher_no)
|
|
|
|
elif abs(debit_credit_diff) >= (1.0 / (10**precision)):
|
|
make_round_off_gle(gl_map, debit_credit_diff, trx_cur_debit_credit_diff, precision)
|
|
|
|
debit_credit_diff, trx_cur_debit_credit_diff = get_debit_credit_difference(gl_map, precision)
|
|
if abs(debit_credit_diff) > allowance:
|
|
if not (
|
|
voucher_type == "Journal Entry"
|
|
and frappe.get_cached_value("Journal Entry", voucher_no, "voucher_type")
|
|
== "Exchange Gain Or Loss"
|
|
):
|
|
raise_debit_credit_not_equal_error(debit_credit_diff, voucher_type, voucher_no)
|
|
|
|
|
|
def get_debit_credit_difference(gl_map, precision):
|
|
debit_credit_diff = 0.0
|
|
trx_cur_debit_credit_diff = 0
|
|
|
|
for entry in gl_map:
|
|
entry.debit = flt(entry.debit, precision)
|
|
entry.credit = flt(entry.credit, precision)
|
|
debit_credit_diff += entry.debit - entry.credit
|
|
|
|
entry.debit_in_transaction_currency = flt(entry.debit_in_transaction_currency, precision)
|
|
entry.credit_in_transaction_currency = flt(entry.credit_in_transaction_currency, precision)
|
|
trx_cur_debit_credit_diff += (
|
|
entry.debit_in_transaction_currency - entry.credit_in_transaction_currency
|
|
)
|
|
|
|
debit_credit_diff = flt(debit_credit_diff, precision)
|
|
trx_cur_debit_credit_diff = flt(trx_cur_debit_credit_diff, precision)
|
|
|
|
return debit_credit_diff, trx_cur_debit_credit_diff
|
|
|
|
|
|
def get_debit_credit_allowance(voucher_type, precision):
|
|
if voucher_type in ("Journal Entry", "Payment Entry"):
|
|
allowance = 5.0 / (10**precision)
|
|
else:
|
|
allowance = 0.5
|
|
|
|
return allowance
|
|
|
|
|
|
def raise_debit_credit_not_equal_error(debit_credit_diff, voucher_type, voucher_no):
|
|
frappe.throw(
|
|
_("Debit and Credit not equal for {0} #{1}. Difference is {2}.").format(
|
|
voucher_type, voucher_no, debit_credit_diff
|
|
)
|
|
)
|
|
|
|
|
|
def has_opening_entries(gl_map: list) -> bool:
|
|
for x in gl_map:
|
|
if x.is_opening == "Yes":
|
|
return True
|
|
return False
|
|
|
|
|
|
def make_round_off_gle(gl_map, debit_credit_diff, trx_cur_debit_credit_diff, precision):
|
|
round_off_account, round_off_cost_center, round_off_for_opening = get_round_off_account_and_cost_center(
|
|
gl_map[0].company, gl_map[0].voucher_type, gl_map[0].voucher_no
|
|
)
|
|
round_off_gle = frappe._dict()
|
|
round_off_account_exists = False
|
|
has_opening_entry = has_opening_entries(gl_map)
|
|
|
|
if has_opening_entry:
|
|
if not round_off_for_opening:
|
|
frappe.throw(
|
|
_("Please set '{0}' in Company: {1}").format(
|
|
frappe.bold("Round Off for Opening"), get_link_to_form("Company", gl_map[0].company)
|
|
)
|
|
)
|
|
|
|
account = round_off_for_opening
|
|
else:
|
|
account = round_off_account
|
|
|
|
if gl_map[0].voucher_type != "Period Closing Voucher":
|
|
for d in gl_map:
|
|
if d.account == account:
|
|
round_off_gle = d
|
|
if d.debit:
|
|
debit_credit_diff -= flt(d.debit) - flt(d.credit)
|
|
else:
|
|
debit_credit_diff += flt(d.credit)
|
|
round_off_account_exists = True
|
|
|
|
if round_off_account_exists and abs(debit_credit_diff) < (1.0 / (10**precision)):
|
|
gl_map.remove(round_off_gle)
|
|
return
|
|
|
|
if not round_off_gle:
|
|
for k in ["voucher_type", "voucher_no", "company", "posting_date", "remarks"]:
|
|
round_off_gle[k] = gl_map[0][k]
|
|
|
|
round_off_gle.update(
|
|
{
|
|
"account": account,
|
|
"debit_in_account_currency": abs(debit_credit_diff) if debit_credit_diff < 0 else 0,
|
|
"credit_in_account_currency": debit_credit_diff if debit_credit_diff > 0 else 0,
|
|
"debit": abs(debit_credit_diff) if debit_credit_diff < 0 else 0,
|
|
"credit": debit_credit_diff if debit_credit_diff > 0 else 0,
|
|
"debit_in_transaction_currency": abs(trx_cur_debit_credit_diff)
|
|
if trx_cur_debit_credit_diff < 0
|
|
else 0,
|
|
"credit_in_transaction_currency": trx_cur_debit_credit_diff
|
|
if trx_cur_debit_credit_diff > 0
|
|
else 0,
|
|
"cost_center": round_off_cost_center,
|
|
"party_type": None,
|
|
"party": None,
|
|
"is_opening": "No",
|
|
"against_voucher_type": None,
|
|
"against_voucher": None,
|
|
}
|
|
)
|
|
|
|
if has_opening_entry:
|
|
round_off_gle.update({"is_opening": "Yes"})
|
|
|
|
update_accounting_dimensions(round_off_gle)
|
|
if not round_off_account_exists:
|
|
gl_map.append(round_off_gle)
|
|
|
|
|
|
def update_accounting_dimensions(round_off_gle):
|
|
dimensions = get_accounting_dimensions()
|
|
meta = frappe.get_meta(round_off_gle["voucher_type"])
|
|
has_all_dimensions = True
|
|
|
|
for dimension in dimensions:
|
|
if not meta.has_field(dimension):
|
|
has_all_dimensions = False
|
|
|
|
if dimensions and has_all_dimensions:
|
|
dimension_values = frappe.db.get_value(
|
|
round_off_gle["voucher_type"], round_off_gle["voucher_no"], dimensions, as_dict=1
|
|
)
|
|
|
|
for dimension in dimensions:
|
|
round_off_gle[dimension] = dimension_values.get(dimension)
|
|
else:
|
|
report_type = frappe.get_cached_value("Account", round_off_gle.account, "report_type")
|
|
for dimension in get_checks_for_pl_and_bs_accounts():
|
|
if (
|
|
round_off_gle.company == dimension.company
|
|
and (
|
|
(report_type == "Profit and Loss" and dimension.mandatory_for_pl)
|
|
or (report_type == "Balance Sheet" and dimension.mandatory_for_bs)
|
|
)
|
|
and dimension.default_dimension
|
|
):
|
|
round_off_gle[dimension.fieldname] = dimension.default_dimension
|
|
|
|
|
|
def get_round_off_account_and_cost_center(company, voucher_type, voucher_no, use_company_default=False):
|
|
round_off_account, round_off_cost_center, round_off_for_opening = frappe.get_cached_value(
|
|
"Company", company, ["round_off_account", "round_off_cost_center", "round_off_for_opening"]
|
|
) or [None, None, None]
|
|
|
|
# Use expense account as fallback
|
|
if not round_off_account:
|
|
round_off_account = frappe.get_cached_value("Company", company, "default_expense_account")
|
|
|
|
meta = frappe.get_meta(voucher_type)
|
|
|
|
# Give first preference to parent cost center for round off GLE
|
|
if not use_company_default and meta.has_field("cost_center"):
|
|
parent_cost_center = frappe.db.get_value(voucher_type, voucher_no, "cost_center")
|
|
if parent_cost_center:
|
|
round_off_cost_center = parent_cost_center
|
|
|
|
if not round_off_account:
|
|
frappe.throw(
|
|
_("Please mention '{0}' in Company: {1}").format(
|
|
frappe.bold("Round Off Account"), get_link_to_form("Company", company)
|
|
)
|
|
)
|
|
|
|
if not round_off_cost_center:
|
|
frappe.throw(
|
|
_("Please mention '{0}' in Company: {1}").format(
|
|
frappe.bold("Round Off Cost Center"), get_link_to_form("Company", company)
|
|
)
|
|
)
|
|
|
|
return round_off_account, round_off_cost_center, round_off_for_opening
|
|
|
|
|
|
def make_reverse_gl_entries(
|
|
gl_entries=None,
|
|
voucher_type=None,
|
|
voucher_no=None,
|
|
adv_adj=False,
|
|
update_outstanding="Yes",
|
|
partial_cancel=False,
|
|
posting_date=None,
|
|
):
|
|
"""
|
|
Get original gl entries of the voucher
|
|
and make reverse gl entries by swapping debit and credit
|
|
"""
|
|
|
|
immutable_ledger_enabled = is_immutable_ledger_enabled()
|
|
|
|
if not gl_entries:
|
|
gl_entry = frappe.qb.DocType("GL Entry")
|
|
gl_entries = (
|
|
frappe.qb.from_(gl_entry)
|
|
.select("*")
|
|
.where(gl_entry.voucher_type == voucher_type)
|
|
.where(gl_entry.voucher_no == voucher_no)
|
|
.where(gl_entry.is_cancelled == 0)
|
|
.for_update()
|
|
).run(as_dict=1)
|
|
|
|
if gl_entries:
|
|
create_payment_ledger_entry(
|
|
gl_entries,
|
|
cancel=1,
|
|
adv_adj=adv_adj,
|
|
update_outstanding=update_outstanding,
|
|
partial_cancel=partial_cancel,
|
|
)
|
|
validate_accounting_period(gl_entries)
|
|
check_freezing_date(gl_entries[0]["posting_date"], gl_entries[0]["company"], adv_adj)
|
|
|
|
is_opening = any(d.get("is_opening") == "Yes" for d in gl_entries)
|
|
|
|
# For reverse entries, use the posting_date parameter if provided and valid
|
|
# Otherwise fall back to original posting_date
|
|
validation_date = posting_date if posting_date else gl_entries[0]["posting_date"]
|
|
validate_against_pcv(is_opening, validation_date, gl_entries[0]["company"])
|
|
|
|
if partial_cancel:
|
|
# Partial cancel is only used by `Advance` in separate account feature.
|
|
# Only cancel GL entries for unlinked reference using `voucher_detail_no`
|
|
gle = frappe.qb.DocType("GL Entry")
|
|
for x in gl_entries:
|
|
query = (
|
|
frappe.qb.update(gle)
|
|
.set(gle.modified, now())
|
|
.set(gle.modified_by, frappe.session.user)
|
|
.where(
|
|
(gle.company == x.company)
|
|
& (gle.account == x.account)
|
|
& (gle.party_type == x.party_type)
|
|
& (gle.party == x.party)
|
|
& (gle.voucher_type == x.voucher_type)
|
|
& (gle.voucher_no == x.voucher_no)
|
|
& (gle.against_voucher_type == x.against_voucher_type)
|
|
& (gle.against_voucher == x.against_voucher)
|
|
& (gle.voucher_detail_no == x.voucher_detail_no)
|
|
)
|
|
)
|
|
|
|
if not immutable_ledger_enabled:
|
|
query = query.set(gle.is_cancelled, 1) # smallint column; postgres rejects boolean true
|
|
|
|
query.run()
|
|
else:
|
|
if not immutable_ledger_enabled:
|
|
gle_names = [x.get("name") for x in gl_entries]
|
|
|
|
# if names are available, cancel only that set of entries
|
|
if not all(gle_names):
|
|
set_as_cancel(gl_entries[0]["voucher_type"], gl_entries[0]["voucher_no"])
|
|
else:
|
|
gle = frappe.qb.DocType("GL Entry")
|
|
(
|
|
frappe.qb.update(gle)
|
|
.set(gle.is_cancelled, 1)
|
|
.set(gle.modified, now())
|
|
.set(gle.modified_by, frappe.session.user)
|
|
.where(gle.name.isin(gle_names) & (gle.is_cancelled == 0))
|
|
).run()
|
|
|
|
for entry in gl_entries:
|
|
new_gle = copy.deepcopy(entry)
|
|
new_gle["name"] = None
|
|
debit = new_gle.get("debit", 0)
|
|
credit = new_gle.get("credit", 0)
|
|
|
|
debit_in_account_currency = new_gle.get("debit_in_account_currency", 0)
|
|
credit_in_account_currency = new_gle.get("credit_in_account_currency", 0)
|
|
debit_in_transaction_currency = new_gle.get("debit_in_transaction_currency", 0)
|
|
credit_in_transaction_currency = new_gle.get("credit_in_transaction_currency", 0)
|
|
|
|
new_gle["debit"] = credit
|
|
new_gle["credit"] = debit
|
|
new_gle["debit_in_account_currency"] = credit_in_account_currency
|
|
new_gle["credit_in_account_currency"] = debit_in_account_currency
|
|
new_gle["debit_in_transaction_currency"] = credit_in_transaction_currency
|
|
new_gle["credit_in_transaction_currency"] = debit_in_transaction_currency
|
|
|
|
new_gle["remarks"] = "On cancellation of " + new_gle["voucher_no"]
|
|
new_gle["is_cancelled"] = 1
|
|
|
|
if immutable_ledger_enabled:
|
|
new_gle["is_cancelled"] = 0
|
|
new_gle["posting_date"] = frappe.form_dict.get("posting_date") or getdate()
|
|
elif posting_date:
|
|
new_gle["posting_date"] = posting_date
|
|
|
|
if new_gle["debit"] or new_gle["credit"]:
|
|
make_entry(new_gle, adv_adj, "Yes")
|
|
|
|
|
|
def set_as_cancel(voucher_type, voucher_no):
|
|
"""
|
|
Set is_cancelled=1 in all original gl entries for the voucher
|
|
"""
|
|
gle = frappe.qb.DocType("GL Entry")
|
|
(
|
|
frappe.qb.update(gle)
|
|
.set(gle.is_cancelled, 1)
|
|
.set(gle.modified, now())
|
|
.set(gle.modified_by, frappe.session.user)
|
|
.where((gle.voucher_type == voucher_type) & (gle.voucher_no == voucher_no) & (gle.is_cancelled == 0))
|
|
).run()
|