chore(release): Bumped to Version 15.60.2

## [15.60.2](https://github.com/frappe/erpnext/compare/v15.60.1...v15.60.2) (2025-05-06)

### Bug Fixes

* 'time to resolve: failed' on issue (backport [#47406](https://github.com/frappe/erpnext/issues/47406)) ([#47407](https://github.com/frappe/erpnext/issues/47407)) ([21612fc](21612fc230))
* backward compatibility for renamed group_by filter on reports (backport [#47362](https://github.com/frappe/erpnext/issues/47362)) ([#47403](https://github.com/frappe/erpnext/issues/47403)) ([0e5c709](0e5c709f7b))
* change shipping address fetching condition ([0aabe4f](0aabe4fd1e))
* completed transactions showing in the list (backport [#47374](https://github.com/frappe/erpnext/issues/47374)) ([#47379](https://github.com/frappe/erpnext/issues/47379)) ([1ef7da8](1ef7da837f))
* do not allocate amount when ref's doctype or name are not set ([c2e36da](c2e36daa32))
* do not mandate depreciation account for assets without depreciation (backport [#47427](https://github.com/frappe/erpnext/issues/47427)) ([#47428](https://github.com/frappe/erpnext/issues/47428)) ([01e975b](01e975b481))
* not able to submit the stock entry ([#47383](https://github.com/frappe/erpnext/issues/47383)) ([035394a](035394ae6a))
* party name in Ledger Summary ([4fc14b3](4fc14b3097))
* precision issue ([b6908a7](b6908a79bd))
* rename unchanged group_by filter related to general ledger report (backport [#47366](https://github.com/frappe/erpnext/issues/47366)) ([#47405](https://github.com/frappe/erpnext/issues/47405)) ([8d1e855](8d1e855dc8))
* renaming group by fieldname and value in reports (backport [#47352](https://github.com/frappe/erpnext/issues/47352)) ([#47360](https://github.com/frappe/erpnext/issues/47360)) ([85a8adf](85a8adf804))
* show party type in due date exceeding message ([f73e99e](f73e99e9d2))
* stock reco recalculate qty not works for opening stock reco ([2bd30e3](2bd30e3c46))
* update accounts on change of mode of payment in sales invoice payment (backport [#47381](https://github.com/frappe/erpnext/issues/47381)) ([#47400](https://github.com/frappe/erpnext/issues/47400)) ([afb44a6](afb44a677c))
* validation for difference account ([f4a43d0](f4a43d07b0))
* warning message before changing the valuation method (backport [#47340](https://github.com/frappe/erpnext/issues/47340)) ([#47342](https://github.com/frappe/erpnext/issues/47342)) ([4ef2b77](4ef2b77973))

.pre-commit-config.yaml

@@ -1,5 +1,5 @@
 exclude: 'node_modules|.git'
-default_stages: [commit]
+default_stages: [pre-commit]
 fail_fast: false
 
 

README.md

@@ -62,7 +62,7 @@ New passwords will be created for the ERPNext "Administrator" user, the MariaDB
 
 ## Learning and community
 
-1. [Frappe School](https://frappe.school) - Learn Frappe Framework and ERPNext from the various courses by the maintainers or from the community.
+1. [Frappe School](https://school.frappe.io) - Learn Frappe Framework and ERPNext from the various courses by the maintainers or from the community.
 2. [Official documentation](https://docs.erpnext.com/) - Extensive documentation for ERPNext.
 3. [Discussion Forum](https://discuss.erpnext.com/) - Engage with community of ERPNext users and service providers.
 4. [Telegram Group](https://erpnext_public.t.me) - Get instant help from huge community of users.

erpnext/__init__.py

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

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -77,9 +77,12 @@
   "reports_tab",
   "remarks_section",
   "general_ledger_remarks_length",
-  "ignore_is_opening_check_for_reporting",
   "column_break_lvjk",
   "receivable_payable_remarks_length",
+  "accounts_receivable_payable_tuning_section",
+  "receivable_payable_fetch_method",
+  "legacy_section",
+  "ignore_is_opening_check_for_reporting",
   "payment_request_settings",
   "create_pr_in_draft_status"
  ],
@@ -532,6 +535,34 @@
    "fieldtype": "Select",
    "label": "Posting Date Inheritance for Exchange Gain / Loss",
    "options": "Invoice\nPayment\nReconciliation Date"
+  },
+  {
+   "fieldname": "column_break_xrnd",
+   "fieldtype": "Column Break"
+  },
+  {
+   "default": "0",
+   "description": "If enabled, Sales Invoice will be generated instead of POS Invoice in POS Transactions for real-time update of G/L and Stock Ledger.",
+   "fieldname": "use_sales_invoice_in_pos",
+   "fieldtype": "Check",
+   "label": "Use Sales Invoice"
+  },
+  {
+   "default": "Buffered Cursor",
+   "fieldname": "receivable_payable_fetch_method",
+   "fieldtype": "Select",
+   "label": "Data Fetch Method",
+   "options": "Buffered Cursor\nUnBuffered Cursor"
+  },
+  {
+   "fieldname": "accounts_receivable_payable_tuning_section",
+   "fieldtype": "Section Break",
+   "label": "Accounts Receivable / Payable Tuning"
+  },
+  {
+   "fieldname": "legacy_section",
+   "fieldtype": "Section Break",
+   "label": "Legacy Fields"
   }
  ],
  "icon": "icon-cog",
@@ -539,7 +570,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2025-01-23 13:15:44.077853",
+ "modified": "2025-05-05 12:29:38.302027",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -54,6 +54,7 @@ class AccountsSettings(Document):
 		merge_similar_account_heads: DF.Check
 		over_billing_allowance: DF.Currency
 		post_change_gl_entries: DF.Check
+		receivable_payable_fetch_method: DF.Literal["Buffered Cursor", "UnBuffered Cursor"]
 		receivable_payable_remarks_length: DF.Int
 		reconciliation_queue_size: DF.Int
 		role_allowed_to_over_bill: DF.Link | None

erpnext/accounts/doctype/bank_clearance/test_bank_clearance.py

@@ -7,6 +7,9 @@ import frappe
 from frappe.utils import add_months, getdate
 
 from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
+from erpnext.accounts.doctype.mode_of_payment.test_mode_of_payment import (
+	set_default_account_for_mode_of_payment,
+)
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
@@ -191,11 +194,13 @@ def make_pos_sales_invoice():
 
 	customer = make_customer(customer="_Test Customer")
 
+	mode_of_payment = frappe.get_doc("Mode of Payment", "Wire Transfer")
+
+	set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", "_Test Bank Clearance - _TC")
+
 	si = create_sales_invoice(customer=customer, item="_Test Item", is_pos=1, qty=1, rate=1000, do_not_save=1)
 	si.set("payments", [])
-	si.append(
-		"payments", {"mode_of_payment": "Cash", "account": "_Test Bank Clearance - _TC", "amount": 1000}
-	)
+	si.append("payments", {"mode_of_payment": "Wire Transfer", "amount": 1000})
 	si.insert()
 	si.submit()
 

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -8,6 +8,7 @@ import frappe
 from frappe import _
 from frappe.model.document import Document
 from frappe.query_builder.custom import ConstantColumn
+from frappe.query_builder.functions import Sum
 from frappe.utils import cint, flt
 
 from erpnext import get_default_cost_center
@@ -373,8 +374,6 @@ def auto_reconcile_vouchers(
 	from_reference_date=None,
 	to_reference_date=None,
 ):
-	frappe.flags.auto_reconcile_vouchers = True
-
 	bank_transactions = get_bank_transactions(bank_account)
 
 	if len(bank_transactions) > 10:
@@ -403,6 +402,8 @@ def auto_reconcile_vouchers(
 def start_auto_reconcile(
 	bank_transactions, from_date, to_date, filter_by_reference_date, from_reference_date, to_reference_date
 ):
+	frappe.flags.auto_reconcile_vouchers = True
+
 	reconciled, partially_reconciled = set(), set()
 	for transaction in bank_transactions:
 		linked_payments = get_linked_payments(
@@ -517,16 +518,23 @@ def subtract_allocations(gl_account, vouchers):
 	voucher_allocated_amounts = get_total_allocated_amount(voucher_docs)
 
 	for voucher in vouchers:
-		rows = voucher_allocated_amounts.get((voucher.get("doctype"), voucher.get("name"))) or []
-		filtered_row = list(filter(lambda row: row.get("gl_account") == gl_account, rows))
-
-		if amount := None if not filtered_row else filtered_row[0]["total"]:
+		if amount := get_allocated_amount(voucher_allocated_amounts, voucher, gl_account):
 			voucher["paid_amount"] -= amount
 
 		copied.append(voucher)
 	return copied
 
 
+def get_allocated_amount(voucher_allocated_amounts, voucher, gl_account):
+	if not (voucher_details := voucher_allocated_amounts.get((voucher.get("doctype"), voucher.get("name")))):
+		return
+
+	if not (row := voucher_details.get(gl_account)):
+		return
+
+	return row.get("total")
+
+
 def check_matching(
 	bank_account,
 	company,
@@ -796,26 +804,20 @@ def get_je_matching_query(
 	je = frappe.qb.DocType("Journal Entry")
 	jea = frappe.qb.DocType("Journal Entry Account")
 
-	ref_condition = je.cheque_no == transaction.reference_number
-	ref_rank = frappe.qb.terms.Case().when(ref_condition, 1).else_(0)
-
 	amount_field = f"{cr_or_dr}_in_account_currency"
-	amount_equality = getattr(jea, amount_field) == transaction.unallocated_amount
-	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(0)
 
 	filter_by_date = je.posting_date.between(from_date, to_date)
 	if cint(filter_by_reference_date):
 		filter_by_date = je.cheque_date.between(from_reference_date, to_reference_date)
 
-	query = (
+	subquery = (
 		frappe.qb.from_(jea)
 		.join(je)
 		.on(jea.parent == je.name)
 		.select(
-			(ref_rank + amount_rank + 1).as_("rank"),
+			Sum(getattr(jea, amount_field)).as_("paid_amount"),
 			ConstantColumn("Journal Entry").as_("doctype"),
 			je.name,
-			getattr(jea, amount_field).as_("paid_amount"),
 			je.cheque_no.as_("reference_no"),
 			je.cheque_date.as_("reference_date"),
 			je.pay_to_recd_from.as_("party"),
@@ -827,13 +829,26 @@ def get_je_matching_query(
 		.where(je.voucher_type != "Opening Entry")
 		.where(je.clearance_date.isnull())
 		.where(jea.account == common_filters.bank_account)
-		.where(amount_equality if exact_match else getattr(jea, amount_field) > 0.0)
 		.where(filter_by_date)
+		.groupby(je.name)
 		.orderby(je.cheque_date if cint(filter_by_reference_date) else je.posting_date)
 	)
 
 	if frappe.flags.auto_reconcile_vouchers is True:
-		query = query.where(ref_condition)
+		subquery = subquery.where(je.cheque_no == transaction.reference_number)
+
+	ref_rank = frappe.qb.terms.Case().when(subquery.reference_no == transaction.reference_number, 1).else_(0)
+	amount_equality = subquery.paid_amount == transaction.unallocated_amount
+	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(0)
+
+	query = (
+		frappe.qb.from_(subquery)
+		.select(
+			"*",
+			(ref_rank + amount_rank + 1).as_("rank"),
+		)
+		.where(amount_equality if exact_match else subquery.paid_amount > 0.0)
+	)
 
 	return query
 

erpnext/accounts/doctype/bank_transaction/bank_transaction.js

@@ -2,27 +2,6 @@
 // For license information, please see license.txt
 
 frappe.ui.form.on("Bank Transaction", {
-	onload(frm) {
-		frm.set_query("payment_document", "payment_entries", function () {
-			const payment_doctypes = frm.events.get_payment_doctypes(frm);
-			return {
-				filters: {
-					name: ["in", payment_doctypes],
-				},
-			};
-		});
-	},
-	refresh(frm) {
-		if (!frm.is_dirty() && frm.doc.payment_entries.length > 0) {
-			frm.add_custom_button(__("Unreconcile Transaction"), () => {
-				frm.call("remove_payment_entries").then(() => frm.refresh());
-			});
-		}
-	},
-	bank_account: function (frm) {
-		set_bank_statement_filter(frm);
-	},
-
 	setup: function (frm) {
 		frm.set_query("party_type", function () {
 			return {
@@ -31,6 +10,41 @@ frappe.ui.form.on("Bank Transaction", {
 				},
 			};
 		});
+
+		frm.set_query("bank_account", function () {
+			return {
+				filters: { is_company_account: 1 },
+			};
+		});
+
+		frm.set_query("payment_document", "payment_entries", function () {
+			const payment_doctypes = frm.events.get_payment_doctypes(frm);
+			return {
+				filters: {
+					name: ["in", payment_doctypes],
+				},
+			};
+		});
+
+		frm.set_query("payment_entry", "payment_entries", function () {
+			return {
+				filters: {
+					docstatus: ["!=", 2],
+				},
+			};
+		});
+	},
+
+	refresh(frm) {
+		if (!frm.is_dirty() && frm.doc.payment_entries.length > 0) {
+			frm.add_custom_button(__("Unreconcile Transaction"), () => {
+				frm.call("remove_payment_entries").then(() => frm.refresh());
+			});
+		}
+	},
+
+	bank_account: function (frm) {
+		set_bank_statement_filter(frm);
 	},
 
 	get_payment_doctypes: function () {
@@ -39,31 +53,6 @@ frappe.ui.form.on("Bank Transaction", {
 	},
 });
 
-frappe.ui.form.on("Bank Transaction Payments", {
-	payment_entries_remove: function (frm, cdt, cdn) {
-		update_clearance_date(frm, cdt, cdn);
-	},
-});
-
-const update_clearance_date = (frm, cdt, cdn) => {
-	if (frm.doc.docstatus === 1) {
-		frappe
-			.xcall("erpnext.accounts.doctype.bank_transaction.bank_transaction.unclear_reference_payment", {
-				doctype: cdt,
-				docname: cdn,
-				bt_name: frm.doc.name,
-			})
-			.then((e) => {
-				if (e == "success") {
-					frappe.show_alert({
-						message: __("Document {0} successfully uncleared", [e]),
-						indicator: "green",
-					});
-				}
-			});
-	}
-};
-
 function set_bank_statement_filter(frm) {
 	frm.set_query("bank_statement", function () {
 		return {

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -5,7 +5,7 @@ import frappe
 from frappe import _
 from frappe.model.docstatus import DocStatus
 from frappe.model.document import Document
-from frappe.utils import flt
+from frappe.utils import flt, getdate
 
 
 class BankTransaction(Document):
@@ -84,16 +84,16 @@ class BankTransaction(Document):
 		if not self.payment_entries:
 			return
 
-		pe = []
+		references = set()
 		for row in self.payment_entries:
 			reference = (row.payment_document, row.payment_entry)
-			if reference in pe:
+			if reference in references:
 				frappe.throw(
 					_("{0} {1} is allocated twice in this Bank Transaction").format(
 						row.payment_document, row.payment_entry
 					)
 				)
-			pe.append(reference)
+			references.add(reference)
 
 	def update_allocated_amount(self):
 		allocated_amount = (
@@ -104,6 +104,19 @@ class BankTransaction(Document):
 		self.allocated_amount = flt(allocated_amount, self.precision("allocated_amount"))
 		self.unallocated_amount = flt(unallocated_amount, self.precision("unallocated_amount"))
 
+	def delink_old_payment_entries(self):
+		if self.flags.updating_linked_bank_transaction:
+			return
+
+		old_doc = self.get_doc_before_save()
+		payment_entry_names = set(pe.name for pe in self.payment_entries)
+
+		for old_pe in old_doc.payment_entries:
+			if old_pe.name in payment_entry_names:
+				continue
+
+			self.delink_payment_entry(old_pe)
+
 	def before_submit(self):
 		self.allocate_payment_entries()
 		self.set_status()
@@ -113,13 +126,14 @@ class BankTransaction(Document):
 
 	def before_update_after_submit(self):
 		self.validate_duplicate_references()
-		self.allocate_payment_entries()
 		self.update_allocated_amount()
+		self.delink_old_payment_entries()
+		self.allocate_payment_entries()
 		self.set_status()
 
 	def on_cancel(self):
 		for payment_entry in self.payment_entries:
-			self.clear_linked_payment_entry(payment_entry, for_cancel=True)
+			self.delink_payment_entry(payment_entry)
 
 		self.set_status()
 
@@ -152,43 +166,55 @@ class BankTransaction(Document):
 		    - 0 > a: Error: already over-allocated
 		- clear means: set the latest transaction date as clearance date
 		"""
+		if self.flags.updating_linked_bank_transaction or not self.payment_entries:
+			return
+
 		remaining_amount = self.unallocated_amount
-		to_remove = []
 		payment_entry_docs = [(pe.payment_document, pe.payment_entry) for pe in self.payment_entries]
 		pe_bt_allocations = get_total_allocated_amount(payment_entry_docs)
+		gl_entries = get_related_bank_gl_entries(payment_entry_docs)
+		gl_bank_account = frappe.db.get_value("Bank Account", self.bank_account, "account")
 
-		for payment_entry in self.payment_entries:
-			if payment_entry.allocated_amount == 0.0:
-				unallocated_amount, should_clear, latest_transaction = get_clearance_details(
-					self,
-					payment_entry,
-					pe_bt_allocations.get((payment_entry.payment_document, payment_entry.payment_entry))
-					or [],
+		for payment_entry in list(self.payment_entries):
+			if payment_entry.allocated_amount != 0:
+				continue
+
+			allocable_amount, should_clear, clearance_date = get_clearance_details(
+				self,
+				payment_entry,
+				pe_bt_allocations.get((payment_entry.payment_document, payment_entry.payment_entry)) or {},
+				gl_entries.get((payment_entry.payment_document, payment_entry.payment_entry)) or {},
+				gl_bank_account,
+			)
+
+			if allocable_amount < 0:
+				frappe.throw(_("Voucher {0} is over-allocated by {1}").format(allocable_amount))
+
+			if remaining_amount <= 0:
+				self.remove(payment_entry)
+				continue
+
+			if allocable_amount == 0:
+				if should_clear:
+					self.clear_linked_payment_entry(payment_entry, clearance_date=clearance_date)
+				self.remove(payment_entry)
+				continue
+
+			should_clear = should_clear and allocable_amount <= remaining_amount
+			payment_entry.allocated_amount = min(allocable_amount, remaining_amount)
+			remaining_amount = flt(
+				remaining_amount - payment_entry.allocated_amount,
+				self.precision("unallocated_amount"),
+			)
+
+			if payment_entry.payment_document == "Bank Transaction":
+				self.update_linked_bank_transaction(
+					payment_entry.payment_entry, payment_entry.allocated_amount
 				)
+			elif should_clear:
+				self.clear_linked_payment_entry(payment_entry, clearance_date=clearance_date)
 
-				if 0.0 == unallocated_amount:
-					if should_clear:
-						latest_transaction.clear_linked_payment_entry(payment_entry)
-					to_remove.append(payment_entry)
-
-				elif remaining_amount <= 0.0:
-					to_remove.append(payment_entry)
-
-				elif 0.0 < unallocated_amount <= remaining_amount:
-					payment_entry.allocated_amount = unallocated_amount
-					remaining_amount -= unallocated_amount
-					if should_clear:
-						latest_transaction.clear_linked_payment_entry(payment_entry)
-
-				elif 0.0 < unallocated_amount:
-					payment_entry.allocated_amount = remaining_amount
-					remaining_amount = 0.0
-
-				elif 0.0 > unallocated_amount:
-					frappe.throw(_("Voucher {0} is over-allocated by {1}").format(unallocated_amount))
-
-		for payment_entry in to_remove:
-			self.remove(payment_entry)
+		self.update_allocated_amount()
 
 	@frappe.whitelist()
 	def remove_payment_entries(self):
@@ -199,14 +225,64 @@ class BankTransaction(Document):
 
 	def remove_payment_entry(self, payment_entry):
 		"Clear payment entry and clearance"
-		self.clear_linked_payment_entry(payment_entry, for_cancel=True)
+		self.delink_payment_entry(payment_entry)
 		self.remove(payment_entry)
 
-	def clear_linked_payment_entry(self, payment_entry, for_cancel=False):
-		clearance_date = None if for_cancel else self.date
-		set_voucher_clearance(
-			payment_entry.payment_document, payment_entry.payment_entry, clearance_date, self
-		)
+	def delink_payment_entry(self, payment_entry):
+		if payment_entry.payment_document == "Bank Transaction":
+			self.update_linked_bank_transaction(payment_entry.payment_entry, allocated_amount=None)
+		else:
+			self.clear_linked_payment_entry(payment_entry, clearance_date=None)
+
+	def clear_linked_payment_entry(self, payment_entry, clearance_date=None):
+		doctype = payment_entry.payment_document
+		docname = payment_entry.payment_entry
+
+		# might be a bank transaction
+		if doctype not in get_doctypes_for_bank_reconciliation():
+			return
+
+		if doctype == "Sales Invoice":
+			frappe.db.set_value(
+				"Sales Invoice Payment",
+				dict(parenttype=doctype, parent=docname),
+				"clearance_date",
+				clearance_date,
+			)
+			return
+
+		frappe.db.set_value(doctype, docname, "clearance_date", clearance_date)
+
+	def update_linked_bank_transaction(self, bank_transaction_name, allocated_amount=None):
+		"""For when a second bank transaction has fixed another, e.g. refund"""
+
+		bt = frappe.get_doc(self.doctype, bank_transaction_name)
+		if allocated_amount:
+			bt.append(
+				"payment_entries",
+				{
+					"payment_document": self.doctype,
+					"payment_entry": self.name,
+					"allocated_amount": allocated_amount,
+				},
+			)
+
+		else:
+			pe = next(
+				(
+					pe
+					for pe in bt.payment_entries
+					if pe.payment_document == self.doctype and pe.payment_entry == self.name
+				),
+				None,
+			)
+			if not pe:
+				return
+
+			bt.flags.updating_linked_bank_transaction = True
+			bt.remove(pe)
+
+		bt.save()
 
 	def auto_set_party(self):
 		from erpnext.accounts.doctype.bank_transaction.auto_match_party import AutoMatchParty
@@ -238,71 +314,107 @@ def get_doctypes_for_bank_reconciliation():
 	return frappe.get_hooks("bank_reconciliation_doctypes")
 
 
-def get_clearance_details(transaction, payment_entry, bt_allocations):
+def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries, gl_bank_account):
 	"""
-	There should only be one bank gle for a voucher.
-	Could be none for a Bank Transaction.
-	But if a JE, could affect two banks.
-	Should only clear the voucher if all bank gles are allocated.
+	There should only be one bank gl entry for a voucher, except for JE.
+	For JE, there can be multiple bank gl entries for the same account.
+	In this case, the allocable_amount will be the sum of amounts of all gl entries of the account.
+	There will be no gl entry for a Bank Transaction so return the unallocated amount.
+	Should only clear the voucher if all bank gl entries are allocated.
 	"""
-	gl_bank_account = frappe.db.get_value("Bank Account", transaction.bank_account, "account")
-	gles = get_related_bank_gl_entries(payment_entry.payment_document, payment_entry.payment_entry)
 
-	unallocated_amount = min(
-		transaction.unallocated_amount,
-		get_paid_amount(payment_entry, transaction.currency, gl_bank_account),
-	)
-	unmatched_gles = len(gles)
-	latest_transaction = transaction
-	for gle in gles:
-		if gle["gl_account"] == gl_bank_account:
-			if gle["amount"] <= 0.0:
-				frappe.throw(
-					_("Voucher {0} value is broken: {1}").format(payment_entry.payment_entry, gle["amount"])
+	transaction_date = getdate(transaction.date)
+
+	if payment_entry.payment_document == "Bank Transaction":
+		bt = frappe.db.get_value(
+			"Bank Transaction",
+			payment_entry.payment_entry,
+			("unallocated_amount", "bank_account"),
+			as_dict=True,
+		)
+
+		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
 				)
+			)
 
-			unmatched_gles -= 1
-			unallocated_amount = gle["amount"]
-			for a in bt_allocations:
-				if a["gl_account"] == gle["gl_account"]:
-					unallocated_amount = gle["amount"] - a["total"]
-					if frappe.utils.getdate(transaction.date) < a["latest_date"]:
-						latest_transaction = frappe.get_doc("Bank Transaction", a["latest_name"])
-		else:
-			# Must be a Journal Entry affecting more than one bank
-			for a in bt_allocations:
-				if a["gl_account"] == gle["gl_account"] and a["total"] == gle["amount"]:
-					unmatched_gles -= 1
+		return abs(bt.unallocated_amount), True, transaction_date
 
-	return unallocated_amount, unmatched_gles == 0, latest_transaction
+	if gl_bank_account not in gl_entries:
+		frappe.throw(
+			_("{} {} is not affecting bank account {}").format(
+				payment_entry.payment_document, payment_entry.payment_entry, gl_bank_account
+			)
+		)
+
+	allocable_amount = gl_entries.pop(gl_bank_account) or 0
+	if allocable_amount <= 0.0:
+		frappe.throw(
+			_("Invalid amount in accounting entries of {} {} for Account {}: {}").format(
+				payment_entry.payment_document, payment_entry.payment_entry, gl_bank_account, allocable_amount
+			)
+		)
+
+	matching_bt_allocaion = bt_allocations.pop(gl_bank_account, {})
+
+	allocable_amount = flt(
+		allocable_amount - matching_bt_allocaion.get("total", 0), transaction.precision("unallocated_amount")
+	)
+
+	should_clear = all(
+		gl_entries[gle_account] == bt_allocations.get(gle_account, {}).get("total", 0)
+		for gle_account in gl_entries
+	)
+
+	bt_allocation_date = matching_bt_allocaion.get("latest_date", None)
+	clearance_date = transaction_date if not bt_allocation_date else max(transaction_date, bt_allocation_date)
+
+	return allocable_amount, should_clear, clearance_date
 
 
-def get_related_bank_gl_entries(doctype, docname):
+def get_related_bank_gl_entries(docs):
 	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
-	return frappe.db.sql(
+	if not docs:
+		return {}
+
+	result = frappe.db.sql(
 		"""
-		SELECT
-			ABS(gle.credit_in_account_currency - gle.debit_in_account_currency) AS amount,
-			gle.account AS gl_account
-		FROM
-			`tabGL Entry` gle
-		LEFT JOIN
-			`tabAccount` ac ON ac.name=gle.account
-		WHERE
-			ac.account_type = 'Bank'
-			AND gle.voucher_type = %(doctype)s
-			AND gle.voucher_no = %(docname)s
-			AND is_cancelled = 0
-		""",
-		dict(doctype=doctype, docname=docname),
+        SELECT
+            gle.voucher_type AS doctype,
+            gle.voucher_no AS docname,
+            gle.account AS gl_account,
+            SUM(ABS(gle.credit_in_account_currency - gle.debit_in_account_currency)) AS amount
+        FROM
+            `tabGL Entry` gle
+        LEFT JOIN
+            `tabAccount` ac ON ac.name = gle.account
+        WHERE
+            ac.account_type = 'Bank'
+            AND (gle.voucher_type, gle.voucher_no) IN %(docs)s
+            AND gle.is_cancelled = 0
+        GROUP BY
+            gle.voucher_type, gle.voucher_no, gle.account
+        """,
+		{"docs": docs},
 		as_dict=True,
 	)
 
+	entries = {}
+	for row in result:
+		key = (row["doctype"], row["docname"])
+		if key not in entries:
+			entries[key] = {}
+		entries[key][row["gl_account"]] = row["amount"]
+
+	return entries
+
 
 def get_total_allocated_amount(docs):
 	"""
 	Gets the sum of allocations for a voucher on each bank GL account
-	along with the latest bank transaction name & date
+	along with the latest bank transaction date
 	NOTE: query may also include just saved vouchers/payments but with zero allocated_amount
 	"""
 	if not docs:
@@ -311,11 +423,10 @@ def get_total_allocated_amount(docs):
 	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
 	result = frappe.db.sql(
 		"""
-		SELECT total, latest_name, latest_date, gl_account, payment_document, payment_entry FROM (
+		SELECT total, latest_date, gl_account, payment_document, payment_entry FROM (
 			SELECT
 				ROW_NUMBER() OVER w AS rownum,
 				SUM(btp.allocated_amount) OVER(PARTITION BY ba.account, btp.payment_document, btp.payment_entry) AS total,
-				FIRST_VALUE(bt.name) OVER w AS latest_name,
 				FIRST_VALUE(bt.date) OVER w AS latest_date,
 				ba.account AS gl_account,
 				btp.payment_document,
@@ -338,104 +449,14 @@ def get_total_allocated_amount(docs):
 
 	payment_allocation_details = {}
 	for row in result:
-		# Why is this *sometimes* a byte string?
-		if isinstance(row["latest_name"], bytes):
-			row["latest_name"] = row["latest_name"].decode()
-		row["latest_date"] = frappe.utils.getdate(row["latest_date"])
-		payment_allocation_details.setdefault((row["payment_document"], row["payment_entry"]), []).append(row)
+		row["latest_date"] = getdate(row["latest_date"])
+		payment_allocation_details.setdefault((row["payment_document"], row["payment_entry"]), {})[
+			row["gl_account"]
+		] = row
 
 	return payment_allocation_details
 
 
-def get_paid_amount(payment_entry, currency, gl_bank_account):
-	if payment_entry.payment_document in ["Payment Entry", "Sales Invoice", "Purchase Invoice"]:
-		paid_amount_field = "paid_amount"
-		if payment_entry.payment_document == "Payment Entry":
-			doc = frappe.get_doc("Payment Entry", payment_entry.payment_entry)
-
-			if doc.payment_type == "Receive":
-				paid_amount_field = (
-					"received_amount" if doc.paid_to_account_currency == currency else "base_received_amount"
-				)
-			elif doc.payment_type == "Pay":
-				paid_amount_field = (
-					"paid_amount" if doc.paid_from_account_currency == currency else "base_paid_amount"
-				)
-
-		return frappe.db.get_value(
-			payment_entry.payment_document, payment_entry.payment_entry, paid_amount_field
-		)
-
-	elif payment_entry.payment_document == "Journal Entry":
-		return abs(
-			frappe.db.get_value(
-				"Journal Entry Account",
-				{"parent": payment_entry.payment_entry, "account": gl_bank_account},
-				"sum(debit_in_account_currency-credit_in_account_currency)",
-			)
-			or 0
-		)
-
-	elif payment_entry.payment_document == "Expense Claim":
-		return frappe.db.get_value(
-			payment_entry.payment_document, payment_entry.payment_entry, "total_amount_reimbursed"
-		)
-
-	elif payment_entry.payment_document == "Loan Disbursement":
-		return frappe.db.get_value(
-			payment_entry.payment_document, payment_entry.payment_entry, "disbursed_amount"
-		)
-
-	elif payment_entry.payment_document == "Loan Repayment":
-		return frappe.db.get_value(payment_entry.payment_document, payment_entry.payment_entry, "amount_paid")
-
-	elif payment_entry.payment_document == "Bank Transaction":
-		dep, wth = frappe.db.get_value(
-			"Bank Transaction", payment_entry.payment_entry, ("deposit", "withdrawal")
-		)
-		return abs(flt(wth) - flt(dep))
-
-	else:
-		frappe.throw(
-			f"Please reconcile {payment_entry.payment_document}: {payment_entry.payment_entry} manually"
-		)
-
-
-def set_voucher_clearance(doctype, docname, clearance_date, self):
-	if doctype in get_doctypes_for_bank_reconciliation():
-		if (
-			doctype == "Payment Entry"
-			and frappe.db.get_value("Payment Entry", docname, "payment_type") == "Internal Transfer"
-			and len(get_reconciled_bank_transactions(doctype, docname)) < 2
-		):
-			return
-
-		if doctype == "Sales Invoice":
-			frappe.db.set_value(
-				"Sales Invoice Payment",
-				dict(parenttype=doctype, parent=docname),
-				"clearance_date",
-				clearance_date,
-			)
-			return
-
-		frappe.db.set_value(doctype, docname, "clearance_date", clearance_date)
-
-	elif doctype == "Bank Transaction":
-		# For when a second bank transaction has fixed another, e.g. refund
-		bt = frappe.get_doc(doctype, docname)
-		if clearance_date:
-			vouchers = [{"payment_doctype": "Bank Transaction", "payment_name": self.name}]
-			bt.add_payment_entries(vouchers)
-			bt.save()
-		else:
-			for pe in bt.payment_entries:
-				if pe.payment_document == self.doctype and pe.payment_entry == self.name:
-					bt.remove(pe)
-					bt.save()
-					break
-
-
 def get_reconciled_bank_transactions(doctype, docname):
 	return frappe.get_all(
 		"Bank Transaction Payments",
@@ -444,13 +465,6 @@ def get_reconciled_bank_transactions(doctype, docname):
 	)
 
 
-@frappe.whitelist()
-def unclear_reference_payment(doctype, docname, bt_name):
-	bt = frappe.get_doc("Bank Transaction", bt_name)
-	set_voucher_clearance(doctype, docname, None, bt)
-	return docname
-
-
 def remove_from_bank_transaction(doctype, docname):
 	"""Remove a (cancelled) voucher from all Bank Transactions."""
 	for bt_name in get_reconciled_bank_transactions(doctype, docname):

erpnext/accounts/doctype/bank_transaction/test_bank_transaction.py

@@ -12,6 +12,9 @@ from erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool
 	get_linked_payments,
 	reconcile_vouchers,
 )
+from erpnext.accounts.doctype.mode_of_payment.test_mode_of_payment import (
+	set_default_account_for_mode_of_payment,
+)
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
 from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
@@ -434,15 +437,13 @@ def add_vouchers(gl_account="_Test Bank - _TC"):
 	except frappe.DuplicateEntryError:
 		pass
 
-	mode_of_payment = frappe.get_doc({"doctype": "Mode of Payment", "name": "Cash"})
+	mode_of_payment = frappe.get_doc({"doctype": "Mode of Payment", "name": "Wire Transfer"})
 
-	if not frappe.db.get_value("Mode of Payment Account", {"company": "_Test Company", "parent": "Cash"}):
-		mode_of_payment.append("accounts", {"company": "_Test Company", "default_account": gl_account})
-		mode_of_payment.save()
+	set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", gl_account)
 
 	si = create_sales_invoice(customer="Fayva", qty=1, rate=109080, do_not_save=1)
 	si.is_pos = 1
-	si.append("payments", {"mode_of_payment": "Cash", "account": gl_account, "amount": 109080})
+	si.append("payments", {"mode_of_payment": "Wire Transfer", "amount": 109080})
 	si.insert()
 	si.submit()
 

erpnext/accounts/doctype/dunning/dunning.py

@@ -220,6 +220,7 @@ def get_dunning_letter_text(dunning_type: str, doc: str | dict, language: str |
 	if not language:
 		language = doc.get("language")
 
+	letter_text = None
 	if language:
 		letter_text = frappe.db.get_value(
 			DOCTYPE, {"parent": dunning_type, "language": language}, FIELDS, as_dict=1

erpnext/accounts/doctype/dunning/test_dunning.py

@@ -1,6 +1,9 @@
 # Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
+import json
+
 import frappe
+from frappe.model import mapper
 from frappe.tests.utils import FrappeTestCase
 from frappe.utils import add_days, nowdate, today
 
@@ -68,6 +71,36 @@ class TestDunning(FrappeTestCase):
 		dunning.reload()
 		self.assertEqual(dunning.status, "Resolved")
 
+	def test_fetch_overdue_payments(self):
+		"""
+		Create SI with overdue payment. Check if overdue payment is fetched in Dunning.
+		"""
+		si1 = create_sales_invoice_against_cost_center(
+			posting_date=add_days(today(), -1 * 6),
+			qty=1,
+			rate=100,
+		)
+
+		si2 = create_sales_invoice_against_cost_center(
+			posting_date=add_days(today(), -1 * 6),
+			qty=1,
+			rate=300,
+		)
+
+		dunning = create_dunning_from_sales_invoice(si1.name)
+		dunning.overdue_payments = []
+
+		method = "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_dunning"
+		updated_dunning = mapper.map_docs(method, json.dumps([si1.name, si2.name]), dunning)
+
+		self.assertEqual(len(updated_dunning.overdue_payments), 2)
+
+		self.assertEqual(updated_dunning.overdue_payments[0].sales_invoice, si1.name)
+		self.assertEqual(updated_dunning.overdue_payments[0].outstanding, si1.outstanding_amount)
+
+		self.assertEqual(updated_dunning.overdue_payments[1].sales_invoice, si2.name)
+		self.assertEqual(updated_dunning.overdue_payments[1].outstanding, si2.outstanding_amount)
+
 	def test_dunning_and_payment_against_partially_due_invoice(self):
 		"""
 		Create SI with first installment overdue. Check impact of Dunning and Payment Entry.

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -7,7 +7,7 @@ from frappe import _
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
 from frappe.model.naming import set_name_from_naming_options
-from frappe.utils import flt, fmt_money
+from frappe.utils import flt, fmt_money, now
 
 import erpnext
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
@@ -456,7 +456,7 @@ def rename_temporarily_named_docs(doctype):
 		set_name_from_naming_options(frappe.get_meta(doctype).autoname, doc)
 		newname = doc.name
 		frappe.db.sql(
-			f"UPDATE `tab{doctype}` SET name = %s, to_rename = 0 where name = %s",
-			(newname, oldname),
+			f"UPDATE `tab{doctype}` SET name = %s, to_rename = 0, modified = %s where name = %s",
+			(newname, now(), oldname),
 			auto_commit=True,
 		)

erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js

@@ -197,7 +197,7 @@ frappe.ui.form.on("Invoice Discounting", {
 						from_date: frm.doc.posting_date,
 						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
 						company: frm.doc.company,
-						group_by: "Group by Voucher (Consolidated)",
+						categorize_by: "Categorize by Voucher (Consolidated)",
 						show_cancelled_entries: frm.doc.docstatus === 2,
 					};
 					frappe.set_route("query-report", "General Ledger");

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -35,7 +35,7 @@ frappe.ui.form.on("Journal Entry", {
 						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
 						company: frm.doc.company,
 						finance_book: frm.doc.finance_book,
-						group_by: "",
+						categorize_by: "",
 						show_cancelled_entries: frm.doc.docstatus === 2,
 					};
 					frappe.set_route("query-report", "General Ledger");

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -250,11 +250,20 @@ class JournalEntry(AccountsController):
 
 	def validate_inter_company_accounts(self):
 		if self.voucher_type == "Inter Company Journal Entry" and self.inter_company_journal_entry_reference:
-			doc = frappe.get_doc("Journal Entry", self.inter_company_journal_entry_reference)
+			doc = frappe.db.get_value(
+				"Journal Entry",
+				self.inter_company_journal_entry_reference,
+				["company", "total_debit", "total_credit"],
+				as_dict=True,
+			)
 			account_currency = frappe.get_cached_value("Company", self.company, "default_currency")
 			previous_account_currency = frappe.get_cached_value("Company", doc.company, "default_currency")
 			if account_currency == previous_account_currency:
-				if self.total_credit != doc.total_debit or self.total_debit != doc.total_credit:
+				credit_precision = self.precision("total_credit")
+				debit_precision = self.precision("total_debit")
+				if (flt(self.total_credit, credit_precision) != flt(doc.total_debit, debit_precision)) or (
+					flt(self.total_debit, debit_precision) != flt(doc.total_credit, credit_precision)
+				):
 					frappe.throw(_("Total Credit/ Debit Amount should be same as linked Journal Entry"))
 
 	def validate_depr_entry_voucher_type(self):

erpnext/accounts/doctype/mode_of_payment/test_mode_of_payment.py

@@ -3,8 +3,25 @@
 
 import unittest
 
-# test_records = frappe.get_test_records('Mode of Payment')
+import frappe
 
 
 class TestModeofPayment(unittest.TestCase):
 	pass
+
+
+def set_default_account_for_mode_of_payment(mode_of_payment, company, account):
+	mode_of_payment.reload()
+	if frappe.db.exists(
+		"Mode of Payment Account", {"parent": mode_of_payment.mode_of_payment, "company": company}
+	):
+		frappe.db.set_value(
+			"Mode of Payment Account",
+			{"parent": mode_of_payment.mode_of_payment, "company": company},
+			"default_account",
+			account,
+		)
+		return
+
+	mode_of_payment.append("accounts", {"company": company, "default_account": account})
+	mode_of_payment.save()

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -411,7 +411,7 @@ frappe.ui.form.on("Payment Entry", {
 						from_date: frm.doc.posting_date,
 						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
 						company: frm.doc.company,
-						group_by: "",
+						categorize_by: "",
 						show_cancelled_entries: frm.doc.docstatus === 2,
 					};
 					frappe.set_route("query-report", "General Ledger");

erpnext/accounts/doctype/payment_entry/payment_entry.json

@@ -203,14 +203,14 @@
    "fieldtype": "Column Break"
   },
   {
-   "depends_on": "party",
+   "depends_on": "eval: doc.party && doc.party_type !== \"Employee\"",
    "fieldname": "contact_person",
    "fieldtype": "Link",
    "label": "Contact",
    "options": "Contact"
   },
   {
-   "depends_on": "contact_person",
+   "depends_on": "eval: (doc.contact_person || doc.party_type === \"Employee\") && doc.contact_email",
    "fieldname": "contact_email",
    "fieldtype": "Data",
    "label": "Email",
@@ -809,7 +809,7 @@
    "table_fieldname": "payment_entries"
   }
  ],
- "modified": "2025-01-31 17:27:28.555246",
+ "modified": "2025-03-24 16:18:19.920701",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry",

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -38,7 +38,11 @@ from erpnext.accounts.general_ledger import (
 	make_reverse_gl_entries,
 	process_gl_map,
 )
-from erpnext.accounts.party import complete_contact_details, get_party_account, set_contact_details
+from erpnext.accounts.party import (
+	complete_contact_details,
+	get_default_contact,
+	get_party_account,
+)
 from erpnext.accounts.utils import (
 	cancel_exchange_gain_loss_journal,
 	get_account_currency,
@@ -249,16 +253,18 @@ class PaymentEntry(AccountsController):
 			reference_names.add(key)
 
 	def set_bank_account_data(self):
-		if self.bank_account:
-			bank_data = get_bank_account_details(self.bank_account)
+		if not self.bank_account:
+			return
 
-			field = "paid_from" if self.payment_type == "Pay" else "paid_to"
+		bank_data = get_bank_account_details(self.bank_account)
 
-			self.bank = bank_data.bank
-			self.bank_account_no = bank_data.bank_account_no
+		field = "paid_from" if self.payment_type == "Pay" else "paid_to"
 
-			if not self.get(field):
-				self.set(field, bank_data.account)
+		self.bank = bank_data.bank
+		self.bank_account_no = bank_data.bank_account_no
+
+		if not self.get(field):
+			self.set(field, bank_data.account)
 
 	def validate_payment_type_with_outstanding(self):
 		total_outstanding = sum(d.allocated_amount for d in self.get("references"))
@@ -276,15 +282,16 @@ class PaymentEntry(AccountsController):
 
 		if self.party_type in ("Customer", "Supplier"):
 			self.validate_allocated_amount_with_latest_data()
-		else:
-			fail_message = _("Row #{0}: Allocated Amount cannot be greater than outstanding amount.")
-			for d in self.get("references"):
-				if (flt(d.allocated_amount)) > 0 and flt(d.allocated_amount) > flt(d.outstanding_amount):
-					frappe.throw(fail_message.format(d.idx))
+			return
 
-				# Check for negative outstanding invoices as well
-				if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(d.outstanding_amount):
-					frappe.throw(fail_message.format(d.idx))
+		fail_message = _("Row #{0}: Allocated Amount cannot be greater than outstanding amount.")
+		for d in self.get("references"):
+			if (flt(d.allocated_amount)) > 0 and flt(d.allocated_amount) > flt(d.outstanding_amount):
+				frappe.throw(fail_message.format(d.idx))
+
+			# Check for negative outstanding invoices as well
+			if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(d.outstanding_amount):
+				frappe.throw(fail_message.format(d.idx))
 
 	def validate_allocated_amount_as_per_payment_request(self):
 		"""
@@ -322,91 +329,89 @@ class PaymentEntry(AccountsController):
 		return False
 
 	def validate_allocated_amount_with_latest_data(self):
-		if self.references:
-			uniq_vouchers = set([(x.reference_doctype, x.reference_name) for x in self.references])
-			vouchers = [frappe._dict({"voucher_type": x[0], "voucher_no": x[1]}) for x in uniq_vouchers]
-			latest_references = get_outstanding_reference_documents(
-				{
-					"posting_date": self.posting_date,
-					"company": self.company,
-					"party_type": self.party_type,
-					"payment_type": self.payment_type,
-					"party": self.party,
-					"party_account": self.paid_from if self.payment_type == "Receive" else self.paid_to,
-					"get_outstanding_invoices": True,
-					"get_orders_to_be_billed": True,
-					"vouchers": vouchers,
-					"book_advance_payments_in_separate_party_account": self.book_advance_payments_in_separate_party_account,
-				},
-				validate=True,
-			)
+		if not self.references:
+			return
 
-			# Group latest_references by (voucher_type, voucher_no)
-			latest_lookup = {}
-			for d in latest_references:
-				d = frappe._dict(d)
-				latest_lookup.setdefault((d.voucher_type, d.voucher_no), frappe._dict())[d.payment_term] = d
+		uniq_vouchers = {(x.reference_doctype, x.reference_name) for x in self.references}
+		vouchers = [frappe._dict({"voucher_type": x[0], "voucher_no": x[1]}) for x in uniq_vouchers]
+		latest_references = get_outstanding_reference_documents(
+			{
+				"posting_date": self.posting_date,
+				"company": self.company,
+				"party_type": self.party_type,
+				"payment_type": self.payment_type,
+				"party": self.party,
+				"party_account": self.paid_from if self.payment_type == "Receive" else self.paid_to,
+				"get_outstanding_invoices": True,
+				"get_orders_to_be_billed": True,
+				"vouchers": vouchers,
+				"book_advance_payments_in_separate_party_account": self.book_advance_payments_in_separate_party_account,
+			},
+			validate=True,
+		)
 
-			for idx, d in enumerate(self.get("references"), start=1):
-				latest = latest_lookup.get((d.reference_doctype, d.reference_name)) or frappe._dict()
+		# Group latest_references by (voucher_type, voucher_no)
+		latest_lookup = {}
+		for d in latest_references:
+			d = frappe._dict(d)
+			latest_lookup.setdefault((d.voucher_type, d.voucher_no), frappe._dict())[d.payment_term] = d
 
-				# If term based allocation is enabled, throw
-				if (
-					d.payment_term is None or d.payment_term == ""
-				) and self.term_based_allocation_enabled_for_reference(d.reference_doctype, d.reference_name):
-					frappe.throw(
-						_(
-							"{0} has Payment Term based allocation enabled. Select a Payment Term for Row #{1} in Payment References section"
-						).format(frappe.bold(d.reference_name), frappe.bold(idx))
-					)
+		for idx, d in enumerate(self.get("references"), start=1):
+			latest = latest_lookup.get((d.reference_doctype, d.reference_name)) or frappe._dict()
 
-				# if no payment template is used by invoice and has a custom term(no `payment_term`), then invoice outstanding will be in 'None' key
-				latest = latest.get(d.payment_term) or latest.get(None)
-				# The reference has already been fully paid
-				if not latest:
-					frappe.throw(
-						_("{0} {1} has already been fully paid.").format(
-							_(d.reference_doctype), d.reference_name
-						)
-					)
-				# The reference has already been partly paid
-				elif (
-					latest.outstanding_amount < latest.invoice_amount
-					and flt(d.outstanding_amount, d.precision("outstanding_amount"))
-					!= flt(latest.outstanding_amount, d.precision("outstanding_amount"))
-					and d.payment_term == ""
-				):
-					frappe.throw(
-						_(
-							"{0} {1} has already been partly paid. Please use the 'Get Outstanding Invoice' or the 'Get Outstanding Orders' button to get the latest outstanding amounts."
-						).format(_(d.reference_doctype), d.reference_name)
-					)
+			# If term based allocation is enabled, throw
+			if (
+				d.payment_term is None or d.payment_term == ""
+			) and self.term_based_allocation_enabled_for_reference(d.reference_doctype, d.reference_name):
+				frappe.throw(
+					_(
+						"{0} has Payment Term based allocation enabled. Select a Payment Term for Row #{1} in Payment References section"
+					).format(frappe.bold(d.reference_name), frappe.bold(idx))
+				)
 
-				fail_message = _("Row #{0}: Allocated Amount cannot be greater than outstanding amount.")
+			# if no payment template is used by invoice and has a custom term(no `payment_term`), then invoice outstanding will be in 'None' key
+			latest = latest.get(d.payment_term) or latest.get(None)
+			# The reference has already been fully paid
+			if not latest:
+				frappe.throw(
+					_("{0} {1} has already been fully paid.").format(_(d.reference_doctype), d.reference_name)
+				)
+			# The reference has already been partly paid
+			elif (
+				latest.outstanding_amount < latest.invoice_amount
+				and flt(d.outstanding_amount, d.precision("outstanding_amount"))
+				!= flt(latest.outstanding_amount, d.precision("outstanding_amount"))
+				and d.payment_term == ""
+			):
+				frappe.throw(
+					_(
+						"{0} {1} has already been partly paid. Please use the 'Get Outstanding Invoice' or the 'Get Outstanding Orders' button to get the latest outstanding amounts."
+					).format(_(d.reference_doctype), d.reference_name)
+				)
 
-				if (
-					d.payment_term
-					and (
-						(flt(d.allocated_amount)) > 0
-						and latest.payment_term_outstanding
-						and (flt(d.allocated_amount) > flt(latest.payment_term_outstanding))
-					)
-					and self.term_based_allocation_enabled_for_reference(
-						d.reference_doctype, d.reference_name
-					)
-				):
-					frappe.throw(
-						_(
-							"Row #{0}: Allocated amount:{1} is greater than outstanding amount:{2} for Payment Term {3}"
-						).format(d.idx, d.allocated_amount, latest.payment_term_outstanding, d.payment_term)
-					)
+			fail_message = _("Row #{0}: Allocated Amount cannot be greater than outstanding amount.")
 
-				if (flt(d.allocated_amount)) > 0 and flt(d.allocated_amount) > flt(latest.outstanding_amount):
-					frappe.throw(fail_message.format(d.idx))
+			if (
+				d.payment_term
+				and (
+					(flt(d.allocated_amount)) > 0
+					and latest.payment_term_outstanding
+					and (flt(d.allocated_amount) > flt(latest.payment_term_outstanding))
+				)
+				and self.term_based_allocation_enabled_for_reference(d.reference_doctype, d.reference_name)
+			):
+				frappe.throw(
+					_(
+						"Row #{0}: Allocated amount:{1} is greater than outstanding amount:{2} for Payment Term {3}"
+					).format(d.idx, d.allocated_amount, latest.payment_term_outstanding, d.payment_term)
+				)
 
-				# Check for negative outstanding invoices as well
-				if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(latest.outstanding_amount):
-					frappe.throw(fail_message.format(d.idx))
+			if (flt(d.allocated_amount)) > 0 and flt(d.allocated_amount) > flt(latest.outstanding_amount):
+				frappe.throw(fail_message.format(d.idx))
+
+			# Check for negative outstanding invoices as well
+			if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(latest.outstanding_amount):
+				frappe.throw(fail_message.format(d.idx))
 
 	def delink_advance_entry_references(self):
 		for reference in self.references:
@@ -440,12 +445,12 @@ class PaymentEntry(AccountsController):
 				self.party_name = frappe.db.get_value(self.party_type, self.party, "name")
 
 		if self.party:
-			if not self.contact_person:
-				set_contact_details(
-					self, party=frappe._dict({"name": self.party}), party_type=self.party_type
-				)
-			else:
-				complete_contact_details(self)
+			if self.party_type == "Employee":
+				self.contact_person = None
+			elif not self.contact_person:
+				self.contact_person = get_default_contact(self.party_type, self.party)
+
+			complete_contact_details(self)
 			if not self.party_balance:
 				self.party_balance = get_balance_on(
 					party_type=self.party_type, party=self.party, date=self.posting_date, company=self.company
@@ -456,15 +461,25 @@ class PaymentEntry(AccountsController):
 				self.set(self.party_account_field, party_account)
 				self.party_account = party_account
 
-		if self.paid_from and not (self.paid_from_account_currency or self.paid_from_account_balance):
+		if self.paid_from and (
+			not self.paid_from_account_currency
+			or not self.paid_from_account_balance
+			or not self.paid_from_account_type
+		):
 			acc = get_account_details(self.paid_from, self.posting_date, self.cost_center)
 			self.paid_from_account_currency = acc.account_currency
 			self.paid_from_account_balance = acc.account_balance
+			self.paid_from_account_type = acc.account_type
 
-		if self.paid_to and not (self.paid_to_account_currency or self.paid_to_account_balance):
+		if self.paid_to and (
+			not self.paid_to_account_currency
+			or not self.paid_to_account_balance
+			or not self.paid_to_account_type
+		):
 			acc = get_account_details(self.paid_to, self.posting_date, self.cost_center)
 			self.paid_to_account_currency = acc.account_currency
 			self.paid_to_account_balance = acc.account_balance
+			self.paid_to_account_type = acc.account_type
 
 		self.party_account_currency = (
 			self.paid_from_account_currency
@@ -479,47 +494,48 @@ class PaymentEntry(AccountsController):
 		reference_exchange_details: dict | None = None,
 	) -> None:
 		for d in self.get("references"):
-			if d.allocated_amount:
-				if update_ref_details_only_for and (
-					(d.reference_doctype, d.reference_name) not in update_ref_details_only_for
-				):
+			if not d.allocated_amount:
+				continue
+
+			if update_ref_details_only_for and (
+				(d.reference_doctype, d.reference_name) not in update_ref_details_only_for
+			):
+				continue
+
+			ref_details = get_reference_details(
+				d.reference_doctype,
+				d.reference_name,
+				self.party_account_currency,
+				self.party_type,
+				self.party,
+			)
+
+			# Only update exchange rate when the reference is Journal Entry
+			if (
+				reference_exchange_details
+				and d.reference_doctype == reference_exchange_details.reference_doctype
+				and d.reference_name == reference_exchange_details.reference_name
+			):
+				ref_details.update({"exchange_rate": reference_exchange_details.exchange_rate})
+
+			for field, value in ref_details.items():
+				if d.exchange_gain_loss:
+					# for cases where gain/loss is booked into invoice
+					# exchange_gain_loss is calculated from invoice & populated
+					# and row.exchange_rate is already set to payment entry's exchange rate
+					# refer -> `update_reference_in_payment_entry()` in utils.py
 					continue
 
-				ref_details = get_reference_details(
-					d.reference_doctype,
-					d.reference_name,
-					self.party_account_currency,
-					self.party_type,
-					self.party,
-				)
-
-				# Only update exchange rate when the reference is Journal Entry
-				if (
-					reference_exchange_details
-					and d.reference_doctype == reference_exchange_details.reference_doctype
-					and d.reference_name == reference_exchange_details.reference_name
-				):
-					ref_details.update({"exchange_rate": reference_exchange_details.exchange_rate})
-
-				for field, value in ref_details.items():
-					if d.exchange_gain_loss:
-						# for cases where gain/loss is booked into invoice
-						# exchange_gain_loss is calculated from invoice & populated
-						# and row.exchange_rate is already set to payment entry's exchange rate
-						# refer -> `update_reference_in_payment_entry()` in utils.py
-						continue
-
-					if field == "exchange_rate" or not d.get(field) or force:
-						d.db_set(field, value)
+				if field == "exchange_rate" or not d.get(field) or force:
+					d.db_set(field, value)
 
 	def validate_payment_type(self):
 		if self.payment_type not in ("Receive", "Pay", "Internal Transfer"):
 			frappe.throw(_("Payment Type must be one of Receive, Pay and Internal Transfer"))
 
 	def validate_party_details(self):
-		if self.party:
-			if not frappe.db.exists(self.party_type, self.party):
-				frappe.throw(_("{0} {1} does not exist").format(_(self.party_type), self.party))
+		if self.party and not frappe.db.exists(self.party_type, self.party):
+			frappe.throw(_("{0} {1} does not exist").format(_(self.party_type), self.party))
 
 	def set_exchange_rate(self, ref_doc=None):
 		self.set_source_exchange_rate(ref_doc)
@@ -529,12 +545,8 @@ class PaymentEntry(AccountsController):
 		if self.paid_from:
 			if self.paid_from_account_currency == self.company_currency:
 				self.source_exchange_rate = 1
-			else:
-				if ref_doc:
-					if self.paid_from_account_currency == ref_doc.currency:
-						self.source_exchange_rate = ref_doc.get("exchange_rate") or ref_doc.get(
-							"conversion_rate"
-						)
+			elif ref_doc and self.paid_from_account_currency == ref_doc.currency:
+				self.source_exchange_rate = ref_doc.get("exchange_rate") or ref_doc.get("conversion_rate")
 
 			if not self.source_exchange_rate:
 				self.source_exchange_rate = get_exchange_rate(
@@ -545,9 +557,8 @@ class PaymentEntry(AccountsController):
 		if self.paid_from_account_currency == self.paid_to_account_currency:
 			self.target_exchange_rate = self.source_exchange_rate
 		elif self.paid_to and not self.target_exchange_rate:
-			if ref_doc:
-				if self.paid_to_account_currency == ref_doc.currency:
-					self.target_exchange_rate = ref_doc.get("exchange_rate") or ref_doc.get("conversion_rate")
+			if ref_doc and self.paid_to_account_currency == ref_doc.currency:
+				self.target_exchange_rate = ref_doc.get("exchange_rate") or ref_doc.get("conversion_rate")
 
 			if not self.target_exchange_rate:
 				self.target_exchange_rate = get_exchange_rate(
@@ -578,63 +589,61 @@ class PaymentEntry(AccountsController):
 			elif d.reference_name:
 				if not frappe.db.exists(d.reference_doctype, d.reference_name):
 					frappe.throw(_("{0} {1} does not exist").format(d.reference_doctype, d.reference_name))
-				else:
-					ref_doc = frappe.get_doc(d.reference_doctype, d.reference_name)
 
-					if d.reference_doctype != "Journal Entry":
-						if self.party != ref_doc.get(scrub(self.party_type)):
-							frappe.throw(
-								_("{0} {1} is not associated with {2} {3}").format(
-									_(d.reference_doctype), d.reference_name, _(self.party_type), self.party
-								)
-							)
-					else:
-						self.validate_journal_entry()
+				ref_doc = frappe.get_doc(d.reference_doctype, d.reference_name)
 
-					if d.reference_doctype in frappe.get_hooks("invoice_doctypes"):
-						if self.party_type == "Customer":
-							ref_party_account = (
-								get_party_account_based_on_invoice_discounting(d.reference_name)
-								or ref_doc.debit_to
-							)
-						elif self.party_type == "Supplier":
-							ref_party_account = ref_doc.credit_to
-						elif self.party_type == "Employee":
-							ref_party_account = ref_doc.payable_account
-
-						if (
-							ref_party_account != self.party_account
-							and not self.book_advance_payments_in_separate_party_account
-						):
-							frappe.throw(
-								_("{0} {1} is associated with {2}, but Party Account is {3}").format(
-									_(d.reference_doctype),
-									d.reference_name,
-									ref_party_account,
-									self.party_account,
-								)
-							)
-
-						if ref_doc.doctype == "Purchase Invoice" and ref_doc.get("on_hold"):
-							frappe.throw(
-								_("{0} {1} is on hold").format(_(d.reference_doctype), d.reference_name),
-								title=_("Invalid Purchase Invoice"),
-							)
-
-					if ref_doc.docstatus != 1:
+				if d.reference_doctype != "Journal Entry":
+					if self.party != ref_doc.get(scrub(self.party_type)):
 						frappe.throw(
-							_("{0} {1} must be submitted").format(_(d.reference_doctype), d.reference_name)
+							_("{0} {1} is not associated with {2} {3}").format(
+								_(d.reference_doctype), d.reference_name, _(self.party_type), self.party
+							)
 						)
+				else:
+					self.validate_journal_entry()
+
+				if d.reference_doctype in frappe.get_hooks("invoice_doctypes"):
+					if self.party_type == "Customer":
+						ref_party_account = (
+							get_party_account_based_on_invoice_discounting(d.reference_name)
+							or ref_doc.debit_to
+						)
+					elif self.party_type == "Supplier":
+						ref_party_account = ref_doc.credit_to
+					elif self.party_type == "Employee":
+						ref_party_account = ref_doc.payable_account
+
+					if (
+						ref_party_account != self.party_account
+						and not self.book_advance_payments_in_separate_party_account
+					):
+						frappe.throw(
+							_("{0} {1} is associated with {2}, but Party Account is {3}").format(
+								_(d.reference_doctype),
+								d.reference_name,
+								ref_party_account,
+								self.party_account,
+							)
+						)
+
+					if ref_doc.doctype == "Purchase Invoice" and ref_doc.get("on_hold"):
+						frappe.throw(
+							_("{0} {1} is on hold").format(_(d.reference_doctype), d.reference_name),
+							title=_("Invalid Purchase Invoice"),
+						)
+
+				if ref_doc.docstatus != 1:
+					frappe.throw(
+						_("{0} {1} must be submitted").format(_(d.reference_doctype), d.reference_name)
+					)
 
 	def get_valid_reference_doctypes(self):
 		if self.party_type == "Customer":
 			return ("Sales Order", "Sales Invoice", "Journal Entry", "Dunning", "Payment Entry")
+		elif self.party_type in ["Shareholder", "Employee"]:
+			return ("Journal Entry",)
 		elif self.party_type == "Supplier":
 			return ("Purchase Order", "Purchase Invoice", "Journal Entry", "Payment Entry")
-		elif self.party_type == "Shareholder":
-			return ("Journal Entry",)
-		elif self.party_type == "Employee":
-			return ("Journal Entry",)
 
 	def validate_paid_invoices(self):
 		no_oustanding_refs = {}
@@ -700,37 +709,39 @@ class PaymentEntry(AccountsController):
 		invoice_paid_amount_map = {}
 
 		for ref in self.get("references"):
-			if ref.payment_term and ref.reference_name:
-				key = (ref.payment_term, ref.reference_name, ref.reference_doctype)
-				invoice_payment_amount_map.setdefault(key, 0.0)
-				invoice_payment_amount_map[key] += ref.allocated_amount
+			if not ref.payment_term or not ref.reference_name:
+				continue
 
-				if not invoice_paid_amount_map.get(key):
-					payment_schedule = frappe.get_all(
-						"Payment Schedule",
-						filters={"parent": ref.reference_name},
-						fields=[
-							"paid_amount",
-							"payment_amount",
-							"payment_term",
-							"discount",
-							"outstanding",
-							"discount_type",
-						],
-					)
-					for term in payment_schedule:
-						invoice_key = (term.payment_term, ref.reference_name, ref.reference_doctype)
-						invoice_paid_amount_map.setdefault(invoice_key, {})
-						invoice_paid_amount_map[invoice_key]["outstanding"] = term.outstanding
-						if not (term.discount_type and term.discount):
-							continue
+			key = (ref.payment_term, ref.reference_name, ref.reference_doctype)
+			invoice_payment_amount_map.setdefault(key, 0.0)
+			invoice_payment_amount_map[key] += ref.allocated_amount
 
-						if term.discount_type == "Percentage":
-							invoice_paid_amount_map[invoice_key]["discounted_amt"] = ref.total_amount * (
-								term.discount / 100
-							)
-						else:
-							invoice_paid_amount_map[invoice_key]["discounted_amt"] = term.discount
+			if not invoice_paid_amount_map.get(key):
+				payment_schedule = frappe.get_all(
+					"Payment Schedule",
+					filters={"parent": ref.reference_name},
+					fields=[
+						"paid_amount",
+						"payment_amount",
+						"payment_term",
+						"discount",
+						"outstanding",
+						"discount_type",
+					],
+				)
+				for term in payment_schedule:
+					invoice_key = (term.payment_term, ref.reference_name, ref.reference_doctype)
+					invoice_paid_amount_map.setdefault(invoice_key, {})
+					invoice_paid_amount_map[invoice_key]["outstanding"] = term.outstanding
+					if not (term.discount_type and term.discount):
+						continue
+
+					if term.discount_type == "Percentage":
+						invoice_paid_amount_map[invoice_key]["discounted_amt"] = ref.total_amount * (
+							term.discount / 100
+						)
+					else:
+						invoice_paid_amount_map[invoice_key]["discounted_amt"] = term.discount
 
 		for idx, (key, allocated_amount) in enumerate(invoice_payment_amount_map.items(), 1):
 			if not invoice_paid_amount_map.get(key):
@@ -977,14 +988,14 @@ class PaymentEntry(AccountsController):
 		applicable_tax = 0
 		base_applicable_tax = 0
 		for tax in self.get("taxes"):
-			if not tax.included_in_paid_amount:
-				amount = -1 * tax.tax_amount if tax.add_deduct_tax == "Deduct" else tax.tax_amount
-				base_amount = (
-					-1 * tax.base_tax_amount if tax.add_deduct_tax == "Deduct" else tax.base_tax_amount
-				)
+			if tax.included_in_paid_amount:
+				continue
 
-				applicable_tax += amount
-				base_applicable_tax += base_amount
+			amount = -1 * tax.tax_amount if tax.add_deduct_tax == "Deduct" else tax.tax_amount
+			base_amount = -1 * tax.base_tax_amount if tax.add_deduct_tax == "Deduct" else tax.base_tax_amount
+
+			applicable_tax += amount
+			base_applicable_tax += base_amount
 
 		self.paid_amount_after_tax = flt(
 			flt(self.paid_amount) + flt(applicable_tax), self.precision("paid_amount_after_tax")
@@ -1648,25 +1659,27 @@ class PaymentEntry(AccountsController):
 
 	def add_deductions_gl_entries(self, gl_entries):
 		for d in self.get("deductions"):
-			if d.amount:
-				account_currency = get_account_currency(d.account)
-				if account_currency != self.company_currency:
-					frappe.throw(_("Currency for {0} must be {1}").format(d.account, self.company_currency))
+			if not d.amount:
+				continue
 
-				gl_entries.append(
-					self.get_gl_dict(
-						{
-							"account": d.account,
-							"account_currency": account_currency,
-							"against": self.party or self.paid_from,
-							"debit_in_account_currency": d.amount,
-							"debit_in_transaction_currency": d.amount / self.transaction_exchange_rate,
-							"debit": d.amount,
-							"cost_center": d.cost_center,
-						},
-						item=d,
-					)
+			account_currency = get_account_currency(d.account)
+			if account_currency != self.company_currency:
+				frappe.throw(_("Currency for {0} must be {1}").format(d.account, self.company_currency))
+
+			gl_entries.append(
+				self.get_gl_dict(
+					{
+						"account": d.account,
+						"account_currency": account_currency,
+						"against": self.party or self.paid_from,
+						"debit_in_account_currency": d.amount,
+						"debit_in_transaction_currency": d.amount / self.transaction_exchange_rate,
+						"debit": d.amount,
+						"cost_center": d.cost_center,
+					},
+					item=d,
 				)
+			)
 
 	def get_party_account_for_taxes(self):
 		if self.payment_type == "Receive":
@@ -1981,7 +1994,7 @@ class PaymentEntry(AccountsController):
 
 			# Re allocate amount to those references which have PR set (Higher priority)
 			for ref in self.references:
-				if not ref.payment_request:
+				if not (ref.reference_doctype and ref.reference_name and ref.payment_request):
 					continue
 
 				# fetch outstanding_amount of `Reference` (Payment Term) and `Payment Request` to allocate new amount
@@ -2032,7 +2045,7 @@ class PaymentEntry(AccountsController):
 					)
 			# Re allocate amount to those references which have no PR (Lower priority)
 			for ref in self.references:
-				if ref.payment_request:
+				if ref.payment_request or not (ref.reference_doctype and ref.reference_name):
 					continue
 
 				key = (ref.reference_doctype, ref.reference_name, ref.get("payment_term"))
@@ -2928,6 +2941,8 @@ def get_payment_entry(
 		party_account_currency if payment_type == "Receive" else bank.account_currency
 	)
 	pe.paid_to_account_currency = party_account_currency if payment_type == "Pay" else bank.account_currency
+	pe.paid_from_account_type = frappe.db.get_value("Account", pe.paid_from, "account_type")
+	pe.paid_to_account_type = frappe.db.get_value("Account", pe.paid_to, "account_type")
 	pe.paid_amount = paid_amount
 	pe.received_amount = received_amount
 	pe.letter_head = doc.get("letter_head")
@@ -3287,26 +3302,25 @@ def set_paid_amount_and_received_amount(
 	if party_account_currency == bank.account_currency:
 		paid_amount = received_amount = abs(outstanding_amount)
 	else:
-		company_currency = frappe.get_cached_value("Company", doc.get("company"), "default_currency")
-		if payment_type == "Receive":
-			paid_amount = abs(outstanding_amount)
-			if bank_amount:
-				received_amount = bank_amount
-			else:
-				if bank and company_currency != bank.account_currency:
-					received_amount = paid_amount / doc.get("conversion_rate", 1)
-				else:
-					received_amount = paid_amount * doc.get("conversion_rate", 1)
+		# settings if it is for receive
+		paid_amount = abs(outstanding_amount)
+		if bank_amount:
+			received_amount = bank_amount
 		else:
-			received_amount = abs(outstanding_amount)
-			if bank_amount:
-				paid_amount = bank_amount
+			company_currency = frappe.get_cached_value("Company", doc.get("company"), "default_currency")
+			if bank and company_currency != bank.account_currency:
+				# doc currency can be different from bank currency
+				posting_date = doc.get("posting_date") or doc.get("transaction_date")
+				conversion_rate = get_exchange_rate(
+					bank.account_currency, party_account_currency, posting_date
+				)
+				received_amount = paid_amount / conversion_rate
 			else:
-				if bank and company_currency != bank.account_currency:
-					paid_amount = received_amount / doc.get("conversion_rate", 1)
-				else:
-					# if party account currency and bank currency is different then populate paid amount as well
-					paid_amount = received_amount * doc.get("conversion_rate", 1)
+				received_amount = paid_amount * doc.get("conversion_rate", 1)
+
+		# if payment type is pay, then paid amount and received amount are swapped
+		if payment_type == "Pay":
+			paid_amount, received_amount = received_amount, paid_amount
 
 	return paid_amount, received_amount
 

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -49,6 +49,8 @@ class TestPaymentEntry(FrappeTestCase):
 		pe.insert()
 		pe.submit()
 
+		self.assertEqual(pe.paid_to_account_type, "Cash")
+
 		expected_gle = dict(
 			(d[0], d) for d in [["Debtors - _TC", 0, 1000, so.name], ["_Test Cash - _TC", 1000.0, 0, None]]
 		)
@@ -560,6 +562,8 @@ class TestPaymentEntry(FrappeTestCase):
 		pe.insert()
 		pe.submit()
 
+		self.assertEqual(pe.paid_from_account_type, "Bank")
+
 		outstanding_amount, status = frappe.db.get_value(
 			"Purchase Invoice", pi.name, ["outstanding_amount", "status"]
 		)

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -1,9 +1,9 @@
 import json
 
 import frappe
-from frappe import _, qb
+from frappe import _
 from frappe.model.document import Document
-from frappe.query_builder.functions import Abs, Sum
+from frappe.query_builder.functions import Sum
 from frappe.utils import flt, nowdate
 from frappe.utils.background_jobs import enqueue
 
@@ -12,7 +12,6 @@ from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
 )
 from erpnext.accounts.doctype.payment_entry.payment_entry import (
-	get_company_defaults,
 	get_payment_entry,
 )
 from erpnext.accounts.doctype.subscription_plan.subscription_plan import get_plan_rate
@@ -120,13 +119,13 @@ class PaymentRequest(Document):
 				title=_("Invalid Amount"),
 			)
 
-		existing_payment_request_amount = flt(
-			get_existing_payment_request_amount(self.reference_doctype, self.reference_name)
-		)
-
 		ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
 		if not hasattr(ref_doc, "order_type") or ref_doc.order_type != "Shopping Cart":
 			ref_amount = get_amount(ref_doc, self.payment_account)
+			if not ref_amount:
+				frappe.throw(_("Payment Entry is already created"))
+
+			existing_payment_request_amount = flt(get_existing_payment_request_amount(ref_doc))
 
 			if existing_payment_request_amount + flt(self.grand_total) > ref_amount:
 				frappe.throw(
@@ -544,6 +543,8 @@ def make_payment_request(**args):
 	gateway_account = get_gateway_details(args) or frappe._dict()
 
 	grand_total = get_amount(ref_doc, gateway_account.get("payment_account"))
+	if not grand_total:
+		frappe.throw(_("Payment Entry is already created"))
 	if args.loyalty_points and args.dt == "Sales Order":
 		from erpnext.accounts.doctype.loyalty_program.loyalty_program import validate_loyalty_points
 
@@ -554,19 +555,8 @@ def make_payment_request(**args):
 		frappe.db.set_value("Sales Order", args.dn, "loyalty_amount", loyalty_amount, update_modified=False)
 		grand_total = grand_total - loyalty_amount
 
-	bank_account = (
-		get_party_bank_account(args.get("party_type"), args.get("party")) if args.get("party_type") else ""
-	)
-
-	draft_payment_request = frappe.db.get_value(
-		"Payment Request",
-		{"reference_doctype": args.dt, "reference_name": args.dn, "docstatus": 0},
-	)
-
 	# fetches existing payment request `grand_total` amount
-	existing_payment_request_amount = get_existing_payment_request_amount(ref_doc.doctype, ref_doc.name)
-
-	existing_paid_amount = get_existing_paid_amount(ref_doc.doctype, ref_doc.name)
+	existing_payment_request_amount = get_existing_payment_request_amount(ref_doc)
 
 	def validate_and_calculate_grand_total(grand_total, existing_payment_request_amount):
 		grand_total -= existing_payment_request_amount
@@ -578,7 +568,7 @@ def make_payment_request(**args):
 		if args.order_type == "Shopping Cart":
 			# If Payment Request is in an advanced stage, then create for remaining amount.
 			if get_existing_payment_request_amount(
-				ref_doc.doctype, ref_doc.name, ["Initiated", "Partially Paid", "Payment Ordered", "Paid"]
+				ref_doc, ["Initiated", "Partially Paid", "Payment Ordered", "Paid"]
 			):
 				grand_total = validate_and_calculate_grand_total(grand_total, existing_payment_request_amount)
 			else:
@@ -587,14 +577,10 @@ def make_payment_request(**args):
 		else:
 			grand_total = validate_and_calculate_grand_total(grand_total, existing_payment_request_amount)
 
-	if existing_paid_amount:
-		if ref_doc.party_account_currency == ref_doc.currency:
-			if ref_doc.conversion_rate:
-				grand_total -= flt(existing_paid_amount / ref_doc.conversion_rate)
-			else:
-				grand_total -= flt(existing_paid_amount)
-		else:
-			grand_total -= flt(existing_paid_amount / ref_doc.conversion_rate)
+	draft_payment_request = frappe.db.get_value(
+		"Payment Request",
+		{"reference_doctype": ref_doc.doctype, "reference_name": ref_doc.name, "docstatus": 0},
+	)
 
 	if draft_payment_request:
 		frappe.db.set_value(
@@ -602,6 +588,11 @@ def make_payment_request(**args):
 		)
 		pr = frappe.get_doc("Payment Request", draft_payment_request)
 	else:
+		bank_account = (
+			get_party_bank_account(args.get("party_type"), args.get("party"))
+			if args.get("party_type")
+			else ""
+		)
 		pr = frappe.new_doc("Payment Request")
 
 		if not args.get("payment_request_type"):
@@ -675,22 +666,40 @@ def make_payment_request(**args):
 
 def get_amount(ref_doc, payment_account=None):
 	"""get amount based on doctype"""
+	grand_total = 0
+
 	dt = ref_doc.doctype
 	if dt in ["Sales Order", "Purchase Order"]:
-		grand_total = flt(ref_doc.rounded_total) or flt(ref_doc.grand_total)
+		advance_amount = flt(ref_doc.advance_paid)
+		if ref_doc.party_account_currency != ref_doc.currency:
+			advance_amount = flt(flt(ref_doc.advance_paid) / ref_doc.conversion_rate)
+
+		grand_total = (flt(ref_doc.rounded_total) or flt(ref_doc.grand_total)) - advance_amount
+
 	elif dt in ["Sales Invoice", "Purchase Invoice"]:
-		if not ref_doc.get("is_pos"):
+		if (
+			dt == "Sales Invoice"
+			and ref_doc.is_pos
+			and ref_doc.payments
+			and any(
+				[
+					payment.type == "Phone" and payment.account == payment_account
+					for payment in ref_doc.payments
+				]
+			)
+		):
+			grand_total = sum(
+				[
+					payment.amount
+					for payment in ref_doc.payments
+					if payment.type == "Phone" and payment.account == payment_account
+				]
+			)
+		else:
 			if ref_doc.party_account_currency == ref_doc.currency:
-				grand_total = flt(ref_doc.rounded_total or ref_doc.grand_total)
+				grand_total = flt(ref_doc.outstanding_amount)
 			else:
-				grand_total = flt(
-					flt(ref_doc.base_rounded_total or ref_doc.base_grand_total) / ref_doc.conversion_rate
-				)
-		elif dt == "Sales Invoice":
-			for pay in ref_doc.payments:
-				if pay.type == "Phone" and pay.account == payment_account:
-					grand_total = pay.amount
-					break
+				grand_total = flt(flt(ref_doc.outstanding_amount) / ref_doc.conversion_rate)
 	elif dt == "POS Invoice":
 		for pay in ref_doc.payments:
 			if pay.type == "Phone" and pay.account == payment_account:
@@ -699,10 +708,7 @@ def get_amount(ref_doc, payment_account=None):
 	elif dt == "Fees":
 		grand_total = ref_doc.outstanding_amount
 
-	if grand_total > 0:
-		return flt(grand_total, get_currency_precision())
-	else:
-		frappe.throw(_("Payment Entry is already created"))
+	return flt(grand_total, get_currency_precision()) if grand_total > 0 else 0
 
 
 def get_irequest_status(payment_requests: None | list = None) -> list:
@@ -745,7 +751,7 @@ def cancel_old_payment_requests(ref_dt, ref_dn):
 						frappe.db.set_value("Integration Request", ireq.name, "status", "Cancelled")
 
 
-def get_existing_payment_request_amount(ref_dt, ref_dn, statuses: list | None = None) -> list:
+def get_existing_payment_request_amount(ref_doc, statuses: list | None = None) -> list:
 	"""
 	Return the total amount of Payment Requests against a reference document.
 	"""
@@ -753,9 +759,9 @@ def get_existing_payment_request_amount(ref_dt, ref_dn, statuses: list | None =
 
 	query = (
 		frappe.qb.from_(PR)
-		.select(Sum(PR.grand_total))
-		.where(PR.reference_doctype == ref_dt)
-		.where(PR.reference_name == ref_dn)
+		.select(Sum(PR.outstanding_amount))
+		.where(PR.reference_doctype == ref_doc.doctype)
+		.where(PR.reference_name == ref_doc.name)
 		.where(PR.docstatus == 1)
 	)
 
@@ -764,43 +770,12 @@ def get_existing_payment_request_amount(ref_dt, ref_dn, statuses: list | None =
 
 	response = query.run()
 
-	return response[0][0] if response[0] else 0
+	os_amount_in_transaction_currency = flt(response[0][0] if response[0] else 0)
 
+	if ref_doc.currency != ref_doc.party_account_currency:
+		os_amount_in_transaction_currency = flt(os_amount_in_transaction_currency / ref_doc.conversion_rate)
 
-def get_existing_paid_amount(doctype, name):
-	PLE = frappe.qb.DocType("Payment Ledger Entry")
-	PER = frappe.qb.DocType("Payment Entry Reference")
-
-	query = (
-		frappe.qb.from_(PLE)
-		.left_join(PER)
-		.on(
-			(PLE.against_voucher_type == PER.reference_doctype)
-			& (PLE.against_voucher_no == PER.reference_name)
-			& (PLE.voucher_type == PER.parenttype)
-			& (PLE.voucher_no == PER.parent)
-		)
-		.select(
-			Abs(Sum(PLE.amount)).as_("total_amount"),
-			Abs(Sum(frappe.qb.terms.Case().when(PER.payment_request.isnotnull(), PLE.amount).else_(0))).as_(
-				"request_paid_amount"
-			),
-		)
-		.where(
-			(PLE.voucher_type.isin([doctype, "Journal Entry", "Payment Entry"]))
-			& (PLE.against_voucher_type == doctype)
-			& (PLE.against_voucher_no == name)
-			& (PLE.delinked == 0)
-			& (PLE.docstatus == 1)
-			& (PLE.amount < 0)
-		)
-	)
-
-	result = query.run()
-	ledger_amount = flt(result[0][0]) if result else 0
-	request_paid_amount = flt(result[0][1]) if result else 0
-
-	return ledger_amount - request_paid_amount
+	return os_amount_in_transaction_currency
 
 
 def get_gateway_details(args):  # nosemgrep

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -313,6 +313,16 @@ class TestPaymentRequest(FrappeTestCase):
 		self.assertEqual(pr.outstanding_amount, 800)
 		self.assertEqual(pr.grand_total, 1000)
 
+		self.assertRaisesRegex(
+			frappe.exceptions.ValidationError,
+			re.compile(r"Payment Request is already created"),
+			make_payment_request,
+			dt="Sales Order",
+			dn=so.name,
+			mute_email=1,
+			submit_doc=1,
+			return_doc=1,
+		)
 		# complete payment
 		pe = pr.create_payment_entry()
 
@@ -331,7 +341,7 @@ class TestPaymentRequest(FrappeTestCase):
 		# creating a more payment Request must not allowed
 		self.assertRaisesRegex(
 			frappe.exceptions.ValidationError,
-			re.compile(r"Payment Request is already created"),
+			re.compile(r"Payment Entry is already created"),
 			make_payment_request,
 			dt="Sales Order",
 			dn=so.name,
@@ -361,6 +371,17 @@ class TestPaymentRequest(FrappeTestCase):
 		self.assertEqual(pr.party_account_currency, "INR")
 		self.assertEqual(pr.status, "Initiated")
 
+		self.assertRaisesRegex(
+			frappe.exceptions.ValidationError,
+			re.compile(r"Payment Request is already created"),
+			make_payment_request,
+			dt="Purchase Invoice",
+			dn=pi.name,
+			mute_email=1,
+			submit_doc=1,
+			return_doc=1,
+		)
+
 		# to make partial payment
 		pe = pr.create_payment_entry(submit=False)
 		pe.paid_amount = 2000
@@ -389,7 +410,7 @@ class TestPaymentRequest(FrappeTestCase):
 		# creating a more payment Request must not allowed
 		self.assertRaisesRegex(
 			frappe.exceptions.ValidationError,
-			re.compile(r"Payment Request is already created"),
+			re.compile(r"Payment Entry is already created"),
 			make_payment_request,
 			dt="Purchase Invoice",
 			dn=pi.name,

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.js

@@ -47,7 +47,7 @@ frappe.ui.form.on("Period Closing Voucher", {
 						from_date: frm.doc.posting_date,
 						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
 						company: frm.doc.company,
-						group_by: "",
+						categorize_by: "",
 						show_cancelled_entries: frm.doc.docstatus === 2,
 					};
 					frappe.set_route("query-report", "General Ledger");

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.py

@@ -124,6 +124,11 @@ class POSClosingEntry(StatusUpdater):
 
 	def on_submit(self):
 		consolidate_pos_invoices(closing_entry=self)
+		frappe.publish_realtime(
+			f"poe_{self.pos_opening_entry}_closed",
+			self,
+			docname=f"POS Opening Entry/{self.pos_opening_entry}",
+		)
 
 	def on_cancel(self):
 		unconsolidate_pos_invoices(closing_entry=self)

erpnext/accounts/doctype/pos_invoice/pos_invoice.js

@@ -323,3 +323,15 @@ frappe.ui.form.on("POS Invoice", {
 		});
 	},
 });
+
+frappe.ui.form.on("Sales Invoice Payment", {
+	mode_of_payment: function (frm) {
+		frappe.call({
+			doc: frm.doc,
+			method: "set_account_for_mode_of_payment",
+			callback: function (r) {
+				refresh_field("payments");
+			},
+		});
+	},
+});

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -196,6 +196,7 @@ class POSInvoice(SalesInvoice):
 
 		# run on validate method of selling controller
 		super(SalesInvoice, self).validate()
+		self.validate_pos_opening_entry()
 		self.validate_auto_set_posting_time()
 		self.validate_mode_of_payment()
 		self.validate_uom_is_integer("stock_uom", "stock_qty")
@@ -320,6 +321,18 @@ class POSInvoice(SalesInvoice):
 						_("Payment related to {0} is not completed").format(pay.mode_of_payment)
 					)
 
+	def validate_pos_opening_entry(self):
+		opening_entries = frappe.get_list(
+			"POS Opening Entry", filters={"pos_profile": self.pos_profile, "status": "Open", "docstatus": 1}
+		)
+		if len(opening_entries) == 0:
+			frappe.throw(
+				title=_("POS Opening Entry Missing"),
+				msg=_("No open POS Opening Entry found for POS Profile {0}.").format(
+					frappe.bold(self.pos_profile)
+				),
+			)
+
 	def validate_stock_availablility(self):
 		if self.is_return:
 			return
@@ -484,8 +497,11 @@ class POSInvoice(SalesInvoice):
 
 	def validate_full_payment(self):
 		invoice_total = flt(self.rounded_total) or flt(self.grand_total)
+		is_partial_payment_allowed = frappe.db.get_value(
+			"POS Profile", self.pos_profile, "allow_partial_payment"
+		)
 
-		if self.docstatus == 1:
+		if self.docstatus == 1 and not is_partial_payment_allowed:
 			if self.is_return and self.paid_amount != invoice_total:
 				frappe.throw(
 					msg=_("Partial Payment in POS Invoice is not allowed."), exc=PartialPaymentValidationError

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -7,6 +7,9 @@ import unittest
 import frappe
 from frappe import _
 
+from erpnext.accounts.doctype.mode_of_payment.test_mode_of_payment import (
+	set_default_account_for_mode_of_payment,
+)
 from erpnext.accounts.doctype.pos_invoice.pos_invoice import PartialPaymentValidationError, make_sales_return
 from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
@@ -26,6 +29,14 @@ class TestPOSInvoice(unittest.TestCase):
 		make_stock_entry(target="_Test Warehouse - _TC", item_code="_Test Item", qty=800, basic_rate=100)
 		frappe.db.sql("delete from `tabTax Rule`")
 
+		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import init_user_and_profile
+		from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
+
+		cls.test_user, cls.pos_profile = init_user_and_profile()
+		create_opening_entry(cls.pos_profile, cls.test_user)
+		mode_of_payment = frappe.get_doc("Mode of Payment", "Bank Draft")
+		set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", "_Test Bank - _TC")
+
 	def tearDown(self):
 		if frappe.session.user != "Administrator":
 			frappe.set_user("Administrator")
@@ -227,12 +238,8 @@ class TestPOSInvoice(unittest.TestCase):
 		pos = create_pos_invoice(qty=10, do_not_save=True)
 
 		pos.set("payments", [])
-		pos.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - _TC", "amount": 500}
-		)
-		pos.append(
-			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 500, "default": 1}
-		)
+		pos.append("payments", {"mode_of_payment": "Bank Draft", "amount": 500})
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 500, "default": 1})
 		pos.insert()
 		pos.submit()
 
@@ -270,9 +277,7 @@ class TestPOSInvoice(unittest.TestCase):
 			do_not_save=1,
 		)
 
-		pos.append(
-			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1000, "default": 1}
-		)
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 1000, "default": 1})
 
 		pos.insert()
 		pos.submit()
@@ -312,9 +317,7 @@ class TestPOSInvoice(unittest.TestCase):
 			do_not_save=1,
 		)
 
-		pos.append(
-			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2000, "default": 1}
-		)
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 2000, "default": 1})
 
 		pos.insert()
 		pos.submit()
@@ -325,9 +328,7 @@ class TestPOSInvoice(unittest.TestCase):
 		# partial return 1
 		pos_return1.get("items")[0].qty = -1
 		pos_return1.set("payments", [])
-		pos_return1.append(
-			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": -1000, "default": 1}
-		)
+		pos_return1.append("payments", {"mode_of_payment": "Cash", "amount": -1000, "default": 1})
 		pos_return1.paid_amount = -1000
 		pos_return1.submit()
 		pos_return1.reload()
@@ -344,9 +345,7 @@ class TestPOSInvoice(unittest.TestCase):
 		# partial return 2
 		pos_return2 = make_sales_return(pos.name)
 		pos_return2.set("payments", [])
-		pos_return2.append(
-			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": -1000, "default": 1}
-		)
+		pos_return2.append("payments", {"mode_of_payment": "Cash", "amount": -1000, "default": 1})
 		pos_return2.paid_amount = -1000
 		pos_return2.submit()
 
@@ -366,10 +365,8 @@ class TestPOSInvoice(unittest.TestCase):
 		)
 
 		pos.set("payments", [])
-		pos.append("payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - _TC", "amount": 50})
-		pos.append(
-			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 60, "default": 1}
-		)
+		pos.append("payments", {"mode_of_payment": "Bank Draft", "amount": 50})
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 60, "default": 1})
 
 		pos.insert()
 		pos.submit()
@@ -387,7 +384,7 @@ class TestPOSInvoice(unittest.TestCase):
 		pos_inv = create_pos_invoice(rate=10000, do_not_save=1)
 		pos_inv.append(
 			"payments",
-			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 9000},
+			{"mode_of_payment": "Cash", "amount": 9000},
 		)
 		pos_inv.insert()
 		self.assertRaises(PartialPaymentValidationError, pos_inv.submit)
@@ -418,9 +415,7 @@ class TestPOSInvoice(unittest.TestCase):
 			do_not_save=1,
 		)
 
-		pos.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - _TC", "amount": 1000}
-		)
+		pos.append("payments", {"mode_of_payment": "Bank Draft", "amount": 1000})
 
 		pos.insert()
 		pos.submit()
@@ -439,9 +434,7 @@ class TestPOSInvoice(unittest.TestCase):
 			do_not_save=1,
 		)
 
-		pos2.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - _TC", "amount": 1000}
-		)
+		pos2.append("payments", {"mode_of_payment": "Bank Draft", "amount": 1000})
 
 		pos2.insert()
 		self.assertRaises(frappe.ValidationError, pos2.submit)
@@ -490,9 +483,7 @@ class TestPOSInvoice(unittest.TestCase):
 			do_not_save=1,
 		)
 
-		pos2.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - _TC", "amount": 1000}
-		)
+		pos2.append("payments", {"mode_of_payment": "Bank Draft", "amount": 1000})
 
 		pos2.insert()
 		self.assertRaises(frappe.ValidationError, pos2.submit)
@@ -555,9 +546,7 @@ class TestPOSInvoice(unittest.TestCase):
 		)
 		pos.get("items")[0].has_serial_no = 1
 		pos.set("payments", [])
-		pos.append(
-			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1000, "default": 1}
-		)
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 1000, "default": 1})
 		pos = pos.save().submit()
 
 		# make a return
@@ -603,7 +592,7 @@ class TestPOSInvoice(unittest.TestCase):
 		inv = create_pos_invoice(customer="Test Loyalty Customer", rate=10000, do_not_save=1)
 		inv.append(
 			"payments",
-			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 10000},
+			{"mode_of_payment": "Cash", "amount": 10000},
 		)
 		inv.insert()
 		inv.submit()
@@ -635,7 +624,7 @@ class TestPOSInvoice(unittest.TestCase):
 		pos_inv = create_pos_invoice(customer="Test Loyalty Customer", rate=10000, do_not_save=1)
 		pos_inv.append(
 			"payments",
-			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 10000},
+			{"mode_of_payment": "Cash", "amount": 10000},
 		)
 		pos_inv.paid_amount = 10000
 		pos_inv.submit()
@@ -650,7 +639,7 @@ class TestPOSInvoice(unittest.TestCase):
 		inv.loyalty_amount = inv.loyalty_points * before_lp_details.conversion_factor
 		inv.append(
 			"payments",
-			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 10000 - inv.loyalty_amount},
+			{"mode_of_payment": "Cash", "amount": 10000 - inv.loyalty_amount},
 		)
 		inv.paid_amount = 10000
 		inv.submit()
@@ -671,12 +660,12 @@ class TestPOSInvoice(unittest.TestCase):
 		frappe.db.sql("delete from `tabPOS Invoice`")
 		test_user, pos_profile = init_user_and_profile()
 		pos_inv = create_pos_invoice(rate=300, additional_discount_percentage=10, do_not_submit=1)
-		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 270})
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "amount": 270})
 		pos_inv.save()
 		pos_inv.submit()
 
 		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
-		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+		pos_inv2.append("payments", {"mode_of_payment": "Cash", "amount": 3200})
 		pos_inv2.save()
 		pos_inv2.submit()
 
@@ -697,7 +686,7 @@ class TestPOSInvoice(unittest.TestCase):
 		frappe.db.sql("delete from `tabPOS Invoice`")
 		test_user, pos_profile = init_user_and_profile()
 		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
-		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "amount": 300})
 		pos_inv.append(
 			"taxes",
 			{
@@ -714,7 +703,7 @@ class TestPOSInvoice(unittest.TestCase):
 
 		pos_inv2 = create_pos_invoice(rate=300, qty=2, do_not_submit=1)
 		pos_inv2.additional_discount_percentage = 10
-		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 540})
+		pos_inv2.append("payments", {"mode_of_payment": "Cash", "amount": 540})
 		pos_inv2.append(
 			"taxes",
 			{
@@ -752,7 +741,7 @@ class TestPOSInvoice(unittest.TestCase):
 		frappe.db.sql("delete from `tabPOS Invoice`")
 		test_user, pos_profile = init_user_and_profile()
 		pos_inv = create_pos_invoice(item=item, rate=300, do_not_submit=1)
-		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "amount": 300})
 		pos_inv.append(
 			"taxes",
 			{
@@ -767,7 +756,7 @@ class TestPOSInvoice(unittest.TestCase):
 		self.assertRaises(frappe.ValidationError, pos_inv.submit)
 
 		pos_inv2 = create_pos_invoice(item=item, rate=400, do_not_submit=1)
-		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 400})
+		pos_inv2.append("payments", {"mode_of_payment": "Cash", "amount": 400})
 		pos_inv2.append(
 			"taxes",
 			{
@@ -812,7 +801,7 @@ class TestPOSInvoice(unittest.TestCase):
 		pos_inv1 = create_pos_invoice(item="_BATCH ITEM Test For Reserve", rate=300, qty=15, do_not_save=1)
 		pos_inv1.append(
 			"payments",
-			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 4500},
+			{"mode_of_payment": "Cash", "amount": 4500},
 		)
 		pos_inv1.items[0].batch_no = batch_no
 		pos_inv1.save()
@@ -833,7 +822,7 @@ class TestPOSInvoice(unittest.TestCase):
 		)
 		pos_inv2.append(
 			"payments",
-			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3000},
+			{"mode_of_payment": "Cash", "amount": 3000},
 		)
 		pos_inv2.save()
 		pos_inv2.submit()
@@ -873,7 +862,7 @@ class TestPOSInvoice(unittest.TestCase):
 		)
 		pos_inv1.append(
 			"payments",
-			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300},
+			{"mode_of_payment": "Cash", "amount": 300},
 		)
 		pos_inv1.save()
 		pos_inv1.submit()

erpnext/accounts/doctype/pos_invoice_item/pos_invoice_item.json

@@ -37,6 +37,7 @@
   "column_break_19",
   "discount_percentage",
   "discount_amount",
+  "distributed_discount_amount",
   "base_rate_with_margin",
   "section_break1",
   "rate",
@@ -847,11 +848,17 @@
   {
    "fieldname": "column_break_ciit",
    "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "distributed_discount_amount",
+   "fieldtype": "Currency",
+   "label": "Distributed Discount Amount",
+   "options": "currency"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2024-05-07 15:56:53.343317",
+ "modified": "2024-05-07 15:56:54.343317",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice Item",

erpnext/accounts/doctype/pos_invoice_item/pos_invoice_item.py

@@ -39,6 +39,7 @@ class POSInvoiceItem(Document):
 		description: DF.TextEditor
 		discount_amount: DF.Currency
 		discount_percentage: DF.Percent
+		distributed_discount_amount: DF.Currency
 		dn_detail: DF.Data | None
 		enable_deferred_revenue: DF.Check
 		expense_account: DF.Link | None

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -2,6 +2,7 @@
 # For license information, please see license.txt
 
 
+import hashlib
 import json
 
 import frappe
@@ -302,10 +303,17 @@ class POSInvoiceMergeLog(Document):
 		accounting_dimensions = get_checks_for_pl_and_bs_accounts()
 		accounting_dimensions_fields = [d.fieldname for d in accounting_dimensions]
 		dimension_values = frappe.db.get_value(
-			"POS Profile", {"name": invoice.pos_profile}, accounting_dimensions_fields, as_dict=1
+			"POS Profile",
+			{"name": invoice.pos_profile},
+			[*accounting_dimensions_fields, "cost_center", "project"],
+			as_dict=1,
 		)
 		for dimension in accounting_dimensions:
-			dimension_value = dimension_values.get(dimension.fieldname)
+			dimension_value = (
+				data[0].get(dimension.fieldname)
+				if data[0].get(dimension.fieldname)
+				else dimension_values.get(dimension.fieldname)
+			)
 
 			if not dimension_value and (dimension.mandatory_for_pl or dimension.mandatory_for_bs):
 				frappe.throw(
@@ -317,6 +325,14 @@ class POSInvoiceMergeLog(Document):
 
 			invoice.set(dimension.fieldname, dimension_value)
 
+		invoice.set(
+			"cost_center",
+			data[0].get("cost_center") if data[0].get("cost_center") else dimension_values.get("cost_center"),
+		)
+		invoice.set(
+			"project", data[0].get("project") if data[0].get("project") else dimension_values.get("project")
+		)
+
 		if self.merge_invoices_based_on == "Customer Group":
 			invoice.flags.ignore_pos_profile = True
 			invoice.pos_profile = ""
@@ -336,7 +352,7 @@ class POSInvoiceMergeLog(Document):
 		for doc in invoice_docs:
 			doc.load_from_db()
 			inv = sales_invoice
-			if doc.is_return:
+			if doc.is_return and credit_notes:
 				for key, value in credit_notes.items():
 					if doc.name in value:
 						inv = key
@@ -446,9 +462,34 @@ def get_invoice_customer_map(pos_invoices):
 		pos_invoice_customer_map.setdefault(customer, [])
 		pos_invoice_customer_map[customer].append(invoice)
 
+	for customer, invoices in pos_invoice_customer_map.items():
+		pos_invoice_customer_map[customer] = split_invoices_by_accounting_dimension(invoices)
+
 	return pos_invoice_customer_map
 
 
+def split_invoices_by_accounting_dimension(pos_invoices):
+	# pos_invoices = {
+	# 	{'dim_field1': 'dim_field1_value1', 'dim_field2': 'dim_field2_value1'}: [],
+	# 	{'dim_field1': 'dim_field1_value2', 'dim_field2': 'dim_field2_value1'}: []
+	# }
+	pos_invoice_accounting_dimensions_map = {}
+	for invoice in pos_invoices:
+		dimension_fields = [d.fieldname for d in get_checks_for_pl_and_bs_accounts()]
+		accounting_dimensions = frappe.db.get_value(
+			"POS Invoice", invoice.pos_invoice, [*dimension_fields, "cost_center", "project"], as_dict=1
+		)
+
+		accounting_dimensions_dic_hash = hashlib.sha256(
+			json.dumps(accounting_dimensions).encode()
+		).hexdigest()
+
+		pos_invoice_accounting_dimensions_map.setdefault(accounting_dimensions_dic_hash, [])
+		pos_invoice_accounting_dimensions_map[accounting_dimensions_dic_hash].append(invoice)
+
+	return pos_invoice_accounting_dimensions_map
+
+
 def consolidate_pos_invoices(pos_invoices=None, closing_entry=None):
 	invoices = pos_invoices or (closing_entry and closing_entry.get("pos_transactions"))
 	if frappe.flags.in_test and not invoices:
@@ -532,20 +573,21 @@ def split_invoices(invoices):
 
 def create_merge_logs(invoice_by_customer, closing_entry=None):
 	try:
-		for customer, invoices in invoice_by_customer.items():
-			for _invoices in split_invoices(invoices):
-				merge_log = frappe.new_doc("POS Invoice Merge Log")
-				merge_log.posting_date = (
-					getdate(closing_entry.get("posting_date")) if closing_entry else nowdate()
-				)
-				merge_log.posting_time = (
-					get_time(closing_entry.get("posting_time")) if closing_entry else nowtime()
-				)
-				merge_log.customer = customer
-				merge_log.pos_closing_entry = closing_entry.get("name") if closing_entry else None
-				merge_log.set("pos_invoices", _invoices)
-				merge_log.save(ignore_permissions=True)
-				merge_log.submit()
+		for customer, invoices_acc_dim in invoice_by_customer.items():
+			for invoices in invoices_acc_dim.values():
+				for _invoices in split_invoices(invoices):
+					merge_log = frappe.new_doc("POS Invoice Merge Log")
+					merge_log.posting_date = (
+						getdate(closing_entry.get("posting_date")) if closing_entry else nowdate()
+					)
+					merge_log.posting_time = (
+						get_time(closing_entry.get("posting_time")) if closing_entry else nowtime()
+					)
+					merge_log.customer = customer
+					merge_log.pos_closing_entry = closing_entry.get("name") if closing_entry else None
+					merge_log.set("pos_invoices", _invoices)
+					merge_log.save(ignore_permissions=True)
+					merge_log.submit()
 		if closing_entry:
 			closing_entry.set_status(update=True, status="Submitted")
 			closing_entry.db_set("error_message", "")

erpnext/accounts/doctype/pos_invoice_merge_log/test_pos_invoice_merge_log.py

@@ -455,3 +455,58 @@ class TestPOSInvoiceMergeLog(unittest.TestCase):
 			frappe.set_user("Administrator")
 			frappe.db.sql("delete from `tabPOS Profile`")
 			frappe.db.sql("delete from `tabPOS Invoice`")
+
+	def test_separate_consolidated_invoice_for_different_accounting_dimensions(self):
+		"""
+		Creating 3 POS Invoices where first POS Invoice has different Cost Center than the other two.
+		Consolidate the Invoices.
+		Check whether the first POS Invoice is consolidated with a separate Sales Invoice than the other two.
+		Check whether the second and third POS Invoice are consolidated with the same Sales Invoice.
+		"""
+		from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
+
+		frappe.db.sql("delete from `tabPOS Invoice`")
+
+		create_cost_center(cost_center_name="_Test POS Cost Center 1", is_group=0)
+		create_cost_center(cost_center_name="_Test POS Cost Center 2", is_group=0)
+
+		try:
+			test_user, pos_profile = init_user_and_profile()
+
+			pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
+			pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
+			pos_inv.cost_center = "_Test POS Cost Center 1 - _TC"
+			pos_inv.save()
+			pos_inv.submit()
+
+			pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
+			pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+			pos_inv.cost_center = "_Test POS Cost Center 2 - _TC"
+			pos_inv2.save()
+			pos_inv2.submit()
+
+			pos_inv3 = create_pos_invoice(rate=2300, do_not_submit=1)
+			pos_inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2300})
+			pos_inv.cost_center = "_Test POS Cost Center 2 - _TC"
+			pos_inv3.save()
+			pos_inv3.submit()
+
+			consolidate_pos_invoices()
+
+			pos_inv.load_from_db()
+			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv.consolidated_invoice))
+
+			pos_inv2.load_from_db()
+			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv2.consolidated_invoice))
+
+			self.assertFalse(pos_inv.consolidated_invoice == pos_inv3.consolidated_invoice)
+
+			pos_inv3.load_from_db()
+			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv3.consolidated_invoice))
+
+			self.assertTrue(pos_inv2.consolidated_invoice == pos_inv3.consolidated_invoice)
+
+		finally:
+			frappe.set_user("Administrator")
+			frappe.db.sql("delete from `tabPOS Profile`")
+			frappe.db.sql("delete from `tabPOS Invoice`")

erpnext/accounts/doctype/pos_opening_entry/pos_opening_entry.py

@@ -70,3 +70,6 @@ class POSOpeningEntry(StatusUpdater):
 
 	def on_submit(self):
 		self.set_status(update=True)
+
+	def on_cancel(self):
+		self.set_status(update=True)

erpnext/accounts/doctype/pos_profile/pos_profile.json

@@ -30,6 +30,7 @@
   "allow_rate_change",
   "allow_discount_change",
   "disable_grand_total_to_default_mop",
+  "allow_partial_payment",
   "section_break_23",
   "item_groups",
   "column_break_25",
@@ -56,7 +57,8 @@
   "apply_discount_on",
   "accounting_dimensions_section",
   "cost_center",
-  "dimension_col_break"
+  "dimension_col_break",
+  "project"
  ],
  "fields": [
   {
@@ -389,6 +391,20 @@
    "fieldname": "disable_grand_total_to_default_mop",
    "fieldtype": "Check",
    "label": "Disable auto setting Grand Total to default Payment Mode"
+  },
+  {
+   "fieldname": "project",
+   "fieldtype": "Link",
+   "label": "Project",
+   "oldfieldname": "cost_center",
+   "oldfieldtype": "Link",
+   "options": "Project"
+  },
+  {
+   "default": "0",
+   "fieldname": "allow_partial_payment",
+   "fieldtype": "Check",
+   "label": "Allow Partial Payment"
   }
  ],
  "icon": "icon-cog",
@@ -416,7 +432,7 @@
    "link_fieldname": "pos_profile"
   }
  ],
- "modified": "2025-01-29 13:12:30.796630",
+ "modified": "2025-04-14 15:58:20.497426",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Profile",
@@ -442,7 +458,8 @@
    "role": "Accounts User"
   }
  ],
- "sort_field": "modified",
+ "row_format": "Dynamic",
+ "sort_field": "creation",
  "sort_order": "DESC",
  "states": []
 }

erpnext/accounts/doctype/pos_profile/pos_profile.py

@@ -29,6 +29,7 @@ class POSProfile(Document):
 
 		account_for_change_amount: DF.Link | None
 		allow_discount_change: DF.Check
+		allow_partial_payment: DF.Check
 		allow_rate_change: DF.Check
 		applicable_for_users: DF.Table[POSProfileUser]
 		apply_discount_on: DF.Literal["Grand Total", "Net Total"]
@@ -54,6 +55,7 @@ class POSProfile(Document):
 		payments: DF.Table[POSPaymentMethod]
 		print_format: DF.Link | None
 		print_receipt_on_order_complete: DF.Check
+		project: DF.Link | None
 		select_print_heading: DF.Link | None
 		selling_price_list: DF.Link | None
 		tax_category: DF.Link | None

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -12,7 +12,7 @@
   "posting_date",
   "company",
   "account",
-  "group_by",
+  "categorize_by",
   "cost_center",
   "territory",
   "ignore_exchange_rate_revaluation_journals",
@@ -174,14 +174,6 @@
    "fieldtype": "Date",
    "label": "Start Date"
   },
-  {
-   "default": "Group by Voucher (Consolidated)",
-   "depends_on": "eval:(doc.report == 'General Ledger');",
-   "fieldname": "group_by",
-   "fieldtype": "Select",
-   "label": "Group By",
-   "options": "\nGroup by Voucher\nGroup by Voucher (Consolidated)"
-  },
   {
    "depends_on": "eval: (doc.report == 'General Ledger');",
    "fieldname": "currency",
@@ -397,10 +389,18 @@
    "fieldname": "show_remarks",
    "fieldtype": "Check",
    "label": "Show Remarks"
+  },
+  {
+   "default": "Categorize by Voucher (Consolidated)",
+   "depends_on": "eval:(doc.report == 'General Ledger');",
+   "fieldname": "categorize_by",
+   "fieldtype": "Select",
+   "label": "Categorize By",
+   "options": "\nCategorize by Voucher\nCategorize by Voucher (Consolidated)"
   }
  ],
  "links": [],
- "modified": "2024-12-11 12:11:13.543134",
+ "modified": "2025-04-30 14:43:23.643006",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",
@@ -436,4 +436,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -44,6 +44,7 @@ class ProcessStatementOfAccounts(Document):
 		ageing_based_on: DF.Literal["Due Date", "Posting Date"]
 		based_on_payment_terms: DF.Check
 		body: DF.TextEditor | None
+		categorize_by: DF.Literal["", "Categorize by Voucher", "Categorize by Voucher (Consolidated)"]
 		cc_to: DF.TableMultiSelect[ProcessStatementOfAccountsCC]
 		collection_name: DF.DynamicLink | None
 		company: DF.Link
@@ -56,7 +57,6 @@ class ProcessStatementOfAccounts(Document):
 		finance_book: DF.Link | None
 		frequency: DF.Literal["Weekly", "Monthly", "Quarterly"]
 		from_date: DF.Date | None
-		group_by: DF.Literal["", "Group by Voucher", "Group by Voucher (Consolidated)"]
 		ignore_cr_dr_notes: DF.Check
 		ignore_exchange_rate_revaluation_journals: DF.Check
 		include_ageing: DF.Check
@@ -204,7 +204,7 @@ def get_gl_filters(doc, entry, tax_id, presentation_currency):
 		"party": [entry.customer],
 		"party_name": [entry.customer_name] if entry.customer_name else None,
 		"presentation_currency": presentation_currency,
-		"group_by": doc.group_by,
+		"categorize_by": doc.categorize_by,
 		"currency": doc.currency,
 		"project": [p.project_name for p in doc.project],
 		"show_opening_entries": 0,

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -143,8 +143,10 @@
   "contact_mobile",
   "contact_email",
   "company_shipping_address_section",
-  "shipping_address",
+  "dispatch_address",
+  "dispatch_address_display",
   "column_break_126",
+  "shipping_address",
   "shipping_address_display",
   "company_billing_address_section",
   "billing_address",
@@ -1546,7 +1548,7 @@
   {
    "fieldname": "company_shipping_address_section",
    "fieldtype": "Section Break",
-   "label": "Company Shipping Address"
+   "label": "Shipping Address"
   },
   {
    "fieldname": "column_break_126",
@@ -1627,13 +1629,28 @@
    "fieldname": "update_outstanding_for_self",
    "fieldtype": "Check",
    "label": "Update Outstanding for Self"
+  },
+  {
+   "fieldname": "dispatch_address_display",
+   "fieldtype": "Text Editor",
+   "label": "Dispatch Address",
+   "print_hide": 1,
+   "read_only": 1
+  },
+  {
+   "fieldname": "dispatch_address",
+   "fieldtype": "Link",
+   "label": "Select Dispatch Address ",
+   "options": "Address",
+   "print_hide": 1
   }
  ],
+ "grid_page_length": 50,
  "icon": "fa fa-file-text",
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-01-14 11:39:04.564610",
+ "modified": "2025-04-09 16:49:22.175081",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",
@@ -1688,6 +1705,7 @@
    "write": 1
   }
  ],
+ "row_format": "Dynamic",
  "search_fields": "posting_date, supplier, bill_no, base_grand_total, outstanding_amount",
  "show_name_in_global_search": 1,
  "sort_field": "modified",

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -117,6 +117,8 @@ class PurchaseInvoice(BuyingController):
 		currency: DF.Link | None
 		disable_rounded_total: DF.Check
 		discount_amount: DF.Currency
+		dispatch_address: DF.Link | None
+		dispatch_address_display: DF.TextEditor | None
 		due_date: DF.Date | None
 		from_date: DF.Date | None
 		grand_total: DF.Currency

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -2094,7 +2094,7 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 			1,
 		)
 		pi = make_pi_from_pr(pr.name)
-		self.assertEqual(pi.payment_schedule[0].payment_amount, 2500)
+		self.assertEqual(pi.payment_schedule[0].payment_amount, 1000)
 
 		automatically_fetch_payment_terms(enable=0)
 		frappe.db.set_value(
@@ -2683,6 +2683,79 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 
 		self.assertRaises(StockOverReturnError, return_doc.save)
 
+	def test_apply_discount_on_grand_total(self):
+		"""
+		To test if after applying discount on grand total,
+		the grand total is calculated correctly without any rounding errors
+		"""
+		invoice = make_purchase_invoice(qty=3, rate=100, do_not_save=True, do_not_submit=True)
+		invoice.append(
+			"items",
+			{
+				"item_code": "_Test Item",
+				"qty": 3,
+				"rate": 50.3,
+			},
+		)
+		invoice.append(
+			"taxes",
+			{
+				"charge_type": "On Net Total",
+				"account_head": "_Test Account VAT - _TC",
+				"description": "VAT",
+				"rate": 15,
+			},
+		)
+
+		# the grand total here will be 518.54
+		invoice.disable_rounded_total = 1
+		# apply discount on grand total to adjust the grand total to 518
+		invoice.discount_amount = 0.54
+
+		invoice.save()
+
+		# check if grand total is 518 and not something like 517.99 due to rounding errors
+		self.assertEqual(invoice.grand_total, 518)
+
+	def test_apply_discount_on_grand_total_with_previous_row_total_tax(self):
+		"""
+		To test if after applying discount on grand total,
+		where the tax is calculated on previous row total, the grand total is calculated correctly
+		"""
+
+		invoice = make_purchase_invoice(qty=2, rate=100, do_not_save=True, do_not_submit=True)
+		invoice.extend(
+			"taxes",
+			[
+				{
+					"charge_type": "Actual",
+					"account_head": "_Test Account VAT - _TC",
+					"description": "VAT",
+					"tax_amount": 100,
+				},
+				{
+					"charge_type": "On Previous Row Amount",
+					"account_head": "_Test Account VAT - _TC",
+					"description": "VAT",
+					"row_id": 1,
+					"rate": 10,
+				},
+				{
+					"charge_type": "On Previous Row Total",
+					"account_head": "_Test Account VAT - _TC",
+					"description": "VAT",
+					"row_id": 1,
+					"rate": 10,
+				},
+			],
+		)
+
+		# the total here will be 340, so applying 40 discount
+		invoice.discount_amount = 40
+		invoice.save()
+
+		self.assertEqual(invoice.grand_total, 300)
+
 
 def set_advance_flag(company, flag, default_account):
 	frappe.db.set_value(

erpnext/accounts/doctype/purchase_invoice_item/purchase_invoice_item.json

@@ -38,6 +38,7 @@
   "column_break_30",
   "discount_percentage",
   "discount_amount",
+  "distributed_discount_amount",
   "base_rate_with_margin",
   "sec_break2",
   "rate",
@@ -840,7 +841,7 @@
   },
   {
    "collapsible": 1,
-   "collapsible_depends_on": "eval: doc.margin_type || doc.discount_amount",
+   "collapsible_depends_on": "eval: doc.margin_type || doc.discount_amount || doc.distributed_discount_amount",
    "fieldname": "section_break_26",
    "fieldtype": "Section Break",
    "label": "Discount and Margin"
@@ -971,12 +972,18 @@
    "no_copy": 1,
    "options": "Company:company:default_currency",
    "print_hide": 1
+  },
+  {
+   "fieldname": "distributed_discount_amount",
+   "fieldtype": "Currency",
+   "label": "Distributed Discount Amount",
+   "options": "currency"
   }
  ],
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-03-12 16:33:12.453290",
+ "modified": "2025-03-12 16:33:13.453290",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice Item",

erpnext/accounts/doctype/purchase_invoice_item/purchase_invoice_item.py

@@ -34,6 +34,7 @@ class PurchaseInvoiceItem(Document):
 		description: DF.TextEditor | None
 		discount_amount: DF.Currency
 		discount_percentage: DF.Percent
+		distributed_discount_amount: DF.Currency
 		enable_deferred_expense: DF.Check
 		expense_account: DF.Link | None
 		from_warehouse: DF.Link | None

erpnext/accounts/doctype/purchase_taxes_and_charges/purchase_taxes_and_charges.json

@@ -196,7 +196,7 @@
    "fieldname": "item_wise_tax_detail",
    "fieldtype": "Code",
    "hidden": 1,
-   "label": "Item Wise Tax Detail ",
+   "label": "Item Wise Tax Detail",
    "oldfieldname": "item_wise_tax_detail",
    "oldfieldtype": "Small Text",
    "print_hide": 1,
@@ -235,10 +235,11 @@
    "read_only": 1
   }
  ],
+ "grid_page_length": 50,
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-04-08 19:51:36.678551",
+ "modified": "2025-04-15 13:14:48.936047",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Taxes and Charges",

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -782,24 +782,6 @@ frappe.ui.form.on("Sales Invoice", {
 			};
 		};
 	},
-	// When multiple companies are set up. in case company name is changed set default company address
-	company: function (frm) {
-		if (frm.doc.company) {
-			frappe.call({
-				method: "erpnext.setup.doctype.company.company.get_default_company_address",
-				args: { name: frm.doc.company, existing_address: frm.doc.company_address || "" },
-				debounce: 2000,
-				callback: function (r) {
-					if (r.message) {
-						frm.set_value("company_address", r.message);
-					} else {
-						frm.set_value("company_address", "");
-					}
-				},
-			});
-		}
-	},
-
 	onload: function (frm) {
 		frm.redemption_conversion_factor = null;
 	},
@@ -1102,6 +1084,18 @@ frappe.ui.form.on("Sales Invoice Timesheet", {
 	},
 });
 
+frappe.ui.form.on("Sales Invoice Payment", {
+	mode_of_payment: function (frm) {
+		frappe.call({
+			doc: frm.doc,
+			method: "set_account_for_mode_of_payment",
+			callback: function (r) {
+				refresh_field("payments");
+			},
+		});
+	},
+});
+
 var set_timesheet_detail_rate = function (cdt, cdn, currency, timelog) {
 	frappe.call({
 		method: "erpnext.projects.doctype.timesheet.timesheet.get_timesheet_detail_rate",

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -267,8 +267,8 @@ class SalesInvoice(SellingController):
 			self.indicator_title = _("Paid")
 
 	def validate(self):
-		super().validate()
 		self.validate_auto_set_posting_time()
+		super().validate()
 
 		if not (self.is_pos or self.is_debit_note):
 			self.so_dn_required()
@@ -751,10 +751,10 @@ class SalesInvoice(SellingController):
 		self.paid_amount = paid_amount
 		self.base_paid_amount = base_paid_amount
 
+	@frappe.whitelist()
 	def set_account_for_mode_of_payment(self):
 		for payment in self.payments:
-			if not payment.account:
-				payment.account = get_bank_cash_account(payment.mode_of_payment, self.company).get("account")
+			payment.account = get_bank_cash_account(payment.mode_of_payment, self.company).get("account")
 
 	def validate_time_sheets_are_submitted(self):
 		for data in self.timesheets:
@@ -1348,7 +1348,7 @@ class SalesInvoice(SellingController):
 		)
 
 		for item in self.get("items"):
-			if flt(item.base_net_amount, item.precision("base_net_amount")):
+			if flt(item.base_net_amount, item.precision("base_net_amount")) or item.is_fixed_asset:
 				# Do not book income for transfer within same company
 				if self.is_internal_transfer():
 					continue
@@ -2298,7 +2298,10 @@ def make_inter_company_transaction(doctype, source_name, target_doc=None):
 			# Invert Addresses
 			update_address(target_doc, "supplier_address", "address_display", source_doc.company_address)
 			update_address(
-				target_doc, "shipping_address", "shipping_address_display", source_doc.customer_address
+				target_doc, "dispatch_address", "dispatch_address_display", source_doc.dispatch_address_name
+			)
+			update_address(
+				target_doc, "shipping_address", "shipping_address_display", source_doc.shipping_address_name
 			)
 			update_address(
 				target_doc, "billing_address", "billing_address_display", source_doc.customer_address
@@ -2720,9 +2723,11 @@ def create_dunning(source_name, target_doc=None, ignore_permissions=False):
 				target.closing_text = letter_text.get("closing_text")
 				target.language = letter_text.get("language")
 
-		# update outstanding
+		# update outstanding from doc
 		if source.payment_schedule and len(source.payment_schedule) == 1:
-			target.overdue_payments[0].outstanding = source.get("outstanding_amount")
+			for row in target.overdue_payments:
+				if row.payment_schedule == source.payment_schedule[0].name:
+					row.outstanding = source.get("outstanding_amount")
 
 		target.validate()
 

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -12,6 +12,9 @@ from frappe.utils import add_days, flt, format_date, getdate, nowdate, today
 
 import erpnext
 from erpnext.accounts.doctype.account.test_account import create_account, get_inventory_account
+from erpnext.accounts.doctype.mode_of_payment.test_mode_of_payment import (
+	set_default_account_for_mode_of_payment,
+)
 from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
 from erpnext.accounts.doctype.purchase_invoice.purchase_invoice import WarehouseMissingError
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import (
@@ -54,6 +57,11 @@ class TestSalesInvoice(FrappeTestCase):
 		create_items(["_Test Internal Transfer Item"], uoms=[{"uom": "Box", "conversion_factor": 10}])
 		create_internal_parties()
 		setup_accounts()
+		mode_of_payment = frappe.get_doc("Mode of Payment", "Bank Draft")
+		set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", "_Test Bank - _TC")
+		set_default_account_for_mode_of_payment(
+			mode_of_payment, "_Test Company with perpetual inventory", "_Test Bank - TCP1"
+		)
 		frappe.db.set_single_value("Accounts Settings", "acc_frozen_upto", None)
 
 	def tearDown(self):
@@ -964,10 +972,8 @@ class TestSalesInvoice(FrappeTestCase):
 		pos.is_pos = 1
 		pos.update_stock = 1
 
-		pos.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - TCP1", "amount": 50}
-		)
-		pos.append("payments", {"mode_of_payment": "Cash", "account": "Cash - TCP1", "amount": 50})
+		pos.append("payments", {"mode_of_payment": "Bank Draft", "amount": 50})
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 50})
 
 		taxes = get_taxes_and_charges()
 		pos.taxes = []
@@ -996,10 +1002,8 @@ class TestSalesInvoice(FrappeTestCase):
 		pos.is_pos = 1
 		pos.pos_profile = pos_profile.name
 
-		pos.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - _TC", "amount": 500}
-		)
-		pos.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 500})
+		pos.append("payments", {"mode_of_payment": "Bank Draft", "amount": 500})
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 500})
 		pos.insert()
 		pos.submit()
 
@@ -1042,10 +1046,8 @@ class TestSalesInvoice(FrappeTestCase):
 		pos.is_pos = 1
 		pos.update_stock = 1
 
-		pos.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - TCP1", "amount": 50}
-		)
-		pos.append("payments", {"mode_of_payment": "Cash", "account": "Cash - TCP1", "amount": 60})
+		pos.append("payments", {"mode_of_payment": "Bank Draft", "amount": 50})
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 60})
 
 		pos.write_off_outstanding_amount_automatically = 1
 		pos.insert()
@@ -1085,10 +1087,8 @@ class TestSalesInvoice(FrappeTestCase):
 		pos.is_pos = 1
 		pos.update_stock = 1
 
-		pos.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - TCP1", "amount": 50}
-		)
-		pos.append("payments", {"mode_of_payment": "Cash", "account": "Cash - TCP1", "amount": 40})
+		pos.append("payments", {"mode_of_payment": "Bank Draft", "amount": 50})
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 40})
 
 		pos.write_off_outstanding_amount_automatically = 1
 		pos.insert()
@@ -1102,7 +1102,7 @@ class TestSalesInvoice(FrappeTestCase):
 
 		pos = create_sales_invoice(do_not_save=True)
 		pos.is_pos = 1
-		pos.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 100})
 		pos.save().submit()
 		self.assertEqual(pos.outstanding_amount, 0.0)
 		self.assertEqual(pos.status, "Paid")
@@ -1173,10 +1173,8 @@ class TestSalesInvoice(FrappeTestCase):
 		for tax in taxes:
 			pos.append("taxes", tax)
 
-		pos.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - TCP1", "amount": 50}
-		)
-		pos.append("payments", {"mode_of_payment": "Cash", "account": "Cash - TCP1", "amount": 60})
+		pos.append("payments", {"mode_of_payment": "Bank Draft", "amount": 50})
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 60})
 
 		pos.insert()
 		pos.submit()
@@ -3904,10 +3902,8 @@ class TestSalesInvoice(FrappeTestCase):
 		pos = create_sales_invoice(qty=10, do_not_save=True)
 		pos.is_pos = 1
 		pos.pos_profile = pos_profile.name
-		pos.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - _TC", "amount": 500}
-		)
-		pos.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 500})
+		pos.append("payments", {"mode_of_payment": "Bank Draft", "amount": 500})
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 500})
 		pos.save().submit()
 
 		pos_return = make_sales_return(pos.name)
@@ -4278,12 +4274,41 @@ class TestSalesInvoice(FrappeTestCase):
 		pos.is_pos = 1
 		pos.pos_profile = pos_profile.name
 		pos.debit_to = "_Test Receivable USD - _TC"
-		pos.append("payments", {"mode_of_payment": "Cash", "account": "_Test Bank - _TC", "amount": 20.35})
+		pos.append("payments", {"mode_of_payment": "Cash", "amount": 20.35})
 		pos.save().submit()
 
 		pos_return = make_sales_return(pos.name)
 		self.assertEqual(abs(pos_return.payments[0].amount), pos.payments[0].amount)
 
+	def test_create_return_invoice_for_self_update(self):
+		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+		from erpnext.controllers.sales_and_purchase_return import make_return_doc
+
+		invoice = create_sales_invoice()
+
+		payment_entry = get_payment_entry(dt=invoice.doctype, dn=invoice.name)
+		payment_entry.reference_no = "test001"
+		payment_entry.reference_date = getdate()
+
+		payment_entry.save()
+		payment_entry.submit()
+
+		r_invoice = make_return_doc(invoice.doctype, invoice.name)
+
+		r_invoice.update_outstanding_for_self = 0
+		r_invoice.save()
+
+		self.assertEqual(r_invoice.update_outstanding_for_self, 1)
+
+		r_invoice.submit()
+
+		self.assertNotEqual(r_invoice.outstanding_amount, 0)
+
+		invoice.reload()
+
+		self.assertEqual(invoice.outstanding_amount, 0)
+
 	def test_prevents_fully_returned_invoice_with_zero_quantity(self):
 		from erpnext.controllers.sales_and_purchase_return import StockOverReturnError, make_return_doc
 

erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.json

@@ -37,6 +37,7 @@
   "column_break_19",
   "discount_percentage",
   "discount_amount",
+  "distributed_discount_amount",
   "base_rate_with_margin",
   "section_break1",
   "rate",
@@ -259,7 +260,7 @@
   },
   {
    "collapsible": 1,
-   "collapsible_depends_on": "eval: doc.margin_type || doc.discount_amount",
+   "collapsible_depends_on": "eval: doc.margin_type || doc.discount_amount || doc.distributed_discount_amount",
    "fieldname": "discount_and_margin",
    "fieldtype": "Section Break",
    "label": "Discount and Margin"
@@ -932,6 +933,12 @@
    "fieldname": "column_break_ytgd",
    "fieldtype": "Column Break"
   },
+  {
+   "fieldname": "distributed_discount_amount",
+   "fieldtype": "Currency",
+   "label": "Distributed Discount Amount",
+   "options": "currency"
+  },
   {
    "fieldname": "available_quantity_section",
    "fieldtype": "Section Break",
@@ -976,7 +983,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-03-12 16:33:52.503777",
+ "modified": "2025-03-12 16:33:55.503777",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Item",

erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.py

@@ -40,6 +40,7 @@ class SalesInvoiceItem(Document):
 		discount_account: DF.Link | None
 		discount_amount: DF.Currency
 		discount_percentage: DF.Percent
+		distributed_discount_amount: DF.Currency
 		dn_detail: DF.Data | None
 		enable_deferred_revenue: DF.Check
 		expense_account: DF.Link | None

erpnext/accounts/party.py

@@ -71,6 +71,7 @@ def get_party_details(
 	party_address=None,
 	company_address=None,
 	shipping_address=None,
+	dispatch_address=None,
 	pos_profile=None,
 ):
 	if not party:
@@ -92,6 +93,7 @@ def get_party_details(
 		party_address,
 		company_address,
 		shipping_address,
+		dispatch_address,
 		pos_profile,
 	)
 
@@ -111,6 +113,7 @@ def _get_party_details(
 	party_address=None,
 	company_address=None,
 	shipping_address=None,
+	dispatch_address=None,
 	pos_profile=None,
 ):
 	party_details = frappe._dict(
@@ -134,6 +137,7 @@ def _get_party_details(
 		party_address,
 		company_address,
 		shipping_address,
+		dispatch_address,
 		ignore_permissions=ignore_permissions,
 	)
 	set_contact_details(party_details, party, party_type)
@@ -191,34 +195,51 @@ def set_address_details(
 	party_address=None,
 	company_address=None,
 	shipping_address=None,
+	dispatch_address=None,
 	*,
 	ignore_permissions=False,
 ):
-	billing_address_field = (
+	# party_billing
+	party_billing_field = (
 		"customer_address" if party_type in ["Lead", "Prospect"] else party_type.lower() + "_address"
 	)
-	party_details[billing_address_field] = party_address or get_default_address(party_type, party.name)
+
+	party_details[party_billing_field] = party_address or get_default_address(party_type, party.name)
 	if doctype:
 		party_details.update(
-			get_fetch_values(doctype, billing_address_field, party_details[billing_address_field])
+			get_fetch_values(doctype, party_billing_field, party_details[party_billing_field])
 		)
-	# address display
-	party_details.address_display = render_address(
-		party_details[billing_address_field], check_permissions=not ignore_permissions
-	)
-	# shipping address
-	if party_type in ["Customer", "Lead"]:
-		party_details.shipping_address_name = shipping_address or get_party_shipping_address(
-			party_type, party.name
-		)
-		party_details.shipping_address = render_address(
-			party_details["shipping_address_name"], check_permissions=not ignore_permissions
-		)
-		if doctype:
-			party_details.update(
-				get_fetch_values(doctype, "shipping_address_name", party_details.shipping_address_name)
-			)
 
+	party_details.address_display = render_address(
+		party_details[party_billing_field], check_permissions=not ignore_permissions
+	)
+
+	# party_shipping
+	if party_type in ["Customer", "Lead"]:
+		party_shipping_field = "shipping_address_name"
+		party_shipping_display = "shipping_address"
+		default_shipping = shipping_address
+
+	else:
+		# Supplier
+		party_shipping_field = "dispatch_address"
+		party_shipping_display = "dispatch_address_display"
+		default_shipping = dispatch_address
+
+	party_details[party_shipping_field] = default_shipping or get_party_shipping_address(
+		party_type, party.name
+	)
+
+	party_details[party_shipping_display] = render_address(
+		party_details[party_shipping_field], check_permissions=not ignore_permissions
+	)
+
+	if doctype:
+		party_details.update(
+			get_fetch_values(doctype, party_shipping_field, party_details[party_shipping_field])
+		)
+
+	# company_address
 	if company_address:
 		party_details.company_address = company_address
 	else:
@@ -256,22 +277,20 @@ def set_address_details(
 					**get_fetch_values(doctype, "shipping_address", party_details.billing_address),
 				)
 
-	party_address, shipping_address = (
-		party_details.get(billing_address_field),
-		party_details.shipping_address_name,
+	party_billing, party_shipping = (
+		party_details.get(party_billing_field),
+		party_details.get(party_shipping_field),
 	)
 
 	party_details["tax_category"] = get_address_tax_category(
-		party.get("tax_category"),
-		party_address,
-		shipping_address if party_type != "Supplier" else party_address,
+		party.get("tax_category"), party_billing, party_shipping
 	)
 
 	if doctype in TRANSACTION_TYPES:
 		with temporary_flag("company", company):
 			get_regional_address_details(party_details, doctype, company)
 
-	return party_address, shipping_address
+	return party_billing, party_shipping
 
 
 @erpnext.allow_regional
@@ -280,32 +299,50 @@ def get_regional_address_details(party_details, doctype, company):
 
 
 def complete_contact_details(party_details):
-	if not party_details.contact_person:
-		party_details.update(
-			{
-				"contact_person": None,
-				"contact_display": None,
-				"contact_email": None,
-				"contact_mobile": None,
-				"contact_phone": None,
-				"contact_designation": None,
-				"contact_department": None,
-			}
+	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,
+		)
+
+		contact_details.update({"contact_person": None, "contact_phone": None})
+	elif party_details.contact_person:
+		contact_details = frappe.db.get_value(
+			"Contact",
+			party_details.contact_person,
+			[
+				"name as contact_person",
+				"full_name as contact_display",
+				"email_id as contact_email",
+				"mobile_no as contact_mobile",
+				"phone as contact_phone",
+				"designation as contact_designation",
+				"department as contact_department",
+			],
+			as_dict=True,
 		)
 	else:
-		fields = [
-			"name as contact_person",
-			"full_name as contact_display",
-			"email_id as contact_email",
-			"mobile_no as contact_mobile",
-			"phone as contact_phone",
-			"designation as contact_designation",
-			"department as contact_department",
-		]
+		contact_details = {
+			"contact_person": None,
+			"contact_display": None,
+			"contact_email": None,
+			"contact_mobile": None,
+			"contact_phone": None,
+			"contact_designation": None,
+			"contact_department": None,
+		}
 
-		contact_details = frappe.db.get_value("Contact", party_details.contact_person, fields, as_dict=True)
-
-		party_details.update(contact_details)
+	party_details.update(contact_details)
 
 
 def set_contact_details(party_details, party, party_type):
@@ -620,34 +657,34 @@ def get_due_date_from_template(template_name, posting_date, bill_date):
 	return due_date
 
 
-def validate_due_date(posting_date, due_date, bill_date=None, template_name=None):
+def validate_due_date(posting_date, due_date, bill_date=None, template_name=None, doctype=None):
 	if getdate(due_date) < getdate(posting_date):
 		frappe.throw(_("Due Date cannot be before Posting / Supplier Invoice Date"))
 	else:
-		if not template_name:
-			return
+		validate_due_date_with_template(posting_date, due_date, bill_date, template_name, doctype)
 
-		default_due_date = get_due_date_from_template(template_name, posting_date, bill_date).strftime(
-			"%Y-%m-%d"
-		)
 
-		if not default_due_date:
-			return
+def validate_due_date_with_template(posting_date, due_date, bill_date, template_name, doctype=None):
+	if not template_name:
+		return
 
-		if default_due_date != posting_date and getdate(due_date) > getdate(default_due_date):
-			is_credit_controller = (
-				frappe.db.get_single_value("Accounts Settings", "credit_controller") in frappe.get_roles()
+	default_due_date = format(get_due_date_from_template(template_name, posting_date, bill_date))
+
+	if not default_due_date:
+		return
+
+	if default_due_date != posting_date and getdate(due_date) > getdate(default_due_date):
+		if frappe.db.get_single_value("Accounts Settings", "credit_controller") in frappe.get_roles():
+			party_type = "supplier" if doctype == "Purchase Invoice" else "customer"
+
+			msgprint(
+				_("Note: Due Date exceeds allowed {0} credit days by {1} day(s)").format(
+					party_type, date_diff(due_date, default_due_date)
+				)
 			)
-			if is_credit_controller:
-				msgprint(
-					_("Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)").format(
-						date_diff(due_date, default_due_date)
-					)
-				)
-			else:
-				frappe.throw(
-					_("Due / Reference Date cannot be after {0}").format(formatdate(default_due_date))
-				)
+
+		else:
+			frappe.throw(_("Due / Reference Date cannot be after {0}").format(formatdate(default_due_date)))
 
 
 @frappe.whitelist()
@@ -771,9 +808,9 @@ def validate_account_party_type(self):
 		account_type = frappe.get_cached_value("Account", self.account, "account_type")
 		if account_type and (account_type not in ["Receivable", "Payable", "Equity"]):
 			frappe.throw(
-				_(
-					"Party Type and Party can only be set for Receivable / Payable account<br><br>" "{0}"
-				).format(self.account)
+				_("Party Type and Party can only be set for Receivable / Payable account<br><br>{0}").format(
+					self.account
+				)
 			)
 
 
@@ -894,12 +931,16 @@ def get_party_shipping_address(doctype: str, name: str) -> str | None:
 			["is_shipping_address", "=", 1],
 			["address_type", "=", "Shipping"],
 		],
-		pluck="name",
-		limit=1,
+		fields=["name", "is_shipping_address"],
 		order_by="is_shipping_address DESC",
 	)
 
-	return shipping_addresses[0] if shipping_addresses else None
+	if shipping_addresses and shipping_addresses[0].is_shipping_address == 1:
+		return shipping_addresses[0].name
+	if len(shipping_addresses) == 1:
+		return shipping_addresses[0].name
+	else:
+		return None
 
 
 def get_partywise_advanced_payment_amount(

erpnext/accounts/report/accounts_payable/accounts_payable.js

@@ -164,7 +164,7 @@ frappe.query_reports["Accounts Payable"] = {
 	},
 };
 
-erpnext.utils.add_dimensions("Accounts Payable", 9);
+erpnext.utils.add_dimensions("Accounts Payable", 10);
 
 function get_party_type_options() {
 	let options = [];

erpnext/accounts/report/accounts_receivable/accounts_receivable.html

@@ -282,4 +282,4 @@
 			{% } %}
 		</tbody>
 	</table>
-	<p class="text-right text-muted">{{ __("Printed On ") }}{%= frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string()) %}</p>
+	<p class="text-right text-muted">{%= __("Printed on {0}", [frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string())]) %}</p>

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -54,6 +54,10 @@ class ReceivablePayableReport:
 			self.filters.range = "30, 60, 90, 120"
 		self.ranges = [num.strip() for num in self.filters.range.split(",") if num.strip().isdigit()]
 		self.range_numbers = [num for num in range(1, len(self.ranges) + 2)]
+		self.ple_fetch_method = (
+			frappe.db.get_single_value("Accounts Settings", "receivable_payable_fetch_method")
+			or "Buffered Cursor"
+		)  # Fail Safe
 
 	def run(self, args):
 		self.filters.update(args)
@@ -90,10 +94,7 @@ class ReceivablePayableReport:
 				self.skip_total_row = 1
 
 	def get_data(self):
-		self.get_ple_entries()
 		self.get_sales_invoices_or_customers_based_on_sales_person()
-		self.voucher_balance = OrderedDict()
-		self.init_voucher_balance()  # invoiced, paid, credit_note, outstanding
 
 		# Build delivery note map against all sales invoices
 		self.build_delivery_note_map()
@@ -110,12 +111,40 @@ class ReceivablePayableReport:
 		# Get Exchange Rate Revaluations
 		self.get_exchange_rate_revaluations()
 
+		self.prepare_ple_query()
 		self.data = []
+		self.voucher_balance = OrderedDict()
 
+		if self.ple_fetch_method == "Buffered Cursor":
+			self.fetch_ple_in_buffered_cursor()
+		elif self.ple_fetch_method == "UnBuffered Cursor":
+			self.fetch_ple_in_unbuffered_cursor()
+
+		self.build_data()
+
+	def fetch_ple_in_buffered_cursor(self):
+		self.ple_entries = frappe.db.sql(self.ple_query.get_sql(), as_dict=True)
+
+		for ple in self.ple_entries:
+			self.init_voucher_balance(ple)  # invoiced, paid, credit_note, outstanding
+
+		# This is unavoidable. Initialization and allocation cannot happen in same loop
 		for ple in self.ple_entries:
 			self.update_voucher_balance(ple)
 
-		self.build_data()
+		delattr(self, "ple_entries")
+
+	def fetch_ple_in_unbuffered_cursor(self):
+		self.ple_entries = []
+		with frappe.db.unbuffered_cursor():
+			for ple in frappe.db.sql(self.ple_query.get_sql(), as_dict=True, as_iterator=True):
+				self.init_voucher_balance(ple)  # invoiced, paid, credit_note, outstanding
+				self.ple_entries.append(ple)
+
+		# This is unavoidable. Initialization and allocation cannot happen in same loop
+		for ple in self.ple_entries:
+			self.update_voucher_balance(ple)
+		delattr(self, "ple_entries")
 
 	def build_voucher_dict(self, ple):
 		return frappe._dict(
@@ -136,26 +165,22 @@ class ReceivablePayableReport:
 			outstanding_in_account_currency=0.0,
 		)
 
-	def init_voucher_balance(self):
-		# build all keys, since we want to exclude vouchers beyond the report date
-		for ple in self.ple_entries:
-			# get the balance object for voucher_type
+	def init_voucher_balance(self, ple):
+		if self.filters.get("ignore_accounts"):
+			key = (ple.voucher_type, ple.voucher_no, ple.party)
+		else:
+			key = (ple.account, ple.voucher_type, ple.voucher_no, ple.party)
 
-			if self.filters.get("ignore_accounts"):
-				key = (ple.voucher_type, ple.voucher_no, ple.party)
-			else:
-				key = (ple.account, ple.voucher_type, ple.voucher_no, ple.party)
+		if key not in self.voucher_balance:
+			self.voucher_balance[key] = self.build_voucher_dict(ple)
 
-			if key not in self.voucher_balance:
-				self.voucher_balance[key] = self.build_voucher_dict(ple)
+		if ple.voucher_type == ple.against_voucher_type and ple.voucher_no == ple.against_voucher_no:
+			self.voucher_balance[key].cost_center = ple.cost_center
 
-			if ple.voucher_type == ple.against_voucher_type and ple.voucher_no == ple.against_voucher_no:
-				self.voucher_balance[key].cost_center = ple.cost_center
+		self.get_invoices(ple)
 
-			self.get_invoices(ple)
-
-			if self.filters.get("group_by_party"):
-				self.init_subtotal_row(ple.party)
+		if self.filters.get("group_by_party"):
+			self.init_subtotal_row(ple.party)
 
 		if self.filters.get("group_by_party") and not self.filters.get("in_party_currency"):
 			self.init_subtotal_row("Total")
@@ -778,7 +803,7 @@ class ReceivablePayableReport:
 		)
 		row["range" + str(index + 1)] = row.outstanding
 
-	def get_ple_entries(self):
+	def prepare_ple_query(self):
 		# get all the GL entries filtered by the given filters
 
 		self.prepare_conditions()
@@ -831,7 +856,7 @@ class ReceivablePayableReport:
 		else:
 			query = query.orderby(self.ple.posting_date, self.ple.party)
 
-		self.ple_entries = query.run(as_dict=True)
+		self.ple_query = query
 
 	def get_sales_invoices_or_customers_based_on_sales_person(self):
 		if self.filters.get("sales_person"):

erpnext/accounts/report/accounts_receivable/test_accounts_receivable.py

@@ -21,7 +21,7 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 	def tearDown(self):
 		frappe.db.rollback()
 
-	def create_sales_invoice(self, no_payment_schedule=False, do_not_submit=False):
+	def create_sales_invoice(self, no_payment_schedule=False, do_not_submit=False, **args):
 		frappe.set_user("Administrator")
 		si = create_sales_invoice(
 			item=self.item,
@@ -34,6 +34,7 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 			rate=100,
 			price_list_rate=100,
 			do_not_save=1,
+			**args,
 		)
 		if not no_payment_schedule:
 			si.append(
@@ -108,7 +109,7 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 		self.assertEqual(expected_data[0], [row.invoiced, row.paid, row.credit_note])
 		pos_inv.cancel()
 
-	def test_accounts_receivable(self):
+	def test_accounts_receivable_with_payment(self):
 		filters = {
 			"company": self.company,
 			"based_on_payment_terms": 1,
@@ -145,11 +146,15 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 		cr_note = self.create_credit_note(si.name, do_not_submit=True)
 		cr_note.update_outstanding_for_self = False
 		cr_note.save().submit()
+
+		# as the invoice partially paid and returning the full amount so the outstanding amount should be True
+		self.assertEqual(cr_note.update_outstanding_for_self, True)
+
 		report = execute(filters)
 
-		expected_data_after_credit_note = [100, 0, 0, 40, -40, self.debit_to]
+		expected_data_after_credit_note = [0, 0, 100, 0, -100, self.debit_to]
 
-		row = report[1][0]
+		row = report[1][-1]
 		self.assertEqual(
 			expected_data_after_credit_note,
 			[
@@ -162,6 +167,99 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 			],
 		)
 
+	def test_accounts_receivable_without_payment(self):
+		filters = {
+			"company": self.company,
+			"based_on_payment_terms": 1,
+			"report_date": today(),
+			"range": "30, 60, 90, 120",
+			"show_remarks": True,
+		}
+
+		# check invoice grand total and invoiced column's value for 3 payment terms
+		si = self.create_sales_invoice()
+
+		report = execute(filters)
+
+		expected_data = [[100, 30, "No Remarks"], [100, 50, "No Remarks"], [100, 20, "No Remarks"]]
+
+		for i in range(3):
+			row = report[1][i - 1]
+			self.assertEqual(expected_data[i - 1], [row.invoice_grand_total, row.invoiced, row.remarks])
+
+		# check invoice grand total, invoiced, paid and outstanding column's value after credit note
+		cr_note = self.create_credit_note(si.name, do_not_submit=True)
+		cr_note.update_outstanding_for_self = False
+		cr_note.save().submit()
+
+		self.assertEqual(cr_note.update_outstanding_for_self, False)
+
+		report = execute(filters)
+
+		row = report[1]
+		self.assertTrue(len(row) == 0)
+
+	def test_accounts_receivable_with_partial_payment(self):
+		filters = {
+			"company": self.company,
+			"based_on_payment_terms": 1,
+			"report_date": today(),
+			"range": "30, 60, 90, 120",
+			"show_remarks": True,
+		}
+
+		# check invoice grand total and invoiced column's value for 3 payment terms
+		si = self.create_sales_invoice(qty=2)
+
+		report = execute(filters)
+
+		expected_data = [[200, 60, "No Remarks"], [200, 100, "No Remarks"], [200, 40, "No Remarks"]]
+
+		for i in range(3):
+			row = report[1][i - 1]
+			self.assertEqual(expected_data[i - 1], [row.invoice_grand_total, row.invoiced, row.remarks])
+
+		# check invoice grand total, invoiced, paid and outstanding column's value after payment
+		self.create_payment_entry(si.name)
+		report = execute(filters)
+
+		expected_data_after_payment = [[200, 60, 40, 20], [200, 100, 0, 100], [200, 40, 0, 40]]
+
+		for i in range(3):
+			row = report[1][i - 1]
+			self.assertEqual(
+				expected_data_after_payment[i - 1],
+				[row.invoice_grand_total, row.invoiced, row.paid, row.outstanding],
+			)
+
+		# check invoice grand total, invoiced, paid and outstanding column's value after credit note
+		cr_note = self.create_credit_note(si.name, do_not_submit=True)
+		cr_note.update_outstanding_for_self = False
+		cr_note.save().submit()
+
+		self.assertFalse(cr_note.update_outstanding_for_self)
+
+		report = execute(filters)
+
+		expected_data_after_credit_note = [
+			[200, 100, 0, 80, 20, self.debit_to],
+			[200, 40, 0, 0, 40, self.debit_to],
+		]
+
+		for i in range(2):
+			row = report[1][i - 1]
+			self.assertEqual(
+				expected_data_after_credit_note[i - 1],
+				[
+					row.invoice_grand_total,
+					row.invoiced,
+					row.paid,
+					row.credit_note,
+					row.outstanding,
+					row.party_account,
+				],
+			)
+
 	def test_cr_note_flag_to_update_self(self):
 		filters = {
 			"company": self.company,

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html

@@ -1,6 +1,3 @@
-<div style="margin-bottom: 7px;">
-	{%= frappe.boot.letter_heads[frappe.defaults.get_default("letter_head")] %}
-</div>
 <h2 class="text-center">{%= __("Bank Reconciliation Statement") %}</h2>
 <h4 class="text-center">{%= filters.account && (filters.account + ", "+filters.report_date)  || "" %} {%= filters.company %}</h4>
 <hr>
@@ -46,4 +43,4 @@
 		{% } %}
 	</tbody>
 </table>
-<p class="text-right text-muted">Printed On {%= frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string()) %}</p>
+<p class="text-right text-muted">{%= __("Printed on {0}", [frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string())]) %}</p>

erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.js

@@ -9,6 +9,7 @@ frappe.query_reports["Customer Ledger Summary"] = {
 			fieldtype: "Link",
 			options: "Company",
 			default: frappe.defaults.get_user_default("Company"),
+			reqd: 1,
 		},
 		{
 			fieldname: "from_date",

erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py

@@ -4,7 +4,19 @@
 
 import frappe
 from frappe import _, qb, scrub
+from frappe.query_builder import Criterion, Tuple
+from frappe.query_builder.functions import IfNull
 from frappe.utils import getdate, nowdate
+from frappe.utils.nestedset import get_descendants_of
+
+from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
+	get_accounting_dimensions,
+	get_dimension_with_children,
+)
+
+TREE_DOCTYPES = frozenset(
+	["Customer Group", "Terrirtory", "Supplier Group", "Sales Partner", "Sales Person", "Cost Center"]
+)
 
 
 class PartyLedgerSummaryReport:
@@ -13,59 +25,110 @@ class PartyLedgerSummaryReport:
 		self.filters.from_date = getdate(self.filters.from_date or nowdate())
 		self.filters.to_date = getdate(self.filters.to_date or nowdate())
 
-		if not self.filters.get("company"):
-			self.filters["company"] = frappe.db.get_single_value("Global Defaults", "default_company")
-
 	def run(self, args):
-		if self.filters.from_date > self.filters.to_date:
-			frappe.throw(_("From Date must be before To Date"))
-
 		self.filters.party_type = args.get("party_type")
-		self.party_naming_by = frappe.db.get_value(args.get("naming_by")[0], None, args.get("naming_by")[1])
+
+		self.validate_filters()
+		self.get_party_details()
+
+		if not self.parties:
+			return [], []
 
 		self.get_gl_entries()
-		self.get_additional_columns()
 		self.get_return_invoices()
 		self.get_party_adjustment_amounts()
 
+		self.party_naming_by = frappe.db.get_single_value(args.get("naming_by")[0], args.get("naming_by")[1])
 		columns = self.get_columns()
 		data = self.get_data()
+
 		return columns, data
 
-	def get_additional_columns(self):
+	def validate_filters(self):
+		if not self.filters.get("company"):
+			frappe.throw(_("{0} is mandatory").format(_("Company")))
+
+		if self.filters.from_date > self.filters.to_date:
+			frappe.throw(_("From Date must be before To Date"))
+
+		self.update_hierarchical_filters()
+
+	def update_hierarchical_filters(self):
+		for doctype in TREE_DOCTYPES:
+			key = scrub(doctype)
+			if self.filters.get(key):
+				self.filters[key] = get_children(doctype, self.filters[key])
+
+	def get_party_details(self):
 		"""
 		Additional Columns for 'User Permission' based access control
 		"""
+		self.parties = []
+		self.party_details = frappe._dict()
+		party_type = self.filters.party_type
 
-		if self.filters.party_type == "Customer":
-			self.territories = frappe._dict({})
-			self.customer_group = frappe._dict({})
+		doctype = qb.DocType(party_type)
+		conditions = self.get_party_conditions(doctype)
+		query = (
+			qb.from_(doctype)
+			.select(doctype.name.as_("party"), f"{scrub(party_type)}_name")
+			.where(Criterion.all(conditions))
+		)
 
-			customer = qb.DocType("Customer")
-			result = (
-				frappe.qb.from_(customer)
-				.select(
-					customer.name, customer.territory, customer.customer_group, customer.default_sales_partner
-				)
-				.where(customer.disabled == 0)
-				.run(as_dict=True)
+		from frappe.desk.reportview import build_match_conditions
+
+		query, params = query.walk()
+		match_conditions = build_match_conditions(party_type)
+
+		if match_conditions:
+			query += "and" + match_conditions
+
+		party_details = frappe.db.sql(query, params, as_dict=True)
+
+		for row in party_details:
+			self.parties.append(row.party)
+			self.party_details[row.party] = row
+
+	def get_party_conditions(self, doctype):
+		conditions = []
+		group_field = "customer_group" if self.filters.party_type == "Customer" else "supplier_group"
+
+		if self.filters.party:
+			conditions.append(doctype.name == self.filters.party)
+
+		if self.filters.territory:
+			conditions.append(doctype.territory.isin(self.filters.territory))
+
+		if self.filters.get(group_field):
+			conditions.append(doctype[group_field].isin(self.filters.get(group_field)))
+
+		if self.filters.payment_terms_template:
+			conditions.append(doctype.payment_terms == self.filters.payment_terms_template)
+
+		if self.filters.sales_partner:
+			conditions.append(doctype.default_sales_partner.isin(self.filters.sales_partner))
+
+		if self.filters.sales_person:
+			sales_team = qb.DocType("Sales Team")
+			sales_invoice = qb.DocType("Sales Invoice")
+
+			customers = (
+				qb.from_(sales_team)
+				.select(sales_team.parent)
+				.where(sales_team.sales_person.isin(self.filters.sales_person))
+				.where(sales_team.parenttype == "Customer")
+			) + (
+				qb.from_(sales_team)
+				.join(sales_invoice)
+				.on(sales_team.parent == sales_invoice.name)
+				.select(sales_invoice.customer)
+				.where(sales_team.sales_person.isin(self.filters.sales_person))
+				.where(sales_team.parenttype == "Sales Invoice")
 			)
 
-			for x in result:
-				self.territories[x.name] = x.territory
-				self.customer_group[x.name] = x.customer_group
-		else:
-			self.supplier_group = frappe._dict({})
-			supplier = qb.DocType("Supplier")
-			result = (
-				frappe.qb.from_(supplier)
-				.select(supplier.name, supplier.supplier_group)
-				.where(supplier.disabled == 0)
-				.run(as_dict=True)
-			)
+			conditions.append(doctype.name.isin(customers))
 
-			for x in result:
-				self.supplier_group[x.name] = x.supplier_group
+		return conditions
 
 	def get_columns(self):
 		columns = [
@@ -81,10 +144,10 @@ class PartyLedgerSummaryReport:
 		if self.party_naming_by == "Naming Series":
 			columns.append(
 				{
-					"label": _(self.filters.party_type + "Name"),
+					"label": _(self.filters.party_type + " Name"),
 					"fieldtype": "Data",
 					"fieldname": "party_name",
-					"width": 110,
+					"width": 150,
 				}
 			)
 
@@ -188,12 +251,14 @@ class PartyLedgerSummaryReport:
 
 		self.party_data = frappe._dict({})
 		for gle in self.gl_entries:
+			party_details = self.party_details.get(gle.party)
+			party_name = party_details.get(f"{scrub(self.filters.party_type)}_name", "")
 			self.party_data.setdefault(
 				gle.party,
 				frappe._dict(
 					{
-						"party": gle.party,
-						"party_name": gle.party_name,
+						**party_details,
+						"party_name": party_name,
 						"opening_balance": 0,
 						"invoiced_amount": 0,
 						"paid_amount": 0,
@@ -204,12 +269,6 @@ class PartyLedgerSummaryReport:
 				),
 			)
 
-			if self.filters.party_type == "Customer":
-				self.party_data[gle.party].update({"territory": self.territories.get(gle.party)})
-				self.party_data[gle.party].update({"customer_group": self.customer_group.get(gle.party)})
-			else:
-				self.party_data[gle.party].update({"supplier_group": self.supplier_group.get(gle.party)})
-
 			amount = gle.get(invoice_dr_or_cr) - gle.get(reverse_dr_or_cr)
 			self.party_data[gle.party].closing_balance += amount
 
@@ -246,164 +305,120 @@ class PartyLedgerSummaryReport:
 		return out
 
 	def get_gl_entries(self):
-		conditions = self.prepare_conditions()
-		join = join_field = ""
-		if self.filters.party_type == "Customer":
-			join_field = ", p.customer_name as party_name"
-			join = "left join `tabCustomer` p on gle.party = p.name"
-		elif self.filters.party_type == "Supplier":
-			join_field = ", p.supplier_name as party_name"
-			join = "left join `tabSupplier` p on gle.party = p.name"
-
-		self.gl_entries = frappe.db.sql(
-			f"""
-			select
-				gle.posting_date, gle.party, gle.voucher_type, gle.voucher_no, gle.against_voucher_type,
-				gle.against_voucher, gle.debit, gle.credit, gle.is_opening {join_field}
-			from `tabGL Entry` gle
-			{join}
-			where
-				gle.docstatus < 2 and gle.is_cancelled = 0 and gle.party_type=%(party_type)s and ifnull(gle.party, '') != ''
-				and gle.posting_date <= %(to_date)s {conditions}
-			order by gle.posting_date
-		""",
-			self.filters,
-			as_dict=True,
+		gle = qb.DocType("GL Entry")
+		query = (
+			qb.from_(gle)
+			.select(
+				gle.posting_date,
+				gle.party,
+				gle.voucher_type,
+				gle.voucher_no,
+				gle.debit,
+				gle.credit,
+				gle.is_opening,
+			)
+			.where(
+				(gle.docstatus < 2)
+				& (gle.is_cancelled == 0)
+				& (gle.party_type == self.filters.party_type)
+				& (IfNull(gle.party, "") != "")
+				& (gle.posting_date <= self.filters.to_date)
+				& (gle.party.isin(self.parties))
+			)
 		)
 
-	def prepare_conditions(self):
-		conditions = [""]
+		query = self.prepare_conditions(query)
 
+		self.gl_entries = query.run(as_dict=True)
+
+	def prepare_conditions(self, query):
+		gle = qb.DocType("GL Entry")
 		if self.filters.company:
-			conditions.append("gle.company=%(company)s")
+			query = query.where(gle.company == self.filters.company)
 
 		if self.filters.finance_book:
-			conditions.append("ifnull(finance_book,'') in (%(finance_book)s, '')")
+			query = query.where(IfNull(gle.finance_book, "") == self.filters.finance_book)
 
-		if self.filters.get("party"):
-			conditions.append("party=%(party)s")
+		if self.filters.cost_center:
+			query = query.where((gle.cost_center).isin(self.filters.cost_center))
 
-		if self.filters.party_type == "Customer":
-			if self.filters.get("customer_group"):
-				lft, rgt = frappe.get_cached_value(
-					"Customer Group", self.filters["customer_group"], ["lft", "rgt"]
-				)
+		if self.filters.project:
+			query = query.where((gle.project).isin(self.filters.project))
 
-				conditions.append(
-					f"""party in (select name from tabCustomer
-					where exists(select name from `tabCustomer Group` where lft >= {lft} and rgt <= {rgt}
-						and name=tabCustomer.customer_group))"""
-				)
+		accounting_dimensions = get_accounting_dimensions(as_list=False)
 
-			if self.filters.get("territory"):
-				lft, rgt = frappe.db.get_value("Territory", self.filters.get("territory"), ["lft", "rgt"])
+		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)
+						)
+						query = query.where(
+							(gle[dimension.fieldname]).isin(self.filters.get(dimension.fieldname))
+						)
+					else:
+						query = query.where(
+							(gle[dimension.fieldname]).isin(self.filters.get(dimension.fieldname))
+						)
 
-				conditions.append(
-					f"""party in (select name from tabCustomer
-					where exists(select name from `tabTerritory` where lft >= {lft} and rgt <= {rgt}
-						and name=tabCustomer.territory))"""
-				)
-
-			if self.filters.get("payment_terms_template"):
-				conditions.append(
-					"party in (select name from tabCustomer where payment_terms=%(payment_terms_template)s)"
-				)
-
-			if self.filters.get("sales_partner"):
-				conditions.append(
-					"party in (select name from tabCustomer where default_sales_partner=%(sales_partner)s)"
-				)
-
-			if self.filters.get("sales_person"):
-				lft, rgt = frappe.db.get_value(
-					"Sales Person", self.filters.get("sales_person"), ["lft", "rgt"]
-				)
-
-				conditions.append(
-					"""exists(select name from `tabSales Team` steam where
-					steam.sales_person in (select name from `tabSales Person` where lft >= {} and rgt <= {})
-					and ((steam.parent = voucher_no and steam.parenttype = voucher_type)
-						or (steam.parent = against_voucher and steam.parenttype = against_voucher_type)
-						or (steam.parent = party and steam.parenttype = 'Customer')))""".format(lft, rgt)
-				)
-
-		if self.filters.party_type == "Supplier":
-			if self.filters.get("supplier_group"):
-				conditions.append(
-					"""party in (select name from tabSupplier
-					where supplier_group=%(supplier_group)s)"""
-				)
-
-		return " and ".join(conditions)
+		return query
 
 	def get_return_invoices(self):
 		doctype = "Sales Invoice" if self.filters.party_type == "Customer" else "Purchase Invoice"
-		self.return_invoices = [
-			d.name
-			for d in frappe.get_all(
-				doctype,
-				filters={
-					"is_return": 1,
-					"docstatus": 1,
-					"posting_date": ["between", [self.filters.from_date, self.filters.to_date]],
-				},
-			)
-		]
+		filters = (
+			{
+				"is_return": 1,
+				"docstatus": 1,
+				"posting_date": ["between", [self.filters.from_date, self.filters.to_date]],
+				f"{scrub(self.filters.party_type)}": ["in", self.parties],
+			},
+		)
+
+		self.return_invoices = frappe.get_all(doctype, filters=filters, pluck="name")
 
 	def get_party_adjustment_amounts(self):
-		conditions = self.prepare_conditions()
 		account_type = "Expense Account" if self.filters.party_type == "Customer" else "Income Account"
-		income_or_expense_accounts = frappe.db.get_all(
-			"Account", filters={"account_type": account_type, "company": self.filters.company}, pluck="name"
-		)
+
 		invoice_dr_or_cr = "debit" if self.filters.party_type == "Customer" else "credit"
 		reverse_dr_or_cr = "credit" if self.filters.party_type == "Customer" else "debit"
 		round_off_account = frappe.get_cached_value("Company", self.filters.company, "round_off_account")
 
-		gl = qb.DocType("GL Entry")
-		if not income_or_expense_accounts:
-			# prevent empty 'in' condition
-			income_or_expense_accounts.append("")
-		else:
-			# escape '%' in account name
-			# ignoring frappe.db.escape as it replaces single quotes with double quotes
-			income_or_expense_accounts = [x.replace("%", "%%") for x in income_or_expense_accounts]
-
-		accounts_query = (
-			qb.from_(gl)
-			.select(gl.voucher_type, gl.voucher_no)
-			.where(
-				(gl.account.isin(income_or_expense_accounts))
-				& (gl.posting_date.gte(self.filters.from_date))
-				& (gl.posting_date.lte(self.filters.to_date))
-			)
-		)
-
-		gl_entries = frappe.db.sql(
-			f"""
-			select
-				posting_date, account, party, voucher_type, voucher_no, debit, credit
-			from
-				`tabGL Entry`
-			where
-				docstatus < 2 and is_cancelled = 0
-				and (voucher_type, voucher_no) in (
-				{accounts_query}
-				) and (voucher_type, voucher_no) in (
-					select voucher_type, voucher_no from `tabGL Entry` gle
-					where gle.party_type=%(party_type)s and ifnull(party, '') != ''
-					and gle.posting_date between %(from_date)s and %(to_date)s and gle.docstatus < 2 {conditions}
-				)
-			""",
-			self.filters,
-			as_dict=True,
-		)
+		current_period_vouchers = set()
+		adjustment_voucher_entries = {}
 
 		self.party_adjustment_details = {}
 		self.party_adjustment_accounts = set()
-		adjustment_voucher_entries = {}
+
+		for gle in self.gl_entries:
+			if (
+				gle.is_opening != "Yes"
+				and gle.posting_date >= self.filters.from_date
+				and gle.posting_date <= self.filters.to_date
+			):
+				current_period_vouchers.add((gle.voucher_type, gle.voucher_no))
+				adjustment_voucher_entries.setdefault((gle.voucher_type, gle.voucher_no), []).append(gle)
+
+		if not current_period_vouchers:
+			return
+
+		gl = qb.DocType("GL Entry")
+		query = (
+			qb.from_(gl)
+			.select(gl.voucher_type, gl.voucher_no)
+			.where(
+				(gl.docstatus < 2)
+				& (gl.is_cancelled == 0)
+				& (gl.posting_date.gte(self.filters.from_date))
+				& (gl.posting_date.lte(self.filters.to_date))
+				& (Tuple((gl.voucher_type, gl.voucher_no)).isin(current_period_vouchers))
+				& (IfNull(gl.party, "") == "")
+			)
+		)
+		query = self.prepare_conditions(query)
+		gl_entries = query.run(as_dict=True)
+
 		for gle in gl_entries:
-			adjustment_voucher_entries.setdefault((gle.voucher_type, gle.voucher_no), [])
 			adjustment_voucher_entries[(gle.voucher_type, gle.voucher_no)].append(gle)
 
 		for voucher_gl_entries in adjustment_voucher_entries.values():
@@ -440,9 +455,16 @@ class PartyLedgerSummaryReport:
 						self.party_adjustment_details[party][account] += amount
 
 
+def get_children(doctype, value):
+	children = get_descendants_of(doctype, value)
+
+	return [value, *children]
+
+
 def execute(filters=None):
 	args = {
 		"party_type": "Customer",
 		"naming_by": ["Selling Settings", "cust_master_name"],
 	}
+
 	return PartyLedgerSummaryReport(filters).run(args)

erpnext/accounts/report/customer_ledger_summary/test_customer_ledger_summary.py

@@ -0,0 +1,152 @@
+import frappe
+from frappe import qb
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import add_days, flt, getdate, today
+
+from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+from erpnext.accounts.report.customer_ledger_summary.customer_ledger_summary import execute
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+
+
+class TestCustomerLedgerSummary(FrappeTestCase, AccountsTestMixin):
+	def setUp(self):
+		self.create_company()
+		self.create_customer()
+		self.create_item()
+		self.clear_old_entries()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def create_sales_invoice(self, do_not_submit=False, **args):
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debit_to,
+			posting_date=today(),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=100,
+			qty=10,
+			price_list_rate=100,
+			do_not_save=1,
+			**args,
+		)
+		si = si.save()
+		if not do_not_submit:
+			si = si.submit()
+		return si
+
+	def create_payment_entry(self, docname, do_not_submit=False):
+		pe = get_payment_entry("Sales Invoice", docname, bank_account=self.cash, party_amount=40)
+		pe.paid_from = self.debit_to
+		pe.insert()
+		if not do_not_submit:
+			pe.submit()
+		return pe
+
+	def create_credit_note(self, docname, do_not_submit=False):
+		credit_note = create_sales_invoice(
+			company=self.company,
+			customer=self.customer,
+			item=self.item,
+			qty=-1,
+			debit_to=self.debit_to,
+			cost_center=self.cost_center,
+			is_return=1,
+			return_against=docname,
+			do_not_submit=do_not_submit,
+		)
+
+		return credit_note
+
+	def test_ledger_summary_basic_output(self):
+		filters = {"company": self.company, "from_date": today(), "to_date": today()}
+
+		si = self.create_sales_invoice(do_not_submit=True)
+		si.save().submit()
+
+		expected = {
+			"party": "_Test Customer",
+			"party_name": "_Test Customer",
+			"opening_balance": 0,
+			"invoiced_amount": 1000.0,
+			"paid_amount": 0,
+			"return_amount": 0,
+			"closing_balance": 1000.0,
+			"currency": "INR",
+			"customer_name": "_Test Customer",
+		}
+
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
+		for field in expected:
+			with self.subTest(field=field):
+				self.assertEqual(report[0].get(field), expected.get(field))
+
+	def test_summary_with_return_and_payment(self):
+		filters = {"company": self.company, "from_date": today(), "to_date": today()}
+
+		si = self.create_sales_invoice(do_not_submit=True)
+		si.save().submit()
+
+		expected = {
+			"party": "_Test Customer",
+			"party_name": "_Test Customer",
+			"opening_balance": 0,
+			"invoiced_amount": 1000.0,
+			"paid_amount": 0,
+			"return_amount": 0,
+			"closing_balance": 1000.0,
+			"currency": "INR",
+			"customer_name": "_Test Customer",
+		}
+
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
+		for field in expected:
+			with self.subTest(field=field):
+				self.assertEqual(report[0].get(field), expected.get(field))
+
+		cr_note = self.create_credit_note(si.name, True)
+		cr_note.items[0].qty = -2
+		cr_note.save().submit()
+
+		expected_after_cr_note = {
+			"party": "_Test Customer",
+			"party_name": "_Test Customer",
+			"opening_balance": 0,
+			"invoiced_amount": 1000.0,
+			"paid_amount": 0,
+			"return_amount": 200.0,
+			"closing_balance": 800.0,
+			"currency": "INR",
+		}
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
+		for field in expected_after_cr_note:
+			with self.subTest(field=field):
+				self.assertEqual(report[0].get(field), expected_after_cr_note.get(field))
+
+		pe = self.create_payment_entry(si.name, True)
+		pe.paid_amount = 500
+		pe.save().submit()
+
+		expected_after_cr_and_payment = {
+			"party": "_Test Customer",
+			"party_name": "_Test Customer",
+			"opening_balance": 0,
+			"invoiced_amount": 1000.0,
+			"paid_amount": 500.0,
+			"return_amount": 200.0,
+			"closing_balance": 300.0,
+			"currency": "INR",
+		}
+
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
+		for field in expected_after_cr_and_payment:
+			with self.subTest(field=field):
+				self.assertEqual(report[0].get(field), expected_after_cr_and_payment.get(field))

erpnext/accounts/report/financial_statements.html

@@ -67,5 +67,5 @@
 	</tbody>
 </table>
 <p class="text-right text-muted">
-	Printed On {%= frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string()) %}
+	{%= __("Printed on {0}", [frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string())]) %}
 </p>

erpnext/accounts/report/financial_statements.py

@@ -9,6 +9,7 @@ import re
 
 import frappe
 from frappe import _
+from frappe.query_builder.functions import Sum
 from frappe.utils import add_days, add_months, cint, cstr, flt, formatdate, get_first_day, getdate
 from pypika.terms import ExistsCriterion
 
@@ -428,6 +429,7 @@ def set_gl_entries_by_account(
 	root_type=None,
 	ignore_closing_entries=False,
 	ignore_opening_entries=False,
+	group_by_account=False,
 ):
 	"""Returns a dict like { "account": [gl entries], ... }"""
 	gl_entries = []
@@ -459,6 +461,7 @@ def set_gl_entries_by_account(
 				root_type,
 				ignore_closing_entries,
 				last_period_closing_voucher[0].name,
+				group_by_account=group_by_account,
 			)
 			from_date = add_days(last_period_closing_voucher[0].period_end_date, 1)
 			ignore_opening_entries = True
@@ -473,6 +476,7 @@ def set_gl_entries_by_account(
 		root_type,
 		ignore_closing_entries,
 		ignore_opening_entries=ignore_opening_entries,
+		group_by_account=group_by_account,
 	)
 
 	if filters and filters.get("presentation_currency"):
@@ -495,16 +499,21 @@ def get_accounting_entries(
 	ignore_closing_entries=None,
 	period_closing_voucher=None,
 	ignore_opening_entries=False,
+	group_by_account=False,
 ):
 	gl_entry = frappe.qb.DocType(doctype)
 	query = (
 		frappe.qb.from_(gl_entry)
 		.select(
 			gl_entry.account,
-			gl_entry.debit,
-			gl_entry.credit,
-			gl_entry.debit_in_account_currency,
-			gl_entry.credit_in_account_currency,
+			gl_entry.debit if not group_by_account else Sum(gl_entry.debit).as_("debit"),
+			gl_entry.credit if not group_by_account else Sum(gl_entry.credit).as_("credit"),
+			gl_entry.debit_in_account_currency
+			if not group_by_account
+			else Sum(gl_entry.debit_in_account_currency).as_("debit_in_account_currency"),
+			gl_entry.credit_in_account_currency
+			if not group_by_account
+			else Sum(gl_entry.credit_in_account_currency).as_("credit_in_account_currency"),
 			gl_entry.account_currency,
 		)
 		.where(gl_entry.company == filters.company)
@@ -539,6 +548,9 @@ def get_accounting_entries(
 	if match_conditions:
 		query += "and" + match_conditions
 
+	if group_by_account:
+		query += " GROUP BY `account`"
+
 	return frappe.db.sql(query, params, as_dict=True)
 
 

erpnext/accounts/report/general_ledger/general_ledger.html

@@ -79,4 +79,4 @@
 		{% } %}
 	</tbody>
 </table>
-<p class="text-right text-muted">Printed On {%= frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string()) %}</p>
+<p class="text-right text-muted">{%= __("Printed on {0}", [frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string())]) %}</p>

erpnext/accounts/report/general_ledger/general_ledger.js

@@ -49,7 +49,7 @@ frappe.query_reports["General Ledger"] = {
 			label: __("Voucher No"),
 			fieldtype: "Data",
 			on_change: function () {
-				frappe.query_report.set_filter_value("group_by", "Group by Voucher (Consolidated)");
+				frappe.query_report.set_filter_value("categorize_by", "Categorize by Voucher (Consolidated)");
 			},
 		},
 		{
@@ -66,7 +66,7 @@ frappe.query_reports["General Ledger"] = {
 			fieldtype: "Autocomplete",
 			options: Object.keys(frappe.boot.party_account_types),
 			on_change: function () {
-				frappe.query_report.set_filter_value("party", "");
+				frappe.query_report.set_filter_value("party", []);
 			},
 		},
 		{
@@ -112,29 +112,29 @@ frappe.query_reports["General Ledger"] = {
 			hidden: 1,
 		},
 		{
-			fieldname: "group_by",
-			label: __("Group by"),
+			fieldname: "categorize_by",
+			label: __("Categorize by"),
 			fieldtype: "Select",
 			options: [
 				"",
 				{
-					label: __("Group by Voucher"),
-					value: "Group by Voucher",
+					label: __("Categorize by Voucher"),
+					value: "Categorize by Voucher",
 				},
 				{
-					label: __("Group by Voucher (Consolidated)"),
-					value: "Group by Voucher (Consolidated)",
+					label: __("Categorize by Voucher (Consolidated)"),
+					value: "Categorize by Voucher (Consolidated)",
 				},
 				{
-					label: __("Group by Account"),
-					value: "Group by Account",
+					label: __("Categorize by Account"),
+					value: "Categorize by Account",
 				},
 				{
-					label: __("Group by Party"),
-					value: "Group by Party",
+					label: __("Categorize by Party"),
+					value: "Categorize by Party",
 				},
 			],
-			default: "Group by Voucher (Consolidated)",
+			default: "Categorize by Voucher (Consolidated)",
 		},
 		{
 			fieldname: "tax_id",

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -63,13 +63,17 @@ def validate_filters(filters, account_details):
 			if not account_details.get(account):
 				frappe.throw(_("Account {0} does not exists").format(account))
 
-	if filters.get("account") and filters.get("group_by") == "Group by Account":
+	if not filters.get("categorize_by") and filters.get("group_by"):
+		filters["categorize_by"] = filters["group_by"]
+		filters["categorize_by"] = filters["categorize_by"].replace("Group by", "Categorize by")
+
+	if filters.get("account") and filters.get("categorize_by") == "Categorize by Account":
 		filters.account = frappe.parse_json(filters.get("account"))
 		for account in filters.account:
 			if account_details[account].is_group == 0:
 				frappe.throw(_("Can not filter based on Child Account, if grouped by Account"))
 
-	if filters.get("voucher_no") and filters.get("group_by") in ["Group by Voucher"]:
+	if filters.get("voucher_no") and filters.get("categorize_by") in ["Categorize by Voucher"]:
 		frappe.throw(_("Can not filter based on Voucher No, if grouped by Voucher"))
 
 	if filters.from_date > filters.to_date:
@@ -163,9 +167,9 @@ def get_gl_entries(filters, accounting_dimensions):
 	if filters.get("include_dimensions"):
 		order_by_statement = "order by posting_date, creation"
 
-	if filters.get("group_by") == "Group by Voucher":
+	if filters.get("categorize_by") == "Categorize by Voucher":
 		order_by_statement = "order by posting_date, voucher_type, voucher_no"
-	if filters.get("group_by") == "Group by Account":
+	if filters.get("categorize_by") == "Categorize by Account":
 		order_by_statement = "order by account, posting_date, creation"
 
 	if filters.get("include_default_book_entries"):
@@ -260,7 +264,7 @@ def get_conditions(filters):
 	if filters.get("voucher_no_not_in"):
 		conditions.append("voucher_no not in %(voucher_no_not_in)s")
 
-	if filters.get("group_by") == "Group by Party" and not filters.get("party_type"):
+	if filters.get("categorize_by") == "Categorize by Party" and not filters.get("party_type"):
 		conditions.append("party_type in ('Customer', 'Supplier')")
 
 	if filters.get("party_type"):
@@ -272,7 +276,7 @@ def get_conditions(filters):
 	if not (
 		filters.get("account")
 		or filters.get("party")
-		or filters.get("group_by") in ["Group by Account", "Group by Party"]
+		or filters.get("categorize_by") in ["Categorize by Account", "Categorize by Party"]
 	):
 		if not ignore_is_opening:
 			conditions.append("(posting_date >=%(from_date)s or is_opening = 'Yes')")
@@ -374,26 +378,26 @@ def get_data_with_opening_closing(filters, account_details, accounting_dimension
 	# Opening for filtered account
 	data.append(totals.opening)
 
-	if filters.get("group_by") != "Group by Voucher (Consolidated)":
+	if filters.get("categorize_by") != "Categorize by Voucher (Consolidated)":
 		for _acc, acc_dict in gle_map.items():
 			# acc
 			if acc_dict.entries:
 				# opening
 				data.append({"debit_in_transaction_currency": None, "credit_in_transaction_currency": None})
-				if (not filters.get("group_by") and not filters.get("voucher_no")) or (
-					filters.get("group_by") and filters.get("group_by") != "Group by Voucher"
+				if (not filters.get("categorize_by") and not filters.get("voucher_no")) or (
+					filters.get("categorize_by") and filters.get("categorize_by") != "Categorize by Voucher"
 				):
 					data.append(acc_dict.totals.opening)
 
 				data += acc_dict.entries
 
 				# totals
-				if filters.get("group_by") or not filters.voucher_no:
+				if filters.get("categorize_by") or not filters.voucher_no:
 					data.append(acc_dict.totals.total)
 
 				# closing
-				if (not filters.get("group_by") and not filters.get("voucher_no")) or (
-					filters.get("group_by") and filters.get("group_by") != "Group by Voucher"
+				if (not filters.get("categorize_by") and not filters.get("voucher_no")) or (
+					filters.get("categorize_by") and filters.get("categorize_by") != "Categorize by Voucher"
 				):
 					data.append(acc_dict.totals.closing)
 
@@ -430,9 +434,9 @@ def get_totals_dict():
 
 
 def group_by_field(group_by):
-	if group_by == "Group by Party":
+	if group_by == "Categorize by Party":
 		return "party"
-	elif group_by in ["Group by Voucher (Consolidated)", "Group by Account"]:
+	elif group_by in ["Categorize by Voucher (Consolidated)", "Categorize by Account"]:
 		return "account"
 	else:
 		return "voucher_no"
@@ -440,7 +444,7 @@ def group_by_field(group_by):
 
 def initialize_gle_map(gl_entries, filters, totals_dict):
 	gle_map = OrderedDict()
-	group_by = group_by_field(filters.get("group_by"))
+	group_by = group_by_field(filters.get("categorize_by"))
 
 	for gle in gl_entries:
 		gle_map.setdefault(gle.get(group_by), _dict(totals=copy.deepcopy(totals_dict), entries=[]))
@@ -450,8 +454,8 @@ def initialize_gle_map(gl_entries, filters, totals_dict):
 def get_accountwise_gle(filters, accounting_dimensions, gl_entries, gle_map, totals):
 	entries = []
 	consolidated_gle = OrderedDict()
-	group_by = group_by_field(filters.get("group_by"))
-	group_by_voucher_consolidated = filters.get("group_by") == "Group by Voucher (Consolidated)"
+	group_by = group_by_field(filters.get("categorize_by"))
+	group_by_voucher_consolidated = filters.get("categorize_by") == "Categorize by Voucher (Consolidated)"
 
 	if filters.get("show_net_values_in_party_account"):
 		account_type_map = get_account_type_map(filters.get("company"))

erpnext/accounts/report/general_ledger/test_general_ledger.py

@@ -155,7 +155,7 @@ class TestGeneralLedger(FrappeTestCase):
 					"from_date": today(),
 					"to_date": today(),
 					"account": [account.name],
-					"group_by": "Group by Voucher (Consolidated)",
+					"categorize_by": "Categorize by Voucher (Consolidated)",
 				}
 			)
 		)
@@ -246,7 +246,7 @@ class TestGeneralLedger(FrappeTestCase):
 					"from_date": today(),
 					"to_date": today(),
 					"account": [account.name],
-					"group_by": "Group by Voucher (Consolidated)",
+					"categorize_by": "Categorize by Voucher (Consolidated)",
 					"ignore_err": True,
 				}
 			)
@@ -261,7 +261,7 @@ class TestGeneralLedger(FrappeTestCase):
 					"from_date": today(),
 					"to_date": today(),
 					"account": [account.name],
-					"group_by": "Group by Voucher (Consolidated)",
+					"categorize_by": "Categorize by Voucher (Consolidated)",
 					"ignore_err": False,
 				}
 			)
@@ -308,7 +308,7 @@ class TestGeneralLedger(FrappeTestCase):
 					"from_date": si.posting_date,
 					"to_date": si.posting_date,
 					"account": [si.debit_to],
-					"group_by": "Group by Voucher (Consolidated)",
+					"categorize_by": "Categorize by Voucher (Consolidated)",
 					"ignore_cr_dr_notes": False,
 				}
 			)
@@ -325,7 +325,7 @@ class TestGeneralLedger(FrappeTestCase):
 					"from_date": si.posting_date,
 					"to_date": si.posting_date,
 					"account": [si.debit_to],
-					"group_by": "Group by Voucher (Consolidated)",
+					"categorize_by": "Categorize by Voucher (Consolidated)",
 					"ignore_cr_dr_notes": True,
 				}
 			)

erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py

@@ -11,7 +11,7 @@ import erpnext
 from erpnext.accounts.report.item_wise_sales_register.item_wise_sales_register import (
 	add_sub_total_row,
 	add_total_row,
-	apply_group_by_conditions,
+	apply_order_by_conditions,
 	get_grand_total,
 	get_group_by_and_display_fields,
 	get_tax_accounts,
@@ -305,12 +305,6 @@ def apply_conditions(query, pi, pii, filters):
 	if filters.get("item_group"):
 		query = query.where(pii.item_group == filters.get("item_group"))
 
-	if not filters.get("group_by"):
-		query = query.orderby(pi.posting_date, order=Order.desc)
-		query = query.orderby(pii.item_group, order=Order.desc)
-	else:
-		query = apply_group_by_conditions(query, pi, pii, filters)
-
 	return query
 
 
@@ -372,7 +366,17 @@ def get_items(filters, additional_table_columns):
 
 	query = apply_conditions(query, pi, pii, filters)
 
-	return query.run(as_dict=True)
+	from frappe.desk.reportview import build_match_conditions
+
+	query, params = query.walk()
+	match_conditions = build_match_conditions(doctype)
+
+	if match_conditions:
+		query += " and " + match_conditions
+
+	query = apply_order_by_conditions(query, pi, pii, filters)
+
+	return frappe.db.sql(query, params, as_dict=True)
 
 
 def get_aii_accounts():

erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py

@@ -384,27 +384,24 @@ def apply_conditions(query, si, sii, filters, additional_conditions=None):
 			| (si.unrealized_profit_loss_account == filters.get("income_account"))
 		)
 
-	if not filters.get("group_by"):
-		query = query.orderby(si.posting_date, order=Order.desc)
-		query = query.orderby(sii.item_group, order=Order.desc)
-	else:
-		query = apply_group_by_conditions(query, si, sii, filters)
-
 	for key, value in (additional_conditions or {}).items():
 		query = query.where(si[key] == value)
 
 	return query
 
 
-def apply_group_by_conditions(query, si, ii, filters):
-	if filters.get("group_by") == "Invoice":
-		query = query.orderby(ii.parent, order=Order.desc)
+def apply_order_by_conditions(query, si, ii, filters):
+	if not filters.get("group_by"):
+		query += f" order by {si.posting_date} desc, {ii.item_group} desc"
+	elif filters.get("group_by") == "Invoice":
+		query += f" order by {ii.parent} desc"
 	elif filters.get("group_by") == "Item":
-		query = query.orderby(ii.item_code)
+		query += f" order by {ii.item_code}"
 	elif filters.get("group_by") == "Item Group":
-		query = query.orderby(ii.item_group)
+		query += f" order by {ii.item_group}"
 	elif filters.get("group_by") in ("Customer", "Customer Group", "Territory", "Supplier"):
-		query = query.orderby(si[frappe.scrub(filters.get("group_by"))])
+		filter_field = frappe.scrub(filters.get("group_by"))
+		query += f" order by {filter_field} desc"
 
 	return query
 
@@ -479,7 +476,17 @@ def get_items(filters, additional_query_columns, additional_conditions=None):
 
 	query = apply_conditions(query, si, sii, filters, additional_conditions)
 
-	return query.run(as_dict=True)
+	from frappe.desk.reportview import build_match_conditions
+
+	query, params = query.walk()
+	match_conditions = build_match_conditions("Sales Invoice")
+
+	if match_conditions:
+		query += " and " + match_conditions
+
+	query = apply_order_by_conditions(query, si, sii, filters)
+
+	return frappe.db.sql(query, params, as_dict=True)
 
 
 def get_delivery_notes_against_sales_order(item_list):

erpnext/accounts/report/purchase_register/purchase_register.py

@@ -397,7 +397,6 @@ def get_invoices(filters, additional_query_columns):
 			pi.mode_of_payment,
 		)
 		.where(pi.docstatus == 1)
-		.orderby(pi.posting_date, pi.name, order=Order.desc)
 	)
 
 	if additional_query_columns:
@@ -421,8 +420,17 @@ def get_invoices(filters, additional_query_columns):
 		)
 		query = query.where(pi.credit_to.isin(party_account))
 
-	invoices = query.run(as_dict=True)
-	return invoices
+	from frappe.desk.reportview import build_match_conditions
+
+	query, params = query.walk()
+	match_conditions = build_match_conditions("Purchase Invoice")
+
+	if match_conditions:
+		query += " and " + match_conditions
+
+	query += " order by posting_date desc, name desc"
+
+	return frappe.db.sql(query, params, as_dict=True)
 
 
 def get_conditions(filters, query, doctype):

erpnext/accounts/report/sales_register/sales_register.py

@@ -439,7 +439,6 @@ def get_invoices(filters, additional_query_columns):
 			si.company,
 		)
 		.where(si.docstatus == 1)
-		.orderby(si.posting_date, si.name, order=Order.desc)
 	)
 
 	if additional_query_columns:
@@ -457,8 +456,17 @@ def get_invoices(filters, additional_query_columns):
 		filters, query, doctype="Sales Invoice", child_doctype="Sales Invoice Item"
 	)
 
-	invoices = query.run(as_dict=True)
-	return invoices
+	from frappe.desk.reportview import build_match_conditions
+
+	query, params = query.walk()
+	match_conditions = build_match_conditions("Sales Invoice")
+
+	if match_conditions:
+		query += " and " + match_conditions
+
+	query += " order by posting_date desc, name desc"
+
+	return frappe.db.sql(query, params, as_dict=True)
 
 
 def get_conditions(filters, query, doctype):

erpnext/accounts/report/supplier_ledger_summary/test_supplier_ledger_summary.py

@@ -0,0 +1,91 @@
+import frappe
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import today
+
+from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
+from erpnext.accounts.report.supplier_ledger_summary.supplier_ledger_summary import execute
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+
+
+class TestSupplierLedgerSummary(FrappeTestCase, AccountsTestMixin):
+	def setUp(self):
+		self.create_company()
+		self.create_supplier()
+		self.create_item()
+		self.clear_old_entries()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def create_purchase_invoice(self, do_not_submit=False):
+		frappe.set_user("Administrator")
+		pi = make_purchase_invoice(
+			item=self.item,
+			company=self.company,
+			supplier=self.supplier,
+			is_return=False,
+			update_stock=False,
+			posting_date=frappe.utils.datetime.date(2021, 5, 1),
+			do_not_save=1,
+			rate=300,
+			price_list_rate=300,
+			qty=1,
+		)
+
+		pi = pi.save()
+		if not do_not_submit:
+			pi = pi.submit()
+		return pi
+
+	def test_basic_supplier_ledger_summary(self):
+		self.create_purchase_invoice()
+
+		filters = {"company": self.company, "from_date": today(), "to_date": today()}
+
+		expected = {
+			"party": "_Test Supplier",
+			"party_name": "_Test Supplier",
+			"opening_balance": 0,
+			"invoiced_amount": 300.0,
+			"paid_amount": 0,
+			"return_amount": 0,
+			"closing_balance": 300.0,
+			"currency": "INR",
+			"supplier_name": "_Test Supplier",
+		}
+
+		report_output = execute(filters)[1]
+		self.assertEqual(len(report_output), 1)
+		for field in expected:
+			with self.subTest(field=field):
+				self.assertEqual(report_output[0].get(field), expected.get(field))
+
+	def test_supplier_ledger_summary_with_filters(self):
+		self.create_purchase_invoice()
+
+		supplier_group = frappe.db.get_value("Supplier", self.supplier, "supplier_group")
+
+		filters = {
+			"company": self.company,
+			"from_date": today(),
+			"to_date": today(),
+			"supplier_group": supplier_group,
+		}
+
+		expected = {
+			"party": "_Test Supplier",
+			"party_name": "_Test Supplier",
+			"opening_balance": 0,
+			"invoiced_amount": 300.0,
+			"paid_amount": 0,
+			"return_amount": 0,
+			"closing_balance": 300.0,
+			"currency": "INR",
+			"supplier_name": "_Test Supplier",
+		}
+
+		report_output = execute(filters)[1]
+		self.assertEqual(len(report_output), 1)
+		for field in expected:
+			with self.subTest(field=field):
+				self.assertEqual(report_output[0].get(field), expected.get(field))

erpnext/accounts/report/tax_withholding_details/tax_withholding_details.py

@@ -4,6 +4,7 @@
 
 import frappe
 from frappe import _
+from frappe.utils import getdate
 
 
 def execute(filters=None):
@@ -33,6 +34,7 @@ def execute(filters=None):
 
 def validate_filters(filters):
 	"""Validate if dates are properly set"""
+	filters = frappe._dict(filters or {})
 	if filters.from_date > filters.to_date:
 		frappe.throw(_("From Date must be before To Date"))
 
@@ -68,7 +70,7 @@ def get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_
 				if not tax_withholding_category:
 					tax_withholding_category = party_map.get(party, {}).get("tax_withholding_category")
 
-				rate = tax_rate_map.get(tax_withholding_category)
+				rate = get_tax_withholding_rates(tax_rate_map.get(tax_withholding_category, []), posting_date)
 			if net_total_map.get((voucher_type, name)):
 				if voucher_type == "Journal Entry" and tax_amount and rate:
 					# back calcalute total amount from rate and tax_amount
@@ -435,12 +437,22 @@ def get_doc_info(vouchers, doctype, tax_category_map, net_total_map=None):
 def get_tax_rate_map(filters):
 	rate_map = frappe.get_all(
 		"Tax Withholding Rate",
-		filters={
-			"from_date": ("<=", filters.get("from_date")),
-			"to_date": (">=", filters.get("to_date")),
-		},
-		fields=["parent", "tax_withholding_rate"],
-		as_list=1,
+		filters={"from_date": ("<=", filters.to_date), "to_date": (">=", filters.from_date)},
+		fields=["parent", "tax_withholding_rate", "from_date", "to_date"],
 	)
 
-	return frappe._dict(rate_map)
+	rate_list = frappe._dict()
+
+	for rate in rate_map:
+		rate_list.setdefault(rate.parent, []).append(frappe._dict(rate))
+
+	return rate_list
+
+
+def get_tax_withholding_rates(tax_withholding, posting_date):
+	# returns the row that matches with the fiscal year from posting date
+	for rate in tax_withholding:
+		if getdate(rate.from_date) <= getdate(posting_date) <= getdate(rate.to_date):
+			return rate.tax_withholding_rate
+
+	return 0

erpnext/accounts/report/tax_withholding_details/test_tax_withholding_details.py

@@ -3,7 +3,7 @@
 
 import frappe
 from frappe.tests.utils import FrappeTestCase
-from frappe.utils import today
+from frappe.utils import add_to_date, today
 
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
@@ -60,6 +60,56 @@ class TestTaxWithholdingDetails(AccountsTestMixin, FrappeTestCase):
 		]
 		self.check_expected_values(result, expected_values)
 
+	def test_date_filters_in_multiple_tax_withholding_rules(self):
+		create_tax_category("TDS - 3", rate=10, account="TDS - _TC", cumulative_threshold=1)
+		# insert new rate in same fiscal year
+		fiscal_year = get_fiscal_year(today(), company="_Test Company")
+		mid_year = add_to_date(fiscal_year[1], months=6)
+		tds_doc = frappe.get_doc("Tax Withholding Category", "TDS - 3")
+		tds_doc.rates[0].to_date = mid_year
+		tds_doc.append(
+			"rates",
+			{
+				"tax_withholding_rate": 20,
+				"from_date": add_to_date(mid_year, days=1),
+				"to_date": fiscal_year[2],
+				"single_threshold": 1,
+				"cumulative_threshold": 1,
+			},
+		)
+
+		tds_doc.save()
+
+		inv_1 = make_purchase_invoice(rate=1000, do_not_submit=True)
+		inv_1.apply_tds = 1
+		inv_1.tax_withholding_category = "TDS - 3"
+		inv_1.submit()
+
+		inv_2 = make_purchase_invoice(
+			rate=1000, do_not_submit=True, posting_date=add_to_date(mid_year, days=1), do_not_save=True
+		)
+		inv_2.set_posting_time = 1
+
+		inv_1.apply_tds = 1
+		inv_2.tax_withholding_category = "TDS - 3"
+		inv_2.save()
+		inv_2.submit()
+
+		result = execute(
+			frappe._dict(
+				company="_Test Company",
+				party_type="Supplier",
+				from_date=fiscal_year[1],
+				to_date=fiscal_year[2],
+			)
+		)[1]
+
+		expected_values = [
+			[inv_1.name, "TDS - 3", 10.0, 5000, 500, 4500],
+			[inv_2.name, "TDS - 3", 20.0, 5000, 1000, 4000],
+		]
+		self.check_expected_values(result, expected_values)
+
 	def check_expected_values(self, result, expected_values):
 		for i in range(len(result)):
 			voucher = frappe._dict(result[i])

erpnext/accounts/report/trial_balance/trial_balance.py

@@ -116,6 +116,7 @@ def get_data(filters):
 		root_rgt=None,
 		ignore_closing_entries=not flt(filters.with_period_closing_entry_for_current_period),
 		ignore_opening_entries=True,
+		group_by_account=True,
 	)
 
 	calculate_values(

erpnext/accounts/test/accounts_mixin.py

@@ -85,6 +85,7 @@ class AccountsTestMixin:
 					"attribute_name": "bank",
 					"account_name": "HDFC",
 					"parent_account": "Bank Accounts - " + abbr,
+					"account_type": "Bank",
 				}
 			),
 			frappe._dict(

erpnext/accounts/test/test_reports.py

@@ -12,8 +12,8 @@ DEFAULT_FILTERS = {
 
 
 REPORT_FILTER_TEST_CASES: list[tuple[ReportName, ReportFilters]] = [
-	("General Ledger", {"group_by": "Group by Voucher (Consolidated)"}),
-	("General Ledger", {"group_by": "Group by Voucher (Consolidated)", "include_dimensions": 1}),
+	("General Ledger", {"categorize_by": "Categorize by Voucher (Consolidated)"}),
+	("General Ledger", {"categorize_by": "Categorize by Voucher (Consolidated)", "include_dimensions": 1}),
 	("Accounts Payable", {"range": "30, 60, 90, 120"}),
 	("Accounts Receivable", {"range": "30, 60, 90, 120"}),
 	("Consolidated Financial Statement", {"report": "Balance Sheet"}),

erpnext/accounts/utils.py

@@ -1854,14 +1854,17 @@ def update_voucher_outstanding(voucher_type, voucher_no, account, party_type, pa
 	):
 		outstanding = voucher_outstanding[0]
 		ref_doc = frappe.get_doc(voucher_type, voucher_no)
+		outstanding_amount = flt(
+			outstanding["outstanding_in_account_currency"], ref_doc.precision("outstanding_amount")
+		)
 
 		# Didn't use db_set for optimisation purpose
-		ref_doc.outstanding_amount = outstanding["outstanding_in_account_currency"] or 0.0
+		ref_doc.outstanding_amount = outstanding_amount
 		frappe.db.set_value(
 			voucher_type,
 			voucher_no,
 			"outstanding_amount",
-			outstanding["outstanding_in_account_currency"] or 0.0,
+			outstanding_amount,
 		)
 
 		ref_doc.set_status(update=True)

erpnext/accounts/workspace/accounting/accounting.json

@@ -621,7 +621,7 @@
    "doc_view": "List",
    "label": "Learn Accounting",
    "type": "URL",
-   "url": "https://frappe.school/courses/erpnext-accounting?utm_source=in_app"
+   "url": "https://school.frappe.io/lms/courses/erpnext-accounting?utm_source=in_app"
   },
   {
    "label": "Chart of Accounts",
@@ -670,4 +670,4 @@
   }
  ],
  "title": "Accounting"
-}
+}

erpnext/assets/doctype/asset/asset.js

@@ -658,10 +658,6 @@ frappe.ui.form.on("Asset", {
 					} else {
 						frm.set_value("purchase_invoice_item", data.purchase_invoice_item);
 					}
-
-					let is_editable = !data.is_multiple_items; // if multiple items, then fields should be read-only
-					frm.set_df_property("gross_purchase_amount", "read_only", is_editable);
-					frm.set_df_property("asset_quantity", "read_only", is_editable);
 				}
 			},
 		});

erpnext/assets/doctype/asset/asset.json

@@ -87,6 +87,7 @@
    "options": "ACC-ASS-.YYYY.-"
   },
   {
+   "allow_on_submit": 1,
    "depends_on": "item_code",
    "fetch_from": "item_code.item_name",
    "fetch_if_empty": 1,
@@ -511,6 +512,7 @@
    "fieldname": "total_asset_cost",
    "fieldtype": "Currency",
    "label": "Total Asset Cost",
+   "no_copy": 1,
    "options": "Company:company:default_currency",
    "read_only": 1
   },
@@ -519,6 +521,7 @@
    "fieldname": "additional_asset_cost",
    "fieldtype": "Currency",
    "label": "Additional Asset Cost",
+   "no_copy": 1,
    "options": "Company:company:default_currency",
    "read_only": 1
   },
@@ -592,7 +595,7 @@
    "link_fieldname": "target_asset"
   }
  ],
- "modified": "2025-02-20 14:09:05.421913",
+ "modified": "2025-04-24 15:31:47.373274",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset",
@@ -630,6 +633,7 @@
    "write": 1
   }
  ],
+ "row_format": "Dynamic",
  "show_name_in_global_search": 1,
  "sort_field": "modified",
  "sort_order": "DESC",

erpnext/assets/doctype/asset/asset.py

@@ -42,14 +42,15 @@ from erpnext.controllers.accounts_controller import AccountsController
 
 class Asset(AccountsController):
 	# begin: auto-generated types
+	# ruff: noqa
+
 	# This code is auto-generated. Do not modify anything in this block.
 
 	from typing import TYPE_CHECKING
 
 	if TYPE_CHECKING:
-		from frappe.types import DF
-
 		from erpnext.assets.doctype.asset_finance_book.asset_finance_book import AssetFinanceBook
+		from frappe.types import DF
 
 		additional_asset_cost: DF.Currency
 		amended_from: DF.Link | None
@@ -117,6 +118,7 @@ class Asset(AccountsController):
 		total_asset_cost: DF.Currency
 		total_number_of_depreciations: DF.Int
 		value_after_depreciation: DF.Currency
+	# ruff: noqa
 	# end: auto-generated types
 
 	def validate(self):
@@ -1167,7 +1169,6 @@ def get_values_from_purchase_doc(purchase_doc_name, item_code, doctype):
 		frappe.throw(_(f"Selected {doctype} does not contain the Item Code {item_code}"))
 
 	first_item = matching_items[0]
-	is_multiple_items = len(matching_items) > 1
 
 	return {
 		"company": purchase_doc.company,
@@ -1176,7 +1177,6 @@ def get_values_from_purchase_doc(purchase_doc_name, item_code, doctype):
 		"asset_quantity": first_item.qty,
 		"cost_center": first_item.cost_center or purchase_doc.get("cost_center"),
 		"asset_location": first_item.get("asset_location"),
-		"is_multiple_items": is_multiple_items,
 		"purchase_receipt_item": first_item.name if doctype == "Purchase Receipt" else None,
 		"purchase_invoice_item": first_item.name if doctype == "Purchase Invoice" else None,
 	}

erpnext/assets/doctype/asset/depreciation.py

@@ -718,16 +718,15 @@ def get_gl_entries_on_asset_disposal(
 
 
 def get_asset_details(asset, finance_book=None):
-	fixed_asset_account, accumulated_depr_account, _ = get_depreciation_accounts(
-		asset.asset_category, asset.company
+	value_after_depreciation = asset.get_value_after_depreciation(finance_book)
+	accumulated_depr_amount = flt(asset.gross_purchase_amount) - flt(value_after_depreciation)
+
+	fixed_asset_account, accumulated_depr_account, _ = get_asset_accounts(
+		asset.asset_category, asset.company, accumulated_depr_amount
 	)
 	disposal_account, depreciation_cost_center = get_disposal_account_and_cost_center(asset.company)
 	depreciation_cost_center = asset.cost_center or depreciation_cost_center
 
-	value_after_depreciation = asset.get_value_after_depreciation(finance_book)
-
-	accumulated_depr_amount = flt(asset.gross_purchase_amount) - flt(value_after_depreciation)
-
 	return (
 		fixed_asset_account,
 		asset,
@@ -739,6 +738,48 @@ def get_asset_details(asset, finance_book=None):
 	)
 
 
+def get_asset_accounts(asset_category, company, accumulated_depr_amount):
+	fixed_asset_account = accumulated_depreciation_account = depreciation_expense_account = None
+
+	accounts = frappe.db.get_value(
+		"Asset Category Account",
+		filters={"parent": asset_category, "company_name": company},
+		fieldname=[
+			"fixed_asset_account",
+			"accumulated_depreciation_account",
+			"depreciation_expense_account",
+		],
+		as_dict=1,
+	)
+
+	if accounts:
+		fixed_asset_account = accounts.fixed_asset_account
+		accumulated_depreciation_account = accounts.accumulated_depreciation_account
+		depreciation_expense_account = accounts.depreciation_expense_account
+
+	if not fixed_asset_account:
+		frappe.throw(_("Please set Fixed Asset Account in Asset Category {0}").format(asset_category))
+
+	if accumulated_depr_amount:
+		accounts = frappe.get_cached_value(
+			"Company", company, ["accumulated_depreciation_account", "depreciation_expense_account"]
+		)
+
+		if not accumulated_depreciation_account:
+			accumulated_depreciation_account = accounts[0]
+		if not depreciation_expense_account:
+			depreciation_expense_account = accounts[1]
+
+		if not accumulated_depreciation_account or not depreciation_expense_account:
+			frappe.throw(
+				_("Please set Depreciation related Accounts in Asset Category {0} or Company {1}").format(
+					asset_category, company
+				)
+			)
+
+	return fixed_asset_account, accumulated_depreciation_account, depreciation_expense_account
+
+
 def get_profit_gl_entries(
 	asset, profit_amount, gl_entries, disposal_account, depreciation_cost_center, date=None
 ):

erpnext/assets/doctype/asset_movement/asset_movement.py

@@ -152,6 +152,9 @@ class AssetMovement(Document):
 				""",
 				args,
 			)
+
+			self.validate_movement_cancellation(d, latest_movement_entry)
+
 			if latest_movement_entry:
 				current_location = latest_movement_entry[0][0]
 				current_employee = latest_movement_entry[0][1]
@@ -179,3 +182,12 @@ class AssetMovement(Document):
 					d.asset,
 					_("Asset issued to Employee {0}").format(get_link_to_form("Employee", current_employee)),
 				)
+
+	def validate_movement_cancellation(self, row, latest_movement_entry):
+		asset_doc = frappe.get_doc("Asset", row.asset)
+		if not latest_movement_entry and asset_doc.docstatus == 1:
+			frappe.throw(
+				_(
+					"Asset {0} has only one movement record. Please create another movement before deleting this one to maintain asset tracking."
+				).format(row.asset)
+			)

erpnext/assets/doctype/asset_movement/test_asset_movement.py

@@ -147,6 +147,45 @@ class TestAssetMovement(unittest.TestCase):
 		movement1.cancel()
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location")
 
+	def test_last_movement_cancellation_validation(self):
+		pr = make_purchase_receipt(item_code="Macbook Pro", qty=1, rate=100000.0, location="Test Location")
+
+		asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, "name")
+		asset = frappe.get_doc("Asset", asset_name)
+		asset.calculate_depreciation = 1
+		asset.available_for_use_date = "2020-06-06"
+		asset.purchase_date = "2020-06-06"
+		asset.append(
+			"finance_books",
+			{
+				"expected_value_after_useful_life": 10000,
+				"next_depreciation_date": "2020-12-31",
+				"depreciation_method": "Straight Line",
+				"total_number_of_depreciations": 3,
+				"frequency_of_depreciation": 10,
+			},
+		)
+		if asset.docstatus == 0:
+			asset.submit()
+
+		AssetMovement = frappe.qb.DocType("Asset Movement")
+		AssetMovementItem = frappe.qb.DocType("Asset Movement Item")
+
+		asset_movement = (
+			frappe.qb.from_(AssetMovement)
+			.join(AssetMovementItem)
+			.on(AssetMovementItem.parent == AssetMovement.name)
+			.select(AssetMovement.name)
+			.where(
+				(AssetMovementItem.asset == asset.name)
+				& (AssetMovement.company == asset.company)
+				& (AssetMovement.docstatus == 1)
+			)
+		).run(as_dict=True)
+
+		asset_movement_doc = frappe.get_doc("Asset Movement", asset_movement[0].name)
+		self.assertRaises(frappe.ValidationError, asset_movement_doc.cancel)
+
 
 def create_asset_movement(**args):
 	args = frappe._dict(args)

erpnext/assets/doctype/asset_repair/asset_repair.py

@@ -98,9 +98,11 @@ class AssetRepair(AccountsController):
 
 			self.increase_asset_value()
 
+			total_repair_cost = self.get_total_value_of_stock_consumed()
 			if self.capitalize_repair_cost:
-				self.asset_doc.total_asset_cost += self.repair_cost
-				self.asset_doc.additional_asset_cost += self.repair_cost
+				total_repair_cost += self.repair_cost
+			self.asset_doc.total_asset_cost += total_repair_cost
+			self.asset_doc.additional_asset_cost += total_repair_cost
 
 			if self.get("stock_consumption"):
 				self.check_for_stock_items_and_warehouse()
@@ -139,9 +141,11 @@ class AssetRepair(AccountsController):
 
 			self.decrease_asset_value()
 
+			total_repair_cost = self.get_total_value_of_stock_consumed()
 			if self.capitalize_repair_cost:
-				self.asset_doc.total_asset_cost -= self.repair_cost
-				self.asset_doc.additional_asset_cost -= self.repair_cost
+				total_repair_cost += self.repair_cost
+			self.asset_doc.total_asset_cost -= total_repair_cost
+			self.asset_doc.additional_asset_cost -= total_repair_cost
 
 			if self.get("capitalize_repair_cost"):
 				self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry")

erpnext/buying/doctype/purchase_order/purchase_order.json

@@ -109,8 +109,10 @@
   "contact_mobile",
   "contact_email",
   "shipping_address_section",
-  "shipping_address",
+  "dispatch_address",
+  "dispatch_address_display",
   "column_break_99",
+  "shipping_address",
   "shipping_address_display",
   "company_billing_address_section",
   "billing_address",
@@ -1269,13 +1271,28 @@
    "fieldtype": "Tab Break",
    "label": "Connections",
    "show_dashboard": 1
+  },
+  {
+   "fieldname": "dispatch_address",
+   "fieldtype": "Link",
+   "label": "Dispatch Address",
+   "options": "Address",
+   "print_hide": 1
+  },
+  {
+   "fieldname": "dispatch_address_display",
+   "fieldtype": "Text Editor",
+   "label": "Dispatch Address Details",
+   "print_hide": 1,
+   "read_only": 1
   }
  ],
+ "grid_page_length": 50,
  "icon": "fa fa-file-text",
  "idx": 105,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-03-20 16:03:31.611808",
+ "modified": "2025-04-09 16:54:08.836106",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Purchase Order",
@@ -1322,6 +1339,7 @@
    "write": 1
   }
  ],
+ "row_format": "Dynamic",
  "search_fields": "status, transaction_date, supplier, grand_total",
  "show_name_in_global_search": 1,
  "sort_field": "modified",

erpnext/buying/doctype/purchase_order/purchase_order.py

@@ -92,6 +92,8 @@ class PurchaseOrder(BuyingController):
 		customer_name: DF.Data | None
 		disable_rounded_total: DF.Check
 		discount_amount: DF.Currency
+		dispatch_address: DF.Link | None
+		dispatch_address_display: DF.TextEditor | None
 		from_date: DF.Date | None
 		grand_total: DF.Currency
 		group_same_items: DF.Check

erpnext/buying/doctype/purchase_order/purchase_order_list.js

@@ -22,15 +22,27 @@ frappe.listview_settings["Purchase Order"] = {
 				return [
 					__("To Receive and Bill"),
 					"orange",
-					"per_received,<,100|per_billed,<,100|status,!=,Closed",
+					"per_received,<,100|per_billed,<,100|status,!=,Closed|docstatus,=,1",
 				];
 			} else {
-				return [__("To Receive"), "orange", "per_received,<,100|per_billed,=,100|status,!=,Closed"];
+				return [
+					__("To Receive"),
+					"orange",
+					"per_received,<,100|per_billed,=,100|status,!=,Closed|docstatus,=,1",
+				];
 			}
 		} else if (flt(doc.per_received) >= 100 && flt(doc.per_billed) < 100 && doc.status !== "Closed") {
-			return [__("To Bill"), "orange", "per_received,=,100|per_billed,<,100|status,!=,Closed"];
+			return [
+				__("To Bill"),
+				"orange",
+				"per_received,=,100|per_billed,<,100|status,!=,Closed|docstatus,=,1",
+			];
 		} else if (flt(doc.per_received) >= 100 && flt(doc.per_billed) == 100 && doc.status !== "Closed") {
-			return [__("Completed"), "green", "per_received,=,100|per_billed,=,100|status,!=,Closed"];
+			return [
+				__("Completed"),
+				"green",
+				"per_received,=,100|per_billed,=,100|status,!=,Closed|docstatus,=,1",
+			];
 		}
 	},
 	onload: function (listview) {

erpnext/buying/doctype/purchase_order_item/purchase_order_item.json

@@ -43,6 +43,7 @@
   "column_break_28",
   "discount_percentage",
   "discount_amount",
+  "distributed_discount_amount",
   "base_rate_with_margin",
   "sec_break2",
   "rate",
@@ -781,7 +782,7 @@
   },
   {
    "collapsible": 1,
-   "collapsible_depends_on": "eval: doc.margin_type || doc.discount_amount",
+   "collapsible_depends_on": "eval: doc.margin_type || doc.discount_amount || doc.distributed_discount_amount",
    "fieldname": "discount_and_margin_section",
    "fieldtype": "Section Break",
    "label": "Discount and Margin"
@@ -911,6 +912,12 @@
    "fieldname": "column_break_fyqr",
    "fieldtype": "Column Break"
   },
+  {
+   "fieldname": "distributed_discount_amount",
+   "fieldtype": "Currency",
+   "label": "Distributed Discount Amount",
+   "options": "currency"
+  },
   {
    "allow_on_submit": 1,
    "depends_on": "eval:parent.is_subcontracted && !parent.is_old_subcontracting_flow",
@@ -927,7 +934,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-03-13 17:27:43.468602",
+ "modified": "2025-03-13 17:27:44.468602",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Purchase Order Item",

erpnext/buying/doctype/purchase_order_item/purchase_order_item.py

@@ -37,6 +37,7 @@ class PurchaseOrderItem(Document):
 		description: DF.TextEditor | None
 		discount_amount: DF.Currency
 		discount_percentage: DF.Percent
+		distributed_discount_amount: DF.Currency
 		expected_delivery_date: DF.Date | None
 		expense_account: DF.Link | None
 		fg_item: DF.Link | None

erpnext/buying/doctype/request_for_quotation/request_for_quotation.js

@@ -154,9 +154,31 @@ frappe.ui.form.on("Request for Quotation", {
 			);
 
 			frm.page.set_inner_btn_group_as_primary(__("Create"));
+
+			frm.add_custom_button(
+				__("Supplier Quotation Comparison"),
+				function () {
+					frm.trigger("show_supplier_quotation_comparison");
+				},
+				__("View")
+			);
 		}
 	},
 
+	show_supplier_quotation_comparison(frm) {
+		const today = new Date();
+		const oneMonthAgo = new Date(today);
+		oneMonthAgo.setMonth(today.getMonth() - 1);
+
+		frappe.route_options = {
+			company: frm.doc.company,
+			from_date: moment(oneMonthAgo).format("YYYY-MM-DD"),
+			to_date: moment(today).format("YYYY-MM-DD"),
+			request_for_quotation: frm.doc.name,
+		};
+		frappe.set_route("query-report", "Supplier Quotation Comparison");
+	},
+
 	make_supplier_quotation: function (frm) {
 		var doc = frm.doc;
 		var dialog = new frappe.ui.Dialog({

erpnext/buying/doctype/supplier_quotation/supplier_quotation.py

@@ -234,6 +234,7 @@ def make_purchase_order(source_name, target_doc=None):
 		{
 			"Supplier Quotation": {
 				"doctype": "Purchase Order",
+				"field_no_map": ["transaction_date"],
 				"validation": {
 					"docstatus": ["=", 1],
 				},

erpnext/buying/doctype/supplier_quotation/test_supplier_quotation.py

@@ -4,6 +4,7 @@
 
 import frappe
 from frappe.tests.utils import FrappeTestCase
+from frappe.utils import add_days, today
 
 
 class TestPurchaseOrder(FrappeTestCase):
@@ -25,7 +26,7 @@ class TestPurchaseOrder(FrappeTestCase):
 
 		for doc in po.get("items"):
 			if doc.get("item_code"):
-				doc.set("schedule_date", "2013-04-12")
+				doc.set("schedule_date", add_days(today(), 1))
 
 		po.insert()
 

erpnext/buying/doctype/supplier_quotation_item/supplier_quotation_item.json

@@ -32,6 +32,7 @@
   "price_list_rate",
   "discount_percentage",
   "discount_amount",
+  "distributed_discount_amount",
   "col_break_price_list",
   "base_price_list_rate",
   "sec_break1",
@@ -565,13 +566,19 @@
   {
    "fieldname": "dimension_col_break",
    "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "distributed_discount_amount",
+   "fieldtype": "Currency",
+   "label": "Distributed Discount Amount",
+   "options": "currency"
   }
  ],
  "idx": 1,
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-11-17 12:25:26.235367",
+ "modified": "2024-06-02 06:22:18.864822",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Supplier Quotation Item",

erpnext/buying/doctype/supplier_quotation_item/supplier_quotation_item.py

@@ -26,6 +26,7 @@ class SupplierQuotationItem(Document):
 		description: DF.TextEditor | None
 		discount_amount: DF.Currency
 		discount_percentage: DF.Percent
+		distributed_discount_amount: DF.Currency
 		expected_delivery_date: DF.Date | None
 		image: DF.Attach | None
 		is_free_item: DF.Check

erpnext/buying/report/supplier_quotation_comparison/supplier_quotation_comparison.html

@@ -94,9 +94,6 @@
     </script>
 
  </head>
-<div style="margin-bottom: 7px;" class="text-center">
-	{%= frappe.boot.letter_heads[frappe.defaults.get_default("letter_head")] %}
-</div>
 <h2 class="text-center">{%= __(report.report_name) %}</h2>
 <h4 class="text-center">{%= filters.item %} </h4>
 
@@ -124,9 +121,7 @@
 	</tbody>
 </table>
 
-<h4 class="text-center"> Analysis Chart </h4>
+<h4 class="text-center">{%= __("Analysis Chart") %}</h4>
 <div id="chart_div"></div>
 
-
-
-<p class="text-right text-muted">Printed On {%= frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string()) %}</p>
+<p class="text-right text-muted">{%= __("Printed on {0}", [frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string())]) %}</p>

erpnext/buying/report/supplier_quotation_comparison/supplier_quotation_comparison.js

@@ -76,14 +76,14 @@ frappe.query_reports["Supplier Quotation Comparison"] = {
 			},
 		},
 		{
-			fieldname: "group_by",
-			label: __("Group by"),
+			fieldname: "categorize_by",
+			label: __("Categorize by"),
 			fieldtype: "Select",
 			options: [
-				{ label: __("Group by Supplier"), value: "Group by Supplier" },
-				{ label: __("Group by Item"), value: "Group by Item" },
+				{ label: __("Categorize by Supplier"), value: "Categorize by Supplier" },
+				{ label: __("Categorize by Item"), value: "Categorize by Item" },
 			],
-			default: __("Group by Supplier"),
+			default: __("Categorize by Supplier"),
 		},
 		{
 			fieldtype: "Check",

erpnext/buying/report/supplier_quotation_comparison/supplier_quotation_comparison.py

@@ -15,6 +15,8 @@ def execute(filters=None):
 	if not filters:
 		return [], []
 
+	validate_filters(filters)
+
 	columns = get_columns(filters)
 	supplier_quotation_data = get_data(filters)
 
@@ -24,6 +26,12 @@ def execute(filters=None):
 	return columns, data, message, chart_data
 
 
+def validate_filters(filters):
+	if not filters.get("categorize_by") and filters.get("group_by"):
+		filters["categorize_by"] = filters["group_by"]
+		filters["categorize_by"] = filters["categorize_by"].replace("Group by", "Categorize by")
+
+
 def get_data(filters):
 	sq = frappe.qb.DocType("Supplier Quotation")
 	sq_item = frappe.qb.DocType("Supplier Quotation Item")
@@ -82,20 +90,14 @@ def prepare_data(supplier_quotation_data, filters):
 	group_wise_map = defaultdict(list)
 	supplier_qty_price_map = {}
 
-	group_by_field = "supplier_name" if filters.get("group_by") == "Group by Supplier" else "item_code"
-	company_currency = frappe.db.get_default("currency")
+	group_by_field = (
+		"supplier_name" if filters.get("categorize_by") == "Categorize by Supplier" else "item_code"
+	)
 	float_precision = cint(frappe.db.get_default("float_precision")) or 2
 
 	for data in supplier_quotation_data:
 		group = data.get(group_by_field)  # get item or supplier value for this row
 
-		supplier_currency = frappe.db.get_value("Supplier", data.get("supplier_name"), "default_currency")
-
-		if supplier_currency:
-			exchange_rate = get_exchange_rate(supplier_currency, company_currency)
-		else:
-			exchange_rate = 1
-
 		row = {
 			"item_code": ""
 			if group_by_field == "item_code"
@@ -103,7 +105,7 @@ def prepare_data(supplier_quotation_data, filters):
 			"supplier_name": "" if group_by_field == "supplier_name" else data.get("supplier_name"),
 			"quotation": data.get("parent"),
 			"qty": data.get("qty"),
-			"price": flt(data.get("amount") * exchange_rate, float_precision),
+			"price": flt(data.get("amount"), float_precision),
 			"uom": data.get("uom"),
 			"price_list_currency": data.get("price_list_currency"),
 			"currency": data.get("currency"),
@@ -209,6 +211,13 @@ def get_columns(filters):
 	columns = [
 		{"fieldname": "uom", "label": _("UOM"), "fieldtype": "Link", "options": "UOM", "width": 90},
 		{"fieldname": "qty", "label": _("Quantity"), "fieldtype": "Float", "width": 80},
+		{
+			"fieldname": "stock_uom",
+			"label": _("Stock UOM"),
+			"fieldtype": "Link",
+			"options": "UOM",
+			"width": 90,
+		},
 		{
 			"fieldname": "currency",
 			"label": _("Currency"),
@@ -223,13 +232,6 @@ def get_columns(filters):
 			"options": "currency",
 			"width": 110,
 		},
-		{
-			"fieldname": "stock_uom",
-			"label": _("Stock UOM"),
-			"fieldtype": "Link",
-			"options": "UOM",
-			"width": 90,
-		},
 		{
 			"fieldname": "price_per_unit",
 			"label": _("Price per Unit (Stock UOM)"),
@@ -274,7 +276,7 @@ def get_columns(filters):
 		},
 	]
 
-	if filters.get("group_by") == "Group by Item":
+	if filters.get("categorize_by") == "Categorize by Item":
 		group_by_columns.reverse()
 
 	columns[0:0] = group_by_columns  # add positioned group by columns to the report

erpnext/buying/workspace/buying/buying.json

@@ -537,7 +537,7 @@
    "doc_view": "List",
    "label": "Learn Procurement",
    "type": "URL",
-   "url": "https://frappe.school/courses/procurement?utm_source=in_app"
+   "url": "https://school.frappe.io/lms/courses/procurement?utm_source=in_app"
   },
   {
    "color": "Yellow",
@@ -572,4 +572,4 @@
   }
  ],
  "title": "Buying"
-}
+}

erpnext/controllers/accounts_controller.py

@@ -165,6 +165,48 @@ class AccountsController(TransactionBase):
 						raise_exception=1,
 					)
 
+	def validate_against_voucher_outstanding(self):
+		from frappe.model.meta import get_meta
+
+		if not get_meta(self.doctype).has_field("outstanding_amount"):
+			return
+
+		if self.get("is_return") and self.return_against and not self.get("is_pos"):
+			against_voucher_outstanding = frappe.get_value(
+				self.doctype, self.return_against, "outstanding_amount"
+			)
+			document_type = "Credit Note" if self.doctype == "Sales Invoice" else "Debit Note"
+
+			msg = ""
+			if self.get("update_outstanding_for_self"):
+				msg = (
+					"We can see {0} is made against {1}. If you want {1}'s outstanding to be updated, "
+					"uncheck '{2}' checkbox. <br><br>Or"
+				).format(
+					frappe.bold(document_type),
+					get_link_to_form(self.doctype, self.get("return_against")),
+					frappe.bold(_("Update Outstanding for Self")),
+				)
+
+			elif not self.update_outstanding_for_self and (
+				abs(flt(self.rounded_total) or flt(self.grand_total)) > flt(against_voucher_outstanding)
+			):
+				self.update_outstanding_for_self = 1
+				msg = (
+					"The outstanding amount {} in {} is lesser than {}. Updating the outstanding to this invoice. <br><br>And"
+				).format(
+					against_voucher_outstanding,
+					get_link_to_form(self.doctype, self.get("return_against")),
+					flt(abs(self.outstanding_amount)),
+				)
+
+			if msg:
+				msg += " you can use {} tool to reconcile against {} later.".format(
+					get_link_to_form("Payment Reconciliation", "Payment Reconciliation"),
+					get_link_to_form(self.doctype, self.get("return_against")),
+				)
+				frappe.msgprint(_(msg))
+
 	def validate(self):
 		if not self.get("is_return") and not self.get("is_debit_note"):
 			self.validate_qty_is_not_zero()
@@ -193,6 +235,7 @@ class AccountsController(TransactionBase):
 		self.disable_tax_included_prices_for_internal_transfer()
 		self.set_incoming_rate()
 		self.init_internal_values()
+		self.validate_against_voucher_outstanding()
 
 		# Need to set taxes based on taxes_and_charges template
 		# before calculating taxes and totals
@@ -228,20 +271,6 @@ class AccountsController(TransactionBase):
 					)
 				)
 
-			if self.get("is_return") and self.get("return_against") and not self.get("is_pos"):
-				if self.get("update_outstanding_for_self"):
-					document_type = "Credit Note" if self.doctype == "Sales Invoice" else "Debit Note"
-					frappe.msgprint(
-						_(
-							"We can see {0} is made against {1}. If you want {1}'s outstanding to be updated, uncheck '{2}' checkbox. <br><br> Or you can use {3} tool to reconcile against {1} later."
-						).format(
-							frappe.bold(document_type),
-							get_link_to_form(self.doctype, self.get("return_against")),
-							frappe.bold(_("Update Outstanding for Self")),
-							get_link_to_form("Payment Reconciliation", "Payment Reconciliation"),
-						)
-					)
-
 			pos_check_field = "is_pos" if self.doctype == "Sales Invoice" else "is_paid"
 			if cint(self.allocate_advances_automatically) and not cint(self.get(pos_check_field)):
 				self.set_advances()
@@ -750,17 +779,10 @@ class AccountsController(TransactionBase):
 			if not self.due_date:
 				frappe.throw(_("Due Date is mandatory"))
 
-			validate_due_date(
-				posting_date,
-				self.due_date,
-				self.payment_terms_template,
-			)
+			validate_due_date(posting_date, self.due_date, None, self.payment_terms_template, self.doctype)
 		elif self.doctype == "Purchase Invoice":
 			validate_due_date(
-				posting_date,
-				self.due_date,
-				self.bill_date,
-				self.payment_terms_template,
+				posting_date, self.due_date, self.bill_date, self.payment_terms_template, self.doctype
 			)
 
 	def set_price_list_currency(self, buying_or_selling):
@@ -1812,8 +1834,11 @@ class AccountsController(TransactionBase):
 			and self.get("discount_amount")
 			and self.get("additional_discount_account")
 		):
-			amount = item.amount
-			base_amount = item.base_amount
+			amount += item.distributed_discount_amount
+			base_amount += flt(
+				item.distributed_discount_amount * self.get("conversion_rate"),
+				item.precision("distributed_discount_amount"),
+			)
 
 		return amount, base_amount
 
@@ -2328,7 +2353,9 @@ class AccountsController(TransactionBase):
 				and automatically_fetch_payment_terms
 				and self.linked_order_has_payment_terms(po_or_so, fieldname, doctype)
 			):
-				self.fetch_payment_terms_from_order(po_or_so, doctype)
+				self.fetch_payment_terms_from_order(
+					po_or_so, doctype, grand_total, base_grand_total, automatically_fetch_payment_terms
+				)
 				if self.get("payment_terms_template"):
 					self.ignore_default_payment_terms_template = 1
 			elif self.get("payment_terms_template"):
@@ -2364,15 +2391,16 @@ class AccountsController(TransactionBase):
 						base_grand_total * flt(d.invoice_portion) / 100, d.precision("base_payment_amount")
 					)
 					d.outstanding = d.payment_amount
-					d.base_outstanding = flt(
-						d.payment_amount * self.get("conversion_rate"), d.precision("base_outstanding")
-					)
+					d.base_outstanding = d.base_payment_amount
 				elif not d.invoice_portion:
 					d.base_payment_amount = flt(
 						d.payment_amount * self.get("conversion_rate"), d.precision("base_payment_amount")
 					)
+					d.base_outstanding = d.base_payment_amount
 		else:
-			self.fetch_payment_terms_from_order(po_or_so, doctype)
+			self.fetch_payment_terms_from_order(
+				po_or_so, doctype, grand_total, base_grand_total, automatically_fetch_payment_terms
+			)
 			self.ignore_default_payment_terms_template = 1
 
 	def get_order_details(self):
@@ -2410,7 +2438,9 @@ class AccountsController(TransactionBase):
 	def linked_order_has_payment_schedule(self, po_or_so):
 		return frappe.get_all("Payment Schedule", filters={"parent": po_or_so})
 
-	def fetch_payment_terms_from_order(self, po_or_so, po_or_so_doctype):
+	def fetch_payment_terms_from_order(
+		self, po_or_so, po_or_so_doctype, grand_total, base_grand_total, automatically_fetch_payment_terms
+	):
 		"""
 		Fetch Payment Terms from Purchase/Sales Order on creating a new Purchase/Sales Invoice.
 		"""
@@ -2426,12 +2456,25 @@ class AccountsController(TransactionBase):
 				"invoice_portion": schedule.invoice_portion,
 				"mode_of_payment": schedule.mode_of_payment,
 				"description": schedule.description,
-				"payment_amount": schedule.payment_amount,
-				"base_payment_amount": schedule.base_payment_amount,
-				"outstanding": schedule.outstanding,
 				"paid_amount": schedule.paid_amount,
 			}
 
+			if automatically_fetch_payment_terms:
+				payment_schedule["payment_amount"] = flt(
+					grand_total * flt(payment_schedule["invoice_portion"]) / 100,
+					schedule.precision("payment_amount"),
+				)
+				payment_schedule["base_payment_amount"] = flt(
+					base_grand_total * flt(payment_schedule["invoice_portion"]) / 100,
+					schedule.precision("base_payment_amount"),
+				)
+				payment_schedule["outstanding"] = payment_schedule["payment_amount"]
+			else:
+				payment_schedule["base_payment_amount"] = flt(
+					schedule.base_payment_amount * self.get("conversion_rate"),
+					schedule.precision("base_payment_amount"),
+				)
+
 			if schedule.discount_type == "Percentage":
 				payment_schedule["discount_type"] = schedule.discount_type
 				payment_schedule["discount"] = schedule.discount

erpnext/controllers/buying_controller.py

@@ -98,7 +98,29 @@ class BuyingController(SubcontractingController):
 						item.from_warehouse,
 						type_of_transaction="Outward",
 						do_not_submit=True,
+						qty=item.qty,
 					)
+				elif (
+					not self.is_new()
+					and item.serial_and_batch_bundle
+					and next(
+						(
+							old_item
+							for old_item in self.get_doc_before_save().items
+							if old_item.name == item.name and old_item.qty != item.qty
+						),
+						None,
+					)
+					and len(
+						sabe := frappe.get_all(
+							"Serial and Batch Entry",
+							filters={"parent": item.serial_and_batch_bundle, "serial_no": ["is", "not set"]},
+							pluck="name",
+						)
+					)
+					== 1
+				):
+					frappe.set_value("Serial and Batch Entry", sabe[0], "qty", item.qty)
 
 	def set_rate_for_standalone_debit_note(self):
 		if self.get("is_return") and self.get("update_stock") and not self.return_against:
@@ -141,6 +163,7 @@ class BuyingController(SubcontractingController):
 					company=self.company,
 					party_address=self.get("supplier_address"),
 					shipping_address=self.get("shipping_address"),
+					dispatch_address=self.get("dispatch_address"),
 					company_address=self.get("billing_address"),
 					fetch_payment_terms_template=not self.get("ignore_default_payment_terms_template"),
 					ignore_permissions=self.flags.ignore_permissions,
@@ -238,6 +261,7 @@ class BuyingController(SubcontractingController):
 		address_dict = {
 			"supplier_address": "address_display",
 			"shipping_address": "shipping_address_display",
+			"dispatch_address": "dispatch_address_display",
 			"billing_address": "billing_address_display",
 		}
 

erpnext/controllers/queries.py

@@ -8,9 +8,10 @@ from collections import OrderedDict, defaultdict
 import frappe
 from frappe import qb, scrub
 from frappe.desk.reportview import get_filters_cond, get_match_cond
+from frappe.permissions import has_permission
 from frappe.query_builder import Criterion, CustomFunction
 from frappe.query_builder.functions import Concat, Locate, Sum
-from frappe.utils import nowdate, today, unique
+from frappe.utils import cint, nowdate, today, unique
 from pypika import Order
 
 import erpnext
@@ -20,10 +21,28 @@ from erpnext.stock.get_item_details import _get_item_tax_template
 # searches for active employees
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
-def employee_query(doctype, txt, searchfield, start, page_len, filters):
+def employee_query(
+	doctype,
+	txt,
+	searchfield,
+	start,
+	page_len,
+	filters,
+	reference_doctype: str | None = None,
+	ignore_user_permissions: bool = False,
+):
 	doctype = "Employee"
 	conditions = []
 	fields = get_fields(doctype, ["name", "employee_name"])
+	ignore_permissions = False
+
+	if reference_doctype and ignore_user_permissions:
+		ignore_permissions = has_ignored_field(reference_doctype, doctype) and has_permission(
+			doctype,
+			ptype="select" if frappe.only_has_select_perm(doctype) else "read",
+		)
+
+	mcond = "" if ignore_permissions else get_match_cond(doctype)
 
 	return frappe.db.sql(
 		"""select {fields} from `tabEmployee`
@@ -42,13 +61,32 @@ def employee_query(doctype, txt, searchfield, start, page_len, filters):
 				"fields": ", ".join(fields),
 				"key": searchfield,
 				"fcond": get_filters_cond(doctype, filters, conditions),
-				"mcond": get_match_cond(doctype),
+				"mcond": mcond,
 			}
 		),
 		{"txt": "%%%s%%" % txt, "_txt": txt.replace("%", ""), "start": start, "page_len": page_len},
 	)
 
 
+def has_ignored_field(reference_doctype, doctype):
+	meta = frappe.get_meta(reference_doctype)
+	for field in meta.fields:
+		if not field.ignore_user_permissions:
+			continue
+		if field.fieldtype == "Link" and field.options == doctype:
+			return True
+		elif field.fieldtype == "Dynamic Link":
+			options = meta.get_link_doctype(field.fieldname)
+			if not options:
+				continue
+			if isinstance(options, str):
+				options = options.split("\n")
+			if doctype in options or "DocType" in options:
+				return True
+
+	return False
+
+
 # searches for leads which are not converted
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
@@ -898,3 +936,32 @@ def get_filtered_child_rows(doctype, txt, searchfield, start, page_len, filters)
 		)
 
 	return query.run(as_dict=False)
+
+
+@frappe.whitelist()
+@frappe.validate_and_sanitize_search_inputs
+def get_item_uom_query(doctype, txt, searchfield, start, page_len, filters):
+	if frappe.db.get_single_value("Stock Settings", "allow_uom_with_conversion_rate_defined_in_item"):
+		query_filters = {"parent": filters.get("item_code")}
+
+		if txt:
+			query_filters["uom"] = ["like", f"%{txt}%"]
+
+		return frappe.get_all(
+			"UOM Conversion Detail",
+			filters=query_filters,
+			fields=["uom", "conversion_factor"],
+			limit_start=start,
+			limit_page_length=page_len,
+			order_by="idx",
+			as_list=1,
+		)
+
+	return frappe.get_all(
+		"UOM",
+		filters={"name": ["like", f"%{txt}%"], "enabled": 1},
+		fields=["name"],
+		limit_start=start,
+		limit_page_length=page_len,
+		as_list=1,
+	)

erpnext/controllers/sales_and_purchase_return.py

@@ -347,6 +347,16 @@ def make_return_doc(doctype: str, source_name: str, target_doc=None, return_agai
 		"Company", company, "default_warehouse_for_sales_return"
 	)
 
+	if doctype == "Sales Invoice":
+		inv_is_consolidated, inv_is_pos = frappe.db.get_value(
+			"Sales Invoice", source_name, ["is_consolidated", "is_pos"]
+		)
+		if inv_is_consolidated and inv_is_pos:
+			frappe.throw(
+				_("Cannot create return for consolidated invoice {0}.").format(source_name),
+				title=_("Cannot Create Return"),
+			)
+
 	def set_missing_values(source, target):
 		doc = frappe.get_doc(target)
 		doc.is_return = 1