📝 Add docstrings to wo-flt-issue

Docstrings generation was requested by @rtdany10.

* https://github.com/frappe/erpnext/pull/50952#issuecomment-3619564968

The following files were modified:

* `erpnext/manufacturing/doctype/work_order/work_order.py`

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

@@ -128,10 +128,9 @@ jobs:
           FRAPPE_BRANCH: ${{ github.event.client_payload.sha || github.event.inputs.branch }}
 
       - name: Run Tests
-        run: 'cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --app erpnext --total-builds ${{ strategy.job-total }} --build-number ${{ matrix.container }}'
+        run: 'cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --app erpnext --total-builds ${{ strategy.job-total }} --build-number ${{ matrix.container }} --with-coverage'
         env:
           TYPE: server
-          CAPTURE_COVERAGE: ${{ github.event_name != 'pull_request' }}
 
 
       - name: Show bench output
@@ -140,7 +139,6 @@ jobs:
 
       - name: Upload coverage data
         uses: actions/upload-artifact@v4
-        if: github.event_name != 'pull_request'
         with:
           name: coverage-${{ matrix.container }}
           path: /home/runner/frappe-bench/sites/coverage.xml
@@ -149,7 +147,6 @@ jobs:
     name: Coverage Wrap Up
     needs: test
     runs-on: ubuntu-latest
-    if: ${{ github.event_name != 'pull_request' }}
     steps:
       - name: Clone
         uses: actions/checkout@v4

.mergify.yml

@@ -50,6 +50,15 @@ pull_request_rules:
           - version-15-hotfix
         assignees:
           - "{{ author }}"
+  - name: backport to version-16-beta
+    conditions:
+      - label="backport version-16-beta"
+    actions:
+      backport:
+        branches:
+          - version-16-beta
+        assignees:
+          - "{{ author }}"
   - name: Automatic merge on CI success and review
     conditions:
       - status-success=linters

erpnext/accounts/deferred_revenue.py

@@ -7,6 +7,7 @@ from frappe.utils import (
 	cint,
 	date_diff,
 	flt,
+	formatdate,
 	get_first_day,
 	get_last_day,
 	get_link_to_form,
@@ -318,7 +319,7 @@ def get_already_booked_amount(doc, item):
 def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 	enable_check = "enable_deferred_revenue" if doc.doctype == "Sales Invoice" else "enable_deferred_expense"
 
-	accounts_frozen_upto = frappe.get_single_value("Accounts Settings", "acc_frozen_upto")
+	accounts_frozen_upto = frappe.db.get_value("Company", doc.company, "accounts_frozen_till_date")
 
 	def _book_deferred_revenue_or_expense(
 		item,

erpnext/accounts/doctype/account/account.py

@@ -93,8 +93,10 @@ class Account(NestedSet):
 			super().on_update()
 
 	def onload(self):
-		frozen_accounts_modifier = frappe.get_single_value("Accounts Settings", "frozen_accounts_modifier")
-		if not frozen_accounts_modifier or frozen_accounts_modifier in frappe.get_roles():
+		role_allowed_for_frozen_entries = frappe.db.get_value(
+			"Company", self.company, "role_allowed_for_frozen_entries"
+		)
+		if not role_allowed_for_frozen_entries or role_allowed_for_frozen_entries in frappe.get_roles():
 			self.set_onload("can_freeze_account", True)
 
 	def autoname(self):
@@ -303,10 +305,10 @@ class Account(NestedSet):
 		if not doc_before_save or doc_before_save.freeze_account == self.freeze_account:
 			return
 
-		frozen_accounts_modifier = frappe.get_cached_value(
-			"Accounts Settings", "Accounts Settings", "frozen_accounts_modifier"
+		role_allowed_for_frozen_entries = frappe.get_cached_value(
+			"Company", self.company, "role_allowed_for_frozen_entries"
 		)
-		if not frozen_accounts_modifier or frozen_accounts_modifier not in frappe.get_roles():
+		if not role_allowed_for_frozen_entries or role_allowed_for_frozen_entries not in frappe.get_roles():
 			throw(_("You are not authorized to set Frozen value"))
 
 	def validate_balance_must_be_debit_or_credit(self):

erpnext/accounts/doctype/account/account_tree.js

@@ -160,6 +160,14 @@ frappe.treeview_settings["Account"] = {
 				.options,
 			description: __("Optional. This setting will be used to filter in various transactions."),
 		},
+		{
+			fieldtype: "Link",
+			fieldname: "account_category",
+			label: __("Account Category"),
+			options: frappe.get_meta("Account").fields.filter((d) => d.fieldname == "account_category")[0]
+				.options,
+			description: __("Optional. Used with Financial Report Template"),
+		},
 		{
 			fieldtype: "Float",
 			fieldname: "tax_rate",

erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py

@@ -228,6 +228,7 @@ def get():
 				},
 				_("Impairment"): {"account_number": "5224", "account_category": "Operating Expenses"},
 				_("Tax Expense"): {"account_number": "5225", "account_category": "Tax Expense"},
+				"account_number": "5200",
 			},
 			"root_type": "Expense",
 			"account_number": "5000",

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -73,13 +73,12 @@
   "calculate_depr_using_total_days",
   "column_break_gjcc",
   "book_asset_depreciation_entry_automatically",
+  "role_to_notify_on_depreciation_failure",
   "closing_settings_tab",
   "period_closing_settings_section",
-  "acc_frozen_upto",
   "ignore_account_closing_balance",
   "use_legacy_controller_for_pcv",
   "column_break_25",
-  "frozen_accounts_modifier",
   "tab_break_dpet",
   "show_balance_in_coa",
   "banking_tab",
@@ -102,21 +101,6 @@
   "use_legacy_budget_controller"
  ],
  "fields": [
-  {
-   "description": "Accounting entries are frozen up to this date. Nobody can create or modify entries except users with the role specified below",
-   "fieldname": "acc_frozen_upto",
-   "fieldtype": "Date",
-   "in_list_view": 1,
-   "label": "Accounts Frozen Till Date"
-  },
-  {
-   "description": "Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts",
-   "fieldname": "frozen_accounts_modifier",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Role Allowed to Set Frozen Accounts and Edit Frozen Entries",
-   "options": "Role"
-  },
   {
    "default": "Billing Address",
    "description": "Address used to determine Tax Category in transactions",
@@ -658,6 +642,13 @@
    "fieldname": "use_legacy_controller_for_pcv",
    "fieldtype": "Check",
    "label": "Use Legacy Controller For Period Closing Voucher"
+  },
+  {
+   "description": "Users with this role will be notified if the asset depreciation gets failed",
+   "fieldname": "role_to_notify_on_depreciation_failure",
+   "fieldtype": "Link",
+   "label": "Role to Notify on Depreciation Failure",
+   "options": "Role"
   }
  ],
  "grid_page_length": 50,
@@ -666,7 +657,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2025-10-20 14:06:08.870427",
+ "modified": "2025-12-03 20:42:13.238050",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -11,7 +11,6 @@ from frappe.model.document import Document
 from frappe.utils import cint
 
 from erpnext.accounts.utils import sync_auto_reconcile_config
-from erpnext.stock.utils import check_pending_reposting
 
 
 class AccountsSettings(Document):
@@ -23,7 +22,6 @@ class AccountsSettings(Document):
 	if TYPE_CHECKING:
 		from frappe.types import DF
 
-		acc_frozen_upto: DF.Date | None
 		add_taxes_from_item_tax_template: DF.Check
 		add_taxes_from_taxes_and_charges_template: DF.Check
 		allow_multi_currency_invoices_against_single_party_account: DF.Check
@@ -50,7 +48,6 @@ class AccountsSettings(Document):
 		enable_party_matching: DF.Check
 		exchange_gain_loss_posting_date: DF.Literal["Invoice", "Payment", "Reconciliation Date"]
 		fetch_valuation_rate_for_internal_transaction: DF.Check
-		frozen_accounts_modifier: DF.Link | None
 		general_ledger_remarks_length: DF.Int
 		ignore_account_closing_balance: DF.Check
 		ignore_is_opening_check_for_reporting: DF.Check
@@ -64,6 +61,7 @@ class AccountsSettings(Document):
 		receivable_payable_remarks_length: DF.Int
 		reconciliation_queue_size: DF.Int
 		role_allowed_to_over_bill: DF.Link | None
+		role_to_notify_on_depreciation_failure: DF.Link | None
 		role_to_override_stop_action: DF.Link | None
 		round_row_wise_tax: DF.Check
 		show_balance_in_coa: DF.Check
@@ -100,9 +98,6 @@ class AccountsSettings(Document):
 		if old_doc.show_payment_schedule_in_print != self.show_payment_schedule_in_print:
 			self.enable_payment_schedule_in_print()
 
-		if old_doc.acc_frozen_upto != self.acc_frozen_upto:
-			self.validate_pending_reposts()
-
 		if clear_cache:
 			frappe.clear_cache()
 
@@ -129,10 +124,6 @@ class AccountsSettings(Document):
 				validate_fields_for_doctype=False,
 			)
 
