chore: update POT file

fix: sync translations from crowdin

.git-blame-ignore-revs

@@ -42,3 +42,6 @@ a308792ee7fda18a681e9181f4fd00b36385bc23
 # noisy typing refactoring of get_item_details
 7b7211ac79c248a79ba8a999ff34e734d874c0ae
 d827ed21adc7b36047e247cbb0dc6388d048a7f9
+
+# `frappe.flags.in_test` => `frappe.in_test`
+7a482a69985c952de0e8193c9d4e086aee65ee6d

.github/helper/install.sh

@@ -66,7 +66,7 @@ sed -i 's/schedule:/# schedule:/g' Procfile
 sed -i 's/socketio:/# socketio:/g' Procfile
 sed -i 's/redis_socketio:/# redis_socketio:/g' Procfile
 
-bench get-app payments --branch ${githubbranch%"-hotfix"}
+bench get-app payments --branch develop
 bench get-app erpnext "${GITHUB_WORKSPACE}"
 
 if [ "$TYPE" == "server" ]; then bench setup requirements --dev; fi

.github/workflows/backport.yml

@@ -5,6 +5,9 @@ on:
       - closed
       - labeled
 
+permissions:
+  contents: read
+
 jobs:
   main:
     runs-on: ubuntu-latest

.github/workflows/docker-release.yml

@@ -2,6 +2,10 @@ name: Trigger Docker build on release
 on:
   release:
     types: [released]
+
+permissions:
+  contents: read
+
 jobs:
   curl:
     runs-on: ubuntu-latest

.github/workflows/docs-checker.yml

@@ -3,6 +3,9 @@ on:
   pull_request:
     types: [ opened, synchronize, reopened, edited ]
 
+permissions:
+  contents: read
+
 jobs:
   build:
     runs-on: ubuntu-latest

.github/workflows/initiate_release.yml

@@ -2,6 +2,10 @@
 # To add/remove versions just modify the matrix.
 
 name: Create weekly release pull requests
+
+permissions:
+  contents: read
+
 on:
   schedule:
     # 9:30 UTC => 3 PM IST Tuesday

.github/workflows/labeller.yml

@@ -3,6 +3,10 @@ on:
   pull_request_target:
     types: [opened, reopened]
 
+permissions:
+  issues: write
+  pull-requests: write
+
 jobs:
   triage:
     runs-on: ubuntu-latest

.github/workflows/linters.yml

@@ -3,6 +3,9 @@ name: Linters
 on:
   pull_request: { }
 
+permissions:
+  contents: read
+
 jobs:
 
   linters:

.github/workflows/patch.yml

@@ -10,6 +10,9 @@ on:
       - '**.csv'
   workflow_dispatch:
 
+permissions:
+  contents: read
+
 concurrency:
   group: patch-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
   cancel-in-progress: true
@@ -36,7 +39,7 @@ jobs:
 
       - name: Check for valid Python & Merge Conflicts
         run: |
-          python -m compileall -f "${GITHUB_WORKSPACE}"
+          python -m compileall -fq "${GITHUB_WORKSPACE}"
           if grep -lr --exclude-dir=node_modules "^<<<<<<< " "${GITHUB_WORKSPACE}"
               then echo "Found merge conflicts"
               exit 1

.github/workflows/patch_faux.yml

@@ -11,6 +11,9 @@ on:
       - "**.html"
       - "**.csv"
 
+permissions:
+  contents: read
+
 jobs:
   test:
     runs-on: ubuntu-latest

.github/workflows/release.yml

@@ -3,6 +3,10 @@ on:
   push:
     branches:
       - version-13
+
+permissions:
+  contents: read
+
 jobs:
   release:
     name: Release

.github/workflows/run-indinvidual-tests.yml

@@ -7,6 +7,9 @@ concurrency:
   group: server-individual-tests-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
   cancel-in-progress: false
 
+permissions:
+  contents: read
+
 jobs:
   discover:
     runs-on: ubuntu-latest

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

@@ -10,6 +10,9 @@ on:
       - "**.md"
       - "**.html"
 
+permissions:
+  contents: read
+
 jobs:
   test:
     runs-on: ubuntu-latest

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

@@ -25,6 +25,9 @@ on:
         required: false
         type: string
 
+permissions:
+  contents: read
+
 concurrency:
   group: server-mariadb-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
   cancel-in-progress: true
@@ -65,7 +68,7 @@ jobs:
 
       - name: Check for valid Python & Merge Conflicts
         run: |
-          python -m compileall -f "${GITHUB_WORKSPACE}"
+          python -m compileall -fq "${GITHUB_WORKSPACE}"
           if grep -lr --exclude-dir=node_modules "^<<<<<<< " "${GITHUB_WORKSPACE}"
               then echo "Found merge conflicts"
               exit 1

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

@@ -12,6 +12,9 @@ concurrency:
   group: server-postgres-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
   cancel-in-progress: true
 
+permissions:
+  contents: read
+
 jobs:
   test:
     if: ${{ contains(github.event.pull_request.labels.*.name, 'postgres') }}
@@ -50,7 +53,7 @@ jobs:
 
       - name: Check for valid Python & Merge Conflicts
         run: |
-          python -m compileall -f "${GITHUB_WORKSPACE}"
+          python -m compileall -fq "${GITHUB_WORKSPACE}"
           if grep -lr --exclude-dir=node_modules "^<<<<<<< " "${GITHUB_WORKSPACE}"
               then echo "Found merge conflicts"
               exit 1

erpnext/__init__.py

@@ -57,7 +57,7 @@ def get_company_currency(company):
 
 def set_perpetual_inventory(enable=1, company=None):
 	if not company:
-		company = "_Test Company" if frappe.flags.in_test else get_default_company()
+		company = "_Test Company" if frappe.in_test else get_default_company()
 
 	company = frappe.get_doc("Company", company)
 	company.enable_perpetual_inventory = enable
@@ -77,7 +77,7 @@ def encode_company_abbr(name, company=None, abbr=None):
 
 def is_perpetual_inventory_enabled(company):
 	if not company:
-		company = "_Test Company" if frappe.flags.in_test else get_default_company()
+		company = "_Test Company" if frappe.in_test else get_default_company()
 
 	if not hasattr(frappe.local, "enable_perpetual_inventory"):
 		frappe.local.enable_perpetual_inventory = {}

erpnext/accounts/deferred_revenue.py

@@ -317,7 +317,7 @@ def get_already_booked_amount(doc, item):
 def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 	enable_check = "enable_deferred_revenue" if doc.doctype == "Sales Invoice" else "enable_deferred_expense"
 
-	accounts_frozen_upto = frappe.db.get_single_value("Accounts Settings", "acc_frozen_upto")
+	accounts_frozen_upto = frappe.get_single_value("Accounts Settings", "acc_frozen_upto")
 
 	def _book_deferred_revenue_or_expense(
 		item,
@@ -526,7 +526,7 @@ def make_gl_entries(
 			make_gl_entries(gl_entries, cancel=(doc.docstatus == 2), merge_entries=True)
 			frappe.db.commit()
 		except Exception as e:
-			if frappe.flags.in_test:
+			if frappe.in_test:
 				doc.log_error(f"Error while processing deferred accounting for Invoice {doc.name}")
 				raise e
 			else:

erpnext/accounts/doctype/account/account.py

@@ -92,7 +92,7 @@ class Account(NestedSet):
 			super().on_update()
 
 	def onload(self):
-		frozen_accounts_modifier = frappe.db.get_single_value("Accounts Settings", "frozen_accounts_modifier")
+		frozen_accounts_modifier = frappe.get_single_value("Accounts Settings", "frozen_accounts_modifier")
 		if not frozen_accounts_modifier or frozen_accounts_modifier in frappe.get_roles():
 			self.set_onload("can_freeze_account", True)
 
@@ -602,7 +602,7 @@ def _ensure_idle_system():
 	# 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:
+	if frappe.in_test:
 		return
 
 	last_gl_update = None

erpnext/accounts/doctype/account/account_tree.js

@@ -139,6 +139,11 @@ 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",
@@ -231,6 +236,10 @@ frappe.treeview_settings["Account"] = {
 							root_company,
 						]);
 					} else {
+						const node = treeview.tree.get_selected_node();
+						if (node.is_root) {
+							frappe.throw(__("Cannot create root account."));
+						}
 						treeview.new_node();
 					}
 				},
@@ -249,7 +258,8 @@ frappe.treeview_settings["Account"] = {
 					].treeview.page.fields_dict.root_company.get_value() ||
 						frappe.flags.ignore_root_company_validation) &&
 					node.expandable &&
-					!node.hide_add
+					!node.hide_add &&
+					!node.is_root
 				);
 			},
 			click: function () {
@@ -265,12 +275,14 @@ frappe.treeview_settings["Account"] = {
 			label: __("View Ledger"),
 			click: function (node, btn) {
 				frappe.route_options = {
-					account: node.label,
 					from_date: erpnext.utils.get_fiscal_year(frappe.datetime.get_today(), true)[1],
 					to_date: erpnext.utils.get_fiscal_year(frappe.datetime.get_today(), true)[2],
 					company:
 						frappe.treeview_settings["Account"].treeview.page.fields_dict.company.get_value(),
 				};
+				if (node.parent_label) {
+					frappe.route_options["account"] = node.label;
+				}
 				frappe.set_route("query-report", "General Ledger");
 			},
 			btnClass: "hidden-xs",

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

@@ -0,0 +1,817 @@
+{
+	"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

@@ -96,8 +96,20 @@
                         "account_number": "1132.000"
                     }, 
                     "account_number": "1130.000"
-                }, 
+                },
+                "Pajak Dibayar di Muka": {
+                    "PPN Masukan": {
+                        "account_number": "1151.001", 
+                        "account_type": "Tax"
+                    },
+                    "PPh 23 Dibayar di Muka": {
+                        "account_number": "1152.001", 
+                        "account_type": "Tax"
+                    }, 
+                    "account_number": "1150.000"
+                },
                 "account_number": "1100.000"
