chore(release): Bumped to Version 16.5.0

# [16.5.0](https://github.com/frappe/erpnext/compare/v16.4.1...v16.5.0) (2026-02-11)

### Bug Fixes

* Added a missing option to the currency field (backport [#52528](https://github.com/frappe/erpnext/issues/52528)) ([#52587](https://github.com/frappe/erpnext/issues/52587)) ([1c3fe00](1c3fe000ba))
* Added validation for quality inspection in job card ([a1ec68c](a1ec68cd1e))
* apply composite asset logic only in draft ([d2387a3](d2387a3af8))
* **balance sheet:** removed the extra labels from the chart ([6a9a28b](6a9a28b4ae))
* **buying:** add supplier group link filters in field level ([9886b46](9886b46cb4))
* correctly calculate running balances for financial report ([7df18af](7df18af799))
* do not show update stock flag unneccessarily ([c0c6cc5](c0c6cc58ed))
* email campaign timeout issue (backport [#51994](https://github.com/frappe/erpnext/issues/51994)) ([#52556](https://github.com/frappe/erpnext/issues/52556)) ([e753df8](e753df8ff0))
* enabling skip delivery option for order type maintenance ([7a78e97](7a78e9705c))
* **gross profit report:** translate column Sales Invoice ([6ff8820](6ff8820732))
* **gross-profit:** handle item group filters ([0d02bbb](0d02bbb01a))
* **gross-profit:** handle returns outside sale period ([9b32c84](9b32c84462))
* handle gross profit and percentage for return invoices ([d081a26](d081a26608))
* item code is tuple with operation id ([9d14c0b](9d14c0b60e))
* **manufacturing:** fix chart period keys ([b99ca48](b99ca486d7))
* **manufacturing:** handle None value for actual_end_date ([b1b75ec](b1b75eca3d))
* **map_current_doc:** prevent mutation of query args in get_query (backport [#52202](https://github.com/frappe/erpnext/issues/52202)) ([#52584](https://github.com/frappe/erpnext/issues/52584)) ([b8256e5](b8256e5f31))
* move company field to first position in sales invoice, purchase invoice, sales order, purchase order and journal entry ([e53ccd0](e53ccd0745))
* not able to complete job card ([c5ff534](c5ff534d58))
* operation status and bom validation ([1122265](11222653ce))
* Period Closing Voucher doesn't exist for GL Entry ([921584c](921584c769))
* process loss error incorrectly thrown even when semi FG BOM does not have any process loss ([4a7ffce](4a7ffce320))
* **quotation:** ignore zero ordered_qty ([cf7c127](cf7c127dc6))
* rate comparison in stock reco ([1f78f45](1f78f45aee))
* remove customer_pos_id reference ([#52396](https://github.com/frappe/erpnext/issues/52396)) ([ab59f73](ab59f73064))
* remove incorrect validation from email digest throwing spurious error (backport [#51827](https://github.com/frappe/erpnext/issues/51827)) ([#52579](https://github.com/frappe/erpnext/issues/52579)) ([dffb6ac](dffb6ac4cf))
* return None instead of 0 if valuation rate is falsy ([64a7956](64a7956a4a))
* stock balance report issue ([62616ad](62616ad9e1))
* stock reservation created against job card ([305483e](305483e074))
* **stock:** add is group filter for warehouse fields ([23a26b5](23a26b540b))
* **stock:** ignore pos reserved batches for stock levels ([e2c1204](e2c12043ae))
* **stock:** inward stock for pick list test record ([801a26a](801a26ae67))
* **stock:** set source warehouse for issue type ([53e512c](53e512ceaf))
* **stock:** update target field attribute ([96dfecf](96dfecf0d5))
* test cases ([ece8d00](ece8d00415))
* validate asset movement transaction date ([#52340](https://github.com/frappe/erpnext/issues/52340)) ([898d2e3](898d2e3c9a))
* Workspace sidebar links for Debit/Credit Notes ([29d33b3](29d33b3139))

### Features

* **accounts:** expand Journal Entry Template to support dimensions and party ([#51621](https://github.com/frappe/erpnext/issues/51621)) ([d06a46a](d06a46ae85))
* allow negative stock for the batch item ([b6afe7f](b6afe7f4da))

### Reverts

* "fix: allow sales invoice to be renamed" ([abef910](abef9109b0))

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -60,7 +60,7 @@ body:
       description: Share exact version number of Frappe and ERPNext you are using.
       placeholder: |
         Frappe version -
-        ERPNext Verion -
+        ERPNext version -
     validations:
       required: true
 

.github/workflows/initiate_release.yml

@@ -19,7 +19,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        version: ["14", "15"]
+        version: ["14", "15", "16"]
 
     steps:
       - uses: octokit/request-action@v2.x

.github/workflows/patch.yml

@@ -113,8 +113,8 @@ jobs:
           jq 'del(.install_apps)' ~/frappe-bench/sites/test_site/site_config.json > tmp.json
           mv tmp.json ~/frappe-bench/sites/test_site/site_config.json
 
-          wget https://erpnext.com/files/v13-erpnext.sql.gz
-          bench --site test_site --force restore ~/frappe-bench/v13-erpnext.sql.gz
+          wget https://frappe.io/files/erpnext-v14.sql.gz
+          bench --site test_site --force restore ~/frappe-bench/erpnext-v14.sql.gz
 
           git -C "apps/frappe" remote set-url upstream https://github.com/frappe/frappe.git
           git -C "apps/erpnext" remote set-url upstream https://github.com/frappe/erpnext.git
@@ -142,7 +142,6 @@ jobs:
             bench --site test_site migrate
           }
 
-          update_to_version 14 3.11
           update_to_version 15 3.13
 
           echo "Updating to latest version"

.github/workflows/release.yml

@@ -2,7 +2,7 @@ name: Generate Semantic Release
 on:
   push:
     branches:
-      - version-13
+      - version-16
 
 permissions:
   contents: read

.github/workflows/server-tests-mariadb-faux.yml

@@ -7,6 +7,7 @@ on:
     paths:
       - "**.js"
       - "**.css"
+      - "**.svg"
       - "**.md"
       - "**.html"
       - 'crowdin.yml'

.releaserc

@@ -1,5 +1,5 @@
 {
-	"branches": ["version-13"],
+	"branches": ["version-16"],
 	"plugins": [
 		"@semantic-release/commit-analyzer", {
 			"preset": "angular",
@@ -21,4 +21,4 @@
 		],
 		"@semantic-release/github"
 	]
-}
+}

README.md

@@ -1,3 +1,4 @@
+
 <div align="center">
     <a href="https://frappe.io/erpnext">
 	<img src="./erpnext/public/images/v16/erpnext.svg" alt="ERPNext Logo" height="80px" width="80xp"/>

erpnext/__init__.py

@@ -6,7 +6,7 @@ import frappe
 from frappe.model.document import Document
 from frappe.utils.user import is_website_user
 
-__version__ = "16.0.0-dev"
+__version__ = "16.5.0"
 
 
 def get_default_company(user=None):

erpnext/accounts/accounts_dashboard/payments/payments.json

@@ -0,0 +1,50 @@
+{
+ "cards": [
+  {
+   "card": "Total Outgoing Bills"
+  },
+  {
+   "card": "Total Incoming Bills"
+  },
+  {
+   "card": "Total Incoming Payment"
+  },
+  {
+   "card": "Total Outgoing Payment"
+  }
+ ],
+ "charts": [
+  {
+   "chart": "Incoming Bills (Purchase Invoice)",
+   "width": "Half"
+  },
+  {
+   "chart": "Outgoing Bills (Sales Invoice)",
+   "width": "Half"
+  },
+  {
+   "chart": "Accounts Receivable Ageing",
+   "width": "Half"
+  },
+  {
+   "chart": "Accounts Payable Ageing",
+   "width": "Half"
+  },
+  {
+   "chart": "Bank Balance",
+   "width": "Full"
+  }
+ ],
+ "creation": "2026-01-26 21:25:12.793893",
+ "dashboard_name": "Payments",
+ "docstatus": 0,
+ "doctype": "Dashboard",
+ "idx": 0,
+ "is_default": 0,
+ "is_standard": 1,
+ "modified": "2026-01-26 21:25:12.793893",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Payments",
+ "owner": "Administrator"
+}

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

@@ -33,6 +33,17 @@
                         }, 
                         "account_number": "1151.000"
                     }, 
+                    "Pajak Dibayar di Muka": {
+                        "PPN Masukan": {
+                            "account_number": "1152.001",
+                            "account_type": "Tax"
+                        },
+                        "PPh 23 Dibayar di Muka": {
+                            "account_number": "1152.002",
+                            "account_type": "Tax"
+                        },
+                        "account_number": "1152.000"
+                    },
                     "account_number": "1150.000"
                 }, 
                 "Kas": {
@@ -97,17 +108,6 @@
                     }, 
                     "account_number": "1130.000"
                 },
-                "Pajak Dibayar di Muka": {
-                    "PPN Masukan": {
-                        "account_number": "1151.001", 
-                        "account_type": "Tax"
-                    },
-                    "PPh 23 Dibayar di Muka": {
-                        "account_number": "1152.001", 
-                        "account_type": "Tax"
-                    }, 
-                    "account_number": "1150.000"
-                },
                 "account_number": "1100.000"
                 
             }, 

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -281,7 +281,7 @@
   },
   {
    "default": "0",
-   "description": "Learn about <a href=\"https://docs.erpnext.com/docs/v13/user/manual/en/accounts/articles/common_party_accounting#:~:text=Common%20Party%20Accounting%20in%20ERPNext,Invoice%20against%20a%20primary%20Supplier.\">Common Party</a>",
+   "description": "Learn about <a href=\"https://docs.frappe.io/erpnext/user/manual/en/common_party_accounting\">Common Party</a>",
    "fieldname": "enable_common_party_accounting",
    "fieldtype": "Check",
    "label": "Enable Common Party Accounting"

erpnext/accounts/doctype/advance_payment_ledger_entry/advance_payment_ledger_entry.json

@@ -50,6 +50,7 @@
    "fieldname": "amount",
    "fieldtype": "Currency",
    "label": "Amount",
+   "options": "currency",
    "read_only": 1
   },
   {

erpnext/accounts/doctype/bank/bank.js

@@ -3,9 +3,6 @@
 frappe.provide("erpnext.integrations");
 
 frappe.ui.form.on("Bank", {
-	onload: function (frm) {
-		add_fields_to_mapping_table(frm);
-	},
 	refresh: function (frm) {
 		add_fields_to_mapping_table(frm);
 		frm.toggle_display(["address_html", "contact_html"], !frm.doc.__islocal);
@@ -37,11 +34,11 @@ let add_fields_to_mapping_table = function (frm) {
 		});
 	});
 
-	frm.fields_dict.bank_transaction_mapping.grid.update_docfield_property(
-		"bank_transaction_field",
-		"options",
-		options
-	);
+	const grid = frm.fields_dict.bank_transaction_mapping?.grid;
+
+	if (grid) {
+		grid.update_docfield_property("bank_transaction_field", "options", options);
+	}
 };
 
 erpnext.integrations.refreshPlaidLink = class refreshPlaidLink {
@@ -116,7 +113,7 @@ erpnext.integrations.refreshPlaidLink = class refreshPlaidLink {
 				"There was an issue connecting to Plaid's authentication server. Check browser console for more information"
 			)
 		);
-		console.log(error);
+		console.error(error);
 	}
 
 	plaid_success(token, response) {

erpnext/accounts/doctype/bank_account/bank_account.js

@@ -42,8 +42,4 @@ frappe.ui.form.on("Bank Account", {
 			});
 		}
 	},
-
-	is_company_account: function (frm) {
-		frm.set_df_property("account", "reqd", frm.doc.is_company_account);
-	},
 });

erpnext/accounts/doctype/bank_account/bank_account.json

@@ -52,6 +52,7 @@
    "fieldtype": "Link",
    "in_list_view": 1,
    "label": "Company Account",
+   "mandatory_depends_on": "is_company_account",
    "options": "Account"
   },
   {
@@ -98,6 +99,7 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Company",
+   "mandatory_depends_on": "is_company_account",
    "options": "Company"
   },
   {
@@ -252,7 +254,7 @@
    "link_fieldname": "default_bank_account"
   }
  ],
- "modified": "2025-08-29 12:32:01.081687",
+ "modified": "2026-01-20 00:46:16.633364",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account",

erpnext/accounts/doctype/bank_account/bank_account.py

@@ -51,25 +51,29 @@ class BankAccount(Document):
 		delete_contact_and_address("Bank Account", self.name)
 
 	def validate(self):
-		self.validate_company()
-		self.validate_account()
+		self.validate_is_company_account()
 		self.update_default_bank_account()
 
-	def validate_account(self):
-		if self.account:
-			if accounts := frappe.db.get_all(
-				"Bank Account", filters={"account": self.account, "name": ["!=", self.name]}, as_list=1
-			):
-				frappe.throw(
-					_("'{0}' account is already used by {1}. Use another account.").format(
-						frappe.bold(self.account),
-						frappe.bold(comma_and([get_link_to_form(self.doctype, x[0]) for x in accounts])),
-					)
-				)
+	def validate_is_company_account(self):
+		if self.is_company_account:
+			if not self.company:
+				frappe.throw(_("Company is mandatory for company account"))
 
-	def validate_company(self):
-		if self.is_company_account and not self.company:
-			frappe.throw(_("Company is mandatory for company account"))
+			if not self.account:
+				frappe.throw(_("Company Account is mandatory"))
+
+			self.validate_account()
+
+	def validate_account(self):
+		if accounts := frappe.db.get_all(
+			"Bank Account", filters={"account": self.account, "name": ["!=", self.name]}, as_list=1
+		):
+			frappe.throw(
+				_("'{0}' account is already used by {1}. Use another account.").format(
+					frappe.bold(self.account),
+					frappe.bold(comma_and([get_link_to_form(self.doctype, x[0]) for x in accounts])),
+				)
+			)
 
 	def update_default_bank_account(self):
 		if self.is_default and not self.disabled:

erpnext/accounts/doctype/financial_report_template/financial_report_engine.py

@@ -541,7 +541,7 @@ class FinancialQueryBuilder:
 			.where(acb_table.period_closing_voucher == closing_voucher)
 		)
 
-		query = self._apply_standard_filters(query, acb_table)
+		query = self._apply_standard_filters(query, acb_table, "Account Closing Balance")
 		results = self._execute_with_permissions(query, "Account Closing Balance")
 
 		for row in results:
@@ -636,12 +636,15 @@ class FinancialQueryBuilder:
 		return self._execute_with_permissions(query, "GL Entry")
 
 	def _calculate_running_balances(self, balances_data: dict, gl_data: list[dict]) -> dict:
-		for row in gl_data:
-			account = row["account"]
+		gl_dict = {row["account"]: row for row in gl_data}
+		accounts = set(balances_data.keys()) | set(gl_dict.keys())
+
+		for account in accounts:
 			if account not in balances_data:
 				balances_data[account] = AccountData(account=account, **self._get_account_meta(account))
 
 			account_data: AccountData = balances_data[account]
+			gl_movement = gl_dict.get(account, {})
 
 			if account_data.has_periods():
 				first_period = account_data.get_period(self.periods[0]["key"])
@@ -651,20 +654,13 @@ class FinancialQueryBuilder:
 
 			for period in self.periods:
 				period_key = period["key"]
-				movement = row.get(period_key, 0.0)
+				movement = gl_movement.get(period_key, 0.0)
 				closing_balance = current_balance + movement
 
 				account_data.add_period(PeriodValue(period_key, current_balance, closing_balance, movement))
 
 				current_balance = closing_balance
 
-		# Accounts with no movements
-		for account_data in balances_data.values():
-			for period in self.periods:
-				period_key = period["key"]
-				if period_key not in account_data.period_values:
-					account_data.add_period(PeriodValue(period_key, 0.0, 0.0, 0.0))
-
 	def _handle_balance_accumulation(self, balances_data):
 		for account_data in balances_data.values():
 			account_data: AccountData
@@ -683,12 +679,12 @@ class FinancialQueryBuilder:
 			else:
 				account_data.unaccumulate_values()
 
-	def _apply_standard_filters(self, query, table):
+	def _apply_standard_filters(self, query, table, doctype: str = "GL Entry"):
 		if self.filters.get("ignore_closing_entries"):
-			if hasattr(table, "is_period_closing_voucher_entry"):
-				query = query.where(table.is_period_closing_voucher_entry == 0)
-			else:
+			if doctype == "GL Entry":
 				query = query.where(table.voucher_type != "Period Closing Voucher")
+			else:
+				query = query.where(table.is_period_closing_voucher_entry == 0)
 
 		if self.filters.get("project"):
 			projects = self.filters.get("project")

erpnext/accounts/doctype/financial_report_template/test_financial_report_engine.py

@@ -16,7 +16,8 @@ from erpnext.accounts.doctype.financial_report_template.financial_report_engine
 from erpnext.accounts.doctype.financial_report_template.test_financial_report_template import (
 	FinancialReportTemplateTestCase,
 )
-from erpnext.accounts.utils import get_currency_precision
+from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
+from erpnext.accounts.utils import get_currency_precision, get_fiscal_year
 
 # On IntegrationTestCase, the doctype test records and all
 # link-field test record dependencies are recursively loaded
@@ -1672,3 +1673,360 @@ class TestFilterExpressionParser(FinancialReportTemplateTestCase):
 		mock_row_invalid = self._create_mock_report_row(invalid_formula)
 		condition = parser.build_condition(mock_row_invalid, account_table)
 		self.assertIsNone(condition)
