chore(release): Bumped to Version 15.101.3

## [15.101.3](https://github.com/frappe/erpnext/compare/v15.101.2...v15.101.3) (2026-03-19)

### Bug Fixes

* **sales_invoice:** using `msgprint` and removed condition checking for `is_created_using_pos` to refetch payment methods ([#53636](https://github.com/frappe/erpnext/issues/53636)) ([65d8a17](65d8a176a6))

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -60,7 +60,7 @@ body:
       description: Share exact version number of Frappe and ERPNext you are using.
       placeholder: |
         Frappe version -
-        ERPNext Verion -
+        ERPNext version -
     validations:
       required: true
 

erpnext/__init__.py

@@ -4,7 +4,7 @@ import inspect
 import frappe
 from frappe.utils.user import is_website_user
 
-__version__ = "15.93.2"
+__version__ = "15.101.3"
 
 
 def get_default_company(user=None):

erpnext/accounts/doctype/account/chart_of_accounts/verified/id_chart_of_accounts.json

@@ -33,6 +33,17 @@
                         }, 
                         "account_number": "1151.000"
                     }, 
+                    "Pajak Dibayar di Muka": {
+                        "PPN Masukan": {
+                            "account_number": "1152.001",
+                            "account_type": "Tax"
+                        },
+                        "PPh 23 Dibayar di Muka": {
+                            "account_number": "1152.002",
+                            "account_type": "Tax"
+                        },
+                        "account_number": "1152.000"
+                    },
                     "account_number": "1150.000"
                 }, 
                 "Kas": {

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -93,6 +93,7 @@
   "receivable_payable_remarks_length",
   "accounts_receivable_payable_tuning_section",
   "receivable_payable_fetch_method",
+  "default_ageing_range",
   "column_break_ntmi",
   "drop_ar_procedures",
   "legacy_section",
@@ -215,7 +216,7 @@
    "description": "Payment Terms from orders will be fetched into the invoices as is",
    "fieldname": "automatically_fetch_payment_terms",
    "fieldtype": "Check",
-   "label": "Automatically Fetch Payment Terms from Order"
+   "label": "Automatically Fetch Payment Terms from Order/Quotation"
   },
   {
    "description": "The percentage you are allowed to bill more against the amount ordered. For example, if the order value is $100 for an item and tolerance is set as 10%, then you are allowed to bill up to $110 ",
@@ -657,6 +658,12 @@
    "fieldname": "show_party_balance",
    "fieldtype": "Check",
    "label": "Show Party Balance"
+  },
+  {
+   "default": "30, 60, 90, 120",
+   "fieldname": "default_ageing_range",
+   "fieldtype": "Data",
+   "label": "Default Ageing Range"
   }
  ],
  "icon": "icon-cog",
@@ -664,7 +671,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2025-11-06 17:48:07.682837",
+ "modified": "2026-03-06 14:49:11.467716",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -41,6 +41,7 @@ class AccountsSettings(Document):
 		check_supplier_invoice_uniqueness: DF.Check
 		create_pr_in_draft_status: DF.Check
 		credit_controller: DF.Link | None
+		default_ageing_range: DF.Data | None
 		delete_linked_ledger_entries: DF.Check
 		determine_address_tax_category_from: DF.Literal["Billing Address", "Shipping Address"]
 		enable_common_party_accounting: DF.Check

erpnext/accounts/doctype/advance_payment_ledger_entry/advance_payment_ledger_entry.json

@@ -48,6 +48,7 @@
    "fieldname": "amount",
    "fieldtype": "Currency",
    "label": "Amount",
+   "options": "currency",
    "read_only": 1
   },
   {

erpnext/accounts/doctype/bank/bank.js

@@ -3,9 +3,6 @@
 frappe.provide("erpnext.integrations");
 
 frappe.ui.form.on("Bank", {
-	onload: function (frm) {
-		add_fields_to_mapping_table(frm);
-	},
 	refresh: function (frm) {
 		add_fields_to_mapping_table(frm);
 		frm.toggle_display(["address_html", "contact_html"], !frm.doc.__islocal);
@@ -37,11 +34,11 @@ let add_fields_to_mapping_table = function (frm) {
 		});
 	});
 
-	frm.fields_dict.bank_transaction_mapping.grid.update_docfield_property(
-		"bank_transaction_field",
-		"options",
-		options
-	);
+	const grid = frm.fields_dict.bank_transaction_mapping?.grid;
+
+	if (grid) {
+		grid.update_docfield_property("bank_transaction_field", "options", options);
+	}
 };
 
 erpnext.integrations.refreshPlaidLink = class refreshPlaidLink {
@@ -116,7 +113,7 @@ erpnext.integrations.refreshPlaidLink = class refreshPlaidLink {
 				"There was an issue connecting to Plaid's authentication server. Check browser console for more information"
 			)
 		);
-		console.log(error);
+		console.error(error);
 	}
 
 	plaid_success(token, response) {

erpnext/accounts/doctype/bank_account/bank_account.js

@@ -42,8 +42,4 @@ frappe.ui.form.on("Bank Account", {
 			});
 		}
 	},
-
-	is_company_account: function (frm) {
-		frm.set_df_property("account", "reqd", frm.doc.is_company_account);
-	},
 });

erpnext/accounts/doctype/bank_account/bank_account.json

@@ -52,6 +52,7 @@
    "fieldtype": "Link",
    "in_list_view": 1,
    "label": "Company Account",
+   "mandatory_depends_on": "is_company_account",
    "options": "Account"
   },
   {
@@ -98,6 +99,7 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Company",
+   "mandatory_depends_on": "is_company_account",
    "options": "Company"
   },
   {
@@ -252,7 +254,7 @@
    "link_fieldname": "default_bank_account"
   }
  ],
- "modified": "2025-08-29 12:32:01.081687",
+ "modified": "2026-01-20 00:46:16.633364",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account",

erpnext/accounts/doctype/bank_account/bank_account.py

@@ -52,31 +52,35 @@ class BankAccount(Document):
 		delete_contact_and_address("Bank Account", self.name)
 
 	def validate(self):
-		self.validate_company()
-		self.validate_account()
+		self.validate_is_company_account()
 		self.update_default_bank_account()
 
-	def validate_account(self):
-		if self.account:
-			if accounts := frappe.db.get_all(
-				"Bank Account", filters={"account": self.account, "name": ["!=", self.name]}, as_list=1
-			):
-				frappe.throw(
-					_("'{0}' account is already used by {1}. Use another account.").format(
-						frappe.bold(self.account),
-						frappe.bold(comma_and([get_link_to_form(self.doctype, x[0]) for x in accounts])),
-					)
-				)
+	def validate_is_company_account(self):
+		if self.is_company_account:
+			if not self.company:
+				frappe.throw(_("Company is mandatory for company account"))
 
-	def validate_company(self):
-		if self.is_company_account and not self.company:
-			frappe.throw(_("Company is manadatory for company account"))
+			if not self.account:
+				frappe.throw(_("Company Account is mandatory"))
+
+			self.validate_account()
 
 	@deprecated
 	def validate_iban(self):
 		"""Kept for backward compatibility, will be removed in v16."""
 		validate_iban(self.iban, throw=True)
 