+                
             }, 
             "Aktiva Tetap": {
                 "Aktiva": {
@@ -557,6 +569,10 @@
                     "Hutang Pajak": {
                         "account_number": "2141.000", 
                         "account_type": "Payable"
+                    },
+                    "PPN Keluaran": {
+                        "account_number": "2142.000", 
+                        "account_type": "Tax"
                     }, 
                     "account_number": "2140.000"
                 }, 

erpnext/accounts/doctype/account_closing_balance/test_account_closing_balance.py

@@ -2,16 +2,7 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
-
-
-class UnitTestAccountClosingBalance(UnitTestCase):
-	"""
-	Unit tests for AccountClosingBalance.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
+from frappe.tests import IntegrationTestCase
 
 
 class TestAccountClosingBalance(IntegrationTestCase):

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -83,7 +83,7 @@ class AccountingDimension(Document):
 				frappe.throw(_("Company {0} is added more than once").format(frappe.bold(default.company)))
 
 	def after_insert(self):
-		if frappe.flags.in_test:
+		if frappe.in_test:
 			make_dimension_in_accounting_doctypes(doc=self)
 		else:
 			frappe.enqueue(
@@ -91,7 +91,7 @@ class AccountingDimension(Document):
 			)
 
 	def on_trash(self):
-		if frappe.flags.in_test:
+		if frappe.in_test:
 			delete_accounting_dimension(doc=self)
 		else:
 			frappe.enqueue(delete_accounting_dimension, doc=self, queue="long", enqueue_after_commit=True)
@@ -213,7 +213,7 @@ def delete_accounting_dimension(doc):
 
 @frappe.whitelist()
 def disable_dimension(doc):
-	if frappe.flags.in_test:
+	if frappe.in_test:
 		toggle_disabling(doc=doc)
 	else:
 		frappe.enqueue(toggle_disabling, doc=doc)

erpnext/accounts/doctype/accounts_settings/accounts_settings.js

@@ -22,4 +22,32 @@ 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

@@ -19,6 +19,7 @@
   "column_break_17",
   "enable_common_party_accounting",
   "allow_multi_currency_invoices_against_single_party_account",
+  "confirm_before_resetting_posting_date",
   "journals_section",
   "merge_similar_account_heads",
   "deferred_accounting_settings_section",
@@ -31,6 +32,7 @@
   "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",
@@ -38,8 +40,14 @@
   "show_taxes_as_table_in_print",
   "column_break_12",
   "show_payment_schedule_in_print",
+  "item_price_settings_section",
+  "maintain_same_internal_transaction_rate",
+  "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",
@@ -59,7 +67,6 @@
   "pos_setting_section",
   "post_change_gl_entries",
   "column_break_xrnd",
-  "use_sales_invoice_in_pos",
   "assets_tab",
   "asset_settings_section",
   "calculate_depr_using_total_days",
@@ -83,10 +90,14 @@
   "receivable_payable_remarks_length",
   "accounts_receivable_payable_tuning_section",
   "receivable_payable_fetch_method",
+  "column_break_ntmi",
+  "drop_ar_procedures",
   "legacy_section",
   "ignore_is_opening_check_for_reporting",
   "payment_request_settings",
-  "create_pr_in_draft_status"
+  "create_pr_in_draft_status",
+  "budget_settings",
+  "use_new_budget_controller"
  ],
  "fields": [
   {
@@ -542,19 +553,12 @@
    "fieldname": "column_break_xrnd",
    "fieldtype": "Column Break"
   },
-  {
-   "default": "0",
-   "description": "If enabled, Sales Invoice will be generated instead of POS Invoice in POS Transactions for real-time update of G/L and Stock Ledger.",
-   "fieldname": "use_sales_invoice_in_pos",
-   "fieldtype": "Check",
-   "label": "Use Sales Invoice"
-  },
   {
    "default": "Buffered Cursor",
    "fieldname": "receivable_payable_fetch_method",
    "fieldtype": "Select",
    "label": "Data Fetch Method",
-   "options": "Buffered Cursor\nUnBuffered Cursor"
+   "options": "Buffered Cursor\nUnBuffered Cursor\nRaw SQL"
   },
   {
    "fieldname": "accounts_receivable_payable_tuning_section",
@@ -565,6 +569,81 @@
    "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": "budget_settings",
+   "fieldtype": "Tab Break",
+   "label": "Budget"
+  },
+  {
+   "default": "1",
+   "fieldname": "use_new_budget_controller",
+   "fieldtype": "Check",
+   "label": "Use New Budget Controller"
+  },
+  {
+   "default": "1",
+   "description": "If enabled, user will be alerted before resetting posting date to current date in relevant transactions",
+   "fieldname": "confirm_before_resetting_posting_date",
+   "fieldtype": "Check",
+   "label": "Confirm before resetting posting date"
+  },
+  {
+   "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"
   }
  ],
  "grid_page_length": 50,
@@ -573,7 +652,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2025-05-05 12:29:38.302027",
+ "modified": "2025-06-23 15:55:33.346398",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -25,7 +25,9 @@ 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
@@ -37,6 +39,7 @@ class AccountsSettings(Document):
 		book_tax_discount_loss: DF.Check
 		calculate_depr_using_total_days: DF.Check
 		check_supplier_invoice_uniqueness: DF.Check
+		confirm_before_resetting_posting_date: DF.Check
 		create_pr_in_draft_status: DF.Check
 		credit_controller: DF.Link | None
 		delete_linked_ledger_entries: DF.Check
@@ -50,14 +53,17 @@ class AccountsSettings(Document):
 		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"]
+		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_balance_in_coa: DF.Check
 		show_inclusive_tax_in_print: DF.Check
@@ -67,10 +73,11 @@ class AccountsSettings(Document):
 		submit_journal_entries: DF.Check
 		unlink_advance_payment_on_cancelation_of_order: DF.Check
 		unlink_payment_on_cancellation_of_invoice: DF.Check
-		use_sales_invoice_in_pos: DF.Check
+		use_new_budget_controller: DF.Check
 	# end: auto-generated types
 
 	def validate(self):
+		self.validate_auto_tax_settings()
 		old_doc = self.get_doc_before_save()
 		clear_cache = False
 
@@ -94,9 +101,6 @@ class AccountsSettings(Document):
 		if old_doc.acc_frozen_upto != self.acc_frozen_upto:
 			self.validate_pending_reposts()
 
-		if old_doc.use_sales_invoice_in_pos != self.use_sales_invoice_in_pos:
-			self.validate_invoice_mode_switch_in_pos()
-
 		if clear_cache:
 			frappe.clear_cache()
 
@@ -141,14 +145,20 @@ class AccountsSettings(Document):
 			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_invoice_mode_switch_in_pos(self):
-		pos_opening_entries_count = frappe.db.count(
-			"POS Opening Entry", filters={"docstatus": 1, "status": "Open"}
-		)
-		if pos_opening_entries_count:
+	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(
-				_("{0} can be enabled/disabled after all the POS Opening Entries are closed.").format(
-					frappe.bold(_("Use Sales Invoice"))
+				_("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=_("Switch Invoice Mode Error"),
+				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/test_advance_payment_ledger_entry.py

@@ -2,7 +2,7 @@
 # See license.txt
 
 import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 from frappe.utils import nowdate, today
 
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -89,46 +89,64 @@ class BankClearance(Document):
 
 	@frappe.whitelist()
 	def update_clearance_date(self):
-		clearance_date_updated = False
+		invalid_document = []
+		invalid_cheque_date = []
+		entries_to_update = []
+
+		def validate_entry(d):
+			is_valid = True
+			if not d.payment_document:
+				invalid_document.append(str(d.idx))
+				is_valid = False
+
+			if d.clearance_date and d.cheque_date and getdate(d.clearance_date) < getdate(d.cheque_date):
+				invalid_cheque_date.append(str(d.idx))
+				is_valid = False
+
+			return is_valid
+
 		for d in self.get("payment_entries"):
-			if d.clearance_date:
-				if not d.payment_document:
-					frappe.throw(_("Row #{0}: Payment document is required to complete the transaction"))
-
-				if d.cheque_date and getdate(d.clearance_date) < getdate(d.cheque_date):
-					frappe.throw(
-						_("Row #{0}: For {1} Clearance date {2} cannot be before Cheque Date {3}").format(
-							d.idx,
-							get_link_to_form(d.payment_document, d.payment_entry),
-							d.clearance_date,
-							d.cheque_date,
-						)
-					)
-
-			if d.clearance_date or self.include_reconciled_entries:
+			if validate_entry(d) and (d.clearance_date or self.include_reconciled_entries):
 				if not d.clearance_date:
 					d.clearance_date = None
 
-				if d.payment_document == "Sales Invoice":
-					frappe.db.set_value(
-						"Sales Invoice Payment",
-						{"parent": d.payment_entry, "account": self.get("account"), "amount": [">", 0]},
-						"clearance_date",
-						d.clearance_date,
-					)
+				entries_to_update.append(d)
 
-				else:
-					# using db_set to trigger notification
-					payment_entry = frappe.get_doc(d.payment_document, d.payment_entry)
-					payment_entry.db_set("clearance_date", d.clearance_date)
+		if invalid_document or invalid_cheque_date:
+			msg = _("<p>Please correct the following row(s):</p><ul>")
+			if invalid_document:
+				msg += _("<li>Payment document required for row(s): {0}</li>").format(
+					", ".join(invalid_document)
+				)
 
-				clearance_date_updated = True
+			if invalid_cheque_date:
+				msg += _("<li>Clearance date must be after cheque date for row(s): {0}</li>").format(
+					", ".join(invalid_cheque_date)
+				)
 
-		if clearance_date_updated:
-			self.get_payment_entries()
-			msgprint(_("Clearance Date updated"))
-		else:
+			msg += "</ul>"
+			frappe.throw(_(msg))
+			return
+
+		if not entries_to_update:
 			msgprint(_("Clearance Date not mentioned"))
+			return
+
+		for d in entries_to_update:
+			if d.payment_document == "Sales Invoice":
+				frappe.db.set_value(
+					"Sales Invoice Payment",
+					{"parent": d.payment_entry, "account": self.get("account"), "amount": [">", 0]},
+					"clearance_date",
+					d.clearance_date,
+				)
+			else:
+				# using db_set to trigger notification
+				payment_entry = frappe.get_lazy_doc(d.payment_document, d.payment_entry)
+				payment_entry.db_set("clearance_date", d.clearance_date)
+
+		self.get_payment_entries()
+		msgprint(_("Clearance Date updated"))
 
 
 def get_payment_entries_for_bank_clearance(

erpnext/accounts/doctype/bank_clearance/test_bank_clearance.py

@@ -146,7 +146,7 @@ def make_payment_entry():
 
 	supplier = create_supplier(supplier_name="_Test Supplier")
 	pi = make_purchase_invoice(
-		supplier=supplier,
+		supplier=supplier.name,
 		supplier_warehouse="_Test Warehouse - _TC",
 		expense_account="Cost of Goods Sold - _TC",
 		uom="Nos",

erpnext/accounts/doctype/bank_reconciliation_tool/test_bank_reconciliation_tool.py

@@ -40,7 +40,7 @@ class TestBankReconciliationTool(AccountsTestMixin, IntegrationTestCase):
 				{
 					"doctype": "Bank Account",
 					"account_name": "HDFC _current_",
-					"bank": bank,
+					"bank": bank.name,
 					"is_company_account": True,
 					"account": self.bank,  # account from Chart of Accounts
 				}

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.js

@@ -70,7 +70,7 @@ frappe.ui.form.on("Bank Statement Import", {
 
 		frm.get_field("import_file").df.options = {
 			restrictions: {
-				allowed_file_types: [".csv", ".xls", ".xlsx"],
+				allowed_file_types: [".csv", ".xls", ".xlsx", ".TXT", ".txt"],
 			},
 		};
 
@@ -81,6 +81,7 @@ frappe.ui.form.on("Bank Statement Import", {
 
 	refresh(frm) {
 		frm.page.hide_icon_group();
+		frm.trigger("toggle_mt940_note");
 		frm.trigger("update_indicators");
 		frm.trigger("import_file");
 		frm.trigger("show_import_log");
@@ -192,6 +193,24 @@ frappe.ui.form.on("Bank Statement Import", {
 		});
 	},
 
+	import_mt940_fromat(frm) {
+		frm.trigger("toggle_mt940_note");
+		frm.save();
+	},
+
+	toggle_mt940_note(frm) {
+		if (!frm.doc.import_mt940_fromat) {
+			frm.set_df_property("custom_delimiters", "hidden", 0);
+			frm.set_df_property("google_sheets_url", "hidden", 0);
+			frm.set_df_property("html_5", "hidden", 0);
+		} else {
+			frm.set_df_property("custom_delimiters", "hidden", 1);
+			frm.set_df_property("google_sheets_url", "hidden", 1);
+			frm.set_df_property("html_5", "hidden", 1);
+		}
+		frm.set_value("import_mt940_fromat", frm.doc.import_mt940_fromat);
+	},
+
 	show_report_error_button(frm) {
 		if (frm.doc.status === "Error") {
 			frappe.db
@@ -290,23 +309,45 @@ frappe.ui.form.on("Bank Statement Import", {
 			.html(__("Loading import file..."))
 			.appendTo(frm.get_field("import_preview").$wrapper);
 
-		frm.call({
-			method: "get_preview_from_template",
-			args: {
-				data_import: frm.doc.name,
-				import_file: frm.doc.import_file,
-				google_sheets_url: frm.doc.google_sheets_url,
+		frappe.run_serially([
+			// Convert MT940 to CSV if .txt file
+			() => {
+				if (frm.doc.import_file && frm.doc.import_file.toLowerCase().endsWith(".txt")) {
+					return frm
+						.call({
+							method: "convert_mt940_to_csv",
+							args: {
+								data_import: frm.doc.name,
+								mt940_file_path: frm.doc.import_file,
+							},
+						})
+						.then((r) => {
+							const file_url = r.message;
+							frm.set_value("import_file", file_url);
+							frm.save();
+						});
+				}
 			},
-			error_handlers: {
-				TimestampMismatchError() {
-					// ignore this error
-				},
+			() => {
+				frm.call({
+					method: "get_preview_from_template",
+					args: {
+						data_import: frm.doc.name,
+						import_file: frm.doc.import_file,
+						google_sheets_url: frm.doc.google_sheets_url,
+					},
+					error_handlers: {
+						TimestampMismatchError() {
+							// ignore this error
+						},
+					},
+				}).then((r) => {
+					let preview_data = r.message;
+					frm.events.show_import_preview(frm, preview_data);
+					frm.events.show_import_warnings(frm, preview_data);
+				});
 			},
-		}).then((r) => {
-			let preview_data = r.message;
-			frm.events.show_import_preview(frm, preview_data);
-			frm.events.show_import_warnings(frm, preview_data);
-		});
+		]);
 	},
 	// method: 'frappe.core.doctype.data_import.data_import.get_preview_from_template',
 

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.json

@@ -11,6 +11,7 @@
   "bank_account",
   "bank",
   "column_break_4",
+  "import_mt940_fromat",
   "custom_delimiters",
   "delimiter_options",
   "google_sheets_url",
@@ -20,6 +21,7 @@
   "download_template",
   "status",
   "template_options",
+  "use_csv_sniffer",
   "import_warnings_section",
   "template_warnings",
   "import_warnings",
@@ -207,14 +209,28 @@
    "fieldname": "delimiter_options",
    "fieldtype": "Data",
    "label": "Delimiter options"
+  },
+  {
+   "default": "0",
+   "fieldname": "use_csv_sniffer",
+   "fieldtype": "Check",
+   "hidden": 1,
+   "label": "Use CSV Sniffer"
+  },
+  {
+   "default": "0",
+   "fieldname": "import_mt940_fromat",
+   "fieldtype": "Check",
+   "label": "Import MT940 Fromat"
   }
  ],
  "hide_toolbar": 1,
  "links": [],
- "modified": "2024-06-25 17:32:07.658250",
+ "modified": "2025-06-11 02:23:22.159961",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Statement Import",
+ "naming_rule": "Expression",
  "owner": "Administrator",
  "permissions": [
   {
@@ -230,8 +246,9 @@
    "write": 1
   }
  ],
+ "row_format": "Dynamic",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.py

@@ -3,15 +3,19 @@
 
 
 import csv
+import io
 import json
 import re
+from datetime import date, datetime
 
 import frappe
+import mt940
 import openpyxl
 from frappe import _
 from frappe.core.doctype.data_import.data_import import DataImport
 from frappe.core.doctype.data_import.importer import Importer, ImportFile
 from frappe.utils.background_jobs import enqueue
+from frappe.utils.file_manager import get_file, save_file
 from frappe.utils.xlsxutils import ILLEGAL_CHARACTERS_RE, handle_html
 from openpyxl.styles import Font
 from openpyxl.utils import get_column_letter
@@ -35,6 +39,7 @@ class BankStatementImport(DataImport):
 		delimiter_options: DF.Data | None
 		google_sheets_url: DF.Data | None
 		import_file: DF.Attach | None
+		import_mt940_fromat: DF.Check
 		import_type: DF.Literal["", "Insert New Records", "Update Existing Records"]
 		mute_emails: DF.Check
 		reference_doctype: DF.Link
@@ -43,6 +48,7 @@ class BankStatementImport(DataImport):
 		submit_after_import: DF.Check
 		template_options: DF.Code | None
 		template_warnings: DF.Code | None
+		use_csv_sniffer: DF.Check
 	# end: auto-generated types
 
 	def __init__(self, *args, **kwargs):
@@ -65,8 +71,9 @@ class BankStatementImport(DataImport):
 
 			self.template_warnings = ""
 
-		self.validate_import_file()
-		self.validate_google_sheets_url()
+		if self.import_file and not self.import_file.lower().endswith(".txt"):
+			self.validate_import_file()
+			self.validate_google_sheets_url()
 
 	def start_import(self):
 		preview = frappe.get_doc("Bank Statement Import", self.name).get_preview_from_template(
@@ -79,7 +86,7 @@ class BankStatementImport(DataImport):
 		from frappe.utils.background_jobs import is_job_enqueued
 		from frappe.utils.scheduler import is_scheduler_inactive
 
-		run_now = frappe.flags.in_test or frappe.conf.developer_mode
+		run_now = frappe.in_test or frappe.conf.developer_mode
 		if is_scheduler_inactive() and not run_now:
 			frappe.throw(_("Scheduler is inactive. Cannot import data."), title=_("Scheduler Inactive"))
 
@@ -104,6 +111,68 @@ class BankStatementImport(DataImport):
 		return None
 
 
+@frappe.whitelist()
+def convert_mt940_to_csv(data_import, mt940_file_path):
+	doc = frappe.get_doc("Bank Statement Import", data_import)
+
+	file_doc, content = get_file(mt940_file_path)
+
+	if not is_mt940_format(content):
+		frappe.throw(_("The uploaded file does not appear to be in valid MT940 format."))
+
+	if is_mt940_format(content) and not doc.import_mt940_fromat:
+		frappe.throw(_("MT940 file detected. Please enable 'Import MT940 Format' to proceed."))
+
+	try:
+		transactions = mt940.parse(content)
+	except Exception as e:
+		frappe.throw(_("Failed to parse MT940 format. Error: {0}").format(str(e)))
+
+	if not transactions:
+		frappe.throw(_("Parsed file is not in valid MT940 format or contains no transactions."))
+
+	# Use in-memory file buffer instead of writing to temp file
+	csv_buffer = io.StringIO()
+	writer = csv.writer(csv_buffer)
+
+	headers = ["Date", "Deposit", "Withdrawal", "Description", "Reference Number", "Bank Account", "Currency"]
+	writer.writerow(headers)
+
+	for txn in transactions:
+		txn_date = getattr(txn, "date", None)
+		raw_date = txn.data.get("date", "")
+
+		if txn_date:
+			date_str = txn_date.strftime("%Y-%m-%d")
+		elif isinstance(raw_date, date | datetime):
+			date_str = raw_date.strftime("%Y-%m-%d")
+		else:
+			date_str = str(raw_date)
+
+		raw_amount = str(txn.data.get("amount", ""))
+		parts = raw_amount.strip().split()
+		amount_value = float(parts[0]) if parts else 0.0
+
+		deposit = amount_value if amount_value > 0 else ""
+		withdrawal = abs(amount_value) if amount_value < 0 else ""
+		description = txn.data.get("extra_details") or ""
+		reference = txn.data.get("transaction_reference") or ""
+		currency = txn.data.get("currency", "")
+
+		writer.writerow([date_str, deposit, withdrawal, description, reference, doc.bank_account, currency])
+
+	# Prepare in-memory CSV for upload
+	csv_content = csv_buffer.getvalue().encode("utf-8")
+	csv_buffer.close()
+
+	filename = f"{frappe.utils.now_datetime().strftime('%Y%m%d%H%M%S')}_converted_mt940.csv"
+
+	# Save to File Manager
+	saved_file = save_file(filename, csv_content, doc.doctype, doc.name, is_private=True, df="import_file")
+
+	return saved_file.file_url
+
+
 @frappe.whitelist()
 def get_preview_from_template(data_import, import_file=None, google_sheets_url=None):
 	return frappe.get_doc("Bank Statement Import", data_import).get_preview_from_template(
@@ -128,6 +197,12 @@ def download_import_log(data_import_name):
 	return frappe.get_doc("Bank Statement Import", data_import_name).download_import_log()
 
 
+def is_mt940_format(content: str) -> bool:
+	"""Check if the content has key MT940 tags"""
+	required_tags = [":20:", ":25:", ":28C:", ":61:"]
+	return all(tag in content for tag in required_tags)
+
+
 def parse_data_from_template(raw_data):
 	data = []
 
@@ -279,7 +354,7 @@ def get_import_status(docname):
 
 @frappe.whitelist()
 def get_import_logs(docname: str):
-	frappe.has_permission("Bank Statement Import")
+	frappe.has_permission("Bank Statement Import", throw=True)
 
 	return frappe.get_all(
 		"Data Import Log",

erpnext/accounts/doctype/bank_transaction/auto_match_party.py

@@ -1,6 +1,7 @@
 import frappe
 from frappe.utils import flt
 from rapidfuzz import fuzz, process
+from rapidfuzz.utils import default_process
 
 
 class AutoMatchParty:
@@ -25,7 +26,7 @@ class AutoMatchParty:
 			deposit=self.deposit,
 		).match()
 
-		fuzzy_matching_enabled = frappe.db.get_single_value("Accounts Settings", "enable_fuzzy_matching")
+		fuzzy_matching_enabled = frappe.get_single_value("Accounts Settings", "enable_fuzzy_matching")
 		if not result and fuzzy_matching_enabled:
 			result = AutoMatchbyPartyNameDescription(
 				bank_party_name=self.bank_party_name, description=self.description, deposit=self.deposit
@@ -132,6 +133,7 @@ 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.json

@@ -45,7 +45,6 @@
    "default": "ACC-BTN-.YYYY.-",
    "fieldname": "naming_series",
    "fieldtype": "Select",
-   "hidden": 1,
    "label": "Series",
    "no_copy": 1,
    "options": "ACC-BTN-.YYYY.-",
@@ -236,9 +235,10 @@
    "fieldtype": "Column Break"
   }
  ],
+ "grid_page_length": 50,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-11-18 18:32:47.203694",
+ "modified": "2025-06-18 17:24:57.044666",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Transaction",
@@ -287,9 +287,10 @@
    "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

@@ -121,7 +121,7 @@ class BankTransaction(Document):
 		self.allocate_payment_entries()
 		self.set_status()
 
-		if frappe.db.get_single_value("Accounts Settings", "enable_party_matching"):
+		if frappe.get_single_value("Accounts Settings", "enable_party_matching"):
 			self.auto_set_party()
 
 	def before_update_after_submit(self):

erpnext/accounts/doctype/bank_transaction/test_auto_match_party.py

@@ -2,21 +2,12 @@
 # License: GNU General Public License v3. See license.txt
 
 import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 from frappe.utils import nowdate
 
 from erpnext.accounts.doctype.bank_transaction.test_bank_transaction import create_bank_account
 
 
-class UnitTestBankTransaction(UnitTestCase):
-	"""
-	Unit tests for BankTransaction.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestAutoMatchParty(IntegrationTestCase):
 	@classmethod
 	def setUpClass(cls):

erpnext/accounts/doctype/bank_transaction/test_bank_transaction.py

@@ -6,7 +6,7 @@ import json
 import frappe
 from frappe import utils
 from frappe.model.docstatus import DocStatus
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool import (
 	get_linked_payments,
@@ -24,15 +24,6 @@ from erpnext.tests.utils import if_lending_app_installed
 EXTRA_TEST_RECORD_DEPENDENCIES = ["Item", "Cost Center"]
 
 
-class UnitTestBankTransaction(UnitTestCase):
-	"""
-	Unit tests for BankTransaction.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestBankTransaction(IntegrationTestCase):
 	def setUp(self):
 		make_pos_profile()

erpnext/accounts/doctype/bisect_accounting_statements/test_bisect_accounting_statements.py

@@ -2,16 +2,7 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
-
-
-class UnitTestBisectAccountingStatements(UnitTestCase):
-	"""
-	Unit tests for BisectAccountingStatements.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
+from frappe.tests import IntegrationTestCase
 
 
 class TestBisectAccountingStatements(IntegrationTestCase):

erpnext/accounts/doctype/bisect_nodes/test_bisect_nodes.py

@@ -2,16 +2,7 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
-
-
-class UnitTestBisectNodes(UnitTestCase):
-	"""
-	Unit tests for BisectNodes.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
+from frappe.tests import IntegrationTestCase
 
 
 class TestBisectNodes(IntegrationTestCase):

erpnext/accounts/doctype/budget/budget.js

@@ -23,6 +23,11 @@ frappe.ui.form.on("Budget", {
 		});
 
 		erpnext.accounts.dimensions.setup_dimension_filters(frm, frm.doctype);
+		frappe.db.get_single_value("Accounts Settings", "use_new_budget_controller").then((value) => {
+			if (!value) {
+				frm.get_field("control_action_for_cumulative_expense_section").hide();
+			}
+		});
 	},
 
 	refresh: function (frm) {

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",
@@ -28,6 +28,10 @@
   "applicable_on_booking_actual_expenses",
   "action_if_annual_budget_exceeded",
   "action_if_accumulated_monthly_budget_exceeded",
+  "control_action_for_cumulative_expense_section",
+  "applicable_on_cumulative_expense",
+  "action_if_annual_exceeded_on_cumulative_expense",
+  "action_if_accumulated_monthly_exceeded_on_cumulative_expense",
   "section_break_21",
   "accounts"
  ],
@@ -195,19 +199,46 @@
   },
   {
    "fieldname": "naming_series",
-   "fieldtype": "Data",
-   "hidden": 1,
+   "fieldtype": "Select",
    "label": "Series",
    "no_copy": 1,
+   "options": "BUDGET-.YYYY.-",
    "print_hide": 1,
-   "read_only": 1,
+   "reqd": 1,
    "set_only_once": 1
+  },
+  {
+   "fieldname": "control_action_for_cumulative_expense_section",
+   "fieldtype": "Section Break",
+   "label": "Control Action for Cumulative Expense"
+  },
+  {
+   "default": "0",
+   "description": "(Purchase Order + Material Request + Actual Expense)",
+   "fieldname": "applicable_on_cumulative_expense",
+   "fieldtype": "Check",
+   "label": "Applicable on Cumulative Expense"
+  },
+  {
+   "depends_on": "eval:doc.applicable_on_cumulative_expense == 1",
+   "fieldname": "action_if_annual_exceeded_on_cumulative_expense",
+   "fieldtype": "Select",
+   "label": "Action if Anual Budget Exceeded on Cumulative Expense",
+   "options": "\nStop\nWarn\nIgnore"
+  },
+  {
+   "depends_on": "eval:doc.applicable_on_cumulative_expense == 1",
+   "fieldname": "action_if_accumulated_monthly_exceeded_on_cumulative_expense",
+   "fieldtype": "Select",
+   "label": "Action if Accumulative Monthly Budget Exceeded on Cumulative Expense",
+   "options": "\nStop\nWarn\nIgnore"
   }
  ],
+ "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-03-27 13:06:42.675933",
+ "modified": "2025-06-16 15:57:13.114981",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Budget",
@@ -231,8 +262,9 @@
    "write": 1
   }
  ],
+ "row_format": "Dynamic",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/budget/budget.py

@@ -36,11 +36,14 @@ class Budget(Document):
 		action_if_accumulated_monthly_budget_exceeded: DF.Literal["", "Stop", "Warn", "Ignore"]
 		action_if_accumulated_monthly_budget_exceeded_on_mr: DF.Literal["", "Stop", "Warn", "Ignore"]
 		action_if_accumulated_monthly_budget_exceeded_on_po: DF.Literal["", "Stop", "Warn", "Ignore"]
+		action_if_accumulated_monthly_exceeded_on_cumulative_expense: DF.Literal["", "Stop", "Warn", "Ignore"]
 		action_if_annual_budget_exceeded: DF.Literal["", "Stop", "Warn", "Ignore"]
 		action_if_annual_budget_exceeded_on_mr: DF.Literal["", "Stop", "Warn", "Ignore"]
 		action_if_annual_budget_exceeded_on_po: DF.Literal["", "Stop", "Warn", "Ignore"]
+		action_if_annual_exceeded_on_cumulative_expense: DF.Literal["", "Stop", "Warn", "Ignore"]
 		amended_from: DF.Link | None
 		applicable_on_booking_actual_expenses: DF.Check
+		applicable_on_cumulative_expense: DF.Check
 		applicable_on_material_request: DF.Check
 		applicable_on_purchase_order: DF.Check
 		budget_against: DF.Literal["", "Cost Center", "Project"]
@@ -48,7 +51,7 @@ class Budget(Document):
 		cost_center: DF.Link | None
 		fiscal_year: DF.Link
 		monthly_distribution: DF.Link | None
-		naming_series: DF.Data | None
+		naming_series: DF.Literal["BUDGET-.YYYY.-"]
 		project: DF.Link | None
 	# end: auto-generated types
 
@@ -136,13 +139,10 @@ 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):
+	if not frappe.db.count("Budget", cache=True):
 		return
 
 	if args.get("company") and not args.fiscal_year:
@@ -151,7 +151,7 @@ def validate_expense_against_budget(args, expense_amount=0):
 			"Company", args.get("company"), "exception_budget_approver_role"
 		)
 
-	if not frappe.get_cached_value("Budget", {"fiscal_year": args.fiscal_year, "company": args.company}):  # nosec
+	if not frappe.db.get_value("Budget", {"fiscal_year": args.fiscal_year, "company": args.company}):
 		return
 
 	if not args.account:
@@ -510,7 +510,7 @@ def get_accumulated_monthly_budget(monthly_distribution, posting_date, fiscal_ye
 	accumulated_percentage = 0.0
 
 	while dt <= getdate(posting_date):
-		if monthly_distribution:
+		if monthly_distribution and distribution:
 			accumulated_percentage += distribution.get(getdate(dt).strftime("%B"), 0)
 		else:
 			accumulated_percentage += 100.0 / 12

erpnext/accounts/doctype/budget/test_budget.py

@@ -5,7 +5,11 @@ import unittest
 import frappe
 from frappe.utils import now_datetime, nowdate
 
-from erpnext.accounts.doctype.budget.budget import BudgetError, get_actual_expense
+from erpnext.accounts.doctype.budget.budget import (
+	BudgetError,
+	get_accumulated_monthly_budget,
+	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
@@ -19,6 +23,9 @@ class TestBudget(ERPNextTestSuite):
 		cls.make_monthly_distribution()
 		cls.make_projects()
 
+	def setUp(self):
+		frappe.db.set_single_value("Accounts Settings", "use_new_budget_controller", True)
+
 	def test_monthly_budget_crossed_ignore(self):
 		set_total_expense_zero(nowdate(), "cost_center")
 
@@ -47,10 +54,13 @@ class TestBudget(ERPNextTestSuite):
 
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 
+		accumulated_limit = get_accumulated_monthly_budget(
+			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+		)
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
 			"_Test Bank - _TC",
-			40000,
+			accumulated_limit + 1,
 			"_Test Cost Center - _TC",
 			posting_date=nowdate(),
 		)
@@ -67,10 +77,13 @@ class TestBudget(ERPNextTestSuite):
 
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 
+		accumulated_limit = get_accumulated_monthly_budget(
+			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+		)
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
 			"_Test Bank - _TC",
-			40000,
+			accumulated_limit + 1,
 			"_Test Cost Center - _TC",
 			posting_date=nowdate(),
 		)
@@ -100,6 +113,10 @@ class TestBudget(ERPNextTestSuite):
 		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",
@@ -113,7 +130,7 @@ class TestBudget(ERPNextTestSuite):
 						"uom": "_Test UOM",
 						"warehouse": "_Test Warehouse - _TC",
 						"schedule_date": nowdate(),
-						"rate": 100000,
+						"rate": accumulated_limit + 1,
 						"expense_account": "_Test Account Cost for Goods Sold - _TC",
 						"cost_center": "_Test Cost Center - _TC",
 					}
@@ -127,6 +144,7 @@ class TestBudget(ERPNextTestSuite):
 
 		budget.load_from_db()
 		budget.cancel()
+		mr.cancel()
 
 	def test_monthly_budget_crossed_for_po(self):
 		budget = make_budget(
@@ -139,7 +157,12 @@ class TestBudget(ERPNextTestSuite):
 		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)
 
-		po = create_purchase_order(transaction_date=nowdate(), do_not_submit=True)
+		accumulated_limit = get_accumulated_monthly_budget(
+			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+		)
+		po = create_purchase_order(
+			transaction_date=nowdate(), qty=1, rate=accumulated_limit + 1, do_not_submit=True
+		)
 
 		po.set_missing_values()
 
@@ -157,11 +180,13 @@ class TestBudget(ERPNextTestSuite):
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 
 		project = frappe.get_value("Project", {"project_name": "_Test Project"})
-
+		accumulated_limit = get_accumulated_monthly_budget(
+			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+		)
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
 			"_Test Bank - _TC",
-			40000,
+			accumulated_limit + 1,
 			"_Test Cost Center - _TC",
 			project=project,
 			posting_date=nowdate(),
@@ -276,10 +301,13 @@ class TestBudget(ERPNextTestSuite):
 		budget = make_budget(budget_against="Cost Center", cost_center="_Test Company - _TC")
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 
+		accumulated_limit = get_accumulated_monthly_budget(
+			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+		)
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
 			"_Test Bank - _TC",
-			40000,
+			accumulated_limit + 1,
 			"_Test Cost Center 2 - _TC",
 			posting_date=nowdate(),
 		)
@@ -306,10 +334,13 @@ class TestBudget(ERPNextTestSuite):
 		budget = make_budget(budget_against="Cost Center", cost_center=cost_center)
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 
+		accumulated_limit = get_accumulated_monthly_budget(
+			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+		)
 		jv = make_journal_entry(
 			"_Test Account Cost for Goods Sold - _TC",
 			"_Test Bank - _TC",
-			40000,
+			accumulated_limit + 1,
 			cost_center,
 			posting_date=nowdate(),
 		)
@@ -353,6 +384,44 @@ class TestBudget(ERPNextTestSuite):
 
 		self.assertRaises(BudgetError, jv.submit)
 
+	def test_action_for_cumulative_limit(self):
+		set_total_expense_zero(nowdate(), "cost_center")
+
+		budget = make_budget(budget_against="Cost Center", applicable_on_cumulative_expense=True)
+
+		accumulated_limit = get_accumulated_monthly_budget(
+			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
+		)
+
+		jv = make_journal_entry(
+			"_Test Account Cost for Goods Sold - _TC",
+			"_Test Bank - _TC",
+			accumulated_limit - 1,
+			"_Test Cost Center - _TC",
+			posting_date=nowdate(),
+		)
+		jv.submit()
+
+		frappe.db.set_value(
+			"Budget", budget.name, "action_if_accumulated_monthly_exceeded_on_cumulative_expense", "Stop"
+		)
+		po = create_purchase_order(
+			transaction_date=nowdate(), qty=1, rate=accumulated_limit + 1, do_not_submit=True
+		)
+		po.set_missing_values()
+
+		self.assertRaises(BudgetError, po.submit)
+
+		frappe.db.set_value(
+			"Budget", budget.name, "action_if_accumulated_monthly_exceeded_on_cumulative_expense", "Ignore"
+		)
+		po.submit()
+
+		budget.load_from_db()
+		budget.cancel()
+		po.cancel()
+		jv.cancel()
+
 
 def set_total_expense_zero(posting_date, budget_against_field=None, budget_against_CC=None):
 	if budget_against_field == "project":
@@ -427,6 +496,7 @@ def make_budget(**args):
 
 	monthly_distribution = frappe.get_doc("Monthly Distribution", "_Test Distribution")
 	monthly_distribution.fiscal_year = fiscal_year
+	monthly_distribution.save()
 
 	budget.fiscal_year = fiscal_year
 	budget.monthly_distribution = "_Test Distribution"
@@ -451,6 +521,15 @@ def make_budget(**args):
 			args.action_if_accumulated_monthly_budget_exceeded_on_po or "Warn"
 		)
 
+	if args.applicable_on_cumulative_expense:
+		budget.applicable_on_cumulative_expense = 1
+		budget.action_if_annual_exceeded_on_cumulative_expense = (
+			args.action_if_annual_exceeded_on_cumulative_expense or "Warn"
+		)
+		budget.action_if_accumulated_monthly_exceeded_on_cumulative_expense = (
+			args.action_if_accumulated_monthly_exceeded_on_cumulative_expense or "Warn"
+		)
+
 	budget.insert()
 	budget.submit()
 

erpnext/accounts/doctype/cost_center_allocation/cost_center_allocation.py

@@ -154,3 +154,7 @@ class CostCenterAllocation(Document):
 					).format(d.cost_center),
 					InvalidChildCostCenter,
 				)
+
+	def clear_cache(self):
+		frappe.clear_cache(doctype="Cost Center")
+		return super().clear_cache()

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.py

@@ -36,7 +36,7 @@ class CurrencyExchangeSettings(Document):
 
 	def validate(self):
 		self.set_parameters_and_result()
-		if frappe.flags.in_test or frappe.flags.in_install or frappe.flags.in_setup_wizard:
+		if frappe.in_test or frappe.flags.in_install or frappe.flags.in_setup_wizard:
 			return
 		response, value = self.validate_parameters()
 		self.validate_result(response, value)

erpnext/accounts/doctype/dunning/test_dunning.py

@@ -4,7 +4,7 @@ import json
 
 import frappe
 from frappe.model import mapper
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, nowdate, today
 
 from erpnext import get_default_cost_center
@@ -22,15 +22,6 @@ from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import (
 EXTRA_TEST_RECORD_DEPENDENCIES = ["Company", "Cost Center"]
 
 
-class UnitTestDunning(UnitTestCase):
-	"""
-	Unit tests for Dunning.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestDunning(IntegrationTestCase):
 	@classmethod
 	def setUpClass(cls):

erpnext/accounts/doctype/fiscal_year/fiscal_year.py

@@ -123,7 +123,7 @@ def check_duplicate_fiscal_year(doc):
 	)
 	for fiscal_year, ysd, yed in year_start_end_dates:
 		if (getdate(doc.year_start_date) == ysd and getdate(doc.year_end_date) == yed) and (
-			not frappe.flags.in_test
+			not frappe.in_test
 		):
 			frappe.throw(
 				_(

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 flt, fmt_money, now
+from frappe.utils import create_batch, flt, fmt_money, now
 
 import erpnext
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
@@ -451,12 +451,20 @@ 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)
-	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, modified = %s where name = %s",
-			(newname, now(), oldname),
-			auto_commit=True,
-		)
+	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()

erpnext/accounts/doctype/item_tax_template/item_tax_template.py

@@ -39,7 +39,16 @@ class ItemTaxTemplate(Document):
 		check_list = []
 		for d in self.get("taxes"):
 			if d.tax_type:
-				account_type = frappe.get_cached_value("Account", d.tax_type, "account_type")
+				account_type, account_company = frappe.get_cached_value(
+					"Account", d.tax_type, ["account_type", "company"]
+				)
+
+				if account_company != self.company:
+					frappe.throw(
+						_("Item Tax Row {0}: Account must belong to Company - {1}").format(
+							d.idx, frappe.bold(self.company)
+						)
+					)
 
 				if account_type not in [
 					"Tax",

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -20,6 +20,39 @@ frappe.ui.form.on("Journal Entry", {
 			"Unreconcile Payment Entries",
 			"Bank Transaction",
 		];
+
+		frm.trigger("set_queries");
+	},
+
+	set_queries(frm) {
+		frm.set_query("periodic_entry_difference_account", function () {
+			return {
+				filters: {
+					is_group: 0,
+					company: frm.doc.company,
+				},
+			};
+		});
+
+		frm.set_query("stock_asset_account", function () {
+			return {
+				filters: {
+					is_group: 0,
+					account_type: "Stock",
+					company: frm.doc.company,
+				},
+			};
+		});
+	},
+
+	get_balance_for_periodic_accounting(frm) {
+		frm.call({
+			method: "get_balance_for_periodic_accounting",
+			doc: frm.doc,
+			callback: function (r) {
+				refresh_field("accounts");
+			},
+		});
 	},
 
 	refresh: function (frm) {

erpnext/accounts/doctype/journal_entry/journal_entry.json

@@ -13,15 +13,21 @@
   "title",
   "voucher_type",
   "naming_series",
-  "finance_book",
   "process_deferred_accounting",
   "reversal_of",
-  "tax_withholding_category",
   "column_break1",
   "from_template",
   "company",
   "posting_date",
+  "finance_book",
   "apply_tds",
+  "tax_withholding_category",
+  "section_break_tcvw",
+  "for_all_stock_asset_accounts",
+  "column_break_wpau",
+  "stock_asset_account",
+  "periodic_entry_difference_account",
+  "get_balance_for_periodic_accounting",
   "2_add_edit_gl_entries",
   "accounts",
   "section_break99",
@@ -40,7 +46,6 @@
   "reference",
   "clearance_date",
   "remark",
-  "paid_loan",
   "inter_company_journal_entry_reference",
   "column_break98",
   "bill_no",
@@ -89,7 +94,7 @@
    "label": "Entry Type",
    "oldfieldname": "voucher_type",
    "oldfieldtype": "Select",
-   "options": "Journal Entry\nInter Company Journal Entry\nBank Entry\nCash Entry\nCredit Card Entry\nDebit Note\nCredit Note\nContra Entry\nExcise Entry\nWrite Off Entry\nOpening Entry\nDepreciation Entry\nAsset Disposal\nExchange Rate Revaluation\nExchange Gain Or Loss\nDeferred Revenue\nDeferred Expense",
+   "options": "Journal Entry\nInter Company Journal Entry\nBank Entry\nCash Entry\nCredit Card Entry\nDebit Note\nCredit Note\nContra Entry\nExcise Entry\nWrite Off Entry\nOpening Entry\nDepreciation Entry\nAsset Disposal\nPeriodic Accounting Entry\nExchange Rate Revaluation\nExchange Gain Or Loss\nDeferred Revenue\nDeferred Expense",
    "reqd": 1,
    "search_index": 1
   },
@@ -304,13 +309,6 @@
    "oldfieldtype": "Small Text",
    "read_only": 1
   },
-  {
-   "fieldname": "paid_loan",
-   "fieldtype": "Data",
-   "hidden": 1,
-   "label": "Paid Loan",
-   "print_hide": 1
-  },
   {
    "depends_on": "eval:doc.voucher_type== \"Inter Company Journal Entry\"",
    "fieldname": "inter_company_journal_entry_reference",
@@ -543,6 +541,42 @@
    "label": "Is System Generated",
    "no_copy": 1,
    "read_only": 1
+  },
+  {
+   "depends_on": "eval:doc.voucher_type === \"Periodic Accounting Entry\"",
+   "fieldname": "periodic_entry_difference_account",
+   "fieldtype": "Link",
+   "label": "Periodic Entry Difference Account",
+   "mandatory_depends_on": "eval:doc.voucher_type === \"Periodic Accounting Entry\"",
+   "options": "Account"
+  },
+  {
+   "depends_on": "eval:doc.voucher_type === \"Periodic Accounting Entry\"",
+   "fieldname": "section_break_tcvw",
+   "fieldtype": "Section Break",
+   "label": "Periodic Accounting"
+  },
+  {
+   "default": "1",
+   "fieldname": "for_all_stock_asset_accounts",
+   "fieldtype": "Check",
+   "label": "For All Stock Asset Accounts"
+  },
+  {
+   "depends_on": "eval:doc.for_all_stock_asset_accounts === 0",
+   "fieldname": "stock_asset_account",
+   "fieldtype": "Link",
+   "label": "Stock Asset Account",
+   "options": "Account"
+  },
+  {
+   "fieldname": "column_break_wpau",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "get_balance_for_periodic_accounting",
+   "fieldtype": "Button",
+   "label": "Get Balance"
   }
  ],
  "icon": "fa fa-file-text",