+
+
+class TestFinancialQueryBuilder(FinancialReportTemplateTestCase):
+	def test_fetch_balances_with_journal_entries(self):
+		company = "_Test Company"
+		cash_account = "_Test Cash - _TC"
+		bank_account = "_Test Bank - _TC"
+
+		# Create journal entries in different periods
+		# October: Transfer 1000 from Bank to Cash
+		jv_oct = make_journal_entry(
+			account1=cash_account,
+			account2=bank_account,
+			amount=1000,
+			posting_date="2024-10-15",
+			company=company,
+			submit=True,
+		)
+
+		# November: Transfer 500 from Bank to Cash
+		jv_nov = make_journal_entry(
+			account1=cash_account,
+			account2=bank_account,
+			amount=500,
+			posting_date="2024-11-20",
+			company=company,
+			submit=True,
+		)
+
+		# December: No transactions (test zero movement period)
+
+		try:
+			# Set up filters and periods for Q4 2024
+			filters = {
+				"company": company,
+				"from_fiscal_year": "2024",
+				"to_fiscal_year": "2024",
+				"period_start_date": "2024-10-01",
+				"period_end_date": "2024-12-31",
+				"filter_based_on": "Date Range",
+				"periodicity": "Monthly",
+			}
+
+			periods = [
+				{"key": "2024_oct", "from_date": "2024-10-01", "to_date": "2024-10-31"},
+				{"key": "2024_nov", "from_date": "2024-11-01", "to_date": "2024-11-30"},
+				{"key": "2024_dec", "from_date": "2024-12-01", "to_date": "2024-12-31"},
+			]
+
+			query_builder = FinancialQueryBuilder(filters, periods)
+
+			# Create account objects as expected by fetch_account_balances
+			accounts = [
+				frappe._dict({"name": cash_account, "account_name": "Cash", "account_number": "1001"}),
+				frappe._dict({"name": bank_account, "account_name": "Bank", "account_number": "1002"}),
+			]
+
+			# Fetch balances using the full workflow
+			balances_data = query_builder.fetch_account_balances(accounts)
+
+			# Verify Cash account balances
+			cash_data = balances_data.get(cash_account)
+			self.assertIsNotNone(cash_data, "Cash account should exist in results")
+
+			# October: movement = +1000 (debit)
+			oct_cash = cash_data.get_period("2024_oct")
+			self.assertIsNotNone(oct_cash, "October period should exist for cash")
+			self.assertEqual(oct_cash.movement, 1000.0, "October cash movement should be 1000")
+
+			# November: movement = +500
+			nov_cash = cash_data.get_period("2024_nov")
+			self.assertIsNotNone(nov_cash, "November period should exist for cash")
+			self.assertEqual(nov_cash.movement, 500.0, "November cash movement should be 500")
+			self.assertEqual(
+				nov_cash.opening, oct_cash.closing, "November opening should equal October closing"
+			)
+
+			# December: movement = 0 (no transactions)
+			dec_cash = cash_data.get_period("2024_dec")
+			self.assertIsNotNone(dec_cash, "December period should exist for cash")
+			self.assertEqual(dec_cash.movement, 0.0, "December cash movement should be 0")
+			self.assertEqual(
+				dec_cash.closing,
+				nov_cash.closing,
+				"December closing should equal November closing when no movement",
+			)
+
+			# Verify Bank account balances (opposite direction)
+			bank_data = balances_data.get(bank_account)
+			self.assertIsNotNone(bank_data, "Bank account should exist in results")
+
+			oct_bank = bank_data.get_period("2024_oct")
+			self.assertEqual(oct_bank.movement, -1000.0, "October bank movement should be -1000")
+
+			nov_bank = bank_data.get_period("2024_nov")
+			self.assertEqual(nov_bank.movement, -500.0, "November bank movement should be -500")
+
+		finally:
+			# Clean up: cancel journal entries
+			jv_nov.cancel()
+			jv_oct.cancel()
+
+	def test_opening_balance_from_previous_period_closing(self):
+		company = "_Test Company"
+		cash_account = "_Test Cash - _TC"
+		sales_account = "Sales - _TC"
+		posting_date_2023 = "2023-06-15"
+
+		# Create journal entry in prior period (2023)
+		# Cash Dr 5000, Sales Cr 5000
+		jv_2023 = make_journal_entry(
+			account1=cash_account,
+			account2=sales_account,
+			amount=5000,
+			posting_date=posting_date_2023,
+			company=company,
+			submit=True,
+		)
+
+		pcv = None
+		jv_2024 = None
+		original_pcv_setting = frappe.db.get_single_value(
+			"Accounts Settings", "use_legacy_controller_for_pcv"
+		)
+
+		try:
+			# Create Period Closing Voucher for 2023
+			# This will create Account Closing Balance entries
+			closing_account = frappe.db.get_value(
+				"Account",
+				{
+					"company": company,
+					"root_type": "Liability",
+					"is_group": 0,
+					"account_type": ["not in", ["Payable", "Receivable"]],
+				},
+				"name",
+			)
+
+			fy_2023 = get_fiscal_year(posting_date_2023, company=company)
+
+			frappe.db.set_single_value("Accounts Settings", "use_legacy_controller_for_pcv", 1)
+
+			pcv = frappe.get_doc(
+				{
+					"doctype": "Period Closing Voucher",
+					"transaction_date": "2023-12-31",
+					"period_start_date": fy_2023[1],
+					"period_end_date": fy_2023[2],
+					"company": company,
+					"fiscal_year": fy_2023[0],
+					"cost_center": "_Test Cost Center - _TC",
+					"closing_account_head": closing_account,
+					"remarks": "Test Period Closing",
+				}
+			)
+			pcv.insert()
+			pcv.submit()
+			pcv.reload()
+
+			# Now create a small transaction in 2024 to ensure the account appears
+			jv_2024 = make_journal_entry(
+				account1=cash_account,
+				account2=sales_account,
+				amount=100,
+				posting_date="2024-01-15",
+				company=company,
+				submit=True,
+			)
+
+			# Set up filters for Q1 2024 (after the period closing)
+			filters = {
+				"company": company,
+				"from_fiscal_year": "2024",
+				"to_fiscal_year": "2024",
+				"period_start_date": "2024-01-01",
+				"period_end_date": "2024-03-31",
+				"filter_based_on": "Date Range",
+				"periodicity": "Monthly",
+				"ignore_closing_entries": True,  # Don't include PCV entries in movements
+			}
+
+			periods = [
+				{"key": "2024_jan", "from_date": "2024-01-01", "to_date": "2024-01-31"},
+				{"key": "2024_feb", "from_date": "2024-02-01", "to_date": "2024-02-29"},
+				{"key": "2024_mar", "from_date": "2024-03-01", "to_date": "2024-03-31"},
+			]
+
+			query_builder = FinancialQueryBuilder(filters, periods)
+
+			accounts = [
+				frappe._dict({"name": cash_account, "account_name": "Cash", "account_number": "1001"}),
+			]
+
+			balances_data = query_builder.fetch_account_balances(accounts)
+
+			# Verify Cash account has opening balance from 2023 transactions
+			cash_data = balances_data.get(cash_account)
+			self.assertIsNotNone(cash_data, "Cash account should exist in results")
+
+			jan_cash = cash_data.get_period("2024_jan")
+			self.assertIsNotNone(jan_cash, "January period should exist")
+
+			# Opening balance should be from prior period
+			# Cash had 5000 debit in 2023, so opening in 2024 should be >= 5000
+			# (may be higher if there were other test transactions)
+			self.assertEqual(
+				jan_cash.opening,
+				5000.0,
+				"January opening should equal to balance from 2023 (5000)",
+			)
+
+			# Verify running balance logic
+			# Movement in January is 100 (from jv_2024)
+			self.assertEqual(jan_cash.movement, 100.0, "January movement should be 100")
+			self.assertEqual(
+				jan_cash.closing, jan_cash.opening + jan_cash.movement, "Closing = Opening + Movement"
+			)
+
+			# February and March should have no movement but carry the balance
+			feb_cash = cash_data.get_period("2024_feb")
+			self.assertEqual(feb_cash.opening, jan_cash.closing, "Feb opening = Jan closing")
+			self.assertEqual(feb_cash.movement, 0.0, "February should have no movement")
+			self.assertEqual(feb_cash.closing, feb_cash.opening, "Feb closing = opening when no movement")
+
+			mar_cash = cash_data.get_period("2024_mar")
+			self.assertEqual(mar_cash.opening, feb_cash.closing, "Mar opening = Feb closing")
+			self.assertEqual(mar_cash.movement, 0.0, "March should have no movement")
+			self.assertEqual(mar_cash.closing, mar_cash.opening, "Mar closing = opening when no movement")
+
+			# Set up filters for Q2 2024
+			filters_q2 = {
+				"company": company,
+				"from_fiscal_year": "2024",
+				"to_fiscal_year": "2024",
+				"period_start_date": "2024-04-01",
+				"period_end_date": "2024-06-30",
+				"filter_based_on": "Date Range",
+				"periodicity": "Monthly",
+				"ignore_closing_entries": True,
+			}
+
+			periods_q2 = [
+				{"key": "2024_apr", "from_date": "2024-04-01", "to_date": "2024-04-30"},
+				{"key": "2024_may", "from_date": "2024-05-01", "to_date": "2024-05-31"},
+				{"key": "2024_jun", "from_date": "2024-06-01", "to_date": "2024-06-30"},
+			]
+
+			query_builder_q2 = FinancialQueryBuilder(filters_q2, periods_q2)
+
+			balances_data_q2 = query_builder_q2.fetch_account_balances(accounts)
+
+			# Verify Cash account in Q2
+			cash_data_q2 = balances_data_q2.get(cash_account)
+			self.assertIsNotNone(cash_data_q2, "Cash account should exist in Q2 results")
+
+			apr_cash = cash_data_q2.get_period("2024_apr")
+			self.assertIsNotNone(apr_cash, "April period should exist")
+
+			# Opening balance in April should equal closing in March
+			self.assertEqual(
+				apr_cash.opening,
+				mar_cash.closing,
+				"April opening should equal March closing balance",
+			)
+
+			self.assertEqual(apr_cash.closing, apr_cash.opening, "April closing = opening when no movement")
+
+		finally:
+			# Clean up
+			frappe.db.set_single_value(
+				"Accounts Settings", "use_legacy_controller_for_pcv", original_pcv_setting or 0
+			)
+
+			if jv_2024:
+				jv_2024.cancel()
+
+			if pcv:
+				pcv.reload()
+				if pcv.docstatus == 1:
+					pcv.cancel()
+
+			jv_2023.cancel()
+
+	def test_account_with_gl_entries_but_no_prior_closing_balance(self):
+		company = "_Test Company"
+		cash_account = "_Test Cash - _TC"
+		bank_account = "_Test Bank - _TC"
+
+		# Create journal entries WITHOUT any prior Period Closing Voucher
+		# This ensures the account exists in gl_dict but NOT in balances_data
+		jv = make_journal_entry(
+			account1=cash_account,
+			account2=bank_account,
+			amount=2500,
+			posting_date="2024-07-15",
+			company=company,
+			submit=True,
+		)
+
+		try:
+			# Set up filters - use a period with no prior PCV
+			filters = {
+				"company": company,
+				"from_fiscal_year": "2024",
+				"to_fiscal_year": "2024",
+				"period_start_date": "2024-07-01",
+				"period_end_date": "2024-09-30",
+				"filter_based_on": "Date Range",
+				"periodicity": "Monthly",
+			}
+
+			periods = [
+				{"key": "2024_jul", "from_date": "2024-07-01", "to_date": "2024-07-31"},
+				{"key": "2024_aug", "from_date": "2024-08-01", "to_date": "2024-08-31"},
+				{"key": "2024_sep", "from_date": "2024-09-01", "to_date": "2024-09-30"},
+			]
+
+			query_builder = FinancialQueryBuilder(filters, periods)
+
+			# Use accounts that have GL entries but may not have Account Closing Balance
+			accounts = [
+				frappe._dict({"name": cash_account, "account_name": "Cash", "account_number": "1001"}),
+				frappe._dict({"name": bank_account, "account_name": "Bank", "account_number": "1002"}),
+			]
+
+			balances_data = query_builder.fetch_account_balances(accounts)
+
+			# Verify accounts are present in results even without prior closing balance
+			cash_data = balances_data.get(cash_account)
+			self.assertIsNotNone(cash_data, "Cash account should exist in results")
+
+			bank_data = balances_data.get(bank_account)
+			self.assertIsNotNone(bank_data, "Bank account should exist in results")
+
+			# Verify July has the movement from journal entry
+			jul_cash = cash_data.get_period("2024_jul")
+			self.assertIsNotNone(jul_cash, "July period should exist for cash")
+			self.assertEqual(jul_cash.movement, 2500.0, "July cash movement should be 2500")
+
+			jul_bank = bank_data.get_period("2024_jul")
+			self.assertIsNotNone(jul_bank, "July period should exist for bank")
+			self.assertEqual(jul_bank.movement, -2500.0, "July bank movement should be -2500")
+
+			# Verify subsequent periods exist with zero movement
+			aug_cash = cash_data.get_period("2024_aug")
+			self.assertIsNotNone(aug_cash, "August period should exist for cash")
+			self.assertEqual(aug_cash.movement, 0.0, "August cash movement should be 0")
+			self.assertEqual(aug_cash.opening, jul_cash.closing, "August opening = July closing")
+
+			sep_cash = cash_data.get_period("2024_sep")
+			self.assertIsNotNone(sep_cash, "September period should exist for cash")
+			self.assertEqual(sep_cash.movement, 0.0, "September cash movement should be 0")
+			self.assertEqual(sep_cash.opening, aug_cash.closing, "September opening = August closing")
+
+		finally:
+			jv.cancel()

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -277,7 +277,21 @@ frappe.ui.form.on("Journal Entry", {
 var update_jv_details = function (doc, r) {
 	$.each(r, function (i, d) {
 		var row = frappe.model.add_child(doc, "Journal Entry Account", "accounts");
-		frappe.model.set_value(row.doctype, row.name, "account", d.account);
+		const {
+			idx,
+			name,
+			owner,
+			parent,
+			parenttype,
+			parentfield,
+			creation,
+			modified,
+			modified_by,
+			doctype,
+			docstatus,
+			...fields
+		} = d;
+		frappe.model.set_value(row.doctype, row.name, fields);
 	});
 	refresh_field("accounts");
 };

erpnext/accounts/doctype/journal_entry/journal_entry.json

@@ -9,6 +9,7 @@
  "engine": "InnoDB",
  "field_order": [
   "entry_type_and_date",
+  "company",
   "is_system_generated",
   "title",
   "voucher_type",
@@ -17,7 +18,6 @@
   "reversal_of",
   "column_break1",
   "from_template",
-  "company",
   "posting_date",
   "finance_book",
   "apply_tds",
@@ -638,7 +638,7 @@
    "table_fieldname": "payment_entries"
   }
  ],
- "modified": "2025-11-13 17:54:14.542903",
+ "modified": "2026-02-03 14:40:39.944524",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry",

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -74,8 +74,8 @@ class JournalEntry(AccountsController):
 		mode_of_payment: DF.Link | None
 		multi_currency: DF.Check
 		naming_series: DF.Literal["ACC-JV-.YYYY.-"]
-		party_not_required: DF.Check
 		override_tax_withholding_entries: DF.Check
+		party_not_required: DF.Check
 		pay_to_recd_from: DF.Data | None
 		payment_order: DF.Link | None
 		periodic_entry_difference_account: DF.Link | None
@@ -179,11 +179,14 @@ class JournalEntry(AccountsController):
 		validate_docs_for_deferred_accounting([self.name], [])
 
 	def submit(self):
-		if len(self.accounts) > 100:
+		if len(self.accounts) > 100 and not self.meta.queue_in_background:
 			queue_submission(self, "_submit")
 		else:
 			return self._submit()
 
+	def before_cancel(self):
+		self.has_asset_adjustment_entry()
+
 	def cancel(self):
 		if len(self.accounts) > 100:
 			queue_submission(self, "_cancel")
@@ -554,12 +557,27 @@ class JournalEntry(AccountsController):
 			)
 			frappe.db.set_value("Journal Entry", self.name, "inter_company_journal_entry_reference", "")
 
