fix: resolved conflicts

(cherry picked from commit 7f8d08c8eb)

# Conflicts:
#	erpnext/assets/doctype/asset/asset.js

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

.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/release.yml

@@ -1,4 +0,0 @@
-changelog:
-  exclude:
-    labels:
-      - skip-release-notes

.github/workflows/label-base-on-title.yml

@@ -1,30 +0,0 @@
-name: "Auto-label PRs based on title"
-
-on:
-  pull_request_target:
-    types: [opened, reopened]
-
-jobs:
-  add-label-if-prefix-matches:
-    permissions:
-      contents: read
-      pull-requests: write
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check PR title and add label if it matches prefixes
-        uses: actions/github-script@v7
-        continue-on-error: true
-        with:
-          script: |
-            const title = context.payload.pull_request.title.toLowerCase();
-            const prefixes = ['chore', 'ci', 'style', 'test', 'refactor'];
-            
-            // Check if the PR title starts with any of the prefixes
-            if (prefixes.some(prefix => title.startsWith(prefix))) {
-              await github.rest.issues.addLabels({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.payload.pull_request.number,
-                labels: ['skip-release-notes']
-              });
-            }

.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"

.pre-commit-config.yaml

@@ -1,5 +1,5 @@
 exclude: 'node_modules|.git'
-default_stages: [pre-commit]
+default_stages: [commit]
 fail_fast: false
 
 

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

@@ -62,9 +62,9 @@ New passwords will be created for the ERPNext "Administrator" user, the MariaDB
 
 ## Learning and community
 
-1. [Frappe School](https://school.frappe.io) - Learn Frappe Framework and ERPNext from the various courses by the maintainers or from the community.
+1. [Frappe School](https://frappe.school) - 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.96.0"
+__version__ = "15.45.4"
 
 
 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

@@ -4,7 +4,7 @@
 
 import frappe
 from frappe import _, throw
-from frappe.utils import add_to_date, cint, cstr, pretty_date
+from frappe.utils import cint, cstr
 from frappe.utils.nestedset import NestedSet, get_ancestors_of, get_descendants_of
 
 import erpnext
@@ -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}):
@@ -515,7 +481,6 @@ def get_account_autoname(account_number, account_name, company):
 
 @frappe.whitelist()
 def update_account_number(name, account_name, account_number=None, from_descendant=False):
-	_ensure_idle_system()
 	account = frappe.get_cached_doc("Account", name)
 	if not account:
 		return
@@ -536,7 +501,7 @@ def update_account_number(name, account_name, account_number=None, from_descenda
 				"name",
 			)
 
-			if old_name and not from_descendant:
+			if old_name:
 				# same account in parent company exists
 				allow_child_account_creation = _("Allow Account Creation Against Child Company")
 
@@ -577,7 +542,6 @@ def update_account_number(name, account_name, account_number=None, from_descenda
 
 @frappe.whitelist()
 def merge_account(old, new):
-	_ensure_idle_system()
 	# Validate properties before merging
 	new_account = frappe.get_cached_doc("Account", new)
 	old_account = frappe.get_cached_doc("Account", old)
@@ -631,55 +595,3 @@ def sync_update_account_number_in_child(
 
 	for d in frappe.db.get_values("Account", filters=filters, fieldname=["company", "name"], as_dict=True):
 		update_account_number(d["name"], account_name, account_number, from_descendant=True)
-
-
-def _ensure_idle_system():
-	# Don't allow renaming if accounting entries are actively being updated, there are two main reasons:
-	# 1. Correctness: It's next to impossible to ensure that renamed account is not being used *right now*.
-	# 2. Performance: Renaming requires locking out many tables entirely and severely degrades performance.
-
-	if frappe.flags.in_test:
-		return
-
-	last_gl_update = None
-	try:
-		# We also lock inserts to GL entry table with for_update here.
-		last_gl_update = frappe.db.get_value("GL Entry", {}, "modified", for_update=True, wait=False)
-	except frappe.QueryTimeoutError:
-		# wait=False fails immediately if there's an active transaction.
-		last_gl_update = add_to_date(None, seconds=-1)
-
-	if not last_gl_update:
-		return
-
-	if last_gl_update > add_to_date(None, minutes=-5):
-		frappe.throw(
-			_(
-				"Last GL Entry update was done {}. This operation is not allowed while system is actively being used. Please wait for 5 minutes before retrying."
-			).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

@@ -138,11 +138,6 @@ frappe.treeview_settings["Account"] = {
 			description: __(
 				"Further accounts can be made under Groups, but entries can be made against non-Groups"
 			),
-			onchange: function () {
-				if (!this.value) {
-					this.layout.set_value("root_type", "");
-				}
-			},
 		},
 		{
 			fieldtype: "Select",
@@ -286,14 +281,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/chart_of_accounts.py

@@ -116,7 +116,6 @@ def identify_is_group(child):
 	return is_group
 
 
-@frappe.whitelist()
 def get_chart(chart_template, existing_company=None):
 	chart = {}
 	if existing_company:

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/id_chart_of_accounts.json

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

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

@@ -98,7 +98,7 @@
                 "Office Maintenance Expenses": {},
                 "Office Rent": {},
                 "Postal Expenses": {},
-                "Print and Stationery": {},
+                "Print and Stationary": {},
                 "Rounded Off": {
                     "account_type": "Round Off"
                 },

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

@@ -22,32 +22,4 @@ 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) {
-	if (frm.doc[field_name]) {
-		const other_field =
-			field_name === "add_taxes_from_item_tax_template"
-				? "add_taxes_from_taxes_and_charges_template"
-				: "add_taxes_from_item_tax_template";
-		frm.set_value(other_field, 0);
-	}
-}

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -31,7 +31,6 @@
   "determine_address_tax_category_from",
   "column_break_19",
   "add_taxes_from_item_tax_template",
-  "add_taxes_from_taxes_and_charges_template",
   "book_tax_discount_loss",
   "round_row_wise_tax",
   "print_settings",
@@ -39,15 +38,8 @@
   "show_taxes_as_table_in_print",
   "column_break_12",
   "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",
   "currency_exchange_section",
   "allow_stale",
-  "allow_pegged_currencies_exchange_rates",
   "column_break_yuug",
   "stale_days",
   "section_break_jpd0",
@@ -56,9 +48,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 +67,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",
@@ -89,18 +77,11 @@
   "reports_tab",
   "remarks_section",
   "general_ledger_remarks_length",
+  "ignore_is_opening_check_for_reporting",
   "column_break_lvjk",
   "receivable_payable_remarks_length",
-  "accounts_receivable_payable_tuning_section",
-  "receivable_payable_fetch_method",
-  "default_ageing_range",
-  "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": [
   {
@@ -307,7 +288,7 @@
   },
   {
    "default": "0",
-   "description": "Learn about <a href=\"https://docs.frappe.io/erpnext/user/manual/en/common_party_accounting\">Common Party</a>",
+   "description": "Learn about <a href=\"https://docs.erpnext.com/docs/v13/user/manual/en/accounts/articles/common_party_accounting#:~:text=Common%20Party%20Accounting%20in%20ERPNext,Invoice%20against%20a%20primary%20Supplier.\">Common Party</a>",
    "fieldname": "enable_common_party_accounting",
    "fieldtype": "Check",
    "label": "Enable Common Party Accounting"
@@ -551,119 +532,6 @@
    "fieldtype": "Select",
    "label": "Posting Date Inheritance for Exchange Gain / Loss",
    "options": "Invoice\nPayment\nReconciliation Date"
-  },
-  {
-   "fieldname": "column_break_xrnd",
-   "fieldtype": "Column Break"
-  },
-  {
-   "default": "Buffered Cursor",
-   "fieldname": "receivable_payable_fetch_method",
-   "fieldtype": "Select",
-   "label": "Data Fetch Method",
-   "options": "Buffered Cursor\nUnBuffered Cursor\nRaw SQL"
-  },
-  {
-   "fieldname": "accounts_receivable_payable_tuning_section",
-   "fieldtype": "Section Break",
-   "label": "Accounts Receivable / Payable Tuning"
-  },
-  {
-   "fieldname": "legacy_section",
-   "fieldtype": "Section Break",
-   "label": "Legacy Fields"
-  },
-  {
-   "default": "0",
-   "fieldname": "maintain_same_internal_transaction_rate",
-   "fieldtype": "Check",
-   "label": "Maintain Same Rate Throughout Internal Transaction"
-  },
-  {
-   "default": "Stop",
-   "depends_on": "maintain_same_internal_transaction_rate",
-   "fieldname": "maintain_same_rate_action",
-   "fieldtype": "Select",
-   "label": "Action if Same Rate is Not Maintained Throughout  Internal Transaction",
-   "mandatory_depends_on": "maintain_same_internal_transaction_rate",
-   "options": "Stop\nWarn"
-  },
-  {
-   "depends_on": "eval: doc.maintain_same_internal_transaction_rate && doc.maintain_same_rate_action == 'Stop'",
-   "fieldname": "role_to_override_stop_action",
-   "fieldtype": "Link",
-   "label": "Role Allowed to Override Stop Action",
-   "options": "Role"
-  },
-  {
-   "fieldname": "item_price_settings_section",
-   "fieldtype": "Section Break",
-   "label": "Item Price Settings"
-  },
-  {
-   "fieldname": "column_break_feyo",
-   "fieldtype": "Column Break"
-  },
-  {
-   "default": "0",
-   "description": "System will do an implicit conversion using the pegged currency. <br>\nEx: Instead of AED -&gt; INR, system will do AED -&gt; USD -&gt; INR using the pegged exchange rate of AED against USD.",
-   "documentation_url": "/app/pegged-currencies/Pegged Currencies",
-   "fieldname": "allow_pegged_currencies_exchange_rates",
-   "fieldtype": "Check",
-   "label": "Allow Implicit Pegged Currency Conversion"
-  },
-  {
-   "default": "0",
-   "description": "If no taxes are set, and Taxes and Charges Template is selected, the system will automatically apply the taxes from the chosen template.",
-   "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"
-  },
-  {
-   "default": "30, 60, 90, 120",
-   "fieldname": "default_ageing_range",
-   "fieldtype": "Data",
-   "label": "Default Ageing Range"
   }
  ],
  "icon": "icon-cog",
@@ -671,7 +539,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2025-12-26 19:46:55.093717",
+ "modified": "2025-01-23 13:15:44.077853",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",
@@ -696,9 +564,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

@@ -25,9 +25,7 @@ class AccountsSettings(Document):
 
 		acc_frozen_upto: DF.Date | None
 		add_taxes_from_item_tax_template: DF.Check
-		add_taxes_from_taxes_and_charges_template: DF.Check
 		allow_multi_currency_invoices_against_single_party_account: DF.Check
-		allow_pegged_currencies_exchange_rates: DF.Check
 		allow_stale: DF.Check
 		auto_reconcile_payments: DF.Check
 		auto_reconciliation_job_trigger: DF.Int
@@ -41,7 +39,6 @@ class AccountsSettings(Document):
 		check_supplier_invoice_uniqueness: DF.Check
 		create_pr_in_draft_status: DF.Check
 		credit_controller: DF.Link | None
-		default_ageing_range: DF.Data | None
 		delete_linked_ledger_entries: DF.Check
 		determine_address_tax_category_from: DF.Literal["Billing Address", "Shipping Address"]
 		enable_common_party_accounting: DF.Check
@@ -49,38 +46,29 @@ 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
 		ignore_is_opening_check_for_reporting: DF.Check
-		maintain_same_internal_transaction_rate: DF.Check
-		maintain_same_rate_action: DF.Literal["Stop", "Warn"]
 		make_payment_via_journal_entry: DF.Check
 		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_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):
-		self.validate_auto_tax_settings()
 		old_doc = self.get_doc_before_save()
 		clear_cache = False
 
@@ -108,7 +96,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:
@@ -116,18 +103,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"):
@@ -160,21 +135,3 @@ class AccountsSettings(Document):
 		if self.has_value_changed("reconciliation_queue_size"):
 			if cint(self.reconciliation_queue_size) < 5 or cint(self.reconciliation_queue_size) > 100:
 				frappe.throw(_("Queue Size should be between 5 and 100"))
-
-	def validate_auto_tax_settings(self):
-		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"))),
-				),
-				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/bank.js

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

erpnext/accounts/doctype/bank_account/bank_account.js

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

erpnext/accounts/doctype/bank_account/bank_account.json

@@ -52,7 +52,6 @@
    "fieldtype": "Link",
    "in_list_view": 1,
    "label": "Company Account",
-   "mandatory_depends_on": "is_company_account",
    "options": "Account"
   },
   {
@@ -99,7 +98,6 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Company",
-   "mandatory_depends_on": "is_company_account",
    "options": "Company"
   },
   {
@@ -134,8 +132,7 @@
    "fieldtype": "Data",
    "in_list_view": 1,
    "label": "IBAN",
-   "length": 34,
-   "options": "IBAN"
+   "length": 30
   },
   {
    "fieldname": "column_break_12",
@@ -211,7 +208,6 @@
    "label": "Disabled"
   }
  ],