@@ -557,7 +591,7 @@
    "table_fieldname": "payment_entries"
   }
  ],
- "modified": "2024-12-26 15:32:20.730666",
+ "modified": "2025-07-06 15:22:58.465131",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry",
@@ -602,10 +636,11 @@
    "role": "Auditor"
   }
  ],
+ "row_format": "Dynamic",
  "search_fields": "voucher_type,posting_date, due_date, cheque_no",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "title_field": "title",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -24,6 +24,7 @@ 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,
@@ -62,6 +63,7 @@ class JournalEntry(AccountsController):
 		difference: DF.Currency
 		due_date: DF.Date | None
 		finance_book: DF.Link | None
+		for_all_stock_asset_accounts: DF.Check
 		from_template: DF.Link | None
 		inter_company_journal_entry_reference: DF.Link | None
 		is_opening: DF.Literal["No", "Yes"]
@@ -70,14 +72,15 @@ class JournalEntry(AccountsController):
 		mode_of_payment: DF.Link | None
 		multi_currency: DF.Check
 		naming_series: DF.Literal["ACC-JV-.YYYY.-"]
-		paid_loan: DF.Data | None
 		pay_to_recd_from: DF.Data | None
 		payment_order: DF.Link | None
+		periodic_entry_difference_account: DF.Link | None
 		posting_date: DF.Date
 		process_deferred_accounting: DF.Link | None
 		remark: DF.SmallText | None
 		reversal_of: DF.Link | None
 		select_print_heading: DF.Link | None
+		stock_asset_account: DF.Link | None
 		stock_entry: DF.Link | None
 		tax_withholding_category: DF.Link | None
 		title: DF.Data | None
@@ -101,6 +104,7 @@ class JournalEntry(AccountsController):
 			"Opening Entry",
 			"Depreciation Entry",
 			"Asset Disposal",
+			"Periodic Accounting Entry",
 			"Exchange Rate Revaluation",
 			"Exchange Gain Or Loss",
 			"Deferred Revenue",
@@ -147,8 +151,7 @@ class JournalEntry(AccountsController):
 
 		if self.docstatus == 0:
 			self.apply_tax_withholding()
-
-		if not self.title:
+		if self.is_new() or not self.title:
 			self.title = self.get_title()
 
 	def validate_advance_accounts(self):
@@ -198,6 +201,76 @@ class JournalEntry(AccountsController):
 		self.update_inter_company_jv()
 		self.update_invoice_discounting()
 
+	@frappe.whitelist()
+	def get_balance_for_periodic_accounting(self):
+		self.validate_company_for_periodic_accounting()
+
+		stock_accounts = self.get_stock_accounts_for_periodic_accounting()
+		self.set("accounts", [])
+		for account in stock_accounts:
+			account_bal, stock_bal, warehouse_list = get_stock_and_account_balance(
+				account, self.posting_date, self.company
+			)
+
+			difference_value = flt(stock_bal - account_bal, self.precision("difference"))
+
+			if difference_value == 0:
+				frappe.msgprint(
+					_("No difference found for stock account {0}").format(frappe.bold(account)),
+					alert=True,
+				)
+				continue
+
+			self.append(
+				"accounts",
+				{
+					"account": account,
+					"debit_in_account_currency": difference_value if difference_value > 0 else 0,
+					"credit_in_account_currency": abs(difference_value) if difference_value < 0 else 0,
+				},
+			)
+
+			self.append(
+				"accounts",
+				{
+					"account": self.periodic_entry_difference_account,
+					"credit_in_account_currency": difference_value if difference_value > 0 else 0,
+					"debit_in_account_currency": abs(difference_value) if difference_value < 0 else 0,
+				},
+			)
+
+	def validate_company_for_periodic_accounting(self):
+		if erpnext.is_perpetual_inventory_enabled(self.company):
+			frappe.throw(
+				_(
+					"Periodic Accounting Entry is not allowed for company {0} with perpetual inventory enabled"
+				).format(self.company)
+			)
+
+		if not self.periodic_entry_difference_account:
+			frappe.throw(_("Please select Periodic Accounting Entry Difference Account"))
+
+	def get_stock_accounts_for_periodic_accounting(self):
+		if self.voucher_type != "Periodic Accounting Entry":
+			return []
+
+		if self.for_all_stock_asset_accounts:
+			return frappe.get_all(
+				"Account",
+				filters={
+					"company": self.company,
+					"account_type": "Stock",
+					"root_type": "Asset",
+					"is_group": 0,
+				},
+				pluck="name",
+			)
+
+		if not self.stock_asset_account:
+			frappe.throw(_("Please select Stock Asset Account"))
+
+		return [self.stock_asset_account]
+
 	def on_update_after_submit(self):
 		# Flag will be set on Reconciliation
 		# Reconciliation tool will anyways repost ledger entries. So, no need to check and do implicit repost.
@@ -238,9 +311,7 @@ class JournalEntry(AccountsController):
 
 	def update_advance_paid(self):
 		advance_paid = frappe._dict()
-		advance_payment_doctypes = frappe.get_hooks("advance_payment_receivable_doctypes") + frappe.get_hooks(
-			"advance_payment_payable_doctypes"
-		)
+		advance_payment_doctypes = get_advance_payment_doctypes()
 		for d in self.get("accounts"):
 			if d.is_advance:
 				if d.reference_type in advance_payment_doctypes:
@@ -280,6 +351,10 @@ class JournalEntry(AccountsController):
 					frappe.throw(_("Account {0} should be of type Expense").format(d.account))
 
 	def validate_stock_accounts(self):
+		if self.voucher_type == "Periodic Accounting Entry":
+			# Skip validation for periodic accounting entry
+			return
+
 		stock_accounts = get_stock_accounts(self.company, accounts=self.accounts)
 		for account in stock_accounts:
 			account_bal, stock_bal, warehouse_list = get_stock_and_account_balance(
@@ -1171,7 +1246,7 @@ class JournalEntry(AccountsController):
 	def make_gl_entries(self, cancel=0, adv_adj=0):
 		from erpnext.accounts.general_ledger import make_gl_entries
 
-		merge_entries = frappe.db.get_single_value("Accounts Settings", "merge_similar_account_heads")
+		merge_entries = frappe.get_single_value("Accounts Settings", "merge_similar_account_heads")
 
 		gl_map = self.build_gl_map()
 		if self.voucher_type in ("Deferred Revenue", "Deferred Expense"):
@@ -1296,7 +1371,9 @@ class JournalEntry(AccountsController):
 
 
 @frappe.whitelist()
-def get_default_bank_cash_account(company, account_type=None, mode_of_payment=None, account=None):
+def get_default_bank_cash_account(
+	company, account_type=None, mode_of_payment=None, account=None, *, fetch_balance=True
+):
 	from erpnext.accounts.doctype.sales_invoice.sales_invoice import get_bank_cash_account
 
 	if mode_of_payment:
@@ -1330,15 +1407,14 @@ def get_default_bank_cash_account(company, account_type=None, mode_of_payment=No
 		account_details = frappe.get_cached_value(
 			"Account", account, ["account_currency", "account_type"], as_dict=1
 		)
-
-		return frappe._dict(
-			{
-				"account": account,
-				"balance": get_balance_on(account),
-				"account_currency": account_details.account_currency,
-				"account_type": account_details.account_type,
-			}
-		)
+		result = {
+			"account": account,
+			"account_currency": account_details.account_currency,
+			"account_type": account_details.account_type,
+		}
+		if fetch_balance:
+			result["balance"] = get_balance_on(account)
+		return frappe._dict(result)
 	else:
 		return frappe._dict()
 

erpnext/accounts/doctype/journal_entry/test_journal_entry.py

@@ -2,7 +2,7 @@
 # License: GNU General Public License v3. See license.txt
 
 import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 from frappe.utils import flt, nowdate
 
 from erpnext.accounts.doctype.account.test_account import get_inventory_account
@@ -10,15 +10,6 @@ from erpnext.accounts.doctype.journal_entry.journal_entry import StockAccountInv
 from erpnext.exceptions import InvalidAccountCurrency
 
 
-class UnitTestJournalEntry(UnitTestCase):
-	"""
-	Unit tests for JournalEntry.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestJournalEntry(IntegrationTestCase):
 	@IntegrationTestCase.change_settings(
 		"Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1}
@@ -588,6 +579,18 @@ class TestJournalEntry(IntegrationTestCase):
 		]
 		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 make_journal_entry(
 	account1,

erpnext/accounts/doctype/ledger_health_monitor/test_ledger_health_monitor.py

@@ -2,16 +2,7 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
-
-
-class UnitTestLedgerHealthMonitor(UnitTestCase):
-	"""
-	Unit tests for LedgerHealthMonitor.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
+from frappe.tests import IntegrationTestCase
 
 
 class TestLedgerHealthMonitor(IntegrationTestCase):

erpnext/accounts/doctype/ledger_merge/ledger_merge.py

@@ -35,7 +35,7 @@ class LedgerMerge(Document):
 		from frappe.utils.background_jobs import enqueue
 		from frappe.utils.scheduler import is_scheduler_inactive
 
-		if is_scheduler_inactive() and not frappe.flags.in_test:
+		if is_scheduler_inactive() and not frappe.in_test:
 			frappe.throw(_("Scheduler is inactive. Cannot merge accounts."), title=_("Scheduler Inactive"))
 
 		job_id = f"ledger_merge::{self.name}"
@@ -47,7 +47,7 @@ class LedgerMerge(Document):
 				event="ledger_merge",
 				job_id=job_id,
 				docname=self.name,
-				now=frappe.conf.developer_mode or frappe.flags.in_test,
+				now=frappe.conf.developer_mode or frappe.in_test,
 			)
 			return True
 

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py

@@ -229,7 +229,7 @@ class OpeningInvoiceCreationTool(Document):
 		else:
 			from frappe.utils.scheduler import is_scheduler_inactive
 
-			if is_scheduler_inactive() and not frappe.flags.in_test:
+			if is_scheduler_inactive() and not frappe.in_test:
 				frappe.throw(_("Scheduler is inactive. Cannot import data."), title=_("Scheduler Inactive"))
 
 			job_id = f"opening_invoice::{self.name}"
@@ -242,7 +242,7 @@ class OpeningInvoiceCreationTool(Document):
 					event="opening_invoice_creation",
 					job_id=job_id,
 					invoices=invoices,
-					now=frappe.conf.developer_mode or frappe.flags.in_test,
+					now=frappe.conf.developer_mode or frappe.in_test,
 				)
 
 

erpnext/accounts/doctype/opening_invoice_creation_tool/test_opening_invoice_creation_tool.py

@@ -2,7 +2,7 @@
 # See license.txt
 
 import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension import (
 	create_dimension,
@@ -15,15 +15,6 @@ from erpnext.accounts.doctype.opening_invoice_creation_tool.opening_invoice_crea
 EXTRA_TEST_RECORD_DEPENDENCIES = ["Customer", "Supplier", "Accounting Dimension"]
 
 
-class UnitTestOpeningInvoiceCreationTool(UnitTestCase):
-	"""
-	Unit tests for OpeningInvoiceCreationTool.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestOpeningInvoiceCreationTool(IntegrationTestCase):
 	@classmethod
 	def setUpClass(cls):

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -46,8 +46,9 @@ from erpnext.accounts.party import (
 from erpnext.accounts.utils import (
 	cancel_exchange_gain_loss_journal,
 	get_account_currency,
-	get_balance_on,
+	get_advance_payment_doctypes,
 	get_outstanding_invoices,
+	get_reconciliation_effect_date,
 )
 from erpnext.controllers.accounts_controller import (
 	AccountsController,
@@ -499,7 +500,7 @@ class PaymentEntry(AccountsController):
 	def delink_advance_entry_references(self):
 		for reference in self.references:
 			if reference.reference_doctype in ("Sales Invoice", "Purchase Invoice"):
-				doc = frappe.get_doc(reference.reference_doctype, reference.reference_name)
+				doc = frappe.get_lazy_doc(reference.reference_doctype, reference.reference_name)
 				doc.delink_advance_entries(self.name)
 
 	def set_missing_values(self):
@@ -640,7 +641,7 @@ class PaymentEntry(AccountsController):
 	def validate_mandatory(self):
 		for field in ("paid_amount", "received_amount", "source_exchange_rate", "target_exchange_rate"):
 			if not self.get(field):
-				frappe.throw(_("{0} is mandatory").format(self.meta.get_label(field)))
+				frappe.throw(_("{0} is mandatory").format(_(self.meta.get_label(field))))
 
 	def validate_reference_documents(self):
 		valid_reference_doctypes = self.get_valid_reference_doctypes()
@@ -662,7 +663,7 @@ class PaymentEntry(AccountsController):
 				if not frappe.db.exists(d.reference_doctype, d.reference_name):
 					frappe.throw(_("{0} {1} does not exist").format(d.reference_doctype, d.reference_name))
 
-				ref_doc = frappe.get_doc(d.reference_doctype, d.reference_name)
+				ref_doc = frappe.get_lazy_doc(d.reference_doctype, d.reference_name)
 
 				if d.reference_doctype != "Journal Entry":
 					if self.party != ref_doc.get(scrub(self.party_type)):
@@ -1100,10 +1101,7 @@ class PaymentEntry(AccountsController):
 
 	def calculate_base_allocated_amount_for_reference(self, d) -> float:
 		base_allocated_amount = 0
-		advance_payment_doctypes = frappe.get_hooks("advance_payment_receivable_doctypes") + frappe.get_hooks(
-			"advance_payment_payable_doctypes"
-		)
-		if d.reference_doctype in advance_payment_doctypes:
+		if d.reference_doctype in get_advance_payment_doctypes():
 			# When referencing Sales/Purchase Order, use the source/target exchange rate depending on payment type.
 			# This is so there are no Exchange Gain/Loss generated for such doctypes
 
@@ -1385,10 +1383,7 @@ class PaymentEntry(AccountsController):
 		if not self.party_account:
 			return
 
-		advance_payment_doctypes = frappe.get_hooks("advance_payment_receivable_doctypes") + frappe.get_hooks(
-			"advance_payment_payable_doctypes"
-		)
-
+		advance_payment_doctypes = get_advance_payment_doctypes()
 		if self.payment_type == "Receive":
 			against_account = self.paid_to
 		else:
@@ -1571,23 +1566,7 @@ class PaymentEntry(AccountsController):
 		else:
 			# For backwards compatibility
 			# Supporting reposting on payment entries reconciled before select field introduction
-			reconciliation_takes_effect_on = frappe.get_cached_value(
-				"Company", self.company, "reconciliation_takes_effect_on"
-			)
-			if reconciliation_takes_effect_on == "Advance Payment Date":
-				posting_date = self.posting_date
-			elif reconciliation_takes_effect_on == "Oldest Of Invoice Or Advance":
-				date_field = "posting_date"
-				if invoice.reference_doctype in ["Sales Order", "Purchase Order"]:
-					date_field = "transaction_date"
-				posting_date = frappe.db.get_value(
-					invoice.reference_doctype, invoice.reference_name, date_field
-				)
-
-				if getdate(posting_date) < getdate(self.posting_date):
-					posting_date = self.posting_date
-			elif reconciliation_takes_effect_on == "Reconciliation Date":
-				posting_date = nowdate()
+			posting_date = get_reconciliation_effect_date(invoice, self.company, self.posting_date)
 			frappe.db.set_value("Payment Entry Reference", invoice.name, "reconcile_effect_on", posting_date)
 
 		dr_or_cr, account = self.get_dr_and_account_for_advances(invoice)
@@ -1781,12 +1760,10 @@ class PaymentEntry(AccountsController):
 		if self.payment_type not in ("Receive", "Pay") or not self.party:
 			return
 
-		advance_payment_doctypes = frappe.get_hooks("advance_payment_receivable_doctypes") + frappe.get_hooks(
-			"advance_payment_payable_doctypes"
-		)
+		advance_payment_doctypes = get_advance_payment_doctypes()
 		for d in self.get("references"):
 			if d.allocated_amount and d.reference_doctype in advance_payment_doctypes:
-				frappe.get_doc(
+				frappe.get_lazy_doc(
 					d.reference_doctype, d.reference_name, for_update=True
 				).set_total_advance_paid()
 
@@ -2786,7 +2763,6 @@ def get_party_details(company, party_type, party, date, cost_center=None):
 
 	party_account = get_party_account(party_type, party, company)
 	account_currency = get_account_currency(party_account)
-	account_balance = get_balance_on(party_account, date, cost_center=cost_center)
 	_party_name = "title" if party_type == "Shareholder" else party_type.lower() + "_name"
 	party_name = frappe.db.get_value(party_type, party, _party_name)
 
@@ -2798,7 +2774,6 @@ def get_party_details(company, party_type, party, date, cost_center=None):
 		"party_account": party_account,
 		"party_name": party_name,
 		"party_account_currency": account_currency,
-		"account_balance": account_balance,
 		"party_bank_account": party_bank_account,
 		"bank_account": bank_account,
 	}
@@ -2816,12 +2791,9 @@ def get_account_details(account, date, cost_center=None):
 	if not account_list:
 		frappe.throw(_("Account: {0} is not permitted under Payment Entry").format(account))
 
-	account_balance = get_balance_on(account, date, cost_center=cost_center, ignore_account_permission=True)
-
 	return frappe._dict(
 		{
 			"account_currency": get_account_currency(account),
-			"account_balance": account_balance,
 			"account_type": frappe.get_cached_value("Account", account, "account_type"),
 		}
 	)
@@ -2871,7 +2843,7 @@ def get_reference_details(
 ):
 	total_amount = outstanding_amount = exchange_rate = account = None
 
-	ref_doc = frappe.get_doc(reference_doctype, reference_name)
+	ref_doc = frappe.get_lazy_doc(reference_doctype, reference_name)
 	company_currency = ref_doc.get("company_currency") or erpnext.get_company_currency(ref_doc.company)
 
 	# Only applies for Reverse Payment Entries
@@ -2969,7 +2941,7 @@ def get_payment_entry(
 	created_from_payment_request=False,
 ):
 	doc = frappe.get_doc(dt, dn)
-	over_billing_allowance = frappe.db.get_single_value("Accounts Settings", "over_billing_allowance")
+	over_billing_allowance = frappe.get_single_value("Accounts Settings", "over_billing_allowance")
 	if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) >= (100.0 + over_billing_allowance):
 		frappe.throw(_("Can only make payment against unbilled {0}").format(_(dt)))
 
@@ -3109,7 +3081,7 @@ def get_payment_entry(
 	if party_account and bank:
 		if discount_amount:
 			base_total_discount_loss = 0
-			if frappe.db.get_single_value("Accounts Settings", "book_tax_discount_loss"):
+			if frappe.get_single_value("Accounts Settings", "book_tax_discount_loss"):
 				base_total_discount_loss = split_early_payment_discount_loss(pe, doc, valid_discounts)
 
 			set_pending_discount_loss(
@@ -3311,11 +3283,16 @@ def get_bank_cash_account(doc, bank_account):
 		"Bank",
 		mode_of_payment=doc.get("mode_of_payment"),
 		account=bank_account,
+		fetch_balance=False,
 	)
 
 	if not bank:
 		bank = get_default_bank_cash_account(
-			doc.company, "Cash", mode_of_payment=doc.get("mode_of_payment"), account=bank_account
+			doc.company,
+			"Cash",
+			mode_of_payment=doc.get("mode_of_payment"),
+			account=bank_account,
+			fetch_balance=False,
 		)
 
 	return bank
@@ -3463,7 +3440,7 @@ def set_pending_discount_loss(pe, doc, discount_amount, base_total_discount_loss
 
 		# If tax loss booking is enabled, pending loss will be rounding loss.
 		# Otherwise it will be the total discount loss.
-		book_tax_loss = frappe.db.get_single_value("Accounts Settings", "book_tax_discount_loss")
+		book_tax_loss = frappe.get_single_value("Accounts Settings", "book_tax_discount_loss")
 		account_type = "round_off_account" if book_tax_loss else "default_discount_account"
 
 		pe.append(

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -4,7 +4,7 @@
 
 import frappe
 from frappe import qb
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, flt, nowdate
 
 from erpnext.accounts.doctype.account.test_account import create_account
@@ -28,15 +28,6 @@ from erpnext.setup.doctype.employee.test_employee import make_employee
 EXTRA_TEST_RECORD_DEPENDENCIES = ["Item", "Currency Exchange"]
 
 
-class UnitTestPaymentEntry(UnitTestCase):
-	"""
-	Unit tests for PaymentEntry.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestPaymentEntry(IntegrationTestCase):
 	def tearDown(self):
 		frappe.db.rollback()

erpnext/accounts/doctype/payment_ledger_entry/test_payment_ledger_entry.py

@@ -3,7 +3,7 @@
 
 import frappe
 from frappe import qb
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 from frappe.utils import nowdate
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
@@ -13,15 +13,6 @@ from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_orde
 from erpnext.stock.doctype.item.test_item import create_item
 
 
-class UnitTestPaymentLedgerEntry(UnitTestCase):
-	"""
-	Unit tests for PaymentLedgerEntry.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestPaymentLedgerEntry(IntegrationTestCase):
 	def setUp(self):
 		self.ple = qb.DocType("Payment Ledger Entry")

erpnext/accounts/doctype/payment_order/test_payment_order.py

@@ -3,7 +3,7 @@
 
 
 import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 from frappe.utils import getdate
 
 from erpnext.accounts.doctype.bank_transaction.test_bank_transaction import (
@@ -17,15 +17,6 @@ from erpnext.accounts.doctype.payment_entry.payment_entry import (
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 
 
-class UnitTestPaymentOrder(UnitTestCase):
-	"""
-	Unit tests for PaymentOrder.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestPaymentOrder(IntegrationTestCase):
 	def setUp(self):
 		# generate and use a uniq hash identifier for 'Bank Account' and it's linked GL 'Account' to avoid validation error

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -407,7 +407,7 @@ class PaymentReconciliation(Document):
 
 	@frappe.whitelist()
 	def is_auto_process_enabled(self):
-		return frappe.db.get_single_value("Accounts Settings", "auto_reconcile_payments")
+		return frappe.get_single_value("Accounts Settings", "auto_reconcile_payments")
 
 	@frappe.whitelist()
 	def calculate_difference_on_allocation_change(self, payment_entry, invoice, allocated_amount):
@@ -532,7 +532,7 @@ class PaymentReconciliation(Document):
 
 	@frappe.whitelist()
 	def reconcile(self):
-		if frappe.db.get_single_value("Accounts Settings", "auto_reconcile_payments"):
+		if frappe.get_single_value("Accounts Settings", "auto_reconcile_payments"):
 			running_doc = is_any_doc_running(
 				dict(
 					company=self.company,
@@ -589,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"):
@@ -826,7 +826,7 @@ def reconcile_dr_cr_note(dr_cr_notes, company, active_dimensions=None):
 
 			create_gain_loss_journal(
 				company,
-				today(),
+				inv.difference_posting_date,
 				inv.party_type,
 				inv.party,
 				inv.account,

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -4,7 +4,7 @@
 
 import frappe
 from frappe import qb
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, add_years, flt, getdate, nowdate, today
 from frappe.utils.data import getdate as convert_to_date
 
@@ -21,15 +21,6 @@ from erpnext.stock.doctype.item.test_item import create_item
 EXTRA_TEST_RECORD_DEPENDENCIES = ["Item"]
 
 
-class UnitTestPaymentReconciliation(UnitTestCase):
-	"""
-	Unit tests for PaymentReconciliation.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestPaymentReconciliation(IntegrationTestCase):
 	def setUp(self):
 		self.create_company()
@@ -1988,7 +1979,9 @@ class TestPaymentReconciliation(IntegrationTestCase):
 
 	def test_reconciliation_on_closed_period_payment(self):
 		# create backdated fiscal year
-		first_fy_start_date = frappe.db.get_value("Fiscal Year", {"disabled": 0}, "min(year_start_date)")
+		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(

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -16,7 +16,7 @@ from erpnext.accounts.doctype.payment_entry.payment_entry import (
 )
 from erpnext.accounts.doctype.subscription_plan.subscription_plan import get_plan_rate
 from erpnext.accounts.party import get_party_account, get_party_bank_account
-from erpnext.accounts.utils import get_account_currency, get_currency_precision
+from erpnext.accounts.utils import get_account_currency, get_advance_payment_doctypes, get_currency_precision
 from erpnext.utilities import payment_app_import_guard
 
 ALLOWED_DOCTYPES_FOR_PAYMENT_REQUEST = [
@@ -464,10 +464,7 @@ class PaymentRequest(Document):
 			return create_stripe_subscription(gateway_controller, data)
 
 	def update_reference_advance_payment_status(self):
-		advance_payment_doctypes = frappe.get_hooks("advance_payment_receivable_doctypes") + frappe.get_hooks(
-			"advance_payment_payable_doctypes"
-		)
-		if self.reference_doctype in advance_payment_doctypes:
+		if self.reference_doctype in get_advance_payment_doctypes():
 			ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
 			ref_doc.set_advance_payment_status()
 
@@ -826,8 +823,7 @@ def update_payment_requests_as_per_pe_references(references=None, cancel=False):
 	if not references:
 		return
 
-	precision = references[0].precision("allocated_amount")
-
+	precision = frappe.get_precision("Payment Entry Reference", "allocated_amount")
 	referenced_payment_requests = frappe.get_all(
 		"Payment Request",
 		filters={"name": ["in", {row.payment_request for row in references if row.payment_request}]},

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -6,7 +6,7 @@ import unittest
 from unittest.mock import patch
 
 import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_terms_template
@@ -58,15 +58,6 @@ payment_method = [
 ]
 
 
-class UnitTestPaymentRequest(UnitTestCase):
-	"""
-	Unit tests for PaymentRequest.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestPaymentRequest(IntegrationTestCase):
 	def setUp(self):
 		for payment_gateway in payment_gateways:
@@ -797,29 +788,58 @@ class TestPaymentRequest(IntegrationTestCase):
 		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()
 
-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 = "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()
 
-	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)
 
-	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)

erpnext/accounts/doctype/pegged_currencies/pegged_currencies.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and contributors
+// For license information, please see license.txt
+
+// frappe.ui.form.on("Pegged Currencies", {
+// 	refresh(frm) {
+
+// 	},
+// });

erpnext/accounts/doctype/pegged_currencies/pegged_currencies.json

@@ -0,0 +1,47 @@
+{
+ "actions": [],
+ "allow_rename": 1,
+ "creation": "2025-05-30 11:47:03.670913",
+ "doctype": "DocType",
+ "engine": "InnoDB",
+ "field_order": [
+  "pegged_currencies_item_section",
+  "pegged_currency_item"
+ ],
+ "fields": [
+  {
+   "fieldname": "pegged_currencies_item_section",
+   "fieldtype": "Section Break"
+  },
+  {
+   "fieldname": "pegged_currency_item",
+   "fieldtype": "Table",
+   "options": "Pegged Currency Details"
+  }
+ ],
+ "grid_page_length": 50,
+ "index_web_pages_for_search": 1,
+ "issingle": 1,
+ "links": [],
+ "modified": "2025-06-02 11:46:31.936714",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Pegged Currencies",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "print": 1,
+   "read": 1,
+   "role": "System Manager",
+   "share": 1,
+   "write": 1
+  }
+ ],
+ "row_format": "Dynamic",
+ "sort_field": "creation",
+ "sort_order": "DESC",
+ "states": []
+}

