chore(release): Bumped to Version 14.92.11

## [14.92.11](https://github.com/frappe/erpnext/compare/v14.92.10...v14.92.11) (2026-01-20)

### Bug Fixes

* Show non-SLE vouchers with GL entries in Stock vs Account Value Comparison report ([6e03d45](6e03d45034))
* **transaction.js:** use flt instead of cint for plc_conversion_rate ([d09de53](d09de53d1d))

erpnext/__init__.py

@@ -3,7 +3,7 @@ import inspect
 
 import frappe
 
-__version__ = "14.88.4"
+__version__ = "14.92.11"
 
 
 def get_default_company(user=None):

erpnext/accounts/doctype/bank_guarantee/bank_guarantee.js

@@ -9,13 +9,6 @@ cur_frm.add_fetch("bank", "swift_number", "swift_number");
 
 frappe.ui.form.on("Bank Guarantee", {
 	setup: function (frm) {
-		frm.set_query("bank", function () {
-			return {
-				filters: {
-					company: frm.doc.company,
-				},
-			};
-		});
 		frm.set_query("bank_account", function () {
 			return {
 				filters: {

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -448,9 +448,8 @@ def unset_existing_data(company):
 		"Sales Taxes and Charges Template",
 		"Purchase Taxes and Charges Template",
 	]:
-		frappe.db.sql(
-			f'''delete from `tab{doctype}` where `company`="%s"''' % (company)  # nosec
-		)
+		dt = frappe.qb.DocType(doctype)
+		frappe.qb.from_(dt).where(dt.company == company).delete().run()
 
 
 def set_default_accounts(company):

erpnext/accounts/doctype/cost_center_allocation/test_cost_center_allocation.py

@@ -4,6 +4,8 @@
 import unittest
 
 import frappe
+from frappe.query_builder.functions import Sum
+from frappe.tests.utils import change_settings
 from frappe.utils import add_days, today
 
 from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
@@ -190,6 +192,31 @@ class TestCostCenterAllocation(unittest.TestCase):
 		coa2.cancel()
 		jv.cancel()
 
+	@change_settings("System Settings", {"rounding_method": "Commercial Rounding"})
+	def test_debit_credit_on_cost_center_allocation_for_commercial_rounding(self):
+		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+
+		cca = create_cost_center_allocation(
+			"_Test Company",
+			"Main Cost Center 1 - _TC",
+			{"Sub Cost Center 2 - _TC": 50, "Sub Cost Center 3 - _TC": 50},
+		)
+
+		si = create_sales_invoice(rate=145.65, cost_center="Main Cost Center 1 - _TC")
+
+		gl_entry = frappe.qb.DocType("GL Entry")
+		gl_entries = (
+			frappe.qb.from_(gl_entry)
+			.select(Sum(gl_entry.credit).as_("cr"), Sum(gl_entry.debit).as_("dr"))
+			.where(gl_entry.voucher_type == "Sales Invoice")
+			.where(gl_entry.voucher_no == si.name)
+		).run(as_dict=1)
+
+		self.assertEqual(gl_entries[0].cr, gl_entries[0].dr)
+
+		si.cancel()
+		cca.cancel()
+
 
 def create_cost_center_allocation(
 	company,

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.js

@@ -19,7 +19,7 @@ frappe.ui.form.on("Currency Exchange Settings", {
 							to: "{to_currency}",
 						};
 						add_param(frm, r.message, params, result);
-					} else if (frm.doc.service_provider == "frankfurter.app") {
+					} else if (["frankfurter.app", "frankfurter.dev"].includes(frm.doc.service_provider)) {
 						let result = ["rates", "{to_currency}"];
 						let params = {
 							base: "{from_currency}",

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.json

@@ -78,7 +78,7 @@
    "fieldname": "service_provider",
    "fieldtype": "Select",
    "label": "Service Provider",
-   "options": "frankfurter.app\nexchangerate.host\nCustom",
+   "options": "frankfurter.dev\nexchangerate.host\nCustom",
    "reqd": 1
   },
   {
@@ -104,7 +104,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2024-03-18 08:32:26.895076",
+ "modified": "2025-11-25 13:03:41.896424",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Currency Exchange Settings",
@@ -141,8 +141,9 @@
    "write": 1
   }
  ],
- "sort_field": "modified",
+ "row_format": "Dynamic",
+ "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.py

@@ -35,7 +35,7 @@ class CurrencyExchangeSettings(Document):
 			self.append("req_params", {"key": "date", "value": "{transaction_date}"})
 			self.append("req_params", {"key": "from", "value": "{from_currency}"})
 			self.append("req_params", {"key": "to", "value": "{to_currency}"})
-		elif self.service_provider == "frankfurter.app":
+		elif self.service_provider in ("frankfurter.dev", "frankfurter.app"):
 			self.set("result_key", [])
 			self.set("req_params", [])
 
@@ -80,11 +80,13 @@ class CurrencyExchangeSettings(Document):
 
 @frappe.whitelist()
 def get_api_endpoint(service_provider: str | None = None, use_http: bool = False):
-	if service_provider and service_provider in ["exchangerate.host", "frankfurter.app"]:
+	if service_provider and service_provider in ["exchangerate.host", "frankfurter.dev", "frankfurter.app"]:
 		if service_provider == "exchangerate.host":
 			api = "api.exchangerate.host/convert"
 		elif service_provider == "frankfurter.app":
 			api = "api.frankfurter.app/{transaction_date}"
+		elif service_provider == "frankfurter.dev":
+			api = "api.frankfurter.dev/v1/{transaction_date}"
 
 		protocol = "https://"
 		if use_http:

erpnext/accounts/doctype/dunning/dunning.py

@@ -55,46 +55,46 @@ class Dunning(AccountsController):
 			"conversion_rate",
 			"cost_center",
 		]
-		inv = frappe.db.get_value("Sales Invoice", self.sales_invoice, invoice_fields, as_dict=1)
 
 		accounting_dimensions = get_accounting_dimensions()
 		invoice_fields.extend(accounting_dimensions)
 
+		inv = frappe.db.get_value("Sales Invoice", self.sales_invoice, invoice_fields, as_dict=1)
+
 		dunning_in_company_currency = flt(self.dunning_amount * inv.conversion_rate)
 		default_cost_center = frappe.get_cached_value("Company", self.company, "cost_center")
 
-		gl_entries.append(
-			self.get_gl_dict(
-				{
-					"account": inv.debit_to,
-					"party_type": "Customer",
-					"party": self.customer,
-					"due_date": self.due_date,
-					"against": self.income_account,
-					"debit": dunning_in_company_currency,
-					"debit_in_account_currency": self.dunning_amount,
-					"against_voucher": self.name,
-					"against_voucher_type": "Dunning",
-					"cost_center": inv.cost_center or default_cost_center,
-					"project": inv.project,
-				},
-				inv.party_account_currency,
-				item=inv,
-			)
-		)
-		gl_entries.append(
-			self.get_gl_dict(
-				{
-					"account": self.income_account,
-					"against": self.customer,
-					"credit": dunning_in_company_currency,
-					"cost_center": inv.cost_center or default_cost_center,
-					"credit_in_account_currency": self.dunning_amount,
-					"project": inv.project,
-				},
-				item=inv,
-			)
-		)
+		debit = {
+			"account": inv.debit_to,
+			"party_type": "Customer",
+			"party": self.customer,
+			"due_date": self.due_date,
+			"against": self.income_account,
+			"debit": dunning_in_company_currency,
+			"debit_in_account_currency": self.dunning_amount,
+			"against_voucher": self.name,
+			"against_voucher_type": "Dunning",
+			"cost_center": inv.cost_center or default_cost_center,
+			"project": inv.project,
+		}
+
+		credit = {
+			"account": self.income_account,
+			"against": self.customer,
+			"credit": dunning_in_company_currency,
+			"credit_in_account_currency": self.dunning_amount,
+			"cost_center": inv.cost_center or default_cost_center,
+			"project": inv.project,
+		}
+
+		for dimension in accounting_dimensions:
+			if val := inv.get(dimension):
+				debit[dimension] = credit[dimension] = val
+
+		gl_entries = [
+			self.get_gl_dict(debit, inv.party_account_currency, item=inv),
+			self.get_gl_dict(credit, item=inv),
+		]
 		make_gl_entries(
 			gl_entries, cancel=(self.docstatus == 2), update_outstanding="No", merge_entries=False
 		)

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -261,7 +261,7 @@ def validate_balance_type(account, adv_adj=False):
 		if balance_must_be:
 			balance = frappe.db.sql(
 				"""select sum(debit) - sum(credit)
-				from `tabGL Entry` where account = %s""",
+				from `tabGL Entry` where is_cancelled = 0 and account = %s""",
 				account,
 			)[0][0]
 

erpnext/accounts/doctype/loyalty_program/loyalty_program.py

@@ -5,6 +5,7 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
+from frappe.query_builder.functions import Sum
 from frappe.utils import flt, today
 
 
@@ -18,22 +19,30 @@ def get_loyalty_details(
 	if not expiry_date:
 		expiry_date = today()
 
-	condition = ""
-	if company:
-		condition = " and company=%s " % frappe.db.escape(company)
-	if not include_expired_entry:
-		condition += " and expiry_date>='%s' " % expiry_date
+	LoyaltyPointEntry = frappe.qb.DocType("Loyalty Point Entry")
 
-	loyalty_point_details = frappe.db.sql(
-		f"""select sum(loyalty_points) as loyalty_points,
-		sum(purchase_amount) as total_spent from `tabLoyalty Point Entry`
-		where customer=%s and loyalty_program=%s and posting_date <= %s
-		{condition}
-		group by customer""",
-		(customer, loyalty_program, expiry_date),
-		as_dict=1,
+	query = (
+		frappe.qb.from_(LoyaltyPointEntry)
+		.select(
+			Sum(LoyaltyPointEntry.loyalty_points).as_("loyalty_points"),
+			Sum(LoyaltyPointEntry.purchase_amount).as_("total_spent"),
+		)
+		.where(
+			(LoyaltyPointEntry.customer == customer)
+			& (LoyaltyPointEntry.loyalty_program == loyalty_program)
+			& (LoyaltyPointEntry.posting_date <= expiry_date)
+		)
+		.groupby(LoyaltyPointEntry.customer)
 	)
 
+	if company:
+		query = query.where(LoyaltyPointEntry.company == company)
+
+	if not include_expired_entry:
+		query = query.where(LoyaltyPointEntry.expiry_date >= expiry_date)
+
+	loyalty_point_details = query.run(as_dict=True)
+
 	if loyalty_point_details:
 		return loyalty_point_details[0]
 	else:

erpnext/accounts/doctype/party_link/party_link.py

@@ -60,6 +60,6 @@ def create_party_link(primary_role, primary_party, secondary_party):
 	party_link.secondary_role = "Customer" if primary_role == "Supplier" else "Supplier"
 	party_link.secondary_party = secondary_party
 
-	party_link.save(ignore_permissions=True)
+	party_link.save()
 
 	return party_link

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -330,7 +330,7 @@ frappe.ui.form.on('Payment Entry', {
 	payment_type: function(frm) {
 		set_default_party_type(frm);
 		if(frm.doc.payment_type == "Internal Transfer") {
-			$.each(["party", "party_balance", "paid_from", "paid_to",
+			$.each(["party", "party_type", "party_balance", "paid_from", "paid_to",
 				"references", "total_allocated_amount"], function(i, field) {
 				frm.set_value(field, null);
 			});

erpnext/accounts/doctype/payment_schedule/payment_schedule.json

@@ -10,14 +10,19 @@
   "description",
   "section_break_4",
   "due_date",
+  "invoice_portion",
   "mode_of_payment",
   "column_break_5",
-  "invoice_portion",
+  "due_date_based_on",
+  "credit_days",
+  "credit_months",
   "section_break_6",
-  "discount_type",
   "discount_date",
-  "column_break_9",
   "discount",
+  "discount_type",
+  "column_break_9",
+  "discount_validity_based_on",
+  "discount_validity",
   "section_break_9",
   "payment_amount",
   "outstanding",
@@ -155,12 +160,50 @@
    "fieldtype": "Currency",
    "label": "Payment Amount (Company Currency)",
    "options": "Company:company:default_currency"
+  },
+  {
+   "fieldname": "due_date_based_on",
+   "fieldtype": "Select",
+   "label": "Due Date Based On",
+   "options": "\nDay(s) after invoice date\nDay(s) after the end of the invoice month\nMonth(s) after the end of the invoice month",
+   "read_only": 1
+  },
+  {
+   "depends_on": "eval:in_list(['Day(s) after invoice date', 'Day(s) after the end of the invoice month'], doc.due_date_based_on)",
+   "fieldname": "credit_days",
+   "fieldtype": "Int",
+   "label": "Credit Days",
+   "non_negative": 1,
+   "read_only": 1
+  },
+  {
+   "depends_on": "eval:doc.due_date_based_on=='Month(s) after the end of the invoice month'",
+   "fieldname": "credit_months",
+   "fieldtype": "Int",
+   "label": "Credit Months",
+   "non_negative": 1,
+   "read_only": 1
+  },
+  {
+   "depends_on": "discount",
+   "fieldname": "discount_validity_based_on",
+   "fieldtype": "Select",
+   "label": "Discount Validity Based On",
+   "options": "\nDay(s) after invoice date\nDay(s) after the end of the invoice month\nMonth(s) after the end of the invoice month",
+   "read_only": 1
+  },
+  {
+   "depends_on": "discount_validity_based_on",
+   "fieldname": "discount_validity",
+   "fieldtype": "Int",
+   "label": "Discount Validity",
+   "read_only": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2022-09-16 13:57:06.382859",
+ "modified": "2025-07-31 08:38:25.820701",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Schedule",
@@ -171,4 +214,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/payment_terms_template_detail/payment_terms_template_detail.json

@@ -161,4 +161,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.js

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

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -560,7 +560,13 @@ class POSInvoice(SalesInvoice):
 				"Account", self.debit_to, "account_currency", cache=True
 			)
 		if not self.due_date and self.customer:
-			self.due_date = get_due_date(self.posting_date, "Customer", self.customer, self.company)
+			self.due_date = get_due_date(
+				self.posting_date,
+				"Customer",
+				self.customer,
+				self.company,
+				template_name=self.payment_terms_template,
+			)
 
 		super(SalesInvoice, self).set_missing_values(for_validate)
 

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -449,7 +449,7 @@ def send_auto_email():
 	selected = frappe.get_list(
 		"Process Statement Of Accounts",
 		filters={"enable_auto_email": 1},
-		or_filters={"to_date": format_date(today()), "posting_date": format_date(today())},
+		or_filters={"to_date": today(), "posting_date": today()},
 	)
 	for entry in selected:
 		send_emails(entry.name, from_scheduler=True)

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -29,7 +29,10 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		this.frm.set_query("expense_account", "items", function () {
 			return {
 				query: "erpnext.controllers.queries.get_expense_account",
-				filters: { company: doc.company },
+				filters: {
+					company: doc.company,
+					disabled: 0,
+				},
 			};
 		});
 	}

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -173,7 +173,12 @@ class PurchaseInvoice(BuyingController):
 			)
 		if not self.due_date:
 			self.due_date = get_due_date(
-				self.posting_date, "Supplier", self.supplier, self.company, self.bill_date
+				self.posting_date,
+				"Supplier",
+				self.supplier,
+				self.company,
+				self.bill_date,
+				template_name=self.payment_terms_template,
 			)
 
 		tds_category = frappe.db.get_value("Supplier", self.supplier, "tax_withholding_category")

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -1816,19 +1816,16 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		rate = flt(sle.stock_value_difference) / flt(sle.actual_qty)
 		self.assertAlmostEqual(rate, 500)
 
+	@change_settings("Accounts Settings", {"automatically_fetch_payment_terms": 1})
 	def test_payment_allocation_for_payment_terms(self):
 		from erpnext.buying.doctype.purchase_order.test_purchase_order import (
 			create_pr_against_po,
 			create_purchase_order,
 		)
-		from erpnext.selling.doctype.sales_order.test_sales_order import (
-			automatically_fetch_payment_terms,
-		)
 		from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
 			make_purchase_invoice as make_pi_from_pr,
 		)
 
-		automatically_fetch_payment_terms()
 		frappe.db.set_value(
 			"Payment Terms Template",
 			"_Test Payment Term Template",
@@ -1854,7 +1851,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		pi = make_pi_from_pr(pr.name)
 		self.assertEqual(pi.payment_schedule[0].payment_amount, 1000)
 
-		automatically_fetch_payment_terms(enable=0)
 		frappe.db.set_value(
 			"Payment Terms Template",
 			"_Test Payment Term Template",

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.py

@@ -151,7 +151,7 @@ def start_repost(account_repost_doc=str) -> None:
 				if doc.doctype in ["Sales Invoice", "Purchase Invoice"]:
 					if not repost_doc.delete_cancelled_entries:
 						doc.docstatus = 2
-						doc.make_gl_entries_on_cancel()
+						doc.make_gl_entries_on_cancel(from_repost=True)
 
 					doc.docstatus = 1
 					if doc.doctype == "Sales Invoice":
@@ -163,7 +163,7 @@ def start_repost(account_repost_doc=str) -> None:
 				elif doc.doctype == "Purchase Receipt":
 					if not repost_doc.delete_cancelled_entries:
 						doc.docstatus = 2
-						doc.make_gl_entries_on_cancel()
+						doc.make_gl_entries_on_cancel(from_repost=True)
 
 					doc.docstatus = 1
 					doc.make_gl_entries(from_repost=True)

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -1025,7 +1025,6 @@ class SalesInvoice(SellingController):
 
 				self.make_exchange_gain_loss_journal()
 			elif self.docstatus == 2:
-				cancel_exchange_gain_loss_journal(frappe._dict(doctype=self.doctype, name=self.name))
 				make_reverse_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
 
 			if update_outstanding == "No":

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -2828,6 +2828,60 @@ class TestSalesInvoice(FrappeTestCase):
 		self.assertEqual(sales_invoice.items[0].item_tax_template, "_Test Account Excise Duty @ 10 - _TC")
 		self.assertEqual(sales_invoice.items[0].item_tax_rate, item_tax_map)
 
+	def test_item_tax_template_change_with_grand_total_discount(self):
+		"""
+		Test that when item tax template changes due to discount on Grand Total,
+		the tax calculations are consistent.
+		"""
+		item = create_item("Test Item With Multiple Tax Templates")
+
+		item.set("taxes", [])
+		item.append(
+			"taxes",
+			{
+				"item_tax_template": "_Test Account Excise Duty @ 10 - _TC",
+				"minimum_net_rate": 0,
+				"maximum_net_rate": 500,
+			},
+		)
+
+		item.append(
+			"taxes",
+			{
+				"item_tax_template": "_Test Account Excise Duty @ 12 - _TC",
+				"minimum_net_rate": 501,
+				"maximum_net_rate": 1000,
+			},
+		)
+
+		item.save()
+
+		si = create_sales_invoice(item=item.name, rate=700, do_not_save=True)
+		si.append(
+			"taxes",
+			{
+				"charge_type": "On Net Total",
+				"account_head": "_Test Account Excise Duty - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "Excise Duty",
+				"rate": 0,
+			},
+		)
+		si.insert()
+
+		self.assertEqual(si.items[0].item_tax_template, "_Test Account Excise Duty @ 12 - _TC")
+
+		si.apply_discount_on = "Grand Total"
+		si.discount_amount = 300
+		si.save()
+
+		# Verify template changed to 10%
+		self.assertEqual(si.items[0].item_tax_template, "_Test Account Excise Duty @ 10 - _TC")
+		self.assertEqual(si.taxes[0].tax_amount, 70)  # 10% of 700
+		self.assertEqual(si.grand_total, 470)  # 700 + 70 - 300
+
+		si.submit()
+
 	@change_settings("Selling Settings", {"enable_discount_accounting": 1})
 	def test_sales_invoice_with_discount_accounting_enabled(self):
 		discount_account = create_account(
@@ -3889,6 +3943,60 @@ class TestSalesInvoice(FrappeTestCase):
 
 		self.assertEqual(invoice.outstanding_amount, 0)
 
+	def test_system_generated_exchange_gain_or_loss_je_after_repost(self):
+		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+		from erpnext.accounts.doctype.repost_accounting_ledger.test_repost_accounting_ledger import (
+			update_repost_settings,
+		)
+
+		update_repost_settings()
+
+		si = create_sales_invoice(
+			customer="_Test Customer USD",
+			debit_to="_Test Receivable USD - _TC",
+			currency="USD",
+			conversion_rate=80,
+		)
+
+		pe = get_payment_entry("Sales Invoice", si.name)
+		pe.reference_no = "10"
+		pe.reference_date = nowdate()
+		pe.paid_from_account_currency = si.currency
+		pe.paid_to_account_currency = "INR"
+		pe.source_exchange_rate = 85
+		pe.target_exchange_rate = 1
+		pe.paid_amount = si.outstanding_amount
+		pe.received_amount = 8500
+		pe.insert()
+		pe.submit()
+
+		ral = frappe.new_doc("Repost Accounting Ledger")
+		ral.company = si.company
+		ral.append("vouchers", {"voucher_type": si.doctype, "voucher_no": si.name})
+		ral.save()
+		ral.submit()
+
+		je = frappe.qb.DocType("Journal Entry")
+		jea = frappe.qb.DocType("Journal Entry Account")
+		q = (
+			(
+				frappe.qb.from_(je)
+				.join(jea)
+				.on(je.name == jea.parent)
+				.select(je.docstatus)
+				.where(
+					(je.voucher_type == "Exchange Gain Or Loss")
+					& (jea.reference_name == si.name)
+					& (jea.reference_type == "Sales Invoice")
+					& (je.is_system_generated == 1)
+				)
+			)
+			.limit(1)
+			.run()
+		)
+
+		self.assertEqual(q[0][0], 1)
+
 
 def check_gl_entries(doc, voucher_no, expected_gle, posting_date):
 	gl_entries = frappe.db.sql(

erpnext/accounts/doctype/share_balance/share_balance.json

@@ -80,7 +80,7 @@
    "collapsible": 0, 
    "columns": 0, 
    "fieldname": "rate", 
-   "fieldtype": "Int", 
+   "fieldtype": "Currency", 
    "hidden": 0, 
    "ignore_user_permissions": 0, 
    "ignore_xss_filter": 0, 
@@ -102,7 +102,7 @@
    "search_index": 0, 
    "set_only_once": 0, 
    "unique": 0
-  }, 
+  },
   {
    "allow_bulk_edit": 0, 
    "allow_on_submit": 0, 
@@ -199,7 +199,7 @@
    "collapsible": 0, 
    "columns": 0, 
    "fieldname": "amount", 
-   "fieldtype": "Int", 
+   "fieldtype": "Currency", 
    "hidden": 0, 
    "ignore_user_permissions": 0, 
    "ignore_xss_filter": 0, 
@@ -221,7 +221,7 @@
    "search_index": 0, 
    "set_only_once": 0, 
    "unique": 0
-  }, 
+  },
   {
    "allow_bulk_edit": 0, 
    "allow_on_submit": 0, 
@@ -324,7 +324,7 @@
  "issingle": 0, 
  "istable": 1, 
  "max_attachments": 0, 
- "modified": "2018-01-10 18:32:36.201124", 
+ "modified": "2025-12-10 08:06:40.611761", 
  "modified_by": "Administrator", 
  "module": "Accounts", 
  "name": "Share Balance", 
@@ -339,4 +339,4 @@
  "sort_order": "DESC", 
  "track_changes": 1, 
  "track_seen": 0
-}
+}

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.json

@@ -75,7 +75,7 @@
   },
   {
    "default": "0",
-   "description": "Even invoices with apply tax withholding unchecked will be considered for checking cumulative threshold breach",
+   "description": "Only payment entries with apply tax withholding unchecked will be considered for checking cumulative threshold breach",
    "fieldname": "consider_party_ledger_amount",
    "fieldtype": "Check",
    "label": "Consider Entire Party Ledger Amount",
@@ -102,10 +102,11 @@
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2021-07-27 21:47:34.396071",
+ "modified": "2025-07-30 07:13:51.785735",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Tax Withholding Category",
+ "naming_rule": "Set by user",
  "owner": "Administrator",
  "permissions": [
   {
@@ -148,4 +149,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "track_changes": 1
-}
+}

erpnext/accounts/general_ledger.py

@@ -179,6 +179,15 @@ def process_gl_map(gl_map, merge_entries=True, precision=None):
 
 
 def distribute_gl_based_on_cost_center_allocation(gl_map, precision=None):
+	round_off_account, default_currency = frappe.get_cached_value(
+		"Company", gl_map[0].company, ["round_off_account", "default_currency"]
+	)
+	if not precision:
+		precision = get_field_precision(
+			frappe.get_meta("GL Entry").get_field("debit"),
+			currency=default_currency,
+		)
+
 	new_gl_map = []
 	for d in gl_map:
 		cost_center = d.get("cost_center")
@@ -192,6 +201,11 @@ def distribute_gl_based_on_cost_center_allocation(gl_map, precision=None):
 			new_gl_map.append(d)
 			continue
 
+		if d.account == round_off_account:
+			d.cost_center = cost_center_allocation[0][0]
+			new_gl_map.append(d)
+			continue
+
 		for sub_cost_center, percentage in cost_center_allocation:
 			gle = copy.deepcopy(d)
 			gle.cost_center = sub_cost_center

erpnext/accounts/report/general_ledger/general_ledger.js

@@ -197,6 +197,11 @@ frappe.query_reports["General Ledger"] = {
 			label: __("Show Net Values in Party Account"),
 			fieldtype: "Check",
 		},
+		{
+			fieldname: "show_amount_in_company_currency",
+			label: __("Show Credit / Debit in Company Currency"),
+			fieldtype: "Check",
+		},
 		{
 			fieldname: "show_remarks",
 			label: __("Show Remarks"),

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -580,6 +580,19 @@ def get_columns(filters):
 		company = filters.get("company") or get_default_company()
 		filters["presentation_currency"] = currency = get_company_currency(company)
 
+	company_currency = get_company_currency(filters.get("company") or get_default_company())
+
+	if (
+		filters.get("show_amount_in_company_currency")
+		and filters["presentation_currency"] != company_currency
+	):
+		frappe.throw(
+			_("Presentation Currency cannot be {0} , When {1} is enabled.").format(
+				frappe.bold(filters["presentation_currency"]),
+				frappe.bold("Show Credit / Debit in Company Currency"),
+			)
+		)
+
 	columns = [
 		{
 			"label": _("GL Entry"),

erpnext/accounts/report/payment_ledger/payment_ledger.py

@@ -46,6 +46,7 @@ class PaymentLedger:
 						against_voucher_no=ple.against_voucher_no,
 						amount=ple.amount,
 						currency=ple.account_currency,
+						company=ple.company,
 					)
 
 					if self.filters.include_account_currency:
@@ -77,6 +78,7 @@ class PaymentLedger:
 					against_voucher_no="Outstanding:",
 					amount=total,
 					currency=voucher_data[0].currency,
+					company=voucher_data[0].company,
 				)
 
 				if self.filters.include_account_currency:
@@ -85,7 +87,12 @@ class PaymentLedger:
 				voucher_data.append(entry)
 
 				# empty row
-				voucher_data.append(frappe._dict())
+				voucher_data.append(
+					frappe._dict(
+						currency=voucher_data[0].currency,
+						company=voucher_data[0].company,
+					)
+				)
 				self.data.extend(voucher_data)
 
 	def build_conditions(self):

erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py

@@ -45,6 +45,7 @@ def get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_
 	gle_map = get_gle_map(tds_docs)
 
 	out = []
+	entries = {}
 	for name, details in gle_map.items():
 		for entry in details:
 			tax_amount, total_amount, grand_total, base_total = 0, 0, 0, 0
@@ -119,8 +120,13 @@ def get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_
 						"supplier_invoice_date": bill_date,
 					}
 				)
-				out.append(row)
 
+				key = entry.voucher_no
+				if key in entries:
+					entries[key]["tax_amount"] += tax_amount
+				else:
+					entries[key] = row
+	out = list(entries.values())
 	out.sort(key=lambda x: (x["section_code"], x["transaction_date"]))
 
 	return out

erpnext/accounts/report/trial_balance_simple/trial_balance_simple.json

@@ -4,15 +4,25 @@
  "disabled": 0, 
  "docstatus": 0, 
  "doctype": "Report", 
+ "filters": [
+  {
+   "fieldname": "company",
+   "fieldtype": "Link",
+   "label": "Company",
+   "mandatory": 1,
+   "options": "Company",
+   "wildcard_filter": 0
+  }
+ ],
  "idx": 0, 
  "is_standard": "Yes", 
- "modified": "2019-01-17 17:20:42.374958", 
+ "modified": "2025-08-28 19:06:54.273322",
  "modified_by": "Administrator", 
  "module": "Accounts", 
  "name": "Trial Balance (Simple)", 
  "owner": "Administrator", 
  "prepared_report": 0, 
- "query": "select fiscal_year as \"Fiscal Year:Data:80\",\n\tcompany as \"Company:Data:220\",\n\tposting_date as \"Posting Date:Date:100\",\n\taccount as \"Account:Data:380\",\n\tsum(debit) as \"Debit:Currency:140\",\n\tsum(credit) as \"Credit:Currency:140\",\n\tfinance_book as \"Finance Book:Link/Finance Book:140\"\nfrom `tabGL Entry`\ngroup by fiscal_year, company, posting_date, account\norder by fiscal_year, company, posting_date, account", 
+ "query": "select fiscal_year as \"Fiscal Year:Data:80\",\n\tcompany as \"Company:Data:220\",\n\tposting_date as \"Posting Date:Date:100\",\n\taccount as \"Account:Data:380\",\n\tsum(debit) as \"Debit:Currency:140\",\n\tsum(credit) as \"Credit:Currency:140\",\n\tfinance_book as \"Finance Book:Link/Finance Book:140\"\nfrom `tabGL Entry`\nwhere is_cancelled = 0 and company = %(company)s\ngroup by fiscal_year, company, posting_date, account\norder by fiscal_year, company, posting_date, account",
  "ref_doctype": "GL Entry", 
  "report_name": "Trial Balance (Simple)", 
  "report_type": "Query Report", 

erpnext/accounts/report/utils.py

@@ -118,7 +118,7 @@ def convert_to_presentation_currency(gl_entries, currency_info, filters=None):
 			len(account_currencies) == 1
 			and account_currency == presentation_currency
 			and not exchange_gain_or_loss
-		):
+		) and not (filters and filters.get("show_amount_in_company_currency")):
 			entry["debit"] = debit_in_account_currency
 			entry["credit"] = credit_in_account_currency
 		else:

erpnext/accounts/utils.py

@@ -2,6 +2,7 @@
 # License: GNU General Public License v3. See license.txt
 
 
+from collections import defaultdict
 from json import loads
 from typing import TYPE_CHECKING, Optional
 
@@ -2195,25 +2196,42 @@ def run_ledger_health_checks():
 					doc.save()
 
 
+def get_link_fields_grouped_by_option(doctype):
+	meta = frappe.get_meta(doctype)
+	link_fields_map = defaultdict(list)
+
+	for df in meta.fields:
+		if df.fieldtype == "Link" and df.options and not df.ignore_user_permissions:
+			link_fields_map[df.options].append(df.fieldname)
+
+	return link_fields_map
+
+
 def build_qb_match_conditions(doctype, user=None) -> list:
 	match_filters = build_match_conditions(doctype, user, False)
+	link_fields_map = get_link_fields_grouped_by_option(doctype)
 	criterion = []
 	apply_strict_user_permissions = frappe.get_system_settings("apply_strict_user_permissions")
 
 	if match_filters:
-		from frappe import qb
-
 		_dt = qb.DocType(doctype)
 
 		for filter in match_filters:
-			for d, names in filter.items():
-				fieldname = d.lower().replace(" ", "_")
-				field = _dt[fieldname]
+			for link_option, allowed_values in filter.items():
+				fieldnames = link_fields_map.get(link_option, [])
+				cond = None
 
-				cond = field.isin(names)
-				if not apply_strict_user_permissions:
-					cond = (Coalesce(field, "") == "") | field.isin(names)
+				if link_option == doctype:
+					cond = _dt["name"].isin(allowed_values)
 
-				criterion.append(cond)
+				for fieldname in fieldnames:
+					field = _dt[fieldname]
+					cond = field.isin(allowed_values)
+
+					if not apply_strict_user_permissions:
+						cond = (Coalesce(field, "") == "") | cond
+
+				if cond:
+					criterion.append(cond)
 
 	return criterion

erpnext/assets/doctype/asset/asset.py

@@ -313,6 +313,7 @@ class Asset(AccountsController):
 				"asset_name": self.asset_name,
 				"target_location": self.location,
 				"to_employee": self.custodian,
+				"company": self.company,
 			}
 		]
 		asset_movement = frappe.get_doc(
@@ -1531,11 +1532,7 @@ def get_straight_line_or_manual_depr_amount(asset, row, schedule_idx, number_of_
 	# if the Depreciation Schedule is being prepared for the first time
 	else:
 		if row.daily_prorata_based:
-			amount = (
-				flt(asset.gross_purchase_amount)
-				- flt(asset.opening_accumulated_depreciation)
-				- flt(row.expected_value_after_useful_life)
-			)
+			amount = flt(asset.gross_purchase_amount) - flt(row.expected_value_after_useful_life)
 			total_days = (
 				date_diff(
 					get_last_day(
@@ -1547,7 +1544,11 @@ def get_straight_line_or_manual_depr_amount(asset, row, schedule_idx, number_of_
 					),
 					add_days(
 						get_last_day(
-							add_months(row.depreciation_start_date, -1 * row.frequency_of_depreciation)
+							add_months(
+								row.depreciation_start_date,
+								(row.frequency_of_depreciation * (asset.number_of_depreciations_booked + 1))
+								* -1,
+							),
 						),
 						1,
 					),
@@ -1570,11 +1571,9 @@ def get_straight_line_or_manual_depr_amount(asset, row, schedule_idx, number_of_
 
 			return daily_depr_amount * (date_diff(to_date, from_date) + 1)
 		else:
-			return (
-				flt(asset.gross_purchase_amount)
-				- flt(asset.opening_accumulated_depreciation)
-				- flt(row.expected_value_after_useful_life)
-			) / flt(row.total_number_of_depreciations - asset.number_of_depreciations_booked)
+			return (flt(asset.gross_purchase_amount) - flt(row.expected_value_after_useful_life)) / flt(
+				row.total_number_of_depreciations
+			)
 
 
 def get_shift_depr_amount(asset, row, schedule_idx):

erpnext/assets/doctype/asset/test_asset.py

@@ -660,7 +660,7 @@ class TestDepreciationMethods(AssetSetup):
 			available_for_use_date="2030-06-06",
 			is_existing_asset=1,
 			number_of_depreciations_booked=2,
-			opening_accumulated_depreciation=47095.89,
+			opening_accumulated_depreciation=47178.08,
 			expected_value_after_useful_life=10000,
 			depreciation_start_date="2032-12-31",
 			total_number_of_depreciations=3,
@@ -668,7 +668,7 @@ class TestDepreciationMethods(AssetSetup):
 		)
 
 		self.assertEqual(asset.status, "Draft")
-		expected_schedules = [["2032-12-31", 42904.11, 90000.0]]
+		expected_schedules = [["2032-12-31", 30000.0, 77178.08], ["2033-06-06", 12821.92, 90000.0]]
 		schedules = [
 			[cstr(d.schedule_date), flt(d.depreciation_amount, 2), d.accumulated_depreciation_amount]
 			for d in asset.get("schedules")

erpnext/buying/doctype/purchase_order/purchase_order.py

@@ -456,9 +456,8 @@ class PurchaseOrder(BuyingController):
 		if not self.is_against_so():
 			return
 		for item in removed_items:
-			prev_ordered_qty = (
+			prev_ordered_qty = flt(
 				frappe.get_cached_value("Sales Order Item", item.get("sales_order_item"), "ordered_qty")
-				or 0.0
 			)
 
 			frappe.db.set_value(

erpnext/buying/doctype/purchase_order/test_purchase_order.py

@@ -526,12 +526,8 @@ class TestPurchaseOrder(FrappeTestCase):
 		self.assertRaises(frappe.ValidationError, pr.submit)
 		self.assertRaises(frappe.ValidationError, pi.submit)
 
+	@change_settings("Accounts Settings", {"automatically_fetch_payment_terms": 1})
 	def test_make_purchase_invoice_with_terms(self):
-		from erpnext.selling.doctype.sales_order.test_sales_order import (
-			automatically_fetch_payment_terms,
-		)
-
-		automatically_fetch_payment_terms()
 		po = create_purchase_order(do_not_save=True)
 
 		self.assertRaises(frappe.ValidationError, make_pi_from_po, po.name)
@@ -555,7 +551,6 @@ class TestPurchaseOrder(FrappeTestCase):
 		self.assertEqual(getdate(pi.payment_schedule[0].due_date), getdate(po.transaction_date))
 		self.assertEqual(pi.payment_schedule[1].payment_amount, 2500.0)
 		self.assertEqual(getdate(pi.payment_schedule[1].due_date), add_days(getdate(po.transaction_date), 30))
-		automatically_fetch_payment_terms(enable=0)
 
 	def test_warehouse_company_validation(self):
 		from erpnext.stock.utils import InvalidWarehouseCompany
@@ -703,6 +698,7 @@ class TestPurchaseOrder(FrappeTestCase):
 		)
 		self.assertEqual(due_date, "2023-03-31")
 
+	@change_settings("Accounts Settings", {"automatically_fetch_payment_terms": 0})
 	def test_terms_are_not_copied_if_automatically_fetch_payment_terms_is_unchecked(self):
 		po = create_purchase_order(do_not_save=1)
 		po.payment_terms_template = "_Test Payment Term Template"
@@ -834,18 +830,16 @@ class TestPurchaseOrder(FrappeTestCase):
 		bo.load_from_db()
 		self.assertEqual(bo.items[0].ordered_qty, 5)
 
+	@change_settings("Accounts Settings", {"automatically_fetch_payment_terms": 1})
 	def test_payment_terms_are_fetched_when_creating_purchase_invoice(self):
 		from erpnext.accounts.doctype.payment_entry.test_payment_entry import (
 			create_payment_terms_template,
 		)
 		from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 		from erpnext.selling.doctype.sales_order.test_sales_order import (
-			automatically_fetch_payment_terms,
 			compare_payment_schedules,
 		)
 
-		automatically_fetch_payment_terms()
-
 		po = create_purchase_order(qty=10, rate=100, do_not_save=1)
 		create_payment_terms_template()
 		po.payment_terms_template = "Test Receivable Template"
@@ -859,8 +853,6 @@ class TestPurchaseOrder(FrappeTestCase):
 		# self.assertEqual(po.payment_terms_template, pi.payment_terms_template)
 		compare_payment_schedules(self, po, pi)
 
-		automatically_fetch_payment_terms(enable=0)
-
 	def test_internal_transfer_flow(self):
 		from erpnext.accounts.doctype.sales_invoice.sales_invoice import (
 			make_inter_company_purchase_invoice,

erpnext/buying/doctype/request_for_quotation/request_for_quotation.py

@@ -9,6 +9,7 @@ from frappe import _
 from frappe.core.doctype.communication.email import make
 from frappe.desk.form.load import get_attachments
 from frappe.model.mapper import get_mapped_doc
+from frappe.query_builder import Order
 from frappe.utils import get_url
 from frappe.utils.print_format import download_pdf
 from frappe.utils.user import get_user_fullname
@@ -502,35 +503,32 @@ def get_supplier_tag():
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def get_rfq_containing_supplier(doctype, txt, searchfield, start, page_len, filters):
-	conditions = ""
-	if txt:
-		conditions += "and rfq.name like '%%" + txt + "%%' "
+	rfq = frappe.qb.DocType("Request for Quotation")
+	rfq_supplier = frappe.qb.DocType("Request for Quotation Supplier")
 
-	if filters.get("transaction_date"):
-		conditions += "and rfq.transaction_date = '{}'".format(filters.get("transaction_date"))
-
-	rfq_data = frappe.db.sql(
-		f"""
-		select
-			distinct rfq.name, rfq.transaction_date,
-			rfq.company
-		from
-			`tabRequest for Quotation` rfq, `tabRequest for Quotation Supplier` rfq_supplier
-		where
-			rfq.name = rfq_supplier.parent
-			and rfq_supplier.supplier = %(supplier)s
-			and rfq.docstatus = 1
-			and rfq.company = %(company)s
-			{conditions}
-		order by rfq.transaction_date ASC
-		limit %(page_len)s offset %(start)s """,
-		{
-			"page_len": page_len,
-			"start": start,
-			"company": filters.get("company"),
-			"supplier": filters.get("supplier"),
-		},
-		as_dict=1,
+	query = (
+		frappe.qb.from_(rfq)
+		.from_(rfq_supplier)
+		.select(rfq.name)
+		.distinct()
+		.select(rfq.transaction_date, rfq.company)
+		.where(
+			(rfq.name == rfq_supplier.parent)
+			& (rfq_supplier.supplier == filters.get("supplier"))
+			& (rfq.docstatus == 1)
+			& (rfq.company == filters.get("company"))
+		)
+		.orderby(rfq.transaction_date, order=Order.asc)
+		.limit(page_len)
+		.offset(start)
 	)
 
+	if txt:
+		query = query.where(rfq.name.like(f"%%{txt}%%"))
+
+	if filters.get("transaction_date"):
+		query = query.where(rfq.transaction_date == filters.get("transaction_date"))
+
+	rfq_data = query.run(as_dict=1)
+
 	return rfq_data

erpnext/buying/doctype/supplier/supplier.js

@@ -42,6 +42,11 @@ frappe.ui.form.on("Supplier", {
 				},
 			};
 		});
+
+		frm.make_methods = {
+			"Bank Account": () => erpnext.utils.make_bank_account(frm.doc.doctype, frm.doc.name),
+			"Pricing Rule": () => erpnext.utils.make_pricing_rule(frm.doc.doctype, frm.doc.name),
+		};
 	},
 
 	refresh: function (frm) {
@@ -84,21 +89,9 @@ frappe.ui.form.on("Supplier", {
 				__("View")
 			);
 
-			frm.add_custom_button(
-				__("Bank Account"),
-				function () {
-					erpnext.utils.make_bank_account(frm.doc.doctype, frm.doc.name);
-				},
-				__("Create")
-			);
+			frm.add_custom_button(__("Bank Account"), () => frm.make_methods["Bank Account"](), __("Create"));
 
-			frm.add_custom_button(
-				__("Pricing Rule"),
-				function () {
-					erpnext.utils.make_pricing_rule(frm.doc.doctype, frm.doc.name);
-				},
-				__("Create")
-			);
+			frm.add_custom_button(__("Pricing Rule"), () => frm.make_methods["Pricing Rule"](), __("Create"));
 
 			frm.add_custom_button(
 				__("Get Supplier Group Details"),
@@ -108,7 +101,10 @@ frappe.ui.form.on("Supplier", {
 				__("Actions")
 			);
 
-			if (cint(frappe.defaults.get_default("enable_common_party_accounting"))) {
+			if (
+				cint(frappe.defaults.get_default("enable_common_party_accounting")) &&
+				frappe.model.can_create("Party Link")
+			) {
 				frm.add_custom_button(
 					__("Link with Customer"),
 					function () {

erpnext/controllers/accounts_controller.py

@@ -213,6 +213,11 @@ class AccountsController(TransactionBase):
 
 		self.validate_date_with_fiscal_year()
 		self.validate_party_accounts()
+		if self.doctype in ["Sales Invoice", "Purchase Invoice"]:
+			if self.is_return:
+				self.validate_qty()
+			else:
+				self.validate_deferred_start_and_end_date()
 
 		self.validate_inter_company_reference()
 
@@ -258,11 +263,6 @@ class AccountsController(TransactionBase):
 
 			self.set_advance_gain_or_loss()
 
-			if self.is_return:
-				self.validate_qty()
-			else:
-				self.validate_deferred_start_and_end_date()
-
 			self.validate_deferred_income_expense_account()
 			self.set_inter_company_account()
 
@@ -2239,6 +2239,7 @@ class AccountsController(TransactionBase):
 
 		self.payment_schedule = []
 		self.payment_terms_template = po_or_so.payment_terms_template
+		posting_date = self.get("bill_date") or self.get("posting_date") or self.get("transaction_date")
 
 		for schedule in po_or_so.payment_schedule:
 			payment_schedule = {
@@ -2251,6 +2252,17 @@ class AccountsController(TransactionBase):
 			}
 
 			if automatically_fetch_payment_terms:
+				if schedule.due_date_based_on:
+					payment_schedule["due_date"] = get_due_date(schedule, posting_date)
+					payment_schedule["due_date_based_on"] = schedule.due_date_based_on
+					payment_schedule["credit_days"] = cint(schedule.credit_days)
+					payment_schedule["credit_months"] = cint(schedule.credit_months)
+
+				if schedule.discount_validity_based_on:
+					payment_schedule["discount_date"] = get_discount_date(schedule, posting_date)
+					payment_schedule["discount_validity_based_on"] = schedule.discount_validity_based_on
+					payment_schedule["discount_validity"] = cint(schedule.discount_validity)
+
 				payment_schedule["payment_amount"] = flt(
 					grand_total * flt(payment_schedule["invoice_portion"]) / 100,
 					schedule.precision("payment_amount"),
@@ -2738,9 +2750,7 @@ def set_balance_in_account_currency(
 			_("Account: {0} with currency: {1} can not be selected").format(gl_dict.account, account_currency)
 		)
 
-	gl_dict["account_currency"] = (
-		company_currency if account_currency == company_currency else account_currency
-	)
+	gl_dict["account_currency"] = account_currency
 
 	# set debit/credit in account currency if not provided
 	if flt(gl_dict.debit) and not flt(gl_dict.debit_in_account_currency):
@@ -2987,14 +2997,26 @@ def get_payment_term_details(
 		term = frappe.get_doc("Payment Term", term)
 	else:
 		term_details.payment_term = term.payment_term
-	term_details.description = term.description
-	term_details.invoice_portion = term.invoice_portion
+
+	fields_to_copy = [
+		"description",
+		"invoice_portion",
+		"discount_type",
+		"discount",
+		"mode_of_payment",
+		"due_date_based_on",
+		"credit_days",
+		"credit_months",
+		"discount_validity_based_on",
+		"discount_validity",
+	]
+
+	for field in fields_to_copy:
+		term_details[field] = term.get(field)
+
 	term_details.payment_amount = flt(term.invoice_portion) * flt(grand_total) / 100
 	term_details.base_payment_amount = flt(term.invoice_portion) * flt(base_grand_total) / 100
-	term_details.discount_type = term.discount_type
-	term_details.discount = term.discount
 	term_details.outstanding = term_details.payment_amount
-	term_details.mode_of_payment = term.mode_of_payment
 
 	if bill_date:
 		term_details.due_date = get_due_date(term, bill_date)
@@ -3013,11 +3035,11 @@ def get_due_date(term, posting_date=None, bill_date=None):
 	due_date = None
 	date = bill_date or posting_date
 	if term.due_date_based_on == "Day(s) after invoice date":
-		due_date = add_days(date, term.credit_days)
+		due_date = add_days(date, cint(term.credit_days))
 	elif term.due_date_based_on == "Day(s) after the end of the invoice month":
-		due_date = add_days(get_last_day(date), term.credit_days)
+		due_date = add_days(get_last_day(date), cint(term.credit_days))
 	elif term.due_date_based_on == "Month(s) after the end of the invoice month":
-		due_date = get_last_day(add_months(date, term.credit_months))
+		due_date = get_last_day(add_months(date, cint(term.credit_months)))
 	return due_date
 
 
@@ -3025,11 +3047,11 @@ def get_discount_date(term, posting_date=None, bill_date=None):
 	discount_validity = None
 	date = bill_date or posting_date
 	if term.discount_validity_based_on == "Day(s) after invoice date":
-		discount_validity = add_days(date, term.discount_validity)
+		discount_validity = add_days(date, cint(term.discount_validity))
 	elif term.discount_validity_based_on == "Day(s) after the end of the invoice month":
-		discount_validity = add_days(get_last_day(date), term.discount_validity)
+		discount_validity = add_days(get_last_day(date), cint(term.discount_validity))
 	elif term.discount_validity_based_on == "Month(s) after the end of the invoice month":
-		discount_validity = get_last_day(add_months(date, term.discount_validity))
+		discount_validity = get_last_day(add_months(date, cint(term.discount_validity)))
 	return discount_validity
 
 

erpnext/controllers/queries.py

@@ -6,7 +6,7 @@ import json
 from collections import defaultdict
 
 import frappe
-from frappe import qb, scrub
+from frappe import cint, qb, scrub
 from frappe.desk.reportview import get_filters_cond, get_match_cond
 from frappe.query_builder import Criterion, CustomFunction
 from frappe.query_builder.functions import Locate
@@ -528,21 +528,27 @@ def get_account_list(doctype, txt, searchfield, start, page_len, filters):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def get_blanket_orders(doctype, txt, searchfield, start, page_len, filters):
-	return frappe.db.sql(
-		"""select distinct bo.name, bo.blanket_order_type, bo.to_date
-		from `tabBlanket Order` bo, `tabBlanket Order Item` boi
-		where
-			boi.parent = bo.name
-			and boi.item_code = {item_code}
-			and bo.blanket_order_type = '{blanket_order_type}'
-			and bo.company = {company}
-			and bo.docstatus = 1""".format(
-			item_code=frappe.db.escape(filters.get("item")),
-			blanket_order_type=filters.get("blanket_order_type"),
-			company=frappe.db.escape(filters.get("company")),
+	bo = frappe.qb.DocType("Blanket Order")
+	bo_item = frappe.qb.DocType("Blanket Order Item")
+
+	blanket_orders = (
+		frappe.qb.from_(bo)
+		.from_(bo_item)
+		.select(bo.name)
+		.distinct()
+		.select(bo.blanket_order_type, bo.to_date)
+		.where(
+			(bo_item.parent == bo.name)
+			& (bo_item.item_code == filters.get("item"))
+			& (bo.blanket_order_type == filters.get("blanket_order_type"))
+			& (bo.company == filters.get("company"))
+			& (bo.docstatus == 1)
 		)
+		.run()
 	)
 
+	return blanket_orders
+
 
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
@@ -560,7 +566,7 @@ def get_income_account(doctype, txt, searchfield, start, page_len, filters):
 	if filters.get("company"):
 		condition += "and tabAccount.company = %(company)s"
 
-	condition += f"and tabAccount.disabled = {filters.get('disabled', 0)}"
+	condition += " and tabAccount.disabled = %(disabled)s"
 
 	return frappe.db.sql(
 		f"""select tabAccount.name from `tabAccount`
@@ -570,7 +576,11 @@ def get_income_account(doctype, txt, searchfield, start, page_len, filters):
 				and tabAccount.`{searchfield}` LIKE %(txt)s
 				{condition} {get_match_cond(doctype)}
 			order by idx desc, name""",
-		{"txt": "%" + txt + "%", "company": filters.get("company", "")},
+		{
+			"txt": "%" + txt + "%",
+			"company": filters.get("company", ""),
+			"disabled": cint(filters.get("disabled", 0)),
+		},
 	)
 
 
@@ -646,7 +656,7 @@ def get_expense_account(doctype, txt, searchfield, start, page_len, filters):
 		where (tabAccount.report_type = "Profit and Loss"
 				or tabAccount.account_type in ("Expense Account", "Fixed Asset", "Temporary", "Asset Received But Not Billed", "Capital Work in Progress"))
 			and tabAccount.is_group=0
-			and tabAccount.docstatus!=2
+		    and tabAccount.disabled = 0
 			and tabAccount.{searchfield} LIKE %(txt)s
 			{condition} {get_match_cond(doctype)}""",
 		{"company": filters.get("company", ""), "txt": "%" + txt + "%"},

erpnext/controllers/selling_controller.py

@@ -728,7 +728,16 @@ class SellingController(StockController):
 
 
 def set_default_income_account_for_item(obj):
-	for d in obj.get("items"):
-		if d.item_code:
-			if getattr(d, "income_account", None):
-				set_item_default(d.item_code, obj.company, "income_account", d.income_account)
+	"""Set income account as default for items in the transaction.
+
+	Updates the item default income account for each item in the transaction
+	if it differs from the company's default income account.
+
+	Args:
+	    obj: Transaction document containing items table with income_account field
+	"""
+	company_default = frappe.get_cached_value("Company", obj.company, "default_income_account")
+	for d in obj.get("items", default=[]):
+		income_account = getattr(d, "income_account", None)
+		if d.item_code and income_account and income_account != company_default:
+			set_item_default(d.item_code, obj.company, "income_account", income_account)

erpnext/controllers/stock_controller.py

@@ -520,8 +520,9 @@ class StockController(AccountsController):
 
 		make_sl_entries(sl_entries, allow_negative_stock, via_landed_cost_voucher)
 
-	def make_gl_entries_on_cancel(self):
-		cancel_exchange_gain_loss_journal(frappe._dict(doctype=self.doctype, name=self.name))
+	def make_gl_entries_on_cancel(self, from_repost=False):
+		if not from_repost:
+			cancel_exchange_gain_loss_journal(frappe._dict(doctype=self.doctype, name=self.name))
 		if frappe.db.sql(
 			"""select name from `tabGL Entry` where voucher_type=%s
 			and voucher_no=%s""",

erpnext/controllers/taxes_and_totals.py

@@ -42,17 +42,23 @@ class calculate_taxes_and_totals:
 		items = list(filter(lambda item: not item.get("is_alternative"), self.doc.get("items")))
 		return items
 
-	def calculate(self):
+	def calculate(self, ignore_tax_template_validation=False):
 		if not len(self._items):
 			return
 
 		self.discount_amount_applied = False
+		self.need_recomputation = False
+		self.ignore_tax_template_validation = ignore_tax_template_validation
+
 		self._calculate()
 
 		if self.doc.meta.get_field("discount_amount"):
 			self.set_discount_amount()
 			self.apply_discount_amount()
 
+		if not ignore_tax_template_validation and self.need_recomputation:
+			return self.calculate(ignore_tax_template_validation=True)
+
 		# Update grand total as per cash and non trade discount
 		if self.doc.apply_discount_on == "Grand Total" and self.doc.get("is_cash_or_non_trade_discount"):
 			self.doc.grand_total -= self.doc.discount_amount
@@ -96,6 +102,9 @@ class calculate_taxes_and_totals:
 			self.doc.base_tax_withholding_net_total = sum_base_net_amount
 
 	def validate_item_tax_template(self):
+		if self.ignore_tax_template_validation:
+			return
+
 		if self.doc.get("is_return") and self.doc.get("return_against"):
 			return
 
@@ -136,6 +145,10 @@ class calculate_taxes_and_totals:
 							)
 						)
 
+						# For correct tax_amount calculation re-computation is required
+						if self.discount_amount_applied and self.doc.apply_discount_on == "Grand Total":
+							self.need_recomputation = True
+
 	def update_item_tax_map(self):
 		for item in self.doc.items:
 			item.item_tax_rate = get_item_tax_map(

erpnext/edi/doctype/code_list/code_list_import.py

@@ -60,7 +60,7 @@ def import_genericode():
 			"doctype": "File",
 			"attached_to_doctype": "Code List",
 			"attached_to_name": code_list.name,
-			"folder": "Home/Attachments",
+			"folder": frappe.db.get_value("File", {"is_attachments_folder": 1}),
 			"file_name": frappe.local.uploaded_filename,
 			"file_url": frappe.local.uploaded_file_url,
 			"is_private": 1,

erpnext/edi/doctype/common_code/common_code.json

@@ -6,6 +6,7 @@
  "engine": "InnoDB",
  "field_order": [
   "code_list",
+  "canonical_uri",
   "title",
   "common_code",
   "description",
@@ -71,10 +72,17 @@
    "in_list_view": 1,
    "label": "Description",
    "max_height": "60px"
+  },
+  {
+   "fetch_from": "code_list.canonical_uri",
+   "fieldname": "canonical_uri",
+   "fieldtype": "Data",
+   "label": "Canonical URI"
   }
  ],
+ "grid_page_length": 50,
  "links": [],
- "modified": "2024-11-06 07:46:17.175687",
+ "modified": "2025-10-04 17:22:28.176155",
  "modified_by": "Administrator",
  "module": "EDI",
  "name": "Common Code",
@@ -94,10 +102,11 @@
    "write": 1
   }
  ],
+ "row_format": "Dynamic",
  "search_fields": "common_code,description",
  "show_title_field_in_link": 1,
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "title_field": "title"
-}
+}

erpnext/edi/doctype/common_code/common_code.py

@@ -22,6 +22,7 @@ class CommonCode(Document):
 
 		additional_data: DF.Code | None
 		applies_to: DF.Table[DynamicLink]
+		canonical_uri: DF.Data | None
 		code_list: DF.Link
 		common_code: DF.Data
 		description: DF.SmallText | None

erpnext/manufacturing/doctype/job_card/job_card.py

@@ -443,7 +443,7 @@ class JobCard(Document):
 			op_row.employee.append(time_log.employee)
 			if time_log.time_in_mins:
 				op_row.completed_time += time_log.time_in_mins
-				op_row.completed_qty += time_log.completed_qty
+				op_row.completed_qty += flt(time_log.completed_qty)
 
 		for row in self.sub_operations:
 			operation_deatils = operation_wise_completed_time.get(row.sub_operation)

erpnext/patches.txt

@@ -377,3 +377,4 @@ execute:frappe.db.set_single_value("Accounts Settings", "receivable_payable_fetc
 erpnext.patches.v14_0.set_update_price_list_based_on
 erpnext.patches.v14_0.rename_group_by_to_categorize_by_in_custom_reports
 erpnext.patches.v14_0.update_full_name_in_contract
+erpnext.patches.v16_0.update_currency_exchange_settings_for_frankfurter #2025-12-11

erpnext/patches/v14_0/update_currency_exchange_settings_for_frankfurter.py

@@ -2,6 +2,15 @@ import frappe
 
 
 def execute():
+	try:
+		from erpnext.patches.v16_0.update_currency_exchange_settings_for_frankfurter import execute
+
+		execute()
+	except ImportError:
+		update_frankfurter_app_parameter_and_result()
+
+
+def update_frankfurter_app_parameter_and_result():
 	settings = frappe.get_doc("Currency Exchange Settings")
 	if settings.service_provider != "frankfurter.app":
 		return

erpnext/patches/v16_0/update_currency_exchange_settings_for_frankfurter.py

@@ -0,0 +1,17 @@
+import frappe
+
+
+def execute():
+	settings_meta = frappe.get_meta("Currency Exchange Settings")
+	settings = frappe.get_doc("Currency Exchange Settings")
+
+	if (
+		"frankfurter.dev" not in settings_meta.get_options("service_provider").split("\n")
+		or settings.service_provider != "frankfurter.app"
+	):
+		return
+
+	settings.service_provider = "frankfurter.dev"
+	settings.set_parameters_and_result()
+	settings.flags.ignore_validate = True
+	settings.save()

erpnext/projects/doctype/timesheet/timesheet.py

@@ -292,12 +292,16 @@ def get_projectwise_timesheet_data(project=None, parent=None, from_time=None, to
 
 @frappe.whitelist()
 def get_timesheet_detail_rate(timelog, currency):
-	timelog_detail = frappe.db.sql(
-		f"""SELECT tsd.billing_amount as billing_amount,
-		ts.currency as currency FROM `tabTimesheet Detail` tsd
-		INNER JOIN `tabTimesheet` ts ON ts.name=tsd.parent
-		WHERE tsd.name = '{timelog}'""",
-		as_dict=1,
+	ts = frappe.qb.DocType("Timesheet")
+	ts_detail = frappe.qb.DocType("Timesheet Detail")
+
+	timelog_detail = (
+		frappe.qb.from_(ts_detail)
+		.inner_join(ts)
+		.on(ts.name == ts_detail.parent)
+		.select(ts_detail.billing_amount.as_("billing_amount"), ts.currency.as_("currency"))
+		.where(ts_detail.name == timelog)
+		.run(as_dict=1)
 	)[0]
 
 	if timelog_detail.currency:

erpnext/projects/web_form/tasks/tasks.py

@@ -1,15 +1,17 @@
+import urllib.parse
+
 import frappe
 
 
 def get_context(context):
-	if frappe.form_dict.project:
-		context.parents = [
-			{"title": frappe.form_dict.project, "route": "/projects?project=" + frappe.form_dict.project}
-		]
-		context.success_url = "/projects?project=" + frappe.form_dict.project
+	if project := frappe.form_dict.project:
+		title = frappe.utils.data.escape_html(project)
+		route = "/projects?" + urllib.parse.urlencode({"project": project})
+		context.parents = [{"title": title, "route": route}]
+		context.success_url = route
 
-	elif context.doc and context.doc.get("project"):
-		context.parents = [
-			{"title": context.doc.project, "route": "/projects?project=" + context.doc.project}
-		]
-		context.success_url = "/projects?project=" + context.doc.project
+	elif context.doc and (project := context.doc.get("project")):
+		title = frappe.utils.data.escape_html(project)
+		route = "/projects?" + urllib.parse.urlencode({"project": project})
+		context.parents = [{"title": title, "route": route}]
+		context.success_url = route

erpnext/public/js/controllers/taxes_and_totals.js

@@ -76,9 +76,10 @@ erpnext.taxes_and_totals = class TaxesAndTotals extends erpnext.payments {
 
 		// Update paid amount on return/debit note creation
 		if (
-			this.frm.doc.doctype === "Purchase Invoice"
-			&& this.frm.doc.is_return
-			&& (this.frm.doc.grand_total > this.frm.doc.paid_amount)
+			this.frm.doc.doctype === "Purchase Invoice" &&
+			this.frm.doc.is_return &&
+			this.frm.doc.grand_total < 0 &&
+			this.frm.doc.grand_total > this.frm.doc.paid_amount
 		) {
 			this.frm.doc.paid_amount = flt(this.frm.doc.grand_total, precision("grand_total"));
 		}

erpnext/public/js/controllers/transaction.js

@@ -438,6 +438,7 @@ erpnext.TransactionController = class TransactionController extends erpnext.taxe
 
 		item.weight_per_unit = 0;
 		item.weight_uom = '';
+		item.uom = null // make UOM blank to update the existing UOM when item changes
 		item.conversion_factor = 0;
 
 		if(['Sales Invoice'].includes(this.frm.doc.doctype)) {
@@ -878,6 +879,15 @@ erpnext.TransactionController = class TransactionController extends erpnext.taxe
 		}
 	}
 
+	discount_date(doc, cdt, cdn) {
+		// Remove fields as discount_date is auto-managed by payment terms
+		const row = locals[cdt][cdn];
+		["discount_validity", "discount_validity_based_on"].forEach((field) => {
+			row[field] = "";
+		});
+		this.frm.refresh_field("payment_schedule");
+	}
+
 	due_date() {
 		// due_date is to be changed, payment terms template and/or payment schedule must
 		// be removed as due_date is automatically changed based on payment terms
@@ -1079,9 +1089,12 @@ erpnext.TransactionController = class TransactionController extends erpnext.taxe
 	plc_conversion_rate() {
 		if(this.frm.doc.price_list_currency === this.get_company_currency()) {
 			this.frm.set_value("plc_conversion_rate", 1.0);
-		} else if(this.frm.doc.price_list_currency === this.frm.doc.currency
-			&& this.frm.doc.plc_conversion_rate && cint(this.frm.doc.plc_conversion_rate) != 1 &&
-			cint(this.frm.doc.plc_conversion_rate) != cint(this.frm.doc.conversion_rate)) {
+		} else if (
+			this.frm.doc.price_list_currency === this.frm.doc.currency &&
+			this.frm.doc.plc_conversion_rate &&
+			flt(this.frm.doc.plc_conversion_rate) != 1 &&
+			flt(this.frm.doc.plc_conversion_rate) != flt(this.frm.doc.conversion_rate)
+		) {
 			this.frm.set_value("conversion_rate", this.frm.doc.plc_conversion_rate);
 		}
 
@@ -2203,6 +2216,7 @@ erpnext.TransactionController = class TransactionController extends erpnext.taxe
 				'item_code': item.item_code,
 				'valid_from': ["<=", doc.transaction_date || doc.bill_date || doc.posting_date],
 				'item_group': item.item_group,
+				'disabled': 0,
 			}
 
 			if (doc.tax_category)
@@ -2244,7 +2258,18 @@ erpnext.TransactionController = class TransactionController extends erpnext.taxe
 	payment_term(doc, cdt, cdn) {
 		const me = this;
 		var row = locals[cdt][cdn];
-		if(row.payment_term) {
+		// empty date condition fields
+		[
+			"due_date_based_on",
+			"credit_days",
+			"credit_months",
+			"discount_validity",
+			"discount_validity_based_on",
+		].forEach(function (field) {
+			row[field] = "";
+		});
+
+		if (row.payment_term) {
 			frappe.call({
 				method: "erpnext.controllers.accounts_controller.get_payment_term_details",
 				args: {
@@ -2254,16 +2279,19 @@ erpnext.TransactionController = class TransactionController extends erpnext.taxe
 					grand_total: this.frm.doc.rounded_total || this.frm.doc.grand_total,
 					base_grand_total: this.frm.doc.base_rounded_total || this.frm.doc.base_grand_total
 				},
-				callback: function(r) {
-					if(r.message && !r.exc) {
-						for (var d in r.message) {
-							frappe.model.set_value(cdt, cdn, d, r.message[d]);
-							const company_currency = me.get_company_currency();
-							me.update_payment_schedule_grid_labels(company_currency);
+				callback: function (r) {
+					if (r.message && !r.exc) {
+						const company_currency = me.get_company_currency();
+						for (let d in r.message) {
+							row[d] = r.message[d];
 						}
+						me.update_payment_schedule_grid_labels(company_currency);
+						me.frm.refresh_field("payment_schedule");
 					}
-				}
-			})
+				},
+			});
+		} else {
+			me.frm.refresh_field("payment_schedule");
 		}
 	}
 

erpnext/public/js/utils.js

@@ -215,17 +215,9 @@ $.extend(erpnext.utils, {
 	},
 
 	make_bank_account: function (doctype, docname) {
-		frappe.call({
-			method: "erpnext.accounts.doctype.bank_account.bank_account.make_bank_account",
-			args: {
-				doctype: doctype,
-				docname: docname,
-			},
-			freeze: true,
-			callback: function (r) {
-				var doclist = frappe.model.sync(r.message);
-				frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
-			},
+		frappe.new_doc("Bank Account", {
+			party_type: doctype,
+			party: docname,
 		});
 	},
 

erpnext/public/js/utils/serial_no_batch_selector.js

@@ -381,7 +381,7 @@ erpnext.SerialNoBatchSelector = class SerialNoBatchSelector {
 								query: "erpnext.controllers.queries.get_batch_no",
 							};
 						},
-						onchange: function () {
+						change: function () {
 							const batch_no = this.get_value();
 							if (!batch_no) {
 								this.grid_row.on_grid_fields_dict.available_qty.set_value(0);

erpnext/selling/doctype/customer/customer.js

@@ -14,6 +14,7 @@ frappe.ui.form.on("Customer", {
 					method: "erpnext.selling.doctype.customer.customer.make_opportunity",
 					frm: cur_frm,
 				}),
+			"Bank Account": () => erpnext.utils.make_bank_account(frm.doc.doctype, frm.doc.name),
 		};
 
 		frm.add_fetch("lead_name", "company_name", "customer_name");
@@ -155,7 +156,10 @@ frappe.ui.form.on("Customer", {
 				__("Actions")
 			);
 
-			if (cint(frappe.defaults.get_default("enable_common_party_accounting"))) {
+			if (
+				cint(frappe.defaults.get_default("enable_common_party_accounting")) &&
+				frappe.model.can_create("Party Link")
+			) {
 				frm.add_custom_button(
 					__("Link with Supplier"),
 					function () {

erpnext/selling/doctype/sales_order/test_sales_order.py

@@ -10,7 +10,7 @@ from frappe.tests.utils import FrappeTestCase, change_settings
 from frappe.utils import add_days, flt, getdate, nowdate, today
 
 from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
-from erpnext.controllers.accounts_controller import update_child_qty_rate
+from erpnext.controllers.accounts_controller import get_due_date, update_child_qty_rate
 from erpnext.maintenance.doctype.maintenance_schedule.test_maintenance_schedule import (
 	make_maintenance_schedule,
 )
@@ -1759,14 +1759,13 @@ class TestSalesOrder(AccountsTestMixin, FrappeTestCase):
 		so.load_from_db()
 		self.assertRaises(frappe.LinkExistsError, so.cancel)
 
+	@change_settings("Accounts Settings", {"automatically_fetch_payment_terms": 1})
 	def test_payment_terms_are_fetched_when_creating_sales_invoice(self):
 		from erpnext.accounts.doctype.payment_entry.test_payment_entry import (
 			create_payment_terms_template,
 		)
 		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 
-		automatically_fetch_payment_terms()
-
 		so = make_sales_order(uom="Nos", do_not_save=1)
 		create_payment_terms_template()
 		so.payment_terms_template = "Test Receivable Template"
@@ -1780,8 +1779,6 @@ class TestSalesOrder(AccountsTestMixin, FrappeTestCase):
 		self.assertEqual(so.payment_terms_template, si.payment_terms_template)
 		compare_payment_schedules(self, so, si)
 
-		automatically_fetch_payment_terms(enable=0)
-
 	def test_zero_amount_sales_order_billing_status(self):
 		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 
@@ -2284,16 +2281,14 @@ class TestSalesOrder(AccountsTestMixin, FrappeTestCase):
 		self.assertRaises(frappe.ValidationError, so1.update_status, "Draft")
 
 
-def automatically_fetch_payment_terms(enable=1):
-	accounts_settings = frappe.get_doc("Accounts Settings")
-	accounts_settings.automatically_fetch_payment_terms = enable
-	accounts_settings.save()
-
-
 def compare_payment_schedules(doc, doc1, doc2):
 	for index, schedule in enumerate(doc1.get("payment_schedule")):
+		posting_date = doc1.get("bill_date") or doc1.get("posting_date") or doc1.get("transaction_date")
+		due_date = schedule.due_date
+		if schedule.due_date_based_on:
+			due_date = get_due_date(schedule, posting_date=posting_date)
 		doc.assertEqual(schedule.payment_term, doc2.payment_schedule[index].payment_term)
-		doc.assertEqual(getdate(schedule.due_date), doc2.payment_schedule[index].due_date)
+		doc.assertEqual(due_date, doc2.payment_schedule[index].due_date)
 		doc.assertEqual(schedule.invoice_portion, doc2.payment_schedule[index].invoice_portion)
 		doc.assertEqual(schedule.payment_amount, doc2.payment_schedule[index].payment_amount)
 

erpnext/selling/doctype/selling_settings/selling_settings.py

@@ -37,15 +37,15 @@ class SellingSettings(Document):
 		)
 
 	def toggle_hide_tax_id(self):
-		self.hide_tax_id = cint(self.hide_tax_id)
+		_hide_tax_id = cint(self.hide_tax_id)
 
 		# Make property setters to hide tax_id fields
 		for doctype in ("Sales Order", "Sales Invoice", "Delivery Note"):
 			make_property_setter(
-				doctype, "tax_id", "hidden", self.hide_tax_id, "Check", validate_fields_for_doctype=False
+				doctype, "tax_id", "hidden", _hide_tax_id, "Check", validate_fields_for_doctype=False
 			)
 			make_property_setter(
-				doctype, "tax_id", "print_hide", self.hide_tax_id, "Check", validate_fields_for_doctype=False
+				doctype, "tax_id", "print_hide", _hide_tax_id, "Check", validate_fields_for_doctype=False
 			)
 
 	def toggle_editable_rate_for_bundle_items(self):

erpnext/setup/doctype/company/company.py

@@ -11,7 +11,7 @@ from frappe.cache_manager import clear_defaults_cache
 from frappe.contacts.address_and_contact import load_address_and_contact
 from frappe.custom.doctype.property_setter.property_setter import make_property_setter
 from frappe.desk.page.setup_wizard.setup_wizard import make_records
-from frappe.utils import cint, formatdate, get_link_to_form, get_timestamp, today
+from frappe.utils import add_months, cint, formatdate, get_first_day, get_link_to_form, get_timestamp, today
 from frappe.utils.nestedset import NestedSet, rebuild_tree
 
 from erpnext.accounts.doctype.account.account import get_account_currency
@@ -614,27 +614,29 @@ def install_country_fixtures(company, country):
 
 
 def update_company_current_month_sales(company):
-	current_month_year = formatdate(today(), "MM-yyyy")
+	from_date = get_first_day(today())
+	to_date = get_first_day(add_months(from_date, 1))
 
 	results = frappe.db.sql(
-		f"""
+		"""
 		SELECT
 			SUM(base_grand_total) AS total,
-			DATE_FORMAT(`posting_date`, '%m-%Y') AS month_year
+			DATE_FORMAT(posting_date, '%%m-%%Y') AS month_year
 		FROM
 			`tabSales Invoice`
 		WHERE
-			DATE_FORMAT(`posting_date`, '%m-%Y') = '{current_month_year}'
+			posting_date >= %s
+			AND posting_date < %s
 			AND docstatus = 1
-			AND company = {frappe.db.escape(company)}
+			AND company = %s
 		GROUP BY
 			month_year
-	""",
+		""",
+		(from_date, to_date, company),
 		as_dict=True,
 	)
 
 	monthly_total = results[0]["total"] if len(results) > 0 else 0
-
 	frappe.db.set_value("Company", company, "total_monthly_sales", monthly_total)
 
 

erpnext/setup/doctype/currency_exchange/test_currency_exchange.py

@@ -68,9 +68,9 @@ def patched_requests_get(*args, **kwargs):
 		if kwargs["params"].get("date") and kwargs["params"].get("from") and kwargs["params"].get("to"):
 			if test_exchange_values.get(kwargs["params"]["date"]):
 				return PatchResponse({"result": test_exchange_values[kwargs["params"]["date"]]}, 200)
-	elif args[0].startswith("https://api.frankfurter.app") and kwargs.get("params"):
+	elif args[0].startswith("https://api.frankfurter.dev") and kwargs.get("params"):
 		if kwargs["params"].get("base") and kwargs["params"].get("symbols"):
-			date = args[0].replace("https://api.frankfurter.app/", "")
+			date = args[0].replace("https://api.frankfurter.dev/v1/", "")
 			if test_exchange_values.get(date):
 				return PatchResponse(
 					{"rates": {kwargs["params"].get("symbols"): test_exchange_values.get(date)}}, 200
@@ -149,7 +149,7 @@ class TestCurrencyExchange(unittest.TestCase):
 		self.assertEqual(flt(exchange_rate, 3), 65.1)
 
 		settings = frappe.get_single("Currency Exchange Settings")
-		settings.service_provider = "frankfurter.app"
+		settings.service_provider = "frankfurter.dev"
 		settings.save()
 
 	def test_exchange_rate_strict(self, mock_get):

erpnext/setup/doctype/employee/employee.js

@@ -21,6 +21,12 @@ erpnext.setup.EmployeeController = class EmployeeController extends frappe.ui.fo
 };
 
 frappe.ui.form.on("Employee", {
+	setup: function (frm) {
+		frm.make_methods = {
+			"Bank Account": () => erpnext.utils.make_bank_account(frm.doc.doctype, frm.doc.name),
+		};
+	},
+
 	onload: function (frm) {
 		frm.set_query("department", function () {
 			return {

erpnext/setup/doctype/employee/test_employee.py

@@ -5,8 +5,10 @@ import unittest
 
 import frappe
 import frappe.utils
+from frappe.query_builder import Criterion
 
 import erpnext
+from erpnext.accounts.utils import build_qb_match_conditions
 from erpnext.setup.doctype.employee.employee import InactiveEmployeeStatusError
 
 test_records = frappe.get_test_records("Employee")
@@ -34,6 +36,32 @@ class TestEmployee(unittest.TestCase):
 		employee_doc.save()
 		self.assertTrue("Employee" not in frappe.get_roles(user))
 
+	def test_employee_user_permission(self):
+		employee1 = make_employee("employee_1_test@company.com", create_user_permission=1)
+		employee2 = make_employee("employee_2_test@company.com", create_user_permission=1)
+		make_employee("employee_3_test@company.com", create_user_permission=1)
+
+		employee1_doc = frappe.get_doc("Employee", employee1)
+		employee2_doc = frappe.get_doc("Employee", employee2)
+
+		employee2_doc.reload()
+		employee2_doc.reports_to = employee1_doc.name
+		employee2_doc.save()
+
+		frappe.set_user(employee1_doc.user_id)
+
+		Employee = frappe.qb.DocType("Employee")
+		qb_employee_list = (
+			frappe.qb.from_(Employee)
+			.select(Employee.name)
+			.where(Criterion.all(build_qb_match_conditions("Employee")))
+			.orderby(Employee.Name)
+		).run(pluck=Employee.name)
+		employee_list = frappe.db.get_list("Employee", pluck="name", order_by="name")
+
+		self.assertEqual(qb_employee_list, employee_list)
+		frappe.set_user("Administrator")
+
 	def tearDown(self):
 		frappe.db.rollback()
 

erpnext/setup/doctype/transaction_deletion_record/transaction_deletion_record.py

@@ -309,8 +309,9 @@ class TransactionDeletionRecord(Document):
 				self.db_set("error_log", None)
 
 	def get_doctypes_to_be_ignored_list(self):
-		singles = frappe.get_all("DocType", filters={"issingle": 1}, pluck="name")
-		doctypes_to_be_ignored_list = singles
+		doctypes_to_be_ignored_list = frappe.get_all(
+			"DocType", or_filters=[["issingle", "=", 1], ["is_virtual", "=", 1]], pluck="name"
+		)
 		for doctype in self.doctypes_to_be_ignored:
 			doctypes_to_be_ignored_list.append(doctype.doctype_name)
 

erpnext/setup/install.py

@@ -80,7 +80,7 @@ def setup_currency_exchange():
 		ces.set("result_key", [])
 		ces.set("req_params", [])
 
-		ces.api_endpoint = "https://api.frankfurter.app/{transaction_date}"
+		ces.api_endpoint = "https://api.frankfurter.dev/v1/{transaction_date}"
 		ces.append("result_key", {"key": "rates"})
 		ces.append("result_key", {"key": "{to_currency}"})
 		ces.append("req_params", {"key": "base", "value": "{from_currency}"})

erpnext/stock/doctype/delivery_note/test_delivery_note.py

@@ -13,7 +13,6 @@ from erpnext.accounts.utils import get_balance_on
 from erpnext.controllers.sales_and_purchase_return import make_return_doc
 from erpnext.selling.doctype.product_bundle.test_product_bundle import make_product_bundle
 from erpnext.selling.doctype.sales_order.test_sales_order import (
-	automatically_fetch_payment_terms,
 	compare_payment_schedules,
 	create_dn_against_so,
 	make_sales_order,
@@ -1026,14 +1025,13 @@ class TestDeliveryNote(FrappeTestCase):
 
 		self.assertTrue("TESTBATCH" in dn.packed_items[0].batch_no, "Batch number not added in packed item")
 
+	@change_settings("Accounts Settings", {"automatically_fetch_payment_terms": 1})
 	def test_payment_terms_are_fetched_when_creating_sales_invoice(self):
 		from erpnext.accounts.doctype.payment_entry.test_payment_entry import (
 			create_payment_terms_template,
 		)
 		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 
-		automatically_fetch_payment_terms()
-
 		so = make_sales_order(uom="Nos", do_not_save=1)
 		create_payment_terms_template()
 		so.payment_terms_template = "Test Receivable Template"
@@ -1053,8 +1051,6 @@ class TestDeliveryNote(FrappeTestCase):
 		self.assertEqual(so.payment_terms_template, si.payment_terms_template)
 		compare_payment_schedules(self, so, si)
 
-		automatically_fetch_payment_terms(enable=0)
-
 	def test_returned_qty_in_return_dn(self):
 		# SO ---> SI ---> DN
 		#                 |
@@ -1511,6 +1507,23 @@ class TestDeliveryNote(FrappeTestCase):
 
 		self.assertEqual(stock_value_difference, 100.0 * 5)
 
+	def test_negative_stock_with_higher_precision(self):
+		original_flt_precision = frappe.db.get_default("float_precision")
+		frappe.db.set_single_value("System Settings", "float_precision", 7)
+
+		item_code = make_item(
+			"Test Negative Stock High Precision Item", properties={"is_stock_item": 1, "valuation_rate": 1}
+		).name
+		dn = create_delivery_note(
+			item_code=item_code,
+			qty=0.0000010,
+			do_not_submit=True,
+		)
+
+		self.assertRaises(frappe.ValidationError, dn.submit)
+
+		frappe.db.set_single_value("System Settings", "float_precision", original_flt_precision)
+
 
 def create_delivery_note(**args):
 	dn = frappe.new_doc("Delivery Note")

erpnext/stock/doctype/material_request/material_request.py

@@ -10,6 +10,7 @@ import json
 import frappe
 from frappe import _, msgprint
 from frappe.model.mapper import get_mapped_doc
+from frappe.query_builder import Order
 from frappe.query_builder.functions import Sum
 from frappe.utils import cint, cstr, flt, get_link_to_form, getdate, new_line_sep, nowdate
 
@@ -498,39 +499,44 @@ def get_items_based_on_default_supplier(supplier):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def get_material_requests_based_on_supplier(doctype, txt, searchfield, start, page_len, filters):
-	conditions = ""
-	if txt:
-		conditions += "and mr.name like '%%" + txt + "%%' "
-
-	if filters.get("transaction_date"):
-		date = filters.get("transaction_date")[1]
-		conditions += f"and mr.transaction_date between '{date[0]}' and '{date[1]}' "
-
 	supplier = filters.get("supplier")
 	supplier_items = get_items_based_on_default_supplier(supplier)
 
 	if not supplier_items:
 		frappe.throw(_("{0} is not the default supplier for any items.").format(supplier))
 
-	material_requests = frappe.db.sql(
-		"""select distinct mr.name, transaction_date,company
-		from `tabMaterial Request` mr, `tabMaterial Request Item` mr_item
-		where mr.name = mr_item.parent
-			and mr_item.item_code in ({})
-			and mr.material_request_type = 'Purchase'
-			and mr.per_ordered < 99.99
-			and mr.docstatus = 1
-			and mr.status != 'Stopped'
-			and mr.company = %s
-			{}
-		order by mr_item.item_code ASC
-		limit {} offset {} """.format(
-			", ".join(["%s"] * len(supplier_items)), conditions, cint(page_len), cint(start)
-		),
-		(*tuple(supplier_items), filters.get("company")),
-		as_dict=1,
+	mr = frappe.qb.DocType("Material Request")
+	mr_item = frappe.qb.DocType("Material Request Item")
+
+	query = (
+		frappe.qb.from_(mr)
+		.from_(mr_item)
+		.select(mr.name)
+		.distinct()
+		.select(mr.transaction_date, mr.company)
+		.where(
+			(mr.name == mr_item.parent)
+			& (mr_item.item_code.isin(supplier_items))
+			& (mr.material_request_type == "Purchase")
+			& (mr.per_ordered < 99.99)
+			& (mr.docstatus == 1)
+			& (mr.status != "Stopped")
+			& (mr.company == filters.get("company"))
+		)
+		.orderby(mr_item.item_code, order=Order.asc)
+		.limit(cint(page_len))
+		.offset(cint(start))
 	)
 
+	if txt:
+		query = query.where(mr.name.like(f"%%{txt}%%"))
+
+	if filters.get("transaction_date"):
+		date = filters.get("transaction_date")[1]
+		query = query.where(mr.transaction_date[date[0] : date[1]])
+
+	material_requests = query.run(as_dict=True)
+
 	return material_requests
 
 

erpnext/stock/doctype/purchase_receipt/purchase_receipt.json

@@ -1077,7 +1077,8 @@
    "no_copy": 1,
    "options": "Delivery Note",
    "print_hide": 1,
-   "read_only": 1
+   "read_only": 1,
+   "search_index": 1
   },
   {
    "fieldname": "scan_barcode",
@@ -1242,7 +1243,7 @@
  "idx": 261,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-11-13 16:55:14.129055",
+ "modified": "2025-08-06 16:41:02.690658",
  "modified_by": "Administrator",
  "module": "Stock",
  "name": "Purchase Receipt",

erpnext/stock/doctype/purchase_receipt/test_purchase_receipt.py

@@ -1056,6 +1056,7 @@ class TestPurchaseReceipt(FrappeTestCase):
 
 		self.assertEqual(discrepancy_caused_by_exchange_rate_diff, amount)
 
+	@change_settings("Accounts Settings", {"automatically_fetch_payment_terms": 1})
 	def test_payment_terms_are_fetched_when_creating_purchase_invoice(self):
 		from erpnext.accounts.doctype.payment_entry.test_payment_entry import (
 			create_payment_terms_template,
@@ -1066,12 +1067,9 @@ class TestPurchaseReceipt(FrappeTestCase):
 			make_pr_against_po,
 		)
 		from erpnext.selling.doctype.sales_order.test_sales_order import (
-			automatically_fetch_payment_terms,
 			compare_payment_schedules,
 		)
 
-		automatically_fetch_payment_terms()
-
 		po = create_purchase_order(qty=10, rate=100, do_not_save=1)
 		create_payment_terms_template()
 		po.payment_terms_template = "Test Receivable Template"
@@ -1089,8 +1087,6 @@ class TestPurchaseReceipt(FrappeTestCase):
 		# self.assertEqual(po.payment_terms_template, pi.payment_terms_template)
 		compare_payment_schedules(self, po, pi)
 
-		automatically_fetch_payment_terms(enable=0)
-
 	@change_settings("Stock Settings", {"allow_negative_stock": 1})
 	def test_neg_to_positive(self):
 		from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry

erpnext/stock/doctype/serial_no/serial_no.py

@@ -193,7 +193,7 @@ class SerialNo(StockController):
 			entries["last_sle"] = last_sle
 
 			if sle_dict.get("incoming", []):
-				entries["purchase_sle"] = sle_dict["incoming"][-1]
+				entries["purchase_sle"] = sle_dict["incoming"][0]
 
 			if last_sle.get("actual_qty") < 0 and sle_dict.get("outgoing", []):
 				entries["delivery_sle"] = sle_dict["outgoing"][0]

erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py

@@ -13,7 +13,7 @@ from erpnext.controllers.stock_controller import StockController
 from erpnext.stock.doctype.batch.batch import get_batch_qty
 from erpnext.stock.doctype.inventory_dimension.inventory_dimension import get_inventory_dimensions
 from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
-from erpnext.stock.utils import get_stock_balance
+from erpnext.stock.utils import get_combine_datetime, get_stock_balance
 
 
 class OpeningEntryAccountError(frappe.ValidationError):
@@ -646,6 +646,7 @@ class StockReconciliation(StockController):
 					self.posting_date,
 					self.posting_time,
 					self.name,
+					sle_creation,
 				)
 
 			precesion = row.precision("current_qty")
@@ -705,8 +706,11 @@ class StockReconciliation(StockController):
 		return allow_negative_stock
 
 
-def get_batch_qty_for_stock_reco(item_code, warehouse, batch_no, posting_date, posting_time, voucher_no):
+def get_batch_qty_for_stock_reco(
+	item_code, warehouse, batch_no, posting_date, posting_time, voucher_no, sle_creation
+):
 	ledger = frappe.qb.DocType("Stock Ledger Entry")
+	posting_datetime = get_combine_datetime(posting_date, posting_time)
 
 	query = (
 		frappe.qb.from_(ledger)
@@ -719,12 +723,11 @@ def get_batch_qty_for_stock_reco(item_code, warehouse, batch_no, posting_date, p
 			& (ledger.docstatus == 1)
 			& (ledger.is_cancelled == 0)
 			& (ledger.batch_no == batch_no)
-			& (ledger.posting_date <= posting_date)
-			& (
-				CombineDatetime(ledger.posting_date, ledger.posting_time)
-				<= CombineDatetime(posting_date, posting_time)
-			)
 			& (ledger.voucher_no != voucher_no)
+			& (
+				(ledger.posting_datetime < posting_datetime)
+				| ((ledger.posting_datetime == posting_datetime) & (ledger.creation < sle_creation))
+			)
 		)
 		.groupby(ledger.batch_no)
 	)
@@ -748,12 +751,12 @@ def get_items(warehouse, posting_date, posting_time, company, item_code=None, ig
 	itemwise_batch_data = get_itemwise_batch(warehouse, posting_date, company, item_code)
 
 	for d in items:
-		if d.item_code in itemwise_batch_data:
+		if (d.item_code, d.warehouse) in itemwise_batch_data:
 			valuation_rate = get_stock_balance(
 				d.item_code, d.warehouse, posting_date, posting_time, with_valuation_rate=True
 			)[1]
 
-			for row in itemwise_batch_data.get(d.item_code):
+			for row in itemwise_batch_data.get((d.item_code, d.warehouse)):
 				if ignore_empty_stock and not row.qty:
 					continue
 
@@ -885,7 +888,7 @@ def get_itemwise_batch(warehouse, posting_date, company, item_code=None):
 	columns, data = execute(filters)
 
 	for row in data:
-		itemwise_batch_data.setdefault(row[0], []).append(
+		itemwise_batch_data.setdefault((row[0], row[3]), []).append(
 			frappe._dict(
 				{
 					"item_code": row[0],

erpnext/stock/get_item_details.py

@@ -635,8 +635,10 @@ def _get_item_tax_template(args, taxes, out=None, for_validate=False):
 	taxes_with_no_validity = []
 
 	for tax in taxes:
-		tax_company = frappe.get_cached_value("Item Tax Template", tax.item_tax_template, "company")
-		if tax_company == args["company"]:
+		disabled, tax_company = frappe.get_cached_value(
+			"Item Tax Template", tax.item_tax_template, ["disabled", "company"]
+		)
+		if not disabled and tax_company == args["company"]:
 			if tax.valid_from or tax.maximum_net_rate:
 				# In purchase Invoice first preference will be given to supplier invoice date
 				# if supplier date is not present then posting date

erpnext/stock/report/stock_ageing/stock_ageing.py

@@ -274,14 +274,6 @@ class FIFOSlots:
 
 			d.actual_qty = d.bal_qty
 			key, fifo_queue, transferred_item_key = self.__init_key_stores(d)
-			serial_nos = d.serial_no if d.serial_no else []
-			if fifo_queue and isinstance(fifo_queue[0][0], str):
-				d.has_serial_no = 1
-
-			if d.actual_qty > 0:
-				self.__compute_incoming_stock(d, fifo_queue, transferred_item_key, serial_nos)
-			else:
-				self.__compute_outgoing_stock(d, fifo_queue, transferred_item_key, serial_nos)
 
 			self.__update_balances(d, key)
 
@@ -439,10 +431,10 @@ class FIFOSlots:
 				transfer_qty_to_pop = 0
 
 	def __update_balances(self, row: dict, key: tuple | str):
-		self.item_details[key]["qty_after_transaction"] = row.qty_after_transaction or row.bal_qty
+		self.item_details[key]["qty_after_transaction"] = row.qty_after_transaction or flt(row.bal_qty)
 
 		if "total_qty" not in self.item_details[key]:
-			self.item_details[key]["total_qty"] = row.actual_qty or row.bal_qty
+			self.item_details[key]["total_qty"] = row.actual_qty or flt(row.bal_qty)
 		else:
 			self.item_details[key]["total_qty"] += row.actual_qty
 

erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py

@@ -41,9 +41,37 @@ def get_data(report_filters):
 		gl_data = voucher_wise_gl_data.get(key) or {}
 		d.account_value = gl_data.get("account_value", 0)
 		d.difference_value = d.stock_value - d.account_value
+		d.ledger_type = "Stock Ledger Entry"
 		if abs(d.difference_value) > 0.1:
 			data.append(d)
 
+		if key in voucher_wise_gl_data:
+			del voucher_wise_gl_data[key]
+
+	if voucher_wise_gl_data:
+		data += get_gl_ledgers_with_no_stock_ledger_entries(voucher_wise_gl_data)
+
+	return data
+
+
+def get_gl_ledgers_with_no_stock_ledger_entries(voucher_wise_gl_data):
+	data = []
+
+	for key in voucher_wise_gl_data:
+		gl_data = voucher_wise_gl_data.get(key) or {}
+		data.append(
+			{
+				"name": gl_data.get("name"),
+				"ledger_type": "GL Entry",
+				"voucher_type": gl_data.get("voucher_type"),
+				"voucher_no": gl_data.get("voucher_no"),
+				"posting_date": gl_data.get("posting_date"),
+				"stock_value": 0,
+				"account_value": gl_data.get("account_value", 0),
+				"difference_value": gl_data.get("account_value", 0) * -1,
+			}
+		)
+
 	return data
 
 
@@ -88,6 +116,7 @@ def get_gl_data(report_filters, filters):
 			"voucher_type",
 			"voucher_no",
 			"sum(debit_in_account_currency) - sum(credit_in_account_currency) as account_value",
+			"posting_date",
 		],
 		group_by="voucher_type, voucher_no",
 	)
@@ -105,10 +134,15 @@ def get_columns(filters):
 		{
 			"label": _("Stock Ledger ID"),
 			"fieldname": "name",
-			"fieldtype": "Link",
-			"options": "Stock Ledger Entry",
+			"fieldtype": "Dynamic Link",
+			"options": "ledger_type",
 			"width": "80",
 		},
+		{
+			"label": _("Ledger Type"),
+			"fieldname": "ledger_type",
+			"fieldtype": "Data",
+		},
 		{"label": _("Posting Date"), "fieldname": "posting_date", "fieldtype": "Date"},
 		{"label": _("Posting Time"), "fieldname": "posting_time", "fieldtype": "Time"},
 		{"label": _("Voucher Type"), "fieldname": "voucher_type", "width": "110"},

erpnext/stock/stock_ledger.py

@@ -489,32 +489,19 @@ class update_entries_after:
 			self.distinct_item_warehouses[key] = val
 			self.new_items_found = True
 		else:
-			# Check if the dependent voucher is reposted
-			# If not, then do not add it to the list
-			if not self.is_dependent_voucher_reposted(dependant_sle):
-				return
-
-			existing_sle_posting_date = self.distinct_item_warehouses[key].get("sle", {}).get("posting_date")
-
-			dependent_voucher_detail_nos = self.get_dependent_voucher_detail_nos(key)
-			if getdate(dependant_sle.posting_date) < getdate(existing_sle_posting_date):
-				if dependent_voucher_detail_nos and dependant_sle.voucher_detail_no in set(
-					dependent_voucher_detail_nos
-				):
+			existing_sle = self.distinct_item_warehouses[key].get("sle", {})
+			if getdate(existing_sle.get("posting_date")) > getdate(dependant_sle.posting_date):
+				self.distinct_item_warehouses[key] = val
+				self.new_items_found = True
+			elif dependant_sle.voucher_type == "Stock Entry" and is_transfer_stock_entry(
+				dependant_sle.voucher_no
+			):
+				if self.distinct_item_warehouses[key].get("transfer_entry_to_repost"):
 					return
 
-				val.sle_changed = True
-				dependent_voucher_detail_nos.append(dependant_sle.voucher_detail_no)
-				val.dependent_voucher_detail_nos = dependent_voucher_detail_nos
+				val["transfer_entry_to_repost"] = True
 				self.distinct_item_warehouses[key] = val
 				self.new_items_found = True
-			elif dependant_sle.voucher_detail_no not in set(dependent_voucher_detail_nos):
-				# Future dependent voucher needs to be repost to get the correct stock value
-				# If dependent voucher has not reposted, then add it to the list
-				dependent_voucher_detail_nos.append(dependant_sle.voucher_detail_no)
-				self.new_items_found = True
-				val.dependent_voucher_detail_nos = dependent_voucher_detail_nos
-				self.distinct_item_warehouses[key] = val
 
 	def is_dependent_voucher_reposted(self, dependant_sle) -> bool:
 		# Return False if the dependent voucher is not reposted
@@ -728,7 +715,11 @@ class update_entries_after:
 		diff = self.wh_data.qty_after_transaction + flt(sle.actual_qty)
 		diff = flt(diff, self.flt_precision)  # respect system precision
 
-		if diff < 0 and abs(diff) > 0.0001:
+		diff_threshold = 0.0001
+		if self.flt_precision > 4:
+			diff_threshold = 10 ** (-1 * self.flt_precision)
+
+		if diff < 0 and abs(diff) > diff_threshold:
 			# negative stock!
 			exc = sle.copy().update({"diff": diff})
 			self.exceptions.setdefault(sle.warehouse, []).append(exc)
@@ -1403,6 +1394,8 @@ def get_sle_by_voucher_detail_no(voucher_detail_no, excluded_sle=None):
 			"posting_time",
 			"voucher_detail_no",
 			"posting_datetime as timestamp",
+			"voucher_type",
+			"voucher_no",
 		],
 		as_dict=1,
 	)
@@ -1830,3 +1823,10 @@ def get_stock_value_difference(item_code, warehouse, posting_date, posting_time,
 
 	difference_amount = query.run()
 	return flt(difference_amount[0][0]) if difference_amount else 0
+
+
+@frappe.request_cache
+def is_transfer_stock_entry(voucher_no):
+	purpose = frappe.get_cached_value("Stock Entry", voucher_no, "purpose")
+
+	return purpose in ["Material Transfer", "Material Transfer for Manufacture", "Send to Subcontractor"]

erpnext/stock/utils.py

@@ -129,8 +129,9 @@ def get_stock_balance(
 	extra_cond = ""
 	if inventory_dimensions_dict:
 		for field, value in inventory_dimensions_dict.items():
+			column = frappe.utils.sanitize_column(field)
 			args[field] = value
-			extra_cond += f" and {field} = %({field})s"
+			extra_cond += f" and {column} = %({field})s"
 
 	last_entry = get_previous_sle(args, extra_cond=extra_cond)
 
@@ -277,8 +278,6 @@ def get_incoming_rate(args, raise_error_if_no_rate=True):
 	if isinstance(args, str):
 		args = json.loads(args)
 
-	voucher_no = args.get("voucher_no") or args.get("name")
-
 	in_rate = None
 	if (args.get("serial_no") or "").strip():
 		in_rate = get_avg_purchase_rate(args.get("serial_no"))
@@ -301,12 +300,13 @@ def get_incoming_rate(args, raise_error_if_no_rate=True):
 				in_rate = (
 					_get_fifo_lifo_rate(previous_stock_queue, args.get("qty") or 0, valuation_method)
 					if previous_stock_queue
-					else 0
+					else None
 				)
 		elif valuation_method == "Moving Average":
-			in_rate = previous_sle.get("valuation_rate") or 0
+			in_rate = previous_sle.get("valuation_rate")
 
 	if in_rate is None:
+		voucher_no = args.get("voucher_no") or args.get("name")
 		in_rate = get_valuation_rate(
 			args.get("item_code"),
 			args.get("warehouse"),

erpnext/support/doctype/issue/issue.py

@@ -158,7 +158,7 @@ def get_issue_list(doctype, txt, filters, limit_start, limit_page_length=20, ord
 		customer = contact_doc.get_link_for("Customer")
 
 	ignore_permissions = False
-	if is_website_user():
+	if is_website_user() and user != "Guest":
 		if not filters:
 			filters = {}