- "grid_page_length": 50,
  "links": [
   {
    "group": "Transactions",
@@ -254,7 +250,7 @@
    "link_fieldname": "default_bank_account"
   }
  ],
- "modified": "2026-01-20 00:46:16.633364",
+ "modified": "2024-10-30 09:41:14.113414",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account",
@@ -286,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):
@@ -52,34 +51,55 @@ class BankAccount(Document):
 		delete_contact_and_address("Bank Account", self.name)
 
 	def validate(self):
-		self.validate_is_company_account()
+		self.validate_company()
+		self.validate_iban()
+		self.validate_account()
 		self.update_default_bank_account()
 
-	def validate_is_company_account(self):
-		if self.is_company_account:
-			if not self.company:
-				frappe.throw(_("Company is mandatory for company account"))
-
-			if not self.account:
-				frappe.throw(_("Company Account is mandatory"))
-
-			self.validate_account()
-
-	@deprecated
-	def validate_iban(self):
-		"""Kept for backward compatibility, will be removed in v16."""
-		validate_iban(self.iban, throw=True)
-
 	def validate_account(self):
-		if accounts := frappe.db.get_all(
-			"Bank Account", filters={"account": self.account, "name": ["!=", self.name]}, as_list=1
-		):
-			frappe.throw(
-				_("'{0}' account is already used by {1}. Use another account.").format(
-					frappe.bold(self.account),
-					frappe.bold(comma_and([get_link_to_form(self.doctype, x[0]) for x in accounts])),
+		if self.account:
+			if accounts := frappe.db.get_all(
+				"Bank Account", filters={"account": self.account, "name": ["!=", self.name]}, as_list=1
+			):
+				frappe.throw(
+					_("'{0}' account is already used by {1}. Use another account.").format(
+						frappe.bold(self.account),
+						frappe.bold(comma_and([get_link_to_form(self.doctype, x[0]) for x in accounts])),
+					)
 				)
-			)
+
+	def validate_company(self):
+		if self.is_company_account and not self.company:
+			frappe.throw(_("Company is manadatory for company account"))
+
+	def validate_iban(self):
+		"""
+		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:
@@ -89,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"""
@@ -162,28 +159,31 @@ def get_payment_entries_for_bank_clearance(
 		as_dict=1,
 	)
 
+	if bank_account:
+		condition += "and bank_account = %(bank_account)s"
+
 	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,
 			"from": from_date,
 			"to": to_date,
+			"bank_account": bank_account,
 		},
 		as_dict=1,
 	)

erpnext/accounts/doctype/bank_clearance/test_bank_clearance.py

@@ -7,9 +7,6 @@ import frappe
 from frappe.utils import add_months, getdate
 
 from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
-from erpnext.accounts.doctype.mode_of_payment.test_mode_of_payment import (
-	set_default_account_for_mode_of_payment,
-)
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
@@ -194,13 +191,11 @@ def make_pos_sales_invoice():
 
 	customer = make_customer(customer="_Test Customer")
 
-	mode_of_payment = frappe.get_doc("Mode of Payment", "Wire Transfer")
-
-	set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", "_Test Bank Clearance - _TC")
-
 	si = create_sales_invoice(customer=customer, item="_Test Item", is_pos=1, qty=1, rate=1000, do_not_save=1)
 	si.set("payments", [])
-	si.append("payments", {"mode_of_payment": "Wire Transfer", "amount": 1000})
+	si.append(
+		"payments", {"mode_of_payment": "Cash", "account": "_Test Bank Clearance - _TC", "amount": 1000}
+	)
 	si.insert()
 	si.submit()
 

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

@@ -8,8 +8,7 @@ import frappe
 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