erpnext/accounts/doctype/pegged_currencies/pegged_currencies.py

@@ -0,0 +1,22 @@
+# Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+# import frappe
+from frappe.model.document import Document
+
+
+class PeggedCurrencies(Document):
+	# begin: auto-generated types
+	# This code is auto-generated. Do not modify anything in this block.
+
+	from typing import TYPE_CHECKING
+
+	if TYPE_CHECKING:
+		from frappe.types import DF
+
+		from erpnext.accounts.doctype.pegged_currencies.pegged_currencies import PeggedCurrencies
+
+		pegged_currency_item: DF.Table[PeggedCurrencies]
+	# end: auto-generated types
+
+	pass

erpnext/accounts/doctype/pegged_currencies/test_pegged_currencies.py

@@ -0,0 +1,29 @@
+# Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+# import frappe
+from frappe.tests import IntegrationTestCase, UnitTestCase
+
+# On IntegrationTestCase, the doctype test records and all
+# link-field test record dependencies are recursively loaded
+# Use these module variables to add/remove to/from that list
+EXTRA_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
+IGNORE_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
+
+
+class UnitTestPeggedCurrencies(UnitTestCase):
+	"""
+	Unit tests for PeggedCurrencies.
+	Use this class for testing individual functions and methods.
+	"""
+
+	pass
+
+
+class IntegrationTestPeggedCurrencies(IntegrationTestCase):
+	"""
+	Integration tests for PeggedCurrencies.
+	Use this class for testing interactions between multiple components.
+	"""
+
+	pass

erpnext/accounts/doctype/pegged_currency_details/pegged_currency_details.json

@@ -0,0 +1,49 @@
+{
+ "actions": [],
+ "allow_rename": 1,
+ "creation": "2025-05-30 11:59:28.219277",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "source_currency",
+  "pegged_against",
+  "pegged_exchange_rate"
+ ],
+ "fields": [
+  {
+   "fieldname": "source_currency",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "Currency",
+   "options": "Currency"
+  },
+  {
+   "fieldname": "pegged_exchange_rate",
+   "fieldtype": "Data",
+   "in_list_view": 1,
+   "label": "Exchange Rate"
+  },
+  {
+   "fieldname": "pegged_against",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "Pegged Against",
+   "options": "Currency"
+  }
+ ],
+ "grid_page_length": 50,
+ "index_web_pages_for_search": 1,
+ "istable": 1,
+ "links": [],
+ "modified": "2025-06-17 14:11:16.521193",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Pegged Currency Details",
+ "owner": "Administrator",
+ "permissions": [],
+ "row_format": "Dynamic",
+ "sort_field": "creation",
+ "sort_order": "DESC",
+ "states": []
+}

erpnext/accounts/doctype/pegged_currency_details/pegged_currency_details.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+# import frappe
+from frappe.model.document import Document
+
+
+class PeggedCurrencyDetails(Document):
+	# begin: auto-generated types
+	# This code is auto-generated. Do not modify anything in this block.
+
+	from typing import TYPE_CHECKING
+
+	if TYPE_CHECKING:
+		from frappe.types import DF
+
+		parent: DF.Data
+		parentfield: DF.Data
+		parenttype: DF.Data
+		pegged_against: DF.Link | None
+		pegged_exchange_rate: DF.Data | None
+		source_currency: DF.Link | None
+	# end: auto-generated types
+
+	pass

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -210,8 +210,10 @@ class PeriodClosingVoucher(AccountsController):
 		return gl_entry
 
 	def get_gle_for_closing_account(self, dimension_balance, dimensions):
-		balance_in_account_currency = flt(dimension_balance.balance_in_account_currency)
 		balance_in_company_currency = flt(dimension_balance.balance_in_company_currency)