+	def validate_account(self):
+		if accounts := frappe.db.get_all(
+			"Bank Account", filters={"account": self.account, "name": ["!=", self.name]}, as_list=1
+		):
+			frappe.throw(
+				_("'{0}' account is already used by {1}. Use another account.").format(
+					frappe.bold(self.account),
+					frappe.bold(comma_and([get_link_to_form(self.doctype, x[0]) for x in accounts])),
+				)
+			)
+
 	def update_default_bank_account(self):
 		if self.is_default and not self.disabled:
 			frappe.db.set_value(

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -5,7 +5,9 @@
 import frappe
 from frappe import _, msgprint
 from frappe.model.document import Document
+from frappe.query_builder import Case
 from frappe.query_builder.custom import ConstantColumn
+from frappe.query_builder.functions import Coalesce, Sum
 from frappe.utils import flt, fmt_money, get_link_to_form, getdate
 from pypika import Order
 
@@ -136,65 +138,162 @@ def get_payment_entries_for_bank_clearance(
 ):
 	entries = []
 
-	condition = ""
-	pe_condition = ""
+	journal_entry = frappe.qb.DocType("Journal Entry")
+	journal_entry_account = frappe.qb.DocType("Journal Entry Account")
+
+	journal_entry_query = (
+		frappe.qb.from_(journal_entry_account)
+		.inner_join(journal_entry)
+		.on(journal_entry_account.parent == journal_entry.name)
+		.select(
+			ConstantColumn("Journal Entry").as_("payment_document"),
+			journal_entry.name.as_("payment_entry"),
+			journal_entry.cheque_no.as_("cheque_number"),
+			journal_entry.cheque_date,
+			Sum(journal_entry_account.debit_in_account_currency).as_("debit"),
+			Sum(journal_entry_account.credit_in_account_currency).as_("credit"),
+			journal_entry.posting_date,
+			journal_entry_account.against_account,
+			journal_entry.clearance_date,
+			journal_entry_account.account_currency,
+		)
+		.where(
+			(journal_entry_account.account == account)
+			& (journal_entry.docstatus == 1)
+			& (journal_entry.posting_date >= from_date)
+			& (journal_entry.posting_date <= to_date)
+			& (journal_entry.is_opening == "No")
+		)
+	)
+
 	if not include_reconciled_entries:
-		condition = "and (clearance_date IS NULL or clearance_date='0000-00-00')"
-		pe_condition = "and (pe.clearance_date IS NULL or pe.clearance_date='0000-00-00')"
+		journal_entry_query = journal_entry_query.where(
+			(journal_entry.clearance_date.isnull()) | (journal_entry.clearance_date == "0000-00-00")
+		)
 
-	journal_entries = frappe.db.sql(
-		f"""
-			select
-				"Journal Entry" as payment_document, t1.name as payment_entry,
-				t1.cheque_no as cheque_number, t1.cheque_date,
-				sum(t2.debit_in_account_currency) as debit, sum(t2.credit_in_account_currency) as credit,
-				t1.posting_date, t2.against_account, t1.clearance_date, t2.account_currency
-			from
-				`tabJournal Entry` t1, `tabJournal Entry Account` t2
-			where
-				t2.parent = t1.name and t2.account = %(account)s and t1.docstatus=1
-				and t1.posting_date >= %(from)s and t1.posting_date <= %(to)s
-				and ifnull(t1.is_opening, 'No') = 'No' {condition}
-			group by t2.account, t1.name
-			order by t1.posting_date ASC, t1.name DESC
-		""",
-		{"account": account, "from": from_date, "to": to_date},
-		as_dict=1,
+	journal_entries = (
+		journal_entry_query.groupby(journal_entry_account.account, journal_entry.name)
+		.orderby(journal_entry.posting_date)
+		.orderby(journal_entry.name, order=Order.desc)
+	).run(as_dict=True)
+
+	pe = frappe.qb.DocType("Payment Entry")
+	company = frappe.qb.DocType("Company")
+	payment_entry_query = (
+		frappe.qb.from_(pe)
+		.join(company)
+		.on(pe.company == company.name)
+		.select(
+			ConstantColumn("Payment Entry").as_("payment_document"),
+			pe.name.as_("payment_entry"),
+			pe.reference_no.as_("cheque_number"),
+			pe.reference_date.as_("cheque_date"),
+			(
+				Case()
+				.when(
+					pe.paid_from == account,
+					(
+						pe.paid_amount
+						+ (
+							Case()
+							.when(
+								(pe.payment_type == "Pay")
+								& (company.default_currency == pe.paid_from_account_currency),
+								pe.base_total_taxes_and_charges,
+							)
+							.else_(pe.total_taxes_and_charges)
+						)
+					),
+				)
+				.else_(0)
+			).as_("credit"),
+			(
+				Case()
+				.when(pe.paid_from == account, 0)
+				.else_(
+					pe.received_amount
+					+ (
+						Case()
+						.when(
+							company.default_currency == pe.paid_to_account_currency,
+							pe.base_total_taxes_and_charges,
+						)
+						.else_(pe.total_taxes_and_charges)
+					)
+				)
+			).as_("debit"),
+			pe.posting_date,
+			Coalesce(pe.party, Case().when(pe.paid_from == account, pe.paid_to).else_(pe.paid_from)).as_(
+				"against_account"
+			),
+			pe.clearance_date,
+			(
+				Case()
+				.when(pe.paid_to == account, pe.paid_to_account_currency)
+				.else_(pe.paid_from_account_currency)
+			).as_("account_currency"),
+		)
+		.where(
+			((pe.paid_from == account) | (pe.paid_to == account))
+			& (pe.docstatus == 1)
+			& (pe.posting_date >= from_date)
+			& (pe.posting_date <= to_date)
+		)
 	)
 
-	payment_entries = frappe.db.sql(
-		f"""
-			select
-				"Payment Entry" as payment_document, pe.name as payment_entry,
-				pe.reference_no as cheque_number, pe.reference_date as cheque_date,
-				if(pe.paid_from=%(account)s, pe.paid_amount + if(pe.payment_type = 'Pay' and c.default_currency = pe.paid_from_account_currency, pe.base_total_taxes_and_charges, pe.total_taxes_and_charges) , 0) as credit,
-				if(pe.paid_from=%(account)s, 0, pe.received_amount + pe.total_taxes_and_charges) as debit,
-				pe.posting_date, ifnull(pe.party,if(pe.paid_from=%(account)s,pe.paid_to,pe.paid_from)) as against_account, pe.clearance_date,
-				if(pe.paid_to=%(account)s, pe.paid_to_account_currency, pe.paid_from_account_currency) as account_currency
-			from `tabPayment Entry` as pe
-			join `tabCompany` c on c.name = pe.company
-			where
-				(pe.paid_from=%(account)s or pe.paid_to=%(account)s) and pe.docstatus=1
-				and pe.posting_date >= %(from)s and pe.posting_date <= %(to)s
-				{pe_condition}
-			order by
-				pe.posting_date ASC, pe.name DESC
-		""",
-		{
-			"account": account,
-			"from": from_date,
-			"to": to_date,
-		},
-		as_dict=1,
+	if not include_reconciled_entries:
+		payment_entry_query = payment_entry_query.where(
+			(pe.clearance_date.isnull()) | (pe.clearance_date == "0000-00-00")
+		)
+
+	payment_entries = (payment_entry_query.orderby(pe.posting_date).orderby(pe.name, order=Order.desc)).run(
+		as_dict=True
 	)
 
-	pos_sales_invoices, pos_purchase_invoices = [], []
+	acc = frappe.qb.DocType("Account")
+
+	pi = frappe.qb.DocType("Purchase Invoice")
+
+	paid_purchase_invoices_query = (
+		frappe.qb.from_(pi)
+		.inner_join(acc)
+		.on(pi.cash_bank_account == acc.name)
+		.select(
+			ConstantColumn("Purchase Invoice").as_("payment_document"),
+			pi.name.as_("payment_entry"),
+			pi.paid_amount.as_("credit"),
+			pi.posting_date,
+			pi.supplier.as_("against_account"),
+			pi.bill_no.as_("cheque_number"),
+			pi.clearance_date,
+			acc.account_currency,
+			ConstantColumn(0).as_("debit"),
+		)
+		.where(
+			(pi.docstatus == 1)
+			& (pi.is_paid == 1)
+			& (pi.cash_bank_account == account)
+			& (pi.posting_date >= from_date)
+			& (pi.posting_date <= to_date)
+		)
+	)
+
+	if not include_reconciled_entries:
+		paid_purchase_invoices_query = paid_purchase_invoices_query.where(
+			(pi.clearance_date.isnull()) | (pi.clearance_date == "0000-00-00")
+		)
+
+	paid_purchase_invoices = (
+		paid_purchase_invoices_query.orderby(pi.posting_date).orderby(pi.name, order=Order.desc)
+	).run(as_dict=True)
+
+	pos_sales_invoices = []
+
 	if include_pos_transactions:
 		si_payment = frappe.qb.DocType("Sales Invoice Payment")
 		si = frappe.qb.DocType("Sales Invoice")
-		acc = frappe.qb.DocType("Account")
 
-		pos_sales_invoices = (
+		pos_sales_invoices_query = (
 			frappe.qb.from_(si_payment)
 			.inner_join(si)
 			.on(si_payment.parent == si.name)
@@ -217,38 +316,22 @@ def get_payment_entries_for_bank_clearance(
 				& (si.posting_date >= from_date)
 				& (si.posting_date <= to_date)
 			)
-			.orderby(si.posting_date)
-			.orderby(si.name, order=Order.desc)
-		).run(as_dict=True)
+		)
 
-		pi = frappe.qb.DocType("Purchase Invoice")
+		if not include_reconciled_entries:
+			pos_sales_invoices_query = pos_sales_invoices_query.where(
+				(si_payment.clearance_date.isnull()) | (si_payment.clearance_date == "0000-00-00")
+			)
 
-		pos_purchase_invoices = (
-			frappe.qb.from_(pi)
-			.inner_join(acc)
-			.on(pi.cash_bank_account == acc.name)
-			.select(
-				ConstantColumn("Purchase Invoice").as_("payment_document"),
-				pi.name.as_("payment_entry"),
-				pi.paid_amount.as_("credit"),
-				pi.posting_date,
-				pi.supplier.as_("against_account"),
-				pi.clearance_date,
-				acc.account_currency,
-				ConstantColumn(0).as_("debit"),
-			)
-			.where(
-				(pi.docstatus == 1)
-				& (pi.cash_bank_account == account)
-				& (pi.posting_date >= from_date)
-				& (pi.posting_date <= to_date)
-			)
-			.orderby(pi.posting_date)
-			.orderby(pi.name, order=Order.desc)
+		pos_sales_invoices = (
+			pos_sales_invoices_query.orderby(si.posting_date).orderby(si.name, order=Order.desc)
 		).run(as_dict=True)
 
 	entries = (
-		list(payment_entries) + list(journal_entries) + list(pos_sales_invoices) + list(pos_purchase_invoices)
+		list(payment_entries)
+		+ list(journal_entries)
+		+ list(pos_sales_invoices)
+		+ list(paid_purchase_invoices)
 	)
 
 	return entries

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.js

@@ -2,6 +2,15 @@
 // For license information, please see license.txt
 
 frappe.ui.form.on("Bank Statement Import", {
+	onload(frm) {
+		frm.set_query("bank_account", function (doc) {
+			return {
+				filters: {
+					company: doc.company,
+				},
+			};
+		});
+	},
 	setup(frm) {
 		frappe.realtime.on("data_import_refresh", ({ data_import }) => {
 			frm.import_in_progress = false;

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -136,6 +136,8 @@ class BankTransaction(Document):
 		self.set_status()
 
 	def on_cancel(self):
+		self.ignore_linked_doctypes = ["GL Entry"]
+
 		for payment_entry in self.payment_entries:
 			self.delink_payment_entry(payment_entry)
 
@@ -370,11 +372,12 @@ def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries
 			("unallocated_amount", "bank_account"),
 			as_dict=True,
 		)
+		bt_bank_account = frappe.db.get_value("Bank Account", bt.bank_account, "account")
 
-		if bt.bank_account != gl_bank_account:
+		if bt_bank_account != gl_bank_account:
 			frappe.throw(
 				_("Bank Account {} in Bank Transaction {} is not matching with Bank Account {}").format(
-					bt.bank_account, payment_entry.payment_entry, gl_bank_account
+					bt_bank_account, payment_entry.payment_entry, gl_bank_account
 				)
 			)
 

erpnext/accounts/doctype/fiscal_year/fiscal_year.py

@@ -4,7 +4,7 @@
 
 import frappe
 from dateutil.relativedelta import relativedelta
-from frappe import _
+from frappe import _, cint
 from frappe.model.document import Document
 from frappe.utils import add_days, add_years, cstr, getdate
 
@@ -33,23 +33,11 @@ class FiscalYear(Document):
 		self.validate_dates()
 		self.validate_overlap()
 
-		if not self.is_new():
-			year_start_end_dates = frappe.db.sql(
-				"""select year_start_date, year_end_date
-				from `tabFiscal Year` where name=%s""",
-				(self.name),
-			)
+	def on_update(self):
+		frappe.cache().delete_key("fiscal_years")
 
-			if year_start_end_dates:
-				if (
-					getdate(self.year_start_date) != year_start_end_dates[0][0]
-					or getdate(self.year_end_date) != year_start_end_dates[0][1]
-				):
-					frappe.throw(
-						_(
-							"Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved."
-						)
-					)
+	def on_trash(self):
+		frappe.cache().delete_key("fiscal_years")
 
 	def validate_dates(self):
 		self.validate_from_to_dates("year_start_date", "year_end_date")
@@ -66,28 +54,20 @@ class FiscalYear(Document):
 				frappe.exceptions.InvalidDates,
 			)
 
-	def on_update(self):
-		check_duplicate_fiscal_year(self)
-		frappe.cache().delete_value("fiscal_years")
-
-	def on_trash(self):
-		frappe.cache().delete_value("fiscal_years")
-
 	def validate_overlap(self):
-		existing_fiscal_years = frappe.db.sql(
-			"""select name from `tabFiscal Year`
-			where (
-				(%(year_start_date)s between year_start_date and year_end_date)
-				or (%(year_end_date)s between year_start_date and year_end_date)
-				or (year_start_date between %(year_start_date)s and %(year_end_date)s)
-				or (year_end_date between %(year_start_date)s and %(year_end_date)s)
-			) and name!=%(name)s""",
-			{
-				"year_start_date": self.year_start_date,
-				"year_end_date": self.year_end_date,
-				"name": self.name or "No Name",
-			},
-			as_dict=True,
+		fy = frappe.qb.DocType("Fiscal Year")
+
+		name = self.name or self.year
+
+		existing_fiscal_years = (
+			frappe.qb.from_(fy)
+			.select(fy.name)
+			.where(
+				(fy.year_start_date <= self.year_end_date)
+				& (fy.year_end_date >= self.year_start_date)
+				& (fy.name != name)
+			)
+			.run(as_dict=True)
 		)
 
 		if existing_fiscal_years:
@@ -110,37 +90,30 @@ class FiscalYear(Document):
 					frappe.throw(
 						_(
 							"Year start date or end date is overlapping with {0}. To avoid please set company"
-						).format(existing.name),
+						).format(frappe.get_desk_link("Fiscal Year", existing.name, open_in_new_tab=True)),
 						frappe.NameError,
 					)
 
 
-@frappe.whitelist()
-def check_duplicate_fiscal_year(doc):
-	year_start_end_dates = frappe.db.sql(
-		"""select name, year_start_date, year_end_date from `tabFiscal Year` where name!=%s""",
-		(doc.name),
-	)
-	for fiscal_year, ysd, yed in year_start_end_dates:
-		if (getdate(doc.year_start_date) == ysd and getdate(doc.year_end_date) == yed) and (
-			not frappe.flags.in_test
-		):
-			frappe.throw(
-				_(
-					"Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}"
-				).format(fiscal_year)
-			)
-
-
-@frappe.whitelist()
 def auto_create_fiscal_year():
-	for d in frappe.db.sql(
-		"""select name from `tabFiscal Year` where year_end_date = date_add(current_date, interval 3 day)"""
-	):
+	fy = frappe.qb.DocType("Fiscal Year")
+
+	# Skipped auto-creating Short Year, as it has very rare use case.
+	# Reference: https://www.irs.gov/businesses/small-businesses-self-employed/tax-years (US)
+	follow_up_date = add_days(getdate(), days=3)
+	fiscal_year = (
+		frappe.qb.from_(fy)
+		.select(fy.name)
+		.where((fy.year_end_date == follow_up_date) & (fy.is_short_year == 0))
+		.run()
+	)
+
+	for d in fiscal_year:
 		try:
 			current_fy = frappe.get_doc("Fiscal Year", d[0])
 
-			new_fy = frappe.copy_doc(current_fy, ignore_no_copy=False)
+			new_fy = frappe.new_doc("Fiscal Year")
+			new_fy.disabled = cint(current_fy.disabled)
 
 			new_fy.year_start_date = add_days(current_fy.year_end_date, 1)
 			new_fy.year_end_date = add_years(current_fy.year_end_date, 1)
@@ -148,6 +121,10 @@ def auto_create_fiscal_year():
 			start_year = cstr(new_fy.year_start_date.year)
 			end_year = cstr(new_fy.year_end_date.year)
 			new_fy.year = start_year if start_year == end_year else (start_year + "-" + end_year)
+
+			for row in current_fy.companies:
+				new_fy.append("companies", {"company": row.company})
+
 			new_fy.auto_created = 1
 
 			new_fy.insert(ignore_permissions=True)

erpnext/accounts/doctype/fiscal_year_company/fiscal_year_company.json

@@ -15,13 +15,14 @@
    "ignore_user_permissions": 1,
    "in_list_view": 1,
    "label": "Company",
-   "options": "Company"
+   "options": "Company",
+   "reqd": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2021-09-28 18:01:53.495929",
+ "modified": "2026-02-20 23:02:26.193606",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Fiscal Year Company",
@@ -30,4 +31,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/fiscal_year_company/fiscal_year_company.py

@@ -14,7 +14,7 @@ class FiscalYearCompany(Document):
 	if TYPE_CHECKING:
 		from frappe.types import DF
 
-		company: DF.Link | None
+		company: DF.Link
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -187,7 +187,6 @@ class GLEntry(Document):
 				account_type == "Profit and Loss"
 				and self.company == dimension.company
 				and dimension.mandatory_for_pl
-				and not dimension.disabled
 				and not self.is_cancelled
 			):
 				if not self.get(dimension.fieldname):
@@ -201,7 +200,6 @@ class GLEntry(Document):
 				account_type == "Balance Sheet"
 				and self.company == dimension.company
 				and dimension.mandatory_for_bs
-				and not dimension.disabled
 				and not self.is_cancelled
 			):
 				if not self.get(dimension.fieldname):

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -20,6 +20,23 @@ frappe.ui.form.on("Journal Entry", {
 			"Unreconcile Payment Entries",
 			"Bank Transaction",
 		];
+		frm.trigger("set_queries");
+	},
+
+	set_queries(frm) {
+		frm.set_query("project", "accounts", function (doc, cdt, cdn) {
+			let row = frappe.get_doc(cdt, cdn);
+			let filters = {
+				company: doc.company,
+			};
+			if (row.party_type == "Customer") {
+				filters.customer = row.party;
+			}
+			return {
+				query: "erpnext.controllers.queries.get_project_name",
+				filters,
+			};
+		});
 	},
 
 	refresh: function (frm) {

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -6,6 +6,7 @@ import json
 
 import frappe
 from frappe import _, msgprint, scrub
+from frappe.core.doctype.submission_queue.submission_queue import queue_submission
 from frappe.utils import comma_and, cstr, flt, fmt_money, formatdate, get_link_to_form, nowdate
 
 import erpnext
@@ -171,16 +172,17 @@ class JournalEntry(AccountsController):
 		validate_docs_for_deferred_accounting([self.name], [])
 
 	def submit(self):
-		if len(self.accounts) > 100:
-			msgprint(_("The task has been enqueued as a background job."), alert=True)
-			self.queue_action("submit", timeout=4600)
+		if len(self.accounts) > 100 and not self.meta.queue_in_background:
+			queue_submission(self, "_submit")
 		else:
 			return self._submit()
 
+	def before_cancel(self):
+		self.has_asset_adjustment_entry()
+
 	def cancel(self):
 		if len(self.accounts) > 100:
-			msgprint(_("The task has been enqueued as a background job."), alert=True)
-			self.queue_action("cancel", timeout=4600)
+			queue_submission(self, "_cancel")
 		else:
 			return self._cancel()
 
@@ -212,6 +214,8 @@ class JournalEntry(AccountsController):
 	def on_cancel(self):
 		# References for this Journal are removed on the `on_cancel` event in accounts_controller
 		super().on_cancel()
+
+		from_doc_events = getattr(self, "ignore_linked_doctypes", ())
 		self.ignore_linked_doctypes = (
 			"GL Entry",
 			"Stock Ledger Entry",
@@ -224,6 +228,10 @@ class JournalEntry(AccountsController):
 			"Unreconcile Payment Entries",
 			"Advance Payment Ledger Entry",
 		)
+
+		if from_doc_events and from_doc_events != self.ignore_linked_doctypes:
+			self.ignore_linked_doctypes = self.ignore_linked_doctypes + from_doc_events
+
 		self.make_gl_entries(1)
 		self.unlink_advance_entry_reference()
 		self.unlink_asset_reference()
@@ -261,6 +269,9 @@ class JournalEntry(AccountsController):
 			frappe.throw(_("Journal Entry type should be set as Depreciation Entry for asset depreciation"))
 
 	def validate_stock_accounts(self):
+		if not erpnext.is_perpetual_inventory_enabled(self.company):
+			return
+
 		stock_accounts = get_stock_accounts(self.company, accounts=self.accounts)
 		for account in stock_accounts:
 			account_bal, stock_bal, warehouse_list = get_stock_and_account_balance(
@@ -448,12 +459,27 @@ class JournalEntry(AccountsController):
 			)
 			frappe.db.set_value("Journal Entry", self.name, "inter_company_journal_entry_reference", "")
 
-	def unlink_asset_adjustment_entry(self):
-		frappe.db.sql(
-			""" update `tabAsset Value Adjustment`
-			set journal_entry = null where journal_entry = %s""",
-			self.name,
+	def has_asset_adjustment_entry(self):
+		if self.flags.get("via_asset_value_adjustment"):
+			return
+
+		asset_value_adjustment = frappe.db.get_value(
+			"Asset Value Adjustment", {"docstatus": 1, "journal_entry": self.name}, "name"
 		)
+		if asset_value_adjustment:
+			frappe.throw(
+				_(
+					"Cannot cancel this document as it is linked with the submitted Asset Value Adjustment <b>{0}</b>. Please cancel the Asset Value Adjustment to continue."
+				).format(frappe.utils.get_link_to_form("Asset Value Adjustment", asset_value_adjustment))
+			)
+
+	def unlink_asset_adjustment_entry(self):
+		AssetValueAdjustment = frappe.qb.DocType("Asset Value Adjustment")
+		(
+			frappe.qb.update(AssetValueAdjustment)
+			.set(AssetValueAdjustment.journal_entry, None)
+			.where(AssetValueAdjustment.journal_entry == self.name)
+		).run()
 
 	def validate_party(self):
 		for d in self.get("accounts"):

erpnext/accounts/doctype/journal_entry_account/journal_entry_account.json

@@ -185,7 +185,7 @@
    "fieldtype": "Select",
    "label": "Reference Type",
    "no_copy": 1,
-   "options": "\nSales Invoice\nPurchase Invoice\nJournal Entry\nSales Order\nPurchase Order\nExpense Claim\nAsset\nLoan\nPayroll Entry\nEmployee Advance\nExchange Rate Revaluation\nInvoice Discounting\nFees\nFull and Final Statement\nPayment Entry",
+   "options": "\nSales Invoice\nPurchase Invoice\nJournal Entry\nSales Order\nPurchase Order\nExpense Claim\nAsset\nLoan\nPayroll Entry\nEmployee Advance\nExchange Rate Revaluation\nInvoice Discounting\nFees\nFull and Final Statement\nPayment Entry\nBank Transaction",
    "search_index": 1
   },
   {
@@ -198,7 +198,7 @@
    "search_index": 1
   },
   {
-   "depends_on": "eval:doc.reference_type&&!in_list(doc.reference_type, ['Expense Claim', 'Asset', 'Employee Loan', 'Employee Advance'])",
+   "depends_on": "eval:doc.reference_type&&!in_list(doc.reference_type, ['Expense Claim', 'Asset', 'Employee Loan', 'Employee Advance', 'Bank Transaction'])",
    "fieldname": "reference_due_date",
    "fieldtype": "Date",
    "label": "Reference Due Date",
@@ -295,7 +295,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-11-27 12:23:33.157655",
+ "modified": "2026-02-19 17:01:22.642454",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry Account",

erpnext/accounts/doctype/journal_entry_account/journal_entry_account.py

@@ -55,6 +55,7 @@ class JournalEntryAccount(Document):
 			"Fees",
 			"Full and Final Statement",
 			"Payment Entry",
+			"Bank Transaction",
 		]
 		user_remark: DF.SmallText | None
 	# end: auto-generated types

erpnext/accounts/doctype/mode_of_payment/mode_of_payment.js

@@ -7,7 +7,7 @@ frappe.ui.form.on("Mode of Payment", {
 			let d = locals[cdt][cdn];
 			return {
 				filters: [
-					["Account", "account_type", "in", "Bank, Cash, Receivable"],
+					["Account", "account_type", "in", ["Bank", "Cash", "Receivable"]],
 					["Account", "is_group", "=", 0],
 					["Account", "company", "=", d.company],
 				],

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -400,6 +400,16 @@ frappe.ui.form.on("Payment Entry", {
 		);
 
 		frm.refresh_fields();
+
+		const party_currency =
+			frm.doc.payment_type === "Receive" ? "paid_from_account_currency" : "paid_to_account_currency";
+
+		var reference_grid = frm.fields_dict["references"].grid;
+		["total_amount", "outstanding_amount", "allocated_amount"].forEach((fieldname) => {
+			reference_grid.update_docfield_property(fieldname, "options", party_currency);
+		});
+
+		reference_grid.refresh();
 	},
 
 	show_general_ledger: function (frm) {
@@ -506,12 +516,16 @@ frappe.ui.form.on("Payment Entry", {
 			frm.set_value("contact_email", "");
 			frm.set_value("contact_person", "");
 		}
+
 		if (frm.doc.payment_type && frm.doc.party_type && frm.doc.party && frm.doc.company) {
 			if (!frm.doc.posting_date) {
 				frappe.msgprint(__("Please select Posting Date before selecting Party"));
 				frm.set_value("party", "");
 				return;
 			}
+
+			erpnext.utils.get_employee_contact_details(frm);
+
 			frm.set_party_account_based_on_party = true;
 
 			let company_currency = frappe.get_doc(":Company", frm.doc.company).default_currency;
@@ -1119,7 +1133,7 @@ frappe.ui.form.on("Payment Entry", {
 
 	allocate_party_amount_against_ref_docs: async function (frm, paid_amount, paid_amount_change) {
 		await frm.call("allocate_amount_to_references", {
-			paid_amount: paid_amount,
+			paid_amount: flt(paid_amount),
 			paid_amount_change: paid_amount_change,
 			allocate_payment_amount: frappe.flags.allocate_payment_amount ?? false,
 		});
@@ -1455,16 +1469,15 @@ frappe.ui.form.on("Payment Entry", {
 			callback: function (r) {
 				if (!r.exc && r.message) {
 					// set taxes table
-					if (r.message) {
-						for (let tax of r.message) {
-							if (tax.charge_type === "On Net Total") {
-								tax.charge_type = "On Paid Amount";
-							}
-							frm.add_child("taxes", tax);
+					let taxes = r.message;
+					taxes.forEach((tax) => {
+						if (tax.charge_type === "On Net Total") {
+							tax.charge_type = "On Paid Amount";
 						}
-						frm.events.apply_taxes(frm);
-						frm.events.set_unallocated_amount(frm);
-					}
+					});
+					frm.set_value("taxes", taxes);
+					frm.events.apply_taxes(frm);
+					frm.events.set_unallocated_amount(frm);
 				}
 			},
 		});

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -1092,20 +1092,32 @@ class PaymentEntry(AccountsController):
 			self.base_paid_amount + deductions_to_consider
 		):
 			self.unallocated_amount = (
-				self.base_paid_amount
-				+ deductions_to_consider
-				- self.base_total_allocated_amount
-				- included_taxes
-			) / self.source_exchange_rate
+				flt(
+					(
+						self.base_paid_amount
+						+ deductions_to_consider
+						- self.base_total_allocated_amount
+						- included_taxes
+					),
+					self.precision("unallocated_amount"),
+				)
+				/ self.source_exchange_rate
+			)
 		elif self.payment_type == "Pay" and self.base_total_allocated_amount < (
 			self.base_received_amount - deductions_to_consider
 		):
 			self.unallocated_amount = (
-				self.base_received_amount
-				- deductions_to_consider
-				- self.base_total_allocated_amount
-				- included_taxes
-			) / self.target_exchange_rate
+				flt(
+					(
+						self.base_received_amount
+						- deductions_to_consider
+						- self.base_total_allocated_amount
+						- included_taxes
+					),
+					self.precision("unallocated_amount"),
+				)
+				/ self.target_exchange_rate
+			)
 
 	def set_exchange_gain_loss(self):
 		exchange_gain_loss = flt(
@@ -2544,14 +2556,9 @@ def get_orders_to_be_billed(
 	if not voucher_type:
 		return []
 
-	# Add cost center condition
-	doc = frappe.get_doc({"doctype": voucher_type})
-	condition = ""
-	if doc and hasattr(doc, "cost_center") and doc.cost_center:
-		condition = " and cost_center='%s'" % cost_center
-
 	# dynamic dimension filters
-	active_dimensions = get_dimensions()[0]
+	condition = ""
+	active_dimensions = get_dimensions(True)[0]
 	for dim in active_dimensions:
 		if filters.get(dim.fieldname):
 			condition += f" and {dim.fieldname}='{filters.get(dim.fieldname)}'"

erpnext/accounts/doctype/payment_entry_deduction/payment_entry_deduction.json

@@ -22,6 +22,7 @@
    "reqd": 1
   },
   {
+   "allow_on_submit": 1,
    "fieldname": "cost_center",
    "fieldtype": "Link",
    "in_list_view": 1,
@@ -59,7 +60,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-11-05 16:07:47.307971",
+ "modified": "2026-03-11 14:26:11.312950",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry Deduction",

erpnext/accounts/doctype/payment_entry_reference/payment_entry_reference.json

@@ -68,7 +68,7 @@
   {
    "columns": 2,
    "fieldname": "total_amount",
-   "fieldtype": "Float",
+   "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Grand Total",
    "print_hide": 1,
@@ -77,7 +77,7 @@
   {
    "columns": 2,
    "fieldname": "outstanding_amount",
-   "fieldtype": "Float",
+   "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Outstanding",
    "read_only": 1
@@ -85,7 +85,7 @@
   {
    "columns": 2,
    "fieldname": "allocated_amount",
-   "fieldtype": "Float",
+   "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Allocated"
   },
@@ -174,7 +174,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-07-25 04:32:11.040025",
+ "modified": "2026-01-05 14:18:03.286224",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry Reference",

erpnext/accounts/doctype/payment_entry_reference/payment_entry_reference.py

@@ -18,12 +18,12 @@ class PaymentEntryReference(Document):
 		account_type: DF.Data | None
 		advance_voucher_no: DF.DynamicLink | None
 		advance_voucher_type: DF.Link | None
-		allocated_amount: DF.Float
+		allocated_amount: DF.Currency
 		bill_no: DF.Data | None
 		due_date: DF.Date | None
 		exchange_gain_loss: DF.Currency
 		exchange_rate: DF.Float
-		outstanding_amount: DF.Float
+		outstanding_amount: DF.Currency
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data
@@ -34,7 +34,7 @@ class PaymentEntryReference(Document):
 		reconcile_effect_on: DF.Date | None
 		reference_doctype: DF.Link
 		reference_name: DF.DynamicLink
-		total_amount: DF.Float
+		total_amount: DF.Currency
 	# end: auto-generated types
 
 	@property

erpnext/accounts/doctype/payment_ledger_entry/payment_ledger_entry.json

@@ -132,6 +132,12 @@
    "fieldtype": "Link",
    "label": "Cost Center",
    "options": "Cost Center"
+  },
+    {
+   "fieldname": "project",
+   "fieldtype": "Link",
+   "label": "Project",
+   "options": "Project"
   },
   {
    "fieldname": "due_date",

erpnext/accounts/doctype/payment_ledger_entry/payment_ledger_entry.py

@@ -38,6 +38,7 @@ class PaymentLedgerEntry(Document):
 		amount_in_account_currency: DF.Currency
 		company: DF.Link | None
 		cost_center: DF.Link | None
+		project: DF.Link | None
 		delinked: DF.Check
 		due_date: DF.Date | None
 		finance_book: DF.Link | None
@@ -133,7 +134,6 @@ class PaymentLedgerEntry(Document):
 				account_type == "Profit and Loss"
 				and self.company == dimension.company
 				and dimension.mandatory_for_pl
-				and not dimension.disabled
 			):
 				if not self.get(dimension.fieldname):
 					frappe.throw(
@@ -146,7 +146,6 @@ class PaymentLedgerEntry(Document):
 				account_type == "Balance Sheet"
 				and self.company == dimension.company
 				and dimension.mandatory_for_bs
-				and not dimension.disabled
 			):
 				if not self.get(dimension.fieldname):
 					frappe.throw(

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -6,7 +6,7 @@ import frappe
 from frappe import _, msgprint, qb
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
-from frappe.query_builder import Criterion
+from frappe.query_builder import Case, Criterion
 from frappe.query_builder.custom import ConstantColumn
 from frappe.utils import flt, fmt_money, get_link_to_form, getdate, nowdate, today
 
@@ -393,6 +393,9 @@ class PaymentReconciliation(Document):
 			inv.outstanding_amount = flt(entry.get("outstanding_amount"))
 
 	def get_difference_amount(self, payment_entry, invoice, allocated_amount):
+		party_account_defaults = frappe.get_cached_value(
+			"Account", self.receivable_payable_account, ["account_type", "account_currency"], as_dict=True
+		)
 		allocated_amount_precision = get_field_precision(
 			frappe.get_meta("Payment Reconciliation Allocation").get_field("allocated_amount")
 		)
@@ -400,9 +403,9 @@ class PaymentReconciliation(Document):
 			frappe.get_meta("Payment Reconciliation Allocation").get_field("difference_amount")
 		)
 		difference_amount = 0
-		if frappe.get_cached_value(
-			"Account", self.receivable_payable_account, "account_currency"
-		) != frappe.get_cached_value("Company", self.company, "default_currency"):
+		if party_account_defaults.get("account_currency") != frappe.get_cached_value(
+			"Company", self.company, "default_currency"
+		):
 			if invoice.get("exchange_rate") and payment_entry.get("exchange_rate", 1) != invoice.get(
 				"exchange_rate", 1
 			):
@@ -414,7 +417,14 @@ class PaymentReconciliation(Document):
 					invoice.get("exchange_rate", 1) * flt(allocated_amount, allocated_amount_precision),
 					difference_amount_precision,
 				)
-				difference_amount = allocated_amount_in_ref_rate - allocated_amount_in_inv_rate
+
+				# Added If clause to handle return Adhoc payments for account type holders ("Payable")
+				if party_account_defaults.get("account_type") in ("Payable") and invoice.get(
+					"invoice_type"
+				) in ["Payment Entry", "Journal Entry"]:
+					difference_amount = allocated_amount_in_inv_rate - allocated_amount_in_ref_rate
+				else:
+					difference_amount = allocated_amount_in_ref_rate - allocated_amount_in_inv_rate
 
 		return difference_amount
 
@@ -677,6 +687,28 @@ class PaymentReconciliation(Document):
 			)
 			invoice_exchange_map.update(journals_map)
 
+		payment_entries = [
+			d.get("invoice_number") for d in invoices if d.get("invoice_type") == "Payment Entry"
+		]
+		payment_entries.extend(
+			[d.get("reference_name") for d in payments if d.get("reference_type") == "Payment Entry"]
+		)
+		if payment_entries:
+			pe = frappe.qb.DocType("Payment Entry")
+			query = (
+				frappe.qb.from_(pe)
+				.select(
+					pe.name,
+					Case()
+					.when(pe.payment_type == "Receive", pe.source_exchange_rate)
+					.else_(pe.target_exchange_rate)
+					.as_("exchange_rate"),
+				)
+				.where(pe.name.isin(payment_entries))
+			)
+			payment_entries = query.run(as_list=1)
+			invoice_exchange_map.update(payment_entries)
+
 		return invoice_exchange_map
 
 	def validate_allocation(self):
@@ -714,7 +746,7 @@ class PaymentReconciliation(Document):
 		ple = qb.DocType("Payment Ledger Entry")
 		for x in self.dimensions:
 			dimension = x.fieldname
-			if self.get(dimension):
+			if self.get(dimension) and frappe.db.has_column("Payment Ledger Entry", dimension):
 				self.accounting_dimension_filter_conditions.append(ple[dimension] == self.get(dimension))
 
 	def build_qb_filter_conditions(self, get_invoices=False, get_return_invoices=False):

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -2336,6 +2336,210 @@ class TestPaymentReconciliation(FrappeTestCase):
 
 		frappe.db.set_value("Company", self.company, default_settings)
 
+	def test_foreign_currency_reverse_payment_entry_against_payment_entry_for_customer(self):
+		transaction_date = nowdate()
+		customer = self.customer3
+		amount = 1000
+		exchange_rate_at_payment = 100
+		exchange_rate_at_reverse_payment = 95
+
+		# Receive amount from customer - 1,00,000
+		pe = self.create_payment_entry(amount=amount, posting_date=transaction_date, customer=customer)
+		pe.payment_type = "Receive"
+		pe.paid_from = self.debtors_eur
+		pe.paid_from_account_currency = "EUR"
+		pe.source_exchange_rate = exchange_rate_at_payment
+		pe.paid_amount = amount
+		pe.received_amount = exchange_rate_at_payment * amount
+		pe.paid_to = self.cash
+		pe.paid_to_account_currency = "INR"
+		pe = pe.save().submit()
+
+		# Pay amount to customer - 95,000
+		reverse_pe = self.create_payment_entry(
+			amount=amount, posting_date=transaction_date, customer=customer
+		)
+		reverse_pe.payment_type = "Pay"
+		reverse_pe.paid_from = self.cash
+		reverse_pe.paid_from_account_currency = "INR"
+		reverse_pe.target_exchange_rate = exchange_rate_at_reverse_payment
+		reverse_pe.paid_amount = exchange_rate_at_reverse_payment * amount
+		reverse_pe.received_amount = amount
+		reverse_pe.paid_to = self.debtors_eur
+		reverse_pe.paid_to_account_currency = "EUR"
+		reverse_pe.save().submit()
+
+		# Reconcile payments
+		pr = self.create_payment_reconciliation()
+		pr.party = customer
+		pr.receivable_payable_account = self.debtors_eur
+		pr.get_unreconciled_entries()
+		invoices = [invoice.as_dict() for invoice in pr.invoices]
+		payments = [payment.as_dict() for payment in pr.payments]
+		self.assertEqual(len(pr.get("invoices")), 1)
+		self.assertEqual(len(pr.get("payments")), 1)
+		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+
+		# Check the difference_amount is a gain of 5000
+		self.assertEqual(flt(pr.allocation[0].get("difference_amount")), 5000.0)
+		pr.reconcile()
+
+	def test_foreign_currency_reverse_payment_entry_against_payment_entry_for_supplier(self):
+		transaction_date = nowdate()
+		self.supplier = "_Test Supplier USD"
+		amount = 1000
+		exchange_rate_at_payment = 100
+		exchange_rate_at_reverse_payment = 95
+
+		# Pay amount to supplier - 1,00,000
+		pe = self.create_payment_entry(amount=amount, posting_date=transaction_date)
+		pe.payment_type = "Pay"
+		pe.party_type = "Supplier"
+		pe.party = self.supplier
+		pe.paid_from = self.cash
+		pe.paid_from_account_currency = "INR"
+		pe.target_exchange_rate = exchange_rate_at_payment
+		pe.paid_amount = exchange_rate_at_payment * amount
+		pe.received_amount = amount
+		pe.paid_to = self.creditors_usd
+		pe.paid_to_account_currency = "USD"
+		pe.save().submit()
+
+		# Receive amount from supplier - 95,000
+		reverse_pe = self.create_payment_entry(amount=amount, posting_date=transaction_date)
+		reverse_pe.payment_type = "Receive"
+		reverse_pe.party_type = "Supplier"
+		reverse_pe.party = self.supplier
+		reverse_pe.paid_from = self.creditors_usd
+		reverse_pe.paid_from_account_currency = "USD"
+		reverse_pe.source_exchange_rate = exchange_rate_at_reverse_payment
+		reverse_pe.paid_amount = amount
+		reverse_pe.received_amount = exchange_rate_at_reverse_payment * amount
+		reverse_pe.paid_to = self.cash
+		reverse_pe.paid_to_account_currency = "INR"
+		reverse_pe = reverse_pe.save().submit()
+
+		# Reconcile payments
+		pr = self.create_payment_reconciliation(party_is_customer=False)
+		pr.party = self.supplier
+		pr.receivable_payable_account = self.creditors_usd
+		pr.get_unreconciled_entries()
+		invoices = [invoice.as_dict() for invoice in pr.invoices]
+		payments = [payment.as_dict() for payment in pr.payments]
+
+		self.assertEqual(len(pr.get("invoices")), 1)
+		self.assertEqual(len(pr.get("payments")), 1)
+		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+
+		# Check the difference_amount is a loss of 5000
+		self.assertEqual(flt(pr.allocation[0].get("difference_amount")), -5000.0)
+		pr.reconcile()
+
+	def test_foreign_currency_reverse_journal_entry_against_journal_entry_for_customer(self):
+		transaction_date = nowdate()
+		customer = self.customer3
+		amount = 1000
+		exchange_rate_at_payment = 95
+		exchange_rate_at_reverse_payment = 100
+
+		# Receive amount from customer - 95,000
+		je1 = self.create_journal_entry(self.cash, self.debtors_eur, amount, transaction_date)
+		je1.multi_currency = 1
+		je1.accounts[0].exchange_rate = 1
+		je1.accounts[0].debit_in_account_currency = exchange_rate_at_payment * amount
+		je1.accounts[0].debit = exchange_rate_at_payment * amount
+		je1.accounts[1].party_type = "Customer"
+		je1.accounts[1].party = customer
+		je1.accounts[1].exchange_rate = exchange_rate_at_payment
+		je1.accounts[1].credit_in_account_currency = amount
+		je1.accounts[1].credit = exchange_rate_at_payment * amount
+		je1.save()
+		je1.submit()
+
+		# Pay amount to customer - 1,00,000
+		je2 = self.create_journal_entry(self.debtors_eur, self.cash, amount, transaction_date)
+		je2.multi_currency = 1
+		je2.accounts[0].party_type = "Customer"
+		je2.accounts[0].party = customer
+		je2.accounts[0].exchange_rate = exchange_rate_at_reverse_payment
+		je2.accounts[0].debit_in_account_currency = amount
+		je2.accounts[0].debit = exchange_rate_at_reverse_payment * amount
+		je2.accounts[1].exchange_rate = 1
+		je2.accounts[1].credit_in_account_currency = exchange_rate_at_reverse_payment * amount
+		je2.accounts[1].credit = exchange_rate_at_reverse_payment * amount
+		je2.save()
+		je2.submit()
+
+		# Reconcile payments
+		pr = self.create_payment_reconciliation()
+		pr.party = customer
+		pr.receivable_payable_account = self.debtors_eur
+		pr.get_unreconciled_entries()
+
+		self.assertEqual(len(pr.invoices), 1)
+		self.assertEqual(len(pr.payments), 1)
+
+		invoices = [invoice.as_dict() for invoice in pr.invoices]
+		payments = [payment.as_dict() for payment in pr.payments]
+		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+
+		# Check the difference_amount is a loss of 5000
+		self.assertEqual(flt(pr.allocation[0].difference_amount), -5000.0)
+		pr.reconcile()
+
+	def test_foreign_currency_reverse_journal_entry_against_journal_entry_for_supplier(self):
+		transaction_date = nowdate()
+		self.supplier = "_Test Supplier USD"
+		amount = 1000
+		exchange_rate_at_payment = 95
+		exchange_rate_at_reverse_payment = 100
+
+		# Pay amount to supplier - 95,000
+		je1 = self.create_journal_entry(self.creditors_usd, self.cash, amount, transaction_date)
+		je1.multi_currency = 1
+		je1.accounts[0].party_type = "Supplier"
+		je1.accounts[0].party = self.supplier
+		je1.accounts[0].exchange_rate = exchange_rate_at_payment
+		je1.accounts[0].debit_in_account_currency = amount
+		je1.accounts[0].debit = exchange_rate_at_payment * amount
+		je1.accounts[1].exchange_rate = 1
+		je1.accounts[1].credit = exchange_rate_at_payment * amount
+		je1.accounts[1].credit_in_account_currency = exchange_rate_at_payment * amount
+		je1.save()
+		je1.submit()
+
+		# Receive amount from supplier - 1,00,000
+		je2 = self.create_journal_entry(self.cash, self.creditors_usd, amount, transaction_date)
+		je2.multi_currency = 1
+		je2.accounts[0].exchange_rate = 1
+		je2.accounts[0].debit = exchange_rate_at_reverse_payment * amount
+		je2.accounts[0].debit_in_account_currency = exchange_rate_at_reverse_payment * amount
+		je2.accounts[1].party_type = "Supplier"
+		je2.accounts[1].party = self.supplier
+		je2.accounts[1].exchange_rate = exchange_rate_at_reverse_payment
+		je2.accounts[1].credit_in_account_currency = amount
+		je2.accounts[1].credit = exchange_rate_at_reverse_payment * amount
+		je2.save()
+		je2.submit()
+
+		# Reconcile payments
+		pr = self.create_payment_reconciliation()
+		pr.party_type = "Supplier"
+		pr.party = self.supplier
+		pr.receivable_payable_account = self.creditors_usd
+		pr.get_unreconciled_entries()
+
+		self.assertEqual(len(pr.invoices), 1)
+		self.assertEqual(len(pr.payments), 1)
+
+		invoices = [invoice.as_dict() for invoice in pr.invoices]
+		payments = [payment.as_dict() for payment in pr.payments]
+		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+
+		# Check the difference_amount is a gain of 5000
+		self.assertEqual(flt(pr.allocation[0].difference_amount), 5000.0)
+		pr.reconcile()
+
 
 def make_customer(customer_name, currency=None):
 	if not frappe.db.exists("Customer", customer_name):

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -536,7 +536,7 @@ class PaymentRequest(Document):
 				row_number += TO_SKIP_NEW_ROW
 
 
-@frappe.whitelist(allow_guest=True)
+@frappe.whitelist()
 def make_payment_request(**args):
 	"""Make payment request"""
 
@@ -548,6 +548,9 @@ def make_payment_request(**args):
 	if args.dn and not isinstance(args.dn, str):
 		frappe.throw(_("Invalid parameter. 'dn' should be of type str"))
 
+	frappe.has_permission("Payment Request", "create", throw=True)
+	frappe.has_permission(args.dt, "read", args.dn, throw=True)
+
 	ref_doc = args.ref_doc or frappe.get_doc(args.dt, args.dn)
 	if not args.get("company"):
 		args.company = ref_doc.company
@@ -822,7 +825,7 @@ def get_print_format_list(ref_doctype):
 	return {"print_format": print_format_list}
 
 
-@frappe.whitelist(allow_guest=True)
+@frappe.whitelist()
 def resend_payment_email(docname):
 	return frappe.get_doc("Payment Request", docname).send_email()
 

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.js

@@ -13,9 +13,9 @@ frappe.ui.form.on("Period Closing Voucher", {
 			return {
 				filters: [
 					["Account", "company", "=", frm.doc.company],
-					["Account", "is_group", "=", "0"],
+					["Account", "is_group", "=", 0],
 					["Account", "freeze_account", "=", "No"],
-					["Account", "root_type", "in", "Liability, Equity"],
+					["Account", "root_type", "in", ["Liability", "Equity"]],
 				],
 			};
 		});

erpnext/accounts/doctype/pos_invoice/pos_invoice.json

@@ -60,7 +60,6 @@
   "sec_warehouse",
   "set_warehouse",
   "items_section",
-  "update_stock",
   "scan_barcode",
   "last_scanned_warehouse",
   "items",
@@ -574,7 +573,6 @@
    "label": "Warehouse"
   },
   {
-   "depends_on": "update_stock",
    "fieldname": "set_warehouse",
    "fieldtype": "Link",
    "label": "Source Warehouse",
@@ -588,15 +586,6 @@
    "oldfieldtype": "Section Break",
    "options": "fa fa-shopping-cart"
   },
-  {
-   "default": "0",
-   "fieldname": "update_stock",
-   "fieldtype": "Check",
-   "label": "Update Stock",
-   "oldfieldname": "update_stock",
-   "oldfieldtype": "Check",
-   "print_hide": 1
-  },
   {
    "fieldname": "scan_barcode",
    "fieldtype": "Data",
@@ -1582,7 +1571,7 @@
  "icon": "fa fa-file-text",
  "is_submittable": 1,
  "links": [],
- "modified": "2025-08-04 22:22:31.471752",
+ "modified": "2026-02-22 04:18:50.691218",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice",
@@ -1627,6 +1616,7 @@
    "role": "All"
   }
  ],
+ "row_format": "Dynamic",
  "search_fields": "posting_date, due_date, customer, base_grand_total, outstanding_amount",
  "show_name_in_global_search": 1,
  "sort_field": "modified",
@@ -1635,4 +1625,4 @@
  "timeline_field": "customer",
  "title_field": "title",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -183,7 +183,6 @@ class POSInvoice(SalesInvoice):
 		total_taxes_and_charges: DF.Currency
 		update_billed_amount_in_delivery_note: DF.Check
 		update_billed_amount_in_sales_order: DF.Check
-		update_stock: DF.Check
 		write_off_account: DF.Link | None
 		write_off_amount: DF.Currency
 		write_off_cost_center: DF.Link | None
@@ -652,7 +651,6 @@ class POSInvoice(SalesInvoice):
 				"tax_category",
 				"ignore_pricing_rule",
 				"company_address",
-				"update_stock",
 			):
 				if not for_validate:
 					self.set(fieldname, profile.get(fieldname))

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -481,6 +481,7 @@ class TestPOSInvoice(unittest.TestCase):
 			rate=1000,
 			serial_no=[serial_nos[0]],
 			do_not_save=1,
+			ignore_sabb_validation=True,
 		)
 
 		pos2.append("payments", {"mode_of_payment": "Bank Draft", "amount": 1000})
@@ -837,6 +838,53 @@ class TestPOSInvoice(unittest.TestCase):
 			if batch.batch_no == batch_no and batch.warehouse == "_Test Warehouse - _TC":
 				self.assertEqual(batch.qty, 5)
 
+	def test_pos_batch_reservation_with_return_qty(self):
+		"""
+		Test POS Invoice reserved qty for batch without bundle with return invoices.
+		"""
+		from erpnext.stock.doctype.serial_and_batch_bundle.serial_and_batch_bundle import (
+			get_auto_batch_nos,
+		)
+		from erpnext.stock.doctype.stock_reconciliation.test_stock_reconciliation import (
+			create_batch_item_with_batch,
+		)
+
+		create_batch_item_with_batch("_Batch Item Reserve Return", "TestBatch-RR 01")
+		se = make_stock_entry(
+			target="_Test Warehouse - _TC",
+			item_code="_Batch Item Reserve Return",
+			qty=30,
+			basic_rate=100,
+		)
+
+		se.reload()
+
+		batch_no = get_batch_from_bundle(se.items[0].serial_and_batch_bundle)
+
+		# POS Invoice for the batch without bundle
+		pos_inv = create_pos_invoice(item="_Batch Item Reserve Return", rate=300, qty=15, do_not_save=1)
+		pos_inv.append(
+			"payments",
+			{"mode_of_payment": "Cash", "amount": 4500},
+		)
+		pos_inv.items[0].batch_no = batch_no
+		pos_inv.save()
+		pos_inv.submit()
+
+		# POS Invoice return
+		pos_return = make_sales_return(pos_inv.name)
+
+		pos_return.insert()
+		pos_return.submit()
+
+		batches = get_auto_batch_nos(
+			frappe._dict({"item_code": "_Batch Item Reserve Return", "warehouse": "_Test Warehouse - _TC"})
+		)
+
+		for batch in batches:
+			if batch.batch_no == batch_no and batch.warehouse == "_Test Warehouse - _TC":
+				self.assertEqual(batch.qty, 30)
+
 	def test_pos_batch_item_qty_validation(self):
 		from erpnext.stock.doctype.serial_and_batch_bundle.serial_and_batch_bundle import (
 			BatchNegativeStockError,
@@ -956,6 +1004,7 @@ class TestPOSInvoice(unittest.TestCase):
 				qty=1,
 				rate=100,
 				do_not_submit=True,
+				ignore_sabb_validation=True,
 			)
 
 			self.assertRaises(frappe.ValidationError, pos_inv.submit)
@@ -1052,7 +1101,6 @@ def create_pos_invoice(**args):
 
 	pos_inv = frappe.new_doc("POS Invoice")
 	pos_inv.update(args)
-	pos_inv.update_stock = 1
 	pos_inv.is_pos = 1
 	pos_inv.pos_profile = args.pos_profile or pos_profile.name
 
@@ -1097,6 +1145,7 @@ def create_pos_invoice(**args):
 					"posting_time": pos_inv.posting_time,
 					"type_of_transaction": type_of_transaction,
 					"do_not_submit": True,
+					"ignore_sabb_validation": args.ignore_sabb_validation,
 				}
 			)
 		).name

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -146,6 +146,7 @@ class POSInvoiceMergeLog(Document):
 
 		sales_invoice.is_consolidated = 1
 		sales_invoice.set_posting_time = 1
+		sales_invoice.update_stock = 1
 
 		if not sales_invoice.posting_date:
 			sales_invoice.posting_date = getdate(self.posting_date)
@@ -174,6 +175,7 @@ class POSInvoiceMergeLog(Document):
 
 			credit_note.is_consolidated = 1
 			credit_note.set_posting_time = 1
+			credit_note.update_stock = 1
 			credit_note.posting_date = getdate(self.posting_date)
 			credit_note.posting_time = get_time(self.posting_time)
 			# TODO: return could be against multiple sales invoice which could also have been consolidated?
@@ -697,6 +699,7 @@ def get_sales_invoice_item(return_against_pos_invoice, pos_invoice_item):
 				& (SalesInvoice.is_return == 0)
 				& (SalesInvoiceItem.pos_invoice == return_against_pos_invoice)
 				& (SalesInvoiceItem.pos_invoice_item == pos_invoice_item)
+				& (SalesInvoice.docstatus == 1)
 			)
 		)
 

erpnext/accounts/doctype/pos_profile/pos_profile.json

@@ -25,7 +25,6 @@
   "validate_stock_on_save",
   "print_receipt_on_order_complete",
   "column_break_16",
-  "update_stock",
   "ignore_pricing_rule",
   "allow_rate_change",
   "allow_discount_change",
@@ -297,7 +296,6 @@
    "options": "Print Format"
   },
   {
-   "depends_on": "update_stock",
    "fieldname": "warehouse",
    "fieldtype": "Link",
    "label": "Warehouse",
@@ -312,14 +310,6 @@
    "fieldtype": "Check",
    "label": "Ignore Pricing Rule"
   },
-  {
-   "default": "1",
-   "fieldname": "update_stock",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Update Stock",
-   "read_only": 1
-  },
   {
    "default": "0",
    "fieldname": "hide_unavailable_items",
@@ -432,7 +422,7 @@
    "link_fieldname": "pos_profile"
   }
  ],
- "modified": "2025-04-14 15:58:20.497426",
+ "modified": "2026-02-22 04:17:03.308876",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Profile",

erpnext/accounts/doctype/pos_profile/pos_profile.py

@@ -61,7 +61,6 @@ class POSProfile(Document):
 		tax_category: DF.Link | None
 		taxes_and_charges: DF.Link | None
 		tc_name: DF.Link | None
-		update_stock: DF.Check
 		validate_stock_on_save: DF.Check
 		warehouse: DF.Link
 		write_off_account: DF.Link

erpnext/accounts/doctype/pricing_rule/pricing_rule.json

@@ -121,7 +121,7 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Apply On",
-   "options": "\nItem Code\nItem Group\nBrand\nTransaction",
+   "options": "Item Code\nItem Group\nBrand\nTransaction",
    "reqd": 1
   },
   {
@@ -657,7 +657,7 @@
  "icon": "fa fa-gift",
  "idx": 1,
  "links": [],
- "modified": "2025-08-20 11:40:07.096854",
+ "modified": "2026-02-17 12:24:07.553505",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Pricing Rule",
@@ -719,4 +719,4 @@
  "sort_order": "DESC",
  "states": [],
  "title_field": "title"
-}
+}

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -45,7 +45,7 @@ class PricingRule(Document):
 		apply_discount_on: DF.Literal["Grand Total", "Net Total"]
 		apply_discount_on_rate: DF.Check
 		apply_multiple_pricing_rules: DF.Check
-		apply_on: DF.Literal["", "Item Code", "Item Group", "Brand", "Transaction"]
+		apply_on: DF.Literal["Item Code", "Item Group", "Brand", "Transaction"]
 		apply_recursion_over: DF.Float
 		apply_rule_on_other: DF.Literal["", "Item Code", "Item Group", "Brand"]
 		brands: DF.Table[PricingRuleBrand]
@@ -346,8 +346,7 @@ def apply_pricing_rule(args, doc=None):
 
 	args = frappe._dict(args)
 
-	if not args.transaction_type:
-		set_transaction_type(args)
+	set_transaction_type(args)
 
 	# list of dictionaries
 	out = []
@@ -683,23 +682,23 @@ def remove_pricing_rules(item_list):
 	return out
 
 
-def set_transaction_type(args):
-	if args.transaction_type:
+def set_transaction_type(pricing_ctx: frappe._dict) -> None:
+	if pricing_ctx.transaction_type in ["buying", "selling"]:
 		return
-	if args.doctype in ("Opportunity", "Quotation", "Sales Order", "Delivery Note", "Sales Invoice"):
-		args.transaction_type = "selling"
-	elif args.doctype in (
+	if pricing_ctx.doctype in ("Opportunity", "Quotation", "Sales Order", "Delivery Note", "Sales Invoice"):
+		pricing_ctx.transaction_type = "selling"
+	elif pricing_ctx.doctype in (
 		"Material Request",
 		"Supplier Quotation",
 		"Purchase Order",
 		"Purchase Receipt",
 		"Purchase Invoice",
 	):
-		args.transaction_type = "buying"
-	elif args.customer:
-		args.transaction_type = "selling"
+		pricing_ctx.transaction_type = "buying"
+	elif pricing_ctx.customer:
+		pricing_ctx.transaction_type = "selling"
 	else:
-		args.transaction_type = "buying"
+		pricing_ctx.transaction_type = "buying"
 
 
 @frappe.whitelist()

erpnext/accounts/doctype/pricing_rule_brand/pricing_rule_brand.json

@@ -20,7 +20,7 @@
    "bold": 0,
    "collapsible": 0,
    "columns": 0,
-   "depends_on": "eval:parent.apply_on == 'Item Code'",
+   "depends_on": "eval:parent.apply_on == 'Brand'",
    "fieldname": "brand",
    "fieldtype": "Link",
    "hidden": 0,
@@ -91,7 +91,7 @@
  "issingle": 0,
  "istable": 1,
  "max_attachments": 0,
- "modified": "2019-03-24 14:48:59.649168",
+ "modified": "2026-02-17 12:17:13.073587",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Pricing Rule Brand",
@@ -107,4 +107,4 @@
  "track_changes": 1,
  "track_seen": 0,
  "track_views": 0
-}
+}

