chore(release): Bumped to Version 15.119.0

# [15.119.0](https://github.com/frappe/erpnext/compare/v15.118.3...v15.119.0) (2026-08-04)

### Bug Fixes

* **accounts:** fetch deferred invoice docs on non-empty `sales_docs` or `purchase_docs` in repost accounting ledger (backport [#57753](https://github.com/frappe/erpnext/issues/57753)) ([#57756](https://github.com/frappe/erpnext/issues/57756)) ([ee4e296](ee4e296ce6))
* **accounts:** skip party dashboard without invoice permission ([9d417da](9d417da3d8))
* **accounts:** update AU standard chart of accounts (backport [#57145](https://github.com/frappe/erpnext/issues/57145)) ([#57607](https://github.com/frappe/erpnext/issues/57607)) ([15c3817](15c381701d))
* **assets:** add permission checks on whitelisted methods on `asset_capitalization` ([338fff2](338fff20db))
* do not fetch a random inventory account when multiple inventory accounts exist (backport [#57626](https://github.com/frappe/erpnext/issues/57626)) ([#57631](https://github.com/frappe/erpnext/issues/57631)) ([972a990](972a990b01))
* escape data in multiple templates (backport [#57742](https://github.com/frappe/erpnext/issues/57742)) ([#57769](https://github.com/frappe/erpnext/issues/57769)) ([928f984](928f984198))
* filter Accounts Receivable by invoice sales partner (backport [#57628](https://github.com/frappe/erpnext/issues/57628)) ([#57646](https://github.com/frappe/erpnext/issues/57646)) ([ebf5a46](ebf5a462b3))
* guard against None row in get_stock_balance_for (backport [#57567](https://github.com/frappe/erpnext/issues/57567)) ([72f293f](72f293f131))
* Ignore permission while deleting user permission ([faa7c46](faa7c466b1))
* incorrect batch-wise valuation rate for entries with same posting datetime ([#57794](https://github.com/frappe/erpnext/issues/57794)) ([431dc2e](431dc2e5f1))
* **item_variant:** added permission checks on `enqueue_multiple_variant_creation` ([9cd5997](9cd5997500))
* let Purchase Receipt cancel defer to Frappe's linked-document check (backport [#57592](https://github.com/frappe/erpnext/issues/57592)) ([#57602](https://github.com/frappe/erpnext/issues/57602)) ([7cecff9](7cecff9fa4))
* **opportunity:** add validation for positive item quantities ([f47346a](f47346aa90))
* **payment reconciliation:** correct supplier gain/loss posting ([78cd25d](78cd25de04))
* **payment_request:** added permission checks on `resend_payment_email` ([c38c9d5](c38c9d5d9b))
* **plant_floor:** add missing perm check on `get_stock_summary` (backport [#57667](https://github.com/frappe/erpnext/issues/57667)) ([#57669](https://github.com/frappe/erpnext/issues/57669)) ([42d5378](42d53783bb))
* preserve UOM conversion factor precision in transactions ([4373e29](4373e295de))
* prevent duplicate shipping charges without cost center ([a6dff3f](a6dff3fc47))
* **projects:** add project filter ([54390bd](54390bdeb9))
* **projects:** include on hold status in project filters and reports ([478426b](478426b436))
* **purchase:** reject purchase returns where every item has zero quantity ([8676add](8676add875))
* **quotation:** carry forward communications from opportunity at after_insert (backport [#57639](https://github.com/frappe/erpnext/issues/57639)) ([#57642](https://github.com/frappe/erpnext/issues/57642)) ([cf42c52](cf42c52530))
* resolve backport conflicts for version-15 ([1602639](1602639a80))
* resolve version 15 backport conflict ([00df865](00df8652e3))
* resolve version-15 backport conflict ([70da05e](70da05edb7))
* respect quantity precision in material transfer validation ([a5ed3a5](a5ed3a5945))
* **sales:** reject sales returns where every item has zero quantity ([48beb2e](48beb2ee23))
* seed standard Item Groups under the existing tree root ([8483350](848335086c)), closes [#57581](https://github.com/frappe/erpnext/issues/57581)
* set transaction currency on payment entry gl entries ([#57613](https://github.com/frappe/erpnext/issues/57613)) ([35f523e](35f523e2dd))
* source manually created asset value from valuation rate ([455d6d4](455d6d4ac1))
* **stock:** pick list serial batch posting date ([#57015](https://github.com/frappe/erpnext/issues/57015)) ([a51750d](a51750db56)), closes [#56951](https://github.com/frappe/erpnext/issues/56951)
* **stock:** validate only the variant attributes that changed ([2993747](2993747636))
* **stock:** value batched packed-item returns from the original bundle  (backport [#57327](https://github.com/frappe/erpnext/issues/57327)) ([#57510](https://github.com/frappe/erpnext/issues/57510)) ([94d63eb](94d63ebb49))
* use payment entry posting date for received amount exchange rate (backport [#57660](https://github.com/frappe/erpnext/issues/57660)) ([#57662](https://github.com/frappe/erpnext/issues/57662)) ([b826b7c](b826b7c3e6))
* validate account frozen date ([310b9d4](310b9d4e65))

### Features

* auto-fill subscription accounting dimensions from plan with item fallback (backport [#57615](https://github.com/frappe/erpnext/issues/57615)) ([#57621](https://github.com/frappe/erpnext/issues/57621)) ([bb36a4f](bb36a4fd08))
* make Shipping Rule Cost Center optional with company default fallback (backport [#57355](https://github.com/frappe/erpnext/issues/57355)) ([#57402](https://github.com/frappe/erpnext/issues/57402)) ([b2918b8](b2918b8bb3))
* status based bar colors in Work Order gantt view (backport [#57634](https://github.com/frappe/erpnext/issues/57634)) ([#57635](https://github.com/frappe/erpnext/issues/57635)) ([68c24f3](68c24f3767))

erpnext/__init__.py

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

erpnext/accounts/doctype/subscription/subscription.py

@@ -222,9 +222,6 @@ class Subscription(Document):
 		"""
 		Sets the status of the `Subscription`
 		"""
-		if self.status == "Cancelled":
-			return
-
 		if self.is_trialling():
 			self.status = "Trialling"
 		elif self.status == "Active" and self.end_date and getdate(posting_date) > getdate(self.end_date):
@@ -561,11 +558,6 @@ class Subscription(Document):
 		1. `process_for_active`
 		2. `process_for_past_due`
 		"""
-		# Snapshot before update_subscription_period() below can roll this forward,
-		# so the cancel_at_period_end check further down still targets the period
-		# that just ended, not the next one.
-		current_period_end = self.current_invoice_end
-
 		if not self.is_current_invoice_generated(
 			self.current_invoice_start, self.current_invoice_end
 		) and self.can_generate_new_invoice(posting_date):
@@ -575,8 +567,8 @@ class Subscription(Document):
 			self.update_subscription_period()
 
 		if self.cancel_at_period_end and (
-			getdate(posting_date) >= getdate(current_period_end)
-			or (self.end_date and getdate(posting_date) >= getdate(self.end_date))
+			getdate(posting_date) >= getdate(self.current_invoice_end)
+			or getdate(posting_date) >= getdate(self.end_date)
 		):
 			self.cancel_subscription()
 

erpnext/accounts/doctype/subscription/test_subscription.py

@@ -280,59 +280,6 @@ class TestSubscription(FrappeTestCase):
 		settings.cancel_after_grace = default_grace_period_action
 		settings.save()
 
-	def test_cancelled_subscription_stays_cancelled_after_payment_and_reprocess(self):
-		# https://github.com/frappe/erpnext/issues/57761
-		subscription = create_subscription(
-			start_date=nowdate(), generate_invoice_at="Beginning of the current subscription period"
-		)
-		subscription.process(posting_date=nowdate())  # generate first invoice
-		invoice = subscription.get_current_invoice()
-		self.assertIsNotNone(invoice)
-
-		invoice.db_set("outstanding_amount", 0)
-		invoice.db_set("status", "Paid")
-
-		subscription.cancel_subscription()
-		self.assertEqual(subscription.status, "Cancelled")
-		cancelation_date = getdate(subscription.cancelation_date)
-
-		subscription.set_subscription_status()
-		self.assertEqual(subscription.status, "Cancelled")
-		self.assertEqual(getdate(subscription.cancelation_date), cancelation_date)
-
-		subscription.cancel_at_period_end = 1
-		subscription.end_date = None
-		invoice_count = len(subscription.invoices)
-		subscription.process()
-		self.assertEqual(subscription.status, "Cancelled")
-		self.assertEqual(len(subscription.invoices), invoice_count)
-
-	def test_subscription_cancels_at_period_end_without_end_date(self):
-		# https://github.com/frappe/erpnext/issues/57761 -- generate_invoice() rolls
-		# current_invoice_end forward to the next period before this check runs, so
-		# with no end_date to fall back on, cancel_at_period_end must compare
-		# against the period that just ended, not the (already advanced) next one.
-		create_plan(
-			plan_name="_Test plan name 11",
-			cost=80,
-			currency="INR",
-			billing_interval="Day",
-			billing_interval_count=3,
-		)
-		subscription = create_subscription(
-			start_date=nowdate(),
-			generate_invoice_at="End of the current subscription period",
-			plans=[{"plan": "_Test plan name 11", "qty": 1}],
-		)
-		subscription.cancel_at_period_end = 1
-		self.assertEqual(len(subscription.invoices), 0)
-		period_end = subscription.current_invoice_end
-
-		subscription.process(posting_date=period_end)
-
-		self.assertEqual(subscription.status, "Cancelled")
-		self.assertEqual(len(subscription.invoices), 1)
-
 	def test_subscription_restart_and_process(self):
 		settings = frappe.get_single("Subscription Settings")
 		default_grace_period_action = settings.cancel_after_grace

erpnext/accounts/report/accounts_payable/accounts_payable.js

@@ -117,11 +117,8 @@ frappe.query_reports["Accounts Payable"] = {
 		{
 			fieldname: "supplier_group",
 			label: __("Supplier Group"),
-			fieldtype: "MultiSelectList",
+			fieldtype: "Link",
 			options: "Supplier Group",
-			get_data: function (txt) {
-				return frappe.db.get_link_options("Supplier Group", txt);
-			},
 			hidden: 1,
 		},
 		{

erpnext/accounts/report/accounts_payable/test_accounts_payable.py

@@ -121,36 +121,6 @@ class TestAccountsPayable(AccountsTestMixin, FrappeTestCase):
 		self.assertEqual(len(report[1]), 2)
 		self.assertEqual([pi.name, payment_term1.payment_term_name], [row.voucher_no, row.payment_term])
 
-	def test_supplier_group_filter(self):
-		pi = self.create_purchase_invoice()
-		supplier_group = frappe.db.get_value("Supplier", self.supplier, "supplier_group")
-		other_group = frappe.get_doc(
-			doctype="Supplier Group",
-			supplier_group_name="_Test Supplier Group AP",
-			parent_supplier_group="All Supplier Groups",
-		).insert()
-
-		filters = {
-			"company": self.company,
-			"party_type": "Supplier",
-			"report_date": today(),
-			"range": "30, 60, 90, 120",
-			"supplier_group": supplier_group,
-		}
-		self.assertIn(pi.name, [row.voucher_no for row in execute(filters)[1]])
-
-		filters.update({"supplier_group": [other_group.name]})
-		self.assertEqual(len(execute(filters)[1]), 0)
-
-		filters.update({"supplier_group": [supplier_group, other_group.name]})
-		self.assertIn(pi.name, [row.voucher_no for row in execute(filters)[1]])
-
-		filters.update({"supplier_group": ["All Supplier Groups"]})
-		self.assertIn(pi.name, [row.voucher_no for row in execute(filters)[1]])
-
-		filters.update({"supplier_group": ["_Test Supplier Group Mars"]})
-		self.assertRaises(frappe.ValidationError, execute, filters)
-
 	def test_project_filter(self):
 		project = frappe.get_doc(
 			{"doctype": "Project", "project_name": "_Test AP Project", "company": self.company}

erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.js

@@ -100,11 +100,8 @@ frappe.query_reports["Accounts Payable Summary"] = {
 		{
 			fieldname: "supplier_group",
 			label: __("Supplier Group"),
-			fieldtype: "MultiSelectList",
+			fieldtype: "Link",
 			options: "Supplier Group",
-			get_data: function (txt) {
-				return frappe.db.get_link_options("Supplier Group", txt);
-			},
 		},
 		{
 			fieldname: "based_on_payment_terms",

erpnext/accounts/report/accounts_receivable/accounts_receivable.js

@@ -140,11 +140,8 @@ frappe.query_reports["Accounts Receivable"] = {
 		{
 			fieldname: "territory",
 			label: __("Territory"),
-			fieldtype: "MultiSelectList",
+			fieldtype: "Link",
 			options: "Territory",
-			get_data: function (txt) {
-				return frappe.db.get_link_options("Territory", txt);
-			},
 		},
 		{
 			fieldname: "group_by_party",

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -1013,13 +1013,7 @@ class ReceivablePayableReport:
 			self.qb_selection_filter.append(self.ple.party.isin(customers))
 
 		if self.filters.get("territory"):
-			territories = get_nested_set_children("Territory", self.filters.territory)
-			customers = (
-				qb.from_(self.customer)
-				.select(self.customer.name)
-				.where(self.customer["territory"].isin(territories))
-			)
-			self.qb_selection_filter.append(self.ple.party.isin(customers))
+			self.get_hierarchical_filters("Territory", "territory")
 
 		if self.filters.get("payment_terms_template"):
 			customer_ptt = self.ple.party.isin(
@@ -1040,10 +1034,11 @@ class ReceivablePayableReport:
 	def add_supplier_filters(self):
 		supplier = qb.DocType("Supplier")
 		if self.filters.get("supplier_group"):
-			groups = get_party_group_with_children("Supplier", self.filters.supplier_group)
 			self.qb_selection_filter.append(
 				self.ple.party.isin(
-					qb.from_(supplier).select(supplier.name).where(supplier.supplier_group.isin(groups))
+					qb.from_(supplier)
+					.select(supplier.name)
+					.where(supplier.supplier_group == self.filters.get("supplier_group"))
 				)
 			)
 
@@ -1095,6 +1090,16 @@ class ReceivablePayableReport:
 
 		return ptt
 
+	def get_hierarchical_filters(self, doctype, key):
+		lft, rgt = frappe.db.get_value(doctype, self.filters.get(key), ["lft", "rgt"])
+
+		doc = qb.DocType(doctype)
+		ple = self.ple
+		customer = self.customer
+		groups = qb.from_(doc).select(doc.name).where((doc.lft >= lft) & (doc.rgt <= rgt))
+		customers = qb.from_(customer).select(customer.name).where(customer[key].isin(groups))
+		self.qb_selection_filter.append(ple.party.isin(customers))
+
 	def add_accounting_dimensions_filters(self):
 		accounting_dimensions = get_accounting_dimensions(as_list=False)
 
@@ -1324,23 +1329,19 @@ def get_party_group_with_children(party, party_groups):
 	if party not in ("Customer", "Supplier"):
 		return []
 
-	return get_nested_set_children(f"{party} Group", party_groups)
+	group_dtype = f"{party} Group"
+	if not isinstance(party_groups, list):
+		party_groups = [d.strip() for d in party_groups.strip().split(",") if d]
 
-
-def get_nested_set_children(doctype, values):
-	if not isinstance(values, list):
-		values = [d.strip() for d in values.split(",") if d.strip()]
-
-	if not values:
-		frappe.throw(_("Please select a valid {0}").format(_(doctype)))
-
-	all_values = []
-	for d in values:
-		if frappe.db.exists(doctype, d):
-			lft, rgt = frappe.db.get_value(doctype, d, ["lft", "rgt"])
-			children = frappe.get_all(doctype, filters={"lft": [">=", lft], "rgt": ["<=", rgt]}, pluck="name")
-			all_values += children
+	all_party_groups = []
+	for d in party_groups:
+		if frappe.db.exists(group_dtype, d):
+			lft, rgt = frappe.db.get_value(group_dtype, d, ["lft", "rgt"])
+			children = frappe.get_all(
+				group_dtype, filters={"lft": [">=", lft], "rgt": ["<=", rgt]}, pluck="name"
+			)
+			all_party_groups += children
 		else:
-			frappe.throw(_("{0}: {1} does not exist").format(doctype, d))
+			frappe.throw(_("{0}: {1} does not exist").format(group_dtype, d))
 
-	return list(set(all_values))
+	return list(set(all_party_groups))

erpnext/accounts/report/accounts_receivable/test_accounts_receivable.py

@@ -771,38 +771,6 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 			# Assert that the customer group of each row is in the list of customer groups
 			self.assertIn(row.customer_group, cus_groups_list)
 
-	def test_territory_filter(self):
-		self.create_sales_invoice()
-		territory = frappe.db.get_value("Customer", self.customer, "territory")
-
-		filters = {
-			"company": self.company,
-			"report_date": today(),
-			"range": "30, 60, 90, 120",
-			"territory": territory,
-		}
-		report = execute(filters)[1]
-		self.assertEqual(len(report), 1)
-		self.assertEqual(
-			[100.0, 100.0, territory], [report[0].invoiced, report[0].outstanding, report[0].territory]
-		)
-
-		filters.update({"territory": ["_Test Territory United States"]})
-		self.assertEqual(len(execute(filters)[1]), 0)
-
-		filters.update({"territory": [territory, "_Test Territory United States"]})
-		self.assertEqual(len(execute(filters)[1]), 1)
-
-		frappe.db.set_value("Customer", self.customer, "territory", "_Test Territory Maharashtra")
-		filters.update({"territory": ["_Test Territory India"]})
-		self.assertEqual(len(execute(filters)[1]), 1)
-
-		filters.update({"territory": ["_Test Territory Mars"]})
-		self.assertRaises(frappe.ValidationError, execute, filters)
-
-		filters.update({"territory": "  "})
-		self.assertRaises(frappe.ValidationError, execute, filters)
-
 	def test_party_account_filter(self):
 		si1 = self.create_sales_invoice()
 		self.customer2 = (

erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.js

@@ -106,11 +106,8 @@ frappe.query_reports["Accounts Receivable Summary"] = {
 		{
 			fieldname: "territory",
 			label: __("Territory"),
-			fieldtype: "MultiSelectList",
+			fieldtype: "Link",
 			options: "Territory",
-			get_data: function (txt) {
-				return frappe.db.get_link_options("Territory", txt);
-			},
 		},
 		{
 			fieldname: "sales_partner",

erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.js

@@ -93,27 +93,5 @@ frappe.query_reports["Customer Ledger Summary"] = {
 			fieldtype: "Data",
 			hidden: 1,
 		},
-		{
-			fieldname: "cost_center",
-			label: __("Cost Center"),
-			fieldtype: "MultiSelectList",
-			get_data: function (txt) {
-				return frappe.db.get_link_options("Cost Center", txt, {
-					company: frappe.query_report.get_filter_value("company"),
-				});
-			},
-		},
-		{
-			fieldname: "project",
-			label: __("Project"),
-			fieldtype: "MultiSelectList",
-			get_data: function (txt) {
-				return frappe.db.get_link_options("Project", txt, {
-					company: frappe.query_report.get_filter_value("company"),
-				});
-			},
-		},
 	],
 };
-
-erpnext.utils.add_dimensions("Customer Ledger Summary", 14);

erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py

@@ -4,10 +4,7 @@
 
 import frappe
 from frappe import _, qb, scrub
-<<<<<<< HEAD
 from frappe.query_builder import Criterion, Tuple
-=======
->>>>>>> 7614f166d8 (refactor: convert sql queries to qb queries)
 from frappe.query_builder.functions import IfNull
 from frappe.utils import getdate, nowdate
 from frappe.utils.nestedset import get_descendants_of
@@ -22,12 +19,6 @@ TREE_DOCTYPES = frozenset(
 	["Customer Group", "Territory", "Supplier Group", "Sales Partner", "Sales Person", "Cost Center"]
 )
 
-from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
-	get_accounting_dimensions,
-	get_dimension_with_children,
-)
-from erpnext.accounts.report.financial_statements import get_cost_centers_with_children
-
 
 class PartyLedgerSummaryReport:
 	def __init__(self, filters=None):
@@ -35,21 +26,6 @@ class PartyLedgerSummaryReport:
 		self.filters.from_date = getdate(self.filters.from_date or nowdate())
 		self.filters.to_date = getdate(self.filters.to_date or nowdate())
 
-<<<<<<< HEAD
-<<<<<<< HEAD
-=======
-		if self.filters.get("cost_center"):
-			self.filters.cost_center = frappe.parse_json(self.filters.get("cost_center"))
-
-		if self.filters.get("project"):
-			self.filters.project = frappe.parse_json(self.filters.get("project"))
-
-=======
->>>>>>> 9610a33d23 (fix: remove irrelavent conditions)
-		if not self.filters.get("company"):
-			self.filters["company"] = frappe.db.get_single_value("Global Defaults", "default_company")
-
->>>>>>> 901bcd5c43 (feat: add accounting dimensions in ledger summary reports)
 	def run(self, args):
 		self.filters.party_type = args.get("party_type")
 
@@ -344,10 +320,6 @@ class PartyLedgerSummaryReport:
 		return out
 
 	def get_gl_entries(self):
-<<<<<<< HEAD
-<<<<<<< HEAD
-=======
->>>>>>> 7614f166d8 (refactor: convert sql queries to qb queries)
 		gle = qb.DocType("GL Entry")
 		query = (
 			qb.from_(gle)
@@ -356,12 +328,7 @@ class PartyLedgerSummaryReport:
 				gle.party,
 				gle.voucher_type,
 				gle.voucher_no,
-<<<<<<< HEAD
 				gle.against_voucher,  # For handling returned invoices (Credit/Debit Notes)
-=======
-				gle.against_voucher_type,
-				gle.against_voucher,
->>>>>>> 7614f166d8 (refactor: convert sql queries to qb queries)
 				gle.debit,
 				gle.credit,
 				gle.is_opening,
@@ -372,60 +339,12 @@ class PartyLedgerSummaryReport:
 				& (gle.party_type == self.filters.party_type)
 				& (IfNull(gle.party, "") != "")
 				& (gle.posting_date <= self.filters.to_date)
-<<<<<<< HEAD
 				& (gle.party.isin(self.parties))
 			)
-=======
-		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,
->>>>>>> 901bcd5c43 (feat: add accounting dimensions in ledger summary reports)
 		)
 
 		query = self.prepare_conditions(query)
 
-=======
-			)
-			.orderby(gle.posting_date)
-		)
-
-		if self.filters.party_type == "Customer":
-			customer = qb.DocType("Customer")
-			query = (
-				query.select(customer.customer_name.as_("party_name"))
-				.left_join(customer)
-				.on(customer.name == gle.party)
-			)
-		elif self.filters.party_type == "Supplier":
-			supplier = qb.DocType("Supplier")
-			query = (
-				query.select(supplier.supplier_name.as_("party_name"))
-				.left_join(supplier)
-				.on(supplier.name == gle.party)
-			)
-
-		query = self.prepare_conditions(query)
->>>>>>> 7614f166d8 (refactor: convert sql queries to qb queries)
 		self.gl_entries = query.run(as_dict=True)
 
 	def prepare_conditions(self, query):
@@ -436,7 +355,6 @@ class PartyLedgerSummaryReport:
 		if self.filters.finance_book:
 			query = query.where(IfNull(gle.finance_book, "") == self.filters.finance_book)
 
-<<<<<<< HEAD
 		if self.filters.cost_center:
 			query = query.where((gle.cost_center).isin(self.filters.cost_center))
 
@@ -460,107 +378,7 @@ class PartyLedgerSummaryReport:
 							(gle[dimension.fieldname]).isin(self.filters.get(dimension.fieldname))
 						)
 
-<<<<<<< HEAD
 		return query
-=======
-				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.party:
-			query = query.where(gle.party == self.filters.party)
-
-		if self.filters.party_type == "Customer":
-			customer = qb.DocType("Customer")
-			if self.filters.customer_group:
-				query = query.where(
-					(gle.party).isin(
-						qb.from_(customer)
-						.select(customer.name)
-						.where(customer.customer_group == self.filters.customer_group)
-					)
-				)
-
-			if self.filters.territory:
-				query = query.where(
-					(gle.party).isin(
-						qb.from_(customer)
-						.select(customer.name)
-						.where(customer.territory == self.filters.territory)
-					)
-				)
-
-			if self.filters.payment_terms_template:
-				query = query.where(
-					(gle.party).isin(
-						qb.from_(customer)
-						.select(customer.name)
-						.where(customer.payment_terms == self.filters.payment_terms_template)
-					)
->>>>>>> 7614f166d8 (refactor: convert sql queries to qb queries)
-				)
-
-			if self.filters.sales_partner:
-				query = query.where(
-					(gle.party).isin(
-						qb.from_(customer)
-						.select(customer.name)
-						.where(customer.default_sales_partner == self.filters.sales_partner)
-					)
-				)
-
-			if self.filters.sales_person:
-				sales_team = qb.DocType("Sales Team")
-				query = query.where(
-					(gle.party).isin(
-						qb.from_(sales_team)
-						.select(sales_team.parent)
-						.where(sales_team.sales_person == self.filters.sales_person)
-					)
-				)
-
-		if self.filters.party_type == "Supplier":
-			if self.filters.supplier_group:
-				supplier = qb.DocType("Supplier")
-				query = query.where(
-					(gle.party).isin(
-						qb.from_(supplier)
-						.select(supplier.name)
-						.where(supplier.supplier_group == self.filters.supplier_group)
-					)
-				)
-
-		if self.filters.cost_center:
-			self.filters.cost_center = get_cost_centers_with_children(self.filters.cost_center)
-			query = query.where((gle.cost_center).isin(self.filters.cost_center))
-
-		if self.filters.project:
-			query = query.where((gle.project).isin(self.filters.project))
-
-		accounting_dimensions = get_accounting_dimensions(as_list=False)
-
-		if accounting_dimensions:
-			for dimension in accounting_dimensions:
-				if self.filters.get(dimension.fieldname):
-					if frappe.get_cached_value("DocType", dimension.document_type, "is_tree"):
-						self.filters[dimension.fieldname] = get_dimension_with_children(
-							dimension.document_type, self.filters.get(dimension.fieldname)
-						)
-						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))
-						)
-
-<<<<<<< HEAD
-		return " and ".join(conditions)
->>>>>>> 901bcd5c43 (feat: add accounting dimensions in ledger summary reports)
-=======
-		return query
->>>>>>> 7614f166d8 (refactor: convert sql queries to qb queries)
 
 	def get_return_invoices(self):
 		doctype = "Sales Invoice" if self.filters.party_type == "Customer" else "Purchase Invoice"
@@ -577,53 +395,13 @@ class PartyLedgerSummaryReport:
 
 	def get_party_adjustment_amounts(self):
 		account_type = "Expense Account" if self.filters.party_type == "Customer" else "Income Account"
-<<<<<<< HEAD
 
-=======
-		self.income_or_expense_accounts = frappe.db.get_all(
-			"Account", filters={"account_type": account_type, "company": self.filters.company}, pluck="name"
-		)
->>>>>>> 7614f166d8 (refactor: convert sql queries to qb queries)
 		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")
 
-<<<<<<< HEAD
 		current_period_vouchers = set()
 		adjustment_voucher_entries = {}
-=======
-		if not self.income_or_expense_accounts:
-			# prevent empty 'in' condition
-			self.income_or_expense_accounts.append("")
-		else:
-			# escape '%' in account name
-			# ignoring frappe.db.escape as it replaces single quotes with double quotes
-			self.income_or_expense_accounts = [x.replace("%", "%%") for x in self.income_or_expense_accounts]
-
-		gl = qb.DocType("GL Entry")
-		accounts_query = self.get_base_accounts_query()
-		accounts_query_voucher_no = accounts_query.select(gl.voucher_no)
-		accounts_query_voucher_type = accounts_query.select(gl.voucher_type)
-
-		subquery = self.get_base_subquery()
-		subquery_voucher_no = subquery.select(gl.voucher_no)
-		subquery_voucher_type = subquery.select(gl.voucher_type)
-
-		gl_entries = (
-			qb.from_(gl)
-			.select(
-				gl.posting_date, gl.account, gl.party, gl.voucher_type, gl.voucher_no, gl.debit, gl.credit
-			)
-			.where(
-				(gl.docstatus < 2)
-				& (gl.is_cancelled == 0)
-				& (gl.voucher_no.isin(accounts_query_voucher_no))
-				& (gl.voucher_type.isin(accounts_query_voucher_type))
-				& (gl.voucher_no.isin(subquery_voucher_no))
-				& (gl.voucher_type.isin(subquery_voucher_type))
-			)
-		).run(as_dict=True)
->>>>>>> 7614f166d8 (refactor: convert sql queries to qb queries)
 
 		self.party_adjustment_details = {}
 		self.party_adjustment_accounts = set()
@@ -694,26 +472,6 @@ class PartyLedgerSummaryReport:
 						self.party_adjustment_details[party].setdefault(account, 0)
 						self.party_adjustment_details[party][account] += amount
 
-	def get_base_accounts_query(self):
-		gl = qb.DocType("GL Entry")
-		query = qb.from_(gl).where(
-			(gl.account.isin(self.income_or_expense_accounts))
-			& (gl.posting_date.gte(self.filters.from_date))
-			& (gl.posting_date.lte(self.filters.to_date))
-		)
-		return query
-
-	def get_base_subquery(self):
-		gl = qb.DocType("GL Entry")
-		query = qb.from_(gl).where(
-			(gl.docstatus < 2)
-			& (gl.party_type == self.filters.party_type)
-			& (IfNull(gl.party, "") != "")
-			& (gl.posting_date.between(self.filters.from_date, self.filters.to_date))
-		)
-		query = self.prepare_conditions(query)
-		return query
-
 
 def get_children(doctype, value):
 	if not isinstance(value, list):

erpnext/accounts/report/supplier_ledger_summary/supplier_ledger_summary.js

@@ -74,27 +74,5 @@ frappe.query_reports["Supplier Ledger Summary"] = {
 			fieldtype: "Data",
 			hidden: 1,
 		},
-		{
-			fieldname: "cost_center",
-			label: __("Cost Center"),
-			fieldtype: "MultiSelectList",
-			get_data: function (txt) {
-				return frappe.db.get_link_options("Cost Center", txt, {
-					company: frappe.query_report.get_filter_value("company"),
-				});
-			},
-		},
-		{
-			fieldname: "project",
-			label: __("Project"),
-			fieldtype: "MultiSelectList",
-			get_data: function (txt) {
-				return frappe.db.get_link_options("Project", txt, {
-					company: frappe.query_report.get_filter_value("company"),
-				});
-			},
-		},
 	],
 };
-
-erpnext.utils.add_dimensions("Supplier Ledger Summary", 11);

erpnext/buying/doctype/purchase_order/test_purchase_order.py

@@ -948,8 +948,6 @@ class TestPurchaseOrder(FrappeTestCase):
 		# self.assertEqual(po.payment_terms_template, pi.payment_terms_template)
 		compare_payment_schedules(self, po, pi)
 
-	@change_settings("Selling Settings", {"maintain_same_sales_rate": 1})
-	@change_settings("Buying Settings", {"maintain_same_rate": 1})
 	def test_internal_transfer_flow(self):
 		from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
 		from erpnext.accounts.doctype.sales_invoice.sales_invoice import (
@@ -961,6 +959,9 @@ class TestPurchaseOrder(FrappeTestCase):
 		)
 		from erpnext.stock.doctype.delivery_note.delivery_note import make_inter_company_purchase_receipt
 
+		frappe.db.set_single_value("Selling Settings", "maintain_same_sales_rate", 1)
+		frappe.db.set_single_value("Buying Settings", "maintain_same_rate", 1)
+
 		prepare_data_for_internal_transfer()
 		supplier = "_Test Internal Supplier 2"
 

erpnext/controllers/status_updater.py

@@ -312,12 +312,13 @@ class StatusUpdater(Document):
 			qty_or_amount,
 		)
 
-		role = None
-		if qty_or_amount == "qty":
-			if args.get("overflow_type") in ("delivery", "receipt"):
-				role = frappe.get_single_value("Stock Settings", "role_allowed_to_over_deliver_receive")
-		else:
-			role = frappe.get_single_value("Accounts Settings", "role_allowed_to_over_bill")
+		role_allowed_to_over_deliver_receive = frappe.db.get_single_value(
+			"Stock Settings", "role_allowed_to_over_deliver_receive"
+		)
+		role_allowed_to_over_bill = frappe.db.get_single_value(
+			"Accounts Settings", "role_allowed_to_over_bill"
+		)
+		role = role_allowed_to_over_deliver_receive if qty_or_amount == "qty" else role_allowed_to_over_bill
 
 		overflow_percent = (
 			(item[args["target_field"]] - item[args["target_ref_field"]]) / item[args["target_ref_field"]]

erpnext/manufacturing/doctype/blanket_order/test_blanket_order.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 import frappe
-from frappe.tests.utils import FrappeTestCase, change_settings
+from frappe.tests.utils import FrappeTestCase
 from frappe.utils import add_months, today
 
 from erpnext import get_company_currency
@@ -91,32 +91,6 @@ class TestBlanketOrder(FrappeTestCase):
 		frappe.db.set_single_value("Buying Settings", "blanket_order_allowance", 10)
 		po.submit()
 
-	@change_settings("Selling Settings", {"blanket_order_allowance": 0})
-	@change_settings("Buying Settings", {"blanket_order_allowance": 0})
-	@change_settings(
-		"Stock Settings",
-		{"over_delivery_receipt_allowance": 10, "role_allowed_to_over_deliver_receive": "Stock Manager"},
-	)
-	def test_stock_over_delivery_role_does_not_bypass_blanket_order_allowance(self):
-		test_user = frappe.get_doc("User", "test@example.com")
-		test_user.add_roles("Accounts User", "Stock Manager")
-
-		frappe.clear_cache()
-		for blanket_order_type, doctype, date_field in (
-			("Selling", "Sales Order", "delivery_date"),
-			("Purchasing", "Purchase Order", "schedule_date"),
-		):
-			bo = make_blanket_order(blanket_order_type=blanket_order_type, quantity=100)
-			frappe.flags.args.doctype = doctype
-			order = make_order(bo.name)
-			order.currency = get_company_currency(order.company)
-			setattr(order, date_field, today())
-			order.items[0].qty = 110
-
-			with self.set_user("test@example.com"):
-				order.flags.ignore_permissions = True
-				self.assertRaises(frappe.ValidationError, order.submit)
-
 	def test_party_item_code(self):
 		item_doc = make_item("_Test Item 1 for Blanket Order")
 		item_code = item_doc.name

erpnext/stock/doctype/purchase_receipt/test_purchase_receipt.py

@@ -4996,66 +4996,6 @@ class TestPurchaseReceipt(FrappeTestCase):
 
 		self.assertEqual(frappe.parse_json(stock_queue), [[20, 0.0]])
 
-	def test_purchase_return_valuation_for_batchwise_valuation_batch(self):
-		from erpnext.controllers.sales_and_purchase_return import make_return_doc
-		from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
-
-		item_code = make_item(
-			"Test Purchase Return Batchwise Valn Item",
-			{
-				"is_stock_item": 1,
-				"has_batch_no": 1,
-				"batch_number_series": "BN-TPRBWV-.#####",
-			},
-		).name
-
-		batch_no = "BN-TPRBWV-00001"
-		batch = frappe.new_doc("Batch").update({"batch_id": batch_no, "item": item_code}).insert()
-		self.assertEqual(batch.use_batchwise_valuation, 1)
-
-		warehouse = "_Test Warehouse - _TC"
-		pr = make_purchase_receipt(
-			item_code=item_code,
-			qty=100,
-			rate=1000,
-			warehouse=warehouse,
-			batch_no=batch_no,
-			use_serial_batch_fields=1,
-		)
-		make_purchase_receipt(
-			item_code=item_code,
-			qty=100,
-			rate=400,
-			warehouse=warehouse,
-			batch_no=batch_no,
-			use_serial_batch_fields=1,
-		)
-		create_delivery_note(
-			item_code=item_code,
-			qty=100,
-			warehouse=warehouse,
-			batch_no=batch_no,
-			use_serial_batch_fields=1,
-		)
-
-		return_pr = make_return_doc("Purchase Receipt", pr.name)
-		return_pr.submit()
-
-		sle = frappe.db.get_value(
-			"Stock Ledger Entry",
-			{"voucher_no": return_pr.name, "is_cancelled": 0},
-			["stock_value_difference", "qty_after_transaction", "stock_value", "serial_and_batch_bundle"],
-			as_dict=True,
-		)
-		self.assertEqual(flt(sle.qty_after_transaction), 0.0)
-		self.assertEqual(flt(sle.stock_value_difference, 2), -70000.0)
-		self.assertEqual(flt(sle.stock_value, 2), 0.0)
-
-		rate = frappe.db.get_value(
-			"Serial and Batch Entry", {"parent": sle.serial_and_batch_bundle}, "incoming_rate"
-		)
-		self.assertEqual(flt(rate, 2), 700.0)
-
 	def test_negative_stock_error_for_purchase_return(self):
 		from erpnext.controllers.sales_and_purchase_return import make_return_doc
 		from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry

erpnext/stock/doctype/serial_and_batch_bundle/serial_and_batch_bundle.py

@@ -402,13 +402,6 @@ class SerialandBatchBundle(Document):
 
 			valuation_method = get_valuation_method(self.item_code)
 
-			# An outward return must go out at the batch's current average rate for a
-			# batchwise valuation batch. The original receipt rate is only correct while
-			# the batch still holds stock at that rate; once other receipts have changed
-			# the average, removing at the original rate strands a residue in the batch
-			# value (negative when returning the costlier receipt).
-			batchwise_avg_rates = self.get_batchwise_return_avg_rates()
-
 			stock_queue = []
 			non_batchwise_batches = []
 			if not self.has_serial_no and valuation_method == "FIFO":
@@ -442,12 +435,6 @@ class SerialandBatchBundle(Document):
 						batches = sorted(list(valuation_details["batches"].keys()))
 						valuation_rate = valuation_details["batches"].get(batches[cint(row.idx) - 1])
 
-				# a batch with an available balance goes out at its current average rate (a
-				# valid 0.0 included); the original receipt rate applies only when there is
-				# no balance to average
-				if not row.serial_no and row.batch_no in batchwise_avg_rates:
-					valuation_rate = batchwise_avg_rates[row.batch_no]
-
 				row.incoming_rate = flt(valuation_rate)
 				row.stock_value_difference = flt(row.qty) * flt(row.incoming_rate)
 
@@ -476,41 +463,6 @@ class SerialandBatchBundle(Document):
 		elif self.type_of_transaction == "Inward":
 			self.set_incoming_rate_for_inward_transaction(row, save, prev_sle=prev_sle)
 
-	def get_batchwise_return_avg_rates(self):
-		from erpnext.stock.utils import get_valuation_method
-
-		if self.type_of_transaction != "Outward" or self.has_serial_no:
-			return {}
-
-		batch_nos = [d.batch_no for d in self.entries if d.batch_no]
-		if not batch_nos:
-			return {}
-
-		if get_valuation_method(self.item_code) == "Moving Average" and frappe.db.get_single_value(
-			"Stock Settings", "do_not_use_batchwise_valuation"
-		):
-			return {}
-
-		batchwise_batches = frappe.get_all(
-			"Batch",
-			filters={"name": ("in", batch_nos), "use_batchwise_valuation": 1},
-			pluck="name",
-		)
-		if not batchwise_batches:
-			return {}
-
-		# scoped to batchwise batches only, so BatchNoValuation's non-batchwise
-		# machinery never runs for them
-		sle = self.get_sle_for_outward_transaction()
-		sle.batch_nos = {batch_no: sle.batch_nos[batch_no] for batch_no in batchwise_batches}
-		sle.batchwise_valuation_batches = batchwise_batches
-		sn_obj = BatchNoValuation(sle=sle, item_code=self.item_code, warehouse=self.warehouse)
-		return {
-			batch_no: abs(flt(sn_obj.batch_avg_rate.get(batch_no)))
-			for batch_no in batchwise_batches
-			if flt(sn_obj.available_qty.get(batch_no))
-		}
-
 	def validate_returned_serial_batch_no(self, return_against, row, original_inv_details):
 		if frappe.flags.through_repost_item_valuation:
 			return

erpnext/stock/doctype/stock_settings/stock_settings.json

@@ -131,8 +131,7 @@
    "description": "The percentage you are allowed to receive or deliver more against the quantity ordered. For example, if you have ordered 100 units, and your Allowance is 10%, then you are allowed to receive 110 units.",
    "fieldname": "over_delivery_receipt_allowance",
    "fieldtype": "Float",
-   "label": "Over Delivery/Receipt Allowance (%)",
-   "non_negative": 1
+   "label": "Over Delivery/Receipt Allowance (%)"
   },
   {
    "default": "Stop",
@@ -283,8 +282,7 @@
    "description": "The percentage you are allowed to transfer more against the quantity ordered. For example, if you have ordered 100 units, and your Allowance is 10%, then you are allowed transfer 110 units.",
    "fieldname": "mr_qty_allowance",
    "fieldtype": "Float",
-   "label": "Over Transfer Allowance",
-   "non_negative": 1
+   "label": "Over Transfer Allowance"
   },
   {
    "default": "0",
@@ -448,8 +446,7 @@
    "description": "The percentage you are allowed to pick more items in the pick list than the ordered quantity.",
    "fieldname": "over_picking_allowance",
    "fieldtype": "Percent",
-   "label": "Over Picking Allowance",
-   "non_negative": 1
+   "label": "Over Picking Allowance"
   },
   {
    "default": "1",
@@ -531,7 +528,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2026-08-01 23:35:02.896836",
+ "modified": "2026-03-27 22:39:16.812184",
  "modified_by": "Administrator",
  "module": "Stock",
  "name": "Stock Settings",

erpnext/stock/doctype/stock_settings/stock_settings.py

@@ -101,7 +101,6 @@ class StockSettings(Document):
 			)
 
 		self.validate_warehouses()
-		self.validate_over_delivery_receipt_allowance()
 		self.cant_change_valuation_method()
 		self.validate_clean_description_html()
 		self.validate_pending_reposts()
@@ -111,10 +110,6 @@ class StockSettings(Document):
 		self.change_precision_for_purchase()
 		self.validate_do_not_use_batchwise_valuation()
 
-	def validate_over_delivery_receipt_allowance(self):
-		if not self.over_delivery_receipt_allowance:
-			self.role_allowed_to_over_deliver_receive = None
-
 	def validate_do_not_use_batchwise_valuation(self):
 		doc_before_save = self.get_doc_before_save()
 		if not doc_before_save:

erpnext/stock/report/stock_ledger/stock_ledger.py

@@ -7,10 +7,8 @@ from collections import defaultdict
 
 import frappe
 from frappe import _
-from frappe.query_builder.functions import CombineDatetime, IfNull, Sum
+from frappe.query_builder.functions import CombineDatetime, Sum
 from frappe.utils import cint, flt, get_datetime
-from pypika import Order
-from pypika.analytics import RowNumber
 
 from erpnext.stock.doctype.inventory_dimension.inventory_dimension import get_inventory_dimensions
 from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
@@ -55,15 +53,14 @@ def execute(filters=None):
 
 	data = []
 	conversion_factors = []
-	opening_rows = opening_row if isinstance(opening_row, list) else ([opening_row] if opening_row else [])
-	for row in opening_rows:
-		data.append(row)
+	if opening_row:
+		data.append(opening_row)
 		conversion_factors.append(0)
 
 	actual_qty = stock_value = 0
-	if opening_rows:
-		actual_qty = opening_rows[0].get("qty_after_transaction", 0)
-		stock_value = opening_rows[0].get("stock_value", 0)
+	if opening_row:
+		actual_qty = opening_row.get("qty_after_transaction")
+		stock_value = opening_row.get("stock_value")
 
 	available_serial_nos = {}
 
@@ -690,120 +687,43 @@ def get_opening_balance(filters, columns, sl_entries, inv_dimension_wise_value=N
 	if not (filters.item_code and filters.warehouse and filters.from_date):
 		return
 
-	item_codes = filters.item_code
-	if isinstance(item_codes, str):
-		item_codes = [item_codes]
+	from erpnext.stock.stock_ledger import get_previous_sle
 
-	warehouses = get_matching_warehouses(filters.warehouse)
-	if not warehouses:
-		return
+	project = None
+	if filters.get("project") and not frappe.get_all(
+		"Inventory Dimension", filters={"reference_document": "Project"}
+	):
+		project = filters.get("project")
 
-	sle_doctype = frappe.qb.DocType("Stock Ledger Entry")
-	sr_doctype = frappe.qb.DocType("Stock Reconciliation")
-
-	opening_reco_query = (
-		frappe.qb.from_(sle_doctype)
-		.inner_join(sr_doctype)
-		.on(sle_doctype.voucher_no == sr_doctype.name)
-		.select(sle_doctype.voucher_no)
-		.where(sle_doctype.docstatus < 2)
-		.where(sle_doctype.is_cancelled == 0)
-		.where(sle_doctype.item_code.isin(item_codes))
-		.where(sle_doctype.warehouse.isin(warehouses))
-		.where(sle_doctype.voucher_type == "Stock Reconciliation")
-		.where(sle_doctype.posting_date == filters.from_date)
-		.where(sr_doctype.purpose == "Opening Stock")
+	last_entry = get_previous_sle(
+		{
+			"item_code": filters.item_code,
+			"warehouse_condition": get_warehouse_condition(filters.warehouse),
+			"posting_date": filters.from_date,
+			"posting_time": "00:00:00",
+			"project": project,
+		},
+		for_report=True,
 	)
 
-	opening_reco_vouchers = set(opening_reco_query.run(pluck=True))
+	# check if any SLEs are actually Opening Stock Reconciliation
+	for sle in list(sl_entries):
+		if (
+			sle.get("voucher_type") == "Stock Reconciliation"
+			and sle.posting_date == filters.from_date
+			and frappe.db.get_value("Stock Reconciliation", sle.voucher_no, "purpose") == "Opening Stock"
+		):
+			last_entry = sle
+			sl_entries.remove(sle)
 
-	if opening_reco_vouchers:
-		sl_entries[:] = [sle for sle in sl_entries if sle.get("voucher_no") not in opening_reco_vouchers]
-
-	sle_cond = (sle_doctype.posting_date < filters.from_date) | (
-		(sle_doctype.posting_date == filters.from_date) & (sle_doctype.posting_time == "00:00:00")
-	)
-	if opening_reco_vouchers:
-		sle_cond = sle_cond | (
-			(sle_doctype.posting_date == filters.from_date)
-			& (sle_doctype.voucher_no.isin(list(opening_reco_vouchers)))
-		)
-
-	subq = (
-		frappe.qb.from_(sle_doctype)
-		.select(
-			sle_doctype.qty_after_transaction,
-			sle_doctype.stock_value,
-			RowNumber()
-			.over(sle_doctype.item_code, sle_doctype.warehouse)
-			.orderby(sle_doctype.posting_datetime, sle_doctype.creation, sle_doctype.name, order=Order.desc)
-			.as_("rn"),
-		)
-		.where(sle_doctype.docstatus < 2)
-		.where(sle_doctype.is_cancelled == 0)
-		.where(sle_doctype.item_code.isin(item_codes))
-		.where(sle_doctype.warehouse.isin(warehouses))
-		.where(sle_cond)
-	)
-
-	for field in ["voucher_no", "project", "company"]:
-		if filters.get(field):
-			subq = subq.where(sle_doctype[field] == filters.get(field))
-
-	inventory_dimension_fields = get_inventory_dimension_fields()
-	if inventory_dimension_fields:
-		for fieldname in inventory_dimension_fields:
-			if filters.get(fieldname):
-				subq = subq.where(sle_doctype[fieldname].isin(filters.get(fieldname)))
-
-	query = (
-		frappe.qb.from_(subq)
-		.select(
-			IfNull(Sum(subq.qty_after_transaction), 0.0).as_("total_qty"),
-			IfNull(Sum(subq.stock_value), 0.0).as_("total_stock_value"),
-		)
-		.where(subq.rn == 1)
-	)
-
-	res = query.run(as_dict=True)
-
-	total_qty = flt(res[0].total_qty) if res else 0.0
-	total_stock_value = flt(res[0].total_stock_value) if res else 0.0
-	valuation_rate = flt(total_stock_value / total_qty) if total_qty else 0.0
-
-	return {
+	row = {
 		"item_code": _("'Opening'"),
-		"qty_after_transaction": total_qty,
-		"valuation_rate": valuation_rate,
-		"stock_value": total_stock_value,
+		"qty_after_transaction": last_entry.get("qty_after_transaction", 0),
+		"valuation_rate": last_entry.get("valuation_rate", 0),
+		"stock_value": last_entry.get("stock_value", 0),
 	}
 
-
-def get_matching_warehouses(warehouses):
-	if not warehouses:
-		return []
-
-	if isinstance(warehouses, str):
-		warehouses = [warehouses]
-
-	warehouse_details = frappe.get_all(
-		"Warehouse",
-		filters={"name": ("in", warehouses)},
-		fields=["lft", "rgt"],
-	)
-
-	if not warehouse_details:
-		return warehouses
-
-	wh = frappe.qb.DocType("Warehouse")
-	cond = None
-	for d in warehouse_details:
-		c = (wh.lft >= d.lft) & (wh.rgt <= d.rgt)
-		cond = c if cond is None else (cond | c)
-
-	matching = (frappe.qb.from_(wh).select(wh.name).where(cond)).run(pluck=True)
-
-	return matching if matching else warehouses
+	return row
 
 
 def get_warehouse_condition(warehouses):
@@ -859,15 +779,7 @@ def get_opening_balance_for_inv_dimension(filters, inv_dimension_wise_value):
 	if not filters.item_code or not filters.warehouse or not filters.from_date:
 		return
 
-	item_codes = filters.get("item_code")
-	if isinstance(item_codes, str):
-		item_codes = [item_codes]
-
-	warehouses = filters.get("warehouse")
-	if isinstance(warehouses, str):
-		warehouses = [warehouses]
-
-	if len(item_codes) > 1 or len(warehouses) > 1:
+	if len(filters.get("item_code")) > 1 or len(filters.get("warehouse")) > 1:
 		return
 
 	sl_doctype = frappe.qb.DocType("Stock Ledger Entry")
@@ -887,11 +799,17 @@ def get_opening_balance_for_inv_dimension(filters, inv_dimension_wise_value):
 		)
 	)
 
-	if item_codes:
-		query = query.where(sl_doctype.item_code.isin(item_codes))
+	if filters.get("item_code"):
+		if isinstance(filters.item_code, list | tuple):
+			query = query.where(sl_doctype.item_code.isin(filters.item_code))
+		else:
+			query = query.where(sl_doctype.item_code == filters.item_code)
 
-	if warehouses:
-		query = query.where(sl_doctype.warehouse.isin(warehouses))
+	if filters.get("warehouse"):
+		if isinstance(filters.warehouse, list | tuple):
+			query = query.where(sl_doctype.warehouse.isin(filters.warehouse))
+		else:
+			query = query.where(sl_doctype.warehouse == filters.warehouse)
 
 	for key, value in inv_dimension_wise_value.items():
 		if isinstance(value, list | tuple):

erpnext/stock/report/stock_ledger/test_stock_ledger_report.py

@@ -5,335 +5,20 @@ import frappe
 from frappe.tests.utils import FrappeTestCase
 from frappe.utils import add_days, today
 
-from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry
-from erpnext.stock.report.stock_ledger.stock_ledger import execute
-
-WAREHOUSE = "Stores - _TC"
+from erpnext.maintenance.doctype.maintenance_schedule.test_maintenance_schedule import (
+	make_serial_item_with_serial,
+)
 
 
-class TestStockLedgerReport(FrappeTestCase):
-	"""Correctness tests for the Stock Ledger report.
-
-	A shared `make_movements`/`run` pair keeps each test small without persisting
-	any data: movements are created per test and rolled back, while the report runs
-	read-only. Tests reuse bootstrap items and transact in `Stores - _TC`, which
-	starts clean (zero balance) for these items.
-	"""
+class TestStockLedgerReeport(FrappeTestCase):
+	def setUp(self) -> None:
+		make_serial_item_with_serial("_Test Stock Report Serial Item")
+		self.filters = frappe._dict(
+			company="_Test Company",
+			from_date=today(),
+			to_date=add_days(today(), 30),
+			item_code=["_Test Stock Report Serial Item"],
+		)
 
 	def tearDown(self) -> None:
 		frappe.db.rollback()
-
-	def make_movements(self, item_code, movements):
-		for movement in movements:
-			make_stock_entry(item_code=item_code, **movement)
-
-	def run_report(self, item_code, from_date=None, to_date=None):
-		filters = frappe._dict(
-			company="_Test Company",
-			from_date=from_date or add_days(today(), -1),
-			to_date=to_date or today(),
-			item_code=[item_code],
-			warehouse=WAREHOUSE,
-		)
-		return list(execute(filters)[1])
-
-	def test_in_out_quantities_and_running_balance(self):
-		item = "_Test Item"
-		self.make_movements(
-			item,
-			[
-				{"qty": 10, "to_warehouse": WAREHOUSE, "basic_rate": 100},
-				{"qty": 4, "from_warehouse": WAREHOUSE},
-			],
-		)
-
-		rows = self.run_report(item)
-		receipt = next(row for row in rows if row.get("in_qty"))
-		issue = next(row for row in rows if row.get("out_qty"))
-
-		self.assertEqual(receipt["in_qty"], 10)
-		self.assertEqual(receipt["qty_after_transaction"], 10)
-		self.assertEqual(issue["out_qty"], -4)
-		self.assertEqual(issue["qty_after_transaction"], 6)
-
-	def test_opening_balance_reflects_movements_before_from_date(self):
-		item = "_Test Item"
-		self.make_movements(
-			item,
-			[
-				{
-					"qty": 10,
-					"to_warehouse": WAREHOUSE,
-					"basic_rate": 100,
-					"posting_date": add_days(today(), -10),
-				},
-				{"qty": 4, "from_warehouse": WAREHOUSE, "posting_date": today()},
-			],
-		)
-
-		rows = self.run_report(item, from_date=add_days(today(), -5), to_date=today())
-
-		# the receipt predates the range, so it surfaces as the opening balance
-		self.assertEqual(rows[0]["item_code"], "'Opening'")
-		self.assertEqual(rows[0]["qty_after_transaction"], 10)
-
-		# the in-range issue draws down from the opening balance
-		issue = next(row for row in rows if row.get("out_qty"))
-		self.assertEqual(issue["qty_after_transaction"], 6)
-
-	def test_filters_to_requested_item_only(self):
-		item_a = "_Test Item"
-		item_b = "_Test Item 2"
-		self.make_movements(item_a, [{"qty": 5, "to_warehouse": WAREHOUSE, "basic_rate": 100}])
-		self.make_movements(item_b, [{"qty": 7, "to_warehouse": WAREHOUSE, "basic_rate": 100}])
-
-		rows = self.run_report(item_a)
-		item_codes = {row["item_code"] for row in rows if row.get("voucher_no")}
-		self.assertEqual(item_codes, {item_a})
-
-	def test_multi_item_opening_balance_with_and_without_transactions(self):
-		item_a = "_Test Item"
-		item_b = "_Test Item 2"
-		self.make_movements(
-			item_a,
-			[
-				{
-					"qty": 10,
-					"to_warehouse": WAREHOUSE,
-					"basic_rate": 100,
-					"posting_date": add_days(today(), -10),
-				}
-			],
-		)
-		self.make_movements(
-			item_b,
-			[{"qty": 5, "to_warehouse": WAREHOUSE, "basic_rate": 50, "posting_date": add_days(today(), -10)}],
-		)
-		self.make_movements(
-			item_a,
-			[{"qty": 2, "from_warehouse": WAREHOUSE, "posting_date": today()}],
-		)
-
-		filters = frappe._dict(
-			company="_Test Company",
-			from_date=add_days(today(), -5),
-			to_date=today(),
-			item_code=[item_a, item_b],
-			warehouse=WAREHOUSE,
-		)
-		columns, rows = execute(filters)
-
-		opening_rows = [row for row in rows if row.get("item_code") == "'Opening'"]
-		self.assertEqual(len(opening_rows), 1)
-		self.assertEqual(opening_rows[0]["qty_after_transaction"], 15)
-
-	def test_multi_warehouse_opening_balance_aggregation(self):
-		item = "_Test Item"
-		warehouse_1 = "Stores - _TC"
-		warehouse_2 = "Finished Goods - _TC"
-
-		self.make_movements(
-			item,
-			[
-				{
-					"qty": 10,
-					"to_warehouse": warehouse_1,
-					"basic_rate": 100,
-					"posting_date": add_days(today(), -10),
-				},
-				{
-					"qty": 20,
-					"to_warehouse": warehouse_2,
-					"basic_rate": 100,
-					"posting_date": add_days(today(), -10),
-				},
-			],
-		)
-
-		filters = frappe._dict(
-			company="_Test Company",
-			from_date=add_days(today(), -5),
-			to_date=today(),
-			item_code=[item],
-			warehouse=[warehouse_1, warehouse_2],
-		)
-		columns, rows = execute(filters)
-
-		opening_rows = [row for row in rows if row.get("item_code") == "'Opening'"]
-		self.assertEqual(len(opening_rows), 1)
-		self.assertEqual(opening_rows[0]["qty_after_transaction"], 30)
-
-	def test_opening_stock_reconciliation_on_from_date_non_midnight_time(self):
-		from erpnext.stock.doctype.stock_reconciliation.test_stock_reconciliation import (
-			create_stock_reconciliation,
-		)
-
-		item = "_Test Item"
-		from_date = today()
-
-		sr = create_stock_reconciliation(
-			item_code=item,
-			warehouse=WAREHOUSE,
-			qty=25,
-			rate=100,
-			posting_date=from_date,
-			posting_time="10:30:00",
-			purpose="Opening Stock",
-			do_not_submit=False,
-		)
-
-		filters = frappe._dict(
-			company="_Test Company",
-			from_date=from_date,
-			to_date=from_date,
-			item_code=[item],
-			warehouse=WAREHOUSE,
-		)
-		columns, rows = execute(filters)
-
-		opening_rows = [row for row in rows if row.get("item_code") == "'Opening'"]
-		self.assertEqual(len(opening_rows), 1)
-		self.assertEqual(opening_rows[0]["qty_after_transaction"], 25)
-
-		# Ensure the Opening Stock Reconciliation is not duplicated in detail transaction rows
-		reco_rows = [row for row in rows if row.get("voucher_no") == sr.name]
-		self.assertEqual(len(reco_rows), 0)
-
-	def test_backdated_sle_independent_maxima_handling(self):
-		item = "_Test Item"
-		# Entry 1: Later posting date (2026-07-20), created first
-		self.make_movements(
-			item,
-			[
-				{
-					"qty": 10,
-					"to_warehouse": WAREHOUSE,
-					"basic_rate": 100,
-					"posting_date": add_days(today(), -10),
-				}
-			],
-		)
-		# Entry 2: Backdated posting date (2026-07-15), created LATER
-		self.make_movements(
-			item,
-			[
-				{
-					"qty": 5,
-					"to_warehouse": WAREHOUSE,
-					"basic_rate": 100,
-					"posting_date": add_days(today(), -15),
-				}
-			],
-		)
-
-		filters = frappe._dict(
-			company="_Test Company",
-			from_date=add_days(today(), -5),
-			to_date=today(),
-			item_code=[item],
-			warehouse=WAREHOUSE,
-		)
-		columns, rows = execute(filters)
-
-		opening_rows = [row for row in rows if row.get("item_code") == "'Opening'"]
-		self.assertEqual(len(opening_rows), 1)
-		# Should correctly pick the latest posting date entry (15 Qty) despite backdated creation order
-		self.assertEqual(opening_rows[0]["qty_after_transaction"], 15)
-
-	def test_filtered_opening_balance_does_not_pick_excluded_creation_entry(self):
-		item = "_Test Item"
-		posting_date = add_days(today(), -10)
-		posting_time = "09:00:00"
-
-		included_entry = make_stock_entry(
-			item_code=item,
-			qty=10,
-			to_warehouse=WAREHOUSE,
-			basic_rate=100,
-			posting_date=posting_date,
-			posting_time=posting_time,
-		)
-		make_stock_entry(
-			item_code=item,
-			qty=50,
-			to_warehouse=WAREHOUSE,
-			basic_rate=100,
-			posting_date=posting_date,
-			posting_time=posting_time,
-		)
-
-		filters = frappe._dict(
-			company="_Test Company",
-			from_date=add_days(today(), -5),
-			to_date=today(),
-			item_code=[item],
-			warehouse=WAREHOUSE,
-			voucher_no=included_entry.name,
-		)
-		columns, rows = execute(filters)
-
-		opening_rows = [row for row in rows if row.get("item_code") == "'Opening'"]
-		self.assertEqual(len(opening_rows), 1)
-		self.assertEqual(opening_rows[0]["qty_after_transaction"], 10)
-
-	def test_tied_creation_terminal_sle_is_not_summed_twice(self):
-		item = "_Test Item"
-		posting_date = add_days(today(), -10)
-		posting_time = "09:00:00"
-
-		stock_entry_1 = make_stock_entry(
-			item_code=item,
-			qty=10,
-			to_warehouse=WAREHOUSE,
-			basic_rate=100,
-			posting_date=posting_date,
-			posting_time=posting_time,
-		)
-		stock_entry_2 = make_stock_entry(
-			item_code=item,
-			qty=5,
-			to_warehouse=WAREHOUSE,
-			basic_rate=100,
-			posting_date=posting_date,
-			posting_time=posting_time,
-		)
-
-		sle_rows = frappe.get_all(
-			"Stock Ledger Entry",
-			filters={
-				"voucher_type": "Stock Entry",
-				"voucher_no": ("in", [stock_entry_1.name, stock_entry_2.name]),
-				"item_code": item,
-				"warehouse": WAREHOUSE,
-				"is_cancelled": 0,
-			},
-			fields=["name", "qty_after_transaction"],
-			order_by="name desc",
-		)
-		self.assertEqual(len(sle_rows), 2)
-
-		for sle in sle_rows:
-			frappe.db.set_value(
-				"Stock Ledger Entry",
-				sle.name,
-				"creation",
-				"2026-01-01 00:00:00.000000",
-				update_modified=False,
-			)
-
-		filters = frappe._dict(
-			company="_Test Company",
-			from_date=add_days(today(), -5),
-			to_date=today(),
-			item_code=[item],
-			warehouse=WAREHOUSE,
-		)
-		columns, rows = execute(filters)
-
-		opening_rows = [row for row in rows if row.get("item_code") == "'Opening'"]
-		self.assertEqual(len(opening_rows), 1)
-		self.assertEqual(opening_rows[0]["qty_after_transaction"], sle_rows[0].qty_after_transaction)
-		self.assertNotEqual(
-			opening_rows[0]["qty_after_transaction"],
-			sum(sle.qty_after_transaction for sle in sle_rows),
-		)

erpnext/stock/serial_batch_bundle.py

@@ -910,11 +910,6 @@ class BatchNoValuation(DeprecatedBatchNoValuation):
 		self.batchwise_valuation_batches = []
 		self.non_batchwise_valuation_batches = []
 
-		if batchwise_batches := self.sle.get("batchwise_valuation_batches"):
-			self.batchwise_valuation_batches = list(batchwise_batches)
-			self.non_batchwise_valuation_batches = list(set(self.batches) - set(batchwise_batches))
-			return
-
 		if get_valuation_method(self.sle.item_code) == "Moving Average" and frappe.db.get_single_value(
 			"Stock Settings", "do_not_use_batchwise_valuation"
 		):