@@ -304,7 +303,6 @@ def create_payment_entry_bts(
 	project=None,
 	cost_center=None,
 	allow_edit=None,
-	company_bank_account=None,
 ):
 	# Create a new payment entry based on the bank transaction
 	bank_transaction = frappe.db.get_values(
@@ -346,9 +344,6 @@ def create_payment_entry_bts(
 	pe.project = project
 	pe.cost_center = cost_center
 
-	if company_bank_account:
-		pe.bank_account = company_bank_account
-
 	pe.validate()
 
 	if allow_edit:
@@ -377,39 +372,11 @@ def auto_reconcile_vouchers(
 	filter_by_reference_date=None,
 	from_reference_date=None,
 	to_reference_date=None,
-):
-	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.msgprint(_("Auto Reconciliation has started in the background"))
-	else:
-		start_auto_reconcile(
-			bank_transactions,
-			from_date,
-			to_date,
-			filter_by_reference_date,
-			from_reference_date,
-			to_reference_date,
-		)
-
-
-def start_auto_reconcile(
-	bank_transactions, from_date, to_date, filter_by_reference_date, from_reference_date, to_reference_date
 ):
 	frappe.flags.auto_reconcile_vouchers = True
-
 	reconciled, partially_reconciled = set(), set()
+
+	bank_transactions = get_bank_transactions(bank_account)
 	for transaction in bank_transactions:
 		linked_payments = get_linked_payments(
 			transaction.name,
@@ -447,6 +414,7 @@ def start_auto_reconcile(
 	frappe.msgprint(title=_("Auto Reconciliation"), msg=alert_message, indicator=indicator)
 
 	frappe.flags.auto_reconcile_vouchers = False
+	return reconciled, partially_reconciled
 
 
 def get_auto_reconcile_message(partially_reconciled, reconciled):
@@ -523,23 +491,16 @@ def subtract_allocations(gl_account, vouchers):
 	voucher_allocated_amounts = get_total_allocated_amount(voucher_docs)
 
 	for voucher in vouchers:
-		if amount := get_allocated_amount(voucher_allocated_amounts, voucher, gl_account):
+		rows = voucher_allocated_amounts.get((voucher.get("doctype"), voucher.get("name"))) or []
+		filtered_row = list(filter(lambda row: row.get("gl_account") == gl_account, rows))
+
+		if amount := None if not filtered_row else filtered_row[0]["total"]:
 			voucher["paid_amount"] -= amount
 
 		copied.append(voucher)
 	return copied
 
 
-def get_allocated_amount(voucher_allocated_amounts, voucher, gl_account):
-	if not (voucher_details := voucher_allocated_amounts.get((voucher.get("doctype"), voucher.get("name")))):
-		return
-
-	if not (row := voucher_details.get(gl_account)):
-		return
-
-	return row.get("total")
-
-
 def check_matching(
 	bank_account,
 	company,
@@ -809,20 +770,26 @@ def get_je_matching_query(
 	je = frappe.qb.DocType("Journal Entry")
 	jea = frappe.qb.DocType("Journal Entry Account")
 
+	ref_condition = je.cheque_no == transaction.reference_number
+	ref_rank = frappe.qb.terms.Case().when(ref_condition, 1).else_(0)
+
 	amount_field = f"{cr_or_dr}_in_account_currency"
+	amount_equality = getattr(jea, amount_field) == transaction.unallocated_amount
+	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(0)
 
 	filter_by_date = je.posting_date.between(from_date, to_date)
 	if cint(filter_by_reference_date):
 		filter_by_date = je.cheque_date.between(from_reference_date, to_reference_date)
 
-	subquery = (
+	query = (
 		frappe.qb.from_(jea)
 		.join(je)
 		.on(jea.parent == je.name)
 		.select(
-			Sum(getattr(jea, amount_field)).as_("paid_amount"),
+			(ref_rank + amount_rank + 1).as_("rank"),
 			ConstantColumn("Journal Entry").as_("doctype"),
 			je.name,
+			getattr(jea, amount_field).as_("paid_amount"),
 			je.cheque_no.as_("reference_no"),
 			je.cheque_date.as_("reference_date"),
 			je.pay_to_recd_from.as_("party"),
@@ -834,26 +801,13 @@ def get_je_matching_query(
 		.where(je.voucher_type != "Opening Entry")
 		.where(je.clearance_date.isnull())
 		.where(jea.account == common_filters.bank_account)
+		.where(amount_equality if exact_match else getattr(jea, amount_field) > 0.0)
 		.where(filter_by_date)
-		.groupby(je.name)
 		.orderby(je.cheque_date if cint(filter_by_reference_date) else je.posting_date)
 	)
 
 	if frappe.flags.auto_reconcile_vouchers is True:
-		subquery = subquery.where(je.cheque_no == transaction.reference_number)
-
-	ref_rank = frappe.qb.terms.Case().when(subquery.reference_no == transaction.reference_number, 1).else_(0)
-	amount_equality = subquery.paid_amount == transaction.unallocated_amount
-	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(0)
-
-	query = (
-		frappe.qb.from_(subquery)
-		.select(
-			"*",
-			(ref_rank + amount_rank + 1).as_("rank"),
-		)
-		.where(amount_equality if exact_match else subquery.paid_amount > 0.0)
-	)
+		query = query.where(ref_condition)
 
 	return query
 

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.py

@@ -277,7 +277,7 @@ def get_import_status(docname):
 
 @frappe.whitelist()
 def get_import_logs(docname: str):
-	frappe.has_permission("Bank Statement Import", throw=True)
+	frappe.has_permission("Bank Statement Import")
 
 	return frappe.get_all(
 		"Data Import Log",

erpnext/accounts/doctype/bank_transaction/auto_match_party.py

@@ -1,7 +1,6 @@
 import frappe
 from frappe.utils import flt
 from rapidfuzz import fuzz, process
-from rapidfuzz.utils import default_process
 
 
 class AutoMatchParty:
@@ -133,7 +132,6 @@ class AutoMatchbyPartyNameDescription:
 			query=self.get(field),
 			choices={row.get("name"): row.get("party_name") for row in names},
 			scorer=fuzz.token_set_ratio,
-			processor=default_process,
 		)
 		party_name, skip = self.process_fuzzy_result(result)
 

erpnext/accounts/doctype/bank_transaction/bank_transaction.js

@@ -2,21 +2,7 @@
 // For license information, please see license.txt
 
 frappe.ui.form.on("Bank Transaction", {
-	setup: function (frm) {
-		frm.set_query("party_type", function () {
-			return {
-				filters: {
-					name: ["in", Object.keys(frappe.boot.party_account_types)],
-				},
-			};
-		});
-
-		frm.set_query("bank_account", function () {
-			return {
-				filters: { is_company_account: 1 },
-			};
-		});
-
+	onload(frm) {
 		frm.set_query("payment_document", "payment_entries", function () {
 			const payment_doctypes = frm.events.get_payment_doctypes(frm);
 			return {
@@ -25,16 +11,7 @@ frappe.ui.form.on("Bank Transaction", {
 				},
 			};
 		});
-
-		frm.set_query("payment_entry", "payment_entries", function () {
-			return {
-				filters: {
-					docstatus: ["!=", 2],
-				},
-			};
-		});
 	},
-
 	refresh(frm) {
 		if (!frm.is_dirty() && frm.doc.payment_entries.length > 0) {
 			frm.add_custom_button(__("Unreconcile Transaction"), () => {
@@ -42,17 +19,51 @@ frappe.ui.form.on("Bank Transaction", {
 			});
 		}
 	},
-
 	bank_account: function (frm) {
 		set_bank_statement_filter(frm);
 	},
 
+	setup: function (frm) {
+		frm.set_query("party_type", function () {
+			return {
+				filters: {
+					name: ["in", Object.keys(frappe.boot.party_account_types)],
+				},
+			};
+		});
+	},
+
 	get_payment_doctypes: function () {
 		// get payment doctypes from all the apps
 		return ["Payment Entry", "Journal Entry", "Sales Invoice", "Purchase Invoice", "Bank Transaction"];
 	},
 });
 
+frappe.ui.form.on("Bank Transaction Payments", {
+	payment_entries_remove: function (frm, cdt, cdn) {
+		update_clearance_date(frm, cdt, cdn);
+	},
+});
+
+const update_clearance_date = (frm, cdt, cdn) => {
+	if (frm.doc.docstatus === 1) {
+		frappe
+			.xcall("erpnext.accounts.doctype.bank_transaction.bank_transaction.unclear_reference_payment", {
+				doctype: cdt,
+				docname: cdn,
+				bt_name: frm.doc.name,
+			})
+			.then((e) => {
+				if (e == "success") {
+					frappe.show_alert({
+						message: __("Document {0} successfully uncleared", [e]),
+						indicator: "green",
+					});
+				}
+			});
+	}
+};
+
 function set_bank_statement_filter(frm) {
 	frm.set_query("bank_statement", function () {
 		return {

erpnext/accounts/doctype/bank_transaction/bank_transaction.json

@@ -38,16 +38,14 @@
   "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": [
   {
    "default": "ACC-BTN-.YYYY.-",
    "fieldname": "naming_series",
    "fieldtype": "Select",
+   "hidden": 1,
    "label": "Series",
    "no_copy": 1,
    "options": "ACC-BTN-.YYYY.-",
@@ -119,14 +117,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 +224,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 +234,11 @@
   {
    "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": "2023-11-18 18:32:47.203694",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Transaction",
@@ -310,10 +287,9 @@
    "write": 1
   }
  ],
- "row_format": "Dynamic",
  "sort_field": "date",
  "sort_order": "DESC",
  "states": [],
  "title_field": "bank_account",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -5,7 +5,7 @@ import frappe
 from frappe import _
 from frappe.model.docstatus import DocStatus
 from frappe.model.document import Document
-from frappe.utils import flt, getdate
+from frappe.utils import flt
 
 
 class BankTransaction(Document):
@@ -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()
 
@@ -88,16 +84,16 @@ class BankTransaction(Document):
 		if not self.payment_entries:
 			return
 
-		references = set()
+		pe = []
 		for row in self.payment_entries:
 			reference = (row.payment_document, row.payment_entry)
-			if reference in references:
+			if reference in pe:
 				frappe.throw(
 					_("{0} {1} is allocated twice in this Bank Transaction").format(
 						row.payment_document, row.payment_entry
 					)
 				)
-			references.add(reference)
+			pe.append(reference)
 
 	def update_allocated_amount(self):
 		allocated_amount = (
@@ -108,19 +104,6 @@ class BankTransaction(Document):
 		self.allocated_amount = flt(allocated_amount, self.precision("allocated_amount"))
 		self.unallocated_amount = flt(unallocated_amount, self.precision("unallocated_amount"))
 
-	def delink_old_payment_entries(self):
-		if self.flags.updating_linked_bank_transaction:
-			return
-
-		old_doc = self.get_doc_before_save()
-		payment_entry_names = set(pe.name for pe in self.payment_entries)
-
-		for old_pe in old_doc.payment_entries:
-			if old_pe.name in payment_entry_names:
-				continue
-
-			self.delink_payment_entry(old_pe)
-
 	def before_submit(self):
 		self.allocate_payment_entries()
 		self.set_status()
@@ -130,14 +113,13 @@ class BankTransaction(Document):
 
 	def before_update_after_submit(self):
 		self.validate_duplicate_references()
-		self.update_allocated_amount()
-		self.delink_old_payment_entries()
 		self.allocate_payment_entries()
+		self.update_allocated_amount()
 		self.set_status()
 
 	def on_cancel(self):
 		for payment_entry in self.payment_entries:
-			self.delink_payment_entry(payment_entry)
+			self.clear_linked_payment_entry(payment_entry, for_cancel=True)
 
 		self.set_status()
 
@@ -170,55 +152,43 @@ class BankTransaction(Document):
 		    - 0 > a: Error: already over-allocated
 		- clear means: set the latest transaction date as clearance date
 		"""
-		if self.flags.updating_linked_bank_transaction or not self.payment_entries:
-			return
-
 		remaining_amount = self.unallocated_amount
+		to_remove = []
 		payment_entry_docs = [(pe.payment_document, pe.payment_entry) for pe in self.payment_entries]
 		pe_bt_allocations = get_total_allocated_amount(payment_entry_docs)
-		gl_entries = get_related_bank_gl_entries(payment_entry_docs)
-		gl_bank_account = frappe.db.get_value("Bank Account", self.bank_account, "account")
 
-		for payment_entry in list(self.payment_entries):
-			if payment_entry.allocated_amount != 0:
-				continue
-
-			allocable_amount, should_clear, clearance_date = get_clearance_details(
-				self,
-				payment_entry,
-				pe_bt_allocations.get((payment_entry.payment_document, payment_entry.payment_entry)) or {},
-				gl_entries.get((payment_entry.payment_document, payment_entry.payment_entry)) or {},
-				gl_bank_account,
-			)
-
-			if allocable_amount < 0:
-				frappe.throw(_("Voucher {0} is over-allocated by {1}").format(allocable_amount))
-
-			if remaining_amount <= 0:
-				self.remove(payment_entry)
-				continue
-
-			if allocable_amount == 0:
-				if should_clear:
-					self.clear_linked_payment_entry(payment_entry, clearance_date=clearance_date)
-				self.remove(payment_entry)
-				continue
-
-			should_clear = should_clear and allocable_amount <= remaining_amount
-			payment_entry.allocated_amount = min(allocable_amount, remaining_amount)
-			remaining_amount = flt(
-				remaining_amount - payment_entry.allocated_amount,
-				self.precision("unallocated_amount"),
-			)
-
-			if payment_entry.payment_document == "Bank Transaction":
-				self.update_linked_bank_transaction(
-					payment_entry.payment_entry, payment_entry.allocated_amount
+		for payment_entry in self.payment_entries:
+			if payment_entry.allocated_amount == 0.0:
+				unallocated_amount, should_clear, latest_transaction = get_clearance_details(
+					self,
+					payment_entry,
+					pe_bt_allocations.get((payment_entry.payment_document, payment_entry.payment_entry))
+					or [],
 				)
-			elif should_clear:
-				self.clear_linked_payment_entry(payment_entry, clearance_date=clearance_date)
 
-		self.update_allocated_amount()
+				if 0.0 == unallocated_amount:
+					if should_clear:
+						latest_transaction.clear_linked_payment_entry(payment_entry)
+					to_remove.append(payment_entry)
+
+				elif remaining_amount <= 0.0:
+					to_remove.append(payment_entry)
+
+				elif 0.0 < unallocated_amount <= remaining_amount:
+					payment_entry.allocated_amount = unallocated_amount
+					remaining_amount -= unallocated_amount
+					if should_clear:
+						latest_transaction.clear_linked_payment_entry(payment_entry)
+
+				elif 0.0 < unallocated_amount:
+					payment_entry.allocated_amount = remaining_amount
+					remaining_amount = 0.0
+
+				elif 0.0 > unallocated_amount:
+					frappe.throw(_("Voucher {0} is over-allocated by {1}").format(unallocated_amount))
+
+		for payment_entry in to_remove:
+			self.remove(payment_entry)
 
 	@frappe.whitelist()
 	def remove_payment_entries(self):
@@ -229,64 +199,14 @@ class BankTransaction(Document):
 
 	def remove_payment_entry(self, payment_entry):
 		"Clear payment entry and clearance"
-		self.delink_payment_entry(payment_entry)
+		self.clear_linked_payment_entry(payment_entry, for_cancel=True)
 		self.remove(payment_entry)
 
-	def delink_payment_entry(self, payment_entry):
-		if payment_entry.payment_document == "Bank Transaction":
-			self.update_linked_bank_transaction(payment_entry.payment_entry, allocated_amount=None)
-		else:
-			self.clear_linked_payment_entry(payment_entry, clearance_date=None)
-
-	def clear_linked_payment_entry(self, payment_entry, clearance_date=None):
-		doctype = payment_entry.payment_document
-		docname = payment_entry.payment_entry
-
-		# might be a bank transaction
-		if doctype not in get_doctypes_for_bank_reconciliation():
-			return
-
-		if doctype == "Sales Invoice":
-			frappe.db.set_value(
-				"Sales Invoice Payment",
-				dict(parenttype=doctype, parent=docname),
-				"clearance_date",
-				clearance_date,
-			)
-			return
-
-		frappe.db.set_value(doctype, docname, "clearance_date", clearance_date)
-
-	def update_linked_bank_transaction(self, bank_transaction_name, allocated_amount=None):
-		"""For when a second bank transaction has fixed another, e.g. refund"""
-
-		bt = frappe.get_doc(self.doctype, bank_transaction_name)
-		if allocated_amount:
-			bt.append(
-				"payment_entries",
-				{
-					"payment_document": self.doctype,
-					"payment_entry": self.name,
-					"allocated_amount": allocated_amount,
-				},
-			)
-
-		else:
-			pe = next(
-				(
-					pe
-					for pe in bt.payment_entries
-					if pe.payment_document == self.doctype and pe.payment_entry == self.name
-				),
-				None,
-			)
-			if not pe:
-				return
-
-			bt.flags.updating_linked_bank_transaction = True
-			bt.remove(pe)
-
-		bt.save()
+	def clear_linked_payment_entry(self, payment_entry, for_cancel=False):
+		clearance_date = None if for_cancel else self.date
+		set_voucher_clearance(
+			payment_entry.payment_document, payment_entry.payment_entry, clearance_date, self
+		)
 
 	def auto_set_party(self):
 		from erpnext.accounts.doctype.bank_transaction.auto_match_party import AutoMatchParty
@@ -311,40 +231,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():
@@ -352,107 +238,71 @@ def get_doctypes_for_bank_reconciliation():
 	return frappe.get_hooks("bank_reconciliation_doctypes")
 
 
-def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries, gl_bank_account):
+def get_clearance_details(transaction, payment_entry, bt_allocations):
 	"""
-	There should only be one bank gl entry for a voucher, except for JE.
-	For JE, there can be multiple bank gl entries for the same account.
-	In this case, the allocable_amount will be the sum of amounts of all gl entries of the account.
-	There will be no gl entry for a Bank Transaction so return the unallocated amount.
-	Should only clear the voucher if all bank gl entries are allocated.
+	There should only be one bank gle for a voucher.
+	Could be none for a Bank Transaction.
+	But if a JE, could affect two banks.
+	Should only clear the voucher if all bank gles are allocated.
 	"""
+	gl_bank_account = frappe.db.get_value("Bank Account", transaction.bank_account, "account")
+	gles = get_related_bank_gl_entries(payment_entry.payment_document, payment_entry.payment_entry)
 
-	transaction_date = getdate(transaction.date)
-
-	if payment_entry.payment_document == "Bank Transaction":
-		bt = frappe.db.get_value(
-			"Bank Transaction",
-			payment_entry.payment_entry,
-			("unallocated_amount", "bank_account"),
-			as_dict=True,
-		)
-
-		if bt.bank_account != gl_bank_account:
-			frappe.throw(
-				_("Bank Account {} in Bank Transaction {} is not matching with Bank Account {}").format(
-					bt.bank_account, payment_entry.payment_entry, gl_bank_account
+	unallocated_amount = min(
+		transaction.unallocated_amount,
+		get_paid_amount(payment_entry, transaction.currency, gl_bank_account),
+	)
+	unmatched_gles = len(gles)
+	latest_transaction = transaction
+	for gle in gles:
+		if gle["gl_account"] == gl_bank_account:
+			if gle["amount"] <= 0.0:
+				frappe.throw(
+					_("Voucher {0} value is broken: {1}").format(payment_entry.payment_entry, gle["amount"])
 				)
-			)
 
-		return abs(bt.unallocated_amount), True, transaction_date
+			unmatched_gles -= 1
+			unallocated_amount = gle["amount"]
+			for a in bt_allocations:
+				if a["gl_account"] == gle["gl_account"]:
+					unallocated_amount = gle["amount"] - a["total"]
+					if frappe.utils.getdate(transaction.date) < a["latest_date"]:
+						latest_transaction = frappe.get_doc("Bank Transaction", a["latest_name"])
+		else:
+			# Must be a Journal Entry affecting more than one bank
+			for a in bt_allocations:
+				if a["gl_account"] == gle["gl_account"] and a["total"] == gle["amount"]:
+					unmatched_gles -= 1
 
-	if gl_bank_account not in gl_entries:
-		frappe.throw(
-			_("{} {} is not affecting bank account {}").format(
-				payment_entry.payment_document, payment_entry.payment_entry, gl_bank_account
-			)
-		)
-
-	allocable_amount = gl_entries.pop(gl_bank_account) or 0
-	if allocable_amount <= 0.0:
-		frappe.throw(
-			_("Invalid amount in accounting entries of {} {} for Account {}: {}").format(
-				payment_entry.payment_document, payment_entry.payment_entry, gl_bank_account, allocable_amount
-			)
-		)
-
-	matching_bt_allocaion = bt_allocations.pop(gl_bank_account, {})
-
-	allocable_amount = flt(
-		allocable_amount - matching_bt_allocaion.get("total", 0), transaction.precision("unallocated_amount")
-	)
-
-	should_clear = all(
-		gl_entries[gle_account] == bt_allocations.get(gle_account, {}).get("total", 0)
-		for gle_account in gl_entries
-	)
-
-	bt_allocation_date = matching_bt_allocaion.get("latest_date", None)
-	clearance_date = transaction_date if not bt_allocation_date else max(transaction_date, bt_allocation_date)
-
-	return allocable_amount, should_clear, clearance_date
+	return unallocated_amount, unmatched_gles == 0, latest_transaction
 
 
-def get_related_bank_gl_entries(docs):
+def get_related_bank_gl_entries(doctype, docname):
 	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
-	if not docs:
-		return {}
-
-	result = frappe.db.sql(
+	return frappe.db.sql(
 		"""
-        SELECT
-            gle.voucher_type AS doctype,
-            gle.voucher_no AS docname,
-            gle.account AS gl_account,
-            SUM(ABS(gle.credit_in_account_currency - gle.debit_in_account_currency)) AS amount
-        FROM
-            `tabGL Entry` gle
-        LEFT JOIN
-            `tabAccount` ac ON ac.name = gle.account
-        WHERE
-            ac.account_type = 'Bank'
-            AND (gle.voucher_type, gle.voucher_no) IN %(docs)s
-            AND gle.is_cancelled = 0
-        GROUP BY
-            gle.voucher_type, gle.voucher_no, gle.account
-        """,
-		{"docs": docs},
+		SELECT
+			ABS(gle.credit_in_account_currency - gle.debit_in_account_currency) AS amount,
+			gle.account AS gl_account
+		FROM
+			`tabGL Entry` gle
+		LEFT JOIN
+			`tabAccount` ac ON ac.name=gle.account
+		WHERE
+			ac.account_type = 'Bank'
+			AND gle.voucher_type = %(doctype)s
+			AND gle.voucher_no = %(docname)s
+			AND is_cancelled = 0
+		""",
+		dict(doctype=doctype, docname=docname),
 		as_dict=True,
 	)
 
-	entries = {}
-	for row in result:
-		key = (row["doctype"], row["docname"])
-		if key not in entries:
-			entries[key] = {}
-		entries[key][row["gl_account"]] = row["amount"]
-
-	return entries
-
 
 def get_total_allocated_amount(docs):
 	"""
 	Gets the sum of allocations for a voucher on each bank GL account
-	along with the latest bank transaction date
+	along with the latest bank transaction name & date
 	NOTE: query may also include just saved vouchers/payments but with zero allocated_amount
 	"""
 	if not docs:
@@ -461,10 +311,11 @@ def get_total_allocated_amount(docs):
 	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
 	result = frappe.db.sql(
 		"""
-		SELECT total, latest_date, gl_account, payment_document, payment_entry FROM (
+		SELECT total, latest_name, latest_date, gl_account, payment_document, payment_entry FROM (
 			SELECT
 				ROW_NUMBER() OVER w AS rownum,
 				SUM(btp.allocated_amount) OVER(PARTITION BY ba.account, btp.payment_document, btp.payment_entry) AS total,
+				FIRST_VALUE(bt.name) OVER w AS latest_name,
 				FIRST_VALUE(bt.date) OVER w AS latest_date,
 				ba.account AS gl_account,
 				btp.payment_document,
@@ -487,14 +338,104 @@ def get_total_allocated_amount(docs):
 
 	payment_allocation_details = {}
 	for row in result:
-		row["latest_date"] = getdate(row["latest_date"])
-		payment_allocation_details.setdefault((row["payment_document"], row["payment_entry"]), {})[
-			row["gl_account"]
-		] = row
+		# Why is this *sometimes* a byte string?
+		if isinstance(row["latest_name"], bytes):
+			row["latest_name"] = row["latest_name"].decode()
+		row["latest_date"] = frappe.utils.getdate(row["latest_date"])
+		payment_allocation_details.setdefault((row["payment_document"], row["payment_entry"]), []).append(row)
 
 	return payment_allocation_details
 
 
+def get_paid_amount(payment_entry, currency, gl_bank_account):
+	if payment_entry.payment_document in ["Payment Entry", "Sales Invoice", "Purchase Invoice"]:
+		paid_amount_field = "paid_amount"
+		if payment_entry.payment_document == "Payment Entry":
+			doc = frappe.get_doc("Payment Entry", payment_entry.payment_entry)
+
+			if doc.payment_type == "Receive":
+				paid_amount_field = (
+					"received_amount" if doc.paid_to_account_currency == currency else "base_received_amount"
+				)
+			elif doc.payment_type == "Pay":
+				paid_amount_field = (
+					"paid_amount" if doc.paid_from_account_currency == currency else "base_paid_amount"
+				)
+
+		return frappe.db.get_value(
+			payment_entry.payment_document, payment_entry.payment_entry, paid_amount_field
+		)
+
+	elif payment_entry.payment_document == "Journal Entry":
+		return abs(
+			frappe.db.get_value(
+				"Journal Entry Account",
+				{"parent": payment_entry.payment_entry, "account": gl_bank_account},
+				"sum(debit_in_account_currency-credit_in_account_currency)",
+			)
+			or 0
+		)
+
+	elif payment_entry.payment_document == "Expense Claim":
+		return frappe.db.get_value(
+			payment_entry.payment_document, payment_entry.payment_entry, "total_amount_reimbursed"
+		)
+
+	elif payment_entry.payment_document == "Loan Disbursement":
+		return frappe.db.get_value(
+			payment_entry.payment_document, payment_entry.payment_entry, "disbursed_amount"
+		)
+
+	elif payment_entry.payment_document == "Loan Repayment":
+		return frappe.db.get_value(payment_entry.payment_document, payment_entry.payment_entry, "amount_paid")
+
+	elif payment_entry.payment_document == "Bank Transaction":
+		dep, wth = frappe.db.get_value(
+			"Bank Transaction", payment_entry.payment_entry, ("deposit", "withdrawal")
+		)
+		return abs(flt(wth) - flt(dep))
+
+	else:
+		frappe.throw(
+			f"Please reconcile {payment_entry.payment_document}: {payment_entry.payment_entry} manually"
+		)
+
+
+def set_voucher_clearance(doctype, docname, clearance_date, self):
+	if doctype in get_doctypes_for_bank_reconciliation():
+		if (
+			doctype == "Payment Entry"
+			and frappe.db.get_value("Payment Entry", docname, "payment_type") == "Internal Transfer"
+			and len(get_reconciled_bank_transactions(doctype, docname)) < 2
+		):
+			return
+
+		if doctype == "Sales Invoice":
+			frappe.db.set_value(
+				"Sales Invoice Payment",
+				dict(parenttype=doctype, parent=docname),
+				"clearance_date",
+				clearance_date,
+			)
+			return
+
+		frappe.db.set_value(doctype, docname, "clearance_date", clearance_date)
+
+	elif doctype == "Bank Transaction":
+		# For when a second bank transaction has fixed another, e.g. refund
+		bt = frappe.get_doc(doctype, docname)
+		if clearance_date:
+			vouchers = [{"payment_doctype": "Bank Transaction", "payment_name": self.name}]
+			bt.add_payment_entries(vouchers)
+			bt.save()
+		else:
+			for pe in bt.payment_entries:
+				if pe.payment_document == self.doctype and pe.payment_entry == self.name:
+					bt.remove(pe)
+					bt.save()
+					break
+
+
 def get_reconciled_bank_transactions(doctype, docname):
 	return frappe.get_all(
 		"Bank Transaction Payments",
@@ -503,6 +444,13 @@ def get_reconciled_bank_transactions(doctype, docname):
 	)
 
 
+@frappe.whitelist()
+def unclear_reference_payment(doctype, docname, bt_name):
+	bt = frappe.get_doc("Bank Transaction", bt_name)
+	set_voucher_clearance(doctype, docname, None, bt)
+	return docname
+
+
 def remove_from_bank_transaction(doctype, docname):
 	"""Remove a (cancelled) voucher from all Bank Transactions."""
 	for bt_name in get_reconciled_bank_transactions(doctype, docname):

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.py

@@ -12,9 +12,6 @@ from erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool
 	get_linked_payments,
 	reconcile_vouchers,
 )
-from erpnext.accounts.doctype.mode_of_payment.test_mode_of_payment import (
-	set_default_account_for_mode_of_payment,
-)
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
 from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
@@ -437,13 +434,15 @@ def add_vouchers(gl_account="_Test Bank - _TC"):
 	except frappe.DuplicateEntryError:
 		pass
 
-	mode_of_payment = frappe.get_doc({"doctype": "Mode of Payment", "name": "Wire Transfer"})
+	mode_of_payment = frappe.get_doc({"doctype": "Mode of Payment", "name": "Cash"})
 
-	set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", gl_account)
+	if not frappe.db.get_value("Mode of Payment Account", {"company": "_Test Company", "parent": "Cash"}):
+		mode_of_payment.append("accounts", {"company": "_Test Company", "default_account": gl_account})
+		mode_of_payment.save()
 
 	si = create_sales_invoice(customer="Fayva", qty=1, rate=109080, do_not_save=1)
 	si.is_pos = 1
-	si.append("payments", {"mode_of_payment": "Wire Transfer", "amount": 109080})
+	si.append("payments", {"mode_of_payment": "Cash", "account": gl_account, "amount": 109080})
 	si.insert()
 	si.submit()
 

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.json

@@ -7,10 +7,10 @@
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
-  "naming_series",
   "budget_against",
   "company",
   "cost_center",
+  "naming_series",
   "project",
   "fiscal_year",
   "column_break_3",
@@ -195,19 +195,19 @@
   },
   {
    "fieldname": "naming_series",
-   "fieldtype": "Select",
+   "fieldtype": "Data",
+   "hidden": 1,
    "label": "Series",
    "no_copy": 1,
-   "options": "BUDGET-.YYYY.-",
    "print_hide": 1,
-   "reqd": 1,
+   "read_only": 1,
    "set_only_once": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-06-16 15:57:13.114981",
+ "modified": "2022-10-10 22:14:36.361509",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Budget",
@@ -235,4 +235,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/budget/budget.py

@@ -48,7 +48,7 @@ class Budget(Document):
 		cost_center: DF.Link | None
 		fiscal_year: DF.Link
 		monthly_distribution: DF.Link | None
-		naming_series: DF.Literal["BUDGET-.YYYY.-"]
+		naming_series: DF.Data | None
 		project: DF.Link | None
 	# end: auto-generated types
 
@@ -136,16 +136,17 @@ class Budget(Document):
 		):
 			self.applicable_on_booking_actual_expenses = 1
 
+	def before_naming(self):
+		self.naming_series = f"{{{frappe.scrub(self.budget_against)}}}./.{self.fiscal_year}/.###"
+
 
 def validate_expense_against_budget(args, expense_amount=0):
 	args = frappe._dict(args)
 	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/coupon_code/test_coupon_code.py

@@ -128,7 +128,7 @@ class TestCouponCode(unittest.TestCase):
 			item_code="_Test Tesla Car",
 			rate=5000,
 			qty=1,
-			do_not_save=True,
+			do_not_submit=True,
 		)
 
 		self.assertEqual(so.items[0].rate, 5000)

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):
@@ -247,7 +220,6 @@ def get_dunning_letter_text(dunning_type: str, doc: str | dict, language: str |
 	if not language:
 		language = doc.get("language")
 
-	letter_text = None
 	if language:
 		letter_text = frappe.db.get_value(
 			DOCTYPE, {"parent": dunning_type, "language": language}, FIELDS, as_dict=1

erpnext/accounts/doctype/dunning/test_dunning.py

@@ -1,9 +1,6 @@
 # Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
-import json
-
 import frappe
-from frappe.model import mapper
 from frappe.tests.utils import FrappeTestCase
 from frappe.utils import add_days, nowdate, today
 
@@ -71,36 +68,6 @@ class TestDunning(FrappeTestCase):
 		dunning.reload()
 		self.assertEqual(dunning.status, "Resolved")
 
-	def test_fetch_overdue_payments(self):
-		"""
-		Create SI with overdue payment. Check if overdue payment is fetched in Dunning.
-		"""
-		si1 = create_sales_invoice_against_cost_center(
-			posting_date=add_days(today(), -1 * 6),
-			qty=1,
-			rate=100,
-		)
-
-		si2 = create_sales_invoice_against_cost_center(
-			posting_date=add_days(today(), -1 * 6),
-			qty=1,
-			rate=300,
-		)
-
-		dunning = create_dunning_from_sales_invoice(si1.name)
-		dunning.overdue_payments = []
-
-		method = "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_dunning"
-		updated_dunning = mapper.map_docs(method, json.dumps([si1.name, si2.name]), dunning)
-
-		self.assertEqual(len(updated_dunning.overdue_payments), 2)
-
-		self.assertEqual(updated_dunning.overdue_payments[0].sales_invoice, si1.name)
-		self.assertEqual(updated_dunning.overdue_payments[0].outstanding, si1.outstanding_amount)
-
-		self.assertEqual(updated_dunning.overdue_payments[1].sales_invoice, si2.name)
-		self.assertEqual(updated_dunning.overdue_payments[1].outstanding, si2.outstanding_amount)
-
 	def test_dunning_and_payment_against_partially_due_invoice(self):
 		"""
 		Create SI with first installment overdue. Check impact of Dunning and Payment Entry.
@@ -139,64 +106,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.json

@@ -279,8 +279,7 @@
   {
    "fieldname": "transaction_exchange_rate",
    "fieldtype": "Float",
-   "label": "Transaction Exchange Rate",
-   "precision": "9"
+   "label": "Transaction Exchange Rate"
   },
   {
    "fieldname": "debit_in_transaction_currency",
@@ -358,7 +357,7 @@
  "idx": 1,
  "in_create": 1,
  "links": [],
- "modified": "2025-02-21 14:36:49.431166",
+ "modified": "2024-08-22 13:03:39.997475",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "GL Entry",

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -7,7 +7,7 @@ from frappe import _
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
 from frappe.model.naming import set_name_from_naming_options
-from frappe.utils import create_batch, flt, fmt_money, now
+from frappe.utils import flt, fmt_money
 
 import erpnext
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
@@ -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 (
@@ -187,6 +185,7 @@ class GLEntry(Document):
 				account_type == "Profit and Loss"
 				and self.company == dimension.company
 				and dimension.mandatory_for_pl
+				and not dimension.disabled
 				and not self.is_cancelled
 			):
 				if not self.get(dimension.fieldname):
@@ -200,6 +199,7 @@ class GLEntry(Document):
 				account_type == "Balance Sheet"
 				and self.company == dimension.company
 				and dimension.mandatory_for_bs
+				and not dimension.disabled
 				and not self.is_cancelled
 			):
 				if not self.get(dimension.fieldname):
@@ -251,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"])
@@ -311,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]
 
@@ -418,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:
@@ -451,20 +451,12 @@ def rename_gle_sle_docs():
 def rename_temporarily_named_docs(doctype):
 	"""Rename temporarily named docs using autoname options"""
 	docs_to_rename = frappe.get_all(doctype, {"to_rename": "1"}, order_by="creation", limit=50000)
-	autoname = frappe.get_meta(doctype).autoname
-
-	for batch in create_batch(docs_to_rename, 100):
-		for doc in batch:
-			oldname = doc.name
-			set_name_from_naming_options(autoname, doc)
-			newname = doc.name
-			frappe.db.sql(
-				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()
+	for doc in docs_to_rename:
+		oldname = doc.name
+		set_name_from_naming_options(frappe.get_meta(doctype).autoname, doc)
+		newname = doc.name
+		frappe.db.sql(
+			f"UPDATE `tab{doctype}` SET name = %s, to_rename = 0 where name = %s",
+			(newname, oldname),
+			auto_commit=True,
+		)

erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js

@@ -197,7 +197,7 @@ frappe.ui.form.on("Invoice Discounting", {
 						from_date: frm.doc.posting_date,
 						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
 						company: frm.doc.company,
-						categorize_by: "Categorize by Voucher (Consolidated)",
+						group_by: "Group by Voucher (Consolidated)",
 						show_cancelled_entries: frm.doc.docstatus === 2,
 					};
 					frappe.set_route("query-report", "General Ledger");

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -20,23 +20,6 @@ frappe.ui.form.on("Journal Entry", {
 			"Unreconcile Payment Entries",
 			"Bank Transaction",
 		];
-		frm.trigger("set_queries");
-	},
-
-	set_queries(frm) {
-		frm.set_query("project", "accounts", function (doc, cdt, cdn) {
-			let row = frappe.get_doc(cdt, cdn);
-			let filters = {
-				company: doc.company,
-			};
-			if (row.party_type == "Customer") {
-				filters.customer = row.party;
-			}
-			return {
-				query: "erpnext.controllers.queries.get_project_name",
-				filters,
-			};
-		});
 	},
 
 	refresh: function (frm) {
@@ -52,7 +35,7 @@ frappe.ui.form.on("Journal Entry", {
 						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
 						company: frm.doc.company,
 						finance_book: frm.doc.finance_book,
-						categorize_by: "",
+						group_by: "",
 						show_cancelled_entries: frm.doc.docstatus === 2,
 					};
 					frappe.set_route("query-report", "General Ledger");
@@ -180,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

@@ -6,7 +6,6 @@ import json
 
 import frappe
 from frappe import _, msgprint, scrub
-from frappe.core.doctype.submission_queue.submission_queue import queue_submission
 from frappe.utils import comma_and, cstr, flt, fmt_money, formatdate, get_link_to_form, nowdate
 
 import erpnext
@@ -25,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,
@@ -34,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):
@@ -74,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
@@ -145,12 +141,12 @@ class JournalEntry(AccountsController):
 		self.validate_empty_accounts_table()
 		self.validate_inter_company_accounts()
 		self.validate_depr_entry_voucher_type()
-		self.validate_company_in_accounting_dimension()
 		self.validate_advance_accounts()
 
 		if self.docstatus == 0:
 			self.apply_tax_withholding()
-		if self.is_new() or not self.title:
+
+		if not self.title:
 			self.title = self.get_title()
 
 	def validate_advance_accounts(self):
@@ -172,17 +168,16 @@ class JournalEntry(AccountsController):
 		validate_docs_for_deferred_accounting([self.name], [])
 
 	def submit(self):
-		if len(self.accounts) > 100 and not self.meta.queue_in_background:
-			queue_submission(self, "_submit")
+		if len(self.accounts) > 100:
+			msgprint(_("The task has been enqueued as a background job."), alert=True)
+			self.queue_action("submit", timeout=4600)
 		else:
 			return self._submit()
 
-	def before_cancel(self):
-		self.has_asset_adjustment_entry()
-
 	def cancel(self):
 		if len(self.accounts) > 100:
-			queue_submission(self, "_cancel")
+			msgprint(_("The task has been enqueued as a background job."), alert=True)
+			self.queue_action("cancel", timeout=4600)
 		else:
 			return self._cancel()
 
@@ -193,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()
@@ -227,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()
@@ -237,22 +236,24 @@ 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(
-				"Journal Entry",
-				self.inter_company_journal_entry_reference,
-				["company", "total_debit", "total_credit"],
-				as_dict=True,
-			)
+			doc = frappe.get_doc("Journal Entry", self.inter_company_journal_entry_reference)
 			account_currency = frappe.get_cached_value("Company", self.company, "default_currency")
 			previous_account_currency = frappe.get_cached_value("Company", doc.company, "default_currency")
 			if account_currency == previous_account_currency:
-				credit_precision = self.precision("total_credit")
-				debit_precision = self.precision("total_debit")
-				if (flt(self.total_credit, credit_precision) != flt(doc.total_debit, debit_precision)) or (
-					flt(self.total_debit, debit_precision) != flt(doc.total_credit, credit_precision)
-				):
+				if self.total_credit != doc.total_debit or self.total_debit != doc.total_credit:
 					frappe.throw(_("Total Credit/ Debit Amount should be same as linked Journal Entry"))
 
 	def validate_depr_entry_voucher_type(self):
@@ -276,7 +277,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":
@@ -450,36 +537,18 @@ class JournalEntry(AccountsController):
 			)
 			frappe.db.set_value("Journal Entry", self.name, "inter_company_journal_entry_reference", "")
 
-	def has_asset_adjustment_entry(self):
-		if self.flags.get("via_asset_value_adjustment"):
-			return
-
-		asset_value_adjustment = frappe.db.get_value(
-			"Asset Value Adjustment", {"docstatus": 1, "journal_entry": self.name}, "name"
-		)
-		if asset_value_adjustment:
-			frappe.throw(
-				_(
-					"Cannot cancel this document as it is linked with the submitted Asset Value Adjustment <b>{0}</b>. Please cancel the Asset Value Adjustment to continue."
-				).format(frappe.utils.get_link_to_form("Asset Value Adjustment", asset_value_adjustment))
-			)
-
 	def unlink_asset_adjustment_entry(self):
-		AssetValueAdjustment = frappe.qb.DocType("Asset Value Adjustment")
-		(
-			frappe.qb.update(AssetValueAdjustment)
-			.set(AssetValueAdjustment.journal_entry, None)
-			.where(AssetValueAdjustment.journal_entry == self.name)
-		).run()
+		frappe.db.sql(
+			""" update `tabAsset Value Adjustment`
+			set journal_entry = null where journal_entry = %s""",
+			self.name,
+		)
 
 	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}"
@@ -488,8 +557,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(
@@ -508,22 +575,8 @@ class JournalEntry(AccountsController):
 		if customers:
 			from erpnext.selling.doctype.customer.customer import check_credit_limit
 
-			customer_details = frappe._dict(
-				frappe.db.get_all(
-					"Customer Credit Limit",
-					filters={
-						"parent": ["in", customers],
-						"parenttype": ["=", "Customer"],
-						"company": ["=", self.company],
-					},
-					fields=["parent", "bypass_credit_limit_check"],
-					as_list=True,
-				)
-			)
-
 			for customer in customers:
-				ignore_outstanding_sales_order = bool(customer_details.get(customer))
-				check_credit_limit(customer, self.company, ignore_outstanding_sales_order)
+				check_credit_limit(customer, self.company)
 
 	def validate_cheque_info(self):
 		if self.voucher_type in ["Bank Entry"]:
@@ -1006,17 +1059,14 @@ class JournalEntry(AccountsController):
 		gl_map = []
 
 		company_currency = erpnext.get_company_currency(self.company)
-		self.transaction_currency = company_currency
-		self.transaction_exchange_rate = 1
 		if self.multi_currency:
 			for row in self.get("accounts"):
 				if row.account_currency != company_currency:
-					# Journal assumes the first foreign currency as transaction currency
-					self.transaction_currency = row.account_currency
-					self.transaction_exchange_rate = row.exchange_rate
+					self.currency = row.account_currency
+					self.conversion_rate = row.exchange_rate
 					break
-
-		advance_doctypes = get_advance_payment_doctypes()
+		else:
+			self.currency = company_currency
 
 		for d in self.get("accounts"):
 			if d.debit or d.credit or (self.voucher_type == "Exchange Gain Or Loss"):
@@ -1024,62 +1074,31 @@ class JournalEntry(AccountsController):
 				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")
+							),
+							"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,
 					)
 				)
@@ -1104,7 +1123,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))
 
@@ -1213,230 +1231,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
@@ -1805,6 +1599,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
 	)
@@ -1826,8 +1622,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):
@@ -576,32 +575,11 @@ class TestJournalEntry(unittest.TestCase):
 			order_by="account",
 		)
 		expected = [
-			{"account": "_Test Bank - _TC", "transaction_exchange_rate": 85.0},
+			{"account": "_Test Bank - _TC", "transaction_exchange_rate": 1.0},
 			{"account": "_Test Receivable USD - _TC", "transaction_exchange_rate": 85.0},
 		]
 		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,
@@ -613,14 +591,13 @@ def make_journal_entry(
 	save=True,
 	submit=False,
 	project=None,
-	company=None,
 ):
 	if not cost_center:
 		cost_center = "_Test Cost Center - _TC"
 
 	jv = frappe.new_doc("Journal Entry")
 	jv.posting_date = posting_date or nowdate()
-	jv.company = company or "_Test Company"
+	jv.company = "_Test Company"
 	jv.user_remark = "test"
 	jv.multi_currency = 1
 	jv.set(

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]
@@ -177,9 +168,8 @@ def validate_loyalty_points(ref_doc, points_to_redeem):
 
 		loyalty_amount = flt(points_to_redeem * loyalty_program_details.conversion_factor)
 
-		total_amount = ref_doc.grand_total if ref_doc.is_rounded_total_disabled() else ref_doc.rounded_total
-		if loyalty_amount > total_amount:
-			frappe.throw(_("You can't redeem Loyalty Points having more value than the Total Amount."))
+		if loyalty_amount > ref_doc.rounded_total:
+			frappe.throw(_("You can't redeem Loyalty Points having more value than the Rounded Total."))
 
 		if not ref_doc.loyalty_amount and ref_doc.loyalty_amount != loyalty_amount:
 			ref_doc.loyalty_amount = loyalty_amount

erpnext/accounts/doctype/mode_of_payment/mode_of_payment.js

@@ -7,7 +7,7 @@ frappe.ui.form.on("Mode of Payment", {
 			let d = locals[cdt][cdn];
 			return {
 				filters: [
-					["Account", "account_type", "in", ["Bank", "Cash", "Receivable"]],
+					["Account", "account_type", "in", "Bank, Cash, Receivable"],
 					["Account", "is_group", "=", 0],
 					["Account", "company", "=", d.company],
 				],

erpnext/accounts/doctype/mode_of_payment/test_mode_of_payment.py

@@ -3,25 +3,8 @@
 
 import unittest
 
-import frappe
+# test_records = frappe.get_test_records('Mode of Payment')
 
 
 class TestModeofPayment(unittest.TestCase):
 	pass
-
-
-def set_default_account_for_mode_of_payment(mode_of_payment, company, account):
-	mode_of_payment.reload()
-	if frappe.db.exists(
-		"Mode of Payment Account", {"parent": mode_of_payment.mode_of_payment, "company": company}
-	):
-		frappe.db.set_value(
-			"Mode of Payment Account",
-			{"parent": mode_of_payment.mode_of_payment, "company": company},
-			"default_account",
-			account,
-		)
-		return
-
-	mode_of_payment.append("accounts", {"company": company, "default_account": account})
-	mode_of_payment.save()

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

@@ -258,10 +258,6 @@ frappe.ui.form.on("Payment Entry", {
 		frappe.flags.allocate_payment_amount = true;
 	},
 
-	validate: async function (frm) {
-		await frm.events.set_exchange_gain_loss_deduction(frm);
-	},
-
 	validate_company: (frm) => {
 		if (!frm.doc.company) {
 			frappe.throw({ message: __("Please select a Company first."), title: __("Mandatory") });
@@ -273,7 +269,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) {
@@ -400,16 +395,6 @@ frappe.ui.form.on("Payment Entry", {
 		);
 
 		frm.refresh_fields();
-
-		const party_currency =
-			frm.doc.payment_type === "Receive" ? "paid_from_account_currency" : "paid_to_account_currency";
-
-		var reference_grid = frm.fields_dict["references"].grid;
-		["total_amount", "outstanding_amount", "allocated_amount"].forEach((fieldname) => {
-			reference_grid.update_docfield_property(fieldname, "options", party_currency);
-		});
-
-		reference_grid.refresh();
 	},
 
 	show_general_ledger: function (frm) {
@@ -422,7 +407,7 @@ frappe.ui.form.on("Payment Entry", {
 						from_date: frm.doc.posting_date,
 						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
 						company: frm.doc.company,
-						categorize_by: "",
+						group_by: "",
 						show_cancelled_entries: frm.doc.docstatus === 2,
 					};
 					frappe.set_route("query-report", "General Ledger");
@@ -445,7 +430,6 @@ frappe.ui.form.on("Payment Entry", {
 					"paid_to",
 					"references",
 					"total_allocated_amount",
-					"party_name",
 				],
 				function (i, field) {
 					frm.set_value(field, null);
@@ -603,8 +587,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,
@@ -614,7 +596,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);
 			}
 		);
 	},
@@ -622,8 +603,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,
@@ -640,7 +619,6 @@ frappe.ui.form.on("Payment Entry", {
 						frm.events.received_amount(frm);
 					}
 				}
-				frm.events.paid_to_account_currency(frm);
 			}
 		);
 	},
@@ -1129,7 +1107,7 @@ frappe.ui.form.on("Payment Entry", {
 
 	allocate_party_amount_against_ref_docs: async function (frm, paid_amount, paid_amount_change) {
 		await frm.call("allocate_amount_to_references", {
-			paid_amount: flt(paid_amount),
+			paid_amount: paid_amount,
 			paid_amount_change: paid_amount_change,
 			allocate_payment_amount: frappe.flags.allocate_payment_amount ?? false,
 		});
@@ -1313,14 +1291,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;
 		}
 
@@ -1364,8 +1343,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({
@@ -1404,34 +1381,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");
 	},
@@ -1531,14 +1480,18 @@ frappe.ui.form.on("Payment Entry", {
 				"Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total'"
 			);
 			d.row_id = "";
-		} else if (d.charge_type == "On Previous Row Amount" || d.charge_type == "On Previous Row Total") {
+		} else if (
+			(d.charge_type == "On Previous Row Amount" || d.charge_type == "On Previous Row Total") &&
+			d.row_id
+		) {
 			if (d.idx == 1) {
 				msg = __(
 					"Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row"
 				);
 				d.charge_type = "";
 			} else if (!d.row_id) {
-				d.row_id = d.idx - 1;
+				msg = __("Please specify a valid Row ID for row {0} in table {1}", [d.idx, __(d.doctype)]);
+				d.row_id = "";
 			} else if (d.row_id && d.row_id >= d.idx) {
 				msg = __(
 					"Cannot refer row number greater than or equal to current row number for this Charge type"
@@ -1940,6 +1893,8 @@ function prompt_for_missing_account(frm, account) {
 			(values) => resolve(values?.[account]),
 			__("Please Specify Account")
 		);
+
+		dialog.on_hide = () => resolve("");
 	});
 }
 

erpnext/accounts/doctype/payment_entry/payment_entry.json

@@ -21,6 +21,7 @@
   "party_name",
   "book_advance_payments_in_separate_party_account",
   "reconcile_on_advance_payment_date",
+  "advance_reconciliation_takes_effect_on",
   "column_break_11",
   "bank_account",
   "party_bank_account",
@@ -202,14 +203,14 @@
    "fieldtype": "Column Break"
   },
   {
-   "depends_on": "eval: doc.party && doc.party_type !== \"Employee\"",
+   "depends_on": "party",
    "fieldname": "contact_person",
    "fieldtype": "Link",
    "label": "Contact",
    "options": "Contact"
   },
   {
-   "depends_on": "eval: (doc.contact_person || doc.party_type === \"Employee\") && doc.contact_email",
+   "depends_on": "contact_person",
    "fieldname": "contact_email",
    "fieldtype": "Data",
    "label": "Email",
@@ -228,7 +229,6 @@
    "fieldname": "party_balance",
    "fieldtype": "Currency",
    "label": "Party Balance",
-   "no_copy": 1,
    "print_hide": 1,
    "read_only": 1
   },
@@ -786,9 +786,18 @@
    "options": "No\nYes",
    "print_hide": 1,
    "search_index": 1
+  },
+  {
+   "default": "Oldest Of Invoice Or Advance",
+   "fetch_from": "company.reconciliation_takes_effect_on",
+   "fieldname": "advance_reconciliation_takes_effect_on",
+   "fieldtype": "Select",
+   "hidden": 1,
+   "label": "Advance Reconciliation Takes Effect On",
+   "no_copy": 1,
+   "options": "Advance Payment Date\nOldest Of Invoice Or Advance\nReconciliation Date"
   }
  ],
- "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [
@@ -800,7 +809,7 @@
    "table_fieldname": "payment_entries"
   }
  ],
- "modified": "2025-05-15 18:01:04.013025",
+ "modified": "2025-01-31 17:27:28.555246",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry",
@@ -840,7 +849,6 @@
    "write": 1
   }
  ],
- "row_format": "Dynamic",
  "show_name_in_global_search": 1,
  "sort_field": "modified",
  "sort_order": "DESC",

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -49,10 +49,8 @@ class TestPaymentEntry(FrappeTestCase):
 		pe.insert()
 		pe.submit()
 
-		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 +82,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)
@@ -284,48 +282,6 @@ class TestPaymentEntry(FrappeTestCase):
 		self.assertEqual(si.payment_schedule[0].paid_amount, 200.0)
 		self.assertEqual(si.payment_schedule[1].paid_amount, 36.0)
 
-	def test_payment_entry_against_payment_terms_with_discount_on_pi(self):
-		pi = make_purchase_invoice(do_not_save=1)
-		create_payment_terms_template_with_discount()
-		pi.payment_terms_template = "Test Discount Template"
-
-		frappe.db.set_value("Company", pi.company, "default_discount_account", "Write Off - _TC")
-
-		pi.append(
-			"taxes",
-			{
-				"charge_type": "On Net Total",
-				"account_head": "_Test Account Service Tax - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"description": "Service Tax",
-				"rate": 18,
-			},
-		)
-		pi.save()
-		pi.submit()
-
-		frappe.db.set_single_value("Accounts Settings", "book_tax_discount_loss", 1)
-		pe_with_tax_loss = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Cash - _TC")
-
-		self.assertEqual(pe_with_tax_loss.references[0].payment_term, "30 Credit Days with 10% Discount")
-		self.assertEqual(pe_with_tax_loss.payment_type, "Pay")
-		self.assertEqual(pe_with_tax_loss.references[0].allocated_amount, 295.0)
-		self.assertEqual(pe_with_tax_loss.paid_amount, 265.5)
-		self.assertEqual(pe_with_tax_loss.difference_amount, 0)
-		self.assertEqual(pe_with_tax_loss.deductions[0].amount, -25.0)  # Loss on Income
-		self.assertEqual(pe_with_tax_loss.deductions[1].amount, -4.5)  # Loss on Tax
-		self.assertEqual(pe_with_tax_loss.deductions[1].account, "_Test Account Service Tax - _TC")
-
-		frappe.db.set_single_value("Accounts Settings", "book_tax_discount_loss", 0)
-		pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Cash - _TC")
-
-		self.assertEqual(pe.references[0].payment_term, "30 Credit Days with 10% Discount")
-		self.assertEqual(pe.payment_type, "Pay")
-		self.assertEqual(pe.references[0].allocated_amount, 295.0)
-		self.assertEqual(pe.paid_amount, 265.5)
-		self.assertEqual(pe.deductions[0].amount, -29.5)
-		self.assertEqual(pe.difference_amount, 0)
-
 	def test_payment_entry_against_payment_terms_with_discount(self):
 		si = create_sales_invoice(do_not_save=1, qty=1, rate=200)
 		create_payment_terms_template_with_discount()
@@ -562,8 +518,6 @@ class TestPaymentEntry(FrappeTestCase):
 		pe.insert()
 		pe.submit()
 
-		self.assertEqual(pe.paid_from_account_type, "Bank")
-
 		outstanding_amount, status = frappe.db.get_value(
 			"Purchase Invoice", pi.name, ["outstanding_amount", "status"]
 		)

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": [
   {
@@ -68,7 +66,7 @@
   {
    "columns": 2,
    "fieldname": "total_amount",
-   "fieldtype": "Currency",
+   "fieldtype": "Float",
    "in_list_view": 1,
    "label": "Grand Total",
    "print_hide": 1,
@@ -77,7 +75,7 @@
   {
    "columns": 2,
    "fieldname": "outstanding_amount",
-   "fieldtype": "Currency",
+   "fieldtype": "Float",
    "in_list_view": 1,
    "label": "Outstanding",
    "read_only": 1
@@ -85,7 +83,7 @@
   {
    "columns": 2,
    "fieldname": "allocated_amount",
-   "fieldtype": "Currency",
+   "fieldtype": "Float",
    "in_list_view": 1,
    "label": "Allocated"
   },
@@ -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": "2026-01-05 14:18:03.286224",
+ "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,25 +16,24 @@ 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.Currency
+		allocated_amount: DF.Float
 		bill_no: DF.Data | None
 		due_date: DF.Date | None
 		exchange_gain_loss: DF.Currency
 		exchange_rate: DF.Float
-		outstanding_amount: DF.Currency
+		outstanding_amount: DF.Float
 		parent: DF.Data
 		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
 		reconcile_effect_on: DF.Date | None
 		reference_doctype: DF.Link
 		reference_name: DF.DynamicLink
-		total_amount: DF.Currency
+		total_amount: DF.Float
 	# end: auto-generated types
 
 	@property

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

@@ -132,12 +132,6 @@
    "fieldtype": "Link",
    "label": "Cost Center",
    "options": "Cost Center"
-  },
-    {
-   "fieldname": "project",
-   "fieldtype": "Link",
-   "label": "Project",
-   "options": "Project"
   },
   {
    "fieldname": "due_date",
@@ -203,4 +197,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/payment_ledger_entry/payment_ledger_entry.py

@@ -38,7 +38,6 @@ class PaymentLedgerEntry(Document):
 		amount_in_account_currency: DF.Currency
 		company: DF.Link | None
 		cost_center: DF.Link | None
-		project: DF.Link | None
 		delinked: DF.Check
 		due_date: DF.Date | None
 		finance_book: DF.Link | None
@@ -134,6 +133,7 @@ class PaymentLedgerEntry(Document):
 				account_type == "Profit and Loss"
 				and self.company == dimension.company
 				and dimension.mandatory_for_pl
+				and not dimension.disabled
 			):
 				if not self.get(dimension.fieldname):
 					frappe.throw(
@@ -146,6 +146,7 @@ class PaymentLedgerEntry(Document):
 				account_type == "Balance Sheet"
 				and self.company == dimension.company
 				and dimension.mandatory_for_bs
+				and not dimension.disabled
 			):
 				if not self.get(dimension.fieldname):
 					frappe.throw(

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,8 +5,7 @@
 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 Case, Criterion
+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,38 +392,16 @@ class PaymentReconciliation(Document):
 			inv.outstanding_amount = flt(entry.get("outstanding_amount"))
 
 	def get_difference_amount(self, payment_entry, invoice, allocated_amount):
-		party_account_defaults = frappe.get_cached_value(
-			"Account", self.receivable_payable_account, ["account_type", "account_currency"], as_dict=True
-		)
-		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 party_account_defaults.get("account_currency") != frappe.get_cached_value(
-			"Company", self.company, "default_currency"
-		):
+		if frappe.get_cached_value(
+			"Account", self.receivable_payable_account, "account_currency"
+		) != frappe.get_cached_value("Company", self.company, "default_currency"):
 			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,
-				)
-
-				# Added If clause to handle return Adhoc payments for account type holders ("Payable")
-				if party_account_defaults.get("account_type") in ("Payable") and invoice.get(
-					"invoice_type"
-				) in ["Payment Entry", "Journal Entry"]:
-					difference_amount = allocated_amount_in_inv_rate - allocated_amount_in_ref_rate
-				else:
-					difference_amount = allocated_amount_in_ref_rate - allocated_amount_in_inv_rate
+				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
 
@@ -599,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"),
 			}
 		)
@@ -613,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"):
@@ -687,28 +663,6 @@ class PaymentReconciliation(Document):
 			)
 			invoice_exchange_map.update(journals_map)
 
-		payment_entries = [
-			d.get("invoice_number") for d in invoices if d.get("invoice_type") == "Payment Entry"
-		]
-		payment_entries.extend(
-			[d.get("reference_name") for d in payments if d.get("reference_type") == "Payment Entry"]
-		)
-		if payment_entries:
-			pe = frappe.qb.DocType("Payment Entry")
-			query = (
-				frappe.qb.from_(pe)
-				.select(
-					pe.name,
-					Case()
-					.when(pe.payment_type == "Receive", pe.source_exchange_rate)
-					.else_(pe.target_exchange_rate)
-					.as_("exchange_rate"),
-				)
-				.where(pe.name.isin(payment_entries))
-			)
-			payment_entries = query.run(as_list=1)
-			invoice_exchange_map.update(payment_entries)
-
 		return invoice_exchange_map
 
 	def validate_allocation(self):
@@ -746,7 +700,7 @@ class PaymentReconciliation(Document):
 		ple = qb.DocType("Payment Ledger Entry")
 		for x in self.dimensions:
 			dimension = x.fieldname
-			if self.get(dimension) and frappe.db.has_column("Payment Ledger Entry", dimension):
+			if self.get(dimension):
 				self.accounting_dimension_filter_conditions.append(ple[dimension] == self.get(dimension))
 
 	def build_qb_filter_conditions(self, get_invoices=False, get_return_invoices=False):
@@ -797,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 = (
@@ -819,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": [
@@ -880,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,340 +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 test_foreign_currency_reverse_payment_entry_against_payment_entry_for_customer(self):
-		transaction_date = nowdate()
-		customer = self.customer3
-		amount = 1000
-		exchange_rate_at_payment = 100
-		exchange_rate_at_reverse_payment = 95
-
-		# Receive amount from customer - 1,00,000
-		pe = self.create_payment_entry(amount=amount, posting_date=transaction_date, customer=customer)
-		pe.payment_type = "Receive"
-		pe.paid_from = self.debtors_eur
-		pe.paid_from_account_currency = "EUR"
-		pe.source_exchange_rate = exchange_rate_at_payment
-		pe.paid_amount = amount
-		pe.received_amount = exchange_rate_at_payment * amount
-		pe.paid_to = self.cash
-		pe.paid_to_account_currency = "INR"
-		pe = pe.save().submit()
-
-		# Pay amount to customer - 95,000
-		reverse_pe = self.create_payment_entry(
-			amount=amount, posting_date=transaction_date, customer=customer
-		)
-		reverse_pe.payment_type = "Pay"
-		reverse_pe.paid_from = self.cash
-		reverse_pe.paid_from_account_currency = "INR"
-		reverse_pe.target_exchange_rate = exchange_rate_at_reverse_payment
-		reverse_pe.paid_amount = exchange_rate_at_reverse_payment * amount
-		reverse_pe.received_amount = amount
-		reverse_pe.paid_to = self.debtors_eur
-		reverse_pe.paid_to_account_currency = "EUR"
-		reverse_pe.save().submit()
-
-		# Reconcile payments
-		pr = self.create_payment_reconciliation()
-		pr.party = customer
-		pr.receivable_payable_account = self.debtors_eur
-		pr.get_unreconciled_entries()
-		invoices = [invoice.as_dict() for invoice in pr.invoices]
-		payments = [payment.as_dict() for payment in pr.payments]
-		self.assertEqual(len(pr.get("invoices")), 1)
-		self.assertEqual(len(pr.get("payments")), 1)
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Check the difference_amount is a gain of 5000
-		self.assertEqual(flt(pr.allocation[0].get("difference_amount")), 5000.0)
-		pr.reconcile()
-
-	def test_foreign_currency_reverse_payment_entry_against_payment_entry_for_supplier(self):
-		transaction_date = nowdate()
-		self.supplier = "_Test Supplier USD"
-		amount = 1000
-		exchange_rate_at_payment = 100
-		exchange_rate_at_reverse_payment = 95
-
-		# Pay amount to supplier - 1,00,000
-		pe = self.create_payment_entry(amount=amount, posting_date=transaction_date)
-		pe.payment_type = "Pay"
-		pe.party_type = "Supplier"
-		pe.party = self.supplier
-		pe.paid_from = self.cash
-		pe.paid_from_account_currency = "INR"
-		pe.target_exchange_rate = exchange_rate_at_payment
-		pe.paid_amount = exchange_rate_at_payment * amount
-		pe.received_amount = amount
-		pe.paid_to = self.creditors_usd
-		pe.paid_to_account_currency = "USD"
-		pe.save().submit()
-
-		# Receive amount from supplier - 95,000
-		reverse_pe = self.create_payment_entry(amount=amount, posting_date=transaction_date)
-		reverse_pe.payment_type = "Receive"
-		reverse_pe.party_type = "Supplier"
-		reverse_pe.party = self.supplier
-		reverse_pe.paid_from = self.creditors_usd
-		reverse_pe.paid_from_account_currency = "USD"
-		reverse_pe.source_exchange_rate = exchange_rate_at_reverse_payment
-		reverse_pe.paid_amount = amount
-		reverse_pe.received_amount = exchange_rate_at_reverse_payment * amount
-		reverse_pe.paid_to = self.cash
-		reverse_pe.paid_to_account_currency = "INR"
-		reverse_pe = reverse_pe.save().submit()
-
-		# Reconcile payments
-		pr = self.create_payment_reconciliation(party_is_customer=False)
-		pr.party = self.supplier
-		pr.receivable_payable_account = self.creditors_usd
-		pr.get_unreconciled_entries()
-		invoices = [invoice.as_dict() for invoice in pr.invoices]
-		payments = [payment.as_dict() for payment in pr.payments]
-
-		self.assertEqual(len(pr.get("invoices")), 1)
-		self.assertEqual(len(pr.get("payments")), 1)
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Check the difference_amount is a loss of 5000
-		self.assertEqual(flt(pr.allocation[0].get("difference_amount")), -5000.0)
-		pr.reconcile()
-
-	def test_foreign_currency_reverse_journal_entry_against_journal_entry_for_customer(self):
-		transaction_date = nowdate()
-		customer = self.customer3
-		amount = 1000
-		exchange_rate_at_payment = 95
-		exchange_rate_at_reverse_payment = 100
-
-		# Receive amount from customer - 95,000
-		je1 = self.create_journal_entry(self.cash, self.debtors_eur, amount, transaction_date)
-		je1.multi_currency = 1
-		je1.accounts[0].exchange_rate = 1
-		je1.accounts[0].debit_in_account_currency = exchange_rate_at_payment * amount
-		je1.accounts[0].debit = exchange_rate_at_payment * amount
-		je1.accounts[1].party_type = "Customer"
-		je1.accounts[1].party = customer
-		je1.accounts[1].exchange_rate = exchange_rate_at_payment
-		je1.accounts[1].credit_in_account_currency = amount
-		je1.accounts[1].credit = exchange_rate_at_payment * amount
-		je1.save()
-		je1.submit()
-
-		# Pay amount to customer - 1,00,000
-		je2 = self.create_journal_entry(self.debtors_eur, self.cash, amount, transaction_date)
-		je2.multi_currency = 1
-		je2.accounts[0].party_type = "Customer"
-		je2.accounts[0].party = customer
-		je2.accounts[0].exchange_rate = exchange_rate_at_reverse_payment
-		je2.accounts[0].debit_in_account_currency = amount
-		je2.accounts[0].debit = exchange_rate_at_reverse_payment * amount
-		je2.accounts[1].exchange_rate = 1
-		je2.accounts[1].credit_in_account_currency = exchange_rate_at_reverse_payment * amount
-		je2.accounts[1].credit = exchange_rate_at_reverse_payment * amount
-		je2.save()
-		je2.submit()
-
-		# Reconcile payments
-		pr = self.create_payment_reconciliation()
-		pr.party = customer
-		pr.receivable_payable_account = self.debtors_eur
-		pr.get_unreconciled_entries()
-
-		self.assertEqual(len(pr.invoices), 1)
-		self.assertEqual(len(pr.payments), 1)
-
-		invoices = [invoice.as_dict() for invoice in pr.invoices]
-		payments = [payment.as_dict() for payment in pr.payments]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Check the difference_amount is a loss of 5000
-		self.assertEqual(flt(pr.allocation[0].difference_amount), -5000.0)
-		pr.reconcile()
-
-	def test_foreign_currency_reverse_journal_entry_against_journal_entry_for_supplier(self):
-		transaction_date = nowdate()
-		self.supplier = "_Test Supplier USD"
-		amount = 1000
-		exchange_rate_at_payment = 95
-		exchange_rate_at_reverse_payment = 100
-
-		# Pay amount to supplier - 95,000
-		je1 = self.create_journal_entry(self.creditors_usd, self.cash, amount, transaction_date)
-		je1.multi_currency = 1
-		je1.accounts[0].party_type = "Supplier"
-		je1.accounts[0].party = self.supplier
-		je1.accounts[0].exchange_rate = exchange_rate_at_payment
-		je1.accounts[0].debit_in_account_currency = amount
-		je1.accounts[0].debit = exchange_rate_at_payment * amount
-		je1.accounts[1].exchange_rate = 1
-		je1.accounts[1].credit = exchange_rate_at_payment * amount
-		je1.accounts[1].credit_in_account_currency = exchange_rate_at_payment * amount
-		je1.save()
-		je1.submit()
-
-		# Receive amount from supplier - 1,00,000
-		je2 = self.create_journal_entry(self.cash, self.creditors_usd, amount, transaction_date)
-		je2.multi_currency = 1
-		je2.accounts[0].exchange_rate = 1
-		je2.accounts[0].debit = exchange_rate_at_reverse_payment * amount
-		je2.accounts[0].debit_in_account_currency = exchange_rate_at_reverse_payment * amount
-		je2.accounts[1].party_type = "Supplier"
-		je2.accounts[1].party = self.supplier
-		je2.accounts[1].exchange_rate = exchange_rate_at_reverse_payment
-		je2.accounts[1].credit_in_account_currency = amount
-		je2.accounts[1].credit = exchange_rate_at_reverse_payment * amount
-		je2.save()
-		je2.submit()
-
-		# Reconcile payments
-		pr = self.create_payment_reconciliation()
-		pr.party_type = "Supplier"
-		pr.party = self.supplier
-		pr.receivable_payable_account = self.creditors_usd
-		pr.get_unreconciled_entries()
-
-		self.assertEqual(len(pr.invoices), 1)
-		self.assertEqual(len(pr.payments), 1)
-
-		invoices = [invoice.as_dict() for invoice in pr.invoices]
-		payments = [payment.as_dict() for payment in pr.payments]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Check the difference_amount is a gain of 5000
-		self.assertEqual(flt(pr.allocation[0].difference_amount), 5000.0)
-		pr.reconcile()
-
 
 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

@@ -1,9 +1,9 @@
 import json
 
 import frappe
-from frappe import _
+from frappe import _, qb
 from frappe.model.document import Document
-from frappe.query_builder.functions import Sum
+from frappe.query_builder.functions import Abs, Sum
 from frappe.utils import flt, nowdate
 from frappe.utils.background_jobs import enqueue
 
@@ -12,6 +12,7 @@ from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
 )
 from erpnext.accounts.doctype.payment_entry.payment_entry import (
+	get_company_defaults,
 	get_payment_entry,
 )
 from erpnext.accounts.doctype.subscription_plan.subscription_plan import get_plan_rate
@@ -119,21 +120,15 @@ class PaymentRequest(Document):
 				title=_("Invalid Amount"),
 			)
 
+		existing_payment_request_amount = flt(
+			get_existing_payment_request_amount(self.reference_doctype, self.reference_name)
+		)
+
 		ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
 		if not hasattr(ref_doc, "order_type") or ref_doc.order_type != "Shopping Cart":
 			ref_amount = get_amount(ref_doc, self.payment_account)
-			if not ref_amount:
-				frappe.throw(_("Payment Entry is already created"))
 
-			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,17 +540,10 @@ 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"))
-	if not grand_total:
-		frappe.throw(_("Payment Entry is already created"))
 	if args.loyalty_points and args.dt == "Sales Order":
 		from erpnext.accounts.doctype.loyalty_program.loyalty_program import validate_loyalty_points
 
@@ -566,8 +554,19 @@ def make_payment_request(**args):
 		frappe.db.set_value("Sales Order", args.dn, "loyalty_amount", loyalty_amount, update_modified=False)
 		grand_total = grand_total - loyalty_amount
 
+	bank_account = (
+		get_party_bank_account(args.get("party_type"), args.get("party")) if args.get("party_type") else ""
+	)
+
+	draft_payment_request = frappe.db.get_value(
+		"Payment Request",
+		{"reference_doctype": args.dt, "reference_name": args.dn, "docstatus": 0},
+	)
+
 	# fetches existing payment request `grand_total` amount
-	existing_payment_request_amount = get_existing_payment_request_amount(ref_doc)
+	existing_payment_request_amount = get_existing_payment_request_amount(ref_doc.doctype, ref_doc.name)
+
+	existing_paid_amount = get_existing_paid_amount(ref_doc.doctype, ref_doc.name)
 
 	def validate_and_calculate_grand_total(grand_total, existing_payment_request_amount):
 		grand_total -= existing_payment_request_amount
@@ -579,7 +578,7 @@ def make_payment_request(**args):
 		if args.order_type == "Shopping Cart":
 			# If Payment Request is in an advanced stage, then create for remaining amount.
 			if get_existing_payment_request_amount(
-				ref_doc, ["Initiated", "Partially Paid", "Payment Ordered", "Paid"]
+				ref_doc.doctype, ref_doc.name, ["Initiated", "Partially Paid", "Payment Ordered", "Paid"]
 			):
 				grand_total = validate_and_calculate_grand_total(grand_total, existing_payment_request_amount)
 			else:
@@ -588,10 +587,14 @@ def make_payment_request(**args):
 		else:
 			grand_total = validate_and_calculate_grand_total(grand_total, existing_payment_request_amount)
 
-	draft_payment_request = frappe.db.get_value(
-		"Payment Request",
-		{"reference_doctype": ref_doc.doctype, "reference_name": ref_doc.name, "docstatus": 0},
-	)
+	if existing_paid_amount:
+		if ref_doc.party_account_currency == ref_doc.currency:
+			if ref_doc.conversion_rate:
+				grand_total -= flt(existing_paid_amount / ref_doc.conversion_rate)
+			else:
+				grand_total -= flt(existing_paid_amount)
+		else:
+			grand_total -= flt(existing_paid_amount / ref_doc.conversion_rate)
 
 	if draft_payment_request:
 		frappe.db.set_value(
@@ -599,11 +602,6 @@ def make_payment_request(**args):
 		)
 		pr = frappe.get_doc("Payment Request", draft_payment_request)
 	else:
-		bank_account = (
-			get_party_bank_account(args.get("party_type"), args.get("party"))
-			if args.get("party_type")
-			else ""
-		)
 		pr = frappe.new_doc("Payment Request")
 
 		if not args.get("payment_request_type"):
@@ -677,40 +675,22 @@ def make_payment_request(**args):
 
 def get_amount(ref_doc, payment_account=None):
 	"""get amount based on doctype"""
-	grand_total = 0
-
 	dt = ref_doc.doctype
 	if dt in ["Sales Order", "Purchase Order"]:
-		advance_amount = flt(ref_doc.advance_paid)
-		if ref_doc.party_account_currency != ref_doc.currency:
-			advance_amount = flt(flt(ref_doc.advance_paid) / ref_doc.conversion_rate)
-
-		grand_total = (flt(ref_doc.rounded_total) or flt(ref_doc.grand_total)) - advance_amount
-
+		grand_total = flt(ref_doc.rounded_total) or flt(ref_doc.grand_total)
 	elif dt in ["Sales Invoice", "Purchase Invoice"]:
-		if (
-			dt == "Sales Invoice"
-			and ref_doc.is_pos
-			and ref_doc.payments
-			and any(
-				[
-					payment.type == "Phone" and payment.account == payment_account
-					for payment in ref_doc.payments
-				]
-			)
-		):
-			grand_total = sum(
-				[
-					payment.amount
-					for payment in ref_doc.payments
-					if payment.type == "Phone" and payment.account == payment_account
-				]
-			)
-		else:
+		if not ref_doc.get("is_pos"):
 			if ref_doc.party_account_currency == ref_doc.currency:
-				grand_total = flt(ref_doc.outstanding_amount)
+				grand_total = flt(ref_doc.rounded_total or ref_doc.grand_total)
 			else:
-				grand_total = flt(flt(ref_doc.outstanding_amount) / ref_doc.conversion_rate)
+				grand_total = flt(
+					flt(ref_doc.base_rounded_total or ref_doc.base_grand_total) / ref_doc.conversion_rate
+				)
+		elif dt == "Sales Invoice":
+			for pay in ref_doc.payments:
+				if pay.type == "Phone" and pay.account == payment_account:
+					grand_total = pay.amount
+					break
 	elif dt == "POS Invoice":
 		for pay in ref_doc.payments:
 			if pay.type == "Phone" and pay.account == payment_account:
@@ -719,7 +699,10 @@ def get_amount(ref_doc, payment_account=None):
 	elif dt == "Fees":
 		grand_total = ref_doc.outstanding_amount
 
-	return flt(grand_total, get_currency_precision()) if grand_total > 0 else 0
+	if grand_total > 0:
+		return flt(grand_total, get_currency_precision())
+	else:
+		frappe.throw(_("Payment Entry is already created"))
 
 
 def get_irequest_status(payment_requests: None | list = None) -> list:
@@ -762,7 +745,7 @@ def cancel_old_payment_requests(ref_dt, ref_dn):
 						frappe.db.set_value("Integration Request", ireq.name, "status", "Cancelled")
 
 
-def get_existing_payment_request_amount(ref_doc, statuses: list | None = None) -> list:
+def get_existing_payment_request_amount(ref_dt, ref_dn, statuses: list | None = None) -> list:
 	"""
 	Return the total amount of Payment Requests against a reference document.
 	"""
@@ -770,9 +753,9 @@ def get_existing_payment_request_amount(ref_doc, statuses: list | None = None) -
 
 	query = (
 		frappe.qb.from_(PR)
-		.select(Sum(PR.outstanding_amount))
-		.where(PR.reference_doctype == ref_doc.doctype)
-		.where(PR.reference_name == ref_doc.name)
+		.select(Sum(PR.grand_total))
+		.where(PR.reference_doctype == ref_dt)
+		.where(PR.reference_name == ref_dn)
 		.where(PR.docstatus == 1)
 	)
 
@@ -781,19 +764,40 @@ def get_existing_payment_request_amount(ref_doc, statuses: list | None = None) -
 
 	response = query.run()
 
-	os_amount_in_transaction_currency = flt(response[0][0] if response[0] else 0)
+	return response[0][0] if response[0] else 0
 
-	if ref_doc.currency != ref_doc.party_account_currency:
-		os_amount_in_transaction_currency = flt(os_amount_in_transaction_currency / ref_doc.conversion_rate)
 
-	return os_amount_in_transaction_currency
+def get_existing_paid_amount(doctype, name):
+	PL = frappe.qb.DocType("Payment Ledger Entry")
+	PER = frappe.qb.DocType("Payment Entry Reference")
+
+	query = (
+		frappe.qb.from_(PL)
+		.left_join(PER)
+		.on(
+			(PL.against_voucher_type == PER.reference_doctype)
+			& (PL.against_voucher_no == PER.reference_name)
+			& (PL.voucher_type == PER.parenttype)
+			& (PL.voucher_no == PER.parent)
+		)
+		.select(Abs(Sum(PL.amount)).as_("total_paid_amount"))
+		.where(PL.against_voucher_type.eq(doctype))
+		.where(PL.against_voucher_no.eq(name))
+		.where(PL.amount < 0)
+		.where(PL.delinked == 0)
+		.where(PER.docstatus == 1)
+		.where(PER.payment_request.isnull())
+	)
+	response = query.run()
+
+	return response[0][0] if response[0] else 0
 
 
 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 +844,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 +858,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 +883,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 +891,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,
 		)
@@ -319,22 +313,12 @@ class TestPaymentRequest(FrappeTestCase):
 		self.assertEqual(pr.outstanding_amount, 800)
 		self.assertEqual(pr.grand_total, 1000)
 
-		self.assertRaisesRegex(
-			frappe.exceptions.ValidationError,
-			re.compile(r"Payment Request is already created"),
-			make_payment_request,
-			dt="Sales Order",
-			dn=so.name,
-			mute_email=1,
-			submit_doc=1,
-			return_doc=1,
-		)
 		# complete payment
 		pe = pr.create_payment_entry()
 
 		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()
@@ -347,7 +331,7 @@ class TestPaymentRequest(FrappeTestCase):
 		# creating a more payment Request must not allowed
 		self.assertRaisesRegex(
 			frappe.exceptions.ValidationError,
-			re.compile(r"Payment Entry is already created"),
+			re.compile(r"Payment Request is already created"),
 			make_payment_request,
 			dt="Sales Order",
 			dn=so.name,
@@ -377,17 +361,6 @@ class TestPaymentRequest(FrappeTestCase):
 		self.assertEqual(pr.party_account_currency, "INR")
 		self.assertEqual(pr.status, "Initiated")
 
-		self.assertRaisesRegex(
-			frappe.exceptions.ValidationError,
-			re.compile(r"Payment Request is already created"),
-			make_payment_request,
-			dt="Purchase Invoice",
-			dn=pi.name,
-			mute_email=1,
-			submit_doc=1,
-			return_doc=1,
-		)
-
 		# to make partial payment
 		pe = pr.create_payment_entry(submit=False)
 		pe.paid_amount = 2000
@@ -416,7 +389,7 @@ class TestPaymentRequest(FrappeTestCase):
 		# creating a more payment Request must not allowed
 		self.assertRaisesRegex(
 			frappe.exceptions.ValidationError,
-			re.compile(r"Payment Entry is already created"),
+			re.compile(r"Payment Request is already created"),
 			make_payment_request,
 			dt="Purchase Invoice",
 			dn=pi.name,
@@ -608,86 +581,29 @@ class TestPaymentRequest(FrappeTestCase):
 		pi.load_from_db()
 		self.assertEqual(pr_2.grand_total, pi.outstanding_amount)
 
-	def test_consider_journal_entry_and_return_invoice(self):
-		from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 
-		si = create_sales_invoice(currency="INR", qty=5, rate=500)
+def test_partial_paid_invoice_with_submitted_payment_entry(self):
+	pi = make_purchase_invoice(currency="INR", qty=1, rate=5000)
+	pi.save()
+	pi.submit()
 
-		je = make_journal_entry("_Test Cash - _TC", "Debtors - _TC", 500, save=False)
-		je.accounts[1].party_type = "Customer"
-		je.accounts[1].party = si.customer
-		je.accounts[1].reference_type = "Sales Invoice"
-		je.accounts[1].reference_name = si.name
-		je.accounts[1].credit_in_account_currency = 500
-		je.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()
 
-		pe = get_payment_entry("Sales Invoice", si.name)
-		pe.paid_amount = 500
-		pe.references[0].allocated_amount = 500
-		pe.save()
-		pe.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()
 
-		cr_note = create_sales_invoice(qty=-1, rate=500, is_return=1, return_against=si.name, do_not_save=1)
-		cr_note.update_outstanding_for_self = 0
-		cr_note.save()
-		cr_note.submit()
-
-		si.load_from_db()
-		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()
-
-		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()
-
-		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)
-
-	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)