erpnext/accounts/doctype/pricing_rule_item_group/pricing_rule_item_group.json

@@ -20,7 +20,7 @@
    "bold": 0,
    "collapsible": 0,
    "columns": 0,
-   "depends_on": "eval:parent.apply_on == 'Item Code'",
+   "depends_on": "eval:parent.apply_on == 'Item Group'",
    "fieldname": "item_group",
    "fieldtype": "Link",
    "hidden": 0,
@@ -91,7 +91,7 @@
  "issingle": 0,
  "istable": 1,
  "max_attachments": 0,
- "modified": "2019-03-24 14:48:59.649168",
+ "modified": "2026-02-17 12:16:57.778471",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Pricing Rule Item Group",
@@ -107,4 +107,4 @@
  "track_changes": 1,
  "track_seen": 0,
  "track_views": 0
-}
+}

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.py

@@ -412,8 +412,9 @@ def reconcile(doc: None | str = None) -> None:
 					for x in allocations:
 						pr.append("allocation", x)
 
+					skip_ref_details_update_for_pe = check_multi_currency(pr)
 					# reconcile
-					pr.reconcile_allocations(skip_ref_details_update_for_pe=True)
+					pr.reconcile_allocations(skip_ref_details_update_for_pe=skip_ref_details_update_for_pe)
 
 					# If Payment Entry, update details only for newly linked references
 					# This is for performance
@@ -503,6 +504,37 @@ def reconcile(doc: None | str = None) -> None:
 				frappe.db.set_value("Process Payment Reconciliation", doc, "status", "Completed")
 
 
+def check_multi_currency(pr_doc):
+	GL = frappe.qb.DocType("GL Entry")
+	Account = frappe.qb.DocType("Account")
+
+	def get_account_currency(voucher_type, voucher_no):
+		currency = (
+			frappe.qb.from_(GL)
+			.join(Account)
+			.on(GL.account == Account.name)
+			.select(Account.account_currency)
+			.where(
+				(GL.voucher_type == voucher_type)
+				& (GL.voucher_no == voucher_no)
+				& (Account.account_type.isin(["Payable", "Receivable"]))
+			)
+			.limit(1)
+		).run(as_dict=True)
+
+		return currency[0].account_currency if currency else None
+
+	for allocation in pr_doc.allocation:
+		reference_currency = get_account_currency(allocation.reference_type, allocation.reference_name)
+
+		invoice_currency = get_account_currency(allocation.invoice_type, allocation.invoice_number)
+
+		if reference_currency != invoice_currency:
+			return True
+
+	return False
+
+
 @frappe.whitelist()
 def is_any_doc_running(for_filter: str | dict | None = None) -> str | None:
 	running_doc = None

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html

@@ -13,7 +13,7 @@
 		</div>
 		{% endif %}
 	</div>
-	<h2 class="text-center">{{ _("STATEMENTS OF ACCOUNTS") }}</h2>
+	<h2 class="text-center">{{ _("GENERAL LEDGER") }}</h2>
 	<div>
 		{% if filters.party[0] == filters.party_name[0] %}
 			<h5 style="float: left;">{{ _("Customer: ") }} <b>{{ filters.party_name[0] }}</b></h5>

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -1,5 +1,6 @@
 {
  "actions": [],
+ "allow_rename": 1,
  "autoname": "Prompt",
  "creation": "2020-05-22 16:46:18.712954",
  "doctype": "DocType",
@@ -67,7 +68,7 @@
    "fieldname": "frequency",
    "fieldtype": "Select",
    "label": "Frequency",
-   "options": "Weekly\nMonthly\nQuarterly"
+   "options": "Daily\nWeekly\nBiweekly\nMonthly\nQuarterly"
   },
   {
    "fieldname": "company",
@@ -401,7 +402,7 @@
   }
  ],
  "links": [],
- "modified": "2025-08-04 18:21:12.603623",
+ "modified": "2025-10-07 12:19:20.719898",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -8,7 +8,7 @@ import frappe
 from frappe import _
 from frappe.desk.reportview import get_match_cond
 from frappe.model.document import Document
-from frappe.utils import add_days, add_months, format_date, getdate, today
+from frappe.utils import add_days, add_months, add_to_date, format_date, getdate, today
 from frappe.utils.jinja import validate_template
 from frappe.utils.pdf import get_pdf
 from frappe.www.printview import get_print_style
@@ -55,7 +55,7 @@ class ProcessStatementOfAccounts(Document):
 		enable_auto_email: DF.Check
 		filter_duration: DF.Int
 		finance_book: DF.Link | None
-		frequency: DF.Literal["Weekly", "Monthly", "Quarterly"]
+		frequency: DF.Literal["Daily", "Weekly", "Biweekly", "Monthly", "Quarterly"]
 		from_date: DF.Date | None
 		ignore_cr_dr_notes: DF.Check
 		ignore_exchange_rate_revaluation_journals: DF.Check
@@ -529,8 +529,9 @@ def send_emails(document_name, from_scheduler=False, posting_date=None):
 
 		if doc.enable_auto_email and from_scheduler:
 			new_to_date = getdate(posting_date or today())
-			if doc.frequency == "Weekly":
-				new_to_date = add_days(new_to_date, 7)
+			if doc.frequency in ("Daily", "Weekly", "Biweekly"):
+				frequency = {"Daily": 1, "Weekly": 7, "Biweekly": 14}
+				new_to_date = add_days(new_to_date, frequency[doc.frequency])
 			else:
 				new_to_date = add_months(new_to_date, 1 if doc.frequency == "Monthly" else 3)
 			new_from_date = add_months(new_to_date, -1 * doc.filter_duration)

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts_accounts_receivable.html

@@ -6,228 +6,304 @@
 	.print-format td {
 		vertical-align:middle !important;
 	}
-	</style>
+</style>
 
-	<div id="header-html" class="hidden-pdf">
-		{% if letter_head.content %}
-		<div class="letter-head text-center">{{ letter_head.content }}</div>
-		<hr style="height:2px;border-width:0;color:black;background-color:black;">
-		{% endif %}
-	</div>
-	<div id="footer-html" class="visible-pdf">
-		{% if letter_head.footer %}
-		<div class="letter-head-footer">
-			<hr style="border-width:0;color:black;background-color:black;padding-bottom:2px;">
-			{{ letter_head.footer }}
-		</div>
-		{% endif %}
-	</div>
-
-	<h2 class="text-center" style="margin-top:0">{{ _(report.report_name) }}</h2>
-	<h4 class="text-center">
-		{{ filters.customer_name }}
-	</h4>
-	<h6 class="text-center">
-		{% if (filters.tax_id) %}
-		{{ _("Tax Id: ") }}{{ filters.tax_id }}
-		{% endif %}
-	</h6>
-	<h5 class="text-center">
-		{{ _(filters.ageing_based_on) }}
-		{{ _("Until") }}
-		{{ frappe.format(filters.report_date, 'Date') }}
-	</h5>
-
-	<div class="clearfix">
-		<div class="pull-left">
-		{% if(filters.payment_terms) %}
-			<strong>{{ _("Payment Terms") }}:</strong> {{ filters.payment_terms }}
-		{% endif %}
-		</div>
-		<div class="pull-right">
-		{% if(filters.credit_limit) %}
-			<strong>{{ _("Credit Limit") }}:</strong> {{ frappe.utils.fmt_money(filters.credit_limit) }}
-		{% endif %}
-		</div>
-	</div>
-
-	{% if(filters.show_future_payments) %}
-		{% set balance_row = data.slice(-1).pop() %}
-		{% for i in report.columns %}
-			{% if i.fieldname == 'age' %}
-				{% set elem = i %}
-			{% endif %}
-		{% endfor %}
-		{% set start = report.columns.findIndex(elem) %}
-		{% set range1 = report.columns[start].label %}
-		{% set range2 = report.columns[start+1].label %}
-		{% set range3 = report.columns[start+2].label %}
-		{% set range4 = report.columns[start+3].label %}
-		{% set range5 = report.columns[start+4].label %}
-		{% set range6 = report.columns[start+5].label %}
-
-		{% if(balance_row) %}
-		<table class="table table-bordered table-condensed">
-			<caption class="text-right">(Amount in {{ data[0]["currency"] ~ "" }})</caption>
-				<colgroup>
-					<col style="width: 30mm;">
-					<col style="width: 18mm;">
-					<col style="width: 18mm;">
-					<col style="width: 18mm;">
-					<col style="width: 18mm;">
-					<col style="width: 18mm;">
-					<col style="width: 18mm;">
-					<col style="width: 18mm;">
-				</colgroup>
-
-			<thead>
-				<tr>
-					<th>{{ _(" ") }}</th>
-					<th>{{ _(range1) }}</th>
-					<th>{{ _(range2) }}</th>
-					<th>{{ _(range3) }}</th>
-					<th>{{ _(range4) }}</th>
-					<th>{{ _(range5) }}</th>
-					<th>{{ _(range6) }}</th>
-					<th>{{ _("Total") }}</th>
-				</tr>
-			</thead>
-			<tbody>
-				<tr>
-					<td>{{ _("Total Outstanding") }}</td>
-					<td class="text-right">
-						{{ format_number(balance_row["age"], null, 2) }}
-					</td>
-					<td class="text-right">
-						{{ frappe.utils.fmt_money(balance_row["range1"], data[data.length-1]["currency"]) }}
-					</td>
-					<td class="text-right">
-						{{ frappe.utils.fmt_money(balance_row["range2"], data[data.length-1]["currency"]) }}
-					</td>
-					<td class="text-right">
-						{{ frappe.utils.fmt_money(balance_row["range3"], data[data.length-1]["currency"]) }}
-					</td>
-					<td class="text-right">
-						{{ frappe.utils.fmt_money(balance_row["range4"], data[data.length-1]["currency"]) }}
-					</td>
-					<td class="text-right">
-						{{ frappe.utils.fmt_money(balance_row["range5"], data[data.length-1]["currency"]) }}
-					</td>
-					<td class="text-right">
-						{{ frappe.utils.fmt_money(flt(balance_row["outstanding"]), data[data.length-1]["currency"]) }}
-					</td>
-				</tr>
-					<td>{{ _("Future Payments") }}</td>
-					<td></td>
-					<td></td>
-					<td></td>
-					<td></td>
-					<td></td>
-					<td></td>
-					<td class="text-right">
-						{{ frappe.utils.fmt_money(flt(balance_row[("future_amount")]), data[data.length-1]["currency"]) }}
-					</td>
-				<tr class="cvs-footer">
-					<th class="text-left">{{ _("Cheques Required") }}</th>
-					<th></th>
-					<th></th>
-					<th></th>
-					<th></th>
-					<th></th>
-					<th></th>
-					<th class="text-right">
-						{{ frappe.utils.fmt_money(flt(balance_row["outstanding"] - balance_row[("future_amount")]), data[data.length-1]["currency"]) }}</th>
-				</tr>
-			</tbody>
-
-		</table>
-		{% endif %}
+<div id="header-html" class="hidden-pdf">
+	{% if letter_head.content %}
+	<div class="letter-head text-center">{{ letter_head.content }}</div>
+	<hr style="height:2px;border-width:0;color:black;background-color:black;">
 	{% endif %}
-	<table class="table table-bordered">
+</div>
+<div id="footer-html" class="visible-pdf">
+	{% if letter_head.footer %}
+	<div class="letter-head-footer">
+		<hr style="border-width:0;color:black;background-color:black;padding-bottom:2px;">
+		{{ letter_head.footer }}
+	</div>
+	{% endif %}
+</div>
+
+<h2 class="text-center" style="margin-top:0">{{ _("STATEMENT OF ACCOUNTS") }}</h2>
+<h4 class="text-center">
+	{{ filters.customer_name }}
+</h4>
+<h6 class="text-center">
+	{% if (filters.tax_id) %}
+		{{ _("Tax Id: {0}").format(filters.tax_id) }}
+	{% endif %}
+</h6>
+<h5 class="text-center">
+	{{ _("{0} until {1}").format(
+		_(filters.ageing_based_on),
+		frappe.format(filters.report_date, 'Date')
+	) }}
+</h5>
+
+<div class="clearfix">
+	<div class="pull-left">
+	{% if(filters.payment_terms) %}
+		<strong>{{ _("Payment Terms:") }}</strong> {{ filters.payment_terms }}
+	{% endif %}
+	</div>
+	<div class="pull-right">
+	{% if(filters.credit_limit) %}
+		<strong>{{ _("Credit Limit:") }}</strong> {{ frappe.utils.fmt_money(filters.credit_limit) }}
+	{% endif %}
+	</div>
+</div>
+
+{% if(filters.show_future_payments)%}
+	{% set balance_row = data[-1] %}
+
+	{% set ns = namespace(idx=None) %}
+	{% for i in report.columns %}
+		{% if i.fieldname == "age" and ns.idx is none %}
+			{% set ns.idx = loop.index0 %}
+		{% endif %}
+	{% endfor %}
+
+	{% set age = report.columns[ns.idx].label %}
+	{% set range1 = report.columns[ns.idx+1].label %}
+	{% set range2 = report.columns[ns.idx+2].label %}
+	{% set range3 = report.columns[ns.idx+3].label %}
+	{% set range4 = report.columns[ns.idx+4].label %}
+	{% set range5 = report.columns[ns.idx+5].label %}
+
+	{% if(balance_row) %}
+	<table class="table table-bordered table-condensed">
+		<caption class="text-right">{{ _("Amount in {0}").format(data[0]["currency"] ~ "") }}</caption>
+			<colgroup>
+				<col style="width: 30mm;">
+				<col style="width: 18mm;">
+				<col style="width: 18mm;">
+				<col style="width: 18mm;">
+				<col style="width: 18mm;">
+				<col style="width: 18mm;">
+				<col style="width: 18mm;">
+				<col style="width: 18mm;">
+			</colgroup>
+
 		<thead>
 			<tr>
-				{% if(report.report_name == "Accounts Receivable" or report.report_name == "Accounts Payable") %}
-					<th style="width: 10%">{{ _("Date") }}</th>
-					<th style="width: 4%">{{ _("Age (Days)") }}</th>
-
-					{% if(report.report_name == "Accounts Receivable" and filters.show_sales_person) %}
-						<th style="width: 14%">{{ _("Reference") }}</th>
-						<th style="width: 10%">{{ _("Sales Person") }}</th>
-					{% else %}
-						<th style="width: 24%">{{ _("Reference") }}</th>
-					{% endif %}
-					{% if not(filters.show_future_payments) %}
-						<th style="width: 20%">
-						{% if (filters.customer or filters.supplier or filters.customer_name) %}
-							{{ _("Remarks") }}
-						{% else %}
-							{{ _("Party") }}
-						{% endif %}
-						</th>
-					{% endif %}
-					<th style="width: 10%; text-align: right">{{ _("Invoiced Amount") }}</th>
-					{% if not(filters.show_future_payments) %}
-						<th style="width: 10%; text-align: right">{{ _("Paid Amount") }}</th>
-						<th style="width: 10%; text-align: right">
-							{% if report.report_name == "Accounts Receivable" %}
-								{{ _('Credit Note') }}
-							{% else %}
-								{{ _('Debit Note') }}
-							{% endif %}
-						</th>
-					{% endif %}
-					<th style="width: 10%; text-align: right">{{ _("Outstanding Amount") }}</th>
-					{% if(filters.show_future_payments) %}
-						{% if(report.report_name == "Accounts Receivable") %}
-							<th style="width: 12%">{{ _("Customer LPO No.") }}</th>
-						{% endif %}
-						<th style="width: 10%">{{ _("Future Payment Ref") }}</th>
-						<th style="width: 10%">{{ _("Future Payment Amount") }}</th>
-						<th style="width: 10%">{{ _("Remaining Balance") }}</th>
-					{% endif %}
-				{% else %}
-					<th style="width: 40%">
-						{% if (filters.customer or filters.supplier or filters.customer_name) %}
-							{{ _("Remarks")}}
-						{% else %}
-							{{ _("Party") }}
-						{% endif %}
-					</th>
-					<th style="width: 15%">{{ _("Total Invoiced Amount") }}</th>
-					<th style="width: 15%">{{ _("Total Paid Amount") }}</th>
-					<th style="width: 15%">
-						{% if report.report_name == "Accounts Receivable Summary" %}
-							{{ _('Credit Note Amount') }}
-						{% else %}
-							{{ _('Debit Note Amount') }}
-						{% endif %}
-					</th>
-					<th style="width: 15%">{{ _("Total Outstanding Amount") }}</th>
-				{% endif %}
+				<th>{{ _(" ") }}</th>
+				<th>{{ _(age) }}</th>
+				<th>{{ _(range1) }}</th>
+				<th>{{ _(range2) }}</th>
+				<th>{{ _(range3) }}</th>
+				<th>{{ _(range4) }}</th>
+				<th>{{ _(range5) }}</th>
+				<th>{{ _("Total") }}</th>
 			</tr>
 		</thead>
 		<tbody>
-			{% for i in range(data|length) %}
-				<tr>
-				{% if(report.report_name == "Accounts Receivable" or report.report_name == "Accounts Payable") %}
-					{% if(data[i]["party"]) %}
-						<td>{{ frappe.format((data[i]["posting_date"]), 'Date') }}</td>
-						<td style="text-align: right">{{ data[i]["age"] }}</td>
-						<td>
-							{% if not(filters.show_future_payments) %}
-								{{ data[i]["voucher_type"] }}
-								<br>
-							{% endif %}
-							{{ data[i]["voucher_no"] }}
-						</td>
+			<tr>
+				<td>{{ _("Total Outstanding") }}</td>
+				<td class="text-right">
+					{{ frappe.utils.flt(balance_row["age"], 2) }}
+				</td>
+				<td class="text-right">
+					{{ frappe.utils.fmt_money(balance_row["range1"], currency=balance_row["currency"]) }}
+				</td>
+				<td class="text-right">
+					{{ frappe.utils.fmt_money(balance_row["range2"], currency=balance_row["currency"]) }}
+				</td>
+				<td class="text-right">
+					{{ frappe.utils.fmt_money(balance_row["range3"], currency=balance_row["currency"]) }}
+				</td>
+				<td class="text-right">
+					{{ frappe.utils.fmt_money(balance_row["range4"], currency=balance_row["currency"]) }}
+				</td>
+				<td class="text-right">
+					{{ frappe.utils.fmt_money(balance_row["range5"], currency=balance_row["currency"]) }}
+				</td>
+				<td class="text-right">
+					{{ frappe.utils.fmt_money(frappe.utils.flt(balance_row["outstanding"]), currency=balance_row["currency"]) }}
+				</td>
+			</tr>
+				<td>{{ _("Future Payments") }}</td>
+				<td></td>
+				<td></td>
+				<td></td>
+				<td></td>
+				<td></td>
+				<td></td>
+				<td class="text-right">
+					{{ frappe.utils.fmt_money(frappe.utils.flt(balance_row["future_amount"]), currency=balance_row["currency"]) }}
+				</td>
+			<tr class="cvs-footer">
+				<th class="text-left">{{ _("Cheques Required") }}</th>
+				<th></th>
+				<th></th>
+				<th></th>
+				<th></th>
+				<th></th>
+				<th></th>
+				<th class="text-right">
+					{{ frappe.utils.fmt_money(frappe.utils.flt(balance_row["outstanding"] - balance_row["future_amount"]), currency=balance_row["currency"]) }}</th>
+			</tr>
+		</tbody>
 