+		debit = balance_in_company_currency if balance_in_company_currency > 0 else 0
+		credit = abs(balance_in_company_currency) if balance_in_company_currency < 0 else 0
+
 		gl_entry = frappe._dict(
 			{
 				"company": self.company,
@@ -220,14 +222,10 @@ class PeriodClosingVoucher(AccountsController):
 				"account_currency": frappe.db.get_value(
 					"Account", self.closing_account_head, "account_currency"
 				),
-				"debit_in_account_currency": balance_in_account_currency
-				if balance_in_account_currency > 0
-				else 0,
-				"debit": balance_in_company_currency if balance_in_company_currency > 0 else 0,
-				"credit_in_account_currency": abs(balance_in_account_currency)
-				if balance_in_account_currency < 0
-				else 0,
-				"credit": abs(balance_in_company_currency) if balance_in_company_currency < 0 else 0,
+				"debit_in_account_currency": debit,
+				"debit": debit,
+				"credit_in_account_currency": credit,
+				"credit": credit,
 				"is_period_closing_voucher_entry": 1,
 				"voucher_type": "Period Closing Voucher",
 				"voucher_no": self.name,

erpnext/accounts/doctype/pos_closing_entry/closing_voucher_details.html

@@ -1,11 +1,11 @@
 <div class="clearfix"></div>
 <div class="box">
-		<div class="grid-body">
+		<div class="grid-body" style="background-color: transparent;">
 			<div class="rows text-center">
 
 				<!-- Sales summary section -->
 				<div>
-						<h6 class="text-center uppercase" style="color: #8D99A6">{{ _("Sales Summary") }}</h6>
+						<h6 class="text-center uppercase">{{ _("Sales Summary") }}</h6>
 						<div class="tax-break-up" style="overflow-x: auto;">
 							<table class="table table-bordered table-hover">
 								<thead>
@@ -32,7 +32,7 @@
 
 				<!-- Mode of payment section -->
 				<div>
-						<h6 class="text-center uppercase" style="color: #8D99A6">{{ _("Mode of Payments") }}</h6>
+						<h6 class="text-center uppercase">{{ _("Mode of Payments") }}</h6>
 						<div class="tax-break-up" style="overflow-x: auto;">
 							<table class="table table-bordered table-hover">
 								<thead>
@@ -57,7 +57,7 @@
 				<!-- Taxes section -->
 				{% if data.taxes %}
 				<div>
-						<h6 class="text-center uppercase" style="color: #8D99A6">{{ _("Taxes") }}</h6>
+						<h6 class="text-center uppercase">{{ _("Taxes") }}</h6>
 						<div class="tax-break-up" style="overflow-x: auto;">
 							<table class="table table-bordered table-hover">
 								<thead>

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.js

@@ -3,7 +3,7 @@
 
 frappe.ui.form.on("POS Closing Entry", {
 	onload: async function (frm) {
-		frm.ignore_doctypes_on_cancel_all = ["POS Invoice Merge Log"];
+		frm.ignore_doctypes_on_cancel_all = ["POS Invoice Merge Log", "Sales Invoice"];
 		frm.set_query("pos_profile", function (doc) {
 			return {
 				filters: { user: doc.user },
@@ -36,17 +36,6 @@ frappe.ui.form.on("POS Closing Entry", {
 			}
 		});
 
-		const is_pos_using_sales_invoice = await frappe.db.get_single_value(
-			"Accounts Settings",
-			"use_sales_invoice_in_pos"
-		);
-
-		if (is_pos_using_sales_invoice) {
-			frm.set_df_property("pos_transactions", "hidden", 1);
-		}
-
-		set_html_data(frm);
-
 		if (frm.doc.docstatus == 1) {
 			if (!frm.doc.posting_date) {
 				frm.set_value("posting_date", frappe.datetime.nowdate());
@@ -91,8 +80,7 @@ frappe.ui.form.on("POS Closing Entry", {
 			frappe.run_serially([
 				() => frappe.dom.freeze(__("Loading Invoices! Please Wait...")),
 				() => frm.trigger("set_opening_amounts"),
-				() => frm.trigger("get_pos_invoices"),
-				() => frm.trigger("get_sales_invoices"),
+				() => frm.trigger("get_invoices"),
 				() => frappe.dom.unfreeze(),
 			]);
 		}
@@ -112,9 +100,9 @@ frappe.ui.form.on("POS Closing Entry", {
 			});
 	},
 
-	get_pos_invoices(frm) {
+	get_invoices(frm) {
 		return frappe.call({
-			method: "erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry.get_pos_invoices",
+			method: "erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry.get_invoices",
 			args: {
 				start: frappe.datetime.get_datetime_as_string(frm.doc.period_start_date),
 				end: frappe.datetime.get_datetime_as_string(frm.doc.period_end_date),
@@ -122,101 +110,14 @@ frappe.ui.form.on("POS Closing Entry", {
 				user: frm.doc.user,
 			},
 			callback: (r) => {
-				let pos_docs = r.message;
-				set_pos_transaction_form_data(pos_docs, frm);
+				let inv_docs = r.message.invoices;
+				set_transaction_form_data(inv_docs, frm);
+				refresh_payments(r.message.payments, frm);
+				add_taxes(r.message.taxes, frm);
 				refresh_fields(frm);
-				set_html_data(frm);
 			},
 		});
 	},
-
-	get_sales_invoices(frm) {
-		return frappe.call({
-			method: "erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry.get_sales_invoices",
-			args: {
-				start: frappe.datetime.get_datetime_as_string(frm.doc.period_start_date),
-				end: frappe.datetime.get_datetime_as_string(frm.doc.period_end_date),
-				pos_profile: frm.doc.pos_profile,
-				user: frm.doc.user,
-			},
-			callback: (r) => {
-				let sales_docs = r.message;
-				set_sales_invoice_transaction_form_data(sales_docs, frm);
-				refresh_fields(frm);
-				set_html_data(frm);
-			},
-		});
-	},
-
-	before_save: async function (frm) {
-		frappe.dom.freeze(__("Processing Sales! Please Wait..."));
-
-		frm.set_value("grand_total", 0);
-		frm.set_value("net_total", 0);
-		frm.set_value("total_quantity", 0);
-		frm.set_value("taxes", []);
-
-		for (let row of frm.doc.payment_reconciliation) {
-			row.expected_amount = row.opening_amount;
-		}
-
-		const is_pos_using_sales_invoice = await frappe.db.get_single_value(
-			"Accounts Settings",
-			"use_sales_invoice_in_pos"
-		);
-
-		if (is_pos_using_sales_invoice) {
-			await Promise.all([
-				frappe.call({
-					method: "erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry.get_pos_invoices",
-					args: {
-						start: frappe.datetime.get_datetime_as_string(frm.doc.period_start_date),
-						end: frappe.datetime.get_datetime_as_string(frm.doc.period_end_date),
-						pos_profile: frm.doc.pos_profile,
-						user: frm.doc.user,
-					},
-					callback: (r) => {
-						let pos_invoices = r.message;
-						for (let doc of pos_invoices) {
-							frm.doc.grand_total += flt(doc.grand_total);
-							frm.doc.net_total += flt(doc.net_total);
-							frm.doc.total_quantity += flt(doc.total_qty);
-							refresh_payments(doc, frm, false);
-							refresh_taxes(doc, frm);
-							refresh_fields(frm);
-							set_html_data(frm);
-						}
-					},
-				}),
-			]);
-		}
-
-		await Promise.all([
-			frappe.call({
-				method: "erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry.get_sales_invoices",
-				args: {
-					start: frappe.datetime.get_datetime_as_string(frm.doc.period_start_date),
-					end: frappe.datetime.get_datetime_as_string(frm.doc.period_end_date),
-					pos_profile: frm.doc.pos_profile,
-					user: frm.doc.user,
-				},
-				callback: (r) => {
-					let sales_invoices = r.message;
-					for (let doc of sales_invoices) {
-						frm.doc.grand_total += flt(doc.grand_total);
-						frm.doc.net_total += flt(doc.net_total);
-						frm.doc.total_quantity += flt(doc.total_qty);
-						refresh_payments(doc, frm, false);
-						refresh_taxes(doc, frm);
-						refresh_fields(frm);
-						set_html_data(frm);
-					}
-				},
-			}),
-		]);
-
-		frappe.dom.unfreeze();
-	},
 });
 
 frappe.ui.form.on("POS Closing Entry Detail", {
@@ -226,57 +127,37 @@ frappe.ui.form.on("POS Closing Entry Detail", {
 	},
 });
 
-function set_pos_transaction_form_data(data, frm) {
+function set_transaction_form_data(data, frm) {
 	data.forEach((d) => {
-		add_to_pos_transaction(d, frm);
+		add_to_transaction(d, frm);
 		frm.doc.grand_total += flt(d.grand_total);
 		frm.doc.net_total += flt(d.net_total);
 		frm.doc.total_quantity += flt(d.total_qty);
-		refresh_payments(d, frm, true);
-		refresh_taxes(d, frm);
+		frm.doc.total_taxes_and_charges += flt(d.total_taxes_and_charges);
 	});
 }
 
-function set_sales_invoice_transaction_form_data(data, frm) {
-	data.forEach((d) => {
-		add_to_sales_invoice_transaction(d, frm);
-		frm.doc.grand_total += flt(d.grand_total);
-		frm.doc.net_total += flt(d.net_total);
-		frm.doc.total_quantity += flt(d.total_qty);
-		refresh_payments(d, frm, true);
-		refresh_taxes(d, frm);
-	});
-}
-
-function add_to_pos_transaction(d, frm) {
-	frm.add_child("pos_transactions", {
-		pos_invoice: d.name,
+function add_to_transaction(d, frm) {
+	const field = d.doctype === "POS Invoice" ? "pos_invoices" : "sales_invoices";
+	frm.add_child(field, {
 		posting_date: d.posting_date,
 		grand_total: d.grand_total,
 		customer: d.customer,
+		is_return: d.is_return,
+		return_against: d.return_against,
+		...(d.doctype === "POS Invoice" && { pos_invoice: d.name }),
+		...(d.doctype === "Sales Invoice" && { sales_invoice: d.name }),
 	});
 }
 
-function add_to_sales_invoice_transaction(d, frm) {
-	frm.add_child("sales_invoice_transactions", {
-		sales_invoice: d.name,
-		posting_date: d.posting_date,
-		grand_total: d.grand_total,
-		customer: d.customer,
-	});
-}
-
-function refresh_payments(d, frm, is_new) {
-	d.payments.forEach((p) => {
+function refresh_payments(payments, frm) {
+	payments.forEach((p) => {
 		const payment = frm.doc.payment_reconciliation.find(
 			(pay) => pay.mode_of_payment === p.mode_of_payment
 		);
-		if (p.account == d.account_for_change_amount) {
-			p.amount -= flt(d.change_amount);
-		}
 		if (payment) {
 			payment.expected_amount += flt(p.amount);
-			if (is_new) payment.closing_amount = payment.expected_amount;
+			payment.closing_amount = payment.expected_amount;
 			payment.difference = payment.closing_amount - payment.expected_amount;
 		} else {
 			frm.add_child("payment_reconciliation", {
@@ -289,49 +170,33 @@ function refresh_payments(d, frm, is_new) {
 	});
 }
 
-function refresh_taxes(d, frm) {
-	d.taxes.forEach((t) => {
-		const tax = frm.doc.taxes.find((tx) => tx.account_head === t.account_head && tx.rate === t.rate);
-		if (tax) {
-			tax.amount += flt(t.tax_amount);
-		} else {
-			frm.add_child("taxes", {
-				account_head: t.account_head,
-				rate: t.rate,
-				amount: t.tax_amount,
-			});
-		}
+function add_taxes(taxes, frm) {
+	taxes.forEach((t) => {
+		frm.add_child("taxes", {
+			account_head: t.account_head,
+			amount: t.tax_amount,
+		});
 	});
 }
 
 function reset_values(frm) {
-	frm.set_value("pos_transactions", []);
-	frm.set_value("sales_invoice_transactions", []);
+	frm.set_value("pos_invoices", []);
+	frm.set_value("sales_invoices", []);
 	frm.set_value("payment_reconciliation", []);
 	frm.set_value("taxes", []);
 	frm.set_value("grand_total", 0);
 	frm.set_value("net_total", 0);
+	frm.set_value("total_taxes_and_charges", 0);
 	frm.set_value("total_quantity", 0);
 }
 
 function refresh_fields(frm) {
-	frm.refresh_field("pos_transactions");
-	frm.refresh_field("sales_invoice_transactions");
+	frm.refresh_field("pos_invoices");
+	frm.refresh_field("sales_invoices");
 	frm.refresh_field("payment_reconciliation");
 	frm.refresh_field("taxes");
 	frm.refresh_field("grand_total");
 	frm.refresh_field("net_total");
+	frm.refresh_field("total_taxes_and_charges");
 	frm.refresh_field("total_quantity");
 }
-
-function set_html_data(frm) {
-	if (frm.doc.docstatus === 1 && frm.doc.status == "Submitted") {
-		frappe.call({
-			method: "get_payment_reconciliation_details",
-			doc: frm.doc,
-			callback: (r) => {
-				frm.get_field("payment_reconciliation_details").$wrapper.html(r.message);
-			},
-		});
-	}
-}

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.json

@@ -20,18 +20,19 @@
   "pos_profile",
   "user",
   "section_break_12",
-  "pos_transactions",
-  "sales_invoice_transactions",
-  "section_break_9",
-  "payment_reconciliation_details",
+  "pos_invoices",
+  "sales_invoices",
+  "taxes_and_charges_section",
+  "taxes",
+  "section_break_13",
+  "column_break_16",
+  "total_quantity",
+  "column_break_ywgl",
+  "net_total",
+  "total_taxes_and_charges",
+  "grand_total",
   "section_break_11",
   "payment_reconciliation",
-  "section_break_13",
-  "grand_total",
-  "net_total",
-  "total_quantity",
-  "column_break_16",
-  "taxes",
   "failure_description_section",
   "error_message",
   "section_break_14",
@@ -73,10 +74,13 @@
    "label": "User Details"
   },
   {
+   "fetch_from": "pos_opening_entry.company",
+   "fetch_if_empty": 1,
    "fieldname": "company",
    "fieldtype": "Link",
    "label": "Company",
    "options": "Company",
+   "read_only": 1,
    "reqd": 1
   },
   {
@@ -85,11 +89,13 @@
   },
   {
    "fetch_from": "pos_opening_entry.pos_profile",
+   "fetch_if_empty": 1,
    "fieldname": "pos_profile",
    "fieldtype": "Link",
    "in_list_view": 1,
    "label": "POS Profile",
    "options": "POS Profile",
+   "read_only": 1,
    "reqd": 1
   },
   {
@@ -98,18 +104,9 @@
    "fieldtype": "Link",
    "label": "Cashier",
    "options": "User",
+   "read_only": 1,
    "reqd": 1
   },
-  {
-   "fieldname": "section_break_9",
-   "fieldtype": "Section Break",
-   "read_only": 1
-  },
-  {
-   "depends_on": "eval:doc.docstatus==1",
-   "fieldname": "payment_reconciliation_details",
-   "fieldtype": "HTML"
-  },
   {
    "fieldname": "section_break_11",
    "fieldtype": "Section Break",
@@ -122,7 +119,6 @@
    "options": "POS Closing Entry Detail"
   },
   {
-   "collapsible": 1,
    "collapsible_depends_on": "eval:doc.docstatus==0",
    "fieldname": "section_break_13",
    "fieldtype": "Section Break",
@@ -177,17 +173,12 @@
    "print_hide": 1,
    "read_only": 1
   },
-  {
-   "fieldname": "pos_transactions",
-   "fieldtype": "Table",
-   "label": "POS Transactions",
-   "options": "POS Invoice Reference"
-  },
   {
    "fieldname": "pos_opening_entry",
    "fieldtype": "Link",
    "label": "POS Opening Entry",
    "options": "POS Opening Entry",
+   "print_hide": 1,
    "reqd": 1
   },
   {
@@ -230,10 +221,36 @@
    "reqd": 1
   },
   {
-   "fieldname": "sales_invoice_transactions",
+   "fieldname": "pos_invoices",
+   "fieldtype": "Table",
+   "label": "POS Transactions",
+   "options": "POS Invoice Reference",
+   "print_hide": 1,
+   "read_only": 1
+  },
+  {
+   "fieldname": "sales_invoices",
    "fieldtype": "Table",
    "label": "Sales Invoice Transactions",
-   "options": "Sales Invoice Reference"
+   "options": "Sales Invoice Reference",
+   "print_hide": 1,
+   "read_only": 1
+  },
+  {
+   "collapsible": 1,
+   "fieldname": "taxes_and_charges_section",
+   "fieldtype": "Section Break",
+   "label": "Taxes and Charges"
+  },
+  {
+   "fieldname": "column_break_ywgl",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "total_taxes_and_charges",
+   "fieldtype": "Currency",
+   "label": "Total Taxes and Charges",
+   "read_only": 1
   }
  ],
  "grid_page_length": 50,
@@ -244,7 +261,7 @@
    "link_fieldname": "pos_closing_entry"
   }
  ],
- "modified": "2025-03-19 19:49:58.845697",
+ "modified": "2025-06-14 02:38:14.962291",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Closing Entry",

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.py

@@ -4,7 +4,10 @@
 
 import frappe
 from frappe import _
-from frappe.utils import flt, get_datetime
+from frappe.query_builder import DocType
+from frappe.query_builder import functions as fn
+from frappe.query_builder.custom import ConstantColumn
+from frappe.utils import flt
 
 from erpnext.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import (
 	consolidate_pos_invoices,
@@ -41,35 +44,45 @@ class POSClosingEntry(StatusUpdater):
 		payment_reconciliation: DF.Table[POSClosingEntryDetail]
 		period_end_date: DF.Datetime
 		period_start_date: DF.Datetime
+		pos_invoices: DF.Table[POSInvoiceReference]
 		pos_opening_entry: DF.Link
 		pos_profile: DF.Link
-		pos_transactions: DF.Table[POSInvoiceReference]
 		posting_date: DF.Date
 		posting_time: DF.Time
-		sales_invoice_transactions: DF.Table[SalesInvoiceReference]
+		sales_invoices: DF.Table[SalesInvoiceReference]
 		status: DF.Literal["Draft", "Submitted", "Queued", "Failed", "Cancelled"]
 		taxes: DF.Table[POSClosingEntryTaxes]
 		total_quantity: DF.Float
+		total_taxes_and_charges: DF.Currency
 		user: DF.Link
 	# end: auto-generated types
 
 	def validate(self):
-		self.posting_date = self.posting_date or frappe.utils.nowdate()
-		self.posting_time = self.posting_time or frappe.utils.nowtime()
+		self.set_posting_date_and_time()
+		self.fetch_invoice_type()
+		self.validate_pos_opening_entry()
+		self.validate_invoice_mode()
 
+	def set_posting_date_and_time(self):
+		if self.posting_date:
+			self.posting_date = frappe.utils.nowdate()
+		if self.posting_time:
+			self.posting_time = frappe.utils.nowtime()
+
+	def fetch_invoice_type(self):
+		self.invoice_type = frappe.db.get_single_value("POS Settings", "invoice_type")
+
+	def validate_pos_opening_entry(self):
 		if frappe.db.get_value("POS Opening Entry", self.pos_opening_entry, "status") != "Open":
 			frappe.throw(_("Selected POS Opening Entry should be open."), title=_("Invalid Opening Entry"))
 
-		self.is_pos_using_sales_invoice = frappe.db.get_single_value(
-			"Accounts Settings", "use_sales_invoice_in_pos"
-		)
-
-		if self.is_pos_using_sales_invoice == 0:
+	def validate_invoice_mode(self):
+		if self.invoice_type == "POS Invoice":
 			self.validate_duplicate_pos_invoices()
 			self.validate_pos_invoices()
 
-		if self.is_pos_using_sales_invoice == 1:
-			if len(self.pos_transactions) != 0:
+		if self.invoice_type == "Sales Invoice":
+			if len(self.pos_invoices) != 0:
 				frappe.throw(_("POS Invoices can't be added when Sales Invoice is enabled"))
 
 		self.validate_duplicate_sales_invoices()
@@ -77,7 +90,7 @@ class POSClosingEntry(StatusUpdater):
 
 	def validate_duplicate_pos_invoices(self):
 		pos_occurences = {}
-		for idx, inv in enumerate(self.pos_transactions, 1):
+		for idx, inv in enumerate(self.pos_invoices, 1):
 			pos_occurences.setdefault(inv.pos_invoice, []).append(idx)
 
 		error_list = []
@@ -92,7 +105,7 @@ class POSClosingEntry(StatusUpdater):
 
 	def validate_pos_invoices(self):
 		invalid_rows = []
-		for d in self.pos_transactions:
+		for d in self.pos_invoices:
 			invalid_row = {"idx": d.idx}
 			pos_invoice = frappe.db.get_values(
 				"POS Invoice",
@@ -130,7 +143,7 @@ class POSClosingEntry(StatusUpdater):
 
 	def validate_duplicate_sales_invoices(self):
 		sales_invoice_occurrences = {}
-		for idx, inv in enumerate(self.sales_invoice_transactions, 1):
+		for idx, inv in enumerate(self.sales_invoices, 1):
 			sales_invoice_occurrences.setdefault(inv.sales_invoice, []).append(idx)
 
 		error_list = []
@@ -145,7 +158,7 @@ class POSClosingEntry(StatusUpdater):
 
 	def validate_sales_invoices(self):
 		invalid_rows = []
-		for d in self.sales_invoice_transactions:
+		for d in self.sales_invoices:
 			invalid_row = {"idx": d.idx}
 			sales_invoice = frappe.db.get_values(
 				"Sales Invoice",
@@ -193,24 +206,19 @@ class POSClosingEntry(StatusUpdater):
 
 		frappe.throw(error_list, title=_("Invalid Sales Invoices"), as_list=True)
 
-	@frappe.whitelist()
-	def get_payment_reconciliation_details(self):
-		currency = frappe.get_cached_value("Company", self.company, "default_currency")
-		return frappe.render_template(
-			"erpnext/accounts/doctype/pos_closing_entry/closing_voucher_details.html",
-			{"data": self, "currency": currency},
-		)
-
 	def on_submit(self):
 		consolidate_pos_invoices(closing_entry=self)
 		frappe.publish_realtime(
-			f"poe_{self.pos_opening_entry}_closed",
-			self,
+			f"poe_{self.pos_opening_entry}",
+			message={"operation": "Closed", "doc": self},
 			docname=f"POS Opening Entry/{self.pos_opening_entry}",
 		)
 
 		self.update_sales_invoices_closing_entry()
 
+	def before_cancel(self):
+		self.check_pce_is_cancellable()
+
 	def on_cancel(self):
 		unconsolidate_pos_invoices(closing_entry=self)
 
@@ -227,11 +235,20 @@ class POSClosingEntry(StatusUpdater):
 		opening_entry.save()
 
 	def update_sales_invoices_closing_entry(self, cancel=False):
-		for d in self.sales_invoice_transactions:
+		for d in self.sales_invoices:
 			frappe.db.set_value(
 				"Sales Invoice", d.sales_invoice, "pos_closing_entry", self.name if not cancel else None
 			)
 
+	def check_pce_is_cancellable(self):
+		if frappe.db.exists("POS Opening Entry", {"pos_profile": self.pos_profile, "status": "Open"}):
+			frappe.throw(
+				title=_("Cannot cancel POS Closing Entry"),
+				msg=_(
+					"POS Profile - {0} is currently open. Please close the POS or cancel the existing POS Opening Entry before cancelling this POS Closing Entry."
+				).format(frappe.bold(self.pos_profile)),
+			)
+
 
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
@@ -241,50 +258,79 @@ def get_cashiers(doctype, txt, searchfield, start, page_len, filters):
 
 
 @frappe.whitelist()
-def get_pos_invoices(start, end, pos_profile, user):
-	data = frappe.db.sql(
-		"""
-	select
-		name, timestamp(posting_date, posting_time) as "timestamp"
-	from
-		`tabPOS Invoice`
-	where
-		owner = %s and docstatus = 1 and pos_profile = %s and ifnull(consolidated_invoice,'') = ''
-	""",
-		(user, pos_profile),
-		as_dict=1,
-	)
+def get_invoices(start, end, pos_profile, user):
+	invoice_doctype = frappe.db.get_single_value("POS Settings", "invoice_type")
 
-	data = list(filter(lambda d: get_datetime(start) <= get_datetime(d.timestamp) <= get_datetime(end), data))
-	# need to get taxes and payments so can't avoid get_doc
-	data = [frappe.get_doc("POS Invoice", d.name).as_dict() for d in data]
+	sales_inv_query = build_invoice_query("Sales Invoice", user, pos_profile, start, end)
+
+	query = sales_inv_query
+
+	if invoice_doctype == "POS Invoice":
+		pos_inv_query = build_invoice_query("POS Invoice", user, pos_profile, start, end)
+		query = query + pos_inv_query
+
+	query = query.orderby(query.timestamp)
+	invoices = query.run(as_dict=1)
+
+	data = {"invoices": invoices, "payments": get_payments(invoices), "taxes": get_taxes(invoices)}
 
 	return data
 
 
-@frappe.whitelist()
-def get_sales_invoices(start, end, pos_profile, user):
-	data = frappe.db.sql(
-		"""
-	select
-		name, timestamp(posting_date, posting_time) as "timestamp"
-	from
-		`tabSales Invoice`
-	where
-		owner = %s
-		and docstatus = 1
-		and is_pos = 1
-		and pos_profile = %s
-		and is_created_using_pos = 1
-		and ifnull(pos_closing_entry,'') = ''
-	""",
-		(user, pos_profile),
-		as_dict=1,
-	)
+def get_payments(invoices):
+	if not len(invoices):
+		return []
 
-	data = [d for d in data if get_datetime(start) <= get_datetime(d.timestamp) <= get_datetime(end)]
-	# need to get taxes and payments so can't avoid get_doc
-	data = [frappe.get_doc("Sales Invoice", d.name).as_dict() for d in data]
+	invoices_name = [d.name for d in invoices]
+
+	SalesInvoicePayment = DocType("Sales Invoice Payment")
+	query = (
+		frappe.qb.from_(SalesInvoicePayment)
+		.where(
+			(SalesInvoicePayment.parenttype.isin(["Sales Invoice", "POS Invoice"]))
+			& (SalesInvoicePayment.parent.isin(invoices_name))
+		)
+		.groupby(SalesInvoicePayment.mode_of_payment)
+		.select(
+			SalesInvoicePayment.mode_of_payment,
+			SalesInvoicePayment.account,
+			fn.Sum(SalesInvoicePayment.amount).as_("amount"),
+		)
+	)
+	data = query.run(as_dict=1)
+
+	change_amount_by_account = {}
+	for d in invoices:
+		change_amount_by_account.setdefault(d.account_for_change_amount, 0)
+		change_amount_by_account[d.account_for_change_amount] += flt(d.change_amount)
+
+	for d in data:
+		if change_amount_by_account.get(d.account):
+			d.amount -= flt(change_amount_by_account.get(d.account))
+
+	return data
+
+
+def get_taxes(invoices):
+	if not len(invoices):
+		return []
+
+	invoices_name = [d.name for d in invoices]
+
+	SalesInvoiceTaxesCharges = DocType("Sales Taxes and Charges")
+	query = (
+		frappe.qb.from_(SalesInvoiceTaxesCharges)
+		.where(
+			(SalesInvoiceTaxesCharges.parenttype.isin(["Sales Invoice", "POS Invoice"]))
+			& (SalesInvoiceTaxesCharges.parent.isin(invoices_name))
+		)
+		.groupby(SalesInvoiceTaxesCharges.account_head)
+		.select(
+			SalesInvoiceTaxesCharges.account_head,
+			fn.Sum(SalesInvoiceTaxesCharges.tax_amount_after_discount_amount).as_("tax_amount"),
+		)
+	)
+	data = query.run(as_dict=1)
 
 	return data
 
@@ -300,98 +346,98 @@ def make_closing_entry_from_opening(opening_entry):
 	closing_entry.grand_total = 0
 	closing_entry.net_total = 0
 	closing_entry.total_quantity = 0
+	closing_entry.total_taxes_and_charges = 0
 
-	is_pos_using_sales_invoice = frappe.db.get_single_value("Accounts Settings", "use_sales_invoice_in_pos")
-
-	pos_invoices = (
-		get_pos_invoices(
-			closing_entry.period_start_date,
-			closing_entry.period_end_date,
-			closing_entry.pos_profile,
-			closing_entry.user,
-		)
-		if is_pos_using_sales_invoice == 0
-		else []
-	)
-
-	sales_invoices = get_sales_invoices(
+	data = get_invoices(
 		closing_entry.period_start_date,
 		closing_entry.period_end_date,
 		closing_entry.pos_profile,
 		closing_entry.user,
 	)
 
-	pos_transactions = []
-	sales_invoice_transactions = []
-	taxes = []
-	payments = []
-	for detail in opening_entry.balance_details:
-		payments.append(
-			frappe._dict(
-				{
-					"mode_of_payment": detail.mode_of_payment,
-					"opening_amount": detail.opening_amount,
-					"expected_amount": detail.opening_amount,
-				}
-			)
+	pos_invoices = []
+	sales_invoices = []
+	taxes = [
+		frappe._dict({"account_head": tx.account_head, "amount": tx.tax_amount}) for tx in data.get("taxes")
+	]
+	payments = [
+		frappe._dict(
+			{
+				"mode_of_payment": p.mode_of_payment,
+				"opening_amount": 0,
+				"expected_amount": p.amount,
+			}
 		)
+		for p in data.get("payments")
+	]
 
-	for d in pos_invoices:
-		pos_transactions.append(
-			frappe._dict(
-				{
-					"pos_invoice": d.name,
-					"posting_date": d.posting_date,
-					"grand_total": d.grand_total,
-					"customer": d.customer,
-				}
-			)
+	for d in data.get("invoices"):
+		invoice = "pos_invoice" if d.doctype == "POS Invoice" else "sales_invoice"
+		invoice_data = frappe._dict(
+			{
+				invoice: d.name,
+				"posting_date": d.posting_date,
+				"grand_total": d.grand_total,
+				"customer": d.customer,
+				"is_return": d.is_return,
+				"return_against": d.return_against,
+			}
 		)
+		if d.doctype == "POS Invoice":
+			pos_invoices.append(invoice_data)
+		else:
+			sales_invoices.append(invoice_data)
 
-	for d in sales_invoices:
-		sales_invoice_transactions.append(
-			frappe._dict(
-				{
-					"sales_invoice": d.name,
-					"posting_date": d.posting_date,
-					"grand_total": d.grand_total,
-					"customer": d.customer,
-				}
-			)
-		)
-
-	for d in [*pos_invoices, *sales_invoices]:
 		closing_entry.grand_total += flt(d.grand_total)
 		closing_entry.net_total += flt(d.net_total)
 		closing_entry.total_quantity += flt(d.total_qty)
+		closing_entry.total_taxes_and_charges += flt(d.total_taxes_and_charges)
 
-		for t in d.taxes:
-			existing_tax = [tx for tx in taxes if tx.account_head == t.account_head and tx.rate == t.rate]
-			if existing_tax:
-				existing_tax[0].amount += flt(t.tax_amount)
-			else:
-				taxes.append(
-					frappe._dict({"account_head": t.account_head, "rate": t.rate, "amount": t.tax_amount})
-				)
-
-		for p in d.payments:
-			existing_pay = [pay for pay in payments if pay.mode_of_payment == p.mode_of_payment]
-			if existing_pay:
-				existing_pay[0].expected_amount += flt(p.amount)
-			else:
-				payments.append(
-					frappe._dict(
-						{
-							"mode_of_payment": p.mode_of_payment,
-							"opening_amount": 0,
-							"expected_amount": p.amount,
-						}
-					)
-				)
-
-	closing_entry.set("pos_transactions", pos_transactions)
-	closing_entry.set("sales_invoice_transactions", sales_invoice_transactions)
+	closing_entry.set("pos_invoices", pos_invoices)
+	closing_entry.set("sales_invoices", sales_invoices)
 	closing_entry.set("payment_reconciliation", payments)
 	closing_entry.set("taxes", taxes)
 
 	return closing_entry
+
+
+def build_invoice_query(invoice_doctype, user, pos_profile, start, end):
+	InvoiceDocType = DocType(invoice_doctype)
+	query = (
+		frappe.qb.from_(InvoiceDocType)
+		.select(
+			InvoiceDocType.name,
+			InvoiceDocType.customer,
+			InvoiceDocType.posting_date,
+			InvoiceDocType.grand_total,
+			InvoiceDocType.net_total,
+			InvoiceDocType.total_qty,
+			InvoiceDocType.total_taxes_and_charges,
+			InvoiceDocType.change_amount,
+			InvoiceDocType.account_for_change_amount,
+			InvoiceDocType.is_return,
+			InvoiceDocType.return_against,
+			fn.Timestamp(InvoiceDocType.posting_date, InvoiceDocType.posting_time).as_("timestamp"),
+			ConstantColumn(invoice_doctype).as_("doctype"),
+		)
+		.where(
+			(InvoiceDocType.owner == user)
+			& (InvoiceDocType.docstatus == 1)
+			& (InvoiceDocType.is_pos == 1)
+			& (InvoiceDocType.pos_profile == pos_profile)
+			& (
+				(fn.Timestamp(InvoiceDocType.posting_date, InvoiceDocType.posting_time) >= start)
+				& (fn.Timestamp(InvoiceDocType.posting_date, InvoiceDocType.posting_time) <= end)
+			)
+		)
+	)
+
+	if invoice_doctype == "POS Invoice":
+		query = query.where(fn.IfNull(InvoiceDocType.consolidated_invoice, "").eq(""))
+	else:
+		query = query.where(
+			(InvoiceDocType.is_created_using_pos == 1)
+			& fn.IfNull(InvoiceDocType.pos_closing_entry, "").eq("")
+		)
+
+	return query

erpnext/accounts/doctype/pos_closing_entry/test_pos_closing_entry.py

@@ -12,10 +12,10 @@ from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension imp
 from erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry import (
 	make_closing_entry_from_opening,
 )
-from erpnext.accounts.doctype.pos_invoice.pos_invoice import make_sales_return
 from erpnext.accounts.doctype.pos_invoice.test_pos_invoice import create_pos_invoice
 from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
 from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.selling.page.point_of_sale.point_of_sale import get_items
 from erpnext.stock.doctype.item.test_item import make_item
 from erpnext.stock.doctype.serial_and_batch_bundle.test_serial_and_batch_bundle import (
@@ -25,8 +25,18 @@ from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
 
 
 class TestPOSClosingEntry(IntegrationTestCase):
+	@classmethod
+	def setUpClass(cls):
+		frappe.db.sql("delete from `tabPOS Opening Entry`")
+		cls.enterClassContext(cls.change_settings("POS Settings", {"invoice_type": "POS Invoice"}))
+
+	@classmethod
+	def tearDownClass(cls):
+		frappe.db.sql("delete from `tabPOS Opening Entry`")
+
 	def setUp(self):
 		# Make stock available for POS Sales
+		frappe.db.sql("delete from `tabPOS Opening Entry`")
 		make_stock_entry(target="_Test Warehouse - _TC", qty=2, basic_rate=100)
 
 	def tearDown(self):
@@ -82,6 +92,8 @@ class TestPOSClosingEntry(IntegrationTestCase):
 		"""
 		Test if quantity is calculated correctly for an item in POS Closing Entry
 		"""
+		from erpnext.accounts.doctype.pos_invoice.pos_invoice import make_sales_return
+
 		test_user, pos_profile = init_user_and_profile()
 		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
@@ -200,9 +212,6 @@ class TestPOSClosingEntry(IntegrationTestCase):
 		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import (
 			init_user_and_profile,
 		)
-		from erpnext.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import (
-			consolidate_pos_invoices,
-		)
 		from erpnext.stock.doctype.batch.batch import get_batch_qty
 
 		frappe.db.sql("delete from `tabPOS Invoice`")
@@ -293,45 +302,171 @@ class TestPOSClosingEntry(IntegrationTestCase):
 		batch_qty_with_pos = get_batch_qty(batch_no, "_Test Warehouse - _TC", item_code)
 		self.assertEqual(batch_qty_with_pos, 10.0)
 
+	@IntegrationTestCase.change_settings("POS Settings", {"invoice_type": "Sales Invoice"})
 	def test_closing_entries_with_sales_invoice(self):
-		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
+
+		pos_si = create_sales_invoice(
+			qty=10, is_created_using_pos=1, pos_profile=pos_profile.name, do_not_save=1
+		)
+		pos_si.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1000})
+		pos_si.save()
+		pos_si.submit()
+
+		pos_si2 = create_sales_invoice(
+			qty=5, is_created_using_pos=1, pos_profile=pos_profile.name, do_not_save=11
+		)
+		pos_si2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1000})
+		pos_si2.save()
+		pos_si2.submit()
+
+		pcv_doc = make_closing_entry_from_opening(opening_entry)
+		payment = pcv_doc.payment_reconciliation[0]
+
+		self.assertEqual(payment.mode_of_payment, "Cash")
+
+		for d in pcv_doc.payment_reconciliation:
+			if d.mode_of_payment == "Cash":
+				d.closing_amount = 1500
+
+		pcv_doc.submit()
+
+		self.assertEqual(pcv_doc.total_quantity, 15)
+		self.assertEqual(pcv_doc.net_total, 1500)
+
+		pos_si2.reload()
+		self.assertEqual(pos_si2.pos_closing_entry, pcv_doc.name)
+
+	def test_sales_invoice_in_pos_invoice_mode(self):
+		"""
+		Test Sales Invoice and Return Sales Invoice creation during POS Invoice mode.
+		"""
+		from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_sales_return
 
 		test_user, pos_profile = init_user_and_profile()
-		# Deleting all opening entry
-		frappe.db.sql("delete from `tabPOS Opening Entry`")
 
-		with self.change_settings("Accounts Settings", {"use_sales_invoice_in_pos": 1}):
-			opening_entry = create_opening_entry(pos_profile, test_user.name)
+		with self.change_settings("POS Settings", {"invoice_type": "Sales Invoice"}):
+			opening_entry1 = create_opening_entry(pos_profile, test_user.name)
 
-			pos_si = create_sales_invoice(qty=10, do_not_save=1)
-			pos_si.is_pos = 1
-			pos_si.pos_profile = pos_profile.name
-			pos_si.is_created_using_pos = 1
-			pos_si.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1000})
-			pos_si.save()
-			pos_si.submit()
+			pos_si1, pos_si2 = create_multiple_sales_invoices(pos_profile)
 
-			pos_si2 = create_sales_invoice(qty=5, do_not_save=1)
-			pos_si2.is_pos = 1
-			pos_si2.pos_profile = pos_profile.name
-			pos_si2.is_created_using_pos = 1
-			pos_si2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1000})
-			pos_si2.save()
-			pos_si2.submit()
+			pos_inv = create_pos_invoice(rate=100, do_not_save=1)
+			pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+			self.assertRaises(frappe.ValidationError, pos_inv.save)
 
-			pcv_doc = make_closing_entry_from_opening(opening_entry)
-			payment = pcv_doc.payment_reconciliation[0]
-
-			self.assertEqual(payment.mode_of_payment, "Cash")
-
-			for d in pcv_doc.payment_reconciliation:
+			pcv_doc1 = make_closing_entry_from_opening(opening_entry1)
+			for d in pcv_doc1.payment_reconciliation:
 				if d.mode_of_payment == "Cash":
-					d.closing_amount = 1500
+					d.closing_amount = 300
 
-			pcv_doc.submit()
+			pcv_doc1.submit()
+			self.assertTrue(pcv_doc1.name)
 
-			self.assertEqual(pcv_doc.total_quantity, 15)
-			self.assertEqual(pcv_doc.net_total, 1500)
+			pos_si1.reload()
+			pos_si2.reload()
+			self.assertEqual(pos_si1.pos_closing_entry, pcv_doc1.name)
+			self.assertEqual(pos_si2.pos_closing_entry, pcv_doc1.name)
+
+		with self.change_settings("POS Settings", {"invoice_type": "POS Invoice"}):
+			opening_entry2 = create_opening_entry(pos_profile, test_user.name)
+
+			pos_inv1, pos_inv2 = create_multiple_pos_invoices(pos_profile)
+
+			# Trying to create Sales Invoice when invoice_type is set to POS Invoice.
+			pos_si3 = create_sales_invoice(
+				qty=1, is_created_using_pos=1, pos_profile=pos_profile.name, do_not_save=1
+			)
+			pos_si3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+			self.assertRaises(frappe.ValidationError, pos_si3.save)
+
+			# Trying to create Return Sales Invoice.
+			pos_rsi1 = make_sales_return(pos_si1.name)
+			pos_rsi1.save()
+			pos_rsi1.submit()
+
+			self.assertEqual(pos_rsi1.paid_amount, -100)
+
+			pcv_doc2 = make_closing_entry_from_opening(opening_entry2)
+			pcv_doc2.submit()
+
+			self.assertTrue(pcv_doc2.name)
+
+			pos_rsi1.reload()
+			self.assertEqual(pos_rsi1.pos_closing_entry, pcv_doc2.name)
+
+			self.assertIn(pos_inv1.name, [d.pos_invoice for d in pcv_doc2.pos_invoices])
+			self.assertNotIn(pos_inv2.name, [d.sales_invoice for d in pcv_doc2.sales_invoices])
+			self.assertIn(pos_rsi1.name, [d.sales_invoice for d in pcv_doc2.sales_invoices])
+			self.assertEqual(pcv_doc2.grand_total, 200)
+
+	def test_pos_invoice_in_sales_invoice_mode(self):
+		"""
+		Test POS Invoice and Return POS Invoice creation during Sales Invoice mode.
+		"""
+		from erpnext.accounts.doctype.pos_invoice.pos_invoice import make_sales_return
+
+		test_user, pos_profile = init_user_and_profile()
+
+		with self.change_settings("POS Settings", {"invoice_type": "POS Invoice"}):
+			opening_entry1 = create_opening_entry(pos_profile, test_user.name)
+
+			pos_inv1, pos_inv2 = create_multiple_pos_invoices(pos_profile)
+
+			# Trying to create Sales Invoice when invoice_type is set to POS Invoice.
+			pos_sinv = create_sales_invoice(
+				qty=1, is_created_using_pos=1, pos_profile=pos_profile.name, do_not_save=1
+			)
+			pos_sinv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+			self.assertRaises(frappe.ValidationError, pos_sinv.save)
+
+			pcv_doc1 = make_closing_entry_from_opening(opening_entry1)
+			for d in pcv_doc1.payment_reconciliation:
+				if d.mode_of_payment == "Cash":
+					d.closing_amount = 300
+
+			pcv_doc1.submit()
+
+			self.assertTrue(pcv_doc1.name)
+
+			self.assertIn(pos_inv1.name, [d.pos_invoice for d in pcv_doc1.pos_invoices])
+			self.assertEqual(pcv_doc1.grand_total, 300)
+
+		with self.change_settings("POS Settings", {"invoice_type": "Sales Invoice"}):
+			opening_entry2 = create_opening_entry(pos_profile, test_user.name)
+
+			pos_si1, pos_si2 = create_multiple_sales_invoices(pos_profile)
+
+			pos_inv3 = create_pos_invoice(rate=100, do_not_save=1)
+			pos_inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+			self.assertRaises(frappe.ValidationError, pos_inv3.save)
+
+			# Creating Return POS Invoice
+			pos_rinv2 = make_sales_return(pos_inv2.name)
+			pos_rinv2.save()
+			pos_rinv2.submit()
+
+			pos_rinv2.reload()
+			self.assertIsNotNone(pos_rinv2.consolidated_invoice)
+
+			# Getting Sales Invoice created during POS Invoice submission.
+			pos_rinv2_si = frappe.get_doc("Sales Invoice", pos_rinv2.consolidated_invoice)
+			self.assertEqual(pos_rinv2_si.is_return, 1)
+			self.assertEqual(pos_rinv2_si.paid_amount, -200)
+
+			pcv_doc2 = make_closing_entry_from_opening(opening_entry2)
+			for d in pcv_doc1.payment_reconciliation:
+				if d.mode_of_payment == "Cash":
+					d.closing_amount = 100
+
+			pcv_doc2.submit()
+			self.assertTrue(pcv_doc2.name)
+
+			pos_si1.reload()
+			pos_si2.reload()
+			pos_rinv2_si.reload()
+			self.assertEqual(pos_si2.pos_closing_entry, pcv_doc2.name)
+			self.assertEqual(pos_rinv2_si.pos_closing_entry, pcv_doc2.name)
 
 
 def init_user_and_profile(**args):
@@ -367,3 +502,31 @@ def get_test_item_qty(pos_profile):
 		"actual_qty"
 	)
 	return test_item_qty
+
+
+def create_multiple_sales_invoices(pos_profile):
+	pos_si1 = create_sales_invoice(qty=1, is_created_using_pos=1, pos_profile=pos_profile.name, do_not_save=1)
+	pos_si1.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+	pos_si1.save()
+	pos_si1.submit()
+
+	pos_si2 = create_sales_invoice(qty=2, is_created_using_pos=1, pos_profile=pos_profile.name, do_not_save=1)
+	pos_si2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 200})
+	pos_si2.save()
+	pos_si2.submit()
+
+	return pos_si1, pos_si2
+
+
+def create_multiple_pos_invoices(pos_profile):
+	pos_inv1 = create_pos_invoice(pos_profile=pos_profile.name, rate=100, do_not_save=1)
+	pos_inv1.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+	pos_inv1.save()
+	pos_inv1.submit()
+
+	pos_inv2 = create_pos_invoice(pos_profile=pos_profile.name, qty=2, do_not_save=1)
+	pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 200})
+	pos_inv2.save()
+	pos_inv2.submit()
+
+	return pos_inv1, pos_inv2

erpnext/accounts/doctype/pos_closing_entry_taxes/pos_closing_entry_taxes.json

@@ -6,17 +6,9 @@
  "engine": "InnoDB",
  "field_order": [
   "account_head",
-  "rate",
   "amount"
  ],
  "fields": [
-  {
-   "fieldname": "rate",
-   "fieldtype": "Percent",
-   "in_list_view": 1,
-   "label": "Tax Rate",
-   "read_only": 1
-  },
   {
    "fieldname": "amount",
    "fieldtype": "Currency",
@@ -35,15 +27,16 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2024-03-27 13:10:14.420657",
+ "modified": "2025-06-06 11:54:02.414461",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Closing Entry Taxes",
  "owner": "Administrator",
  "permissions": [],
  "quick_entry": 1,
+ "row_format": "Dynamic",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/pos_closing_entry_taxes/pos_closing_entry_taxes.py

@@ -19,7 +19,6 @@ class POSClosingEntryTaxes(Document):
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data
-		rate: DF.Percent
 	# end: auto-generated types
 
 	pass

erpnext/accounts/doctype/pos_invoice/pos_invoice.js

@@ -66,6 +66,13 @@ erpnext.selling.POSInvoiceController = class POSInvoiceController extends erpnex
 
 		if (doc.docstatus == 1 && !doc.is_return) {
 			this.frm.add_custom_button(__("Return"), this.make_sales_return.bind(this), __("Create"));
+			if (["Partly Paid", "Overdue", "Unpaid"].includes(doc.status)) {
+				this.frm.add_custom_button(
+					__("Payment"),
+					this.collect_outstanding_payment.bind(this),
+					__("Create")
+				);
+			}
 			this.frm.page.set_inner_btn_group_as_primary(__("Create"));
 		}
 
@@ -210,6 +217,138 @@ erpnext.selling.POSInvoiceController = class POSInvoiceController extends erpnex
 			frm: this.frm,
 		});
 	}
+
+	async collect_outstanding_payment() {
+		const total_amount = flt(this.frm.doc.rounded_total) | flt(this.frm.doc.grand_total);
+		const paid_amount = flt(this.frm.doc.paid_amount);
+		const outstanding_amount = flt(this.frm.doc.outstanding_amount);
+		const me = this;
+
+		const table_fields = [
+			{
+				fieldname: "mode_of_payment",
+				fieldtype: "Link",
+				in_list_view: 1,
+				label: __("Mode of Payment"),
+				options: "Mode of Payment",
+				reqd: 1,
+			},
+			{
+				fieldname: "amount",
+				fieldtype: "Currency",
+				in_list_view: 1,
+				label: __("Amount"),
+				options: this.frm.doc.currency,
+				reqd: 1,
+				onchange: function () {
+					dialog.fields_dict.payments.df.data.some((d) => {
+						if (d.idx == this.doc.idx) {
+							d.amount = this.value === null ? 0 : this.value;
+							dialog.fields_dict.payments.grid.refresh();
+							return true;
+						}
+					});
+
+					let amount = 0;
+					for (let d of dialog.fields_dict.payments.df.data) {
+						amount += d.amount;
+					}
+
+					let change_amount = total_amount - (paid_amount + amount);
+
+					dialog.fields_dict.outstanding_amount.set_value(
+						outstanding_amount - amount < 0 ? 0 : outstanding_amount - amount
+					);
+					dialog.fields_dict.paid_amount.set_value(paid_amount + amount);
+					dialog.fields_dict.change_amount.set_value(change_amount < 0 ? change_amount * -1 : 0);
+				},
+			},
+		];
+		const payment_method_data = await this.fetch_pos_payment_methods();
+		const dialog = new frappe.ui.Dialog({
+			title: __("Collect Outstanding Amount"),
+			fields: [
+				{
+					fieldname: "payments",
+					fieldtype: "Table",
+					label: __("Payments"),
+					cannot_add_rows: false,
+					in_place_edit: true,
+					reqd: 1,
+					data: payment_method_data,
+					fields: table_fields,
+				},
+				{
+					fieldname: "section_break_1",
+					fieldtype: "Section Break",
+				},
+				{
+					fieldname: "outstanding_amount",
+					fieldtype: "Currency",
+					label: __("Outstanding Amount"),
+					read_only: 1,
+					default: outstanding_amount,
+				},
+				{
+					fieldname: "column_break_1",
+					fieldtype: "Column Break",
+				},
+				{
+					fieldname: "paid_amount",
+					fieldtype: "Currency",
+					label: __("Paid Amount"),
+					read_only: 1,
+					default: paid_amount,
+				},
+				{
+					fieldname: "change_amount",
+					fieldtype: "Currency",
+					label: __("Change Amount"),
+					read_only: 1,
+					default: 0,
+				},
+			],
+			primary_action_label: __("Submit"),
+			primary_action(values) {
+				dialog.hide();
+				me.frm.call({
+					doc: me.frm.doc,
+					method: "update_payments",
+					args: {
+						payments: values.payments.filter((d) => d.amount != 0),
+					},
+					freeze: true,
+					callback: function (r) {
+						if (!r.exc) {
+							frappe.show_alert({
+								message: __("Payments updated."),
+								indicator: "green",
+							});
+							me.frm.reload_doc();
+						} else {
+							frappe.show_alert({
+								message: __("Payments could not be updated."),
+								indicator: "red",
+							});
+						}
+					},
+				});
+			},
+		});
+		dialog.show();
+	}
+
+	async fetch_pos_payment_methods() {
+		const pos_profile = this.frm.doc.pos_profile;
+		if (!pos_profile) return;
+		const pos_profile_doc = await frappe.db.get_doc("POS Profile", pos_profile);
+		const data = [];
+		pos_profile_doc.payments.forEach((pay) => {
+			const { mode_of_payment } = pay;
+			data.push({ mode_of_payment, amount: 0 });
+		});
+		return data;
+	}
 };
 
 extend_cscript(cur_frm.cscript, new erpnext.selling.POSInvoiceController({ frm: cur_frm }));

erpnext/accounts/doctype/pos_invoice/pos_invoice.json

@@ -30,24 +30,6 @@
   "project",
   "dimension_col_break",
   "cost_center",
-  "customer_po_details",
-  "po_no",
-  "column_break_23",
-  "po_date",
-  "address_and_contact",
-  "customer_address",
-  "address_display",
-  "contact_person",
-  "contact_display",
-  "contact_mobile",
-  "contact_email",
-  "territory",
-  "col_break4",
-  "shipping_address_name",
-  "shipping_address",
-  "company_address",
-  "company_address_display",
-  "company_contact_person",
   "currency_and_price_list",
   "currency",
   "conversion_rate",
@@ -91,14 +73,6 @@
   "base_total_taxes_and_charges",
   "column_break_47",
   "total_taxes_and_charges",
-  "loyalty_points_redemption",
-  "loyalty_points",
-  "loyalty_amount",
-  "redeem_loyalty_points",
-  "column_break_77",
-  "loyalty_program",
-  "loyalty_redemption_account",
-  "loyalty_redemption_cost_center",
   "section_break_49",
   "coupon_code",
   "apply_discount_on",
@@ -118,13 +92,7 @@
   "in_words",
   "total_advance",
   "outstanding_amount",
-  "advances_section",
-  "allocate_advances_automatically",
-  "get_advances",
-  "advances",
-  "payment_schedule_section",
-  "payment_terms_template",
-  "payment_schedule",
+  "payments_tab",
   "payments_section",
   "cash_bank_account",
   "payments",
@@ -137,6 +105,10 @@
   "column_break_90",
   "change_amount",
   "account_for_change_amount",
+  "advances_section",
+  "allocate_advances_automatically",
+  "get_advances",
+  "advances",
   "column_break4",
   "write_off_amount",
   "base_write_off_amount",
@@ -144,9 +116,41 @@
   "column_break_74",
   "write_off_account",
   "write_off_cost_center",
+  "loyalty_points_redemption",
+  "loyalty_points",
+  "loyalty_amount",
+  "redeem_loyalty_points",
+  "column_break_77",
+  "loyalty_program",
+  "loyalty_redemption_account",
+  "loyalty_redemption_cost_center",
+  "contact_and_address_tab",
+  "address_and_contact",
+  "customer_address",
+  "address_display",
+  "contact_person",
+  "contact_display",
+  "contact_mobile",
+  "contact_email",
+  "territory",
+  "col_break4",
+  "shipping_address_name",
+  "shipping_address",
+  "company_address",
+  "company_address_display",
+  "company_contact_person",
+  "terms_tab",
+  "payment_schedule_section",
+  "payment_terms_template",
+  "payment_schedule",
   "terms_section_break",
   "tc_name",
   "terms",
+  "more_info_tab",
+  "customer_po_details",
+  "po_no",
+  "column_break_23",
+  "po_date",
   "edit_printing_settings",
   "letter_head",
   "group_same_items",
@@ -398,7 +402,6 @@
    "label": "Customer's Purchase Order Date"
   },
   {
-   "collapsible": 1,
    "fieldname": "address_and_contact",
    "fieldtype": "Section Break",
    "label": "Address and Contact"
@@ -1050,7 +1053,6 @@
    "print_hide": 1
   },
   {
-   "collapsible": 1,
    "collapsible_depends_on": "eval:(!doc.is_pos && !doc.is_return)",
    "fieldname": "payment_schedule_section",
    "fieldtype": "Section Break",
@@ -1130,8 +1132,10 @@
    "read_only": 1
   },
   {
+   "collapsible": 1,
    "fieldname": "section_break_88",
-   "fieldtype": "Section Break"
+   "fieldtype": "Section Break",
+   "label": "Changes"
   },
   {
    "depends_on": "is_pos",
@@ -1218,7 +1222,6 @@
    "print_hide": 1
   },
   {
-   "collapsible": 1,
    "collapsible_depends_on": "terms",
    "fieldname": "terms_section_break",
    "fieldtype": "Section Break",
@@ -1330,7 +1333,7 @@
    "in_standard_filter": 1,
    "label": "Status",
    "no_copy": 1,
-   "options": "\nDraft\nReturn\nCredit Note Issued\nConsolidated\nSubmitted\nPaid\nUnpaid\nUnpaid and Discounted\nOverdue and Discounted\nOverdue\nCancelled",
+   "options": "\nDraft\nReturn\nCredit Note Issued\nConsolidated\nSubmitted\nPaid\nPartly Paid\nUnpaid\nPartly Paid and Discounted\nUnpaid and Discounted\nOverdue and Discounted\nOverdue\nCancelled",
    "print_hide": 1,
    "read_only": 1
   },
@@ -1416,6 +1419,8 @@
    "width": "50%"
   },
   {
+   "fetch_from": "sales_partner.commission_rate",
+   "fetch_if_empty": 1,
    "fieldname": "commission_rate",
    "fieldtype": "Float",
    "label": "Commission Rate (%)",
@@ -1568,12 +1573,32 @@
    "label": "Company Contact Person",
    "options": "Contact",
    "print_hide": 1
+  },
+  {
+   "fieldname": "payments_tab",
+   "fieldtype": "Tab Break",
+   "label": "Payments"
+  },
+  {
+   "fieldname": "contact_and_address_tab",
+   "fieldtype": "Tab Break",
+   "label": "Address & Contact"
+  },
+  {
+   "fieldname": "terms_tab",
+   "fieldtype": "Tab Break",
+   "label": "Terms"
+  },
+  {
+   "fieldname": "more_info_tab",
+   "fieldtype": "Tab Break",
+   "label": "More Info"
   }
  ],
  "icon": "fa fa-file-text",
  "is_submittable": 1,
  "links": [],
- "modified": "2025-01-06 15:03:19.957277",
+ "modified": "2025-07-18 16:50:30.516162",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice",
@@ -1618,6 +1643,7 @@
    "role": "All"
   }
  ],
+ "row_format": "Dynamic",
  "search_fields": "posting_date, due_date, customer, base_grand_total, outstanding_amount",
  "show_name_in_global_search": 1,
  "sort_field": "creation",

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -149,7 +149,9 @@ class POSInvoice(SalesInvoice):
 			"Consolidated",
 			"Submitted",
 			"Paid",
+			"Partly Paid",
 			"Unpaid",
+			"Partly Paid and Discounted",
 			"Unpaid and Discounted",
 			"Overdue and Discounted",
 			"Overdue",
@@ -220,6 +222,9 @@ class POSInvoice(SalesInvoice):
 
 			validate_coupon_code(self.coupon_code)
 
+	def before_submit(self):
+		self.set_outstanding_amount()
+
 	def on_submit(self):
 		# create the loyalty point ledger entry if the customer is enrolled in any loyalty program
 		if not self.is_return and self.loyalty_program:
@@ -243,7 +248,7 @@ class POSInvoice(SalesInvoice):
 			update_coupon_code_count(self.coupon_code, "used")
 		self.clear_unallocated_mode_of_payments()
 
-		if self.is_return and self.is_pos_using_sales_invoice:
+		if self.is_return and self.invoice_type_in_pos == "Sales Invoice":
 			self.create_and_add_consolidated_sales_invoice()
 
 	def before_cancel(self):
@@ -276,6 +281,8 @@ class POSInvoice(SalesInvoice):
 			against_psi_doc.delete_loyalty_point_entry()
 			against_psi_doc.make_loyalty_point_entry()
 
+		self.db_set("status", "Cancelled")
+
 		if self.coupon_code:
 			from erpnext.accounts.doctype.pricing_rule.utils import update_coupon_code_count
 
@@ -371,18 +378,6 @@ class POSInvoice(SalesInvoice):
 						_("Payment related to {0} is not completed").format(pay.mode_of_payment)
 					)
 
-	def validate_pos_opening_entry(self):
-		opening_entries = frappe.get_list(
-			"POS Opening Entry", filters={"pos_profile": self.pos_profile, "status": "Open", "docstatus": 1}
-		)
-		if len(opening_entries) == 0:
-			frappe.throw(
-				title=_("POS Opening Entry Missing"),
-				msg=_("No open POS Opening Entry found for POS Profile {0}.").format(
-					frappe.bold(self.pos_profile)
-				),
-			)
-
 	def validate_stock_availablility(self):
 		if self.is_return:
 			return
@@ -422,10 +417,8 @@ class POSInvoice(SalesInvoice):
 					)
 
 	def validate_is_pos_using_sales_invoice(self):
-		self.is_pos_using_sales_invoice = frappe.db.get_single_value(
-			"Accounts Settings", "use_sales_invoice_in_pos"
-		)
-		if self.is_pos_using_sales_invoice and not self.is_return:
+		self.invoice_type_in_pos = frappe.db.get_single_value("POS Settings", "invoice_type")
+		if self.invoice_type_in_pos == "Sales Invoice" and not self.is_return:
 			frappe.throw(_("Sales Invoice mode is activated in POS. Please create Sales Invoice instead."))
 
 	def validate_serialised_or_batched_item(self):
@@ -537,6 +530,10 @@ class POSInvoice(SalesInvoice):
 				)
 			)
 
+	def set_outstanding_amount(self):
+		total = flt(self.rounded_total) or flt(self.grand_total)
+		self.outstanding_amount = total - flt(self.paid_amount) if total > flt(self.paid_amount) else 0
+
 	def validate_loyalty_transaction(self):
 		if self.redeem_loyalty_points and (
 			not self.loyalty_redemption_account or not self.loyalty_redemption_cost_center
@@ -558,6 +555,8 @@ class POSInvoice(SalesInvoice):
 				self.status = "Draft"
 			return
 
+		total = flt(self.rounded_total) or flt(self.grand_total)
+
 		if not status:
 			if self.docstatus == 2:
 				status = "Cancelled"
@@ -573,6 +572,14 @@ class POSInvoice(SalesInvoice):
 					self.status = "Overdue and Discounted"
 				elif flt(self.outstanding_amount) > 0 and getdate(self.due_date) < getdate(nowdate()):
 					self.status = "Overdue"
+				elif (
+					0 < flt(self.outstanding_amount) < total
+					and self.is_discounted
+					and self.get_discounting_status() == "Disbursed"
+				):
+					self.status = "Partly Paid and Discounted"
+				elif 0 < flt(self.outstanding_amount) < total:
+					self.status = "Partly Paid"
 				elif (
 					flt(self.outstanding_amount) > 0
 					and getdate(self.due_date) >= getdate(nowdate())
@@ -793,6 +800,48 @@ class POSInvoice(SalesInvoice):
 		if pr:
 			return frappe.get_doc("Payment Request", pr)
 
+	@frappe.whitelist()
+	def update_payments(self, payments):
+		if self.status == "Consolidated":
+			frappe.throw(_("Create Payment Entry for Consolidated POS Invoices."))
+
+		paid_amount = flt(self.paid_amount)
+		total = flt(self.rounded_total) or flt(self.grand_total)
+
+		if paid_amount >= total:
+			frappe.throw(title=_("Invoice Paid"), msg=_("This invoice has already been paid."))
+
+		idx = self.payments[-1].idx if self.payments else -1
+
+		for d in payments:
+			idx += 1
+			payment = create_payments_on_invoice(self, idx, frappe._dict(d))
+			paid_amount += flt(payment.amount)
+			payment.submit()
+
+		paid_amount = flt(flt(paid_amount), self.precision("paid_amount"))
+		base_paid_amount = flt(flt(paid_amount * self.conversion_rate), self.precision("base_paid_amount"))
+		outstanding_amount = (
+			flt(flt(total - paid_amount), self.precision("outstanding_amount")) if total > paid_amount else 0
+		)
+		change_amount = (
+			flt(flt(paid_amount - total), self.precision("change_amount")) if paid_amount > total else 0
+		)
+
+		pi = frappe.qb.DocType("POS Invoice")
+		query = (
+			frappe.qb.update(pi)
+			.set(pi.paid_amount, paid_amount)
+			.set(pi.base_paid_amount, base_paid_amount)
+			.set(pi.outstanding_amount, outstanding_amount)
+			.set(pi.change_amount, change_amount)
+			.where(pi.name == self.name)
+		)
+		query.run()
+		self.reload()
+
+		self.set_status(update=True)
+
 
 @frappe.whitelist()
 def get_stock_availability(item_code, warehouse):
@@ -944,3 +993,19 @@ def get_item_group(pos_profile):
 			item_groups.extend(get_descendants_of("Item Group", row.item_group))
 
 	return list(set(item_groups))
+
+
+def create_payments_on_invoice(doc, idx, payment_details):
+	from erpnext.accounts.doctype.sales_invoice.sales_invoice import get_bank_cash_account
+
+	payment = frappe.new_doc("Sales Invoice Payment")
+	payment.idx = idx
+	payment.mode_of_payment = payment_details.mode_of_payment
+	payment.amount = payment_details.amount
+	payment.base_amount = payment.amount * doc.conversion_rate
+	payment.parent = doc.name
+	payment.parentfield = "payments"
+	payment.parenttype = doc.doctype
+	payment.account = get_bank_cash_account(payment.mode_of_payment, doc.company).get("account")
+
+	return payment

erpnext/accounts/doctype/pos_invoice/pos_invoice_list.js

@@ -18,11 +18,13 @@ frappe.listview_settings["POS Invoice"] = {
 			Draft: "red",
 			Unpaid: "orange",
 			Paid: "green",
+			"Partly Paid": "yellow",
 			Submitted: "blue",
 			Consolidated: "green",
 			Return: "darkgrey",
 			"Unpaid and Discounted": "orange",
 			"Overdue and Discounted": "red",
+			"Partly Paid and Discounted": "yellow",
 			Overdue: "red",
 		};
 		return [__(doc.status), status_color[doc.status], "status,=," + doc.status];

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -29,6 +29,7 @@ class TestPOSInvoice(IntegrationTestCase):
 	def setUpClass(cls):
 		super().setUpClass()
 		cls.enterClassContext(cls.change_settings("Selling Settings", validate_selling_price=0))
+		cls.enterClassContext(cls.change_settings("POS Settings", invoice_type="POS Invoice"))
 		make_stock_entry(target="_Test Warehouse - _TC", item_code="_Test Item", qty=800, basic_rate=100)
 		frappe.db.sql("delete from `tabTax Rule`")
 
@@ -36,10 +37,16 @@ class TestPOSInvoice(IntegrationTestCase):
 		from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
 
 		cls.test_user, cls.pos_profile = init_user_and_profile()
-		create_opening_entry(cls.pos_profile, cls.test_user)
+		cls.opening_entry = create_opening_entry(cls.pos_profile, cls.test_user.name)
 		mode_of_payment = frappe.get_doc("Mode of Payment", "Bank Draft")
 		set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", "_Test Bank - _TC")
 
+	@classmethod
+	def tearDownClass(cls):
+		frappe.db.sql("delete from `tabPOS Invoice`")
+		opening_entry_doc = frappe.get_doc("POS Opening Entry", cls.opening_entry.name)
+		opening_entry_doc.cancel()
+
 	def tearDown(self):
 		if frappe.session.user != "Administrator":
 			frappe.set_user("Administrator")
@@ -394,6 +401,50 @@ class TestPOSInvoice(IntegrationTestCase):
 		pos_inv.insert()
 		self.assertRaises(PartialPaymentValidationError, pos_inv.submit)
 
+	def test_partly_paid_invoices(self):
+		set_allow_partial_payment(self.pos_profile, 1)
+
+		pos_inv = create_pos_invoice(pos_profile=self.pos_profile.name, rate=100, do_not_save=1)
+		pos_inv.append(
+			"payments",
+			{"mode_of_payment": "Cash", "amount": 90},
+		)
+		pos_inv.save()
+		pos_inv.submit()
+
+		self.assertEqual(pos_inv.paid_amount, 90)
+		self.assertEqual(pos_inv.status, "Partly Paid")
+
+		pos_inv.update_payments(payments=[{"mode_of_payment": "Cash", "amount": 10}])
+		self.assertEqual(pos_inv.paid_amount, 100)
+		self.assertEqual(pos_inv.status, "Paid")
+
+		set_allow_partial_payment(self.pos_profile, 0)
+
+	def test_multi_payment_for_partly_paid_invoices(self):
+		set_allow_partial_payment(self.pos_profile, 1)
+
+		pos_inv = create_pos_invoice(pos_profile=self.pos_profile.name, rate=100, do_not_save=1)
+		pos_inv.append(
+			"payments",
+			{"mode_of_payment": "Cash", "amount": 90},
+		)
+		pos_inv.save()
+		pos_inv.submit()
+
+		self.assertEqual(pos_inv.paid_amount, 90)
+		self.assertEqual(pos_inv.status, "Partly Paid")
+
+		pos_inv.update_payments(payments=[{"mode_of_payment": "Cash", "amount": 5}])
+		self.assertEqual(pos_inv.paid_amount, 95)
+		self.assertEqual(pos_inv.status, "Partly Paid")
+
+		pos_inv.update_payments(payments=[{"mode_of_payment": "Cash", "amount": 5}])
+		self.assertEqual(pos_inv.paid_amount, 100)
+		self.assertEqual(pos_inv.status, "Paid")
+
+		set_allow_partial_payment(self.pos_profile, 0)
+
 	def test_serialized_item_transaction(self):
 		from erpnext.stock.doctype.stock_entry.test_stock_entry import make_serialized_item
 
@@ -1082,8 +1133,7 @@ def create_pos_invoice(**args):
 	return pos_inv
 
 
-def make_batch_item(item_name):
-	from erpnext.stock.doctype.item.test_item import make_item
-
-	if not frappe.db.exists(item_name):
-		return make_item(item_name, dict(has_batch_no=1, create_new_batch=1, is_stock_item=1))
+def set_allow_partial_payment(pos_profile, value):
+	pos_profile.reload()
+	pos_profile.allow_partial_payment = value
+	pos_profile.save()

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.json

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

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -29,11 +29,10 @@ class POSInvoiceMergeLog(Document):
 	if TYPE_CHECKING:
 		from frappe.types import DF
 
-		from erpnext.accounts.doctype.pos_invoice_reference.pos_invoice_reference import (
-			POSInvoiceReference,
-		)
+		from erpnext.accounts.doctype.pos_invoice_reference.pos_invoice_reference import POSInvoiceReference
 
 		amended_from: DF.Link | None
+		company: DF.Link
 		consolidated_credit_note: DF.Link | None
 		consolidated_invoice: DF.Link | None
 		customer: DF.Link
@@ -259,6 +258,7 @@ class POSInvoiceMergeLog(Document):
 				if not found:
 					tax.charge_type = "Actual"
 					tax.idx = idx
+					tax.row_id = None
 					idx += 1
 					tax.included_in_print_rate = 0
 					tax.tax_amount = tax.tax_amount_after_discount_amount
@@ -338,6 +338,11 @@ class POSInvoiceMergeLog(Document):
 			invoice.flags.ignore_pos_profile = True
 			invoice.pos_profile = ""
 
+		# Unset Commission Section
+		invoice.set("sales_partner", None)
+		invoice.set("commission_rate", 0)
+		invoice.set("total_commission", 0)
+
 		return invoice
 
 	def get_new_sales_invoice(self):
@@ -491,8 +496,8 @@ def split_invoices_by_accounting_dimension(pos_invoices):
 
 
 def consolidate_pos_invoices(pos_invoices=None, closing_entry=None):
-	invoices = pos_invoices or (closing_entry and closing_entry.get("pos_transactions"))
-	if frappe.flags.in_test and not invoices:
+	invoices = pos_invoices or (closing_entry and closing_entry.get("pos_invoices"))
+	if frappe.in_test and not invoices:
 		invoices = get_all_unconsolidated_invoices()
 
 	invoice_by_customer = get_invoice_customer_map(invoices)
@@ -509,7 +514,7 @@ def unconsolidate_pos_invoices(closing_entry):
 		"POS Invoice Merge Log", filters={"pos_closing_entry": closing_entry.name}, pluck="name"
 	)
 
-	if len(closing_entry.pos_transactions) >= 10:
+	if len(closing_entry.pos_invoices) >= 10:
 		closing_entry.set_status(update=True, status="Queued")
 		enqueue_job(cancel_merge_logs, merge_logs=merge_logs, closing_entry=closing_entry)
 	else:
@@ -583,6 +588,7 @@ def create_merge_logs(invoice_by_customer, closing_entry=None):
 					merge_log.posting_time = (
 						get_time(closing_entry.get("posting_time")) if closing_entry else nowtime()
 					)
+					merge_log.company = closing_entry.get("company") if closing_entry else None
 					merge_log.customer = customer
 					merge_log.pos_closing_entry = closing_entry.get("name") if closing_entry else None
 					merge_log.set("pos_invoices", _invoices)
@@ -654,7 +660,7 @@ def enqueue_job(job, **kwargs):
 			timeout=10000,
 			event="processing_merge_logs",
 			job_id=job_id,
-			now=frappe.conf.developer_mode or frappe.flags.in_test,
+			now=frappe.conf.developer_mode or frappe.in_test,
 		)
 
 		if job == create_merge_logs:
@@ -666,7 +672,7 @@ def enqueue_job(job, **kwargs):
 
 
 def check_scheduler_status():
-	if is_scheduler_inactive() and not frappe.flags.in_test:
+	if is_scheduler_inactive() and not frappe.in_test:
 		frappe.throw(_("Scheduler is inactive. Cannot enqueue job."), title=_("Scheduler Inactive"))
 
 

erpnext/accounts/doctype/pos_invoice_merge_log/test_pos_invoice_merge_log.py

@@ -3,268 +3,332 @@
 import json
 
 import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 
+from erpnext.accounts.doctype.mode_of_payment.test_mode_of_payment import (
+	set_default_account_for_mode_of_payment,
+)
+from erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry import (
+	make_closing_entry_from_opening,
+)
 from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import init_user_and_profile
 from erpnext.accounts.doctype.pos_invoice.pos_invoice import make_sales_return
 from erpnext.accounts.doctype.pos_invoice.test_pos_invoice import create_pos_invoice
-from erpnext.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import (
-	consolidate_pos_invoices,
-)
+from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
 from erpnext.stock.doctype.serial_and_batch_bundle.test_serial_and_batch_bundle import (
 	get_serial_nos_from_bundle,
 )
 from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry
 
 
-class UnitTestPosInvoiceMergeLog(UnitTestCase):
-	"""
-	Unit tests for PosInvoiceMergeLog.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestPOSInvoiceMergeLog(IntegrationTestCase):
 	@classmethod
 	def setUpClass(cls):
 		super().setUpClass()
+		frappe.db.sql("delete from `tabPOS Opening Entry`")
 		cls.enterClassContext(cls.change_settings("Selling Settings", validate_selling_price=0))
+		cls.enterClassContext(cls.change_settings("POS Settings", invoice_type="POS Invoice"))
+		mode_of_payment = frappe.get_doc("Mode of Payment", "Bank Draft")
+		set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", "_Test Bank - _TC")
+
+	def setUp(self):
+		frappe.db.sql("delete from `tabPOS Invoice`")
+
+	def tearDown(self):
+		frappe.set_user("Administrator")
+		frappe.db.sql("delete from `tabPOS Profile`")
+		frappe.db.sql("delete from `tabPOS Invoice`")
 
 	def test_consolidated_invoice_creation(self):
-		frappe.db.sql("delete from `tabPOS Invoice`")
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
-		try:
-			test_user, pos_profile = init_user_and_profile()
+		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
+		pos_inv.save()
+		pos_inv.submit()
 
-			pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
-			pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
-			pos_inv.save()
-			pos_inv.submit()
+		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
+		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+		pos_inv2.save()
+		pos_inv2.submit()
 
-			pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
-			pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
-			pos_inv2.save()
-			pos_inv2.submit()
+		pos_inv3 = create_pos_invoice(customer="_Test Customer 2", rate=2300, do_not_submit=1)
+		pos_inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2300})
+		pos_inv3.save()
+		pos_inv3.submit()
 
-			pos_inv3 = create_pos_invoice(customer="_Test Customer 2", rate=2300, do_not_submit=1)
-			pos_inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2300})
-			pos_inv3.save()
-			pos_inv3.submit()
+		closing_entry = make_closing_entry_from_opening(opening_entry)
+		closing_entry.insert()
+		closing_entry.submit()
 
-			consolidate_pos_invoices()
+		pos_inv.load_from_db()
+		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv.consolidated_invoice))
 
-			pos_inv.load_from_db()
-			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv.consolidated_invoice))
+		pos_inv3.load_from_db()
+		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv3.consolidated_invoice))
 
-			pos_inv3.load_from_db()
-			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv3.consolidated_invoice))
-
-			self.assertFalse(pos_inv.consolidated_invoice == pos_inv3.consolidated_invoice)
-
-		finally:
-			frappe.set_user("Administrator")
-			frappe.db.sql("delete from `tabPOS Profile`")
-			frappe.db.sql("delete from `tabPOS Invoice`")
+		self.assertFalse(pos_inv.consolidated_invoice == pos_inv3.consolidated_invoice)
 
 	def test_consolidated_credit_note_creation(self):
-		frappe.db.sql("delete from `tabPOS Invoice`")
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
-		try:
-			test_user, pos_profile = init_user_and_profile()
+		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
+		pos_inv.save()
+		pos_inv.submit()
 
-			pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
-			pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
-			pos_inv.save()
-			pos_inv.submit()
+		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
+		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+		pos_inv2.save()
+		pos_inv2.submit()
 
-			pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
-			pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
-			pos_inv2.save()
-			pos_inv2.submit()
+		pos_inv3 = create_pos_invoice(customer="_Test Customer 2", rate=2300, do_not_submit=1)
+		pos_inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2300})
+		pos_inv3.save()
+		pos_inv3.submit()
 
-			pos_inv3 = create_pos_invoice(customer="_Test Customer 2", rate=2300, do_not_submit=1)
-			pos_inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2300})
-			pos_inv3.save()
-			pos_inv3.submit()
+		pos_inv_cn = make_sales_return(pos_inv.name)
+		pos_inv_cn.set("payments", [])
+		pos_inv_cn.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": -100})
+		pos_inv_cn.append(
+			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - _TC", "amount": -200}
+		)
+		pos_inv_cn.paid_amount = -300
+		pos_inv_cn.submit()
 
-			pos_inv_cn = make_sales_return(pos_inv.name)
-			pos_inv_cn.set("payments", [])
-			pos_inv_cn.append(
-				"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": -100}
-			)
-			pos_inv_cn.append(
-				"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - _TC", "amount": -200}
-			)
-			pos_inv_cn.paid_amount = -300
-			pos_inv_cn.submit()
+		closing_entry = make_closing_entry_from_opening(opening_entry)
+		closing_entry.insert()
+		closing_entry.submit()
 
-			consolidate_pos_invoices()
+		pos_inv.load_from_db()
+		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv.consolidated_invoice))
 
-			pos_inv.load_from_db()
-			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv.consolidated_invoice))
+		pos_inv3.load_from_db()
+		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv3.consolidated_invoice))
 
-			pos_inv3.load_from_db()
-			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv3.consolidated_invoice))
-
-			pos_inv_cn.load_from_db()
-			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv_cn.consolidated_invoice))
-			consolidated_credit_note = frappe.get_doc("Sales Invoice", pos_inv_cn.consolidated_invoice)
-			self.assertEqual(consolidated_credit_note.is_return, 1)
-			self.assertEqual(consolidated_credit_note.payments[0].mode_of_payment, "Cash")
-			self.assertEqual(consolidated_credit_note.payments[0].amount, -100)
-			self.assertEqual(consolidated_credit_note.payments[1].mode_of_payment, "Bank Draft")
-			self.assertEqual(consolidated_credit_note.payments[1].amount, -200)
-
-		finally:
-			frappe.set_user("Administrator")
-			frappe.db.sql("delete from `tabPOS Profile`")
-			frappe.db.sql("delete from `tabPOS Invoice`")
+		pos_inv_cn.load_from_db()
+		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv_cn.consolidated_invoice))
+		consolidated_credit_note = frappe.get_doc("Sales Invoice", pos_inv_cn.consolidated_invoice)
+		self.assertEqual(consolidated_credit_note.is_return, 1)
+		self.assertEqual(consolidated_credit_note.payments[0].mode_of_payment, "Cash")
+		self.assertEqual(consolidated_credit_note.payments[0].amount, -100)
+		self.assertEqual(consolidated_credit_note.payments[1].mode_of_payment, "Bank Draft")
+		self.assertEqual(consolidated_credit_note.payments[1].amount, -200)
 
 	def test_consolidated_invoice_item_taxes(self):
-		frappe.db.sql("delete from `tabPOS Invoice`")
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
-		try:
-			inv = create_pos_invoice(qty=1, rate=100, do_not_save=True)
+		inv = create_pos_invoice(qty=1, rate=100, do_not_save=True)
 
-			inv.append(
-				"taxes",
-				{
-					"account_head": "_Test Account VAT - _TC",
-					"charge_type": "On Net Total",
-					"cost_center": "_Test Cost Center - _TC",
-					"description": "VAT",
-					"doctype": "Sales Taxes and Charges",
-					"rate": 9,
-				},
-			)
-			inv.insert()
-			inv.payments[0].amount = inv.grand_total
-			inv.save()
-			inv.submit()
+		inv.append(
+			"taxes",
+			{
+				"account_head": "_Test Account VAT - _TC",
+				"charge_type": "On Net Total",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "VAT",
+				"doctype": "Sales Taxes and Charges",
+				"rate": 9,
+			},
+		)
+		inv.insert()
+		inv.payments[0].amount = inv.grand_total
+		inv.save()
+		inv.submit()
 
-			inv2 = create_pos_invoice(qty=1, rate=100, do_not_save=True)
-			inv2.get("items")[0].item_code = "_Test Item 2"
-			inv2.append(
-				"taxes",
-				{
-					"account_head": "_Test Account VAT - _TC",
-					"charge_type": "On Net Total",
-					"cost_center": "_Test Cost Center - _TC",
-					"description": "VAT",
-					"doctype": "Sales Taxes and Charges",
-					"rate": 5,
-				},
-			)
-			inv2.insert()
-			inv2.payments[0].amount = inv.grand_total
-			inv2.save()
-			inv2.submit()
+		inv2 = create_pos_invoice(qty=1, rate=100, do_not_save=True)
+		inv2.get("items")[0].item_code = "_Test Item 2"
+		inv2.append(
+			"taxes",
+			{
+				"account_head": "_Test Account VAT - _TC",
+				"charge_type": "On Net Total",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "VAT",
+				"doctype": "Sales Taxes and Charges",
+				"rate": 5,
+			},
+		)
+		inv2.insert()
+		inv2.payments[0].amount = inv.grand_total
+		inv2.save()
+		inv2.submit()
 
-			consolidate_pos_invoices()
-			inv.load_from_db()
+		closing_entry = make_closing_entry_from_opening(opening_entry)
+		closing_entry.insert()
+		closing_entry.submit()
 
-			consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
-			item_wise_tax_detail = json.loads(consolidated_invoice.get("taxes")[0].item_wise_tax_detail)
-			expected_item_wise_tax_detail = {
-				"_Test Item": {
-					"tax_rate": 9,
-					"tax_amount": 9,
-					"net_amount": 100,
-				},
-				"_Test Item 2": {
-					"tax_rate": 5,
-					"tax_amount": 5,
-					"net_amount": 100,
-				},
-			}
-			self.assertEqual(item_wise_tax_detail, expected_item_wise_tax_detail)
-		finally:
-			frappe.set_user("Administrator")
-			frappe.db.sql("delete from `tabPOS Profile`")
-			frappe.db.sql("delete from `tabPOS Invoice`")
+		inv.load_from_db()
+
+		consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
+		item_wise_tax_detail = json.loads(consolidated_invoice.get("taxes")[0].item_wise_tax_detail)
+		expected_item_wise_tax_detail = {
+			"_Test Item": {
+				"tax_rate": 9,
+				"tax_amount": 9,
+				"net_amount": 100,
+			},
+			"_Test Item 2": {
+				"tax_rate": 5,
+				"tax_amount": 5,
+				"net_amount": 100,
+			},
+		}
+		self.assertEqual(item_wise_tax_detail, expected_item_wise_tax_detail)
 
 	def test_consolidation_round_off_error_1(self):
 		"""
 		Test round off error in consolidated invoice creation if POS Invoice has inclusive tax
 		"""
 
-		frappe.db.sql("delete from `tabPOS Invoice`")
+		make_stock_entry(
+			to_warehouse="_Test Warehouse - _TC",
+			item_code="_Test Item",
+			rate=8000,
+			qty=10,
+		)
 
-		try:
-			make_stock_entry(
-				to_warehouse="_Test Warehouse - _TC",
-				item_code="_Test Item",
-				rate=8000,
-				qty=10,
-			)
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
-			init_user_and_profile()
+		inv = create_pos_invoice(qty=3, rate=10000, do_not_save=True)
+		inv.append(
+			"taxes",
+			{
+				"account_head": "_Test Account VAT - _TC",
+				"charge_type": "On Net Total",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "VAT",
+				"doctype": "Sales Taxes and Charges",
+				"rate": 7.5,
+				"included_in_print_rate": 1,
+			},
+		)
+		inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 30000})
+		inv.insert()
+		inv.submit()
 
-			inv = create_pos_invoice(qty=3, rate=10000, do_not_save=True)
-			inv.append(
-				"taxes",
-				{
-					"account_head": "_Test Account VAT - _TC",
-					"charge_type": "On Net Total",
-					"cost_center": "_Test Cost Center - _TC",
-					"description": "VAT",
-					"doctype": "Sales Taxes and Charges",
-					"rate": 7.5,
-					"included_in_print_rate": 1,
-				},
-			)
-			inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 30000})
-			inv.insert()
-			inv.submit()
+		inv2 = create_pos_invoice(qty=3, rate=10000, do_not_save=True)
+		inv2.append(
+			"taxes",
+			{
+				"account_head": "_Test Account VAT - _TC",
+				"charge_type": "On Net Total",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "VAT",
+				"doctype": "Sales Taxes and Charges",
+				"rate": 7.5,
+				"included_in_print_rate": 1,
+			},
+		)
+		inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 30000})
+		inv2.insert()
+		inv2.submit()
 
-			inv2 = create_pos_invoice(qty=3, rate=10000, do_not_save=True)
-			inv2.append(
-				"taxes",
-				{
-					"account_head": "_Test Account VAT - _TC",
-					"charge_type": "On Net Total",
-					"cost_center": "_Test Cost Center - _TC",
-					"description": "VAT",
-					"doctype": "Sales Taxes and Charges",
-					"rate": 7.5,
-					"included_in_print_rate": 1,
-				},
-			)
-			inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 30000})
-			inv2.insert()
-			inv2.submit()
+		closing_entry = make_closing_entry_from_opening(opening_entry)
+		closing_entry.insert()
+		closing_entry.submit()
 
-			consolidate_pos_invoices()
-
-			inv.load_from_db()
-			consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
-			self.assertEqual(consolidated_invoice.outstanding_amount, 0)
-			self.assertEqual(consolidated_invoice.status, "Paid")
-
-		finally:
-			frappe.set_user("Administrator")
-			frappe.db.sql("delete from `tabPOS Profile`")
-			frappe.db.sql("delete from `tabPOS Invoice`")
+		inv.load_from_db()
+		consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
+		self.assertEqual(consolidated_invoice.outstanding_amount, 0)
+		self.assertEqual(consolidated_invoice.status, "Paid")
 
 	def test_consolidation_round_off_error_2(self):
 		"""
 		Test the same case as above but with an Unpaid POS Invoice
 		"""
-		frappe.db.sql("delete from `tabPOS Invoice`")
+		make_stock_entry(
+			to_warehouse="_Test Warehouse - _TC",
+			item_code="_Test Item",
+			rate=8000,
+			qty=10,
+		)
 
-		try:
-			make_stock_entry(
-				to_warehouse="_Test Warehouse - _TC",
-				item_code="_Test Item",
-				rate=8000,
-				qty=10,
-			)
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
-			init_user_and_profile()
+		inv = create_pos_invoice(qty=6, rate=10000, do_not_save=True)
+		inv.append(
+			"taxes",
+			{
+				"account_head": "_Test Account VAT - _TC",
+				"charge_type": "On Net Total",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "VAT",
+				"doctype": "Sales Taxes and Charges",
+				"rate": 7.5,
+				"included_in_print_rate": 1,
+			},
+		)
+		inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 60000})
+		inv.insert()
+		inv.submit()
 
-			inv = create_pos_invoice(qty=6, rate=10000, do_not_save=True)
+		inv2 = create_pos_invoice(qty=6, rate=10000, do_not_save=True)
+		inv2.append(
+			"taxes",
+			{
+				"account_head": "_Test Account VAT - _TC",
+				"charge_type": "On Net Total",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "VAT",
+				"doctype": "Sales Taxes and Charges",
+				"rate": 7.5,
+				"included_in_print_rate": 1,
+			},
+		)
+		inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 60000})
+		inv2.insert()
+		inv2.submit()
+
+		inv3 = create_pos_invoice(qty=3, rate=600, do_not_save=True)
+		inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1800})
+		inv3.insert()
+		inv3.submit()
+
+		closing_entry = make_closing_entry_from_opening(opening_entry)
+		closing_entry.insert()
+		closing_entry.submit()
+
+		inv.load_from_db()
+		consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
+		self.assertNotEqual(consolidated_invoice.outstanding_amount, 800)
+		self.assertEqual(consolidated_invoice.status, "Paid")
+
+	@IntegrationTestCase.change_settings(
+		"System Settings", {"number_format": "#,###.###", "currency_precision": 3, "float_precision": 3}
+	)
+	def test_consolidation_round_off_error_3(self):
+		make_stock_entry(
+			to_warehouse="_Test Warehouse - _TC",
+			item_code="_Test Item",
+			rate=8000,
+			qty=10,
+		)
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
+
+		item_rates = [69, 59, 29]
+		for _i in [1, 2]:
+			inv = create_pos_invoice(is_return=1, do_not_save=1)
+			inv.items = []
+			for rate in item_rates:
+				inv.append(
+					"items",
+					{
+						"item_code": "_Test Item",
+						"warehouse": "_Test Warehouse - _TC",
+						"qty": -1,
+						"rate": rate,
+						"income_account": "Sales - _TC",
+						"expense_account": "Cost of Goods Sold - _TC",
+						"cost_center": "_Test Cost Center - _TC",
+					},
+				)
 			inv.append(
 				"taxes",
 				{
@@ -273,146 +337,56 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 					"cost_center": "_Test Cost Center - _TC",
 					"description": "VAT",
 					"doctype": "Sales Taxes and Charges",
-					"rate": 7.5,
+					"rate": 15,
 					"included_in_print_rate": 1,
 				},
 			)
-			inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 60000})
-			inv.insert()
+			inv.payments = []
+			inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": -157})
+			inv.paid_amount = -157
+			inv.save()
 			inv.submit()
 
-			inv2 = create_pos_invoice(qty=6, rate=10000, do_not_save=True)
-			inv2.append(
-				"taxes",
-				{
-					"account_head": "_Test Account VAT - _TC",
-					"charge_type": "On Net Total",
-					"cost_center": "_Test Cost Center - _TC",
-					"description": "VAT",
-					"doctype": "Sales Taxes and Charges",
-					"rate": 7.5,
-					"included_in_print_rate": 1,
-				},
-			)
-			inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 60000})
-			inv2.insert()
-			inv2.submit()
+		closing_entry = make_closing_entry_from_opening(opening_entry)
+		closing_entry.insert()
+		closing_entry.submit()
 
-			inv3 = create_pos_invoice(qty=3, rate=600, do_not_save=True)
-			inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1800})
-			inv3.insert()
-			inv3.submit()
-
-			consolidate_pos_invoices()
-
-			inv.load_from_db()
-			consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
-			self.assertNotEqual(consolidated_invoice.outstanding_amount, 800)
-			self.assertEqual(consolidated_invoice.status, "Paid")
-
-		finally:
-			frappe.set_user("Administrator")
-			frappe.db.sql("delete from `tabPOS Profile`")
-			frappe.db.sql("delete from `tabPOS Invoice`")
-
-	@IntegrationTestCase.change_settings(
-		"System Settings", {"number_format": "#,###.###", "currency_precision": 3, "float_precision": 3}
-	)
-	def test_consolidation_round_off_error_3(self):
-		frappe.db.sql("delete from `tabPOS Invoice`")
-
-		try:
-			make_stock_entry(
-				to_warehouse="_Test Warehouse - _TC",
-				item_code="_Test Item",
-				rate=8000,
-				qty=10,
-			)
-			init_user_and_profile()
-
-			item_rates = [69, 59, 29]
-			for _i in [1, 2]:
-				inv = create_pos_invoice(is_return=1, do_not_save=1)
-				inv.items = []
-				for rate in item_rates:
-					inv.append(
-						"items",
-						{
-							"item_code": "_Test Item",
-							"warehouse": "_Test Warehouse - _TC",
-							"qty": -1,
-							"rate": rate,
-							"income_account": "Sales - _TC",
-							"expense_account": "Cost of Goods Sold - _TC",
-							"cost_center": "_Test Cost Center - _TC",
-						},
-					)
-				inv.append(
-					"taxes",
-					{
-						"account_head": "_Test Account VAT - _TC",
-						"charge_type": "On Net Total",
-						"cost_center": "_Test Cost Center - _TC",
-						"description": "VAT",
-						"doctype": "Sales Taxes and Charges",
-						"rate": 15,
-						"included_in_print_rate": 1,
-					},
-				)
-				inv.payments = []
-				inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": -157})
-				inv.paid_amount = -157
-				inv.save()
-				inv.submit()
-
-			consolidate_pos_invoices()
-
-			inv.load_from_db()
-			consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
-			self.assertEqual(consolidated_invoice.status, "Return")
-			self.assertEqual(consolidated_invoice.rounding_adjustment, -0.002)
-
-		finally:
-			frappe.set_user("Administrator")
-			frappe.db.sql("delete from `tabPOS Profile`")
-			frappe.db.sql("delete from `tabPOS Invoice`")
+		inv.load_from_db()
+		consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
+		self.assertEqual(consolidated_invoice.status, "Return")
+		self.assertEqual(consolidated_invoice.rounding_adjustment, -0.002)
 
 	def test_consolidation_rounding_adjustment(self):
 		"""
 		Test if the rounding adjustment is calculated correctly
 		"""
-		frappe.db.sql("delete from `tabPOS Invoice`")
+		make_stock_entry(
+			to_warehouse="_Test Warehouse - _TC",
+			item_code="_Test Item",
+			rate=8000,
+			qty=10,
+		)
 
-		try:
-			make_stock_entry(
-				to_warehouse="_Test Warehouse - _TC",
-				item_code="_Test Item",
-				rate=8000,
-				qty=10,
-			)
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
-			init_user_and_profile()
+		inv = create_pos_invoice(qty=1, rate=69.5, do_not_save=True)
+		inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 70})
+		inv.insert()
+		inv.submit()
 
-			inv = create_pos_invoice(qty=1, rate=69.5, do_not_save=True)
-			inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 70})
-			inv.insert()
-			inv.submit()
+		inv2 = create_pos_invoice(qty=1, rate=59.5, do_not_save=True)
+		inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 60})
+		inv2.insert()
+		inv2.submit()
 
-			inv2 = create_pos_invoice(qty=1, rate=59.5, do_not_save=True)
-			inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 60})
-			inv2.insert()
-			inv2.submit()
+		closing_entry = make_closing_entry_from_opening(opening_entry)
+		closing_entry.insert()
+		closing_entry.submit()
 
-			consolidate_pos_invoices()
-
-			inv.load_from_db()
-			consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
-			self.assertEqual(consolidated_invoice.rounding_adjustment, 1)
-
-		finally:
-			frappe.set_user("Administrator")
-			frappe.db.sql("delete from `tabPOS Profile`")
-			frappe.db.sql("delete from `tabPOS Invoice`")
+		inv.load_from_db()
+		consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
+		self.assertEqual(consolidated_invoice.rounding_adjustment, 1)
 
 	def test_serial_no_case_1(self):
 		"""
@@ -427,51 +401,46 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 
 		from erpnext.stock.doctype.stock_entry.test_stock_entry import make_serialized_item
 
-		frappe.db.sql("delete from `tabPOS Invoice`")
+		se = make_serialized_item(self)
+		serial_no = get_serial_nos_from_bundle(se.get("items")[0].serial_and_batch_bundle)[0]
 
-		try:
-			se = make_serialized_item(self)
-			serial_no = get_serial_nos_from_bundle(se.get("items")[0].serial_and_batch_bundle)[0]
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
-			init_user_and_profile()
+		pos_inv = create_pos_invoice(
+			item_code="_Test Serialized Item With Series",
+			serial_no=[serial_no],
+			qty=1,
+			rate=100,
+			do_not_submit=1,
+		)
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+		pos_inv.save()
+		pos_inv.submit()
 
-			pos_inv = create_pos_invoice(
-				item_code="_Test Serialized Item With Series",
-				serial_no=[serial_no],
-				qty=1,
-				rate=100,
-				do_not_submit=1,
-			)
-			pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
-			pos_inv.save()
-			pos_inv.submit()
+		pos_inv_cn = make_sales_return(pos_inv.name)
+		pos_inv_cn.paid_amount = -100
+		pos_inv_cn.submit()
 
-			pos_inv_cn = make_sales_return(pos_inv.name)
-			pos_inv_cn.paid_amount = -100
-			pos_inv_cn.submit()
+		pos_inv2 = create_pos_invoice(
+			item_code="_Test Serialized Item With Series",
+			serial_no=[serial_no],
+			qty=1,
+			rate=100,
+			do_not_submit=1,
+		)
+		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+		pos_inv2.save()
+		pos_inv2.submit()
 
-			pos_inv2 = create_pos_invoice(
-				item_code="_Test Serialized Item With Series",
-				serial_no=[serial_no],
-				qty=1,
-				rate=100,
-				do_not_submit=1,
-			)
-			pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
-			pos_inv2.save()
-			pos_inv2.submit()
+		closing_entry = make_closing_entry_from_opening(opening_entry)
+		closing_entry.insert()
+		closing_entry.submit()
 
-			consolidate_pos_invoices()
+		pos_inv.load_from_db()
+		pos_inv2.load_from_db()
 
-			pos_inv.load_from_db()
-			pos_inv2.load_from_db()
-
-			self.assertNotEqual(pos_inv.consolidated_invoice, pos_inv2.consolidated_invoice)
-
-		finally:
-			frappe.set_user("Administrator")
-			frappe.db.sql("delete from `tabPOS Profile`")
-			frappe.db.sql("delete from `tabPOS Invoice`")
+		self.assertNotEqual(pos_inv.consolidated_invoice, pos_inv2.consolidated_invoice)
 
 	def test_separate_consolidated_invoice_for_different_accounting_dimensions(self):
 		"""
@@ -482,48 +451,66 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		"""
 		from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
 
-		frappe.db.sql("delete from `tabPOS Invoice`")
-
 		create_cost_center(cost_center_name="_Test POS Cost Center 1", is_group=0)
 		create_cost_center(cost_center_name="_Test POS Cost Center 2", is_group=0)
 
-		try:
-			test_user, pos_profile = init_user_and_profile()
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
-			pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
-			pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
-			pos_inv.cost_center = "_Test POS Cost Center 1 - _TC"
-			pos_inv.save()
-			pos_inv.submit()
+		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
+		pos_inv.cost_center = "_Test POS Cost Center 1 - _TC"
+		pos_inv.save()
+		pos_inv.submit()
 
-			pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
-			pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
-			pos_inv.cost_center = "_Test POS Cost Center 2 - _TC"
-			pos_inv2.save()
-			pos_inv2.submit()
+		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
+		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+		pos_inv.cost_center = "_Test POS Cost Center 2 - _TC"
+		pos_inv2.save()
+		pos_inv2.submit()
 
-			pos_inv3 = create_pos_invoice(rate=2300, do_not_submit=1)
-			pos_inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2300})
-			pos_inv.cost_center = "_Test POS Cost Center 2 - _TC"
-			pos_inv3.save()
-			pos_inv3.submit()
+		pos_inv3 = create_pos_invoice(rate=2300, do_not_submit=1)
+		pos_inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2300})
+		pos_inv.cost_center = "_Test POS Cost Center 2 - _TC"
+		pos_inv3.save()
+		pos_inv3.submit()
 
