chore(release): Bumped to Version 15.118.2

## [15.118.2](https://github.com/frappe/erpnext/compare/v15.118.1...v15.118.2) (2026-07-28)

### Bug Fixes

* add is_active filter ([bb1320f](bb1320f8df))
* add permission check for `get_item_details` (backport [#57515](https://github.com/frappe/erpnext/issues/57515)) ([#57550](https://github.com/frappe/erpnext/issues/57550)) ([41effcf](41effcf754))
* check if item is variant when creating WO from MR ([745513d](745513d0c2))
* **crm:** align Opportunity status checks with Quotation statuses (backport [#57489](https://github.com/frappe/erpnext/issues/57489)) ([#57490](https://github.com/frappe/erpnext/issues/57490)) ([53d9d1c](53d9d1c50d))
* **crm:** clarify the reason why an opportunity cannot be declared as lost (backport [#57495](https://github.com/frappe/erpnext/issues/57495)) ([#57497](https://github.com/frappe/erpnext/issues/57497)) ([98a0fd8](98a0fd814e))
* detect the currency column by fieldtype in trends total row ([8cceb6a](8cceb6af10))
* enable the 'Include Zero Stock Items' filter by default to show zero-stock items in the Stock Balance report ([#57458](https://github.com/frappe/erpnext/issues/57458)) ([4e8f5de](4e8f5de5cb))
* guard against missing is_your_company_address custom field on address ([6fa522d](6fa522d031))
* Incorrect creation time at the time cancelling an entry causing an issue especially same posting datetime  (backport [#57380](https://github.com/frappe/erpnext/issues/57380)) ([#57396](https://github.com/frappe/erpnext/issues/57396)) ([ae0cd16](ae0cd164f3))
* **manufacturing:** fall back to UOM Conversion Factor in Production Plan (backport [#57553](https://github.com/frappe/erpnext/issues/57553)) ([#57555](https://github.com/frappe/erpnext/issues/57555)) ([12b4c13](12b4c134ca))
* **manufacturing:** update cost of BOMs created via BOM Creator ([25e5b10](25e5b107be))
* map pick list customer to delivery note when no sales order ([0dc5894](0dc5894499)), closes [#57412](https://github.com/frappe/erpnext/issues/57412)
* migrate stored AR/AP ageing filter to renamed field ([e2319c3](e2319c3ffe))
* pool batch slot values on every run, not only when negative ([f38b3b4](f38b3b422d))
* **ppcv:** replace incorrect usage of `frappe.in_test` with `frappe.flags.in_test` in version-15 ([#57579](https://github.com/frappe/erpnext/issues/57579)) ([abc53b0](abc53b0d39))
* **quotation:** carry forward communications from opportunity (backport [#57507](https://github.com/frappe/erpnext/issues/57507)) ([#57508](https://github.com/frappe/erpnext/issues/57508)) ([ceb6778](ceb677844f))
* rebalance batch slot values at the pooled rate when driven negative ([4808202](48082020e8))
* recalculate operating cost on hour rate change in routing ([4fe91bd](4fe91bd8b8))
* rename misleading filter labels in AR/AP reports ([60b4e60](60b4e6053d))
* resolve backport conflict in stock ageing test imports ([a2ace9d](a2ace9d394))
* respect child warehouse account override in Stock and Account Value Comparison ([#57552](https://github.com/frappe/erpnext/issues/57552)) ([20b6dd3](20b6dd3d0f))
* respect selected BOM when creating work order for variant item ([#57359](https://github.com/frappe/erpnext/issues/57359)) ([c5235af](c5235af6bf))
* respect user permissions in party dashboard company list ([348555b](348555b127)), closes [frappe/erpnext#57428](https://github.com/frappe/erpnext/issues/57428)
* restore Save button on reverse journal entry ([d937385](d9373850ad))
* seed cancelled voucher replay from before its posting datetime ([1ff297e](1ff297e9da))
* **stock:** narrow legacy serial ledger lookup by item (backport [#57499](https://github.com/frappe/erpnext/issues/57499)) ([#57505](https://github.com/frappe/erpnext/issues/57505)) ([c70cf8e](c70cf8e554))
* stop storing "{supplier_name}" / "{customer_name}" as the document title ([d96999d](d96999de7f))
* **subcontracting:** release raw-material reservation when closing a subcontracting order ([d970627](d9706271ff))
* **tnc:** `get_terms_and_conditions` render_template with `safe_exec` (backport [#56944](https://github.com/frappe/erpnext/issues/56944)) (backport [#56977](https://github.com/frappe/erpnext/issues/56977)) ([#57106](https://github.com/frappe/erpnext/issues/57106)) ([1d60ab4](1d60ab449c))
* typeerror in get_batches_by_oldest for mixed batch expiry ([56bd024](56bd024f39))
* update operating cost when propagating workstation hour rate to routing ([#57504](https://github.com/frappe/erpnext/issues/57504)) ([8f68b7e](8f68b7ed20))
* use company currency instead of global default in report (backport [#56561](https://github.com/frappe/erpnext/issues/56561)) ([0ad0d77](0ad0d7733b))

.github/workflows/linters.yml

@@ -18,7 +18,19 @@ jobs:
           cache: pip
 
       - name: Install and Run Pre-commit
-        uses: pre-commit/action@v3.0.0
+        uses: pre-commit/action@v3.0.1
+
+  semgrep:
+    name: semgrep
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python 3.10
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+          cache: pip
 
       - name: Download Semgrep rules
         run: git clone --depth 1 https://github.com/frappe/semgrep-rules.git frappe-semgrep-rules

.pre-commit-config.yaml

@@ -50,7 +50,6 @@ repos:
                 cypress/.*|
                 .*node_modules.*|
                 .*boilerplate.*|
-                erpnext/public/js/controllers/.*|
                 erpnext/templates/pages/order.js|
                 erpnext/templates/includes/.*
             )$

erpnext/__init__.py

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

erpnext/accounts/custom/address.py

@@ -15,7 +15,7 @@ class ERPNextAddress(Address):
 
 	def link_address(self):
 		"""Link address based on owner"""
-		if self.is_your_company_address:
+		if self.get("is_your_company_address"):
 			return
 
 		return super().link_address()
@@ -26,7 +26,9 @@ class ERPNextAddress(Address):
 				self.is_your_company_address = 1
 
 	def validate_reference(self):
-		if self.is_your_company_address and not [row for row in self.links if row.link_doctype == "Company"]:
+		if self.get("is_your_company_address") and not [
+			row for row in self.links if row.link_doctype == "Company"
+		]:
 			frappe.throw(
 				_(
 					"Address needs to be linked to a Company. Please add a row for Company in the Links table."

erpnext/accounts/doctype/account/account.py

@@ -119,6 +119,7 @@ class Account(NestedSet):
 		self.validate_account_currency()
 		self.validate_root_company_and_sync_account_to_children()
 		self.validate_receivable_payable_account_type()
+		self.validate_stock_account_type_change()
 
 	def validate_parent_child_account_type(self):
 		if self.parent_account:
@@ -207,6 +208,36 @@ class Account(NestedSet):
 				frappe.msgprint(msg)
 				self.add_comment("Comment", msg)
 
+	def validate_stock_account_type_change(self):
+		doc_before_save = self.get_doc_before_save()
+		if not (doc_before_save and doc_before_save.account_type == "Stock"):
+			return
+
+		if self.account_type == "Stock":
+			return
+
+		if self.stock_ledger_entry_exists():
+			frappe.throw(
+				_(
+					"The account type of {0} cannot be changed from {1} because stock ledger entries exist against it."
+				).format(frappe.bold(self.name), frappe.bold(_("Stock")))
+			)
+
+	def stock_ledger_entry_exists(self):
+		from erpnext.stock import get_warehouse_account_map
+
+		warehouse_account = get_warehouse_account_map(self.company)
+		warehouses = [wh for wh, details in warehouse_account.items() if details.account == self.name]
+		if not warehouses:
+			return False
+
+		return bool(
+			frappe.db.count(
+				"Stock Ledger Entry",
+				filters={"warehouse": ("in", warehouses), "is_cancelled": 0},
+			)
+		)
+
 	def validate_root_details(self):
 		doc_before_save = self.get_doc_before_save()
 

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

@@ -406,8 +406,7 @@
 				"Customer Deposits": {
 					"account_number": "2500",
 					"is_group": 0,
-					"root_type": "Liability",
-					"account_type": "Payable"
+					"root_type": "Liability"
 				}
 			},
 			"Non Current Liabilities": {

erpnext/accounts/doctype/account/test_account.py

@@ -313,6 +313,31 @@ class TestAccount(unittest.TestCase):
 		acc.account_currency = "USD"
 		self.assertRaises(frappe.ValidationError, acc.save)
 
+	def test_stock_account_type_change_with_ledger_entries(self):
+		from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry
+
+		company = "_Test Company with perpetual inventory"
+		warehouse = "Stores - TCP1"
+		stock_account = get_warehouse_account(frappe.get_doc("Warehouse", warehouse))
+
+		make_stock_entry(
+			item_code="_Test Item",
+			target=warehouse,
+			company=company,
+			qty=5,
+			basic_rate=100,
+		)
+
+		account = frappe.get_doc("Account", stock_account)
+		self.assertEqual(account.account_type, "Stock")
+
+		account.account_type = ""
+		self.assertRaises(frappe.ValidationError, account.save)
+
+		account.reload()
+		account.account_name = f"{account.account_name} Updated"
+		account.save()  # non-type change stays allowed
+
 	def test_account_balance(self):
 		from erpnext.accounts.utils import get_balance_on
 

erpnext/accounts/doctype/accounting_period/accounting_period.py

@@ -5,6 +5,7 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
+from frappe.utils import getdate, nowdate
 
 
 class OverlapError(frappe.ValidationError):
@@ -34,8 +35,20 @@ class AccountingPeriod(Document):
 	# end: auto-generated types
 
 	def validate(self):
+		self.validate_dates()
 		self.validate_overlap()
 
+	def validate_dates(self):
+		if getdate(self.start_date) > getdate(self.end_date):
+			frappe.throw(_("Start Date cannot be after End Date"))
+
+		if getdate(self.end_date) > getdate(nowdate()):
+			frappe.throw(
+				_(
+					"Accounting Period cannot be created for a future date. End Date {0} is after today."
+				).format(frappe.bold(frappe.format(self.end_date, "Date")))
+			)
+
 	def before_insert(self):
 		self.bootstrap_doctypes_for_closing()
 

erpnext/accounts/doctype/accounting_period/test_accounting_period.py

@@ -4,7 +4,7 @@
 import unittest
 
 import frappe
-from frappe.utils import add_months, nowdate
+from frappe.utils import nowdate
 
 from erpnext.accounts.doctype.accounting_period.accounting_period import (
 	ClosedAccountingPeriod,
@@ -47,7 +47,7 @@ def create_accounting_period(**args):
 
 	accounting_period = frappe.new_doc("Accounting Period")
 	accounting_period.start_date = args.start_date or nowdate()
-	accounting_period.end_date = args.end_date or add_months(nowdate(), 1)
+	accounting_period.end_date = args.end_date or nowdate()
 	accounting_period.company = args.company or "_Test Company"
 	accounting_period.period_name = args.period_name or "_Test_Period_Name_1"
 	accounting_period.append("closed_documents", {"document_type": "Sales Invoice", "closed": 1})

erpnext/accounts/doctype/bank_account/bank_account.py

@@ -115,7 +115,7 @@ def get_party_bank_account(party_type, party):
 	)
 
 
-def get_default_company_bank_account(company, party_type, party):
+def get_default_company_bank_account(company, party_type, party, ignore_permissions=True):
 	default_company_bank_account = frappe.db.get_value(party_type, party, "default_bank_account")
 	if default_company_bank_account:
 		if company != frappe.get_cached_value("Bank Account", default_company_bank_account, "company"):
@@ -126,6 +126,14 @@ def get_default_company_bank_account(company, party_type, party):
 			"Bank Account", {"company": company, "is_company_account": 1, "is_default": 1}
 		)
 
+	if not ignore_permissions:
+		default_company_bank_account = (
+			default_company_bank_account
+			if default_company_bank_account
+			and frappe.get_cached_doc("Bank Account", default_company_bank_account).has_permission("select")
+			else None
+		)
+
 	return default_company_bank_account
 
 

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -57,7 +57,7 @@ def get_bank_transactions(bank_account, from_date=None, to_date=None):
 		filters.append(["date", "<=", to_date])
 	if from_date:
 		filters.append(["date", ">=", from_date])
-	transactions = frappe.get_all(
+	transactions = frappe.get_list(
 		"Bank Transaction",
 		fields=[
 			"date",
@@ -82,6 +82,7 @@ def get_bank_transactions(bank_account, from_date=None, to_date=None):
 @frappe.whitelist()
 def get_account_balance(bank_account, till_date, company):
 	# returns account balance till the specified date
+	frappe.has_permission("Bank Account", "read", bank_account, throw=True)
 	account = frappe.db.get_value("Bank Account", bank_account, "account")
 	filters = frappe._dict(
 		{

erpnext/accounts/doctype/bank_transaction/test_bank_transaction.py

@@ -115,6 +115,36 @@ class TestBankTransaction(FrappeTestCase):
 		self.assertEqual(bank_transaction.unallocated_amount, 1700)
 		self.assertEqual(bank_transaction.payment_entries, [])
 
+	# Amending a reconciled payment entry must not carry over its clearance date
+	def test_clearance_date_cleared_on_amend(self):
+		bank_transaction = frappe.get_doc(
+			"Bank Transaction",
+			dict(description="1512567 BG/000003025 OPSKATTUZWXXX AT776000000098709849 Herr G"),
+		)
+		payment = frappe.get_doc("Payment Entry", dict(party="Mr G", paid_amount=1700))
+		vouchers = json.dumps(
+			[
+				{
+					"payment_doctype": "Payment Entry",
+					"payment_name": payment.name,
+					"amount": bank_transaction.unallocated_amount,
+				}
+			]
+		)
+		reconcile_vouchers(bank_transaction.name, vouchers)
+
+		self.assertTrue(frappe.db.get_value("Payment Entry", payment.name, "clearance_date"))
+
+		payment.reload()
+		payment.cancel()
+
+		amended = frappe.copy_doc(payment)
+		amended.amended_from = payment.name
+		amended.docstatus = 0
+		amended.insert()
+
+		self.assertFalse(amended.clearance_date)
+
 	# Check if ERPNext can correctly filter a linked payments based on the debit/credit amount
 	def test_debit_credit_output(self):
 		bank_transaction = frappe.get_doc(

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -215,6 +215,7 @@ def build_forest(data):
 		for row in data:
 			account_name, parent_account, account_number, parent_account_number = row[0:4]
 			if account_number:
+				account_number = cstr(account_number).strip()
 				account_name = f"{account_number} - {account_name}"
 			if parent_account_number:
 				parent_account_number = cstr(parent_account_number).strip()

erpnext/accounts/doctype/dunning/dunning.js

@@ -169,23 +169,10 @@ frappe.ui.form.on("Dunning", {
 	},
 	get_dunning_letter_text: function (frm) {
 		if (frm.doc.dunning_type) {
-			frappe.call({
-				method: "erpnext.accounts.doctype.dunning.dunning.get_dunning_letter_text",
-				args: {
-					dunning_type: frm.doc.dunning_type,
-					language: frm.doc.language,
-					doc: frm.doc,
-				},
-				callback: function (r) {
-					if (r.message) {
-						frm.set_value("body_text", r.message.body_text);
-						frm.set_value("closing_text", r.message.closing_text);
-						frm.set_value("language", r.message.language);
-					} else {
-						frm.set_value("body_text", "");
-						frm.set_value("closing_text", "");
-					}
-				},
+			frm.call("get_dunning_letter_text").then((r) => {
+				if (!r.exc) {
+					frm.refresh_fields();
+				}
 			});
 		}
 	},

erpnext/accounts/doctype/dunning/dunning.py

@@ -156,6 +156,46 @@ class Dunning(AccountsController):
 			"Serial and Batch Bundle",
 		]
 
+	@frappe.whitelist()
+	def get_dunning_letter_text(self):
+		DOCTYPE = "Dunning Letter Text"
+		FIELDS = ["body_text", "closing_text", "language"]
+
+		if not self.dunning_type:
+			return
+
+		filters = {"parent": self.dunning_type, "is_default_language": 1}
+
+		if self.language:
+			filters.pop("is_default_language")
+			filters["language"] = self.language
+
+		letter_text = frappe.db.get_value(DOCTYPE, filters, FIELDS, as_dict=True)
+
+		if not letter_text:
+			msg = (
+				_("Dunning Letter for Dunning Type {0} in language '{1}' not found.").format(
+					frappe.bold(self.dunning_type), frappe.bold(self.language)
+				)
+				if self.language
+				else _("Dunning Letter for Dunning Type {0} not found.").format(
+					frappe.bold(self.dunning_type)
+				)
+			)
+			frappe.msgprint(msg, alert=True, indicator="yellow")
+
+		self.body_text = (
+			frappe.render_template(letter_text.body_text, self.as_dict(), restrict_globals=True)
+			if letter_text
+			else None
+		)
+		self.closing_text = (
+			frappe.render_template(letter_text.closing_text, self.as_dict(), restrict_globals=True)
+			if letter_text
+			else None
+		)
+		self.language = letter_text.language if letter_text else self.language
+
 
 def update_linked_dunnings(doc, previous_outstanding_amount):
 	if (
@@ -234,35 +274,3 @@ def get_linked_dunnings_as_per_state(sales_invoice, state):
 			& (overdue_payment.sales_invoice == sales_invoice)
 		)
 	).run(as_dict=True)
-
-
-@frappe.whitelist()
-def get_dunning_letter_text(dunning_type: str, doc: str | dict, language: str | None = None) -> dict:
-	DOCTYPE = "Dunning Letter Text"
-	FIELDS = ["body_text", "closing_text", "language"]
-
-	if isinstance(doc, str):
-		doc = json.loads(doc)
-
-	if not language:
-		language = doc.get("language")
-
-	letter_text = None
-	if language:
-		letter_text = frappe.db.get_value(
-			DOCTYPE, {"parent": dunning_type, "language": language}, FIELDS, as_dict=1
-		)
-
-	if not letter_text:
-		letter_text = frappe.db.get_value(
-			DOCTYPE, {"parent": dunning_type, "is_default_language": 1}, FIELDS, as_dict=1
-		)
-
-	if not letter_text:
-		return {}
-
-	return {
-		"body_text": frappe.render_template(letter_text.body_text, doc),
-		"closing_text": frappe.render_template(letter_text.closing_text, doc),
-		"language": letter_text.language,
-	}

erpnext/accounts/doctype/dunning_type/dunning_type.py

@@ -3,7 +3,10 @@
 
 
 import frappe
+from frappe import _
 from frappe.model.document import Document
+from frappe.utils import comma_and
+from frappe.utils.jinja import validate_template
 
 
 class DunningType(Document):
@@ -30,3 +33,134 @@ class DunningType(Document):
 	def autoname(self):
 		company_abbr = frappe.get_value("Company", self.company, "abbr")
 		self.name = f"{self.dunning_type} - {company_abbr}"
+
+	def validate(self):
+		self.validate_dunning_letter_text()
+		self.validate_income_account()
+		self.validate_cost_center()
+		self.set_default_dunning_type()
+
+	def validate_dunning_letter_text(self):
+		self.validate_languages()
+		self.validate_is_default_language()
+		self.validate_dunning_letter_text_templates()
+
+	def validate_income_account(self):
+		if not self.income_account:
+			return
+
+		account = frappe.get_cached_doc("Account", self.income_account)
+
+		msg = []
+		if account.company != self.company:
+			msg.append(
+				_(
+					"{0} doesn't belong to Company {1}. Please select an Income Account that belongs to Company {1}."
+				).format(frappe.bold(self.income_account), frappe.bold(self.company))
+			)
+
+		if account.disabled:
+			msg.append(
+				_("{0} is disabled. Please select a valid Income Account.").format(
+					frappe.bold(self.income_account)
+				)
+			)
+
+		if account.root_type != "Income":
+			msg.append(
+				_("{0} is not an Income Account. Please select a valid Income Account.").format(
+					frappe.bold(self.income_account)
+				)
+			)
+
+		if account.is_group:
+			msg.append(
+				_("{0} is a group account. Please select a non-group Income Account.").format(
+					frappe.bold(self.income_account)
+				)
+			)
+
+		if msg:
+			frappe.msgprint(
+				msg,
+				title=_("Income Account Validation Error"),
+				as_list=True,
+				raise_exception=frappe.ValidationError,
+			)
+
+	def validate_cost_center(self):
+		if not self.cost_center:
+			return
+
+		cost_center = frappe.get_cached_doc("Cost Center", self.cost_center)
+
+		msg = []
+		if cost_center.company != self.company:
+			msg.append(
+				_(
+					"{0} doesn't belong to Company {1}. Please select a Cost Center that belongs to Company {1}."
+				).format(frappe.bold(self.cost_center), frappe.bold(self.company))
+			)
+
+		if cost_center.disabled:
+			msg.append(
+				_("{0} is disabled. Please select an enabled Cost Center.").format(
+					frappe.bold(self.cost_center)
+				)
+			)
+
+		if cost_center.is_group:
+			msg.append(
+				_("{0} is a group Cost Center. Please select a non-group Cost Center.").format(
+					frappe.bold(self.cost_center)
+				)
+			)
+
+		if msg:
+			frappe.msgprint(
+				msg,
+				title=_("Cost Center Validation Error"),
+				as_list=True,
+				raise_exception=frappe.ValidationError,
+			)
+
+	def validate_languages(self):
+		languages = [d.language for d in self.dunning_letter_text]
+
+		if len(languages) == len(set(languages)):
+			return
+
+		frappe.throw(_("Duplicate languages found on Dunning Letter Text. Keep only one of them."))
+
+	def validate_is_default_language(self):
+		is_default_language_list = [
+			d.language for d in self.dunning_letter_text if d.is_default_language == 1
+		]
+
+		if len(is_default_language_list) <= 1:
+			return
+
+		frappe.throw(
+			_("{0} languages are marked as default languages. Please select only one of them.").format(
+				comma_and(is_default_language_list, add_quotes=True)
+			)
+		)
+
+	def validate_dunning_letter_text_templates(self):
+		for d in self.dunning_letter_text:
+			if d.body_text:
+				validate_template(d.body_text, restrict_globals=True)
+
+			if d.closing_text:
+				validate_template(d.closing_text, restrict_globals=True)
+
+	def set_default_dunning_type(self):
+		if self.is_default != 1:
+			return
+
+		frappe.db.set_value(
+			"Dunning Type",
+			{"company": self.company, "is_default": 1, "name": ["!=", self.name]},
+			"is_default",
+			0,
+		)

erpnext/accounts/doctype/dunning_type/test_dunning_type.py

@@ -1,9 +1,199 @@
 # Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
-import unittest
+import frappe
+from frappe.tests.utils import FrappeTestCase
 
 
-class TestDunningType(unittest.TestCase):
-	pass
+def make_dunning_type(dunning_type, company="_Test Company", **kwargs):
+	doc = frappe.new_doc("Dunning Type")
+	doc.dunning_type = dunning_type
+	doc.company = company
+	doc.dunning_fee = kwargs.get("dunning_fee", 100)
+	doc.rate_of_interest = kwargs.get("rate_of_interest", 5)
+	doc.is_default = kwargs.get("is_default", 0)
+
+	if "income_account" in kwargs:
+		doc.income_account = kwargs["income_account"]
+	elif kwargs.get("income_account") is not False:
+		doc.income_account = "Sales - _TC" if company == "_Test Company" else "Sales - _TC1"
+
+	if "cost_center" in kwargs:
+		doc.cost_center = kwargs["cost_center"]
+	elif kwargs.get("cost_center") is not False:
+		doc.cost_center = "Main - _TC" if company == "_Test Company" else "Main - _TC1"
+
+	for row in kwargs.get("dunning_letter_text", [{"language": "en", "body_text": "Test body"}]):
+		doc.append("dunning_letter_text", row)
+
+	return doc
+
+
+class TestDunningType(FrappeTestCase):
+	def test_income_account_must_belong_to_company(self):
+		doc = make_dunning_type("_Test Dunning Wrong Company Account", income_account="Sales - _TC1")
+		self.assertRaisesRegex(frappe.ValidationError, "doesn't belong to Company", doc.insert)
+
+	def test_income_account_must_not_be_disabled(self):
+		disabled_account = frappe.get_doc(
+			{
+				"doctype": "Account",
+				"account_name": "_Test Disabled Income Account",
+				"parent_account": "Direct Income - _TC",
+				"company": "_Test Company",
+				"account_type": "Income Account",
+				"disabled": 1,
+			}
+		).insert()
+
+		doc = make_dunning_type("_Test Dunning Disabled Account", income_account=disabled_account.name)
+		self.assertRaisesRegex(frappe.ValidationError, "is disabled", doc.insert)
+
+	def test_income_account_must_be_income_type(self):
+		doc = make_dunning_type("_Test Dunning Non Income Account", income_account="Debtors - _TC")
+		self.assertRaisesRegex(frappe.ValidationError, "is not an Income Account", doc.insert)
+
+	def test_income_account_must_not_be_group(self):
+		doc = make_dunning_type("_Test Dunning Group Account", income_account="Income - _TC")
+		self.assertRaisesRegex(frappe.ValidationError, "is a group account", doc.insert)
+
+	def test_income_account_is_optional(self):
+		doc = make_dunning_type("_Test Dunning No Income Account", income_account=False)
+		doc.insert()
+		self.assertFalse(doc.income_account)
+
+	def test_valid_income_account_passes(self):
+		doc = make_dunning_type("_Test Dunning Valid Income Account", income_account="Sales - _TC")
+		doc.insert()
+		self.assertEqual(doc.income_account, "Sales - _TC")
+
+	def test_cost_center_must_belong_to_company(self):
+		doc = make_dunning_type("_Test Dunning Wrong Company CC", cost_center="Main - _TC1")
+		self.assertRaisesRegex(frappe.ValidationError, "doesn't belong to Company", doc.insert)
+
+	def test_cost_center_must_not_be_disabled(self):
+		disabled_cc = frappe.get_doc(
+			{
+				"doctype": "Cost Center",
+				"cost_center_name": "_Test Disabled Cost Center",
+				"parent_cost_center": "_Test Company - _TC",
+				"company": "_Test Company",
+				"disabled": 1,
+			}
+		).insert()
+
+		doc = make_dunning_type("_Test Dunning Disabled CC", cost_center=disabled_cc.name)
+		self.assertRaisesRegex(frappe.ValidationError, "is disabled", doc.insert)
+
+	def test_cost_center_must_not_be_group(self):
+		doc = make_dunning_type("_Test Dunning Group CC", cost_center="_Test Company - _TC")
+		self.assertRaisesRegex(frappe.ValidationError, "is a group Cost Center", doc.insert)
+
+	def test_cost_center_is_optional(self):
+		doc = make_dunning_type("_Test Dunning No CC", cost_center=False)
+		doc.insert()
+		self.assertFalse(doc.cost_center)
+
+	def test_valid_cost_center_passes(self):
+		doc = make_dunning_type("_Test Dunning Valid CC", cost_center="Main - _TC")
+		doc.insert()
+		self.assertEqual(doc.cost_center, "Main - _TC")
+
+	def test_duplicate_languages_not_allowed(self):
+		doc = make_dunning_type(
+			"_Test Dunning Duplicate Language",
+			dunning_letter_text=[
+				{"language": "en", "body_text": "Body one"},
+				{"language": "en", "body_text": "Body two"},
+			],
+		)
+		self.assertRaisesRegex(frappe.ValidationError, "Duplicate languages found", doc.insert)
+
+	def test_unique_languages_allowed(self):
+		doc = make_dunning_type(
+			"_Test Dunning Unique Languages",
+			dunning_letter_text=[
+				{"language": "en", "body_text": "Body one"},
+				{"language": "de", "body_text": "Body two"},
+			],
+		)
+		doc.insert()
+		self.assertEqual(len(doc.dunning_letter_text), 2)
+
+	def test_only_one_default_language_allowed(self):
+		doc = make_dunning_type(
+			"_Test Dunning Multiple Default Language",
+			dunning_letter_text=[
+				{"language": "en", "body_text": "Body one", "is_default_language": 1},
+				{"language": "de", "body_text": "Body two", "is_default_language": 1},
+			],
+		)
+		self.assertRaisesRegex(
+			frappe.ValidationError, "languages are marked as default languages", doc.insert
+		)
+
+	def test_single_default_language_allowed(self):
+		doc = make_dunning_type(
+			"_Test Dunning Single Default Language",
+			dunning_letter_text=[
+				{"language": "en", "body_text": "Body one", "is_default_language": 1},
+				{"language": "de", "body_text": "Body two", "is_default_language": 0},
+			],
+		)
+		doc.insert()
+		self.assertEqual(doc.dunning_letter_text[0].is_default_language, 1)
+
+	def test_invalid_jinja_template_in_body_text_raises(self):
+		doc = make_dunning_type(
+			"_Test Dunning Invalid Body Template",
+			dunning_letter_text=[{"language": "en", "body_text": "{{ unclosed"}],
+		)
+		self.assertRaisesRegex(frappe.ValidationError, "Syntax error in template", doc.insert)
+
+	def test_invalid_jinja_template_in_closing_text_raises(self):
+		doc = make_dunning_type(
+			"_Test Dunning Invalid Closing Template",
+			dunning_letter_text=[
+				{"language": "en", "body_text": "Valid body", "closing_text": "{{ unclosed"}
+			],
+		)
+		self.assertRaisesRegex(frappe.ValidationError, "Syntax error in template", doc.insert)
+
+	def test_valid_jinja_template_passes(self):
+		doc = make_dunning_type(
+			"_Test Dunning Valid Template",
+			dunning_letter_text=[
+				{
+					"language": "en",
+					"body_text": "Outstanding amount is {{ outstanding_amount }}",
+					"closing_text": "Regards, {{ company }}",
+				}
+			],
+		)
+		doc.insert()
+		self.assertTrue(doc.name)
+
+	def test_set_default_dunning_type_unsets_previous_default(self):
+		first = make_dunning_type("_Test Dunning Default One", is_default=1)
+		first.insert()
+		self.assertEqual(frappe.db.get_value("Dunning Type", first.name, "is_default"), 1)
+
+		second = make_dunning_type("_Test Dunning Default Two", is_default=1)
+		second.insert()
+
+		self.assertEqual(frappe.db.get_value("Dunning Type", first.name, "is_default"), 0)
+		self.assertEqual(frappe.db.get_value("Dunning Type", second.name, "is_default"), 1)
+
+	def test_set_default_dunning_type_scoped_per_company(self):
+		company_1 = make_dunning_type("_Test Dunning Default Co1", is_default=1)
+		company_1.insert()
+
+		company_2 = make_dunning_type(
+			"_Test Dunning Default Co2",
+			company="_Test Company 1",
+			is_default=1,
+		)
+		company_2.insert()
+
+		self.assertEqual(frappe.db.get_value("Dunning Type", company_1.name, "is_default"), 1)
+		self.assertEqual(frappe.db.get_value("Dunning Type", company_2.name, "is_default"), 1)

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js

@@ -22,17 +22,27 @@ frappe.ui.form.on("Exchange Rate Revaluation", {
 	refresh: function (frm) {
 		if (frm.doc.docstatus == 1) {
 			frappe.call({
-				method: "check_journal_entry_condition",
+				method: "check_journal_and_reversal",
 				doc: frm.doc,
 				callback: function (r) {
 					if (r.message) {
-						frm.add_custom_button(
-							__("Journal Entries"),
-							function () {
-								return frm.events.make_jv(frm);
-							},
-							__("Create")
-						);
+						if (!r.message.journals_posted) {
+							frm.add_custom_button(
+								__("Journal Entries"),
+								function () {
+									return frm.events.make_jv(frm);
+								},
+								__("Create")
+							);
+						} else if (!r.message.reversals_posted) {
+							frm.add_custom_button(
+								__("Reversal Journal Entries"),
+								function () {
+									return frm.events.make_reverse_journal(frm);
+								},
+								__("Create")
+							);
+						}
 					}
 				},
 			});
@@ -100,6 +110,14 @@ frappe.ui.form.on("Exchange Rate Revaluation", {
 			},
 		});
 	},
+	make_reverse_journal: function (frm) {
+		frappe.call({
+			method: "make_reverse_journal",
+			doc: frm.doc,
+			freeze: true,
+			freeze_message: __("Reversing Journals..."),
+		});
+	},
 });
 
 frappe.ui.form.on("Exchange Rate Revaluation Account", {

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -8,7 +8,7 @@ from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
 from frappe.query_builder import Criterion, Order
 from frappe.query_builder.functions import NullIf, Sum
-from frappe.utils import flt, get_link_to_form
+from frappe.utils import flt, get_link_to_form, nowdate
 
 import erpnext
 from erpnext.accounts.doctype.journal_entry.journal_entry import get_balance_on
@@ -90,25 +90,31 @@ class ExchangeRateRevaluation(Document):
 		)
 
 	def on_cancel(self):
-		self.ignore_linked_doctypes = "GL Entry"
+		self.ignore_linked_doctypes = ["GL Entry", "Payment Ledger Entry"]
 
 	@frappe.whitelist()
-	def check_journal_entry_condition(self):
+	def check_journal_and_reversal(self):
 		exchange_gain_loss_account = self.get_for_unrealized_gain_loss_account()
 
+		journals_posted = False
+		reversals_posted = False
+
+		je = qb.DocType("Journal Entry")
 		jea = qb.DocType("Journal Entry Account")
 		journals = (
-			qb.from_(jea)
-			.select(jea.parent)
+			qb.from_(je)
+			.join(jea)
+			.on(je.name == jea.parent)
+			.select(je.name)
 			.distinct()
 			.where(
 				(jea.reference_type == "Exchange Rate Revaluation")
 				& (jea.reference_name == self.name)
 				& (jea.docstatus == 1)
+				& (je.reversal_of.isnull())  # omit journals that have reversals
 			)
-			.run()
+			.run(pluck="name")
 		)
-
 		if journals:
 			gle = qb.DocType("GL Entry")
 			total_amt = (
@@ -123,12 +129,31 @@ class ExchangeRateRevaluation(Document):
 				.run()
 			)
 
-			if total_amt and total_amt[0][0] != self.total_gain_loss:
-				return True
+			if total_amt and total_amt[0][0] == self.total_gain_loss:
+				journals_posted = True
 			else:
-				return False
+				journals_posted = False
 
-		return True
+		# reverse journals
+		reverse_journals = (
+			qb.from_(je)
+			.join(jea)
+			.on(je.name == jea.parent)
+			.select(je.name)
+			.where(
+				(jea.reference_type == "Exchange Rate Revaluation")
+				& (jea.reference_name == self.name)
+				& (jea.docstatus == 1)
+				& (je.reversal_of.notnull())
+			)
+			.run(pluck="name")
+		)
+		if reverse_journals:
+			reversals_posted = True
+		else:
+			reversals_posted = False
+
+		return {"journals_posted": journals_posted, "reversals_posted": reversals_posted}
 
 	def fetch_and_calculate_accounts_data(self):
 		accounts = self.get_accounts_data()
@@ -342,6 +367,7 @@ class ExchangeRateRevaluation(Document):
 
 	@frappe.whitelist()
 	def make_jv_entries(self):
+		frappe.has_permission("Journal Entry", "write", throw=True)
 		zero_balance_jv = self.make_jv_for_zero_balance()
 		if zero_balance_jv:
 			frappe.msgprint(
@@ -571,6 +597,49 @@ class ExchangeRateRevaluation(Document):
 		journal_entry.save()
 		return journal_entry
 
+	@frappe.whitelist()
+	def make_reverse_journal(self):
+		frappe.has_permission("Journal Entry", "write", throw=True)
+		je = qb.DocType("Journal Entry")
+		jea = qb.DocType("Journal Entry Account")
+		journals = (
+			qb.from_(je)
+			.join(jea)
+			.on(je.name == jea.parent)
+			.select(je.name)
+			.distinct()
+			.where(
+				(jea.reference_type == "Exchange Rate Revaluation")
+				& (jea.reference_name == self.name)
+				& (jea.docstatus == 1)
+				& (je.reversal_of.isnull())  # omit journals that have reversals
+			)
+			.run(pluck="name")
+		)
+		if journals:
+			from erpnext.accounts.doctype.journal_entry.journal_entry import make_reverse_journal_entry
+
+			if drafts := frappe.db.get_all(
+				"Journal Entry",
+				filters={"docstatus": 0, "reversal_of": ["in", journals]},
+				pluck="name",
+			):
+				part = "journals are" if len(drafts) > 1 else "journal is"
+				doc_links = ", ".join(["{}".format(get_link_to_form("Journal Entry", x)) for x in drafts])
+				frappe.throw(
+					msg=_("Reverse {0} already available in draft status: {1}").format(part, doc_links),
+				)
+			else:
+				for x in journals:
+					reversal = make_reverse_journal_entry(x)
+					reversal.posting_date = nowdate()
+					reversal.save()
+					frappe.msgprint(
+						_("A draft reverse journal for {0} has been created: {1}").format(
+							frappe.bold(x), get_link_to_form("Journal Entry", reversal.name)
+						)
+					)
+
 
 def calculate_exchange_rate_using_last_gle(company, account, party_type, party):
 	"""

erpnext/accounts/doctype/exchange_rate_revaluation/test_exchange_rate_revaluation.py

@@ -130,7 +130,8 @@ class TestExchangeRateRevaluation(AccountsTestMixin, FrappeTestCase):
 		err = err.save().submit()
 
 		# Create JV for ERR
-		self.assertTrue(err.check_journal_entry_condition())
+		ret = err.check_journal_and_reversal()
+		self.assertFalse(ret.get("journals_posted"))
 		err_journals = err.make_jv_entries()
 		je = frappe.get_doc("Journal Entry", err_journals.get("zero_balance_jv"))
 		je = je.submit()
@@ -213,7 +214,8 @@ class TestExchangeRateRevaluation(AccountsTestMixin, FrappeTestCase):
 		err = err.save().submit()
 
 		# Create JV for ERR
-		self.assertTrue(err.check_journal_entry_condition())
+		ret = err.check_journal_and_reversal()
+		self.assertFalse(ret.get("journals_posted"))
 		err_journals = err.make_jv_entries()
 		je = frappe.get_doc("Journal Entry", err_journals.get("zero_balance_jv"))
 		je = je.submit()
@@ -287,3 +289,91 @@ class TestExchangeRateRevaluation(AccountsTestMixin, FrappeTestCase):
 
 		for key, _val in expected_data.items():
 			self.assertEqual(expected_data.get(key), account_details.get(key))
+
+	@change_settings(
+		"Accounts Settings",
+		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
+	)
+	def test_05_revaluation_journal_reversal(self):
+		"""
+		Test reversing of revaluation journals
+		"""
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debtors_usd,
+			posting_date=today(),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=100,
+			price_list_rate=100,
+			do_not_submit=1,
+		)
+		si.currency = "USD"
+		si.conversion_rate = 80
+		si.save().submit()
+
+		err = frappe.new_doc("Exchange Rate Revaluation")
+		err.company = self.company
+		err.posting_date = today()
+		err.fetch_and_calculate_accounts_data()
+		self.assertEqual(len(err.accounts), 1)
+		err.save().submit()
+
+		gain_loss_account = err.get_for_unrealized_gain_loss_account()
+		usd_account = err.accounts[0].account
+		old_balance = err.accounts[0].balance_in_base_currency
+		new_balance = err.accounts[0].new_balance_in_base_currency
+		total_gain_loss = err.total_gain_loss
+
+		# Create JV for ERR
+		ret = err.check_journal_and_reversal()
+		self.assertFalse(ret.get("journals_posted"))
+		err_journals = err.make_jv_entries()
+		je = frappe.get_doc("Journal Entry", err_journals.get("revaluation_jv"))
+		je = je.submit()
+
+		je.reload()
+		self.assertEqual(je.voucher_type, "Exchange Rate Revaluation")
+		self.assertEqual(len(je.accounts), 3)
+		expected = [
+			(usd_account, new_balance, 0.0, 100.0, 0.0),
+			(usd_account, 0.0, old_balance, 0.0, 100.0),
+			(gain_loss_account, 0.0, total_gain_loss, 0.0, total_gain_loss),
+		]
+		actual = []
+		for acc in je.accounts:
+			actual.append(
+				(
+					acc.account,
+					acc.debit,
+					acc.credit,
+					acc.debit_in_account_currency,
+					acc.credit_in_account_currency,
+				)
+			)
+		self.assertEqual(expected, actual)
+
+		# Assert reversals are not posted
+		ret = err.check_journal_and_reversal()
+		self.assertTrue(ret.get("journals_posted"))
+		self.assertFalse(ret.get("reversals_posted"))
+
+		err.make_reverse_journal()
+		# submit
+		draft = frappe.db.get_all(
+			"Journal Entry",
+			filters={"docstatus": 0, "reversal_of": je.name, "voucher_type": "Exchange Rate Revaluation"},
+			pluck="name",
+		)
+		self.assertIsNotNone(draft)
+		frappe.get_doc("Journal Entry", draft[0]).submit()
+		ret = err.check_journal_and_reversal()
+		self.assertTrue(ret.get("journals_posted"))
+		self.assertTrue(ret.get("reversals_posted"))
+
+		reverse_jv = frappe.db.get_all(
+			"Journal Entry", filters={"reversal_of": err_journals.get("revaluation_jv")}, pluck="name"
+		)
+		self.assertIsNotNone(reverse_jv)

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -40,6 +40,10 @@ frappe.ui.form.on("Journal Entry", {
 	},
 
 	refresh: function (frm) {
+		if (frm.doc.reversal_of && (frm.is_new() || frm.doc.docstatus == 0)) {
+			erpnext.journal_entry.lock_reversal_entry(frm);
+		}
+
 		erpnext.toggle_naming_series();
 
 		if (frm.doc.docstatus > 0) {
@@ -509,6 +513,14 @@ $.extend(erpnext.journal_entry, {
 		});
 	},
 
+	lock_reversal_entry: function (frm) {
+		frm.fields
+			.filter((field) => field.has_input)
+			.filter((field) => field.df.fieldname != "posting_date")
+			.forEach((field) => frm.set_df_property(field.df.fieldname, "read_only", 1));
+		frm.set_df_property("accounts", "read_only", 1);
+	},
+
 	set_debit_credit_in_company_currency: function (frm, cdt, cdn) {
 		var row = locals[cdt][cdn];
 

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -21,6 +21,7 @@ from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger
 from erpnext.accounts.doctype.tax_withholding_category.tax_withholding_category import (
 	get_party_tax_withholding_details,
 )
+from erpnext.accounts.general_ledger import validate_opening_entry_against_pcv
 from erpnext.accounts.party import get_party_account
 from erpnext.accounts.utils import (
 	cancel_exchange_gain_loss_journal,
@@ -123,6 +124,9 @@ class JournalEntry(AccountsController):
 		if not self.is_opening:
 			self.is_opening = "No"
 
+		if self.is_opening == "Yes":
+			validate_opening_entry_against_pcv(self.company)
+
 		self.clearance_date = None
 
 		self.validate_party()

erpnext/accounts/doctype/journal_entry/journal_entry_list.js

@@ -1,12 +1,15 @@
 frappe.listview_settings["Journal Entry"] = {
-	add_fields: ["voucher_type", "posting_date", "total_debit", "company", "user_remark"],
+	add_fields: ["voucher_type", "posting_date", "total_debit", "company", "user_remark", "reversal_of"],
 	get_indicator: function (doc) {
 		if (doc.docstatus == 0) {
 			return [__("Draft", "red", "docstatus,=,0")];
 		} else if (doc.docstatus == 2) {
 			return [__("Cancelled", "grey", "docstatus,=,2")];
-		} else {
-			return [__(doc.voucher_type), "blue", "voucher_type,=," + doc.voucher_type];
+		} else if (doc.docstatus === 1) {
+			if (doc.reversal_of && doc.voucher_type == "Exchange Rate Revaluation") {
+				return [__("Reversal Of Exchange Rate Revaluation"), "blue"];
+			}
+			return [__(doc.voucher_type), "blue", `voucher_type,=,${doc.voucher_type}`];
 		}
 	},
 };

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js

@@ -24,15 +24,22 @@ frappe.ui.form.on("Opening Invoice Creation Tool", {
 				setTimeout(
 					() => {
 						frm.doc.import_in_progress = false;
-						frm.clear_table("invoices");
-						frm.refresh_fields();
 						frm.page.clear_indicator();
 						frm.dashboard.hide_progress();
 
-						if (frm.doc.invoice_type == "Sales") {
-							frappe.msgprint(__("Opening Sales Invoices have been created."));
+						if (!data.errors) {
+							frm.clear_table("invoices");
+							frm.refresh_fields();
+							const message =
+								frm.doc.invoice_type == "Sales"
+									? __("Opening Sales Invoice(s) have been created.")
+									: __("Opening Purchase Invoice(s) have been created.");
+							frappe.show_alert({
+								message: message,
+								indicator: "green",
+							});
 						} else {
-							frappe.msgprint(__("Opening Purchase Invoices have been created."));
+							frm.refresh_fields();
 						}
 					},
 					1500,
@@ -75,29 +82,31 @@ frappe.ui.form.on("Opening Invoice Creation Tool", {
 	},
 
 	setup_company_filters: function (frm) {
-		frm.set_query("cost_center", "invoices", function (doc, cdt, cdn) {
-			return {
-				filters: {
-					company: doc.company,
-				},
-			};
+		frm.events.apply_company_query_filter(frm, "cost_center", "invoices", { is_group: 0 });
+		frm.events.apply_company_query_filter(frm, "project", "invoices");
+		frm.events.apply_company_query_filter(frm, "project");
+		frm.events.apply_company_query_filter(frm, "cost_center", undefined, { is_group: 0 });
+		frm.events.apply_company_query_filter(frm, "temporary_opening_account", "invoices", {
+			account_type: "Temporary",
+			is_group: 0,
 		});
+	},
 
-		frm.set_query("cost_center", function (doc) {
+	apply_company_query_filter: function (frm, field_name, child_doctype = null, filters = {}) {
+		const query = function (doc) {
 			return {
 				filters: {
 					company: doc.company,
+					...filters,
 				},
 			};
-		});
+		};
 
-		frm.set_query("temporary_opening_account", "invoices", function (doc, cdt, cdn) {
-			return {
-				filters: {
-					company: doc.company,
-				},
-			};
-		});
+		if (child_doctype) {
+			frm.set_query(field_name, child_doctype, query);
+		} else {
+			frm.set_query(field_name, query);
+		}
 	},
 
 	company: function (frm) {
@@ -121,10 +130,7 @@ frappe.ui.form.on("Opening Invoice Creation Tool", {
 	},
 
 	invoice_type: function (frm) {
-		$.each(frm.doc.invoices, (idx, row) => {
-			row.party_type = frm.doc.invoice_type == "Sales" ? "Customer" : "Supplier";
-			row.party = "";
-		});
+		frm.clear_table("invoices");
 		frm.refresh_fields();
 	},
 
@@ -165,7 +171,19 @@ frappe.ui.form.on("Opening Invoice Creation Tool", {
 });
 
 frappe.ui.form.on("Opening Invoice Creation Tool Item", {
-	invoices_add: (frm) => {
+	invoices_add: (frm, cdt, cdn) => {
+		const row = frappe.get_doc(cdt, cdn);
+		const field_copy = [];
+
+		["project", "cost_center"].forEach((fieldname) => {
+			if (frm.doc[fieldname]) {
+				frappe.model.set_value(cdt, cdn, fieldname, frm.doc[fieldname]);
+			} else {
+				field_copy.push(fieldname);
+			}
+		});
+
+		frm.script_manager.copy_from_first_row("invoices", row, field_copy);
 		frm.trigger("update_invoice_table");
 	},
 });

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py

@@ -122,6 +122,17 @@ class OpeningInvoiceCreationTool(Document):
 			if not row.get(scrub(d)):
 				frappe.throw(mandatory_error_msg.format(row.idx, d, self.invoice_type))
 
+		self.validate_temporary_opening_account(row)
+
+	def validate_temporary_opening_account(self, row):
+		account_type = frappe.get_cached_value("Account", row.temporary_opening_account, "account_type")
+		if account_type != "Temporary":
+			frappe.throw(
+				_("Row #{0}: {1} account is not of type {2}").format(
+					row.idx, row.temporary_opening_account, "Temporary"
+				)
+			)
+
 	def get_invoices(self):
 		invoices = []
 		for row in self.invoices:
@@ -191,6 +202,7 @@ class OpeningInvoiceCreationTool(Document):
 					"description": row.item_name or "Opening Invoice Item",
 					income_expense_account_field: row.temporary_opening_account,
 					"cost_center": cost_center,
+					"project": row.get("project") or self.get("project"),
 				}
 			)
 
@@ -254,22 +266,32 @@ class OpeningInvoiceCreationTool(Document):
 def start_import(invoices):
 	errors = 0
 	names = []
+	total = len(invoices)
 	for idx, d in enumerate(invoices):
+		# Scope each invoice to a savepoint so a failure only undoes that invoice.
+		# A plain rollback() would discard the whole transaction — including invoices
+		# imported earlier in this batch and the error logs of earlier failures (the
+		# latter only survive on mariadb because the Error Log table is MyISAM; on
+		# postgres they would be lost). Rolling back to a savepoint keeps both.
+		savepoint = f"opening_invoice_{frappe.generate_hash(length=8)}"
+		frappe.db.savepoint(savepoint)
+		is_last = idx == total - 1
 		try:
 			invoice_number = None
 			if d.invoice_number:
 				invoice_number = d.invoice_number
-			publish(idx, len(invoices), d.doctype)
 			doc = frappe.get_doc(d)
 			doc.flags.ignore_mandatory = True
 			doc.insert(set_name=invoice_number)
 			doc.submit()
 			frappe.db.commit()
 			names.append(doc.name)
+			publish(idx, total, d.doctype, errors=errors if is_last else None)
 		except Exception:
 			errors += 1
 			frappe.db.rollback()
 			doc.log_error("Opening invoice creation failed")
+			publish(idx, total, d.doctype, errors=errors if is_last else None)
 	if errors:
 		frappe.msgprint(
 			_("You had {} errors while creating opening invoices. Check {} for more details").format(
@@ -281,7 +303,7 @@ def start_import(invoices):
 	return names
 
 
-def publish(index, total, doctype):
+def publish(index, total, doctype, errors=None):
 	frappe.publish_realtime(
 		"opening_invoice_creation_progress",
 		dict(
@@ -289,6 +311,7 @@ def publish(index, total, doctype):
 			message=_("Creating {} out of {} {}").format(index + 1, total, doctype),
 			count=index + 1,
 			total=total,
+			errors=errors,
 		),
 		user=frappe.session.user,
 	)

erpnext/accounts/doctype/opening_invoice_creation_tool/test_opening_invoice_creation_tool.py

@@ -3,6 +3,7 @@
 
 import frappe
 from frappe.tests.utils import FrappeTestCase
+from frappe.utils import add_days, today
 
 from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension import (
 	create_dimension,
@@ -11,6 +12,7 @@ from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension imp
 from erpnext.accounts.doctype.opening_invoice_creation_tool.opening_invoice_creation_tool import (
 	get_temporary_opening_account,
 )
+from erpnext.projects.doctype.project.test_project import make_project
 
 test_dependencies = ["Customer", "Supplier", "Accounting Dimension"]
 
@@ -27,21 +29,26 @@ class TestOpeningInvoiceCreationTool(FrappeTestCase):
 		self,
 		invoice_type="Sales",
 		company=None,
-		party_1=None,
-		party_2=None,
-		invoice_number=None,
+		invoices=None,
+		project=None,
+		cost_center=None,
 		department=None,
+		return_doc=False,
 	):
 		doc = frappe.get_single("Opening Invoice Creation Tool")
 		args = get_opening_invoice_creation_dict(
 			invoice_type=invoice_type,
 			company=company,
-			party_1=party_1,
-			party_2=party_2,
-			invoice_number=invoice_number,
+			invoices=invoices,
+			project=project,
+			cost_center=cost_center,
 			department=department,
 		)
 		doc.update(args)
+
+		if return_doc:
+			return doc
+
 		return doc.make_invoices()
 
 	def test_opening_sales_invoice_creation(self):
@@ -50,8 +57,8 @@ class TestOpeningInvoiceCreationTool(FrappeTestCase):
 		self.assertEqual(len(invoices), 2)
 		expected_value = {
 			"keys": ["customer", "outstanding_amount", "status"],
-			0: ["_Test Customer", 300, "Overdue"],
-			1: ["_Test Customer 1", 250, "Overdue"],
+			0: ["_Test Customer", 200, "Overdue"],
+			1: ["_Test Customer 1", 200, "Overdue"],
 		}
 		self.check_expected_values(invoices, expected_value)
 
@@ -68,48 +75,34 @@ class TestOpeningInvoiceCreationTool(FrappeTestCase):
 			for field_idx, field in enumerate(expected_value["keys"]):
 				self.assertEqual(si.get(field, ""), expected_value[invoice_idx][field_idx])
 
+	def test_opening_invoice_requires_temporary_account_type(self):
+		doc = self.make_invoices(company="_Test Opening Invoice Company", return_doc=True)
+		doc.invoices[0].temporary_opening_account = "Sales - _TOIC"
+		self.assertRaises(frappe.ValidationError, doc.make_invoices)
+
 	def test_opening_purchase_invoice_creation(self):
 		invoices = self.make_invoices(invoice_type="Purchase", company="_Test Opening Invoice Company")
 
 		self.assertEqual(len(invoices), 2)
 		expected_value = {
 			"keys": ["supplier", "outstanding_amount", "status"],
-			0: ["_Test Supplier", 300, "Overdue"],
-			1: ["_Test Supplier 1", 250, "Overdue"],
+			0: ["_Test Supplier", 200, "Overdue"],
+			1: ["_Test Supplier 1", 200, "Overdue"],
 		}
 		self.check_expected_values(invoices, expected_value, "Purchase")
 
 	def test_opening_sales_invoice_creation_with_missing_debit_account(self):
-		company = "_Test Opening Invoice Company"
 		party_1, party_2 = make_customer("Customer A"), make_customer("Customer B")
 
-		old_default_receivable_account = frappe.db.get_value("Company", company, "default_receivable_account")
-		frappe.db.set_value("Company", company, "default_receivable_account", "")
+		old_default_receivable_account = frappe.db.get_value(
+			"Company", "_Test Opening Invoice Company", "default_receivable_account"
+		)
+		frappe.db.set_value("Company", "_Test Opening Invoice Company", "default_receivable_account", "")
 
-		if not frappe.db.exists("Cost Center", "_Test Opening Invoice Company - _TOIC"):
-			cc = frappe.get_doc(
-				{
-					"doctype": "Cost Center",
-					"cost_center_name": "_Test Opening Invoice Company",
-					"is_group": 1,
-					"company": "_Test Opening Invoice Company",
-				}
-			)
-			cc.insert(ignore_mandatory=True)
-			cc2 = frappe.get_doc(
-				{
-					"doctype": "Cost Center",
-					"cost_center_name": "Main",
-					"is_group": 0,
-					"company": "_Test Opening Invoice Company",
-					"parent_cost_center": cc.name,
-				}
-			)
-			cc2.insert()
-
-		frappe.db.set_value("Company", company, "cost_center", "Main - _TOIC")
-
-		self.make_invoices(company="_Test Opening Invoice Company", party_1=party_1, party_2=party_2)
+		self.make_invoices(
+			company="_Test Opening Invoice Company",
+			invoices=[{"party": party_1}, {"party": party_2}],
+		)
 
 		# Check if missing debit account error raised
 		error_log = frappe.db.exists(
@@ -119,74 +112,113 @@ class TestOpeningInvoiceCreationTool(FrappeTestCase):
 		self.assertTrue(error_log)
 
 		# teardown
-		frappe.db.set_value("Company", company, "default_receivable_account", old_default_receivable_account)
-
-	def test_renaming_of_invoice_using_invoice_number_field(self):
-		company = "_Test Opening Invoice Company"
-		party_1, party_2 = make_customer("Customer A"), make_customer("Customer B")
-		self.make_invoices(
-			company=company, party_1=party_1, party_2=party_2, invoice_number="TEST-NEW-INV-11"
+		frappe.db.set_value(
+			"Company",
+			"_Test Opening Invoice Company",
+			"default_receivable_account",
+			old_default_receivable_account,
 		)
 
-		sales_inv1 = frappe.get_all("Sales Invoice", filters={"customer": "Customer A"})[0].get("name")
-		sales_inv2 = frappe.get_all("Sales Invoice", filters={"customer": "Customer B"})[0].get("name")
-		self.assertEqual(sales_inv1, "TEST-NEW-INV-11")
+	def test_renaming_of_invoice_using_invoice_number_field(self):
+		party_1, party_2 = make_customer("Customer A"), make_customer("Customer B")
+		inv_num = f"TEST-NEW-INV-{frappe.generate_hash(length=8)}"
+		invoices = self.make_invoices(
+			company="_Test Opening Invoice Company",
+			invoices=[
+				{"party": party_1, "invoice_number": inv_num},
+				{"party": party_2},
+			],
+		)
 
-		# teardown
-		for inv in [sales_inv1, sales_inv2]:
-			doc = frappe.get_doc("Sales Invoice", inv)
-			doc.cancel()
+		self.assertEqual(invoices[0], inv_num)
 
 	def test_opening_invoice_with_accounting_dimension(self):
 		invoices = self.make_invoices(
 			invoice_type="Sales", company="_Test Opening Invoice Company", department="Sales - _TOIC"
 		)
 
-		expected_value = {
-			"keys": ["customer", "outstanding_amount", "status", "department"],
-			0: ["_Test Customer", 300, "Overdue", "Sales - _TOIC"],
-			1: ["_Test Customer 1", 250, "Overdue", "Sales - _TOIC"],
-		}
-		self.check_expected_values(invoices, expected_value, invoice_type="Sales")
+		for invoice in invoices:
+			self.assertEqual(frappe.db.get_value("Sales Invoice", invoice, "department"), "Sales - _TOIC")
 
-	def tearDown(self):
+	def test_opening_entry_project_linking(self):
+		doc = self.make_invoices(
+			company="_Test Opening Invoice Company", invoice_type="Sales", return_doc=True
+		)
+		project_1 = make_project(
+			{"project_name": "Test Opening Invoice projecty 01", "company": "_Test Opening Invoice Company"}
+		)
+		project_2 = make_project(
+			{"project_name": "Test Opening Invoice projecty 02", "company": "_Test Opening Invoice Company"}
+		)
+		doc.invoices[0].project = project_1.name
+		doc.invoices[1].project = project_2.name
+		invoices = doc.make_invoices()
+		sales_invoice_1 = frappe.get_doc("Sales Invoice", invoices[0])
+		sales_invoice_2 = frappe.get_doc("Sales Invoice", invoices[1])
+
+		self.assertEqual(sales_invoice_1.items[0].project, project_1.name)
+		self.assertEqual(sales_invoice_2.items[0].project, project_2.name)
+
+	@classmethod
+	def tearDownClass(cls):
 		disable_dimension()
+		super().tearDownClass()
 
 
 def get_opening_invoice_creation_dict(**args):
 	party = "Customer" if args.get("invoice_type", "Sales") == "Sales" else "Supplier"
 	company = args.get("company", "_Test Company")
+	default_invoices = []
+	default_invoice_rows = [
+		{
+			"qty": 1.0,
+			"outstanding_amount": 200,
+			"party": f"_Test {party}",
+			"item_name": "Opening Item",
+			"due_date": add_days(today(), -10),
+			"posting_date": add_days(today(), -15),
+			"temporary_opening_account": get_temporary_opening_account(company),
+		},
+		{
+			"qty": 1.0,
+			"outstanding_amount": 200,
+			"party": f"_Test {party} 1",
+			"item_name": "Opening Item",
+			"due_date": add_days(today(), -10),
+			"posting_date": add_days(today(), -15),
+			"temporary_opening_account": get_temporary_opening_account(company),
+		},
+	]
+
+	for row in args.get("invoices") or default_invoice_rows:
+		default_invoices.append(
+			{
+				"qty": row.get("qty") or 1.0,
+				"outstanding_amount": row.get("outstanding_amount") or 200,
+				"party": row.get("party") or f"_Test {party}",
+				"item_name": row.get("item_name") or "Opening Item",
+				"due_date": row.get("due_date") or add_days(today(), -10),
+				"posting_date": row.get("posting_date") or add_days(today(), -15),
+				"temporary_opening_account": row.get("temporary_opening_account")
+				or get_temporary_opening_account(company),
+				"invoice_number": row.get("invoice_number"),
+				"project": row.get("project"),
+				"cost_center": row.get("cost_center"),
+			}
+		)
 
 	invoice_dict = frappe._dict(
 		{
 			"company": company,
 			"invoice_type": args.get("invoice_type", "Sales"),
-			"invoices": [
-				{
-					"qty": 1.0,
-					"outstanding_amount": 300,
-					"party": args.get("party_1") or f"_Test {party}",
-					"item_name": "Opening Item",
-					"due_date": "2016-09-10",
-					"posting_date": "2016-09-05",
-					"temporary_opening_account": get_temporary_opening_account(company),
-					"invoice_number": args.get("invoice_number"),
-				},
-				{
-					"qty": 2.0,
-					"outstanding_amount": 250,
-					"party": args.get("party_2") or f"_Test {party} 1",
-					"item_name": "Opening Item",
-					"due_date": "2016-09-10",
-					"posting_date": "2016-09-05",
-					"temporary_opening_account": get_temporary_opening_account(company),
-					"invoice_number": None,
-				},
-			],
+			"project": args.get("project"),
+			"cost_center": args.get("cost_center"),
+			"invoices": default_invoices,
 		}
 	)
 
 	invoice_dict.update(args)
+	invoice_dict.invoices = default_invoices
 	return invoice_dict
 
 

erpnext/accounts/doctype/opening_invoice_creation_tool_item/opening_invoice_creation_tool_item.json

@@ -19,7 +19,8 @@
   "qty",
   "accounting_dimensions_section",
   "cost_center",
-  "dimension_col_break"
+  "dimension_col_break",
+  "project"
  ],
  "fields": [
   {
@@ -79,6 +80,7 @@
    "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Outstanding Amount",
+   "options": "Company:company:default_currency",
    "reqd": 1
   },
   {
@@ -111,11 +113,17 @@
    "fieldname": "invoice_number",
    "fieldtype": "Data",
    "label": "Invoice Number"
+  },
+  {
+   "fieldname": "project",
+   "fieldtype": "Link",
+   "label": "Project",
+   "options": "Project"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2022-03-21 19:31:45.382656",
+ "modified": "2026-07-03 15:17:11.938499",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Opening Invoice Creation Tool Item",
@@ -126,4 +134,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/opening_invoice_creation_tool_item/opening_invoice_creation_tool_item.py

@@ -25,6 +25,7 @@ class OpeningInvoiceCreationToolItem(Document):
 		party: DF.DynamicLink
 		party_type: DF.Link | None
 		posting_date: DF.Date | None
+		project: DF.Link | None
 		qty: DF.Data | None
 		temporary_opening_account: DF.Link | None
 	# end: auto-generated types

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -2691,6 +2691,9 @@ def get_party_details(company, party_type, party, date, cost_center=None):
 	if not frappe.db.exists(party_type, party):
 		frappe.throw(_("{0} {1} does not exist").format(_(party_type), party))
 
+	ptype = "select" if frappe.only_has_select_perm(party_type) else "read"
+	frappe.has_permission(party_type, ptype, party, throw=True)
+
 	party_account = get_party_account(party_type, party, company)
 	account_currency = get_account_currency(party_account)
 	account_balance = (
@@ -2707,7 +2710,7 @@ def get_party_details(company, party_type, party, date, cost_center=None):
 	)
 	if party_type in ["Customer", "Supplier"]:
 		party_bank_account = get_party_bank_account(party_type, party)
-		bank_account = get_default_company_bank_account(company, party_type, party)
+		bank_account = get_default_company_bank_account(company, party_type, party, ignore_permissions=False)
 
 	return {
 		"party_account": party_account,
@@ -2808,9 +2811,7 @@ def get_reference_details(
 			exchange_rate = get_exchange_rate(party_account_currency, company_currency, ref_doc.posting_date)
 		else:
 			exchange_rate = 1
-			outstanding_amount, total_amount = get_outstanding_on_journal_entry(
-				reference_name, party_type, party
-			)
+		outstanding_amount, total_amount = get_outstanding_on_journal_entry(reference_name, party_type, party)
 
 	elif reference_doctype == "Payment Entry":
 		if reverse_payment_details := frappe.db.get_all(

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -796,10 +796,17 @@ class PaymentReconciliation(Document):
 
 
 def reconcile_dr_cr_note(dr_cr_notes, company, active_dimensions=None):
+	allocated_amount_precision = get_field_precision(
+		frappe.get_meta("Payment Reconciliation Allocation").get_field("allocated_amount")
+	)
 	for inv in dr_cr_notes:
 		if (
-			abs(frappe.db.get_value(inv.voucher_type, inv.voucher_no, "outstanding_amount"))
-			< inv.allocated_amount
+			flt(
+				abs(frappe.db.get_value(inv.voucher_type, inv.voucher_no, "outstanding_amount"))
+				- inv.allocated_amount,
+				allocated_amount_precision,
+			)
+			< 0
 		):
 			frappe.throw(
 				_("{0} has been modified after you pulled it. Please pull it again.").format(inv.voucher_type)

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -155,6 +155,7 @@ class TestPaymentReconciliation(FrappeTestCase):
 		sinv = create_sales_invoice(
 			qty=qty,
 			rate=rate,
+			posting_date=posting_date,
 			company=self.company,
 			customer=self.customer,
 			item_code=self.item,
@@ -2146,7 +2147,7 @@ class TestPaymentReconciliation(FrappeTestCase):
 		pr.reconcile()
 
 		si.reload()
-		self.assertEqual(si.status, "Partly Paid")
+		self.assertEqual(si.status, "Overdue")
 		# check PR tool output post reconciliation
 		self.assertEqual(len(pr.get("invoices")), 1)
 		self.assertEqual(pr.get("invoices")[0].get("outstanding_amount"), 120)
@@ -2540,6 +2541,76 @@ class TestPaymentReconciliation(FrappeTestCase):
 		self.assertEqual(flt(pr.allocation[0].difference_amount), 5000.0)
 		pr.reconcile()
 
+	def test_cr_note_split_across_invoices_floating_point_precision(self):
+		"""Regression: when a credit note is split across multiple invoices, floating-point
+		arithmetic (150 - 8.45 - 90.72 = 50.83000000000001) must not cause reconcile() to fail.
+
+		The test environment rounds INR totals to whole rupees (smallest_currency_fraction_value=0),
+		so the invoices are created with round-number totals (100, 200, 100) and then partially paid
+		down to the decimal outstanding amounts (8.45, 90.72, 72.57) via payment entries.
+		"""
+		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+
+		# Create invoices on different posting dates to control sort-order in Payment Reconciliation
+		# (invoices are sorted by posting_date ascending, so si_a is processed first).
+		# Processing order 8.45 → 90.72 → 72.57 produces the float chain:
+		#   150 - 8.45 = 141.55  →  141.55 - 90.72 = 50.83000000000001
+		# The last allocation row will therefore carry allocated_amount = 50.83000000000001.
+		si_a = self.create_sales_invoice(qty=1, rate=100, posting_date=add_days(nowdate(), -2))
+		si_b = self.create_sales_invoice(qty=1, rate=200, posting_date=add_days(nowdate(), -1))
+		si_c = self.create_sales_invoice(qty=1, rate=100, posting_date=nowdate())
+
+		# Partially pay each invoice so the remaining outstanding is a clean decimal value.
+		# INR rounds the invoice total to a whole rupee, so we achieve decimal outstandings
+		# by subtracting a decimal-valued payment from the integer total:
+		#   100 - 91.55 = 8.45
+		#   200 - 109.28 = 90.72
+		#   100 - 27.43 = 72.57
+		for si, partial_paid in ((si_a, 91.55), (si_b, 109.28), (si_c, 27.43)):
+			pe = get_payment_entry(si.doctype, si.name)
+			pe.paid_amount = partial_paid
+			pe.received_amount = partial_paid
+			pe.references[0].allocated_amount = partial_paid
+			pe.save().submit()
+
+		cr_note = self.create_sales_invoice(
+			qty=-1, rate=150, posting_date=nowdate(), do_not_save=True, do_not_submit=True
+		)
+		cr_note.is_return = 1
+		cr_note = cr_note.save().submit()
+
+		pr = self.create_payment_reconciliation()
+		# Widen date range so all three invoices (oldest is -2 days) are fetched
+		pr.from_invoice_date = add_days(nowdate(), -2)
+		pr.to_invoice_date = nowdate()
+		pr.from_payment_date = nowdate()
+		pr.to_payment_date = nowdate()
+
+		pr.get_unreconciled_entries()
+		self.assertEqual(len(pr.invoices), 3)
+		self.assertEqual(len(pr.payments), 1)
+
+		invoices = [x.as_dict() for x in pr.invoices]
+		payments = [x.as_dict() for x in pr.payments]
+		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+
+		# Credit note (150) covers all of si_a (8.45) and si_b (90.72), then partially si_c
+		self.assertEqual(len(pr.allocation), 3)
+		last_row = pr.allocation[-1]
+		# Last allocated amount should be ~50.83 (possibly 50.83000000000001 due to float arithmetic)
+		self.assertAlmostEqual(flt(last_row.allocated_amount), 50.83, places=2)
+
+		# reconcile() must not raise "has been modified after you pulled it" due to float imprecision
+		pr.reconcile()
+
+		si_a.reload()
+		si_b.reload()
+		si_c.reload()
+		self.assertEqual(si_a.outstanding_amount, 0)
+		self.assertEqual(si_b.outstanding_amount, 0)
+		# si_c is only partially settled: 72.57 - 50.83 = 21.74
+		self.assertAlmostEqual(si_c.outstanding_amount, 21.74, places=2)
+
 
 def make_customer(customer_name, currency=None):
 	if not frappe.db.exists("Customer", customer_name):

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -367,6 +367,7 @@ class PaymentRequest(Document):
 			bank_amount=bank_amount,
 			created_from_payment_request=True,
 		)
+		payment_entry.set_missing_ref_details(force=True)
 
 		payment_entry.update(
 			{
@@ -834,6 +835,7 @@ def resend_payment_email(docname):
 @frappe.whitelist()
 def make_payment_entry(docname):
 	doc = frappe.get_doc("Payment Request", docname)
+	doc.check_permission("read")
 	return doc.create_payment_entry(submit=False).as_dict()
 
 

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -618,6 +618,22 @@ class TestPaymentRequest(FrappeTestCase):
 		pi.load_from_db()
 		self.assertEqual(pr_2.grand_total, pi.outstanding_amount)
 
+	def test_payment_entry_reference_details_fetched_from_invoice(self):
+		pi = make_purchase_invoice(currency="INR", qty=1, rate=94500)
+		pi.submit()
+
+		pr = make_payment_request(dt="Purchase Invoice", dn=pi.name, mute_email=1, submit_doc=0, return_doc=1)
+		pr.grand_total = 94000
+		pr.submit()
+
+		pe = pr.create_payment_entry(submit=False)
+
+		self.assertEqual(pe.references[0].reference_name, pi.name)
+		self.assertEqual(pe.references[0].total_amount, pi.grand_total)
+		self.assertEqual(pe.references[0].outstanding_amount, pi.outstanding_amount)
+		self.assertEqual(pe.references[0].allocated_amount, 94000)
+		self.assertEqual(pe.paid_amount, 94000)
+
 	def test_consider_journal_entry_and_return_invoice(self):
 		from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -379,12 +379,15 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 
 		self.make_period_closing_voucher(posting_date="2021-03-31")
 
-		# Passed posting_date is after PCV end date, so cancellation should not fail.
-		make_reverse_gl_entries(
-			voucher_type="Journal Entry",
-			voucher_no=jv.name,
-			posting_date="2022-01-01",
-		)
+		frappe.db.set_single_value("Accounts Settings", "acc_frozen_upto", "2021-12-31")
+
+		try:
+			make_reverse_gl_entries(
+				voucher_type="Journal Entry",
+				voucher_no=jv.name,
+			)
+		finally:
+			frappe.db.set_single_value("Accounts Settings", "acc_frozen_upto", None)
 
 		totals_after_cancel = frappe.db.sql(
 			"""

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -156,6 +156,24 @@ class PricingRule(Document):
 			if len(values) != len(set(values)):
 				frappe.throw(_("Duplicate {0} found in the table").format(self.apply_on))
 
+			if self.apply_on == "Item Code":
+				self.validate_template_with_variant(values)
+
+	def validate_template_with_variant(self, item_codes):
+		# throws if a template and its variant both exist in one rule
+		variants = frappe.get_all(
+			"Item",
+			filters={"name": ("in", item_codes), "variant_of": ("in", item_codes)},
+			fields=["name", "variant_of"],
+		)
+		if variants:
+			variant = variants[0]
+			frappe.throw(
+				_("Variant {0} and its template {1} cannot both be added to the same Pricing Rule").format(
+					frappe.bold(variant.name), frappe.bold(variant.variant_of)
+				)
+			)
+
 	def validate_mandatory(self):
 		if self.has_priority and not self.priority:
 			throw(_("Priority is mandatory"), frappe.MandatoryError, _("Please Set Priority"))

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -336,6 +336,31 @@ class TestPricingRule(FrappeTestCase):
 		details = get_item_details(args)
 		self.assertEqual(details.get("discount_percentage"), 17.5)
 
+	def test_pricing_rule_with_template_and_its_variant(self):
+		if not frappe.db.exists("Item", "Test Variant PRT"):
+			variant = frappe.new_doc("Item")
+			variant.item_code = "Test Variant PRT"
+			variant.item_name = "Test Variant PRT"
+			variant.item_group = "_Test Item Group"
+			variant.is_stock_item = 1
+			variant.variant_of = "_Test Variant Item"
+			variant.stock_uom = "_Test UOM"
+			variant.append("attributes", {"attribute": "Test Size", "attribute_value": "Medium"})
+			variant.insert()
+
+		rule = frappe.new_doc("Pricing Rule")
+		rule.title = "_Test Pricing Rule Template Variant"
+		rule.apply_on = "Item Code"
+		rule.currency = "USD"
+		rule.selling = 1
+		rule.rate_or_discount = "Discount Percentage"
+		rule.discount_percentage = 10
+		rule.company = "_Test Company"
+		rule.append("items", {"item_code": "_Test Variant Item"})
+		rule.append("items", {"item_code": "Test Variant PRT"})
+
+		self.assertRaises(frappe.ValidationError, rule.insert)
+
 	def test_pricing_rule_for_stock_qty(self):
 		test_record = {
 			"doctype": "Pricing Rule",

erpnext/accounts/doctype/process_period_closing_voucher/process_period_closing_voucher.py

@@ -86,50 +86,55 @@ class ProcessPeriodClosingVoucher(Document):
 		cancel_pcv_processing(self.name)
 
 
+def initialize_parallel_threads(docname: str):
+	threads = 4
+	timeout = frappe.db.get_single_value("Accounts Settings", "pcv_job_timeout") or 3600
+	ppcvd = qb.DocType("Process Period Closing Voucher Detail")
+
+	frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Running")
+
+	if normal_balances := (
+		qb.from_(ppcvd)
+		.select(ppcvd.name, ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
+		.where(ppcvd.parent.eq(docname) & ppcvd.status.eq("Queued"))
+		.orderby(ppcvd.parentfield, ppcvd.idx, ppcvd.processing_date)
+		.limit(threads)
+		.for_update(skip_locked=True)
+		.run(as_dict=True)
+	):
+		if not is_scheduler_inactive():
+			for x in normal_balances:
+				frappe.db.set_value(
+					"Process Period Closing Voucher Detail",
+					x.name,
+					"status",
+					"Running",
+				)
+				frappe.enqueue(
+					method="erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.process_individual_date",
+					queue="long",
+					timeout=timeout,
+					is_async=True,
+					enqueue_after_commit=True,
+					docname=docname,
+					row_name=x.name,
+					date=x.processing_date,
+					report_type=x.report_type,
+					parentfield=x.parentfield,
+				)
+			# keep transaction on PPCV and PPCVD short
+			# prevents concurrency errors - REPEATABLE READ
+			if not frappe.flags.in_test:
+				frappe.db.commit()  # nosemgrep
+	else:
+		frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Completed")
+
+
 @frappe.whitelist()
 def start_pcv_processing(docname: str):
 	if frappe.db.get_value("Process Period Closing Voucher", docname, "status") in ["Queued", "Running"]:
-		frappe.has_permission("Process Payment Reconciliation", "write", doc=docname, throw=True)
-		frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Running")
-
-		timeout = frappe.db.get_single_value("Accounts Settings", "pcv_job_timeout") or 3600
-
-		ppcvd = qb.DocType("Process Period Closing Voucher Detail")
-		if normal_balances := (
-			qb.from_(ppcvd)
-			.select(ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
-			.where(ppcvd.parent.eq(docname) & ppcvd.status.eq("Queued"))
-			.orderby(ppcvd.parentfield, ppcvd.idx, ppcvd.processing_date)
-			.limit(4)
-			.for_update(skip_locked=True)
-			.run(as_dict=True)
-		):
-			if not is_scheduler_inactive():
-				for x in normal_balances:
-					frappe.db.set_value(
-						"Process Period Closing Voucher Detail",
-						{
-							"processing_date": x.processing_date,
-							"parent": docname,
-							"report_type": x.report_type,
-							"parentfield": x.parentfield,
-						},
-						"status",
-						"Running",
-					)
-					frappe.enqueue(
-						method="erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.process_individual_date",
-						queue="long",
-						timeout=timeout,
-						is_async=True,
-						enqueue_after_commit=True,
-						docname=docname,
-						date=x.processing_date,
-						report_type=x.report_type,
-						parentfield=x.parentfield,
-					)
-		else:
-			frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Completed")
+		frappe.has_permission("Process Period Closing Voucher", "write", doc=docname, throw=True)
+		initialize_parallel_threads(docname)
 
 
 @frappe.whitelist()
@@ -247,11 +252,11 @@ def get_gle_for_closing_account(pcv, dimension_balance, dimensions):
 @frappe.whitelist()
 def schedule_next_date(docname: str):
 	timeout = frappe.db.get_single_value("Accounts Settings", "pcv_job_timeout") or 3600
-
 	ppcvd = qb.DocType("Process Period Closing Voucher Detail")
+
 	if to_process := (
 		qb.from_(ppcvd)
-		.select(ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
+		.select(ppcvd.name, ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
 		.where(ppcvd.parent.eq(docname) & ppcvd.status.eq("Queued"))
 		.orderby(ppcvd.parentfield, ppcvd.idx, ppcvd.processing_date)
 		.limit(1)
@@ -261,15 +266,15 @@ def schedule_next_date(docname: str):
 		if not is_scheduler_inactive():
 			frappe.db.set_value(
 				"Process Period Closing Voucher Detail",
-				{
-					"processing_date": to_process[0].processing_date,
-					"parent": docname,
-					"report_type": to_process[0].report_type,
-					"parentfield": to_process[0].parentfield,
-				},
+				to_process[0].name,
 				"status",
 				"Running",
 			)
+			# keep transaction on PPCV and PPCVD short
+			# prevents concurrency errors - REPEATABLE READ
+			if not frappe.flags.in_test:
+				frappe.db.commit()  # nosemgrep
+
 			frappe.enqueue(
 				method="erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.process_individual_date",
 				queue="long",
@@ -277,6 +282,7 @@ def schedule_next_date(docname: str):
 				is_async=True,
 				enqueue_after_commit=True,
 				docname=docname,
+				row_name=to_process[0].name,
 				date=to_process[0].processing_date,
 				report_type=to_process[0].report_type,
 				parentfield=to_process[0].parentfield,
@@ -441,6 +447,11 @@ def summarize_and_post_ledger_entries(docname):
 
 	make_closing_entries(closing_entries, pcv.name, pcv.company, pcv.period_end_date)
 
+	# keep transaction on PPCV and PPCVD short
+	# prevents concurrency errors - REPEATABLE READ
+	if not frappe.flags.in_test:
+		frappe.db.commit()  # nosemgrep
+
 	frappe.db.set_value("Period Closing Voucher", pcv.name, "gle_processing_status", "Completed")
 	frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Completed")
 
@@ -526,10 +537,10 @@ def build_dimension_wise_balance_dict(gl_entries):
 	return dimension_balances
 
 
-def process_individual_date(docname: str, date, report_type, parentfield):
+def process_individual_date(docname: str, row_name, date, report_type, parentfield):
 	current_date_status = frappe.db.get_value(
 		"Process Period Closing Voucher Detail",
-		{"processing_date": date, "report_type": report_type, "parentfield": parentfield},
+		row_name,
 		"status",
 	)
 	if current_date_status != "Running":
@@ -576,17 +587,20 @@ def process_individual_date(docname: str, date, report_type, parentfield):
 	# save results
 	frappe.db.set_value(
 		"Process Period Closing Voucher Detail",
-		{"processing_date": date, "parent": docname, "report_type": report_type, "parentfield": parentfield},
+		row_name,
 		"closing_balance",
 		frappe.json.dumps(res),
 	)
 
 	frappe.db.set_value(
 		"Process Period Closing Voucher Detail",
-		{"processing_date": date, "parent": docname, "report_type": report_type, "parentfield": parentfield},
+		row_name,
 		"status",
 		"Completed",
 	)
+	# commit heavy computation before touching PPCV or PPCVD
+	if not frappe.flags.in_test:
+		frappe.db.commit()  # nosemgrep
 
 	# chain call
 	schedule_next_date(docname)

erpnext/accounts/doctype/process_period_closing_voucher_detail/process_period_closing_voucher_detail.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and contributors
 # For license information, please see license.txt
 
-# import frappe
+import frappe
 from frappe.model.document import Document
 
 
@@ -24,3 +24,10 @@ class ProcessPeriodClosingVoucherDetail(Document):
 	# end: auto-generated types
 
 	pass
+
+
+def on_doctype_update():
+	frappe.db.add_index(
+		"Process Period Closing Voucher Detail",
+		["parent", "status", "parentfield", "idx", "processing_date"],
+	)

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html

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

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -97,9 +97,9 @@ class ProcessStatementOfAccounts(Document):
 		if not self.pdf_name:
 			self.pdf_name = "{{ customer.customer_name }}"
 
-		validate_template(self.subject)
-		validate_template(self.body)
-		validate_template(self.pdf_name)
+		validate_template(self.subject, restrict_globals=True)
+		validate_template(self.body, restrict_globals=True)
+		validate_template(self.pdf_name, restrict_globals=True)
 
 		if not self.customers:
 			frappe.throw(_("Customers not selected."))
@@ -390,7 +390,6 @@ def get_context(customer, doc):
 	return {
 		"doc": template_doc,
 		"customer": frappe.get_doc("Customer", customer),
-		"frappe": frappe.utils,
 	}
 
 
@@ -440,6 +439,8 @@ def get_customer_emails(customer_name, primary_mandatory, billing_and_primary=Tr
 	when Is Billing Contact checked
 	and Primary email- email with Is Primary checked"""
 
+	frappe.has_permission("Customer", "read", customer_name, throw=True)
+
 	billing_email = frappe.db.sql(
 		"""
 		SELECT
@@ -483,6 +484,7 @@ def get_customer_emails(customer_name, primary_mandatory, billing_and_primary=Tr
 @frappe.whitelist()
 def download_statements(document_name):
 	doc = frappe.get_doc("Process Statement Of Accounts", document_name)
+	doc.check_permission("read")
 	report = get_report_pdf(doc)
 	if report:
 		frappe.local.response.filename = doc.name + ".pdf"
@@ -499,15 +501,15 @@ def send_emails(document_name, from_scheduler=False, posting_date=None):
 	if report:
 		for customer, report_pdf in report.items():
 			context = get_context(customer, doc)
-			filename = frappe.render_template(doc.pdf_name, context)
+			filename = frappe.render_template(doc.pdf_name, context, restrict_globals=True)
 			attachments = [{"fname": filename + ".pdf", "fcontent": report_pdf}]
 
 			recipients, cc = get_recipients_and_cc(customer, doc)
 			if not recipients:
 				continue
 
-			subject = frappe.render_template(doc.subject, context)
-			message = frappe.render_template(doc.body, context)
+			subject = frappe.render_template(doc.subject, context, restrict_globals=True)
+			message = frappe.render_template(doc.body, context, restrict_globals=True)
 
 			if doc.sender:
 				sender_email = frappe.db.get_value("Email Account", doc.sender, "email_id")

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -1397,8 +1397,10 @@
    "fetch_from": "supplier.represents_company",
    "fieldname": "represents_company",
    "fieldtype": "Link",
+   "ignore_user_permissions": 1,
    "label": "Represents Company",
-   "options": "Company"
+   "options": "Company",
+   "read_only": 1
   },
   {
    "depends_on": "eval:doc.update_stock && doc.is_internal_supplier",
@@ -1660,7 +1662,7 @@
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2026-03-17 20:44:00.221219",
+ "modified": "2026-07-12 23:54:21.263951",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -2924,6 +2924,24 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		# Test 4 - Since this PI is overbilled by 130% and only 120% is allowed, it will fail
 		self.assertRaises(frappe.ValidationError, pi.submit)
 
+	@change_settings("Accounts Settings", {"over_billing_allowance": 0})
+	def test_non_stock_item_over_billing_against_po_is_blocked(self):
+		service_item = create_item(
+			"_Test Service Item Non Stock PI",
+			is_stock_item=0,
+			is_purchase_item=1,
+		).name
+
+		po = create_purchase_order(item_code=service_item, qty=5, rate=100, do_not_save=False)
+		po.submit()
+
+		pi = make_pi_from_po(po.name)
+		pi.items[0].qty = 10  # overbill by 100 %
+		pi.save()
+
+		with self.assertRaises(frappe.ValidationError):
+			pi.submit()
+
 	def test_discount_percentage_not_set_when_amount_is_manually_set(self):
 		pi = make_purchase_invoice(do_not_save=True)
 		discount_amount = 7

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -2884,8 +2884,6 @@ def create_dunning(source_name, target_doc=None, ignore_permissions=False):
 	from frappe.model.mapper import get_mapped_doc
 
 	def postprocess_dunning(source, target):
-		from erpnext.accounts.doctype.dunning.dunning import get_dunning_letter_text
-
 		dunning_type = frappe.db.exists("Dunning Type", {"is_default": 1, "company": source.company})
 		if dunning_type:
 			dunning_type = frappe.get_doc("Dunning Type", dunning_type)
@@ -2894,14 +2892,8 @@ def create_dunning(source_name, target_doc=None, ignore_permissions=False):
 			target.dunning_fee = dunning_type.dunning_fee
 			target.income_account = dunning_type.income_account
 			target.cost_center = dunning_type.cost_center
-			letter_text = get_dunning_letter_text(
-				dunning_type=dunning_type.name, doc=target.as_dict(), language=source.language
-			)
-
-			if letter_text:
-				target.body_text = letter_text.get("body_text")
-				target.closing_text = letter_text.get("closing_text")
-				target.language = letter_text.get("language")
+			target.language = source.language
+			target.get_dunning_letter_text()
 
 		# update outstanding from doc
 		if source.payment_schedule and len(source.payment_schedule) == 1:

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -3700,6 +3700,51 @@ class TestSalesInvoice(FrappeTestCase):
 		self.assertTrue("cannot overbill" in str(err.exception).lower())
 		dn.cancel()
 
+	@change_settings("Accounts Settings", {"over_billing_allowance": 0})
+	def test_non_stock_item_over_billing_against_so_is_blocked(self):
+		from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice as make_si_from_so
+		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+
+		service_item = create_item(
+			"_Test Service Item Non Stock SI",
+			is_stock_item=0,
+		).name
+
+		so = make_sales_order(item_code=service_item, qty=5, rate=100)
+		so.submit()
+
+		si = make_si_from_so(so.name)
+		si.items[0].qty = 10  # overbill by 100 %
+		si.save()
+
+		with self.assertRaises(frappe.ValidationError):
+			si.submit()
+
+	@change_settings("Accounts Settings", {"over_billing_allowance": 0})
+	def test_non_stock_item_over_billing_against_so_from_quotation_is_blocked(self):
+		from erpnext.selling.doctype.quotation.quotation import make_sales_order as make_so_from_quotation
+		from erpnext.selling.doctype.quotation.test_quotation import make_quotation
+		from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice as make_si_from_so
+
+		service_item = create_item(
+			"_Test Service Item Non Stock SI Quot",
+			is_stock_item=0,
+		).name
+
+		quotation = make_quotation(item_code=service_item, qty=5, rate=100)
+
+		so = make_so_from_quotation(quotation.name)
+		so.delivery_date = frappe.utils.add_days(frappe.utils.today(), 7)
+		so.insert()
+		so.submit()
+
+		si = make_si_from_so(so.name)
+		si.items[0].qty = 10  # overbill by 100 %
+		si.save()
+
+		with self.assertRaises(frappe.ValidationError):
+			si.submit()
+
 	@change_settings(
 		"Accounts Settings",
 		{

erpnext/accounts/general_ledger.py

@@ -697,13 +697,15 @@ def make_reverse_gl_entries(
 			partial_cancel=partial_cancel,
 		)
 		validate_accounting_period(gl_entries)
-		check_freezing_date(gl_entries[0]["posting_date"], adv_adj)
 
 		is_opening = any(d.get("is_opening") == "Yes" for d in gl_entries)
 
-		# For reverse entries, use the posting_date parameter if provided and valid
-		# Otherwise fall back to original posting_date
-		validation_date = posting_date if posting_date else gl_entries[0]["posting_date"]
+		if immutable_ledger_enabled:
+			validation_date = posting_date or frappe.form_dict.get("posting_date") or getdate()
+		else:
+			validation_date = posting_date if posting_date else gl_entries[0]["posting_date"]
+
+		check_freezing_date(validation_date, adv_adj)
 		validate_against_pcv(is_opening, validation_date, gl_entries[0]["company"])
 
 		if partial_cancel:
@@ -770,7 +772,7 @@ def make_reverse_gl_entries(
 
 			if immutable_ledger_enabled:
 				new_gle["is_cancelled"] = 0
-				new_gle["posting_date"] = frappe.form_dict.get("posting_date") or getdate()
+				new_gle["posting_date"] = posting_date or frappe.form_dict.get("posting_date") or getdate()
 			elif posting_date:
 				new_gle["posting_date"] = posting_date
 
@@ -802,13 +804,24 @@ def check_freezing_date(posting_date, adv_adj=False):
 				)
 
 
-def validate_against_pcv(is_opening, posting_date, company):
-	if is_opening and frappe.db.exists("Period Closing Voucher", {"docstatus": 1, "company": company}):
+def validate_opening_entry_against_pcv(company):
+	if frappe.db.exists("Period Closing Voucher", {"docstatus": 1, "company": company}):
 		frappe.throw(
-			_("Opening Entry can not be created after Period Closing Voucher is created."),
+			_(
+				"A Period Closing Voucher is already submitted and an Opening Entry can no longer be created. {0} to learn more."
+			).format(
+				'<a href="https://docs.frappe.io/erpnext/period-closing-voucher#14-pcv-and-opening-entries" target="_blank" rel="noopener">'
+				+ _("Read the docs")
+				+ "</a>"
+			),
 			title=_("Invalid Opening Entry"),
 		)
 
+
+def validate_against_pcv(is_opening, posting_date, company):
+	if is_opening:
+		validate_opening_entry_against_pcv(company)
+
 	# Local import so you don't have to touch file-level imports
 	from frappe.query_builder.functions import Max
 

erpnext/accounts/party.py

@@ -431,6 +431,17 @@ def get_party_account(party_type, party=None, company=None, include_advance=Fals
 	Will first search in party (Customer / Supplier) record, if not found,
 	will search in group (Customer Group / Supplier Group),
 	finally will return default."""
+
+	def account_perm_check(account):
+		ptype = "select" if frappe.only_has_select_perm("Account") else "read"
+		if frappe.has_permission("Account", ptype, account):
+			return
+
+		# Using custom message to prevent data leak in case of `apply_strict_permission` is enabled.
+		frappe.throw(
+			_("User don't have permissions to select/read this account."), exc=frappe.PermissionError
+		)
+
 	if not party_type:
 		frappe.throw(_("Party Type is mandatory"))
 	if not company:
@@ -441,46 +452,51 @@ def get_party_account(party_type, party=None, company=None, include_advance=Fals
 			"default_receivable_account" if party_type == "Customer" else "default_payable_account"
 		)
 
-		return frappe.get_cached_value("Company", company, default_account_name)
-
-	account = frappe.db.get_value(
-		"Party Account", {"parenttype": party_type, "parent": party, "company": company}, "account"
-	)
-
-	if not account and party_type in ["Customer", "Supplier"]:
-		party_group_doctype = "Customer Group" if party_type == "Customer" else "Supplier Group"
-		group = frappe.get_cached_value(party_type, party, scrub(party_group_doctype))
+		account = frappe.get_cached_value("Company", company, default_account_name)
+	else:
 		account = frappe.db.get_value(
-			"Party Account",
-			{"parenttype": party_group_doctype, "parent": group, "company": company},
-			"account",
+			"Party Account", {"parenttype": party_type, "parent": party, "company": company}, "account"
 		)
 
-	if not account and party_type in ["Customer", "Supplier"]:
-		default_account_name = (
-			"default_receivable_account" if party_type == "Customer" else "default_payable_account"
-		)
-		account = frappe.get_cached_value("Company", company, default_account_name)
+		if not account and party_type in ["Customer", "Supplier"]:
+			party_group_doctype = "Customer Group" if party_type == "Customer" else "Supplier Group"
+			group = frappe.get_cached_value(party_type, party, scrub(party_group_doctype))
+			account = frappe.db.get_value(
+				"Party Account",
+				{"parenttype": party_group_doctype, "parent": group, "company": company},
+				"account",
+			)
 
-	existing_gle_currency = get_party_gle_currency(party_type, party, company)
-	if existing_gle_currency:
-		if account:
-			account_currency = frappe.get_cached_value("Account", account, "account_currency")
-		if (account and account_currency != existing_gle_currency) or not account:
-			account = get_party_gle_account(party_type, party, company)
+		if not account and party_type in ["Customer", "Supplier"]:
+			default_account_name = (
+				"default_receivable_account" if party_type == "Customer" else "default_payable_account"
+			)
+			account = frappe.get_cached_value("Company", company, default_account_name)
 
-	# get default account on the basis of party type
-	if not account:
-		account_type = frappe.get_cached_value("Party Type", party_type, "account_type")
-		default_account_name = "default_" + account_type.lower() + "_account"
-		account = frappe.get_cached_value("Company", company, default_account_name)
+		existing_gle_currency = get_party_gle_currency(party_type, party, company)
+		if existing_gle_currency:
+			if account:
+				account_currency = frappe.get_cached_value("Account", account, "account_currency")
+			if (account and account_currency != existing_gle_currency) or not account:
+				account = get_party_gle_account(party_type, party, company)
 
-	if include_advance and party_type in ["Customer", "Supplier", "Student"]:
+		# get default account on the basis of party type
+		if not account:
+			account_type = frappe.get_cached_value("Party Type", party_type, "account_type")
+			default_account_name = "default_" + account_type.lower() + "_account"
+			account = frappe.get_cached_value("Company", company, default_account_name)
+
+	if account:
+		account_perm_check(account)
+
+	if include_advance and party and party_type in ["Customer", "Supplier", "Student"]:
 		advance_account = get_party_advance_account(party_type, party, company)
+
 		if advance_account:
+			account_perm_check(advance_account)
 			return [account, advance_account]
-		else:
-			return [account]
+
+		return [account]
 
 	return account
 
@@ -837,7 +853,7 @@ def get_dashboard_info(party_type, party, loyalty_program=None):
 
 	doctype = "Sales Invoice" if party_type == "Customer" else "Purchase Invoice"
 
-	companies = frappe.get_all(
+	companies = frappe.get_list(
 		doctype, filters={"docstatus": 1, party_type.lower(): party}, distinct=1, fields=["company"]
 	)
 

erpnext/accounts/report/accounts_payable/accounts_payable.js

@@ -13,7 +13,7 @@ frappe.query_reports["Accounts Payable"] = {
 		},
 		{
 			fieldname: "report_date",
-			label: __("Posting Date"),
+			label: __("Report Date"),
 			fieldtype: "Date",
 			default: frappe.datetime.get_today(),
 		},
@@ -69,10 +69,10 @@ frappe.query_reports["Accounts Payable"] = {
 			default: "Due Date",
 		},
 		{
-			fieldname: "calculate_ageing_with",
-			label: __("Calculate Ageing With"),
+			fieldname: "age_as_on",
+			label: __("Age as on"),
 			fieldtype: "Select",
-			options: "Report Date\nToday Date",
+			options: "Report Date\nToday",
 			default: "Report Date",
 		},
 		{

erpnext/accounts/report/accounts_payable/accounts_payable.json

@@ -7,7 +7,7 @@
  "doctype": "Report", 
  "idx": 3, 
  "is_standard": "Yes", 
- "modified": "2017-02-24 20:09:46.150861", 
+ "modified": "2026-07-01 13:37:41.185347",
  "modified_by": "Administrator", 
  "module": "Accounts", 
  "name": "Accounts Payable", 
@@ -15,6 +15,11 @@
  "ref_doctype": "Purchase Invoice", 
  "report_name": "Accounts Payable", 
  "report_type": "Script Report", 
+ "doctype_to_sync": [
+  {
+   "doc_type": "Payment Ledger Entry"
+  }
+ ],
  "roles": [
   {
    "role": "Accounts User"
@@ -28,5 +33,7 @@
   {
    "role": "Auditor"
   }
- ]
-}
+ ],
+ "snapshot_report": 0,
+ "timeout": 0
+}

erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.js

@@ -12,7 +12,7 @@ frappe.query_reports["Accounts Payable Summary"] = {
 		},
 		{
 			fieldname: "report_date",
-			label: __("Posting Date"),
+			label: __("Report Date"),
 			fieldtype: "Date",
 			default: frappe.datetime.get_today(),
 		},
@@ -24,10 +24,10 @@ frappe.query_reports["Accounts Payable Summary"] = {
 			default: "Due Date",
 		},
 		{
-			fieldname: "calculate_ageing_with",
-			label: __("Calculate Ageing With"),
+			fieldname: "age_as_on",
+			label: __("Age as on"),
 			fieldtype: "Select",
-			options: "Report Date\nToday Date",
+			options: "Report Date\nToday",
 			default: "Report Date",
 		},
 		{

erpnext/accounts/report/accounts_receivable/accounts_receivable.js

@@ -15,7 +15,7 @@ frappe.query_reports["Accounts Receivable"] = {
 		},
 		{
 			fieldname: "report_date",
-			label: __("Posting Date"),
+			label: __("Report Date"),
 			fieldtype: "Date",
 			default: frappe.datetime.get_today(),
 		},
@@ -98,10 +98,10 @@ frappe.query_reports["Accounts Receivable"] = {
 			default: "Due Date",
 		},
 		{
-			fieldname: "calculate_ageing_with",
-			label: __("Calculate Ageing With"),
+			fieldname: "age_as_on",
+			label: __("Age as on"),
 			fieldtype: "Select",
-			options: "Report Date\nToday Date",
+			options: "Report Date\nToday",
 			default: "Report Date",
 		},
 		{

erpnext/accounts/report/accounts_receivable/accounts_receivable.json

@@ -7,7 +7,7 @@
  "doctype": "Report", 
  "idx": 3, 
  "is_standard": "Yes", 
- "modified": "2017-03-06 05:52:06.235584", 
+ "modified": "2026-07-01 13:37:44.167999",
  "modified_by": "Administrator", 
  "module": "Accounts", 
  "name": "Accounts Receivable", 
@@ -15,6 +15,11 @@
  "ref_doctype": "Sales Invoice", 
  "report_name": "Accounts Receivable", 
  "report_type": "Script Report", 
+ "doctype_to_sync": [
+  {
+   "doc_type": "Payment Ledger Entry"
+  }
+ ],
  "roles": [
   {
    "role": "Accounts Manager"
@@ -22,5 +27,7 @@
   {
    "role": "Accounts User"
   }
- ]
-}
+ ],
+ "snapshot_report": 0,
+ "timeout": 0
+}

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -55,8 +55,7 @@ class ReceivablePayableReport:
 		self.filters.report_date = getdate(self.filters.report_date or nowdate())
 		self.age_as_on = (
 			getdate(nowdate())
-			if "calculate_ageing_with" not in self.filters
-			or self.filters.calculate_ageing_with == "Today Date"
+			if "age_as_on" not in self.filters or self.filters.age_as_on == "Today"
 			else self.filters.report_date
 		)
 
@@ -263,10 +262,12 @@ class ReceivablePayableReport:
 
 		# Build and use a separate row for Employee Advances.
 		# This allows Payments or Journals made against Emp Advance to be processed.
-		if (
-			not row
-			and ple.against_voucher_type == "Employee Advance"
-			and self.filters.handle_employee_advances
+		if not row and (
+			(ple.against_voucher_type == "Employee Advance" and self.filters.handle_employee_advances)
+			or (
+				ple.against_voucher_type == "Exchange Rate Revaluation"
+				and self.filters.for_revaluation_journals
+			)
 		):
 			_d = self.build_voucher_dict(ple)
 			_d.voucher_type = ple.against_voucher_type

erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.js

@@ -12,7 +12,7 @@ frappe.query_reports["Accounts Receivable Summary"] = {
 		},
 		{
 			fieldname: "report_date",
-			label: __("Posting Date"),
+			label: __("Report Date"),
 			fieldtype: "Date",
 			default: frappe.datetime.get_today(),
 		},
@@ -24,10 +24,10 @@ frappe.query_reports["Accounts Receivable Summary"] = {
 			default: "Due Date",
 		},
 		{
-			fieldname: "calculate_ageing_with",
-			label: __("Calculate Ageing With"),
+			fieldname: "age_as_on",
+			label: __("Age as on"),
 			fieldtype: "Select",
-			options: "Report Date\nToday Date",
+			options: "Report Date\nToday",
 			default: "Report Date",
 		},
 		{

erpnext/accounts/report/balance_sheet/balance_sheet.json

@@ -6,7 +6,7 @@
  "doctype": "Report", 
  "idx": 2, 
  "is_standard": "Yes", 
- "modified": "2018-09-07 12:18:21.850851", 
+ "modified": "2026-06-22 13:38:25.236839",
  "modified_by": "Administrator", 
  "module": "Accounts", 
  "name": "Balance Sheet", 
@@ -15,6 +15,11 @@
  "ref_doctype": "GL Entry", 
  "report_name": "Balance Sheet", 
  "report_type": "Script Report", 
+ "doctype_to_sync": [
+  {
+   "doc_type": "GL Entry"
+  }
+ ],
  "roles": [
   {
    "role": "Accounts User"
@@ -25,5 +30,7 @@
   {
    "role": "Auditor"
   }
- ]
-}
+ ],
+ "synced_report": 0,
+ "timeout": 0
+}

erpnext/accounts/report/balance_sheet/balance_sheet.py

@@ -4,14 +4,23 @@
 
 import frappe
 from frappe import _
-from frappe.utils import cint, flt
+from frappe.utils import add_days, cint, flt
 
 from erpnext.accounts.report.financial_statements import (
+	accumulate_values_into_parents,
+	add_total_row,
+	calculate_values,
 	compute_growth_view_data,
+	filter_accounts,
+	filter_out_zero_value_rows,
+	get_accounting_entries,
+	get_accounts,
+	get_appropriate_currency,
 	get_columns,
 	get_data,
 	get_filtered_list_for_consolidated_report,
 	get_period_list,
+	prepare_data,
 )
 
 
@@ -259,3 +268,196 @@ def get_chart_data(filters, chart_columns, asset, liability, equity, currency):
 	chart["currency"] = currency
 
 	return chart
+
+
+def execute_snapshot_report(filters):
+	from frappe.database.duckdb.database import get_latest_sync
+
+	if not (conn := get_latest_sync("GL Entry")):
+		frappe.throw(_("Balance Sheet requires {0} to be synced to DuckDB").format(frappe.bold("GL Entry")))
+
+	period_list = get_period_list(
+		filters.from_fiscal_year,
+		filters.to_fiscal_year,
+		filters.period_start_date,
+		filters.period_end_date,
+		filters.filter_based_on,
+		filters.periodicity,
+		company=filters.company,
+	)
+	filters.period_start_date = period_list[0]["year_start_date"]
+
+	currency = filters.presentation_currency or frappe.get_cached_value(
+		"Company", filters.company, "default_currency"
+	)
+
+	asset = _get_data_duckdb(conn, filters, "Asset", "Debit", period_list)
+	liability = _get_data_duckdb(conn, filters, "Liability", "Credit", period_list)
+	equity = _get_data_duckdb(conn, filters, "Equity", "Credit", period_list)
+
+	provisional_profit_loss, total_credit = get_provisional_profit_loss(
+		asset, liability, equity, period_list, filters.company, currency
+	)
+	message, opening_balance = check_opening_balance(asset, liability, equity)
+
+	data = []
+	data.extend(asset or [])
+	data.extend(liability or [])
+	data.extend(equity or [])
+	if opening_balance and round(opening_balance, 2) != 0:
+		unclosed = {
+			"account_name": "'" + _("Unclosed Fiscal Years Profit / Loss (Credit)") + "'",
+			"account": "'" + _("Unclosed Fiscal Years Profit / Loss (Credit)") + "'",
+			"warn_if_negative": True,
+			"currency": currency,
+		}
+		for period in period_list:
+			unclosed[period.key] = opening_balance
+			if provisional_profit_loss:
+				provisional_profit_loss[period.key] = provisional_profit_loss[period.key] - opening_balance
+		unclosed["total"] = opening_balance
+		data.append(unclosed)
+
+	if provisional_profit_loss:
+		data.append(provisional_profit_loss)
+	if total_credit:
+		data.append(total_credit)
+
+	columns = get_columns(
+		filters.periodicity, period_list, filters.accumulated_values, company=filters.company
+	)
+	chart = get_chart_data(filters, period_list, asset, liability, equity, currency)
+	report_summary, primitive_summary = get_report_summary(
+		period_list, asset, liability, equity, provisional_profit_loss, currency, filters
+	)
+
+	if filters.get("selected_view") == "Growth":
+		compute_growth_view_data(data, period_list)
+
+	return columns, data, message, chart, report_summary, primitive_summary
+
+
+def _get_data_duckdb(conn, filters, root_type, balance_must_be, period_list):
+	accounts = get_accounts(filters.company, root_type)
+	if not accounts:
+		return None
+
+	accounts, accounts_by_name, parent_children_map = filter_accounts(accounts)
+	company_currency = get_appropriate_currency(filters.company, filters)
+
+	gl_entries_by_account = {}
+	_load_gl_entries_duckdb(conn, filters, period_list, accounts, gl_entries_by_account, root_type)
+
+	calculate_values(
+		accounts_by_name,
+		gl_entries_by_account,
+		period_list,
+		filters.accumulated_values,
+		False,
+	)
+	accumulate_values_into_parents(accounts, accounts_by_name, period_list)
+
+	out = prepare_data(
+		accounts,
+		balance_must_be,
+		period_list,
+		company_currency,
+		accumulated_values=filters.accumulated_values,
+	)
+	out = filter_out_zero_value_rows(out, parent_children_map, filters.show_zero_values)
+
+	if out:
+		add_total_row(out, root_type, balance_must_be, period_list, company_currency)
+
+	return out
+
+
+def _load_gl_entries_duckdb(conn, filters, period_list, accounts, gl_entries_by_account, root_type):
+	from erpnext.accounts.report.trial_balance.trial_balance import (
+		_extra_gl_conditions,
+		_fetch_gl_rows_duckdb,
+	)
+	from erpnext.accounts.report.utils import convert_to_presentation_currency, get_currency
+
+	company = filters.company
+	year_start_date = period_list[0]["year_start_date"]
+	last_to_date = period_list[-1]["to_date"]
+	ignore_is_opening = frappe.get_single_value("Accounts Settings", "ignore_is_opening_check_for_reporting")
+
+	leaf_accounts = [acc.name for acc in accounts if not acc.is_group]
+	if not leaf_accounts:
+		return
+
+	opening_from_date = None
+	ignore_opening_entries = False
+
+	ignore_closing_balances = frappe.get_single_value("Accounts Settings", "ignore_account_closing_balance")
+	if not ignore_closing_balances:
+		last_pcv_list = frappe.db.get_all(
+			"Period Closing Voucher",
+			filters={
+				"docstatus": 1,
+				"company": company,
+				"period_end_date": ("<", filters.get("period_start_date") or year_start_date),
+			},
+			fields=["period_end_date", "name"],
+			order_by="period_end_date desc",
+			limit=1,
+		)
+		if last_pcv_list:
+			last_pcv = last_pcv_list[0]
+			pcv_entries = get_accounting_entries(
+				"Account Closing Balance",
+				None,
+				last_to_date,
+				filters,
+				root_type=root_type,
+				ignore_closing_entries=False,
+				period_closing_voucher=last_pcv.name,
+			)
+			if filters.get("presentation_currency"):
+				convert_to_presentation_currency(pcv_entries, get_currency(filters))
+			for entry in pcv_entries:
+				gl_entries_by_account.setdefault(entry.account, []).append(entry)
+			opening_from_date = add_days(last_pcv.period_end_date, 1)
+			ignore_opening_entries = True
+
+	extra_cond, extra_params = _extra_gl_conditions(filters)
+	account_placeholders = ", ".join(["?"] * len(leaf_accounts))
+	base_conds = [
+		"company = ?",
+		"is_cancelled = 0",
+		f"account IN ({account_placeholders})",
+	]
+	base_params = [company, *leaf_accounts]
+	if ignore_opening_entries and not ignore_is_opening:
+		base_conds.append("is_opening = 'No'")
+	base_conds.extend(extra_cond)
+	base_params.extend(extra_params)
+
+	# Opening GL entries from DuckDB (entries before year_start_date)
+	open_conds = [*base_conds, "posting_date < ?"]
+	open_params = [*base_params, year_start_date]
+	if opening_from_date:
+		open_conds = [*open_conds, "posting_date >= ?"]
+		open_params = [*open_params, opening_from_date]
+
+	opening_entries = _fetch_gl_rows_duckdb(conn, open_conds, open_params)
+	if filters.get("presentation_currency"):
+		convert_to_presentation_currency(opening_entries, get_currency(filters))
+	synthetic_open_date = add_days(year_start_date, -1)
+	for entry in opening_entries:
+		entry.posting_date = synthetic_open_date
+		gl_entries_by_account.setdefault(entry.account, []).append(entry)
+
+	# Period GL entries from DuckDB (one aggregated query per period)
+	for period in period_list:
+		period_conds = [*base_conds, "posting_date >= ?", "posting_date <= ?"]
+		period_params = [*base_params, period.from_date, period.to_date]
+
+		period_entries = _fetch_gl_rows_duckdb(conn, period_conds, period_params)
+		if filters.get("presentation_currency"):
+			convert_to_presentation_currency(period_entries, get_currency(filters))
+		for entry in period_entries:
+			entry.posting_date = period.to_date
+			gl_entries_by_account.setdefault(entry.account, []).append(entry)

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html

@@ -28,16 +28,16 @@
 						<br>{%= __("Clearance Date") %}: {%= frappe.datetime.str_to_user(data[i]["clearance_date"]) %}
 					{% } %}
 				</td>
-				<td style="text-align: right">{%= format_currency(data[i]["debit"]) %}</td>
-				<td style="text-align: right">{%= format_currency(data[i]["credit"]) %}</td>
+				<td style="text-align: right">{%= format_currency(data[i]["debit"], data[i]["account_currency"]) %}</td>
+				<td style="text-align: right">{%= format_currency(data[i]["credit"], data[i]["account_currency"]) %}</td>
 			</tr>
 			{% } else { %}
 			<tr>
 				<td></td>
 				<td></td>
 				<td>{%= data[i]["payment_entry"] %}</td>
-				<td style="text-align: right">{%= format_currency(data[i]["debit"]) %}</td>
-				<td style="text-align: right">{%= format_currency(data[i]["credit"]) %}</td>
+				<td style="text-align: right">{%= format_currency(data[i]["debit"], data[i]["account_currency"]) %}</td>
+				<td style="text-align: right">{%= format_currency(data[i]["credit"], data[i]["account_currency"]) %}</td>
 			</tr>
 			{% } %}
 		{% } %}

erpnext/accounts/report/cash_flow/cash_flow.py

@@ -73,6 +73,7 @@ def execute(filters=None):
 				"parent_section": None,
 				"indent": 0.0,
 				"section": cash_flow_section["section_header"],
+				"currency": company_currency,
 			}
 		)
 

erpnext/accounts/report/general_ledger/general_ledger.json

@@ -6,11 +6,15 @@
  "disabled": 0,
  "docstatus": 0,
  "doctype": "Report",
+ "doctype_to_sync": [
+  {
+   "doc_type": "GL Entry"
+  }
+ ],
  "filters": [],
  "idx": 3,
  "is_standard": "Yes",
- "letterhead": null,
- "modified": "2025-11-05 15:47:59.597853",
+ "modified": "2026-07-01 13:36:06.682661",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "General Ledger",
@@ -30,5 +34,6 @@
    "role": "Auditor"
   }
  ],
+ "snapshot_report": 0,
  "timeout": 0
 }

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -792,3 +792,288 @@ def get_columns(filters):
 		columns.extend([{"label": _("Remarks"), "fieldname": "remarks", "width": 400}])
 
 	return columns
+
+
+def execute_snapshot_report(filters):
+	from frappe.database.duckdb.database import get_latest_sync
+
+	if conn := get_latest_sync("GL Entry"):
+		return _execute_with_duckdb_conn(filters, conn)
+
+	frappe.throw(_("General Ledger requires {0} to be synced to DuckDB").format(frappe.bold("GL Entry")))
+
+
+def _execute_with_duckdb_conn(filters, conn):
+	if not filters:
+		return [], []
+
+	account_details = {}
+
+	if filters.get("print_in_account_currency") and not filters.get("account"):
+		frappe.throw(_("Select an account to print in account currency"))
+
+	for acc in frappe.get_all("Account", fields=["name", "is_group"]):
+		account_details.setdefault(acc.name, acc)
+
+	if filters.get("party"):
+		filters.party = frappe.parse_json(filters.get("party"))
+
+	validate_filters(filters, account_details)
+	validate_party(filters)
+	filters = set_account_currency(filters)
+	columns = get_columns(filters)
+	res = get_result_duckdb(filters, account_details, conn)
+	return columns, res
+
+
+def get_result_duckdb(filters, account_details, conn):
+	accounting_dimensions = []
+	if filters.get("include_dimensions"):
+		accounting_dimensions = get_accounting_dimensions()
+
+	gl_entries = get_gl_entries_duckdb(filters, accounting_dimensions, conn)
+	data = get_data_with_opening_closing(filters, account_details, accounting_dimensions, gl_entries)
+	return get_result_as_list(data, filters)
+
+
+def get_gl_entries_duckdb(filters, accounting_dimensions, conn):
+	currency_map = get_currency(filters)
+
+	col_names = [
+		"gl_entry",
+		"posting_date",
+		"account",
+		"party_type",
+		"party",
+		"voucher_type",
+		"voucher_subtype",
+		"voucher_no",
+		"cost_center",
+		"project",
+		"against_voucher_type",
+		"against_voucher",
+		"account_currency",
+		"against",
+		"is_opening",
+		"creation",
+		"debit",
+		"credit",
+		"debit_in_account_currency",
+		"credit_in_account_currency",
+	]
+	select_exprs = [
+		"name",
+		"posting_date",
+		"account",
+		"party_type",
+		"party",
+		"voucher_type",
+		"voucher_subtype",
+		"voucher_no",
+		"cost_center",
+		"project",
+		"against_voucher_type",
+		"against_voucher",
+		"account_currency",
+		"against",
+		"is_opening",
+		"creation",
+		"debit",
+		"credit",
+		"debit_in_account_currency",
+		"credit_in_account_currency",
+	]
+
+	if filters.get("show_remarks"):
+		remarks_length = frappe.get_single_value("Accounts Settings", "general_ledger_remarks_length")
+		if remarks_length:
+			select_exprs.append(f"substr(remarks, 1, {int(remarks_length)})")
+		else:
+			select_exprs.append("remarks")
+		col_names.append("remarks")
+
+	if filters.get("add_values_in_transaction_currency"):
+		select_exprs += [
+			"debit_in_transaction_currency",
+			"credit_in_transaction_currency",
+			"transaction_currency",
+		]
+		col_names += [
+			"debit_in_transaction_currency",
+			"credit_in_transaction_currency",
+			"transaction_currency",
+		]
+
+	if accounting_dimensions:
+		select_exprs += accounting_dimensions
+		col_names += accounting_dimensions
+
+	order_by = "posting_date, account, creation"
+	if filters.get("include_dimensions"):
+		order_by = "posting_date, creation"
+	if filters.get("categorize_by") == "Categorize by Voucher":
+		order_by = "posting_date, voucher_type, voucher_no"
+	if filters.get("categorize_by") == "Categorize by Account":
+		order_by = "account, posting_date, creation"
+
+	if filters.get("include_default_book_entries"):
+		filters["company_fb"] = frappe.get_cached_value(
+			"Company", filters.get("company"), "default_finance_book"
+		)
+
+	conditions, params = _build_gl_conditions_duckdb(filters)
+	select_clause = ", ".join(select_exprs)
+	sql = f'SELECT {select_clause} FROM "tabGL Entry" WHERE {" AND ".join(conditions)} ORDER BY {order_by}'
+
+	rows = conn.execute(sql, params).fetchall()
+	gl_entries = [frappe._dict(zip(col_names, row, strict=False)) for row in rows]
+
+	party_name_map = get_party_name_map()
+	for gl_entry in gl_entries:
+		if gl_entry.party_type and gl_entry.party:
+			gl_entry.party_name = party_name_map.get(gl_entry.party_type, {}).get(gl_entry.party)
+
+	if filters.get("presentation_currency"):
+		return convert_to_presentation_currency(gl_entries, currency_map, filters)
+	return gl_entries
+
+
+def _build_gl_conditions_duckdb(filters):
+	ignore_is_opening = frappe.get_single_value("Accounts Settings", "ignore_is_opening_check_for_reporting")
+
+	conditions = ["company = ?"]
+	params = [filters.company]
+
+	if filters.get("account"):
+		filters.account = get_accounts_with_children(filters.account)
+		if filters.account:
+			conditions.append(f"account IN ({', '.join(['?'] * len(filters.account))})")
+			params.extend(filters.account)
+
+	if filters.get("cost_center"):
+		filters.cost_center = get_cost_centers_with_children(filters.cost_center)
+		conditions.append(f"cost_center IN ({', '.join(['?'] * len(filters.cost_center))})")
+		params.extend(filters.cost_center)
+
+	if filters.get("voucher_no"):
+		conditions.append("voucher_no = ?")
+		params.append(filters.voucher_no)
+
+	if filters.get("against_voucher_no"):
+		conditions.append("against_voucher = ?")
+		params.append(filters.against_voucher_no)
+
+	if filters.get("ignore_err"):
+		err_journals = frappe.db.get_all(
+			"Journal Entry",
+			filters={
+				"company": filters.get("company"),
+				"docstatus": 1,
+				"voucher_type": ("in", ["Exchange Rate Revaluation", "Exchange Gain Or Loss"]),
+			},
+			pluck="name",
+		)
+		if err_journals:
+			filters.update({"voucher_no_not_in": err_journals})
+
+	if filters.get("ignore_cr_dr_notes"):
+		system_generated = frappe.db.get_all(
+			"Journal Entry",
+			filters={
+				"company": filters.get("company"),
+				"docstatus": 1,
+				"voucher_type": ("in", ["Credit Note", "Debit Note"]),
+				"is_system_generated": 1,
+			},
+			pluck="name",
+		)
+		if system_generated:
+			vouchers_to_ignore = (filters.get("voucher_no_not_in") or []) + system_generated
+			filters.update({"voucher_no_not_in": vouchers_to_ignore})
+
+	if filters.get("voucher_no_not_in"):
+		vouchers = filters.voucher_no_not_in
+		conditions.append(f"voucher_no NOT IN ({', '.join(['?'] * len(vouchers))})")
+		params.extend(vouchers)
+
+	if filters.get("categorize_by") == "Categorize by Party" and not filters.get("party_type"):
+		conditions.append("party_type IN ('Customer', 'Supplier')")
+
+	if filters.get("party_type"):
+		conditions.append("party_type = ?")
+		params.append(filters.party_type)
+
+	if filters.get("party"):
+		conditions.append(f"party IN ({', '.join(['?'] * len(filters.party))})")
+		params.extend(filters.party)
+
+	# from_date: skip when filtering by account/party to allow opening balance calc in Python
+	if filters.get("disable_opening_balance_calculation"):
+		if not ignore_is_opening:
+			conditions.append("(posting_date >= ? OR is_opening = 'Yes')")
+		else:
+			conditions.append("posting_date >= ?")
+		params.append(filters.from_date)
+	elif not (
+		filters.get("account")
+		or filters.get("party")
+		or filters.get("categorize_by") in ["Categorize by Account", "Categorize by Party"]
+	):
+		if not ignore_is_opening:
+			conditions.append("(posting_date >= ? OR is_opening = 'Yes')")
+		else:
+			conditions.append("posting_date >= ?")
+		params.append(filters.from_date)
+
+	if not ignore_is_opening:
+		conditions.append("(posting_date <= ? OR is_opening = 'Yes')")
+	else:
+		conditions.append("posting_date <= ?")
+	params.append(filters.to_date)
+
+	if filters.get("project"):
+		conditions.append(f"project IN ({', '.join(['?'] * len(filters.project))})")
+		params.extend(filters.project)
+
+	company_fb = filters.get("company_fb") or frappe.get_cached_value(
+		"Company", filters.company, "default_finance_book"
+	)
+	if filters.get("include_default_book_entries"):
+		if filters.get("finance_book"):
+			if company_fb and cstr(filters.finance_book) != cstr(company_fb):
+				frappe.throw(
+					_("To use a different finance book, please uncheck 'Include Default FB Entries'")
+				)
+			fb_vals = [cstr(filters.finance_book), ""]
+		else:
+			fb_vals = [cstr(company_fb), ""]
+		conditions.append(f"(finance_book IN ({', '.join(['?'] * len(fb_vals))}) OR finance_book IS NULL)")
+		params.extend(fb_vals)
+	else:
+		if filters.get("finance_book"):
+			conditions.append("(finance_book IN (?, '') OR finance_book IS NULL)")
+			params.append(cstr(filters.finance_book))
+		else:
+			conditions.append("(finance_book IN ('') OR finance_book IS NULL)")
+
+	if not filters.get("show_cancelled_entries"):
+		conditions.append("is_cancelled = 0")
+
+	accounting_dimensions_list = get_accounting_dimensions(as_list=False)
+	if accounting_dimensions_list:
+		for dimension in accounting_dimensions_list:
+			if not dimension.disabled and dimension.document_type != "Finance Book":
+				if filters.get(dimension.fieldname):
+					if frappe.get_cached_value("DocType", dimension.document_type, "is_tree"):
+						filters[dimension.fieldname] = get_dimension_with_children(
+							dimension.document_type, filters.get(dimension.fieldname)
+						)
+					vals = (
+						filters[dimension.fieldname]
+						if isinstance(filters[dimension.fieldname], list)
+						else [filters[dimension.fieldname]]
+					)
+					conditions.append(f"{dimension.fieldname} IN ({', '.join(['?'] * len(vals))})")
+					params.extend(vals)
+
+	return conditions, params

erpnext/accounts/report/gross_profit/gross_profit.py

@@ -227,6 +227,7 @@ def get_data_when_grouped_by_invoice(columns, gross_profit_data, filters, group_
 				)
 				if total_base_amount
 				else 0,
+				"currency": filters.currency,
 			}
 		)
 	)
@@ -269,6 +270,7 @@ def get_data_when_not_grouped_by_invoice(gross_profit_data, filters, group_wise_
 		"buying_amount": total_buying_amount,
 		"gross_profit": total_gross_profit,
 		"gross_profit_percent": flt(gross_profit_percent, currency_precision),
+		"currency": filters.currency,
 	}
 
 	total_row = [total_row.get(col, None) for col in [*group_columns, "currency"]]
@@ -562,7 +564,12 @@ class GrossProfitGenerator:
 								row.base_amount = packed_item.base_amount
 
 			# get buying amount
-			if row.item_code in product_bundles:
+			if row.is_debit_note:
+				# Rate adjustment debit notes have no stock movement, so buying amount is zero
+				if not grouped_by_invoice:
+					row.qty = 0
+				row.buying_amount = 0
+			elif row.item_code in product_bundles:
 				row.buying_amount = flt(
 					self.get_buying_amount_from_product_bundle(row, product_bundles[row.item_code]),
 					self.currency_precision,
@@ -925,6 +932,7 @@ class GrossProfitGenerator:
 			SalesInvoice.customer_group,
 			SalesInvoice.customer_name,
 			SalesInvoice.territory,
+			SalesInvoice.is_debit_note,
 			SalesInvoiceItem.item_code,
 			SalesInvoice.base_net_total.as_("invoice_base_net_total"),
 			SalesInvoiceItem.item_name,
@@ -1104,6 +1112,7 @@ class GrossProfitGenerator:
 				"posting_time": row.posting_time,
 				"project": row.project,
 				"update_stock": row.update_stock,
+				"is_debit_note": row.is_debit_note,
 				"customer": row.customer,
 				"customer_group": row.customer_group,
 				"customer_name": row.customer_name,
@@ -1142,6 +1151,7 @@ class GrossProfitGenerator:
 				"description": item.description,
 				"warehouse": item.warehouse or row.warehouse,
 				"update_stock": row.update_stock,
+				"is_debit_note": row.is_debit_note,
 				"item_group": "",
 				"brand": "",
 				"dn_detail": row.dn_detail,

erpnext/accounts/report/gross_profit/test_gross_profit.py

@@ -727,6 +727,160 @@ class TestGrossProfit(FrappeTestCase):
 		self.assertEqual(total[7], 1000.0)
 		self.assertEqual(total[8], 100.0)
 
+	def create_rate_adjustment_debit_note(self, against_invoice, adjustment_rate, item_code=None):
+		"""Create a rate adjustment debit note with no stock movement."""
+		dn = self.create_sales_invoice(qty=1, rate=adjustment_rate, do_not_save=True, do_not_submit=True)
+		if item_code:
+			dn.items[0].item_code = item_code
+			dn.items[0].item_name = item_code
+		dn.is_debit_note = 1
+		dn.return_against = against_invoice.name
+		dn.items[0].allow_zero_valuation_rate = 1
+		return dn.save().submit()
+
+	def test_debit_note_has_zero_buying_amount_and_full_gross_profit(self):
+		"""
+		Rate adjustment debit note (is_debit_note=1) should show buying_amount=0
+		since there is no stock movement. Gross profit equals the adjustment amount
+		and gross profit % equals 100%.
+		"""
+		make_stock_entry(
+			company=self.company,
+			item_code=self.item,
+			target=self.warehouse,
+			qty=1,
+			basic_rate=100,
+		)
+
+		sinv = self.create_sales_invoice(qty=1, rate=200, do_not_submit=True)
+		sinv.update_stock = 1
+		sinv = sinv.save().submit()
+
+		debit_note = self.create_rate_adjustment_debit_note(sinv, adjustment_rate=20)
+
+		filters = frappe._dict(
+			company=self.company,
+			from_date=nowdate(),
+			to_date=nowdate(),
+			group_by="Invoice",
+		)
+
+		columns, data = execute(filters=filters)
+
+		dn_item_rows = [
+			x for x in data if x.get("parent_invoice") == debit_note.name and x.get("indent") == 1.0
+		]
+		self.assertEqual(len(dn_item_rows), 1)
+
+		dn_row = dn_item_rows[0]
+		self.assertEqual(dn_row.buying_amount, 0.0)
+		self.assertEqual(dn_row.selling_amount, 20.0)
+		self.assertEqual(dn_row.gross_profit, 20.0)
+		self.assertEqual(dn_row["gross_profit_%"], 100.0)
+
+	def test_original_invoice_unaffected_by_rate_adjustment_debit_note(self):
+		"""
+		The original invoice's GP should be derived solely from its own selling
+		amount and COGS — the rate adjustment debit note must not alter it.
+		"""
+		make_stock_entry(
+			company=self.company,
+			item_code=self.item,
+			target=self.warehouse,
+			qty=1,
+			basic_rate=100,
+		)
+
+		sinv = self.create_sales_invoice(qty=1, rate=200, do_not_submit=True)
+		sinv.update_stock = 1
+		sinv = sinv.save().submit()
+
+		self.create_rate_adjustment_debit_note(sinv, adjustment_rate=20)
+
+		filters = frappe._dict(
+			company=self.company,
+			from_date=nowdate(),
+			to_date=nowdate(),
+			group_by="Invoice",
+		)
+
+		columns, data = execute(filters=filters)
+
+		sinv_item_rows = [x for x in data if x.get("parent_invoice") == sinv.name and x.get("indent") == 1.0]
+		self.assertEqual(len(sinv_item_rows), 1)
+
+		sinv_row = sinv_item_rows[0]
+		self.assertEqual(sinv_row.selling_amount, 200.0)
+		self.assertEqual(sinv_row.buying_amount, 100.0)
+		self.assertEqual(sinv_row.gross_profit, 100.0)
+		self.assertEqual(sinv_row["gross_profit_%"], 50.0)
+
+	def test_debit_note_qty_not_inflated_in_grouped_report(self):
+		"""
+		When grouped by Item Code, the debit note (qty=0) must not inflate
+		the group's qty or buying_amount. The selling amount and average
+		selling rate correctly reflect the rate adjustment.
+		"""
+		item = create_item("_Test Rate Adjustment Debit Note Item")
+
+		make_stock_entry(
+			company=self.company,
+			item_code=item.item_code,
+			target=self.warehouse,
+			qty=1,
+			basic_rate=100,
+		)
+
+		sinv = create_sales_invoice(
+			qty=1,
+			rate=200,
+			company=self.company,
+			customer=self.customer,
+			item_code=item.item_code,
+			item_name=item.item_code,
+			cost_center=self.cost_center,
+			warehouse=self.warehouse,
+			debit_to=self.debit_to,
+			parent_cost_center=self.cost_center,
+			update_stock=1,
+			currency="INR",
+			income_account=self.income_account,
+			expense_account=self.expense_account,
+		)
+
+		self.create_rate_adjustment_debit_note(sinv, adjustment_rate=20, item_code=item.item_code)
+
+		filters = frappe._dict(
+			company=self.company,
+			from_date=nowdate(),
+			to_date=nowdate(),
+			group_by="Item Code",
+		)
+
+		columns, data = execute(filters=filters)
+
+		# group_by="Item Code" column order:
+		# [item_code, item_name, brand, description, qty, base_rate,
+		#  buying_rate, base_amount, buying_amount, gross_profit, gross_profit_percent, currency]
+		item_row = next((row for row in data if row[0] == item.item_code), None)
+		self.assertIsNotNone(item_row)
+
+		qty, base_rate, buying_amount, base_amount, gross_profit, gp_percent = (
+			item_row[4],
+			item_row[5],
+			item_row[8],
+			item_row[7],
+			item_row[9],
+			item_row[10],
+		)
+
+		self.assertEqual(qty, 1.0)  # debit note adds qty=0, not inflated
+		self.assertEqual(buying_amount, 100.0)  # only original invoice COGS
+		self.assertEqual(base_amount, 220.0)  # 200 (original) + 20 (adjustment)
+		self.assertEqual(base_rate, 220.0)  # avg selling rate = 220/1
+		self.assertEqual(gross_profit, 120.0)  # 220 - 100
+		self.assertAlmostEqual(gp_percent, 54.545, places=2)  # 120/220 * 100
+
 
 def make_sales_person(sales_person_name="_Test Sales Person"):
 	if not frappe.db.exists("Sales Person", {"sales_person_name": sales_person_name}):

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.json

@@ -7,7 +7,7 @@
  "doctype": "Report", 
  "idx": 2, 
  "is_standard": "Yes", 
- "modified": "2017-02-24 20:12:40.282376", 
+ "modified": "2026-07-01 13:36:14.934965",
  "modified_by": "Administrator", 
  "module": "Accounts", 
  "name": "Profit and Loss Statement", 
@@ -15,6 +15,12 @@
  "ref_doctype": "GL Entry", 
  "report_name": "Profit and Loss Statement", 
  "report_type": "Script Report", 
+ "doctype_to_sync": [
+  {
+   "doc_type": "GL Entry"
+  }
+ ],
+ "filters": [],
  "roles": [
   {
    "role": "Accounts User"
@@ -25,5 +31,7 @@
   {
    "role": "Auditor"
   }
- ]
-}
+ ],
+ "snapshot_report": 0,
+ "timeout": 0
+}

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py

@@ -7,12 +7,20 @@ from frappe import _
 from frappe.utils import flt
 
 from erpnext.accounts.report.financial_statements import (
+	accumulate_values_into_parents,
+	add_total_row,
+	calculate_values,
 	compute_growth_view_data,
 	compute_margin_view_data,
+	filter_accounts,
+	filter_out_zero_value_rows,
+	get_accounts,
+	get_appropriate_currency,
 	get_columns,
 	get_data,
 	get_filtered_list_for_consolidated_report,
 	get_period_list,
+	prepare_data,
 )
 
 
@@ -193,3 +201,125 @@ def get_chart_data(filters, chart_columns, income, expense, net_profit_loss, cur
 	chart["currency"] = currency
 
 	return chart
+
+
+def execute_snapshot_report(filters):
+	from frappe.database.duckdb.database import get_latest_sync
+
+	if not (conn := get_latest_sync("GL Entry")):
+		frappe.throw(
+			_("Profit and Loss Statement requires {0} to be synced to DuckDB").format(frappe.bold("GL Entry"))
+		)
+
+	period_list = get_period_list(
+		filters.from_fiscal_year,
+		filters.to_fiscal_year,
+		filters.period_start_date,
+		filters.period_end_date,
+		filters.filter_based_on,
+		filters.periodicity,
+		company=filters.company,
+	)
+
+	income = _get_data_duckdb(conn, filters, "Income", "Credit", period_list)
+	expense = _get_data_duckdb(conn, filters, "Expense", "Debit", period_list)
+
+	net_profit_loss = get_net_profit_loss(
+		income, expense, period_list, filters.company, filters.presentation_currency
+	)
+
+	data = []
+	data.extend(income or [])
+	data.extend(expense or [])
+	if net_profit_loss:
+		data.append(net_profit_loss)
+
+	columns = get_columns(filters.periodicity, period_list, filters.accumulated_values, filters.company)
+
+	currency = filters.presentation_currency or frappe.get_cached_value(
+		"Company", filters.company, "default_currency"
+	)
+	chart = get_chart_data(filters, period_list, income, expense, net_profit_loss, currency)
+
+	report_summary, primitive_summary = get_report_summary(
+		period_list, filters.periodicity, income, expense, net_profit_loss, currency, filters
+	)
+
+	if filters.get("selected_view") == "Growth":
+		compute_growth_view_data(data, period_list)
+
+	if filters.get("selected_view") == "Margin":
+		compute_margin_view_data(data, period_list, filters.accumulated_values)
+
+	return columns, data, None, chart, report_summary, primitive_summary
+
+
+def _get_data_duckdb(conn, filters, root_type, balance_must_be, period_list):
+	accounts = get_accounts(filters.company, root_type)
+	if not accounts:
+		return None
+
+	accounts, accounts_by_name, parent_children_map = filter_accounts(accounts)
+	company_currency = get_appropriate_currency(filters.company, filters)
+
+	gl_entries_by_account = {}
+	_load_gl_entries_duckdb(conn, filters, period_list, accounts, gl_entries_by_account)
+
+	calculate_values(
+		accounts_by_name,
+		gl_entries_by_account,
+		period_list,
+		filters.accumulated_values,
+		False,
+	)
+	accumulate_values_into_parents(accounts, accounts_by_name, period_list)
+
+	out = prepare_data(
+		accounts,
+		balance_must_be,
+		period_list,
+		company_currency,
+		accumulated_values=filters.accumulated_values,
+	)
+	out = filter_out_zero_value_rows(out, parent_children_map, filters.show_zero_values)
+
+	if out:
+		add_total_row(out, root_type, balance_must_be, period_list, company_currency)
+
+	return out
+
+
+def _load_gl_entries_duckdb(conn, filters, period_list, accounts, gl_entries_by_account):
+	from erpnext.accounts.report.trial_balance.trial_balance import (
+		_extra_gl_conditions,
+		_fetch_gl_rows_duckdb,
+	)
+	from erpnext.accounts.report.utils import convert_to_presentation_currency, get_currency
+
+	company = filters.company
+	leaf_accounts = [acc.name for acc in accounts if not acc.is_group]
+	if not leaf_accounts:
+		return
+
+	extra_cond, extra_params = _extra_gl_conditions(filters)
+	account_placeholders = ", ".join(["?"] * len(leaf_accounts))
+	base_conds = [
+		"company = ?",
+		"is_cancelled = 0",
+		f"account IN ({account_placeholders})",
+		"voucher_type != 'Period Closing Voucher'",
+	]
+	base_params = [company, *leaf_accounts]
+	base_conds.extend(extra_cond)
+	base_params.extend(extra_params)
+
+	for period in period_list:
+		period_conds = [*base_conds, "posting_date >= ?", "posting_date <= ?"]
+		period_params = [*base_params, period.from_date, period.to_date]
+
+		period_entries = _fetch_gl_rows_duckdb(conn, period_conds, period_params)
+		if filters.get("presentation_currency"):
+			convert_to_presentation_currency(period_entries, get_currency(filters))
+		for entry in period_entries:
+			entry.posting_date = period.to_date
+			gl_entries_by_account.setdefault(entry.account, []).append(entry)

erpnext/accounts/report/trial_balance/trial_balance.json

@@ -7,13 +7,18 @@
  "doctype": "Report", 
  "idx": 2, 
  "is_standard": "Yes", 
- "modified": "2017-02-24 20:12:33.520866", 
+ "modified": "2026-07-01 17:32:21.801141",
  "modified_by": "Administrator", 
  "module": "Accounts", 
  "name": "Trial Balance", 
  "owner": "Administrator", 
  "ref_doctype": "GL Entry", 
  "report_name": "Trial Balance", 
+ "doctype_to_sync": [
+  {
+   "doc_type": "GL Entry"
+  }
+ ],
  "report_type": "Script Report",
  "roles": [
   {
@@ -25,5 +30,7 @@
   {
    "role": "Auditor"
   }
- ]
-}
+ ],
+ "snapshot_report": 0,
+ "timeout": 0
+}

erpnext/accounts/report/trial_balance/trial_balance.py

@@ -510,3 +510,215 @@ def hide_group_accounts(data):
 			d.update(indent=0)
 			non_group_accounts_data.append(d)
 	return non_group_accounts_data
+
+
+def execute_snapshot_report(filters):
+	from frappe.database.duckdb.database import get_latest_sync
+
+	if conn := get_latest_sync("GL Entry"):
+		validate_filters(filters)
+		columns = get_columns()
+		data = get_data_duckdb(filters, conn)
+		return columns, data
+	else:
+		frappe.throw(_("Trial Balance requires {0} to be synced to DuckDB").format(frappe.bold("GL Entry")))
+
+
+def get_data_duckdb(filters, conn):
+	# accounts and all metadata via frappe.db — only GL Entry comes from DuckDB
+	accounts = frappe.db.sql(
+		"""select name, account_number, parent_account, account_name, root_type, report_type, is_group, lft, rgt
+		from `tabAccount` where company=%s order by lft""",
+		filters.company,
+		as_dict=True,
+	)
+	if not accounts:
+		return None
+
+	company_currency = filters.presentation_currency or erpnext.get_company_currency(filters.company)
+	ignore_is_opening = frappe.get_single_value("Accounts Settings", "ignore_is_opening_check_for_reporting")
+	accounts, accounts_by_name, parent_children_map = filter_accounts(accounts)
+
+	gl_entries_by_account = get_period_gl_entries_duckdb(conn, filters, ignore_is_opening)
+	opening_balances = get_opening_balances_duckdb(conn, filters, ignore_is_opening)
+
+	calculate_values(
+		accounts,
+		gl_entries_by_account,
+		opening_balances,
+		filters.get("show_net_values"),
+		ignore_is_opening=ignore_is_opening,
+	)
+	accumulate_values_into_parents(accounts, accounts_by_name)
+
+	data = prepare_data(accounts, filters, parent_children_map, company_currency)
+	return filter_out_zero_value_rows(
+		data, parent_children_map, show_zero_values=filters.get("show_zero_values")
+	)
+
+
+def _extra_gl_conditions(filters):
+	"""Returns (conditions, params) for optional shared GL Entry filters."""
+	conditions, params = [], []
+
+	if filters.get("cost_center"):
+		cc = get_cost_centers_with_children(filters.get("cost_center"))
+		conditions.append(f"cost_center IN ({', '.join(['?'] * len(cc))})")
+		params.extend(cc)
+
+	if filters.get("project"):
+		proj = filters.project if isinstance(filters.project, list) else [filters.project]
+		conditions.append(f"project IN ({', '.join(['?'] * len(proj))})")
+		params.extend(proj)
+
+	if frappe.db.count("Finance Book"):
+		company_fb = frappe.get_cached_value("Company", filters.company, "default_finance_book")
+		if filters.get("include_default_book_entries"):
+			if filters.get("finance_book") and company_fb and cstr(filters.finance_book) != cstr(company_fb):
+				frappe.throw(
+					_("To use a different finance book, please uncheck 'Include Default FB Entries'")
+				)
+			fb_list = [cstr(filters.get("finance_book")), cstr(company_fb), ""]
+		else:
+			fb_list = [cstr(filters.get("finance_book")), ""]
+		conditions.append(f"(finance_book IN ({', '.join(['?'] * len(fb_list))}) OR finance_book IS NULL)")
+		params.extend(fb_list)
+
+	for dim in get_accounting_dimensions(as_list=False):
+		if filters.get(dim.fieldname):
+			if frappe.get_cached_value("DocType", dim.document_type, "is_tree"):
+				filters[dim.fieldname] = get_dimension_with_children(
+					dim.document_type, filters.get(dim.fieldname)
+				)
+			vals = (
+				filters[dim.fieldname]
+				if isinstance(filters[dim.fieldname], list)
+				else [filters[dim.fieldname]]
+			)
+			conditions.append(f"{dim.fieldname} IN ({', '.join(['?'] * len(vals))})")
+			params.extend(vals)
+
+	return conditions, params
+
+
+def _fetch_gl_rows_duckdb(conn, conditions, params):
+	cols = [
+		"account",
+		"debit",
+		"credit",
+		"debit_in_account_currency",
+		"credit_in_account_currency",
+		"account_currency",
+	]
+	sql = f"""SELECT account, SUM(debit), SUM(credit),
+	                 SUM(debit_in_account_currency), SUM(credit_in_account_currency), account_currency
+	          FROM "tabGL Entry" WHERE {" AND ".join(conditions)}
+	          GROUP BY account, account_currency"""
+	return [frappe._dict(zip(cols, row, strict=False)) for row in conn.execute(sql, params).fetchall()]
+
+
+def get_period_gl_entries_duckdb(conn, filters, ignore_is_opening):
+	conditions = ["company = ?", "is_cancelled = 0", "posting_date >= ?", "posting_date <= ?"]
+	params = [filters.company, filters.from_date, filters.to_date]
+
+	if not ignore_is_opening:
+		conditions.append("is_opening = 'No'")
+	if not flt(filters.get("with_period_closing_entry_for_current_period")):
+		conditions.append("voucher_type != 'Period Closing Voucher'")
+
+	extra_cond, extra_params = _extra_gl_conditions(filters)
+	conditions.extend(extra_cond)
+	params.extend(extra_params)
+
+	entries = _fetch_gl_rows_duckdb(conn, conditions, params)
+	if filters.get("presentation_currency"):
+		convert_to_presentation_currency(entries, get_currency(filters))
+
+	gl_entries_by_account = {}
+	for entry in entries:
+		gl_entries_by_account.setdefault(entry.account, []).append(entry)
+	return gl_entries_by_account
+
+
+def get_opening_balances_duckdb(conn, filters, ignore_is_opening):
+	bs = _get_rootwise_opening_duckdb(conn, filters, "Balance Sheet", ignore_is_opening)
+	pl = _get_rootwise_opening_duckdb(conn, filters, "Profit and Loss", ignore_is_opening)
+	bs.update(pl)
+	return bs
+
+
+def _get_rootwise_opening_duckdb(conn, filters, report_type, ignore_is_opening):
+	accounting_dimensions = get_accounting_dimensions(as_list=False)
+	ignore_closing_balances = frappe.get_single_value("Accounts Settings", "ignore_account_closing_balance")
+	last_pcv = ""
+
+	if not ignore_closing_balances:
+		last_pcv = frappe.db.get_all(
+			"Period Closing Voucher",
+			filters={"docstatus": 1, "company": filters.company, "period_end_date": ("<", filters.from_date)},
+			fields=["period_end_date", "name"],
+			order_by="period_end_date desc",
+			limit=1,
+		)
+
+	if last_pcv:
+		# Account Closing Balance fetched via frappe (not GL Entry)
+		gle = get_opening_balance(
+			"Account Closing Balance",
+			filters,
+			report_type,
+			accounting_dimensions,
+			period_closing_voucher=last_pcv[0].name,
+			ignore_is_opening=ignore_is_opening,
+		)
+		if getdate(last_pcv[0].period_end_date) < getdate(add_days(filters.from_date, -1)):
+			start_date = add_days(last_pcv[0].period_end_date, 1)
+			gle += _get_gl_entry_opening_duckdb(
+				conn, filters, report_type, ignore_is_opening, start_date=start_date
+			)
+	else:
+		gle = _get_gl_entry_opening_duckdb(conn, filters, report_type, ignore_is_opening)
+
+	opening = frappe._dict()
+	for d in gle:
+		opening.setdefault(d.account, {"account": d.account, "opening_debit": 0.0, "opening_credit": 0.0})
+		opening[d.account]["opening_debit"] += flt(d.debit)
+		opening[d.account]["opening_credit"] += flt(d.credit)
+	return opening
+
+
+def _get_gl_entry_opening_duckdb(conn, filters, report_type, ignore_is_opening, start_date=None):
+	accounts = frappe.db.get_all("Account", filters={"report_type": report_type}, pluck="name")
+	if not accounts:
+		return []
+
+	conditions = ["company = ?", f"account IN ({', '.join(['?'] * len(accounts))})", "is_cancelled = 0"]
+	params = [filters.company, *accounts]
+
+	if start_date:
+		conditions.append("posting_date >= ? AND posting_date < ?")
+		params.extend([start_date, filters.from_date])
+		if not ignore_is_opening:
+			conditions.append("is_opening = 'No'")
+	elif not ignore_is_opening:
+		conditions.append("(posting_date < ? OR is_opening = 'Yes')")
+		params.append(filters.from_date)
+	else:
+		conditions.append("posting_date < ?")
+		params.append(filters.from_date)
+
+	if not filters.get("show_unclosed_fy_pl_balances") and report_type == "Profit and Loss":
+		conditions.append("posting_date >= ?")
+		params.append(filters.year_start_date)
+
+	if not flt(filters.get("with_period_closing_entry_for_opening")):
+		conditions.append("voucher_type != 'Period Closing Voucher'")
+
+	extra_cond, extra_params = _extra_gl_conditions(filters)
+	conditions.extend(extra_cond)
+	params.extend(extra_params)
+
+	gle = _fetch_gl_rows_duckdb(conn, conditions, params)
+	if filters.get("presentation_currency"):
+		convert_to_presentation_currency(gle, get_currency(filters))
+	return gle

erpnext/assets/doctype/asset_repair/asset_repair.js

@@ -74,6 +74,15 @@ frappe.ui.form.on("Asset Repair", {
 				};
 			};
 		}
+		if (frm.doc.asset) {
+			frappe.db.get_value("Asset", frm.doc.asset, "status").then(({ message }) => {
+				frm.set_df_property(
+					"capitalize_repair_cost",
+					"read_only",
+					message && message.status === "Fully Depreciated"
+				);
+			});
+		}
 	},
 
 	repair_status: (frm) => {

erpnext/assets/doctype/asset_repair/asset_repair.json

@@ -140,7 +140,7 @@
    "fieldtype": "Link",
    "in_list_view": 1,
    "label": "Asset",
-   "link_filters": "[[\"Asset\",\"status\",\"not in\",[\"Work In Progress\",\"Capitalized\",\"Fully Depreciated\",\"Sold\",\"Scrapped\",\"Cancelled\",null]]]",
+   "link_filters": "[[\"Asset\",\"status\",\"not in\",[\"Work In Progress\",\"Capitalized\",\"Sold\",\"Scrapped\",\"Cancelled\",null]]]",
    "options": "Asset",
    "reqd": 1
   },
@@ -251,7 +251,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2026-01-06 15:48:13.862505",
+ "modified": "2026-07-14 10:00:00.000000",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset Repair",

erpnext/assets/doctype/asset_repair/asset_repair.py

@@ -77,12 +77,15 @@ class AssetRepair(AccountsController):
 				)
 
 	def validate_asset(self):
-		if self.asset_doc.status in ("Sold", "Fully Depreciated", "Scrapped"):
+		if self.asset_doc.status in ("Sold", "Scrapped"):
 			frappe.throw(
 				_("Asset {0} is in {1} status and cannot be repaired.").format(
 					get_link_to_form("Asset", self.asset), self.asset_doc.status
 				)
 			)
+		if self.asset_doc.get_status() == "Fully Depreciated":
+			self.capitalize_repair_cost = 0
+			self.increase_in_asset_life = 0
 
 	def validate_dates(self):
 		if self.completion_date and (getdate(self.failure_date) > getdate(self.completion_date)):

erpnext/bulk_transaction/doctype/bulk_transaction_log/bulk_transaction_log.py

@@ -30,10 +30,7 @@ class BulkTransactionLog(Document):
 	def load_from_db(self):
 		log_detail = qb.DocType("Bulk Transaction Log Detail")
 
-		has_records = frappe.db.sql(
-			"select exists (select * from `tabBulk Transaction Log Detail` where date = %s);",
-			(self.name,),
-		)[0][0]
+		has_records = frappe.db.exists("Bulk Transaction Log Detail", {"date": self.name})
 		if not has_records:
 			raise frappe.DoesNotExistError
 

erpnext/buying/doctype/purchase_order/purchase_order.json

@@ -171,14 +171,12 @@
   },
   {
    "allow_on_submit": 1,
-   "default": "{supplier_name}",
    "fieldname": "title",
    "fieldtype": "Data",
    "hidden": 1,
    "label": "Title",
    "no_copy": 1,
-   "print_hide": 1,
-   "reqd": 1
+   "print_hide": 1
   },
   {
    "fieldname": "naming_series",
@@ -1309,7 +1307,7 @@
  "idx": 105,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-07-31 17:19:40.816883",
+ "modified": "2026-07-28 12:20:11.284370",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Purchase Order",

erpnext/buying/doctype/purchase_order/purchase_order.py

@@ -162,7 +162,7 @@ class PurchaseOrder(BuyingController):
 		taxes_and_charges_deducted: DF.Currency
 		tc_name: DF.Link | None
 		terms: DF.TextEditor | None
-		title: DF.Data
+		title: DF.Data | None
 		to_date: DF.Date | None
 		total: DF.Currency
 		total_net_weight: DF.Float

erpnext/buying/doctype/supplier/supplier.py

@@ -16,7 +16,10 @@ from erpnext.accounts.party import (
 	validate_party_accounts,
 	validate_party_currency_before_merging,
 )
-from erpnext.controllers.website_list_for_contact import add_role_for_portal_user
+from erpnext.controllers.website_list_for_contact import (
+	add_role_for_portal_user,
+	link_portal_users_to_contacts,
+)
 from erpnext.utilities.transaction_base import TransactionBase
 
 
@@ -103,6 +106,7 @@ class Supplier(TransactionBase):
 	def on_update(self):
 		self.create_primary_contact()
 		self.create_primary_address()
+		link_portal_users_to_contacts(self)
 
 	def add_role_for_user(self):
 		for portal_user in self.portal_users:

erpnext/buying/doctype/supplier/test_supplier.py

@@ -204,7 +204,28 @@ class TestSupplierPortal(FrappeTestCase):
 		supplier.append("portal_users", {"user": user})
 		supplier.save()
 
-		frappe.set_user(user)
-		_, suppliers = get_customers_suppliers("Purchase Order", user)
+		with self.set_user(user):
+			_, suppliers = get_customers_suppliers("Purchase Order", user)
 
 		self.assertIn(supplier.name, suppliers)
+
+	def test_portal_user_contact_link(self):
+		user_email = frappe.generate_hash() + "@example.com"
+		user = frappe.new_doc("User")
+		user.email = user_email
+		user.first_name = "Test Portal Contact User"
+		user.send_welcome_email = False
+		user.insert(ignore_permissions=True)
+
+		contact = frappe.new_doc("Contact")
+		contact.first_name = "Test Portal Contact User"
+		contact.add_email(user_email, is_primary=1)
+		contact.links = []
+		contact.insert(ignore_permissions=True)
+
+		supplier = create_supplier()
+		supplier.append("portal_users", {"user": user.name})
+		supplier.save()
+
+		contact.reload()
+		self.assertTrue(contact.has_link("Supplier", supplier.name))

erpnext/buying/doctype/supplier_quotation_item/supplier_quotation_item.json

@@ -307,6 +307,7 @@
    "fieldname": "net_rate",
    "fieldtype": "Currency",
    "label": "Net Rate",
+   "options": "currency",
    "print_hide": 1,
    "read_only": 1
   },
@@ -613,7 +614,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-06-17 12:05:52.441645",
+ "modified": "2026-07-15 10:33:24.855979",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Supplier Quotation Item",

erpnext/buying/report/purchase_order_trends/purchase_order_trends.py

@@ -14,7 +14,6 @@ def execute(filters=None):
 	conditions = get_columns(filters, "Purchase Order")
 	data = get_data(filters, conditions)
 	chart_data = get_chart_data(data, conditions, filters)
-
 	return conditions["columns"], data, None, chart_data
 
 
@@ -39,9 +38,15 @@ def get_chart_data(data, conditions, filters):
 	labels = [column.split(":")[0] for column in columns]
 	datapoints = [0] * len(labels)
 
+	group_by_col_idx = None
+	if filters.get("group_by"):
+		group_by_col_idx = conditions["columns"].index(conditions["grbc"][0])
+
 	for row in data:
-		# If group by filter, don't add first row of group (it's already summed)
-		if not row[start]:
+		# Skip the final grand-total row
+		if row[0] == f"'{_('Total')}'":
+			continue
+		if group_by_col_idx is not None and row[group_by_col_idx] == "":
 			continue
 		# Remove None values and compute only periodic data
 		row = [x if x else 0 for x in row[start:-2]]
@@ -60,4 +65,6 @@ def get_chart_data(data, conditions, filters):
 		"type": "line",
 		"lineOptions": {"regionFill": 1},
 		"fieldtype": "Currency",
+		"options": "currency",
+		"currency": conditions.get("company_currency"),
 	}

erpnext/controllers/accounts_controller.py

@@ -141,6 +141,26 @@ class AccountsController(TransactionBase):
 			if self.doctype in relevant_docs:
 				self.set_payment_schedule()
 
+	def before_insert(self):
+		self.clear_clearance_date_on_amend()
+
+	def clear_clearance_date_on_amend(self):
+		"""Drop the bank reconciliation clearance date copied over while amending.
+
+		The framework copies `no_copy` fields when amending, so a reconciled
+		voucher would carry a stale clearance date into its amendment even though
+		the linked bank transaction gets unreconciled on cancellation.
+		"""
+		if not self.get("amended_from"):
+			return
+
+		if self.meta.has_field("clearance_date"):
+			self.clearance_date = None
+
+		for payment in self.get("payments") or []:
+			if payment.meta.has_field("clearance_date"):
+				payment.clearance_date = None
+
 	def remove_bundle_for_non_stock_invoices(self):
 		has_sabb = False
 		if self.doctype in ("Sales Invoice", "Purchase Invoice") and not self.update_stock:

erpnext/controllers/item_variant.py

@@ -177,6 +177,68 @@ def update_variant_attribute_values(item_attribute):
 	frappe.flags.attribute_values = None
 
 
+def get_attribute_abbr_renames(item_attribute):
+	"""Return the set of (current) attribute values whose abbreviation was renamed."""
+	if item_attribute.numeric_values:
+		return set()
+
+	db_value = item_attribute.get_doc_before_save()
+	if not db_value:
+		return set()
+
+	old_abbrs = {d.name: d.abbr for d in db_value.item_attribute_values}
+	changed_values = set()
+
+	for row in item_attribute.item_attribute_values:
+		if row.name in old_abbrs and old_abbrs[row.name] != row.abbr:
+			changed_values.add(row.attribute_value)
+
+	return changed_values
+
+
+def update_variant_item_codes_for_abbr_renames(item_attribute):
+	"""Rebuild item_code/item_name of variant Items affected by a renamed Item Attribute abbreviation."""
+	changed_values = get_attribute_abbr_renames(item_attribute)
+	if not changed_values:
+		return
+
+	item_variant_table = frappe.qb.DocType("Item Variant Attribute")
+	variant_names = (
+		frappe.qb.from_(item_variant_table)
+		.select(item_variant_table.parent)
+		.where(item_variant_table.attribute == item_attribute.name)
+		.where(item_variant_table.attribute_value.isin(list(changed_values)))
+		.distinct()
+		.run(pluck=True)
+	)
+
+	for variant_name in variant_names:
+		rename_variant_item_code(variant_name)
+
+
+def rename_variant_item_code(variant_name):
+	"""Recompute a variant's item_code/item_name from its template and current attribute abbreviations,
+	renaming the Item if it has changed."""
+	variant = frappe.get_doc("Item", variant_name)
+	if not variant.variant_of:
+		return
+
+	template = frappe.get_cached_doc("Item", variant.variant_of)
+
+	new_code = frappe._dict({"item_code": None, "item_name": None, "attributes": variant.attributes})
+	make_variant_item_code(template.item_code, template.item_name, new_code)
+
+	if not new_code.item_code or new_code.item_code == variant.item_code:
+		return
+
+	frappe.rename_doc("Item", variant.item_code, new_code.item_code)
+
+	# Keep item_name in lockstep with item_code: both are derived from the same abbreviation, so
+	# item_name is always rebuilt here too, even if it had since been customized away from that pattern.
+	if new_code.item_name and new_code.item_name != variant.item_name:
+		frappe.db.set_value("Item", new_code.item_code, "item_name", new_code.item_name)
+
+
 def validate_item_attribute_value(attributes_list, attribute, attribute_value, item, from_variant=True):
 	allow_rename_attribute_value = frappe.db.get_single_value(
 		"Item Variant Settings", "allow_rename_attribute_value"

erpnext/controllers/sales_and_purchase_return.py

@@ -143,7 +143,7 @@ def validate_returned_items(doc):
 					ref.rate
 					and flt(d.rate) > ref.rate
 					and doc.doctype in ("Delivery Note", "Sales Invoice")
-					and get_valuation_method(ref.item_code) != "Moving Average"
+					and get_valuation_method(d.item_code) != "Moving Average"
 				):
 					frappe.throw(
 						_("Row # {0}: Rate cannot be greater than the rate used in {1} {2}").format(

erpnext/controllers/status_updater.py

@@ -135,7 +135,7 @@ status_map = {
 		],
 		[
 			"Partially Ordered",
-			"eval:self.status != 'Stopped' and self.per_ordered < 100 and self.per_ordered > 0 and self.docstatus == 1 and self.material_request_type != 'Material Transfer'",
+			"eval:self.status != 'Stopped' and self.per_ordered < 100 and self.per_ordered > 0 and self.per_received < 100 and self.docstatus == 1 and self.material_request_type not in ['Material Transfer', 'Customer Provided']",
 		],
 	],
 	"POS Opening Entry": [
@@ -158,7 +158,8 @@ status_map = {
 	"Pick List": [
 		["Draft", None],
 		["Open", "eval:self.docstatus == 1"],
-		["Completed", "stock_entry_exists"],
+		["Completed", "is_fully_transferred"],
+		["Partially Transferred", "is_partially_transferred"],
 		[
 			"Partly Delivered",
 			"eval:self.purpose == 'Delivery' and self.delivery_status == 'Partly Delivered'",
@@ -275,6 +276,12 @@ class StatusUpdater(Document):
 						item["idx"] = d.idx
 						item["target_ref_field"] = args["target_ref_field"].replace("_", " ")
 
+						# skip qty over-allowance check for non-stock items
+						if "qty" in args.get("target_ref_field", "") and not frappe.get_cached_value(
+							"Item", item["item_code"], "is_stock_item"
+						):
+							continue
+
 						# if not item[args['target_ref_field']]:
 						# 	msgprint(_("Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0").format(item.item_code))
 						if args.get("no_allowance"):

erpnext/controllers/stock_controller.py

@@ -263,6 +263,10 @@ class StockController(AccountsController):
 			parent_details = self.get_parent_details_for_packed_items()
 
 		for row in self.get(table_name):
+			item_code = row.get("rm_item_code") or row.get("item_code")
+			if not item_code or not self.is_serial_batch_item(item_code):
+				continue
+
 			if (
 				not via_landed_cost_voucher
 				and row.serial_and_batch_bundle
@@ -1490,6 +1494,9 @@ class StockController(AccountsController):
 			"remarks": remarks,
 		}
 
+		if project:
+			gl_entry.update({"project": project})
+
 		if voucher_detail_no:
 			gl_entry.update({"voucher_detail_no": voucher_detail_no})
 
@@ -1506,9 +1513,10 @@ class StockController(AccountsController):
 
 
 @frappe.whitelist()
-def show_accounting_ledger_preview(company, doctype, docname):
+def show_accounting_ledger_preview(company: str, doctype: str, docname: str):
 	filters = frappe._dict(company=company, include_dimensions=1)
 	doc = frappe.get_doc(doctype, docname)
+	doc.check_permission("read")
 	doc.run_method("before_gl_preview")
 
 	gl_columns, gl_data = get_accounting_ledger_preview(doc, filters)
@@ -1519,9 +1527,10 @@ def show_accounting_ledger_preview(company, doctype, docname):
 
 
 @frappe.whitelist()
-def show_stock_ledger_preview(company, doctype, docname):
+def show_stock_ledger_preview(company: str, doctype: str, docname: str):
 	filters = frappe._dict(company=company)
 	doc = frappe.get_doc(doctype, docname)
+	doc.check_permission("read")
 	doc.run_method("before_sl_preview")
 
 	sl_columns, sl_data = get_stock_ledger_preview(doc, filters)

erpnext/controllers/taxes_and_totals.py

@@ -185,7 +185,7 @@ class calculate_taxes_and_totals:
 			return
 
 		if not self.discount_amount_applied:
-			do_not_round_fields = ["valuation_rate", "incoming_rate"]
+			do_not_round_fields = ["valuation_rate", "incoming_rate", "sales_incoming_rate"]
 
 			for item in self.doc.items:
 				self.doc.round_floats_in(item, do_not_round_fields=do_not_round_fields)

erpnext/controllers/tests/test_website_list_for_contact.py

@@ -0,0 +1,36 @@
+# Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import json
+
+from frappe.tests.utils import FrappeTestCase
+
+
+class TestWebsiteListForContact(FrappeTestCase):
+	def test_get_list_context_currency_symbols(self):
+		# get_list_context builds the enabled-currency symbol map via frappe.get_all (converted from
+		# raw SQL). Exercises that query and asserts a known enabled currency is present.
+		from erpnext.controllers.website_list_for_contact import get_list_context
+
+		context = get_list_context()
+
+		symbols = json.loads(context["currency_symbols"])
+		self.assertIsInstance(symbols, dict)
+		self.assertIn("USD", symbols)
+
+	def test_rfq_transaction_list_returns_supplier_rfq(self):
+		# rfq_transaction_list filters RFQs by the supplier (parties[0]) and uses SELECT DISTINCT with
+		# ORDER BY creation -- both must be valid on Postgres, and the supplier filter must compare to the
+		# party value (not a stray `party[0]` column reference).
+		from erpnext.buying.doctype.request_for_quotation.test_request_for_quotation import (
+			make_request_for_quotation,
+		)
+		from erpnext.controllers.website_list_for_contact import rfq_transaction_list
+
+		rfq = make_request_for_quotation()
+		supplier = rfq.suppliers[0].supplier
+
+		rows = rfq_transaction_list(
+			"Request for Quotation Supplier", "Request for Quotation", [supplier], 0, 20
+		)
+		self.assertIn(rfq.name, [row.name for row in rows])

erpnext/controllers/trends.py

@@ -6,6 +6,7 @@ import frappe
 from frappe import _
 from frappe.utils import DateTimeLikeObject, getdate, today
 
+import erpnext
 from erpnext.accounts.utils import get_fiscal_year
 
 
@@ -42,6 +43,9 @@ def get_columns(filters, trans):
 		"addl_tables": based_on_details["addl_tables"],
 		"addl_tables_relational_cond": based_on_details.get("addl_tables_relational_cond", ""),
 	}
+	conditions["company_currency"] = (
+		erpnext.get_company_currency(filters.get("company")) if filters.get("company") else None
+	)
 
 	return conditions
 
@@ -206,7 +210,7 @@ def get_data(filters, conditions):
 
 				data.append(des)
 
-		total_row = calculate_total_row(data1, conditions["columns"])
+		total_row = calculate_total_row(data1, conditions["columns"], conditions.get("company_currency"))
 		data.append(total_row)
 	else:
 		data = frappe.db.sql(
@@ -231,19 +235,24 @@ def get_data(filters, conditions):
 			as_list=1,
 		)
 
-		total_row = calculate_total_row(data, conditions["columns"])
+		total_row = calculate_total_row(data, conditions["columns"], conditions.get("company_currency"))
 		data.append(total_row)
 
 	return data
 
 
-def calculate_total_row(data, columns):
+def calculate_total_row(data, columns, company_currency=None):
 	def wrap_in_quotes(label):
 		return f"'{label}'"
 
 	total_values = {}
+	currency_col_idx = None
 	for i, col in enumerate(columns):
-		if "Float" in col or "Currency/currency" in col:
+		# based-on and group-by columns are dicts, periodic and total columns are strings
+		if isinstance(col, dict):
+			if col.get("fieldtype") == "Link" and col.get("options") == "Currency":
+				currency_col_idx = i
+		elif "Float" in col or "Currency/currency" in col:
 			total_values[i] = 0
 
 	for row in data:
@@ -254,6 +263,9 @@ def calculate_total_row(data, columns):
 	for i in range(1, len(columns)):
 		total_row.append(total_values.get(i, None))
 
+	if currency_col_idx is not None:
+		total_row[currency_col_idx] = company_currency
+
 	return total_row
 
 
@@ -361,13 +373,24 @@ def based_wise_columns_query(based_on, trans):
 
 	# based_on_cols, based_on_select, based_on_group_by, addl_tables
 	if based_on == "Item":
-		based_on_details["based_on_cols"] = ["Item:Link/Item:120", "Item Name:Data:120"]
+		based_on_details["based_on_cols"] = [
+			{"label": _("Item"), "fieldtype": "Link", "options": "Item", "width": 120, "fieldname": "item"},
+			{"label": _("Item Name"), "fieldtype": "Data", "width": 120, "fieldname": "item_name"},
+		]
 		based_on_details["based_on_select"] = "t2.item_code, t2.item_name,"
 		based_on_details["based_on_group_by"] = "t2.item_code"
 		based_on_details["addl_tables"] = ""
 
 	elif based_on == "Item Group":
-		based_on_details["based_on_cols"] = ["Item Group:Link/Item Group:120"]
+		based_on_details["based_on_cols"] = [
+			{
+				"label": _("Item Group"),
+				"fieldtype": "Link",
+				"options": "Item Group",
+				"width": 120,
+				"fieldname": "item_group",
+			}
+		]
 		based_on_details["based_on_select"] = "t2.item_group,"
 		based_on_details["based_on_group_by"] = "t2.item_group"
 		based_on_details["addl_tables"] = ""
@@ -375,32 +398,80 @@ def based_wise_columns_query(based_on, trans):
 	elif based_on == "Customer":
 		if trans == "Quotation":
 			based_on_details["based_on_cols"] = [
-				"Party:Link/Customer:120",
-				"Party Name:Data:120",
-				"Territory:Link/Territory:120",
+				{
+					"label": _("Party"),
+					"fieldtype": "Link",
+					"options": "Customer",
+					"width": 120,
+					"fieldname": "party",
+				},
+				{"label": _("Party Name"), "fieldtype": "Data", "width": 120, "fieldname": "party_name"},
+				{
+					"label": _("Territory"),
+					"fieldtype": "Link",
+					"options": "Territory",
+					"width": 120,
+					"fieldname": "territory",
+				},
 			]
 			based_on_details["based_on_select"] = "t1.party_name, t1.customer_name, t1.territory,"
 		else:
 			based_on_details["based_on_cols"] = [
-				"Customer:Link/Customer:120",
-				"Customer Name:Data:120",
-				"Territory:Link/Territory:120",
+				{
+					"label": _("Customer"),
+					"fieldtype": "Link",
+					"options": "Customer",
+					"width": 120,
+					"fieldname": "customer",
+				},
+				{
+					"label": _("Customer Name"),
+					"fieldtype": "Data",
+					"width": 120,
+					"fieldname": "customer_name",
+				},
+				{
+					"label": _("Territory"),
+					"fieldtype": "Link",
+					"options": "Territory",
+					"width": 120,
+					"fieldname": "territory",
+				},
 			]
 			based_on_details["based_on_select"] = "t1.customer, t1.customer_name, t1.territory,"
 		based_on_details["based_on_group_by"] = "t1.party_name" if trans == "Quotation" else "t1.customer"
 		based_on_details["addl_tables"] = ""
 
 	elif based_on == "Customer Group":
-		based_on_details["based_on_cols"] = ["Customer Group:Link/Customer Group"]
+		based_on_details["based_on_cols"] = [
+			{
+				"label": _("Customer Group"),
+				"fieldtype": "Link",
+				"options": "Customer Group",
+				"fieldname": "customer_group",
+			}
+		]
 		based_on_details["based_on_select"] = "t1.customer_group,"
 		based_on_details["based_on_group_by"] = "t1.customer_group"
 		based_on_details["addl_tables"] = ""
 
 	elif based_on == "Supplier":
 		based_on_details["based_on_cols"] = [
-			"Supplier:Link/Supplier:120",
-			"Supplier Name:Data:120",
-			"Supplier Group:Link/Supplier Group:140",
+			{
+				"label": _("Supplier"),
+				"fieldtype": "Link",
+				"options": "Supplier",
+				"width": 120,
+				"fieldname": "supplier",
+			},
+			{"label": _("Supplier Name"), "fieldtype": "Data", "width": 120, "fieldname": "supplier_name"},
+			{
+				"label": _("Supplier Group"),
+				"fieldtype": "Link",
+				"options": "Supplier Group",
+				"width": 140,
+				"fieldname": "supplier_group",
+			},
 		]
 		based_on_details["based_on_select"] = "t1.supplier, t1.supplier_name, t3.supplier_group,"
 		based_on_details["based_on_group_by"] = "t1.supplier"
@@ -408,26 +479,58 @@ def based_wise_columns_query(based_on, trans):
 		based_on_details["addl_tables_relational_cond"] = " and t1.supplier = t3.name"
 
 	elif based_on == "Supplier Group":
-		based_on_details["based_on_cols"] = ["Supplier Group:Link/Supplier Group:140"]
+		based_on_details["based_on_cols"] = [
+			{
+				"label": _("Supplier Group"),
+				"fieldtype": "Link",
+				"options": "Supplier Group",
+				"width": 140,
+				"fieldname": "supplier_group",
+			}
+		]
 		based_on_details["based_on_select"] = "t3.supplier_group,"
 		based_on_details["based_on_group_by"] = "t3.supplier_group"
 		based_on_details["addl_tables"] = ",`tabSupplier` t3"
 		based_on_details["addl_tables_relational_cond"] = " and t1.supplier = t3.name"
 
 	elif based_on == "Territory":
-		based_on_details["based_on_cols"] = ["Territory:Link/Territory:120"]
+		based_on_details["based_on_cols"] = [
+			{
+				"label": _("Territory"),
+				"fieldtype": "Link",
+				"options": "Territory",
+				"width": 120,
+				"fieldname": "territory",
+			}
+		]
 		based_on_details["based_on_select"] = "t1.territory,"
 		based_on_details["based_on_group_by"] = "t1.territory"
 		based_on_details["addl_tables"] = ""
 
 	elif based_on == "Project":
 		if trans in ["Sales Invoice", "Delivery Note", "Sales Order"]:
-			based_on_details["based_on_cols"] = ["Project:Link/Project:120"]
+			based_on_details["based_on_cols"] = [
+				{
+					"label": _("Project"),
+					"fieldtype": "Link",
+					"options": "Project",
+					"width": 120,
+					"fieldname": "project",
+				}
+			]
 			based_on_details["based_on_select"] = "t1.project,"
 			based_on_details["based_on_group_by"] = "t1.project"
 			based_on_details["addl_tables"] = ""
 		elif trans in ["Purchase Order", "Purchase Invoice", "Purchase Receipt"]:
-			based_on_details["based_on_cols"] = ["Project:Link/Project:120"]
+			based_on_details["based_on_cols"] = [
+				{
+					"label": _("Project"),
+					"fieldtype": "Link",
+					"options": "Project",
+					"width": 120,
+					"fieldname": "project",
+				}
+			]
 			based_on_details["based_on_select"] = "t2.project,"
 			based_on_details["based_on_group_by"] = "t2.project"
 			based_on_details["addl_tables"] = ""
@@ -435,7 +538,15 @@ def based_wise_columns_query(based_on, trans):
 			frappe.throw(_("Project-wise data is not available for Quotation"))
 
 	based_on_details["based_on_select"] += "t4.default_currency as currency,"
-	based_on_details["based_on_cols"].append("Currency:Link/Currency:120")
+	based_on_details["based_on_cols"].append(
+		{
+			"label": _("Currency"),
+			"fieldtype": "Link",
+			"options": "Currency",
+			"width": 120,
+			"fieldname": "currency",
+		}
+	)
 	based_on_details["addl_tables"] += ", `tabCompany` t4"
 	based_on_details["addl_tables_relational_cond"] = (
 		based_on_details.get("addl_tables_relational_cond", "") + " and t1.company = t4.name"
@@ -446,6 +557,14 @@ def based_wise_columns_query(based_on, trans):
 
 def group_wise_column(group_by):
 	if group_by:
-		return [group_by + ":Link/" + group_by + ":120"]
+		return [
+			{
+				"label": _(group_by),
+				"fieldtype": "Link",
+				"options": group_by,
+				"width": 120,
+				"fieldname": frappe.scrub(group_by),
+			}
+		]
 	else:
 		return []

erpnext/controllers/website_list_for_contact.py

@@ -7,6 +7,8 @@ import json
 import frappe
 from frappe import _
 from frappe.modules.utils import get_module_app
+from frappe.query_builder import Criterion
+from frappe.query_builder.functions import Lower
 from frappe.utils import cint, flt, has_common
 from frappe.utils.user import is_website_user
 
@@ -181,9 +183,10 @@ def rfq_transaction_list(parties_doctype, doctype, parties, limit_start, limit_p
 	party = frappe.qb.DocType(parties_doctype)
 	data = (
 		frappe.qb.from_(party)
-		.select(party.parent.as_("name"), party.supplier)
+		# creation must be selected: Postgres requires SELECT DISTINCT order-by exprs in the select list
+		.select(party.parent.as_("name"), party.supplier, party.creation)
 		.distinct()
-		.where((party.supplier == party[0]) & (party.docstatus == 1))
+		.where((party.supplier == parties[0]) & (party.docstatus == 1))
 		.orderby(party.creation, order=frappe.qb.desc)
 		.limit(limit_page_length)
 		.offset(limit_start)
@@ -305,3 +308,63 @@ def add_role_for_portal_user(portal_user, role):
 
 	user_doc.add_roles(role)
 	frappe.msgprint(_("Added {1} Role to User {0}.").format(frappe.bold(user_doc.name), role), alert=True)
+
+
+def link_portal_users_to_contacts(doc):
+	"""When portal users are added to Supplier/Customer, link them to the Contact profile."""
+	# a User's name is its (lowercased) email, so portal_users are already the emails
+	portal_users = {p.user for p in doc.get("portal_users") or [] if p.user}
+	if not portal_users:
+		return
+
+	before = doc.get_doc_before_save()
+	if before:
+		previous_users = {p.user for p in before.get("portal_users") or [] if p.user}
+		if portal_users == previous_users:
+			return
+
+	portal_users = list(portal_users)
+
+	contact = frappe.qb.DocType("Contact")
+	contact_email = frappe.qb.DocType("Contact Email")
+
+	query = (
+		frappe.qb.from_(contact)
+		.left_join(contact_email)
+		.on(contact_email.parent == contact.name)
+		.select(contact.name)
+		.distinct()
+	)
+
+	conditions = [
+		contact.user.isin(portal_users),
+		Lower(contact.email_id).isin(portal_users),
+		Lower(contact_email.email_id).isin(portal_users),
+	]
+
+	query = query.where(Criterion.any(conditions))
+	contacts = query.run(pluck=True)
+
+	if not contacts:
+		return
+
+	dynamic_link = frappe.qb.DocType("Dynamic Link")
+	existing_links = (
+		frappe.qb.from_(dynamic_link)
+		.select(dynamic_link.parent)
+		.where(
+			(dynamic_link.parenttype == "Contact")
+			& (dynamic_link.parent.isin(contacts))
+			& (dynamic_link.link_doctype == doc.doctype)
+			& (dynamic_link.link_name == doc.name)
+		)
+		.run(pluck=True)
+	)
+
+	contacts_to_link = [name for name in contacts if name not in existing_links]
+
+	for name in contacts_to_link:
+		contact_doc = frappe.get_doc("Contact", name)
+		if not contact_doc.has_link(doc.doctype, doc.name):
+			contact_doc.append("links", {"link_doctype": doc.doctype, "link_name": doc.name})
+			contact_doc.save(ignore_permissions=True)

erpnext/crm/doctype/appointment/appointment.json

@@ -7,7 +7,11 @@
  "engine": "InnoDB",
  "field_order": [
   "scheduled_time",
+  "column_break_xaox",
   "status",
+  "created_through_portal",
+  "email_verified",
+  "verification_token",
   "customer_details_section",
   "customer_name",
   "customer_phone_number",
@@ -54,7 +58,8 @@
    "fieldtype": "Datetime",
    "in_list_view": 1,
    "label": "Scheduled Time",
-   "reqd": 1
+   "reqd": 1,
+   "search_index": 1
   },
   {
    "fieldname": "status",
@@ -77,6 +82,7 @@
    "fieldname": "customer_email",
    "fieldtype": "Data",
    "label": "Email",
+   "options": "Email",
    "reqd": 1
   },
   {
@@ -99,14 +105,43 @@
    "fieldtype": "Dynamic Link",
    "label": "Party",
    "options": "appointment_with"
+  },
+  {
+   "default": "0",
+   "fieldname": "created_through_portal",
+   "fieldtype": "Check",
+   "label": "Created through Portal",
+   "read_only": 1,
+   "set_only_once": 1
+  },
+  {
+   "fieldname": "column_break_xaox",
+   "fieldtype": "Column Break"
+  },
+  {
+   "default": "0",
+   "depends_on": "eval:doc.created_through_portal === 1;",
+   "fieldname": "email_verified",
+   "fieldtype": "Check",
+   "label": "Email Verified",
+   "read_only": 1
+  },
+  {
+   "fieldname": "verification_token",
+   "fieldtype": "Data",
+   "label": "Verification Token",
+   "hidden": 1,
+   "read_only": 1,
+   "no_copy": 1,
+   "search_index": 1
   }
  ],
  "links": [],
- "modified": "2022-12-15 11:11:02.131986",
+ "modified": "2026-07-20 02:00:00.000000",
  "modified_by": "Administrator",
  "module": "CRM",
  "name": "Appointment",
- "name_case": "UPPER CASE",
+ "naming_rule": "Expression (old style)",
  "owner": "Administrator",
  "permissions": [
   {
@@ -158,8 +193,9 @@
   }
  ],
  "quick_entry": 1,
- "sort_field": "modified",
+ "row_format": "Dynamic",
+ "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/crm/doctype/appointment/appointment.py

@@ -3,14 +3,20 @@
 
 
 from collections import Counter
+from datetime import timedelta
+from urllib.parse import urlencode
 
 import frappe
 from frappe import _
 from frappe.desk.form.assign_to import add as add_assignment
 from frappe.model.document import Document
 from frappe.share import add_docshare
-from frappe.utils import get_url, getdate, now
-from frappe.utils.verified_command import get_signed_params
+from frappe.utils import add_to_date, cint, date_diff, get_datetime, get_url, getdate, now, now_datetime
+from frappe.utils.data import sha256_hash
+
+from erpnext.setup.doctype.holiday_list.holiday_list import is_holiday
+
+WEEKDAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
 
 
 class Appointment(Document):
@@ -24,103 +30,227 @@ class Appointment(Document):
 
 		appointment_with: DF.Link | None
 		calendar_event: DF.Link | None
+		created_through_portal: DF.Check
 		customer_details: DF.LongText | None
 		customer_email: DF.Data
 		customer_name: DF.Data
 		customer_phone_number: DF.Data | None
 		customer_skype: DF.Data | None
+		email_verified: DF.Check
 		party: DF.DynamicLink | None
 		scheduled_time: DF.Datetime
 		status: DF.Literal["Open", "Unverified", "Closed"]
+		verification_token: DF.Data | None
 	# end: auto-generated types
 
-	def find_lead_by_email(self):
-		lead_list = frappe.get_list(
-			"Lead", filters={"email_id": self.customer_email}, ignore_permissions=True
-		)
-		if lead_list:
-			return lead_list[0].name
-		return None
+	def validate(self):
+		self.validate_status_update()
+		if not self.has_value_changed("scheduled_time"):
+			return
 
-	def find_customer_by_email(self):
-		customer_list = frappe.get_list(
-			"Customer", filters={"email_id": self.customer_email}, ignore_permissions=True
+		self.validate_backdated_booking()
+
+		if is_appointment_scheduling_enabled():
+			self.validate_advanced_booking()
+			self.validate_holiday()
+			self.validate_slot_timing()
+
+		self.validate_available_time_slot()
+
+	def validate_status_update(self):
+		if not self.has_value_changed("status"):
+			return
+
+		if not self.created_through_portal:
+			if self.status == "Unverified":
+				frappe.throw(_("Appointments created manually cannot have 'Unverified' status."))
+			return
+
+		if self.status == "Unverified" and self.email_verified:
+			frappe.throw(_("A verified appointment cannot be moved back to 'Unverified' status."))
+
+		if self.status == "Open" and not self.email_verified:
+			frappe.throw(
+				_("An appointment booked through the portal can only be opened via email verification.")
+			)
+
+	def validate_backdated_booking(self):
+		if get_datetime(self.scheduled_time) < now_datetime():
+			frappe.throw(_("Appointment cannot be scheduled for a past time."))
+
+	def validate_advanced_booking(self):
+		advance_booking_days = cint(get_booking_settings().advance_booking_days)
+
+		if advance_booking_days and date_diff(self.scheduled_time, now_datetime()) > advance_booking_days:
+			frappe.throw(
+				_("Appointment can only be scheduled up to {0} day(s) in advance.").format(
+					advance_booking_days
+				)
+			)
+
+	def validate_holiday(self):
+		holiday_list = get_booking_settings().holiday_list
+
+		if not holiday_list:
+			frappe.throw(_("Please add a valid Holiday List on Appointment Booking Settings."))
+
+		if is_holiday(holiday_list, getdate(self.scheduled_time)):
+			frappe.throw(_("Appointment cannot be scheduled on a holiday."))
+
+	def validate_slot_timing(self):
+		settings = get_booking_settings()
+		if not settings.availability_of_slots:
+			frappe.throw(_("No availability of slots are found. Please add on Appointment Booking Settings."))
+
+		scheduled_time = get_datetime(self.scheduled_time)
+		day_of_week = WEEKDAYS[scheduled_time.weekday()]
+		slot_start = timedelta(
+			hours=scheduled_time.hour, minutes=scheduled_time.minute, seconds=scheduled_time.second
 		)
-		if customer_list:
-			return customer_list[0].name
-		return None
+		slot_end = slot_start + timedelta(minutes=cint(settings.appointment_duration))
+
+		for slot in settings.availability_of_slots:
+			if slot.day_of_week == day_of_week and slot.from_time <= slot_start and slot_end <= slot.to_time:
+				return
+
+		frappe.throw(_("Appointment must be scheduled within the available slot timings."))
+
+	def validate_available_time_slot(self):
+		settings = get_booking_settings()
+		if not cint(settings.number_of_agents):
+			return
+
+		# the locking read serializes concurrent bookings for the same window,
+		# so two simultaneous requests cannot both pass the capacity check
+		booked = count_overlapping_appointments(
+			self.scheduled_time,
+			cint(settings.appointment_duration),
+			exclude_appointment=self.name,
+			for_update=True,
+		)
+
+		if booked >= cint(settings.number_of_agents):
+			frappe.throw(_("Time slot is not available"))
 
 	def before_insert(self):
-		number_of_appointments_in_same_slot = frappe.db.count(
-			"Appointment", filters={"scheduled_time": self.scheduled_time}
-		)
-		number_of_agents = frappe.db.get_single_value("Appointment Booking Settings", "number_of_agents")
-		if not number_of_agents == 0:
-			if number_of_appointments_in_same_slot >= number_of_agents:
-				frappe.throw(_("Time slot is not available"))
-		# Link lead
-		if not self.party:
-			lead = self.find_lead_by_email()
-			customer = self.find_customer_by_email()
-			if customer:
-				self.appointment_with = "Customer"
-				self.party = customer
-			else:
-				self.appointment_with = "Lead"
-				self.party = lead
+		# Set status to "Unverified" for new Appointments.
+		if self.created_through_portal:
+			self.status = "Unverified"
+			return
+
+		self.link_customer_lead()
 
 	def after_insert(self):
-		if self.party:
-			# Create Calendar event
+		if not self.created_through_portal and self.party:
 			self.auto_assign()
 			self.create_calendar_event()
-		else:
-			# Set status to unverified
-			self.status = "Unverified"
-			# Send email to confirm
-			self.send_confirmation_email()
+			return
+
+		# Send email to confirm
+		self.send_confirmation_email()
+
+	def on_update(self):
+		# capture transitions before nested saves during materialization
+		# refresh the before-save snapshot
+		status_changed = self.has_value_changed("status")
+		email_just_verified = bool(
+			self.created_through_portal and self.email_verified
+		) and self.has_value_changed("email_verified")
+
+		self.link_auto_assign_and_create_calendar_event()
+
+		if email_just_verified:
+			self.send_appointment_confirmed_email()
+
+		if status_changed:
+			self.update_event_and_assignments_status()
+
+	def on_trash(self):
+		# the Event only references the party, not the appointment,
+		# so it must be cleaned up explicitly
+		if not self.calendar_event:
+			return
+
+		event = self.calendar_event
+		self.db_set("calendar_event", None, update_modified=False)
+		frappe.delete_doc("Event", event, ignore_permissions=True)
 
 	def send_confirmation_email(self):
-		verify_url = self._get_verify_url()
-		template = "confirm_appointment"
-		args = {
-			"link": verify_url,
-			"site_url": frappe.utils.get_url(),
-			"full_name": self.customer_name,
-		}
+		self.send_email_to_customer(
+			template="confirm_appointment",
+			subject=_("Appointment Confirmation"),
+			args={"link": self._get_verify_url(), "expiry_minutes": get_verification_link_expiry()},
+		)
+		frappe.msgprint(_("Please check your email to confirm the appointment."))
+
+	def send_appointment_confirmed_email(self):
+		self.send_email_to_customer(
+			template="appointment_confirmed",
+			subject=_("Appointment Confirmed"),
+			args={"scheduled_time": frappe.utils.format_datetime(self.scheduled_time)},
+			reference_doctype="Appointment",
+			reference_name=self.name,
+		)
+
+	def send_email_to_customer(self, template, subject, args, **kwargs):
 		frappe.sendmail(
 			recipients=[self.customer_email],
 			template=template,
-			args=args,
-			subject=_("Appointment Confirmation"),
+			args={"full_name": self.customer_name, "site_url": frappe.utils.get_url(), **args},
+			subject=subject,
+			**kwargs,
 		)
-		if frappe.session.user == "Guest":
-			frappe.msgprint(_("Please check your email to confirm the appointment"))
-		else:
-			frappe.msgprint(
-				_("Appointment was created. But no lead was found. Please check the email to confirm")
-			)
 
-	def on_change(self):
-		# Sync Calendar
-		if not self.calendar_event:
+	def link_auto_assign_and_create_calendar_event(self):
+		if self.is_new() or (self.created_through_portal and not self.email_verified):
 			return
+
+		if not self.calendar_event:
+			# first materialization: link the party, assign an agent, create the event
+			self.link_customer_lead()
+			self.auto_assign()
+			self.create_calendar_event()
+
+		self.sync_calendar_event()
+
+	def sync_calendar_event(self):
+		if not self.calendar_event or not self.has_value_changed("scheduled_time"):
+			return
+
 		cal_event = frappe.get_doc("Event", self.calendar_event)
 		cal_event.starts_on = self.scheduled_time
 		cal_event.save(ignore_permissions=True)
 
-	def set_verified(self, email):
-		if not email == self.customer_email:
-			frappe.throw(_("Email verification failed."))
-		# Create new lead
+	def update_event_and_assignments_status(self):
+		"""Close or reopen the calendar event and assignments along with the appointment."""
+		if self.status == "Unverified":
+			return
+
+		is_closed = self.status == "Closed"
+		new_status = "Closed" if is_closed else "Open"
+
+		if self.calendar_event:
+			frappe.db.set_value("Event", self.calendar_event, "status", new_status)
+
+		# only move ToDos between Open and Closed - never touch Cancelled ones
+		todo_filters = {
+			"reference_type": "Appointment",
+			"reference_name": self.name,
+			"status": "Open" if is_closed else "Closed",
+		}
+		frappe.db.set_value("ToDo", todo_filters, "status", new_status)
+
+	def link_customer_lead(self):
+		if not self.party:
+			customer = self.find_party_by_email("Customer")
+			self.appointment_with = "Customer" if customer else "Lead"
+			self.party = customer or self.find_party_by_email("Lead")
+
 		self.create_lead_and_link()
-		# Remove unverified status
-		self.status = "Open"
-		# Create calender event
-		self.auto_assign()
-		self.create_calendar_event()
-		self.save(ignore_permissions=True)
-		frappe.db.commit()
+
+	def find_party_by_email(self, doctype):
+		party = frappe.get_all(doctype, filters={"email_id": self.customer_email}, limit=1, pluck="name")
+		return party[0] if party else None
 
 	def create_lead_and_link(self):
 		# Return if already linked
@@ -139,86 +269,39 @@ class Appointment(Document):
 		if self.customer_details:
 			lead.append(
 				"notes",
-				{
-					"note": self.customer_details,
-					"added_by": frappe.session.user,
-					"added_on": now(),
-				},
+				{"note": self.customer_details, "added_by": frappe.session.user, "added_on": now()},
 			)
 
-		lead.insert(ignore_permissions=True)
-
-		# Link lead
-		self.party = lead.name
+		self.party = lead.insert(ignore_permissions=True).name
 
 	def auto_assign(self):
-		existing_assignee = self.get_assignee_from_latest_opportunity()
-		if existing_assignee:
-			# If the latest opportunity is assigned to someone
-			# Assign the appointment to the same
-			self.assign_agent(existing_assignee)
-			return
 		if self._assign:
 			return
-		available_agents = _get_agents_sorted_by_asc_workload(getdate(self.scheduled_time))
-		for agent in available_agents:
-			if _check_agent_availability(agent, self.scheduled_time):
-				self.assign_agent(agent[0])
-			break
+
+		if existing_assignee := self.get_assignee_from_latest_opportunity():
+			# assign to whoever handles the party's latest opportunity
+			self.assign_agent(existing_assignee)
+			return
+
+		busy_agents = get_busy_agents(self.scheduled_time)
+		for agent in _get_agents_sorted_by_asc_workload(getdate(self.scheduled_time)):
+			if agent not in busy_agents:
+				self.assign_agent(agent)
+				break
 
 	def get_assignee_from_latest_opportunity(self):
-		if not self.party:
+		if not self.party or not frappe.db.exists("Lead", self.party):
 			return None
-		if not frappe.db.exists("Lead", self.party):
-			return None
-		opporutnities = frappe.get_list(
+
+		opportunities = frappe.get_all(
 			"Opportunity",
-			filters={
-				"party_name": self.party,
-			},
-			ignore_permissions=True,
+			filters={"party_name": self.party},
+			fields=["_assign"],
 			order_by="creation desc",
+			limit=1,
 		)
-		if not opporutnities:
-			return None
-		latest_opportunity = frappe.get_doc("Opportunity", opporutnities[0].name)
-		assignee = latest_opportunity._assign
-		if not assignee:
-			return None
-		assignee = frappe.parse_json(assignee)[0]
-		return assignee
-
-	def create_calendar_event(self):
-		if self.calendar_event:
-			return
-		appointment_event = frappe.get_doc(
-			{
-				"doctype": "Event",
-				"subject": " ".join(["Appointment with", self.customer_name]),
-				"starts_on": self.scheduled_time,
-				"status": "Open",
-				"type": "Public",
-				"send_reminder": frappe.db.get_single_value(
-					"Appointment Booking Settings", "email_reminders"
-				),
-				"event_participants": [
-					dict(reference_doctype=self.appointment_with, reference_docname=self.party)
-				],
-			}
-		)
-		employee = _get_employee_from_user(self._assign)
-		if employee:
-			appointment_event.append(
-				"event_participants", dict(reference_doctype="Employee", reference_docname=employee.name)
-			)
-		appointment_event.insert(ignore_permissions=True)
-		self.calendar_event = appointment_event.name
-		self.save(ignore_permissions=True)
-
-	def _get_verify_url(self):
-		verify_route = "/book_appointment/verify"
-		params = {"email": self.customer_email, "appointment": self.name}
-		return get_url(verify_route + "?" + get_signed_params(params))
+		assignees = opportunities and frappe.parse_json(opportunities[0]._assign or "[]")
+		return assignees[0] if assignees else None
 
 	def assign_agent(self, agent):
 		if not frappe.has_permission(doc=self, user=agent):
@@ -226,45 +309,157 @@ class Appointment(Document):
 
 		add_assignment({"doctype": self.doctype, "name": self.name, "assign_to": [agent]})
 
+	def create_calendar_event(self):
+		if self.calendar_event:
+			return
+
+		event = frappe.get_doc(
+			{
+				"doctype": "Event",
+				"subject": f"Appointment with {self.customer_name}",
+				"starts_on": self.scheduled_time,
+				"status": "Open",
+				"type": "Public",
+				"send_reminder": cint(get_booking_settings().email_reminders),
+				"event_participants": self.get_event_participants(),
+			}
+		).insert(ignore_permissions=True)
+
+		self.calendar_event = event.name
+		self.save(ignore_permissions=True)
+
+	def get_event_participants(self):
+		participants = [dict(reference_doctype=self.appointment_with, reference_docname=self.party)]
+
+		if employee := _get_employee_from_user(self._assign):
+			participants.append(dict(reference_doctype="Employee", reference_docname=employee.name))
+
+		return participants
+
+	def _get_verify_url(self):
+		key = self.generate_verification_key()
+		return get_url("/book_appointment/verify?" + urlencode({"key": key}))
+
+	def generate_verification_key(self):
+		# store only the hash; the raw key lives solely in the emailed link
+		key = frappe.generate_hash()
+		self.db_set("verification_token", sha256_hash(key), update_modified=False)
+		return key
+
+
+def get_booking_settings():
+	return frappe.get_cached_doc("Appointment Booking Settings")
+
+
+def is_appointment_scheduling_enabled():
+	return bool(cint(get_booking_settings().enable_scheduling))
+
+
+def get_verification_link_expiry():
+	"""Verification link expiry window in minutes."""
+	return cint(get_booking_settings().verification_link_expiry_duration)
+
+
+def count_overlapping_appointments(
+	scheduled_time, appointment_duration, exclude_appointment=None, for_update=False
+):
+	"""Count non-Closed appointments whose duration window overlaps `scheduled_time`.
+	With `for_update`, the range stays locked until commit, serializing concurrent bookings."""
+	# select the rows (not COUNT) so `for_update` stays valid: PostgreSQL
+	# rejects `FOR UPDATE` combined with an aggregate function
+	appointment = frappe.qb.DocType("Appointment")
+	query = (
+		frappe.qb.from_(appointment)
+		.select(appointment.name)
+		.where(appointment.scheduled_time > add_to_date(scheduled_time, minutes=-appointment_duration))
+		.where(appointment.scheduled_time < add_to_date(scheduled_time, minutes=appointment_duration))
+		.where(appointment.status != "Closed")
+	)
+
+	if exclude_appointment:
+		query = query.where(appointment.name != exclude_appointment)
+
+	if for_update:
+		query = query.for_update()
+
+	return len(query.run())
+
+
+def handle_expired_unverified_appointments():
+	"""Close or delete Unverified appointments whose verification link has expired."""
+	expiry = get_verification_link_expiry()
+	if not expiry:
+		return
+
+	cutoff = add_to_date(now_datetime(), minutes=-expiry)
+	filters = {"status": "Unverified", "creation": ("<", cutoff)}
+	action = get_booking_settings().action_for_expired_unverified_appointments or "Mark as Closed"
+
+	if action == "Mark as Closed":
+		frappe.db.set_value("Appointment", filters, "status", "Closed")
+	elif action == "Delete Permanently":
+		for name in frappe.get_all("Appointment", filters=filters, pluck="name"):
+			frappe.delete_doc("Appointment", name, ignore_permissions=True)
+
 
 def _get_agents_sorted_by_asc_workload(date):
-	appointments = frappe.get_all("Appointment", fields="*")
-	agent_list = _get_agent_list_as_strings()
-	if not appointments:
-		return agent_list
-	appointment_counter = Counter(agent_list)
-	for appointment in appointments:
-		assign_data = appointment._assign
-		if isinstance(assign_data, str):
-			assign_data = assign_data.strip()
-		if not assign_data:
-			continue
-		assigned_to = frappe.parse_json(assign_data)
-		if assigned_to and (assigned_to[0] in agent_list) and getdate(appointment.scheduled_time) == date:
-			appointment_counter[assigned_to[0]] += 1
-	sorted_agent_list = appointment_counter.most_common()
-	sorted_agent_list.reverse()
-	return sorted_agent_list
+	# count only the given day's assignments; scheduled_time is indexed so the
+	# date range is resolved in SQL instead of scanning every appointment ever
+	workload = Counter(agent.user for agent in get_booking_settings().agent_list)
+	assigns = frappe.get_all(
+		"Appointment",
+		filters=[
+			["_assign", "is", "set"],
+			["scheduled_time", ">=", getdate(date)],
+			["scheduled_time", "<", add_to_date(getdate(date), days=1)],
+		],
+		pluck="_assign",
+	)
+
+	for assign in assigns:
+		assignees = frappe.parse_json((assign or "").strip() or "[]")
+		if assignees and assignees[0] in workload:
+			workload[assignees[0]] += 1
+
+	return [agent for agent, _workload in reversed(workload.most_common())]
 
 
-def _get_agent_list_as_strings():
-	agent_list_as_strings = []
-	agent_list = frappe.get_doc("Appointment Booking Settings").agent_list
-	for agent in agent_list:
-		agent_list_as_strings.append(agent.user)
-	return agent_list_as_strings
+def get_busy_agents(scheduled_time):
+	"""Agents already assigned to a non-Closed appointment overlapping `scheduled_time`."""
+	duration = _get_appointment_duration()
+	assigns = frappe.get_all(
+		"Appointment",
+		filters=[
+			["scheduled_time", ">", add_to_date(scheduled_time, minutes=-duration)],
+			["scheduled_time", "<", add_to_date(scheduled_time, minutes=duration)],
+			["status", "!=", "Closed"],
+		],
+		pluck="_assign",
+	)
+	return {assignee for assign in assigns for assignee in frappe.parse_json(assign or "[]")}
 
 
 def _check_agent_availability(agent_email, scheduled_time):
-	appointemnts_at_scheduled_time = frappe.get_all("Appointment", filters={"scheduled_time": scheduled_time})
-	for appointment in appointemnts_at_scheduled_time:
-		if appointment._assign == agent_email:
-			return False
-	return True
+	return agent_email not in get_busy_agents(scheduled_time)
+
+
+def get_booked_slot_times(from_time, to_time):
+	"""scheduled_times of non-Closed appointments within (from_time, to_time), for slot availability."""
+	return frappe.get_all(
+		"Appointment",
+		filters=[
+			["scheduled_time", ">", from_time],
+			["scheduled_time", "<", to_time],
+			["status", "!=", "Closed"],
+		],
+		pluck="scheduled_time",
+	)
+
+
+def _get_appointment_duration():
+	return cint(get_booking_settings().appointment_duration)
 
 
 def _get_employee_from_user(user):
 	employee_docname = frappe.db.get_value("Employee", {"user_id": user})
-	if employee_docname:
-		return frappe.get_doc("Employee", employee_docname)
-	return None
+	return frappe.get_doc("Employee", employee_docname) if employee_docname else None

erpnext/crm/doctype/appointment/test_appointment.py

@@ -2,37 +2,175 @@
 # See license.txt
 
 import datetime
-import unittest
+from unittest.mock import patch
+from urllib.parse import parse_qs, urlparse
 
 import frappe
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import add_to_date, getdate, now_datetime, set_request
+from frappe.utils.data import get_system_timezone, sha256_hash
+
+from erpnext.crm.doctype.appointment.appointment import (
+	Appointment,
+	_check_agent_availability,
+	handle_expired_unverified_appointments,
+)
+from erpnext.setup.doctype.holiday_list.test_holiday_list import make_holiday_list
+from erpnext.www.book_appointment.index import create_appointment, get_appointment_slots
+from erpnext.www.book_appointment.verify import index as verify_index
 
 LEAD_EMAIL = "test_appointment_lead@example.com"
+VERIFICATION_EXPIRY_MINUTES = 30
+ALL_WEEKDAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
 
 
-def create_test_appointment():
-	test_appointment = frappe.get_doc(
-		{
-			"doctype": "Appointment",
-			"status": "Open",
-			"customer_name": "Test Lead",
-			"customer_phone_number": "666",
-			"customer_skype": "test",
-			"customer_email": LEAD_EMAIL,
-			"scheduled_time": datetime.datetime.now(),
-			"customer_details": "Hello, Friend!",
-		}
-	)
+def create_test_appointment(**kwargs):
+	args = {
+		"doctype": "Appointment",
+		"status": "Open",
+		"customer_name": "Test Lead",
+		"customer_phone_number": "666",
+		"customer_skype": "test",
+		"customer_email": LEAD_EMAIL,
+		"scheduled_time": add_to_date(now_datetime(), hours=2),
+		"customer_details": "Hello, Friend!",
+	}
+	args.update(kwargs)
+	test_appointment = frappe.get_doc(args)
 	test_appointment.insert()
 	return test_appointment
 
 
-class TestAppointment(unittest.TestCase):
-	def setUpClass():
-		frappe.db.delete("Lead", {"email_id": LEAD_EMAIL})
+def create_lead(email, name="Existing Lead"):
+	frappe.db.delete("Lead", {"email_id": email})
+	return frappe.get_doc({"doctype": "Lead", "lead_name": name, "email_id": email}).insert(
+		ignore_permissions=True
+	)
 
+
+def set_booking_setting(field, value):
+	frappe.db.set_single_value("Appointment Booking Settings", field, value)
+
+
+def slot_on(days_from_now, hour, minute=0):
+	day = datetime.date.today() + datetime.timedelta(days=days_from_now)
+	return datetime.datetime.combine(day, datetime.time(hour, minute))
+
+
+def backdate_creation(appointment_name, minutes):
+	frappe.db.set_value(
+		"Appointment",
+		appointment_name,
+		"creation",
+		add_to_date(now_datetime(), minutes=-minutes),
+		update_modified=False,
+	)
+
+
+def get_status(appointment_name):
+	return frappe.db.get_value("Appointment", appointment_name, "status")
+
+
+def get_assignees(appointment_name):
+	return frappe.parse_json(frappe.db.get_value("Appointment", appointment_name, "_assign") or "[]")
+
+
+def get_todo_statuses(appointment_name):
+	return frappe.get_all(
+		"ToDo",
+		filters={"reference_type": "Appointment", "reference_name": appointment_name},
+		pluck="status",
+	)
+
+
+def parse_verify_url(verify_url):
+	parsed = urlparse(verify_url)
+	return parsed, {key: value[0] for key, value in parse_qs(parsed.query).items()}
+
+
+class TestAppointment(FrappeTestCase):
 	def setUp(self):
+		# sending an email commits the transaction (EmailQueue sets its status
+		# with commit=True), which would break the per-test rollback below
+		frappe.flags.mute_emails = 1
+		set_booking_setting("verification_link_expiry_duration", VERIFICATION_EXPIRY_MINUTES)
+		frappe.db.delete("Lead", {"email_id": LEAD_EMAIL})
 		self.test_appointment = create_test_appointment()
-		self.test_appointment.set_verified(self.test_appointment.customer_email)
+
+	def tearDown(self):
+		frappe.db.rollback()
+		frappe.clear_document_cache("Appointment Booking Settings", "Appointment Booking Settings")
+		frappe.flags.mute_emails = 0
+
+	def _configure_booking_settings(self, holiday_dates=None, agents=None):
+		holiday_list = make_holiday_list(
+			"_Test Appointment Holiday List",
+			from_date=getdate(),
+			to_date=add_to_date(getdate(), days=60),
+			holiday_dates=holiday_dates or [],
+		)
+
+		settings = frappe.get_doc("Appointment Booking Settings")
+		settings.enable_scheduling = 1
+		settings.enable_appointment_portal = 1
+		settings.appointment_duration = 30
+		settings.advance_booking_days = 30
+		settings.verification_link_expiry_duration = VERIFICATION_EXPIRY_MINUTES
+		settings.holiday_list = holiday_list.name
+		settings.set("agent_list", [])
+		for agent in agents or ["Administrator"]:
+			settings.append("agent_list", {"user": agent})
+		settings.set("availability_of_slots", [])
+		for day in ALL_WEEKDAYS:
+			settings.append(
+				"availability_of_slots", {"day_of_week": day, "from_time": "09:00:00", "to_time": "17:00:00"}
+			)
+		settings.save()
+
+	def _create_portal_appointment(self, email, days_from_now=7, time="10:00:00"):
+		"""Book as Guest. The verification email is mocked and kept on
+		``self._verification_email_mock`` for assertions."""
+		if not getattr(self, "_booking_settings_configured", False):
+			self._configure_booking_settings()
+			self._booking_settings_configured = True
+
+		with self.set_user("Guest"), patch.object(Appointment, "send_confirmation_email") as mock_send:
+			appointment = create_appointment(
+				date=str(datetime.date.today() + datetime.timedelta(days=days_from_now)),
+				time=time,
+				tz=get_system_timezone(),
+				contact={"name": "Portal Visitor", "email": email, "number": "123", "skype": "", "notes": ""},
+			)
+		self._verification_email_mock = mock_send
+		return appointment
+
+	def _request_verification(self, appointment, verify_url=None):
+		"""Simulate the GET request made by clicking the emailed verification link.
+
+		The confirmation email sent on successful verification is mocked and kept
+		on ``self._confirmed_email_mock`` for assertions.
+		"""
+		parsed, params = parse_verify_url(verify_url or appointment._get_verify_url())
+
+		old_request = getattr(frappe.local, "request", None)
+		old_form_dict = frappe.local.form_dict
+		old_user = frappe.session.user
+		try:
+			# the real link is clicked by an anonymous visitor; set_user resets
+			# form_dict, so switch the user before populating the request
+			frappe.set_user("Guest")
+			set_request(method="GET", path=f"{parsed.path}?{parsed.query}")
+			frappe.local.form_dict = frappe._dict(params)
+			context = frappe._dict()
+			with patch.object(Appointment, "send_appointment_confirmed_email") as mock_confirmed:
+				verify_index.get_context(context)
+			self._confirmed_email_mock = mock_confirmed
+			return context
+		finally:
+			frappe.set_user(old_user)
+			frappe.local.request = old_request
+			frappe.local.form_dict = old_form_dict
+			frappe.local.flags.commit = False
 
 	def test_calendar_event_created(self):
 		cal_event = frappe.get_doc("Event", self.test_appointment.calendar_event)
@@ -40,3 +178,369 @@ class TestAppointment(unittest.TestCase):
 
 	def test_lead_linked(self):
 		self.assertTrue(self.test_appointment.party)
+
+	def test_desk_created_appointment_skips_email_verification(self):
+		"""Appointments created from the desk (created_through_portal unset) must be
+		linked and confirmed immediately - no verification email should be sent."""
+		with patch.object(Appointment, "send_confirmation_email") as mock_send:
+			appointment = create_test_appointment(customer_email="another_desk_lead@example.com")
+
+		mock_send.assert_not_called()
+		self.assertEqual(appointment.status, "Open")
+		self.assertTrue(appointment.party)
+		frappe.db.delete("Lead", {"email_id": "another_desk_lead@example.com"})
+
+	def test_portal_booking_stays_unverified_for_existing_lead(self):
+		"""A portal booking whose email matches an existing Lead/Customer must NOT
+		be auto-linked - it must stay Unverified until the email is confirmed."""
+		create_lead("existing_lead@example.com")
+		appointment = self._create_portal_appointment("existing_lead@example.com", days_from_now=5)
+
+		self._verification_email_mock.assert_called_once()
+		self.assertTrue(appointment.created_through_portal)
+		self.assertEqual(appointment.status, "Unverified")
+		self.assertFalse(appointment.email_verified)
+		self.assertFalse(appointment.party)
+
+	def test_verify_url_uses_opaque_token(self):
+		appointment = self._create_portal_appointment("portal_visitor@example.com")
+		parsed, params = parse_verify_url(appointment._get_verify_url())
+
+		# the link carries only an opaque key - no email, name or signed params
+		self.assertEqual(set(params), {"key"})
+		self.assertNotIn("email", parsed.query)
+		# only the hash of that key is stored on the appointment
+		stored = frappe.db.get_value("Appointment", appointment.name, "verification_token")
+		self.assertEqual(stored, sha256_hash(params["key"]))
+
+	def test_email_verification_within_expiry_window(self):
+		# Link used within the validity window - verification succeeds and the
+		# appointment gets linked, assigned and added to the calendar
+		on_time = self._create_portal_appointment("portal_visitor_on_time@example.com")
+		context = self._request_verification(on_time)
+
+		self.assertTrue(context.success)
+		self._confirmed_email_mock.assert_called_once()
+		on_time.reload()
+		self.assertEqual(on_time.status, "Open")
+		self.assertTrue(on_time.email_verified)
+		self.assertTrue(on_time.party)
+		self.assertTrue(on_time.calendar_event)
+
+		# Link used after the validity window - verification fails
+		late = self._create_portal_appointment("portal_visitor_late@example.com", days_from_now=10)
+		after_expiry = add_to_date(now_datetime(), minutes=VERIFICATION_EXPIRY_MINUTES + 1)
+		with patch.object(verify_index, "now_datetime", return_value=after_expiry):
+			context = self._request_verification(late)
+
+		self.assertFalse(context.success)
+		self._confirmed_email_mock.assert_not_called()
+		late.reload()
+		self.assertEqual(late.status, "Unverified")
+		self.assertFalse(late.email_verified)
+		self.assertFalse(late.party)
+
+	def test_verification_link_reused_after_success(self):
+		appointment = self._create_portal_appointment("portal_visitor_twice@example.com")
+		verify_url = appointment._get_verify_url()
+
+		context = self._request_verification(appointment, verify_url=verify_url)
+		self.assertTrue(context.success)
+		self._confirmed_email_mock.assert_called_once()
+
+		# re-clicking the link is idempotent and does not send another email
+		context = self._request_verification(appointment, verify_url=verify_url)
+		self.assertTrue(context.success)
+		self.assertIn("already verified", context.message)
+		self._confirmed_email_mock.assert_not_called()
+
+	def test_verification_link_for_deleted_appointment(self):
+		"""A verification link can outlive its appointment - clicking it must
+		render a friendly message, not crash."""
+		appointment = self._create_portal_appointment("portal_visitor_gone@example.com")
+		verify_url = appointment._get_verify_url()
+		frappe.delete_doc("Appointment", appointment.name, ignore_permissions=True)
+
+		context = self._request_verification(appointment, verify_url=verify_url)
+
+		self.assertFalse(context.success)
+		self.assertIn("book the appointment again", context.message)
+
+	def test_reschedule_syncs_calendar_event(self):
+		new_time = add_to_date(self.test_appointment.scheduled_time, hours=1)
+		self.test_appointment.scheduled_time = new_time
+		self.test_appointment.save()
+
+		starts_on = frappe.db.get_value("Event", self.test_appointment.calendar_event, "starts_on")
+		self.assertEqual(starts_on, new_time)
+
+	def test_portal_endpoint_disabled(self):
+		self._configure_booking_settings()
+		set_booking_setting("enable_appointment_portal", 0)
+
+		with self.set_user("Guest"), self.assertRaises(frappe.Redirect):
+			create_appointment(
+				date=str(datetime.date.today() + datetime.timedelta(days=3)),
+				time="10:00:00",
+				tz="UTC",
+				contact={
+					"name": "Blocked",
+					"email": "blocked@example.com",
+					"number": "1",
+					"skype": "",
+					"notes": "",
+				},
+			)
+
+	def test_booked_slot_unavailable_on_portal(self):
+		self._configure_booking_settings()
+		tz = get_system_timezone()
+		day = datetime.date.today() + datetime.timedelta(days=2)
+
+		def get_availability():
+			with self.set_user("Guest"):
+				slots = get_appointment_slots(str(day), tz)
+			return {slot["time"].strftime("%H:%M"): slot["availability"] for slot in slots}
+
+		booked = create_test_appointment(
+			customer_email="slot_taken@example.com", scheduled_time=slot_on(2, 10)
+		)
+
+		availability = get_availability()
+		self.assertFalse(availability["10:00"])
+		self.assertTrue(availability["13:00"])
+
+		# closing the appointment frees its slot on the portal
+		booked.status = "Closed"
+		booked.save()
+		self.assertTrue(get_availability()["10:00"])
+
+		# an off-grid desk appointment blocks every portal slot it overlaps
+		create_test_appointment(customer_email="off_grid@example.com", scheduled_time=slot_on(2, 13, 15))
+		availability = get_availability()
+		self.assertFalse(availability["13:00"])
+		self.assertFalse(availability["13:30"])
+		self.assertTrue(availability["14:00"])
+
+	def test_expired_unverified_appointments_are_closed(self):
+		stale = self._create_portal_appointment("portal_visitor_stale@example.com", days_from_now=8)
+		fresh = self._create_portal_appointment("portal_visitor_fresh@example.com", days_from_now=9)
+		verify_url = stale._get_verify_url()
+
+		backdate_creation(stale.name, VERIFICATION_EXPIRY_MINUTES + 15)
+		set_booking_setting("action_for_expired_unverified_appointments", "Mark as Closed")
+
+		handle_expired_unverified_appointments()
+
+		self.assertEqual(get_status(stale.name), "Closed")
+		self.assertEqual(get_status(fresh.name), "Unverified")
+		# Open appointments are never touched, regardless of age
+		self.assertEqual(get_status(self.test_appointment.name), "Open")
+
+		# clicking the link of a closed appointment renders a friendly message
+		context = self._request_verification(stale, verify_url=verify_url)
+		self.assertFalse(context.success)
+		self.assertIn("closed", context.message)
+
+	def test_expired_unverified_appointments_are_deleted(self):
+		stale = self._create_portal_appointment("portal_visitor_purged@example.com", days_from_now=8)
+		fresh = self._create_portal_appointment("portal_visitor_kept@example.com", days_from_now=9)
+
+		backdate_creation(stale.name, VERIFICATION_EXPIRY_MINUTES + 15)
+		set_booking_setting("action_for_expired_unverified_appointments", "Delete Permanently")
+
+		handle_expired_unverified_appointments()
+
+		self.assertFalse(frappe.db.exists("Appointment", stale.name))
+		self.assertTrue(frappe.db.exists("Appointment", fresh.name))
+		self.assertTrue(frappe.db.exists("Appointment", self.test_appointment.name))
+
+	def test_cleanup_skipped_when_expiry_not_configured(self):
+		appointment = self._create_portal_appointment("portal_visitor_no_expiry@example.com")
+		backdate_creation(appointment.name, 5)
+		set_booking_setting("verification_link_expiry_duration", 0)
+
+		handle_expired_unverified_appointments()
+
+		self.assertEqual(get_status(appointment.name), "Unverified")
+
+	def test_status_transition_rules(self):
+		# desk appointments can never be Unverified
+		with self.assertRaises(frappe.ValidationError):
+			create_test_appointment(customer_email="desk_unverified@example.com", status="Unverified")
+
+		# portal appointments cannot be opened manually before verification
+		unverified = self._create_portal_appointment("manual_open@example.com")
+		unverified.status = "Open"
+		with self.assertRaises(frappe.ValidationError):
+			unverified.save(ignore_permissions=True)
+
+		# verified appointments cannot be reverted to Unverified
+		verified = self._create_portal_appointment("revert_unverified@example.com", days_from_now=8)
+		self._request_verification(verified)
+		verified.reload()
+		verified.status = "Unverified"
+		with self.assertRaises(frappe.ValidationError):
+			verified.save(ignore_permissions=True)
+
+		# both desk and verified portal appointments can be closed and reopened
+		for appointment in (self.test_appointment, verified):
+			appointment.reload()
+			appointment.status = "Closed"
+			appointment.save(ignore_permissions=True)
+			appointment.status = "Open"
+			appointment.save(ignore_permissions=True)
+			self.assertEqual(appointment.status, "Open")
+
+	def test_agent_auto_assignment(self):
+		agent_email = "appointment_agent@example.com"
+		if not frappe.db.exists("User", agent_email):
+			frappe.get_doc(
+				{"doctype": "User", "email": agent_email, "first_name": "Appointment Agent"}
+			).insert(ignore_permissions=True)
+
+		self._configure_booking_settings(agents=["Administrator", agent_email])
+		first = create_test_appointment(
+			customer_email="assigned_one@example.com", scheduled_time=slot_on(2, 11)
+		)
+		second = create_test_appointment(
+			customer_email="assigned_two@example.com", scheduled_time=slot_on(2, 11)
+		)
+
+		# both appointments in the same slot get an agent, and never the same one
+		self.assertTrue(get_assignees(first.name))
+		self.assertTrue(get_assignees(second.name))
+		self.assertNotEqual(get_assignees(first.name), get_assignees(second.name))
+
+		# closing an assigned appointment closes its ToDo without re-assigning
+		first.reload()
+		first.status = "Closed"
+		first.save()
+		self.assertTrue(get_todo_statuses(first.name))
+		self.assertTrue(all(status == "Closed" for status in get_todo_statuses(first.name)))
+
+		# reopening brings the ToDos back
+		first.status = "Open"
+		first.save()
+		self.assertTrue(all(status == "Open" for status in get_todo_statuses(first.name)))
+
+	def test_agent_busy_for_the_whole_appointment_duration(self):
+		self._configure_booking_settings()
+		slot = slot_on(3, 11)
+		appointment = create_test_appointment(customer_email="busy_agent@example.com", scheduled_time=slot)
+		assignee = get_assignees(appointment.name)[0]
+
+		# busy anywhere inside the 30-minute appointment window, free right after it
+		self.assertFalse(_check_agent_availability(assignee, slot))
+		self.assertFalse(_check_agent_availability(assignee, slot + datetime.timedelta(minutes=15)))
+		self.assertTrue(_check_agent_availability(assignee, slot + datetime.timedelta(minutes=30)))
+
+	def test_closed_appointment_closes_calendar_event(self):
+		self.test_appointment.status = "Closed"
+		self.test_appointment.save()
+		event_status = frappe.db.get_value("Event", self.test_appointment.calendar_event, "status")
+		self.assertEqual(event_status, "Closed")
+
+		# reopening the appointment reopens the calendar event
+		self.test_appointment.status = "Open"
+		self.test_appointment.save()
+		event_status = frappe.db.get_value("Event", self.test_appointment.calendar_event, "status")
+		self.assertEqual(event_status, "Open")
+
+	def test_deleting_appointment_deletes_calendar_event(self):
+		event = self.test_appointment.calendar_event
+		self.assertTrue(frappe.db.exists("Event", event))
+
+		frappe.delete_doc("Appointment", self.test_appointment.name)
+
+		self.assertFalse(frappe.db.exists("Event", event))
+
+	def test_backdated_appointment_is_rejected(self):
+		with self.assertRaises(frappe.ValidationError):
+			create_test_appointment(
+				customer_email="backdated@example.com",
+				scheduled_time=add_to_date(now_datetime(), hours=-1),
+			)
+
+	def test_booking_beyond_advance_window_is_rejected(self):
+		self._configure_booking_settings()
+		set_booking_setting("advance_booking_days", 7)
+
+		# within the advance booking window - allowed
+		within = create_test_appointment(
+			customer_email="advance_within@example.com", scheduled_time=slot_on(5, 10)
+		)
+		self.assertTrue(frappe.db.exists("Appointment", within.name))
+
+		# beyond the advance booking window - rejected
+		with self.assertRaises(frappe.ValidationError):
+			create_test_appointment(
+				customer_email="advance_beyond@example.com", scheduled_time=slot_on(8, 10)
+			)
+
+	def test_appointment_on_holiday_is_rejected(self):
+		holiday = add_to_date(getdate(), days=3)
+		self._configure_booking_settings(
+			holiday_dates=[{"holiday_date": holiday, "description": "Test Holiday"}]
+		)
+
+		with self.assertRaises(frappe.ValidationError):
+			create_test_appointment(customer_email="on_holiday@example.com", scheduled_time=slot_on(3, 10))
+
+		# the day after the holiday is bookable
+		after_holiday = create_test_appointment(
+			customer_email="after_holiday@example.com", scheduled_time=slot_on(4, 10)
+		)
+		self.assertTrue(frappe.db.exists("Appointment", after_holiday.name))
+
+	def test_appointment_outside_slot_timing_is_rejected(self):
+		self._configure_booking_settings()
+
+		# before the slot opens
+		with self.assertRaises(frappe.ValidationError):
+			create_test_appointment(customer_email="before_opening@example.com", scheduled_time=slot_on(2, 8))
+
+		# starts within the slot but would end after it closes
+		with self.assertRaises(frappe.ValidationError):
+			create_test_appointment(
+				customer_email="past_closing@example.com", scheduled_time=slot_on(2, 16, 45)
+			)
+
+		# within the slot timings
+		within = create_test_appointment(
+			customer_email="within_slot@example.com", scheduled_time=slot_on(2, 10)
+		)
+		self.assertTrue(frappe.db.exists("Appointment", within.name))
+
+	def test_overlapping_time_slot_capacity(self):
+		set_booking_setting("number_of_agents", 1)
+		set_booking_setting("appointment_duration", 30)
+
+		slot = slot_on(1, 10)
+		first = create_test_appointment(customer_email="slot_first@example.com", scheduled_time=slot)
+
+		# a booking starting inside the first appointment's duration is rejected
+		with self.assertRaises(frappe.ValidationError):
+			create_test_appointment(
+				customer_email="slot_overlap@example.com",
+				scheduled_time=slot + datetime.timedelta(minutes=15),
+			)
+
+		# rescheduling must not count the appointment's own booked slot
+		first.scheduled_time = slot + datetime.timedelta(minutes=10)
+		first.save()
+
+		# a booking starting exactly when the rescheduled one ends is allowed
+		adjacent = create_test_appointment(
+			customer_email="slot_adjacent@example.com",
+			scheduled_time=slot + datetime.timedelta(minutes=40),
+		)
+		self.assertTrue(frappe.db.exists("Appointment", adjacent.name))
+
+		# a closed (cancelled) appointment frees its slot
+		first.status = "Closed"
+		first.save()
+		after_cancellation = create_test_appointment(
+			customer_email="after_cancellation@example.com", scheduled_time=slot
+		)
+		self.assertTrue(frappe.db.exists("Appointment", after_cancellation.name))

erpnext/crm/doctype/appointment_booking_settings/appointment_booking_settings.json

@@ -1,48 +1,56 @@
 {
  "actions": [],
+ "allow_bulk_edit": 1,
  "creation": "2019-08-27 10:56:48.309824",
  "doctype": "DocType",
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
-  "enable_scheduling",
-  "agent_detail_section",
-  "availability_of_slots",
-  "number_of_agents",
-  "agent_list",
-  "holiday_list",
   "appointment_details_section",
   "appointment_duration",
   "email_reminders",
+  "column_break_ehiq",
+  "agent_list",
+  "number_of_agents",
+  "agent_detail_section",
+  "enable_scheduling",
+  "availability_of_slots",
+  "section_break_bkln",
+  "column_break_alwa",
   "advance_booking_days",
+  "column_break_bspp",
+  "holiday_list",
   "success_details",
-  "success_redirect_url"
+  "enable_appointment_portal",
+  "verification_link_expiry_duration",
+  "column_break_fovk",
+  "success_redirect_url",
+  "action_for_expired_unverified_appointments"
  ],
  "fields": [
   {
+   "depends_on": "eval:doc.enable_scheduling === 1;",
    "fieldname": "availability_of_slots",
    "fieldtype": "Table",
    "label": "Availability Of Slots",
-   "options": "Appointment Booking Slots",
-   "reqd": 1
+   "mandatory_depends_on": "eval:doc.enable_scheduling === 1;",
+   "options": "Appointment Booking Slots"
   },
   {
-   "default": "1",
    "fieldname": "number_of_agents",
    "fieldtype": "Int",
-   "hidden": 1,
    "in_list_view": 1,
    "label": "Number of Concurrent Appointments",
-   "read_only": 1,
-   "reqd": 1
+   "read_only": 1
   },
   {
+   "depends_on": "eval:doc.enable_scheduling === 1;",
    "fieldname": "holiday_list",
    "fieldtype": "Link",
    "in_list_view": 1,
    "label": "Holiday List",
-   "options": "Holiday List",
-   "reqd": 1
+   "mandatory_depends_on": "eval:doc.enable_scheduling === 1;",
+   "options": "Holiday List"
   },
   {
    "default": "60",
@@ -60,29 +68,31 @@
   },
   {
    "default": "7",
+   "depends_on": "eval:doc.enable_scheduling === 1;",
    "fieldname": "advance_booking_days",
    "fieldtype": "Int",
    "label": "Number of days appointments can be booked in advance",
-   "reqd": 1
+   "mandatory_depends_on": "eval:doc.enable_scheduling === 1;"
   },
   {
    "fieldname": "agent_list",
    "fieldtype": "Table MultiSelect",
    "label": "Agents",
-   "options": "Assignment Rule User",
-   "reqd": 1
+   "mandatory_depends_on": "eval:doc.enable_scheduling === 1;",
+   "options": "Assignment Rule User"
   },
   {
    "default": "0",
    "fieldname": "enable_scheduling",
    "fieldtype": "Check",
    "label": "Enable Appointment Scheduling",
-   "reqd": 1
+   "mandatory_depends_on": "eval:doc.enable_appointment_portal === 1;"
   },
   {
    "fieldname": "agent_detail_section",
    "fieldtype": "Section Break",
-   "label": "Agent Details"
+   "hide_border": 1,
+   "label": "Appointment Scheduling"
   },
   {
    "fieldname": "appointment_details_section",
@@ -92,18 +102,68 @@
   {
    "fieldname": "success_details",
    "fieldtype": "Section Break",
-   "label": "Success Settings"
+   "label": "Appointment Booking Portal Settings"
   },
   {
    "description": "Leave blank for home.\nThis is relative to site URL, for example \"about\" will redirect to \"https://yoursitename.com/about\"",
    "fieldname": "success_redirect_url",
    "fieldtype": "Data",
-   "label": "Success Redirect URL"
+   "label": "Success Redirect URL",
+   "permlevel": 1
+  },
+  {
+   "default": "30",
+   "depends_on": "eval: doc.enable_scheduling === 1;",
+   "description": "In Minutes (min: 15 mins, max: 60 mins)",
+   "fieldname": "verification_link_expiry_duration",
+   "fieldtype": "Int",
+   "label": "Verification Link Expiry Duration",
+   "mandatory_depends_on": "eval:doc.enable_appointment_portal === 1;",
+   "max_value": 60.0,
+   "min_value": 15.0,
+   "non_negative": 1,
+   "permlevel": 1
+  },
+  {
+   "fieldname": "column_break_ehiq",
+   "fieldtype": "Column Break"
+  },
+  {
+   "default": "0",
+   "fieldname": "enable_appointment_portal",
+   "fieldtype": "Check",
+   "label": "Enable Appointment Booking Through Portal",
+   "permlevel": 1
+  },
+  {
+   "fieldname": "column_break_fovk",
+   "fieldtype": "Column Break"
+  },
+  {
+   "default": "Mark as Closed",
+   "fieldname": "action_for_expired_unverified_appointments",
+   "fieldtype": "Select",
+   "label": "Action for Expired Unverified Appointments",
+   "options": "Mark as Closed\nDelete Permanently",
+   "permlevel": 1
+  },
+  {
+   "fieldname": "section_break_bkln",
+   "fieldtype": "Section Break"
+  },
+  {
+   "fieldname": "column_break_alwa",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "column_break_bspp",
+   "fieldtype": "Column Break"
   }
  ],
+ "grid_page_length": 50,
  "issingle": 1,
  "links": [],
- "modified": "2022-12-15 11:10:13.517742",
+ "modified": "2026-07-20 00:11:18.996384",
  "modified_by": "Administrator",
  "module": "CRM",
  "name": "Appointment Booking Settings",
@@ -137,6 +197,15 @@
    "role": "Sales Manager",
    "share": 1,
    "write": 1
+  },
+  {
+   "email": 1,
+   "permlevel": 1,
+   "print": 1,
+   "read": 1,
+   "role": "System Manager",
+   "share": 1,
+   "write": 1
   }
  ],
  "quick_entry": 1,
@@ -144,4 +213,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/crm/doctype/appointment_booking_settings/appointment_booking_settings.py

@@ -3,11 +3,11 @@
 
 
 import datetime
-import typing
 
 import frappe
 from frappe import _
 from frappe.model.document import Document
+from frappe.utils import getdate
 
 
 class AppointmentBookingSettings(Document):
@@ -26,33 +26,43 @@ class AppointmentBookingSettings(Document):
 			AppointmentBookingSlots,
 		)
 
+		action_for_expired_unverified_appointments: DF.Literal["Mark as Closed", "Delete Permanently"]
 		advance_booking_days: DF.Int
 		agent_list: DF.TableMultiSelect[AssignmentRuleUser]
 		appointment_duration: DF.Int
 		availability_of_slots: DF.Table[AppointmentBookingSlots]
 		email_reminders: DF.Check
+		enable_appointment_portal: DF.Check
 		enable_scheduling: DF.Check
-		holiday_list: DF.Link
+		holiday_list: DF.Link | None
 		number_of_agents: DF.Int
 		success_redirect_url: DF.Data | None
+		verification_link_expiry_duration: DF.Int
 	# end: auto-generated types
 
-	agent_list: typing.ClassVar[list] = []  # Hack
-	min_date = "01/01/1970 "
-	format_string = "%d/%m/%Y %H:%M:%S"
-
 	def validate(self):
-		self.validate_availability_of_slots()
-
-	def save(self):
 		self.number_of_agents = len(self.agent_list)
-		super().save()
+		self.validate_appointment_scheduling()
+		self.validate_portal_booking()
+
+	def validate_appointment_scheduling(self):
+		if not self.enable_scheduling:
+			return
+
+		self.validate_availability_of_slots()
+		self.validate_holiday_list()
+		self.validate_advance_booking_days()
 
 	def validate_availability_of_slots(self):
+		if not self.availability_of_slots:
+			frappe.throw(
+				_("Please fill up the Availability of Slots table to enable Appointment Scheduling.")
+			)
+
+		format_string = "%Y-%m-%d %H:%M:%S"
 		for record in self.availability_of_slots:
-			from_time = datetime.datetime.strptime(self.min_date + record.from_time, self.format_string)
-			to_time = datetime.datetime.strptime(self.min_date + record.to_time, self.format_string)
-			to_time - from_time
+			from_time = datetime.datetime.strptime(f"1970-01-01 {record.from_time}", format_string)
+			to_time = datetime.datetime.strptime(f"1970-01-01 {record.to_time}", format_string)
 			self.validate_from_and_to_time(from_time, to_time, record)
 			self.duration_is_divisible(from_time, to_time)
 
@@ -67,3 +77,38 @@ class AppointmentBookingSettings(Document):
 		timedelta = to_time - from_time
 		if timedelta.total_seconds() % (self.appointment_duration * 60):
 			frappe.throw(_("The difference between from time and To Time must be a multiple of Appointment"))
+
+	def validate_holiday_list(self):
+		if not self.holiday_list:
+			frappe.throw(_("Please select a Holiday List to enable Appointment Scheduling."))
+
+		hl_from_date, hl_to_date = frappe.get_cached_value(
+			"Holiday List", self.holiday_list, ["from_date", "to_date"]
+		)
+		now = getdate()
+
+		if not (now >= hl_from_date and now <= hl_to_date):
+			frappe.throw(_("Holiday List - {0} is not valid for current date.").format(self.holiday_list))
+
+	def validate_advance_booking_days(self):
+		if not self.advance_booking_days:
+			frappe.throw(_("Advance Booking Days is mandatory for Appointment Scheduling."))
+
+	def validate_portal_booking(self):
+		if not self.enable_appointment_portal:
+			return
+
+		if not self.enable_scheduling:
+			frappe.throw(
+				_("Appointment Scheduling needs to be enabled for Appointment Booking through portal.")
+			)
+
+		self.validate_link_expiry_duration()
+
+	def validate_link_expiry_duration(self):
+		if (
+			not self.verification_link_expiry_duration
+			or self.verification_link_expiry_duration > 60
+			or self.verification_link_expiry_duration < 15
+		):
+			frappe.throw(_("'Verification Link Expiry Duration' must be between 15 to 60 minutes."))

erpnext/crm/doctype/appointment_booking_settings/test_appointment_booking_settings.py

@@ -1,9 +1,125 @@
 # Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
-import unittest
+import datetime
+
+import frappe
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import add_to_date, getdate
+
+from erpnext.setup.doctype.holiday_list.test_holiday_list import make_holiday_list
 
 
-class TestAppointmentBookingSettings(unittest.TestCase):
-	pass
+class TestAppointmentBookingSettings(FrappeTestCase):
+	def assert_invalid(self, settings):
+		with self.assertRaises(frappe.ValidationError):
+			settings.save()
+
+	def make_settings(self, appointment_duration=30):
+		doc = frappe.new_doc("Appointment Booking Settings")
+		doc.appointment_duration = appointment_duration
+		return doc
+
+	def dt(self, hms):
+		# the controller parses times against a fixed epoch date
+		return datetime.datetime.strptime("1970-01-01 " + hms, "%Y-%m-%d %H:%M:%S")
+
+	def get_valid_scheduling_settings(self):
+		holiday_list = make_holiday_list(
+			"_Test Booking Settings Holiday List",
+			from_date=getdate(),
+			to_date=add_to_date(getdate(), days=30),
+			holiday_dates=[],
+		)
+
+		settings = frappe.get_doc("Appointment Booking Settings")
+		settings.enable_scheduling = 1
+		settings.appointment_duration = 30
+		settings.advance_booking_days = 7
+		settings.verification_link_expiry_duration = 30
+		settings.holiday_list = holiday_list.name
+		settings.set("agent_list", [])
+		settings.append("agent_list", {"user": "Administrator"})
+		settings.set("availability_of_slots", [])
+		settings.append(
+			"availability_of_slots",
+			{"day_of_week": "Monday", "from_time": "09:00:00", "to_time": "17:00:00"},
+		)
+		return settings
+
+	def test_from_time_must_precede_to_time(self):
+		doc = self.make_settings()
+		record = frappe._dict(day_of_week="Monday")
+		self.assertRaises(
+			frappe.ValidationError,
+			doc.validate_from_and_to_time,
+			self.dt("18:00:00"),
+			self.dt("09:00:00"),
+			record,
+		)
+		doc.validate_from_and_to_time(self.dt("09:00:00"), self.dt("18:00:00"), record)  # valid order
+
+	def test_slot_length_must_be_a_multiple_of_the_duration(self):
+		doc = self.make_settings(appointment_duration=30)
+		# 60 minutes is two 30-minute appointments -> fine
+		doc.duration_is_divisible(self.dt("09:00:00"), self.dt("10:00:00"))
+		# 45 minutes leaves a partial appointment -> rejected
+		self.assertRaises(
+			frappe.ValidationError, doc.duration_is_divisible, self.dt("09:00:00"), self.dt("09:45:00")
+		)
+
+	def test_scheduling_requires_slots(self):
+		settings = self.get_valid_scheduling_settings()
+		settings.set("availability_of_slots", [])
+
+		self.assert_invalid(settings)
+
+	def test_validate_checks_every_slot(self):
+		settings = self.get_valid_scheduling_settings()
+		settings.append(
+			"availability_of_slots",
+			{"day_of_week": "Tuesday", "from_time": "09:00:00", "to_time": "09:45:00"},
+		)
+
+		self.assert_invalid(settings)
+
+	def test_scheduling_requires_holiday_list_covering_today(self):
+		settings = self.get_valid_scheduling_settings()
+		settings.holiday_list = None
+		self.assert_invalid(settings)
+
+		expired_list = make_holiday_list(
+			"_Test Booking Settings Expired Holiday List",
+			from_date=add_to_date(getdate(), days=-60),
+			to_date=add_to_date(getdate(), days=-30),
+			holiday_dates=[],
+		)
+		settings.holiday_list = expired_list.name
+		self.assert_invalid(settings)
+
+	def test_scheduling_requires_advance_booking_days(self):
+		settings = self.get_valid_scheduling_settings()
+		settings.advance_booking_days = 0
+
+		self.assert_invalid(settings)
+
+	def test_portal_requires_scheduling(self):
+		settings = frappe.get_doc("Appointment Booking Settings")
+		settings.enable_scheduling = 0
+		settings.enable_appointment_portal = 1
+
+		self.assert_invalid(settings)
+
+	def test_portal_expiry_duration_bounds(self):
+		settings = self.get_valid_scheduling_settings()
+		settings.enable_appointment_portal = 1
+		settings.verification_link_expiry_duration = 5
+
+		self.assert_invalid(settings)
+
+	def test_number_of_agents_derived_from_agent_list(self):
+		settings = self.get_valid_scheduling_settings()
+		settings.number_of_agents = 99
+		settings.save()
+
+		self.assertEqual(frappe.db.get_single_value("Appointment Booking Settings", "number_of_agents"), 1)

erpnext/crm/doctype/crm_settings/crm_settings.js

@@ -2,6 +2,35 @@
 // For license information, please see license.txt
 
 frappe.ui.form.on("CRM Settings", {
-	// refresh: function(frm) {
-	// }
+	refresh: function (frm) {
+		const flag = frm.events.calculate_visiblity_flag(frm);
+
+		frm.set_df_property("allowed_users", "hidden", !flag);
+		frm.set_df_property("allowed_users", "reqd", flag);
+	},
+
+	enable_frappe_crm_data_synchronization: function (frm) {
+		const flag = frm.events.calculate_visiblity_flag(frm);
+
+		if (flag) {
+			frappe.show_alert(
+				__("Allowed Users is required for data synchronization from remote Frappe CRM site.")
+			);
+		}
+
+		/*
+		make allowed_users field visible and mandatory if enable_frappe_crm_data_synchronization
+		is set and crm app is not installed.
+		*/
+
+		frm.set_df_property("allowed_users", "hidden", !flag);
+		frm.set_df_property("allowed_users", "reqd", flag);
+	},
+
+	calculate_visiblity_flag: function (frm) {
+		const crm_sync_enabled = frm.doc.enable_frappe_crm_data_synchronization;
+		const is_crm_installed = cint(frappe.utils.get_installed_apps().includes("crm"));
+
+		return crm_sync_enabled && !is_crm_installed;
+	},
 });

erpnext/crm/doctype/crm_settings/crm_settings.json

@@ -120,9 +120,9 @@
    "fieldtype": "Column Break"
   },
   {
-   "depends_on": "eval:doc.enable_frappe_crm_data_synchronization === 1;",
    "fieldname": "allowed_users",
    "fieldtype": "Table MultiSelect",
+   "hidden": 1,
    "label": "Allowed Users",
    "options": "Frappe CRM Allowed User",
    "permlevel": 1
@@ -139,7 +139,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2026-06-22 01:26:13.474915",
+ "modified": "2026-07-01 01:09:16.461470",
  "modified_by": "Administrator",
  "module": "CRM",
  "name": "CRM Settings",

erpnext/crm/doctype/crm_settings/crm_settings.py

@@ -3,9 +3,11 @@
 
 import frappe
 from frappe import _
-from frappe.custom.doctype.custom_field.custom_field import create_custom_fields, delete_custom_fields
+from frappe.custom.doctype.custom_field.custom_field import create_custom_fields
 from frappe.model.document import Document
 
+from erpnext.crm.frappe_crm_api import is_crm_installed
+
 
 class CRMSettings(Document):
 	# begin: auto-generated types
@@ -46,13 +48,16 @@ class CRMSettings(Document):
 			)
 
 	def validate_allowed_users(self):
-		if self.enable_frappe_crm_data_synchronization and not self.allowed_users:
+		if self.enable_frappe_crm_data_synchronization and not (is_crm_installed() or self.allowed_users):
 			frappe.throw(
 				_(
 					"Please add atleast one user on Allowed Users to allow Data Synchronization from Frappe CRM site."
 				)
 			)
 
+		if self.enable_frappe_crm_data_synchronization and is_crm_installed() and self.allowed_users:
+			frappe.throw(_("Allowed Users is not required as Frappe CRM is already installed on the site."))
+
 	def before_save(self):
 		self.clear_allowed_users()
 

erpnext/crm/doctype/lead/lead.py

@@ -438,6 +438,7 @@ def get_lead_details(lead, posting_date=None, company=None, doctype=None):
 	out = frappe._dict()
 
 	lead_doc = frappe.get_doc("Lead", lead)
+	lead_doc.check_permission()
 	lead = lead_doc
 
 	out.update(

erpnext/crm/doctype/opportunity/opportunity.py

@@ -277,13 +277,17 @@ class Opportunity(TransactionBase, CRMNote):
 			self.save()
 
 		else:
-			frappe.throw(_("Cannot declare as lost, because Quotation has been made."))
+			frappe.throw(_("Cannot declare as Lost because an active Quotation exists."))
 
 	def has_active_quotation(self):
 		if not self.get("items", []):
 			return frappe.get_all(
 				"Quotation",
-				{"opportunity": self.name, "status": ("not in", ["Lost", "Closed"]), "docstatus": 1},
+				{
+					"opportunity": self.name,
+					"status": ("not in", ["Lost", "Cancelled", "Expired"]),
+					"docstatus": 1,
+				},
 				"name",
 			)
 		else:
@@ -292,14 +296,20 @@ class Opportunity(TransactionBase, CRMNote):
 				select q.name
 				from `tabQuotation` q, `tabQuotation Item` qi
 				where q.name = qi.parent and q.docstatus=1 and qi.prevdoc_docname =%s
-				and q.status not in ('Lost', 'Closed')""",
+				and q.status not in ('Lost', 'Cancelled', 'Expired')""",
 				self.name,
 			)
 
 	def has_ordered_quotation(self):
 		if not self.get("items", []):
 			return frappe.get_all(
-				"Quotation", {"opportunity": self.name, "status": "Ordered", "docstatus": 1}, "name"
+				"Quotation",
+				{
+					"opportunity": self.name,
+					"status": ("in", ["Ordered", "Partially Ordered"]),
+					"docstatus": 1,
+				},
+				"name",
 			)
 		else:
 			return frappe.db.sql(
@@ -307,7 +317,7 @@ class Opportunity(TransactionBase, CRMNote):
 				select q.name
 				from `tabQuotation` q, `tabQuotation Item` qi
 				where q.name = qi.parent and q.docstatus=1 and qi.prevdoc_docname =%s
-				and q.status = 'Ordered'""",
+				and q.status in ('Ordered', 'Partially Ordered')""",
 				self.name,
 			)
 

erpnext/crm/doctype/prospect/prospect.py

@@ -136,7 +136,7 @@ def make_opportunity(source_name, target_doc=None):
 
 @frappe.whitelist()
 def get_opportunities(prospect):
-	return frappe.get_all(
+	return frappe.get_list(
 		"Opportunity",
 		filters={"opportunity_from": "Prospect", "party_name": prospect},
 		fields=[

erpnext/crm/frappe_crm_api.py

@@ -1,5 +1,6 @@
 import json
 
+import click
 import frappe
 from frappe import _
 
@@ -150,7 +151,9 @@ def create_customer(customer_data=None):
 			for field in CUSTOMER_ALLOWED_FIELDS:
 				if customer_data.get(field) is not None:
 					customer.set(field, customer_data.get(field))
-			customer.insert(ignore_permissions=True)
+
+			# If CRM is installed on the site, User Permission cannot be ignored while saving Customer Records.
+			customer.insert(ignore_permissions=not is_crm_installed())
 			customer_name = customer.name
 
 		contacts = json.loads(customer_data.get("contacts"))
@@ -169,6 +172,10 @@ def validate_frappe_crm_sync():
 			_("Frappe CRM data synchronization is not enabled on ERPNext. Contact System Manager of ERPNext.")
 		)
 
+	# Skip allowed_users validation if CRM is installed on the site.
+	if is_crm_installed():
+		return
+
 	allowed_users = [d.user for d in CRMSettings.allowed_users]
 
 	if frappe.session.user not in allowed_users:
@@ -178,3 +185,35 @@ def validate_frappe_crm_sync():
 			),
 			exc=frappe.PermissionError,
 		)
+
+
+def is_crm_installed():
+	return "crm" in frappe.get_installed_apps()
+
+
+def remove_allowed_users_on_crm_install():
+	try:
+		CRMSettings = frappe.get_single("CRM Settings")
+
+		if not CRMSettings.enable_frappe_crm_data_synchronization:
+			return
+
+		CRMSettings.allowed_users = []
+		CRMSettings.save()
+		click.secho("Removed 'Allowed Users' from CRM Settings.")
+	except Exception:
+		click.secho("'Allowed Users' from CRM Settings couldn't be cleared.")
+
+
+def disable_frappe_crm_data_synchronization_on_crm_uninstall():
+	try:
+		CRMSettings = frappe.get_single("CRM Settings")
+
+		if not CRMSettings.enable_frappe_crm_data_synchronization:
+			return
+
+		CRMSettings.enable_frappe_crm_data_synchronization = 0
+		CRMSettings.save()
+		click.secho("'Enable Frappe CRM Data Synchronization' on CRM Settings has been disabled.")
+	except Exception:
+		click.secho("'Enable Frappe CRM Data Synchronization' on CRM Settings could not be disabled.")

erpnext/crm/utils.py

@@ -166,6 +166,7 @@ def get_open_todos(ref_doctype, ref_docname):
 			"allocated_to",
 			"date",
 		],
+		order_by="date asc",
 	)
 
 
@@ -190,6 +191,7 @@ def get_open_events(ref_doctype, ref_docname):
 			& (event_link.reference_docname == ref_docname)
 			& (event.status == "Open")
 		)
+		.orderby(event.starts_on)
 	)
 	data = query.run(as_dict=True)
 

erpnext/hooks.py

@@ -61,6 +61,9 @@ before_install = [
 ]
 after_install = "erpnext.setup.install.after_install"
 
+after_app_install = "erpnext.setup.install.after_app_install"
+after_app_uninstall = "erpnext.setup.install.after_app_uninstall"
+
 boot_session = "erpnext.startup.boot.boot_session"
 notification_config = "erpnext.startup.notifications.get_notification_config"
 get_help_messages = "erpnext.utilities.activation.get_help_messages"
@@ -428,6 +431,7 @@ scheduler_events = {
 	],
 	"hourly_long": [],
 	"hourly_maintenance": [
+		"erpnext.crm.doctype.appointment.appointment.handle_expired_unverified_appointments",
 		"erpnext.stock.doctype.repost_item_valuation.repost_item_valuation.repost_entries",
 		"erpnext.utilities.bulk_transaction.retry",
 		"erpnext.projects.doctype.project.project.collect_project_status",

erpnext/manufacturing/doctype/bom/bom.js

@@ -441,7 +441,11 @@ frappe.ui.form.on("BOM", {
 	},
 
 	routing(frm) {
-		if (frm.doc.routing && frm.doc.with_operations && !frm.doc.operations.length) {
+		// Refetch operations whenever the routing is (re)selected, so that
+		// changing the routing - e.g. on a new BOM version copied from another
+		// BOM - replaces the operations with those of the newly selected routing
+		// instead of keeping the old ones.
+		if (frm.doc.routing && frm.doc.with_operations) {
 			frappe.call({
 				doc: frm.doc,
 				method: "get_routing",