-	def unlink_asset_adjustment_entry(self):
-		frappe.db.sql(
-			""" update `tabAsset Value Adjustment`
-			set journal_entry = null where journal_entry = %s""",
-			self.name,
+	def has_asset_adjustment_entry(self):
+		if self.flags.get("via_asset_value_adjustment"):
+			return
+
+		asset_value_adjustment = frappe.db.get_value(
+			"Asset Value Adjustment", {"docstatus": 1, "journal_entry": self.name}, "name"
 		)
+		if asset_value_adjustment:
+			frappe.throw(
+				_(
+					"Cannot cancel this document as it is linked with the submitted Asset Value Adjustment <b>{0}</b>. Please cancel the Asset Value Adjustment to continue."
+				).format(frappe.utils.get_link_to_form("Asset Value Adjustment", asset_value_adjustment))
+			)
+
+	def unlink_asset_adjustment_entry(self):
+		AssetValueAdjustment = frappe.qb.DocType("Asset Value Adjustment")
+		(
+			frappe.qb.update(AssetValueAdjustment)
+			.set(AssetValueAdjustment.journal_entry, None)
+			.where(AssetValueAdjustment.journal_entry == self.name)
+		).run()
 
 	def validate_party(self):
 		for d in self.get("accounts"):
@@ -1673,6 +1691,10 @@ def get_exchange_rate(
 	credit=None,
 	exchange_rate=None,
 ):
+	# Ensure exchange_rate is always numeric to avoid calculation errors
+	if isinstance(exchange_rate, str):
+		exchange_rate = flt(exchange_rate) or 1
+
 	account_details = frappe.get_cached_value(
 		"Account", account, ["account_type", "root_type", "account_currency", "company"], as_dict=1
 	)

erpnext/accounts/doctype/journal_entry_template/journal_entry_template.js

@@ -3,6 +3,7 @@
 
 frappe.ui.form.on("Journal Entry Template", {
 	onload: function (frm) {
+		erpnext.accounts.dimensions.setup_dimension_filters(frm, frm.doctype);
 		if (frm.is_new()) {
 			frappe.call({
 				type: "GET",
@@ -37,6 +38,31 @@ frappe.ui.form.on("Journal Entry Template", {
 
 			return { filters: filters };
 		});
+
+		frm.set_query("project", "accounts", function (doc, cdt, cdn) {
+			let row = frappe.get_doc(cdt, cdn);
+			let filters = {
+				company: doc.company,
+			};
+			if (row.party_type == "Customer") {
+				filters.customer = row.party;
+			}
+			return {
+				query: "erpnext.controllers.queries.get_project_name",
+				filters,
+			};
+		});
+
+		frm.set_query("party_type", "accounts", function (doc, cdt, cdn) {
+			const row = locals[cdt][cdn];
+
+			return {
+				query: "erpnext.setup.doctype.party_type.party_type.get_party_type",
+				filters: {
+					account: row.account,
+				},
+			};
+		});
 	},
 	voucher_type: function (frm) {
 		var add_accounts = function (doc, r) {

erpnext/accounts/doctype/journal_entry_template/journal_entry_template.py

@@ -3,6 +3,7 @@
 
 
 import frappe
+from frappe import _
 from frappe.model.document import Document
 
 
@@ -42,7 +43,29 @@ class JournalEntryTemplate(Document):
 		]
 	# end: auto-generated types
 
-	pass
+	def validate(self):
+		self.validate_party()
+
+	def validate_party(self):
+		"""
+		Loop over all accounts and see if party and party type is set correctly
+		"""
+		for account in self.accounts:
+			if account.party_type:
+				account_type = frappe.get_cached_value("Account", account.account, "account_type")
+				if account_type not in ["Receivable", "Payable"]:
+					frappe.throw(
+						_(
+							"Check row {0} for account {1}: Party Type is only allowed for Receivable or Payable accounts"
+						).format(account.idx, account.account)
+					)
+
+			if account.party and not account.party_type:
+				frappe.throw(
+					_("Check row {0} for account {1}: Party is only allowed if Party Type is set").format(
+						account.idx, account.account
+					)
+				)
 
 
 @frappe.whitelist()

erpnext/accounts/doctype/journal_entry_template_account/journal_entry_template_account.json

@@ -5,7 +5,13 @@
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
-  "account"
+  "account",
+  "party_type",
+  "party",
+  "accounting_dimensions_section",
+  "cost_center",
+  "dimension_col_break",
+  "project"
  ],
  "fields": [
   {
@@ -15,18 +21,55 @@
    "label": "Account",
    "options": "Account",
    "reqd": 1
+  },
+  {
+   "fieldname": "party_type",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "Party Type",
+   "options": "DocType"
+  },
+  {
+   "fieldname": "party",
+   "fieldtype": "Dynamic Link",
+   "in_list_view": 1,
+   "label": "Party",
+   "options": "party_type"
+  },
+  {
+   "collapsible": 1,
+   "fieldname": "accounting_dimensions_section",
+   "fieldtype": "Section Break",
+   "label": "Accounting Dimensions"
+  },
+  {
+   "fieldname": "cost_center",
+   "fieldtype": "Link",
+   "label": "Cost Center",
+   "options": "Cost Center"
+  },
+  {
+   "fieldname": "project",
+   "fieldtype": "Link",
+   "label": "Project",
+   "options": "Project"
+  },
+  {
+   "fieldname": "dimension_col_break",
+   "fieldtype": "Column Break"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2024-03-27 13:09:58.986448",
+ "modified": "2026-01-09 13:16:27.615083",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry Template Account",
  "owner": "Administrator",
  "permissions": [],
+ "row_format": "Dynamic",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/journal_entry_template_account/journal_entry_template_account.py

@@ -16,9 +16,13 @@ class JournalEntryTemplateAccount(Document):
 		from frappe.types import DF
 
 		account: DF.Link
+		cost_center: DF.Link | None
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data
+		party: DF.DynamicLink | None
+		party_type: DF.Link | None
+		project: DF.Link | None
 	# end: auto-generated types
 
 	pass

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -400,6 +400,16 @@ frappe.ui.form.on("Payment Entry", {
 		);
 
 		frm.refresh_fields();
+
+		const party_currency =
+			frm.doc.payment_type === "Receive" ? "paid_from_account_currency" : "paid_to_account_currency";
+
+		var reference_grid = frm.fields_dict["references"].grid;
+		["total_amount", "outstanding_amount", "allocated_amount"].forEach((fieldname) => {
+			reference_grid.update_docfield_property(fieldname, "options", party_currency);
+		});
+
+		reference_grid.refresh();
 	},
 
 	show_general_ledger: function (frm) {
@@ -1104,7 +1114,7 @@ frappe.ui.form.on("Payment Entry", {
 
 	allocate_party_amount_against_ref_docs: async function (frm, paid_amount, paid_amount_change) {
 		await frm.call("allocate_amount_to_references", {
-			paid_amount: paid_amount,
+			paid_amount: flt(paid_amount),
 			paid_amount_change: paid_amount_change,
 			allocate_payment_amount: frappe.flags.allocate_payment_amount ?? false,
 		});

erpnext/accounts/doctype/payment_ledger_entry/payment_ledger_entry.json

@@ -132,6 +132,12 @@
    "fieldtype": "Link",
    "label": "Cost Center",
    "options": "Cost Center"
+  },
+    {
+   "fieldname": "project",
+   "fieldtype": "Link",
+   "label": "Project",
+   "options": "Project"
   },
   {
    "fieldname": "due_date",

erpnext/accounts/doctype/payment_ledger_entry/payment_ledger_entry.py

@@ -38,6 +38,7 @@ class PaymentLedgerEntry(Document):
 		amount_in_account_currency: DF.Currency
 		company: DF.Link | None
 		cost_center: DF.Link | None
+		project: DF.Link | None
 		delinked: DF.Check
 		due_date: DF.Date | None
 		finance_book: DF.Link | None

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -746,7 +746,7 @@ class PaymentReconciliation(Document):
 		ple = qb.DocType("Payment Ledger Entry")
 		for x in self.dimensions:
 			dimension = x.fieldname
-			if self.get(dimension):
+			if self.get(dimension) and frappe.db.has_column("Payment Ledger Entry", dimension):
 				self.accounting_dimension_filter_conditions.append(ple[dimension] == self.get(dimension))
 
 	def build_qb_filter_conditions(self, get_invoices=False, get_return_invoices=False):

erpnext/accounts/doctype/pos_invoice/pos_invoice.json

@@ -1610,13 +1610,14 @@
    "hidden": 1,
    "label": "Item Wise Tax Details",
    "no_copy": 1,
-   "options": "Item Wise Tax Detail"
+   "options": "Item Wise Tax Detail",
+   "print_hide": 1
   }
  ],
  "icon": "fa fa-file-text",
  "is_submittable": 1,
  "links": [],
- "modified": "2025-08-04 22:22:31.471752",
+ "modified": "2026-01-29 21:20:51.376875",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice",

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -898,6 +898,53 @@ class TestPOSInvoice(IntegrationTestCase):
 			if batch.batch_no == batch_no and batch.warehouse == "_Test Warehouse - _TC":
 				self.assertEqual(batch.qty, 5)
 
+	def test_pos_batch_reservation_with_return_qty(self):
+		"""
+		Test POS Invoice reserved qty for batch without bundle with return invoices.
+		"""
+		from erpnext.stock.doctype.serial_and_batch_bundle.serial_and_batch_bundle import (
+			get_auto_batch_nos,
+		)
+		from erpnext.stock.doctype.stock_reconciliation.test_stock_reconciliation import (
+			create_batch_item_with_batch,
+		)
+
+		create_batch_item_with_batch("_Batch Item Reserve Return", "TestBatch-RR 01")
+		se = make_stock_entry(
+			target="_Test Warehouse - _TC",
+			item_code="_Batch Item Reserve Return",
+			qty=30,
+			basic_rate=100,
+		)
+
+		se.reload()
+
+		batch_no = get_batch_from_bundle(se.items[0].serial_and_batch_bundle)
+
+		# POS Invoice for the batch without bundle
+		pos_inv = create_pos_invoice(item="_Batch Item Reserve Return", rate=300, qty=15, do_not_save=1)
+		pos_inv.append(
+			"payments",
+			{"mode_of_payment": "Cash", "amount": 4500},
+		)
+		pos_inv.items[0].batch_no = batch_no
+		pos_inv.save()
+		pos_inv.submit()
+
+		# POS Invoice return
+		pos_return = make_sales_return(pos_inv.name)
+
+		pos_return.insert()
+		pos_return.submit()
+
+		batches = get_auto_batch_nos(
+			frappe._dict({"item_code": "_Batch Item Reserve Return", "warehouse": "_Test Warehouse - _TC"})
+		)
+
+		for batch in batches:
+			if batch.batch_no == batch_no and batch.warehouse == "_Test Warehouse - _TC":
+				self.assertEqual(batch.qty, 30)
+
 	def test_pos_batch_item_qty_validation(self):
 		from erpnext.stock.doctype.serial_and_batch_bundle.serial_and_batch_bundle import (
 			BatchNegativeStockError,

erpnext/accounts/doctype/pos_profile/test_pos_profile.py

@@ -99,8 +99,7 @@ def get_customers_list(pos_profile=None):
 
 	return (
 		frappe.db.sql(
-			f""" select name, customer_name, customer_group,
-		territory, customer_pos_id from tabCustomer where disabled = 0
+			f""" select name, customer_name, customer_group, territory from tabCustomer where disabled = 0
 		and {cond}""",
 			tuple(customer_groups),
 			as_dict=1,

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.py

@@ -415,8 +415,9 @@ def reconcile(doc: None | str = None) -> None:
 					for x in allocations:
 						pr.append("allocation", x)
 
+					skip_ref_details_update_for_pe = check_multi_currency(pr)
 					# reconcile
-					pr.reconcile_allocations(skip_ref_details_update_for_pe=True)
+					pr.reconcile_allocations(skip_ref_details_update_for_pe=skip_ref_details_update_for_pe)
 
 					# If Payment Entry, update details only for newly linked references
 					# This is for performance
@@ -504,6 +505,37 @@ def reconcile(doc: None | str = None) -> None:
 				frappe.db.set_value("Process Payment Reconciliation", doc, "status", "Completed")
 
 
+def check_multi_currency(pr_doc):
+	GL = frappe.qb.DocType("GL Entry")
+	Account = frappe.qb.DocType("Account")
+
+	def get_account_currency(voucher_type, voucher_no):
+		currency = (
+			frappe.qb.from_(GL)
+			.join(Account)
+			.on(GL.account == Account.name)
+			.select(Account.account_currency)
+			.where(
+				(GL.voucher_type == voucher_type)
+				& (GL.voucher_no == voucher_no)
+				& (Account.account_type.isin(["Payable", "Receivable"]))
+			)
+			.limit(1)
+		).run(as_dict=True)
+
+		return currency[0].account_currency if currency else None
+
+	for allocation in pr_doc.allocation:
+		reference_currency = get_account_currency(allocation.reference_type, allocation.reference_name)
+
+		invoice_currency = get_account_currency(allocation.invoice_type, allocation.invoice_number)
+
+		if reference_currency != invoice_currency:
+			return True
+
+	return False
+
+
 @frappe.whitelist()
 def is_any_doc_running(for_filter: str | dict | None = None) -> str | None:
 	running_doc = None

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -8,12 +8,12 @@
  "email_append_to": 1,
  "engine": "InnoDB",
  "field_order": [
+  "company",
   "title",
   "naming_series",
   "supplier",
   "supplier_name",
   "tax_id",
-  "company",
   "column_break_6",
   "posting_date",
   "posting_time",
@@ -606,6 +606,7 @@
   },
   {
    "default": "0",
+   "depends_on": "eval:doc.items.every((item) => !item.pr_detail)",
    "fieldname": "update_stock",
    "fieldtype": "Check",
    "label": "Update Stock",
@@ -1625,7 +1626,8 @@
    "hidden": 1,
    "label": "Item Wise Tax Details",
    "no_copy": 1,
-   "options": "Item Wise Tax Detail"
+   "options": "Item Wise Tax Detail",
+   "print_hide": 1
   },
   {
    "collapsible": 1,
@@ -1667,7 +1669,7 @@
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-12-15 06:41:38.237728",
+ "modified": "2026-02-05 20:45:16.964500",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -36,7 +36,7 @@ from erpnext.accounts.utils import get_account_currency, get_fiscal_year, update
 from erpnext.assets.doctype.asset.asset import is_cwip_accounting_enabled
 from erpnext.assets.doctype.asset_category.asset_category import get_asset_category_account
 from erpnext.buying.utils import check_on_hold_or_closed_status
-from erpnext.controllers.accounts_controller import validate_account_head
+from erpnext.controllers.accounts_controller import merge_taxes, validate_account_head
 from erpnext.controllers.buying_controller import BuyingController
 from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
 	update_billed_amount_based_on_po,
@@ -2005,9 +2005,17 @@ def make_purchase_receipt(source_name, target_doc=None, args=None):
 		args = json.loads(args)
 
 	def post_parent_process(source_parent, target_parent):
-		for row in target_parent.get("items"):
-			if row.get("qty") == 0:
-				target_parent.remove(row)
+		remove_items_with_zero_qty(target_parent)
+		set_missing_values(source_parent, target_parent)
+
+	def remove_items_with_zero_qty(target_parent):
+		target_parent.items = [row for row in target_parent.get("items") if row.get("qty") != 0]
+
+	def set_missing_values(source_parent, target_parent):
+		target_parent.run_method("set_missing_values")
+		if args and args.get("merge_taxes"):
+			merge_taxes(source_parent, target_parent)
+		target_parent.run_method("calculate_taxes_and_totals")
 
 	def update_item(obj, target, source_parent):
 		from erpnext.controllers.sales_and_purchase_return import get_returned_qty_map_for_row
@@ -2059,7 +2067,11 @@ def make_purchase_receipt(source_name, target_doc=None, args=None):
 				"postprocess": update_item,
 				"condition": lambda doc: abs(doc.received_qty) < abs(doc.qty) and select_item(doc),
 			},
-			"Purchase Taxes and Charges": {"doctype": "Purchase Taxes and Charges"},
+			"Purchase Taxes and Charges": {
+				"doctype": "Purchase Taxes and Charges",
+				"reset_value": not (args and args.get("merge_taxes")),
+				"ignore": args.get("merge_taxes") if args else 0,
+			},
 		},
 		target_doc,
 		post_parent_process,

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -44,6 +44,7 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 			"Unreconcile Payment Entries",
 			"Serial and Batch Bundle",
 			"Bank Transaction",
+			"Packing Slip",
 		];
 
 		if (!this.frm.doc.__islocal && !this.frm.doc.customer && this.frm.doc.debit_to) {
@@ -115,18 +116,21 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 			}
 
 			if (cint(doc.update_stock) != 1) {
-				// show Make Delivery Note button only if Sales Invoice is not created from Delivery Note
-				var from_delivery_note = false;
-				from_delivery_note = this.frm.doc.items.some(function (item) {
-					return item.delivery_note ? true : false;
-				});
-
-				if (!from_delivery_note && !is_delivered_by_supplier) {
-					this.frm.add_custom_button(
-						__("Delivery"),
-						this.frm.cscript["Make Delivery Note"],
-						__("Create")
+				if (!is_delivered_by_supplier) {
+					const should_create_delivery_note = doc.items.some(
+						(item) =>
+							item.qty - item.delivered_qty > 0 &&
+							!item.scio_detail &&
+							!item.dn_detail &&
+							!item.delivered_by_supplier
 					);
+					if (should_create_delivery_note) {
+						this.frm.add_custom_button(
+							__("Delivery Note"),
+							this.frm.cscript["Make Delivery Note"],
+							__("Create")
+						);
+					}
 				}
 			}
 

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -7,12 +7,12 @@
  "engine": "InnoDB",
  "field_order": [
   "customer_section",
+  "company",
+  "company_tax_id",
   "naming_series",
   "customer",
   "customer_name",
   "tax_id",
-  "company",
-  "company_tax_id",
   "column_break1",
   "posting_date",
   "posting_time",
@@ -703,6 +703,7 @@
   },
   {
    "default": "0",
+   "depends_on": "eval:doc.items.every((item) => !item.dn_detail)",
    "fieldname": "update_stock",
    "fieldtype": "Check",
    "hide_days": 1,
@@ -778,8 +779,7 @@
   },
   {
    "collapsible": 1,
-   "collapsible_depends_on": "eval:doc.total_billing_amount > 0",
-   "depends_on": "eval:!doc.is_return",
+   "collapsible_depends_on": "eval:doc.total_billing_amount > 0 || doc.total_billing_hours > 0",
    "fieldname": "time_sheet_list",
    "fieldtype": "Section Break",
    "hide_border": 1,
@@ -793,7 +793,6 @@
    "hide_days": 1,
    "hide_seconds": 1,
    "label": "Time Sheets",
-   "no_copy": 1,
    "options": "Sales Invoice Timesheet",
    "print_hide": 1
   },
@@ -2092,7 +2091,7 @@
    "fieldtype": "Column Break"
   },
   {
-   "depends_on": "eval:(!doc.is_return && doc.total_billing_amount > 0)",
+   "depends_on": "eval:doc.total_billing_amount > 0 || doc.total_billing_hours > 0",
    "fieldname": "section_break_104",
    "fieldtype": "Section Break"
   },
@@ -2252,7 +2251,8 @@
    "hidden": 1,
    "label": "Item Wise Tax Details",
    "no_copy": 1,
-   "options": "Item Wise Tax Detail"
+   "options": "Item Wise Tax Detail",
+   "print_hide": 1
   },
   {
    "default": "0",
@@ -2306,7 +2306,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2025-10-09 14:48:59.472826",
+ "modified": "2026-02-06 20:43:44.732805",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -352,10 +352,22 @@ class SalesInvoice(SellingController):
 			self.is_opening = "No"
 
 		self.set_against_income_account()
-		self.validate_time_sheets_are_submitted()
+
+		if self.is_return and not self.return_against and self.timesheets:
+			frappe.throw(_("Direct return is not allowed for Timesheet."))
+
+		if not self.is_return:
+			self.validate_time_sheets_are_submitted()
+
 		self.validate_multiple_billing("Delivery Note", "dn_detail", "amount")
-		if self.is_return:
-			self.timesheets = []
+
+		if self.is_return and self.return_against:
+			for row in self.timesheets:
+				if row.billing_hours:
+					row.billing_hours = -abs(row.billing_hours)
+				if row.billing_amount:
+					row.billing_amount = -abs(row.billing_amount)
+
 		self.update_packing_list()
 		self.set_billing_hours_and_amount()
 		self.update_timesheet_billing_for_project()
@@ -484,7 +496,7 @@ class SalesInvoice(SellingController):
 		if cint(self.is_pos) != 1 and not self.is_return:
 			self.update_against_document_in_jv()
 
-		self.update_time_sheet(self.name)
+		self.update_time_sheet(None if (self.is_return and self.return_against) else self.name)
 
 		if frappe.get_single_value("Selling Settings", "sales_update_frequency") == "Each Transaction":
 			update_company_current_month_sales(self.company)
@@ -564,7 +576,7 @@ class SalesInvoice(SellingController):
 		self.check_if_consolidated_invoice()
 
 		super().before_cancel()
-		self.update_time_sheet(None)
+		self.update_time_sheet(self.return_against if (self.is_return and self.return_against) else None)
 
 	def on_cancel(self):
 		check_if_return_invoice_linked_with_payment_entry(self)
@@ -804,8 +816,20 @@ class SalesInvoice(SellingController):
 		for data in timesheet.time_logs:
 			if (
 				(self.project and args.timesheet_detail == data.name)
-				or (not self.project and not data.sales_invoice)
-				or (not sales_invoice and data.sales_invoice == self.name)
+				or (not self.project and not data.sales_invoice and args.timesheet_detail == data.name)
+				or (
+					not sales_invoice
+					and data.sales_invoice == self.name
+					and args.timesheet_detail == data.name
+				)
+				or (
+					self.is_return
+					and self.return_against
+					and data.sales_invoice
+					and data.sales_invoice == self.return_against
+					and not sales_invoice
+					and args.timesheet_detail == data.name
+				)
 			):
 				data.sales_invoice = sales_invoice
 
@@ -845,11 +869,26 @@ class SalesInvoice(SellingController):
 			payment.account = get_bank_cash_account(payment.mode_of_payment, self.company).get("account")
 
 	def validate_time_sheets_are_submitted(self):
+		# Note: This validation is skipped for return invoices
+		# to allow returns to reference already-billed timesheet details
 		for data in self.timesheets:
+			# Handle invoice duplication
+			if data.time_sheet and data.timesheet_detail:
+				if sales_invoice := frappe.db.get_value(
+					"Timesheet Detail", data.timesheet_detail, "sales_invoice"
+				):
+					frappe.throw(
+						_("Row {0}: Sales Invoice {1} is already created for {2}").format(
+							data.idx, frappe.bold(sales_invoice), frappe.bold(data.time_sheet)
+						)
+					)
+
 			if data.time_sheet:
 				status = frappe.db.get_value("Timesheet", data.time_sheet, "status")
-				if status not in ["Submitted", "Payslip"]:
-					frappe.throw(_("Timesheet {0} is already completed or cancelled").format(data.time_sheet))
+				if status not in ["Submitted", "Payslip", "Partially Billed"]:
+					frappe.throw(
+						_("Timesheet {0} cannot be invoiced in its current state").format(data.time_sheet)
+					)
 
 	def set_pos_fields(self, for_validate=False):
 		"""Set retail related fields from POS Profiles"""
@@ -1283,7 +1322,12 @@ class SalesInvoice(SellingController):
 					timesheet.billing_amount = ts_doc.total_billable_amount
 
 	def update_timesheet_billing_for_project(self):
-		if not self.timesheets and self.project and self.is_auto_fetch_timesheet_enabled():
+		if (
+			not self.is_return
+			and not self.timesheets
+			and self.project
+			and self.is_auto_fetch_timesheet_enabled()
+		):
 			self.add_timesheet_data()
 		else:
 			self.calculate_billing_amount_for_timesheet()
@@ -2378,7 +2422,10 @@ def make_delivery_note(source_name, target_doc=None):
 					"cost_center": "cost_center",
 				},
 				"postprocess": update_item,
-				"condition": lambda doc: doc.delivered_by_supplier != 1 and not doc.scio_detail,
+				"condition": lambda doc: doc.delivered_by_supplier != 1
+				and not doc.scio_detail
+				and not doc.dn_detail
+				and doc.qty - doc.delivered_qty > 0,
 			},
 			"Sales Taxes and Charges": {"doctype": "Sales Taxes and Charges", "reset_value": True},
 			"Sales Team": {

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -2951,6 +2951,60 @@ class TestSalesInvoice(ERPNextTestSuite):
 		self.assertEqual(sales_invoice.items[0].item_tax_template, "_Test Account Excise Duty @ 10 - _TC")
 		self.assertEqual(sales_invoice.items[0].item_tax_rate, item_tax_map)
 
+	def test_item_tax_template_change_with_grand_total_discount(self):
+		"""
+		Test that when item tax template changes due to discount on Grand Total,
+		the tax calculations are consistent.
+		"""
+		item = create_item("Test Item With Multiple Tax Templates")
+
+		item.set("taxes", [])
+		item.append(
+			"taxes",
+			{
+				"item_tax_template": "_Test Account Excise Duty @ 10 - _TC",
+				"minimum_net_rate": 0,
+				"maximum_net_rate": 500,
+			},
+		)
+
+		item.append(
+			"taxes",
+			{
+				"item_tax_template": "_Test Account Excise Duty @ 12 - _TC",
+				"minimum_net_rate": 501,
+				"maximum_net_rate": 1000,
+			},
+		)
+
+		item.save()
+
+		si = create_sales_invoice(item=item.name, rate=700, do_not_save=True)
+		si.append(
+			"taxes",
+			{
+				"charge_type": "On Net Total",
+				"account_head": "_Test Account Excise Duty - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "Excise Duty",
+				"rate": 0,
+			},
+		)
+		si.insert()
+
+		self.assertEqual(si.items[0].item_tax_template, "_Test Account Excise Duty @ 12 - _TC")
+
+		si.apply_discount_on = "Grand Total"
+		si.discount_amount = 300
+		si.save()
+
+		# Verify template changed to 10%
+		self.assertEqual(si.items[0].item_tax_template, "_Test Account Excise Duty @ 10 - _TC")
+		self.assertEqual(si.taxes[0].tax_amount, 70)  # 10% of 700
+		self.assertEqual(si.grand_total, 470)  # 700 + 70 - 300
+
+		si.submit()
+
 	@IntegrationTestCase.change_settings("Selling Settings", {"enable_discount_accounting": 1})
 	def test_sales_invoice_with_discount_accounting_enabled(self):
 		discount_account = create_account(
@@ -4691,6 +4745,66 @@ class TestSalesInvoice(ERPNextTestSuite):
 
 		doc.db_set("do_not_use_batchwise_valuation", original_value)
 
+	@change_settings("Selling Settings", {"set_zero_rate_for_expired_batch": True})
+	def test_zero_valuation_for_standalone_credit_note_with_expired_batch(self):
+		item_code = "_Test Item for Expiry Batch Zero Valuation"
+		make_item_for_si(
+			item_code,
+			{
+				"is_stock_item": 1,
+				"has_batch_no": 1,
+				"has_expiry_date": 1,
+				"shelf_life_in_days": 2,
+				"create_new_batch": 1,
+				"batch_number_series": "TBATCH-EBZV.####",
+			},
+		)
+
+		se = make_stock_entry(
+			item_code=item_code,
+			qty=10,
+			target="_Test Warehouse - _TC",
+			rate=100,
+		)
+
+		# fetch batch no from bundle
+		batch_no = get_batch_from_bundle(se.items[0].serial_and_batch_bundle)
+
+		si = create_sales_invoice(
+			posting_date=add_days(nowdate(), 3),
+			item=item_code,
+			qty=-10,
+			rate=100,
+			is_return=1,
+			update_stock=1,
+			use_serial_batch_fields=1,
+			do_not_save=1,
+			do_not_submit=1,
+		)
+
+		si.items[0].batch_no = batch_no
+		si.save()
+		si.submit()
+
+		si.reload()
+		# check zero incoming rate in voucher
+		self.assertEqual(si.items[0].incoming_rate, 0.0)
+
+		# chekc zero incoming rate in stock ledger
+		stock_ledger_entry = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{
+				"voucher_type": "Sales Invoice",
+				"voucher_no": si.name,
+				"item_code": item_code,
+				"warehouse": "_Test Warehouse - _TC",
+			},
+			["incoming_rate", "valuation_rate"],
+			as_dict=True,
+		)
+
+		self.assertEqual(stock_ledger_entry.incoming_rate, 0.0)
+
 
 def make_item_for_si(item_code, properties=None):
 	from erpnext.stock.doctype.item.test_item import make_item

erpnext/accounts/doctype/sales_invoice_timesheet/sales_invoice_timesheet.json

@@ -52,7 +52,6 @@
    "fieldtype": "Data",
    "hidden": 1,
    "label": "Timesheet Detail",
-   "no_copy": 1,
    "print_hide": 1,
    "read_only": 1
   },
@@ -117,15 +116,16 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2024-03-27 13:10:36.562795",
+ "modified": "2025-12-23 13:54:17.677187",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Timesheet",
  "owner": "Administrator",
  "permissions": [],
  "quick_entry": 1,
+ "row_format": "Dynamic",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/tax_withholding_category/test_tax_withholding_category.py

@@ -415,7 +415,6 @@ class TestTaxWithholdingCategory(IntegrationTestCase):
 					"cost_center": "Main - _TC",
 					"tax_amount": 500,
 					"description": "Test",
-					"add_deduct_tax": "Add",
 				},
 			)
 			pi.save()
@@ -506,7 +505,6 @@ class TestTaxWithholdingCategory(IntegrationTestCase):
 					"cost_center": "Main - _TC",
 					"tax_amount": 200,
 					"description": "Test Gross Tax",
-					"add_deduct_tax": "Add",
 				},
 			)
 			si.save()
@@ -541,10 +539,10 @@ class TestTaxWithholdingCategory(IntegrationTestCase):
 				"cost_center": "Main - _TC",
 				"tax_amount": 400,
 				"description": "Test Gross Tax",
-				"add_deduct_tax": "Add",
 			},
 		)
 		si.save()
+		si.reload()
 		si.submit()
 		invoices.append(si)
 		# For amount before threshold (first 8000 + VAT): TCS entry with amount zero
@@ -594,7 +592,6 @@ class TestTaxWithholdingCategory(IntegrationTestCase):
 				"cost_center": "Main - _TC",
 				"tax_amount": 500,
 				"description": "VAT added to test TDS calculation on gross amount",
-				"add_deduct_tax": "Add",
 			},
 		)
 		si.save()
@@ -1024,7 +1021,6 @@ class TestTaxWithholdingCategory(IntegrationTestCase):
 				"cost_center": "Main - _TC",
 				"tax_amount": 1000,
 				"description": "VAT added to test TDS calculation on gross amount",
-				"add_deduct_tax": "Add",
 			},
 		)
 		pi.save()
@@ -1162,7 +1158,6 @@ class TestTaxWithholdingCategory(IntegrationTestCase):
 				"cost_center": "Main - _TC",
 				"tax_amount": 8000,
 				"description": "Test",
-				"add_deduct_tax": "Add",
 			},
 		)
 

erpnext/accounts/doctype/tax_withholding_entry/tax_withholding_entry.py

@@ -708,6 +708,10 @@ class TaxWithholdingController:
 		existing_taxes = {row.account_head: row for row in self.doc.taxes if row.is_tax_withholding_account}
 		precision = self.doc.precision("tax_amount", "taxes")
 		conversion_rate = self.get_conversion_rate()
+		add_deduct_tax = "Deduct"
+
+		if self.party_type == "Customer":
+			add_deduct_tax = "Add"
 
 		for account_head, base_amount in account_amount_map.items():
 			tax_amount = flt(base_amount / conversion_rate, precision)
@@ -724,6 +728,7 @@ class TaxWithholdingController:
 				tax_row = self._create_tax_row(account_head, tax_amount)
 				for_update = False
 
+			tax_row.add_deduct_tax = add_deduct_tax
 			# Set item-wise tax breakup for this tax row
 			self._set_item_wise_tax_for_tds(
 				tax_row, account_head, category_withholding_map, for_update=for_update
@@ -743,7 +748,6 @@ class TaxWithholdingController:
 				"account_head": account_head,
 				"description": account_head,
 				"cost_center": cost_center,
-				"add_deduct_tax": "Deduct",
 				"tax_amount": tax_amount,
 				"dont_recompute_tax": 1,
 			},
@@ -807,12 +811,14 @@ class TaxWithholdingController:
 			else:
 				item_tax_amount = 0
 
+			multiplier = -1 if tax_row.add_deduct_tax == "Deduct" else 1
+
 			self.doc._item_wise_tax_details.append(
 				frappe._dict(
 					item=item,
 					tax=tax_row,
 					rate=category.tax_rate,
-					amount=item_tax_amount * -1,  # Negative because it's a deduction
+					amount=item_tax_amount * multiplier,
 					taxable_amount=item_base_taxable,
 				)
 			)

erpnext/accounts/doctype/transaction_deletion_record_details/transaction_deletion_record_details.json

@@ -43,16 +43,18 @@
    "read_only": 1
   }
  ],
+ "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-03-27 13:10:55.008837",
+ "modified": "2025-11-14 16:17:25.584675",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Transaction Deletion Record Details",
  "owner": "Administrator",
  "permissions": [],
+ "row_format": "Dynamic",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/print_format/journal_auditing_voucher/journal_auditing_voucher.html

@@ -17,7 +17,7 @@
             </div>
             <div class="col-xs-6">
                 <table>
-                    <tr><td><strong>Date: </strong></td><td>{{  frappe.utils.format_date(doc.creation)  }}</td></tr>
+                    <tr><td><strong>Date: </strong></td><td>{{  frappe.utils.format_date(doc.posting_date)  }}</td></tr>
                 </table>
             </div>
     </div>

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -877,11 +877,15 @@ class ReceivablePayableReport:
 		else:
 			entry_date = row.posting_date
 
+		row.range0 = 0.0
+
 		self.get_ageing_data(entry_date, row)
 
-		# ageing buckets should not have amounts if due date is not reached
 		if getdate(entry_date) > getdate(self.age_as_on):
+			row.range0 = row.outstanding
 			[setattr(row, f"range{i}", 0.0) for i in self.range_numbers]
+			row.total_due = 0
+			return
 
 		row.total_due = sum(row[f"range{i}"] for i in self.range_numbers)
 
@@ -1281,6 +1285,8 @@ class ReceivablePayableReport:
 		ranges = [*self.ranges, _("Above")]
 
 		prev_range_value = 0
+		self.add_column(label=_("<0"), fieldname="range0", fieldtype="Currency")
+		self.ageing_column_labels.append(_("<0"))
 		for idx, curr_range_value in enumerate(ranges):
 			label = f"{prev_range_value}-{curr_range_value}"
 			self.add_column(label=label, fieldname="range" + str(idx + 1))
@@ -1296,7 +1302,9 @@ class ReceivablePayableReport:
 		for row in self.data:
 			row = frappe._dict(row)
 			if not cint(row.bold):
-				values = [flt(row.get(f"range{i}", None), precision) for i in self.range_numbers]
+				values = [flt(row.get("range0", 0), precision)] + [
+					flt(row.get(f"range{i}", 0), precision) for i in self.range_numbers
+				]
 				rows.append({"values": values})
 
 		self.chart = {

erpnext/accounts/report/balance_sheet/balance_sheet.py

@@ -232,11 +232,11 @@ def get_report_summary(
 
 
 def get_chart_data(filters, columns, asset, liability, equity, currency):
-	labels = [d.get("label") for d in columns[2:]]
+	labels = [d.get("label") for d in columns[4:]]
 
 	asset_data, liability_data, equity_data = [], [], []
 
-	for p in columns[2:]:
+	for p in columns[4:]:
 		if asset:
 			asset_data.append(asset[-2].get(p.get("fieldname")))
 		if liability:

erpnext/accounts/report/budget_variance_report/budget_variance_report.py

@@ -18,6 +18,8 @@ def execute(filters=None):
 		dimensions = filters.get("budget_against_filter")
 	else:
 		dimensions = get_budget_dimensions(filters)
+	if not dimensions:
+		return columns, [], None, None
 
 	budget_records = get_budget_records(filters, dimensions)
 	budget_map = build_budget_map(budget_records, filters)

erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py

@@ -219,13 +219,18 @@ def get_net_profit(
 
 	has_value = False
 
+	gross_income_roots = [row for row in (gross_income or []) if not flt(row.get("indent"))]
+	non_gross_income_roots = [row for row in (non_gross_income or []) if not flt(row.get("indent"))]
+	gross_expense_roots = [row for row in (gross_expense or []) if not flt(row.get("indent"))]
+	non_gross_expense_roots = [row for row in (non_gross_expense or []) if not flt(row.get("indent"))]
+
 	for period in period_list:
 		key = period if consolidated else period.key
-		gross_income_for_period = flt(gross_income[0].get(key, 0)) if gross_income else 0
-		non_gross_income_for_period = flt(non_gross_income[0].get(key, 0)) if non_gross_income else 0
 
-		gross_expense_for_period = flt(gross_expense[0].get(key, 0)) if gross_expense else 0
-		non_gross_expense_for_period = flt(non_gross_expense[0].get(key, 0)) if non_gross_expense else 0
+		gross_income_for_period = sum(flt(row.get(key, 0)) for row in gross_income_roots)
+		non_gross_income_for_period = sum(flt(row.get(key, 0)) for row in non_gross_income_roots)
+		gross_expense_for_period = sum(flt(row.get(key, 0)) for row in gross_expense_roots)
+		non_gross_expense_for_period = sum(flt(row.get(key, 0)) for row in non_gross_expense_roots)
 
 		total_income = gross_income_for_period + non_gross_income_for_period
 		total_expense = gross_expense_for_period + non_gross_expense_for_period

erpnext/accounts/report/gross_profit/gross_profit.py

@@ -5,15 +5,16 @@ from collections import OrderedDict
 
 import frappe
 from frappe import _, qb, scrub
-from frappe.query_builder import Order
+from frappe.query_builder import Case, Order
+from frappe.query_builder.functions import Coalesce
 from frappe.utils import cint, flt, formatdate
+from pypika.terms import ExistsCriterion
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
 	get_dimension_with_children,
 )
 from erpnext.accounts.report.financial_statements import get_cost_centers_with_children
-from erpnext.controllers.queries import get_match_cond
 from erpnext.stock.report.stock_ledger.stock_ledger import get_item_group_condition
 from erpnext.stock.utils import get_incoming_rate
 
@@ -176,7 +177,9 @@ def get_data_when_grouped_by_invoice(columns, gross_profit_data, filters, group_
 	column_names = get_column_names()
 
 	# to display item as Item Code: Item Name
-	columns[0] = "Sales Invoice:Link/Item:300"
+	columns[0]["fieldname"] = "sales_invoice"
+	columns[0]["options"] = "Item"
+	columns[0]["width"] = 300
 	# removing Item Code and Item Name columns
 	supplier_master_name = frappe.db.get_single_value("Buying Settings", "supp_master_name")
 	customer_master_name = frappe.db.get_single_value("Selling Settings", "cust_master_name")
@@ -203,7 +206,11 @@ def get_data_when_grouped_by_invoice(columns, gross_profit_data, filters, group_
 
 		data.append(row)
 
-	total_gross_profit = total_base_amount - total_buying_amount
+	total_gross_profit = flt(
+		total_base_amount + abs(total_buying_amount)
+		if total_buying_amount < 0
+		else total_base_amount - total_buying_amount,
+	)
 	data.append(
 		frappe._dict(
 			{
@@ -215,7 +222,7 @@ def get_data_when_grouped_by_invoice(columns, gross_profit_data, filters, group_
 				"buying_amount": total_buying_amount,
 				"gross_profit": total_gross_profit,
 				"gross_profit_%": flt(
-					(total_gross_profit / total_base_amount) * 100.0,
+					(total_gross_profit / abs(total_base_amount)) * 100.0,
 					cint(frappe.db.get_default("currency_precision")) or 3,
 				)
 				if total_base_amount
@@ -248,9 +255,13 @@ def get_data_when_not_grouped_by_invoice(gross_profit_data, filters, group_wise_
 
 		data.append(row)
 
-	total_gross_profit = total_base_amount - total_buying_amount
+	total_gross_profit = flt(
+		total_base_amount + abs(total_buying_amount)
+		if total_buying_amount < 0
+		else total_base_amount - total_buying_amount,
+	)
 	currency_precision = cint(frappe.db.get_default("currency_precision")) or 3
-	gross_profit_percent = (total_gross_profit / total_base_amount * 100.0) if total_base_amount else 0
+	gross_profit_percent = (total_gross_profit / abs(total_base_amount) * 100.0) if total_base_amount else 0
 
 	total_row = {
 		group_columns[0]: "Total",
@@ -581,10 +592,15 @@ class GrossProfitGenerator:
 				base_amount += row.base_amount
 
 			# calculate gross profit
-			row.gross_profit = flt(row.base_amount - row.buying_amount, self.currency_precision)
+			row.gross_profit = flt(
+				row.base_amount + abs(row.buying_amount)
+				if row.buying_amount < 0
+				else row.base_amount - row.buying_amount,
+				self.currency_precision,
+			)
 			if row.base_amount:
 				row.gross_profit_percent = flt(
-					(row.gross_profit / row.base_amount) * 100.0,
+					(row.gross_profit / abs(row.base_amount)) * 100.0,
 					self.currency_precision,
 				)
 			else:
@@ -673,9 +689,14 @@ class GrossProfitGenerator:
 		return new_row
 
 	def set_average_gross_profit(self, new_row):
-		new_row.gross_profit = flt(new_row.base_amount - new_row.buying_amount, self.currency_precision)
+		new_row.gross_profit = flt(
+			new_row.base_amount + abs(new_row.buying_amount)
+			if new_row.buying_amount < 0
+			else new_row.base_amount - new_row.buying_amount,
+			self.currency_precision,
+		)
 		new_row.gross_profit_percent = (
-			flt(((new_row.gross_profit / new_row.base_amount) * 100.0), self.currency_precision)
+			flt(((new_row.gross_profit / abs(new_row.base_amount)) * 100.0), self.currency_precision)
 			if new_row.base_amount
 			else 0
 		)
@@ -851,129 +872,173 @@ class GrossProfitGenerator:
 		return flt(last_purchase_rate[0][0]) if last_purchase_rate else 0
 
 	def load_invoice_items(self):
-		conditions = ""
-		if self.filters.company:
-			conditions += " and `tabSales Invoice`.company = %(company)s"
-		if self.filters.from_date:
-			conditions += " and posting_date >= %(from_date)s"
-		if self.filters.to_date:
-			conditions += " and posting_date <= %(to_date)s"
+		self.si_list = []
+
+		SalesInvoice = frappe.qb.DocType("Sales Invoice")
+		base_query = self.prepare_invoice_query()
 
 		if self.filters.include_returned_invoices:
-			conditions += " and (is_return = 0 or (is_return=1 and return_against is null))"
+			invoice_query = base_query.where(
+				(SalesInvoice.is_return == 0)
+				| ((SalesInvoice.is_return == 1) & SalesInvoice.return_against.isnull())
+			)
 		else:
-			conditions += " and is_return = 0"
+			invoice_query = base_query.where(SalesInvoice.is_return == 0)
 
-		if self.filters.item_group:
-			conditions += f" and {get_item_group_condition(self.filters.item_group)}"
+		self.si_list += invoice_query.run(as_dict=True)
+		self.prepare_vouchers_to_ignore()
 
-		if self.filters.sales_person:
-			conditions += """
-				and exists(select 1
-							from `tabSales Team` st
-							where st.parent = `tabSales Invoice`.name
-							and   st.sales_person = %(sales_person)s)
-			"""
+		ret_invoice_query = base_query.where(
+			(SalesInvoice.is_return == 1) & SalesInvoice.return_against.isnotnull()
+		)
+		if self.vouchers_to_ignore:
+			ret_invoice_query = ret_invoice_query.where(
+				SalesInvoice.return_against.notin(self.vouchers_to_ignore)
+			)
+
+		self.si_list += ret_invoice_query.run(as_dict=True)
+
+	def prepare_invoice_query(self):
+		SalesInvoice = frappe.qb.DocType("Sales Invoice")
+		SalesInvoiceItem = frappe.qb.DocType("Sales Invoice Item")
+		Item = frappe.qb.DocType("Item")
+		SalesTeam = frappe.qb.DocType("Sales Team")
+		PaymentSchedule = frappe.qb.DocType("Payment Schedule")
+
+		query = (
+			frappe.qb.from_(SalesInvoice)
+			.join(SalesInvoiceItem)
+			.on(SalesInvoiceItem.parent == SalesInvoice.name)
+			.join(Item)
+			.on(Item.name == SalesInvoiceItem.item_code)
+			.where((SalesInvoice.docstatus == 1) & (SalesInvoice.is_opening != "Yes"))
+		)
+
+		query = self.apply_common_filters(query, SalesInvoice, SalesInvoiceItem, SalesTeam, Item)
+
+		query = query.select(
+			SalesInvoiceItem.parenttype,
+			SalesInvoiceItem.parent,
+			SalesInvoice.posting_date,
+			SalesInvoice.posting_time,
+			SalesInvoice.project,
+			SalesInvoice.update_stock,
+			SalesInvoice.customer,
+			SalesInvoice.customer_group,
+			SalesInvoice.customer_name,
+			SalesInvoice.territory,
+			SalesInvoiceItem.item_code,
+			SalesInvoice.base_net_total.as_("invoice_base_net_total"),
+			SalesInvoiceItem.item_name,
+			SalesInvoiceItem.description,
+			SalesInvoiceItem.warehouse,
+			SalesInvoiceItem.item_group,
+			SalesInvoiceItem.brand,
+			SalesInvoiceItem.so_detail,
+			SalesInvoiceItem.sales_order,
+			SalesInvoiceItem.dn_detail,
+			SalesInvoiceItem.delivery_note,
+			SalesInvoiceItem.stock_qty.as_("qty"),
+			SalesInvoiceItem.base_net_rate,
+			SalesInvoiceItem.base_net_amount,
+			SalesInvoiceItem.name.as_("item_row"),
+			SalesInvoice.is_return,
+			SalesInvoiceItem.cost_center,
+			SalesInvoiceItem.serial_and_batch_bundle,
+		)
 
 		if self.filters.group_by == "Sales Person":
-			sales_person_cols = """, sales.sales_person,
-				sales.allocated_percentage * `tabSales Invoice Item`.base_net_amount / 100 as allocated_amount,
-				sales.incentives
-			"""
-			sales_team_table = "left join `tabSales Team` sales on sales.parent = `tabSales Invoice`.name"
-		else:
-			sales_person_cols = ""
-			sales_team_table = ""
+			query = query.select(
+				SalesTeam.sales_person,
+				(SalesTeam.allocated_percentage * SalesInvoiceItem.base_net_amount / 100).as_(
+					"allocated_amount"
+				),
+				SalesTeam.incentives,
+			)
+
+			query = query.left_join(SalesTeam).on(SalesTeam.parent == SalesInvoice.name)
 
 		if self.filters.group_by == "Payment Term":
-			payment_term_cols = """,if(`tabSales Invoice`.is_return = 1,
-										'{}',
-										coalesce(schedule.payment_term, '{}')) as payment_term,
-									schedule.invoice_portion,
-									schedule.payment_amount """.format(_("Sales Return"), _("No Terms"))
-			payment_term_table = """ left join `tabPayment Schedule` schedule on schedule.parent = `tabSales Invoice`.name and
-																				`tabSales Invoice`.is_return = 0 """
-		else:
-			payment_term_cols = ""
-			payment_term_table = ""
+			query = query.select(
+				Case()
+				.when(SalesInvoice.is_return == 1, _("Sales Return"))
+				.else_(Coalesce(PaymentSchedule.payment_term, _("No Terms")))
+				.as_("payment_term"),
+				PaymentSchedule.invoice_portion,
+				PaymentSchedule.payment_amount,
+			)
 
-		if self.filters.get("sales_invoice"):
-			conditions += " and `tabSales Invoice`.name = %(sales_invoice)s"
+			query = query.left_join(PaymentSchedule).on(
+				(PaymentSchedule.parent == SalesInvoice.name) & (SalesInvoice.is_return == 0)
+			)
 
-		if self.filters.get("item_code"):
-			conditions += " and `tabSales Invoice Item`.item_code = %(item_code)s"
+		query = query.orderby(SalesInvoice.posting_date, order=Order.desc).orderby(
+			SalesInvoice.posting_time, order=Order.desc
+		)
 
-		if self.filters.get("cost_center"):
+		return query
+
+	def apply_common_filters(self, query, SalesInvoice, SalesInvoiceItem, SalesTeam, Item):
+		if self.filters.company:
+			query = query.where(SalesInvoice.company == self.filters.company)
+
+		if self.filters.from_date:
+			query = query.where(SalesInvoice.posting_date >= self.filters.from_date)
+
+		if self.filters.to_date:
+			query = query.where(SalesInvoice.posting_date <= self.filters.to_date)
+
+		if self.filters.item_group:
+			query = query.where(get_item_group_condition(self.filters.item_group, Item))
+
+		if self.filters.sales_person:
+			query = query.where(
+				ExistsCriterion(
+					frappe.qb.from_(SalesTeam)
+					.select(1)
+					.where(
+						(SalesTeam.parent == SalesInvoice.name)
+						& (SalesTeam.sales_person == self.filters.sales_person)
+					)
+				)
+			)
+
+		if self.filters.sales_invoice:
+			query = query.where(SalesInvoice.name == self.filters.sales_invoice)
+
+		if self.filters.item_code:
+			query = query.where(SalesInvoiceItem.item_code == self.filters.item_code)
+
+		if self.filters.cost_center:
 			self.filters.cost_center = frappe.parse_json(self.filters.get("cost_center"))
 			self.filters.cost_center = get_cost_centers_with_children(self.filters.cost_center)
-			conditions += " and `tabSales Invoice Item`.cost_center in %(cost_center)s"
+			query = query.where(SalesInvoiceItem.cost_center.isin(self.filters.cost_center))
 
-		if self.filters.get("project"):
+		if self.filters.project:
 			self.filters.project = frappe.parse_json(self.filters.get("project"))
-			conditions += " and `tabSales Invoice Item`.project in %(project)s"
+			query = query.where(SalesInvoiceItem.project.isin(self.filters.project))
 
-		accounting_dimensions = get_accounting_dimensions(as_list=False)
-		if accounting_dimensions:
-			for dimension in accounting_dimensions:
-				if self.filters.get(dimension.fieldname):
-					if frappe.get_cached_value("DocType", dimension.document_type, "is_tree"):
-						self.filters[dimension.fieldname] = get_dimension_with_children(
-							dimension.document_type, self.filters.get(dimension.fieldname)
-						)
-						conditions += (
-							f" and `tabSales Invoice Item`.{dimension.fieldname} in %({dimension.fieldname})s"
-						)
-					else:
-						conditions += (
-							f" and `tabSales Invoice Item`.{dimension.fieldname} in %({dimension.fieldname})s"
-						)
+		for dim in get_accounting_dimensions(as_list=False) or []:
+			if self.filters.get(dim.fieldname):
+				if frappe.get_cached_value("DocType", dim.document_type, "is_tree"):
+					self.filters[dim.fieldname] = get_dimension_with_children(
+						dim.document_type, self.filters.get(dim.fieldname)
+					)
+				query = query.where(SalesInvoiceItem[dim.fieldname].isin(self.filters[dim.fieldname]))
 
-		if self.filters.get("warehouse"):
-			warehouse_details = frappe.db.get_value(
-				"Warehouse", self.filters.get("warehouse"), ["lft", "rgt"], as_dict=1
+		if self.filters.warehouse:
+			lft, rgt = frappe.db.get_value("Warehouse", self.filters.warehouse, ["lft", "rgt"])
+			WH = frappe.qb.DocType("Warehouse")
+			query = query.where(
+				SalesInvoiceItem.warehouse.isin(
+					frappe.qb.from_(WH).select(WH.name).where((WH.lft >= lft) & (WH.rgt <= rgt))
+				)
 			)
-			if warehouse_details:
-				conditions += f" and `tabSales Invoice Item`.warehouse in (select name from `tabWarehouse` wh where wh.lft >= {warehouse_details.lft} and wh.rgt <= {warehouse_details.rgt} and warehouse = wh.name)"
 
-		self.si_list = frappe.db.sql(
-			"""
-			select
-				`tabSales Invoice Item`.parenttype, `tabSales Invoice Item`.parent,
-				`tabSales Invoice`.posting_date, `tabSales Invoice`.posting_time,
-				`tabSales Invoice`.project, `tabSales Invoice`.update_stock,
-				`tabSales Invoice`.customer, `tabSales Invoice`.customer_group, `tabSales Invoice`.customer_name,
-				`tabSales Invoice`.territory, `tabSales Invoice Item`.item_code,
-				`tabSales Invoice`.base_net_total as "invoice_base_net_total",
-				`tabSales Invoice Item`.item_name, `tabSales Invoice Item`.description,
-				`tabSales Invoice Item`.warehouse, `tabSales Invoice Item`.item_group,
-				`tabSales Invoice Item`.brand, `tabSales Invoice Item`.so_detail,
-				`tabSales Invoice Item`.sales_order, `tabSales Invoice Item`.dn_detail,
-				`tabSales Invoice Item`.delivery_note, `tabSales Invoice Item`.stock_qty as qty,
-				`tabSales Invoice Item`.base_net_rate, `tabSales Invoice Item`.base_net_amount,
-				`tabSales Invoice Item`.name as "item_row", `tabSales Invoice`.is_return,
-				`tabSales Invoice Item`.cost_center, `tabSales Invoice Item`.serial_and_batch_bundle
-				{sales_person_cols}
-				{payment_term_cols}
-			from
-				`tabSales Invoice` inner join `tabSales Invoice Item`
-					on `tabSales Invoice Item`.parent = `tabSales Invoice`.name
-				join `tabItem` item on item.name = `tabSales Invoice Item`.item_code
-				{sales_team_table}
-				{payment_term_table}
-			where
-				`tabSales Invoice`.docstatus=1 and `tabSales Invoice`.is_opening!='Yes' {conditions} {match_cond}
-			order by
-				`tabSales Invoice`.posting_date desc, `tabSales Invoice`.posting_time desc""".format(
-				conditions=conditions,
-				sales_person_cols=sales_person_cols,
-				sales_team_table=sales_team_table,
-				payment_term_cols=payment_term_cols,
-				payment_term_table=payment_term_table,
-				match_cond=get_match_cond("Sales Invoice"),
-			),
-			self.filters,
-			as_dict=1,
-		)
+		return query
+
+	def prepare_vouchers_to_ignore(self):
+		self.vouchers_to_ignore = tuple(row["parent"] for row in self.si_list)
 
 	def get_delivery_notes(self):
 		self.delivery_notes = frappe._dict({})

erpnext/accounts/report/gross_profit/test_gross_profit.py

@@ -470,7 +470,7 @@ class TestGrossProfit(IntegrationTestCase):
 			"selling_amount": -100.0,
 			"buying_amount": 0.0,
 			"gross_profit": -100.0,
-			"gross_profit_%": 100.0,
+			"gross_profit_%": -100.0,
 		}
 		gp_entry = [x for x in data if x.parent_invoice == sinv.name]
 		report_output = {k: v for k, v in gp_entry[0].items() if k in expected_entry}
@@ -649,21 +649,24 @@ class TestGrossProfit(IntegrationTestCase):
 	def test_profit_for_later_period_return(self):
 		month_start_date, month_end_date = get_first_day(nowdate()), get_last_day(nowdate())
 
+		sales_inv_date = month_start_date
+		return_inv_date = add_days(month_end_date, 1)
+
 		# create sales invoice on month start date
 		sinv = self.create_sales_invoice(qty=1, rate=100, do_not_save=True, do_not_submit=True)
 		sinv.set_posting_time = 1
-		sinv.posting_date = month_start_date
+		sinv.posting_date = sales_inv_date
 		sinv.save().submit()
 
 		# create credit note on next month start date
 		cr_note = make_sales_return(sinv.name)
 		cr_note.set_posting_time = 1
-		cr_note.posting_date = add_days(month_end_date, 1)
+		cr_note.posting_date = return_inv_date
 		cr_note.save().submit()
 
 		# apply filters for invoiced period
 		filters = frappe._dict(
-			company=self.company, from_date=month_start_date, to_date=month_end_date, group_by="Invoice"
+			company=self.company, from_date=month_start_date, to_date=month_start_date, group_by="Invoice"
 		)
 
 		_, data = execute(filters=filters)
@@ -675,7 +678,7 @@ class TestGrossProfit(IntegrationTestCase):
 		self.assertEqual(total.get("gross_profit_%"), 100.0)
 
 		# extend filters upto returned period
-		filters.update(to_date=add_days(month_end_date, 1))
+		filters.update({"to_date": return_inv_date})
 
 		_, data = execute(filters=filters)
 		total = data[-1]
@@ -684,3 +687,63 @@ class TestGrossProfit(IntegrationTestCase):
 		self.assertEqual(total.buying_amount, 0.0)
 		self.assertEqual(total.gross_profit, 0.0)
 		self.assertEqual(total.get("gross_profit_%"), 0.0)
+
+		# apply filters only on returned period
+		filters.update({"from_date": return_inv_date, "to_date": return_inv_date})
+		_, data = execute(filters=filters)
+		total = data[-1]
+
+		self.assertEqual(total.selling_amount, -100.0)
+		self.assertEqual(total.buying_amount, 0.0)
+		self.assertEqual(total.gross_profit, -100.0)
+		self.assertEqual(total.get("gross_profit_%"), -100.0)
+
+	def test_sales_person_wise_gross_profit(self):
+		sales_person = make_sales_person("_Test Sales Person")
+
+		posting_date = get_first_day(nowdate())
+		qty = 10
+		rate = 100
+
+		sinv = self.create_sales_invoice(qty=qty, rate=rate, do_not_save=True, do_not_submit=True)
+		sinv.set_posting_time = 1
+		sinv.posting_date = posting_date
+		sinv.append(
+			"sales_team",
+			{
+				"sales_person": sales_person.name,
+				"allocated_percentage": 100,
+				"allocated_amount": 1000.0,
+				"commission_rate": 5,
+				"incentives": 5,
+			},
+		)
+		sinv.save().submit()
+
+		filters = frappe._dict(
+			company=self.company, from_date=posting_date, to_date=posting_date, group_by="Sales Person"
+		)
+
+		_, data = execute(filters=filters)
+		total = data[-1]
+
+		self.assertEqual(total[5], 1000.0)
+		self.assertEqual(total[6], 0.0)
+		self.assertEqual(total[7], 1000.0)
+		self.assertEqual(total[8], 100.0)
+
+
+def make_sales_person(sales_person_name="_Test Sales Person"):
+	if not frappe.db.exists("Sales Person", {"sales_person_name": sales_person_name}):
+		sales_person_doc = frappe.get_doc(
+			{
+				"doctype": "Sales Person",
+				"is_group": 0,
+				"parent_sales_person": "Sales Team",
+				"sales_person_name": sales_person_name,
+			}
+		).insert(ignore_permissions=True)
+	else:
+		sales_person_doc = frappe.get_doc("Sales Person", {"sales_person_name": sales_person_name})
+
+	return sales_person_doc

erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py

@@ -105,7 +105,7 @@ def _execute(filters=None, additional_table_columns=None, additional_conditions=
 			{
 				"total_tax": total_tax,
 				"total_other_charges": total_other_charges,
-				"total": d.base_net_amount + total_tax,
+				"total": d.base_net_amount + total_tax + total_other_charges,
 				"currency": company_currency,
 			}
 		)

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py

@@ -163,11 +163,11 @@ def get_net_profit_loss(income, expense, period_list, company, currency=None, co
 
 
 def get_chart_data(filters, columns, income, expense, net_profit_loss, currency):
-	labels = [d.get("label") for d in columns[2:]]
+	labels = [d.get("label") for d in columns[4:]]
 
 	income_data, expense_data, net_profit = [], [], []
 
-	for p in columns[2:]:
+	for p in columns[4:]:
 		if income:
 			income_data.append(income[-2].get(p.get("fieldname")))
 		if expense:

erpnext/accounts/report/tax_withholding_details/tax_withholding_details.py

@@ -154,17 +154,11 @@ def get_columns(filters):
 			"width": 60,
 		},
 		{
-			"label": _("Total Amount"),
+			"label": _("Taxable Amount"),
 			"fieldname": "total_amount",
 			"fieldtype": "Currency",
 			"width": 120,
 		},
-		{
-			"label": _("Base Total"),
-			"fieldname": "base_total",
-			"fieldtype": "Currency",
-			"width": 120,
-		},
 		{
 			"label": _("Tax Amount"),
 			"fieldname": "tax_amount",
@@ -172,10 +166,16 @@ def get_columns(filters):
 			"width": 120,
 		},
 		{
-			"label": _("Grand Total"),
+			"label": _("Grand Total (Company Currency)"),
+			"fieldname": "base_total",
+			"fieldtype": "Currency",
+			"width": 150,
+		},
+		{
+			"label": _("Grand Total (Transaction Currency)"),
 			"fieldname": "grand_total",
 			"fieldtype": "Currency",
-			"width": 120,
+			"width": 170,
 		},
 		{
 			"label": _("Reference Date"),

erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py

@@ -106,7 +106,7 @@ def get_columns(filters):
 			"width": 120,
 		},
 		{
-			"label": _("Total Amount"),
+			"label": _("Total Taxable Amount"),
 			"fieldname": "total_amount",
 			"fieldtype": "Float",
 			"width": 120,

erpnext/accounts/utils.py

@@ -11,6 +11,7 @@ import frappe.defaults
 from frappe import _, qb, throw
 from frappe.desk.reportview import build_match_conditions
 from frappe.model.meta import get_field_precision
+from frappe.model.naming import determine_consecutive_week_number
 from frappe.query_builder import AliasedQuery, Case, Criterion, Field, Table
 from frappe.query_builder.functions import Count, IfNull, Max, Round, Sum
 from frappe.query_builder.utils import DocType
@@ -25,6 +26,7 @@ from frappe.utils import (
 	get_number_format_info,
 	getdate,
 	now,
+	now_datetime,
 	nowdate,
 )
 from frappe.utils.caching import site_cache
@@ -66,6 +68,7 @@ def get_fiscal_year(
 	as_dict=False,
 	boolean=None,
 	raise_on_missing=True,
+	truncate=False,
 ):
 	if isinstance(raise_on_missing, str):
 		raise_on_missing = loads(raise_on_missing)
@@ -79,7 +82,14 @@ def get_fiscal_year(
 	fiscal_years = get_fiscal_years(
 		date, fiscal_year, label, verbose, company, as_dict=as_dict, raise_on_missing=raise_on_missing
 	)
-	return False if not fiscal_years else fiscal_years[0]
+
+	if fiscal_years:
+		fiscal_year = fiscal_years[0]
+		if truncate:
+			return ("-".join(y[-2:] for y in fiscal_year[0].split("-")), fiscal_year[1], fiscal_year[2])
+		return fiscal_year
+
+	return False
 
 
 def get_fiscal_years(
@@ -547,6 +557,7 @@ def reconcile_against_document(
 				doc.make_advance_gl_entries(entry=row)
 		else:
 			_delete_pl_entries(voucher_type, voucher_no)
+			_delete_adv_pl_entries(voucher_type, voucher_no)
 			gl_map = doc.build_gl_map()
 			# Make sure there is no overallocation
 			from erpnext.accounts.general_ledger import process_debit_credit_difference
@@ -1500,14 +1511,14 @@ def get_autoname_with_number(number_value, doc_title, company):
 
 
 def parse_naming_series_variable(doc, variable):
-	if variable == "FY":
+	if variable in ["FY", "TFY"]:
 		if doc:
 			date = doc.get("posting_date") or doc.get("transaction_date") or getdate()
 			company = doc.get("company")
 		else:
 			date = getdate()
 			company = None
-		return get_fiscal_year(date=date, company=company)[0]
+		return get_fiscal_year(date=date, company=company, truncate=variable == "TFY")[0]
 
 	elif variable == "ABBR":
 		if doc:
@@ -1517,6 +1528,18 @@ def parse_naming_series_variable(doc, variable):
 
 		return frappe.db.get_value("Company", company, "abbr") if company else ""
 
+	else:
+		data = {"YY": "%y", "YYYY": "%Y", "MM": "%m", "DD": "%d", "JJJ": "%j"}
+		date = (
+			(
+				getdate(doc.get("posting_date") or doc.get("transaction_date") or doc.get("posting_datetime"))
+				or now_datetime()
+			)
+			if frappe.get_single_value("Global Defaults", "use_posting_datetime_for_naming_documents")
+			else now_datetime()
+		)
+		return date.strftime(data[variable]) if variable in data else determine_consecutive_week_number(date)
+
 
 @frappe.whitelist()
 def get_coa(doctype, parent, is_root=None, chart=None):
@@ -1946,6 +1969,7 @@ def get_payment_ledger_entries(gl_entries, cancel=0):
 					account=gle.account,
 					party_type=gle.party_type,
 					party=gle.party,
+					project=gle.project,
 					cost_center=gle.cost_center,
 					finance_book=gle.finance_book,
 					due_date=gle.due_date,

erpnext/accounts/workspace/invoicing/invoicing.json

@@ -14,10 +14,10 @@
  "for_user": "",
  "hide_custom": 0,
  "icon": "accounting",
- "idx": 3,
+ "idx": 4,
  "indicator_color": "",
  "is_hidden": 0,
- "label": "Accounting",
+ "label": "Invoicing",
  "links": [
   {
    "hidden": 0,
@@ -587,10 +587,10 @@
    "type": "Link"
   }
  ],
- "modified": "2025-12-24 13:20:34.857205",
+ "modified": "2026-01-23 11:05:47.246213",
  "modified_by": "Administrator",
  "module": "Accounts",
- "name": "Accounting",
+ "name": "Invoicing",
  "number_cards": [
   {
    "label": "Outgoing Bills",
@@ -617,6 +617,6 @@
  "roles": [],
  "sequence_id": 2.0,
  "shortcuts": [],
- "title": "Accounting",
+ "title": "Invoicing",
  "type": "Workspace"
 }

erpnext/assets/doctype/asset/asset.js

@@ -116,14 +116,6 @@ frappe.ui.form.on("Asset", {
 					__("Manage")
 				);
 
-				frm.add_custom_button(
-					__("Repair Asset"),
-					function () {
-						frm.trigger("create_asset_repair");
-					},
-					__("Manage")
-				);
-
 				frm.add_custom_button(
 					__("Split Asset"),
 					function () {
@@ -155,6 +147,14 @@ frappe.ui.form.on("Asset", {
 					},
 					__("Manage")
 				);
+
+				frm.add_custom_button(
+					__("Repair Asset"),
+					function () {
+						frm.trigger("create_asset_repair");
+					},
+					__("Manage")
+				);
 			}
 
 			if (!frm.doc.calculate_depreciation) {
@@ -513,12 +513,14 @@ frappe.ui.form.on("Asset", {
 	},
 
 	is_composite_asset: function (frm) {
-		if (frm.doc.is_composite_asset) {
-			frm.set_value("net_purchase_amount", 0);
-		} else {
-			frm.set_df_property("net_purchase_amount", "read_only", 0);
+		if (frm.doc.docstatus == 0) {
+			if (frm.doc.is_composite_asset) {
+				frm.set_value("net_purchase_amount", 0);
+			} else {
+				frm.set_df_property("net_purchase_amount", "read_only", 0);
+			}
+			frm.trigger("toggle_reference_doc");
 		}
-		frm.trigger("toggle_reference_doc");
 	},
 
 	make_sales_invoice: function (frm) {

erpnext/assets/doctype/asset/asset.py

@@ -244,6 +244,8 @@ class Asset(AccountsController):
 
 	def before_submit(self):
 		if self.is_composite_asset and not has_active_capitalization(self.name):
+			if self.split_from and has_active_capitalization(self.split_from):
+				return
 			frappe.throw(_("Please capitalize this asset before submitting."))
 
 	def on_submit(self):

erpnext/assets/doctype/asset/depreciation.py

@@ -246,7 +246,9 @@ def _make_journal_entry_for_depreciation(
 
 def setup_journal_entry_metadata(je, depr_schedule_doc, depr_series, depr_schedule, asset):
 	je.voucher_type = "Depreciation Entry"
-	je.naming_series = depr_series
+	if depr_series:
+		je.naming_series = depr_series
+
 	je.posting_date = depr_schedule.schedule_date
 	je.company = asset.company
 	je.finance_book = depr_schedule_doc.finance_book

erpnext/assets/doctype/asset/test_asset.py

@@ -1691,6 +1691,71 @@ class TestDepreciationBasics(AssetSetup):
 		pr.submit()
 		self.assertTrue(get_gl_entries("Purchase Receipt", pr.name))
 
+	def test_split_asset_created_via_capitalization(self):
+		"""Test that assets created via Asset Capitalization can be split without capitalization error"""
+		from erpnext.assets.doctype.asset_capitalization.test_asset_capitalization import (
+			create_asset_capitalization,
+			create_asset_capitalization_data,
+		)
+
+		# Ensure test data exists
+		create_asset_capitalization_data()
+
+		company = "_Test Company with perpetual inventory"
+		set_depreciation_settings_in_company(company=company)
+		name = frappe.db.get_value(
+			"Asset Category Account",
+			filters={"parent": "Computers", "company_name": company},
+			fieldname=["name"],
+		)
+		frappe.db.set_value("Asset Category Account", name, "capital_work_in_progress_account", "")
+
+		stock_rate = 1000
+		stock_qty = 2
+		total_amount = 2000
+
+		# Create composite asset
+		wip_composite_asset = create_asset(
+			asset_name="Asset Capitalization WIP Composite Asset for Split",
+			is_composite_asset=1,
+			warehouse="Stores - TCP1",
+			company=company,
+			asset_quantity=2,  # Set quantity > 1 to allow splitting
+		)
+
+		# Create and submit Asset Capitalization
+		asset_capitalization = create_asset_capitalization(
+			target_asset=wip_composite_asset.name,
+			stock_qty=stock_qty,
+			stock_rate=stock_rate,
+			company=company,
+			submit=1,
+		)
+
+		# Verify asset was capitalized
+		target_asset = frappe.get_doc("Asset", asset_capitalization.target_asset)
+		self.assertEqual(target_asset.net_purchase_amount, total_amount)
+		self.assertEqual(target_asset.status, "Work In Progress")
+
+		# Submit the capitalized asset
+		target_asset.submit()
+		self.assertEqual(target_asset.status, "Submitted")
+
+		# Split the asset - this should work without capitalization error
+		split_qty = 1
+		splitted_asset = split_asset(target_asset.name, split_qty)
+
+		# Verify split asset was created and submitted successfully
+		self.assertIsNotNone(splitted_asset)
+		self.assertEqual(splitted_asset.asset_quantity, split_qty)
+		self.assertEqual(splitted_asset.split_from, target_asset.name)
+		self.assertEqual(splitted_asset.docstatus, 1)  # Should be submitted
+		self.assertEqual(splitted_asset.status, "Submitted")
+
+		# Verify original asset was updated
+		target_asset.reload()
+		self.assertEqual(target_asset.asset_quantity, 1)  # Remaining quantity
+
 
 def get_gl_entries(doctype, docname):
 	gl_entry = frappe.qb.DocType("GL Entry")

erpnext/assets/doctype/asset_capitalization/asset_capitalization.py

@@ -574,13 +574,19 @@ class AssetCapitalization(StockController):
 		if self.docstatus == 2:
 			net_purchase_amount = asset_doc.net_purchase_amount - total_target_asset_value
 			purchase_amount = asset_doc.purchase_amount - total_target_asset_value
-			asset_doc.db_set("total_asset_cost", asset_doc.total_asset_cost - total_target_asset_value)
+			total_asset_cost = asset_doc.total_asset_cost - total_target_asset_value
 		else:
 			net_purchase_amount = asset_doc.net_purchase_amount + total_target_asset_value
 			purchase_amount = asset_doc.purchase_amount + total_target_asset_value
+			total_asset_cost = asset_doc.total_asset_cost + total_target_asset_value
 
-		asset_doc.db_set("net_purchase_amount", net_purchase_amount)
-		asset_doc.db_set("purchase_amount", purchase_amount)
+		asset_doc.db_set(
+			{
+				"net_purchase_amount": net_purchase_amount,
+				"purchase_amount": purchase_amount,
+				"total_asset_cost": total_asset_cost,
+			}
+		)
 
 		frappe.msgprint(
 			_("Asset {0} has been updated. Please set the depreciation details if any and submit it.").format(

erpnext/assets/doctype/asset_movement/asset_movement.py

@@ -5,7 +5,7 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.utils import cstr, get_link_to_form
+from frappe.utils import cstr, get_datetime, get_link_to_form
 
 from erpnext.assets.doctype.asset_activity.asset_activity import add_asset_activity
 
@@ -34,6 +34,7 @@ class AssetMovement(Document):
 		for d in self.assets:
 			self.validate_asset(d)
 			self.validate_movement(d)
+			self.validate_transaction_date(d)
 
 	def validate_asset(self, d):
 		status, company = frappe.db.get_value("Asset", d.asset, ["status", "company"])
@@ -51,6 +52,18 @@ class AssetMovement(Document):
 		else:
 			self.validate_employee(d)
 
+	def validate_transaction_date(self, d):
+		previous_movement_date = frappe.db.get_value(
+			"Asset Movement",
+			[["Asset Movement Item", "asset", "=", d.asset], ["docstatus", "=", 1]],
+			"transaction_date",
+			order_by="transaction_date desc",
+		)
+		if previous_movement_date and get_datetime(previous_movement_date) > get_datetime(
+			self.transaction_date
+		):
+			frappe.throw(_("Transaction date can't be earlier than previous movement date"))
+
 	def validate_location_and_employee(self, d):
 		self.validate_location(d)
 		self.validate_employee(d)

erpnext/assets/doctype/asset_movement/test_asset_movement.py

@@ -4,9 +4,9 @@ import unittest
 
 import frappe
 from frappe.tests import IntegrationTestCase
-from frappe.utils import now
+from frappe.utils import add_days, now
 
-from erpnext.assets.doctype.asset.test_asset import create_asset_data
+from erpnext.assets.doctype.asset.test_asset import create_asset, create_asset_data
 from erpnext.setup.doctype.employee.test_employee import make_employee
 from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
 
@@ -147,6 +147,33 @@ class TestAssetMovement(IntegrationTestCase):
 		movement1.cancel()
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location")
 
+	def test_movement_transaction_date(self):
+		asset = create_asset(item_code="Macbook Pro", do_not_save=1)
+		asset.save().submit()
+
+		if not frappe.db.exists("Location", "Test Location 2"):
+			frappe.get_doc({"doctype": "Location", "location_name": "Test Location 2"}).insert()
+
+		asset_creation_date = frappe.db.get_value(
+			"Asset Movement",
+			[["Asset Movement Item", "asset", "=", asset.name], ["docstatus", "=", 1]],
+			"transaction_date",
+		)
+		asset_movement = create_asset_movement(
+			purpose="Transfer",
+			company=asset.company,
+			assets=[
+				{
+					"asset": asset.name,
+					"source_location": "Test Location",
+					"target_location": "Test Location 2",
+				}
+			],
+			transaction_date=add_days(asset_creation_date, -1),
+			do_not_save=True,
+		)
+		self.assertRaises(frappe.ValidationError, asset_movement.save)
+
 
 def create_asset_movement(**args):
 	args = frappe._dict(args)
@@ -165,9 +192,10 @@ def create_asset_movement(**args):
 			"reference_name": args.reference_name,
 		}
 	)
-
-	movement.insert()
-	movement.submit()
+	if not args.do_not_save:
+		movement.insert(ignore_if_duplicate=True)
+		if not args.do_not_submit:
+			movement.submit()
 
 	return movement
 

erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py

@@ -74,7 +74,7 @@ class AssetValueAdjustment(Document):
 		)
 
 	def on_cancel(self):
-		frappe.get_doc("Journal Entry", self.journal_entry).cancel()
+		self.cancel_asset_revaluation_entry()
 		self.update_asset()
 		add_asset_activity(
 			self.asset,
@@ -167,6 +167,17 @@ class AssetValueAdjustment(Document):
 			if dimension.get("mandatory_for_pl"):
 				debit_entry.update({dimension["fieldname"]: dimension_value})
 
+	def cancel_asset_revaluation_entry(self):
+		if not self.journal_entry:
+			return
+
+		revaluation_entry = frappe.get_doc("Journal Entry", self.journal_entry)
+		if revaluation_entry.docstatus == 1:
+			# Ignore permissions to match Journal Entry submission behavior
+			revaluation_entry.flags.ignore_permissions = True
+			revaluation_entry.flags.via_asset_value_adjustment = True
+			revaluation_entry.cancel()
+
 	def update_asset(self):
 		asset = self.update_asset_value_after_depreciation()
 		note = self.get_adjustment_note()

erpnext/buying/doctype/purchase_order/purchase_order.js

@@ -803,7 +803,7 @@ frappe.ui.form.on("Purchase Order", "is_subcontracted", function (frm) {
 
 function prevent_past_schedule_dates(frm) {
 	if (frm.doc.transaction_date) {
-		frm.fields_dict["schedule_date"].datepicker.update({
+		frm.fields_dict["schedule_date"].datepicker?.update({
 			minDate: new Date(frm.doc.transaction_date),
 		});
 	}

erpnext/buying/doctype/purchase_order/purchase_order.json

@@ -9,10 +9,9 @@
  "engine": "InnoDB",
  "field_order": [
   "supplier_section",
+  "company",
   "title",
   "naming_series",
-  "supplier",
-  "supplier_name",
   "order_confirmation_no",
   "order_confirmation_date",
   "get_items_from_open_material_requests",
@@ -21,8 +20,9 @@
   "transaction_date",
   "schedule_date",
   "column_break1",
-  "company",
+  "supplier",
   "is_subcontracted",
+  "supplier_name",
   "has_unit_price_items",
   "supplier_warehouse",
   "amended_from",
@@ -1301,7 +1301,8 @@
    "hidden": 1,
    "label": "Item Wise Tax Details",
    "no_copy": 1,
-   "options": "Item Wise Tax Detail"
+   "options": "Item Wise Tax Detail",
+   "print_hide": 1
   }
  ],
  "grid_page_length": 50,
@@ -1309,7 +1310,7 @@
  "idx": 105,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-09-28 11:00:56.635116",
+ "modified": "2026-02-03 14:44:55.192192",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Purchase Order",

erpnext/buying/doctype/purchase_order/purchase_order.py

@@ -149,6 +149,7 @@ class PurchaseOrder(BuyingController):
 		supplied_items: DF.Table[PurchaseOrderItemSupplied]
 		supplier: DF.Link
 		supplier_address: DF.Link | None
+		supplier_group: DF.Link | None
 		supplier_name: DF.Data | None
 		supplier_warehouse: DF.Link | None
 		tax_category: DF.Link | None

erpnext/buying/doctype/purchase_order/test_purchase_order.py

@@ -1330,6 +1330,55 @@ class TestPurchaseOrder(IntegrationTestCase):
 		pi = make_pi_from_po(po.name)
 		self.assertEqual(pi.items[0].qty, 50)
 
+	def test_multiple_advances_against_purchase_order_are_allocated_across_partial_purchase_invoices(self):
+		# step - 1: create PO
+		po = create_purchase_order(qty=10, rate=10)
+
+		# step - 2: create first partial advance payment
+		pe1 = get_payment_entry("Purchase Order", po.name, bank_account="_Test Bank - _TC")
+		pe1.reference_no = "1"
+		pe1.reference_date = nowdate()
+		pe1.paid_amount = 50
+		pe1.references[0].allocated_amount = 50
+		pe1.save(ignore_permissions=True).submit()
+
+		# check first advance paid against PO
+		po.reload()
+		self.assertEqual(po.advance_paid, 50)
+
+		# step - 3: create first PI for partial qty and allocate first advance
+		pi_1 = make_pi_from_po(po.name)
+		pi_1.update_stock = 1
+		pi_1.allocate_advances_automatically = 1
+		pi_1.items[0].qty = 5
+		pi_1.save(ignore_permissions=True).submit()
+
+		# step - 4: create second advance payment for remaining
+		pe2 = get_payment_entry("Purchase Order", po.name, bank_account="_Test Bank - _TC")
+		pe2.reference_no = "2"
+		pe2.reference_date = nowdate()
+		pe2.paid_amount = 50
+		pe2.references[0].allocated_amount = 50
+		pe2.save(ignore_permissions=True).submit()
+
+		# check second advance paid against PO
+		po.reload()
+		self.assertEqual(po.advance_paid, 100)
+
+		# step - 5: create second PI for remaining qty and allocate second advance
+		pi_2 = make_pi_from_po(po.name)
+		pi_2.update_stock = 1
+		pi_2.allocate_advances_automatically = 1
+		pi_2.save(ignore_permissions=True).submit()
+
+		# check PO and PI status
+		po.reload()
+		pi_1.reload()
+		pi_2.reload()
+		self.assertEqual(pi_1.status, "Paid")
+		self.assertEqual(pi_2.status, "Paid")
+		self.assertEqual(po.status, "Completed")
+
 
 def create_po_for_sc_testing():
 	from erpnext.controllers.tests.test_subcontracting_controller import (

erpnext/buying/doctype/request_for_quotation/request_for_quotation.py

@@ -304,12 +304,17 @@ class RequestforQuotation(BuyingController):
 		else:
 			sender = frappe.session.user not in STANDARD_USERS and frappe.session.user or None
 
+		rendered_message = frappe.render_template(self.message_for_supplier, doc_args)
+		subject_source = (
+			self.subject
+			or frappe.get_value("Email Template", self.email_template, "subject")
+			or _("Request for Quotation")
+		)
+		rendered_subject = frappe.render_template(subject_source, doc_args)
 		if preview:
 			return {
-				"message": self.message_for_supplier,
-				"subject": self.subject
-				or frappe.get_value("Email Template", self.email_template, "subject")
-				or _("Request for Quotation"),
+				"message": rendered_message,
+				"subject": rendered_subject,
 			}
 
 		attachments = []
@@ -333,10 +338,8 @@ class RequestforQuotation(BuyingController):
 		self.send_email(
 			data,
 			sender,
-			self.subject
-			or frappe.get_value("Email Template", self.email_template, "subject")
-			or _("Request for Quotation"),
-			self.message_for_supplier,
+			rendered_subject,
+			rendered_message,
 			attachments,
 		)
 

erpnext/buying/doctype/request_for_quotation_item/request_for_quotation_item.json

@@ -63,7 +63,6 @@
    "fieldtype": "Column Break"
   },
   {
-   "fetch_from": "item_code.item_name",
    "fieldname": "item_name",
    "fieldtype": "Data",
    "in_global_search": 1,
@@ -262,7 +261,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-04-28 23:30:22.927989",
+ "modified": "2026-01-31 19:46:27.884592",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Request for Quotation Item",

erpnext/buying/doctype/supplier/supplier.js

@@ -135,14 +135,6 @@ frappe.ui.form.on("Supplier", {
 			// indicators
 			erpnext.utils.set_party_dashboard_indicators(frm);
 		}
-
-		frm.set_query("supplier_group", () => {
-			return {
-				filters: {
-					is_group: 0,
-				},
-			};
-		});
 	},
 	get_supplier_group_details: function (frm) {
 		frappe.call({

erpnext/buying/doctype/supplier/supplier.json

@@ -167,6 +167,7 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Supplier Group",
+   "link_filters": "[[\"Supplier Group\",\"is_group\",\"=\",0]]",
    "oldfieldname": "supplier_type",
    "oldfieldtype": "Link",
    "options": "Supplier Group"
@@ -383,7 +384,7 @@
   },
   {
    "fieldname": "primary_address",
-   "fieldtype": "Text",
+   "fieldtype": "Text Editor",
    "label": "Primary Address",
    "read_only": 1
   },
@@ -500,7 +501,7 @@
    "link_fieldname": "party"
   }
  ],
- "modified": "2025-06-29 05:30:50.398653",
+ "modified": "2026-02-06 12:58:01.398824",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Supplier",

erpnext/buying/doctype/supplier/supplier.py

@@ -62,7 +62,7 @@ class Supplier(TransactionBase):
 		portal_users: DF.Table[PortalUser]
 		prevent_pos: DF.Check
 		prevent_rfqs: DF.Check
-		primary_address: DF.Text | None
+		primary_address: DF.TextEditor | None
 		release_date: DF.Date | None
 		represents_company: DF.Link | None
 		supplier_details: DF.Text | None

erpnext/buying/doctype/supplier_quotation/supplier_quotation.js

@@ -16,6 +16,14 @@ erpnext.buying.SupplierQuotationController = class SupplierQuotationController e
 			return !doc.qty && me.frm.doc.has_unit_price_items ? "yellow" : "";
 		});
 
+		this.frm.set_query("warehouse", "items", (doc, cdt, cdn) => {
+			return {
+				filters: {
+					company: doc.company,
+					is_group: 0,
+				},
+			};
+		});
 		super.setup();
 	}
 

erpnext/buying/doctype/supplier_quotation/supplier_quotation.json

@@ -938,7 +938,8 @@
    "hidden": 1,
    "label": "Item Wise Tax Details",
    "no_copy": 1,
-   "options": "Item Wise Tax Detail"
+   "options": "Item Wise Tax Detail",
+   "print_hide": 1
   }
  ],
  "grid_page_length": 50,
@@ -947,7 +948,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-07-23 02:22:43.526822",
+ "modified": "2026-01-29 21:23:13.778468",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Supplier Quotation",

erpnext/controllers/accounts_controller.py

@@ -187,9 +187,8 @@ class AccountsController(TransactionBase):
 
 			msg = ""
 			if self.get("update_outstanding_for_self"):
-				msg = (
-					"We can see {0} is made against {1}. If you want {1}'s outstanding to be updated, "
-					"uncheck '{2}' checkbox. <br><br>Or"
+				msg = _(
+					"We can see {0} is made against {1}. If you want {1}'s outstanding to be updated, uncheck the '{2}' checkbox."
 				).format(
 					frappe.bold(document_type),
 					get_link_to_form(self.doctype, self.get("return_against")),
@@ -200,8 +199,8 @@ class AccountsController(TransactionBase):
 				abs(flt(self.rounded_total) or flt(self.grand_total)) > flt(against_voucher_outstanding)
 			):
 				self.update_outstanding_for_self = 1
-				msg = (
-					"The outstanding amount {} in {} is lesser than {}. Updating the outstanding to this invoice. <br><br>And"
+				msg = _(
+					"The outstanding amount {0} in {1} is lesser than {2}. Updating the outstanding to this invoice."
 				).format(
 					against_voucher_outstanding,
 					get_link_to_form(self.doctype, self.get("return_against")),
@@ -209,11 +208,11 @@ class AccountsController(TransactionBase):
 				)
 
 			if msg:
-				msg += " you can use {} tool to reconcile against {} later.".format(
+				msg += "<br><br>" + _("You can use {0} to reconcile against {1} later.").format(
 					get_link_to_form("Payment Reconciliation"),
 					get_link_to_form(self.doctype, self.get("return_against")),
 				)
-				frappe.msgprint(_(msg))
+				frappe.msgprint(msg)
 
 	def validate(self):
 		if not self.get("is_return") and not self.get("is_debit_note"):

erpnext/controllers/queries.py

@@ -212,7 +212,10 @@ def item_query(doctype, txt, searchfield, start, page_len, filters, as_dict=Fals
 			party = filters.get("customer") or filters.get("supplier")
 			item_rules_list = frappe.get_all(
 				"Party Specific Item",
-				filters={"party": party},
+				filters={
+					"party": ["!=", party],
+					"party_type": "Customer" if filters.get("customer") else "Supplier",
+				},
 				fields=["restrict_based_on", "based_on_value"],
 			)
 
@@ -226,7 +229,7 @@ def item_query(doctype, txt, searchfield, start, page_len, filters, as_dict=Fals
 				filters_dict[rule.restrict_based_on].append(rule.based_on_value)
 
 			for filter in filters_dict:
-				filters[scrub(filter)] = ["in", filters_dict[filter]]
+				filters[scrub(filter)] = ["not in", filters_dict[filter]]
 
 			if filters.get("customer"):
 				del filters["customer"]

erpnext/controllers/sales_and_purchase_return.py

@@ -12,7 +12,7 @@ from frappe.utils import cint, flt, format_datetime, get_datetime
 
 import erpnext
 from erpnext.stock.serial_batch_bundle import get_batches_from_bundle
-from erpnext.stock.utils import get_combine_datetime, get_incoming_rate, get_valuation_method
+from erpnext.stock.utils import get_combine_datetime, get_incoming_rate, get_valuation_method, getdate
 
 
 class StockOverReturnError(frappe.ValidationError):
@@ -759,6 +759,29 @@ def get_rate_for_return(
 		StockLedgerEntry = frappe.qb.DocType("Stock Ledger Entry")
 		select_field = Abs(StockLedgerEntry.stock_value_difference / StockLedgerEntry.actual_qty)
 
+	item_details = frappe.get_cached_value("Item", item_code, ["has_batch_no", "has_expiry_date"], as_dict=1)
+	set_zero_rate_for_expired_batch = frappe.db.get_single_value(
+		"Selling Settings", "set_zero_rate_for_expired_batch"
+	)
+
+	if (
+		set_zero_rate_for_expired_batch
+		and item_details.has_batch_no
+		and item_details.has_expiry_date
+		and not return_against
+		and voucher_type in ["Sales Invoice", "Delivery Note"]
+	):
+		# set incoming_rate zero explicitly for standalone credit note with expired batch
+		batch_no = frappe.db.get_value(f"{voucher_type} Item", voucher_detail_no, "batch_no")
+		if batch_no and is_batch_expired(batch_no, sle.get("posting_date")):
+			frappe.db.set_value(
+				voucher_type + " Item",
+				voucher_detail_no,
+				"incoming_rate",
+				0,
+			)
+			return 0
+
 	rate = flt(frappe.db.get_value("Stock Ledger Entry", filters, select_field))
 	if not (rate and return_against) and voucher_type in ["Sales Invoice", "Delivery Note"]:
 		rate = frappe.db.get_value(f"{voucher_type} Item", voucher_detail_no, "incoming_rate")
@@ -823,12 +846,34 @@ def get_filters(
 	if reference_voucher_detail_no:
 		filters["voucher_detail_no"] = reference_voucher_detail_no
 
-	if voucher_type in ["Purchase Receipt", "Purchase Invoice"] and item_row and item_row.get("warehouse"):
-		filters["warehouse"] = item_row.get("warehouse")
+	warehouses = []
+	if voucher_type in ["Purchase Receipt", "Purchase Invoice"] and item_row:
+		if reference_voucher_detail_no:
+			warehouses = get_warehouses_for_return(voucher_type, reference_voucher_detail_no)
+
+		if item_row.get("warehouse") and item_row.get("warehouse") in warehouses:
+			filters["warehouse"] = item_row.get("warehouse")
 
 	return filters
 
 
+def get_warehouses_for_return(voucher_type, name):
+	warehouses = []
+	warehouse_details = frappe.get_all(
+		voucher_type + " Item",
+		filters={"name": name, "docstatus": 1},
+		fields=["warehouse", "rejected_warehouse"],
+	)
+
+	for d in warehouse_details:
+		if d.warehouse:
+			warehouses.append(d.warehouse)
+		if d.rejected_warehouse:
+			warehouses.append(d.rejected_warehouse)
+
+	return warehouses
+
+
 def get_returned_serial_nos(child_doc, parent_doc, serial_no_field=None, ignore_voucher_detail_no=None):
 	from erpnext.stock.doctype.serial_no.serial_no import (
 		get_serial_nos as get_serial_nos_from_serial_no,
@@ -1276,3 +1321,17 @@ def get_sales_invoice_item_from_consolidated_invoice(return_against_pos_invoice,
 		return result[0].name if result else None
 	except Exception:
 		return None
+
+
+def is_batch_expired(batch_no, posting_date):
+	"""
+	To check whether the batch is expired or not based on the posting date.
+	"""
+	expiry_date = frappe.db.get_value("Batch", batch_no, "expiry_date")
+	if not expiry_date:
+		return
+
+	if getdate(posting_date) > getdate(expiry_date):
+		return True
+
+	return False

erpnext/controllers/selling_controller.py

@@ -8,7 +8,7 @@ from frappe.utils import cint, flt, get_link_to_form, nowtime
 
 from erpnext.accounts.party import render_address
 from erpnext.controllers.accounts_controller import get_taxes_and_charges
-from erpnext.controllers.sales_and_purchase_return import get_rate_for_return
+from erpnext.controllers.sales_and_purchase_return import get_rate_for_return, is_batch_expired
 from erpnext.controllers.stock_controller import StockController
 from erpnext.stock.doctype.item.item import set_item_default
 from erpnext.stock.get_item_details import get_bin_details, get_conversion_factor
@@ -296,7 +296,7 @@ class SellingController(StockController):
 				_(
 					"""Row #{0}: Selling rate for item {1} is lower than its {2}.
 					Selling {3} should be atleast {4}.<br><br>Alternatively,
-					you can disable selling price validation in {5} to bypass
+					you can disable '{5}' in {6} to bypass
 					this validation."""
 				).format(
 					idx,
@@ -304,7 +304,8 @@ class SellingController(StockController):
 					bold(ref_rate_field),
 					bold("net rate"),
 					bold(rate),
-					get_link_to_form("Selling Settings", "Selling Settings"),
+					bold(frappe.get_meta("Selling Settings").get_label("validate_selling_price")),
+					get_link_to_form("Selling Settings"),
 				),
 				title=_("Invalid Selling Price"),
 			)
@@ -313,7 +314,6 @@ class SellingController(StockController):
 			return
 
 		is_internal_customer = self.get("is_internal_customer")
-		valuation_rate_map = {}
 
 		for item in self.items:
 			if not item.item_code or item.is_free_item:
@@ -323,7 +323,9 @@ class SellingController(StockController):
 				"Item", item.item_code, ("last_purchase_rate", "is_stock_item")
 			)
 
-			last_purchase_rate_in_sales_uom = last_purchase_rate * (item.conversion_factor or 1)
+			last_purchase_rate_in_sales_uom = flt(
+				last_purchase_rate * (item.conversion_factor or 1), item.precision("base_net_rate")
+			)
 
 			if flt(item.base_net_rate) < flt(last_purchase_rate_in_sales_uom):
 				throw_message(item.idx, item.item_name, last_purchase_rate_in_sales_uom, "last purchase rate")
@@ -331,50 +333,16 @@ class SellingController(StockController):
 			if is_internal_customer or not is_stock_item:
 				continue
 
-			valuation_rate_map[(item.item_code, item.warehouse)] = None
-
-		if not valuation_rate_map:
-			return
-
-		or_conditions = (
-			f"""(item_code = {frappe.db.escape(valuation_rate[0])}
-			and warehouse = {frappe.db.escape(valuation_rate[1])})"""
-			for valuation_rate in valuation_rate_map
-		)
-
-		valuation_rates = frappe.db.sql(
-			f"""
-			select
-				item_code, warehouse, valuation_rate
-			from
-				`tabBin`
-			where
-				({" or ".join(or_conditions)})
-				and valuation_rate > 0
-		""",
-			as_dict=True,
-		)
-
-		for rate in valuation_rates:
-			valuation_rate_map[(rate.item_code, rate.warehouse)] = rate.valuation_rate
-
-		for item in self.items:
-			if not item.item_code or item.is_free_item:
-				continue
-
-			last_valuation_rate = valuation_rate_map.get((item.item_code, item.warehouse))
-
-			if not last_valuation_rate:
-				continue
-
-			last_valuation_rate_in_sales_uom = last_valuation_rate * (item.conversion_factor or 1)
-
-			if flt(item.base_net_rate) < flt(last_valuation_rate_in_sales_uom):
+			if item.get("incoming_rate") and item.base_net_rate < (
+				valuation_rate := flt(
+					item.incoming_rate * (item.conversion_factor or 1), item.precision("base_net_rate")
+				)
+			):
 				throw_message(
 					item.idx,
 					item.item_name,
-					last_valuation_rate_in_sales_uom,
-					"valuation rate (Moving Average)",
+					valuation_rate,
+					"valuation rate",
 				)
 
 	def get_item_list(self):
@@ -533,19 +501,37 @@ class SellingController(StockController):
 		if self.doctype not in ("Delivery Note", "Sales Invoice"):
 			return
 
+		from erpnext.stock.serial_batch_bundle import get_batch_nos
+
 		allow_at_arms_length_price = frappe.get_cached_value(
 			"Stock Settings", None, "allow_internal_transfer_at_arms_length_price"
 		)
+		set_zero_rate_for_expired_batch = frappe.db.get_single_value(
+			"Selling Settings", "set_zero_rate_for_expired_batch"
+		)
+
+		old_doc = self.get_doc_before_save()
 		items = self.get("items") + (self.get("packed_items") or [])
 		for d in items:
 			if not frappe.get_cached_value("Item", d.item_code, "is_stock_item"):
 				continue
 
 			item_details = frappe.get_cached_value(
-				"Item", d.item_code, ["has_serial_no", "has_batch_no"], as_dict=1
+				"Item", d.item_code, ["has_serial_no", "has_batch_no", "has_expiry_date"], as_dict=1
 			)
 
-			if not self.get("return_against") or (
+			if (
+				set_zero_rate_for_expired_batch
+				and item_details.has_batch_no
+				and item_details.has_expiry_date
+				and self.get("is_return")
+				and not self.get("return_against")
+				and is_batch_expired(d.batch_no, self.get("posting_date"))
+			):
+				# set incoming rate as zero for stand-lone credit note with expired batch
+				d.incoming_rate = 0
+
+			elif not self.get("return_against") or (
 				get_valuation_method(d.item_code, self.company) == "Moving Average"
 				and self.get("is_return")
 				and not item_details.has_serial_no
@@ -554,6 +540,29 @@ class SellingController(StockController):
 				# Get incoming rate based on original item cost based on valuation method
 				qty = flt(d.get("stock_qty") or d.get("actual_qty") or d.get("qty"))
 
+				if old_doc:
+					old_item = next(
+						(
+							item
+							for item in (old_doc.get("items") + (old_doc.get("packed_items") or []))
+							if item.name == d.name
+						),
+						None,
+					)
+					if old_item:
+						old_qty = flt(
+							old_item.get("stock_qty") or old_item.get("actual_qty") or old_item.get("qty")
+						)
+						if (
+							old_item.item_code != d.item_code
+							or old_item.warehouse != d.warehouse
+							or old_qty != qty
+							or old_item.batch_no != d.batch_no
+							or get_batch_nos(old_item.serial_and_batch_bundle)
+							!= get_batch_nos(d.serial_and_batch_bundle)
+						):
+							d.incoming_rate = 0
+
 				if (
 					not d.incoming_rate
 					or self.is_internal_transfer()

erpnext/controllers/status_updater.py

@@ -91,7 +91,8 @@ status_map = {
 	],
 	"Delivery Note": [
 		["Draft", None],
-		["To Bill", "eval:self.per_billed < 100 and self.docstatus == 1"],
+		["To Bill", "eval:self.per_billed == 0 and self.docstatus == 1"],
+		["Partially Billed", "eval:self.per_billed < 100 and self.per_billed > 0 and self.docstatus == 1"],
 		["Completed", "eval:self.per_billed == 100 and self.docstatus == 1"],
 		["Return Issued", "eval:self.per_returned == 100 and self.docstatus == 1"],
 		["Return", "eval:self.is_return == 1 and self.per_billed == 0 and self.docstatus == 1"],
@@ -443,7 +444,7 @@ class StatusUpdater(Document):
 		):
 			return
 
-		if args["source_dt"] != "Pick List Item":
+		if args["source_dt"] != "Pick List Item" and args["target_dt"] != "Quotation Item":
 			if qty_or_amount == "qty":
 				action_msg = _(
 					'To allow over receipt / delivery, update "Over Receipt/Delivery Allowance" in Stock Settings or the Item.'

erpnext/controllers/stock_controller.py

@@ -552,7 +552,10 @@ class StockController(AccountsController):
 		if is_rejected:
 			serial_nos = row.get("rejected_serial_no")
 			type_of_transaction = "Inward" if not self.is_return else "Outward"
-			qty = row.get("rejected_qty")
+			qty = flt(
+				row.get("rejected_qty") * row.get("conversion_factor", 1.0),
+				frappe.get_precision("Serial and Batch Entry", "qty"),
+			)
 			warehouse = row.get("rejected_warehouse")
 
 		if (

erpnext/controllers/subcontracting_controller.py

@@ -166,29 +166,46 @@ class SubcontractingController(StockController):
 						_("Row {0}: Item {1} must be a subcontracted item.").format(item.idx, item.item_name)
 					)
 
-				if self.doctype != "Subcontracting Receipt" and item.qty > flt(
-					get_pending_subcontracted_quantity(
-						self.doctype,
-						self.purchase_order if self.doctype == "Subcontracting Order" else self.sales_order,
-					).get(
-						item.purchase_order_item
-						if self.doctype == "Subcontracting Order"
-						else item.sales_order_item
-					)
-					/ item.subcontracting_conversion_factor,
-					frappe.get_precision(
+				if self.doctype != "Subcontracting Receipt":
+					order_item_doctype = (
 						"Purchase Order Item"
 						if self.doctype == "Subcontracting Order"
-						else "Sales Order Item",
-						"qty",
-					),
-				):
-					frappe.throw(
-						_(
-							"Row {0}: Item {1}'s quantity cannot be higher than the available quantity."
-						).format(item.idx, item.item_name)
+						else "Sales Order Item"
 					)
 
+					order_name = (
+						self.purchase_order if self.doctype == "Subcontracting Order" else self.sales_order
+					)
+					order_item_field = frappe.scrub(order_item_doctype)
+
+					if not item.get(order_item_field):
+						frappe.throw(
+							_("Row {0}: Item {1} must be linked to a {2}.").format(
+								item.idx, item.item_name, order_item_doctype
+							)
+						)
+
+					pending_qty = flt(
+						flt(
+							get_pending_subcontracted_quantity(
+								order_item_doctype,
+								order_name,
+							).get(item.get(order_item_field))
+						)
+						/ item.subcontracting_conversion_factor,
+						frappe.get_precision(
+							order_item_doctype,
+							"qty",
+						),
+					)
+
+					if item.qty > pending_qty:
+						frappe.throw(
+							_(
+								"Row {0}: Item {1}'s quantity cannot be higher than the available quantity."
+							).format(item.idx, item.item_name)
+						)
+
 				if self.doctype != "Subcontracting Inward Order":
 					item.amount = item.qty * item.rate
 
@@ -296,10 +313,10 @@ class SubcontractingController(StockController):
 		):
 			for row in frappe.get_all(
 				f"{self.subcontract_data.order_doctype} Item",
-				fields=["item_code", {"SUB": ["qty", "received_qty"], "as": "qty"}, "parent", "name"],
+				fields=["item_code", {"SUB": ["qty", "received_qty"], "as": "qty"}, "parent", "bom"],
 				filters={"docstatus": 1, "parent": ("in", self.subcontract_orders)},
 			):
-				self.qty_to_be_received[(row.item_code, row.parent)] += row.qty
+				self.qty_to_be_received[(row.item_code, row.parent, row.bom)] += row.qty
 
 	def __get_transferred_items(self):
 		se = frappe.qb.DocType("Stock Entry")
@@ -610,7 +627,9 @@ class SubcontractingController(StockController):
 			and self.doctype != "Subcontracting Inward Order"
 		):
 			row.reserve_warehouse = self.set_reserve_warehouse or item.warehouse
-		elif frappe.get_cached_value("Item", row.rm_item_code, "is_customer_provided_item"):
+		elif frappe.get_cached_value("Item", row.rm_item_code, "is_customer_provided_item") and self.get(
+			"customer_warehouse"
+		):
 			row.warehouse = self.customer_warehouse
 
 	def __set_alternative_item(self, bom_item):
@@ -904,13 +923,17 @@ class SubcontractingController(StockController):
 		self.__set_serial_nos(item_row, rm_obj)
 
 	def __get_qty_based_on_material_transfer(self, item_row, transfer_item):
-		key = (item_row.item_code, item_row.get(self.subcontract_data.order_field))
+		key = (
+			item_row.item_code,
+			item_row.get(self.subcontract_data.order_field),
+			item_row.get("bom"),
+		)
 
 		if self.qty_to_be_received == item_row.qty:
 			return transfer_item.qty
 
-		if self.qty_to_be_received:
-			qty = (flt(item_row.qty) * flt(transfer_item.qty)) / flt(self.qty_to_be_received.get(key, 0))
+		if self.qty_to_be_received.get(key):
+			qty = (flt(item_row.qty) * flt(transfer_item.qty)) / flt(self.qty_to_be_received.get(key))
 			transfer_item.item_details.required_qty = transfer_item.qty
 
 			if transfer_item.serial_no or frappe.get_cached_value(
@@ -959,7 +982,11 @@ class SubcontractingController(StockController):
 
 				if self.qty_to_be_received:
 					self.qty_to_be_received[
-						(row.item_code, row.get(self.subcontract_data.order_field))
+						(
+							row.item_code,
+							row.get(self.subcontract_data.order_field),
+							row.get("bom"),
+						)
 					] -= row.qty
 
 	def __set_rate_for_serial_and_batch_bundle(self):
@@ -1331,9 +1358,7 @@ def get_item_details(items):
 
 
 def get_pending_subcontracted_quantity(doctype, name):
-	table = frappe.qb.DocType(
-		"Purchase Order Item" if doctype == "Subcontracting Order" else "Sales Order Item"
-	)
+	table = frappe.qb.DocType(doctype)
 	query = (
 		frappe.qb.from_(table)
 		.select(table.name, table.stock_qty, table.subcontracted_qty)

erpnext/controllers/subcontracting_inward_controller.py

@@ -720,6 +720,7 @@ class SubcontractingInwardController:
 				item.db_set("scio_detail", scio_rm.name)
 
 		if data:
+			precision = self.precision("customer_provided_item_cost", "items")
 			result = frappe.get_all(
 				"Subcontracting Inward Order Received Item",
 				filters={
@@ -734,10 +735,17 @@ class SubcontractingInwardController:
 			table = frappe.qb.DocType("Subcontracting Inward Order Received Item")
 			case_expr_qty, case_expr_rate = Case(), Case()
 			for d in result:
-				d.received_qty += (
-					data[d.name].transfer_qty if self._action == "submit" else -data[d.name].transfer_qty
+				current_qty = flt(data[d.name].transfer_qty) * (1 if self._action == "submit" else -1)
+				current_rate = flt(data[d.name].rate)
+
+				# Calculate weighted average rate
+				old_total = d.rate * d.received_qty
+				current_total = current_rate * current_qty
+
+				d.received_qty = d.received_qty + current_qty
+				d.rate = (
+					flt((old_total + current_total) / d.received_qty, precision) if d.received_qty else 0.0
 				)
-				d.rate += data[d.name].rate if self._action == "submit" else -data[d.name].rate
 
 				if not d.required_qty and not d.received_qty:
 					deleted_docs.append(d.name)

erpnext/controllers/taxes_and_totals.py

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

erpnext/controllers/tests/test_accounts_controller.py

@@ -2,8 +2,6 @@
 # For license information, please see license.txt
 
 
-from datetime import datetime
-
 import frappe
 from frappe import qb
 from frappe.query_builder.functions import Sum
@@ -2480,3 +2478,21 @@ class TestAccountsController(IntegrationTestCase):
 		self.assertRaises(frappe.ValidationError, po.save)
 		po.items[0].delivered_by_supplier = 1
 		po.save()
+
+	@IntegrationTestCase.change_settings("Global Defaults", {"use_posting_datetime_for_naming_documents": 1})
+	def test_document_naming_rule_based_on_posting_date(self):
+		frappe.new_doc(
+			"Document Naming Rule", document_type="Sales Invoice", prefix="SI-.MM.-.YYYY.-"
+		).submit()
+
+		si = create_sales_invoice(do_not_save=True)
+		si.set_posting_time = 1
+		si.posting_date = "2025-12-31"
+		si.save()
+		self.assertEqual(si.name, "SI-12-2025-00001")
+
+		si = create_sales_invoice(do_not_save=True)
+		si.set_posting_time = 1
+		si.posting_date = "2026-01-01"
+		si.save()
+		self.assertEqual(si.name, "SI-01-2026-00002")

erpnext/crm/doctype/email_campaign/email_campaign.py

@@ -38,18 +38,18 @@ class EmailCampaign(Document):
 	def set_date(self):
 		if getdate(self.start_date) < getdate(today()):
 			frappe.throw(_("Start Date cannot be before the current date"))
+
 		# set the end date as start date + max(send after days) in campaign schedule
-		send_after_days = []
-		campaign = frappe.get_doc("Campaign", self.campaign_name)
-		for entry in campaign.get("campaign_schedules"):
-			send_after_days.append(entry.send_after_days)
-		try:
-			self.end_date = add_days(getdate(self.start_date), max(send_after_days))
-		except ValueError:
+		campaign = frappe.get_cached_doc("Campaign", self.campaign_name)
+		send_after_days = [entry.send_after_days for entry in campaign.get("campaign_schedules")]
+
+		if not send_after_days:
 			frappe.throw(
 				_("Please set up the Campaign Schedule in the Campaign {0}").format(self.campaign_name)
 			)
 
+		self.end_date = add_days(getdate(self.start_date), max(send_after_days))
+
 	def validate_lead(self):
 		lead_email_id = frappe.db.get_value("Lead", self.recipient, "email_id")
 		if not lead_email_id:
@@ -77,58 +77,128 @@ class EmailCampaign(Document):
 		start_date = getdate(self.start_date)
 		end_date = getdate(self.end_date)
 		today_date = getdate(today())
+
 		if start_date > today_date:
-			self.db_set("status", "Scheduled", update_modified=False)
+			new_status = "Scheduled"
 		elif end_date >= today_date:
-			self.db_set("status", "In Progress", update_modified=False)
-		elif end_date < today_date:
-			self.db_set("status", "Completed", update_modified=False)
+			new_status = "In Progress"
+		else:
+			new_status = "Completed"
+
+		if self.status != new_status:
+			self.db_set("status", new_status, update_modified=False)
 
 
 # called through hooks to send campaign mails to leads
 def send_email_to_leads_or_contacts():
+	today_date = getdate(today())
+
+	# Get all active email campaigns in a single query
 	email_campaigns = frappe.get_all(
-		"Email Campaign", filters={"status": ("not in", ["Unsubscribed", "Completed", "Scheduled"])}
+		"Email Campaign",
+		filters={"status": "In Progress"},
+		fields=["name", "campaign_name", "email_campaign_for", "recipient", "start_date", "sender"],
 	)
-	for camp in email_campaigns:
-		email_campaign = frappe.get_doc("Email Campaign", camp.name)
-		campaign = frappe.get_cached_doc("Campaign", email_campaign.campaign_name)
+
+	if not email_campaigns:
+		return
+
+	# Process each email campaign
+	for email_campaign in email_campaigns:
+		try:
+			campaign = frappe.get_cached_doc("Campaign", email_campaign.campaign_name)
+		except frappe.DoesNotExistError:
+			frappe.log_error(
+				title=_("Email Campaign Error"),
+				message=_("Campaign {0} not found").format(email_campaign.campaign_name),
+			)
+			continue
+
+		# Find schedules that match today
 		for entry in campaign.get("campaign_schedules"):
-			scheduled_date = add_days(email_campaign.get("start_date"), entry.get("send_after_days"))
-			if scheduled_date == getdate(today()):
-				send_mail(entry, email_campaign)
+			try:
+				scheduled_date = add_days(getdate(email_campaign.start_date), entry.get("send_after_days"))
+				if scheduled_date == today_date:
+					send_mail(entry, email_campaign)
+			except Exception:
+				frappe.log_error(
+					title=_("Email Campaign Send Error"),
+					message=_("Failed to send email for campaign {0} to {1}").format(
+						email_campaign.name, email_campaign.recipient
+					),
+				)
 
 
 def send_mail(entry, email_campaign):
-	recipient_list = []
-	if email_campaign.email_campaign_for == "Email Group":
-		for member in frappe.db.get_list(
-			"Email Group Member", filters={"email_group": email_campaign.get("recipient")}, fields=["email"]
-		):
-			recipient_list.append(member["email"])
+	campaign_for = email_campaign.get("email_campaign_for")
+	recipient = email_campaign.get("recipient")
+	sender_user = email_campaign.get("sender")
+	campaign_name = email_campaign.get("name")
+
+	# Get recipient emails
+	if campaign_for == "Email Group":
+		recipient_list = frappe.get_all(
+			"Email Group Member",
+			filters={"email_group": recipient, "unsubscribed": 0},
+			pluck="email",
+		)
 	else:
-		recipient_list.append(
-			frappe.db.get_value(
-				email_campaign.email_campaign_for, email_campaign.get("recipient"), "email_id"
+		email_id = frappe.db.get_value(campaign_for, recipient, "email_id")
+		if not email_id:
+			frappe.log_error(
+				title=_("Email Campaign Error"),
+				message=_("No email found for {0} {1}").format(campaign_for, recipient),
 			)
+			return
+		recipient_list = [email_id]
+
+	if not recipient_list:
+		frappe.log_error(
+			title=_("Email Campaign Error"),
+			message=_("No recipients found for campaign {0}").format(campaign_name),
+		)
+		return
+
+	# Get email template and sender
+	email_template = frappe.get_cached_doc("Email Template", entry.get("email_template"))
+	sender = frappe.db.get_value("User", sender_user, "email") if sender_user else None
+
+	# Build context for template rendering
+	if campaign_for != "Email Group":
+		context = {"doc": frappe.get_doc(campaign_for, recipient)}
+	else:
+		# For email groups, use the email group document as context
+		context = {"doc": frappe.get_doc("Email Group", recipient)}
+
+	# Render template
+	subject = frappe.render_template(email_template.get("subject"), context)
+	content = frappe.render_template(email_template.response_, context)
+
+	try:
+		comm = make(
+			doctype="Email Campaign",
+			name=campaign_name,
+			subject=subject,
+			content=content,
+			sender=sender,
+			recipients=recipient_list,
+			communication_medium="Email",
+			sent_or_received="Sent",
+			send_email=False,
+			email_template=email_template.name,
 		)
 
-	email_template = frappe.get_doc("Email Template", entry.get("email_template"))
-	sender = frappe.db.get_value("User", email_campaign.get("sender"), "email")
-	context = {"doc": frappe.get_doc(email_campaign.email_campaign_for, email_campaign.recipient)}
-	# send mail and link communication to document
-	comm = make(
-		doctype="Email Campaign",
-		name=email_campaign.name,
-		subject=frappe.render_template(email_template.get("subject"), context),
-		content=frappe.render_template(email_template.response_, context),
-		sender=sender,
-		bcc=recipient_list,
-		communication_medium="Email",
-		sent_or_received="Sent",
-		send_email=True,
-		email_template=email_template.name,
-	)
+		frappe.sendmail(
+			recipients=recipient_list,
+			subject=subject,
+			content=content,
+			sender=sender,
+			communication=comm["name"],
+			queue_separately=True,
+		)
+	except Exception:
+		frappe.log_error(title="Email Campaign Failed.")
+
 	return comm
 
 
@@ -140,7 +210,12 @@ def unsubscribe_recipient(unsubscribe, method):
 
 # called through hooks to update email campaign status daily
 def set_email_campaign_status():
-	email_campaigns = frappe.get_all("Email Campaign", filters={"status": ("!=", "Unsubscribed")})
-	for entry in email_campaigns:
-		email_campaign = frappe.get_doc("Email Campaign", entry.name)
+	email_campaigns = frappe.get_all(
+		"Email Campaign",
+		filters={"status": ("!=", "Unsubscribed")},
+		pluck="name",
+	)
+
+	for name in email_campaigns:
+		email_campaign = frappe.get_doc("Email Campaign", name)
 		email_campaign.update_status()

erpnext/desktop_icon/accounting.json

@@ -1,20 +1,20 @@
 {
  "app": "erpnext",
- "creation": "2025-11-17 20:55:11.854086",
+ "creation": "2026-01-27 17:02:43.440221",
  "docstatus": 0,
  "doctype": "Desktop Icon",
  "hidden": 0,
  "icon": "accounting",
- "icon_type": "Link",
+ "icon_type": "Folder",
  "idx": 1,
  "label": "Accounting",
- "link_to": "Accounting",
+ "link_to": "",
  "link_type": "Workspace Sidebar",
- "modified": "2026-01-01 20:07:01.203651",
+ "modified": "2026-01-27 17:04:04.351402",
  "modified_by": "Administrator",
  "name": "Accounting",
  "owner": "Administrator",
- "parent_icon": "Accounts",
+ "parent_icon": "",
  "restrict_removal": 0,
  "roles": [],
  "standard": 1

erpnext/desktop_icon/accounts.json

@@ -1,18 +0,0 @@
-{
- "app": "erpnext",
- "creation": "2025-11-12 13:07:51.988728",
- "docstatus": 0,
- "doctype": "Desktop Icon",
- "hidden": 0,
- "icon_type": "Folder",
- "idx": 1,
- "label": "Accounts",
- "link_type": "DocType",
- "logo_url": "",
- "modified": "2025-11-17 17:39:36.915358",
- "modified_by": "Administrator",
- "name": "Accounts",
- "owner": "Administrator",
- "roles": [],
- "standard": 1
-}

erpnext/desktop_icon/accounts_setup.json

@@ -0,0 +1,21 @@
+{
+ "app": "erpnext",
+ "bg_color": "blue",
+ "creation": "2026-01-27 17:37:55.824821",
+ "docstatus": 0,
+ "doctype": "Desktop Icon",
+ "hidden": 0,
+ "icon_type": "Link",
+ "idx": 3,
+ "label": "Accounts Setup",
+ "link_to": "Accounts Setup",
+ "link_type": "Workspace Sidebar",
+ "modified": "2026-01-27 18:34:57.092350",
+ "modified_by": "Administrator",
+ "name": "Accounts Setup",
+ "owner": "Administrator",
+ "parent_icon": "Accounting",
+ "restrict_removal": 0,
+ "roles": [],
+ "standard": 1
+}

erpnext/desktop_icon/banking.json

@@ -14,7 +14,7 @@
  "modified_by": "Administrator",
  "name": "Banking",
  "owner": "Administrator",
- "parent_icon": "Accounts",
+ "parent_icon": "Accounting",
  "restrict_removal": 0,
  "roles": [],
  "standard": 1

erpnext/desktop_icon/budget.json

@@ -1,20 +1,20 @@
 {
  "app": "erpnext",
- "creation": "2025-11-10 16:54:04.780644",
+ "creation": "2026-01-23 11:00:23.272751",
  "docstatus": 0,
  "doctype": "Desktop Icon",
  "hidden": 0,
  "icon": "expenses",
  "icon_type": "Link",
- "idx": 4,
+ "idx": 6,
  "label": "Budget",
  "link_to": "Budget",
  "link_type": "Workspace Sidebar",
- "modified": "2026-01-01 20:07:01.449176",
+ "modified": "2026-01-23 14:39:30.839274",
  "modified_by": "Administrator",
  "name": "Budget",
  "owner": "Administrator",
- "parent_icon": "Accounts",
+ "parent_icon": "Accounting",
  "restrict_removal": 0,
  "roles": [],
  "standard": 1

erpnext/desktop_icon/financial_reports.json

@@ -1,20 +1,20 @@
 {
  "app": "erpnext",
- "creation": "2025-11-17 20:55:11.772622",
+ "creation": "2026-01-23 11:00:23.250819",
  "docstatus": 0,
  "doctype": "Desktop Icon",
  "hidden": 0,
  "icon": "file",
  "icon_type": "Link",
- "idx": 0,
+ "idx": 2,
  "label": "Financial Reports",
  "link_to": "Financial Reports",
  "link_type": "Workspace Sidebar",
- "modified": "2026-01-01 20:07:01.253367",
+ "modified": "2026-01-23 14:38:46.479759",
  "modified_by": "Administrator",
  "name": "Financial Reports",
  "owner": "Administrator",
- "parent_icon": "Accounts",
+ "parent_icon": "Accounting",
  "restrict_removal": 0,
  "roles": [],
  "sidebar": "",

erpnext/desktop_icon/invoicing.json

@@ -0,0 +1,21 @@
+{
+ "app": "erpnext",
+ "creation": "2026-01-23 10:51:05.799725",
+ "docstatus": 0,
+ "doctype": "Desktop Icon",
+ "hidden": 0,
+ "icon": "accounting",
+ "icon_type": "Link",
+ "idx": 0,
+ "label": "Invoicing",
+ "link_to": "Invoicing",
+ "link_type": "Workspace Sidebar",
+ "modified": "2026-01-23 15:17:23.564795",
+ "modified_by": "Administrator",
+ "name": "Invoicing",
+ "owner": "Administrator",
+ "parent_icon": "Accounting",
+ "restrict_removal": 0,
+ "roles": [],
+ "standard": 1
+}

erpnext/desktop_icon/payments.json

@@ -0,0 +1,22 @@
+{
+ "app": "erpnext",
+ "bg_color": "blue",
+ "creation": "2026-01-27 17:37:55.866525",
+ "docstatus": 0,
+ "doctype": "Desktop Icon",
+ "hidden": 0,
+ "icon": "receipt-text",
+ "icon_type": "Link",
+ "idx": 1,
+ "label": "Payments",
+ "link_to": "Payments",
+ "link_type": "Workspace Sidebar",
+ "modified": "2026-01-27 18:31:59.617181",
+ "modified_by": "Administrator",
+ "name": "Payments",
+ "owner": "Administrator",
+ "parent_icon": "Accounting",
+ "restrict_removal": 0,
+ "roles": [],
+ "standard": 1
+}

erpnext/desktop_icon/share_management.json

@@ -1,19 +1,19 @@
 {
  "app": "erpnext",
- "creation": "2026-01-12 12:31:53.444807",
+ "creation": "2026-01-23 11:00:23.303554",
  "docstatus": 0,
  "doctype": "Desktop Icon",
  "hidden": 0,
  "icon_type": "Link",
- "idx": 8,
+ "idx": 7,
  "label": "Share Management",
  "link_to": "Share Management",
  "link_type": "Workspace Sidebar",
- "modified": "2026-01-12 12:31:53.444807",
+ "modified": "2026-01-23 14:39:34.128991",
  "modified_by": "Administrator",
  "name": "Share Management",
  "owner": "Administrator",
- "parent_icon": "Accounts",
+ "parent_icon": "Accounting",
  "restrict_removal": 0,
  "roles": [],
  "standard": 1

erpnext/desktop_icon/subscription.json

@@ -1,20 +1,20 @@
 {
  "app": "erpnext",
- "creation": "2025-11-10 16:14:25.976756",
+ "creation": "2026-01-23 11:00:23.344237",
  "docstatus": 0,
  "doctype": "Desktop Icon",
  "hidden": 0,
  "icon": "monitor-check",
  "icon_type": "Link",
- "idx": 99,
+ "idx": 8,
  "label": "Subscription",
  "link_to": "Subscription",
  "link_type": "Workspace Sidebar",
- "modified": "2026-01-01 20:07:01.548581",
+ "modified": "2026-01-23 14:39:37.830722",
  "modified_by": "Administrator",
  "name": "Subscription",
  "owner": "Administrator",
- "parent_icon": "Accounts",
+ "parent_icon": "Accounting",
  "restrict_removal": 0,
  "roles": [],
  "standard": 1

erpnext/desktop_icon/taxes.json

@@ -1,20 +1,20 @@
 {
  "app": "erpnext",
- "creation": "2025-11-12 15:05:54.474218",
+ "creation": "2026-01-23 11:00:23.262357",
  "docstatus": 0,
  "doctype": "Desktop Icon",
  "hidden": 0,
  "icon": "book-text",
  "icon_type": "Link",
- "idx": 3,
+ "idx": 4,
  "label": "Taxes",
  "link_to": "Taxes",
  "link_type": "Workspace Sidebar",
- "modified": "2026-01-01 20:07:01.356333",
+ "modified": "2026-01-23 14:39:25.636166",
  "modified_by": "Administrator",
  "name": "Taxes",
  "owner": "Administrator",
- "parent_icon": "Accounts",
+ "parent_icon": "Accounting",
  "restrict_removal": 0,
  "roles": [],
  "sidebar": "",

erpnext/hooks.py

@@ -8,7 +8,7 @@ app_email = "hello@frappe.io"
 app_license = "GNU General Public License (v3)"
 source_link = "https://github.com/frappe/erpnext"
 app_logo_url = "/assets/erpnext/images/erpnext-logo.svg"
-app_home = "/app/home"
+app_home = "/desk"
 
 add_to_apps_screen = [
 	{
@@ -402,9 +402,10 @@ doc_events = {
 }
 
 # function should expect the variable and doc as arguments
+naming_series_variables_list = ["FY", "TFY", "ABBR", "MM", "DD", "YY", "YYYY", "JJJ", "WW"]
 naming_series_variables = {
-	"FY": "erpnext.accounts.utils.parse_naming_series_variable",
-	"ABBR": "erpnext.accounts.utils.parse_naming_series_variable",
+	variable: "erpnext.accounts.utils.parse_naming_series_variable"
+	for variable in naming_series_variables_list
 }
 
 # On cancel event Payment Entry will be exempted and all linked submittable doctype will get cancelled.
@@ -533,6 +534,7 @@ accounting_dimension_doctypes = [
 	"Purchase Order Item",
 	"Sales Order Item",
 	"Journal Entry Account",
+	"Journal Entry Template Account",
 	"Material Request Item",
 	"Delivery Note Item",
 	"Purchase Receipt Item",
@@ -569,6 +571,7 @@ accounting_dimension_doctypes = [
 	"Payment Request",
 	"Asset Movement Item",
 	"Asset Depreciation Schedule",
+	"Advance Taxes and Charges",
 ]
 
 get_matching_queries = (