-	def validate_pending_reposts(self):
-		if self.acc_frozen_upto:
-			check_pending_reposting(self.acc_frozen_upto)
-
 	def validate_and_sync_auto_reconcile_config(self):
 		if self.has_value_changed("auto_reconciliation_job_trigger"):
 			if (

erpnext/accounts/doctype/accounts_settings/regional/united_states.js

@@ -1,11 +1,16 @@
 frappe.ui.form.on("Accounts Settings", {
 	refresh: function (frm) {
-		frm.set_df_property("acc_frozen_upto", "label", "Books Closed Through");
-		frm.set_df_property(
-			"frozen_accounts_modifier",
-			"label",
-			"Role Allowed to Close Books & Make Changes to Closed Periods"
-		);
 		frm.set_df_property("credit_controller", "label", "Credit Manager");
 	},
 });
+
+frappe.ui.form.on("Company", {
+	refresh: function (frm) {
+		frm.set_df_property("accounts_frozen_till_date", "label", "Books Closed Through");
+		frm.set_df_property(
+			"role_allowed_for_frozen_entries",
+			"label",
+			"Role Allowed to Close Books & Make Changes to Closed Periods"
+		);
+	},
+});

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.py

@@ -14,6 +14,7 @@ import openpyxl
 from frappe import _
 from frappe.core.doctype.data_import.data_import import DataImport
 from frappe.core.doctype.data_import.importer import Importer, ImportFile
+from frappe.query_builder.functions import Count
 from frappe.utils.background_jobs import enqueue
 from frappe.utils.file_manager import get_file, save_file
 from frappe.utils.xlsxutils import ILLEGAL_CHARACTERS_RE, handle_html
@@ -371,7 +372,7 @@ def get_import_status(docname):
 
 	logs = frappe.get_all(
 		"Data Import Log",
-		fields=["count(*) as count", "success"],
+		fields=[{"COUNT": "*", "as": "count"}, "success"],
 		filters={"data_import": docname},
 		group_by="success",
 	)

erpnext/accounts/doctype/budget/budget.js

@@ -4,16 +4,6 @@ frappe.provide("erpnext.accounts.dimensions");
 
 frappe.ui.form.on("Budget", {
 	onload: function (frm) {
-		frm.set_query("account", "accounts", function () {
-			return {
-				filters: {
-					company: frm.doc.company,
-					report_type: "Profit and Loss",
-					is_group: 0,
-				},
-			};
-		});
-
 		frm.set_query("monthly_distribution", function () {
 			return {
 				filters: {
@@ -30,8 +20,28 @@ frappe.ui.form.on("Budget", {
 		});
 	},
 
-	refresh: function (frm) {
+	refresh: async function (frm) {
 		frm.trigger("toggle_reqd_fields");
+
+		if (!frm.doc.__islocal && frm.doc.docstatus == 1) {
+			let exception_role = await frappe.db.get_value(
+				"Company",
+				frm.doc.company,
+				"exception_budget_approver_role"
+			);
+
+			const role = exception_role.message.exception_budget_approver_role;
+
+			if (role && frappe.user.has_role(role)) {
+				frm.add_custom_button(
+					__("Revise Budget"),
+					function () {
+						frm.events.revise_budget_action(frm);
+					},
+					__("Actions")
+				);
+			}
+		}
 	},
 
 	budget_against: function (frm) {
@@ -39,6 +49,15 @@ frappe.ui.form.on("Budget", {
 		frm.trigger("toggle_reqd_fields");
 	},
 
+	budget_amount(frm) {
+		if (frm.doc.budget_distribution?.length) {
+			frm.doc.budget_distribution.forEach((row) => {
+				row.amount = flt((row.percent / 100) * frm.doc.budget_amount, 2);
+			});
+			frm.refresh_field("budget_distribution");
+		}
+	},
+
 	set_null_value: function (frm) {
 		if (frm.doc.budget_against == "Cost Center") {
 			frm.set_value("project", null);
@@ -51,4 +70,44 @@ frappe.ui.form.on("Budget", {
 		frm.toggle_reqd("cost_center", frm.doc.budget_against == "Cost Center");
 		frm.toggle_reqd("project", frm.doc.budget_against == "Project");
 	},
+
+	revise_budget_action: function (frm) {
+		frappe.confirm(
+			__(
+				"Are you sure you want to revise this budget? The current budget will be cancelled and a new draft will be created."
+			),
+			function () {
+				frappe.call({
+					method: "erpnext.accounts.doctype.budget.budget.revise_budget",
+					args: { budget_name: frm.doc.name },
+					callback: function (r) {
+						if (r.message) {
+							frappe.msgprint(__("New revised budget created successfully"));
+							frappe.set_route("Form", "Budget", r.message);
+						}
+					},
+				});
+			},
+			function () {
+				frappe.msgprint(__("Revision cancelled"));
+			}
+		);
+	},
+});
+
+frappe.ui.form.on("Budget Distribution", {
+	amount(frm, cdt, cdn) {
+		let row = frappe.get_doc(cdt, cdn);
+		if (frm.doc.budget_amount) {
+			row.percent = flt((row.amount / frm.doc.budget_amount) * 100, 2);
+			frm.refresh_field("budget_distribution");
+		}
+	},
+	percent(frm, cdt, cdn) {
+		let row = frappe.get_doc(cdt, cdn);
+		if (frm.doc.budget_amount) {
+			row.amount = flt((row.percent / 100) * frm.doc.budget_amount, 2);
+			frm.refresh_field("budget_distribution");
+		}
+	},
 });

erpnext/accounts/doctype/budget/budget.json

@@ -12,10 +12,19 @@
   "company",
   "cost_center",
   "project",
-  "fiscal_year",
+  "account",
   "column_break_3",
-  "monthly_distribution",
   "amended_from",
+  "from_fiscal_year",
+  "to_fiscal_year",
+  "budget_start_date",
+  "budget_end_date",
+  "distribution_frequency",
+  "budget_amount",
+  "section_break_nwug",
+  "distribute_equally",
+  "section_break_fpdt",
+  "budget_distribution",
   "section_break_6",
   "applicable_on_material_request",
   "action_if_annual_budget_exceeded_on_mr",
@@ -32,8 +41,8 @@
   "applicable_on_cumulative_expense",
   "action_if_annual_exceeded_on_cumulative_expense",
   "action_if_accumulated_monthly_exceeded_on_cumulative_expense",
-  "section_break_21",
-  "accounts"
+  "section_break_kkan",
+  "revision_of"
  ],
  "fields": [
   {
@@ -44,6 +53,7 @@
    "in_standard_filter": 1,
    "label": "Budget Against",
    "options": "\nCost Center\nProject",
+   "read_only_depends_on": "eval: doc.revision_of",
    "reqd": 1
   },
   {
@@ -53,6 +63,7 @@
    "in_standard_filter": 1,
    "label": "Company",
    "options": "Company",
+   "read_only_depends_on": "eval: doc.revision_of",
    "reqd": 1
   },
   {
@@ -62,7 +73,8 @@
    "in_global_search": 1,
    "in_standard_filter": 1,
    "label": "Cost Center",
-   "options": "Cost Center"
+   "options": "Cost Center",
+   "read_only_depends_on": "eval: doc.revision_of"
   },
   {
    "depends_on": "eval:doc.budget_against == 'Project'",
@@ -70,28 +82,13 @@
    "fieldtype": "Link",
    "in_standard_filter": 1,
    "label": "Project",
-   "options": "Project"
-  },
-  {
-   "fieldname": "fiscal_year",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "in_standard_filter": 1,
-   "label": "Fiscal Year",
-   "options": "Fiscal Year",
-   "reqd": 1
+   "options": "Project",
+   "read_only_depends_on": "eval: doc.revision_of"
   },
   {
    "fieldname": "column_break_3",
    "fieldtype": "Column Break"
   },
-  {
-   "depends_on": "eval:in_list([\"Stop\", \"Warn\"], doc.action_if_accumulated_monthly_budget_exceeded_on_po || doc.action_if_accumulated_monthly_budget_exceeded_on_mr || doc.action_if_accumulated_monthly_budget_exceeded_on_actual)",
-   "fieldname": "monthly_distribution",
-   "fieldtype": "Link",
-   "label": "Monthly Distribution",
-   "options": "Monthly Distribution"
-  },
   {
    "fieldname": "amended_from",
    "fieldtype": "Link",
@@ -187,22 +184,12 @@
    "options": "\nStop\nWarn\nIgnore"
   },
   {
-   "fieldname": "section_break_21",
-   "fieldtype": "Section Break"
-  },
-  {
-   "fieldname": "accounts",
-   "fieldtype": "Table",
-   "label": "Budget Accounts",
-   "options": "Budget Account",
-   "reqd": 1
-  },
-  {
+   "default": "BUDGET-.########",
    "fieldname": "naming_series",
    "fieldtype": "Select",
    "label": "Series",
    "no_copy": 1,
-   "options": "BUDGET-.YYYY.-",
+   "options": "BUDGET-.########",
    "print_hide": 1,
    "reqd": 1,
    "set_only_once": 1
@@ -232,13 +219,97 @@
    "fieldtype": "Select",
    "label": "Action if Accumulative Monthly Budget Exceeded on Cumulative Expense",
    "options": "\nStop\nWarn\nIgnore"
+  },
+  {
+   "fieldname": "section_break_fpdt",
+   "fieldtype": "Section Break"
+  },
+  {
+   "fieldname": "budget_distribution",
+   "fieldtype": "Table",
+   "label": "Budget Distribution",
+   "options": "Budget Distribution"
+  },
+  {
+   "fieldname": "account",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "Account",
+   "options": "Account",
+   "read_only_depends_on": "eval: doc.revision_of",
+   "reqd": 1
+  },
+  {
+   "fieldname": "budget_amount",
+   "fieldtype": "Currency",
+   "label": "Budget Amount",
+   "reqd": 1
+  },
+  {
+   "fieldname": "section_break_kkan",
+   "fieldtype": "Section Break"
+  },
+  {
+   "fieldname": "revision_of",
+   "fieldtype": "Data",
+   "label": "Revision Of",
+   "no_copy": 1,
+   "read_only": 1
+  },
+  {
+   "default": "1",
+   "fieldname": "distribute_equally",
+   "fieldtype": "Check",
+   "label": "Distribute Equally"
+  },
+  {
+   "fieldname": "section_break_nwug",
+   "fieldtype": "Section Break",
+   "hide_border": 1
+  },
+  {
+   "fieldname": "from_fiscal_year",
+   "fieldtype": "Link",
+   "label": "From Fiscal Year",
+   "options": "Fiscal Year",
+   "read_only_depends_on": "eval: doc.revision_of",
+   "reqd": 1
+  },
+  {
+   "fieldname": "to_fiscal_year",
+   "fieldtype": "Link",
+   "label": "To Fiscal Year",
+   "options": "Fiscal Year",
+   "read_only_depends_on": "eval: doc.revision_of",
+   "reqd": 1
+  },
+  {
+   "fieldname": "budget_start_date",
+   "fieldtype": "Date",
+   "hidden": 1,
+   "label": "Budget Start Date"
+  },
+  {
+   "fieldname": "budget_end_date",
+   "fieldtype": "Date",
+   "hidden": 1,
+   "label": "Budget End Date"
+  },
+  {
+   "default": "Monthly",
+   "fieldname": "distribution_frequency",
+   "fieldtype": "Select",
+   "label": "Distribution Frequency",
+   "options": "Monthly\nQuarterly\nHalf-Yearly\nYearly",
+   "read_only_depends_on": "eval: doc.revision_of",
+   "reqd": 1
   }
  ],
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-06-16 15:57:13.114981",
+ "modified": "2025-11-19 17:00:00.648224",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Budget",

erpnext/accounts/doctype/budget/budget.py

@@ -2,10 +2,14 @@
 # For license information, please see license.txt
 
 
+from datetime import date
+
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.utils import add_months, flt, fmt_money, get_last_day, getdate
+from frappe.query_builder.functions import Sum
+from frappe.utils import add_months, flt, fmt_money, get_last_day, getdate, month_diff
+from frappe.utils.data import get_first_day, nowdate
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
@@ -30,9 +34,9 @@ class Budget(Document):
 	if TYPE_CHECKING:
 		from frappe.types import DF
 
-		from erpnext.accounts.doctype.budget_account.budget_account import BudgetAccount
+		from erpnext.accounts.doctype.budget_distribution.budget_distribution import BudgetDistribution
 
-		accounts: DF.Table[BudgetAccount]
+		account: DF.Link
 		action_if_accumulated_monthly_budget_exceeded: DF.Literal["", "Stop", "Warn", "Ignore"]
 		action_if_accumulated_monthly_budget_exceeded_on_mr: DF.Literal["", "Stop", "Warn", "Ignore"]
 		action_if_accumulated_monthly_budget_exceeded_on_po: DF.Literal["", "Stop", "Warn", "Ignore"]
@@ -47,73 +51,117 @@ class Budget(Document):
 		applicable_on_material_request: DF.Check
 		applicable_on_purchase_order: DF.Check
 		budget_against: DF.Literal["", "Cost Center", "Project"]
+		budget_amount: DF.Currency
+		budget_distribution: DF.Table[BudgetDistribution]
+		budget_end_date: DF.Date | None
+		budget_start_date: DF.Date | None
 		company: DF.Link
 		cost_center: DF.Link | None
-		fiscal_year: DF.Link
-		monthly_distribution: DF.Link | None
-		naming_series: DF.Literal["BUDGET-.YYYY.-"]
+		distribute_equally: DF.Check
+		distribution_frequency: DF.Literal["Monthly", "Quarterly", "Half-Yearly", "Yearly"]
+		from_fiscal_year: DF.Link
+		naming_series: DF.Literal["BUDGET-.########"]
 		project: DF.Link | None
+		revision_of: DF.Data | None
+		to_fiscal_year: DF.Link
 	# end: auto-generated types
 
 	def validate(self):
 		if not self.get(frappe.scrub(self.budget_against)):
 			frappe.throw(_("{0} is mandatory").format(self.budget_against))
+		self.validate_budget_amount()
+		self.validate_fiscal_year()
+		self.set_fiscal_year_dates()
 		self.validate_duplicate()
-		self.validate_accounts()
+		self.validate_account()
 		self.set_null_value()
 		self.validate_applicable_for()
+		self.validate_existing_expenses()
+
+	def validate_budget_amount(self):
+		if self.budget_amount <= 0:
+			frappe.throw(_("Budget Amount can not be {0}.").format(self.budget_amount))
+
+	def validate_fiscal_year(self):
+		if self.from_fiscal_year:
+			self.validate_fiscal_year_company(self.from_fiscal_year, self.company)
+		if self.to_fiscal_year:
+			self.validate_fiscal_year_company(self.to_fiscal_year, self.company)
+
+	def validate_fiscal_year_company(self, fiscal_year, company):
+		linked_companies = frappe.get_all(
+			"Fiscal Year Company", filters={"parent": fiscal_year}, pluck="company"
+		)
+		if linked_companies and company not in linked_companies:
+			frappe.throw(_("Fiscal Year {0} is not available for Company {1}.").format(fiscal_year, company))
+
+	def set_fiscal_year_dates(self):
+		if self.from_fiscal_year:
+			self.budget_start_date = frappe.get_cached_value(
+				"Fiscal Year", self.from_fiscal_year, "year_start_date"
+			)
+		if self.to_fiscal_year:
+			self.budget_end_date = frappe.get_cached_value(
+				"Fiscal Year", self.to_fiscal_year, "year_end_date"
+			)
+
+		if self.budget_start_date > self.budget_end_date:
+			frappe.throw(_("From Fiscal Year cannot be greater than To Fiscal Year"))
 
 	def validate_duplicate(self):
 		budget_against_field = frappe.scrub(self.budget_against)
 		budget_against = self.get(budget_against_field)
+		account = self.account
+
+		if not account:
+			return
 
-		accounts = [d.account for d in self.accounts] or []
 		existing_budget = frappe.db.sql(
-			"""
-			select
-				b.name, ba.account from `tabBudget` b, `tabBudget Account` ba
-			where
-				ba.parent = b.name and b.docstatus < 2 and b.company = {} and {}={} and
-				b.fiscal_year={} and b.name != {} and ba.account in ({}) """.format(
-				"%s", budget_against_field, "%s", "%s", "%s", ",".join(["%s"] * len(accounts))
-			),
-			(self.company, budget_against, self.fiscal_year, self.name, *tuple(accounts)),
-			as_dict=1,
+			f"""
+			SELECT name, account
+			FROM `tabBudget`
+			WHERE
+				docstatus < 2
+				AND company = %s
+				AND {budget_against_field} = %s
+				AND account = %s
+				AND name != %s
+				AND (
+					(SELECT year_start_date FROM `tabFiscal Year` WHERE name = from_fiscal_year) <= %s
+					AND (SELECT year_end_date FROM `tabFiscal Year` WHERE name = to_fiscal_year) >= %s
+				)
+			""",
+			(self.company, budget_against, account, self.name, self.budget_end_date, self.budget_start_date),
+			as_dict=True,
 		)
 
-		for d in existing_budget:
+		if existing_budget:
+			d = existing_budget[0]
 			frappe.throw(
 				_(
-					"Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4}"
-				).format(d.name, self.budget_against, budget_against, d.account, self.fiscal_year),
+					"Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' with overlapping fiscal years."
+				).format(d.name, self.budget_against, budget_against, d.account),
 				DuplicateBudgetError,
 			)
 
-	def validate_accounts(self):
-		account_list = []
-		for d in self.get("accounts"):
-			if d.account:
-				account_details = frappe.get_cached_value(
-					"Account", d.account, ["is_group", "company", "report_type"], as_dict=1
+	def validate_account(self):
+		if not self.account:
+			frappe.throw(_("Account is mandatory"))
+
+		account_details = frappe.get_cached_value(
+			"Account", self.account, ["is_group", "company", "report_type"], as_dict=1
+		)
+
+		if account_details.is_group:
+			frappe.throw(_("Budget cannot be assigned against Group Account {0}").format(self.account))
+		elif account_details.company != self.company:
+			frappe.throw(_("Account {0} does not belong to company {1}").format(self.account, self.company))
+		elif account_details.report_type != "Profit and Loss":
+			frappe.throw(
+				_("Budget cannot be assigned against {0}, as it's not an Income or Expense account").format(
+					self.account
 				)
-
-				if account_details.is_group:
-					frappe.throw(_("Budget cannot be assigned against Group Account {0}").format(d.account))
-				elif account_details.company != self.company:
-					frappe.throw(
-						_("Account {0} does not belongs to company {1}").format(d.account, self.company)
-					)
-				elif account_details.report_type != "Profit and Loss":
-					frappe.throw(
-						_(
-							"Budget cannot be assigned against {0}, as it's not an Income or Expense account"
-						).format(d.account)
-					)
-
-				if d.account in account_list:
-					frappe.throw(_("Account {0} has been entered multiple times").format(d.account))
-				else:
-					account_list.append(d.account)
+			)
 
 	def set_null_value(self):
 		if self.budget_against == "Cost Center":
@@ -139,30 +187,201 @@ class Budget(Document):
 		):
 			self.applicable_on_booking_actual_expenses = 1
 
+	def validate_existing_expenses(self):
+		if self.is_new() and self.revision_of:
+			return
 
-def validate_expense_against_budget(args, expense_amount=0):
-	args = frappe._dict(args)
+		params = frappe._dict(
+			{
+				"company": self.company,
+				"account": self.account,
+				"budget_start_date": self.budget_start_date,
+				"budget_end_date": self.budget_end_date,
+				"budget_against_field": frappe.scrub(self.budget_against),
+				"budget_against_doctype": frappe.unscrub(self.budget_against),
+			}
+		)
+
+		params[params.budget_against_field] = self.get(params.budget_against_field)
+
+		if frappe.get_cached_value("DocType", params.budget_against_doctype, "is_tree"):
+			params.is_tree = True
+		else:
+			params.is_tree = False
+
+		actual_spent = get_actual_expense(params)
+
+		if actual_spent > self.budget_amount:
+			frappe.throw(
+				_(
+					"Spending for Account {0} ({1}) between {2} and {3} "
+					"has already exceeded the new allocated budget. "
+					"Spent: {4}, Budget: {5}"
+				).format(
+					frappe.bold(self.account),
+					frappe.bold(self.company),
+					frappe.bold(self.budget_start_date),
+					frappe.bold(self.budget_end_date),
+					frappe.bold(frappe.utils.fmt_money(actual_spent)),
+					frappe.bold(frappe.utils.fmt_money(self.budget_amount)),
+				),
+				title=_("Budget Limit Exceeded"),
+			)
+
+	def before_save(self):
+		self.allocate_budget()
+
+	def on_update(self):
+		self.validate_distribution_totals()
+
+	def allocate_budget(self):
+		if self.revision_of:
+			return
+
+		if not self.should_regenerate_budget_distribution():
+			return
+
+		self.set("budget_distribution", [])
+
+		periods = self.get_budget_periods()
+		total_periods = len(periods)
+		row_percent = 100 / total_periods if total_periods else 0
+
+		for start_date, end_date in periods:
+			row = self.append("budget_distribution", {})
+			row.start_date = start_date
+			row.end_date = end_date
+			self.add_allocated_amount(row, row_percent)
+
+	def should_regenerate_budget_distribution(self):
+		"""Check whether budget distribution should be recalculated."""
+		old_doc = self.get_doc_before_save() if not self.is_new() else None
+		if not old_doc or not self.budget_distribution:
+			return True
+
+		if old_doc:
+			changed_fields = [
+				"from_fiscal_year",
+				"to_fiscal_year",
+				"budget_amount",
+				"distribution_frequency",
+				"distribute_equally",
+			]
+			for field in changed_fields:
+				if old_doc.get(field) != self.get(field):
+					return True
+
+		return bool(self.distribute_equally)
+
+	def get_budget_periods(self):
+		"""Return list of (start_date, end_date) tuples based on frequency."""
+		frequency = self.distribution_frequency
+		periods = []
+
+		start_date = getdate(self.budget_start_date)
+		end_date = getdate(self.budget_end_date)
+
+		while start_date <= end_date:
+			period_start = get_first_day(start_date)
+			period_end = self.get_period_end(period_start, frequency)
+			period_end = min(period_end, end_date)
+
+			periods.append((period_start, period_end))
+			start_date = add_months(period_start, self.get_month_increment(frequency))
+
+		return periods
+
+	def get_period_end(self, start_date, frequency):
+		"""Return the correct end date for a given frequency."""
+		if frequency == "Monthly":
+			return get_last_day(start_date)
+		elif frequency == "Quarterly":
+			return get_last_day(add_months(start_date, 2))
+		elif frequency == "Half-Yearly":
+			return get_last_day(add_months(start_date, 5))
+		else:  # Yearly
+			return get_last_day(add_months(start_date, 11))
+
+	def get_month_increment(self, frequency):
+		"""Return how many months to move forward for the next period."""
+		return {
+			"Monthly": 1,
+			"Quarterly": 3,
+			"Half-Yearly": 6,
+			"Yearly": 12,
+		}.get(frequency, 1)
+
+	def add_allocated_amount(self, row, row_percent):
+		if not self.distribute_equally:
+			row.amount = 0
+			row.percent = 0
+		else:
+			row.amount = flt(self.budget_amount * row_percent / 100, 3)
+			row.percent = flt(row_percent, 3)
+
+	def validate_distribution_totals(self):
+		if self.should_regenerate_budget_distribution():
+			return
+
+		total_amount = sum(d.amount for d in self.budget_distribution)
+		total_percent = sum(d.percent for d in self.budget_distribution)
+
+		if flt(abs(total_amount - self.budget_amount), 2) > 0.10:
+			frappe.throw(
+				_("Total distributed amount {0} must be equal to Budget Amount {1}").format(
+					flt(total_amount, 2), self.budget_amount
+				)
+			)
+
+		if flt(abs(total_percent - 100), 2) > 0.10:
+			frappe.throw(
+				_("Total distribution percent must equal 100 (currently {0})").format(round(total_percent, 2))
+			)
+
+
+def validate_expense_against_budget(params, expense_amount=0):
+	params = frappe._dict(params)
 	if not frappe.db.count("Budget", cache=True):
 		return
 
-	if not args.fiscal_year:
-		args.fiscal_year = get_fiscal_year(args.get("posting_date"), company=args.get("company"))[0]
+	if not params.fiscal_year:
+		params.fiscal_year = get_fiscal_year(params.get("posting_date"), company=params.get("company"))[0]
 
-	if args.get("company"):
-		frappe.flags.exception_approver_role = frappe.get_cached_value(
-			"Company", args.get("company"), "exception_budget_approver_role"
-		)
+	posting_date = getdate(params.get("posting_date"))
+	posting_fiscal_year = get_fiscal_year(posting_date, company=params.get("company"))[0]
+	year_start_date, year_end_date = get_fiscal_year_date_range(posting_fiscal_year, posting_fiscal_year)
 
-	if not frappe.db.get_value("Budget", {"fiscal_year": args.fiscal_year, "company": args.company}):
+	budget_exists = frappe.db.sql(
+		"""
+		select name
+		from `tabBudget`
+		where company = %s
+		and docstatus = 1
+		and (SELECT year_start_date FROM `tabFiscal Year` WHERE name = from_fiscal_year) <= %s
+		and (SELECT year_end_date FROM `tabFiscal Year` WHERE name = to_fiscal_year) >= %s
+		limit 1
+		""",
+		(params.company, year_end_date, year_start_date),
+	)
+
+	if not budget_exists:
 		return
 
-	if not args.account:
-		args.account = args.get("expense_account")
+	if params.get("company"):
+		frappe.flags.exception_approver_role = frappe.get_cached_value(
+			"Company", params.get("company"), "exception_budget_approver_role"
+		)
 
-	if not (args.get("account") and args.get("cost_center")) and args.item_code:
-		args.cost_center, args.account = get_item_details(args)
+	if not params.account:
+		params.account = params.get("expense_account")
 
-	if not args.account:
+	if not params.get("expense_account") and params.get("account"):
+		params.expense_account = params.account
+
+	if not (params.get("account") and params.get("cost_center")) and params.item_code:
+		params.cost_center, params.account = get_item_details(params)
+
+	if not params.account:
 		return
 
 	default_dimensions = [
@@ -180,59 +399,78 @@ def validate_expense_against_budget(args, expense_amount=0):
 		budget_against = dimension.get("fieldname")
 
 		if (
-			args.get(budget_against)
-			and args.account
-			and (frappe.get_cached_value("Account", args.account, "root_type") == "Expense")
+			params.get(budget_against)
+			and params.account
+			and (frappe.get_cached_value("Account", params.account, "root_type") == "Expense")
 		):
 			doctype = dimension.get("document_type")
 
 			if frappe.get_cached_value("DocType", doctype, "is_tree"):
-				lft, rgt = frappe.get_cached_value(doctype, args.get(budget_against), ["lft", "rgt"])
+				lft, rgt = frappe.get_cached_value(doctype, params.get(budget_against), ["lft", "rgt"])
 				condition = f"""and exists(select name from `tab{doctype}`
 					where lft<={lft} and rgt>={rgt} and name=b.{budget_against})"""  # nosec
-				args.is_tree = True
+				params.is_tree = True
 			else:
-				condition = f"and b.{budget_against}={frappe.db.escape(args.get(budget_against))}"
-				args.is_tree = False
+				condition = f"and b.{budget_against}={frappe.db.escape(params.get(budget_against))}"
+				params.is_tree = False
 
-			args.budget_against_field = budget_against
-			args.budget_against_doctype = doctype
+			params.budget_against_field = budget_against
+			params.budget_against_doctype = doctype
 
 			budget_records = frappe.db.sql(
 				f"""
-				select
-					b.{budget_against} as budget_against, ba.budget_amount, b.monthly_distribution,
-					ifnull(b.applicable_on_material_request, 0) as for_material_request,
-					ifnull(applicable_on_purchase_order, 0) as for_purchase_order,
-					ifnull(applicable_on_booking_actual_expenses,0) as for_actual_expenses,
-					b.action_if_annual_budget_exceeded, b.action_if_accumulated_monthly_budget_exceeded,
-					b.action_if_annual_budget_exceeded_on_mr, b.action_if_accumulated_monthly_budget_exceeded_on_mr,
-					b.action_if_annual_budget_exceeded_on_po, b.action_if_accumulated_monthly_budget_exceeded_on_po
-				from
-					`tabBudget` b, `tabBudget Account` ba
-				where
-					b.name=ba.parent and b.fiscal_year=%s
-					and ba.account=%s and b.docstatus=1
+				SELECT
+					b.name,
+					b.{budget_against} AS budget_against,
+					b.budget_amount,
+					b.from_fiscal_year,
+					b.to_fiscal_year,
+					b.budget_start_date,
+					b.budget_end_date,
+					IFNULL(b.applicable_on_material_request, 0) AS for_material_request,
+					IFNULL(b.applicable_on_purchase_order, 0) AS for_purchase_order,
+					IFNULL(b.applicable_on_booking_actual_expenses, 0) AS for_actual_expenses,
+					b.action_if_annual_budget_exceeded,
+					b.action_if_accumulated_monthly_budget_exceeded,
+					b.action_if_annual_budget_exceeded_on_mr,
+					b.action_if_accumulated_monthly_budget_exceeded_on_mr,
+					b.action_if_annual_budget_exceeded_on_po,
+					b.action_if_accumulated_monthly_budget_exceeded_on_po
+				FROM
+					`tabBudget` b
+				WHERE
+					b.company = %s
+					AND b.docstatus = 1
+					AND %s BETWEEN b.budget_start_date AND b.budget_end_date
+					AND b.account = %s
 					{condition}
-			""",
-				(args.fiscal_year, args.account),
+				""",
+				(params.company, params.posting_date, params.account),
 				as_dict=True,
 			)  # nosec
 
 			if budget_records:
-				validate_budget_records(args, budget_records, expense_amount)
+				validate_budget_records(params, budget_records, expense_amount)
 
 
-def validate_budget_records(args, budget_records, expense_amount):
+def validate_budget_records(params, budget_records, expense_amount):
 	for budget in budget_records:
 		if flt(budget.budget_amount):
-			yearly_action, monthly_action = get_actions(args, budget)
-			args["for_material_request"] = budget.for_material_request
-			args["for_purchase_order"] = budget.for_purchase_order
+			yearly_action, monthly_action = get_actions(params, budget)
+			params["for_material_request"] = budget.for_material_request
+			params["for_purchase_order"] = budget.for_purchase_order
+			params["from_fiscal_year"], params["to_fiscal_year"] = (
+				budget.from_fiscal_year,
+				budget.to_fiscal_year,
+			)
+			params["budget_start_date"], params["budget_end_date"] = (
+				budget.budget_start_date,
+				budget.budget_end_date,
+			)
 
 			if yearly_action in ("Stop", "Warn"):
 				compare_expense_with_budget(
-					args,
+					params,
 					flt(budget.budget_amount),
 					_("Annual"),
 					yearly_action,
@@ -241,14 +479,12 @@ def validate_budget_records(args, budget_records, expense_amount):
 				)
 
 			if monthly_action in ["Stop", "Warn"]:
-				budget_amount = get_accumulated_monthly_budget(
-					budget.monthly_distribution, args.posting_date, args.fiscal_year, budget.budget_amount
-				)
+				budget_amount = get_accumulated_monthly_budget(budget.name, params.posting_date)
 
-				args["month_end_date"] = get_last_day(args.posting_date)
+				params["month_end_date"] = get_last_day(params.posting_date)
 
 				compare_expense_with_budget(
-					args,
+					params,
 					budget_amount,
 					_("Accumulated Monthly"),
 					monthly_action,
@@ -257,38 +493,41 @@ def validate_budget_records(args, budget_records, expense_amount):
 				)
 
 
-def compare_expense_with_budget(args, budget_amount, action_for, action, budget_against, amount=0):
-	args.actual_expense, args.requested_amount, args.ordered_amount = get_actual_expense(args), 0, 0
+def compare_expense_with_budget(params, budget_amount, action_for, action, budget_against, amount=0):
+	params.actual_expense, params.requested_amount, params.ordered_amount = get_actual_expense(params), 0, 0
 	if not amount:
-		args.requested_amount, args.ordered_amount = get_requested_amount(args), get_ordered_amount(args)
+		params.requested_amount, params.ordered_amount = (
+			get_requested_amount(params),
+			get_ordered_amount(params),
+		)
 
-		if args.get("doctype") == "Material Request" and args.for_material_request:
-			amount = args.requested_amount + args.ordered_amount
+		if params.get("doctype") == "Material Request" and params.for_material_request:
+			amount = params.requested_amount + params.ordered_amount
 
-		elif args.get("doctype") == "Purchase Order" and args.for_purchase_order:
-			amount = args.ordered_amount
+		elif params.get("doctype") == "Purchase Order" and params.for_purchase_order:
+			amount = params.ordered_amount
 
-	total_expense = args.actual_expense + amount
+	total_expense = params.actual_expense + amount
 
 	if total_expense > budget_amount:
-		if args.actual_expense > budget_amount:
-			diff = args.actual_expense - budget_amount
+		if params.actual_expense > budget_amount:
+			diff = params.actual_expense - budget_amount
 			_msg = _("{0} Budget for Account {1} against {2} {3} is {4}. It is already exceeded by {5}.")
 		else:
 			diff = total_expense - budget_amount
 			_msg = _("{0} Budget for Account {1} against {2} {3} is {4}. It will be exceeded by {5}.")
 
-		currency = frappe.get_cached_value("Company", args.company, "default_currency")
+		currency = frappe.get_cached_value("Company", params.company, "default_currency")
 		msg = _msg.format(
 			_(action_for),
-			frappe.bold(args.account),
-			frappe.unscrub(args.budget_against_field),
+			frappe.bold(params.account),
+			frappe.unscrub(params.budget_against_field),
 			frappe.bold(budget_against),
 			frappe.bold(fmt_money(budget_amount, currency=currency)),
 			frappe.bold(fmt_money(diff, currency=currency)),
 		)
 
-		msg += get_expense_breakup(args, currency, budget_against)
+		msg += get_expense_breakup(params, currency, budget_against)
 
 		if frappe.flags.exception_approver_role and frappe.flags.exception_approver_role in frappe.get_roles(
 			frappe.session.user
@@ -301,14 +540,25 @@ def compare_expense_with_budget(args, budget_amount, action_for, action, budget_
 			frappe.msgprint(msg, indicator="orange", title=_("Budget Exceeded"))
 
 
-def get_expense_breakup(args, currency, budget_against):
-	msg = "<hr> {{ _('Total Expenses booked through') }} - <ul>"
+def get_expense_breakup(params, currency, budget_against):
+	msg = "<hr> {} - <ul>".format(_("Total Expenses booked through"))
 
 	common_filters = frappe._dict(
 		{
-			args.budget_against_field: budget_against,
-			"account": args.account,
-			"company": args.company,
+			params.budget_against_field: budget_against,
+			"account": params.account,
+			"company": params.company,
+		}
+	)
+
+	from_date = frappe.get_cached_value("Fiscal Year", params.from_fiscal_year, "year_start_date")
+	to_date = frappe.get_cached_value("Fiscal Year", params.to_fiscal_year, "year_end_date")
+	gl_filters = common_filters.copy()
+	gl_filters.update(
+		{
+			"from_date": from_date,
+			"to_date": to_date,
+			"is_cancelled": 0,
 		}
 	)
 
@@ -317,18 +567,23 @@ def get_expense_breakup(args, currency, budget_against):
 		+ frappe.utils.get_link_to_report(
 			"General Ledger",
 			label=_("Actual Expenses"),
-			filters=common_filters.copy().update(
-				{
-					"from_date": frappe.get_cached_value("Fiscal Year", args.fiscal_year, "year_start_date"),
-					"to_date": frappe.get_cached_value("Fiscal Year", args.fiscal_year, "year_end_date"),
-					"is_cancelled": 0,
-				}
-			),
+			filters=gl_filters,
 		)
 		+ " - "
-		+ frappe.bold(fmt_money(args.actual_expense, currency=currency))
+		+ frappe.bold(fmt_money(params.actual_expense, currency=currency))
 		+ "</li>"
 	)
+	mr_filters = common_filters.copy()
+	mr_filters.update(
+		{
+			"status": [["!=", "Stopped"]],
+			"docstatus": 1,
+			"material_request_type": "Purchase",
+			"schedule_date": [["between", [from_date, to_date]]],
+			"item_code": params.item_code,
+			"per_ordered": [["<", 100]],
+		}
+	)
 
 	msg += (
 		"<li>"
@@ -337,22 +592,24 @@ def get_expense_breakup(args, currency, budget_against):
 			label=_("Material Requests"),
 			report_type="Report Builder",
 			doctype="Material Request",
-			filters=common_filters.copy().update(
-				{
-					"status": [["!=", "Stopped"]],
-					"docstatus": 1,
-					"material_request_type": "Purchase",
-					"schedule_date": [["fiscal year", "2023-2024"]],
-					"item_code": args.item_code,
-					"per_ordered": [["<", 100]],
-				}
-			),
+			filters=mr_filters,
 		)
 		+ " - "
-		+ frappe.bold(fmt_money(args.requested_amount, currency=currency))
+		+ frappe.bold(fmt_money(params.requested_amount, currency=currency))
 		+ "</li>"
 	)
 
+	po_filters = common_filters.copy()
+	po_filters.update(
+		{
+			"status": [["!=", "Closed"]],
+			"docstatus": 1,
+			"transaction_date": [["between", [from_date, to_date]]],
+			"item_code": params.item_code,
+			"per_billed": [["<", 100]],
+		}
+	)
+
 	msg += (
 		"<li>"
 		+ frappe.utils.get_link_to_report(
@@ -360,42 +617,34 @@ def get_expense_breakup(args, currency, budget_against):
 			label=_("Unbilled Orders"),
 			report_type="Report Builder",
 			doctype="Purchase Order",
-			filters=common_filters.copy().update(
-				{
-					"status": [["!=", "Closed"]],
-					"docstatus": 1,
-					"transaction_date": [["fiscal year", "2023-2024"]],
-					"item_code": args.item_code,
-					"per_billed": [["<", 100]],
-				}
-			),
+			filters=po_filters,
 		)
 		+ " - "
-		+ frappe.bold(fmt_money(args.ordered_amount, currency=currency))
+		+ frappe.bold(fmt_money(params.ordered_amount, currency=currency))
 		+ "</li></ul>"
 	)
 
 	return msg
 
 
-def get_actions(args, budget):
+def get_actions(params, budget):
 	yearly_action = budget.action_if_annual_budget_exceeded
 	monthly_action = budget.action_if_accumulated_monthly_budget_exceeded
 
-	if args.get("doctype") == "Material Request" and budget.for_material_request:
+	if params.get("doctype") == "Material Request" and budget.for_material_request:
 		yearly_action = budget.action_if_annual_budget_exceeded_on_mr
 		monthly_action = budget.action_if_accumulated_monthly_budget_exceeded_on_mr
 
-	elif args.get("doctype") == "Purchase Order" and budget.for_purchase_order:
+	elif params.get("doctype") == "Purchase Order" and budget.for_purchase_order:
 		yearly_action = budget.action_if_annual_budget_exceeded_on_po
 		monthly_action = budget.action_if_accumulated_monthly_budget_exceeded_on_po
 
 	return yearly_action, monthly_action
 
 
-def get_requested_amount(args):
-	item_code = args.get("item_code")
-	condition = get_other_condition(args, "Material Request")
+def get_requested_amount(params):
+	item_code = params.get("item_code")
+	condition = get_other_condition(params, "Material Request")
 
 	data = frappe.db.sql(
 		""" select ifnull((sum(child.stock_qty - child.ordered_qty) * rate), 0) as amount
@@ -409,9 +658,9 @@ def get_requested_amount(args):
 	return data[0][0] if data else 0
 
 
-def get_ordered_amount(args):
-	item_code = args.get("item_code")
-	condition = get_other_condition(args, "Purchase Order")
+def get_ordered_amount(params):
+	item_code = params.get("item_code")
+	condition = get_other_condition(params, "Purchase Order")
 
 	data = frappe.db.sql(
 		f""" select ifnull(sum(child.amount - child.billed_amt), 0) as amount
@@ -425,111 +674,102 @@ def get_ordered_amount(args):
 	return data[0][0] if data else 0
 
 
-def get_other_condition(args, for_doc):
-	condition = "expense_account = '%s'" % (args.expense_account)
-	budget_against_field = args.get("budget_against_field")
+def get_other_condition(params, for_doc):
+	condition = f"expense_account = '{params.expense_account}'"
+	budget_against_field = params.get("budget_against_field")
 
-	if budget_against_field and args.get(budget_against_field):
-		condition += f" and child.{budget_against_field} = '{args.get(budget_against_field)}'"
+	if budget_against_field and params.get(budget_against_field):
+		condition += f" and child.{budget_against_field} = '{params.get(budget_against_field)}'"
 
-	if args.get("fiscal_year"):
-		date_field = "schedule_date" if for_doc == "Material Request" else "transaction_date"
-		start_date, end_date = frappe.get_cached_value(
-			"Fiscal Year", args.get("fiscal_year"), ["year_start_date", "year_end_date"]
-		)
+	date_field = "schedule_date" if for_doc == "Material Request" else "transaction_date"
 
-		condition += f""" and parent.{date_field}
-			between '{start_date}' and '{end_date}' """
+	start_date = frappe.get_cached_value("Fiscal Year", params.from_fiscal_year, "year_start_date")
+	end_date = frappe.get_cached_value("Fiscal Year", params.to_fiscal_year, "year_end_date")
+
+	condition += f" and parent.{date_field} between '{start_date}' and '{end_date}'"
 
 	return condition
 
 
-def get_actual_expense(args):
-	if not args.budget_against_doctype:
-		args.budget_against_doctype = frappe.unscrub(args.budget_against_field)
+def get_actual_expense(params):
+	if not params.budget_against_doctype:
+		params.budget_against_doctype = frappe.unscrub(params.budget_against_field)
 
-	budget_against_field = args.get("budget_against_field")
-	condition1 = " and gle.posting_date <= %(month_end_date)s" if args.get("month_end_date") else ""
+	budget_against_field = params.get("budget_against_field")
+	condition1 = " and gle.posting_date <= %(month_end_date)s" if params.get("month_end_date") else ""
 
-	if args.is_tree:
+	date_condition = (
+		f"and gle.posting_date between '{params.budget_start_date}' and '{params.budget_end_date}'"
+	)
+
+	if params.is_tree:
 		lft_rgt = frappe.db.get_value(
-			args.budget_against_doctype, args.get(budget_against_field), ["lft", "rgt"], as_dict=1
+			params.budget_against_doctype, params.get(budget_against_field), ["lft", "rgt"], as_dict=1
 		)
+		params.update(lft_rgt)
 
-		args.update(lft_rgt)
-
-		condition2 = f"""and exists(select name from `tab{args.budget_against_doctype}`
-			where lft>=%(lft)s and rgt<=%(rgt)s
-			and name=gle.{budget_against_field})"""
+		condition2 = f"""
+			and exists(
+				select name from `tab{params.budget_against_doctype}`
+				where lft >= %(lft)s and rgt <= %(rgt)s
+				and name = gle.{budget_against_field}
+			)
+		"""
 	else:
-		condition2 = f"""and exists(select name from `tab{args.budget_against_doctype}`
-		where name=gle.{budget_against_field} and
-		gle.{budget_against_field} = %({budget_against_field})s)"""
+		condition2 = f"""
+			and gle.{budget_against_field} = %({budget_against_field})s
+		"""
 
 	amount = flt(
 		frappe.db.sql(
 			f"""
-		select sum(gle.debit) - sum(gle.credit)
-		from `tabGL Entry` gle
-		where
-			is_cancelled = 0
-			and gle.account=%(account)s
-			{condition1}
-			and gle.fiscal_year=%(fiscal_year)s
-			and gle.company=%(company)s
-			and gle.docstatus=1
-			{condition2}
-	""",
-			(args),
+				select sum(gle.debit) - sum(gle.credit)
+				from `tabGL Entry` gle
+				where
+					is_cancelled = 0
+					and gle.account = %(account)s
+					{condition1}
+					{date_condition}
+					and gle.company = %(company)s
+					and gle.docstatus = 1
+					{condition2}
+			""",
+			params,
 		)[0][0]
 	)  # nosec
 
 	return amount
 
 
-def get_accumulated_monthly_budget(monthly_distribution, posting_date, fiscal_year, annual_budget):
-	distribution = {}
-	if monthly_distribution:
-		mdp = frappe.qb.DocType("Monthly Distribution Percentage")
-		md = frappe.qb.DocType("Monthly Distribution")
+def get_accumulated_monthly_budget(budget_name, posting_date):
+	posting_date = getdate(posting_date)
 
-		res = (
-			frappe.qb.from_(mdp)
-			.join(md)
-			.on(mdp.parent == md.name)
-			.select(mdp.month, mdp.percentage_allocation)
-			.where(md.fiscal_year == fiscal_year)
-			.where(md.name == monthly_distribution)
-			.run(as_dict=True)
-		)
+	bd = frappe.qb.DocType("Budget Distribution")
+	b = frappe.qb.DocType("Budget")
 
-		for d in res:
-			distribution.setdefault(d.month, d.percentage_allocation)
+	result = (
+		frappe.qb.from_(bd)
+		.join(b)
+		.on(bd.parent == b.name)
+		.select(Sum(bd.amount).as_("accumulated_amount"))
+		.where(b.name == budget_name)
+		.where(bd.start_date <= posting_date)
+		.run(as_dict=True)
+	)
 
-	dt = frappe.get_cached_value("Fiscal Year", fiscal_year, "year_start_date")
-	accumulated_percentage = 0.0
-
-	while dt <= getdate(posting_date):
-		if monthly_distribution and distribution:
-			accumulated_percentage += distribution.get(getdate(dt).strftime("%B"), 0)
-		else:
-			accumulated_percentage += 100.0 / 12
-
-		dt = add_months(dt, 1)
-
-	return annual_budget * accumulated_percentage / 100
+	return flt(result[0]["accumulated_amount"]) if result else 0.0
 
 
-def get_item_details(args):
+def get_item_details(params):
 	cost_center, expense_account = None, None
 
-	if not args.get("company"):
+	if not params.get("company"):
 		return cost_center, expense_account
 
-	if args.item_code:
+	if params.item_code:
 		item_defaults = frappe.db.get_value(
 			"Item Default",
-			{"parent": args.item_code, "company": args.get("company")},
+			{"parent": params.item_code, "company": params.get("company")},
 			["buying_cost_center", "expense_account"],
 		)
 		if item_defaults:
@@ -537,7 +777,7 @@ def get_item_details(args):
 
 	if not (cost_center and expense_account):
 		for doctype in ["Item Group", "Company"]:
-			data = get_expense_cost_center(doctype, args)
+			data = get_expense_cost_center(doctype, params)
 
 			if not cost_center and data:
 				cost_center = data[0]
@@ -551,14 +791,39 @@ def get_item_details(args):
 	return cost_center, expense_account
 
 
-def get_expense_cost_center(doctype, args):
+def get_expense_cost_center(doctype, params):
 	if doctype == "Item Group":
 		return frappe.db.get_value(
 			"Item Default",
-			{"parent": args.get(frappe.scrub(doctype)), "company": args.get("company")},
+			{"parent": params.get(frappe.scrub(doctype)), "company": params.get("company")},
 			["buying_cost_center", "expense_account"],
 		)
 	else:
 		return frappe.db.get_value(
-			doctype, args.get(frappe.scrub(doctype)), ["cost_center", "default_expense_account"]
+			doctype, params.get(frappe.scrub(doctype)), ["cost_center", "default_expense_account"]
 		)
+
+
+def get_fiscal_year_date_range(from_fiscal_year, to_fiscal_year):
+	from_year = frappe.get_cached_value(
+		"Fiscal Year", from_fiscal_year, ["year_start_date", "year_end_date"], as_dict=True
+	)
+	to_year = frappe.get_cached_value(
+		"Fiscal Year", to_fiscal_year, ["year_start_date", "year_end_date"], as_dict=True
+	)
+	return from_year.year_start_date, to_year.year_end_date
+
+
+@frappe.whitelist()
+def revise_budget(budget_name):
+	old_budget = frappe.get_doc("Budget", budget_name)
+
+	if old_budget.docstatus == 1:
+		old_budget.cancel()
+
+	new_budget = frappe.copy_doc(old_budget)
+	new_budget.docstatus = 0
+	new_budget.revision_of = old_budget.name
+	new_budget.insert()
+
+	return new_budget.name

erpnext/accounts/doctype/budget/test_budget.py

@@ -3,12 +3,14 @@
 import unittest
 
 import frappe
-from frappe.utils import now_datetime, nowdate
+from frappe.client import submit
+from frappe.utils import add_days, flt, get_first_day, get_last_day, getdate, now_datetime, nowdate
 
 from erpnext.accounts.doctype.budget.budget import (
 	BudgetError,
 	get_accumulated_monthly_budget,
 	get_actual_expense,
+	revise_budget,
 )
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 from erpnext.accounts.utils import get_fiscal_year
@@ -25,11 +27,15 @@ class TestBudget(ERPNextTestSuite):
 
 	def setUp(self):
 		frappe.db.set_single_value("Accounts Settings", "use_legacy_budget_controller", False)
+		self.company = "_Test Company"
+		self.fiscal_year = frappe.db.get_value("Fiscal Year", {}, "name")
+		self.account = "_Test Account Cost for Goods Sold - _TC"
+		self.cost_center = "_Test Cost Center - _TC"
 
 	def test_monthly_budget_crossed_ignore(self):
 		set_total_expense_zero(nowdate(), "cost_center")
 
-		budget = make_budget(budget_against="Cost Center")
+		budget = make_budget(budget_against="Cost Center", do_not_save=False, submit_budget=True)
 
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
@@ -50,12 +56,13 @@ class TestBudget(ERPNextTestSuite):
 	def test_monthly_budget_crossed_stop1(self):
 		set_total_expense_zero(nowdate(), "cost_center")
 
-		budget = make_budget(budget_against="Cost Center")
+		budget = make_budget(budget_against="Cost Center", do_not_save=False, submit_budget=True)
 
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 
 		accumulated_limit = get_accumulated_monthly_budget(
-			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+			budget.name,
+			nowdate(),
 		)
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
@@ -73,13 +80,11 @@ class TestBudget(ERPNextTestSuite):
 	def test_exception_approver_role(self):
 		set_total_expense_zero(nowdate(), "cost_center")
 
-		budget = make_budget(budget_against="Cost Center")
+		budget = make_budget(budget_against="Cost Center", do_not_save=False, submit_budget=True)
 
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 
-		accumulated_limit = get_accumulated_monthly_budget(
-			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
-		)
+		accumulated_limit = get_accumulated_monthly_budget(budget.name, nowdate())
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
 			"_Test Bank - _TC",
@@ -107,16 +112,16 @@ class TestBudget(ERPNextTestSuite):
 			applicable_on_purchase_order=1,
 			action_if_accumulated_monthly_budget_exceeded_on_mr="Stop",
 			budget_against="Cost Center",
+			do_not_save=False,
+			submit_budget=True,
 		)
 
-		fiscal_year = get_fiscal_year(nowdate())[0]
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
-		frappe.db.set_value("Budget", budget.name, "fiscal_year", fiscal_year)
 
 		accumulated_limit = get_accumulated_monthly_budget(
-			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+			budget.name,
+			nowdate(),
 		)
-
 		mr = frappe.get_doc(
 			{
 				"doctype": "Material Request",
@@ -151,14 +156,15 @@ class TestBudget(ERPNextTestSuite):
 			applicable_on_purchase_order=1,
 			action_if_accumulated_monthly_budget_exceeded_on_po="Stop",
 			budget_against="Cost Center",
+			do_not_save=False,
+			submit_budget=True,
 		)
 
-		fiscal_year = get_fiscal_year(nowdate())[0]
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
-		frappe.db.set_value("Budget", budget.name, "fiscal_year", fiscal_year)
 
 		accumulated_limit = get_accumulated_monthly_budget(
-			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+			budget.name,
+			nowdate(),
 		)
 		po = create_purchase_order(
 			transaction_date=nowdate(), qty=1, rate=accumulated_limit + 1, do_not_submit=True
@@ -175,13 +181,14 @@ class TestBudget(ERPNextTestSuite):
 	def test_monthly_budget_crossed_stop2(self):
 		set_total_expense_zero(nowdate(), "project")
 
-		budget = make_budget(budget_against="Project")
+		budget = make_budget(budget_against="Project", do_not_save=False, submit_budget=True)
 
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 
 		project = frappe.get_value("Project", {"project_name": "_Test Project"})
 		accumulated_limit = get_accumulated_monthly_budget(
-			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+			budget.name,
+			nowdate(),
 		)
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
@@ -200,7 +207,7 @@ class TestBudget(ERPNextTestSuite):
 	def test_yearly_budget_crossed_stop1(self):
 		set_total_expense_zero(nowdate(), "cost_center")
 
-		budget = make_budget(budget_against="Cost Center")
+		budget = make_budget(budget_against="Cost Center", do_not_save=False, submit_budget=True)
 
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
@@ -217,7 +224,7 @@ class TestBudget(ERPNextTestSuite):
 	def test_yearly_budget_crossed_stop2(self):
 		set_total_expense_zero(nowdate(), "project")
 
-		budget = make_budget(budget_against="Project")
+		budget = make_budget(budget_against="Project", do_not_save=False, submit_budget=True)
 
 		project = frappe.get_value("Project", {"project_name": "_Test Project"})
 
@@ -237,7 +244,7 @@ class TestBudget(ERPNextTestSuite):
 	def test_monthly_budget_on_cancellation1(self):
 		set_total_expense_zero(nowdate(), "cost_center")
 
-		budget = make_budget(budget_against="Cost Center")
+		budget = make_budget(budget_against="Cost Center", do_not_save=False, submit_budget=True)
 		month = now_datetime().month
 		if month > 9:
 			month = 9
@@ -266,7 +273,7 @@ class TestBudget(ERPNextTestSuite):
 	def test_monthly_budget_on_cancellation2(self):
 		set_total_expense_zero(nowdate(), "project")
 
-		budget = make_budget(budget_against="Project")
+		budget = make_budget(budget_against="Project", do_not_save=False, submit_budget=True)
 		month = now_datetime().month
 		if month > 9:
 			month = 9
@@ -298,11 +305,17 @@ class TestBudget(ERPNextTestSuite):
 		set_total_expense_zero(nowdate(), "cost_center")
 		set_total_expense_zero(nowdate(), "cost_center", "_Test Cost Center 2 - _TC")
 
-		budget = make_budget(budget_against="Cost Center", cost_center="_Test Company - _TC")
+		budget = make_budget(
+			budget_against="Cost Center",
+			cost_center="_Test Company - _TC",
+			do_not_save=False,
+			submit_budget=True,
+		)
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 
 		accumulated_limit = get_accumulated_monthly_budget(
-			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+			budget.name,
+			nowdate(),
 		)
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
@@ -331,11 +344,14 @@ class TestBudget(ERPNextTestSuite):
 				}
 			).insert(ignore_permissions=True)
 
-		budget = make_budget(budget_against="Cost Center", cost_center=cost_center)
+		budget = make_budget(
+			budget_against="Cost Center", cost_center=cost_center, do_not_save=False, submit_budget=True
+		)
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 
 		accumulated_limit = get_accumulated_monthly_budget(
-			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+			budget.name,
+			nowdate(),
 		)
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
@@ -372,7 +388,12 @@ class TestBudget(ERPNextTestSuite):
 			{"Sub Budget Cost Center 1 - _TC": 60, "Sub Budget Cost Center 2 - _TC": 40},
 		)
 
-		make_budget(budget_against="Cost Center", cost_center="Main Budget Cost Center 1 - _TC")
+		make_budget(
+			budget_against="Cost Center",
+			cost_center="Main Budget Cost Center 1 - _TC",
+			do_not_save=False,
+			submit_budget=True,
+		)
 
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
@@ -387,12 +408,15 @@ class TestBudget(ERPNextTestSuite):
 	def test_action_for_cumulative_limit(self):
 		set_total_expense_zero(nowdate(), "cost_center")
 
-		budget = make_budget(budget_against="Cost Center", applicable_on_cumulative_expense=True)
-
-		accumulated_limit = get_accumulated_monthly_budget(
-			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+		budget = make_budget(
+			budget_against="Cost Center",
+			applicable_on_cumulative_expense=True,
+			do_not_save=False,
+			submit_budget=True,
 		)
 
+		accumulated_limit = get_accumulated_monthly_budget(budget.name, nowdate())
+
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
 			"_Test Bank - _TC",
@@ -422,6 +446,165 @@ class TestBudget(ERPNextTestSuite):
 		po.cancel()
 		jv.cancel()
 
+	def test_fiscal_year_validation(self):
+		frappe.get_doc(
+			{
+				"doctype": "Fiscal Year",
+				"year": "2100",
+				"year_start_date": "2100-04-01",
+				"year_end_date": "2101-03-31",
+				"companies": [{"company": "_Test Company"}],
+			}
+		).insert(ignore_permissions=True)
+
+		budget = make_budget(
+			budget_against="Cost Center",
+			from_fiscal_year="2100",
+			to_fiscal_year="2099",
+			do_not_save=True,
+			submit_budget=False,
+		)
+
+		with self.assertRaises(frappe.ValidationError):
+			budget.save()
+
+	def test_total_distribution_equals_budget(self):
+		budget = make_budget(
+			budget_against="Cost Center",
+			applicable_on_cumulative_expense=True,
+			distribute_equally=0,
+			budget_amount=12000,
+			do_not_save=False,
+			submit_budget=False,
+		)
+
+		for row in budget.budget_distribution:
+			row.amount = 2000
+
+		with self.assertRaises(frappe.ValidationError):
+			budget.save()
+
+	def test_evenly_distribute_budget(self):
+		budget = make_budget(
+			budget_against="Cost Center", budget_amount=120000, do_not_save=False, submit_budget=True
+		)
+
+		total = sum([d.amount for d in budget.budget_distribution])
+		self.assertEqual(flt(total), 120000)
+		self.assertTrue(all(d.amount == 10000 for d in budget.budget_distribution))
+
+	def test_create_revised_budget(self):
+		budget = make_budget(
+			budget_against="Cost Center", budget_amount=120000, do_not_save=False, submit_budget=True
+		)
+
+		revised_name = revise_budget(budget.name)
+
+		revised_budget = frappe.get_doc("Budget", revised_name)
+		self.assertNotEqual(budget.name, revised_budget.name)
+		self.assertEqual(revised_budget.budget_against, budget.budget_against)
+		self.assertEqual(revised_budget.budget_amount, budget.budget_amount)
+
+		old_budget = frappe.get_doc("Budget", budget.name)
+		self.assertEqual(old_budget.docstatus, 2)
+
+	def test_revision_preserves_distribution(self):
+		set_total_expense_zero(nowdate(), "cost_center", "_Test Cost Center - _TC")
+		budget = make_budget(
+			budget_against="Cost Center", budget_amount=120000, do_not_save=False, submit_budget=True
+		)
+
+		revised_name = revise_budget(budget.name)
+		revised_budget = frappe.get_doc("Budget", revised_name)
+
+		self.assertGreater(len(revised_budget.budget_distribution), 0)
+
+		total = sum(row.amount for row in revised_budget.budget_distribution)
+		self.assertEqual(total, revised_budget.budget_amount)
+
+	def test_manual_budget_amount_total(self):
+		budget = make_budget(
+			budget_against="Cost Center",
+			distribute_equally=0,
+			budget_amount=30000,
+			budget_start_date="2025-04-01",
+			budget_end_date="2025-06-30",
+			do_not_save=False,
+			submit_budget=False,
+		)
+
+		budget.budget_distribution = []
+
+		for row in [
+			{"start_date": "2025-04-01", "end_date": "2025-04-30", "amount": 10000, "percent": 33.33},
+			{"start_date": "2025-05-01", "end_date": "2025-05-31", "amount": 15000, "percent": 50.00},
+			{"start_date": "2025-06-01", "end_date": "2025-06-30", "amount": 5000, "percent": 16.67},
+		]:
+			budget.append("budget_distribution", row)
+
+		budget.save()
+
+		total_child_amount = sum(row.amount for row in budget.budget_distribution)
+
+		self.assertEqual(total_child_amount, budget.budget_amount)
+
+	def test_fiscal_year_company_mismatch(self):
+		budget = make_budget(budget_against="Cost Center", do_not_save=True, submit_budget=False)
+
+		fy = frappe.get_doc(
+			{
+				"doctype": "Fiscal Year",
+				"year": "2099",
+				"year_start_date": "2099-04-01",
+				"year_end_date": "2100-03-31",
+				"companies": [{"company": "_Test Company 2"}],
+			}
+		).insert(ignore_permissions=True)
+
+		budget.from_fiscal_year = fy.name
+		budget.to_fiscal_year = fy.name
+		budget.company = "_Test Company"
+
+		with self.assertRaises(frappe.ValidationError):
+			budget.save()
+
+	def test_manual_distribution_total_equals_budget_amount(self):
+		budget = make_budget(
+			budget_against="Cost Center",
+			cost_center="_Test Cost Center - _TC",
+			distribute_equally=0,
+			budget_amount=12000,
+			do_not_save=False,
+			submit_budget=False,
+		)
+
+		for d in budget.budget_distribution:
+			d.amount = 2000
+
+		with self.assertRaises(frappe.ValidationError):
+			budget.save()
+
+	def test_duplicate_budget_validation(self):
+		budget = make_budget(
+			budget_against="Cost Center",
+			distribute_equally=1,
+			budget_amount=15000,
+			do_not_save=False,
+			submit_budget=True,
+		)
+
+		new_budget = frappe.new_doc("Budget")
+		new_budget.company = "_Test Company"
+		new_budget.from_fiscal_year = budget.from_fiscal_year
+		new_budget.to_fiscal_year = new_budget.from_fiscal_year
+		new_budget.budget_against = "Cost Center"
+		new_budget.cost_center = "_Test Cost Center - _TC"
+		new_budget.account = "_Test Account Cost for Goods Sold - _TC"
+		new_budget.budget_amount = 10000
+
+		with self.assertRaises(frappe.ValidationError):
+			new_budget.insert()
+
 
 def set_total_expense_zero(posting_date, budget_against_field=None, budget_against_CC=None):
 	if budget_against_field == "project":
@@ -430,21 +613,32 @@ def set_total_expense_zero(posting_date, budget_against_field=None, budget_again
 		budget_against = budget_against_CC or "_Test Cost Center - _TC"
 
 	fiscal_year = get_fiscal_year(nowdate())[0]
+	fiscal_year_start_date, fiscal_year_end_date = get_fiscal_year(nowdate())[1:3]
 
 	args = frappe._dict(
 		{
 			"account": "_Test Account Cost for Goods Sold - _TC",
 			"cost_center": "_Test Cost Center - _TC",
-			"monthly_end_date": posting_date,
+			"month_end_date": posting_date,
 			"company": "_Test Company",
-			"fiscal_year": fiscal_year,
+			"from_fiscal_year": fiscal_year,
+			"to_fiscal_year": fiscal_year,
 			"budget_against_field": budget_against_field,
+			"budget_start_date": fiscal_year_start_date,
+			"budget_end_date": fiscal_year_end_date,
 		}
 	)
 
 	if not args.get(budget_against_field):
 		args[budget_against_field] = budget_against
 
+	args.budget_against_doctype = frappe.unscrub(budget_against_field)
+
+	if frappe.get_cached_value("DocType", args.budget_against_doctype, "is_tree"):
+		args.is_tree = True
+	else:
+		args.is_tree = False
+
 	existing_expense = get_actual_expense(args)
 
 	if existing_expense:
@@ -474,18 +668,33 @@ def make_budget(**args):
 
 	budget_against = args.budget_against
 	cost_center = args.cost_center
-
 	fiscal_year = get_fiscal_year(nowdate())[0]
 
 	if budget_against == "Project":
-		project_name = "{}%".format("_Test Project/" + fiscal_year)
-		budget_list = frappe.get_all("Budget", fields=["name"], filters={"name": ("like", project_name)})
+		project = frappe.get_value("Project", {"project_name": "_Test Project"})
+		budget_list = frappe.get_all(
+			"Budget",
+			filters={
+				"project": project,
+				"account": "_Test Account Cost for Goods Sold - _TC",
+			},
+			pluck="name",
+		)
 	else:
-		cost_center_name = "{}%".format(cost_center or "_Test Cost Center - _TC/" + fiscal_year)
-		budget_list = frappe.get_all("Budget", fields=["name"], filters={"name": ("like", cost_center_name)})
-	for d in budget_list:
-		frappe.db.sql("delete from `tabBudget` where name = %(name)s", d)
-		frappe.db.sql("delete from `tabBudget Account` where parent = %(name)s", d)
+		budget_list = frappe.get_all(
+			"Budget",
+			filters={
+				"cost_center": cost_center or "_Test Cost Center - _TC",
+				"account": "_Test Account Cost for Goods Sold - _TC",
+			},
+			pluck="name",
+		)
+
+	for name in budget_list:
+		doc = frappe.get_doc("Budget", name)
+		if doc.docstatus == 1:
+			doc.cancel()
+		frappe.delete_doc("Budget", name, force=True, ignore_missing=True)
 
 	budget = frappe.new_doc("Budget")
 
@@ -494,18 +703,18 @@ def make_budget(**args):
 	else:
 		budget.cost_center = cost_center or "_Test Cost Center - _TC"
 
-	monthly_distribution = frappe.get_doc("Monthly Distribution", "_Test Distribution")
-	monthly_distribution.fiscal_year = fiscal_year
-	monthly_distribution.save()
-
-	budget.fiscal_year = fiscal_year
-	budget.monthly_distribution = "_Test Distribution"
+	budget.from_fiscal_year = args.from_fiscal_year or fiscal_year
+	budget.to_fiscal_year = args.to_fiscal_year or fiscal_year
 	budget.company = "_Test Company"
+	budget.account = "_Test Account Cost for Goods Sold - _TC"
+	budget.budget_amount = args.budget_amount or 200000
 	budget.applicable_on_booking_actual_expenses = 1
 	budget.action_if_annual_budget_exceeded = "Stop"
 	budget.action_if_accumulated_monthly_budget_exceeded = "Ignore"
 	budget.budget_against = budget_against
-	budget.append("accounts", {"account": "_Test Account Cost for Goods Sold - _TC", "budget_amount": 200000})
+
+	budget.distribution_frequency = "Monthly"
+	budget.distribute_equally = args.get("distribute_equally", 1)
 
 	if args.applicable_on_material_request:
 		budget.applicable_on_material_request = 1
@@ -530,7 +739,13 @@ def make_budget(**args):
 			args.action_if_accumulated_monthly_exceeded_on_cumulative_expense or "Warn"
 		)
 
-	budget.insert()
-	budget.submit()
+	if not args.do_not_save:
+		try:
+			budget.insert(ignore_if_duplicate=True)
+		except frappe.DuplicateEntryError:
+			pass
+
+	if args.submit_budget:
+		budget.submit()
 
 	return budget

erpnext/accounts/doctype/budget_distribution/budget_distribution.json

@@ -0,0 +1,58 @@
+{
+ "actions": [],
+ "allow_rename": 1,
+ "creation": "2025-10-12 23:31:03.841996",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "start_date",
+  "end_date",
+  "amount",
+  "percent"
+ ],
+ "fields": [
+  {
+   "fieldname": "start_date",
+   "fieldtype": "Date",
+   "in_list_view": 1,
+   "label": "Start Date",
+   "read_only": 1,
+   "search_index": 1
+  },
+  {
+   "fieldname": "end_date",
+   "fieldtype": "Date",
+   "in_list_view": 1,
+   "label": "End Date",
+   "read_only": 1
+  },
+  {
+   "fieldname": "amount",
+   "fieldtype": "Currency",
+   "in_list_view": 1,
+   "label": "Amount"
+  },
+  {
+   "fieldname": "percent",
+   "fieldtype": "Percent",
+   "in_list_view": 1,
+   "label": "Percent"
+  }
+ ],
+ "grid_page_length": 50,
+ "index_web_pages_for_search": 1,
+ "istable": 1,
+ "links": [],
+ "modified": "2025-11-03 13:18:28.398198",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Budget Distribution",
+ "owner": "Administrator",
+ "permissions": [],
+ "row_format": "Dynamic",
+ "rows_threshold_for_grid_search": 20,
+ "sort_field": "creation",
+ "sort_order": "DESC",
+ "states": []
+}

erpnext/accounts/doctype/budget_distribution/budget_distribution.py

@@ -0,0 +1,26 @@
+# Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+# import frappe
+from frappe.model.document import Document
+
+
+class BudgetDistribution(Document):
+	# begin: auto-generated types
+	# This code is auto-generated. Do not modify anything in this block.
+
+	from typing import TYPE_CHECKING
+
+	if TYPE_CHECKING:
+		from frappe.types import DF
+
+		amount: DF.Currency
+		end_date: DF.Date | None
+		parent: DF.Data
+		parentfield: DF.Data
+		parenttype: DF.Data
+		percent: DF.Percent
+		start_date: DF.Date | None
+	# end: auto-generated types
+
+	pass

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.js

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

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.json

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

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.py

@@ -29,7 +29,7 @@ class CurrencyExchangeSettings(Document):
 		disabled: DF.Check
 		req_params: DF.Table[CurrencyExchangeSettingsDetails]
 		result_key: DF.Table[CurrencyExchangeSettingsResult]
-		service_provider: DF.Literal["frankfurter.app", "exchangerate.host", "Custom"]
+		service_provider: DF.Literal["frankfurter.dev", "exchangerate.host", "Custom"]
 		url: DF.Data | None
 		use_http: DF.Check
 	# end: auto-generated types
@@ -60,7 +60,7 @@ class CurrencyExchangeSettings(Document):
 			self.append("req_params", {"key": "date", "value": "{transaction_date}"})
 			self.append("req_params", {"key": "from", "value": "{from_currency}"})
 			self.append("req_params", {"key": "to", "value": "{to_currency}"})
-		elif self.service_provider == "frankfurter.app":
+		elif self.service_provider == "frankfurter.dev":
 			self.set("result_key", [])
 			self.set("req_params", [])
 
@@ -105,11 +105,11 @@ class CurrencyExchangeSettings(Document):
 
 @frappe.whitelist()
 def get_api_endpoint(service_provider: str | None = None, use_http: bool = False):
-	if service_provider and service_provider in ["exchangerate.host", "frankfurter.app"]:
+	if service_provider and service_provider in ["exchangerate.host", "frankfurter.dev"]:
 		if service_provider == "exchangerate.host":
 			api = "api.exchangerate.host/convert"
-		elif service_provider == "frankfurter.app":
-			api = "api.frankfurter.app/{transaction_date}"
+		elif service_provider == "frankfurter.dev":
+			api = "api.frankfurter.dev/v1/{transaction_date}"
 
 		protocol = "https://"
 		if use_http:

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -252,7 +252,7 @@ class ExchangeRateRevaluation(Document):
 		company_currency = erpnext.get_company_currency(company)
 		precision = get_field_precision(
 			frappe.get_meta("Exchange Rate Revaluation Account").get_field("new_balance_in_base_currency"),
-			company_currency,
+			currency=company_currency,
 		)
 
 		if account_details:

erpnext/accounts/doctype/exchange_rate_revaluation/test_exchange_rate_revaluation.py

@@ -3,6 +3,8 @@
 
 
 import frappe
+from frappe.query_builder import functions
+from frappe.query_builder.utils import DocType
 from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, flt, today
 
@@ -81,10 +83,11 @@ class TestExchangeRateRevaluation(AccountsTestMixin, IntegrationTestCase):
 		self.assertEqual(je.total_debit, 8500.0)
 		self.assertEqual(je.total_credit, 8500.0)
 
+		gl = DocType("GL Entry")
 		acc_balance = frappe.db.get_all(
 			"GL Entry",
 			filters={"account": self.debtors_usd, "is_cancelled": 0},
-			fields=["sum(debit)-sum(credit) as balance"],
+			fields=[(functions.Sum(gl.debit) - functions.Sum(gl.credit)).as_("balance")],
 		)[0]
 		self.assertEqual(acc_balance.balance, 8500.0)
 
@@ -146,12 +149,15 @@ class TestExchangeRateRevaluation(AccountsTestMixin, IntegrationTestCase):
 		self.assertEqual(je.total_debit, 500.0)
 		self.assertEqual(je.total_credit, 500.0)
 
+		gl = DocType("GL Entry")
 		acc_balance = frappe.db.get_all(
 			"GL Entry",
 			filters={"account": self.debtors_usd, "is_cancelled": 0},
 			fields=[
-				"sum(debit)-sum(credit) as balance",
-				"sum(debit_in_account_currency)-sum(credit_in_account_currency) as balance_in_account_currency",
+				(functions.Sum(gl.debit) - functions.Sum(gl.credit)).as_("balance"),
+				(
+					functions.Sum(gl.debit_in_account_currency) - functions.Sum(gl.credit_in_account_currency)
+				).as_("balance_in_account_currency"),
 			],
 		)[0]
 		# account shouldn't have balance in base and account currency
@@ -193,12 +199,15 @@ class TestExchangeRateRevaluation(AccountsTestMixin, IntegrationTestCase):
 		pe.references = []
 		pe.save().submit()
 
+		gl = DocType("GL Entry")
 		acc_balance = frappe.db.get_all(
 			"GL Entry",
 			filters={"account": self.debtors_usd, "is_cancelled": 0},
 			fields=[
-				"sum(debit)-sum(credit) as balance",
-				"sum(debit_in_account_currency)-sum(credit_in_account_currency) as balance_in_account_currency",
+				(functions.Sum(gl.debit) - functions.Sum(gl.credit)).as_("balance"),
+				(
+					functions.Sum(gl.debit_in_account_currency) - functions.Sum(gl.credit_in_account_currency)
+				).as_("balance_in_account_currency"),
 			],
 		)[0]
 		# account should have balance only in account currency
@@ -235,12 +244,15 @@ class TestExchangeRateRevaluation(AccountsTestMixin, IntegrationTestCase):
 		self.assertEqual(flt(je.total_debit, precision), 0.0)
 		self.assertEqual(flt(je.total_credit, precision), 0.0)
 
+		gl = DocType("GL Entry")
 		acc_balance = frappe.db.get_all(
 			"GL Entry",
 			filters={"account": self.debtors_usd, "is_cancelled": 0},
 			fields=[
-				"sum(debit)-sum(credit) as balance",
-				"sum(debit_in_account_currency)-sum(credit_in_account_currency) as balance_in_account_currency",
+				(functions.Sum(gl.debit) - functions.Sum(gl.credit)).as_("balance"),
+				(
+					functions.Sum(gl.debit_in_account_currency) - functions.Sum(gl.credit_in_account_currency)
+				).as_("balance_in_account_currency"),
 			],
 		)[0]
 		# account shouldn't have balance in base and account currency post revaluation

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -100,7 +100,7 @@ class GLEntry(Document):
 			self.validate_account_details(adv_adj)
 			self.validate_dimensions_for_pl_and_bs()
 			validate_balance_type(self.account, adv_adj)
-			validate_frozen_account(self.account, adv_adj)
+			validate_frozen_account(self.company, self.account, adv_adj)
 
 			if (
 				self.voucher_type == "Journal Entry"
@@ -276,7 +276,7 @@ class GLEntry(Document):
 			)
 
 	def validate_party(self):
-		validate_party_frozen_disabled(self.party_type, self.party)
+		validate_party_frozen_disabled(self.company, self.party_type, self.party)
 		validate_account_party_type(self)
 
 	def validate_currency(self):
@@ -419,16 +419,16 @@ def update_outstanding_amt(
 		ref_doc.set_status(update=True)
 
 
-def validate_frozen_account(account, adv_adj=None):
+def validate_frozen_account(company, account, adv_adj=None):
 	frozen_account = frappe.get_cached_value("Account", account, "freeze_account")
 	if frozen_account == "Yes" and not adv_adj:
-		frozen_accounts_modifier = frappe.get_cached_value(
-			"Accounts Settings", None, "frozen_accounts_modifier"
+		role_allowed_for_frozen_entries = frappe.get_cached_value(
+			"Company", company, "role_allowed_for_frozen_entries"
 		)
 
-		if not frozen_accounts_modifier:
+		if not role_allowed_for_frozen_entries:
 			frappe.throw(_("Account {0} is frozen").format(account))
-		elif frozen_accounts_modifier not in frappe.get_roles():
+		elif role_allowed_for_frozen_entries not in frappe.get_roles():
 			frappe.throw(_("Not authorized to edit frozen Account {0}").format(account))
 
 
@@ -442,7 +442,7 @@ def update_against_account(voucher_type, voucher_no):
 	if not entries:
 		return
 	company_currency = erpnext.get_company_currency(entries[0].company)
-	precision = get_field_precision(frappe.get_meta("GL Entry").get_field("debit"), company_currency)
+	precision = get_field_precision(frappe.get_meta("GL Entry").get_field("debit"), currency=company_currency)
 
 	accounts_debited, accounts_credited = [], []
 	for d in entries:

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -720,6 +720,8 @@ $.extend(erpnext.journal_entry, {
 					}
 				},
 			});
+		} else {
+			erpnext.journal_entry.clear_fields(frm, dt, dn);
 		}
 	},
 	set_amount_on_last_row: function (frm, dt, dn) {
@@ -744,4 +746,13 @@ $.extend(erpnext.journal_entry, {
 		}
 		refresh_field("accounts");
 	},
+	clear_fields: function (frm, dt, dn) {
+		let row = locals[dt][dn];
+
+		row.party_type = null;
+		row.party = null;
+		row.bank_account = null;
+
+		frm.refresh_field("accounts");
+	},
 });

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -453,7 +453,7 @@ class JournalEntry(AccountsController):
 			if (
 				d.reference_type == "Asset"
 				and d.reference_name
-				and d.account_type == "Depreciation"
+				and frappe.get_cached_value("Account", d.account, "root_type") == "Expense"
 				and d.debit
 			):
 				asset = frappe.get_cached_doc("Asset", d.reference_name)
@@ -1719,6 +1719,9 @@ def get_account_details_and_party_type(account, date, company, debit=None, credi
 		"party_type": party_type,
 		"account_type": account_details.account_type,
 		"account_currency": account_details.account_currency or company_currency,
+		"bank_account": (
+			frappe.db.get_value("Bank Account", {"account": account, "company": company}) or None
+		),
 		# The date used to retreive the exchange rate here is the date passed in
 		# as an argument to this function. It is assumed to be the date on which the balance is sought
 		"exchange_rate": get_exchange_rate(

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py

@@ -71,8 +71,8 @@ class OpeningInvoiceCreationTool(Document):
 		max_count = {}
 		fields = [
 			"company",
-			"count(name) as total_invoices",
-			"sum(outstanding_amount) as outstanding_amount",
+			{"COUNT": "*", "as": "total_invoices"},
+			{"SUM": "outstanding_amount", "as": "outstanding_amount"},
 		]
 		companies = frappe.get_all("Company", fields=["name as company", "default_currency as currency"])
 		if not companies:

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -1874,7 +1874,7 @@ class PaymentEntry(AccountsController):
 				else:
 					self.total_taxes_and_charges += current_tax_amount
 
-			self.base_total_taxes_and_charges += tax.base_tax_amount
+			self.base_total_taxes_and_charges += current_tax_amount
 
 		if self.get("taxes"):
 			self.paid_amount_after_tax = self.get("taxes")[-1].base_total

erpnext/accounts/doctype/payment_ledger_entry/payment_ledger_entry.py

@@ -159,7 +159,7 @@ class PaymentLedgerEntry(Document):
 	def on_update(self):
 		adv_adj = self.flags.adv_adj
 		if not self.flags.from_repost:
-			validate_frozen_account(self.account, adv_adj)
+			validate_frozen_account(self.company, self.account, adv_adj)
 			if not self.delinked:
 				self.validate_account_details()
 				self.validate_dimensions_for_pl_and_bs()

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js

@@ -334,7 +334,9 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 					},
 					{
 						fieldtype: "HTML",
-						options: "<b> New Journal Entry will be posted for the difference amount </b>",
+						options: __(
+							"New Journal Entry will be posted for the difference amount. The Posting Date can be modified."
+						).bold(),
 					},
 				],
 				primary_action: () => {

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -669,7 +669,7 @@ class PaymentReconciliation(Document):
 						"party": self.party,
 					},
 					fields=[
-						"parent as `name`",
+						"parent as name",
 						"exchange_rate",
 					],
 					as_list=1,
@@ -765,6 +765,14 @@ class PaymentReconciliation(Document):
 
 def reconcile_dr_cr_note(dr_cr_notes, company, active_dimensions=None):
 	for inv in dr_cr_notes:
+		if (
+			abs(frappe.db.get_value(inv.voucher_type, inv.voucher_no, "outstanding_amount"))
+			< inv.allocated_amount
+		):
+			frappe.throw(
+				_("{0} has been modified after you pulled it. Please pull it again.").format(inv.voucher_type)
+			)
+
 		voucher_type = "Credit Note" if inv.voucher_type == "Sales Invoice" else "Debit Note"
 
 		reconcile_dr_or_cr = (

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -975,7 +975,7 @@ class TestPaymentReconciliation(IntegrationTestCase):
 		total_credit_amount = frappe.db.get_all(
 			"Journal Entry Account",
 			{"account": self.debtors_eur, "docstatus": 1, "reference_name": si.name},
-			"sum(credit) as amount",
+			[{"SUM": "credit", "as": "amount"}],
 			group_by="reference_name",
 		)[0].amount
 
@@ -1069,7 +1069,7 @@ class TestPaymentReconciliation(IntegrationTestCase):
 		total_credit_amount = frappe.db.get_all(
 			"Journal Entry Account",
 			{"account": self.debtors_eur, "docstatus": 1, "reference_name": si.name},
-			"sum(credit) as amount",
+			[{"SUM": "credit", "as": "amount"}],
 			group_by="reference_name",
 		)[0].amount
 

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -20,6 +20,11 @@ from erpnext.accounts.party import get_due_date, get_party_account
 from erpnext.controllers.queries import item_query as _item_query
 from erpnext.controllers.sales_and_purchase_return import get_sales_invoice_item_from_consolidated_invoice
 from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
+from erpnext.stock.stock_ledger import is_negative_stock_allowed
+
+
+class ProductBundleStockValidationError(frappe.ValidationError):
+	pass
 
 
 class POSInvoice(SalesInvoice):
@@ -191,6 +196,9 @@ class POSInvoice(SalesInvoice):
 		super().__init__(*args, **kwargs)
 
 	def validate(self):
+		if not self.customer:
+			frappe.throw(_("Please select Customer first"))
+
 		if not cint(self.is_pos):
 			frappe.throw(
 				_("POS Invoice should have the field {0} checked.").format(frappe.bold(_("Include Payment")))
@@ -390,34 +398,69 @@ class POSInvoice(SalesInvoice):
 		):
 			return
 
-		from erpnext.stock.stock_ledger import is_negative_stock_allowed
-
 		for d in self.get("items"):
 			if not d.serial_and_batch_bundle:
-				if is_negative_stock_allowed(item_code=d.item_code):
-					return
+				if frappe.db.exists("Product Bundle", d.item_code):
+					(
+						availability,
+						is_stock_item,
+						is_negative_stock_allowed,
+					) = get_product_bundle_stock_availability(d.item_code, d.warehouse, d.stock_qty)
 
-				available_stock, is_stock_item = get_stock_availability(d.item_code, d.warehouse)
+				else:
+					availability, is_stock_item, is_negative_stock_allowed = get_stock_availability(
+						d.item_code, d.warehouse
+					)
 
-				item_code, warehouse, _qty = (
-					frappe.bold(d.item_code),
-					frappe.bold(d.warehouse),
-					frappe.bold(d.qty),
-				)
-				if is_stock_item and flt(available_stock) <= 0:
-					frappe.throw(
-						_("Row #{}: Item Code: {} is not available under warehouse {}.").format(
-							d.idx, item_code, warehouse
-						),
-						title=_("Item Unavailable"),
-					)
-				elif is_stock_item and flt(available_stock) < flt(d.stock_qty):
-					frappe.throw(
-						_("Row #{}: Stock quantity not enough for Item Code: {} under warehouse {}.").format(
-							d.idx, item_code, warehouse
-						),
-						title=_("Item Unavailable"),
-					)
+				if is_negative_stock_allowed:
+					continue
+
+				if isinstance(availability, list):
+					error_msgs = []
+					for item in availability:
+						if flt(item["available"]) < flt(item["required"]):
+							error_msgs.append(
+								_("<li>Packed Item {0}: Required {1}, Available {2}</li>").format(
+									frappe.bold(item["item_code"]),
+									frappe.bold(flt(item["required"], 2)),
+									frappe.bold(flt(item["available"], 2)),
+								)
+							)
+
+					if error_msgs:
+						frappe.throw(
+							_(
+								"<b>Row #{0}:</b> Bundle {1} in warehouse {2} has insufficient packed items:<br><div style='margin-top: 15px;'><ul style='line-height: 0.8;'>{3}</ul></div>"
+							).format(
+								d.idx,
+								frappe.bold(d.item_code),
+								frappe.bold(d.warehouse),
+								"<br>".join(error_msgs),
+							),
+							title=_("Insufficient Stock for Product Bundle Items"),
+							exc=ProductBundleStockValidationError,
+						)
+
+				else:
+					item_code, warehouse = frappe.bold(d.item_code), frappe.bold(d.warehouse)
+					if is_stock_item and flt(availability) <= 0:
+						frappe.throw(
+							_("Row #{0}: Item {1} has no stock in warehouse {2}.").format(
+								d.idx, item_code, warehouse
+							),
+							title=_("Item Out of Stock"),
+						)
+					elif is_stock_item and flt(availability) < flt(d.stock_qty):
+						frappe.throw(
+							_("Row #{0}: Item {1} in warehouse {2}: Available {3}, Needed {4}.").format(
+								d.idx,
+								item_code,
+								warehouse,
+								frappe.bold(flt(availability, 2)),
+								frappe.bold(flt(d.stock_qty, 2)),
+							),
+							title=_("Insufficient Stock"),
+						)
 
 	def validate_is_pos_using_sales_invoice(self):
 		self.invoice_type_in_pos = frappe.db.get_single_value("POS Settings", "invoice_type")
@@ -860,15 +903,35 @@ def get_stock_availability(item_code, warehouse):
 		bin_qty = get_bin_qty(item_code, warehouse)
 		pos_sales_qty = get_pos_reserved_qty(item_code, warehouse)
 
-		return bin_qty - pos_sales_qty, is_stock_item
+		return bin_qty - pos_sales_qty, is_stock_item, is_negative_stock_allowed(item_code=item_code)
 	else:
 		is_stock_item = True
 		if frappe.db.exists("Product Bundle", {"name": item_code, "disabled": 0}):
-			return get_bundle_availability(item_code, warehouse), is_stock_item
+			return get_bundle_availability(item_code, warehouse), is_stock_item, False
 		else:
 			is_stock_item = False
 			# Is a service item or non_stock item
-			return 0, is_stock_item
+			return 0, is_stock_item, False
+
+
+def get_product_bundle_stock_availability(item_code, warehouse, item_qty):
+	is_stock_item = True
+	bundle = frappe.get_doc("Product Bundle", item_code)
+	availabilities = []
+	for bundle_item in bundle.items:
+		if frappe.get_value("Item", bundle_item.item_code, "is_stock_item"):
+			bin_qty = get_bin_qty(bundle_item.item_code, warehouse)
+			reserved_qty = get_pos_reserved_qty(bundle_item.item_code, warehouse)
+			available = bin_qty - reserved_qty
+			availabilities.append(
+				{
+					"item_code": bundle_item.item_code,
+					"required": bundle_item.qty * item_qty,
+					"available": available,
+				}
+			)
+
+	return availabilities, is_stock_item, is_negative_stock_allowed(item_code=item_code)
 
 
 def get_bundle_availability(bundle_item_code, warehouse):

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -1024,6 +1024,84 @@ class TestPOSInvoice(IntegrationTestCase):
 			frappe.db.rollback(save_point="before_test_delivered_serial_no_case")
 			frappe.set_user("Administrator")
 
+	def test_bundle_stock_availability_validation(self):
+		from erpnext.accounts.doctype.pos_invoice.pos_invoice import ProductBundleStockValidationError
+		from erpnext.accounts.doctype.pos_invoice_merge_log.test_pos_invoice_merge_log import (
+			init_user_and_profile,
+		)
+		from erpnext.selling.doctype.product_bundle.test_product_bundle import make_product_bundle
+		from erpnext.stock.doctype.item.test_item import create_item
+
+		init_user_and_profile()
+
+		frappe.set_user("Administrator")
+
+		warehouse = "_Test Warehouse - _TC"
+		company = "_Test Company"
+
+		# Create stock sub-items
+		sub_item_a = "_Test Bundle SubA"
+		if not frappe.db.exists("Item", sub_item_a):
+			create_item(
+				item_code=sub_item_a,
+				is_stock_item=1,
+			)
+
+		sub_item_b = "_Test Bundle SubB"
+		if not frappe.db.exists("Item", sub_item_b):
+			create_item(
+				item_code=sub_item_b,
+				is_stock_item=1,
+			)
+
+		# Add initial stock: SubA=5, SubB=2
+		make_stock_entry(item_code=sub_item_a, target=warehouse, qty=5, company=company)
+		make_stock_entry(item_code=sub_item_b, target=warehouse, qty=2, company=company)
+
+		# Create Product Bundle: Test Bundle (SubA x2 + SubB x1)
+		bundle_item = "_Test Bundle"
+		if not frappe.db.exists("Item", bundle_item):
+			create_item(
+				item_code=bundle_item,
+				is_stock_item=0,
+			)
+
+		if not frappe.db.exists("Product Bundle", bundle_item):
+			make_product_bundle(parent=bundle_item, items=[sub_item_a, sub_item_b])
+
+		# Test Case 1: Sufficient stock (bundle qty=1: requires SubA=2 (<=5), SubB=1 (<=2)) -> No error
+		pos_inv_sufficient = create_pos_invoice(
+			item=bundle_item,
+			qty=1,
+			rate=100,
+			warehouse=warehouse,
+			pos_profile=self.pos_profile.name,
+			do_not_save=1,
+		)
+		pos_inv_sufficient.append("payments", {"mode_of_payment": "Cash", "amount": 100, "default": 1})
+		pos_inv_sufficient.insert()
+		pos_inv_sufficient.submit()
+
+		pos_inv_sufficient.cancel()
+		pos_inv_sufficient.delete()
+
+		# Test Case 2: Insufficient stock (reduce SubB to 1, bundle qty=2: requires SubB=2 >1) -> Error with details
+		make_stock_entry(item_code=sub_item_b, from_warehouse=warehouse, qty=1, company=company)
+
+		pos_inv_insufficient = create_pos_invoice(
+			item=bundle_item,
+			qty=2,
+			rate=100,
+			warehouse=warehouse,
+			pos_profile=self.pos_profile.name,
+			do_not_save=1,
+		)
+		pos_inv_insufficient.append("payments", {"mode_of_payment": "Cash", "amount": 200, "default": 1})
+		pos_inv_insufficient.save()
+		self.assertRaises(ProductBundleStockValidationError, pos_inv_insufficient.submit)
+
+		frappe.set_user("test@example.com")
+
 
 def create_pos_invoice(**args):
 	args = frappe._dict(args)

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -713,6 +713,7 @@ def get_item_uoms(doctype, txt, searchfield, start, page_len, filters):
 	return frappe.get_all(
 		"UOM Conversion Detail",
 		filters={"parent": ("in", items), "uom": ("like", f"{txt}%")},
-		fields=["distinct uom"],
+		fields=["uom"],
 		as_list=1,
+		distinct=True,
 	)

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -243,10 +243,13 @@ def get_other_conditions(conditions, values, args):
 		if group_condition:
 			conditions += " and " + group_condition
 
-	if args.get("transaction_date"):
+	date = args.get("transaction_date") or frappe.get_value(
+		args.get("doctype"), args.get("name"), "posting_date", ignore=True
+	)
+	if date:
 		conditions += """ and %(transaction_date)s between ifnull(`tabPricing Rule`.valid_from, '2000-01-01')
 			and ifnull(`tabPricing Rule`.valid_upto, '2500-12-31')"""
-		values["transaction_date"] = args.get("transaction_date")
+		values["transaction_date"] = date
 
 	if args.get("doctype") in [
 		"Quotation",

erpnext/accounts/doctype/process_deferred_accounting/test_process_deferred_accounting.py

@@ -16,7 +16,7 @@ from erpnext.stock.doctype.item.test_item import create_item
 class TestProcessDeferredAccounting(IntegrationTestCase):
 	def test_creation_of_ledger_entry_on_submit(self):
 		"""test creation of gl entries on submission of document"""
-		change_acc_settings(acc_frozen_upto="2023-05-31", book_deferred_entries_based_on="Months")
+		change_acc_settings(acc_frozen_till_date="2023-05-31", book_deferred_entries_based_on="Months")
 
 		deferred_account = create_account(
 			account_name="Deferred Revenue for Accounts Frozen",
@@ -92,8 +92,10 @@ class TestProcessDeferredAccounting(IntegrationTestCase):
 		pda.cancel()
 
 
-def change_acc_settings(acc_frozen_upto="", book_deferred_entries_based_on="Days"):
+def change_acc_settings(
+	company="_Test Company", acc_frozen_till_date=None, book_deferred_entries_based_on="Days"
+):
 	acc_settings = frappe.get_doc("Accounts Settings", "Accounts Settings")
-	acc_settings.acc_frozen_upto = acc_frozen_upto
 	acc_settings.book_deferred_entries_based_on = book_deferred_entries_based_on
+	frappe.db.set_value("Company", company, "accounts_frozen_till_date", acc_frozen_till_date)
 	acc_settings.save()

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -12,6 +12,7 @@ erpnext.buying.setup_buying_controller();
 
 erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.BuyingController {
 	setup(doc) {
+		this.setup_accounting_dimension_triggers();
 		this.setup_posting_date_time_check();
 		super.setup(doc);
 

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -1374,7 +1374,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 		total_debit_amount = frappe.db.get_all(
 			"Journal Entry Account",
 			{"account": creditors_account, "docstatus": 1, "reference_name": pi.name},
-			"sum(debit) as amount",
+			[{"SUM": "debit", "as": "amount"}],
 			group_by="reference_name",
 		)[0].amount
 		self.assertEqual(flt(total_debit_amount, 2), 2500)
@@ -1456,7 +1456,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 		total_debit_amount = frappe.db.get_all(
 			"Journal Entry Account",
 			{"account": creditors_account, "docstatus": 1, "reference_name": pi_2.name},
-			"sum(debit) as amount",
+			[{"SUM": "debit", "as": "amount"}],
 			group_by="reference_name",
 		)[0].amount
 		self.assertEqual(flt(total_debit_amount, 2), 1500)

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.py

@@ -213,7 +213,10 @@ def get_allowed_types_from_settings(child_doc: bool = False):
 	repost_docs = [
 		x.document_type
 		for x in frappe.db.get_all(
-			"Repost Allowed Types", filters={"allowed": True}, fields=["distinct(document_type)"]
+			"Repost Allowed Types",
+			filters={"allowed": True},
+			fields=["document_type"],
+			distinct=True,
 		)
 	]
 	result = repost_docs
@@ -287,7 +290,11 @@ def get_repost_allowed_types(doctype, txt, searchfield, start, page_len, filters
 		filters.update({"document_type": ("like", f"%{txt}%")})
 
 	if allowed_types := frappe.db.get_all(
-		"Repost Allowed Types", filters=filters, fields=["distinct(document_type)"], as_list=1
+		"Repost Allowed Types",
+		filters=filters,
+		fields=["document_type"],
+		as_list=1,
+		distinct=True,
 	):
 		return allowed_types
 	return []

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -14,6 +14,7 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 	erpnext.selling.SellingController
 ) {
 	setup(doc) {
+		this.setup_accounting_dimension_triggers();
 		this.setup_posting_date_time_check();
 		super.setup(doc);
 		this.frm.make_methods = {

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -282,59 +282,6 @@ class SalesInvoice(SellingController):
 			self.indicator_color = "green"
 			self.indicator_title = _("Paid")
 
-	def before_print(self, settings=None):
-		from frappe.contacts.doctype.address.address import get_address_display_list
-
-		super().before_print(settings)
-
-		company_details = frappe.get_value(
-			"Company", self.company, ["company_logo", "website", "phone_no", "email"], as_dict=True
-		)
-
-		required_fields = [
-			company_details.get("company_logo"),
-			company_details.get("phone_no"),
-			company_details.get("email"),
-		]
-
-		if not all(required_fields) and not frappe.has_permission("Company", "write", throw=False):
-			frappe.msgprint(
-				_(
-					"Some required Company details are missing. You don't have permission to update them. Please contact your System Manager."
-				)
-			)
-			return
-
-		if not self.company_address and not frappe.has_permission("Sales Invoice", "write", throw=False):
-			frappe.msgprint(
-				_(
-					"Company Address is missing. You don't have permission to update it. Please contact your System Manager."
-				)
-			)
-			return
-
-		address_display_list = get_address_display_list("Company", self.company)
-		address_line = address_display_list[0].get("address_line1") if address_display_list else ""
-
-		required_fields.append(self.company_address)
-		required_fields.append(address_line)
-
-		if not all(required_fields):
-			frappe.publish_realtime(
-				"sales_invoice_before_print",
-				{
-					"company_logo": company_details.get("company_logo"),
-					"website": company_details.get("website"),
-					"phone_no": company_details.get("phone_no"),
-					"email": company_details.get("email"),
-					"address_line": address_line,
-					"company": self.company,
-					"company_address": self.company_address,
-					"name": self.name,
-				},
-				user=frappe.session.user,
-			)
-
 	def validate(self):
 		self.validate_auto_set_posting_time()
 		super().validate()
@@ -1678,7 +1625,11 @@ class SalesInvoice(SellingController):
 		)
 
 		for item in self.get("items"):
-			if flt(item.base_net_amount, item.precision("base_net_amount")) or item.is_fixed_asset:
+			if (
+				flt(item.base_net_amount, item.precision("base_net_amount"))
+				or item.is_fixed_asset
+				or enable_discount_accounting
+			):
 				# Do not book income for transfer within same company
 				if self.is_internal_transfer():
 					continue
@@ -2948,59 +2899,6 @@ def get_loyalty_programs(customer):
 		return lp_details
 
 
-@frappe.whitelist()
-def save_company_master_details(name, company, details):
-	from frappe.utils import validate_email_address
-
-	if isinstance(details, str):
-		details = frappe.parse_json(details)
-
-	if details.get("email"):
-		validate_email_address(details.get("email"), throw=True)
-
-	company_fields = ["company_logo", "website", "phone_no", "email"]
-	company_fields_to_update = {field: details.get(field) for field in company_fields if details.get(field)}
-
-	if company_fields_to_update:
-		frappe.db.set_value("Company", company, company_fields_to_update)
-
-	company_address = details.get("company_address")
-	if details.get("address_line1"):
-		address_doc = frappe.get_doc(
-			{
-				"doctype": "Address",
-				"address_title": details.get("address_title"),
-				"address_type": details.get("address_type"),
-				"address_line1": details.get("address_line1"),
-				"address_line2": details.get("address_line2"),
-				"city": details.get("city"),
-				"state": details.get("state"),
-				"pincode": details.get("pincode"),
-				"country": details.get("country"),
-				"is_your_company_address": 1,
-				"links": [{"link_doctype": "Company", "link_name": company}],
-			}
-		)
-		address_doc.insert()
-		company_address = address_doc.name
-
-	if company_address:
-		company_address_display = frappe.db.get_value("Sales Invoice", name, "company_address_display")
-		if not company_address_display or details.get("address_line1"):
-			from frappe.query_builder import DocType
-
-			SalesInvoice = DocType("Sales Invoice")
-
-			(
-				frappe.qb.update(SalesInvoice)
-				.set(SalesInvoice.company_address, company_address)
-				.set(SalesInvoice.company_address_display, get_address_display(company_address))
-				.where(SalesInvoice.name == name)
-			).run()
-
-	return True
-
-
 @frappe.whitelist()
 def create_invoice_discounting(source_name, target_doc=None):
 	invoice = frappe.get_doc("Sales Invoice", source_name)

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -63,7 +63,8 @@ class TestSalesInvoice(ERPNextTestSuite):
 		set_default_account_for_mode_of_payment(
 			mode_of_payment, "_Test Company with perpetual inventory", "_Test Bank - TCP1"
 		)
-		frappe.db.set_single_value("Accounts Settings", "acc_frozen_upto", None)
+		for company in frappe.get_all("Company", pluck="name"):
+			frappe.db.set_value("Company", company, "accounts_frozen_till_date", None)
 
 	@change_settings(
 		"Accounts Settings",
@@ -3398,8 +3399,8 @@ class TestSalesInvoice(ERPNextTestSuite):
 			si.commission_rate = commission_rate
 			self.assertRaises(frappe.ValidationError, si.save)
 
-	@IntegrationTestCase.change_settings("Accounts Settings", {"acc_frozen_upto": add_days(getdate(), 1)})
 	def test_sales_invoice_submission_post_account_freezing_date(self):
+		frappe.db.set_value("Company", "_Test Company", "accounts_frozen_till_date", add_days(getdate(), 1))
 		si = create_sales_invoice(do_not_save=True)
 		si.posting_date = add_days(getdate(), 1)
 		si.save()
@@ -3407,6 +3408,7 @@ class TestSalesInvoice(ERPNextTestSuite):
 		self.assertRaises(frappe.ValidationError, si.submit)
 		si.posting_date = getdate()
 		si.submit()
+		frappe.db.set_value("Company", "_Test Company", "accounts_frozen_till_date", None)
 
 	@IntegrationTestCase.change_settings("Accounts Settings", {"over_billing_allowance": 0})
 	def test_over_billing_case_against_delivery_note(self):
@@ -3473,7 +3475,7 @@ class TestSalesInvoice(ERPNextTestSuite):
 		si.save()
 		si.submit()
 
-		frappe.db.set_single_value("Accounts Settings", "acc_frozen_upto", getdate("2019-01-31"))
+		frappe.db.set_value("Company", "_Test Company", "accounts_frozen_till_date", getdate("2019-01-31"))
 
 		pda1 = frappe.get_doc(
 			dict(
@@ -3612,7 +3614,7 @@ class TestSalesInvoice(ERPNextTestSuite):
 		frappe.db.get_all(
 			"Payment Ledger Entry",
 			filters={"against_voucher_no": si.name, "delinked": 0},
-			fields=["sum(amount), sum(amount_in_account_currency)"],
+			fields=[{"SUM": "amount"}, {"SUM": "amount_in_account_currency"}],
 			as_list=1,
 		)
 

erpnext/accounts/doctype/subscription/test_subscription.py

@@ -27,7 +27,7 @@ class TestSubscription(IntegrationTestCase):
 		make_plans()
 		create_parties()
 		reset_settings()
-		frappe.db.set_single_value("Accounts Settings", "acc_frozen_upto", None)
+		frappe.db.set_value("Company", "_Test Company", "accounts_frozen_till_date", None)
 
 	def tearDown(self):
 		frappe.db.rollback()

erpnext/accounts/doctype/tax_withholding_category/test_tax_withholding_category.py

@@ -121,7 +121,7 @@ class TestTaxWithholdingCategory(IntegrationTestCase):
 		gl_entries = frappe.db.get_all(
 			"GL Entry",
 			filters={"voucher_no": pi.name},
-			fields=["account", "sum(debit) as debit", "sum(credit) as credit"],
+			fields=["account", {"SUM": "debit", "as": "debit"}, {"SUM": "credit", "as": "credit"}],
 			group_by="account",
 		)
 		self.assertEqual(len(gl_entries), 3)

erpnext/accounts/general_ledger.py

@@ -301,7 +301,9 @@ def merge_similar_entries(gl_map, precision=None):
 	company_currency = erpnext.get_company_currency(company)
 
 	if not precision:
-		precision = get_field_precision(frappe.get_meta("GL Entry").get_field("debit"), company_currency)
+		precision = get_field_precision(
+			frappe.get_meta("GL Entry").get_field("debit"), currency=company_currency
+		)
 
 	# filter zero debit and credit entries
 	merged_gl_map = filter(
@@ -404,7 +406,7 @@ def save_entries(gl_map, adv_adj, update_outstanding, from_repost=False):
 
 	dimension_filter_map = get_dimension_filter_map()
 	if gl_map:
-		check_freezing_date(gl_map[0]["posting_date"], adv_adj)
+		check_freezing_date(gl_map[0]["posting_date"], gl_map[0]["company"], adv_adj)
 		is_opening = any(d.get("is_opening") == "Yes" for d in gl_map)
 		if gl_map[0]["voucher_type"] != "Period Closing Voucher":
 			validate_against_pcv(is_opening, gl_map[0]["posting_date"], gl_map[0]["company"])
@@ -765,7 +767,7 @@ def make_reverse_gl_entries(
 				make_entry(new_gle, adv_adj, "Yes")
 
 
-def check_freezing_date(posting_date, adv_adj=False):
+def check_freezing_date(posting_date, company, adv_adj=False):
 	"""
 	Nobody can do GL Entries where posting date is before freezing date
 	except authorized person
@@ -774,17 +776,17 @@ def check_freezing_date(posting_date, adv_adj=False):
 	Hence stop admin to bypass if accounts are freezed
 	"""
 	if not adv_adj:
-		acc_frozen_upto = frappe.get_single_value("Accounts Settings", "acc_frozen_upto")
-		if acc_frozen_upto:
-			frozen_accounts_modifier = frappe.get_single_value(
-				"Accounts Settings", "frozen_accounts_modifier"
+		acc_frozen_till_date = frappe.db.get_value("Company", company, "accounts_frozen_till_date")
+		if acc_frozen_till_date:
+			frozen_accounts_modifier = frappe.db.get_value(
+				"Company", company, "role_allowed_for_frozen_entries"
 			)
-			if getdate(posting_date) <= getdate(acc_frozen_upto) and (
+			if getdate(posting_date) <= getdate(acc_frozen_till_date) and (
 				frozen_accounts_modifier not in frappe.get_roles() or frappe.session.user == "Administrator"
 			):
 				frappe.throw(
 					_("You are not authorized to add or update entries before {0}").format(
-						formatdate(acc_frozen_upto)
+						formatdate(acc_frozen_till_date)
 					)
 				)
 

erpnext/accounts/letterhead/company_letterhead.html

@@ -1,108 +1,108 @@
 <style>
-    .letter-head {
-        border-radius: 18px;
-        padding-right: 12px;
-        margin-left: 12px;
-        margin-right: 12px;
-    }
+	.letter-head {
+		border-radius: 18px;
+		padding-right: 12px;
+		margin-left: 12px;
+		margin-right: 12px;
+	}
 
-    .letter-head td{
-        padding: 0px !important;
-    }
-    .invoice-header {
-        width: 100%;
-    }
-    .logo-cell {
-        width: 100px;
-        text-align: center;
-        position: relative;
-    }
-    .logo-container {
-        width: 90px;
-        display: block;
-    }
-    .logo-container img {
-        max-width: 90px;
-        max-height: 90px;
-        display: inline-block;
-        border-radius: 15px;
-    }
-    .company-details {
-        width: 40%;
-        align-content: center;
-    }
-    .company-name {
-        font-size: 14px;
-        font-weight: bold;
-        color: #171717;
-        margin-bottom: 4px;
-    }
-    .invoice-info-cell {
-        float: right;
-        vertical-align: top;
-    }
-    .invoice-info {
-        margin-bottom: 2px;
-    }
-    .invoice-label {
-        color: #7C7C7C;
-        display: inline-block;
-        width: 60px;
-        margin-right: 5px;
-    }
+	.letter-head td {
+		padding: 0px !important;
+	}
+	.invoice-header {
+		width: 100%;
+	}
+	.logo-cell {
+		width: 100px;
+		text-align: center;
+		position: relative;
+	}
+	.logo-container {
+		width: 90px;
+		display: block;
+	}
+	.logo-container img {
+		max-width: 90px;
+		max-height: 90px;
+		display: inline-block;
+		border-radius: 15px;
+	}
+	.company-details {
+		width: 40%;
+		align-content: center;
+	}
+	.company-name {
+		font-size: 14px;
+		font-weight: bold;
+		color: #171717;
+		margin-bottom: 4px;
+	}
+	.invoice-info-cell {
+		float: right;
+		vertical-align: top;
+	}
+	.invoice-info {
+		margin-bottom: 2px;
+	}
+	.invoice-label {
+		color: #7c7c7c;
+		display: inline-block;
+		margin-right: 5px;
+	}
 </style>
 
 <table class="invoice-header">
-    <tbody>
-        <tr>
-            <td class="logo-cell" style="vertical-align: middle !important;">
-                <div class="logo-container">
-                    {% set company_logo = frappe.db.get_value("Company", doc.company, "company_logo") %}
-                    {% if company_logo %}
-                        <img src="{{ frappe.utils.get_url(company_logo) }}" alt="Company Logo">
-                    {% endif %}
-                </div>
-            </td>
+	<tbody>
+		<tr>
+			<td class="logo-cell" style="vertical-align: middle !important">
+				<div class="logo-container">
+					{% set company_logo = frappe.db.get_value("Company", doc.company, "company_logo") %} {% if
+					company_logo %}
+					<img src="{{ frappe.utils.get_url(company_logo) }}" alt="Company Logo" />
+					{% endif %}
+				</div>
+			</td>
 
-            <td class="company-details">
-                <div class="company-name">
-                    {{ doc.company }}
-                </div>
-                {% if doc.company_address %}
-                    {% set company_address = frappe.db.get_value("Address", doc.company_address, ["address_line1", "address_line2", "city", "state", "pincode", "country"], as_dict=True) %}
+			<td class="company-details">
+				<div class="company-name">{{ doc.company }}</div>
+				{% if doc.company_address %} {% set company_address = frappe.db.get_value("Address",
+				doc.company_address, ["address_line1", "address_line2", "city", "state", "pincode",
+				"country"], as_dict=True) %} {% elif doc.billing_address %} {% set company_address =
+				frappe.db.get_value("Address", doc.billing_address, ["address_line1", "address_line2", "city",
+				"state", "pincode", "country"], as_dict=True) %} {% endif %} {% if company_address %} {{
+				company_address.address_line1 or "" }}<br />
+				{% if company_address.address_line2 %} {{ company_address.address_line2 }}<br />
+				{% endif %} {{ company_address.city or "" }}, {{ company_address.state or "" }} {{
+				company_address.pincode or "" }}, {{ company_address.country or ""}}<br />
+				{% endif %}
+			</td>
 
-                    {{ company_address.get("address_line1") or "" }}<br>
-                    {% if company_address.get("address_line2") %}{{ company_address.get("address_line2") }}<br>{% endif %}
-                    {{ company_address.get("city") or "" }}, {{ company_address.get("state") or "" }} {{ company_address.get("pincode") or "" }}, {{ company_address.get("country") or "" }}<br>
-                {% endif %}
-            </td>
+			<td class="invoice-info-cell">
+				{% set website = frappe.db.get_value("Company", doc.company, "website") %} {% set email =
+				frappe.db.get_value("Company", doc.company, "email") %} {% set phone_no =
+				frappe.db.get_value("Company", doc.company, "phone_no") %}
 
-            <td class="invoice-info-cell">
-                {% set company_details = frappe.db.get_value("Company", doc.company, ["website", "email", "phone_no"], as_dict=True) %}
-
-                <div class="invoice-info">
-                    <span class="invoice-label">{{ _("Invoice:") }}</span>
-                    <span>{{ doc.name }}</span>
-                </div>
-                {% if company_details.website %}
-                    <div class="invoice-info">
-                        <span class="invoice-label">{{ _("Website:") }}</span>
-                        <span>{{ company_details.website }}</span>
-                    </div>
-                {% endif %}
-                {% if company_details.email %}
-                    <div class="invoice-info">
-                        <span class="invoice-label">{{ _("Email:") }}</span>
-                        <span>{{ company_details.email }}</span>
-                    </div>
-                {% endif %}
-                {% if company_details.phone_no %}
-                    <div class="invoice-info">
-                        <span class="invoice-label">{{ _("Contact:") }}</span>
-                        <span>{{ company_details.phone_no }}</span>
-                    </div>
-                {% endif %}
-            </td>
-        </tr>
-    </tbody>
+				<div class="invoice-info">
+					<span class="invoice-label">{{ doc.doctype }}</span>
+					<span>{{ doc.name }}</span>
+				</div>
+				{% if website %}
+				<div class="invoice-info">
+					<span class="invoice-label">{{ _("Website:") }}</span>
+					<span>{{ website }}</span>
+				</div>
+				{% endif %} {% if email %}
+				<div class="invoice-info">
+					<span class="invoice-label">{{ _("Email:") }}</span>
+					<span>{{ email }}</span>
+				</div>
+				{% endif %} {% if phone_no %}
+				<div class="invoice-info">
+					<span class="invoice-label">{{ _("Contact:") }}</span>
+					<span>{{ phone_no }}</span>
+				</div>
+				{% endif %}
+			</td>
+		</tr>
+	</tbody>
 </table>

erpnext/accounts/letterhead/company_letterhead_grey.html

@@ -1,7 +1,7 @@
 <style>
 	.print-format-preview {
-        margin-top: 12px;
-    }
+		margin-top: 12px;
+	}
 	.letter-head {
 		border-radius: 18px;
 		background: #f8f8f8;
@@ -82,41 +82,43 @@
 				{% endif %}
 				<div class="company-name">{{ doc.company }}</div>
 				<div class="company-address">
-					{% if doc.company_address %}
-						{% set company_address = frappe.db.get_value("Address", doc.company_address, ["address_line1", "address_line2", "city", "state", "pincode", "country"], as_dict=True) %}
-						{{ company_address.address_line1 or "" }}<br />
-						{% if company_address.address_line2 %} {{ company_address.address_line2 }}<br /> {% endif %}
-						{{ company_address.city or "" }}, {{ company_address.state or "" }}
-						{{ company_address.pincode or "" }}, {{ company_address.country or ""}}<br />
+					{% if doc.company_address %} {% set company_address = frappe.db.get_value("Address",
+					doc.company_address, ["address_line1", "address_line2", "city", "state", "pincode",
+					"country"], as_dict=True) %} {% elif doc.billing_address %} {% set company_address =
+					frappe.db.get_value("Address", doc.billing_address, ["address_line1", "address_line2",
+					"city", "state", "pincode", "country"], as_dict=True) %} {% endif %} {% if company_address
+					%} {{ company_address.address_line1 or "" }}<br />
+					{% if company_address.address_line2 %} {{ company_address.address_line2 }}<br />
+					{% endif %} {{ company_address.city or "" }}, {{ company_address.state or "" }} {{
+					company_address.pincode or "" }}, {{ company_address.country or ""}}<br />
 					{% endif %}
 				</div>
 			</td>
 
 			<td style="vertical-align: top">
 				<div style="height: 90px; margin-bottom: 10px; text-align: right">
-					<div class="invoice-title">{{ _("Sales Invoice") }}</div>
+					<div class="invoice-title">{{ doc.doctype }}</div>
 					<div class="invoice-number">{{ doc.name }}</div>
 					<br />
 				</div>
 				<div style="text-align: left; float: right" class="other-details">
-					{% set company_details = frappe.db.get_value("Company", doc.company, ["website", "email", "phone_no"], as_dict=True) %}
-					{% if company_details.website %}
-						<div>
-							<span class="contact-title">{{ _("Website:") }}</span
-							><span class="contact-value">{{ company_details.website }}</span>
-						</div>
-					{% endif %}
-					{% if company_details.email %}
-						<div>
-							<span class="contact-title">{{ _("Email:") }}</span
-							><span class="contact-value">{{ company_details.email }}</span>
-						</div>
-					{% endif %}
-					{% if company_details.phone_no %}
-						<div>
-							<span class="contact-title">{{ _("Contact:") }}</span
-							><span class="contact-value">{{ company_details.phone_no }}</span>
-						</div>
+					{% set company_details = frappe.db.get_value("Company", doc.company, ["website", "email",
+					"phone_no"], as_dict=True) %} {% set website = company_details.website %} {% set email =
+					company_details.email %} {% set phone_no = company_details.phone_no %} {% if website %}
+					<div>
+						<span class="contact-title">{{ _("Website:") }}</span
+						><span class="contact-value">{{ website }}</span>
+					</div>
+					{% endif %} {% if email %}
+					<div>
+						<span class="contact-title">{{ _("Email:") }}</span
+						><span class="contact-value">{{ email }}</span>
+					</div>
+					{% endif %} {% if phone_no %}
+					<div>
+						<span class="contact-title">{{ _("Contact:") }}</span
+						><span class="contact-value">{{ phone_no }}</span>
+					</div>
 					{% endif %}
 				</div>
 			</td>

erpnext/accounts/party.py

@@ -795,7 +795,7 @@ def get_payment_terms_template(party_name, party_type, company=None):
 	return template
 
 
-def validate_party_frozen_disabled(party_type, party_name):
+def validate_party_frozen_disabled(company, party_type, party_name):
 	if frappe.flags.ignore_party_validation:
 		return
 
@@ -805,10 +805,10 @@ def validate_party_frozen_disabled(party_type, party_name):
 			if party.disabled:
 				frappe.throw(_("{0} {1} is disabled").format(party_type, party_name), PartyDisabled)
 			elif party.get("is_frozen"):
-				frozen_accounts_modifier = frappe.get_single_value(
-					"Accounts Settings", "frozen_accounts_modifier"
+				role_allowed_for_frozen_entries = frappe.get_cached_value(
+					"Company", company, "role_allowed_for_frozen_entries"
 				)
-				if frozen_accounts_modifier not in frappe.get_roles():
+				if role_allowed_for_frozen_entries not in frappe.get_roles():
 					frappe.throw(_("{0} {1} is frozen").format(party_type, party_name), PartyFrozen)
 
 		elif party_type == "Employee":
@@ -854,8 +854,8 @@ def get_dashboard_info(party_type, party, loyalty_program=None):
 		group_by="company",
 		fields=[
 			"company",
-			"sum(grand_total) as grand_total",
-			"sum(base_grand_total) as base_grand_total",
+			{"SUM": "grand_total", "as": "grand_total"},
+			{"SUM": "base_grand_total", "as": "base_grand_total"},
 		],
 	)
 
@@ -870,7 +870,7 @@ def get_dashboard_info(party_type, party, loyalty_program=None):
 					"expiry_date": (">=", getdate()),
 				},
 				group_by="company",
-				fields=["company", "sum(loyalty_points) as loyalty_points"],
+				fields=["company", {"SUM": "loyalty_points", "as": "loyalty_points"}],
 				as_list=1,
 			)
 		)

erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.js

@@ -102,6 +102,11 @@ frappe.query_reports["Accounts Payable Summary"] = {
 			label: __("Revaluation Journals"),
 			fieldtype: "Check",
 		},
+		{
+			fieldname: "show_gl_balance",
+			label: __("Show GL Balance"),
+			fieldtype: "Check",
+		},
 	],
 
 	onload: function (report) {

erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py

@@ -53,7 +53,7 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 		)
 
 		if self.filters.show_gl_balance:
-			gl_balance_map = get_gl_balance(self.filters.report_date, self.filters.company)
+			gl_balance_map = get_gl_balance(self.filters.report_date, self.filters.company, self.account_type)
 
 		for party, party_dict in self.party_total.items():
 			if flt(party_dict.outstanding, self.currency_precision) == 0:
@@ -206,11 +206,15 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 		)
 
 
-def get_gl_balance(report_date, company):
+def get_gl_balance(report_date, company, account_type):
+	if account_type == "Payable":
+		balance_calc_fields = ["party", {"SUM": [{"SUB": ["credit", "debit"]}], "as": "balance"}]
+	else:
+		balance_calc_fields = ["party", {"SUM": [{"SUB": ["debit", "credit"]}], "as": "balance"}]
 	return frappe._dict(
 		frappe.db.get_all(
 			"GL Entry",
-			fields=["party", "sum(debit -  credit)"],
+			fields=balance_calc_fields,
 			filters={"posting_date": ("<=", report_date), "is_cancelled": 0, "company": company},
 			group_by="party",
 			as_list=1,

erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py

@@ -69,12 +69,18 @@ class PartyLedgerSummaryReport:
 		party_type = self.filters.party_type
 
 		doctype = qb.DocType(party_type)
+
+		party_details_fields = [
+			doctype.name.as_("party"),
+			f"{scrub(party_type)}_name",
+			f"{scrub(party_type)}_group",
+		]
+
+		if party_type == "Customer":
+			party_details_fields.append(doctype.territory)
+
 		conditions = self.get_party_conditions(doctype)
-		query = (
-			qb.from_(doctype)
-			.select(doctype.name.as_("party"), f"{scrub(party_type)}_name")
-			.where(Criterion.all(conditions))
-		)
+		query = qb.from_(doctype).select(*party_details_fields).where(Criterion.all(conditions))
 
 		from frappe.desk.reportview import build_match_conditions
 
@@ -153,6 +159,31 @@ class PartyLedgerSummaryReport:
 
 		credit_or_debit_note = "Credit Note" if self.filters.party_type == "Customer" else "Debit Note"
 
+		if self.filters.party_type == "Customer":
+			columns += [
+				{
+					"label": _("Customer Group"),
+					"fieldname": "customer_group",
+					"fieldtype": "Link",
+					"options": "Customer Group",
+				},
+				{
+					"label": _("Territory"),
+					"fieldname": "territory",
+					"fieldtype": "Link",
+					"options": "Territory",
+				},
+			]
+		else:
+			columns += [
+				{
+					"label": _("Supplier Group"),
+					"fieldname": "supplier_group",
+					"fieldtype": "Link",
+					"options": "Supplier Group",
+				}
+			]
+
 		columns += [
 			{
 				"label": _("Opening Balance"),
@@ -214,35 +245,6 @@ class PartyLedgerSummaryReport:
 			},
 		]
 
-		# Hidden columns for handling 'User Permissions'
-		if self.filters.party_type == "Customer":
-			columns += [
-				{
-					"label": _("Territory"),
-					"fieldname": "territory",
-					"fieldtype": "Link",
-					"options": "Territory",
-					"hidden": 1,
-				},
-				{
-					"label": _("Customer Group"),
-					"fieldname": "customer_group",
-					"fieldtype": "Link",
-					"options": "Customer Group",
-					"hidden": 1,
-				},
-			]
-		else:
-			columns += [
-				{
-					"label": _("Supplier Group"),
-					"fieldname": "supplier_group",
-					"fieldtype": "Link",
-					"options": "Supplier Group",
-					"hidden": 1,
-				}
-			]
-
 		columns.append({"label": _("Dr/Cr"), "fieldname": "dr_or_cr", "fieldtype": "Data", "width": 100})
 		return columns
 

erpnext/accounts/report/customer_ledger_summary/test_customer_ledger_summary.py

@@ -186,6 +186,8 @@ class TestCustomerLedgerSummary(AccountsTestMixin, IntegrationTestCase):
 		expected = {
 			"party": "_Test Customer",
 			"customer_name": "_Test Customer",
+			"customer_group": "_Test Customer Group",
+			"territory": "_Test Territory",
 			"party_name": "_Test Customer",
 			"opening_balance": 0,
 			"invoiced_amount": 100.0,
@@ -213,6 +215,8 @@ class TestCustomerLedgerSummary(AccountsTestMixin, IntegrationTestCase):
 		expected = {
 			"party": "_Test Customer",
 			"customer_name": "_Test Customer",
+			"customer_group": "_Test Customer Group",
+			"territory": "_Test Territory",
 			"party_name": "_Test Customer",
 			"opening_balance": 0,
 			"invoiced_amount": 100.0,

erpnext/accounts/report/financial_ratios/financial_ratios.py

@@ -174,7 +174,7 @@ def add_solvency_ratios(
 	return_on_equity_ratio = {"ratio": _("Return on Equity Ratio")}
 
 	for year in years:
-		profit_after_tax = flt(total_income.get(year)) + flt(total_expense.get(year))
+		profit_after_tax = flt(total_income.get(year)) - flt(total_expense.get(year))
 		share_holder_fund = flt(total_asset.get(year)) - flt(total_liability.get(year))
 
 		debt_equity_ratio[year] = calculate_ratio(total_liability.get(year), share_holder_fund, precision)
@@ -199,7 +199,7 @@ def add_turnover_ratios(data, years, period_list, filters, total_asset, net_sale
 
 	avg_data = {}
 	for d in ["Receivable", "Payable", "Stock"]:
-		avg_data[frappe.scrub(d)] = avg_ratio_balance("Receivable", period_list, precision, filters)
+		avg_data[frappe.scrub(d)] = avg_ratio_balance(d, period_list, precision, filters)
 
 	avg_debtors, avg_creditors, avg_stock = (
 		avg_data.get("receivable"),

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -588,6 +588,13 @@ def get_accountwise_gle(filters, accounting_dimensions, gl_entries, gle_map):
 				else:
 					update_value_in_dict(consolidated_gle, key, gle)
 
+		if filters.get("include_dimensions"):
+			dimensions = [*accounting_dimensions, "cost_center", "project"]
+
+			for dimension in dimensions:
+				if val := gle.get(dimension):
+					gle[dimension] = _(val)
+
 	for value in consolidated_gle.values():
 		update_value_in_dict(totals, "total", value)
 		update_value_in_dict(totals, "closing", value)

erpnext/accounts/utils.py

@@ -11,8 +11,8 @@ 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.query_builder import AliasedQuery, Case, Criterion, Table
-from frappe.query_builder.functions import Count, Max, Round, Sum
+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
 from frappe.utils import (
 	add_days,
@@ -1311,7 +1311,10 @@ def get_children(doctype, parent, company, is_root=False, include_disabled=False
 	if frappe.db.has_column(doctype, "disabled") and not include_disabled:
 		filters.append(["disabled", "=", False])
 
-	filters.append([f'ifnull(`{parent_fieldname}`,"")', "=", "" if is_root else parent])
+	if is_root:
+		filters.append(IfNull(Field(parent_fieldname), "") == "")
+	else:
+		filters.append([parent_fieldname, "=", parent])
 
 	if is_root:
 		fields += ["root_type", "report_type", "account_currency"] if doctype == "Account" else []

erpnext/assets/doctype/asset/asset.js

@@ -198,7 +198,7 @@ frappe.ui.form.on("Asset", {
 					callback: function (r) {
 						if (!r.message) {
 							$(".primary-action").prop("hidden", true);
-							$(".form-message").text("Capitalize this asset to confirm");
+							$(".form-message").text(__("Capitalize this asset to confirm"));
 
 							frm.add_custom_button(__("Capitalize Asset"), function () {
 								frm.trigger("create_asset_capitalization");

erpnext/assets/doctype/asset/asset.py

@@ -7,6 +7,7 @@ import math
 
 import frappe
 from frappe import _
+from frappe.query_builder.functions import IfNull, Sum
 from frappe.utils import (
 	cint,
 	flt,
@@ -121,7 +122,7 @@ class Asset(AccountsController):
 	def validate(self):
 		self.validate_category()
 		self.validate_precision()
-		self.validate_linked_purchase_docs()
+		self.validate_linked_purchase_documents()
 		self.set_purchase_doc_row_item()
 		self.validate_asset_values()
 		self.validate_asset_and_reference()
@@ -151,9 +152,9 @@ class Asset(AccountsController):
 			if not schedule_doc:
 				schedule_doc = frappe.new_doc("Asset Depreciation Schedule")
 				schedule_doc.asset = self.name
-			schedule_doc.create_depreciation_schedule(row)
-			schedule_doc.save()
-			schedules.append(schedule_doc.name)
+				schedule_doc.create_depreciation_schedule(row)
+				schedule_doc.save()
+				schedules.append(schedule_doc.name)
 
 		self.show_schedule_creation_message(schedules)
 
@@ -422,20 +423,67 @@ class Asset(AccountsController):
 		if self.available_for_use_date and getdate(self.available_for_use_date) < getdate(self.purchase_date):
 			frappe.throw(_("Available-for-use Date should be after purchase date"))
 
-	def validate_linked_purchase_docs(self):
-		for doctype_field, doctype_name in [
+	def validate_linked_purchase_documents(self):
+		for fieldname, doctype in [
 			("purchase_receipt", "Purchase Receipt"),
 			("purchase_invoice", "Purchase Invoice"),
 		]:
-			linked_doc = getattr(self, doctype_field, None)
-			if linked_doc:
-				docstatus = frappe.db.get_value(doctype_name, linked_doc, "docstatus")
-				if docstatus == 0:
-					frappe.throw(
-						_("{0} is still in Draft. Please submit it before saving the Asset.").format(
-							get_link_to_form(doctype_name, linked_doc)
-						)
+			purchase_doc = getattr(self, fieldname, None)
+
+			if not purchase_doc:
+				continue
+
+			if frappe.db.get_value(doctype, purchase_doc, "docstatus") == 0:
+				frappe.throw(
+					_("{0} is in Draft. Submit it before creating the Asset.").format(
+						get_link_to_form(doctype, purchase_doc)
 					)
+				)
+
+			self.validate_asset_qty_with_purchase_doc(doctype, purchase_doc)
+
+	def validate_asset_qty_with_purchase_doc(self, doctype, purchase_doc):
+		Asset = frappe.qb.DocType("Asset")
+
+		if doctype == "Purchase Invoice":
+			asset_filter = Asset.purchase_invoice == purchase_doc
+		else:
+			asset_filter = Asset.purchase_receipt == purchase_doc
+
+		existing_asset_qty = (
+			frappe.qb.from_(Asset)
+			.select(IfNull(Sum(Asset.asset_quantity), 0))
+			.where((Asset.item_code == self.item_code) & (Asset.name != self.name) & (Asset.docstatus != 2))
+			.where(asset_filter)
+		).run()[0][0]
+
+		PurchaseDoc = frappe.qb.DocType(doctype)
+		PurchaseDocItems = frappe.qb.DocType(f"{doctype} Item")
+
+		purchased_qty = (
+			frappe.qb.from_(PurchaseDoc)
+			.join(PurchaseDocItems)
+			.on(PurchaseDoc.name == PurchaseDocItems.parent)
+			.select(IfNull(Sum(PurchaseDocItems.qty), 0))
+			.where(PurchaseDoc.name == purchase_doc)
+			.where(PurchaseDocItems.item_code == self.item_code)
+		).run()[0][0]
+
+		if (existing_asset_qty + self.asset_quantity) > purchased_qty:
+			frappe.throw(
+				_(
+					"<b>Cannot create asset.</b><br><br>"
+					"You're trying to create <b>{0} asset(s)</b> from {2} {3}.<br>"
+					"However, only <b>{1} item(s)</b> were purchased and <b>{4} asset(s)</b> already exist against {5}."
+				).format(
+					self.asset_quantity,
+					purchased_qty,
+					doctype,
+					get_link_to_form(doctype, purchase_doc),
+					existing_asset_qty,
+					purchase_doc,
+				)
+			)
 
 	def validate_gross_and_purchase_amount(self):
 		if self.is_existing_asset:
@@ -1212,7 +1260,7 @@ def get_values_from_purchase_doc(purchase_doc_name, item_code, doctype):
 
 	return {
 		"company": purchase_doc.company,
-		"purchase_date": purchase_doc.get("bill_date") or purchase_doc.get("posting_date"),
+		"purchase_date": purchase_doc.get("posting_date"),
 		"net_purchase_amount": flt(first_item.base_net_amount),
 		"asset_quantity": first_item.qty,
 		"cost_center": first_item.cost_center or purchase_doc.get("cost_center"),

erpnext/assets/doctype/asset/depreciation.py

@@ -96,13 +96,28 @@ def get_depreciable_assets_data(date):
 		.orderby(a.creation, order=Order.desc)
 	)
 
-	acc_frozen_upto = get_acc_frozen_upto()
-	if acc_frozen_upto:
-		res = res.where(ds.schedule_date > acc_frozen_upto)
+	companies_with_frozen_limits = get_companies_with_frozen_limits()
 
-	res = res.run()
+	for company, frozen_upto in companies_with_frozen_limits.items():
+		res = res.where((a.company != company) | (ds.schedule_date > frozen_upto))
 
-	return res
+	return res.run()
+
+
+def get_companies_with_frozen_limits():
+	companies_with_frozen_limits = {}
+	for d in frappe.get_all(
+		"Company", fields=["name", "accounts_frozen_till_date", "role_allowed_for_frozen_entries"]
+	):
+		if not d.accounts_frozen_till_date:
+			continue
+
+		if (
+			d.role_allowed_for_frozen_entries not in frappe.get_roles()
+			and frappe.session.user != "Administrator"
+		):
+			companies_with_frozen_limits[d.name] = getdate(d.accounts_frozen_till_date)
+	return companies_with_frozen_limits
 
 
 def make_depreciation_entry_on_disposal(asset_doc, disposal_date=None):
@@ -111,20 +126,6 @@ def make_depreciation_entry_on_disposal(asset_doc, disposal_date=None):
 		make_depreciation_entry(depr_schedule_name, disposal_date)
 
 
-def get_acc_frozen_upto():
-	acc_frozen_upto = frappe.get_single_value("Accounts Settings", "acc_frozen_upto")
-
-	if not acc_frozen_upto:
-		return
-
-	frozen_accounts_modifier = frappe.get_single_value("Accounts Settings", "frozen_accounts_modifier")
-
-	if frozen_accounts_modifier not in frappe.get_roles() or frappe.session.user == "Administrator":
-		return getdate(acc_frozen_upto)
-
-	return
-
-
 def get_credit_debit_accounts_for_asset(asset_category, company):
 	# Returns credit and debit accounts for the given asset category and company.
 	(_, accumulated_depr_account, depr_expense_account) = get_depreciation_accounts(asset_category, company)
@@ -307,7 +308,8 @@ def set_depr_entry_posting_status_for_failed_assets(failed_asset_names):
 
 
 def notify_depr_entry_posting_error(failed_asset_names, error_log_names):
-	recipients = get_users_with_role("Accounts Manager")
+	user_role = frappe.db.get_single_value("Accounts Settings", "role_to_notify_on_depreciation_failure")
+	recipients = get_users_with_role(user_role or "Accounts Manager")
 
 	if not recipients:
 		recipients = get_users_with_role("System Manager")

erpnext/assets/doctype/asset_repair/asset_repair.js

@@ -73,14 +73,7 @@ frappe.ui.form.on("Asset Repair", {
 	},
 
 	refresh: function (frm) {
-		if (frm.doc.docstatus) {
-			frm.add_custom_button(__("View General Ledger"), function () {
-				frappe.route_options = {
-					voucher_no: frm.doc.name,
-				};
-				frappe.set_route("query-report", "General Ledger");
-			});
-		}
+		frm.events.show_general_ledger(frm);
 
 		let sbb_field = frm.get_docfield("stock_items", "serial_and_batch_bundle");
 		if (sbb_field) {
@@ -144,6 +137,26 @@ frappe.ui.form.on("Asset Repair", {
 			frm.set_value("repair_cost", 0);
 		}
 	},
+
+	show_general_ledger: (frm) => {
+		if (frm.doc.docstatus > 0) {
+			frm.add_custom_button(
+				__("Accounting Ledger"),
+				function () {
+					frappe.route_options = {
+						voucher_no: frm.doc.name,
+						from_date: frm.doc.posting_date,
+						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
+						company: frm.doc.company,
+						categorize_by: "",
+						show_cancelled_entries: frm.doc.docstatus === 2,
+					};
+					frappe.set_route("query-report", "General Ledger");
+				},
+				__("View")
+			);
+		}
+	},
 });
 
 frappe.ui.form.on("Asset Repair Consumed Item", {

erpnext/assets/doctype/asset_repair/asset_repair.json

@@ -260,8 +260,13 @@
  ],
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
- "links": [],
- "modified": "2025-11-04 23:06:43.644846",
+ "links": [
+  {
+   "link_doctype": "Stock Entry",
+   "link_fieldname": "asset_repair"
+  }
+ ],
+ "modified": "2025-11-28 13:04:34.921098",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset Repair",

erpnext/assets/doctype/asset_repair/asset_repair.py

@@ -7,6 +7,9 @@ from frappe.query_builder import DocType
 from frappe.utils import cint, flt, get_link_to_form, getdate, time_diff_in_hours
 
 import erpnext
+from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
+	get_accounting_dimensions,
+)
 from erpnext.accounts.general_ledger import make_gl_entries
 from erpnext.assets.doctype.asset.asset import get_asset_account
 from erpnext.assets.doctype.asset_activity.asset_activity import add_asset_activity
@@ -231,6 +234,12 @@ class AssetRepair(AccountsController):
 			}
 		)
 
+		accounting_dimensions = {
+			"cost_center": self.cost_center,
+			"project": self.project,
+			**{dimension: self.get(dimension) for dimension in get_accounting_dimensions()},
+		}
+
 		for stock_item in self.get("stock_items"):
 			self.validate_serial_no(stock_item)
 
@@ -242,8 +251,7 @@ class AssetRepair(AccountsController):
 					"qty": stock_item.consumed_quantity,
 					"basic_rate": stock_item.valuation_rate,
 					"serial_and_batch_bundle": stock_item.serial_and_batch_bundle,
-					"cost_center": self.cost_center,
-					"project": self.project,
+					**accounting_dimensions,
 				},
 			)
 
@@ -320,7 +328,8 @@ class AssetRepair(AccountsController):
 					"voucher_no": self.name,
 					"cost_center": self.cost_center,
 					"posting_date": self.completion_date,
-					"against_voucher_type": "Purchase Invoice",
+					"against_voucher_type": "Asset",
+					"against_voucher": self.asset,
 					"company": self.company,
 				},
 				item=self,

erpnext/assets/doctype/asset_repair/test_asset_repair.py

@@ -3,6 +3,8 @@
 import unittest
 
 import frappe
+from frappe import qb
+from frappe.query_builder.functions import Sum
 from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, add_months, flt, get_first_day, nowdate, nowtime, today
 
@@ -322,6 +324,31 @@ class TestAssetRepair(IntegrationTestCase):
 		stock_entry = frappe.get_last_doc("Stock Entry")
 		self.assertEqual(stock_entry.asset_repair, asset_repair.name)
 
+	def test_gl_entries_with_capitalized_asset_repair(self):
+		asset = create_asset(is_existing_asset=1, calculate_depreciation=1, submit=1)
+		asset_repair = create_asset_repair(
+			asset=asset, capitalize_repair_cost=1, item="_Test Non Stock Item", submit=1
+		)
+		asset.reload()
+
+		GLEntry = qb.DocType("GL Entry")
+		res = (
+			qb.from_(GLEntry)
+			.select(Sum(GLEntry.debit_in_account_currency).as_("total_debit"))
+			.where(
+				(GLEntry.voucher_type == "Asset Repair")
+				& (GLEntry.voucher_no == asset_repair.name)
+				& (GLEntry.against_voucher_type == "Asset")
+				& (GLEntry.against_voucher == asset.name)
+				& (GLEntry.company == asset.company)
+				& (GLEntry.is_cancelled == 0)
+			)
+		).run(as_dict=True)
+		booked_value = res[0].total_debit if res else 0
+
+		self.assertEqual(asset.additional_asset_cost, asset_repair.repair_cost)
+		self.assertEqual(booked_value, asset_repair.repair_cost)
+
 
 def num_of_depreciations(asset):
 	return asset.finance_books[0].total_number_of_depreciations + (

erpnext/buying/doctype/buying_settings/buying_settings.json

@@ -36,6 +36,7 @@
   "backflush_raw_materials_of_subcontract_based_on",
   "column_break_11",
   "over_transfer_allowance",
+  "validate_consumed_qty",
   "section_break_xcug",
   "auto_create_subcontracting_order",
   "column_break_izrr",
@@ -270,6 +271,14 @@
    "label": "Fixed Outgoing Email Account",
    "link_filters": "[[\"Email Account\",\"enable_outgoing\",\"=\",1]]",
    "options": "Email Account"
+  },
+  {
+   "default": "0",
+   "depends_on": "eval:doc.backflush_raw_materials_of_subcontract_based_on == \"Material Transferred for Subcontract\"",
+   "description": "Raw materials consumed qty will be validated based on FG BOM required qty",
+   "fieldname": "validate_consumed_qty",
+   "fieldtype": "Check",
+   "label": "Validate Consumed Qty (as per BOM)"
   }
  ],
  "grid_page_length": 50,
@@ -278,7 +287,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2025-08-20 22:13:38.506889",
+ "modified": "2025-11-20 12:59:09.925862",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Buying Settings",

erpnext/buying/doctype/buying_settings/buying_settings.py

@@ -44,6 +44,7 @@ class BuyingSettings(Document):
 		supp_master_name: DF.Literal["Supplier Name", "Naming Series", "Auto Name"]
 		supplier_group: DF.Link | None
 		use_transaction_date_exchange_rate: DF.Check
+		validate_consumed_qty: DF.Check
 	# end: auto-generated types
 
 	def validate(self):

erpnext/buying/doctype/purchase_order/purchase_order.js

@@ -317,6 +317,7 @@ erpnext.buying.PurchaseOrderController = class PurchaseOrderController extends (
 	erpnext.buying.BuyingController
 ) {
 	setup() {
+		this.setup_accounting_dimension_triggers();
 		this.frm.custom_make_buttons = {
 			"Purchase Receipt": "Purchase Receipt",
 			"Purchase Invoice": "Purchase Invoice",

erpnext/buying/doctype/supplier/supplier.js

@@ -41,18 +41,20 @@ frappe.ui.form.on("Supplier", {
 
 		frm.set_query("supplier_primary_contact", function (doc) {
 			return {
-				query: "erpnext.buying.doctype.supplier.supplier.get_supplier_primary_contact",
+				query: "erpnext.buying.doctype.supplier.supplier.get_supplier_primary",
 				filters: {
 					supplier: doc.name,
+					type: "Contact",
 				},
 			};
 		});
 
 		frm.set_query("supplier_primary_address", function (doc) {
 			return {
+				query: "erpnext.buying.doctype.supplier.supplier.get_supplier_primary",
 				filters: {
-					link_doctype: "Supplier",
-					link_name: doc.name,
+					supplier: doc.name,
+					type: "Address",
 				},
 			};
 		});
@@ -133,6 +135,14 @@ 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.py

@@ -219,19 +219,25 @@ class Supplier(TransactionBase):
 
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
-def get_supplier_primary_contact(doctype, txt, searchfield, start, page_len, filters):
+def get_supplier_primary(doctype, txt, searchfield, start, page_len, filters):
 	supplier = filters.get("supplier")
-	contact = frappe.qb.DocType("Contact")
+	type = filters.get("type")
+	type_doctype = frappe.qb.DocType(type)
 	dynamic_link = frappe.qb.DocType("Dynamic Link")
 
-	return (
-		frappe.qb.from_(contact)
+	query = (
+		frappe.qb.from_(type_doctype)
 		.join(dynamic_link)
-		.on(contact.name == dynamic_link.parent)
-		.select(contact.name, contact.email_id)
+		.on(type_doctype.name == dynamic_link.parent)
+		.select(type_doctype.name)
 		.where(
 			(dynamic_link.link_name == supplier)
 			& (dynamic_link.link_doctype == "Supplier")
-			& (contact.name.like(f"%{txt}%"))
+			& (type_doctype.name.like(f"%{txt}%"))
 		)
-	).run(as_dict=False)
+	)
+
+	if type == "Contact":
+		query = query.select(type_doctype.email_id)
+
+	return query.run()

erpnext/controllers/accounts_controller.py

@@ -7,6 +7,7 @@ from collections import defaultdict
 
 import frappe
 from frappe import _, bold, qb, throw
+from frappe.contacts.doctype.address.address import get_address_display
 from frappe.model.workflow import get_workflow_name, is_transition_condition_satisfied
 from frappe.query_builder import Criterion, DocType
 from frappe.query_builder.custom import ConstantColumn
@@ -310,6 +311,31 @@ class AccountsController(TransactionBase):
 		self.set_default_letter_head()
 		self.validate_company_in_accounting_dimension()
 		self.validate_party_address_and_contact()
+		self.validate_company_linked_addresses()
+
+	def validate_company_linked_addresses(self):
+		address_fields = []
+		if self.doctype in ("Quotation", "Sales Order", "Delivery Note", "Sales Invoice"):
+			address_fields = ["dispatch_address_name", "company_address"]
+		elif self.doctype in ("Purchase Order", "Purchase Receipt", "Purchase Invoice", "Supplier Quotation"):
+			address_fields = ["billing_address", "shipping_address"]
+
+		for field in address_fields:
+			address = self.get(field)
+			if address and not frappe.db.exists(
+				"Dynamic Link",
+				{
+					"parent": address,
+					"parenttype": "Address",
+					"link_doctype": "Company",
+					"link_name": self.company,
+				},
+			):
+				frappe.throw(
+					_("{0} does not belong to the {1}.").format(
+						_(self.meta.get_label(field)), bold(self.company)
+					)
+				)
 
 	def set_default_letter_head(self):
 		if hasattr(self, "letter_head") and not self.letter_head:
@@ -364,6 +390,24 @@ class AccountsController(TransactionBase):
 
 		for _doctype in repost_doctypes:
 			dt = frappe.qb.DocType(_doctype)
+
+			cancelled_entries = (
+				frappe.qb.from_(dt)
+				.select(dt.parent, dt.parenttype)
+				.where((dt.voucher_type == self.doctype) & (dt.voucher_no == self.name) & (dt.docstatus == 2))
+				.run(as_dict=True)
+			)
+
+			if cancelled_entries:
+				entries = "<br>".join([get_link_to_form(d.parenttype, d.parent) for d in cancelled_entries])
+
+				frappe.throw(
+					_(
+						"The following cancelled repost entries exist for <b>{0}</b>:<br><br>{1}<br><br>"
+						"Kindly delete these entries before continuing."
+					).format(self.name, entries)
+				)
+
 			rows = (
 				frappe.qb.from_(dt)
 				.select(dt.name, dt.parent, dt.parenttype)
@@ -2313,7 +2357,7 @@ class AccountsController(TransactionBase):
 
 	def validate_party(self):
 		party_type, party = self.get_party()
-		validate_party_frozen_disabled(party_type, party)
+		validate_party_frozen_disabled(self.company, party_type, party)
 
 	def get_party(self):
 		party_type = None
@@ -4167,3 +4211,130 @@ def update_gl_dict_with_regional_fields(doc, gl_dict):
 def update_gl_dict_with_app_based_fields(doc, gl_dict):
 	for method in frappe.get_hooks("update_gl_dict_with_app_based_fields", default=[]):
 		frappe.get_attr(method)(doc, gl_dict)
+
+
+@frappe.whitelist()
+def get_missing_company_details(doctype, docname):
+	from frappe.contacts.doctype.address.address import get_address_display_list
+
+	company = frappe.db.get_value(doctype, docname, "company")
+	if doctype == "Purchase Order":
+		company_address = frappe.db.get_value(doctype, docname, "billing_address")
+	else:
+		company_address = frappe.db.get_value(doctype, docname, "company_address")
+
+	company_details = frappe.get_value(
+		"Company", company, ["company_logo", "website", "phone_no", "email"], as_dict=True
+	)
+
+	required_fields = [
+		company_details.get("company_logo"),
+		company_details.get("phone_no"),
+		company_details.get("email"),
+	]
+
+	if not all(required_fields) and not frappe.has_permission("Company", "write", throw=False):
+		frappe.msgprint(
+			_(
+				"Some required Company details are missing. You don't have permission to update them. Please contact your System Manager."
+			)
+		)
+		return
+
+	if not company_address and not frappe.has_permission(doctype, "write", throw=False):
+		frappe.msgprint(
+			_(
+				"Company Address is missing. You don't have permission to update it. Please contact your System Manager."
+			)
+		)
+		return
+
+	address_display_list = get_address_display_list("Company", company)
+	address_line = address_display_list[0].get("address_line1") if address_display_list else ""
+
+	required_fields.append(company_address)
+	required_fields.append(address_line)
+
+	if all(required_fields):
+		return False
+	return {
+		"company_logo": company_details.get("company_logo"),
+		"website": company_details.get("website"),
+		"phone_no": company_details.get("phone_no"),
+		"email": company_details.get("email"),
+		"address_line": address_line,
+		"company": company,
+		"company_address": company_address,
+		"name": docname,
+	}
+
+
+@frappe.whitelist()
+def update_company_master_and_address(current_doctype, name, company, details):
+	from frappe.utils import validate_email_address
+
+	if isinstance(details, str):
+		details = frappe.parse_json(details)
+
+	if details.get("email"):
+		validate_email_address(details.get("email"), throw=True)
+
+	company_fields = ["company_logo", "website", "phone_no", "email"]
+	company_fields_to_update = {field: details.get(field) for field in company_fields if details.get(field)}
+
+	if company_fields_to_update:
+		frappe.db.set_value("Company", company, company_fields_to_update)
+
+	company_address = details.get("company_address")
+	if details.get("address_line1"):
+		address_doc = frappe.get_doc(
+			{
+				"doctype": "Address",
+				"address_title": details.get("address_title"),
+				"address_type": details.get("address_type"),
+				"address_line1": details.get("address_line1"),
+				"address_line2": details.get("address_line2"),
+				"city": details.get("city"),
+				"state": details.get("state"),
+				"pincode": details.get("pincode"),
+				"country": details.get("country"),
+				"is_your_company_address": 1,
+				"links": [{"link_doctype": "Company", "link_name": company}],
+			}
+		)
+		address_doc.insert()
+		company_address = address_doc.name
+
+	update_doc_company_address(current_doctype, name, company_address, details)
+
+
+def update_doc_company_address(current_doctype, docname, company_address, details):
+	if not company_address:
+		return
+
+	address_field_map = {
+		"Purchase Order": ("billing_address", "billing_address_display"),
+		"Sales Invoice": ("company_address", "company_address_display"),
+		"Delivery Note": ("company_address", "company_address_display"),
+		"POS Invoice": ("company_address", "company_address_display"),
+	}
+
+	address_field, display_field = address_field_map.get(
+		current_doctype, ("company_address", "company_address_display")
+	)
+
+	current_display = frappe.db.get_value(current_doctype, docname, display_field)
+
+	if current_display and not details.get("address_line1"):
+		return
+
+	from frappe.query_builder import DocType
+
+	DocType = DocType(current_doctype)
+
+	(
+		frappe.qb.update(DocType)
+		.set(getattr(DocType, address_field), company_address)
+		.set(getattr(DocType, display_field), get_address_display(company_address))
+		.where(DocType.name == docname)
+	).run()

erpnext/controllers/budget_controller.py

@@ -59,10 +59,8 @@ class BudgetValidation:
 		_obj.update(
 			{
 				"accumulated_monthly_budget": get_accumulated_monthly_budget(
-					self.budget_map[key].monthly_distribution,
+					self.budget_map[key].name,
 					self.doc_date,
-					self.fiscal_year,
-					self.budget_map[key].budget_amount,
 				)
 			}
 		)
@@ -164,16 +162,19 @@ class BudgetValidation:
 
 	def get_budget_records(self) -> list:
 		bud = qb.DocType("Budget")
-		bud_acc = qb.DocType("Budget Account")
+
 		query = (
 			qb.from_(bud)
-			.inner_join(bud_acc)
-			.on(bud.name == bud_acc.parent)
 			.select(
 				bud.name,
 				bud.budget_against,
 				bud.company,
-				bud.monthly_distribution,
+				bud.account,
+				bud.budget_amount,
+				bud.from_fiscal_year,
+				bud.to_fiscal_year,
+				bud.budget_start_date,
+				bud.budget_end_date,
 				bud.applicable_on_material_request,
 				bud.action_if_annual_budget_exceeded_on_mr,
 				bud.action_if_accumulated_monthly_budget_exceeded_on_mr,
@@ -186,13 +187,15 @@ class BudgetValidation:
 				bud.applicable_on_cumulative_expense,
 				bud.action_if_annual_exceeded_on_cumulative_expense,
 				bud.action_if_accumulated_monthly_exceeded_on_cumulative_expense,
-				bud_acc.account,
-				bud_acc.budget_amount,
 			)
-			.where(bud.docstatus.eq(1) & bud.fiscal_year.eq(self.fiscal_year) & bud.company.eq(self.company))
+			.where(
+				(bud.docstatus == 1)
+				& (bud.company == self.company)
+				& (bud.budget_start_date <= self.doc_date)
+				& (bud.budget_end_date >= self.doc_date)
+			)
 		)
 
-		# add dimension fields
 		for x in self.dimensions:
 			query = query.select(bud[x.get("fieldname")])
 
@@ -314,8 +317,8 @@ class BudgetValidation:
 					frappe.bold(key[2]),
 					frappe.bold(frappe.unscrub(key[0])),
 					frappe.bold(key[1]),
-					frappe.bold(fmt_money(annual_diff, currency=currency)),
 					frappe.bold(fmt_money(budget_amt, currency=currency)),
+					frappe.bold(fmt_money(annual_diff, currency=currency)),
 				)
 				self.execute_action(config.action_for_annual, _msg)
 
@@ -425,7 +428,7 @@ class BudgetValidation:
 				frappe.bold(key[2]),
 				frappe.bold(frappe.unscrub(key[0])),
 				frappe.bold(key[1]),
-				frappe.bold(fmt_money(v_map.accumulated_montly_budget, currency=currency)),
+				frappe.bold(fmt_money(v_map.accumulated_monthly_budget, currency=currency)),
 				self.budget_applicable_for(v_map, current_amt),
 				frappe.bold(fmt_money(monthly_diff, currency=currency)),
 			)

erpnext/controllers/sales_and_purchase_return.py

@@ -186,7 +186,7 @@ def validate_quantity(doc, key, args, ref, valid_items, already_returned_items):
 		frappe.get_meta(doc.doctype + " Item").get_field(
 			"stock_qty" if doc.get("update_stock", "") else "qty"
 		),
-		company_currency,
+		currency=company_currency,
 	)
 
 	for column in fields:
@@ -323,22 +323,24 @@ def get_returned_qty_map_for_row(return_against, party, row_name, doctype):
 		party_type = "customer"
 
 	fields = [
-		f"sum(abs(`tab{child_doctype}`.qty)) as qty",
+		{"SUM": [{"ABS": f"`tab{child_doctype}`.qty"}], "as": "qty"},
 	]
 
 	if doctype != "Subcontracting Receipt":
 		fields += [
-			f"sum(abs(`tab{child_doctype}`.stock_qty)) as stock_qty",
+			{"SUM": [{"ABS": f"`tab{child_doctype}`.stock_qty"}], "as": "stock_qty"},
 		]
 
 	if doctype in ("Purchase Receipt", "Purchase Invoice", "Subcontracting Receipt"):
 		fields += [
-			f"sum(abs(`tab{child_doctype}`.rejected_qty)) as rejected_qty",
-			f"sum(abs(`tab{child_doctype}`.received_qty)) as received_qty",
+			{"SUM": [{"ABS": f"`tab{child_doctype}`.rejected_qty"}], "as": "rejected_qty"},
+			{"SUM": [{"ABS": f"`tab{child_doctype}`.received_qty"}], "as": "received_qty"},
 		]
 
 		if doctype == "Purchase Receipt":
-			fields += [f"sum(abs(`tab{child_doctype}`.received_stock_qty)) as received_stock_qty"]
+			fields += [
+				{"SUM": [{"ABS": f"`tab{child_doctype}`.received_stock_qty"}], "as": "received_stock_qty"}
+			]
 
 	# Used retrun against and supplier and is_retrun because there is an index added for it
 	data = frappe.get_all(

erpnext/controllers/selling_controller.py

@@ -99,6 +99,7 @@ class SellingController(StockController):
 		# set contact and address details for customer, if they are not mentioned
 		self.set_missing_lead_customer_details(for_validate=for_validate)
 		self.set_price_list_and_item_details(for_validate=for_validate)
+		self.set_company_contact_person()
 
 	def set_missing_lead_customer_details(self, for_validate=False):
 		customer, lead = None, None
@@ -154,6 +155,13 @@ class SellingController(StockController):
 		self.set_price_list_currency("Selling")
 		self.set_missing_item_details(for_validate=for_validate)
 
+	def set_company_contact_person(self):
+		"""Set the Company's Default Sales Contact as Company Contact Person."""
+		if self.company and self.meta.has_field("company_contact_person") and not self.company_contact_person:
+			self.company_contact_person = frappe.get_cached_value(
+				"Company", self.company, "default_sales_contact"
+			)
+
 	def remove_shipping_charge(self):
 		if self.shipping_rule:
 			shipping_rule = frappe.get_last_doc("Shipping Rule", self.shipping_rule)

erpnext/controllers/status_updater.py

@@ -101,6 +101,7 @@ status_map = {
 		["Draft", None],
 		["To Bill", "eval:self.per_billed == 0 and self.docstatus == 1"],
 		["Partly Billed", "eval:self.per_billed > 0 and self.per_billed < 100 and self.docstatus == 1"],
+		["Return", "eval:self.is_return == 1 and self.per_billed == 0 and self.docstatus == 1"],
 		["Return Issued", "eval:self.per_returned == 100 and self.docstatus == 1"],
 		[
 			"Completed",
@@ -562,11 +563,14 @@ class StatusUpdater(Document):
 			fields=[target_ref_field, target_field],
 		)
 
-		sum_ref = sum(abs(record[target_ref_field]) for record in child_records)
+		# For operator dicts, the alias is in the "as" key; for strings, use the field name directly
+		ref_key = target_ref_field.get("as") if isinstance(target_ref_field, dict) else target_ref_field
+
+		sum_ref = sum(abs(record[ref_key]) for record in child_records)
 
 		if sum_ref > 0:
 			percentage = round(
-				sum(min(abs(record[target_field]), abs(record[target_ref_field])) for record in child_records)
+				sum(min(abs(record[target_field]), abs(record[ref_key])) for record in child_records)
 				/ sum_ref
 				* 100,
 				6,

erpnext/controllers/stock_controller.py

@@ -25,6 +25,7 @@ from erpnext.controllers.sales_and_purchase_return import (
 from erpnext.setup.doctype.brand.brand import get_brand_defaults
 from erpnext.setup.doctype.item_group.item_group import get_item_group_defaults
 from erpnext.stock import get_warehouse_account_map
+from erpnext.stock.doctype.batch.batch import get_batch_qty
 from erpnext.stock.doctype.inventory_dimension.inventory_dimension import (
 	get_evaluated_inventory_dimension,
 )
@@ -1183,6 +1184,109 @@ class StockController(AccountsController):
 			self.doctype, self.name, self.docstatus, via_landed_cost_voucher=via_landed_cost_voucher
 		)
 
+		self.validate_reserved_batches()
+
+	def validate_reserved_batches(self):
+		if not frappe.db.get_single_value("Stock Settings", "enable_stock_reservation"):
+			return
+
+		if self.doctype not in ["Delivery Note", "Sales Invoice", "Stock Entry"]:
+			return
+
+		batches = frappe.get_all(
+			"Serial and Batch Entry",
+			filters={
+				"voucher_type": self.doctype,
+				"voucher_no": self.name,
+				"docstatus": 1,
+				"batch_no": ("is", "set"),
+				"qty": ("<", 0),
+			},
+			pluck="batch_no",
+		)
+
+		if not batches:
+			return
+
+		field_mapper = {
+			"Sales Invoice": [["Sales Order", "sales_order"]],
+			"Delivery Note": [["Sales Order", "against_sales_order"]],
+			"Stock Entry": [
+				["Work Order", "work_order"],
+				["Subcontracting Inward Order", "subcontracting_inward_order"],
+			],
+		}.get(self.doctype)
+
+		qty_field = {
+			"Sales Invoice": "qty",
+			"Delivery Note": "qty",
+			"Stock Entry": "fg_completed_qty",
+		}.get(self.doctype)
+
+		reserved_batches_data = self.get_reserved_batches(batches)
+		items = self.items
+		if self.doctype == "Stock Entry":
+			items = [self]
+
+		for item in items:
+			for field in field_mapper:
+				if not item.get(field[1]):
+					continue
+
+				value = item.get(field[1])
+				for row in reserved_batches_data:
+					if self.doctype in ["Sales Invoice", "Delivery Note"] and row.item_code != item.get(
+						"item_code"
+					):
+						continue
+
+					if row.voucher_no == value:
+						continue
+
+					batch_qty = get_batch_qty(
+						row.batch_no,
+						row.warehouse,
+						posting_date=self.posting_date,
+						posting_time=self.posting_time,
+						consider_negative_batches=True,
+					)
+
+					if item.get(qty_field) < batch_qty:
+						continue
+
+					frappe.throw(
+						_(
+							"The batch {0} is already reserved in {1} {2}. So, cannot proceed with the {3} {4}, which is created against the {5} {6}."
+						).format(
+							frappe.bold(row.batch_no),
+							frappe.bold(row.voucher_type),
+							frappe.bold(row.voucher_no),
+							frappe.bold(self.doctype),
+							frappe.bold(self.name),
+							frappe.bold(field[0]),
+							frappe.bold(value),
+						),
+						title=_("Reserved Batch Conflict"),
+					)
+
+	def get_reserved_batches(self, batches):
+		doctype = frappe.qb.DocType("Stock Reservation Entry")
+		child_doc = frappe.qb.DocType("Serial and Batch Entry")
+
+		return (
+			frappe.qb.from_(doctype)
+			.join(child_doc)
+			.on(doctype.name == child_doc.parent)
+			.select(
+				child_doc.batch_no,
+				doctype.voucher_type,
+				doctype.voucher_no,
+				doctype.item_code,
+				doctype.warehouse,
+			)
+			.where((doctype.docstatus == 1) & (child_doc.batch_no.isin(batches)))
+		).run(as_dict=True)
+
 	def make_gl_entries_on_cancel(self, from_repost=False):
 		if not from_repost:
 			cancel_exchange_gain_loss_journal(frappe._dict(doctype=self.doctype, name=self.name))
@@ -1235,7 +1339,7 @@ class StockController(AccountsController):
 				total_returned += flt(item.returned_qty * item.rate)
 
 			if total_returned < total_amount:
-				target_ref_field = "(amount - (returned_qty * rate))"
+				target_ref_field = {"SUB": ["amount", {"MUL": ["returned_qty", "rate"]}], "as": "ref_amount"}
 
 		self._update_percent_field(
 			{
@@ -1541,7 +1645,7 @@ class StockController(AccountsController):
 				rule = frappe.db.get_value(
 					"Putaway Rule",
 					{"item_code": item.get("item_code"), "warehouse": item.get(warehouse_field)},
-					["name", "disable"],
+					["stock_capacity", "name", "disable"],
 					as_dict=True,
 				)
 				if rule:
@@ -1560,7 +1664,11 @@ class StockController(AccountsController):
 						rule_map[rule_name]["warehouse"] = item.get(warehouse_field)
 						rule_map[rule_name]["item"] = item.get("item_code")
 						rule_map[rule_name]["qty_put"] = 0
-						rule_map[rule_name]["capacity"] = get_available_putaway_capacity(rule_name)
+						rule_map[rule_name]["capacity"] = (
+							rule.stock_capacity
+							if self.doctype == "Stock Reconciliation"
+							else get_available_putaway_capacity(rule_name)
+						)
 					rule_map[rule_name]["qty_put"] += flt(stock_qty)
 
 			for rule, values in rule_map.items():

erpnext/controllers/subcontracting_controller.py

@@ -11,6 +11,7 @@ from frappe.model.mapper import get_mapped_doc
 from frappe.utils import cint, flt, get_link_to_form
 
 from erpnext.controllers.stock_controller import StockController
+from erpnext.stock.doctype.batch.batch import get_batch_qty
 from erpnext.stock.doctype.serial_and_batch_bundle.serial_and_batch_bundle import (
 	combine_datetime,
 	get_auto_batch_nos,
@@ -292,7 +293,7 @@ class SubcontractingController(StockController):
 		):
 			for row in frappe.get_all(
 				f"{self.subcontract_data.order_doctype} Item",
-				fields=["item_code", "(qty - received_qty) as qty", "parent", "name"],
+				fields=["item_code", {"SUB": ["qty", "received_qty"], "as": "qty"}, "parent", "name"],
 				filters={"docstatus": 1, "parent": ("in", self.subcontract_orders)},
 			):
 				self.qty_to_be_received[(row.item_code, row.parent)] += row.qty
@@ -549,11 +550,13 @@ class SubcontractingController(StockController):
 		if item.get("serial_and_batch_bundle"):
 			frappe.delete_doc("Serial and Batch Bundle", item.serial_and_batch_bundle, force=True)
 
-	def __get_materials_from_bom(self, item_code, bom_no, exploded_item=0):
+	def _get_materials_from_bom(self, item_code, bom_no, exploded_item=0):
 		data = []
 
 		doctype = "BOM Item" if not exploded_item else "BOM Explosion Item"
-		fields = [f"`tab{doctype}`.`stock_qty` / `tabBOM`.`quantity` as qty_consumed_per_unit"]
+		fields = [
+			{"DIV": [f"`tab{doctype}`.`stock_qty`", "`tabBOM`.`quantity`"], "as": "qty_consumed_per_unit"}
+		]
 
 		alias_dict = {
 			"item_code": "rm_item_code",
@@ -588,7 +591,7 @@ class SubcontractingController(StockController):
 		to_remove = []
 		for item in data:
 			if item.is_phantom_item:
-				data += self.__get_materials_from_bom(
+				data += self._get_materials_from_bom(
 					item.rm_item_code, item.bom_no, exploded_item=exploded_item
 				)
 				to_remove.append(item)
@@ -756,7 +759,11 @@ class SubcontractingController(StockController):
 					serial_nos = get_filtered_serial_nos(serial_nos, self, "supplied_items")
 					row.serial_no = "\n".join(serial_nos)
 
-			elif item_details.has_batch_no and not row.serial_and_batch_bundle and not row.batch_no:
+			elif (
+				item_details.has_batch_no
+				and not row.serial_and_batch_bundle
+				and (not row.batch_no or self.batch_has_not_available(row.batch_no, row.consumed_qty))
+			):
 				batches = get_auto_batch_nos(kwargs)
 				if batches:
 					consumed_qty = row.consumed_qty
@@ -781,6 +788,11 @@ class SubcontractingController(StockController):
 							)
 							consumed_qty -= d.get("qty")
 
+	def batch_has_not_available(self, batch_no, qty_required):
+		batch_qty = get_batch_qty(batch_no, self.supplier_warehouse, consider_negative_batches=True)
+
+		return batch_qty < qty_required
+
 	def update_rate_for_supplied_items(self):
 		if self.doctype != "Subcontracting Receipt":
 			return
@@ -919,7 +931,7 @@ class SubcontractingController(StockController):
 			if self.doctype == self.subcontract_data.order_doctype or (
 				self.backflush_based_on == "BOM" or self.is_return
 			):
-				for bom_item in self.__get_materials_from_bom(
+				for bom_item in self._get_materials_from_bom(
 					row.item_code, row.bom, row.get("include_exploded_items")
 				):
 					qty = flt(bom_item.qty_consumed_per_unit) * flt(row.qty) * row.conversion_factor

erpnext/controllers/taxes_and_totals.py

@@ -505,8 +505,9 @@ class calculate_taxes_and_totals:
 
 		for idx, d in enumerate(self.doc._item_wise_tax_details):
 			tax = d.get("tax")
-			if not tax:
+			if not tax or (tax.get("charge_type") == "Actual" and d.rate == 0):
 				continue
+
 			tax._total_tax_breakup += d.amount or 0
 			tax._last_row_idx = idx
 

erpnext/controllers/tests/test_accounts_controller.py

@@ -16,7 +16,10 @@ from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_pay
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.party import get_party_account
-from erpnext.buying.doctype.purchase_order.test_purchase_order import prepare_data_for_internal_transfer
+from erpnext.buying.doctype.purchase_order.test_purchase_order import (
+	create_purchase_order,
+	prepare_data_for_internal_transfer,
+)
 from erpnext.projects.doctype.project.test_project import make_project
 from erpnext.stock.doctype.item.test_item import create_item
 
@@ -2432,3 +2435,34 @@ class TestAccountsController(IntegrationTestCase):
 
 		# Second return should only get remaining discount (100 - 60 = 40)
 		self.assertEqual(return_si_2.discount_amount, -40)
+
+	def test_company_linked_address(self):
+		from erpnext.crm.doctype.prospect.test_prospect import make_address
+
+		company_address = make_address(
+			address_title="Company", address_type="Shipping", address_line1="100", city="Mumbai"
+		)
+		company_address.append("links", {"link_doctype": "Company", "link_name": "_Test Company"})
+		company_address.save()
+
+		customer_shipping = make_address(
+			address_title="Customer", address_type="Shipping", address_line1="10"
+		)
+		customer_shipping.append("links", {"link_doctype": "Customer", "link_name": "_Test Customer"})
+		customer_shipping.save()
+
+		supplier_billing = make_address(address_title="Supplier", address_line1="2", city="Ahmedabad")
+		supplier_billing.append("links", {"link_doctype": "Supplier", "link_name": "_Test Supplier"})
+		supplier_billing.save()
+
+		po = create_purchase_order(do_not_save=True)
+		po.shipping_address = customer_shipping.name
+		self.assertRaises(frappe.ValidationError, po.save)
+		po.shipping_address = company_address.name
+		po.save()
+
+		po.billing_address = supplier_billing.name
+		self.assertRaises(frappe.ValidationError, po.save)
+		po.billing_address = company_address.name
+		po.reload()
+		po.save()

erpnext/controllers/tests/test_item_wise_inventory_account.py

@@ -328,7 +328,7 @@ class TestItemWiseInventoryAccount(IntegrationTestCase):
 					"voucher_no": pr.name,
 					"item_code": ("in", items),
 				},
-				fields=["sum(stock_value_difference) as value"],
+				fields=[{"SUM": "stock_value_difference", "as": "value"}],
 			)
 
 			gl_value = frappe.db.get_value(
@@ -435,7 +435,7 @@ class TestItemWiseInventoryAccount(IntegrationTestCase):
 			sle_value = frappe.get_all(
 				"Stock Ledger Entry",
 				filters={"voucher_type": "Delivery Note", "voucher_no": dn.name, "item_code": ("in", items)},
-				fields=["sum(stock_value_difference) as value"],
+				fields=[{"SUM": "stock_value_difference", "as": "value"}],
 			)
 
 			gl_value = (

erpnext/crm/doctype/email_campaign/email_campaign.py

@@ -123,7 +123,7 @@ def send_mail(entry, email_campaign):
 		subject=frappe.render_template(email_template.get("subject"), context),
 		content=frappe.render_template(email_template.response_, context),
 		sender=sender,
-		recipients=recipient_list,
+		bcc=recipient_list,
 		communication_medium="Email",
 		sent_or_received="Sent",
 		send_email=True,

erpnext/crm/doctype/lead/lead.js

@@ -239,6 +239,7 @@ erpnext.LeadController = class LeadController extends frappe.ui.form.Controller
 		crm_activities.refresh();
 	}
 };
-if (this.frm) {
-	extend_cscript(this.frm.cscript, new erpnext.LeadController({ frm: this.frm }));
+
+if (cur_frm) {
+	extend_cscript(cur_frm.cscript, new erpnext.LeadController({ frm: cur_frm }));
 }

erpnext/crm/report/opportunity_summary_by_sales_stage/opportunity_summary_by_sales_stage.py

@@ -74,7 +74,7 @@ class OpportunitySummaryBySalesStage:
 		}[self.filters.get("based_on")]
 
 		data_based_on = {
-			"Number": "count(name) as count",
+			"Number": {"COUNT": "*", "as": "count"},
 			"Amount": "opportunity_amount as amount",
 		}[self.filters.get("data_based_on")]
 

erpnext/crm/report/sales_pipeline_analytics/sales_pipeline_analytics.py

@@ -8,6 +8,7 @@ from itertools import groupby
 import frappe
 from dateutil.relativedelta import relativedelta
 from frappe import _
+from frappe.query_builder.custom import Month, MonthName, Quarter
 from frappe.utils import cint, flt, getdate
 
 from erpnext.setup.utils import get_exchange_rate
@@ -74,7 +75,7 @@ class SalesPipelineAnalytics:
 		]
 
 		self.data_based_on = {
-			"Number": "count(name) as count",
+			"Number": {"COUNT": "*", "as": "count"},
 			"Amount": "opportunity_amount as amount",
 		}[self.filters.get("based_on")]
 
@@ -82,40 +83,52 @@ class SalesPipelineAnalytics:
 			self.filters.get("pipeline_by")
 		]
 
-		self.group_by_period = {
-			"Monthly": "month(expected_closing)",
-			"Quarterly": "QUARTER(expected_closing)",
-		}[self.filters.get("range")]
+		opp = frappe.qb.DocType("Opportunity")
+
+		if self.filters.get("range") == "Monthly":
+			self.group_by_period = Month(opp.expected_closing)
+			self.duration = MonthName(opp.expected_closing).as_("month")
+		else:
+			self.group_by_period = Quarter(opp.expected_closing)
+			self.duration = Quarter(opp.expected_closing).as_("quarter")
 
 		self.pipeline_by = {"Owner": "opportunity_owner", "Sales Stage": "sales_stage"}[
 			self.filters.get("pipeline_by")
 		]
 
-		self.duration = {
-			"Monthly": "monthname(expected_closing) as month",
-			"Quarterly": "QUARTER(expected_closing) as quarter",
-		}[self.filters.get("range")]
-
 		self.period_by = {"Monthly": "month", "Quarterly": "quarter"}[self.filters.get("range")]
 
 	def get_data(self):
 		self.get_fields()
 
+		opp = frappe.qb.DocType("Opportunity")
+		query = frappe.qb.get_query(
+			"Opportunity",
+			filters=self.get_conditions(),
+			ignore_permissions=True,
+		)
+
+		pipeline_field = opp._assign if self.group_by_based_on == "_assign" else opp.sales_stage
+
 		if self.filters.get("based_on") == "Number":
-			self.query_result = frappe.db.get_list(
-				"Opportunity",
-				filters=self.get_conditions(),
-				fields=[self.based_on, self.data_based_on, self.duration],
-				group_by=f"{self.group_by_based_on},{self.group_by_period}",
-				order_by=self.group_by_period,
+			self.query_result = (
+				query.select(
+					pipeline_field.as_(self.pipeline_by),
+					frappe.query_builder.functions.Count("*").as_("count"),
+					self.duration,
+				)
+				.groupby(pipeline_field, self.group_by_period)
+				.orderby(self.group_by_period)
+				.run(as_dict=True)
 			)
 
 		if self.filters.get("based_on") == "Amount":
-			self.query_result = frappe.db.get_list(
-				"Opportunity",
-				filters=self.get_conditions(),
-				fields=[self.based_on, self.data_based_on, self.duration, "currency"],
-			)
+			self.query_result = query.select(
+				pipeline_field.as_(self.pipeline_by),
+				opp.opportunity_amount.as_("amount"),
+				self.duration,
+				opp.currency,
+			).run(as_dict=True)
 
 			self.convert_to_base_currency()
 

erpnext/desktop_icon/banking.json

@@ -4,12 +4,13 @@
  "docstatus": 0,
  "doctype": "Desktop Icon",
  "hidden": 0,
+ "icon": "dollar-sign",
  "icon_type": "Link",
  "idx": 5,
  "label": "Banking",
  "link_to": "Bank Reconciliation Tool",
  "link_type": "DocType",
- "modified": "2025-11-17 13:34:23.484506",
+ "modified": "2025-11-19 15:57:20.139306",
  "modified_by": "Administrator",
  "name": "Banking",
  "owner": "Administrator",

erpnext/desktop_icon/home.json

@@ -10,7 +10,7 @@
  "label": "Home",
  "link_to": "Home",
  "link_type": "Workspace",
- "modified": "2025-11-17 20:57:59.794979",
+ "modified": "2025-11-20 16:09:28.269913",
  "modified_by": "Administrator",
  "name": "Home",
  "owner": "Administrator",

erpnext/desktop_icon/opening_&_closing.json

@@ -4,12 +4,13 @@
  "docstatus": 0,
  "doctype": "Desktop Icon",
  "hidden": 0,
+ "icon": "panel-top-open",
  "icon_type": "Link",
  "idx": 2,
  "label": "Opening & Closing",
  "link_to": "Period Closing Voucher",
  "link_type": "DocType",
- "modified": "2025-11-17 13:33:51.092576",
+ "modified": "2025-11-19 15:59:14.805915",
  "modified_by": "Administrator",
  "name": "Opening & Closing",
  "owner": "Administrator",

erpnext/desktop_icon/subscription.json

@@ -4,13 +4,13 @@
  "docstatus": 0,
  "doctype": "Desktop Icon",
  "hidden": 0,
- "icon": "accounting",
+ "icon": "monitor-check",
  "icon_type": "Link",
  "idx": 6,
  "label": "Subscription",
  "link_to": "Subscription",
  "link_type": "DocType",
- "modified": "2025-11-17 13:34:40.653317",
+ "modified": "2025-11-19 16:02:32.686833",
  "modified_by": "Administrator",
  "name": "Subscription",
  "owner": "Administrator",

erpnext/desktop_icon/taxes.json

@@ -4,12 +4,13 @@
  "docstatus": 0,
  "doctype": "Desktop Icon",
  "hidden": 0,
+ "icon": "book-text",
  "icon_type": "Link",
  "idx": 3,
  "label": "Taxes",
  "link_to": "Item Tax Template",
  "link_type": "DocType",
- "modified": "2025-11-17 13:34:03.502433",
+ "modified": "2025-11-19 15:58:21.226664",
  "modified_by": "Administrator",
  "name": "Taxes",
  "owner": "Administrator",