-			consolidate_pos_invoices()
+		closing_entry = make_closing_entry_from_opening(opening_entry)
+		closing_entry.insert()
+		closing_entry.submit()
 
-			pos_inv.load_from_db()
-			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv.consolidated_invoice))
+		pos_inv.load_from_db()
+		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv.consolidated_invoice))
 
-			pos_inv2.load_from_db()
-			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv2.consolidated_invoice))
+		pos_inv2.load_from_db()
+		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv2.consolidated_invoice))
 
-			self.assertFalse(pos_inv.consolidated_invoice == pos_inv3.consolidated_invoice)
+		self.assertFalse(pos_inv.consolidated_invoice == pos_inv3.consolidated_invoice)
 
-			pos_inv3.load_from_db()
-			self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv3.consolidated_invoice))
+		pos_inv3.load_from_db()
+		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv3.consolidated_invoice))
 
-			self.assertTrue(pos_inv2.consolidated_invoice == pos_inv3.consolidated_invoice)
+		self.assertTrue(pos_inv2.consolidated_invoice == pos_inv3.consolidated_invoice)
 
-		finally:
-			frappe.set_user("Administrator")
-			frappe.db.sql("delete from `tabPOS Profile`")
-			frappe.db.sql("delete from `tabPOS Invoice`")
+	def test_company_in_pos_invoice_merge_log(self):
+		"""
+		Test if the company is fetched from POS Closing Entry
+		"""
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
+
+		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
+		pos_inv.save()
+		pos_inv.submit()
+
+		closing_entry = make_closing_entry_from_opening(opening_entry)
+		closing_entry.insert()
+		closing_entry.submit()
+
+		self.assertTrue(frappe.db.exists("POS Invoice Merge Log", {"pos_closing_entry": closing_entry.name}))
+
+		pos_merge_log_company = frappe.db.get_value(
+			"POS Invoice Merge Log", {"pos_closing_entry": closing_entry.name}, "company"
+		)
+		self.assertEqual(pos_merge_log_company, closing_entry.company)

