chore: resolve conflicts

Co-authored-by: Deepesh Garg <deepeshgarg6@gmail.com>
(cherry picked from commit a74e1f1600)

# Conflicts:
#	erpnext/selling/doctype/customer/customer.py

.github/CONTRIBUTING.md

@@ -6,7 +6,7 @@ Feature requests are also a great way to take the product forward. New ideas can
 
 When you are raising an Issue, you should keep a few things in mind. Remember that the developer does not have access to your machine so you must give all the information you can while raising an Issue. If you are suggesting a feature, you should be very clear about what you want.
 
-The Issue list is not the right place to ask a question or start a general discussion. If you want to do that , then the right place is the forum [https://discuss.frappe.io](https://discuss.frappe.io/c/erpnext/6).
+The Issue list is not the right place to ask a question or start a general discussion. If you want to do that , then the right place is the forum [https://discuss.erpnext.com](https://discuss.erpnext.com).
 
 ### Reply and Closing Policy
 

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -9,7 +9,7 @@ body:
         Welcome to ERPNext issue tracker! Before creating an issue, please heed the following:
 
         1. This tracker should only be used to report bugs and request features / enhancements to ERPNext
-            - For questions and general support, checkout the [user manual](https://docs.erpnext.com/) or use [forum](https://discuss.frappe.io/c/erpnext/6)
+            - For questions and general support, checkout the [user manual](https://docs.erpnext.com/) or use [forum](https://discuss.erpnext.com)
             - For documentation issues, propose edit on [documentation site](https://docs.erpnext.com/) directly.
         2. When making a bug report, make sure you provide all required information. The easier it is for
            maintainers to reproduce, the faster it'll be fixed.

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,5 @@
 blank_issues_enabled: false
 contact_links:
   - name: Community Forum
-    url: https://discuss.frappe.io/c/erpnext/6
+    url: https://discuss.erpnext.com/
     about: For general QnA, discussions and community help.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -11,7 +11,7 @@ assignees: ''
 Welcome to ERPNext issue tracker! Before creating an issue, please heed the following:
 
 1. This tracker should only be used to report bugs and request features / enhancements to ERPNext
-    - For questions and general support, checkout the manual https://docs.erpnext.com or use https://discuss.frappe.io/c/erpnext/6
+    - For questions and general support, checkout the manual https://erpnext.com/docs/user/manual/en or use https://discuss.erpnext.com
 2. Use the search function before creating a new issue. Duplicates will be closed and directed to
    the original discussion.
 3. When making a feature request, make sure to be as verbose as possible. The better you convey your message, the greater the drive to make it happen.
@@ -21,7 +21,7 @@ Please keep in mind that we get many many requests and we can't possibly work on
 
 If you're in urgent need to a feature, please try the following channels to get paid developments done quickly:
 1. Certified ERPNext partners: https://erpnext.com/partners 
-2. Developer community on ERPNext forums: https://discuss.frappe.io/c/framework/5  
+2. Developer community on ERPNext forums: https://discuss.erpnext.com/c/developers/5 
 3. Telegram group for ERPNext/Frappe development work: https://t.me/erpnext_opps 
 
 -->

.github/workflows/patch_faux.yml

@@ -1,25 +0,0 @@
-# Tests are skipped for these files but github doesn't allow "passing" hence this is required.
-
-name: Skipped Patch Test
-
-on:
-  pull_request:
-    paths:
-      - "**.js"
-      - "**.css"
-      - "**.md"
-      - "**.html"
-      - "**.csv"
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    name: Patch Test
-
-    steps:
-      - name: Pass skipped tests unconditionally
-        run: "echo Skipped"

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

@@ -1,27 +0,0 @@
-# Tests are skipped for these files but github doesn't allow "passing" hence this is required.
-
-name: Skipped Tests
-
-on:
-  pull_request:
-    paths:
-      - "**.js"
-      - "**.css"
-      - "**.md"
-      - "**.html"
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        container: [1, 2, 3, 4]
-
-    name: Python Unit Tests
-
-    steps:
-      - name: Pass skipped tests unconditionally
-        run: "echo Skipped"

CODEOWNERS

@@ -3,21 +3,22 @@
 # These owners will be the default owners for everything in
 # the repo. Unless a later match takes precedence,
 
-erpnext/accounts/               @ruthra-kumar
-erpnext/assets/                 @khushi8112
-erpnext/regional                @ruthra-kumar
-erpnext/selling                 @ruthra-kumar
-erpnext/support/                @ruthra-kumar
+erpnext/accounts/               @deepeshgarg007 @ruthra-kumar
+erpnext/assets/                 @khushi8112 @deepeshgarg007
+erpnext/regional                @deepeshgarg007 @ruthra-kumar
+erpnext/selling                 @deepeshgarg007 @ruthra-kumar
+erpnext/support/                @deepeshgarg007
+pos*                            
 
-erpnext/buying/                 @rohitwaghchaure @mihir-kandoi
+erpnext/buying/                 @rohitwaghchaure
 erpnext/maintenance/            @rohitwaghchaure
-erpnext/manufacturing/          @rohitwaghchaure @mihir-kandoi
+erpnext/manufacturing/          @rohitwaghchaure
 erpnext/quality_management/     @rohitwaghchaure
-erpnext/stock/                  @rohitwaghchaure @mihir-kandoi
-erpnext/subcontracting          @mihir-kandoi
+erpnext/stock/                  @rohitwaghchaure
+erpnext/subcontracting          @rohitwaghchaure
 
-erpnext/controllers/            @ruthra-kumar @rohitwaghchaure @mihir-kandoi
-erpnext/patches/                @ruthra-kumar
+erpnext/controllers/            @deepeshgarg007 @rohitwaghchaure
+erpnext/patches/                @deepeshgarg007 
 
-.github/                        @ruthra-kumar
+.github/                        @deepeshgarg007
 pyproject.toml                  @akhilnarang

README.md

@@ -64,7 +64,7 @@ New passwords will be created for the ERPNext "Administrator" user, the MariaDB
 
 1. [Frappe School](https://school.frappe.io) - Learn Frappe Framework and ERPNext from the various courses by the maintainers or from the community.
 2. [Official documentation](https://docs.erpnext.com/) - Extensive documentation for ERPNext.
-3. [Discussion Forum](https://discuss.frappe.io/c/erpnext/6) - Engage with community of ERPNext users and service providers.
+3. [Discussion Forum](https://discuss.erpnext.com/) - Engage with community of ERPNext users and service providers.
 4. [Telegram Group](https://erpnext_public.t.me) - Get instant help from huge community of users.
 
 

erpnext/__init__.py

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

erpnext/accounts/deferred_revenue.py

@@ -46,8 +46,7 @@ def validate_service_stop_date(doc):
 		if (
 			old_stop_dates
 			and old_stop_dates.get(item.name)
-			and item.service_stop_date
-			and getdate(item.service_stop_date) != getdate(old_stop_dates.get(item.name))
+			and item.service_stop_date != old_stop_dates.get(item.name)
 		):
 			frappe.throw(_("Cannot change Service Stop Date for item in row {0}").format(item.idx))
 

erpnext/accounts/doctype/account/account.py

@@ -110,7 +110,6 @@ class Account(NestedSet):
 		self.validate_parent_child_account_type()
 		self.validate_root_details()
 		self.validate_account_number()
-		self.validate_disabled()
 		self.validate_group_or_ledger()
 		self.set_root_and_report_type()
 		self.validate_mandatory()
@@ -170,7 +169,7 @@ class Account(NestedSet):
 			if par.root_type:
 				self.root_type = par.root_type
 
-		if cint(self.is_group):
+		if self.is_group:
 			db_value = self.get_doc_before_save()
 			if db_value:
 				if self.report_type != db_value.report_type:
@@ -213,7 +212,7 @@ class Account(NestedSet):
 		if doc_before_save and not doc_before_save.parent_account:
 			throw(_("Root cannot be edited."), RootNotEditable)
 
-		if not self.parent_account and not cint(self.is_group):
+		if not self.parent_account and not self.is_group:
 			throw(_("The root account {0} must be a group").format(frappe.bold(self.name)))
 
 	def validate_root_company_and_sync_account_to_children(self):
@@ -255,14 +254,6 @@ class Account(NestedSet):
 
 			self.create_account_for_child_company(parent_acc_name_map, descendants, parent_acc_name)
 
-	def validate_disabled(self):
-		doc_before_save = self.get_doc_before_save()
-		if not doc_before_save or cint(doc_before_save.disabled) == cint(self.disabled):
-			return
-
-		if cint(self.disabled):
-			self.validate_default_accounts_in_company()
-
 	def validate_group_or_ledger(self):
 		doc_before_save = self.get_doc_before_save()
 		if not doc_before_save or cint(doc_before_save.is_group) == cint(self.is_group):
@@ -270,35 +261,12 @@ class Account(NestedSet):
 
 		if self.check_gle_exists():
 			throw(_("Account with existing transaction cannot be converted to ledger"))
-		elif cint(self.is_group):
+		elif self.is_group:
 			if self.account_type and not self.flags.exclude_account_type_check:
 				throw(_("Cannot covert to Group because Account Type is selected."))
-			self.validate_default_accounts_in_company()
 		elif self.check_if_child_exists():
 			throw(_("Account with child nodes cannot be set as ledger"))
 
-	def validate_default_accounts_in_company(self):
-		default_account_fields = get_company_default_account_fields()
-
-		company_default_accounts = frappe.db.get_value(
-			"Company", self.company, list(default_account_fields.keys()), as_dict=1
-		)
-
-		msg = _("Account {0} cannot be disabled as it is already set as {1} for {2}.")
-
-		if not self.disabled:
-			msg = _("Account {0} cannot be converted to Group as it is already set as {1} for {2}.")
-
-		for d in default_account_fields:
-			if company_default_accounts.get(d) == self.name:
-				throw(
-					msg.format(
-						frappe.bold(self.name),
-						frappe.bold(default_account_fields.get(d)),
-						frappe.bold(self.company),
-					)
-				)
-
 	def validate_frozen_accounts_modifier(self):
 		doc_before_save = self.get_doc_before_save()
 		if not doc_before_save or doc_before_save.freeze_account == self.freeze_account:
@@ -336,9 +304,7 @@ class Account(NestedSet):
 			self.account_currency = frappe.get_cached_value("Company", self.company, "default_currency")
 			self.currency_explicitly_specified = False
 
-		gl_currency = frappe.db.get_value(
-			"GL Entry", {"account": self.name, "is_cancelled": 0}, "account_currency"
-		)
+		gl_currency = frappe.db.get_value("GL Entry", {"account": self.name}, "account_currency")
 
 		if gl_currency and self.account_currency != gl_currency:
 			if frappe.db.get_value("GL Entry", {"account": self.name}):
@@ -659,27 +625,3 @@ def _ensure_idle_system():
 			).format(pretty_date(last_gl_update)),
 			title=_("System In Use"),
 		)
-
-
-def get_company_default_account_fields():
-	return {
-		"default_bank_account": "Default Bank Account",
-		"default_cash_account": "Default Cash Account",
-		"default_receivable_account": "Default Receivable Account",
-		"default_payable_account": "Default Payable Account",
-		"default_expense_account": "Default Expense Account",
-		"default_income_account": "Default Income Account",
-		"stock_received_but_not_billed": "Stock Received But Not Billed Account",
-		"stock_adjustment_account": "Stock Adjustment Account",
-		"write_off_account": "Write Off Account",
-		"default_discount_account": "Default Payment Discount Account",
-		"unrealized_profit_loss_account": "Unrealized Profit / Loss Account",
-		"exchange_gain_loss_account": "Exchange Gain / Loss Account",
-		"unrealized_exchange_gain_loss_account": "Unrealized Exchange Gain / Loss Account",
-		"round_off_account": "Round Off Account",
-		"default_deferred_revenue_account": "Default Deferred Revenue Account",
-		"default_deferred_expense_account": "Default Deferred Expense Account",
-		"accumulated_depreciation_account": "Accumulated Depreciation Account",
-		"depreciation_expense_account": "Depreciation Expense Account",
-		"disposal_account": "Gain/Loss Account on Asset Disposal",
-	}

erpnext/accounts/doctype/account/account_tree.js

@@ -286,14 +286,12 @@ frappe.treeview_settings["Account"] = {
 			label: __("View Ledger"),
 			click: function (node, btn) {
 				frappe.route_options = {
+					account: node.label,
 					from_date: erpnext.utils.get_fiscal_year(frappe.datetime.get_today(), true)[1],
 					to_date: erpnext.utils.get_fiscal_year(frappe.datetime.get_today(), true)[2],
 					company:
 						frappe.treeview_settings["Account"].treeview.page.fields_dict.company.get_value(),
 				};
-				if (node.parent_label) {
-					frappe.route_options["account"] = node.label;
-				}
 				frappe.set_route("query-report", "General Ledger");
 			},
 			btnClass: "hidden-xs",

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

@@ -1,817 +0,0 @@
-{
-	"country_code": "au",
-	"name": "Australia - Chart of Accounts with Account Numbers",
-	"tree": {
-		"Assets": {
-			"Current Assets": {
-				"Cash On Hand": {
-					"Cash On Hand": {
-						"account_number": "11010",
-						"account_type": "Cash"
-					},
-					"account_number": "110",
-					"is_group": 1
-				},
-				"Cash at Bank": {
-					"Every Day Bank Account": {
-						"account_number": "11510",
-						"account_type": "Bank"
-					},
-					"Business Savings Account": {
-						"account_number": "11520"
-					},
-					"Business Term Deposit": {
-						"account_number": "11530"
-					},
-					"account_number": "115",
-					"is_group": 1
-				},
-				"Trade Receivables": {
-					"Trade Debtors": {
-						"account_number": "12010",
-						"account_type": "Receivable"
-					},
-					"Provision for Doubtful Debts": {
-						"account_number": "12020"
-					},
-					"Sundry Debtors": {
-						"account_number": "12030"
-					},
-					"Debtor Refund": {
-						"account_number": "12040"
-					},
-					"account_number": "120",
-					"is_group": 1
-				},
-				"Inventory": {
-					"Stock On Hand": {
-						"account_number": "13010",
-						"account_type": "Stock"
-					},
-					"WIP - Work In Progress - Manufacturing": {
-						"account_number": "13020"
-					},
-					"account_number": "130",
-					"is_group": 1
-				},
-				"Prepayments": {
-					"Prepayments": {
-						"account_number": "14010"
-					},
-					"Provisional Tax Paid": {
-						"account_number": "14020"
-					},
-					"account_number": "140",
-					"is_group": 1
-				},
-				"account_number": "11",
-				"is_group": 1
-			},
-			"Non Current Assets": {
-				"Plant & Equipment": {
-					"Plant & Equipment": {
-						"account_number": "16010",
-						"account_type": "Fixed Asset"
-					},
-					"Accumulated Depreciation Plant & Equipment": {
-						"account_number": "16020",
-						"account_type": "Accumulated Depreciation"
-					},
-					"account_number": "160",
-					"is_group": 1
-				},
-				"Motor Vehicle": {
-					"Motor Vehicle": {
-						"account_number": "16110",
-						"account_type": "Fixed Asset"
-					},
-					"Accumulated Depreciation Motor Vehicle": {
-						"account_number": "16120",
-						"account_type": "Accumulated Depreciation"
-					},
-					"account_number": "161",
-					"is_group": 1
-				},
-				"Office Equipment": {
-					"Office Furniture & Equipment": {
-						"account_number": "16210",
-						"account_type": "Fixed Asset"
-					},
-					"Accumulated Depreciation Office Furniture & Equipment": {
-						"account_number": "16220",
-						"account_type": "Accumulated Depreciation"
-					},
-					"account_number": "162",
-					"is_group": 1
-				},
-				"Computer Equipment": {
-					"Computer Equipment": {
-						"account_number": "16310",
-						"account_type": "Fixed Asset"
-					},
-					"Accumulated Depreciation Computer Equipment": {
-						"account_number": "16320",
-						"account_type": "Accumulated Depreciation"
-					},
-					"account_number": "163",
-					"is_group": 1
-				},
-				"Building": {
-					"Buildings": {
-						"account_number": "16410",
-						"account_type": "Fixed Asset"
-					},
-					"Accumulated Depreciation Buildings": {
-						"account_number": "16420",
-						"account_type": "Accumulated Depreciation"
-					},
-					"CWIP - Construction Work In Progress": {
-						"account_number": "16430",
-						"account_type": "Capital Work in Progress"
-					},
-					"Accumulated Depreciation - Others": {
-						"account_number": "16440",
-						"account_type": "Accumulated Depreciation"
-					},
-					"account_number": "164",
-					"is_group": 1
-				},
-				"Related Party": {
-					"Loan to Party 1": {
-						"account_number": "17010"
-					},
-					"account_number": "170",
-					"is_group": 1
-				},
-				"Investments & Unlisted Entities": {
-					"Investment - Entity 1": {
-						"account_number": "17510"
-					},
-					"account_number": "175",
-					"is_group": 1
-				},
-				"Intagible Assets": {
-					"Goodwill": {
-						"account_number": "18010"
-					},
-					"Opening Balance Temporary ": {
-						"account_number": "18090",
-						"account_type": "Temporary"
-					},
-					"account_number": "180",
-					"is_group": 1
-				},
-				"account_number": "16",
-				"is_group": 1
-			},
-			"account_number": "1",
-			"root_type": "Asset"
-		},
-		"Liabilities": {
-			"Current Liabilities": {
-				"Trade Payables - Current": {
-					"Trade Creditors": {
-						"account_number": "21010",
-						"account_type": "Payable"
-					},
-					"Goods Received Not Invoiced": {
-						"account_number": "21050",
-						"account_type": "Stock Received But Not Billed"
-					},
-					"Service Received Not Invoiced": {
-						"account_number": "21060"
-					},
-					"Asset Received Not Invoiced": {
-						"account_number": "21070",
-						"account_type": "Asset Received But Not Billed"
-					},
-					"account_number": "210",
-					"is_group": 1
-				},
-				"Other Payables - Current": {
-					"Accrued Expenses": {
-						"account_number": "21510"
-					},
-					"Payroll - Wages Clearing": {
-						"account_number": "21550"
-					},
-					"Payroll - Superannuation Deductions": {
-						"account_number": "21555"
-					},
-					"Payroll - Misc Deductions": {
-						"account_number": "21560"
-					},
-					"Payroll - Withholding Tax Payable": {
-						"account_number": "21565"
-					},
-					"account_number": "215",
-					"is_group": 1
-				},
-				"GST": {
-					"GST Payments to ATO": {
-						"account_number": "22030"
-					},
-					"Provision for PAYG Tax": {
-						"account_number": "22040"
-					},
-					"account_number": "220",
-					"account_type": "Tax",
-					"is_group": 1
-				},
-				"Interest & Non Bearing Liabilities - Current": {
-					"Credit Card - VISA": {
-						"account_number": "22510"
-					},
-					"account_number": "225",
-					"is_group": 1
-				},
-				"Bank Overdraft": {
-					"Bank Overdraft  Cash at Bank": {
-						"account_number": "23010"
-					},
-					"account_number": "230",
-					"is_group": 1
-				},
-				"Trade Finance": {
-					"Trade Finance": {
-						"account_number": "23510"
-					},
-					"account_number": "235",
-					"is_group": 1
-				},
-				"Lease Liabilities": {
-					"Finance Lease - Current": {
-						"account_number": "24010"
-					},
-					"account_number": "240",
-					"is_group": 1
-				},
-				"Provisions": {
-					"Provision for Long Service Leave": {
-						"account_number": "24510"
-					},
-					"Provision for Holiday Pay": {
-						"account_number": "24520"
-					},
-					"account_number": "245",
-					"is_group": 1
-				},
-				"account_number": "21",
-				"is_group": 1
-			},
-			"Non Current Liabilities": {
-				"Trade & Other Payables - Non Current": {
-					"Loan Account - Party 1": {
-						"account_number": "25010"
-					},
-					"account_number": "250",
-					"is_group": 1
-				},
-				"Interest & Non Bearing Liabilities - Non Current": {
-					"Non Current Liability - Director Loan": {
-						"account_number": "25510"
-					},
-					"account_number": "255",
-					"is_group": 1
-				},
-				"Bank Loans - Non Current": {
-					"Bank Loan 1 - Non Current": {
-						"account_number": "26010"
-					},
-					"account_number": "260",
-					"is_group": 1
-				},
-				"Lease Liabilities - Non Current": {
-					"Finance Lease - Non Current": {
-						"account_number": "27010"
-					},
-					"account_number": "270",
-					"is_group": 1
-				},
-				"Provisions - Non Current": {
-					"Provision for Long Service Leave": {
-						"account_number": "27510"
-					},
-					"Provision for Holiday Pay": {
-						"account_number": "27520"
-					},
-					"account_number": "275",
-					"is_group": 1
-				},
-				"account_number": "25",
-				"is_group": 1
-			},
-			"account_number": "2",
-			"root_type": "Liability"
-		},
-		"Equity": {
-			"Equity": {
-				"Owner's/Shareholder's Equity": {
-					"Owner's/Shareholders Capital": {
-						"account_number": "31010",
-						"account_type": "Equity"
-					},
-					"Owner's/Shareholders Drawings": {
-						"account_number": "31020",
-						"account_type": "Equity"
-					},
-					"account_number": "310",
-					"is_group": 1
-				},
-				"Earnings": {
-					"Current Year Earnings": {
-						"account_number": "35010",
-						"account_type": "Equity"
-					},
-					"Retained Earnings": {
-						"account_number": "35020",
-						"account_type": "Equity"
-					},
-					"account_number": "350",
-					"is_group": 1
-				},
-				"account_number": "31",
-				"is_group": 1
-			},
-			"account_number": "3",
-			"root_type": "Equity"
-		},
-		"Revenue": {
-			"Revenue": {
-				"Sales Revenue": {
-					"Sales Income": {
-						"account_number": "41010",
-						"account_type": "Income Account"
-					},
-					"Freight Income": {
-						"account_number": "41020",
-						"account_type": "Income Account"
-					},
-					"Other Income": {
-						"account_number": "41030",
-						"account_type": "Income Account"
-					},
-					"Service Income": {
-						"account_number": "41040",
-						"account_type": "Income Account"
-					},
-					"account_number": "410",
-					"is_group": 1
-				},
-				"Other Revenue": {
-					"Commission Received": {
-						"account_number": "42010"
-					},
-					"Discounts Received": {
-						"account_number": "42020"
-					},
-					"Interest received": {
-						"account_number": "42030"
-					},
-					"Profit/Loss on Sales of Assets": {
-						"account_number": "42040"
-					},
-					"Rent Received": {
-						"account_number": "42050"
-					},
-					"Sundry Income": {
-						"account_number": "42060"
-					},
-					"account_number": "420",
-					"is_group": 1
-				},
-				"account_number": "41",
-				"is_group": 1
-			},
-			"account_number": "4",
-			"root_type": "Income"
-		},
-		"Cost of Goods": {
-			"Cost of Goods": {
-				"Cost of Goods Sold": {
-					"Cost of Goods Sold": {
-						"account_number": "51010",
-						"account_type": "Cost of Goods Sold"
-					},
-					"Freight Expenses (sales related)": {
-						"account_number": "51020"
-					},
-					"Discounts Given": {
-						"account_number": "51030"
-					},
-					"Subcontracting Charges": {
-						"account_number": "51040"
-					},
-					"account_number": "510",
-					"is_group": 1
-				},
-				"Other COGS": {
-					"Purchases - Miscellaneous": {
-						"account_number": "52010"
-					},
-					"Duty & Customs Fees": {
-						"account_number": "52020",
-						"account_type": "Tax"
-					},
-					"Freight Inwards": {
-						"account_number": "52030",
-						"account_type": "Chargeable"
-					},
-					"Stock Adjustment": {
-						"account_number": "52040",
-						"account_type": "Stock Adjustment"
-					},
-					"Stock Wirte Off": {
-						"account_number": "52050",
-						"account_type": "Stock Adjustment"
-					},
-					"Stock Valuation Expenses": {
-						"account_number": "52060",
-						"account_type": "Expenses Included In Valuation"
-					},
-					"Asset Valuation Expenses": {
-						"account_number": "52070",
-						"account_type": "Expenses Included In Asset Valuation"
-					},
-					"account_number": "520",
-					"is_group": 1
-				},
-				"account_number": "51",
-				"is_group": 1
-			},
-			"account_number": "5",
-			"root_type": "Expense"
-		},
-		"Expenses": {
-			"Fixed Expenses": {
-				"Payroll & Related Expenses": {
-					"Salaries & Wages": {
-						"account_number": "61010"
-					},
-					"Superannuation": {
-						"account_number": "61015"
-					},
-					"Staff Amenities - GST Paid": {
-						"account_number": "61020"
-					},
-					"Staff Amenities - GST Free": {
-						"account_number": "61025"
-					},
-					"Staff Recruitment": {
-						"account_number": "61030"
-					},
-					"Staff Training": {
-						"account_number": "61035"
-					},
-					"Fringe Benefits Tax": {
-						"account_number": "61040"
-					},
-					"Payroll Tax": {
-						"account_number": "61045"
-					},
-					"Workers Compensation": {
-						"account_number": "61050"
-					},
-					"Long Service Leave": {
-						"account_number": "61060"
-					},
-					"Mileage Reimbursement": {
-						"account_number": "61070"
-					},
-					"Overtime": {
-						"account_number": "61080"
-					},
-					"Worksafe Insurance": {
-						"account_number": "61090"
-					},
-					"account_number": "610",
-					"is_group": 1
-				},
-				"Depreciation Expenses": {
-					"Depreciation - Plant & Equipment": {
-						"account_number": "62010",
-						"account_type": "Depreciation"
-					},
-					"Depreciation - Motor Vehicle": {
-						"account_number": "62020",
-						"account_type": "Depreciation"
-					},
-					"Depreciation - Office Equipment": {
-						"account_number": "62030",
-						"account_type": "Depreciation"
-					},
-					"Depreciation - Computer Equipment": {
-						"account_number": "62040",
-						"account_type": "Depreciation"
-					},
-					"Depreciation - Building": {
-						"account_number": "62050",
-						"account_type": "Depreciation"
-					},
-					"Depreciation - Others": {
-						"account_number": "62510",
-						"account_type": "Depreciation"
-					},
-					"account_number": "620",
-					"is_group": 1
-				},
-				"account_number": "61",
-				"is_group": 1
-			},
-			"Accrued Expenses": {
-				"Accrued Expenses": {
-					"Accrued Expenses - Salaries & Wages": {
-						"account_number": "63010"
-					},
-					"Accrued Expenses - Interest": {
-						"account_number": "63020"
-					},
-					"account_number": "630",
-					"is_group": 1
-				},
-				"account_number": "63",
-				"is_group": 1
-			},
-			"Operating Expenses": {
-				"General and Administrative Expenses": {
-					"Low Value Assets less than $300": {
-						"account_number": "64010"
-					},
-					"Office Supplies": {
-						"account_number": "64020"
-					},
-					"Postage & Courier": {
-						"account_number": "64025"
-					},
-					"Printing & Stationery": {
-						"account_number": "64030"
-					},
-					"Registration Fees / Filing Fees": {
-						"account_number": "64040"
-					},
-					"Travel & Accommodation - Local": {
-						"account_number": "64050"
-					},
-					"Travel & Accommodation - Overseas": {
-						"account_number": "64060"
-					},
-					"Relocation Costs": {
-						"account_number": "64070"
-					},
-					"Hire Charges": {
-						"account_number": "64080"
-					},
-					"Repairs & Maintenance": {
-						"account_number": "64210"
-					},
-					"Cleaning Expenses": {
-						"account_number": "64215"
-					},
-					"Uniforms": {
-						"account_number": "64220"
-					},
-					"Security": {
-						"account_number": "64225"
-					},
-					"Subscriptions & Licences": {
-						"account_number": "64510"
-					},
-					"Software Expenses": {
-						"account_number": "64515"
-					},
-					"Marketing Expenses": {
-						"account_number": "64520"
-					},
-					"Advertising Expenses": {
-						"account_number": "64525"
-					},
-					"Website Hosting & Domain Expenses": {
-						"account_number": "64530"
-					},
-					"Computer Repairs / Supplies": {
-						"account_number": "64540"
-					},
-					"Conferences": {
-						"account_number": "64550"
-					},
-					"Consultancy /Contract Services": {
-						"account_number": "64560"
-					},
-					"Training Services": {
-						"account_number": "64570"
-					},
-					"Workshop Supplies": {
-						"account_number": "64580"
-					},
-					"Consumables": {
-						"account_number": "64585"
-					},
-					"Entertainment Expenses - Deductible": {
-						"account_number": "64810"
-					},
-					"Entertainment Expenses - Non Deductible": {
-						"account_number": "64820"
-					},
-					"Amortisation Of Goodwill": {
-						"account_number": "64910"
-					},
-					"General / Miscellaneous Expenses": {
-						"account_number": "64915",
-						"account_type": "Chargeable"
-					},
-					"Donations": {
-						"account_number": "64920"
-					},
-					"Client Gifts": {
-						"account_number": "64930"
-					},
-					"Employee Gifts": {
-						"account_number": "64935"
-					},
-					"account_number": "640",
-					"is_group": 1
-				},
-				"Occupancy Expenses": {
-					"Rental Expenses": {
-						"account_number": "65010"
-					},
-					"Property Insurance": {
-						"account_number": "65020"
-					},
-					"Electricity Expenses": {
-						"account_number": "65030"
-					},
-					"Water Rates": {
-						"account_number": "65040"
-					},
-					"Gas Expenses": {
-						"account_number": "65050"
-					},
-					"Property Taxes": {
-						"account_number": "65060"
-					},
-					"Rates": {
-						"account_number": "65070"
-					},
-					"account_number": "650",
-					"is_group": 1
-				},
-				"Communication & Vehicle Expenses": {
-					"Internet Expenses": {
-						"account_number": "66010"
-					},
-					"Mobile Telephone": {
-						"account_number": "66020"
-					},
-					"Telephone Expenses": {
-						"account_number": "66030"
-					},
-					"Motor Vehicle - Fuel Expenses": {
-						"account_number": "66040"
-					},
-					"Motor Vehicle - Parking & Tolls": {
-						"account_number": "66050"
-					},
-					"Motor Vehicle - Registration & Insurance": {
-						"account_number": "66060"
-					},
-					"Motor Vehicle - Service & Repairs": {
-						"account_number": "66070"
-					},
-					"Taxi": {
-						"account_number": "66080"
-					},
-					"account_number": "660",
-					"is_group": 1
-				},
-				"account_number": "64",
-				"is_group": 1
-			},
-			"Non-Operating Expenses": {
-				"Finance Costs": {
-					"Interest - Bank Loans": {
-						"account_number": "67010"
-					},
-					"Interest - Finance Leases": {
-						"account_number": "67020"
-					},
-					"Interest  - Other Loans": {
-						"account_number": "67025"
-					},
-					"Insurance": {
-						"account_number": "67030"
-					},
-					"Bank Charges": {
-						"account_number": "67050"
-					},
-					"Rounding off": {
-						"account_number": "67055",
-						"account_type": "Round Off"
-					},
-					"Audit Fees": {
-						"account_number": "67060"
-					},
-					"Accounting Fees": {
-						"account_number": "67070"
-					},
-					"Legal Fees": {
-						"account_number": "67080"
-					},
-					"Management Fees": {
-						"account_number": "67090"
-					},
-					"account_number": "670",
-					"is_group": 1
-				},
-				"Other Costs": {
-					"Doubtful Debts": {
-						"account_number": "67510"
-					},
-					"Fines": {
-						"account_number": "67520"
-					},
-					"Debt Collection": {
-						"account_number": "67530"
-					},
-					"Bad Debts": {
-						"account_number": "67540"
-					},
-					"account_number": "675",
-					"is_group": 1
-				},
-				"account_number": "67",
-				"is_group": 1
-			},
-			"Variable Expenses": {
-				"Variable Expenses": {
-					"Bonus & Commissions Paid": {
-						"account_number": "68010"
-					},
-					"Bonus & Commissions To be Paid": {
-						"account_number": "68020"
-					},
-					"Warranty Claims": {
-						"account_number": "68030"
-					},
-					"account_number": "680",
-					"is_group": 1
-				},
-				"account_number": "68",
-				"is_group": 1
-			},
-			"account_number": "6",
-			"root_type": "Expense"
-		},
-		"Other Income": {
-			"Other Income": {
-				"Interest Income": {
-					"Interest Income": {
-						"account_number": "71010"
-					},
-					"account_number": "710",
-					"is_group": 1
-				},
-				"Asset Disposal Income": {
-					"Gain on Asset Disposal": {
-						"account_number": "73010"
-					},
-					"account_number": "730",
-					"is_group": 1
-				},
-				"account_number": "71",
-				"is_group": 1
-			},
-			"account_number": "7",
-			"root_type": "Income"
-		},
-		"Other Expenses": {
-			"Other Expenses": {
-				"Income Tax Expenses": {
-					"Income Tax Expenses": {
-						"account_number": "81010"
-					},
-					"account_number": "810",
-					"is_group": 1
-				},
-				"Foreign Exchange Gain/Loss": {
-					"Exchange Loss/Gain - Realized": {
-						"account_number": "82010"
-					},
-					"account_number": "820",
-					"is_group": 1
-				},
-				"Asset Disposal Expenses": {
-					"Loss on Asset Disposal": {
-						"account_number": "83010"
-					},
-					"account_number": "830",
-					"is_group": 1
-				},
-				"account_number": "81",
-				"is_group": 1
-			},
-			"account_number": "8",
-			"root_type": "Expense"
-		}
-	}
-}

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

@@ -13,7 +13,7 @@ def get():
 				_("Bank Accounts"): {"account_type": "Bank", "is_group": 1},
 				_("Cash In Hand"): {_("Cash"): {"account_type": "Cash"}, "account_type": "Cash"},
 				_("Loans and Advances (Assets)"): {
-					_("Employee Advances"): {"account_type": "Payable"},
+					_("Employee Advances"): {},
 				},
 				_("Securities and Deposits"): {_("Earnest Money"): {}},
 				_("Stock Assets"): {

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

@@ -20,7 +20,7 @@ def get():
 					"account_number": "1100",
 				},
 				_("Loans and Advances (Assets)"): {
-					_("Employee Advances"): {"account_number": "1610", "account_type": "Payable"},
+					_("Employee Advances"): {"account_number": "1610"},
 					"account_number": "1600",
 				},
 				_("Securities and Deposits"): {

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -111,15 +111,17 @@ class AccountingDimension(Document):
 def make_dimension_in_accounting_doctypes(doc, doclist=None):
 	if not doclist:
 		doclist = get_doctypes_with_dimensions()
+
 	doc_count = len(get_accounting_dimensions())
 	count = 0
-	repostable_doctypes = get_allowed_types_from_settings(child_doc=True)
+	repostable_doctypes = get_allowed_types_from_settings()
 
 	for doctype in doclist:
 		if (doc_count + 1) % 2 == 0:
 			insert_after_field = "dimension_col_break"
 		else:
 			insert_after_field = "accounting_dimensions_section"
+
 		df = {
 			"fieldname": doc.fieldname,
 			"label": doc.label,
@@ -309,8 +311,8 @@ def get_dimensions(with_cost_center_and_project=False):
 	if with_cost_center_and_project:
 		dimension_filters.extend(
 			[
-				frappe._dict({"fieldname": "cost_center", "document_type": "Cost Center"}),
-				frappe._dict({"fieldname": "project", "document_type": "Project"}),
+				{"fieldname": "cost_center", "document_type": "Cost Center"},
+				{"fieldname": "project", "document_type": "Project"},
 			]
 		)
 

erpnext/accounts/doctype/accounting_dimension_filter/accounting_dimension_filter.json

@@ -7,7 +7,6 @@
  "engine": "InnoDB",
  "field_order": [
   "accounting_dimension",
-  "fieldname",
   "disabled",
   "column_break_2",
   "company",
@@ -91,17 +90,11 @@
    "fieldname": "apply_restriction_on_values",
    "fieldtype": "Check",
    "label": "Apply restriction on dimension values"
-  },
-  {
-   "fieldname": "fieldname",
-   "fieldtype": "Data",
-   "hidden": 1,
-   "label": "Fieldname"
   }
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2025-08-08 14:13:22.203011",
+ "modified": "2023-06-07 14:59:41.869117",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounting Dimension Filter",
@@ -146,8 +139,8 @@
   }
  ],
  "quick_entry": 1,
- "sort_field": "creation",
+ "sort_field": "modified",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/accounting_dimension_filter/accounting_dimension_filter.py

@@ -17,16 +17,17 @@ class AccountingDimensionFilter(Document):
 		from frappe.types import DF
 
 		from erpnext.accounts.doctype.allowed_dimension.allowed_dimension import AllowedDimension
-		from erpnext.accounts.doctype.applicable_on_account.applicable_on_account import ApplicableOnAccount
+		from erpnext.accounts.doctype.applicable_on_account.applicable_on_account import (
+			ApplicableOnAccount,
+		)
 
-		accounting_dimension: DF.Literal[None]
+		accounting_dimension: DF.Literal
 		accounts: DF.Table[ApplicableOnAccount]
 		allow_or_restrict: DF.Literal["Allow", "Restrict"]
 		apply_restriction_on_values: DF.Check
 		company: DF.Link
 		dimensions: DF.Table[AllowedDimension]
 		disabled: DF.Check
-		fieldname: DF.Data | None
 	# end: auto-generated types
 
 	def before_save(self):
@@ -36,10 +37,6 @@ class AccountingDimensionFilter(Document):
 			self.set("dimensions", [])
 
 	def validate(self):
-		self.fieldname = frappe.db.get_value(
-			"Accounting Dimension", {"document_type": self.accounting_dimension}, "fieldname"
-		) or frappe.scrub(self.accounting_dimension)  # scrub to handle default accounting dimension
-
 		self.validate_applicable_accounts()
 
 	def validate_applicable_accounts(self):
@@ -75,7 +72,7 @@ def get_dimension_filter_map():
 			"""
 			SELECT
 				a.applicable_on_account, d.dimension_value, p.accounting_dimension,
-				p.allow_or_restrict, p.fieldname, a.is_mandatory
+				p.allow_or_restrict, a.is_mandatory
 			FROM
 				`tabApplicable On Account` a,
 				`tabAccounting Dimension Filter` p
@@ -90,6 +87,8 @@ def get_dimension_filter_map():
 		dimension_filter_map = {}
 
 		for f in filters:
+			f.fieldname = scrub(f.accounting_dimension)
+
 			build_map(
 				dimension_filter_map,
 				f.fieldname,

erpnext/accounts/doctype/accounts_settings/accounts_settings.js

@@ -26,20 +26,9 @@ frappe.ui.form.on("Accounts Settings", {
 	add_taxes_from_taxes_and_charges_template(frm) {
 		toggle_tax_settings(frm, "add_taxes_from_taxes_and_charges_template");
 	},
-
 	add_taxes_from_item_tax_template(frm) {
 		toggle_tax_settings(frm, "add_taxes_from_item_tax_template");
 	},
-
-	drop_ar_procedures: function (frm) {
-		frm.call({
-			doc: frm.doc,
-			method: "drop_ar_sql_procedures",
-			callback: function (r) {
-				frappe.show_alert(__("Procedures dropped"), 5);
-			},
-		});
-	},
 });
 
 function toggle_tax_settings(frm, field_name) {

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -41,7 +41,6 @@
   "show_payment_schedule_in_print",
   "item_price_settings_section",
   "maintain_same_internal_transaction_rate",
-  "fetch_valuation_rate_for_internal_transaction",
   "column_break_feyo",
   "maintain_same_rate_action",
   "role_to_override_stop_action",
@@ -56,9 +55,6 @@
   "reconciliation_queue_size",
   "column_break_resa",
   "exchange_gain_loss_posting_date",
-  "payment_entry_settings",
-  "show_account_balance",
-  "show_party_balance",
   "invoicing_settings_tab",
   "accounts_transactions_settings_section",
   "over_billing_allowance",
@@ -78,7 +74,6 @@
   "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",
@@ -93,13 +88,10 @@
   "receivable_payable_remarks_length",
   "accounts_receivable_payable_tuning_section",
   "receivable_payable_fetch_method",
-  "column_break_ntmi",
-  "drop_ar_procedures",
   "legacy_section",
   "ignore_is_opening_check_for_reporting",
   "payment_request_settings",
-  "create_pr_in_draft_status",
-  "column_break_xrnd"
+  "create_pr_in_draft_status"
  ],
  "fields": [
   {
@@ -560,7 +552,7 @@
    "fieldname": "receivable_payable_fetch_method",
    "fieldtype": "Select",
    "label": "Data Fetch Method",
-   "options": "Buffered Cursor\nUnBuffered Cursor\nRaw SQL"
+   "options": "Buffered Cursor\nUnBuffered Cursor"
   },
   {
    "fieldname": "accounts_receivable_payable_tuning_section",
@@ -617,46 +609,6 @@
    "fieldname": "add_taxes_from_taxes_and_charges_template",
    "fieldtype": "Check",
    "label": "Automatically Add Taxes from Taxes and Charges Template"
-  },
-  {
-   "fieldname": "column_break_ntmi",
-   "fieldtype": "Column Break"
-  },
-  {
-   "depends_on": "eval:doc.receivable_payable_fetch_method == \"Raw SQL\"",
-   "description": "Drops existing SQL Procedures and Function setup by Accounts Receivable report",
-   "fieldname": "drop_ar_procedures",
-   "fieldtype": "Button",
-   "label": "Drop Procedures"
-  },
-  {
-   "default": "0",
-   "fieldname": "fetch_valuation_rate_for_internal_transaction",
-   "fieldtype": "Check",
-   "label": "Fetch Valuation Rate for Internal Transaction"
-  },
-  {
-   "default": "1",
-   "fieldname": "use_legacy_controller_for_pcv",
-   "fieldtype": "Check",
-   "label": "Use Legacy Controller For Period Closing Voucher"
-  },
-  {
-   "fieldname": "payment_entry_settings",
-   "fieldtype": "Section Break",
-   "label": "Payment Entry Settings"
-  },
-  {
-   "default": "0",
-   "fieldname": "show_account_balance",
-   "fieldtype": "Check",
-   "label": "Show Account Balance"
-  },
-  {
-   "default": "0",
-   "fieldname": "show_party_balance",
-   "fieldtype": "Check",
-   "label": "Show Party Balance"
   }
  ],
  "icon": "icon-cog",
@@ -664,7 +616,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2025-11-06 17:48:07.682837",
+ "modified": "2025-06-23 15:55:33.346398",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",
@@ -689,9 +641,8 @@
   }
  ],
  "quick_entry": 1,
- "row_format": "Dynamic",
  "sort_field": "modified",
  "sort_order": "ASC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -48,7 +48,6 @@ class AccountsSettings(Document):
 		enable_immutable_ledger: DF.Check
 		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
@@ -59,23 +58,20 @@ class AccountsSettings(Document):
 		merge_similar_account_heads: DF.Check
 		over_billing_allowance: DF.Currency
 		post_change_gl_entries: DF.Check
-		receivable_payable_fetch_method: DF.Literal["Buffered Cursor", "UnBuffered Cursor", "Raw SQL"]
+		receivable_payable_fetch_method: DF.Literal["Buffered Cursor", "UnBuffered Cursor"]
 		receivable_payable_remarks_length: DF.Int
 		reconciliation_queue_size: DF.Int
 		role_allowed_to_over_bill: DF.Link | None
 		role_to_override_stop_action: DF.Link | None
 		round_row_wise_tax: DF.Check
-		show_account_balance: DF.Check
 		show_balance_in_coa: DF.Check
 		show_inclusive_tax_in_print: DF.Check
-		show_party_balance: DF.Check
 		show_payment_schedule_in_print: DF.Check
 		show_taxes_as_table_in_print: DF.Check
 		stale_days: DF.Int
 		submit_journal_entries: DF.Check
 		unlink_advance_payment_on_cancelation_of_order: DF.Check
 		unlink_payment_on_cancellation_of_invoice: DF.Check
-		use_legacy_controller_for_pcv: DF.Check
 	# end: auto-generated types
 
 	def validate(self):
@@ -107,7 +103,6 @@ class AccountsSettings(Document):
 			frappe.clear_cache()
 
 		self.validate_and_sync_auto_reconcile_config()
-		self.hide_or_show_party_and_account_balance()
 
 	def validate_stale_days(self):
 		if not self.allow_stale and cint(self.stale_days) <= 0:
@@ -115,18 +110,6 @@ class AccountsSettings(Document):
 				_("Stale Days should start from 1."), title="Error", indicator="red", raise_exception=1
 			)
 
-	def hide_or_show_party_and_account_balance(self):
-		def set_property(fieldname, value):
-			make_property_setter("Payment Entry", fieldname, "hidden", value, "Check")
-
-		if self.has_value_changed("show_party_balance"):
-			set_property("party_balance", not self.show_party_balance)
-
-		if self.has_value_changed("show_account_balance"):
-			account_fields = ["paid_from_account_balance", "paid_to_account_balance"]
-			for field in account_fields:
-				set_property(field, not self.show_account_balance)
-
 	def enable_payment_schedule_in_print(self):
 		show_in_print = cint(self.show_payment_schedule_in_print)
 		for doctype in ("Sales Order", "Sales Invoice", "Purchase Order", "Purchase Invoice"):
@@ -164,16 +147,8 @@ class AccountsSettings(Document):
 		if self.add_taxes_from_item_tax_template and self.add_taxes_from_taxes_and_charges_template:
 			frappe.throw(
 				_("You cannot enable both the settings '{0}' and '{1}'.").format(
-					frappe.bold(_(self.meta.get_label("add_taxes_from_item_tax_template"))),
-					frappe.bold(_(self.meta.get_label("add_taxes_from_taxes_and_charges_template"))),
+					frappe.bold(self.meta.get_label("add_taxes_from_item_tax_template")),
+					frappe.bold(self.meta.get_label("add_taxes_from_taxes_and_charges_template")),
 				),
 				title=_("Auto Tax Settings Error"),
 			)
-
-	@frappe.whitelist()
-	def drop_ar_sql_procedures(self):
-		from erpnext.accounts.report.accounts_receivable.accounts_receivable import InitSQLProceduresForAR
-
-		frappe.db.sql(f"drop function if exists {InitSQLProceduresForAR.genkey_function_name}")
-		frappe.db.sql(f"drop procedure if exists {InitSQLProceduresForAR.init_procedure_name}")
-		frappe.db.sql(f"drop procedure if exists {InitSQLProceduresForAR.allocate_procedure_name}")

erpnext/accounts/doctype/advance_payment_ledger_entry/advance_payment_ledger_entry.json

@@ -12,8 +12,7 @@
   "against_voucher_no",
   "amount",
   "currency",
-  "event",
-  "delinked"
+  "event"
  ],
  "fields": [
   {
@@ -69,20 +68,12 @@
    "label": "Company",
    "options": "Company",
    "read_only": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "delinked",
-   "fieldtype": "Check",
-   "label": "DeLinked",
-   "read_only": 1
   }
  ],
- "grid_page_length": 50,
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2025-10-13 15:11:58.300836",
+ "modified": "2024-11-05 10:31:28.736671",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Advance Payment Ledger Entry",
@@ -116,8 +107,7 @@
    "share": 1
   }
  ],
- "row_format": "Dynamic",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/advance_payment_ledger_entry/advance_payment_ledger_entry.py

@@ -1,11 +1,9 @@
 # Copyright (c) 2024, Frappe Technologies Pvt. Ltd. and contributors
 # For license information, please see license.txt
 
-import frappe
+# import frappe
 from frappe.model.document import Document
 
-from erpnext.accounts.utils import get_advance_payment_doctypes, update_voucher_outstanding
-
 
 class AdvancePaymentLedgerEntry(Document):
 	# begin: auto-generated types
@@ -21,28 +19,9 @@ class AdvancePaymentLedgerEntry(Document):
 		amount: DF.Currency
 		company: DF.Link | None
 		currency: DF.Link | None
-		delinked: DF.Check
 		event: DF.Data | None
 		voucher_no: DF.DynamicLink | None
 		voucher_type: DF.Link | None
 	# end: auto-generated types
 
-	def on_update(self):
-		if (
-			self.against_voucher_type in get_advance_payment_doctypes()
-			and self.flags.update_outstanding == "Yes"
-			and not frappe.flags.is_reverse_depr_entry
-		):
-			update_voucher_outstanding(self.against_voucher_type, self.against_voucher_no, None, None, None)
-
-
-def on_doctype_update():
-	frappe.db.add_index(
-		"Advance Payment Ledger Entry",
-		["against_voucher_type", "against_voucher_no"],
-	)
-
-	frappe.db.add_index(
-		"Advance Payment Ledger Entry",
-		["voucher_type", "voucher_no"],
-	)
+	pass

erpnext/accounts/doctype/advance_taxes_and_charges/advance_taxes_and_charges.json

@@ -16,7 +16,6 @@
   "accounting_dimensions_section",
   "cost_center",
   "dimension_col_break",
-  "project",
   "section_break_8",
   "rate",
   "section_break_9",
@@ -93,13 +92,6 @@
    "fieldname": "dimension_col_break",
    "fieldtype": "Column Break"
   },
-  {
-    "allow_on_submit": 1,
-    "fieldname": "project",
-    "fieldtype": "Link",
-    "label": "Project",
-    "options": "Project"
-  },
   {
    "fieldname": "section_break_8",
    "fieldtype": "Section Break"

erpnext/accounts/doctype/bank_account/bank_account.json

@@ -132,8 +132,7 @@
    "fieldtype": "Data",
    "in_list_view": 1,
    "label": "IBAN",
-   "length": 34,
-   "options": "IBAN"
+   "length": 30
   },
   {
    "fieldname": "column_break_12",
@@ -209,7 +208,6 @@
    "label": "Disabled"
   }
  ],
- "grid_page_length": 50,
  "links": [
   {
    "group": "Transactions",
@@ -252,7 +250,7 @@
    "link_fieldname": "default_bank_account"
   }
  ],
- "modified": "2025-08-29 12:32:01.081687",
+ "modified": "2024-10-30 09:41:14.113414",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account",
@@ -284,7 +282,6 @@
    "write": 1
   }
  ],
- "row_format": "Dynamic",
  "search_fields": "bank,account",
  "sort_field": "modified",
  "sort_order": "DESC",

erpnext/accounts/doctype/bank_account/bank_account.py

@@ -9,8 +9,7 @@ from frappe.contacts.address_and_contact import (
 	load_address_and_contact,
 )
 from frappe.model.document import Document
-from frappe.utils import comma_and, get_link_to_form, validate_iban
-from frappe.utils.deprecations import deprecated
+from frappe.utils import comma_and, get_link_to_form
 
 
 class BankAccount(Document):
@@ -53,6 +52,7 @@ class BankAccount(Document):
 
 	def validate(self):
 		self.validate_company()
+		self.validate_iban()
 		self.validate_account()
 		self.update_default_bank_account()
 
@@ -72,10 +72,34 @@ class BankAccount(Document):
 		if self.is_company_account and not self.company:
 			frappe.throw(_("Company is manadatory for company account"))
 
-	@deprecated
 	def validate_iban(self):
-		"""Kept for backward compatibility, will be removed in v16."""
-		validate_iban(self.iban, throw=True)
+		"""
+		Algorithm: https://en.wikipedia.org/wiki/International_Bank_Account_Number#Validating_the_IBAN
+		"""
+		# IBAN field is optional
+		if not self.iban:
+			return
+
+		def encode_char(c):
+			# Position in the alphabet (A=1, B=2, ...) plus nine
+			return str(9 + ord(c) - 64)
+
+		# remove whitespaces, upper case to get the right number from ord()
+		iban = "".join(self.iban.split(" ")).upper()
+
+		# Move country code and checksum from the start to the end
+		flipped = iban[4:] + iban[:4]
+
+		# Encode characters as numbers
+		encoded = [encode_char(c) if ord(c) >= 65 and ord(c) <= 90 else c for c in flipped]
+
+		try:
+			to_check = int("".join(encoded))
+		except ValueError:
+			frappe.throw(_("IBAN is not valid"))
+
+		if to_check % 97 != 1:
+			frappe.throw(_("IBAN is not valid"))
 
 	def update_default_bank_account(self):
 		if self.is_default and not self.disabled:
@@ -85,7 +109,6 @@ class BankAccount(Document):
 					"party_type": self.party_type,
 					"party": self.party,
 					"is_company_account": self.is_company_account,
-					"company": self.company,
 					"is_default": 1,
 					"disabled": 0,
 				},

erpnext/accounts/doctype/bank_account/test_bank_account.py

@@ -3,8 +3,45 @@
 
 import unittest
 
+import frappe
+from frappe import ValidationError
+
 # test_records = frappe.get_test_records('Bank Account')
 
 
 class TestBankAccount(unittest.TestCase):
-	pass
+	def test_validate_iban(self):
+		valid_ibans = [
+			"GB82 WEST 1234 5698 7654 32",
+			"DE91 1000 0000 0123 4567 89",
+			"FR76 3000 6000 0112 3456 7890 189",
+		]
+
+		invalid_ibans = [
+			# wrong checksum (3rd place)
+			"GB72 WEST 1234 5698 7654 32",
+			"DE81 1000 0000 0123 4567 89",
+			"FR66 3000 6000 0112 3456 7890 189",
+		]
+
+		bank_account = frappe.get_doc({"doctype": "Bank Account"})
+
+		try:
+			bank_account.validate_iban()
+		except AttributeError:
+			msg = "BankAccount.validate_iban() failed for empty IBAN"
+			self.fail(msg=msg)
+
+		for iban in valid_ibans:
+			bank_account.iban = iban
+			try:
+				bank_account.validate_iban()
+			except ValidationError:
+				msg = f"BankAccount.validate_iban() failed for valid IBAN {iban}"
+				self.fail(msg=msg)
+
+		for not_iban in invalid_ibans:
+			bank_account.iban = not_iban
+			msg = f"BankAccount.validate_iban() accepted invalid IBAN {not_iban}"
+			with self.assertRaises(ValidationError, msg=msg):
+				bank_account.validate_iban()

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -118,9 +118,8 @@ class BankClearance(Document):
 
 				else:
 					# using db_set to trigger notification
-					frappe.db.set_value(
-						d.payment_document, d.payment_entry, "clearance_date", d.clearance_date
-					)
+					payment_entry = frappe.get_doc(d.payment_document, d.payment_entry)
+					payment_entry.db_set("clearance_date", d.clearance_date)
 
 				clearance_date_updated = True
 
@@ -137,10 +136,8 @@ def get_payment_entries_for_bank_clearance(
 	entries = []
 
 	condition = ""
-	pe_condition = ""
 	if not include_reconciled_entries:
 		condition = "and (clearance_date IS NULL or clearance_date='0000-00-00')"
-		pe_condition = "and (pe.clearance_date IS NULL or pe.clearance_date='0000-00-00')"
 
 	journal_entries = frappe.db.sql(
 		f"""
@@ -165,20 +162,19 @@ def get_payment_entries_for_bank_clearance(
 	payment_entries = frappe.db.sql(
 		f"""
 			select
-				"Payment Entry" as payment_document, pe.name as payment_entry,
-				pe.reference_no as cheque_number, pe.reference_date as cheque_date,
-				if(pe.paid_from=%(account)s, pe.paid_amount + if(pe.payment_type = 'Pay' and c.default_currency = pe.paid_from_account_currency, pe.base_total_taxes_and_charges, pe.total_taxes_and_charges) , 0) as credit,
-				if(pe.paid_from=%(account)s, 0, pe.received_amount + pe.total_taxes_and_charges) as debit,
-				pe.posting_date, ifnull(pe.party,if(pe.paid_from=%(account)s,pe.paid_to,pe.paid_from)) as against_account, pe.clearance_date,
-				if(pe.paid_to=%(account)s, pe.paid_to_account_currency, pe.paid_from_account_currency) as account_currency
-			from `tabPayment Entry` as pe
-			join `tabCompany` c on c.name = pe.company
+				"Payment Entry" as payment_document, name as payment_entry,
+				reference_no as cheque_number, reference_date as cheque_date,
+				if(paid_from=%(account)s, paid_amount + total_taxes_and_charges, 0) as credit,
+				if(paid_from=%(account)s, 0, received_amount + total_taxes_and_charges) as debit,
+				posting_date, ifnull(party,if(paid_from=%(account)s,paid_to,paid_from)) as against_account, clearance_date,
+				if(paid_to=%(account)s, paid_to_account_currency, paid_from_account_currency) as account_currency
+			from `tabPayment Entry`
 			where
-				(pe.paid_from=%(account)s or pe.paid_to=%(account)s) and pe.docstatus=1
-				and pe.posting_date >= %(from)s and pe.posting_date <= %(to)s
-				{pe_condition}
+				(paid_from=%(account)s or paid_to=%(account)s) and docstatus=1
+				and posting_date >= %(from)s and posting_date <= %(to)s
+				{condition}
 			order by
-				pe.posting_date ASC, pe.name DESC
+				posting_date ASC, name DESC
 		""",
 		{
 			"account": account,

erpnext/accounts/doctype/bank_guarantee/bank_guarantee.js

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

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -9,7 +9,7 @@ from frappe import _
 from frappe.model.document import Document
 from frappe.query_builder.custom import ConstantColumn
 from frappe.query_builder.functions import Sum
-from frappe.utils import cint, create_batch, flt
+from frappe.utils import cint, flt
 
 from erpnext import get_default_cost_center
 from erpnext.accounts.doctype.bank_transaction.bank_transaction import get_total_allocated_amount
@@ -377,17 +377,16 @@ def auto_reconcile_vouchers(
 	bank_transactions = get_bank_transactions(bank_account)
 
 	if len(bank_transactions) > 10:
-		for bank_transaction_batch in create_batch(bank_transactions, 1000):
-			frappe.enqueue(
-				method="erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.start_auto_reconcile",
-				queue="long",
-				bank_transactions=bank_transaction_batch,
-				from_date=from_date,
-				to_date=to_date,
-				filter_by_reference_date=filter_by_reference_date,
-				from_reference_date=from_reference_date,
-				to_reference_date=to_reference_date,
-			)
+		frappe.enqueue(
+			method="erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.start_auto_reconcile",
+			queue="long",
+			bank_transactions=bank_transactions,
+			from_date=from_date,
+			to_date=to_date,
+			filter_by_reference_date=filter_by_reference_date,
+			from_reference_date=from_reference_date,
+			to_reference_date=to_reference_date,
+		)
 		frappe.msgprint(_("Auto Reconciliation has started in the background"))
 	else:
 		start_auto_reconcile(

erpnext/accounts/doctype/bank_transaction/bank_transaction.json

@@ -38,10 +38,7 @@
   "column_break_3czf",
   "bank_party_name",
   "bank_party_account_number",
-  "bank_party_iban",
-  "extended_bank_statement_section",
-  "included_fee",
-  "excluded_fee"
+  "bank_party_iban"
  ],
  "fields": [
   {
@@ -119,14 +116,15 @@
   {
    "allow_on_submit": 1,
    "fieldname": "reference_number",
-   "fieldtype": "Small Text",
+   "fieldtype": "Data",
    "label": "Reference Number"
   },
   {
    "fieldname": "transaction_id",
    "fieldtype": "Data",
    "label": "Transaction ID",
-   "read_only": 1
+   "read_only": 1,
+   "unique": 1
   },
   {
    "allow_on_submit": 1,
@@ -225,8 +223,7 @@
   {
    "fieldname": "bank_party_iban",
    "fieldtype": "Data",
-   "label": "Party IBAN (Bank Statement)",
-   "options": "IBAN"
+   "label": "Party IBAN (Bank Statement)"
   },
   {
    "fieldname": "bank_party_account_number",
@@ -236,32 +233,12 @@
   {
    "fieldname": "column_break_oufv",
    "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "extended_bank_statement_section",
-   "fieldtype": "Section Break",
-   "label": "Extended Bank Statement"
-  },
-  {
-   "fieldname": "included_fee",
-   "fieldtype": "Currency",
-   "label": "Included Fee",
-   "non_negative": 1,
-   "options": "currency"
-  },
-  {
-   "description": "On save, the Excluded Fee will be converted to an Included Fee.",
-   "fieldname": "excluded_fee",
-   "fieldtype": "Currency",
-   "label": "Excluded Fee",
-   "non_negative": 1,
-   "options": "currency"
   }
  ],
  "grid_page_length": 50,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-12-07 20:49:18.600757",
+ "modified": "2025-06-18 17:24:57.044666",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Transaction",

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -32,13 +32,11 @@ class BankTransaction(Document):
 		date: DF.Date | None
 		deposit: DF.Currency
 		description: DF.SmallText | None
-		excluded_fee: DF.Currency
-		included_fee: DF.Currency
 		naming_series: DF.Literal["ACC-BTN-.YYYY.-"]
 		party: DF.DynamicLink | None
 		party_type: DF.Link | None
 		payment_entries: DF.Table[BankTransactionPayments]
-		reference_number: DF.SmallText | None
+		reference_number: DF.Data | None
 		status: DF.Literal["", "Pending", "Settled", "Unreconciled", "Reconciled", "Cancelled"]
 		transaction_id: DF.Data | None
 		transaction_type: DF.Data | None
@@ -47,11 +45,9 @@ class BankTransaction(Document):
 	# end: auto-generated types
 
 	def before_validate(self):
-		self.handle_excluded_fee()
 		self.update_allocated_amount()
 
 	def validate(self):
-		self.validate_included_fee()
 		self.validate_duplicate_references()
 		self.validate_currency()
 
@@ -311,40 +307,6 @@ class BankTransaction(Document):
 
 		self.party_type, self.party = result
 
-	def validate_included_fee(self):
-		"""
-		The included_fee is only handled for withdrawals. An included_fee for a deposit, is not credited to the account and is
-		therefore outside of the deposit value and can be larger than the deposit itself.
-		"""
-
-		if self.included_fee and self.withdrawal:
-			if self.included_fee > self.withdrawal:
-				frappe.throw(_("Included fee is bigger than the withdrawal itself."))
-
-	def handle_excluded_fee(self):
-		# Include the excluded fee on validate to handle all further processing the same
-		excluded_fee = flt(self.excluded_fee)
-		if excluded_fee <= 0:
-			return
-
-		# Suppress a negative deposit (aka withdrawal), likely not intendend
-		if flt(self.deposit) > 0 and (flt(self.deposit) - excluded_fee) < 0:
-			frappe.throw(_("The Excluded Fee is bigger than the Deposit it is deducted from."))
-
-		# Enforce directionality
-		if flt(self.deposit) > 0 and flt(self.withdrawal) > 0:
-			frappe.throw(
-				_("Only one of Deposit or Withdrawal should be non-zero when applying an Excluded Fee.")
-			)
-
-		if flt(self.deposit) > 0:
-			self.deposit = flt(self.deposit) - excluded_fee
-		# A fee applied to deposit and withdrawal equal 0 become a withdrawal
-		elif flt(self.withdrawal) >= 0:
-			self.withdrawal = flt(self.withdrawal) + excluded_fee
-		self.included_fee = flt(self.included_fee) + excluded_fee
-		self.excluded_fee = 0
-
 
 @frappe.whitelist()
 def get_doctypes_for_bank_reconciliation():

erpnext/accounts/doctype/bank_transaction/test_auto_match_party.py

@@ -7,9 +7,6 @@ from frappe.utils import nowdate
 
 from erpnext.accounts.doctype.bank_transaction.test_bank_transaction import create_bank_account
 
-IBAN_1 = "DE02000000003716541159"
-IBAN_2 = "DE02500105170137075030"
-
 
 class TestAutoMatchParty(FrappeTestCase):
 	@classmethod
@@ -25,24 +22,24 @@ class TestAutoMatchParty(FrappeTestCase):
 		frappe.db.set_single_value("Accounts Settings", "enable_fuzzy_matching", 0)
 
 	def test_match_by_account_number(self):
-		create_supplier_for_match(account_no=IBAN_1[11:])
+		create_supplier_for_match(account_no="000000003716541159")
 		doc = create_bank_transaction(
 			withdrawal=1200,
 			transaction_id="562213b0ca1bf838dab8f2c6a39bbc3b",
-			account_no=IBAN_1[11:],
-			iban=IBAN_1,
+			account_no="000000003716541159",
+			iban="DE02000000003716541159",
 		)
 
 		self.assertEqual(doc.party_type, "Supplier")
 		self.assertEqual(doc.party, "John Doe & Co.")
 
 	def test_match_by_iban(self):
-		create_supplier_for_match(iban=IBAN_1)
+		create_supplier_for_match(iban="DE02000000003716541159")
 		doc = create_bank_transaction(
 			withdrawal=1200,
 			transaction_id="c5455a224602afaa51592a9d9250600d",
-			account_no=IBAN_1[11:],
-			iban=IBAN_1,
+			account_no="000000003716541159",
+			iban="DE02000000003716541159",
 		)
 
 		self.assertEqual(doc.party_type, "Supplier")
@@ -54,7 +51,7 @@ class TestAutoMatchParty(FrappeTestCase):
 			withdrawal=1200,
 			transaction_id="1f6f661f347ff7b1ea588665f473adb1",
 			party_name="Ella Jackson",
-			iban=IBAN_2,
+			iban="DE04000000003716545346",
 		)
 		self.assertEqual(doc.party_type, "Supplier")
 		self.assertEqual(doc.party, "Jackson Ella W.")

erpnext/accounts/doctype/bank_transaction/test_bank_transaction_fees.py

@@ -1,133 +0,0 @@
-# Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and Contributors
-# See license.txt
-
-import frappe
-from frappe.tests.utils import FrappeTestCase
-
-
-class TestBankTransactionFees(FrappeTestCase):
-	def test_included_fee_throws(self):
-		"""A fee that's part of a withdrawal cannot be bigger than the
-		withdrawal itself."""
-		bt = frappe.new_doc("Bank Transaction")
-		bt.withdrawal = 100
-		bt.included_fee = 101
-
-		self.assertRaises(frappe.ValidationError, bt.validate_included_fee)
-
-	def test_included_fee_allows_equal(self):
-		"""A fee that's part of a withdrawal may be equal to the withdrawal
-		amount (only the fee was deducted from the account)."""
-		bt = frappe.new_doc("Bank Transaction")
-		bt.withdrawal = 100
-		bt.included_fee = 100
-
-		bt.validate_included_fee()
-
-	def test_included_fee_allows_for_deposit(self):
-		"""For deposits, a fee may be recorded separately without limiting the
-		received amount."""
-		bt = frappe.new_doc("Bank Transaction")
-		bt.deposit = 10
-		bt.included_fee = 999
-
-		bt.validate_included_fee()
-
-	def test_excluded_fee_noop_when_zero(self):
-		"""When there is no excluded fee to apply, the amounts should remain
-		unchanged."""
-		bt = frappe.new_doc("Bank Transaction")
-		bt.deposit = 100
-		bt.withdrawal = 0
-		bt.included_fee = 5
-		bt.excluded_fee = 0
-
-		bt.handle_excluded_fee()
-
-		self.assertEqual(bt.deposit, 100)
-		self.assertEqual(bt.withdrawal, 0)
-		self.assertEqual(bt.included_fee, 5)
-		self.assertEqual(bt.excluded_fee, 0)
-
-	def test_excluded_fee_throws_when_exceeds_deposit(self):
-		"""A fee deducted from an incoming payment must not exceed the incoming
-		amount (else it would be a withdrawal, a conversion we don't support)."""
-		bt = frappe.new_doc("Bank Transaction")
-		bt.deposit = 10
-		bt.excluded_fee = 11
-
-		self.assertRaises(frappe.ValidationError, bt.handle_excluded_fee)
-
-	def test_excluded_fee_throws_when_both_deposit_and_withdrawal_are_set(self):
-		"""A transaction must be either incoming or outgoing when applying a
-		fee, not both."""
-		bt = frappe.new_doc("Bank Transaction")
-		bt.deposit = 10
-		bt.withdrawal = 10
-		bt.excluded_fee = 1
-
-		self.assertRaises(frappe.ValidationError, bt.handle_excluded_fee)
-
-	def test_excluded_fee_deducts_from_deposit(self):
-		"""When a fee is deducted from an incoming payment, the net received
-		amount decreases and the fee is tracked as included."""
-		bt = frappe.new_doc("Bank Transaction")
-		bt.deposit = 100
-		bt.withdrawal = 0
-		bt.included_fee = 2
-		bt.excluded_fee = 5
-
-		bt.handle_excluded_fee()
-
-		self.assertEqual(bt.deposit, 95)
-		self.assertEqual(bt.withdrawal, 0)
-		self.assertEqual(bt.included_fee, 7)
-		self.assertEqual(bt.excluded_fee, 0)
-
-	def test_excluded_fee_can_reduce_an_incoming_payment_to_zero(self):
-		"""A separately-deducted fee may reduce an incoming payment to zero,
-		while still tracking the fee."""
-		bt = frappe.new_doc("Bank Transaction")
-		bt.deposit = 5
-		bt.withdrawal = 0
-		bt.included_fee = 0
-		bt.excluded_fee = 5
-
-		bt.handle_excluded_fee()
-
-		self.assertEqual(bt.deposit, 0)
-		self.assertEqual(bt.withdrawal, 0)
-		self.assertEqual(bt.included_fee, 5)
-		self.assertEqual(bt.excluded_fee, 0)
-
-	def test_excluded_fee_increases_outgoing_payment(self):
-		"""When a separately-deducted fee is provided for an outgoing payment,
-		the total money leaving increases and the fee is tracked."""
-		bt = frappe.new_doc("Bank Transaction")
-		bt.deposit = 0
-		bt.withdrawal = 100
-		bt.included_fee = 2
-		bt.excluded_fee = 5
-
-		bt.handle_excluded_fee()
-
-		self.assertEqual(bt.deposit, 0)
-		self.assertEqual(bt.withdrawal, 105)
-		self.assertEqual(bt.included_fee, 7)
-		self.assertEqual(bt.excluded_fee, 0)
-
-	def test_excluded_fee_turns_zero_amount_into_withdrawal(self):
-		"""If only an excluded fee is provided, it should be treated as an
-		outgoing payment and the fee is then tracked as included."""
-		bt = frappe.new_doc("Bank Transaction")
-		bt.deposit = 0
-		bt.withdrawal = 0
-		bt.included_fee = 0
-		bt.excluded_fee = 5
-
-		bt.handle_excluded_fee()
-
-		self.assertEqual(bt.deposit, 0)
-		self.assertEqual(bt.withdrawal, 5)
-		self.assertEqual(bt.included_fee, 5)
-		self.assertEqual(bt.excluded_fee, 0)

erpnext/accounts/doctype/budget/budget.py

@@ -142,10 +142,8 @@ def validate_expense_against_budget(args, expense_amount=0):
 	if not frappe.get_all("Budget", limit=1):
 		return
 
-	if not args.fiscal_year:
+	if args.get("company") and not args.fiscal_year:
 		args.fiscal_year = get_fiscal_year(args.get("posting_date"), company=args.get("company"))[0]
-
-	if args.get("company"):
 		frappe.flags.exception_approver_role = frappe.get_cached_value(
 			"Company", args.get("company"), "exception_budget_approver_role"
 		)

erpnext/accounts/doctype/budget/test_budget.py

@@ -6,11 +6,7 @@ import unittest
 import frappe
 from frappe.utils import now_datetime, nowdate
 
-from erpnext.accounts.doctype.budget.budget import (
-	BudgetError,
-	get_accumulated_monthly_budget,
-	get_actual_expense,
-)
+from erpnext.accounts.doctype.budget.budget import BudgetError, get_actual_expense
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 from erpnext.accounts.utils import get_fiscal_year
 from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
@@ -100,10 +96,6 @@ class TestBudget(unittest.TestCase):
 		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
-		)
-
 		mr = frappe.get_doc(
 			{
 				"doctype": "Material Request",
@@ -117,7 +109,7 @@ class TestBudget(unittest.TestCase):
 						"uom": "_Test UOM",
 						"warehouse": "_Test Warehouse - _TC",
 						"schedule_date": nowdate(),
-						"rate": accumulated_limit + 1,
+						"rate": 100000,
 						"expense_account": "_Test Account Cost for Goods Sold - _TC",
 						"cost_center": "_Test Cost Center - _TC",
 					}

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

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

erpnext/accounts/doctype/cost_center_allocation/test_cost_center_allocation.py

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

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.js

@@ -19,7 +19,7 @@ frappe.ui.form.on("Currency Exchange Settings", {
 							to: "{to_currency}",
 						};
 						add_param(frm, r.message, params, result);
-					} else if (["frankfurter.app", "frankfurter.dev"].includes(frm.doc.service_provider)) {
+					} else if (frm.doc.service_provider == "frankfurter.app") {
 						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.dev\nexchangerate.host\nCustom",
+   "options": "frankfurter.app\nexchangerate.host\nCustom",
    "reqd": 1
   },
   {
@@ -104,7 +104,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2025-11-25 13:03:41.896424",
+ "modified": "2024-03-18 08:32:26.895076",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Currency Exchange Settings",
@@ -141,9 +141,8 @@
    "write": 1
   }
  ],
- "row_format": "Dynamic",
- "sort_field": "creation",
+ "sort_field": "modified",
  "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.dev", "exchangerate.host", "Custom"]
+		service_provider: DF.Literal["frankfurter.app", "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 in ("frankfurter.dev", "frankfurter.app"):
+		elif self.service_provider == "frankfurter.app":
 			self.set("result_key", [])
 			self.set("req_params", [])
 
@@ -105,13 +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.dev", "frankfurter.app"]:
+	if service_provider and service_provider in ["exchangerate.host", "frankfurter.app"]:
 		if service_provider == "exchangerate.host":
 			api = "api.exchangerate.host/convert"
 		elif service_provider == "frankfurter.app":
 			api = "api.frankfurter.app/{transaction_date}"
-		elif service_provider == "frankfurter.dev":
-			api = "api.frankfurter.dev/v1/{transaction_date}"
 
 		protocol = "https://"
 		if use_http:

erpnext/accounts/doctype/dunning/dunning.py

@@ -11,7 +11,6 @@
 
 		-> Resolves dunning automatically
 """
-
 import json
 
 import frappe
@@ -157,66 +156,40 @@ class Dunning(AccountsController):
 		]
 
 
-def update_linked_dunnings(doc, previous_outstanding_amount):
-	if (
-		doc.doctype != "Sales Invoice"
-		or doc.is_return
-		or previous_outstanding_amount == doc.outstanding_amount
-	):
-		return
+def resolve_dunning(doc, state):
+	"""
+	Check if all payments have been made and resolve dunning, if yes. Called
+	when a Payment Entry is submitted.
+	"""
+	for reference in doc.references:
+		# Consider partial and full payments:
+		# Submitting full payment: outstanding_amount will be 0
+		# Submitting 1st partial payment: outstanding_amount will be the pending installment
+		# Cancelling full payment: outstanding_amount will revert to total amount
+		# Cancelling last partial payment: outstanding_amount will revert to pending amount
+		submit_condition = reference.outstanding_amount < reference.total_amount
+		cancel_condition = reference.outstanding_amount <= reference.total_amount
 
-	to_resolve = doc.outstanding_amount < previous_outstanding_amount
-	state = "Unresolved" if to_resolve else "Resolved"
-	dunnings = get_linked_dunnings_as_per_state(doc.name, state)
-	if not dunnings:
-		return
+		if reference.reference_doctype == "Sales Invoice" and (
+			submit_condition if doc.docstatus == 1 else cancel_condition
+		):
+			state = "Resolved" if doc.docstatus == 2 else "Unresolved"
+			dunnings = get_linked_dunnings_as_per_state(reference.reference_name, state)
 
-	dunnings = [frappe.get_doc("Dunning", dunning.name) for dunning in dunnings]
-	invoices = set()
-	payment_schedule_ids = set()
+			for dunning in dunnings:
+				resolve = True
+				dunning = frappe.get_doc("Dunning", dunning.get("name"))
+				for overdue_payment in dunning.overdue_payments:
+					outstanding_inv = frappe.get_value(
+						"Sales Invoice", overdue_payment.sales_invoice, "outstanding_amount"
+					)
+					outstanding_ps = frappe.get_value(
+						"Payment Schedule", overdue_payment.payment_schedule, "outstanding"
+					)
+					resolve = False if (outstanding_ps > 0 and outstanding_inv > 0) else True
 
-	for dunning in dunnings:
-		for overdue_payment in dunning.overdue_payments:
-			invoices.add(overdue_payment.sales_invoice)
-			if overdue_payment.payment_schedule:
-				payment_schedule_ids.add(overdue_payment.payment_schedule)
-
-	invoice_outstanding_amounts = dict(
-		frappe.get_all(
-			"Sales Invoice",
-			filters={"name": ["in", list(invoices)]},
-			fields=["name", "outstanding_amount"],
-			as_list=True,
-		)
-	)
-
-	ps_outstanding_amounts = (
-		dict(
-			frappe.get_all(
-				"Payment Schedule",
-				filters={"name": ["in", list(payment_schedule_ids)]},
-				fields=["name", "outstanding"],
-				as_list=True,
-			)
-		)
-		if payment_schedule_ids
-		else {}
-	)
-
-	for dunning in dunnings:
-		has_outstanding = False
-		for overdue_payment in dunning.overdue_payments:
-			invoice_outstanding = invoice_outstanding_amounts[overdue_payment.sales_invoice]
-			ps_outstanding = ps_outstanding_amounts.get(overdue_payment.payment_schedule, 0)
-			has_outstanding = invoice_outstanding > 0 and ps_outstanding > 0
-			if has_outstanding:
-				break
-
-		new_status = "Resolved" if not has_outstanding else "Unresolved"
-
-		if dunning.status != new_status:
-			dunning.status = new_status
-			dunning.save()
+				dunning.status = "Resolved" if resolve else "Unresolved"
+				dunning.save()
 
 
 def get_linked_dunnings_as_per_state(sales_invoice, state):

erpnext/accounts/doctype/dunning/test_dunning.py

@@ -139,64 +139,6 @@ class TestDunning(FrappeTestCase):
 		self.assertEqual(sales_invoice.status, "Overdue")
 		self.assertEqual(dunning.status, "Unresolved")
 
-	def test_dunning_resolution_from_credit_note(self):
-		"""
-		Test that dunning is resolved when a credit note is issued against the original invoice.
-		"""
-		sales_invoice = create_sales_invoice_against_cost_center(
-			posting_date=add_days(today(), -10), qty=1, rate=100
-		)
-		dunning = create_dunning_from_sales_invoice(sales_invoice.name)
-		dunning.submit()
-
-		self.assertEqual(dunning.status, "Unresolved")
-
-		credit_note = frappe.copy_doc(sales_invoice)
-		credit_note.is_return = 1
-		credit_note.return_against = sales_invoice.name
-		credit_note.update_outstanding_for_self = 0
-
-		for item in credit_note.items:
-			item.qty = -item.qty
-
-		credit_note.save()
-		credit_note.submit()
-
-		dunning.reload()
-		self.assertEqual(dunning.status, "Resolved")
-
-		credit_note.cancel()
-		dunning.reload()
-		self.assertEqual(dunning.status, "Unresolved")
-
-	def test_dunning_not_affected_by_standalone_credit_note(self):
-		"""
-		Test that dunning is NOT resolved when a credit note has update_outstanding_for_self checked.
-		"""
-		sales_invoice = create_sales_invoice_against_cost_center(
-			posting_date=add_days(today(), -10), qty=1, rate=100
-		)
-		dunning = create_dunning_from_sales_invoice(sales_invoice.name)
-		dunning.submit()
-
-		self.assertEqual(dunning.status, "Unresolved")
-
-		credit_note = frappe.copy_doc(sales_invoice)
-		credit_note.is_return = 1
-		credit_note.return_against = sales_invoice.name
-		credit_note.update_outstanding_for_self = 1
-
-		for item in credit_note.items:
-			item.qty = -item.qty
-
-		credit_note.save()
-
-		credit_note = frappe.get_doc("Sales Invoice", credit_note.name)
-		credit_note.submit()
-
-		dunning.reload()
-		self.assertEqual(dunning.status, "Unresolved")
-
 
 def create_dunning(overdue_days, dunning_type_name=None):
 	posting_date = add_days(today(), -1 * overdue_days)

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -134,8 +134,7 @@ class ExchangeRateRevaluation(Document):
 		accounts = self.get_accounts_data()
 		if accounts:
 			for acc in accounts:
-				if acc.get("gain_loss"):
-					self.append("accounts", acc)
+				self.append("accounts", acc)
 
 	@frappe.whitelist()
 	def get_accounts_data(self):
@@ -252,7 +251,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"),
-			currency=company_currency,
+			company_currency,
 		)
 
 		if account_details:
@@ -486,9 +485,6 @@ class ExchangeRateRevaluation(Document):
 		journal_entry.posting_date = self.posting_date
 		journal_entry.multi_currency = 1
 
-		# Prevent JE from overriding user-entered exchange rates (e.g., rate of 1)
-		journal_entry.flags.ignore_exchange_rate = True
-
 		journal_entry_accounts = []
 		for d in accounts:
 			if not flt(d.get("balance_in_account_currency"), d.precision("balance_in_account_currency")):

erpnext/accounts/doctype/fiscal_year/fiscal_year.py

@@ -99,7 +99,7 @@ class FiscalYear(Document):
 				)
 
 				overlap = False
-				if not self.get("companies") and not company_for_existing:
+				if not self.get("companies") or not company_for_existing:
 					overlap = True
 
 				for d in self.get("companies"):

erpnext/accounts/doctype/fiscal_year/test_fiscal_year.py

@@ -26,27 +26,6 @@ class TestFiscalYear(unittest.TestCase):
 
 		self.assertRaises(frappe.exceptions.InvalidDates, fy.insert)
 
-	def test_company_fiscal_year_overlap(self):
-		for name in ["_Test Global FY 2001", "_Test Company FY 2001"]:
-			if frappe.db.exists("Fiscal Year", name):
-				frappe.delete_doc("Fiscal Year", name)
-
-		global_fy = frappe.new_doc("Fiscal Year")
-		global_fy.year = "_Test Global FY 2001"
-		global_fy.year_start_date = "2001-04-01"
-		global_fy.year_end_date = "2002-03-31"
-		global_fy.insert()
-
-		company_fy = frappe.new_doc("Fiscal Year")
-		company_fy.year = "_Test Company FY 2001"
-		company_fy.year_start_date = "2001-01-01"
-		company_fy.year_end_date = "2001-12-31"
-		company_fy.append("companies", {"company": "_Test Company"})
-
-		company_fy.insert()
-		self.assertTrue(frappe.db.exists("Fiscal Year", global_fy.name))
-		self.assertTrue(frappe.db.exists("Fiscal Year", company_fy.name))
-
 
 def test_record_generator():
 	test_records = [

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -131,20 +131,18 @@ class GLEntry(Document):
 
 		if not self.is_cancelled and not (self.party_type and self.party):
 			account_type = frappe.get_cached_value("Account", self.account, "account_type")
-
-			if not frappe.flags.party_not_required:  # skipping validation if party is not required
-				if account_type == "Receivable":
-					frappe.throw(
-						_("{0} {1}: Customer is required against Receivable account {2}").format(
-							self.voucher_type, self.voucher_no, self.account
-						)
+			if account_type == "Receivable":
+				frappe.throw(
+					_("{0} {1}: Customer is required against Receivable account {2}").format(
+						self.voucher_type, self.voucher_no, self.account
 					)
-				elif account_type == "Payable":
-					frappe.throw(
-						_("{0} {1}: Supplier is required against Payable account {2}").format(
-							self.voucher_type, self.voucher_no, self.account
-						)
+				)
+			elif account_type == "Payable":
+				frappe.throw(
+					_("{0} {1}: Supplier is required against Payable account {2}").format(
+						self.voucher_type, self.voucher_no, self.account
 					)
+				)
 
 		# Zero value transaction is not allowed
 		if not (
@@ -253,7 +251,7 @@ class GLEntry(Document):
 			)
 
 	def validate_cost_center(self):
-		if not self.cost_center or self.is_cancelled:
+		if not self.cost_center:
 			return
 
 		is_group, company = frappe.get_cached_value("Cost Center", self.cost_center, ["is_group", "company"])
@@ -313,7 +311,7 @@ def validate_balance_type(account, adv_adj=False):
 		if balance_must_be:
 			balance = frappe.db.sql(
 				"""select sum(debit) - sum(credit)
-				from `tabGL Entry` where is_cancelled = 0 and account = %s""",
+				from `tabGL Entry` where account = %s""",
 				account,
 			)[0][0]
 
@@ -420,7 +418,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"), currency=company_currency)
+	precision = get_field_precision(frappe.get_meta("GL Entry").get_field("debit"), company_currency)
 
 	accounts_debited, accounts_credited = [], []
 	for d in entries:
@@ -464,9 +462,4 @@ def rename_temporarily_named_docs(doctype):
 				f"UPDATE `tab{doctype}` SET name = %s, to_rename = 0, modified = %s where name = %s",
 				(newname, now(), oldname),
 			)
-
-			for hook_type in ("on_gle_rename", "on_sle_rename"):
-				for hook in frappe.get_hooks(hook_type):
-					frappe.call(hook, newname=newname, oldname=oldname)
-
 		frappe.db.commit()

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -163,7 +163,6 @@ frappe.ui.form.on("Journal Entry", {
 		});
 
 		erpnext.accounts.dimensions.update_dimension(frm, frm.doctype);
-		erpnext.utils.set_letter_head(frm);
 	},
 
 	voucher_type: function (frm) {

erpnext/accounts/doctype/journal_entry/journal_entry.json

@@ -59,7 +59,6 @@
   "addtional_info",
   "mode_of_payment",
   "payment_order",
-  "party_not_required",
   "column_break3",
   "is_opening",
   "stock_entry",
@@ -544,14 +543,6 @@
    "label": "Is System Generated",
    "no_copy": 1,
    "read_only": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "party_not_required",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Party Not Required",
-   "no_copy": 1
   }
  ],
  "icon": "fa fa-file-text",
@@ -566,7 +557,7 @@
    "table_fieldname": "payment_entries"
   }
  ],
- "modified": "2025-09-29 13:05:46.982277",
+ "modified": "2024-07-18 15:32:29.413598",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry",

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -24,7 +24,6 @@ from erpnext.accounts.party import get_party_account
 from erpnext.accounts.utils import (
 	cancel_exchange_gain_loss_journal,
 	get_account_currency,
-	get_advance_payment_doctypes,
 	get_balance_on,
 	get_stock_accounts,
 	get_stock_and_account_balance,
@@ -33,7 +32,6 @@ from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_sched
 	get_depr_schedule,
 )
 from erpnext.controllers.accounts_controller import AccountsController
-from erpnext.setup.utils import get_exchange_rate as _get_exchange_rate
 
 
 class StockAccountInvalidTransaction(frappe.ValidationError):
@@ -73,7 +71,6 @@ class JournalEntry(AccountsController):
 		multi_currency: DF.Check
 		naming_series: DF.Literal["ACC-JV-.YYYY.-"]
 		paid_loan: DF.Data | None
-		party_not_required: DF.Check
 		pay_to_recd_from: DF.Data | None
 		payment_order: DF.Link | None
 		posting_date: DF.Date
@@ -149,8 +146,8 @@ class JournalEntry(AccountsController):
 
 		if self.docstatus == 0:
 			self.apply_tax_withholding()
-		if self.is_new() or not self.title:
-			self.title = self.get_title()
+
+		self.title = self.get_title()
 
 	def validate_advance_accounts(self):
 		journal_accounts = set([x.account for x in self.accounts])
@@ -191,8 +188,10 @@ class JournalEntry(AccountsController):
 
 	def on_submit(self):
 		self.validate_cheque_info()
-		self.make_gl_entries()
 		self.check_credit_limit()
+		self.make_gl_entries()
+		self.make_advance_payment_ledger_entries()
+		self.update_advance_paid()
 		self.update_asset_value()
 		self.update_inter_company_jv()
 		self.update_invoice_discounting()
@@ -225,6 +224,8 @@ class JournalEntry(AccountsController):
 			"Advance Payment Ledger Entry",
 		)
 		self.make_gl_entries(1)
+		self.make_advance_payment_ledger_entries()
+		self.update_advance_paid()
 		self.unlink_advance_entry_reference()
 		self.unlink_asset_reference()
 		self.unlink_inter_company_jv()
@@ -235,6 +236,17 @@ class JournalEntry(AccountsController):
 	def get_title(self):
 		return self.pay_to_recd_from or self.accounts[0].account
 
+	def update_advance_paid(self):
+		advance_paid = frappe._dict()
+		for d in self.get("accounts"):
+			if d.is_advance:
+				if d.reference_type in frappe.get_hooks("advance_payment_doctypes"):
+					advance_paid.setdefault(d.reference_type, []).append(d.reference_name)
+
+		for voucher_type, order_list in advance_paid.items():
+			for voucher_no in list(set(order_list)):
+				frappe.get_doc(voucher_type, voucher_no).set_total_advance_paid()
+
 	def validate_inter_company_accounts(self):
 		if self.voucher_type == "Inter Company Journal Entry" and self.inter_company_journal_entry_reference:
 			doc = frappe.db.get_value(
@@ -274,7 +286,93 @@ class JournalEntry(AccountsController):
 				)
 
 	def apply_tax_withholding(self):
-		JournalEntryTaxWithholding(self).apply()
+		from erpnext.accounts.report.general_ledger.general_ledger import get_account_type_map
+
+		if not self.apply_tds or self.voucher_type not in ("Debit Note", "Credit Note"):
+			return
+
+		parties = [d.party for d in self.get("accounts") if d.party]
+		parties = list(set(parties))
+
+		if len(parties) > 1:
+			frappe.throw(_("Cannot apply TDS against multiple parties in one entry"))
+
+		account_type_map = get_account_type_map(self.company)
+		party_type = "supplier" if self.voucher_type == "Credit Note" else "customer"
+		doctype = "Purchase Invoice" if self.voucher_type == "Credit Note" else "Sales Invoice"
+		debit_or_credit = (
+			"debit_in_account_currency"
+			if self.voucher_type == "Credit Note"
+			else "credit_in_account_currency"
+		)
+		rev_debit_or_credit = (
+			"credit_in_account_currency"
+			if debit_or_credit == "debit_in_account_currency"
+			else "debit_in_account_currency"
+		)
+
+		party_account = get_party_account(party_type.title(), parties[0], self.company)
+
+		net_total = sum(
+			d.get(debit_or_credit)
+			for d in self.get("accounts")
+			if account_type_map.get(d.account) not in ("Tax", "Chargeable")
+		)
+
+		party_amount = sum(
+			d.get(rev_debit_or_credit) for d in self.get("accounts") if d.account == party_account
+		)
+
+		inv = frappe._dict(
+			{
+				party_type: parties[0],
+				"doctype": doctype,
+				"company": self.company,
+				"posting_date": self.posting_date,
+				"net_total": net_total,
+			}
+		)
+
+		tax_withholding_details, advance_taxes, voucher_wise_amount = get_party_tax_withholding_details(
+			inv, self.tax_withholding_category
+		)
+
+		if not tax_withholding_details:
+			return
+
+		accounts = []
+		for d in self.get("accounts"):
+			if d.get("account") == tax_withholding_details.get("account_head"):
+				d.update(
+					{
+						"account": tax_withholding_details.get("account_head"),
+						debit_or_credit: tax_withholding_details.get("tax_amount"),
+					}
+				)
+
+			accounts.append(d.get("account"))
+
+			if d.get("account") == party_account:
+				d.update({rev_debit_or_credit: party_amount - tax_withholding_details.get("tax_amount")})
+
+		if not accounts or tax_withholding_details.get("account_head") not in accounts:
+			self.append(
+				"accounts",
+				{
+					"account": tax_withholding_details.get("account_head"),
+					rev_debit_or_credit: tax_withholding_details.get("tax_amount"),
+					"against_account": parties[0],
+				},
+			)
+
+		to_remove = [
+			d
+			for d in self.get("accounts")
+			if not d.get(rev_debit_or_credit) and d.account == tax_withholding_details.get("account_head")
+		]
+
+		for d in to_remove:
+			self.remove(d)
 
 	def update_asset_value(self):
 		if self.flags.planned_depr_entry or self.voucher_type != "Depreciation Entry":
@@ -458,11 +556,8 @@ class JournalEntry(AccountsController):
 	def validate_party(self):
 		for d in self.get("accounts"):
 			account_type = frappe.get_cached_value("Account", d.account, "account_type")
-
 			if account_type in ["Receivable", "Payable"]:
-				if (
-					not (d.party_type and d.party) and not self.party_not_required
-				):  # skipping validation if party_not_required is passed via payroll entry
+				if not (d.party_type and d.party):
 					frappe.throw(
 						_(
 							"Row {0}: Party Type and Party is required for Receivable / Payable account {1}"
@@ -471,8 +566,6 @@ class JournalEntry(AccountsController):
 				elif (
 					d.party_type
 					and frappe.db.get_value("Party Type", d.party_type, "account_type") != account_type
-					and d.party_type
-					!= "Employee"  # making an excpetion for employee since they can be both payable and receivable
 				):
 					frappe.throw(
 						_("Row {0}: Account {1} and Party Type {2} have different account types").format(
@@ -999,70 +1092,49 @@ class JournalEntry(AccountsController):
 					self.transaction_exchange_rate = row.exchange_rate
 					break
 
-		advance_doctypes = get_advance_payment_doctypes()
-
 		for d in self.get("accounts"):
 			if d.debit or d.credit or (self.voucher_type == "Exchange Gain Or Loss"):
 				r = [d.user_remark, self.remark]
 				r = [x for x in r if x]
 				remarks = "\n".join(r)
 
-				row = {
-					"account": d.account,
-					"party_type": d.party_type,
-					"due_date": self.due_date,
-					"party": d.party,
-					"against": d.against_account,
-					"debit": flt(d.debit, d.precision("debit")),
-					"credit": flt(d.credit, d.precision("credit")),
-					"account_currency": d.account_currency,
-					"debit_in_account_currency": flt(
-						d.debit_in_account_currency, d.precision("debit_in_account_currency")
-					),
-					"credit_in_account_currency": flt(
-						d.credit_in_account_currency, d.precision("credit_in_account_currency")
-					),
-					"transaction_currency": self.transaction_currency,
-					"transaction_exchange_rate": self.transaction_exchange_rate,
-					"debit_in_transaction_currency": flt(
-						d.debit_in_account_currency, d.precision("debit_in_account_currency")
-					)
-					if self.transaction_currency == d.account_currency
-					else flt(d.debit, d.precision("debit")) / self.transaction_exchange_rate,
-					"credit_in_transaction_currency": flt(
-						d.credit_in_account_currency, d.precision("credit_in_account_currency")
-					)
-					if self.transaction_currency == d.account_currency
-					else flt(d.credit, d.precision("credit")) / self.transaction_exchange_rate,
-					"against_voucher_type": d.reference_type,
-					"against_voucher": d.reference_name,
-					"remarks": remarks,
-					"voucher_detail_no": d.reference_detail_no,
-					"cost_center": d.cost_center,
-					"project": d.project,
-					"finance_book": self.finance_book,
-					"advance_voucher_type": d.advance_voucher_type,
-					"advance_voucher_no": d.advance_voucher_no,
-				}
-
-				if d.reference_type in advance_doctypes:
-					row.update(
-						{
-							"against_voucher_type": self.doctype,
-							"against_voucher": self.name,
-							"advance_voucher_type": d.reference_type,
-							"advance_voucher_no": d.reference_name,
-						}
-					)
-
-				# set flag to skip party validation
-				account_type = frappe.get_cached_value("Account", d.account, "account_type")
-				if account_type in ["Receivable", "Payable"] and self.party_not_required:
-					frappe.flags.party_not_required = True
-
 				gl_map.append(
 					self.get_gl_dict(
-						row,
+						{
+							"account": d.account,
+							"party_type": d.party_type,
+							"due_date": self.due_date,
+							"party": d.party,
+							"against": d.against_account,
+							"debit": flt(d.debit, d.precision("debit")),
+							"credit": flt(d.credit, d.precision("credit")),
+							"account_currency": d.account_currency,
+							"debit_in_account_currency": flt(
+								d.debit_in_account_currency, d.precision("debit_in_account_currency")
+							),
+							"credit_in_account_currency": flt(
+								d.credit_in_account_currency, d.precision("credit_in_account_currency")
+							),
+							"transaction_currency": self.transaction_currency,
+							"transaction_exchange_rate": self.transaction_exchange_rate,
+							"debit_in_transaction_currency": flt(
+								d.debit_in_account_currency, d.precision("debit_in_account_currency")
+							)
+							if self.transaction_currency == d.account_currency
+							else flt(d.debit, d.precision("debit")) / self.transaction_exchange_rate,
+							"credit_in_transaction_currency": flt(
+								d.credit_in_account_currency, d.precision("credit_in_account_currency")
+							)
+							if self.transaction_currency == d.account_currency
+							else flt(d.credit, d.precision("credit")) / self.transaction_exchange_rate,
+							"against_voucher_type": d.reference_type,
+							"against_voucher": d.reference_name,
+							"remarks": remarks,
+							"voucher_detail_no": d.reference_detail_no,
+							"cost_center": d.cost_center,
+							"project": d.project,
+							"finance_book": self.finance_book,
+						},
 						item=d,
 					)
 				)
@@ -1087,7 +1159,6 @@ class JournalEntry(AccountsController):
 				merge_entries=merge_entries,
 				update_outstanding=update_outstanding,
 			)
-			frappe.flags.party_not_required = False
 			if cancel:
 				cancel_exchange_gain_loss_journal(frappe._dict(doctype=self.doctype, name=self.name))
 
@@ -1196,230 +1267,6 @@ class JournalEntry(AccountsController):
 			frappe.throw(_("Accounts table cannot be blank."))
 
 
-class JournalEntryTaxWithholding:
-	def __init__(self, journal_entry):
-		self.doc: JournalEntry = journal_entry
-		self.party = None
-		self.party_type = None
-		self.party_account = None
-		self.party_row = None
-		self.existing_tds_rows = []
-		self.precision = None
-		self.has_multiple_parties = False
-
-		# Direction fields based on party type
-		self.party_field = None  # "credit" for Supplier, "debit" for Customer
-		self.reverse_field = None  # opposite of party_field
-
-	def apply(self):
-		if not self._set_party_info():
-			return
-
-		self._setup_direction_fields()
-		self._reset_existing_tds()
-
-		if not self._should_apply_tds():
-			self._cleanup_duplicate_tds_rows(None)
-			return
-
-		if self.has_multiple_parties:
-			frappe.throw(_("Cannot apply TDS against multiple parties in one entry"))
-
-		net_total = self._calculate_net_total()
-		if net_total <= 0:
-			return
-
-		tds_details = self._get_tds_details(net_total)
-		if not tds_details or not tds_details.get("tax_amount"):
-			return
-
-		self._create_or_update_tds_row(tds_details)
-		self._update_party_amount(tds_details.get("tax_amount"), is_reversal=False)
-
-		self._recalculate_totals()
-
-	def _should_apply_tds(self):
-		return self.doc.apply_tds and self.doc.voucher_type in ("Debit Note", "Credit Note")
-
-	def _set_party_info(self):
-		for row in self.doc.get("accounts"):
-			if row.party_type in ("Customer", "Supplier") and row.party:
-				if self.party and row.party != self.party:
-					self.has_multiple_parties = True
-
-				if not self.party:
-					self.party = row.party
-					self.party_type = row.party_type
-					self.party_account = row.account
-					self.party_row = row
-
-			if row.get("is_tax_withholding_account"):
-				self.existing_tds_rows.append(row)
-
-		return bool(self.party)
-
-	def _setup_direction_fields(self):
-		"""
-		For Supplier (TDS): party has credit, TDS reduces credit
-		For Customer (TCS): party has debit, TCS increases debit
-		"""
-		if self.party_type == "Supplier":
-			self.party_field = "credit"
-			self.reverse_field = "debit"
-		else:  # Customer
-			self.party_field = "debit"
-			self.reverse_field = "credit"
-
-		self.precision = self.doc.precision(self.party_field, self.party_row)
-
-	def _reset_existing_tds(self):
-		for row in self.existing_tds_rows:
-			# TDS amount is always in credit (liability to government)
-			tds_amount = flt(row.get("credit") - row.get("debit"), self.precision)
-			if not tds_amount:
-				continue
-
-			self._update_party_amount(tds_amount, is_reversal=True)
-
-			# zero_out_tds_row
-			row.update(
-				{
-					"credit": 0,
-					"credit_in_account_currency": 0,
-					"debit": 0,
-					"debit_in_account_currency": 0,
-				}
-			)
-
-	def _update_party_amount(self, amount, is_reversal=False):
-		amount = flt(amount, self.precision)
-		amount_in_party_currency = flt(amount / self.party_row.get("exchange_rate", 1), self.precision)
-
-		# Determine which field the party amount is in
-		active_field = self.party_field if self.party_row.get(self.party_field) else self.reverse_field
-
-		# If amount is in reverse field, flip the signs
-		if active_field == self.reverse_field:
-			amount = -amount
-			amount_in_party_currency = -amount_in_party_currency
-
-		# Direction multiplier based on party type:
-		# Customer (TCS): +1 (add to debit)
-		# Supplier (TDS): -1 (subtract from credit)
-		direction = 1 if self.party_type == "Customer" else -1
-
-		# Reversal inverts the direction
-		if is_reversal:
-			direction = -direction
-
-		adjustment = amount * direction
-		adjustment_in_party_currency = amount_in_party_currency * direction
-
-		active_field_account_currency = f"{active_field}_in_account_currency"
-
-		self.party_row.update(
-			{
-				active_field: flt(self.party_row.get(active_field) + adjustment, self.precision),
-				active_field_account_currency: flt(
-					self.party_row.get(active_field_account_currency) + adjustment_in_party_currency,
-					self.precision,
-				),
-			}
-		)
-
-	def _calculate_net_total(self):
-		from erpnext.accounts.report.general_ledger.general_ledger import get_account_type_map
-
-		account_type_map = get_account_type_map(self.doc.company)
-
-		return flt(
-			sum(
-				d.get(self.reverse_field) - d.get(self.party_field)
-				for d in self.doc.get("accounts")
-				if account_type_map.get(d.account) not in ("Tax", "Chargeable")
-				and d.account != self.party_account
-				and not d.get("is_tax_withholding_account")
-			),
-			self.precision,
-		)
-
-	def _get_tds_details(self, net_total):
-		return get_party_tax_withholding_details(
-			frappe._dict(
-				{
-					"party_type": self.party_type,
-					"party": self.party,
-					"doctype": self.doc.doctype,
-					"company": self.doc.company,
-					"posting_date": self.doc.posting_date,
-					"tax_withholding_net_total": net_total,
-					"base_tax_withholding_net_total": net_total,
-					"grand_total": net_total,
-				}
-			),
-			self.doc.tax_withholding_category,
-		)
-
-	def _create_or_update_tds_row(self, tds_details):
-		tax_account = tds_details.get("account_head")
-		account_currency = get_account_currency(tax_account)
-		company_currency = frappe.get_cached_value("Company", self.doc.company, "default_currency")
-		exchange_rate = _get_exchange_rate(account_currency, company_currency, self.doc.posting_date)
-
-		tax_amount = flt(tds_details.get("tax_amount"), self.precision)
-		tax_amount_in_account_currency = flt(tax_amount / exchange_rate, self.precision)
-
-		# Find existing TDS row for this account
-		tax_row = None
-		for row in self.doc.get("accounts"):
-			if row.account == tax_account and row.get("is_tax_withholding_account"):
-				tax_row = row
-				break
-
-		if not tax_row:
-			tax_row = self.doc.append(
-				"accounts",
-				{
-					"account": tax_account,
-					"account_currency": account_currency,
-					"exchange_rate": exchange_rate,
-					"cost_center": tds_details.get("cost_center"),
-					"credit": 0,
-					"credit_in_account_currency": 0,
-					"debit": 0,
-					"debit_in_account_currency": 0,
-					"is_tax_withholding_account": 1,
-				},
-			)
-
-		# TDS/TCS is always credited (liability to government)
-		tax_row.update(
-			{
-				"credit": tax_amount,
-				"credit_in_account_currency": tax_amount_in_account_currency,
-				"debit": 0,
-				"debit_in_account_currency": 0,
-			}
-		)
-
-		self._cleanup_duplicate_tds_rows(tax_row)
-
-	def _cleanup_duplicate_tds_rows(self, current_tax_row):
-		rows_to_remove = [
-			row
-			for row in self.doc.get("accounts")
-			if row.get("is_tax_withholding_account") and row != current_tax_row
-		]
-
-		for row in rows_to_remove:
-			self.doc.remove(row)
-
-	def _recalculate_totals(self):
-		self.doc.set_amounts_in_company_currency()
-		self.doc.set_total_debit_credit()
-		self.doc.set_against_account()
-
-
 @frappe.whitelist()
 def get_default_bank_cash_account(company, account_type=None, mode_of_payment=None, account=None):
 	from erpnext.accounts.doctype.sales_invoice.sales_invoice import get_bank_cash_account
@@ -1788,6 +1635,8 @@ def get_exchange_rate(
 	credit=None,
 	exchange_rate=None,
 ):
+	from erpnext.setup.utils import get_exchange_rate
+
 	account_details = frappe.get_cached_value(
 		"Account", account, ["account_type", "root_type", "account_currency", "company"], as_dict=1
 	)
@@ -1809,8 +1658,8 @@ def get_exchange_rate(
 
 		# The date used to retreive the exchange rate here is the date passed
 		# in as an argument to this function.
-		elif (not flt(exchange_rate) or flt(exchange_rate) == 1) and account_currency and posting_date:
-			exchange_rate = _get_exchange_rate(account_currency, company_currency, posting_date)
+		elif (not exchange_rate or flt(exchange_rate) == 1) and account_currency and posting_date:
+			exchange_rate = get_exchange_rate(account_currency, company_currency, posting_date)
 	else:
 		exchange_rate = 1
 

erpnext/accounts/doctype/journal_entry/test_journal_entry.py

@@ -11,7 +11,6 @@ from frappe.utils import flt, nowdate
 from erpnext.accounts.doctype.account.test_account import get_inventory_account
 from erpnext.accounts.doctype.journal_entry.journal_entry import StockAccountInvalidTransaction
 from erpnext.exceptions import InvalidAccountCurrency
-from erpnext.selling.doctype.customer.test_customer import make_customer, set_credit_limit
 
 
 class TestJournalEntry(unittest.TestCase):
@@ -581,27 +580,6 @@ class TestJournalEntry(unittest.TestCase):
 		]
 		self.assertEqual(expected, actual)
 
-	def test_pay_to_recd_from(self):
-		jv = make_journal_entry("_Test Cash - _TC", "_Test Bank - _TC", 100, save=False)
-		jv.pay_to_recd_from = "_Test Receiver"
-		jv.save()
-		self.assertEqual(jv.pay_to_recd_from, "_Test Receiver")
-
-		jv.pay_to_recd_from = "_Test Receiver 2"
-		jv.save()
-		jv.submit()
-
-		self.assertEqual(jv.pay_to_recd_from, "_Test Receiver 2")
-
-	def test_credit_limit_for_customer(self):
-		customer = make_customer("_Test New Customer")
-		set_credit_limit("_Test New Customer", "_Test Company", 50)
-		jv = make_journal_entry(account1="Debtors - _TC", account2="_Test Cash - _TC", amount=100, save=False)
-		jv.accounts[0].party_type = "Customer"
-		jv.accounts[0].party = customer
-		jv.save()
-		self.assertRaises(frappe.ValidationError, jv.submit)
-
 
 def make_journal_entry(
 	account1,

erpnext/accounts/doctype/journal_entry_account/journal_entry_account.json

@@ -32,9 +32,6 @@
   "reference_name",
   "reference_due_date",
   "reference_detail_no",
-  "advance_voucher_type",
-  "advance_voucher_no",
-  "is_tax_withholding_account",
   "col_break3",
   "is_advance",
   "user_remark",
@@ -107,6 +104,7 @@
    "fieldname": "account_currency",
    "fieldtype": "Link",
    "label": "Account Currency",
+   "no_copy": 1,
    "options": "Currency",
    "print_hide": 1,
    "read_only": 1
@@ -265,37 +263,12 @@
    "label": "Reference Detail No",
    "no_copy": 1,
    "search_index": 1
-  },
-  {
-   "fieldname": "advance_voucher_type",
-   "fieldtype": "Link",
-   "label": "Advance Voucher Type",
-   "no_copy": 1,
-   "options": "DocType",
-   "read_only": 1,
-   "search_index": 1
-  },
-  {
-   "fieldname": "advance_voucher_no",
-   "fieldtype": "Dynamic Link",
-   "label": "Advance Voucher No",
-   "no_copy": 1,
-   "options": "advance_voucher_type",
-   "read_only": 1,
-   "search_index": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "is_tax_withholding_account",
-   "fieldtype": "Check",
-   "label": "Is Tax Withholding Account",
-   "read_only": 1
   }
  ],
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-11-27 12:23:33.157655",
+ "modified": "2024-02-05 01:10:50.224840",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry Account",
@@ -306,4 +279,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/journal_entry_account/journal_entry_account.py

@@ -17,9 +17,8 @@ class JournalEntryAccount(Document):
 		account: DF.Link
 		account_currency: DF.Link | None
 		account_type: DF.Data | None
-		advance_voucher_no: DF.DynamicLink | None
-		advance_voucher_type: DF.Link | None
 		against_account: DF.Text | None
+		balance: DF.Currency
 		bank_account: DF.Link | None
 		cost_center: DF.Link | None
 		credit: DF.Currency
@@ -28,11 +27,11 @@ class JournalEntryAccount(Document):
 		debit_in_account_currency: DF.Currency
 		exchange_rate: DF.Float
 		is_advance: DF.Literal["No", "Yes"]
-		is_tax_withholding_account: DF.Check
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data
 		party: DF.DynamicLink | None
+		party_balance: DF.Currency
 		party_type: DF.Link | None
 		project: DF.Link | None
 		reference_detail_no: DF.Data | None

erpnext/accounts/doctype/loyalty_program/loyalty_program.json

@@ -24,7 +24,6 @@
   "accounting_dimensions_section",
   "cost_center",
   "dimension_col_break",
-  "project",
   "help_section",
   "loyalty_program_help"
  ],
@@ -144,12 +143,6 @@
   {
    "fieldname": "dimension_col_break",
    "fieldtype": "Column Break"
-  },
-  {
-    "fieldname": "project",
-    "fieldtype": "Link",
-    "label": "Project",
-    "options": "Project"
   }
  ],
  "modified": "2019-05-26 09:11:46.120251",

erpnext/accounts/doctype/loyalty_program/loyalty_program.py

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

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.json

@@ -13,7 +13,6 @@
   "accounting_dimensions_section",
   "cost_center",
   "dimension_col_break",
-  "project",
   "section_break_4",
   "invoices"
  ],
@@ -63,12 +62,6 @@
    "label": "Cost Center",
    "options": "Cost Center"
   },
-  {
-    "fieldname": "project",
-    "fieldtype": "Link",
-    "label": "Project",
-    "options": "Project"
-  },
   {
    "collapsible": 1,
    "fieldname": "accounting_dimensions_section",

erpnext/accounts/doctype/party_link/party_link.py

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

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -273,7 +273,6 @@ frappe.ui.form.on("Payment Entry", {
 		frm.events.hide_unhide_fields(frm);
 		frm.events.set_dynamic_labels(frm);
 		erpnext.accounts.dimensions.update_dimension(frm, frm.doctype);
-		erpnext.utils.set_letter_head(frm);
 	},
 
 	contact_person: function (frm) {
@@ -592,8 +591,6 @@ frappe.ui.form.on("Payment Entry", {
 	paid_from: function (frm) {
 		if (frm.set_party_account_based_on_party) return;
 
-		frm.events.set_company_bank_account(frm);
-
 		frm.events.set_account_currency_and_balance(
 			frm,
 			frm.doc.paid_from,
@@ -603,7 +600,6 @@ frappe.ui.form.on("Payment Entry", {
 				if (frm.doc.payment_type == "Pay") {
 					frm.events.paid_amount(frm);
 				}
-				frm.events.paid_from_account_currency(frm);
 			}
 		);
 	},
@@ -611,8 +607,6 @@ frappe.ui.form.on("Payment Entry", {
 	paid_to: function (frm) {
 		if (frm.set_party_account_based_on_party) return;
 
-		frm.events.set_company_bank_account(frm);
-
 		frm.events.set_account_currency_and_balance(
 			frm,
 			frm.doc.paid_to,
@@ -629,7 +623,6 @@ frappe.ui.form.on("Payment Entry", {
 						frm.events.received_amount(frm);
 					}
 				}
-				frm.events.paid_to_account_currency(frm);
 			}
 		);
 	},
@@ -1302,14 +1295,15 @@ frappe.ui.form.on("Payment Entry", {
 		let row = (frm.doc.deductions || []).find((t) => t.is_exchange_gain_loss);
 
 		if (!row) {
-			const company_defaults = frappe.get_doc(":Company", frm.doc.company);
+			const response = await get_company_defaults(frm.doc.company);
+
 			const account =
-				company_defaults?.[account_fieldname] ||
+				response.message?.[account_fieldname] ||
 				(await prompt_for_missing_account(frm, account_fieldname));
 
 			row = frm.add_child("deductions");
 			row.account = account;
-			row.cost_center = company_defaults?.cost_center;
+			row.cost_center = response.message?.cost_center;
 			row.is_exchange_gain_loss = 1;
 		}
 
@@ -1353,8 +1347,6 @@ frappe.ui.form.on("Payment Entry", {
 	},
 
 	bank_account: function (frm) {
-		if (frm.set_company_bank_account_based_on_coa) return;
-
 		const field = frm.doc.payment_type == "Pay" ? "paid_from" : "paid_to";
 		if (frm.doc.bank_account && ["Pay", "Receive"].includes(frm.doc.payment_type)) {
 			frappe.call({
@@ -1393,34 +1385,6 @@ frappe.ui.form.on("Payment Entry", {
 		}
 	},
 
-	set_company_bank_account: function (frm) {
-		if (!["Pay", "Receive"].includes(frm.doc.payment_type)) return;
-
-		const field = frm.doc.payment_type == "Pay" ? "paid_from" : "paid_to";
-
-		if (!frm.doc.company || !frm.doc[field]) return;
-
-		frm.set_company_bank_account_based_on_coa = true;
-
-		frappe.call({
-			method: "frappe.client.get_value",
-			args: {
-				doctype: "Bank Account",
-				filters: {
-					company: frm.doc.company,
-					account: frm.doc[field],
-					disabled: 0,
-				},
-				fieldname: ["name"],
-			},
-			callback: async function (r) {
-				if (r.message) await frm.set_value("bank_account", r.message.name);
-
-				frm.set_company_bank_account_based_on_coa = false;
-			},
-		});
-	},
-
 	sales_taxes_and_charges_template: function (frm) {
 		frm.trigger("fetch_taxes_from_template");
 	},

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -46,10 +46,8 @@ from erpnext.accounts.party import (
 from erpnext.accounts.utils import (
 	cancel_exchange_gain_loss_journal,
 	get_account_currency,
-	get_advance_payment_doctypes,
 	get_balance_on,
 	get_outstanding_invoices,
-	get_reconciliation_effect_date,
 )
 from erpnext.controllers.accounts_controller import (
 	AccountsController,
@@ -117,10 +115,12 @@ class PaymentEntry(AccountsController):
 	def on_submit(self):
 		if self.difference_amount:
 			frappe.throw(_("Difference Amount must be zero"))
-		self.update_payment_requests()
-		self.update_payment_schedule()
 		self.make_gl_entries()
 		self.update_outstanding_amounts()
+		self.update_payment_schedule()
+		self.update_payment_requests()
+		self.make_advance_payment_ledger_entries()
+		self.update_advance_paid()  # advance_paid_status depends on the payment request amount
 		self.set_status()
 
 	def validate_for_repost(self):
@@ -220,11 +220,13 @@ class PaymentEntry(AccountsController):
 			"Advance Payment Ledger Entry",
 		)
 		super().on_cancel()
-		self.update_payment_requests(cancel=True)
-		self.update_payment_schedule(cancel=1)
 		self.make_gl_entries(cancel=1)
 		self.update_outstanding_amounts()
 		self.delink_advance_entry_references()
+		self.update_payment_schedule(cancel=1)
+		self.update_payment_requests(cancel=True)
+		self.make_advance_payment_ledger_entries()
+		self.update_advance_paid()  # advance_paid_status depends on the payment request amount
 		self.set_status()
 
 	def update_payment_requests(self, cancel=False):
@@ -449,7 +451,7 @@ class PaymentEntry(AccountsController):
 				self.contact_person = get_default_contact(self.party_type, self.party)
 
 			complete_contact_details(self)
-			if not self.party_balance and frappe.get_single_value("Accounts Settings", "show_party_balance"):
+			if not self.party_balance:
 				self.party_balance = get_balance_on(
 					party_type=self.party_type, party=self.party, date=self.posting_date, company=self.company
 				)
@@ -566,7 +568,7 @@ class PaymentEntry(AccountsController):
 	def validate_mandatory(self):
 		for field in ("paid_amount", "received_amount", "source_exchange_rate", "target_exchange_rate"):
 			if not self.get(field):
-				frappe.throw(_("{0} is mandatory").format(_(self.meta.get_label(field))))
+				frappe.throw(_("{0} is mandatory").format(self.meta.get_label(field)))
 
 	def validate_reference_documents(self):
 		valid_reference_doctypes = self.get_valid_reference_doctypes()
@@ -1026,7 +1028,7 @@ class PaymentEntry(AccountsController):
 
 	def calculate_base_allocated_amount_for_reference(self, d) -> float:
 		base_allocated_amount = 0
-		if d.reference_doctype in get_advance_payment_doctypes():
+		if d.reference_doctype in frappe.get_hooks("advance_payment_doctypes"):
 			# When referencing Sales/Purchase Order, use the source/target exchange rate depending on payment type.
 			# This is so there are no Exchange Gain/Loss generated for such doctypes
 
@@ -1306,7 +1308,8 @@ class PaymentEntry(AccountsController):
 		if not self.party_account:
 			return
 
-		advance_payment_doctypes = get_advance_payment_doctypes()
+		advance_payment_doctypes = frappe.get_hooks("advance_payment_doctypes")
+
 		if self.payment_type == "Receive":
 			against_account = self.paid_to
 		else:
@@ -1362,27 +1365,23 @@ class PaymentEntry(AccountsController):
 						dr_or_cr + "_in_transaction_currency": d.allocated_amount
 						if self.transaction_currency == self.party_account_currency
 						else allocated_amount_in_company_currency / self.transaction_exchange_rate,
-						"advance_voucher_type": d.advance_voucher_type,
-						"advance_voucher_no": d.advance_voucher_no,
 					},
 					item=self,
 				)
 			)
 
-			if d.reference_doctype in advance_payment_doctypes:
-				# advance reference
-				gle.update(
-					{
-						"against_voucher_type": self.doctype,
-						"against_voucher": self.name,
-						"advance_voucher_type": d.reference_doctype,
-						"advance_voucher_no": d.reference_name,
-					}
-				)
-
-			elif self.book_advance_payments_in_separate_party_account:
-				# Do not reference Invoices while Advance is in separate party account
-				gle.update({"against_voucher_type": self.doctype, "against_voucher": self.name})
+			if self.book_advance_payments_in_separate_party_account:
+				if d.reference_doctype in advance_payment_doctypes:
+					# Upon reconciliation, whole ledger will be reposted. So, reference to SO/PO is fine
+					gle.update(
+						{
+							"against_voucher_type": d.reference_doctype,
+							"against_voucher": d.reference_name,
+						}
+					)
+				else:
+					# Do not reference Invoices while Advance is in separate party account
+					gle.update({"against_voucher_type": self.doctype, "against_voucher": self.name})
 			else:
 				gle.update(
 					{
@@ -1487,14 +1486,29 @@ class PaymentEntry(AccountsController):
 			"voucher_no": self.name,
 			"voucher_detail_no": invoice.name,
 		}
+
 		if invoice.reconcile_effect_on:
 			posting_date = invoice.reconcile_effect_on
 		else:
 			# For backwards compatibility
 			# Supporting reposting on payment entries reconciled before select field introduction
-			posting_date = get_reconciliation_effect_date(
-				invoice.reference_doctype, invoice.reference_name, self.company, self.posting_date
+			reconciliation_takes_effect_on = frappe.get_cached_value(
+				"Company", self.company, "reconciliation_takes_effect_on"
 			)
+			if reconciliation_takes_effect_on == "Advance Payment Date":
+				posting_date = self.posting_date
+			elif reconciliation_takes_effect_on == "Oldest Of Invoice Or Advance":
+				date_field = "posting_date"
+				if invoice.reference_doctype in ["Sales Order", "Purchase Order"]:
+					date_field = "transaction_date"
+				posting_date = frappe.db.get_value(
+					invoice.reference_doctype, invoice.reference_name, date_field
+				)
+
+				if getdate(posting_date) < getdate(self.posting_date):
+					posting_date = self.posting_date
+			elif reconciliation_takes_effect_on == "Reconciliation Date":
+				posting_date = nowdate()
 			frappe.db.set_value("Payment Entry Reference", invoice.name, "reconcile_effect_on", posting_date)
 
 		dr_or_cr, account = self.get_dr_and_account_for_advances(invoice)
@@ -1512,8 +1526,6 @@ class PaymentEntry(AccountsController):
 			{
 				"against_voucher_type": invoice.reference_doctype,
 				"against_voucher": invoice.reference_name,
-				"advance_voucher_type": invoice.advance_voucher_type,
-				"advance_voucher_no": invoice.advance_voucher_no,
 				"posting_date": posting_date,
 			}
 		)
@@ -1538,8 +1550,6 @@ class PaymentEntry(AccountsController):
 			{
 				"against_voucher_type": "Payment Entry",
 				"against_voucher": self.name,
-				"advance_voucher_type": invoice.advance_voucher_type,
-				"advance_voucher_no": invoice.advance_voucher_no,
 			}
 		)
 		gle = self.get_gl_dict(
@@ -1688,6 +1698,14 @@ class PaymentEntry(AccountsController):
 
 		return flt(gl_dict.get(field, 0) / (conversion_rate or 1))
 
+	def update_advance_paid(self):
+		if self.payment_type in ("Receive", "Pay") and self.party:
+			for d in self.get("references"):
+				if d.allocated_amount and d.reference_doctype in frappe.get_hooks("advance_payment_doctypes"):
+					frappe.get_doc(
+						d.reference_doctype, d.reference_name, for_update=True
+					).set_total_advance_paid()
+
 	def on_recurring(self, reference_doc, auto_repeat_doc):
 		self.reference_no = reference_doc.name
 		self.reference_date = nowdate()
@@ -1800,7 +1818,7 @@ class PaymentEntry(AccountsController):
 				else:
 					self.total_taxes_and_charges += current_tax_amount
 
-			self.base_total_taxes_and_charges += current_tax_amount
+			self.base_total_taxes_and_charges += tax.base_tax_amount
 
 		if self.get("taxes"):
 			self.paid_amount_after_tax = self.get("taxes")[-1].base_total
@@ -2684,17 +2702,11 @@ def get_party_details(company, party_type, party, date, cost_center=None):
 
 	party_account = get_party_account(party_type, party, company)
 	account_currency = get_account_currency(party_account)
-	account_balance = (
-		get_balance_on(party_account, date, cost_center=cost_center)
-		if frappe.get_single_value("Accounts Settings", "show_account_balance")
-		else 0
-	)
+	account_balance = get_balance_on(party_account, date, cost_center=cost_center)
 	_party_name = "title" if party_type == "Shareholder" else party_type.lower() + "_name"
 	party_name = frappe.db.get_value(party_type, party, _party_name)
-	party_balance = (
-		get_balance_on(party_type=party_type, party=party, company=company, cost_center=cost_center)
-		if frappe.get_single_value("Accounts Settings", "show_party_balance")
-		else 0
+	party_balance = get_balance_on(
+		party_type=party_type, party=party, company=company, cost_center=cost_center
 	)
 	if party_type in ["Customer", "Supplier"]:
 		party_bank_account = get_party_bank_account(party_type, party)
@@ -2723,11 +2735,7 @@ def get_account_details(account, date, cost_center=None):
 	if not account_list:
 		frappe.throw(_("Account: {0} is not permitted under Payment Entry").format(account))
 
-	account_balance = (
-		get_balance_on(account, date, cost_center=cost_center, ignore_account_permission=True)
-		if frappe.get_single_value("Accounts Settings", "show_account_balance")
-		else 0
-	)
+	account_balance = get_balance_on(account, date, cost_center=cost_center, ignore_account_permission=True)
 
 	return frappe._dict(
 		{
@@ -3539,18 +3547,11 @@ def get_paid_amount(dt, dn, party_type, party, account, due_date):
 def get_party_and_account_balance(
 	company, date, paid_from=None, paid_to=None, ptype=None, pty=None, cost_center=None
 ):
-	show_account_balance = frappe.get_single_value("Accounts Settings", "show_account_balance")
 	return frappe._dict(
 		{
-			"party_balance": get_balance_on(party_type=ptype, party=pty, cost_center=cost_center)
-			if frappe.get_single_value("Accounts Settings", "show_party_balance")
-			else 0,
-			"paid_from_account_balance": get_balance_on(paid_from, date, cost_center=cost_center)
-			if show_account_balance
-			else 0,
-			"paid_to_account_balance": get_balance_on(paid_to, date=date, cost_center=cost_center)
-			if show_account_balance
-			else 0,
+			"party_balance": get_balance_on(party_type=ptype, party=pty, cost_center=cost_center),
+			"paid_from_account_balance": get_balance_on(paid_from, date, cost_center=cost_center),
+			"paid_to_account_balance": get_balance_on(paid_to, date=date, cost_center=cost_center),
 		}
 	)
 

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -52,7 +52,7 @@ class TestPaymentEntry(FrappeTestCase):
 		self.assertEqual(pe.paid_to_account_type, "Cash")
 
 		expected_gle = dict(
-			(d[0], d) for d in [["Debtors - _TC", 0, 1000, pe.name], ["_Test Cash - _TC", 1000.0, 0, None]]
+			(d[0], d) for d in [["Debtors - _TC", 0, 1000, so.name], ["_Test Cash - _TC", 1000.0, 0, None]]
 		)
 
 		self.validate_gl_entries(pe.name, expected_gle)
@@ -84,7 +84,7 @@ class TestPaymentEntry(FrappeTestCase):
 
 		expected_gle = dict(
 			(d[0], d)
-			for d in [["_Test Receivable USD - _TC", 0, 5500, pe.name], [pe.paid_to, 5500.0, 0, None]]
+			for d in [["_Test Receivable USD - _TC", 0, 5500, so.name], [pe.paid_to, 5500.0, 0, None]]
 		)
 
 		self.validate_gl_entries(pe.name, expected_gle)

erpnext/accounts/doctype/payment_entry_reference/payment_entry_reference.json

@@ -22,9 +22,7 @@
   "exchange_gain_loss",
   "account",
   "payment_request",
-  "payment_request_outstanding",
-  "advance_voucher_type",
-  "advance_voucher_no"
+  "payment_request_outstanding"
  ],
  "fields": [
   {
@@ -153,28 +151,12 @@
    "fieldtype": "Date",
    "label": "Reconcile Effect On",
    "read_only": 1
-  },
-  {
-   "columns": 2,
-   "fieldname": "advance_voucher_type",
-   "fieldtype": "Link",
-   "label": "Advance Voucher Type",
-   "options": "DocType",
-   "read_only": 1
-  },
-  {
-   "columns": 2,
-   "fieldname": "advance_voucher_no",
-   "fieldtype": "Dynamic Link",
-   "label": "Advance Voucher No",
-   "options": "advance_voucher_type",
-   "read_only": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-07-25 04:32:11.040025",
+ "modified": "2025-01-13 15:56:18.895082",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry Reference",
@@ -185,4 +167,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/payment_entry_reference/payment_entry_reference.py

@@ -16,8 +16,6 @@ class PaymentEntryReference(Document):
 
 		account: DF.Link | None
 		account_type: DF.Data | None
-		advance_voucher_no: DF.DynamicLink | None
-		advance_voucher_type: DF.Link | None
 		allocated_amount: DF.Float
 		bill_no: DF.Data | None
 		due_date: DF.Date | None
@@ -28,6 +26,7 @@ class PaymentEntryReference(Document):
 		parentfield: DF.Data
 		parenttype: DF.Data
 		payment_request: DF.Link | None
+		payment_request_outstanding: DF.Float
 		payment_term: DF.Link | None
 		payment_term_outstanding: DF.Float
 		payment_type: DF.Data | None

erpnext/accounts/doctype/payment_gateway_account/payment_gateway_account.js

@@ -8,14 +8,4 @@ frappe.ui.form.on("Payment Gateway Account", {
 			frm.set_df_property("payment_gateway", "read_only", 1);
 		}
 	},
-
-	setup(frm) {
-		frm.set_query("payment_account", function () {
-			return {
-				filters: {
-					company: frm.doc.company,
-				},
-			};
-		});
-	},
 });

erpnext/accounts/doctype/payment_gateway_account/payment_gateway_account.json

@@ -6,7 +6,6 @@
  "field_order": [
   "payment_gateway",
   "payment_channel",
-  "company",
   "is_default",
   "column_break_4",
   "payment_account",
@@ -71,21 +70,11 @@
    "fieldtype": "Select",
    "label": "Payment Channel",
    "options": "\nEmail\nPhone"
-  },
-  {
-   "fieldname": "company",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Company",
-   "options": "Company",
-   "print_hide": 1,
-   "remember_last_selected_value": 1,
-   "reqd": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2025-07-14 16:49:55.210352",
+ "modified": "2020-09-20 13:30:27.722852",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Gateway Account",
@@ -106,4 +95,4 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC"
-}
+}

erpnext/accounts/doctype/payment_gateway_account/payment_gateway_account.py

@@ -15,7 +15,6 @@ class PaymentGatewayAccount(Document):
 	if TYPE_CHECKING:
 		from frappe.types import DF
 
-		company: DF.Link
 		currency: DF.ReadOnly | None
 		is_default: DF.Check
 		message: DF.SmallText | None
@@ -25,8 +24,7 @@ class PaymentGatewayAccount(Document):
 	# end: auto-generated types
 
 	def autoname(self):
-		abbr = frappe.db.get_value("Company", self.company, "abbr")
-		self.name = self.payment_gateway + " - " + self.currency + " - " + abbr
+		self.name = self.payment_gateway + " - " + self.currency
 
 	def validate(self):
 		self.currency = frappe.get_cached_value("Account", self.payment_account, "account_currency")
@@ -36,15 +34,13 @@ class PaymentGatewayAccount(Document):
 
 	def update_default_payment_gateway(self):
 		if self.is_default:
-			frappe.db.set_value(
-				"Payment Gateway Account",
-				{"is_default": 1, "name": ["!=", self.name], "company": self.company},
-				"is_default",
-				0,
+			frappe.db.sql(
+				"""update `tabPayment Gateway Account` set is_default = 0
+				where is_default = 1 """
 			)
 
 	def set_as_default_if_not_set(self):
-		if not frappe.db.exists(
-			"Payment Gateway Account", {"is_default": 1, "name": ("!=", self.name), "company": self.company}
+		if not frappe.db.get_value(
+			"Payment Gateway Account", {"is_default": 1, "name": ("!=", self.name)}, "name"
 		):
 			self.is_default = 1

erpnext/accounts/doctype/payment_ledger_entry/payment_ledger_entry.json

@@ -197,4 +197,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js

@@ -61,22 +61,6 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 				},
 			};
 		});
-		this.frm.set_query("cost_center", "payments", () => {
-			return {
-				filters: {
-					company: this.frm.doc.company,
-					is_group: 0,
-				},
-			};
-		});
-		this.frm.set_query("cost_center", "allocation", () => {
-			return {
-				filters: {
-					company: this.frm.doc.company,
-					is_group: 0,
-				},
-			};
-		});
 	}
 
 	refresh() {
@@ -334,9 +318,7 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 					},
 					{
 						fieldtype: "HTML",
-						options: __(
-							"New Journal Entry will be posted for the difference amount. The Posting Date can be modified."
-						).bold(),
+						options: "<b> New Journal Entry will be posted for the difference amount </b>",
 					},
 				],
 				primary_action: () => {
@@ -403,16 +385,6 @@ frappe.ui.form.on("Payment Reconciliation Allocation", {
 		// filter payment
 		let payment = frm.doc.payments.filter((x) => x.reference_name == row.reference_name);
 
-		let amount = payment[0].amount;
-		for (const d of frm.doc.allocation) {
-			if (row.reference_name == d.reference_name && amount) {
-				if (d.allocated_amount <= amount) {
-					d.amount = amount;
-					amount -= d.allocated_amount;
-				}
-			}
-		}
-
 		frm.call({
 			doc: frm.doc,
 			method: "calculate_difference_on_allocation_change",

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.json

@@ -28,7 +28,6 @@
   "accounting_dimensions_section",
   "cost_center",
   "dimension_col_break",
-  "project",
   "sec_break1",
   "invoice_name",
   "invoices",
@@ -194,12 +193,6 @@
    "label": "Cost Center",
    "options": "Cost Center"
   },
-  {
-    "fieldname": "project",
-    "fieldtype": "Link",
-    "label": "Project",
-    "options": "Project"
-  },
   {
    "depends_on": "eval:doc.party",
    "description": "Only 'Payment Entries' made against this advance account are supported.",

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -5,7 +5,6 @@
 import frappe
 from frappe import _, msgprint, qb
 from frappe.model.document import Document
-from frappe.model.meta import get_field_precision
 from frappe.query_builder import Criterion
 from frappe.query_builder.custom import ConstantColumn
 from frappe.utils import flt, fmt_money, get_link_to_form, getdate, nowdate, today
@@ -72,7 +71,7 @@ class PaymentReconciliation(Document):
 		self.common_filter_conditions = []
 		self.accounting_dimension_filter_conditions = []
 		self.ple_posting_date_filter = []
-		self.dimensions = get_dimensions(with_cost_center_and_project=True)[0]
+		self.dimensions = get_dimensions()[0]
 
 	def load_from_db(self):
 		# 'modified' attribute is required for `run_doc_method` to work properly.
@@ -393,12 +392,6 @@ class PaymentReconciliation(Document):
 			inv.outstanding_amount = flt(entry.get("outstanding_amount"))
 
 	def get_difference_amount(self, payment_entry, invoice, allocated_amount):
-		allocated_amount_precision = get_field_precision(
-			frappe.get_meta("Payment Reconciliation Allocation").get_field("allocated_amount")
-		)
-		difference_amount_precision = get_field_precision(
-			frappe.get_meta("Payment Reconciliation Allocation").get_field("difference_amount")
-		)
 		difference_amount = 0
 		if frappe.get_cached_value(
 			"Account", self.receivable_payable_account, "account_currency"
@@ -406,14 +399,8 @@ class PaymentReconciliation(Document):
 			if invoice.get("exchange_rate") and payment_entry.get("exchange_rate", 1) != invoice.get(
 				"exchange_rate", 1
 			):
-				allocated_amount_in_ref_rate = flt(
-					payment_entry.get("exchange_rate", 1) * flt(allocated_amount, allocated_amount_precision),
-					difference_amount_precision,
-				)
-				allocated_amount_in_inv_rate = flt(
-					invoice.get("exchange_rate", 1) * flt(allocated_amount, allocated_amount_precision),
-					difference_amount_precision,
-				)
+				allocated_amount_in_ref_rate = payment_entry.get("exchange_rate", 1) * allocated_amount
+				allocated_amount_in_inv_rate = invoice.get("exchange_rate", 1) * allocated_amount
 				difference_amount = allocated_amount_in_ref_rate - allocated_amount_in_inv_rate
 
 		return difference_amount
@@ -589,7 +576,6 @@ class PaymentReconciliation(Document):
 				"difference_amount": flt(row.get("difference_amount")),
 				"difference_account": row.get("difference_account"),
 				"difference_posting_date": row.get("gain_loss_posting_date"),
-				"debit_or_credit_note_posting_date": row.get("debit_or_credit_note_posting_date"),
 				"cost_center": row.get("cost_center"),
 			}
 		)
@@ -603,7 +589,7 @@ class PaymentReconciliation(Document):
 	def check_mandatory_to_fetch(self):
 		for fieldname in ["company", "party_type", "party", "receivable_payable_account"]:
 			if not self.get(fieldname):
-				frappe.throw(_("Please select {0} first").format(_(self.meta.get_label(fieldname))))
+				frappe.throw(_("Please select {0} first").format(self.meta.get_label(fieldname)))
 
 	def validate_entries(self):
 		if not self.get("invoices"):
@@ -765,14 +751,6 @@ 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 = (
@@ -787,7 +765,7 @@ def reconcile_dr_cr_note(dr_cr_notes, company, active_dimensions=None):
 			{
 				"doctype": "Journal Entry",
 				"voucher_type": voucher_type,
-				"posting_date": inv.get("debit_or_credit_note_posting_date") or today(),
+				"posting_date": today(),
 				"company": company,
 				"multi_currency": 1 if inv.currency != company_currency else 0,
 				"accounts": [
@@ -848,7 +826,7 @@ def reconcile_dr_cr_note(dr_cr_notes, company, active_dimensions=None):
 
 			create_gain_loss_journal(
 				company,
-				inv.difference_posting_date,
+				today(),
 				inv.party_type,
 				inv.party,
 				inv.account,

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -1714,67 +1714,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		)
 		self.assertEqual(len(pl_entries), 3)
 
-	def test_advance_payment_reconciliation_date_for_older_date(self):
-		old_settings = frappe.db.get_value(
-			"Company",
-			self.company,
-			[
-				"reconciliation_takes_effect_on",
-				"default_advance_paid_account",
-				"book_advance_payments_in_separate_party_account",
-			],
-			as_dict=True,
-		)
-		frappe.db.set_value(
-			"Company",
-			self.company,
-			{
-				"book_advance_payments_in_separate_party_account": 1,
-				"default_advance_paid_account": self.advance_payable_account,
-				"reconciliation_takes_effect_on": "Oldest Of Invoice Or Advance",
-			},
-		)
-
-		self.supplier = "_Test Supplier"
-
-		pi1 = self.create_purchase_invoice(qty=10, rate=100)
-		po = self.create_purchase_order(qty=10, rate=100)
-
-		pay = get_payment_entry(po.doctype, po.name)
-		pay.paid_amount = 1000
-		pay.save().submit()
-
-		pr = frappe.new_doc("Payment Reconciliation")
-		pr.company = self.company
-		pr.party_type = "Supplier"
-		pr.party = self.supplier
-		pr.receivable_payable_account = get_party_account(pr.party_type, pr.party, pr.company)
-		pr.default_advance_account = self.advance_payable_account
-		pr.get_unreconciled_entries()
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [x.as_dict() for x in pr.payments]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-		pr.allocation[0].allocated_amount = 100
-		pr.reconcile()
-
-		pay.reload()
-		self.assertEqual(getdate(pay.references[0].reconcile_effect_on), getdate(pi1.posting_date))
-
-		# test setting of date if not available
-		frappe.db.set_value("Payment Entry Reference", pay.references[1].name, "reconcile_effect_on", None)
-		pay.reload()
-		pay.cancel()
-
-		pay.reload()
-		pi1.reload()
-		po.reload()
-
-		self.assertEqual(getdate(pay.references[0].reconcile_effect_on), getdate(pi1.posting_date))
-		pi1.cancel()
-		po.cancel()
-
-		frappe.db.set_value("Company", self.company, old_settings)
-
 	def test_advance_payment_reconciliation_against_journal_for_customer(self):
 		frappe.db.set_value(
 			"Company",
@@ -2206,136 +2145,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		self.assertEqual(len(pr.get("payments")), 0)
 		self.assertEqual(pr.get("invoices")[0].get("outstanding_amount"), 200)
 
-	def test_partial_advance_payment_with_closed_fiscal_year(self):
-		"""
-		Test Advance Payment partial reconciliation before period closing and partial after period closing
-		"""
-		default_settings = frappe.db.get_value(
-			"Company",
-			self.company,
-			[
-				"book_advance_payments_in_separate_party_account",
-				"default_advance_paid_account",
-				"reconciliation_takes_effect_on",
-			],
-			as_dict=True,
-		)
-		first_fy_start_date = frappe.db.get_value("Fiscal Year", {"disabled": 0}, "min(year_start_date)")
-		prev_fy_start_date = add_years(first_fy_start_date, -1)
-		prev_fy_end_date = add_days(first_fy_start_date, -1)
-
-		create_fiscal_year(
-			company=self.company, year_start_date=prev_fy_start_date, year_end_date=prev_fy_end_date
-		)
-
-		frappe.db.set_value(
-			"Company",
-			self.company,
-			{
-				"book_advance_payments_in_separate_party_account": 1,
-				"default_advance_paid_account": self.advance_payable_account,
-				"reconciliation_takes_effect_on": "Oldest Of Invoice Or Advance",
-			},
-		)
-
-		self.supplier = "_Test Supplier"
-
-		# Create advance payment of 1000 (previous FY)
-		pe = self.create_payment_entry(amount=1000, posting_date=prev_fy_start_date)
-		pe.party_type = "Supplier"
-		pe.party = self.supplier
-		pe.payment_type = "Pay"
-		pe.paid_from = self.cash
-		pe.paid_to = self.advance_payable_account
-		pe.save().submit()
-
-		# Create purchase invoice of 600 (previous FY)
-		pi1 = self.create_purchase_invoice(qty=1, rate=600, do_not_submit=True)
-		pi1.posting_date = prev_fy_start_date
-		pi1.set_posting_time = 1
-		pi1.supplier = self.supplier
-		pi1.credit_to = self.creditors
-		pi1.save().submit()
-
-		# Reconcile advance payment
-		pr = self.create_payment_reconciliation(party_is_customer=False)
-		pr.party = self.supplier
-		pr.receivable_payable_account = self.creditors
-		pr.default_advance_account = self.advance_payable_account
-		pr.from_invoice_date = pr.to_invoice_date = pi1.posting_date
-		pr.from_payment_date = pr.to_payment_date = pe.posting_date
-		pr.get_unreconciled_entries()
-		invoices = [x.as_dict() for x in pr.invoices if x.invoice_number == pi1.name]
-		payments = [x.as_dict() for x in pr.payments if x.reference_name == pe.name]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-		pr.reconcile()
-
-		# Verify partial reconciliation
-		pe.reload()
-		pi1.reload()
-
-		self.assertEqual(len(pe.references), 1)
-		self.assertEqual(pe.references[0].allocated_amount, 600)
-		self.assertEqual(flt(pe.unallocated_amount), 400)
-
-		self.assertEqual(pi1.outstanding_amount, 0)
-		self.assertEqual(pi1.status, "Paid")
-
-		# Close accounting period for March (previous FY)
-		pcv = make_period_closing_voucher(
-			company=self.company, cost_center=self.cost_center, posting_date=prev_fy_end_date
-		)
-		pcv.reload()
-		self.assertEqual(pcv.gle_processing_status, "Completed")
-
-		# Change reconciliation setting to "Reconciliation Date"
-		frappe.db.set_value(
-			"Company",
-			self.company,
-			"reconciliation_takes_effect_on",
-			"Reconciliation Date",
-		)
-
-		# Create new purchase invoice for 400 in new fiscal year
-		pi2 = self.create_purchase_invoice(qty=1, rate=400, do_not_submit=True)
-		pi2.posting_date = today()
-		pi2.set_posting_time = 1
-		pi2.supplier = self.supplier
-		pi2.currency = "INR"
-		pi2.credit_to = self.creditors
-		pi2.save()
-		pi2.submit()
-
-		# Allocate 600 from advance payment to purchase invoice
-		pr = self.create_payment_reconciliation(party_is_customer=False)
-		pr.party = self.supplier
-		pr.receivable_payable_account = self.creditors
-		pr.default_advance_account = self.advance_payable_account
-		pr.from_invoice_date = pr.to_invoice_date = pi2.posting_date
-		pr.from_payment_date = pr.to_payment_date = pe.posting_date
-		pr.get_unreconciled_entries()
-		invoices = [x.as_dict() for x in pr.invoices if x.invoice_number == pi2.name]
-		payments = [x.as_dict() for x in pr.payments if x.reference_name == pe.name]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-		pr.reconcile()
-
-		pe.reload()
-		pi2.reload()
-
-		# Assert advance payment is fully allocated
-		self.assertEqual(len(pe.references), 2)
-		self.assertEqual(flt(pe.unallocated_amount), 0)
-
-		# Assert new invoice is fully paid
-		self.assertEqual(pi2.outstanding_amount, 0)
-		self.assertEqual(pi2.status, "Paid")
-
-		# Verify reconciliation dates are correct based on company setting
-		self.assertEqual(getdate(pe.references[0].reconcile_effect_on), getdate(pi1.posting_date))
-		self.assertEqual(getdate(pe.references[1].reconcile_effect_on), getdate(pi2.posting_date))
-
-		frappe.db.set_value("Company", self.company, default_settings)
-
 
 def make_customer(customer_name, currency=None):
 	if not frappe.db.exists("Customer", customer_name):

erpnext/accounts/doctype/payment_reconciliation_allocation/payment_reconciliation_allocation.json

@@ -20,7 +20,6 @@
   "section_break_5",
   "difference_amount",
   "gain_loss_posting_date",
-  "debit_or_credit_note_posting_date",
   "column_break_7",
   "difference_account",
   "exchange_rate",
@@ -169,17 +168,12 @@
   {
    "fieldname": "dimension_col_break",
    "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "debit_or_credit_note_posting_date",
-   "fieldtype": "Date",
-   "label": "Debit / Credit Note Posting Date"
   }
  ],
  "is_virtual": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-08-20 19:12:50.406769",
+ "modified": "2023-12-14 13:38:26.104150",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Allocation",
@@ -189,4 +183,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/payment_reconciliation_allocation/payment_reconciliation_allocation.py

@@ -18,7 +18,6 @@ class PaymentReconciliationAllocation(Document):
 		amount: DF.Currency
 		cost_center: DF.Link | None
 		currency: DF.Link | None
-		debit_or_credit_note_posting_date: DF.Date | None
 		difference_account: DF.Link | None
 		difference_amount: DF.Currency
 		exchange_rate: DF.Float

erpnext/accounts/doctype/payment_request/payment_request.js

@@ -9,14 +9,6 @@ frappe.ui.form.on("Payment Request", {
 				query: "erpnext.setup.doctype.party_type.party_type.get_party_type",
 			};
 		});
-
-		frm.set_query("payment_gateway_account", function () {
-			return {
-				filters: {
-					company: frm.doc.company,
-				},
-			};
-		});
 	},
 });
 

erpnext/accounts/doctype/payment_request/payment_request.json

@@ -226,8 +226,7 @@
    "fetch_from": "bank_account.iban",
    "fieldname": "iban",
    "fieldtype": "Read Only",
-   "label": "IBAN",
-   "options": "IBAN"
+   "label": "IBAN"
   },
   {
    "fetch_from": "bank_account.branch_code",
@@ -444,12 +443,11 @@
    "label": "Phone Number"
   }
  ],
- "grid_page_length": 50,
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-08-29 11:52:48.555415",
+ "modified": "2024-12-27 21:29:10.361894",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Request",
@@ -484,9 +482,8 @@
    "write": 1
   }
  ],
- "row_format": "Dynamic",
  "show_preview_popup": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -127,13 +127,7 @@ class PaymentRequest(Document):
 
 			existing_payment_request_amount = flt(get_existing_payment_request_amount(ref_doc))
 
-			if (
-				flt(
-					existing_payment_request_amount + flt(self.grand_total, self.precision("grand_total")),
-					get_currency_precision(),
-				)
-				> ref_amount
-			):
+			if existing_payment_request_amount + flt(self.grand_total) > ref_amount:
 				frappe.throw(
 					_("Total Payment Request amount cannot be greater than {0} amount").format(
 						self.reference_doctype
@@ -545,12 +539,7 @@ def make_payment_request(**args):
 	if args.dt not in ALLOWED_DOCTYPES_FOR_PAYMENT_REQUEST:
 		frappe.throw(_("Payment Requests cannot be created against: {0}").format(frappe.bold(args.dt)))
 
-	if args.dn and not isinstance(args.dn, str):
-		frappe.throw(_("Invalid parameter. 'dn' should be of type str"))
-
-	ref_doc = args.ref_doc or frappe.get_doc(args.dt, args.dn)
-	if not args.get("company"):
-		args.company = ref_doc.company
+	ref_doc = frappe.get_doc(args.dt, args.dn)
 	gateway_account = get_gateway_details(args) or frappe._dict()
 
 	grand_total = get_amount(ref_doc, gateway_account.get("payment_account"))
@@ -793,7 +782,7 @@ def get_gateway_details(args):  # nosemgrep
 	"""
 	Return gateway and payment account of default payment gateway
 	"""
-	gateway_account = args.get("payment_gateway_account", {"is_default": 1, "company": args.company})
+	gateway_account = args.get("payment_gateway_account", {"is_default": 1})
 	if gateway_account:
 		return get_payment_gateway_account(gateway_account)
 
@@ -840,7 +829,8 @@ def update_payment_requests_as_per_pe_references(references=None, cancel=False):
 	if not references:
 		return
 
-	precision = frappe.get_precision("Payment Entry Reference", "allocated_amount")
+	precision = references[0].precision("allocated_amount")
+
 	referenced_payment_requests = frappe.get_all(
 		"Payment Request",
 		filters={"name": ["in", {row.payment_request for row in references if row.payment_request}]},
@@ -853,7 +843,6 @@ def update_payment_requests_as_per_pe_references(references=None, cancel=False):
 	)
 
 	referenced_payment_requests = {pr.name: pr for pr in referenced_payment_requests}
-	doc_updates = {}
 
 	for ref in references:
 		if not ref.payment_request:
@@ -879,7 +868,7 @@ def update_payment_requests_as_per_pe_references(references=None, cancel=False):
 				title=_("Invalid Allocated Amount"),
 			)
 
-		# determine status
+		# update status
 		if new_outstanding_amount == payment_request["grand_total"]:
 			status = "Initiated" if payment_request["payment_request_type"] == "Outward" else "Requested"
 		elif new_outstanding_amount == 0:
@@ -887,15 +876,12 @@ def update_payment_requests_as_per_pe_references(references=None, cancel=False):
 		elif new_outstanding_amount > 0:
 			status = "Partially Paid"
 
-		# prepare bulk update data
-		doc_updates[ref.payment_request] = {
-			"outstanding_amount": new_outstanding_amount,
-			"status": status,
-		}
-
-	# bulk update all payment requests
-	if doc_updates:
-		frappe.db.bulk_update("Payment Request", doc_updates)
+		# update database
+		frappe.db.set_value(
+			"Payment Request",
+			ref.payment_request,
+			{"outstanding_amount": new_outstanding_amount, "status": status},
+		)
 
 
 def get_dummy_message(doc):

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -28,14 +28,12 @@ payment_method = [
 		"payment_gateway": "_Test Gateway",
 		"payment_account": "_Test Bank - _TC",
 		"currency": "INR",
-		"company": "_Test Company",
 	},
 	{
 		"doctype": "Payment Gateway Account",
 		"payment_gateway": "_Test Gateway",
 		"payment_account": "_Test Bank USD - _TC",
 		"currency": "USD",
-		"company": "_Test Company",
 	},
 ]
 
@@ -48,11 +46,7 @@ class TestPaymentRequest(FrappeTestCase):
 		for method in payment_method:
 			if not frappe.db.get_value(
 				"Payment Gateway Account",
-				{
-					"payment_gateway": method["payment_gateway"],
-					"currency": method["currency"],
-					"company": method["company"],
-				},
+				{"payment_gateway": method["payment_gateway"], "currency": method["currency"]},
 				"name",
 			):
 				frappe.get_doc(method).insert(ignore_permissions=True)
@@ -66,7 +60,7 @@ class TestPaymentRequest(FrappeTestCase):
 			dt="Sales Order",
 			dn=so_inr.name,
 			recipient_id="saurabh@erpnext.com",
-			payment_gateway_account="_Test Gateway - INR - _TC",
+			payment_gateway_account="_Test Gateway - INR",
 		)
 
 		self.assertEqual(pr.reference_doctype, "Sales Order")
@@ -80,7 +74,7 @@ class TestPaymentRequest(FrappeTestCase):
 			dt="Sales Invoice",
 			dn=si_usd.name,
 			recipient_id="saurabh@erpnext.com",
-			payment_gateway_account="_Test Gateway - USD - _TC",
+			payment_gateway_account="_Test Gateway - USD",
 		)
 
 		self.assertEqual(pr.reference_doctype, "Sales Invoice")
@@ -101,7 +95,7 @@ class TestPaymentRequest(FrappeTestCase):
 			party="_Test Supplier USD",
 			recipient_id="user@example.com",
 			mute_email=1,
-			payment_gateway_account="_Test Gateway - USD - _TC",
+			payment_gateway_account="_Test Gateway - USD",
 			submit_doc=1,
 			return_doc=1,
 		)
@@ -125,7 +119,7 @@ class TestPaymentRequest(FrappeTestCase):
 			dn=purchase_invoice.name,
 			recipient_id="user@example.com",
 			mute_email=1,
-			payment_gateway_account="_Test Gateway - USD - _TC",
+			payment_gateway_account="_Test Gateway - USD",
 			return_doc=1,
 		)
 
@@ -144,7 +138,7 @@ class TestPaymentRequest(FrappeTestCase):
 			dn=purchase_invoice.name,
 			recipient_id="user@example.com",
 			mute_email=1,
-			payment_gateway_account="_Test Gateway - USD - _TC",
+			payment_gateway_account="_Test Gateway - USD",
 			return_doc=1,
 		)
 
@@ -168,7 +162,7 @@ class TestPaymentRequest(FrappeTestCase):
 			dn=so_inr.name,
 			recipient_id="saurabh@erpnext.com",
 			mute_email=1,
-			payment_gateway_account="_Test Gateway - INR - _TC",
+			payment_gateway_account="_Test Gateway - INR",
 			submit_doc=1,
 			return_doc=1,
 		)
@@ -190,7 +184,7 @@ class TestPaymentRequest(FrappeTestCase):
 			dn=si_usd.name,
 			recipient_id="saurabh@erpnext.com",
 			mute_email=1,
-			payment_gateway_account="_Test Gateway - USD - _TC",
+			payment_gateway_account="_Test Gateway - USD",
 			submit_doc=1,
 			return_doc=1,
 		)
@@ -234,7 +228,7 @@ class TestPaymentRequest(FrappeTestCase):
 			dn=si_usd.name,
 			recipient_id="saurabh@erpnext.com",
 			mute_email=1,
-			payment_gateway_account="_Test Gateway - USD - _TC",
+			payment_gateway_account="_Test Gateway - USD",
 			submit_doc=1,
 			return_doc=1,
 		)
@@ -334,7 +328,7 @@ class TestPaymentRequest(FrappeTestCase):
 
 		self.assertEqual(pe.paid_amount, 800)  # paid amount set from pr's outstanding amount
 		self.assertEqual(pe.references[0].allocated_amount, 800)
-		self.assertEqual(pe.references[0].outstanding_amount, 0)  # Also for orders it will zero
+		self.assertEqual(pe.references[0].outstanding_amount, 800)  # for Orders it is not zero
 		self.assertEqual(pe.references[0].payment_request, pr.name)
 
 		so.load_from_db()
@@ -636,58 +630,29 @@ class TestPaymentRequest(FrappeTestCase):
 		pr = make_payment_request(dt="Sales Invoice", dn=si.name, mute_email=1)
 		self.assertEqual(pr.grand_total, si.outstanding_amount)
 
-	def test_partial_paid_invoice_with_submitted_payment_entry(self):
-		pi = make_purchase_invoice(currency="INR", qty=1, rate=5000)
-		pi.save()
-		pi.submit()
 
-		pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
-		pe.reference_no = "PURINV0001"
-		pe.reference_date = frappe.utils.nowdate()
-		pe.paid_amount = 2500
-		pe.references[0].allocated_amount = 2500
-		pe.save()
-		pe.submit()
-		pe.cancel()
+def test_partial_paid_invoice_with_submitted_payment_entry(self):
+	pi = make_purchase_invoice(currency="INR", qty=1, rate=5000)
+	pi.save()
+	pi.submit()
 
-		pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
-		pe.reference_no = "PURINV0002"
-		pe.reference_date = frappe.utils.nowdate()
-		pe.paid_amount = 2500
-		pe.references[0].allocated_amount = 2500
-		pe.save()
-		pe.submit()
+	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
+	pe.reference_no = "PURINV0001"
+	pe.reference_date = frappe.utils.nowdate()
+	pe.paid_amount = 2500
+	pe.references[0].allocated_amount = 2500
+	pe.save()
+	pe.submit()
+	pe.cancel()
 
-		pi.load_from_db()
-		pr = make_payment_request(dt="Purchase Invoice", dn=pi.name, mute_email=1)
-		self.assertEqual(pr.grand_total, pi.outstanding_amount)
+	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
+	pe.reference_no = "PURINV0002"
+	pe.reference_date = frappe.utils.nowdate()
+	pe.paid_amount = 2500
+	pe.references[0].allocated_amount = 2500
+	pe.save()
+	pe.submit()
 
-	def test_payment_request_on_unreconcile(self):
-		pi = make_purchase_invoice(currency="INR", qty=1, rate=500)
-		pi.submit()
-
-		pr = make_payment_request(
-			dt=pi.doctype,
-			dn=pi.name,
-			mute_email=1,
-			submit_doc=True,
-			return_doc=True,
-		)
-		self.assertEqual(pr.grand_total, pi.outstanding_amount)
-
-		pe = pr.create_payment_entry()
-		unreconcile = frappe.get_doc(
-			{
-				"doctype": "Unreconcile Payment",
-				"company": pe.company,
-				"voucher_type": pe.doctype,
-				"voucher_no": pe.name,
-			}
-		)
-		unreconcile.add_references()
-		unreconcile.submit()
-
-		pi.load_from_db()
-		pr.load_from_db()
-
-		self.assertEqual(pr.grand_total, pi.outstanding_amount)
+	pi.load_from_db()
+	pr = make_payment_request(dt="Purchase Invoice", dn=pi.name, mute_email=1)
+	self.assertEqual(pr.grand_total, pi.outstanding_amount)

erpnext/accounts/doctype/payment_schedule/payment_schedule.json

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

erpnext/accounts/doctype/payment_schedule/payment_schedule.py

@@ -17,27 +17,12 @@ class PaymentSchedule(Document):
 		base_outstanding: DF.Currency
 		base_paid_amount: DF.Currency
 		base_payment_amount: DF.Currency
-		credit_days: DF.Int
-		credit_months: DF.Int
 		description: DF.SmallText | None
 		discount: DF.Float
 		discount_date: DF.Date | None
 		discount_type: DF.Literal["Percentage", "Amount"]
-		discount_validity: DF.Int
-		discount_validity_based_on: DF.Literal[
-			"",
-			"Day(s) after invoice date",
-			"Day(s) after the end of the invoice month",
-			"Month(s) after the end of the invoice month",
-		]
 		discounted_amount: DF.Currency
 		due_date: DF.Date
-		due_date_based_on: DF.Literal[
-			"",
-			"Day(s) after invoice date",
-			"Day(s) after the end of the invoice month",
-			"Month(s) after the end of the invoice month",
-		]
 		invoice_portion: DF.Percent
 		mode_of_payment: DF.Link | None
 		outstanding: DF.Currency

erpnext/accounts/doctype/payment_terms_template_detail/payment_terms_template_detail.json

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

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.js

@@ -4,8 +4,6 @@
 frappe.ui.form.on("Period Closing Voucher", {
 	onload: function (frm) {
 		if (!frm.doc.transaction_date) frm.doc.transaction_date = frappe.datetime.obj_to_str(new Date());
-
-		frm.ignore_doctypes_on_cancel_all = ["Process Period Closing Voucher"];
 	},
 
 	setup: function (frm) {

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -75,17 +75,6 @@ class PeriodClosingVoucher(AccountsController):
 			return
 
 		previous_fiscal_year_start_date = previous_fiscal_year[0][1]
-		previous_fiscal_year_closed = frappe.db.exists(
-			"Period Closing Voucher",
-			{
-				"period_end_date": ("between", [previous_fiscal_year_start_date, last_year_closing]),
-				"docstatus": 1,
-				"company": self.company,
-			},
-		)
-		if previous_fiscal_year_closed:
-			return
-
 		gle_exists_in_previous_year = frappe.db.exists(
 			"GL Entry",
 			{
@@ -97,7 +86,16 @@ class PeriodClosingVoucher(AccountsController):
 		if not gle_exists_in_previous_year:
 			return
 
-		frappe.throw(_("Previous Year is not closed, please close it first"))
+		previous_fiscal_year_closed = frappe.db.exists(
+			"Period Closing Voucher",
+			{
+				"period_end_date": ("between", [previous_fiscal_year_start_date, last_year_closing]),
+				"docstatus": 1,
+				"company": self.company,
+			},
+		)
+		if not previous_fiscal_year_closed:
+			frappe.throw(_("Previous Year is not closed, please close it first"))
 
 	def block_if_future_closing_voucher_exists(self):
 		future_closing_voucher = self.get_future_closing_voucher()
@@ -132,11 +130,7 @@ class PeriodClosingVoucher(AccountsController):
 
 	def on_submit(self):
 		self.db_set("gle_processing_status", "In Progress")
-		if frappe.get_single_value("Accounts Settings", "use_legacy_controller_for_pcv"):
-			self.make_gl_entries()
-		else:
-			ppcv = frappe.get_doc({"doctype": "Process Period Closing Voucher", "parent_pcv": self.name})
-			ppcv.save().submit()
+		self.make_gl_entries()
 
 	def on_cancel(self):
 		self.ignore_linked_doctypes = (
@@ -144,29 +138,11 @@ class PeriodClosingVoucher(AccountsController):
 			"Stock Ledger Entry",
 			"Payment Ledger Entry",
 			"Account Closing Balance",
-			"Process Period Closing Voucher",
 		)
 		self.block_if_future_closing_voucher_exists()
-
-		if not frappe.get_single_value("Accounts Settings", "use_legacy_controller_for_pcv"):
-			self.cancel_process_pcv_docs()
-
 		self.db_set("gle_processing_status", "In Progress")
 		self.cancel_gl_entries()
 
-	def cancel_process_pcv_docs(self):
-		ppcvs = frappe.db.get_all("Process Period Closing Voucher", {"parent_pcv": self.name, "docstatus": 1})
-		for x in ppcvs:
-			frappe.get_doc("Process Period Closing Voucher", x.name).cancel()
-
-	def on_trash(self):
-		super().on_trash()
-		ppcvs = frappe.db.get_all(
-			"Process Period Closing Voucher", {"parent_pcv": self.name, "docstatus": ["in", [1, 2]]}
-		)
-		for x in ppcvs:
-			frappe.delete_doc("Process Period Closing Voucher", x.name, force=True, ignore_permissions=True)
-
 	def make_gl_entries(self):
 		if frappe.db.estimate_count("GL Entry") > 100_000:
 			frappe.enqueue(
@@ -234,10 +210,8 @@ class PeriodClosingVoucher(AccountsController):
 		return gl_entry
 
 	def get_gle_for_closing_account(self, dimension_balance, dimensions):
+		balance_in_account_currency = flt(dimension_balance.balance_in_account_currency)
 		balance_in_company_currency = flt(dimension_balance.balance_in_company_currency)
-		debit = balance_in_company_currency if balance_in_company_currency > 0 else 0
-		credit = abs(balance_in_company_currency) if balance_in_company_currency < 0 else 0
-
 		gl_entry = frappe._dict(
 			{
 				"company": self.company,
@@ -246,10 +220,14 @@ class PeriodClosingVoucher(AccountsController):
 				"account_currency": frappe.db.get_value(
 					"Account", self.closing_account_head, "account_currency"
 				),
-				"debit_in_account_currency": debit,
-				"debit": debit,
-				"credit_in_account_currency": credit,
-				"credit": credit,
+				"debit_in_account_currency": balance_in_account_currency
+				if balance_in_account_currency > 0
+				else 0,
+				"debit": balance_in_company_currency if balance_in_company_currency > 0 else 0,
+				"credit_in_account_currency": abs(balance_in_account_currency)
+				if balance_in_account_currency < 0
+				else 0,
+				"credit": abs(balance_in_company_currency) if balance_in_company_currency < 0 else 0,
 				"is_period_closing_voucher_entry": 1,
 				"voucher_type": "Period Closing Voucher",
 				"voucher_no": self.name,
@@ -475,15 +453,8 @@ def process_gl_and_closing_entries(doc):
 		frappe.db.set_value(doc.doctype, doc.name, "gle_processing_status", "Completed")
 	except Exception as e:
 		frappe.db.rollback()
-		frappe.log_error(title=_("Period Closing Voucher {0} GL Entry Processing Failed").format(doc.name))
-		frappe.db.set_value(
-			doc.doctype,
-			doc.name,
-			{
-				"error_message": str(e),
-				"gle_processing_status": "Failed",
-			},
-		)
+		frappe.log_error(e)
+		frappe.db.set_value(doc.doctype, doc.name, "gle_processing_status", "Failed")
 
 
 def process_cancellation(voucher_type, voucher_no):
@@ -495,17 +466,8 @@ def process_cancellation(voucher_type, voucher_no):
 		frappe.db.set_value("Period Closing Voucher", voucher_no, "gle_processing_status", "Completed")
 	except Exception as e:
 		frappe.db.rollback()
-		frappe.log_error(
-			title=_("Period Closing Voucher {0} GL Entry Cancellation Failed").format(voucher_no)
-		)
-		frappe.db.set_value(
-			voucher_type,
-			voucher_no,
-			{
-				"error_message": str(e),
-				"gle_processing_status": "Failed",
-			},
-		)
+		frappe.log_error(e)
+		frappe.db.set_value("Period Closing Voucher", voucher_no, "gle_processing_status", "Failed")
 
 
 def delete_closing_entries(voucher_no):

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -14,10 +14,6 @@ from erpnext.accounts.utils import get_fiscal_year
 
 
 class TestPeriodClosingVoucher(unittest.TestCase):
-	def setUp(self):
-		super().setUp()
-		frappe.db.set_single_value("Accounts Settings", "use_legacy_controller_for_pcv", 1)
-
 	def test_closing_entry(self):
 		frappe.db.sql("delete from `tabGL Entry` where company='Test PCV Company'")
 		frappe.db.sql("delete from `tabPeriod Closing Voucher` where company='Test PCV Company'")

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.py

@@ -161,8 +161,6 @@ def get_pos_invoices(start, end, pos_profile, user):
 		`tabPOS Invoice`
 	where
 		owner = %s and docstatus = 1 and pos_profile = %s and ifnull(consolidated_invoice,'') = ''
-	order by
-		timestamp
 	""",
 		(user, pos_profile),
 		as_dict=1,

erpnext/accounts/doctype/pos_invoice/pos_invoice.js

@@ -14,7 +14,6 @@ erpnext.selling.POSInvoiceController = class POSInvoiceController extends erpnex
 	}
 
 	company() {
-		erpnext.utils.set_letter_head(this.frm);
 		erpnext.accounts.dimensions.update_dimension(this.frm, this.frm.doctype);
 		this.frm.set_value("set_warehouse", "");
 		this.frm.set_value("taxes_and_charges", "");
@@ -55,16 +54,6 @@ erpnext.selling.POSInvoiceController = class POSInvoiceController extends erpnex
 		});
 
 		erpnext.accounts.dimensions.setup_dimension_filters(this.frm, this.frm.doctype);
-
-		if (this.frm.doc.pos_profile) {
-			frappe.db
-				.get_value("POS Profile", this.frm.doc.pos_profile, "disable_grand_total_to_default_mop")
-				.then((r) => {
-					if (!r.exc) {
-						this.frm.skip_default_payment = r.message.disable_grand_total_to_default_mop;
-					}
-				});
-		}
 	}
 
 	onload_post_render(frm) {
@@ -123,7 +112,6 @@ erpnext.selling.POSInvoiceController = class POSInvoiceController extends erpnex
 						this.frm.meta.default_print_format = r.message.print_format || "";
 						this.frm.doc.campaign = r.message.campaign;
 						this.frm.allow_print_before_pay = r.message.allow_print_before_pay;
-						this.frm.skip_default_payment = r.message.skip_default_payment;
 					}
 					this.frm.script_manager.trigger("update_stock");
 					this.calculate_taxes_and_totals();

erpnext/accounts/doctype/pos_invoice/pos_invoice.json

@@ -62,7 +62,6 @@
   "items_section",
   "update_stock",
   "scan_barcode",
-  "last_scanned_warehouse",
   "items",
   "pricing_rule_details",
   "pricing_rules",
@@ -302,7 +301,6 @@
    "search_index": 1
   },
   {
-   "default": "Now",
    "fieldname": "posting_time",
    "fieldtype": "Time",
    "label": "Posting Time",
@@ -1445,8 +1443,6 @@
    "width": "50%"
   },
   {
-   "fetch_from": "sales_partner.commission_rate",
-   "fetch_if_empty": 1,
    "fieldname": "commission_rate",
    "fieldtype": "Float",
    "label": "Commission Rate (%)",
@@ -1570,19 +1566,12 @@
    "label": "Company Contact Person",
    "options": "Contact",
    "print_hide": 1
-  },
-  {
-   "depends_on": "eval: doc.last_scanned_warehouse",
-   "fieldname": "last_scanned_warehouse",
-   "fieldtype": "Data",
-   "is_virtual": 1,
-   "label": "Last Scanned Warehouse"
   }
  ],
  "icon": "fa fa-file-text",
  "is_submittable": 1,
  "links": [],
- "modified": "2025-08-04 22:22:31.471752",
+ "modified": "2024-11-26 13:10:50.309570",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice",

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -18,17 +18,12 @@ from erpnext.accounts.doctype.sales_invoice.sales_invoice import (
 from erpnext.accounts.party import get_due_date, get_party_account
 from erpnext.controllers.queries import item_query as _item_query
 from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
-from erpnext.stock.stock_ledger import is_negative_stock_allowed
 
 
 class PartialPaymentValidationError(frappe.ValidationError):
 	pass
 
 
-class ProductBundleStockValidationError(frappe.ValidationError):
-	pass
-
-
 class POSInvoice(SalesInvoice):
 	# begin: auto-generated types
 	# This code is auto-generated. Do not modify anything in this block.
@@ -194,9 +189,6 @@ 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")))
@@ -224,7 +216,6 @@ class POSInvoice(SalesInvoice):
 		self.validate_loyalty_transaction()
 		self.validate_company_with_pos_company()
 		self.validate_full_payment()
-		self.update_packing_list()
 		if self.coupon_code:
 			from erpnext.accounts.doctype.pricing_rule.utils import validate_coupon_code
 
@@ -353,69 +344,34 @@ 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 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)
+				if is_negative_stock_allowed(item_code=d.item_code):
+					return
 
-				else:
-					availability, is_stock_item, is_negative_stock_allowed = get_stock_availability(
-						d.item_code, d.warehouse
+				available_stock, is_stock_item = 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 {}. Available quantity {}."
+						).format(d.idx, item_code, warehouse, available_stock),
+						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_serialised_or_batched_item(self):
 		error_msg = []
@@ -711,13 +667,7 @@ class POSInvoice(SalesInvoice):
 				"Account", self.debit_to, "account_currency"
 			)
 		if not self.due_date and self.customer:
-			self.due_date = get_due_date(
-				self.posting_date,
-				"Customer",
-				self.customer,
-				self.company,
-				template_name=self.payment_terms_template,
-			)
+			self.due_date = get_due_date(self.posting_date, "Customer", self.customer, self.company)
 
 		super(SalesInvoice, self).set_missing_values(for_validate)
 
@@ -730,7 +680,6 @@ class POSInvoice(SalesInvoice):
 				"print_format": print_format,
 				"campaign": profile.get("campaign"),
 				"allow_print_before_pay": profile.get("allow_print_before_pay"),
-				"skip_default_payment": profile.get("disable_grand_total_to_default_mop"),
 			}
 
 	@frappe.whitelist()
@@ -808,35 +757,15 @@ 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, is_negative_stock_allowed(item_code=item_code)
+		return bin_qty - pos_sales_qty, is_stock_item
 	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, False
+			return get_bundle_availability(item_code, warehouse), is_stock_item
 		else:
 			is_stock_item = False
 			# Is a service item or non_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)
+			return 0, is_stock_item
 
 
 def get_bundle_availability(bundle_item_code, warehouse):
@@ -845,8 +774,10 @@ def get_bundle_availability(bundle_item_code, warehouse):
 	bundle_bin_qty = 1000000
 	for item in product_bundle.items:
 		item_bin_qty = get_bin_qty(item.item_code, warehouse)
+		item_pos_reserved_qty = get_pos_reserved_qty(item.item_code, warehouse)
+		available_qty = item_bin_qty - item_pos_reserved_qty
 
-		max_available_bundles = item_bin_qty / item.qty
+		max_available_bundles = available_qty / item.qty
 		if bundle_bin_qty > max_available_bundles and frappe.get_value(
 			"Item", item.item_code, "is_stock_item"
 		):
@@ -869,49 +800,13 @@ def get_bin_qty(item_code, warehouse):
 
 
 def get_pos_reserved_qty(item_code, warehouse):
-	"""
-	Calculate total quantity reserved for the given item and warehouse.
-
-	Includes:
-	- Direct sales of the item in submitted POS Invoices
-	- Sales of the item as a component of a Product Bundle
-
-	Excludes consolidated invoices (already merged into Sales Invoices via
-	POS Closing Entry). Used to reflect near real-time availability in the
-	POS UI and to prevent overselling while multiple sessions may be active.
-	"""
-	pinv_item_reserved_qty = get_pos_reserved_qty_from_table("POS Invoice Item", item_code, warehouse)
-	packed_item_reserved_qty = get_pos_reserved_qty_from_table("Packed Item", item_code, warehouse)
-
-	reserved_qty = pinv_item_reserved_qty + packed_item_reserved_qty
-
-	return reserved_qty
-
-
-def get_pos_reserved_qty_from_table(child_table, item_code, warehouse):
-	"""
-	Get the total reserved quantity for a given item in POS Invoices
-	from a specific child table.
-
-	Args:
-	  child_table (str): Name of the child table to query
-	                (e.g., "POS Invoice Item", "Packed Item").
-	  item_code (str): The Item Code to filter by.
-	  warehouse (str): The Warehouse to filter by.
-
-	Returns:
-	  float: The total reserved quantity for the item in the given
-	                warehouse from submitted, unconsolidated POS Invoices.
-	"""
 	p_inv = frappe.qb.DocType("POS Invoice")
-	p_item = frappe.qb.DocType(child_table)
-
-	qty_column = "qty" if child_table == "Packed Item" else "stock_qty"
+	p_item = frappe.qb.DocType("POS Invoice Item")
 
 	reserved_qty = (
 		frappe.qb.from_(p_inv)
 		.from_(p_item)
-		.select(Sum(p_item[qty_column]).as_("stock_qty"))
+		.select(Sum(p_item.stock_qty).as_("stock_qty"))
 		.where(
 			(p_inv.name == p_item.parent)
 			& (IfNull(p_inv.consolidated_invoice, "") == "")

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -964,84 +964,6 @@ class TestPOSInvoice(unittest.TestCase):
 			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)
@@ -1149,3 +1071,10 @@ def create_pos_invoice(**args):
 		pos_inv.payment_schedule = []
 
 	return pos_inv
+
+
+def make_batch_item(item_name):
+	from erpnext.stock.doctype.item.test_item import make_item
+
+	if not frappe.db.exists(item_name):
+		return make_item(item_name, dict(has_batch_no=1, create_new_batch=1, is_stock_item=1))

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.json

@@ -5,7 +5,6 @@
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
-  "company",
   "posting_date",
   "posting_time",
   "merge_invoices_based_on",
@@ -114,22 +113,12 @@
    "label": "Posting Time",
    "no_copy": 1,
    "reqd": 1
-  },
-  {
-   "fieldname": "company",
-   "fieldtype": "Link",
-   "in_standard_filter": 1,
-   "label": "Company",
-   "options": "Company",
-   "print_hide": 1,
-   "remember_last_selected_value": 1,
-   "reqd": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-07-02 17:08:04.747202",
+ "modified": "2022-08-01 11:36:42.456429",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice Merge Log",
@@ -190,9 +179,8 @@
    "write": 1
   }
  ],
- "row_format": "Dynamic",
- "sort_field": "creation",
+ "sort_field": "modified",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -28,10 +28,11 @@ class POSInvoiceMergeLog(Document):
 	if TYPE_CHECKING:
 		from frappe.types import DF
 
-		from erpnext.accounts.doctype.pos_invoice_reference.pos_invoice_reference import POSInvoiceReference
+		from erpnext.accounts.doctype.pos_invoice_reference.pos_invoice_reference import (
+			POSInvoiceReference,
+		)
 
 		amended_from: DF.Link | None
-		company: DF.Link
 		consolidated_credit_note: DF.Link | None
 		consolidated_invoice: DF.Link | None
 		customer: DF.Link
@@ -337,11 +338,6 @@ class POSInvoiceMergeLog(Document):
 			invoice.flags.ignore_pos_profile = True
 			invoice.pos_profile = ""
 
-		# Unset Commission Section
-		invoice.set("sales_partner", None)
-		invoice.set("commission_rate", 0)
-		invoice.set("total_commission", 0)
-
 		return invoice
 
 	def get_new_sales_invoice(self):
@@ -588,7 +584,6 @@ def create_merge_logs(invoice_by_customer, closing_entry=None):
 					merge_log.posting_time = (
 						get_time(closing_entry.get("posting_time")) if closing_entry else nowtime()
 					)
-					merge_log.company = closing_entry.get("company") if closing_entry else None
 					merge_log.customer = customer
 					merge_log.pos_closing_entry = closing_entry.get("name") if closing_entry else None
 					merge_log.set("pos_invoices", _invoices)

erpnext/accounts/doctype/pos_opening_entry/pos_opening_entry.py

@@ -41,19 +41,9 @@ class POSOpeningEntry(StatusUpdater):
 		self.set_status()
 
 	def validate_pos_profile_and_cashier(self):
-		if not frappe.db.exists("POS Profile", self.pos_profile):
-			frappe.throw(_("POS Profile {} does not exist.").format(self.pos_profile))
-
-		pos_profile_company, pos_profile_disabled = frappe.db.get_value(
-			"POS Profile", self.pos_profile, ["company", "disabled"]
-		)
-
-		if pos_profile_disabled:
-			frappe.throw(_("POS Profile {} is disabled.").format(frappe.bold(self.pos_profile)))
-
-		if self.company != pos_profile_company:
+		if self.company != frappe.db.get_value("POS Profile", self.pos_profile, "company"):
 			frappe.throw(
-				_("POS Profile {} does not belong to company {}").format(self.pos_profile, self.company)
+				_("POS Profile {} does not belongs to company {}").format(self.pos_profile, self.company)
 			)
 
 		if not cint(frappe.db.get_value("User", self.user, "enabled")):

erpnext/accounts/doctype/pos_profile/pos_profile.js

@@ -135,7 +135,6 @@ frappe.ui.form.on("POS Profile", {
 	company: function (frm) {
 		frm.trigger("toggle_display_account_head");
 		erpnext.accounts.dimensions.update_dimension(frm, frm.doctype);
-		erpnext.utils.set_letter_head(frm);
 	},
 
 	toggle_display_account_head: function (frm) {

erpnext/accounts/doctype/pos_profile/pos_profile.py

@@ -70,7 +70,6 @@ class POSProfile(Document):
 	# end: auto-generated types
 
 	def validate(self):
-		self.validate_disabled()
 		self.validate_default_profile()
 		self.validate_all_link_fields()
 		self.validate_duplicate_groups()
@@ -95,21 +94,6 @@ class POSProfile(Document):
 					title=_("Mandatory Accounting Dimension"),
 				)
 
-	def validate_disabled(self):
-		old_doc = self.get_doc_before_save()
-
-		if (
-			old_doc
-			and self.disabled
-			and old_doc.disabled != self.disabled
-			and frappe.db.exists("POS Opening Entry", {"pos_profile": self.name, "status": "Open"})
-		):
-			frappe.throw(
-				_("POS Profile {0} cannot be disabled as there are ongoing POS sessions.").format(
-					frappe.bold(self.name)
-				)
-			)
-
 	def validate_default_profile(self):
 		for row in self.applicable_for_users:
 			res = frappe.db.sql(

erpnext/accounts/doctype/pos_profile/test_pos_profile.py

@@ -4,7 +4,6 @@
 import unittest
 
 import frappe
-from frappe.utils import cint
 
 from erpnext.accounts.doctype.pos_profile.pos_profile import (
 	get_child_nodes,
@@ -39,51 +38,6 @@ class TestPOSProfile(unittest.TestCase):
 
 		frappe.db.sql("delete from `tabPOS Profile`")
 
-	def test_disabled_pos_profile_creation(self):
-		make_pos_profile(name="_Test POS Profile 001", disabled=1)
-
-		pos_profile = frappe.get_doc("POS Profile", "_Test POS Profile 001")
-
-		if pos_profile:
-			self.assertEqual(pos_profile.disabled, 1)
-
-	def test_disabled_pos_profile_after_opening(self):
-		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import init_user_and_profile
-		from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
-
-		test_user, pos_profile = init_user_and_profile()
-
-		if pos_profile:
-			create_opening_entry(pos_profile, test_user.name)
-			self.assertEqual(pos_profile.disabled, 0)
-
-			pos_profile.disabled = 1
-			self.assertRaises(frappe.ValidationError, pos_profile.save)
-
-	def test_disabled_pos_profile_after_completing_session(self):
-		from erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry import (
-			make_closing_entry_from_opening,
-		)
-		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import init_user_and_profile
-		from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import (
-			create_opening_entry,
-		)
-
-		test_user, pos_profile = init_user_and_profile()
-		frappe.db.delete("POS Opening Entry", {"pos_profile": pos_profile.name})
-
-		if pos_profile:
-			opening_entry = create_opening_entry(pos_profile, test_user.name)
-
-			closing_entry = make_closing_entry_from_opening(opening_entry)
-			closing_entry.submit()
-
-			pos_profile.disabled = 1
-			pos_profile.save()
-			pos_profile.reload()
-
-			self.assertEqual(pos_profile.disabled, 1)
-
 
 def get_customers_list(pos_profile=None):
 	if pos_profile is None:
@@ -163,7 +117,6 @@ def make_pos_profile(**args):
 			"write_off_account": args.write_off_account or "_Test Write Off - _TC",
 			"write_off_cost_center": args.write_off_cost_center or "_Test Write Off Cost Center - _TC",
 			"location": "Block 1" if not args.do_not_set_accounting_dimension else None,
-			"disabled": cint(args.disabled) or 0,
 		}
 	)
 

erpnext/accounts/doctype/pricing_rule/pricing_rule.json

@@ -174,7 +174,6 @@
   },
   {
    "default": "0",
-   "depends_on": "eval:doc.apply_on != 'Transaction'",
    "fieldname": "is_cumulative",
    "fieldtype": "Check",
    "label": "Is Cumulative"
@@ -657,7 +656,7 @@
  "icon": "fa fa-gift",
  "idx": 1,
  "links": [],
- "modified": "2025-08-20 11:40:07.096854",
+ "modified": "2025-02-17 18:15:39.824639",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Pricing Rule",

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -169,7 +169,7 @@ class PricingRule(Document):
 
 		tocheck = frappe.scrub(self.get("applicable_for", ""))
 		if tocheck and not self.get(tocheck):
-			throw(_("{0} is required").format(_(self.meta.get_label(tocheck))), frappe.MandatoryError)
+			throw(_("{0} is required").format(self.meta.get_label(tocheck)), frappe.MandatoryError)
 
 		if self.apply_rule_on_other:
 			o_field = "other_" + frappe.scrub(self.apply_rule_on_other)

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -205,56 +205,6 @@ class TestPricingRule(FrappeTestCase):
 		details = get_item_details(args)
 		self.assertEqual(details.get("discount_percentage"), 10)
 
-	def test_unset_group_condition(self):
-		"""
-		If args are not set for group condition, then pricing rule should not be applied.
-		"""
-		from erpnext.stock.get_item_details import get_item_details
-
-		test_record = {
-			"doctype": "Pricing Rule",
-			"title": "_Test Pricing Rule",
-			"apply_on": "Item Code",
-			"items": [{"item_code": "_Test Item"}],
-			"currency": "USD",
-			"selling": 1,
-			"rate_or_discount": "Discount Percentage",
-			"rate": 0,
-			"discount_percentage": 10,
-			"applicable_for": "Territory",
-			"territory": "All Territories",
-			"company": "_Test Company",
-		}
-		frappe.get_doc(test_record.copy()).insert()
-		args = frappe._dict(
-			{
-				"item_code": "_Test Item",
-				"company": "_Test Company",
-				"price_list": "_Test Price List",
-				"currency": "_Test Currency",
-				"doctype": "Sales Order",
-				"conversion_rate": 1,
-				"price_list_currency": "_Test Currency",
-				"plc_conversion_rate": 1,
-				"order_type": "Sales",
-				"customer": "_Test Customer",
-				"name": None,
-			}
-		)
-
-		# without territory in customer
-		customer = frappe.get_doc("Customer", "_Test Customer")
-		territory = customer.territory
-
-		customer.territory = None
-		customer.save()
-
-		details = get_item_details(args)
-		self.assertEqual(details.get("discount_percentage"), 0)
-
-		customer.territory = territory
-		customer.save()
-
 	def test_pricing_rule_for_variants(self):
 		from erpnext.stock.get_item_details import get_item_details
 

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -223,10 +223,6 @@ def _get_tree_conditions(args, parenttype, table, allow_blank=True):
 			)
 
 			frappe.flags.tree_conditions[key] = condition
-
-	elif allow_blank:
-		condition = f"ifnull({table}.{field}, '') = ''"
-
 	return condition
 
 
@@ -243,13 +239,10 @@ def get_other_conditions(conditions, values, args):
 		if group_condition:
 			conditions += " and " + group_condition
 
-	date = args.get("transaction_date") or frappe.get_value(
-		args.get("doctype"), args.get("name"), "posting_date", ignore=True
-	)
-	if date:
+	if args.get("transaction_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"] = date
+		values["transaction_date"] = args.get("transaction_date")
 
 	if args.get("doctype") in [
 		"Quotation",
@@ -586,7 +579,11 @@ def apply_pricing_rule_on_transaction(doc):
 					if not d.get(pr_field):
 						continue
 
-					if d.validate_applied_rule and (doc.get(field) or 0) < d.get(pr_field):
+					if (
+						d.validate_applied_rule
+						and doc.get(field) is not None
+						and doc.get(field) < d.get(pr_field)
+					):
 						frappe.msgprint(_("User has not applied rule on the invoice {0}").format(doc.name))
 					else:
 						if not d.coupon_code_based:

erpnext/accounts/doctype/process_deferred_accounting/test_process_deferred_accounting.py

@@ -40,13 +40,6 @@ class TestProcessDeferredAccounting(unittest.TestCase):
 		si.save()
 		si.submit()
 
-		original_gle = [
-			["Debtors - _TC", 3000.0, 0, "2023-07-01"],
-			[deferred_account, 0.0, 3000, "2023-07-01"],
-		]
-
-		check_gl_entries(self, si.name, original_gle, "2023-07-01")
-
 		process_deferred_accounting = frappe.get_doc(
 			dict(
 				doctype="Process Deferred Accounting",
@@ -70,12 +63,6 @@ class TestProcessDeferredAccounting(unittest.TestCase):
 		]
 
 		check_gl_entries(self, si.name, expected_gle, "2023-07-01")
-
-		# cancel the process deferred accounting document
-		process_deferred_accounting.cancel()
-
-		# check if gl entries are cancelled
-		check_gl_entries(self, si.name, original_gle, "2023-07-01")
 		change_acc_settings()
 
 	def test_pda_submission_and_cancellation(self):

erpnext/accounts/doctype/process_period_closing_voucher/process_period_closing_voucher.js

@@ -1,71 +0,0 @@
-// Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and contributors
-// For license information, please see license.txt
-
-frappe.ui.form.on("Process Period Closing Voucher", {
-	refresh(frm) {
-		if (frm.doc.docstatus == 1 && ["Queued"].find((x) => x == frm.doc.status)) {
-			let execute_btn = __("Start");
-
-			frm.add_custom_button(execute_btn, () => {
-				frm.call({
-					method: "erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.start_pcv_processing",
-					args: {
-						docname: frm.doc.name,
-					},
-				}).then((r) => {
-					if (!r.exc) {
-						frappe.show_alert(__("Job Started"));
-						frm.reload_doc();
-					}
-				});
-			});
-		}
-
-		if (frm.doc.docstatus == 1 && ["Running"].find((x) => x == frm.doc.status)) {
-			let execute_btn = __("Pause");
-
-			frm.add_custom_button(execute_btn, () => {
-				frm.call({
-					method: "erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.pause_pcv_processing",
-					args: {
-						docname: frm.doc.name,
-					},
-				}).then((r) => {
-					if (!r.exc) {
-						frappe.show_alert(__("PCV Paused"));
-						frm.reload_doc();
-					}
-				});
-			});
-		}
-
-		if (frm.doc.docstatus == 1 && ["Paused"].find((x) => x == frm.doc.status)) {
-			let execute_btn = __("Resume");
-
-			frm.add_custom_button(execute_btn, () => {
-				frm.call({
-					method: "erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.resume_pcv_processing",
-					args: {
-						docname: frm.doc.name,
-					},
-				}).then((r) => {
-					if (!r.exc) {
-						frappe.show_alert(__("PCV Resumed"));
-						frm.reload_doc();
-					}
-				});
-			});
-		}
-		// progress bar
-		let progress = 0;
-
-		let normal_finished = frm.doc.normal_balances.filter((x) => x.status == "Completed").length;
-		let opening_finished = frm.doc.z_opening_balances.filter((x) => x.status == "Completed").length;
-
-		progress =
-			((normal_finished + opening_finished) /
-				(frm.doc.normal_balances.length + frm.doc.z_opening_balances.length)) *
-			100;
-		frm.dashboard.add_progress("Books closure progress", progress, "");
-	},
-});