-						{% if(report.report_name == "Accounts Receivable" and filters.show_sales_person) %}
-						<td>{{ data[i]["sales_person"] }}</td>
+	</table>
+	{% endif %}
+{% endif %}
+<table class="table table-bordered">
+	<thead>
+		<tr>
+			{% if(report.report_name == "Accounts Receivable" or report.report_name == "Accounts Payable") %}
+				<th style="width: 10%">{{ _("Date") }}</th>
+				<th style="width: 4%">{{ _("Age (Days)") }}</th>
+
+				{% if(report.report_name == "Accounts Receivable" and filters.show_sales_person) %}
+					<th style="width: 14%">{{ _("Reference") }}</th>
+					<th style="width: 10%">{{ _("Sales Person") }}</th>
+				{% else %}
+					<th style="width: 24%">{{ _("Reference") }}</th>
+				{% endif %}
+				{% if not(filters.show_future_payments) and filters.show_remarks %}
+					<th style="width: 20%">
+					{% if (filters.customer or filters.supplier or filters.customer_name) %}
+						{{ _("Remarks") }}
+					{% else %}
+						{{ _("Party") }}
+					{% endif %}
+					</th>
+				{% endif %}
+				<th style="width: 10%; text-align: right">{{ _("Invoiced Amount") }}</th>
+				{% if not(filters.show_future_payments) %}
+					<th style="width: 10%; text-align: right">{{ _("Paid Amount") }}</th>
+					<th style="width: 10%; text-align: right">
+						{% if report.report_name == "Accounts Receivable" %}
+							{{ _("Credit Note") }}
+						{% else %}
+							{{ _("Debit Note") }}
 						{% endif %}
+					</th>
+				{% endif %}
+				<th style="width: 10%; text-align: right">{{ _("Outstanding Amount") }}</th>
+				{% if(filters.show_future_payments) %}
+					{% if(report.report_name == "Accounts Receivable") %}
+						<th style="width: 12%">{{ _("Customer LPO No.") }}</th>
+					{% endif %}
+					<th style="width: 10%">{{ _("Future Payment Ref") }}</th>
+					<th style="width: 10%">{{ _("Future Payment Amount") }}</th>
+					<th style="width: 10%">{{ _("Remaining Balance") }}</th>
+				{% endif %}
+			{% else %}
+				<th style="width: 40%">
+					{% if (filters.customer or filters.supplier or filters.customer_name) %}
+						{{ _("Remarks")}}
+					{% else %}
+						{{ _("Party") }}
+					{% endif %}
+				</th>
+				<th style="width: 15%">{{ _("Total Invoiced Amount") }}</th>
+				<th style="width: 15%">{{ _("Total Paid Amount") }}</th>
+				<th style="width: 15%">
+					{% if report.report_name == "Accounts Receivable Summary" %}
+						{{ _("Credit Note Amount") }}
+					{% else %}
+						{{ _("Debit Note Amount") }}
+					{% endif %}
+				</th>
+				<th style="width: 15%">{{ _("Total Outstanding Amount") }}</th>
+			{% endif %}
+		</tr>
+	</thead>
+	<tbody>
+		{% for i in range(data|length) %}
+			<tr>
+			{% if(report.report_name == "Accounts Receivable" or report.report_name == "Accounts Payable") %}
+				{% if(data[i]["party"]) %}
+					<td>{{ frappe.format(data[i]["posting_date"], 'Date') }}</td>
+					<td style="text-align: right">{{ data[i]["age"] }}</td>
+					<td>
+						{% if not(filters.show_future_payments) %}
+							{{ data[i]["voucher_type"] }}
+							<br>
+						{% endif %}
+						{{ data[i]["voucher_no"] }}
+					</td>
 
-						{% if not (filters.show_future_payments) %}
+					{% if(report.report_name == "Accounts Receivable" and filters.show_sales_person) %}
+					<td>{{ data[i]["sales_person"] }}</td>
+					{% endif %}
+
+					{% if not (filters.show_future_payments) and filters.show_remarks %}
+					<td>
+						{% if(not(filters.customer or filters.supplier or filters.customer_name)) %}
+							{{ data[i]["party"] }}
+							{% if(data[i]["customer_name"] and data[i]["customer_name"] != data[i]["party"]) %}
+								<br> {{ data[i]["customer_name"] }}
+							{% elif(data[i]["supplier_name"] != data[i]["party"]) %}
+								<br> {{ data[i]["supplier_name"] }}
+							{% endif %}
+						{% endif %}
+						<div>
+						{% if data[i]["remarks"] %}
+							{{ _("Remarks") }}:
+							{{ data[i]["remarks"] }}
+						{% endif %}
+						</div>
+					</td>
+					{% endif %}
+
+					<td style="text-align: right">
+						{{ frappe.utils.fmt_money(data[i]["invoiced"], currency=data[i]["currency"]) }}</td>
+
+					{% if not(filters.show_future_payments) %}
+						<td style="text-align: right">
+							{{ frappe.utils.fmt_money(data[i]["paid"], currency=data[i]["currency"]) }}</td>
+						<td style="text-align: right">
+							{{ frappe.utils.fmt_money(data[i]["credit_note"], currency=data[i]["currency"]) }}</td>
+					{% endif %}
+					<td style="text-align: right">
+						{{ frappe.utils.fmt_money(data[i]["outstanding"], currency=data[i]["currency"]) }}</td>
+
+					{% if(filters.show_future_payments) %}
+						{% if(report.report_name == "Accounts Receivable") %}
+							<td style="text-align: right">
+								{{ data[i]["po_no"] }}</td>
+						{% endif %}
+						<td style="text-align: right">{{ data[i]["future_ref"] }}</td>
+						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["future_amount"], currency=data[i]["currency"]) }}</td>
+						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["remaining_balance"], currency=data[i]["currency"]) }}</td>
+					{% endif %}
+				{% else %}
+					<td></td>
+					{% if not(filters.show_future_payments) %}
+					<td></td>
+					{% endif %}
+					{% if(report.report_name == "Accounts Receivable" and filters.show_sales_person) %}
+					<td></td>
+					{% endif %}
+					<td></td>
+					<td style="text-align: right"><b>{{ _("Total") }}</b></td>
+					<td style="text-align: right">
+						{{ frappe.utils.fmt_money(data[i]["invoiced"], data[i]["currency"]) }}</td>
+
+					{% if not(filters.show_future_payments) %}
+						<td style="text-align: right">
+							{{ frappe.utils.fmt_money(data[i]["paid"], currency=data[i]["currency"]) }}</td>
+						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["credit_note"], currency=data[i]["currency"]) }} </td>
+					{% endif %}
+					<td style="text-align: right">
+						{{ frappe.utils.fmt_money(data[i]["outstanding"], currency=data[i]["currency"]) }}</td>
+
+					{% if(filters.show_future_payments) %}
+						{% if(report.report_name == "Accounts Receivable") %}
+							<td style="text-align: right">
+								{{ data[i]["po_no"] }}</td>
+						{% endif %}
+						<td style="text-align: right">{{ data[i]["future_ref"] }}</td>
+						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["future_amount"], currency=data[i]["currency"]) }}</td>
+						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["remaining_balance"], currency=data[i]["currency"]) }}</td>
+					{% endif %}
+				{% endif %}
+			{% else %}
+				{% if(data[i]["party"] or "&nbsp;") %}
+					{% if not(data[i]["is_total_row"]) %}
 						<td>
-							{% if(not(filters.customer or filters.supplier or filters.customer_name)) %}
+							{% if(not(filters.customer | filters.supplier)) %}
 								{{ data[i]["party"] }}
 								{% if(data[i]["customer_name"] and data[i]["customer_name"] != data[i]["party"]) %}
 									<br> {{ data[i]["customer_name"] }}
@@ -235,132 +311,73 @@
 									<br> {{ data[i]["supplier_name"] }}
 								{% endif %}
 							{% endif %}
-							<div>
-							{% if data[i]["remarks"] %}
-								{{ _("Remarks") }}:
-								{{ data[i]["remarks"] }}
-							{% endif %}
-							</div>
+							<br>{{ _("Remarks") }}:
+							{{ data[i]["remarks"] }}
 						</td>
-						{% endif %}
-
-						<td style="text-align: right">
-							{{ frappe.utils.fmt_money(data[i]["invoiced"], currency=data[i]["currency"]) }}</td>
-
-						{% if not(filters.show_future_payments) %}
-							<td style="text-align: right">
-								{{ frappe.utils.fmt_money(data[i]["paid"], currency=data[i]["currency"]) }}</td>
-							<td style="text-align: right">
-								{{ frappe.utils.fmt_money(data[i]["credit_note"], currency=data[i]["currency"]) }}</td>
-						{% endif %}
-						<td style="text-align: right">
-							{{ frappe.utils.fmt_money(data[i]["outstanding"], currency=data[i]["currency"]) }}</td>
-
-						{% if(filters.show_future_payments) %}
-							{% if(report.report_name == "Accounts Receivable") %}
-								<td style="text-align: right">
-									{{ data[i]["po_no"] }}</td>
-							{% endif %}
-							<td style="text-align: right">{{ data[i]["future_ref"] }}</td>
-							<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["future_amount"], currency=data[i]["currency"]) }}</td>
-							<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["remaining_balance"], currency=data[i]["currency"]) }}</td>
-						{% endif %}
 					{% else %}
-						<td></td>
-						{% if not(filters.show_future_payments) %}
-						<td></td>
-						{% endif %}
-						{% if(report.report_name == "Accounts Receivable" and filters.show_sales_person) %}
-						<td></td>
-						{% endif %}
-						<td></td>
-						<td style="text-align: right"><b>{{ _("Total") }}</b></td>
-						<td style="text-align: right">
-							{{ frappe.utils.fmt_money(data[i]["invoiced"], data[i]["currency"]) }}</td>
-
-						{% if not(filters.show_future_payments) %}
-							<td style="text-align: right">
-								{{ frappe.utils.fmt_money(data[i]["paid"], currency=data[i]["currency"]) }}</td>
-							<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["credit_note"], currency=data[i]["currency"]) }} </td>
-						{% endif %}
-						<td style="text-align: right">
-							{{ frappe.utils.fmt_money(data[i]["outstanding"], currency=data[i]["currency"]) }}</td>
-
-						{% if(filters.show_future_payments) %}
-							{% if(report.report_name == "Accounts Receivable") %}
-								<td style="text-align: right">
-									{{ data[i]["po_no"] }}</td>
-							{% endif %}
-							<td style="text-align: right">{{ data[i]["future_ref"] }}</td>
-							<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["future_amount"], currency=data[i]["currency"]) }}</td>
-							<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["remaining_balance"], currency=data[i]["currency"]) }}</td>
-						{% endif %}
-					{% endif %}
-				{% else %}
-					{% if(data[i]["party"] or "&nbsp;") %}
-						{% if not(data[i]["is_total_row"]) %}
-							<td>
-								{% if(not(filters.customer | filters.supplier)) %}
-									{{ data[i]["party"] }}
-									{% if(data[i]["customer_name"] and data[i]["customer_name"] != data[i]["party"]) %}
-										<br> {{ data[i]["customer_name"] }}
-									{% elif(data[i]["supplier_name"] != data[i]["party"]) %}
-										<br> {{ data[i]["supplier_name"] }}
-									{% endif %}
-								{% endif %}
-								<br>{{ _("Remarks") }}:
-								{{ data[i]["remarks"] }}
-							</td>
-						{% else %}
-							<td><b>{{ _("Total") }}</b></td>
-						{% endif %}
-						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["invoiced"], currency=data[i]["currency"]) }}</td>
-						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["paid"], currency=data[i]["currency"]) }}</td>
-						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["credit_note"], currency=data[i]["currency"]) }}</td>
-						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["outstanding"], currency=data[i]["currency"]) }}</td>
+						<td><b>{{ _("Total") }}</b></td>
 					{% endif %}
+					<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["invoiced"], currency=data[i]["currency"]) }}</td>
+					<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["paid"], currency=data[i]["currency"]) }}</td>
+					<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["credit_note"], currency=data[i]["currency"]) }}</td>
+					<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["outstanding"], currency=data[i]["currency"]) }}</td>
 				{% endif %}
-				</tr>
-			{% endfor %}
-			<td></td>
-			<td></td>
+			{% endif %}
+			</tr>
+		{% endfor %}
+		<td></td>
+		<td></td>
+		{% if (filters.show_future_payments) or filters.show_remarks %}
 			<td></td>
+		{% endif %}
+		{% if not(filters.show_future_payments) %}
 			<td></td>
 			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="invoiced"), currency=data[0]["currency"]) }}</b></td>
 			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="paid"), currency=data[0]["currency"]) }}</b></td>
 			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="credit_note"), currency=data[0]["currency"]) }}</b></td>
 			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="outstanding"), currency=data[0]["currency"]) }}</b></td>
-		</tbody>
-	</table>
-	<br>
-	{% if ageing %}
-	<h4 class="text-center">{{ _("Ageing Report based on ") }} {{ ageing.ageing_based_on }}
-		{{ _("up to " ) }}  {{ frappe.format(filters.report_date, 'Date')}}
-	</h4>
-	<table class="table table-bordered">
-		<thead>
-			<tr>
-				<th style="width: 25%">0 - 30 Days</th>
-				<th style="width: 25%">30 - 60 Days</th>
-				<th style="width: 25%">60 - 90 Days</th>
-				<th style="width: 25%">90 - 120 Days</th>
-				<th style="width: 20%">Above 120 Days</th>
-			</tr>
-		</thead>
-		<tbody>
-			<tr>
-				<td>{{ frappe.utils.fmt_money(ageing.range1, currency=data[0]["currency"]) }}</td>
-				<td>{{ frappe.utils.fmt_money(ageing.range2, currency=data[0]["currency"]) }}</td>
-				<td>{{ frappe.utils.fmt_money(ageing.range3, currency=data[0]["currency"]) }}</td>
-				<td>{{ frappe.utils.fmt_money(ageing.range4, currency=data[0]["currency"]) }}</td>
-				<td>{{ frappe.utils.fmt_money(ageing.range5, currency=filters.presentation_currency) }}</td>
-			</tr>
-		</tbody>
-	</table>
-	{% endif %}
-	{% if terms_and_conditions %}
-	<div>
-		{{ terms_and_conditions }}
-	</div>
-	{% endif %}
-	<p class="text-right text-muted">{{ _("Printed On ") }}{{ frappe.utils.now() }}</p>
+		{% else %}
+			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="invoiced"), currency=data[0]["currency"]) }}</b></td>
+			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="outstanding"), currency=data[0]["currency"]) }}</b></td>
+			<td></td>
+			<td></td>
+			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="future_amount"), currency=data[0]["currency"]) }}</b></td>
+			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="remaining_balance"), currency=data[0]["currency"]) }}</b></td>
+		{% endif %}
+	</tbody>
+</table>
+<br>
+{% if ageing %}
+<h4 class="text-center">
+	{{ _("Ageing Report based on {0} up to {1}").format(
+		ageing.ageing_based_on,
+		frappe.format(filters.report_date, "Date")
+	) }}
+</h4>
+<table class="table table-bordered">
+	<thead>
+		<tr>
+			<th style="width: 25%">{{ _("0 - 30 Days") }}</th>
+			<th style="width: 25%">{{ _("30 - 60 Days") }}</th>
+			<th style="width: 25%">{{ _("60 - 90 Days") }}</th>
+			<th style="width: 25%">{{ _("90 - 120 Days") }}</th>
+			<th style="width: 20%">{{ _("Above 120 Days") }}</th>
+		</tr>
+	</thead>
+	<tbody>
+		<tr>
+			<td>{{ frappe.utils.fmt_money(ageing.range1, currency=data[0]["currency"]) }}</td>
+			<td>{{ frappe.utils.fmt_money(ageing.range2, currency=data[0]["currency"]) }}</td>
+			<td>{{ frappe.utils.fmt_money(ageing.range3, currency=data[0]["currency"]) }}</td>
+			<td>{{ frappe.utils.fmt_money(ageing.range4, currency=data[0]["currency"]) }}</td>
+			<td>{{ frappe.utils.fmt_money(ageing.range5, currency=filters.presentation_currency) }}</td>
+		</tr>
+	</tbody>
+</table>
+{% endif %}
+{% if terms_and_conditions %}
+<div>
+	{{ terms_and_conditions }}
+</div>
+{% endif %}
+<p class="text-right text-muted">{{ _("Printed on {0}").format(frappe.utils.now()) }}</p>

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -312,7 +312,7 @@
    "fieldname": "posting_date",
    "fieldtype": "Date",
    "in_list_view": 1,
-   "label": "Date",
+   "label": "Posting Date",
    "oldfieldname": "posting_date",
    "oldfieldtype": "Date",
    "print_hide": 1,
@@ -603,6 +603,7 @@
   },
   {
    "default": "0",
+   "depends_on": "eval:doc.items.every((item) => !item.pr_detail)",
    "fieldname": "update_stock",
    "fieldtype": "Check",
    "label": "Update Stock",
@@ -1659,7 +1660,7 @@
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-08-04 19:19:11.380664",
+ "modified": "2026-02-05 20:45:16.964500",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -38,7 +38,7 @@ from erpnext.accounts.utils import get_account_currency, get_fiscal_year, update
 from erpnext.assets.doctype.asset.asset import is_cwip_accounting_enabled
 from erpnext.assets.doctype.asset_category.asset_category import get_asset_category_account
 from erpnext.buying.utils import check_on_hold_or_closed_status
-from erpnext.controllers.accounts_controller import validate_account_head
+from erpnext.controllers.accounts_controller import merge_taxes, validate_account_head
 from erpnext.controllers.buying_controller import BuyingController
 from erpnext.stock import get_warehouse_account_map
 from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
@@ -728,9 +728,10 @@ class PurchaseInvoice(BuyingController):
 			for item in self.get("items"):
 				if item.purchase_receipt:
 					frappe.throw(
-						_("Stock cannot be updated against Purchase Receipt {0}").format(
-							item.purchase_receipt
-						)
+						_(
+							"Stock cannot be updated for Purchase Invoice {0} because a Purchase Receipt {1} has already been created for this transaction. Please disable the 'Update Stock' checkbox in the Purchase Invoice and save the invoice."
+						).format(self.name, item.purchase_receipt),
+						title=_("Stock Update Not Allowed"),
 					)
 
 	def validate_for_repost(self):
@@ -1729,10 +1730,6 @@ class PurchaseInvoice(BuyingController):
 			project_doc.db_update()
 
 	def validate_supplier_invoice(self):
-		if self.bill_date:
-			if getdate(self.bill_date) > getdate(self.posting_date):
-				frappe.throw(_("Supplier Invoice Date cannot be greater than Posting Date"))
-
 		if self.bill_no:
 			if cint(frappe.db.get_single_value("Accounts Settings", "check_supplier_invoice_uniqueness")):
 				fiscal_year = get_fiscal_year(self.posting_date, company=self.company, as_dict=True)
@@ -2083,6 +2080,19 @@ def make_purchase_receipt(source_name, target_doc=None, args=None):
 	if isinstance(args, str):
 		args = json.loads(args)
 
+	def post_parent_process(source_parent, target_parent):
+		remove_items_with_zero_qty(target_parent)
+		set_missing_values(source_parent, target_parent)
+
+	def remove_items_with_zero_qty(target_parent):
+		target_parent.items = [row for row in target_parent.get("items") if row.get("qty") != 0]
+
+	def set_missing_values(source_parent, target_parent):
+		target_parent.run_method("set_missing_values")
+		if args and args.get("merge_taxes"):
+			merge_taxes(source_parent, target_parent)
+		target_parent.run_method("calculate_taxes_and_totals")
+
 	def update_item(obj, target, source_parent):
 		target.qty = flt(obj.qty) - flt(obj.received_qty)
 		target.received_qty = flt(obj.qty) - flt(obj.received_qty)
@@ -2122,7 +2132,11 @@ def make_purchase_receipt(source_name, target_doc=None, args=None):
 				"postprocess": update_item,
 				"condition": lambda doc: abs(doc.received_qty) < abs(doc.qty) and select_item(doc),
 			},
-			"Purchase Taxes and Charges": {"doctype": "Purchase Taxes and Charges"},
+			"Purchase Taxes and Charges": {
+				"doctype": "Purchase Taxes and Charges",
+				"reset_value": not (args and args.get("merge_taxes")),
+				"ignore": args.get("merge_taxes") if args else 0,
+			},
 		},
 		target_doc,
 	)

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.py

@@ -215,16 +215,22 @@ def start_repost(account_repost_doc=str) -> None:
 
 
 def get_allowed_types_from_settings(child_doc: bool = False):
-	repost_docs = [
-		x.document_type
-		for x in frappe.db.get_all(
-			"Repost Allowed Types", filters={"allowed": True}, fields=["distinct(document_type)"]
-		)
-	]
+	# Avoid DISTINCT(...) here: Frappe applies a default ORDER BY which breaks on Postgres
+	# when used with SELECT DISTINCT.
+	repost_docs = frappe.db.get_all(
+		"Repost Allowed Types",
+		filters={"allowed": True},
+		pluck="document_type",
+	)
+
+	# De-dupe while preserving order (first occurrence wins)
+	repost_docs = list(dict.fromkeys(repost_docs))
 	result = repost_docs
 
 	if repost_docs and child_doc:
 		result.extend(get_child_docs(repost_docs))
+		# Keep uniqueness after extending
+		result = list(dict.fromkeys(result))
 
 	return result
 
@@ -291,8 +297,11 @@ def get_repost_allowed_types(doctype, txt, searchfield, start, page_len, filters
 	if txt:
 		filters.update({"document_type": ("like", f"%{txt}%")})
 
-	if allowed_types := frappe.db.get_all(
-		"Repost Allowed Types", filters=filters, fields=["distinct(document_type)"], as_list=1
-	):
-		return allowed_types
-	return []
+	allowed_types = frappe.db.get_all(
+		"Repost Allowed Types",
+		filters=filters,
+		pluck="document_type",
+	)
+
+	allowed_types = list(dict.fromkeys(allowed_types))
+	return [[dt] for dt in allowed_types]

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -43,6 +43,7 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 			"Unreconcile Payment Entries",
 			"Serial and Batch Bundle",
 			"Bank Transaction",
+			"Packing Slip",
 		];
 
 		if (!this.frm.doc.__islocal && !this.frm.doc.customer && this.frm.doc.debit_to) {
@@ -117,12 +118,20 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 					return item.delivery_note ? true : false;
 				});
 
-				if (!from_delivery_note && !is_delivered_by_supplier) {
-					cur_frm.add_custom_button(
-						__("Delivery"),
-						cur_frm.cscript["Make Delivery Note"],
-						__("Create")
+				if (!is_delivered_by_supplier) {
+					const should_create_delivery_note = doc.items.some(
+						(item) =>
+							item.qty - item.delivered_qty > 0 &&
+							!item.dn_detail &&
+							!item.delivered_by_supplier
 					);
+					if (should_create_delivery_note) {
+						this.frm.add_custom_button(
+							__("Delivery Note"),
+							this.frm.cscript["Make Delivery Note"],
+							__("Create")
+						);
+					}
 				}
 			}
 

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -373,7 +373,7 @@
    "fieldtype": "Date",
    "hide_days": 1,
    "hide_seconds": 1,
-   "label": "Date",
+   "label": "Posting Date",
    "no_copy": 1,
    "oldfieldname": "posting_date",
    "oldfieldtype": "Date",
@@ -701,6 +701,7 @@
   },
   {
    "default": "0",
+   "depends_on": "eval:doc.items.every((item) => !item.dn_detail)",
    "fieldname": "update_stock",
    "fieldtype": "Check",
    "hide_days": 1,
@@ -2199,7 +2200,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2025-09-09 14:48:59.472826",
+ "modified": "2026-02-05 20:43:44.732805",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -804,11 +804,9 @@ class SalesInvoice(SellingController):
 		if self.pos_profile:
 			pos = frappe.get_doc("POS Profile", self.pos_profile)
 
-		if not self.get("payments") and not for_validate:
-			update_multi_mode_option(self, pos)
-
 		if pos:
 			if not for_validate:
+				update_multi_mode_option(self, pos)
 				self.tax_category = pos.get("tax_category")
 
 			if not for_validate and not self.customer:
@@ -854,9 +852,6 @@ class SalesInvoice(SellingController):
 			if selling_price_list:
 				self.set("selling_price_list", selling_price_list)
 
-			if not for_validate:
-				self.update_stock = cint(pos.get("update_stock"))
-
 			# set pos values in items
 			for item in self.get("items"):
 				if item.get("item_code"):
@@ -1097,7 +1092,9 @@ class SalesInvoice(SellingController):
 			d.projected_qty = bin and flt(bin[0]["projected_qty"]) or 0
 
 	def update_packing_list(self):
-		if cint(self.update_stock) == 1:
+		if self.doctype == "POS Invoice" or (
+			self.doctype == "Sales Invoice" and cint(self.update_stock) == 1
+		):
 			from erpnext.stock.doctype.packed_item.packed_item import make_packing_list
 
 			make_packing_list(self)
@@ -1200,6 +1197,9 @@ class SalesInvoice(SellingController):
 				throw(_("Delivery Note {0} is not submitted").format(d.delivery_note))
 
 	def process_asset_depreciation(self):
+		if self.is_internal_transfer():
+			return
+
 		if (self.is_return and self.docstatus == 2) or (not self.is_return and self.docstatus == 1):
 			self.depreciate_asset_on_sale()
 		else:
@@ -2211,7 +2211,9 @@ def make_delivery_note(source_name, target_doc=None):
 					"cost_center": "cost_center",
 				},
 				"postprocess": update_item,
-				"condition": lambda doc: doc.delivered_by_supplier != 1,
+				"condition": lambda doc: doc.delivered_by_supplier != 1
+				and not doc.dn_detail
+				and doc.qty - doc.delivered_qty > 0,
 			},
 			"Sales Taxes and Charges": {"doctype": "Sales Taxes and Charges", "reset_value": True},
 			"Sales Team": {
@@ -2743,6 +2745,8 @@ def update_multi_mode_option(doc, pos_profile):
 		payment.account = payment_mode.default_account
 		payment.type = payment_mode.type
 
+	mop_refetched = bool(doc.payments)
+
 	doc.set("payments", [])
 	invalid_modes = []
 	mode_of_payments = [d.mode_of_payment for d in pos_profile.get("payments")]
@@ -2764,6 +2768,11 @@ def update_multi_mode_option(doc, pos_profile):
 			msg = _("Please set default Cash or Bank account in Mode of Payments {}")
 		frappe.throw(msg.format(", ".join(invalid_modes)), title=_("Missing Account"))
 
+	if mop_refetched:
+		frappe.msgprint(
+			_("Payment methods refreshed. Please review before proceeding."), indicator="orange", alert=True
+		)
+
 
 def get_all_mode_of_payments(doc):
 	return frappe.db.sql(

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -2974,6 +2974,60 @@ class TestSalesInvoice(FrappeTestCase):
 		self.assertEqual(sales_invoice.items[0].item_tax_template, "_Test Account Excise Duty @ 10 - _TC")
 		self.assertEqual(sales_invoice.items[0].item_tax_rate, item_tax_map)
 
+	def test_item_tax_template_change_with_grand_total_discount(self):
+		"""
+		Test that when item tax template changes due to discount on Grand Total,
+		the tax calculations are consistent.
+		"""
+		item = create_item("Test Item With Multiple Tax Templates")
+
+		item.set("taxes", [])
+		item.append(
+			"taxes",
+			{
+				"item_tax_template": "_Test Account Excise Duty @ 10 - _TC",
+				"minimum_net_rate": 0,
+				"maximum_net_rate": 500,
+			},
+		)
+
+		item.append(
+			"taxes",
+			{
+				"item_tax_template": "_Test Account Excise Duty @ 12 - _TC",
+				"minimum_net_rate": 501,
+				"maximum_net_rate": 1000,
+			},
+		)
+
+		item.save()
+
+		si = create_sales_invoice(item=item.name, rate=700, do_not_save=True)
+		si.append(
+			"taxes",
+			{
+				"charge_type": "On Net Total",
+				"account_head": "_Test Account Excise Duty - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "Excise Duty",
+				"rate": 0,
+			},
+		)
+		si.insert()
+
+		self.assertEqual(si.items[0].item_tax_template, "_Test Account Excise Duty @ 12 - _TC")
+
+		si.apply_discount_on = "Grand Total"
+		si.discount_amount = 300
+		si.save()
+
+		# Verify template changed to 10%
+		self.assertEqual(si.items[0].item_tax_template, "_Test Account Excise Duty @ 10 - _TC")
+		self.assertEqual(si.taxes[0].tax_amount, 70)  # 10% of 700
+		self.assertEqual(si.grand_total, 470)  # 700 + 70 - 300
+
+		si.submit()
+
 	@change_settings("Selling Settings", {"enable_discount_accounting": 1})
 	def test_sales_invoice_with_discount_accounting_enabled(self):
 		discount_account = create_account(
@@ -4721,6 +4775,66 @@ class TestSalesInvoice(FrappeTestCase):
 
 		self.assertEqual(q[0][0], 1)
 
+	@change_settings("Selling Settings", {"set_zero_rate_for_expired_batch": True})
+	def test_zero_valuation_for_standalone_credit_note_with_expired_batch(self):
+		item_code = "_Test Item for Expiry Batch Zero Valuation"
+		make_item_for_si(
+			item_code,
+			{
+				"is_stock_item": 1,
+				"has_batch_no": 1,
+				"has_expiry_date": 1,
+				"shelf_life_in_days": 2,
+				"create_new_batch": 1,
+				"batch_number_series": "TBATCH-EBZV.####",
+			},
+		)
+
+		se = make_stock_entry(
+			item_code=item_code,
+			qty=10,
+			target="_Test Warehouse - _TC",
+			rate=100,
+		)
+
+		# fetch batch no from bundle
+		batch_no = get_batch_from_bundle(se.items[0].serial_and_batch_bundle)
+
+		si = create_sales_invoice(
+			posting_date=add_days(nowdate(), 3),
+			item=item_code,
+			qty=-10,
+			rate=100,
+			is_return=1,
+			update_stock=1,
+			use_serial_batch_fields=1,
+			do_not_save=1,
+			do_not_submit=1,
+		)
+
+		si.items[0].batch_no = batch_no
+		si.save()
+		si.submit()
+
+		si.reload()
+		# check zero incoming rate in voucher
+		self.assertEqual(si.items[0].incoming_rate, 0.0)
+
+		# chekc zero incoming rate in stock ledger
+		stock_ledger_entry = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{
+				"voucher_type": "Sales Invoice",
+				"voucher_no": si.name,
+				"item_code": item_code,
+				"warehouse": "_Test Warehouse - _TC",
+			},
+			["incoming_rate", "valuation_rate"],
+			as_dict=True,
+		)
+
+		self.assertEqual(stock_ledger_entry.incoming_rate, 0.0)
+
 
 def make_item_for_si(item_code, properties=None):
 	from erpnext.stock.doctype.item.test_item import make_item

erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.json

@@ -840,6 +840,7 @@
    "fieldtype": "Currency",
    "label": "Incoming Rate (Costing)",
    "no_copy": 1,
+   "non_negative": 1,
    "options": "Company:company:default_currency",
    "print_hide": 1
   },
@@ -983,7 +984,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-03-12 16:33:55.503777",
+ "modified": "2026-02-23 14:37:14.853941",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Item",
@@ -993,4 +994,4 @@
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/sales_invoice_payment/sales_invoice_payment.json

@@ -26,7 +26,7 @@
   },
   {
    "default": "0",
-   "depends_on": "eval:parent.doctype == 'Sales Invoice'",
+   "depends_on": "eval: [\"POS Invoice\", \"Sales Invoice\"].includes(parent.doctype)",
    "fieldname": "amount",
    "fieldtype": "Currency",
    "in_list_view": 1,
@@ -85,7 +85,7 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2024-01-23 16:20:06.436979",
+ "modified": "2026-02-16 20:46:34.592604",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Payment",
@@ -95,4 +95,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/general_ledger.py

@@ -12,6 +12,7 @@ from frappe.utils import cint, flt, formatdate, get_link_to_form, getdate, now
 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,
@@ -612,6 +613,18 @@ def update_accounting_dimensions(round_off_gle):
 
 		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):