erpnext/accounts/doctype/pos_opening_entry/pos_opening_entry.py

@@ -37,6 +37,8 @@ class POSOpeningEntry(StatusUpdater):
 
 	def validate(self):
 		self.validate_pos_profile_and_cashier()
+		self.check_open_pos_exists()
+		self.check_user_already_assigned()
 		self.validate_payment_method_account()
 		self.set_status()
 
@@ -49,6 +51,22 @@ class POSOpeningEntry(StatusUpdater):
 		if not cint(frappe.db.get_value("User", self.user, "enabled")):
 			frappe.throw(_("User {} is disabled. Please select valid user/cashier").format(self.user))
 
+	def check_open_pos_exists(self):
+		if frappe.db.exists("POS Opening Entry", {"pos_profile": self.pos_profile, "status": "Open"}):
+			frappe.throw(
+				title=_("POS Opening Entry Exists"),
+				msg=_(
+					"{0} is open. Close the POS or cancel the existing POS Opening Entry to create a new POS Opening Entry."
+				).format(frappe.bold(self.pos_profile)),
+			)
+
+	def check_user_already_assigned(self):
+		if frappe.db.exists("POS Opening Entry", {"user": self.user, "status": "Open"}):
+			frappe.throw(
+				title=_("Cannot Assign Cashier"),
+				msg=_("Cashier is currently assigned to another POS."),
+			)
+
 	def validate_payment_method_account(self):
 		invalid_modes = []
 		for d in self.balance_details:
