chore(release): Bumped to Version 15.121.0

# [15.121.0](https://github.com/frappe/erpnext/compare/v15.120.0...v15.121.0) (2026-09-02)

### Bug Fixes

* **accounts:** set pos profile on invoices respecting user permissions (backport [#58508](https://github.com/frappe/erpnext/issues/58508)) ([#58518](https://github.com/frappe/erpnext/issues/58518)) ([1187fb8](1187fb8e01))
* **accounts:** validate frozen accounts in period closing voucher ([#58477](https://github.com/frappe/erpnext/issues/58477)) ([045d708](045d7086d1))
* add missing perm checks on various whitelisted methods (backport [#58652](https://github.com/frappe/erpnext/issues/58652)) ([#58653](https://github.com/frappe/erpnext/issues/58653)) ([547d82d](547d82da56))
* add type hints to make_request_for_quotation ([567730e](567730e38e))
* **bank_statement_import:** add missing permission check on multiple whitelisted methods (backport [#58221](https://github.com/frappe/erpnext/issues/58221)) ([#58223](https://github.com/frappe/erpnext/issues/58223)) ([fa903f4](fa903f40fd))
* clarify duplicate internal party messages ([#58469](https://github.com/frappe/erpnext/issues/58469)) ([17208e7](17208e7434))
* **company:** throw if linked to demo_company field ([de260bd](de260bd43c))
* **crm:** add missing permission validation on `get_contract_template` (backport [#58621](https://github.com/frappe/erpnext/issues/58621)) ([#58622](https://github.com/frappe/erpnext/issues/58622)) ([d1b615b](d1b615b851))
* **crm:** check write permission in edit_note ([2b2a005](2b2a005682))
* do not map the same row twice in "Get Items From" (backport [#58617](https://github.com/frappe/erpnext/issues/58617)) ([#58618](https://github.com/frappe/erpnext/issues/58618)) ([28175a5](28175a5c9d))
* filter fully ordered items when creating RFQ from Material Request ([08ec311](08ec31174c))
* keep Currency and Price List section open for foreign currency (backport [#58074](https://github.com/frappe/erpnext/issues/58074)) ([#58112](https://github.com/frappe/erpnext/issues/58112)) ([f5ce20f](f5ce20f122))
* keep source rate on re-fetch when maintain same rate is enabled (backport [#57479](https://github.com/frappe/erpnext/issues/57479)) ([#58332](https://github.com/frappe/erpnext/issues/58332)) ([228ab2d](228ab2d97e)), closes [frappe/erpnext#57436](https://github.com/frappe/erpnext/issues/57436)
* **manufacturing:** preserve job card qty in mr transfer (backport [#58482](https://github.com/frappe/erpnext/issues/58482)) ([#58498](https://github.com/frappe/erpnext/issues/58498)) ([099a5a7](099a5a71d9))
* **manufacturing:** use packed row delivery date ([#58569](https://github.com/frappe/erpnext/issues/58569)) ([9c19b02](9c19b024db))
* mark item tax templates as not applicable (backport [#54673](https://github.com/frappe/erpnext/issues/54673)) (backport [#54677](https://github.com/frappe/erpnext/issues/54677)) ([#58462](https://github.com/frappe/erpnext/issues/58462)) ([d62f6e7](d62f6e715f))
* persist redistributed additional costs during stock entry repost (backport [#58433](https://github.com/frappe/erpnext/issues/58433)) ([#58532](https://github.com/frappe/erpnext/issues/58532)) ([c4e7cfa](c4e7cfa6a0))
* **projects:** check read permission on source in create_duplicate_project ([af8c010](af8c010aa8))
* **projects:** ignore cancelled invoices in timesheet portal (backport [#58501](https://github.com/frappe/erpnext/issues/58501)) ([#58503](https://github.com/frappe/erpnext/issues/58503)) ([5a51895](5a518951e4))
* reset hardcoded letter head on Incorrect Serial and Batch Bundle report ([ccdaa92](ccdaa92de8))
* resolve analytics backport conflicts ([605918d](605918d3a2))
* resolve conflicts ([c6717fb](c6717fb758))
* resolve stock entry backport conflicts ([e126c45](e126c4597b))
* round party balances to currency precision in Trial Balance for Party ([b98d193](b98d193b77))
* **selling:** check quotation write permission before marking lost ([#58493](https://github.com/frappe/erpnext/issues/58493)) ([33ebc7d](33ebc7d7e3))
* **selling:** check sales order permission before work order creation ([#58492](https://github.com/frappe/erpnext/issues/58492)) ([0609b06](0609b06564))
* **sms_settings:** add patch to pre-fill roles into SMS Settings Roles Table ([0cef90d](0cef90d079))
* **stock:** keep pick list links when refetching stock entry items ([22377fa](22377fa86d))
* **stock:** load available serial no report (backport [#58558](https://github.com/frappe/erpnext/issues/58558)) ([#58561](https://github.com/frappe/erpnext/issues/58561)) ([2d46bb9](2d46bb962c))
* **stock:** preserve exchange gain loss journals in lcv ([#58505](https://github.com/frappe/erpnext/issues/58505)) ([c6fedf4](c6fedf4aca))
* **stock:** reset bin when a repost finds no stock ledger entries  ([#58434](https://github.com/frappe/erpnext/issues/58434)) ([b00062d](b00062df86)), closes [#58362](https://github.com/frappe/erpnext/issues/58362)
* **stock:** validate serial inventory dimensions ([#58394](https://github.com/frappe/erpnext/issues/58394)) ([bc071d7](bc071d7793))
* sum item and its alternate transferred qty on work order required items ([5851bb3](5851bb3b6e))
* **taxes:** skip tax addition for invoice created from opening invoice tool ([7090c6f](7090c6fdab))
* **timesheet:** scoping whitelisted methods output to projects and timesheets that are acccessible to users (backport [#58267](https://github.com/frappe/erpnext/issues/58267)) ([#58576](https://github.com/frappe/erpnext/issues/58576)) ([c656497](c656497aac))
* translate doctype in map msg (backport [#58515](https://github.com/frappe/erpnext/issues/58515)) ([#58516](https://github.com/frappe/erpnext/issues/58516)) ([d87a4b2](d87a4b2541))
* translate label in party validation (backport [#58624](https://github.com/frappe/erpnext/issues/58624)) ([#58625](https://github.com/frappe/erpnext/issues/58625)) ([307ffcd](307ffcd5c3))
* validate items against source Sales Order in Material Request ([32d44c6](32d44c6e91))
* validate POS Settings invoice and search fields on the server (backport [#58611](https://github.com/frappe/erpnext/issues/58611)) ([#58612](https://github.com/frappe/erpnext/issues/58612)) ([c5bc5f9](c5bc5f9c31))
* Work Order picks wrong Delivery Date when Sales Order has the same item in multiple rows ([#58527](https://github.com/frappe/erpnext/issues/58527)) ([7454735](7454735595))

### Features

* **analytics:** filter sales and purchase analytics by entity ([#58402](https://github.com/frappe/erpnext/issues/58402)) ([0dddd00](0dddd00073))

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.121.0"
 
 
 def get_default_company(user=None):

erpnext/accounts/report/utils.py

@@ -304,9 +304,6 @@ def get_payment_entries(filters, args):
 			pe.mode_of_payment,
 			pe.project,
 			pe.cost_center,
-			pe.payment_type,
-			pe.source_exchange_rate,
-			pe.target_exchange_rate,
 		)
 		.where(
 			(pe.docstatus == 1)
@@ -317,22 +314,6 @@ def get_payment_entries(filters, args):
 	)
 	query = apply_common_conditions(filters, query, doctype="Payment Entry", payments=True)
 	payment_entries = query.run(as_dict=True)
-
-	if payment_entries:
-		ded = frappe.qb.DocType("Payment Entry Deduction")
-		deduction_totals = frappe._dict(
-			frappe.qb.from_(ded)
-			.select(ded.parent, Sum(ded.amount))
-			.where(ded.parent.isin([d.name for d in payment_entries]) & (ded.is_exchange_gain_loss == 0))
-			.groupby(ded.parent)
-			.run()
-		)
-		for d in payment_entries:
-			exchange_rate = (
-				d.source_exchange_rate if d.payment_type == "Receive" else d.target_exchange_rate
-			) or 1
-			d.base_grand_total = flt(d.base_grand_total) + flt(deduction_totals.get(d.name)) / exchange_rate
-
 	return payment_entries
 
 

erpnext/crm/doctype/email_campaign/email_campaign.py

@@ -29,18 +29,11 @@ class EmailCampaign(Document):
 
 	def validate(self):
 		self.set_date()
-		self.validate_recipient_email()
-		self.validate_email_campaign_already_exists()
-		self.update_status()
-
-	def validate_recipient_email(self):
-		if not self.recipient:
-			return
-
+		# checking if email is set for lead. Not checking for contact as email is a mandatory field for contact.
 		if self.email_campaign_for == "Lead":
 			self.validate_lead()
-		elif self.email_campaign_for == "Contact":
-			self.validate_contact()
+		self.validate_email_campaign_already_exists()
+		self.update_status()
 
 	def set_date(self):
 		if getdate(self.start_date) < getdate(today()):
@@ -63,13 +56,6 @@ class EmailCampaign(Document):
 			lead_name = frappe.db.get_value("Lead", self.recipient, "lead_name")
 			frappe.throw(_("Please set an email id for the Lead {0}").format(lead_name))
 
-	def validate_contact(self):
-		contact = frappe.db.get_value("Contact", self.recipient, ["email_id", "full_name"], as_dict=True)
-		if contact and not contact.email_id:
-			frappe.throw(
-				_("Please set a primary email ID for the Contact {0}").format(frappe.bold(contact.full_name))
-			)
-
 	def validate_email_campaign_already_exists(self):
 		email_campaign_exists = frappe.db.exists(
 			"Email Campaign",

erpnext/crm/doctype/email_campaign/test_email_campaign.py

@@ -1,84 +1,9 @@
 # Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+# import frappe
 import unittest
 
-import frappe
-from frappe.utils import add_days, getdate, today
-
 
 class TestEmailCampaign(unittest.TestCase):
-	"""Email Campaign derives its window from the linked Campaign schedule and
-	guards the start date and the recipient's email."""
-
-	def setUp(self):
-		frappe.set_user("Administrator")
-
-	def make_email_template(self):
-		name = "_Test EC Email Template"
-		if not frappe.db.exists("Email Template", name):
-			frappe.get_doc(
-				{"doctype": "Email Template", "name": name, "subject": "Test", "response": "Hello"}
-			).insert()
-		return name
-
-	def make_campaign(self, schedules):
-		campaign = frappe.new_doc("Campaign")
-		campaign.campaign_name = f"_Test EC Campaign {frappe.generate_hash(length=6)}"
-		for days in schedules:
-			campaign.append(
-				"campaign_schedules",
-				{"send_after_days": days, "email_template": self.make_email_template()},
-			)
-		return campaign.insert()
-
-	def make_email_campaign(self, campaign_name, start_date=None):
-		doc = frappe.new_doc("Email Campaign")
-		doc.campaign_name = campaign_name
-		doc.start_date = start_date or today()
-		return doc
-
-	def test_start_date_cannot_be_in_the_past(self):
-		doc = self.make_email_campaign("irrelevant", start_date=add_days(today(), -1))
-		self.assertRaises(frappe.ValidationError, doc.set_date)
-
-	def test_end_date_is_start_plus_max_send_after_days(self):
-		campaign = self.make_campaign(schedules=[0, 5])
-		doc = self.make_email_campaign(campaign.name)
-		doc.set_date()
-		self.assertEqual(getdate(doc.end_date), add_days(getdate(today()), 5))
-
-	def test_campaign_without_a_schedule_is_rejected(self):
-		campaign = self.make_campaign(schedules=[])
-		doc = self.make_email_campaign(campaign.name)
-		self.assertRaises(frappe.ValidationError, doc.set_date)
-
-	def test_lead_without_an_email_is_rejected(self):
-		lead = frappe.get_doc({"doctype": "Lead", "lead_name": "_Test Lead No Email"}).insert()
-		doc = frappe.new_doc("Email Campaign")
-		doc.email_campaign_for = "Lead"
-		doc.recipient = lead.name
-		self.assertRaises(frappe.ValidationError, doc.validate_lead)
-
-	def test_contact_without_an_email_is_rejected(self):
-		contact = frappe.get_doc({"doctype": "Contact", "first_name": "_Test Contact No Email"}).insert()
-		campaign = self.make_campaign(schedules=[0])
-		doc = self.make_email_campaign(campaign.name)
-		doc.email_campaign_for = "Contact"
-		doc.recipient = contact.name
-		self.assertRaisesRegex(frappe.ValidationError, "primary email ID", doc.insert)
-
-	def test_contact_with_an_email_is_accepted(self):
-		contact = frappe.get_doc(
-			{
-				"doctype": "Contact",
-				"first_name": "_Test Contact With Email",
-				"email_ids": [{"email_id": "_test_email_campaign@example.com", "is_primary": 1}],
-			}
-		).insert()
-		campaign = self.make_campaign(schedules=[0])
-		doc = self.make_email_campaign(campaign.name)
-		doc.email_campaign_for = "Contact"
-		doc.recipient = contact.name
-		doc.insert()
-		self.assertEqual(doc.status, "In Progress")
+	pass

erpnext/crm/doctype/lead/lead.py

@@ -516,11 +516,8 @@ def get_lead_with_phone_number(number):
 	return lead
 
 
-@frappe.whitelist(methods=["POST"])
-def add_lead_to_prospect(lead: str, prospect: str):
-	if lead:
-		frappe.has_permission("Lead", "read", lead, throw=True)
-
+@frappe.whitelist()
+def add_lead_to_prospect(lead, prospect):
 	prospect = frappe.get_doc("Prospect", prospect)
 	prospect.append("leads", {"lead": lead})
 	prospect.save()

erpnext/manufacturing/doctype/job_card/test_job_card.py

@@ -206,6 +206,43 @@ class TestJobCard(FrappeTestCase):
 		# transfer was made for 2 fg qty in first transfer Stock Entry
 		self.assertEqual(transfer_entry_2.fg_completed_qty, 0)
 
+	def test_material_request_stock_entry_uses_job_card_coverage(self):
+		from erpnext.stock.doctype.material_request.material_request import make_stock_entry
+
+		self.transfer_material_against = "Job Card"
+		self.source_warehouse = "Stores - _TC"
+		job_card = frappe.get_last_doc("Job Card", {"work_order": self.work_order.name})
+		mr = make_material_request(job_card.name)
+		mr.schedule_date = today()
+		for row in mr.items:
+			row.qty = flt(row.qty) / 2
+			row.stock_qty = flt(row.stock_qty) / 2
+		mr.submit()
+
+		stock_entry = make_stock_entry(mr.name)
+		self.assertEqual(stock_entry.fg_completed_qty, job_card.for_quantity / 2)
+
+		selected_row = mr.items[0]
+		try:
+			frappe.flags.selected_children = {"items": [selected_row.name]}
+			selected_stock_entry = make_stock_entry(mr.name)
+		finally:
+			frappe.flags.selected_children = None
+
+		self.assertEqual(
+			[row.job_card_item for row in selected_stock_entry.items], [selected_row.job_card_item]
+		)
+		self.assertEqual(selected_stock_entry.fg_completed_qty, 0)
+
+		for row in mr.items:
+			transferred_qty = flt(row.stock_qty) / 2
+			frappe.db.set_value("Job Card Item", row.job_card_item, "transferred_qty", transferred_qty)
+			frappe.db.set_value(row.doctype, row.name, "ordered_qty", transferred_qty)
+		mr.reload()
+
+		repeated_stock_entry = make_stock_entry(mr.name)
+		self.assertEqual(repeated_stock_entry.fg_completed_qty, job_card.for_quantity / 4)
+
 	@change_settings("Manufacturing Settings", {"job_card_excess_transfer": 1})
 	def test_job_card_excess_material_transfer(self):
 		"Test transferring more than required RM against Job Card."
@@ -616,6 +653,7 @@ class TestJobCard(FrappeTestCase):
 		self.assertEqual(ste.job_card, job_card_name)
 		self.assertEqual(ste.from_bom, 1.0)
 		self.assertEqual(ste.bom_no, work_order.bom_no)
+		self.assertEqual(ste.fg_completed_qty, frappe.get_value("Job Card", job_card_name, "for_quantity"))
 
 	def test_job_card_proccess_qty_and_completed_qty(self):
 		from erpnext.manufacturing.doctype.routing.test_routing import (

erpnext/manufacturing/doctype/production_plan/production_plan.py

@@ -887,9 +887,6 @@ class ProductionPlan(Document):
 		material_request_map = {}
 
 		for item in self.mr_items:
-			if not item.quantity:
-				continue
-
 			item_doc = frappe.get_cached_doc("Item", item.item_code)
 
 			material_request_type = item.material_request_type or item_doc.default_material_request_type

erpnext/manufacturing/doctype/production_plan/test_production_plan.py

@@ -107,19 +107,6 @@ class TestProductionPlan(FrappeTestCase):
 		pln = frappe.get_doc("Production Plan", pln.name)
 		pln.cancel()
 
-	def test_production_plan_mr_creation_skips_zero_qty(self):
-		pln = create_production_plan(item_code="Test Production Item 1", do_not_submit=1)
-		pln.mr_items[0].quantity = 0
-		pln.save().submit()
-
-		pln.make_material_request()
-
-		quantities = frappe.get_all(
-			"Material Request Item", filters={"production_plan": pln.name}, pluck="qty"
-		)
-		self.assertEqual(len(quantities), len(pln.mr_items) - 1)
-		self.assertNotIn(0, quantities)
-
 	def test_production_plan_start_date(self):
 		"Test if Work Order has same Planned Start Date as Prod Plan."
 		planned_date = add_to_date(date=None, days=3)

erpnext/manufacturing/doctype/work_order/services/__init__.py

@@ -0,0 +1 @@
+

erpnext/manufacturing/doctype/work_order/services/material_coverage.py

@@ -0,0 +1,22 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+from collections.abc import Mapping
+
+from frappe.utils import flt
+
+
+def get_minimum_material_coverage_fraction(
+	required_qty: Mapping[str, float], transferred_qty: Mapping[str, float], precision: int
+) -> float:
+	"""Return the least-covered component ratio at the configured quantity precision."""
+	coverage = []
+	for item_code, required in required_qty.items():
+		transferred = flt(transferred_qty.get(item_code))
+		# Stored values can differ after the digits that the user can enter or see.
+		if flt(transferred, precision) == flt(required, precision):
+			coverage.append(1.0)
+		else:
+			coverage.append(transferred / required)
+
+	return min(coverage, default=0.0)

erpnext/manufacturing/doctype/work_order/test_work_order.py

@@ -1461,9 +1461,11 @@ class TestWorkOrder(FrappeTestCase):
 		del transfer_entry.get("items")[0]  # transfer only one RM
 		transfer_entry.submit()
 
-		# WO's "Material Transferred for Mfg" shows all is transferred, one RM is pending
+		# One required item is still missing, so no finished-good quantity is covered yet.
 		work_order.reload()
-		self.assertEqual(work_order.material_transferred_for_manufacturing, 1)
+		self.assertEqual(transfer_entry.fg_completed_qty, 0)
+		self.assertEqual(work_order.material_transferred_for_manufacturing, 0)
+		self.assertEqual(work_order.status, "In Process")
 		self.assertEqual(work_order.required_items[0].transferred_qty, 0)
 		self.assertEqual(work_order.required_items[1].transferred_qty, 2)
 
@@ -1483,6 +1485,47 @@ class TestWorkOrder(FrappeTestCase):
 		self.assertEqual(work_order.required_items[0].transferred_qty, 1)
 		self.assertEqual(work_order.required_items[1].transferred_qty, 2)
 
+	def test_material_transfer_claim_follows_actual_coverage(self):
+		work_order = make_wo_order_test_record(planned_start_date=now(), qty=4)
+		test_stock_entry.make_stock_entry(
+			item_code="_Test Item", target="_Test Warehouse - _TC", qty=10, basic_rate=5000.0
+		)
+		test_stock_entry.make_stock_entry(
+			item_code="_Test Item Home Desktop 100",
+			target="_Test Warehouse - _TC",
+			qty=20,
+			basic_rate=1000.0,
+		)
+
+		transfer_entry = frappe.get_doc(
+			make_stock_entry(work_order.name, "Material Transfer for Manufacture", 4)
+		)
+		for row in transfer_entry.items:
+			if row.item_code == "_Test Item":
+				row.qty = 1
+		transfer_entry.submit()
+
+		work_order.reload()
+		self.assertEqual(transfer_entry.fg_completed_qty, 1)
+		self.assertEqual(work_order.material_transferred_for_manufacturing, 1)
+
+		remainder_entry = frappe.get_doc(
+			make_stock_entry(work_order.name, "Material Transfer for Manufacture", 3)
+		)
+		remainder_entry.submit()
+
+		work_order.reload()
+		self.assertEqual(remainder_entry.fg_completed_qty, 3)
+		self.assertEqual(work_order.material_transferred_for_manufacturing, 4)
+
+	def test_material_coverage_cap_skips_manufacture_entry(self):
+		work_order = make_wo_order_test_record(planned_start_date=now(), qty=1)
+		manufacture_entry = frappe.get_doc(make_stock_entry(work_order.name, "Manufacture", 1))
+		manufacture_entry.pro_doc = work_order
+		manufacture_entry._action = "submit"
+
+		self.assertFalse(manufacture_entry._should_cap_completed_qty())
+
 	def test_material_transferred_min_fraction_on_partial_pick_list(self):
 		"""Pick-list flow (fg_completed_qty = 0): 'Material Transferred for Manufacturing'
 		must reflect the least-transferred required item (the bottleneck), instead of being
@@ -1545,6 +1588,97 @@ class TestWorkOrder(FrappeTestCase):
 		work_order.reload()
 		self.assertEqual(work_order.material_transferred_for_manufacturing, 2.0)
 
+	def test_material_transferred_ignores_hidden_precision_difference(self):
+		work_order = make_wo_order_test_record(planned_start_date=now(), qty=2)
+		test_stock_entry.make_stock_entry(
+			item_code="_Test Item", target="_Test Warehouse - _TC", qty=10, basic_rate=5000.0
+		)
+		test_stock_entry.make_stock_entry(
+			item_code="_Test Item Home Desktop 100",
+			target="_Test Warehouse - _TC",
+			qty=10,
+			basic_rate=1000.0,
+		)
+
+		precision = work_order.precision("required_qty", "required_items")
+		hidden_difference = 4 / (10 ** (precision + 1))
+		row = work_order.required_items[0]
+		row.db_set("required_qty", flt(row.required_qty) + hidden_difference, update_modified=False)
+		work_order.reload()
+		required_qty = {row.item_code: flt(row.required_qty) for row in work_order.required_items}
+
+		transfer_entry = frappe.get_doc(
+			make_stock_entry(work_order.name, "Material Transfer for Manufacture", 0)
+		)
+		for item in transfer_entry.items:
+			item.qty = flt(required_qty[item.item_code], precision)
+			item.transfer_qty = item.qty
+		transfer_entry.submit()
+
+		work_order.reload()
+		self.assertEqual(
+			flt(work_order.required_items[0].required_qty, precision),
+			flt(work_order.required_items[0].transferred_qty, precision),
+		)
+		self.assertEqual(work_order.material_transferred_for_manufacturing, work_order.qty)
+
+	def test_repair_material_transfer_precision_patch(self):
+		from erpnext.patches.v16_0.repair_work_order_material_transfer import (
+			execute,
+			get_precision_affected_work_orders,
+		)
+
+		precision = frappe.get_precision("Work Order Item", "required_qty")
+		hidden_difference = 4 / (10 ** (precision + 1))
+		work_order = make_wo_order_test_record(planned_start_date=now(), qty=2)
+		for index, row in enumerate(work_order.required_items):
+			required_qty = flt(row.required_qty) + (hidden_difference if index == 0 else 0)
+			row.db_set(
+				{
+					"required_qty": required_qty,
+					"transferred_qty": flt(required_qty, precision),
+				},
+				update_modified=False,
+			)
+		work_order.db_set("material_transferred_for_manufacturing", 1.99, update_modified=False)
+
+		partial_work_order = make_wo_order_test_record(planned_start_date=now(), qty=2)
+		for row in partial_work_order.required_items:
+			row.db_set("transferred_qty", row.required_qty, update_modified=False)
+		partial_row = partial_work_order.required_items[0]
+		partial_row.db_set(
+			"transferred_qty",
+			flt(partial_row.required_qty, precision) - (1 / (10**precision)),
+			update_modified=False,
+		)
+		partial_work_order.db_set("material_transferred_for_manufacturing", 1.99, update_modified=False)
+
+		terminal_work_orders = []
+		for status in ("Stopped", "Closed", "Completed"):
+			terminal_work_order = make_wo_order_test_record(planned_start_date=now(), qty=2)
+			for row in terminal_work_order.required_items:
+				row.db_set("transferred_qty", row.required_qty, update_modified=False)
+			terminal_work_order.db_set(
+				{"material_transferred_for_manufacturing": 1.99, "status": status},
+				update_modified=False,
+			)
+			terminal_work_orders.append(terminal_work_order)
+
+		updates = get_precision_affected_work_orders()
+		self.assertIn(work_order.name, updates)
+		self.assertNotIn(partial_work_order.name, updates)
+		for terminal_work_order in terminal_work_orders:
+			self.assertNotIn(terminal_work_order.name, updates)
+
+		execute()
+		work_order.reload()
+		partial_work_order.reload()
+		self.assertEqual(work_order.material_transferred_for_manufacturing, work_order.qty)
+		self.assertEqual(partial_work_order.material_transferred_for_manufacturing, 1.99)
+		for terminal_work_order in terminal_work_orders:
+			terminal_work_order.reload()
+			self.assertEqual(terminal_work_order.material_transferred_for_manufacturing, 1.99)
+
 	def test_status_in_process_when_only_one_required_item_transferred(self):
 		"""Stock Entry created from a Pick List that picked only one of the required items:
 		min-fraction keeps material_transferred_for_manufacturing at 0, but the work order must

erpnext/manufacturing/doctype/work_order/work_order.py

@@ -31,6 +31,9 @@ from erpnext.manufacturing.doctype.bom.bom import (
 from erpnext.manufacturing.doctype.manufacturing_settings.manufacturing_settings import (
 	get_mins_between_operations,
 )
+from erpnext.manufacturing.doctype.work_order.services.material_coverage import (
+	get_minimum_material_coverage_fraction,
+)
 from erpnext.setup.doctype.item_group.item_group import get_item_group_defaults
 from erpnext.stock.doctype.batch.batch import make_batch
 from erpnext.stock.doctype.item.item import get_item_defaults, validate_end_of_life
@@ -458,8 +461,7 @@ class WorkOrder(Document):
 		return status
 
 	def has_transferred_material(self):
-		"""True if any raw material was transferred against this work order via a pick list
-		(these leave material_transferred_for_manufacturing at 0 via the min-fraction rule)."""
+		"""True if any raw material was transferred against this work order."""
 		ste = frappe.qb.DocType("Stock Entry")
 		ste_child = frappe.qb.DocType("Stock Entry Detail")
 		qty = (
@@ -472,7 +474,6 @@ class WorkOrder(Document):
 				& (ste.docstatus == 1)
 				& (ste.purpose == "Material Transfer for Manufacture")
 				& (ste.is_return == 0)
-				& (ste.pick_list.isnotnull())
 			)
 		).run()[0][0]
 		return flt(qty) > 0
@@ -1303,20 +1304,13 @@ class WorkOrder(Document):
 		self.recompute_material_transferred_for_manufacturing(transferred_items)
 
 	def recompute_material_transferred_for_manufacturing(self, transferred_items):
-		"""Set material_transferred_for_manufacturing based on actual item-level transfers, not fg_completed_qty."""
+		"""Set transferred quantity from the raw materials that have actually moved."""
 		# Job Card transfers use the minimum completed quantity across operations.
 		if self.operations and self.transfer_material_against == "Job Card":
 			return
 
-		# When fg_completed_qty > 0 (direct stock entries, excess transfer), preserve the
-		# SUM(fg_completed_qty) approach so excess-transfer tracking works correctly.
-		sum_fg_completed_qty = self.get_transferred_or_manufactured_qty("Material Transfer for Manufacture")
-		if sum_fg_completed_qty:
-			self.db_set("material_transferred_for_manufacturing", sum_fg_completed_qty)
-			return
+		claimed_qty = self.get_transferred_or_manufactured_qty("Material Transfer for Manufacture")
 
-		# Pick list flow sets fg_completed_qty=0; use min-fraction of actual item transfers
-		# so partial availability does not prematurely mark the work order as fully transferred.
 		required_by_item = {}
 		for row in self.required_items:
 			if not row.include_item_in_manufacturing or flt(row.required_qty) <= 0:
@@ -1326,12 +1320,13 @@ class WorkOrder(Document):
 		if not required_by_item:
 			return
 
-		min_fraction = min(
-			flt(transferred_items.get(item_code) or 0) / required_qty
-			for item_code, required_qty in required_by_item.items()
+		min_fraction = get_minimum_material_coverage_fraction(
+			required_by_item,
+			transferred_items,
+			self.precision("required_qty", "required_items"),
 		)
-		min_fraction = min(min_fraction, 1.0)
-		material_transferred = min_fraction * flt(self.qty)
+		covered_qty = min_fraction * flt(self.qty)
+		material_transferred = min(covered_qty, max(flt(self.qty), claimed_qty))
 		self.db_set("material_transferred_for_manufacturing", material_transferred)
 
 	def update_returned_qty(self):

erpnext/manufacturing/report/bom_stock_analysis/bom_stock_analysis.js

@@ -1,60 +0,0 @@
-// Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and contributors
-// For license information, please see license.txt
-
-frappe.query_reports["BOM Stock Analysis"] = {
-	filters: [
-		{
-			fieldname: "bom",
-			label: __("BOM"),
-			fieldtype: "Link",
-			options: "BOM",
-			reqd: 1,
-			get_query: () => ({ filters: { docstatus: 1 } }),
-		},
-		{
-			fieldname: "warehouse",
-			label: __("Warehouse"),
-			fieldtype: "Link",
-			options: "Warehouse",
-		},
-		{
-			fieldname: "qty_to_make",
-			label: __("FG Items to Make"),
-			fieldtype: "Float",
-		},
-		{
-			fieldname: "show_exploded_view",
-			label: __("Show availability of exploded items"),
-			fieldtype: "Check",
-			default: false,
-		},
-	],
-	formatter(value, row, column, data, default_formatter) {
-		if (data && data.bold && column.fieldname === "item") {
-			return value ? `<b>${value}</b>` : "";
-		}
-
-		value = default_formatter(value, row, column, data);
-
-		if (column.fieldname === "difference_qty" && value !== "" && value !== undefined) {
-			const numeric = parseFloat(value.replace(/,/g, "")) || 0;
-			if (numeric < 0) {
-				value = `<span style="color: red">${value}</span>`;
-			} else if (numeric > 0) {
-				value = `<span style="color: green">${value}</span>`;
-			}
-		}
-
-		if (data && data.bold) {
-			if (column.fieldname === "description") {
-				const qty_to_make = Number(frappe.query_report.get_filter_value("qty_to_make")) || 0;
-				const producible = Number(String(data.description ?? "").replace(/,/g, "")) || 0;
-				const colour = qty_to_make && producible < qty_to_make ? "red" : "green";
-				return `<b style="color: ${colour}">${value}</b>`;
-			}
-			return `<b>${value}</b>`;
-		}
-
-		return value;
-	},
-};

erpnext/patches.txt

@@ -447,6 +447,7 @@ erpnext.patches.v16_0.rename_ar_ap_ageing_filter
 erpnext.patches.v15_0.fix_titles
 erpnext.patches.v16_0.backfill_repost_accounting_ledger_status
 erpnext.patches.v16_0.merge_seeded_item_group_root
+erpnext.patches.v16_0.repair_work_order_material_transfer
 erpnext.patches.v16_0.remove_frappe_crm_custom_fields
 erpnext.patches.v16_0.append_fieldname_to_pos_search_fields
 erpnext.patches.v16_0.add_transaction_roles_to_sms_settings

erpnext/patches/v16_0/repair_work_order_material_transfer.py

@@ -0,0 +1,65 @@
+import frappe
+from frappe.utils import flt
+from pypika import functions as fn
+
+from erpnext.manufacturing.doctype.work_order.services.material_coverage import (
+	get_minimum_material_coverage_fraction,
+)
+
+
+def execute():
+	updates = get_precision_affected_work_orders()
+	frappe.db.bulk_update("Work Order", updates, update_modified=False)
+
+
+def get_precision_affected_work_orders():
+	"""Return Work Orders whose components cover the plan at quantity precision."""
+	work_orders = {}
+	for row in _get_candidate_rows():
+		work_order = work_orders.setdefault(
+			row.work_order,
+			{"qty": flt(row.qty), "required_qty": {}, "transferred_qty": {}},
+		)
+		item_code = row.item_code
+		work_order["required_qty"][item_code] = work_order["required_qty"].get(item_code, 0.0) + flt(
+			row.required_qty
+		)
+		work_order["transferred_qty"][item_code] = max(
+			work_order["transferred_qty"].get(item_code, 0.0), flt(row.transferred_qty)
+		)
+
+	precision = frappe.get_precision("Work Order Item", "required_qty")
+	return {
+		name: {"material_transferred_for_manufacturing": values["qty"]}
+		for name, values in work_orders.items()
+		if get_minimum_material_coverage_fraction(
+			values["required_qty"], values["transferred_qty"], precision
+		)
+		>= 1.0
+	}
+
+
+def _get_candidate_rows():
+	work_order = frappe.qb.DocType("Work Order")
+	required_item = frappe.qb.DocType("Work Order Item")
+	return (
+		frappe.qb.from_(work_order)
+		.inner_join(required_item)
+		.on(required_item.parent == work_order.name)
+		.select(
+			work_order.name.as_("work_order"),
+			work_order.qty,
+			required_item.item_code,
+			required_item.required_qty,
+			required_item.transferred_qty,
+		)
+		.where(
+			(work_order.docstatus == 1)
+			& (work_order.status.notin(["Stopped", "Closed", "Completed"]))
+			& (fn.Coalesce(work_order.skip_transfer, 0) == 0)
+			& (fn.Coalesce(work_order.material_transferred_for_manufacturing, 0) < work_order.qty)
+			& (fn.Coalesce(work_order.transfer_material_against, "") != "Job Card")
+			& (required_item.include_item_in_manufacturing == 1)
+			& (required_item.required_qty > 0)
+		)
+	).run(as_dict=True)

erpnext/setup/doctype/company/company.py

@@ -986,12 +986,8 @@ def get_billing_shipping_address(name, billing_address=None, shipping_address=No
 	return {"primary_address": primary_address, "shipping_address": shipping_address}
 
 
-@frappe.whitelist(methods=["POST"])
+@frappe.whitelist()
 def create_transaction_deletion_request(company):
-	frappe.only_for("System Manager")
-	# User Permission check
-	frappe.has_permission("Company", ptype="delete", doc=company, throw=True)
-
 	from erpnext.setup.doctype.transaction_deletion_record.transaction_deletion_record import (
 		is_deletion_doc_running,
 	)
@@ -999,7 +995,6 @@ def create_transaction_deletion_request(company):
 	is_deletion_doc_running(company)
 
 	tdr = frappe.get_doc({"doctype": "Transaction Deletion Record", "company": company})
-
 	tdr.submit()
 	tdr.start_deletion_tasks()
 

erpnext/setup/doctype/transaction_deletion_record/transaction_deletion_record.json

@@ -1,6 +1,5 @@
 {
  "actions": [],
- "allow_bulk_edit": 1,
  "autoname": "TDL.####",
  "creation": "2021-04-06 20:17:18.404716",
  "doctype": "DocType",
@@ -142,18 +141,19 @@
    "read_only": 1
   }
  ],
- "in_create": 1,
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2026-09-02 20:32:19.679290",
+ "modified": "2024-03-21 10:29:19.456413",
  "modified_by": "Administrator",
  "module": "Setup",
  "name": "Transaction Deletion Record",
- "naming_rule": "Expression",
+ "naming_rule": "Expression (old style)",
  "owner": "Administrator",
  "permissions": [
   {
+   "create": 1,
+   "delete": 1,
    "email": 1,
    "export": 1,
    "print": 1,
@@ -161,6 +161,7 @@
    "report": 1,
    "role": "System Manager",
    "share": 1,
+   "submit": 1,
    "write": 1
   }
  ],
@@ -168,4 +169,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/stock/doctype/batch/batch_list.js

@@ -5,12 +5,12 @@ frappe.listview_settings["Batch"] = {
 			return [__("Disabled"), "gray", "disabled,=,1"];
 		} else if (
 			doc.expiry_date &&
-			frappe.datetime.get_diff(doc.expiry_date, frappe.datetime.nowdate()) < 0
+			frappe.datetime.get_diff(doc.expiry_date, frappe.datetime.nowdate()) <= 0
 		) {
 			return [
 				__("Expired"),
 				"red",
-				"expiry_date,not in,|expiry_date,<,Today|batch_qty,>,0|disabled,=,0",
+				"expiry_date,not in,|expiry_date,<=,Today|batch_qty,>,0|disabled,=,0",
 			];
 		} else if (!doc.batch_qty) {
 			return [__("Empty"), "gray", "batch_qty,=,0|disabled,=,0"];

erpnext/stock/doctype/material_request/material_request.js

@@ -93,27 +93,8 @@ frappe.ui.form.on("Material Request", {
 		erpnext.accounts.dimensions.setup_dimension_filters(frm, frm.doctype);
 		if (!frm.doc.buying_price_list) {
 			const buying_price_list = frappe.defaults.get_default("buying_price_list");
-			if (buying_price_list) {
-				const docname = frm.doc.name;
-				frappe.call({
-					type: "GET",
-					method: "frappe.client.has_permission",
-					no_spinner: true,
-					args: {
-						doctype: "Price List",
-						docname: buying_price_list,
-						perm_type: "read",
-					},
-					callback: ({ message }) => {
-						if (
-							message?.has_permission &&
-							frm.doc.name === docname &&
-							!frm.doc.buying_price_list
-						) {
-							frm.set_value("buying_price_list", buying_price_list);
-						}
-					},
-				});
+			if (frappe.has_permission("Price List", "read", buying_price_list)) {
+				frm.set_value("buying_price_list", buying_price_list);
 			}
 		}
 	},

erpnext/stock/doctype/material_request/material_request.py

@@ -806,6 +806,8 @@ def make_stock_entry(source_name, target_doc=None):
 				target.fg_completed_qty = job_card_details[0].for_quantity
 				target.from_bom = 1
 
+			target.cap_completed_qty_to_material_coverage()
+
 	doclist = get_mapped_doc(
 		"Material Request",
 		source_name,

erpnext/stock/doctype/stock_entry/stock_entry.py

@@ -32,6 +32,9 @@ from erpnext.manufacturing.doctype.bom.bom import (
 	get_scrap_items_from_sub_assemblies,
 	validate_bom_no,
 )
+from erpnext.manufacturing.doctype.work_order.services.material_coverage import (
+	get_minimum_material_coverage_fraction,
+)
 from erpnext.setup.doctype.brand.brand import get_brand_defaults
 from erpnext.setup.doctype.item_group.item_group import get_item_group_defaults
 from erpnext.stock.doctype.batch.batch import get_batch_qty
@@ -262,6 +265,7 @@ class StockEntry(StockController):
 		self.calculate_rate_and_amount()
 		self.validate_putaway_capacity()
 		self.validate_component_and_quantities()
+		self._cap_completed_qty_to_material_coverage()
 		self.validate_finished_good_serial_batch_for_work_order()
 
 		if not self.get("purpose") == "Manufacture":
@@ -1186,6 +1190,124 @@ class StockEntry(StockController):
 					title=_("Missing Item"),
 				)
 
+	def _cap_completed_qty_to_material_coverage(self):
+		if not self._should_cap_completed_qty():
+			return
+		# Keep an excessive claim intact so the Work Order allowance check can reject it.
+		max_qty = flt(self.pro_doc.qty)
+		overproduction_percentage = flt(
+			frappe.db.get_single_value("Manufacturing Settings", "overproduction_percentage_for_work_order")
+		)
+		to_transfer_qty = flt(self.pro_doc.material_transferred_for_manufacturing) + flt(
+			self.fg_completed_qty
+		)
+		transfer_limit_qty = max_qty + (max_qty * overproduction_percentage / 100)
+		if transfer_limit_qty < to_transfer_qty:
+			return
+
+		self.cap_completed_qty_to_material_coverage()
+
+	def cap_completed_qty_to_material_coverage(self):
+		required_qty, transferred_qty, target_qty, precision = self._get_material_coverage_data()
+		if not required_qty:
+			return
+
+		covered_before = self._get_covered_qty(required_qty, transferred_qty, target_qty, precision)
+		for row in self.items:
+			if self.job_card:
+				material_reference = row.job_card_item
+				transferred = flt(row.qty)
+			else:
+				material_reference = row.original_item or row.item_code
+				transferred = flt(row.qty) * flt(row.conversion_factor or 1)
+
+			if material_reference in required_qty and (self.job_card or row.s_warehouse):
+				transferred_qty[material_reference] += transferred
+
+		covered_after = self._get_covered_qty(required_qty, transferred_qty, target_qty, precision)
+		covered_by_entry = flt(max(covered_after - covered_before, 0), self.precision("fg_completed_qty"))
+		self.fg_completed_qty = min(flt(self.fg_completed_qty), covered_by_entry)
+
+	def _should_cap_completed_qty(self):
+		if self.get("_action") != "submit":
+			return False
+		if self.purpose != "Material Transfer for Manufacture":
+			return False
+		if not self.pro_doc or not self.fg_completed_qty:
+			return False
+		if self.is_return or self.get("is_additional_transfer_entry"):
+			return False
+		return not (self.pro_doc.operations and self.pro_doc.transfer_material_against == "Job Card")
+
+	def _get_material_coverage_data(self):
+		if self.job_card:
+			return self._get_job_card_material_qty()
+		return self._get_work_order_material_qty()
+
+	def _get_job_card_material_qty(self):
+		job_card = frappe.get_doc("Job Card", self.job_card)
+		required_qty = {}
+		transferred_qty = {}
+		for row in job_card.items:
+			if flt(row.required_qty) <= 0:
+				continue
+			required_qty[row.name] = flt(row.required_qty)
+			transferred_qty[row.name] = flt(row.transferred_qty)
+
+		return (
+			required_qty,
+			transferred_qty,
+			self._get_job_card_target_qty(job_card),
+			job_card.precision("required_qty", "items"),
+		)
+
+	def _get_job_card_target_qty(self, job_card):
+		required_by_item = {}
+		for row in job_card.items:
+			required_by_item[row.item_code] = required_by_item.get(row.item_code, 0.0) + flt(row.required_qty)
+
+		work_order_required_by_item = {}
+		work_order = frappe.get_doc("Work Order", job_card.work_order)
+		for row in work_order.required_items:
+			if job_card.operation != row.operation:
+				continue
+			work_order_required_by_item[row.item_code] = work_order_required_by_item.get(
+				row.item_code, 0.0
+			) + flt(row.required_qty)
+
+		target_qty = [
+			item_required * flt(work_order.qty) / work_order_required_by_item[item_code]
+			for item_code, item_required in required_by_item.items()
+			if work_order_required_by_item.get(item_code)
+		]
+		return min(target_qty) if target_qty else job_card.for_quantity
+
+	def _get_work_order_material_qty(self):
+		required_qty = {}
+		transferred_qty = {}
+		for row in self.pro_doc.required_items:
+			if not row.include_item_in_manufacturing or flt(row.required_qty) <= 0:
+				continue
+			required_qty[row.item_code] = required_qty.get(row.item_code, 0.0) + flt(row.required_qty)
+			# Duplicate required-item rows each hold the aggregate transferred quantity.
+			transferred_qty[row.item_code] = max(
+				transferred_qty.get(row.item_code, 0.0), flt(row.transferred_qty)
+			)
+		return (
+			required_qty,
+			transferred_qty,
+			self.pro_doc.qty,
+			self.pro_doc.precision("required_qty", "required_items"),
+		)
+
+	def _get_covered_qty(self, required_qty, transferred_qty, target_qty, precision):
+		min_fraction = get_minimum_material_coverage_fraction(
+			required_qty,
+			transferred_qty,
+			precision,
+		)
+		return min_fraction * flt(target_qty)
+
 	def _validate_no_excess_transfer(self):
 		if self.is_return:
 			return