@@ -791,12 +804,19 @@ def validate_against_pcv(is_opening, posting_date, company):
 			title=_("Invalid Opening Entry"),
 		)
 
-	last_pcv_date = frappe.db.get_value(
-		"Period Closing Voucher", {"docstatus": 1, "company": company}, "max(period_end_date)"
-	)
+	# Local import so you don't have to touch file-level imports
+	from frappe.query_builder.functions import Max
+
+	pcv = frappe.qb.DocType("Period Closing Voucher")
+
+	last_pcv_date = (
+		frappe.qb.from_(pcv)
+		.select(Max(pcv.period_end_date))
+		.where((pcv.docstatus == 1) & (pcv.company == company))
+	).run(pluck=True)[0]
 
 	if last_pcv_date and getdate(posting_date) <= getdate(last_pcv_date):
-		message = _("Books have been closed till the period ending on {0}").format(formatdate(last_pcv_date))
+		message = _("Books have been closed till the period ending on {0}.").format(formatdate(last_pcv_date))
 		message += "</br >"
 		message += _("You cannot create/amend any accounting entries till this date.")
 		frappe.throw(message, title=_("Period Closed"))

erpnext/accounts/notification/notification_for_new_fiscal_year/notification_for_new_fiscal_year.html

@@ -0,0 +1,43 @@
+<h4>{{ _("New Fiscal Year - {0}").format(doc.name) }}</h4>
+
+<p>{{ _("A new fiscal year has been automatically created.") }}</p>
+
+<p>{{ _("Fiscal Year Details") }}</p>
+
+<table style="margin-bottom: 1rem; width: 70%">
+    <tr>
+        <td style="font-weight:bold; width: 40%">{{ _("Year Name") }}</td>
+        <td>{{ doc.name }}</td>
+    </tr>
+    <tr>
+        <td style="font-weight:bold; width: 40%">{{ _("Start Date") }}</td>
+        <td>{{ frappe.format_value(doc.year_start_date) }}</td>
+    </tr>
+    <tr>
+        <td style="font-weight:bold; width: 40%">{{ _("End Date") }}</td>
+        <td>{{ frappe.format_value(doc.year_end_date) }}</td>
+    </tr>
+    {% if doc.companies|length > 0 %}
+    <tr>
+        <td style="vertical-align: top; font-weight: bold; width: 40%" rowspan="{{ doc.companies|length }}">
+        {% if doc.companies|length < 2 %}
+            {{ _("Company") }}
+        {% else %}
+            {{ _("Companies") }}
+        {% endif %}
+        </td>
+        <td>{{ doc.companies[0].company }}</td>
+    </tr>
+    {% for idx in range(1, doc.companies|length) %}
+    <tr>
+        <td>{{ doc.companies[idx].company }}</td>
+    </tr>
+    {% endfor %}
+    {% endif %}
+</table>
+
+{% if doc.disabled %}
+<p>{{ _("The fiscal year has been automatically created in a Disabled state to maintain consistency with the previous fiscal year's status.") }}</p>
+{% endif %}
+
+<p>{{ _("Please review the {0} configuration and complete any required financial setup activities.").format(frappe.utils.get_link_to_form("Fiscal Year", doc.name, frappe.bold("Fiscal Year"))) }}</p>

erpnext/accounts/notification/notification_for_new_fiscal_year/notification_for_new_fiscal_year.json

@@ -1,7 +1,7 @@
 {
  "attach_print": 0,
  "channel": "Email",
- "condition": "doc.auto_created",
+ "condition": "doc.auto_created == 1",
  "creation": "2018-04-25 14:19:05.440361",
  "days_in_advance": 0,
  "docstatus": 0,
@@ -11,19 +11,22 @@
  "event": "New",
  "idx": 0,
  "is_standard": 1,
- "message": "<h3>{{_(\"Fiscal Year\")}}</h3>\n\n<p>{{ _(\"New fiscal year created :- \") }} {{ doc.name }}</p>",
- "modified": "2018-04-25 14:30:38.588534",
+ "message": "<h4>{{ _(\"New Fiscal Year - {0}\").format(doc.name) }}</h4>\n\n<p>{{ _(\"A new fiscal year has been automatically created.\") }}</p>\n\n<p>{{ _(\"Fiscal Year Details\") }}</p>\n\n<table style=\"margin-bottom: 1rem; width: 70%\">\n    <tr>\n        <td style=\"font-weight:bold; width: 40%\">{{ _(\"Year Name\") }}</td>\n        <td>{{ doc.name }}</td>\n    </tr>\n    <tr>\n        <td style=\"font-weight:bold; width: 40%\">{{ _(\"Start Date\") }}</td>\n        <td>{{ frappe.format_value(doc.year_start_date) }}</td>\n    </tr>\n    <tr>\n        <td style=\"font-weight:bold; width: 40%\">{{ _(\"End Date\") }}</td>\n        <td>{{ frappe.format_value(doc.year_end_date) }}</td>\n    </tr>\n    {% if doc.companies|length > 0 %}\n    <tr>\n        <td style=\"vertical-align: top; font-weight: bold; width: 40%\" rowspan=\"{{ doc.companies|length }}\">\n        {% if doc.companies|length < 2 %}\n            {{ _(\"Company\") }}\n        {% else %}\n            {{ _(\"Companies\") }}\n        {% endif %}\n        </td>\n        <td>{{ doc.companies[0].company }}</td>\n    </tr>\n    {% for idx in range(1, doc.companies|length) %}\n    <tr>\n        <td>{{ doc.companies[idx].company }}</td>\n    </tr>\n    {% endfor %}\n    {% endif %}\n</table>\n\n{% if doc.disabled %}\n<p>{{ _(\"The fiscal year has been automatically created in a Disabled state to maintain consistency with the previous fiscal year's status.\") }}</p>\n{% endif %}\n\n<p>{{ _(\"Please review the {0} configuration and complete any required financial setup activities.\").format(frappe.utils.get_link_to_form(\"Fiscal Year\", doc.name, frappe.bold(\"Fiscal Year\"))) }}</p>",
+ "message_type": "HTML",
+ "modified": "2026-02-21 15:59:07.775679",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Notification for new fiscal year",
  "owner": "Administrator",
  "recipients": [
   {
-   "email_by_role": "Accounts User"
+   "receiver_by_role": "Accounts Manager"
   },
   {
-   "email_by_role": "Accounts Manager"
+   "receiver_by_role": "Accounts User"
   }
  ],
- "subject": "Notification for new fiscal year {{ doc.name }}"
+ "send_system_notification": 0,
+ "send_to_all_assignees": 0,
+ "subject": "{{ _(\"New Fiscal Year {0} - Review Required\").format(doc.name) }}"
 }

erpnext/accounts/party.py

@@ -7,18 +7,16 @@ from frappe import _, msgprint, qb, scrub
 from frappe.contacts.doctype.address.address import get_company_address, get_default_address
 from frappe.core.doctype.user_permission.user_permission import get_permitted_documents
 from frappe.model.utils import get_fetch_values
-from frappe.query_builder.functions import Abs, Count, Date, Sum
+from frappe.query_builder.functions import Abs, Date, Sum
 from frappe.utils import (
 	add_days,
 	add_months,
-	add_years,
 	cint,
 	cstr,
 	date_diff,
 	flt,
 	formatdate,
 	get_last_day,
-	get_timestamp,
 	getdate,
 	nowdate,
 )
@@ -302,19 +300,9 @@ def complete_contact_details(party_details):
 	contact_details = frappe._dict()
 
 	if party_details.party_type == "Employee":
-		contact_details = frappe.db.get_value(
-			"Employee",
-			party_details.party,
-			[
-				"employee_name as contact_display",
-				"prefered_email as contact_email",
-				"cell_number as contact_mobile",
-				"designation as contact_designation",
-				"department as contact_department",
-			],
-			as_dict=True,
-		)
+		from erpnext.setup.doctype.employee.employee import _get_contact_details as get_employee_contact
 
+		contact_details = get_employee_contact(party_details.party)
 		contact_details.update({"contact_person": None, "contact_phone": None})
 	elif party_details.contact_person:
 		contact_details = frappe.db.get_value(

erpnext/accounts/print_format/journal_auditing_voucher/journal_auditing_voucher.html

@@ -17,7 +17,7 @@
             </div>
             <div class="col-xs-6">
                 <table>
-                    <tr><td><strong>Date: </strong></td><td>{{  frappe.utils.format_date(doc.creation)  }}</td></tr>
+                    <tr><td><strong>Date: </strong></td><td>{{  frappe.utils.format_date(doc.posting_date)  }}</td></tr>
                 </table>
             </div>
     </div>

erpnext/accounts/print_format/point_of_sale/point_of_sale.json

@@ -1,23 +0,0 @@
-{
- "align_labels_right": 0,
- "creation": "2016-05-05 17:16:18.564460",
- "custom_format": 1,
- "disabled": 0,
- "doc_type": "Sales Invoice",
- "docstatus": 0,
- "doctype": "Print Format",
- "font": "Default",
- "html": "<style>\n\t.print-format table, .print-format tr, \n\t.print-format td, .print-format div, .print-format p {\n\t\tfont-family: Monospace;\n\t\tline-height: 200%;\n\t\tvertical-align: middle;\n\t}\n\t@media screen {\n\t\t.print-format {\n\t\t\twidth: 4in;\n\t\t\tpadding: 0.25in;\n\t\t\tmin-height: 8in;\n\t\t}\n\t}\n</style>\n\n<p class=\"text-center\">\n\t{{ company }}<br>\n\t{{  __(\"POS No : \") }} {{ offline_pos_name }}<br>\n</p>\n<p>\n\t<b>{{ __(\"Customer\") }}:</b> {{ customer }}<br>\n</p>\n\n<p>\n\t<b>{{ __(\"Date\") }}:</b> {{ dateutil.global_date_format(posting_date) }}<br>\n</p>\n\n<hr>\n<table class=\"table table-condensed cart no-border\">\n\t<thead>\n\t\t<tr>\n\t\t\t<th width=\"50%\">{{ __(\"Item\") }}</b></th>\n\t\t\t<th width=\"25%\" class=\"text-right\">{{ __(\"Qty\") }}</th>\n\t\t\t<th width=\"25%\" class=\"text-right\">{{ __(\"Amount\") }}</th>\n\t\t</tr>\n\t</thead>\n\t<tbody>\n\t\t{% for item in items %}\n\t\t<tr>\n\t\t\t<td>\n\t\t\t\t{{ item.item_name }}\n\t\t\t</td>\n\t\t\t<td class=\"text-right\">{{ format_number(item.qty, null,precision(\"difference\")) }}<br>@ {{ format_currency(item.rate, currency) }}</td>\n\t\t\t<td class=\"text-right\">{{ format_currency(item.amount, currency) }}</td>\n\t\t</tr>\n\t\t{% endfor %}\n\t</tbody>\n</table>\n\n<table class=\"table table-condensed no-border\">\n\t<tbody>\n\t\t<tr>\n\t\t\t<td class=\"text-right\" style=\"width: 70%\">\n\t\t\t\t{{ __(\"Net Total\") }}\n\t\t\t</td>\n\t\t\t<td class=\"text-right\">\n\t\t\t\t{{ format_currency(total, currency) }}\n\t\t\t</td>\n\t\t</tr>\n\t\t{% for row in taxes %}\n\t\t{% if not row.included_in_print_rate %}\n\t\t<tr>\n\t\t\t<td class=\"text-right\" style=\"width: 70%\">\n\t\t\t\t{{ row.description }}\n\t\t\t</td>\n\t\t\t<td class=\"text-right\">\n\t\t\t\t{{ format_currency(row.tax_amount, currency) }}\n\t\t\t</td>\n\t\t</tr>\n\t\t{% endif %}\n\t\t{% endfor %}\n\t\t{% if discount_amount %}\n\t\t<tr>\n\t\t\t<td class=\"text-right\" style=\"width: 75%\">\n\t\t\t\t{{ __(\"Discount\") }}\n\t\t\t</td>\n\t\t\t<td class=\"text-right\">\n\t\t\t\t{{ format_currency(discount_amount, currency) }}\n\t\t\t</td>\n\t\t</tr>\n\t\t{% endif %}\n\t\t<tr>\n\t\t\t<td class=\"text-right\" style=\"width: 75%\">\n\t\t\t\t<b>{{ __(\"Grand Total\") }}</b>\n\t\t\t</td>\n\t\t\t<td class=\"text-right\">\n\t\t\t\t{{ format_currency(grand_total, currency) }}\n\t\t\t</td>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td class=\"text-right\" style=\"width: 75%\">\n\t\t\t\t<b>{{ __(\"Paid Amount\") }}</b>\n\t\t\t</td>\n\t\t\t<td class=\"text-right\">\n\t\t\t\t{{ format_currency(paid_amount, currency) }}\n\t\t\t</td>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td class=\"text-right\" style=\"width: 75%\">\n\t\t\t\t<b>{{ __(\"Qty Total\") }}</b>\n\t\t\t</td>\n\t\t\t<td class=\"text-right\">\n\t\t\t\t{{ qty_total }}\n\t\t\t</td>\n\t\t</tr>\n\t</tbody>\n</table>\n\n\n<hr>\n<p>{{ terms }}</p>\n<p class=\"text-center\">{{ __(\"Thank you, please visit again.\") }}</p>",
- "idx": 0,
- "line_breaks": 0,
- "modified": "2019-09-05 17:20:30.726659",
- "modified_by": "Administrator",
- "module": "Accounts",
- "name": "Point of Sale",
- "owner": "Administrator",
- "print_format_builder": 0,
- "print_format_type": "JS",
- "raw_printing": 0,
- "show_section_headings": 0,
- "standard": "Yes"
-}

erpnext/accounts/report/accounts_payable/accounts_payable.js

@@ -165,6 +165,10 @@ frappe.query_reports["Accounts Payable"] = {
 			var filters = report.get_values();
 			frappe.set_route("query-report", "Accounts Payable Summary", { company: filters.company });
 		});
+
+		if (frappe.boot.sysdefaults.default_ageing_range) {
+			report.set_filter_value("range", frappe.boot.sysdefaults.default_ageing_range);
+		}
 	},
 };
 

erpnext/accounts/report/accounts_payable/test_accounts_payable.py

@@ -1,6 +1,6 @@
 import frappe
 from frappe.tests.utils import FrappeTestCase
-from frappe.utils import today
+from frappe.utils import add_days, today
 
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 from erpnext.accounts.report.accounts_payable.accounts_payable import execute
@@ -57,3 +57,66 @@ class TestAccountsPayable(AccountsTestMixin, FrappeTestCase):
 		if not do_not_submit:
 			pi = pi.submit()
 		return pi
+
+	def test_payment_terms_template_filters(self):
+		from erpnext.controllers.accounts_controller import get_payment_terms
+
+		payment_term1 = frappe.get_doc(
+			{"doctype": "Payment Term", "payment_term_name": "_Test 50% on 15 Days"}
+		).insert()
+		payment_term2 = frappe.get_doc(
+			{"doctype": "Payment Term", "payment_term_name": "_Test 50% on 30 Days"}
+		).insert()
+
+		template = frappe.get_doc(
+			{
+				"doctype": "Payment Terms Template",
+				"template_name": "_Test 50-50",
+				"terms": [
+					{
+						"doctype": "Payment Terms Template Detail",
+						"due_date_based_on": "Day(s) after invoice date",
+						"payment_term": payment_term1.name,
+						"description": "_Test 50-50",
+						"invoice_portion": 50,
+						"credit_days": 15,
+					},
+					{
+						"doctype": "Payment Terms Template Detail",
+						"due_date_based_on": "Day(s) after invoice date",
+						"payment_term": payment_term2.name,
+						"description": "_Test 50-50",
+						"invoice_portion": 50,
+						"credit_days": 30,
+					},
+				],
+			}
+		)
+		template.insert()
+
+		filters = {
+			"company": self.company,
+			"report_date": today(),
+			"range": "30, 60, 90, 120",
+			"based_on_payment_terms": 1,
+			"payment_terms_template": template.name,
+			"ageing_based_on": "Posting Date",
+		}
+
+		pi = self.create_purchase_invoice(do_not_submit=True)
+		pi.payment_terms_template = template.name
+		schedule = get_payment_terms(template.name)
+		pi.set("payment_schedule", [])
+
+		for row in schedule:
+			row["due_date"] = add_days(pi.posting_date, row.get("credit_days", 0))
+			pi.append("payment_schedule", row)
+
+		pi.save()
+		pi.submit()
+
+		report = execute(filters)
+		row = report[1][0]
+
+		self.assertEqual(len(report[1]), 2)
+		self.assertEqual([pi.name, payment_term1.payment_term_name], [row.voucher_no, row.payment_term])

erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.js

@@ -114,6 +114,10 @@ frappe.query_reports["Accounts Payable Summary"] = {
 			var filters = report.get_values();
 			frappe.set_route("query-report", "Accounts Payable", { company: filters.company });
 		});
+
+		if (frappe.boot.sysdefaults.default_ageing_range) {
+			report.set_filter_value("range", frappe.boot.sysdefaults.default_ageing_range);
+		}
 	},
 };
 

erpnext/accounts/report/accounts_receivable/accounts_receivable.js

@@ -192,6 +192,10 @@ frappe.query_reports["Accounts Receivable"] = {
 			var filters = report.get_values();
 			frappe.set_route("query-report", "Accounts Receivable Summary", { company: filters.company });
 		});
+
+		if (frappe.boot.sysdefaults.default_ageing_range) {
+			report.set_filter_value("range", frappe.boot.sysdefaults.default_ageing_range);
+		}
 	},
 };
 

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -1029,9 +1029,8 @@ class ReceivablePayableReport:
 		self,
 	):
 		self.customer = qb.DocType("Customer")
-
 		if self.filters.get("customer_group"):
-			groups = get_customer_group_with_children(self.filters.customer_group)
+			groups = get_party_group_with_children("Customer", self.filters.customer_group)
 			customers = (
 				qb.from_(self.customer)
 				.select(self.customer.name)
@@ -1043,14 +1042,18 @@ class ReceivablePayableReport:
 			self.get_hierarchical_filters("Territory", "territory")
 
 		if self.filters.get("payment_terms_template"):
-			self.qb_selection_filter.append(
-				self.ple.party.isin(
-					qb.from_(self.customer)
-					.select(self.customer.name)
-					.where(self.customer.payment_terms == self.filters.get("payment_terms_template"))
-				)
+			customer_ptt = self.ple.party.isin(
+				qb.from_(self.customer)
+				.select(self.customer.name)
+				.where(self.customer.payment_terms == self.filters.get("payment_terms_template"))
 			)
 
+			si_ptt = self.add_payment_term_template_filters("Sales Invoice")
+
+			sales_ptt = self.ple.against_voucher_no.isin(si_ptt)
+
+			self.qb_selection_filter.append(Criterion.any([customer_ptt, sales_ptt]))
+
 		if self.filters.get("sales_partner"):
 			self.qb_selection_filter.append(
 				self.ple.party.isin(
@@ -1075,14 +1078,53 @@ class ReceivablePayableReport:
 			)
 
 		if self.filters.get("payment_terms_template"):
-			self.qb_selection_filter.append(
-				self.ple.party.isin(
-					qb.from_(supplier)
-					.select(supplier.name)
-					.where(supplier.payment_terms == self.filters.get("supplier_group"))
-				)
+			supplier_ptt = self.ple.party.isin(
+				qb.from_(supplier)
+				.select(supplier.name)
+				.where(supplier.payment_terms == self.filters.get("payment_terms_template"))
 			)
 
+			pi_ptt = self.add_payment_term_template_filters("Purchase Invoice")
+
+			purchase_ptt = self.ple.against_voucher_no.isin(pi_ptt)
+
+			self.qb_selection_filter.append(Criterion.any([supplier_ptt, purchase_ptt]))
+
+	def add_payment_term_template_filters(self, dtype):
+		voucher_type = qb.DocType(dtype)
+
+		ptt = (
+			qb.from_(voucher_type)
+			.select(voucher_type.name)
+			.where(voucher_type.payment_terms_template == self.filters.get("payment_terms_template"))
+			.where(voucher_type.company == self.filters.company)
+		)
+
+		if dtype == "Purchase Invoice":
+			party = "Supplier"
+			party_group_type = "supplier_group"
+			acc_type = "credit_to"
+		else:
+			party = "Customer"
+			party_group_type = "customer_group"
+			acc_type = "debit_to"
+
+		if self.filters.get(party_group_type):
+			party_groups = get_party_group_with_children(party, self.filters.get(party_group_type))
+			ptt = ptt.where((voucher_type[party_group_type]).isin(party_groups))
+
+		if self.filters.party:
+			ptt = ptt.where((voucher_type[party.lower()]).isin(self.filters.party))
+
+		if self.filters.cost_center:
+			cost_centers = get_cost_centers_with_children(self.filters.cost_center)
+			ptt = ptt.where(voucher_type.cost_center.isin(cost_centers))
+
+		if self.filters.party_account:
+			ptt = ptt.where(voucher_type[acc_type] == self.filters.party_account)
+
+		return ptt
+
 	def get_hierarchical_filters(self, doctype, key):
 		lft, rgt = frappe.db.get_value(doctype, self.filters.get(key), ["lft", "rgt"])
 
@@ -1320,20 +1362,26 @@ class ReceivablePayableReport:
 		self.err_journals = [x[0] for x in results] if results else []
 
 
-def get_customer_group_with_children(customer_groups):
-	if not isinstance(customer_groups, list):
-		customer_groups = [d.strip() for d in customer_groups.strip().split(",") if d]
+def get_party_group_with_children(party, party_groups):
+	if party not in ("Customer", "Supplier"):
+		return []
 
-	all_customer_groups = []
-	for d in customer_groups:
-		if frappe.db.exists("Customer Group", d):
-			lft, rgt = frappe.db.get_value("Customer Group", d, ["lft", "rgt"])
-			children = frappe.get_all("Customer Group", filters={"lft": [">=", lft], "rgt": ["<=", rgt]})
-			all_customer_groups += [c.name for c in children]
+	group_dtype = f"{party} Group"
+	if not isinstance(party_groups, list):
+		party_groups = [d.strip() for d in party_groups.strip().split(",") if d]
+
+	all_party_groups = []
+	for d in party_groups:
+		if frappe.db.exists(group_dtype, d):
+			lft, rgt = frappe.db.get_value(group_dtype, d, ["lft", "rgt"])
+			children = frappe.get_all(
+				group_dtype, filters={"lft": [">=", lft], "rgt": ["<=", rgt]}, pluck="name"
+			)
+			all_party_groups += children
 		else:
-			frappe.throw(_("Customer Group: {0} does not exist").format(d))
+			frappe.throw(_("{0}: {1} does not exist").format(group_dtype, d))
 
-	return list(set(all_customer_groups))
+	return list(set(all_party_groups))
 
 
 class InitSQLProceduresForAR:

erpnext/accounts/report/accounts_receivable/test_accounts_receivable.py

@@ -1139,3 +1139,66 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 		self.assertEqual(len(report[1]), 1)
 		row = report[1][0]
 		self.assertEqual(expected_data_after_payment, [row.voucher_no, row.cost_center, row.outstanding])
+
+	def test_payment_terms_template_filters(self):
+		from erpnext.controllers.accounts_controller import get_payment_terms
+
+		payment_term1 = frappe.get_doc(
+			{"doctype": "Payment Term", "payment_term_name": "_Test 50% on 15 Days"}
+		).insert()
+		payment_term2 = frappe.get_doc(
+			{"doctype": "Payment Term", "payment_term_name": "_Test 50% on 30 Days"}
+		).insert()
+
+		template = frappe.get_doc(
+			{
+				"doctype": "Payment Terms Template",
+				"template_name": "_Test 50-50",
+				"terms": [
+					{
+						"doctype": "Payment Terms Template Detail",
+						"due_date_based_on": "Day(s) after invoice date",
+						"payment_term": payment_term1.name,
+						"description": "_Test 50-50",
+						"invoice_portion": 50,
+						"credit_days": 15,
+					},
+					{
+						"doctype": "Payment Terms Template Detail",
+						"due_date_based_on": "Day(s) after invoice date",
+						"payment_term": payment_term2.name,
+						"description": "_Test 50-50",
+						"invoice_portion": 50,
+						"credit_days": 30,
+					},
+				],
+			}
+		)
+		template.insert()
+
+		filters = {
+			"company": self.company,
+			"report_date": today(),
+			"range": "30, 60, 90, 120",
+			"based_on_payment_terms": 1,
+			"payment_terms_template": template.name,
+			"ageing_based_on": "Posting Date",
+		}
+
+		si = self.create_sales_invoice(no_payment_schedule=True, do_not_submit=True)
+		si.payment_terms_template = template.name
+		schedule = get_payment_terms(template.name)
+		si.set("payment_schedule", [])
+
+		for row in schedule:
+			row["due_date"] = add_days(si.posting_date, row.get("credit_days", 0))
+			si.append("payment_schedule", row)
+
+		si.save()
+		si.submit()
+
+		report = execute(filters)
+		row = report[1][0]
+
+		self.assertEqual(len(report[1]), 2)
+		self.assertEqual([si.name, payment_term1.payment_term_name], [row.voucher_no, row.payment_term])

erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.js

@@ -137,6 +137,10 @@ frappe.query_reports["Accounts Receivable Summary"] = {
 			var filters = report.get_values();
 			frappe.set_route("query-report", "Accounts Receivable", { company: filters.company });
 		});
+
+		if (frappe.boot.sysdefaults.default_ageing_range) {
+			report.set_filter_value("range", frappe.boot.sysdefaults.default_ageing_range);
+		}
 	},
 };
 

erpnext/accounts/report/balance_sheet/balance_sheet.py

@@ -96,7 +96,7 @@ def execute(filters=None):
 		filters.periodicity, period_list, filters.accumulated_values, company=filters.company
 	)
 