@@ -71,5 +89,25 @@ class POSOpeningEntry(StatusUpdater):
 	def on_submit(self):
 		self.set_status(update=True)
 
+	def before_cancel(self):
+		self.check_poe_is_cancellable()
+
 	def on_cancel(self):
 		self.set_status(update=True)
+		frappe.publish_realtime(
+			f"poe_{self.name}",
+			message={"operation": "Cancelled"},
+			docname=f"POS Opening Entry/{self.name}",
+		)
+
+	def check_poe_is_cancellable(self):
+		from erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry import get_invoices
+
+		invoices = get_invoices(
+			self.period_start_date, frappe.utils.get_datetime(), self.pos_profile, self.user
+		)
+		if invoices.get("invoices"):
+			frappe.throw(
+				title=_("POS Opening Entry Cancellation Error"),
+				msg=_("POS Opening Entry cannot be cancelled as unconsolidated Invoices exists."),
+			)

erpnext/accounts/doctype/pos_opening_entry/test_pos_opening_entry.py

@@ -3,14 +3,107 @@
 import unittest
 
 import frappe
+from frappe.core.doctype.user_permission.test_user_permission import create_user
 from frappe.tests import IntegrationTestCase
 
+from erpnext.accounts.doctype.pos_invoice.test_pos_invoice import create_pos_invoice
+from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
+from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
+
 
 class TestPOSOpeningEntry(IntegrationTestCase):
-	pass
+	@classmethod
+	def setUpClass(cls):
+		frappe.db.sql("delete from `tabPOS Opening Entry`")
+		cls.enterClassContext(cls.change_settings("POS Settings", {"invoice_type": "POS Invoice"}))
+
+	@classmethod
+	def tearDownClass(cls):
+		frappe.db.sql("delete from `tabPOS Opening Entry`")
+
+	def setUp(self):
+		# Make stock available for POS Sales
+		frappe.db.sql("delete from `tabPOS Opening Entry`")
+		make_stock_entry(target="_Test Warehouse - _TC", qty=2, basic_rate=100)
+		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import init_user_and_profile
+
+		self.init_user_and_profile = init_user_and_profile
+
+	def tearDown(self):
+		frappe.set_user("Administrator")
+		frappe.db.sql("delete from `tabPOS Profile`")
+
+	def test_pos_opening_entry(self):
+		test_user, pos_profile = self.init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
+
+		self.assertEqual(opening_entry.status, "Open")
+		self.assertNotEqual(opening_entry.docstatus, 0)
+
+	def test_multiple_pos_opening_entries_for_same_pos_profile(self):
+		test_user, pos_profile = self.init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
+
+		self.assertEqual(opening_entry.status, "Open")
+		with self.assertRaises(frappe.ValidationError):
+			create_opening_entry(pos_profile, test_user.name)
+
+	def test_multiple_pos_opening_entry_for_multiple_pos_profiles(self):
+		test_user, pos_profile = self.init_user_and_profile()
+		opening_entry_1 = create_opening_entry(pos_profile, test_user.name)
+
+		self.assertEqual(opening_entry_1.status, "Open")
+		self.assertEqual(opening_entry_1.user, test_user.name)
+
+		cashier_user = create_user("test_cashier@example.com", "Accounts Manager", "Sales Manager")
+		frappe.set_user(cashier_user.name)
+
+		pos_profile2 = make_pos_profile(name="_Test POS Profile 2")
+		opening_entry_2 = create_opening_entry(pos_profile2, cashier_user.name)
+
+		self.assertEqual(opening_entry_2.status, "Open")
+		self.assertEqual(opening_entry_2.user, cashier_user.name)
+
+	def test_multiple_pos_opening_entry_for_same_pos_profile_by_multiple_user(self):
+		test_user, pos_profile = self.init_user_and_profile()
+		cashier_user = create_user("test_cashier@example.com", "Accounts Manager", "Sales Manager")
+
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
+		self.assertEqual(opening_entry.status, "Open")
+
+		with self.assertRaises(frappe.ValidationError):
+			create_opening_entry(pos_profile, cashier_user.name)
+
+	def test_user_assignment_to_multiple_pos_profile(self):
+		test_user, pos_profile = self.init_user_and_profile()
+		opening_entry_1 = create_opening_entry(pos_profile, test_user.name)
+		self.assertEqual(opening_entry_1.user, test_user.name)
+
+		pos_profile2 = make_pos_profile(name="_Test POS Profile 2")
+		with self.assertRaises(frappe.ValidationError):
+			create_opening_entry(pos_profile2, test_user.name)
+
+	def test_cancel_pos_opening_entry_without_invoices(self):
+		test_user, pos_profile = self.init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name, get_obj=True)
+
+		opening_entry.cancel()
+		self.assertEqual(opening_entry.status, "Cancelled")
+		self.assertNotEqual(opening_entry.docstatus, 1)
+
+	def test_cancel_pos_opening_entry_with_invoice(self):
+		test_user, pos_profile = self.init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name, get_obj=True)
+
+		pos_inv1 = create_pos_invoice(pos_profile=pos_profile.name, rate=100, do_not_save=1)
+		pos_inv1.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+		pos_inv1.save()
+		pos_inv1.submit()
+
+		self.assertRaises(frappe.ValidationError, opening_entry.cancel)
 
 
-def create_opening_entry(pos_profile, user):
+def create_opening_entry(pos_profile, user, get_obj=False):
 	entry = frappe.new_doc("POS Opening Entry")
 	entry.pos_profile = pos_profile.name
 	entry.user = user
@@ -24,4 +117,7 @@ def create_opening_entry(pos_profile, user):
 	entry.set("balance_details", balance_details)
 	entry.submit()
 
+	if get_obj:
+		return entry
+
 	return entry.as_dict()

erpnext/accounts/doctype/pos_profile/pos_profile.json

@@ -26,12 +26,14 @@
   "auto_add_item_to_cart",
   "validate_stock_on_save",
   "print_receipt_on_order_complete",
+  "action_on_new_invoice",
   "column_break_16",
   "update_stock",
   "ignore_pricing_rule",
   "allow_rate_change",
   "allow_discount_change",
   "set_grand_total_to_default_mop",
+  "allow_partial_payment",
   "section_break_23",
   "item_groups",
   "column_break_25",
@@ -415,6 +417,19 @@
    "fieldname": "set_grand_total_to_default_mop",
    "fieldtype": "Check",
    "label": "Set Grand Total to Default Payment Method"
+  },
+  {
+   "default": "Always Ask",
+   "fieldname": "action_on_new_invoice",
+   "fieldtype": "Select",
+   "label": "Action on New Invoice",
+   "options": "Always Ask\nSave Changes and Load New Invoice\nDiscard Changes and Load New Invoice"
+  },
+  {
+   "default": "0",
+   "fieldname": "allow_partial_payment",
+   "fieldtype": "Check",
+   "label": "Allow Partial Payment"
   }
  ],
  "grid_page_length": 50,
@@ -443,7 +458,7 @@
    "link_fieldname": "pos_profile"
   }
  ],
- "modified": "2025-05-09 11:23:28.632136",
+ "modified": "2025-06-24 11:19:19.834905",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Profile",

erpnext/accounts/doctype/pos_profile/pos_profile.py

@@ -28,7 +28,11 @@ class POSProfile(Document):
 		from erpnext.accounts.doctype.pos_profile_user.pos_profile_user import POSProfileUser
 
 		account_for_change_amount: DF.Link | None
+		action_on_new_invoice: DF.Literal[
+			"Always Ask", "Save Changes and Load New Invoice", "Discard Changes and Load New Invoice"
+		]
 		allow_discount_change: DF.Check
+		allow_partial_payment: DF.Check
 		allow_rate_change: DF.Check
 		applicable_for_users: DF.Table[POSProfileUser]
 		apply_discount_on: DF.Literal["Grand Total", "Net Total"]

erpnext/accounts/doctype/pos_settings/pos_settings.json

@@ -5,6 +5,8 @@
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
+  "invoice_type",
+  "section_break_gyos",
   "invoice_fields",
   "pos_search_fields"
  ],
@@ -12,7 +14,7 @@
   {
    "fieldname": "invoice_fields",
    "fieldtype": "Table",
-   "label": "POS Field",
+   "label": "POS Additional Fields",
    "options": "POS Field"
   },
   {
@@ -20,11 +22,23 @@
    "fieldtype": "Table",
    "label": "POS Search Fields",
    "options": "POS Search Fields"
+  },
+  {
+   "default": "Sales Invoice",
+   "description": "The system will create a Sales Invoice or a POS Invoice from the POS interface based on this setting. For high-volume transactions, it is recommended to use POS Invoice.",
+   "fieldname": "invoice_type",
+   "fieldtype": "Select",
+   "label": "Invoice Type Created via POS Screen",
+   "options": "Sales Invoice\nPOS Invoice"
+  },
+  {
+   "fieldname": "section_break_gyos",
+   "fieldtype": "Section Break"
   }
  ],
  "issingle": 1,
  "links": [],
- "modified": "2024-03-27 13:10:17.083132",
+ "modified": "2025-06-06 11:36:44.885353",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Settings",
@@ -56,8 +70,9 @@
   }
  ],
  "quick_entry": 1,
+ "row_format": "Dynamic",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/pos_settings/pos_settings.py

@@ -21,10 +21,16 @@ class POSSettings(Document):
 		from erpnext.accounts.doctype.pos_search_fields.pos_search_fields import POSSearchFields
 
 		invoice_fields: DF.Table[POSField]
+		invoice_type: DF.Literal["Sales Invoice", "POS Invoice"]
 		pos_search_fields: DF.Table[POSSearchFields]
 	# end: auto-generated types
 
 	def validate(self):
+		old_doc = self.get_doc_before_save()
+
+		if old_doc.invoice_type != self.invoice_type:
+			self.validate_invoice_type()
+
 		self.validate_invoice_fields()
 
 	def validate_invoice_fields(self):
@@ -36,3 +42,15 @@ class POSSettings(Document):
 				frappe.throw(
 					title=_("Duplicate POS Fields"), msg=_("'{0}' has been already added.").format(field)
 				)
+
+	def validate_invoice_type(self):
+		pos_opening_entries_count = frappe.db.count(
+			"POS Opening Entry", filters={"docstatus": 1, "status": "Open"}
+		)
+		if pos_opening_entries_count:
+			frappe.throw(
+				_("{0} cannot be changed with opened Opening Entries.").format(
+					frappe.bold(_("Invoice Type"))
+				),
+				title=_("Invoice Document Type Selection Error"),
+			)

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

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

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -5,7 +5,7 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
+from frappe.tests import IntegrationTestCase
 
 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
@@ -15,15 +15,6 @@ from erpnext.stock.doctype.item.test_item import make_item
 from erpnext.stock.get_item_details import get_item_details
 
 
-class UnitTestPricingRule(UnitTestCase):
-	"""
-	Unit tests for PricingRule.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
 class TestPricingRule(IntegrationTestCase):
 	def setUp(self):
 		delete_existing_pricing_rules()
@@ -215,6 +206,56 @@ class TestPricingRule(IntegrationTestCase):
 		details = get_item_details(args)
 		self.assertEqual(details.get("discount_percentage"), 10)
 
+	def test_unset_group_condition(self):
+		"""
+		If args are not set for group condition, then pricing rule should not be applied.
+		"""
+		from erpnext.stock.get_item_details import get_item_details
+
+		test_record = {
+			"doctype": "Pricing Rule",
+			"title": "_Test Pricing Rule",
+			"apply_on": "Item Code",
+			"items": [{"item_code": "_Test Item"}],
+			"currency": "USD",
+			"selling": 1,
+			"rate_or_discount": "Discount Percentage",
+			"rate": 0,
+			"discount_percentage": 10,
+			"applicable_for": "Territory",
+			"territory": "All Territories",
+			"company": "_Test Company",
+		}
+		frappe.get_doc(test_record.copy()).insert()
+		args = frappe._dict(
+			{
+				"item_code": "_Test Item",
+				"company": "_Test Company",
+				"price_list": "_Test Price List",
+				"currency": "_Test Currency",
+				"doctype": "Sales Order",
+				"conversion_rate": 1,
+				"price_list_currency": "_Test Currency",
+				"plc_conversion_rate": 1,
+				"order_type": "Sales",
+				"customer": "_Test Customer",
+				"name": None,
+			}
+		)
+
+		# without territory in customer
+		customer = frappe.get_doc("Customer", "_Test Customer")
+		territory = customer.territory
+
+		customer.territory = None
+		customer.save()
+
+		details = get_item_details(args)
+		self.assertEqual(details.get("discount_percentage"), 0)
+
+		customer.territory = territory
+		customer.save()
+
 	def test_pricing_rule_for_variants(self):
 		from erpnext.stock.get_item_details import get_item_details
 

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -28,7 +28,7 @@ def get_pricing_rules(args, doc=None):
 	pricing_rules = []
 	values = {}
 
-	if not frappe.db.exists("Pricing Rule", {"disable": 0, args.transaction_type: 1}):
+	if not frappe.db.count("Pricing Rule", cache=True):
 		return
 
 	for apply_on in ["Item Code", "Item Group", "Brand"]:
@@ -115,8 +115,8 @@ def _get_pricing_rules(apply_on, args, values):
 		if apply_on_field == "item_code":
 			if args.get("uom", None):
 				item_conditions += (
-					" and ({child_doc}.uom='{item_uom}' or IFNULL({child_doc}.uom, '')='')".format(
-						child_doc=child_doc, item_uom=args.get("uom")
+					" and ({child_doc}.uom={item_uom} or IFNULL({child_doc}.uom, '')='')".format(
+						child_doc=child_doc, item_uom=frappe.db.escape(args.get("uom"))
 					)
 				)
 			if "variant_of" not in args:
@@ -128,8 +128,8 @@ def _get_pricing_rules(apply_on, args, values):
 	elif apply_on_field == "item_group":
 		item_conditions = _get_tree_conditions(args, "Item Group", child_doc, False)
 		if args.get("uom", None):
-			item_conditions += " and ({child_doc}.uom='{item_uom}' or IFNULL({child_doc}.uom, '')='')".format(
-				child_doc=child_doc, item_uom=args.get("uom")
+			item_conditions += " and ({child_doc}.uom={item_uom} or IFNULL({child_doc}.uom, '')='')".format(
+				child_doc=child_doc, item_uom=frappe.db.escape(args.get("uom"))
 			)
 
 	conditions += get_other_conditions(conditions, values, args)
@@ -223,6 +223,10 @@ def _get_tree_conditions(args, parenttype, table, allow_blank=True):
 			)
 
 			frappe.flags.tree_conditions[key] = condition
+
+	elif allow_blank:
+		condition = f"ifnull({table}.{field}, '') = ''"
+
 	return condition
 
 

erpnext/accounts/doctype/process_deferred_accounting/test_process_deferred_accounting.py

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