-	chart = get_chart_data(filters, columns, asset, liability, equity, currency)
+	chart = get_chart_data(filters, period_list, asset, liability, equity, currency)
 
 	report_summary, primitive_summary = get_report_summary(
 		period_list, asset, liability, equity, provisional_profit_loss, currency, filters
@@ -225,18 +225,19 @@ def get_report_summary(
 	], (net_asset - net_liability + net_equity)
 
 
-def get_chart_data(filters, columns, asset, liability, equity, currency):
-	labels = [d.get("label") for d in columns[2:]]
+def get_chart_data(filters, chart_columns, asset, liability, equity, currency):
+	labels = [col.get("label") for col in chart_columns]
 
 	asset_data, liability_data, equity_data = [], [], []
 
-	for p in columns[2:]:
+	for col in chart_columns:
+		key = col.get("key") or col.get("fieldname")
 		if asset:
-			asset_data.append(asset[-2].get(p.get("fieldname")))
+			asset_data.append(asset[-2].get(key))
 		if liability:
-			liability_data.append(liability[-2].get(p.get("fieldname")))
+			liability_data.append(liability[-2].get(key))
 		if equity:
-			equity_data.append(equity[-2].get(p.get("fieldname")))
+			equity_data.append(equity[-2].get(key))
 
 	datasets = []
 	if asset_data:

erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py

@@ -4,7 +4,10 @@
 
 import frappe
 from frappe import _
-from frappe.utils import getdate, nowdate
+from frappe.query_builder import Case
+from frappe.query_builder.custom import ConstantColumn
+from frappe.utils import getdate
+from pypika import Order
 
 
 def execute(filters=None):
@@ -48,17 +51,6 @@ def get_columns():
 	return columns
 
 
-def get_conditions(filters):
-	conditions = ""
-
-	if filters.get("from_date"):
-		conditions += " and posting_date>=%(from_date)s"
-	if filters.get("to_date"):
-		conditions += " and posting_date<=%(to_date)s"
-
-	return conditions
-
-
 def get_entries(filters):
 	entries = []
 
@@ -73,41 +65,90 @@ def get_entries(filters):
 
 	return sorted(
 		entries,
-		key=lambda k: k[2].strftime("%H%M%S") or getdate(nowdate()),
+		key=lambda k: getdate(k[2]),
 	)
 
 
 def get_entries_for_bank_clearance_summary(filters):
 	entries = []
 
-	conditions = get_conditions(filters)
+	je = frappe.qb.DocType("Journal Entry")
+	jea = frappe.qb.DocType("Journal Entry Account")
 
-	journal_entries = frappe.db.sql(
-		f"""SELECT
-			"Journal Entry", jv.name, jv.posting_date, jv.cheque_no,
-			jv.clearance_date, jvd.against_account, jvd.debit - jvd.credit
-		FROM
-			`tabJournal Entry Account` jvd, `tabJournal Entry` jv
-		WHERE
-			jvd.parent = jv.name and jv.docstatus=1 and jvd.account = %(account)s {conditions}
-			order by posting_date DESC, jv.name DESC""",
-		filters,
-		as_list=1,
-	)
+	journal_entries = (
+		frappe.qb.from_(jea)
+		.inner_join(je)
+		.on(jea.parent == je.name)
+		.select(
+			ConstantColumn("Journal Entry").as_("payment_document"),
+			je.name.as_("payment_entry"),
+			je.posting_date,
+			je.cheque_no,
+			je.clearance_date,
+			jea.against_account,
+			jea.debit_in_account_currency - jea.credit_in_account_currency,
+		)
+		.where(
+			(jea.account == filters.account)
+			& (je.docstatus == 1)
+			& (je.posting_date >= filters.from_date)
+			& (je.posting_date <= filters.to_date)
+			& ((je.is_opening == "No") | (je.is_opening.isnull()))
+		)
+		.orderby(je.posting_date, order=Order.desc)
+		.orderby(je.name, order=Order.desc)
+	).run(as_list=True)
 
-	payment_entries = frappe.db.sql(
-		f"""SELECT
-			"Payment Entry", name, posting_date, reference_no, clearance_date, party,
-			if(paid_from=%(account)s, ((paid_amount * -1) - total_taxes_and_charges) , received_amount)
-		FROM
-			`tabPayment Entry`
-		WHERE
-			docstatus=1 and (paid_from = %(account)s or paid_to = %(account)s) {conditions}
-			order by posting_date DESC, name DESC""",
-		filters,
-		as_list=1,
-	)
+	pe = frappe.qb.DocType("Payment Entry")
+	payment_entries = (
+		frappe.qb.from_(pe)
+		.select(
+			ConstantColumn("Payment Entry").as_("payment_document"),
+			pe.name.as_("payment_entry"),
+			pe.posting_date,
+			pe.reference_no.as_("cheque_no"),
+			pe.clearance_date,
+			pe.party.as_("against_account"),
+			Case()
+			.when(
+				(pe.paid_from == filters.account),
+				((pe.paid_amount * -1) - pe.total_taxes_and_charges),
+			)
+			.else_(pe.received_amount),
+		)
+		.where((pe.paid_from == filters.account) | (pe.paid_to == filters.account))
+		.where(
+			(pe.docstatus == 1)
+			& (pe.posting_date >= filters.from_date)
+			& (pe.posting_date <= filters.to_date)
+		)
+		.orderby(pe.posting_date, order=Order.desc)
+		.orderby(pe.name, order=Order.desc)
+	).run(as_list=True)
 
-	entries = journal_entries + payment_entries
+	pi = frappe.qb.DocType("Purchase Invoice")
+	purchase_invoices = (
+		frappe.qb.from_(pi)
+		.select(
+			ConstantColumn("Purchase Invoice").as_("payment_document"),
+			pi.name.as_("payment_entry"),
+			pi.posting_date,
+			pi.bill_no.as_("cheque_no"),
+			pi.clearance_date,
+			pi.supplier.as_("against_account"),
+			(pi.paid_amount * -1).as_("amount"),
+		)
+		.where(
+			(pi.docstatus == 1)
+			& (pi.is_paid == 1)
+			& (pi.cash_bank_account == filters.account)
+			& (pi.posting_date >= filters.from_date)
+			& (pi.posting_date <= filters.to_date)
+		)
+		.orderby(pi.posting_date, order=Order.desc)
+		.orderby(pi.name, order=Order.desc)
+	).run(as_list=True)
+
+	entries = journal_entries + payment_entries + purchase_invoices
 
 	return entries

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py

@@ -4,7 +4,11 @@
 
 import frappe
 from frappe import _
+from frappe.query_builder import Case
+from frappe.query_builder.custom import ConstantColumn
+from frappe.query_builder.functions import Coalesce, Sum
 from frappe.utils import flt, getdate
+from pypika import Order
 
 from erpnext.accounts.utils import get_balance_on
 
@@ -123,73 +127,143 @@ def get_entries_for_bank_reconciliation_statement(filters):
 
 	payment_entries = get_payment_entries(filters)
 
+	purchase_invoices = get_purchase_invoices(filters)
+
 	pos_entries = []
 	if filters.include_pos_transactions:
 		pos_entries = get_pos_entries(filters)
 
-	return list(journal_entries) + list(payment_entries) + list(pos_entries)
+	return list(journal_entries) + list(payment_entries) + list(pos_entries) + list(purchase_invoices)
 
 
 def get_journal_entries(filters):
-	return frappe.db.sql(
-		"""
-		select "Journal Entry" as payment_document, jv.posting_date,
-			jv.name as payment_entry, jvd.debit_in_account_currency as debit,
-			jvd.credit_in_account_currency as credit, jvd.against_account,
-			jv.cheque_no as reference_no, jv.cheque_date as ref_date, jv.clearance_date, jvd.account_currency
-		from
-			`tabJournal Entry Account` jvd, `tabJournal Entry` jv
-		where jvd.parent = jv.name and jv.docstatus=1
-			and jvd.account = %(account)s and jv.posting_date <= %(report_date)s
-			and ifnull(jv.clearance_date, '4000-01-01') > %(report_date)s
-			and ifnull(jv.is_opening, 'No') = 'No'
-			and jv.company = %(company)s """,
-		filters,
-		as_dict=1,
-	)
+	je = frappe.qb.DocType("Journal Entry")
+	jea = frappe.qb.DocType("Journal Entry Account")
+	return (
+		frappe.qb.from_(jea)
+		.join(je)
+		.on(jea.parent == je.name)
+		.select(
+			ConstantColumn("Journal Entry").as_("payment_document"),
+			je.name.as_("payment_entry"),
+			je.posting_date,
+			jea.debit_in_account_currency.as_("debit"),
+			jea.credit_in_account_currency.as_("credit"),
+			jea.against_account,
+			je.cheque_no.as_("reference_no"),
+			je.cheque_date.as_("ref_date"),
+			je.clearance_date,
+			jea.account_currency,
+		)
+		.where(
+			(je.docstatus == 1)
+			& (jea.account == filters.account)
+			& (je.posting_date <= filters.report_date)
+			& (je.clearance_date.isnull() | (je.clearance_date > filters.report_date))
+			& (je.company == filters.company)
+			& ((je.is_opening.isnull()) | (je.is_opening == "No"))
+		)
+		.orderby(je.posting_date)
+		.orderby(je.name, order=Order.desc)
+	).run(as_dict=True)
 
 
 def get_payment_entries(filters):
-	return frappe.db.sql(
-		"""
-		select
-			"Payment Entry" as payment_document, name as payment_entry,
-			reference_no, reference_date as ref_date,
-			if(paid_to=%(account)s, received_amount_after_tax, 0) as debit,
-			if(paid_from=%(account)s, paid_amount_after_tax, 0) as credit,
-			posting_date, ifnull(party,if(paid_from=%(account)s,paid_to,paid_from)) as against_account, clearance_date,
-			if(paid_to=%(account)s, paid_to_account_currency, paid_from_account_currency) as account_currency
-		from `tabPayment Entry`
-		where
-			(paid_from=%(account)s or paid_to=%(account)s) and docstatus=1
-			and posting_date <= %(report_date)s
-			and ifnull(clearance_date, '4000-01-01') > %(report_date)s
-			and company = %(company)s
-	""",
-		filters,
-		as_dict=1,
-	)
+	pe = frappe.qb.DocType("Payment Entry")
+	return (
+		frappe.qb.from_(pe)
+		.select(
+			ConstantColumn("Payment Entry").as_("payment_document"),
+			pe.name.as_("payment_entry"),
+			pe.reference_no.as_("reference_no"),
+			pe.reference_date.as_("ref_date"),
+			Case().when(pe.paid_to == filters.account, pe.received_amount_after_tax).else_(0).as_("debit"),
+			Case().when(pe.paid_from == filters.account, pe.paid_amount_after_tax).else_(0).as_("credit"),
+			pe.posting_date,
+			Coalesce(
+				pe.party, Case().when(pe.paid_from == filters.account, pe.paid_to).else_(pe.paid_from)
+			).as_("against_account"),
+			pe.clearance_date,
+			(
+				Case()
+				.when(pe.paid_to == filters.account, pe.paid_to_account_currency)
+				.else_(pe.paid_from_account_currency)
+			).as_("account_currency"),
+		)
+		.where(
+			(pe.docstatus == 1)
+			& ((pe.paid_from == filters.account) | (pe.paid_to == filters.account))
+			& (pe.posting_date <= filters.report_date)
+			& (pe.clearance_date.isnull() | (pe.clearance_date > filters.report_date))
+			& (pe.company == filters.company)
+		)
+		.orderby(pe.posting_date)
+		.orderby(pe.name, order=Order.desc)
+	).run(as_dict=True)
+
+
+def get_purchase_invoices(filters):
+	pi = frappe.qb.DocType("Purchase Invoice")
+	acc = frappe.qb.DocType("Account")
+	return (
+		frappe.qb.from_(pi)
+		.inner_join(acc)
+		.on(pi.cash_bank_account == acc.name)
+		.select(
+			ConstantColumn("Purchase Invoice").as_("payment_document"),
+			pi.name.as_("payment_entry"),
+			pi.bill_no.as_("reference_no"),
+			pi.posting_date.as_("ref_date"),
+			Case().when(pi.paid_amount < 0, pi.paid_amount * -1).else_(0).as_("debit"),
+			Case().when(pi.paid_amount > 0, pi.paid_amount).else_(0).as_("credit"),
+			pi.posting_date,
+			pi.supplier.as_("against_account"),
+			pi.clearance_date,
+			acc.account_currency,
+		)
+		.where(
+			(pi.docstatus == 1)
+			& (pi.is_paid == 1)
+			& (pi.cash_bank_account == filters.account)
+			& (pi.posting_date <= filters.report_date)
+			& (pi.clearance_date.isnull() | (pi.clearance_date > filters.report_date))
+			& (pi.company == filters.company)
+		)
+		.orderby(pi.posting_date)
+		.orderby(pi.name, order=Order.desc)
+	).run(as_dict=True)
 
 
 def get_pos_entries(filters):
-	return frappe.db.sql(
-		"""
-			select
-				"Sales Invoice Payment" as payment_document, sip.name as payment_entry, sip.amount as debit,
-				si.posting_date, si.debit_to as against_account, sip.clearance_date,
-				account.account_currency, 0 as credit
-			from `tabSales Invoice Payment` sip, `tabSales Invoice` si, `tabAccount` account
-			where
-				sip.account=%(account)s and si.docstatus=1 and sip.parent = si.name
-				and account.name = sip.account and si.posting_date <= %(report_date)s and
-				ifnull(sip.clearance_date, '4000-01-01') > %(report_date)s
-				and si.company = %(company)s
-			order by
-				si.posting_date ASC, si.name DESC
-		""",
-		filters,
-		as_dict=1,
-	)
+	si = frappe.qb.DocType("Sales Invoice")
+	si_payment = frappe.qb.DocType("Sales Invoice Payment")
+	acc = frappe.qb.DocType("Account")
+	return (
+		frappe.qb.from_(si_payment)
+		.join(si)
+		.on(si_payment.parent == si.name)
+		.join(acc)
+		.on(si_payment.account == acc.name)
+		.select(
+			ConstantColumn("Sales Invoice").as_("payment_document"),
+			si.name.as_("payment_entry"),
+			si_payment.amount.as_("debit"),
+			si.posting_date,
+			si.debit_to.as_("against_account"),
+			si_payment.clearance_date,
+			acc.account_currency,
+			ConstantColumn(0).as_("credit"),
+		)
+		.where(
+			(si_payment.account == filters.account)
+			& (si.docstatus == 1)
+			& (si.posting_date <= filters.report_date)
+			& (si_payment.clearance_date.isnull() | (si_payment.clearance_date > filters.report_date))
+			& (si.company == filters.company)
+		)
+		.orderby(si.posting_date)
+		.orderby(si_payment.name, order=Order.desc)
+	).run(as_dict=True)
 
 
 def get_amounts_not_reflected_in_system(filters):
@@ -205,30 +279,66 @@ def get_amounts_not_reflected_in_system(filters):
 
 
 def get_amounts_not_reflected_in_system_for_bank_reconciliation_statement(filters):
-	je_amount = frappe.db.sql(
-		"""
-		select sum(jvd.debit_in_account_currency - jvd.credit_in_account_currency)
-		from `tabJournal Entry Account` jvd, `tabJournal Entry` jv
-		where jvd.parent = jv.name and jv.docstatus=1 and jvd.account=%(account)s
-		and jv.posting_date > %(report_date)s and jv.clearance_date <= %(report_date)s
-		and ifnull(jv.is_opening, 'No') = 'No' """,
-		filters,
+	je = frappe.qb.DocType("Journal Entry")
+	jea = frappe.qb.DocType("Journal Entry Account")
+
+	je_amount = (
+		frappe.qb.from_(jea)
+		.inner_join(je)
+		.on(jea.parent == je.name)
+		.select(
+			Sum(jea.debit_in_account_currency - jea.credit_in_account_currency).as_("amount"),
+		)
+		.where(
+			(je.docstatus == 1)
+			& (jea.account == filters.account)
+			& (je.posting_date > filters.report_date)
+			& (je.clearance_date <= filters.report_date)
+			& (je.company == filters.company)
+			& ((je.is_opening.isnull()) | (je.is_opening == "No"))
+		)
+		.run(as_dict=True)
 	)
+	je_amount = flt(je_amount[0].amount) if je_amount else 0.0
 
-	je_amount = flt(je_amount[0][0]) if je_amount else 0.0
-
-	pe_amount = frappe.db.sql(
-		"""
-		select sum(if(paid_from=%(account)s, paid_amount, received_amount))
-		from `tabPayment Entry`
-		where (paid_from=%(account)s or paid_to=%(account)s) and docstatus=1
-		and posting_date > %(report_date)s and clearance_date <= %(report_date)s""",
-		filters,
+	pe = frappe.qb.DocType("Payment Entry")
+	pe_amount = (
+		frappe.qb.from_(pe)
+		.select(
+			Sum(Case().when(pe.paid_from == filters.account, pe.paid_amount).else_(pe.received_amount)).as_(
+				"amount"
+			),
+		)
+		.where(
+			((pe.paid_from == filters.account) | (pe.paid_to == filters.account))
+			& (pe.docstatus == 1)
+			& (pe.posting_date > filters.report_date)
+			& (pe.clearance_date <= filters.report_date)
+			& (pe.company == filters.company)
+		)
+		.run(as_dict=True)
 	)
+	pe_amount = flt(pe_amount[0].amount) if pe_amount else 0.0
 
-	pe_amount = flt(pe_amount[0][0]) if pe_amount else 0.0
+	pi = frappe.qb.DocType("Purchase Invoice")
+	pi_amount = (
+		frappe.qb.from_(pi)
+		.select(
+			Sum(pi.paid_amount).as_("amount"),
+		)
+		.where(
+			(pi.docstatus == 1)
+			& (pi.is_paid == 1)
+			& (pi.cash_bank_account == filters.account)
+			& (pi.posting_date > filters.report_date)
+			& (pi.clearance_date <= filters.report_date)
+			& (pi.company == filters.company)
+		)
+	).run(as_dict=True)
 
-	return je_amount + pe_amount
+	pi_amount = flt(pi_amount[0].amount) if pi_amount else 0.0
+
+	return je_amount + pe_amount + pi_amount
 
 
 def get_balance_row(label, amount, account_currency):

erpnext/accounts/report/cash_flow/cash_flow.py

@@ -139,7 +139,7 @@ def execute(filters=None):
 		True,
 	)
 
-	chart = get_chart_data(columns, data, company_currency)
+	chart = get_chart_data(period_list, data, company_currency)
 
 	report_summary = get_report_summary(summary_data, company_currency)
 
@@ -411,13 +411,12 @@ def get_report_summary(summary_data, currency):
 	return report_summary
 
 
-def get_chart_data(columns, data, currency):
-	labels = [d.get("label") for d in columns[2:]]
-	print(data)
+def get_chart_data(period_list, data, currency):
+	labels = [period.get("label") for period in period_list]
 	datasets = [
 		{
 			"name": section.get("section").replace("'", ""),
-			"values": [section.get(d.get("fieldname")) for d in columns[2:]],
+			"values": [section.get(period.get("key")) for period in period_list],
 		}
 		for section in data
 		if section.get("parent_section") is None and section.get("currency")

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py

@@ -48,22 +48,25 @@ def execute(filters=None):
 		return columns, data, message, chart
 
 	fiscal_year = get_fiscal_year_data(filters.get("from_fiscal_year"), filters.get("to_fiscal_year"))
-	companies_column, companies = get_companies(filters)
-	columns = get_columns(companies_column, filters)
+	company_list, companies = get_companies(filters)
+	company_columns = get_company_columns(company_list, filters)
+	columns = get_columns(company_columns)
 
 	if filters.get("report") == "Balance Sheet":
 		data, message, chart, report_summary = get_balance_sheet_data(
-			fiscal_year, companies, columns, filters
+			fiscal_year, companies, company_columns, filters
 		)
 	elif filters.get("report") == "Profit and Loss Statement":
-		data, message, chart, report_summary = get_profit_loss_data(fiscal_year, companies, columns, filters)
+		data, message, chart, report_summary = get_profit_loss_data(
+			fiscal_year, companies, company_columns, filters
+		)
 	else:
 		data, report_summary = get_cash_flow_data(fiscal_year, companies, filters)
 
 	return columns, data, message, chart, report_summary
 
 
-def get_balance_sheet_data(fiscal_year, companies, columns, filters):
+def get_balance_sheet_data(fiscal_year, companies, company_columns, filters):
 	asset = get_data(companies, "Asset", "Debit", fiscal_year, filters=filters)
 
 	liability = get_data(companies, "Liability", "Credit", fiscal_year, filters=filters)
@@ -116,7 +119,7 @@ def get_balance_sheet_data(fiscal_year, companies, columns, filters):
 		True,
 	)
 
-	chart = get_chart_data(filters, columns, asset, liability, equity, company_currency)
+	chart = get_chart_data(filters, company_columns, asset, liability, equity, company_currency)
 
 	return data, message, chart, report_summary
 
@@ -164,7 +167,7 @@ def get_root_account_name(root_type, company):
 		return root_account[0][0]
 
 
-def get_profit_loss_data(fiscal_year, companies, columns, filters):
+def get_profit_loss_data(fiscal_year, companies, company_columns, filters):
 	income, expense, net_profit_loss = get_income_expense_data(companies, fiscal_year, filters)
 	company_currency = get_company_currency(filters)
 
@@ -174,7 +177,7 @@ def get_profit_loss_data(fiscal_year, companies, columns, filters):
 	if net_profit_loss:
 		data.append(net_profit_loss)
 
-	chart = get_pl_chart_data(filters, columns, income, expense, net_profit_loss, company_currency)
+	chart = get_pl_chart_data(filters, company_columns, income, expense, net_profit_loss, company_currency)
 
 	report_summary, primitive_summary = get_pl_summary(
 		companies, "", income, expense, net_profit_loss, company_currency, filters, True
@@ -279,7 +282,30 @@ def get_account_type_based_data(account_type, companies, fiscal_year, filters):
 	return data
 
 
-def get_columns(companies, filters):
+def get_company_columns(companies, filters):
+	company_columns = []
+	for company in companies:
+		apply_currency_formatter = 1 if not filters.presentation_currency else 0
+		currency = filters.presentation_currency
+		if not currency:
+			currency = erpnext.get_company_currency(company)
+
+		company_columns.append(
+			{
+				"fieldname": company,
+				"label": f"{company} ({currency})",
+				"fieldtype": "Currency",
+				"options": "currency",
+				"width": 150,
+				"apply_currency_formatter": apply_currency_formatter,
+				"company_name": company,
+			}
+		)
+
+	return company_columns
+
+
+def get_columns(company_columns):
 	columns = [
 		{
 			"fieldname": "account",
@@ -297,23 +323,7 @@ def get_columns(companies, filters):
 		},
 	]
 
-	for company in companies:
-		apply_currency_formatter = 1 if not filters.presentation_currency else 0
-		currency = filters.presentation_currency
-		if not currency:
-			currency = erpnext.get_company_currency(company)
-
-		columns.append(
-			{
-				"fieldname": company,
-				"label": f"{company} ({currency})",
-				"fieldtype": "Currency",
-				"options": "currency",
-				"width": 150,
-				"apply_currency_formatter": apply_currency_formatter,
-				"company_name": company,
-			}
-		)
+	columns.extend(company_columns)
 
 	return columns
 

erpnext/accounts/report/general_and_payment_ledger_comparison/general_and_payment_ledger_comparison.js

@@ -37,6 +37,20 @@ function get_filters() {
 				});
 			},
 		},
+		{
+			fieldname: "party_type",
+			label: __("Party Type"),
+			fieldtype: "Link",
+			options: "Party Type",
+			width: 100,
+		},
+		{
+			fieldname: "party",
+			label: __("Party"),
+			fieldtype: "Dynamic Link",
+			options: "party_type",
+			width: 100,
+		},
 		{
 			fieldname: "voucher_no",
 			label: __("Voucher No"),

erpnext/accounts/report/general_and_payment_ledger_comparison/general_and_payment_ledger_comparison.py

@@ -68,6 +68,12 @@ class General_Payment_Ledger_Comparison:
 				if self.filters.period_end_date:
 					filter_criterion.append(gle.posting_date.lte(self.filters.period_end_date))
 
+				if self.filters.party_type:
+					filter_criterion.append(gle.party_type.eq(self.filters.party_type))
+
+				if self.filters.party:
+					filter_criterion.append(gle.party.eq(self.filters.party))
+
 				if acc_type == "receivable":
 					outstanding = (Sum(gle.debit) - Sum(gle.credit)).as_("outstanding")
 				else:
@@ -111,6 +117,12 @@ class General_Payment_Ledger_Comparison:
 				if self.filters.period_end_date:
 					filter_criterion.append(ple.posting_date.lte(self.filters.period_end_date))
 
+				if self.filters.party_type:
+					filter_criterion.append(ple.party_type.eq(self.filters.party_type))
+
+				if self.filters.party:
+					filter_criterion.append(ple.party.eq(self.filters.party))
+
 				self.account_types[acc_type].ple = (
 					qb.from_(ple)
 					.select(

erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py

@@ -219,13 +219,18 @@ def get_net_profit(
 
 	has_value = False
 
+	gross_income_roots = [row for row in (gross_income or []) if not flt(row.get("indent"))]
+	non_gross_income_roots = [row for row in (non_gross_income or []) if not flt(row.get("indent"))]
+	gross_expense_roots = [row for row in (gross_expense or []) if not flt(row.get("indent"))]
+	non_gross_expense_roots = [row for row in (non_gross_expense or []) if not flt(row.get("indent"))]
+
 	for period in period_list:
 		key = period if consolidated else period.key
-		gross_income_for_period = flt(gross_income[0].get(key, 0)) if gross_income else 0
-		non_gross_income_for_period = flt(non_gross_income[0].get(key, 0)) if non_gross_income else 0
 
-		gross_expense_for_period = flt(gross_expense[0].get(key, 0)) if gross_expense else 0
-		non_gross_expense_for_period = flt(non_gross_expense[0].get(key, 0)) if non_gross_expense else 0
+		gross_income_for_period = sum(flt(row.get(key, 0)) for row in gross_income_roots)
+		non_gross_income_for_period = sum(flt(row.get(key, 0)) for row in non_gross_income_roots)
+		gross_expense_for_period = sum(flt(row.get(key, 0)) for row in gross_expense_roots)
+		non_gross_expense_for_period = sum(flt(row.get(key, 0)) for row in non_gross_expense_roots)
 
 		total_income = gross_income_for_period + non_gross_income_for_period
 		total_expense = gross_expense_for_period + non_gross_expense_for_period

erpnext/accounts/report/gross_profit/gross_profit.py

@@ -5,15 +5,16 @@ from collections import OrderedDict
 
 import frappe
 from frappe import _, qb, scrub
-from frappe.query_builder import Order
+from frappe.query_builder import Case, Order
+from frappe.query_builder.functions import Coalesce
 from frappe.utils import cint, flt, formatdate
+from pypika.terms import ExistsCriterion
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
 	get_dimension_with_children,
 )
 from erpnext.accounts.report.financial_statements import get_cost_centers_with_children
-from erpnext.controllers.queries import get_match_cond
 from erpnext.stock.report.stock_ledger.stock_ledger import get_item_group_condition
 from erpnext.stock.utils import get_incoming_rate
 
@@ -176,7 +177,9 @@ def get_data_when_grouped_by_invoice(columns, gross_profit_data, filters, group_
 	column_names = get_column_names()
 
 	# to display item as Item Code: Item Name
-	columns[0] = "Sales Invoice:Link/Item:300"
+	columns[0]["fieldname"] = "sales_invoice"
+	columns[0]["options"] = "Item"
+	columns[0]["width"] = 300
 	# removing Item Code and Item Name columns
 	supplier_master_name = frappe.db.get_single_value("Buying Settings", "supp_master_name")
 	customer_master_name = frappe.db.get_single_value("Selling Settings", "cust_master_name")
@@ -203,7 +206,11 @@ def get_data_when_grouped_by_invoice(columns, gross_profit_data, filters, group_
 
 		data.append(row)
 
-	total_gross_profit = total_base_amount - total_buying_amount
+	total_gross_profit = flt(
+		total_base_amount + abs(total_buying_amount)
+		if total_buying_amount < 0
+		else total_base_amount - total_buying_amount,
+	)
 	data.append(
 		frappe._dict(
 			{
@@ -215,7 +222,7 @@ def get_data_when_grouped_by_invoice(columns, gross_profit_data, filters, group_
 				"buying_amount": total_buying_amount,
 				"gross_profit": total_gross_profit,
 				"gross_profit_%": flt(
-					(total_gross_profit / total_base_amount) * 100.0,
+					(total_gross_profit / abs(total_base_amount)) * 100.0,
 					cint(frappe.db.get_default("currency_precision")) or 3,
 				)
 				if total_base_amount
@@ -248,9 +255,13 @@ def get_data_when_not_grouped_by_invoice(gross_profit_data, filters, group_wise_
 
 		data.append(row)
 
-	total_gross_profit = total_base_amount - total_buying_amount
+	total_gross_profit = flt(
+		total_base_amount + abs(total_buying_amount)
+		if total_buying_amount < 0
+		else total_base_amount - total_buying_amount,
+	)
 	currency_precision = cint(frappe.db.get_default("currency_precision")) or 3
-	gross_profit_percent = (total_gross_profit / total_base_amount * 100.0) if total_base_amount else 0
+	gross_profit_percent = (total_gross_profit / abs(total_base_amount) * 100.0) if total_base_amount else 0
 
 	total_row = {
 		group_columns[0]: "Total",
@@ -581,10 +592,15 @@ class GrossProfitGenerator:
 				base_amount += row.base_amount
 
 			# calculate gross profit
-			row.gross_profit = flt(row.base_amount - row.buying_amount, self.currency_precision)
+			row.gross_profit = flt(
+				row.base_amount + abs(row.buying_amount)
+				if row.buying_amount < 0
+				else row.base_amount - row.buying_amount,
+				self.currency_precision,
+			)
 			if row.base_amount:
 				row.gross_profit_percent = flt(
-					(row.gross_profit / row.base_amount) * 100.0,
+					(row.gross_profit / abs(row.base_amount)) * 100.0,
 					self.currency_precision,
 				)
 			else:
@@ -633,7 +649,7 @@ class GrossProfitGenerator:
 						new_row = row
 						self.set_average_based_on_payment_term_portion(new_row, row, invoice_portion)
 					else:
-						new_row.qty += flt(row.qty)
+						new_row.qty = flt((new_row.qty + row.qty), self.float_precision)
 						self.set_average_based_on_payment_term_portion(new_row, row, invoice_portion, True)
 
 				new_row = self.set_average_rate(new_row)
@@ -643,11 +659,17 @@ class GrossProfitGenerator:
 					if i == 0:
 						new_row = row
 					else:
-						new_row.qty += flt(row.qty)
-						new_row.buying_amount += flt(row.buying_amount, self.currency_precision)
-						new_row.base_amount += flt(row.base_amount, self.currency_precision)
+						new_row.qty = flt((new_row.qty + row.qty), self.float_precision)
+						new_row.buying_amount = flt(
+							(new_row.buying_amount + row.buying_amount), self.currency_precision
+						)
+						new_row.base_amount = flt(
+							(new_row.base_amount + row.base_amount), self.currency_precision
+						)
 						if self.filters.get("group_by") == "Sales Person":
-							new_row.allocated_amount += flt(row.allocated_amount, self.currency_precision)
+							new_row.allocated_amount = flt(
+								(new_row.allocated_amount + row.allocated_amount), self.currency_precision
+							)
 				new_row = self.set_average_rate(new_row)
 				self.grouped_data.append(new_row)
 
@@ -673,9 +695,14 @@ class GrossProfitGenerator:
 		return new_row
 
 	def set_average_gross_profit(self, new_row):
-		new_row.gross_profit = flt(new_row.base_amount - new_row.buying_amount, self.currency_precision)
+		new_row.gross_profit = flt(
+			new_row.base_amount + abs(new_row.buying_amount)
+			if new_row.buying_amount < 0
+			else new_row.base_amount - new_row.buying_amount,
+			self.currency_precision,
+		)
 		new_row.gross_profit_percent = (
-			flt(((new_row.gross_profit / new_row.base_amount) * 100.0), self.currency_precision)
+			flt(((new_row.gross_profit / abs(new_row.base_amount)) * 100.0), self.currency_precision)
 			if new_row.base_amount
 			else 0
 		)
@@ -851,129 +878,173 @@ class GrossProfitGenerator:
 		return flt(last_purchase_rate[0][0]) if last_purchase_rate else 0
 
 	def load_invoice_items(self):
-		conditions = ""
-		if self.filters.company:
-			conditions += " and `tabSales Invoice`.company = %(company)s"
-		if self.filters.from_date:
-			conditions += " and posting_date >= %(from_date)s"
-		if self.filters.to_date:
-			conditions += " and posting_date <= %(to_date)s"
+		self.si_list = []
+
+		SalesInvoice = frappe.qb.DocType("Sales Invoice")
+		base_query = self.prepare_invoice_query()
 
 		if self.filters.include_returned_invoices:
-			conditions += " and (is_return = 0 or (is_return=1 and return_against is null))"
+			invoice_query = base_query.where(
+				(SalesInvoice.is_return == 0)
+				| ((SalesInvoice.is_return == 1) & SalesInvoice.return_against.isnull())
+			)
 		else:
-			conditions += " and is_return = 0"
+			invoice_query = base_query.where(SalesInvoice.is_return == 0)
 
-		if self.filters.item_group:
-			conditions += f" and {get_item_group_condition(self.filters.item_group)}"
+		self.si_list += invoice_query.run(as_dict=True)
+		self.prepare_vouchers_to_ignore()
 
-		if self.filters.sales_person:
-			conditions += """
-				and exists(select 1
-							from `tabSales Team` st
-							where st.parent = `tabSales Invoice`.name
-							and   st.sales_person = %(sales_person)s)
-			"""
+		ret_invoice_query = base_query.where(
+			(SalesInvoice.is_return == 1) & SalesInvoice.return_against.isnotnull()
+		)
+		if self.vouchers_to_ignore:
+			ret_invoice_query = ret_invoice_query.where(
+				SalesInvoice.return_against.notin(self.vouchers_to_ignore)
+			)
+
+		self.si_list += ret_invoice_query.run(as_dict=True)
+
+	def prepare_invoice_query(self):
+		SalesInvoice = frappe.qb.DocType("Sales Invoice")
+		SalesInvoiceItem = frappe.qb.DocType("Sales Invoice Item")
+		Item = frappe.qb.DocType("Item")
+		SalesTeam = frappe.qb.DocType("Sales Team")
+		PaymentSchedule = frappe.qb.DocType("Payment Schedule")
+
+		query = (
+			frappe.qb.from_(SalesInvoice)
+			.join(SalesInvoiceItem)
+			.on(SalesInvoiceItem.parent == SalesInvoice.name)
+			.join(Item)
+			.on(Item.name == SalesInvoiceItem.item_code)
+			.where((SalesInvoice.docstatus == 1) & (SalesInvoice.is_opening != "Yes"))
+		)
+
+		query = self.apply_common_filters(query, SalesInvoice, SalesInvoiceItem, SalesTeam, Item)
+
+		query = query.select(
+			SalesInvoiceItem.parenttype,
+			SalesInvoiceItem.parent,
+			SalesInvoice.posting_date,
+			SalesInvoice.posting_time,
+			SalesInvoice.project,
+			SalesInvoice.update_stock,
+			SalesInvoice.customer,
+			SalesInvoice.customer_group,
+			SalesInvoice.customer_name,
+			SalesInvoice.territory,
+			SalesInvoiceItem.item_code,
+			SalesInvoice.base_net_total.as_("invoice_base_net_total"),
+			SalesInvoiceItem.item_name,
+			SalesInvoiceItem.description,
+			SalesInvoiceItem.warehouse,
+			SalesInvoiceItem.item_group,
+			SalesInvoiceItem.brand,
+			SalesInvoiceItem.so_detail,
+			SalesInvoiceItem.sales_order,
+			SalesInvoiceItem.dn_detail,
+			SalesInvoiceItem.delivery_note,
+			SalesInvoiceItem.stock_qty.as_("qty"),
+			SalesInvoiceItem.base_net_rate,
+			SalesInvoiceItem.base_net_amount,
+			SalesInvoiceItem.name.as_("item_row"),
+			SalesInvoice.is_return,
+			SalesInvoiceItem.cost_center,
+			SalesInvoiceItem.serial_and_batch_bundle,
+		)
 
 		if self.filters.group_by == "Sales Person":
-			sales_person_cols = """, sales.sales_person,
-				sales.allocated_percentage * `tabSales Invoice Item`.base_net_amount / 100 as allocated_amount,
-				sales.incentives
-			"""
-			sales_team_table = "left join `tabSales Team` sales on sales.parent = `tabSales Invoice`.name"
-		else:
-			sales_person_cols = ""
-			sales_team_table = ""
+			query = query.select(
+				SalesTeam.sales_person,
+				(SalesTeam.allocated_percentage * SalesInvoiceItem.base_net_amount / 100).as_(
+					"allocated_amount"
+				),
+				SalesTeam.incentives,
+			)
+
+			query = query.left_join(SalesTeam).on(SalesTeam.parent == SalesInvoice.name)
 
 		if self.filters.group_by == "Payment Term":
-			payment_term_cols = """,if(`tabSales Invoice`.is_return = 1,
-										'{}',
-										coalesce(schedule.payment_term, '{}')) as payment_term,
-									schedule.invoice_portion,
-									schedule.payment_amount """.format(_("Sales Return"), _("No Terms"))
-			payment_term_table = """ left join `tabPayment Schedule` schedule on schedule.parent = `tabSales Invoice`.name and
-																				`tabSales Invoice`.is_return = 0 """
-		else:
-			payment_term_cols = ""
-			payment_term_table = ""
+			query = query.select(
+				Case()
+				.when(SalesInvoice.is_return == 1, _("Sales Return"))
+				.else_(Coalesce(PaymentSchedule.payment_term, _("No Terms")))
+				.as_("payment_term"),
+				PaymentSchedule.invoice_portion,
+				PaymentSchedule.payment_amount,
+			)
 
-		if self.filters.get("sales_invoice"):
-			conditions += " and `tabSales Invoice`.name = %(sales_invoice)s"
+			query = query.left_join(PaymentSchedule).on(
+				(PaymentSchedule.parent == SalesInvoice.name) & (SalesInvoice.is_return == 0)
+			)
 
-		if self.filters.get("item_code"):
-			conditions += " and `tabSales Invoice Item`.item_code = %(item_code)s"
+		query = query.orderby(SalesInvoice.posting_date, order=Order.desc).orderby(
+			SalesInvoice.posting_time, order=Order.desc
+		)
 
-		if self.filters.get("cost_center"):
+		return query
+
+	def apply_common_filters(self, query, SalesInvoice, SalesInvoiceItem, SalesTeam, Item):
+		if self.filters.company:
+			query = query.where(SalesInvoice.company == self.filters.company)
+
+		if self.filters.from_date:
+			query = query.where(SalesInvoice.posting_date >= self.filters.from_date)
+
+		if self.filters.to_date:
+			query = query.where(SalesInvoice.posting_date <= self.filters.to_date)
+
+		if self.filters.item_group:
+			query = query.where(get_item_group_condition(self.filters.item_group, Item))
+
+		if self.filters.sales_person:
+			query = query.where(
+				ExistsCriterion(
+					frappe.qb.from_(SalesTeam)
+					.select(1)
+					.where(
+						(SalesTeam.parent == SalesInvoice.name)
+						& (SalesTeam.sales_person == self.filters.sales_person)
+					)
+				)
+			)
+
+		if self.filters.sales_invoice:
+			query = query.where(SalesInvoice.name == self.filters.sales_invoice)
+
+		if self.filters.item_code:
+			query = query.where(SalesInvoiceItem.item_code == self.filters.item_code)
+
+		if self.filters.cost_center:
 			self.filters.cost_center = frappe.parse_json(self.filters.get("cost_center"))
 			self.filters.cost_center = get_cost_centers_with_children(self.filters.cost_center)
-			conditions += " and `tabSales Invoice Item`.cost_center in %(cost_center)s"
+			query = query.where(SalesInvoiceItem.cost_center.isin(self.filters.cost_center))
 
-		if self.filters.get("project"):
+		if self.filters.project:
 			self.filters.project = frappe.parse_json(self.filters.get("project"))
-			conditions += " and `tabSales Invoice Item`.project in %(project)s"
+			query = query.where(SalesInvoiceItem.project.isin(self.filters.project))
 
-		accounting_dimensions = get_accounting_dimensions(as_list=False)
-		if accounting_dimensions:
-			for dimension in accounting_dimensions:
-				if self.filters.get(dimension.fieldname):
-					if frappe.get_cached_value("DocType", dimension.document_type, "is_tree"):
-						self.filters[dimension.fieldname] = get_dimension_with_children(
-							dimension.document_type, self.filters.get(dimension.fieldname)
-						)
-						conditions += (
-							f" and `tabSales Invoice Item`.{dimension.fieldname} in %({dimension.fieldname})s"
-						)
-					else:
-						conditions += (
-							f" and `tabSales Invoice Item`.{dimension.fieldname} in %({dimension.fieldname})s"
-						)
+		for dim in get_accounting_dimensions(as_list=False) or []:
+			if self.filters.get(dim.fieldname):
+				if frappe.get_cached_value("DocType", dim.document_type, "is_tree"):
+					self.filters[dim.fieldname] = get_dimension_with_children(
+						dim.document_type, self.filters.get(dim.fieldname)
+					)
+				query = query.where(SalesInvoiceItem[dim.fieldname].isin(self.filters[dim.fieldname]))
 
-		if self.filters.get("warehouse"):
-			warehouse_details = frappe.db.get_value(
-				"Warehouse", self.filters.get("warehouse"), ["lft", "rgt"], as_dict=1
+		if self.filters.warehouse:
+			lft, rgt = frappe.db.get_value("Warehouse", self.filters.warehouse, ["lft", "rgt"])
+			WH = frappe.qb.DocType("Warehouse")
+			query = query.where(
+				SalesInvoiceItem.warehouse.isin(
+					frappe.qb.from_(WH).select(WH.name).where((WH.lft >= lft) & (WH.rgt <= rgt))
+				)
 			)
-			if warehouse_details:
-				conditions += f" and `tabSales Invoice Item`.warehouse in (select name from `tabWarehouse` wh where wh.lft >= {warehouse_details.lft} and wh.rgt <= {warehouse_details.rgt} and warehouse = wh.name)"
 
-		self.si_list = frappe.db.sql(
-			"""
-			select
-				`tabSales Invoice Item`.parenttype, `tabSales Invoice Item`.parent,
-				`tabSales Invoice`.posting_date, `tabSales Invoice`.posting_time,
-				`tabSales Invoice`.project, `tabSales Invoice`.update_stock,
-				`tabSales Invoice`.customer, `tabSales Invoice`.customer_group, `tabSales Invoice`.customer_name,
-				`tabSales Invoice`.territory, `tabSales Invoice Item`.item_code,
-				`tabSales Invoice`.base_net_total as "invoice_base_net_total",
-				`tabSales Invoice Item`.item_name, `tabSales Invoice Item`.description,
-				`tabSales Invoice Item`.warehouse, `tabSales Invoice Item`.item_group,
-				`tabSales Invoice Item`.brand, `tabSales Invoice Item`.so_detail,
-				`tabSales Invoice Item`.sales_order, `tabSales Invoice Item`.dn_detail,
-				`tabSales Invoice Item`.delivery_note, `tabSales Invoice Item`.stock_qty as qty,
-				`tabSales Invoice Item`.base_net_rate, `tabSales Invoice Item`.base_net_amount,
-				`tabSales Invoice Item`.name as "item_row", `tabSales Invoice`.is_return,
-				`tabSales Invoice Item`.cost_center, `tabSales Invoice Item`.serial_and_batch_bundle
-				{sales_person_cols}
-				{payment_term_cols}
-			from
-				`tabSales Invoice` inner join `tabSales Invoice Item`
-					on `tabSales Invoice Item`.parent = `tabSales Invoice`.name
-				join `tabItem` item on item.name = `tabSales Invoice Item`.item_code
-				{sales_team_table}
-				{payment_term_table}
-			where
-				`tabSales Invoice`.docstatus=1 and `tabSales Invoice`.is_opening!='Yes' {conditions} {match_cond}
-			order by
-				`tabSales Invoice`.posting_date desc, `tabSales Invoice`.posting_time desc""".format(
-				conditions=conditions,
-				sales_person_cols=sales_person_cols,
-				sales_team_table=sales_team_table,
-				payment_term_cols=payment_term_cols,
-				payment_term_table=payment_term_table,
-				match_cond=get_match_cond("Sales Invoice"),
-			),
-			self.filters,
-			as_dict=1,
-		)
+		return query
+
+	def prepare_vouchers_to_ignore(self):
+		self.vouchers_to_ignore = tuple(row["parent"] for row in self.si_list)
 
 	def get_delivery_notes(self):
 		self.delivery_notes = frappe._dict({})

erpnext/accounts/report/gross_profit/test_gross_profit.py

@@ -439,6 +439,7 @@ class TestGrossProfit(FrappeTestCase):
 			qty=-1, rate=100, posting_date=nowdate(), do_not_save=True, do_not_submit=True
 		)
 		sinv.is_return = 1
+		sinv.items[0].allow_zero_valuation_rate = 1
 		sinv = sinv.save().submit()
 
 		filters = frappe._dict(
@@ -465,7 +466,7 @@ class TestGrossProfit(FrappeTestCase):
 			"selling_amount": -100.0,
 			"buying_amount": 0.0,
 			"gross_profit": -100.0,
-			"gross_profit_%": 100.0,
+			"gross_profit_%": -100.0,
 		}
 		gp_entry = [x for x in data if x.parent_invoice == sinv.name]
 		self.assertDictContainsSubset(expected_entry, gp_entry[0])
@@ -642,21 +643,24 @@ class TestGrossProfit(FrappeTestCase):
 	def test_profit_for_later_period_return(self):
 		month_start_date, month_end_date = get_first_day(nowdate()), get_last_day(nowdate())
 
+		sales_inv_date = month_start_date
+		return_inv_date = add_days(month_end_date, 1)
+
 		# create sales invoice on month start date
 		sinv = self.create_sales_invoice(qty=1, rate=100, do_not_save=True, do_not_submit=True)
 		sinv.set_posting_time = 1
-		sinv.posting_date = month_start_date
+		sinv.posting_date = sales_inv_date
 		sinv.save().submit()
 
 		# create credit note on next month start date
 		cr_note = make_sales_return(sinv.name)
 		cr_note.set_posting_time = 1
-		cr_note.posting_date = add_days(month_end_date, 1)
+		cr_note.posting_date = return_inv_date
 		cr_note.save().submit()
 
 		# apply filters for invoiced period
 		filters = frappe._dict(
-			company=self.company, from_date=month_start_date, to_date=month_end_date, group_by="Invoice"
+			company=self.company, from_date=month_start_date, to_date=month_start_date, group_by="Invoice"
 		)
 
 		_, data = execute(filters=filters)
@@ -668,7 +672,7 @@ class TestGrossProfit(FrappeTestCase):
 		self.assertEqual(total.get("gross_profit_%"), 100.0)
 
 		# extend filters upto returned period
-		filters.update(to_date=add_days(month_end_date, 1))
+		filters.update({"to_date": return_inv_date})
 
 		_, data = execute(filters=filters)
 		total = data[-1]
@@ -677,3 +681,63 @@ class TestGrossProfit(FrappeTestCase):
 		self.assertEqual(total.buying_amount, 0.0)
 		self.assertEqual(total.gross_profit, 0.0)
 		self.assertEqual(total.get("gross_profit_%"), 0.0)
+
+		# apply filters only on returned period
+		filters.update({"from_date": return_inv_date, "to_date": return_inv_date})
+		_, data = execute(filters=filters)
+		total = data[-1]
+
+		self.assertEqual(total.selling_amount, -100.0)
+		self.assertEqual(total.buying_amount, 0.0)
+		self.assertEqual(total.gross_profit, -100.0)
+		self.assertEqual(total.get("gross_profit_%"), -100.0)
+
+	def test_sales_person_wise_gross_profit(self):
+		sales_person = make_sales_person("_Test Sales Person")
+
+		posting_date = get_first_day(nowdate())
+		qty = 10
+		rate = 100
+
+		sinv = self.create_sales_invoice(qty=qty, rate=rate, do_not_save=True, do_not_submit=True)
+		sinv.set_posting_time = 1
+		sinv.posting_date = posting_date
+		sinv.append(
+			"sales_team",
+			{
+				"sales_person": sales_person.name,
+				"allocated_percentage": 100,
+				"allocated_amount": 1000.0,
+				"commission_rate": 5,
+				"incentives": 5,
+			},
+		)
+		sinv.save().submit()
+
+		filters = frappe._dict(
+			company=self.company, from_date=posting_date, to_date=posting_date, group_by="Sales Person"
+		)
+
+		_, data = execute(filters=filters)
+		total = data[-1]
+
+		self.assertEqual(total[5], 1000.0)
+		self.assertEqual(total[6], 0.0)
+		self.assertEqual(total[7], 1000.0)
+		self.assertEqual(total[8], 100.0)
+
+
+def make_sales_person(sales_person_name="_Test Sales Person"):
+	if not frappe.db.exists("Sales Person", {"sales_person_name": sales_person_name}):
+		sales_person_doc = frappe.get_doc(
+			{
+				"doctype": "Sales Person",
+				"is_group": 0,
+				"parent_sales_person": "Sales Team",
+				"sales_person_name": sales_person_name,
+			}
+		).insert(ignore_permissions=True)
+	else:
+		sales_person_doc = frappe.get_doc("Sales Person", {"sales_person_name": sales_person_name})
+
+	return sales_person_doc

erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py

@@ -105,7 +105,7 @@ def _execute(filters=None, additional_table_columns=None, additional_conditions=
 			{
 				"total_tax": total_tax,
 				"total_other_charges": total_other_charges,
-				"total": d.base_net_amount + total_tax,
+				"total": d.base_net_amount + total_tax + total_other_charges,
 				"currency": company_currency,
 			}
 		)

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.js

@@ -22,7 +22,7 @@ frappe.query_reports["Profit and Loss Statement"]["filters"].push(
 		fieldname: "accumulated_values",
 		label: __("Accumulated Values"),
 		fieldtype: "Check",
-		default: 1,
+		default: 0,
 	},
 	{
 		fieldname: "include_default_book_entries",

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py

@@ -62,7 +62,7 @@ def execute(filters=None):
 	currency = filters.presentation_currency or frappe.get_cached_value(
 		"Company", filters.company, "default_currency"
 	)
-	chart = get_chart_data(filters, columns, income, expense, net_profit_loss, currency)
+	chart = get_chart_data(filters, period_list, income, expense, net_profit_loss, currency)
 
 	report_summary, primitive_summary = get_report_summary(
 		period_list, filters.periodicity, income, expense, net_profit_loss, currency, filters
@@ -158,18 +158,20 @@ def get_net_profit_loss(income, expense, period_list, company, currency=None, co
 		return net_profit_loss
 
 
-def get_chart_data(filters, columns, income, expense, net_profit_loss, currency):
-	labels = [d.get("label") for d in columns[2:]]
+def get_chart_data(filters, chart_columns, income, expense, net_profit_loss, currency):
+	labels = [col.get("label") for col in chart_columns]
 
 	income_data, expense_data, net_profit = [], [], []
 
-	for p in columns[2:]:
+	for col in chart_columns:
+		key = col.get("key") or col.get("fieldname")
+
 		if income:
-			income_data.append(income[-2].get(p.get("fieldname")))
+			income_data.append(income[-2].get(key))
 		if expense:
-			expense_data.append(expense[-2].get(p.get("fieldname")))
+			expense_data.append(expense[-2].get(key))
 		if net_profit_loss:
-			net_profit.append(net_profit_loss.get(p.get("fieldname")))
+			net_profit.append(net_profit_loss.get(key))
 
 	datasets = []
 	if income_data:

erpnext/accounts/report/profitability_analysis/profitability_analysis.py

@@ -3,7 +3,8 @@
 
 
 import frappe
-from frappe import _
+from frappe import _, qb
+from frappe.query_builder import Criterion
 from frappe.utils import cstr, flt
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import get_dimensions
@@ -33,11 +34,19 @@ def execute(filters=None):
 
 def get_accounts_data(based_on, company):
 	if based_on == "Cost Center":
-		return frappe.db.sql(
-			"""select name, parent_cost_center as parent_account, cost_center_name as account_name, lft, rgt
-			from `tabCost Center` where company=%s order by name""",
-			company,
-			as_dict=True,
+		cc = qb.DocType("Cost Center")
+		return (
+			qb.from_(cc)
+			.select(
+				cc.name,
+				cc.parent_cost_center.as_("parent_account"),
+				cc.cost_center_name.as_("account_name"),
+				cc.lft,
+				cc.rgt,
+			)
+			.where(cc.company.eq(company))
+			.orderby(cc.name)
+			.run(as_dict=True)
 		)
 	elif based_on == "Project":
 		return frappe.get_all("Project", fields=["name"], filters={"company": company}, order_by="name")
@@ -206,27 +215,38 @@ def set_gl_entries_by_account(
 	company, from_date, to_date, based_on, gl_entries_by_account, ignore_closing_entries=False
 ):
 	"""Returns a dict like { "account": [gl entries], ... }"""
-	additional_conditions = []
+	gl = qb.DocType("GL Entry")
+	acc = qb.DocType("Account")
+
+	conditions = []
+	conditions.append(gl.company.eq(company))
+	conditions.append(gl[based_on].notnull())
+	conditions.append(gl.is_cancelled.eq(0))
+
+	if from_date and to_date:
+		conditions.append(gl.posting_date.between(from_date, to_date))
+	elif from_date and not to_date:
+		conditions.append(gl.posting_date.gte(from_date))
+	elif not from_date and to_date:
+		conditions.append(gl.posting_date.lte(to_date))
 
 	if ignore_closing_entries:
-		additional_conditions.append("and voucher_type !='Period Closing Voucher'")
+		conditions.append(gl.voucher_type.ne("Period Closing Voucher"))
 
-	if from_date:
-		additional_conditions.append("and posting_date >= %(from_date)s")
-
-	gl_entries = frappe.db.sql(
-		"""select posting_date, {based_on} as based_on, debit, credit,
-		is_opening, (select root_type from `tabAccount` where name = account) as type
-		from `tabGL Entry` where company=%(company)s
-		{additional_conditions}
-		and posting_date <= %(to_date)s
-		and {based_on} is not null
-		and is_cancelled = 0
-		order by {based_on}, posting_date""".format(
-			additional_conditions="\n".join(additional_conditions), based_on=based_on
-		),
-		{"company": company, "from_date": from_date, "to_date": to_date},
-		as_dict=True,
+	root_subquery = qb.from_(acc).select(acc.root_type).where(acc.name.eq(gl.account))
+	gl_entries = (
+		qb.from_(gl)
+		.select(
+			gl.posting_date,
+			gl[based_on].as_("based_on"),
+			gl.debit,
+			gl.credit,
+			gl.is_opening,
+			root_subquery.as_("type"),
+		)
+		.where(Criterion.all(conditions))
+		.orderby(gl[based_on], gl.posting_date)
+		.run(as_dict=True)
 	)
 
 	for entry in gl_entries:

erpnext/accounts/report/purchase_invoice_trends/purchase_invoice_trends.json

@@ -7,10 +7,10 @@
  "docstatus": 0,
  "doctype": "Report",
  "filters": [],
- "idx": 3,
+ "idx": 4,
  "is_standard": "Yes",
- "letterhead": null,
- "modified": "2025-11-05 11:55:49.950442",
+ "letter_head": null,
+ "modified": "2026-03-13 17:35:39.703838",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice Trends",

erpnext/accounts/report/sales_invoice_trends/sales_invoice_trends.json

@@ -9,8 +9,8 @@
  "filters": [],
  "idx": 3,
  "is_standard": "Yes",
- "letterhead": null,
- "modified": "2025-11-05 11:55:50.070651",
+ "letter_head": null,
+ "modified": "2026-03-13 17:36:13.725601",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Trends",

erpnext/accounts/report/tax_withholding_details/tax_withholding_details.py

@@ -5,6 +5,7 @@
 import frappe
 from frappe import _
 from frappe.utils import flt, getdate
+from pypika import Tuple
 
 from erpnext.accounts.utils import get_currency_precision
 
@@ -19,18 +20,14 @@ def execute(filters=None):
 
 	validate_filters(filters)
 	(
-		tds_docs,
 		tds_accounts,
 		tax_category_map,
-		journal_entry_party_map,
 		net_total_map,
 	) = get_tds_docs(filters)
 
 	columns = get_columns(filters)
 
-	res = get_result(
-		filters, tds_docs, tds_accounts, tax_category_map, journal_entry_party_map, net_total_map
-	)
+	res = get_result(filters, tds_accounts, tax_category_map, net_total_map)
 	return columns, res
 
 
@@ -41,27 +38,23 @@ def validate_filters(filters):
 		frappe.throw(_("From Date must be before To Date"))
 
 
-def get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_party_map, net_total_map):
-	party_map = get_party_pan_map(filters.get("party_type"))
+def get_result(filters, tds_accounts, tax_category_map, net_total_map):
+	party_names = {v.party for v in net_total_map.values() if v.party}
+	party_map = get_party_pan_map(filters.get("party_type"), party_names)
 	tax_rate_map = get_tax_rate_map(filters)
-	gle_map = get_gle_map(tds_docs)
+	gle_map = get_gle_map(net_total_map)
 	precision = get_currency_precision()
 
-	out = []
 	entries = {}
-	for name, details in gle_map.items():
+	for (voucher_type, name), details in gle_map.items():
 		for entry in details:
-			tax_amount, total_amount, grand_total, base_total = 0, 0, 0, 0
+			tax_amount, total_amount, grand_total, base_total, base_tax_withholding_net_total = 0, 0, 0, 0, 0
 			tax_withholding_category, rate = None, None
 			bill_no, bill_date = "", ""
-			party = entry.party or entry.against
 			posting_date = entry.posting_date
-			voucher_type = entry.voucher_type
 
-			if voucher_type == "Journal Entry":
-				party_list = journal_entry_party_map.get(name)
-				if party_list:
-					party = party_list[0]
+			values = net_total_map.get((voucher_type, name))
+			party = values.party if values else (entry.party or entry.against)
 
 			if entry.account in tds_accounts.keys():
 				tax_amount += entry.credit - entry.debit
@@ -76,29 +69,35 @@ def get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_
 
 				rate = get_tax_withholding_rates(tax_rate_map.get(tax_withholding_category, []), posting_date)
 
-			values = net_total_map.get((voucher_type, name))
-
 			if values:
 				if voucher_type == "Journal Entry" and tax_amount and rate:
 					# back calculate total amount from rate and tax_amount
-					base_total = min(flt(tax_amount / (rate / 100), precision=precision), values[0])
+					base_total = min(
+						flt(tax_amount / (rate / 100), precision=precision),
+						values.base_tax_withholding_net_total,
+					)
 					total_amount = grand_total = base_total
+					base_tax_withholding_net_total = total_amount
 
 				else:
 					if tax_amount and rate:
 						# back calculate total amount from rate and tax_amount
 						total_amount = flt((tax_amount * 100) / rate, precision=precision)
 					else:
-						total_amount = values[0]
+						total_amount = values.base_tax_withholding_net_total
 
-					grand_total = values[1]
-					base_total = values[2]
+					grand_total = values.grand_total
+					base_total = values.base_total
+					base_tax_withholding_net_total = total_amount
 
 					if voucher_type == "Purchase Invoice":
-						bill_no = values[3]
-						bill_date = values[4]
+						base_tax_withholding_net_total = values.base_tax_withholding_net_total
+						bill_no = values.bill_no
+						bill_date = values.bill_date
+
 			else:
 				total_amount += entry.credit
+				base_tax_withholding_net_total = total_amount
 
 			if tax_amount:
 				if party_map.get(party, {}).get("party_type") == "Supplier":
@@ -125,6 +124,7 @@ def get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_
 						"rate": rate,
 						"total_amount": total_amount,
 						"grand_total": grand_total,
+						"base_tax_withholding_net_total": base_tax_withholding_net_total,
 						"base_total": base_total,
 						"tax_amount": tax_amount,
 						"transaction_date": posting_date,
@@ -141,14 +141,17 @@ def get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_
 				else:
 					entries[key] = row
 	out = list(entries.values())
-	out.sort(key=lambda x: (x["section_code"], x["transaction_date"]))
+	out.sort(key=lambda x: (x["section_code"], x["transaction_date"], x["ref_no"]))
 
 	return out
 
 
-def get_party_pan_map(party_type):
+def get_party_pan_map(party_type, party_names):
 	party_map = frappe._dict()
 
+	if not party_names:
+		return party_map
+
 	fields = ["name", "tax_withholding_category"]
 	if party_type == "Supplier":
 		fields += ["supplier_type", "supplier_name"]
@@ -158,7 +161,7 @@ def get_party_pan_map(party_type):
 	if frappe.db.has_column(party_type, "pan"):
 		fields.append("pan")
 
-	party_details = frappe.db.get_all(party_type, fields=fields)
+	party_details = frappe.db.get_all(party_type, filters={"name": ("in", list(party_names))}, fields=fields)
 
 	for party in party_details:
 		party.party_type = party_type
@@ -167,22 +170,33 @@ def get_party_pan_map(party_type):
 	return party_map
 
 
-def get_gle_map(documents):
-	# create gle_map of the form
-	# {"purchase_invoice": list of dict of all gle created for this invoice}
+def get_gle_map(net_total_map):
+	if not net_total_map:
+		return {}
+
+	gle = frappe.qb.DocType("GL Entry")
+	voucher_pairs = list(net_total_map.keys())
+
+	rows = (
+		frappe.qb.from_(gle)
+		.select(
+			gle.credit,
+			gle.debit,
+			gle.account,
+			gle.voucher_no,
+			gle.posting_date,
+			gle.voucher_type,
+			gle.against,
+			gle.party,
+			gle.party_type,
+		)
+		.where(gle.is_cancelled == 0)
+		.where(Tuple(gle.voucher_type, gle.voucher_no).isin(voucher_pairs))
+	).run(as_dict=True)
+
 	gle_map = {}
-
-	gle = frappe.db.get_all(
-		"GL Entry",
-		{"voucher_no": ["in", documents], "is_cancelled": 0},
-		["credit", "debit", "account", "voucher_no", "posting_date", "voucher_type", "against", "party"],
-	)
-
-	for d in gle:
-		if d.voucher_no not in gle_map:
-			gle_map[d.voucher_no] = [d]
-		else:
-			gle_map[d.voucher_no].append(d)
+	for d in rows:
+		gle_map.setdefault((d.voucher_type, d.voucher_no), []).append(d)
 
 	return gle_map
 
@@ -252,14 +266,14 @@ def get_columns(filters):
 				"width": 60,
 			},
 			{
-				"label": _("Total Amount"),
-				"fieldname": "total_amount",
+				"label": _("Tax Withholding Net Total"),
+				"fieldname": "base_tax_withholding_net_total",
 				"fieldtype": "Float",
-				"width": 120,
+				"width": 150,
 			},
 			{
-				"label": _("Base Total"),
-				"fieldname": "base_total",
+				"label": _("Taxable Amount"),
+				"fieldname": "total_amount",
 				"fieldtype": "Float",
 				"width": 120,
 			},
@@ -270,10 +284,16 @@ def get_columns(filters):
 				"width": 120,
 			},
 			{
-				"label": _("Grand Total"),
+				"label": _("Grand Total (Company Currency)"),
+				"fieldname": "base_total",
+				"fieldtype": "Float",
+				"width": 150,
+			},
+			{
+				"label": _("Grand Total (Transaction Currency)"),
 				"fieldname": "grand_total",
 				"fieldtype": "Float",
-				"width": 120,
+				"width": 170,
 			},
 			{"label": _("Transaction Type"), "fieldname": "transaction_type", "width": 130},
 			{
@@ -296,14 +316,9 @@ def get_columns(filters):
 
 
 def get_tds_docs(filters):
-	tds_documents = []
-	purchase_invoices = []
-	sales_invoices = []
-	payment_entries = []
-	journal_entries = []
+	vouchers = frappe._dict()
 	tax_category_map = frappe._dict()
 	net_total_map = frappe._dict()
-	journal_entry_party_map = frappe._dict()
 	bank_accounts = frappe.get_all("Account", {"is_group": 0, "account_type": "Bank"}, pluck="name")
 
 	_tds_accounts = frappe.get_all(
@@ -322,35 +337,14 @@ def get_tds_docs(filters):
 	tds_docs = get_tds_docs_query(filters, bank_accounts, list(tds_accounts.keys())).run(as_dict=True)
 
 	for d in tds_docs:
-		if d.voucher_type == "Purchase Invoice":
-			purchase_invoices.append(d.voucher_no)
-		if d.voucher_type == "Sales Invoice":
-			sales_invoices.append(d.voucher_no)
-		elif d.voucher_type == "Payment Entry":
-			payment_entries.append(d.voucher_no)
-		elif d.voucher_type == "Journal Entry":
-			journal_entries.append(d.voucher_no)
+		vouchers.setdefault(d.voucher_type, set()).add(d.voucher_no)
 
-		tds_documents.append(d.voucher_no)
-
-	if purchase_invoices:
-		get_doc_info(purchase_invoices, "Purchase Invoice", tax_category_map, net_total_map)
-
-	if sales_invoices:
-		get_doc_info(sales_invoices, "Sales Invoice", tax_category_map, net_total_map)
-
-	if payment_entries:
-		get_doc_info(payment_entries, "Payment Entry", tax_category_map, net_total_map)
-
-	if journal_entries:
-		journal_entry_party_map = get_journal_entry_party_map(journal_entries)
-		get_doc_info(journal_entries, "Journal Entry", tax_category_map, net_total_map)
+	for voucher_type, docs in vouchers.items():
+		get_doc_info(docs, voucher_type, tax_category_map, net_total_map, filters)
 
 	return (
-		tds_documents,
 		tds_accounts,
 		tax_category_map,
-		journal_entry_party_map,
 		net_total_map,
 	)
 
@@ -361,11 +355,16 @@ def get_tds_docs_query(filters, bank_accounts, tds_accounts):
 			_("No {0} Accounts found for this company.").format(frappe.bold(_("Tax Withholding"))),
 			title=_("Accounts Missing Error"),
 		)
+
+	invoice_voucher = "Purchase Invoice" if filters.get("party_type") == "Supplier" else "Sales Invoice"
+	voucher_types = {"Payment Entry", "Journal Entry", invoice_voucher}
+
 	gle = frappe.qb.DocType("GL Entry")
 	query = (
 		frappe.qb.from_(gle)
 		.select("voucher_no", "voucher_type", "against", "party")
 		.where(gle.is_cancelled == 0)
+		.where(gle.voucher_type.isin(voucher_types))
 	)
 
 	if filters.get("from_date"):
@@ -391,25 +390,27 @@ def get_tds_docs_query(filters, bank_accounts, tds_accounts):
 	return query
 
 
-def get_journal_entry_party_map(journal_entries):
+def get_journal_entry_party_map(journal_entries, party_type):
 	journal_entry_party_map = {}
 	for d in frappe.db.get_all(
 		"Journal Entry Account",
 		{
 			"parent": ("in", journal_entries),
-			"party_type": ("in", ("Supplier", "Customer")),
+			"party_type": party_type,
 			"party": ("is", "set"),
 		},
 		["parent", "party"],
 	):
-		if d.parent not in journal_entry_party_map:
-			journal_entry_party_map[d.parent] = []
-		journal_entry_party_map[d.parent].append(d.party)
+		journal_entry_party_map.setdefault(d.parent, []).append(d.party)
 
 	return journal_entry_party_map
 
 
-def get_doc_info(vouchers, doctype, tax_category_map, net_total_map=None):
+def get_doc_info(vouchers, doctype, tax_category_map, net_total_map=None, filters=None):
+	journal_entry_party_map = {}
+	party_type = filters.get("party_type") if filters else None
+	party = filters.get("party") if filters else None
+
 	common_fields = ["name"]
 	fields_dict = {
 		"Purchase Invoice": [
@@ -419,37 +420,81 @@ def get_doc_info(vouchers, doctype, tax_category_map, net_total_map=None):
 			"base_total",
 			"bill_no",
 			"bill_date",
+			"supplier",
 		],
-		"Sales Invoice": ["base_net_total", "grand_total", "base_total"],
+		"Sales Invoice": ["base_net_total", "grand_total", "base_total", "customer"],
 		"Payment Entry": [
 			"tax_withholding_category",
 			"paid_amount",
 			"paid_amount_after_tax",
 			"base_paid_amount",
+			"party",
+			"party_type",
 		],
 		"Journal Entry": ["tax_withholding_category", "total_debit"],
 	}
+	party_field = {
+		"Purchase Invoice": "supplier",
+		"Sales Invoice": "customer",
+		"Payment Entry": "party",
+	}
 
-	entries = frappe.get_all(
-		doctype, filters={"name": ("in", vouchers)}, fields=common_fields + fields_dict[doctype]
-	)
+	doc_filters = {"name": ("in", vouchers)}
+
+	if party and party_field.get(doctype):
+		doc_filters[party_field[doctype]] = party
+
+	if doctype == "Payment Entry":
+		doc_filters["party_type"] = party_type
+
+	entries = frappe.get_all(doctype, filters=doc_filters, fields=common_fields + fields_dict[doctype])
+
+	if doctype == "Journal Entry":
+		journal_entry_party_map = get_journal_entry_party_map(vouchers, party_type=party_type)
 
 	for entry in entries:
 		tax_category_map[(doctype, entry.name)] = entry.tax_withholding_category
+
+		value = frappe._dict(
+			party=None,
+			party_type=party_type,
+			base_tax_withholding_net_total=0,
+			grand_total=0,
+			base_total=0,
+			bill_no="",
+			bill_date="",
+		)
+
 		if doctype == "Purchase Invoice":
-			value = [
-				entry.base_tax_withholding_net_total,
-				entry.grand_total,
-				entry.base_total,
-				entry.bill_no,
-				entry.bill_date,
-			]
+			value.party = entry.supplier
+			value.party_type = "Supplier"
+			value.base_tax_withholding_net_total = entry.base_tax_withholding_net_total
+			value.grand_total = entry.grand_total
+			value.base_total = entry.base_total
+			value.bill_no = entry.bill_no
+			value.bill_date = entry.bill_date
 		elif doctype == "Sales Invoice":
-			value = [entry.base_net_total, entry.grand_total, entry.base_total]
+			value.party = entry.customer
+			value.party_type = "Customer"
+			value.base_tax_withholding_net_total = entry.base_net_total
+			value.grand_total = entry.grand_total
+			value.base_total = entry.base_total
 		elif doctype == "Payment Entry":
-			value = [entry.paid_amount, entry.paid_amount_after_tax, entry.base_paid_amount]
+			value.party = entry.party
+			value.party_type = entry.party_type
+			value.base_tax_withholding_net_total = entry.paid_amount
+			value.grand_total = entry.paid_amount_after_tax
+			value.base_total = entry.base_paid_amount
 		else:
-			value = [entry.total_debit] * 3
+			party_list = journal_entry_party_map.get(entry.name, [])
+			if party and party in party_list:
+				value.party = party
+			elif party_list:
+				value.party = sorted(party_list)[0]
+			value.party_type = party_type
+			value.base_tax_withholding_net_total = entry.total_debit
+			value.grand_total = entry.total_debit
+			value.base_total = entry.total_debit
 
 		net_total_map[(doctype, entry.name)] = value
 

erpnext/accounts/report/tax_withholding_details/test_tax_withholding_details.py

@@ -35,9 +35,9 @@ class TestTaxWithholdingDetails(AccountsTestMixin, FrappeTestCase):
 		result = execute(filters)[1]
 		expected_values = [
 			# Check for JV totals using back calculation logic
-			[jv.name, "TCS", 0.075, -10000.0, -7.5, -10000.0],
-			[pe.name, "TCS", 0.075, 2550, 0.53, 2550.53],
-			[si.name, "TCS", 0.075, 1000, 0.52, 1000.52],
+			[jv.name, "TCS", 0.075, -10000.0, -10000.0, -7.5, -10000.0],
+			[pe.name, "TCS", 0.075, 706.67, 2550.0, 0.53, 2550.53],
+			[si.name, "TCS", 0.075, 693.33, 1000.0, 0.52, 1000.52],
 		]
 		self.check_expected_values(result, expected_values)
 
@@ -55,8 +55,8 @@ class TestTaxWithholdingDetails(AccountsTestMixin, FrappeTestCase):
 			frappe._dict(company="_Test Company", party_type="Supplier", from_date=today(), to_date=today())
 		)[1]
 		expected_values = [
-			[inv_1.name, "TDS - 1", 10, 5000, 500, 5500],
-			[inv_2.name, "TDS - 2", 20, 5000, 1000, 6000],
+			[inv_1.name, "TDS - 1", 10, 5000, 5000, 500, 5500],
+			[inv_2.name, "TDS - 2", 20, 5000, 5000, 1000, 6000],
 		]
 		self.check_expected_values(result, expected_values)
 
@@ -107,8 +107,8 @@ class TestTaxWithholdingDetails(AccountsTestMixin, FrappeTestCase):
 		)[1]
 
 		expected_values = [
-			[inv_1.name, "TDS - 3", 10.0, 5000, 500, 4500],
-			[inv_2.name, "TDS - 3", 20.0, 5000, 1000, 4000],
+			[inv_1.name, "TDS - 3", 10.0, 5000, 5000, 500, 4500],
+			[inv_2.name, "TDS - 3", 20.0, 5000, 5000, 1000, 4000],
 		]
 		self.check_expected_values(result, expected_values)
 
@@ -120,6 +120,7 @@ class TestTaxWithholdingDetails(AccountsTestMixin, FrappeTestCase):
 				voucher.ref_no,
 				voucher.section_code,
 				voucher.rate,
+				voucher.base_tax_withholding_net_total,
 				voucher.base_total,
 				voucher.tax_amount,
 				voucher.grand_total,

erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py

@@ -20,16 +20,12 @@ def execute(filters=None):
 
 	columns = get_columns(filters)
 	(
-		tds_docs,
 		tds_accounts,
 		tax_category_map,
-		journal_entry_party_map,
-		invoice_total_map,
+		net_total_map,
 	) = get_tds_docs(filters)
 
-	res = get_result(
-		filters, tds_docs, tds_accounts, tax_category_map, journal_entry_party_map, invoice_total_map
-	)
+	res = get_result(filters, tds_accounts, tax_category_map, net_total_map)
 	final_result = group_by_party_and_category(res, filters)
 
 	return columns, final_result
@@ -128,7 +124,7 @@ def get_columns(filters):
 				"width": 120,
 			},
 			{
-				"label": _("Total Amount"),
+				"label": _("Total Taxable Amount"),
 				"fieldname": "total_amount",
 				"fieldtype": "Float",
 				"width": 120,

erpnext/accounts/report/trial_balance/trial_balance.js

@@ -112,6 +112,12 @@ frappe.query_reports["Trial Balance"] = {
 			fieldtype: "Check",
 			default: 1,
 		},
+		{
+			fieldname: "show_group_accounts",
+			label: __("Show Group Accounts"),
+			fieldtype: "Check",
+			default: 1,
+		},
 	],
 	formatter: erpnext.financial_statements.formatter,
 	tree: true,

erpnext/accounts/report/trial_balance/trial_balance.py

@@ -83,7 +83,7 @@ def validate_filters(filters):
 
 def get_data(filters):
 	accounts = frappe.db.sql(
-		"""select name, account_number, parent_account, account_name, root_type, report_type, lft, rgt
+		"""select name, account_number, parent_account, account_name, root_type, report_type, is_group, lft, rgt
 
 		from `tabAccount` where company=%s order by lft""",
 		filters.company,
@@ -345,7 +345,7 @@ def calculate_values(accounts, gl_entries_by_account, opening_balances, show_net
 			prepare_opening_closing(d)
 
 
-def calculate_total_row(accounts, company_currency):
+def calculate_total_row(data, company_currency, show_group_accounts=True):
 	total_row = {
 		"account": "'" + _("Total") + "'",
 		"account_name": "'" + _("Total") + "'",
@@ -362,10 +362,16 @@ def calculate_total_row(accounts, company_currency):
 		"currency": company_currency,
 	}
 
-	for d in accounts:
-		if not d.parent_account:
-			for field in value_fields:
-				total_row[field] += d[field]
+	def sum_value_fields(row):
+		for field in value_fields:
+			total_row[field] += row[field]
+
+	for d in data:
+		if not show_group_accounts:
+			sum_value_fields(d)
+
+		elif show_group_accounts and not d.get("parent_account"):
+			sum_value_fields(d)
 
 	return total_row
 
@@ -393,6 +399,7 @@ def prepare_data(accounts, filters, parent_children_map, company_currency):
 			"from_date": filters.from_date,
 			"to_date": filters.to_date,
 			"currency": company_currency,
+			"is_group_account": d.is_group,
 			"account_name": (
 				f"{d.account_number} - {d.account_name}" if d.account_number else d.account_name
 			),
@@ -408,7 +415,13 @@ def prepare_data(accounts, filters, parent_children_map, company_currency):
 		row["has_value"] = has_value
 		data.append(row)
 
-	total_row = calculate_total_row(accounts, company_currency)
+	if not filters.get("show_group_accounts"):
+		data = hide_group_accounts(data)
+
+	total_row = calculate_total_row(
+		data, company_currency, show_group_accounts=filters.get("show_group_accounts")
+	)
+
 	data.extend([{}, total_row])
 
 	return data
@@ -488,3 +501,12 @@ def prepare_opening_closing(row):
 			row[valid_col] = 0.0
 		else:
 			row[reverse_col] = 0.0
+
+
+def hide_group_accounts(data):
+	non_group_accounts_data = []
+	for d in data:
+		if not d.get("is_group_account"):
+			d.update(indent=0)
+			non_group_accounts_data.append(d)
+	return non_group_accounts_data

erpnext/accounts/report/trial_balance_for_party/trial_balance_for_party.js

@@ -81,5 +81,11 @@ frappe.query_reports["Trial Balance for Party"] = {
 			label: __("Show zero values"),
 			fieldtype: "Check",
 		},
+		{
+			fieldname: "exclude_zero_balance_parties",
+			label: __("Exclude Zero Balance Parties"),
+			fieldtype: "Check",
+			default: 1,
+		},
 	],
 };

erpnext/accounts/report/trial_balance_for_party/trial_balance_for_party.py

@@ -75,20 +75,20 @@ def get_data(filters, show_party_name):
 		closing_debit, closing_credit = toggle_debit_credit(opening_debit + debit, opening_credit + credit)
 		row.update({"closing_debit": closing_debit, "closing_credit": closing_credit})
 
-		# totals
-		for col in total_row:
-			total_row[col] += row.get(col)
-
 		row.update({"currency": company_currency})
 
 		has_value = False
 		if opening_debit or opening_credit or debit or credit or closing_debit or closing_credit:
 			has_value = True
+		# Exclude zero balance parties if filter is set
+		if filters.get("exclude_zero_balance_parties") and not closing_debit and not closing_credit:
+			continue
 
 		if cint(filters.show_zero_values) or has_value:
 			data.append(row)
-
-	# Add total row
+			# totals
+			for col in total_row:
+				total_row[col] += row.get(col)
 
 	total_row.update({"party": "'" + _("Totals") + "'", "currency": company_currency})
 	data.append(total_row)

erpnext/accounts/utils.py

@@ -454,7 +454,8 @@ def _build_dimensions_dict_for_exc_gain_loss(
 	dimensions_dict = frappe._dict()
 	if entry and active_dimensions:
 		for dim in active_dimensions:
-			dimensions_dict[dim.fieldname] = entry.get(dim.fieldname)
+			if entry_dimension := entry.get(dim.fieldname):
+				dimensions_dict[dim.fieldname] = entry_dimension
 	return dimensions_dict
 
 
@@ -511,6 +512,7 @@ def reconcile_against_document(
 				doc.make_advance_gl_entries(entry=row)
 		else:
 			_delete_pl_entries(voucher_type, voucher_no)
+			_delete_adv_pl_entries(voucher_type, voucher_no)
 			gl_map = doc.build_gl_map()
 			# Make sure there is no overallocation
 			from erpnext.accounts.general_ledger import process_debit_credit_difference
@@ -1867,6 +1869,7 @@ def get_payment_ledger_entries(gl_entries, cancel=0):
 					account=gle.account,
 					party_type=gle.party_type,
 					party=gle.party,
+					project=gle.project,
 					cost_center=gle.cost_center,
 					finance_book=gle.finance_book,
 					due_date=gle.due_date,

erpnext/assets/doctype/asset/asset.js

@@ -36,6 +36,7 @@ frappe.ui.form.on("Asset", {
 	},
 
 	company: function (frm) {
+		frm.trigger("set_dynamic_labels");
 		erpnext.accounts.dimensions.update_dimension(frm, frm.doctype);
 	},
 
@@ -87,6 +88,7 @@ frappe.ui.form.on("Asset", {
 	},
 
 	refresh: function (frm) {
+		frm.trigger("set_dynamic_labels");
 		frappe.ui.form.trigger("Asset", "is_existing_asset");
 		frm.toggle_display("next_depreciation_date", frm.doc.docstatus < 1);
 
@@ -221,6 +223,10 @@ frappe.ui.form.on("Asset", {
 		}
 	},
 
+	set_dynamic_labels: function (frm) {
+		frm.set_currency_labels(["gross_purchase_amount"], erpnext.get_currency(frm.doc.company));
+	},
+
 	set_depr_posting_failure_alert: function (frm) {
 		const alert = `
 			<div class="row">
@@ -235,26 +241,64 @@ frappe.ui.form.on("Asset", {
 	},
 
 	toggle_reference_doc: function (frm) {
-		if (frm.doc.purchase_receipt && frm.doc.purchase_invoice && frm.doc.docstatus === 1) {
-			frm.set_df_property("purchase_invoice", "read_only", 1);
-			frm.set_df_property("purchase_receipt", "read_only", 1);
-		} else if (frm.doc.is_existing_asset || frm.doc.is_composite_asset) {
-			frm.toggle_reqd("purchase_receipt", 0);
-			frm.toggle_reqd("purchase_invoice", 0);
-		} else if (frm.doc.purchase_receipt) {
-			// if purchase receipt link is set then set PI disabled
-			frm.toggle_reqd("purchase_invoice", 0);
-			frm.set_df_property("purchase_invoice", "read_only", 1);
-		} else if (frm.doc.purchase_invoice) {
-			// if purchase invoice link is set then set PR disabled
-			frm.toggle_reqd("purchase_receipt", 0);
-			frm.set_df_property("purchase_receipt", "read_only", 1);
-		} else {
-			frm.toggle_reqd("purchase_receipt", 1);
-			frm.set_df_property("purchase_receipt", "read_only", 0);
-			frm.toggle_reqd("purchase_invoice", 1);
-			frm.set_df_property("purchase_invoice", "read_only", 0);
+		const is_submitted = frm.doc.docstatus === 1;
+		const is_special_asset = frm.doc.is_existing_asset || frm.doc.is_composite_asset;
+
+		const clear_field = (field) => {
+			if (frm.doc[field]) {
+				frm.set_value(field, "");
+			}
+		};
+
+		["purchase_receipt", "purchase_receipt_item", "purchase_invoice", "purchase_invoice_item"].forEach(
+			(field) => {
+				frm.toggle_reqd(field, 0);
+				frm.set_df_property(field, "read_only", 0);
+			}
+		);
+
+		if (is_submitted) {
+			[
+				"purchase_receipt",
+				"purchase_receipt_item",
+				"purchase_invoice",
+				"purchase_invoice_item",
+			].forEach((field) => {
+				frm.set_df_property(field, "read_only", 1);
+			});
+			return;
 		}
+
+		if (is_special_asset) {
+			clear_field("purchase_receipt");
+			clear_field("purchase_receipt_item");
+			clear_field("purchase_invoice");
+			clear_field("purchase_invoice_item");
+			return;
+		}
+
+		if (frm.doc.purchase_receipt) {
+			frm.toggle_reqd("purchase_receipt_item", 1);
+
+			["purchase_invoice", "purchase_invoice_item"].forEach((field) => {
+				clear_field(field);
+				frm.set_df_property(field, "read_only", 1);
+			});
+			return;
+		}
+
+		if (frm.doc.purchase_invoice) {
+			frm.toggle_reqd("purchase_invoice_item", 1);
+
+			["purchase_receipt", "purchase_receipt_item"].forEach((field) => {
+				clear_field(field);
+				frm.set_df_property(field, "read_only", 1);
+			});
+			return;
+		}
+
+		frm.toggle_reqd("purchase_receipt", 1);
+		frm.toggle_reqd("purchase_invoice", 1);
 	},
 
 	make_journal_entry: function (frm) {
@@ -484,7 +528,6 @@ frappe.ui.form.on("Asset", {
 		} else {
 			frm.set_df_property("gross_purchase_amount", "read_only", 0);
 		}
-
 		frm.trigger("toggle_reference_doc");
 	},
 

erpnext/assets/doctype/asset/asset.json

@@ -229,7 +229,7 @@
    "fieldtype": "Currency",
    "label": "Net Purchase Amount",
    "mandatory_depends_on": "eval:(!doc.is_composite_asset || doc.docstatus==1)",
-   "options": "Company:company:default_currency",
+   "options": "currency",
    "read_only_depends_on": "eval: doc.is_composite_asset"
   },
   {
@@ -597,7 +597,7 @@
    "link_fieldname": "target_asset"
   }
  ],
- "modified": "2025-12-23 16:01:10.195932",
+ "modified": "2026-03-13 12:15:25.734623",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset",

erpnext/assets/doctype/asset/asset.py

@@ -669,7 +669,10 @@ class Asset(AccountsController):
 	def get_status(self):
 		"""Returns status based on whether it is draft, submitted, scrapped or depreciated"""
 		if self.docstatus == 0:
-			status = "Draft"
+			if self.is_composite_asset:
+				status = "Work In Progress"
+			else:
+				status = "Draft"
 		elif self.docstatus == 1:
 			status = "Submitted"
 

erpnext/assets/doctype/asset_capitalization/asset_capitalization.json

@@ -177,6 +177,7 @@
    "default": "1",
    "fieldname": "target_qty",
    "fieldtype": "Float",
+   "hidden": 1,
    "label": "Target Qty"
   },
   {
@@ -290,10 +291,10 @@
    "options": "Cost Center"
   },
   {
-    "fieldname": "project",
-    "fieldtype": "Link",
-    "label": "Project",
-    "options": "Project"
+   "fieldname": "project",
+   "fieldtype": "Link",
+   "label": "Project",
+   "options": "Project"
   },
   {
    "fieldname": "dimension_col_break",
@@ -324,7 +325,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-01-08 13:14:33.008458",
+ "modified": "2026-01-13 17:25:01.352568",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset Capitalization",
@@ -362,10 +363,11 @@
    "write": 1
   }
  ],
+ "row_format": "Dynamic",
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": [],
  "title_field": "title",
  "track_changes": 1,
  "track_seen": 1
-}
+}