fix: incorrect qty for material request in Production Plan (backport #37270) (#37275)

fix: incorrect qty for material request in Production Plan (#37270)

(cherry picked from commit 8fe4a4d3aa)

Co-authored-by: rohitwaghchaure <rohitw1991@gmail.com>

.github/helper/install.sh

@@ -68,6 +68,6 @@ if [ "$TYPE" == "server" ]; then bench setup requirements --dev; fi
 
 wait $wkpid
 
-bench start &> bench_run_logs.txt &
+bench start &>> ~/frappe-bench/bench_start.log &
 CI=Yes bench build --app frappe &
 bench --site test_site reinstall --yes

.github/workflows/patch.yml

@@ -23,7 +23,7 @@ jobs:
 
     services:
       mysql:
-        image: mariadb:10.3
+        image: mariadb:10.6
         env:
           MARIADB_ROOT_PASSWORD: 'root'
         ports:
@@ -45,9 +45,7 @@ jobs:
       - name: Setup Python
         uses: "actions/setup-python@v4"
         with:
-          python-version: |
-              3.7
-              3.10
+          python-version: '3.10'
 
       - name: Setup Node
         uses: actions/setup-node@v2
@@ -102,40 +100,60 @@ jobs:
       - name: Run Patch Tests
         run: |
           cd ~/frappe-bench/
-          wget https://erpnext.com/files/v10-erpnext.sql.gz
-          bench --site test_site --force restore ~/frappe-bench/v10-erpnext.sql.gz
+          bench remove-app payments --force
+          jq 'del(.install_apps)' ~/frappe-bench/sites/test_site/site_config.json > tmp.json
+          mv tmp.json ~/frappe-bench/sites/test_site/site_config.json
+
+          wget https://erpnext.com/files/v13-erpnext.sql.gz
+          bench --site test_site --force restore ~/frappe-bench/v13-erpnext.sql.gz
 
           git -C "apps/frappe" remote set-url upstream https://github.com/frappe/frappe.git
           git -C "apps/erpnext" remote set-url upstream https://github.com/frappe/erpnext.git
 
-          for version in $(seq 12 13)
-          do
-              echo "Updating to v$version"
-              branch_name="version-$version-hotfix"
 
-              git -C "apps/frappe" fetch --depth 1 upstream $branch_name:$branch_name
-              git -C "apps/erpnext" fetch --depth 1 upstream $branch_name:$branch_name
+          function update_to_version() {
+            version=$1
 
-              git -C "apps/frappe" checkout -q -f $branch_name
-              git -C "apps/erpnext" checkout -q -f $branch_name
+            branch_name="version-$version-hotfix"
+            echo "Updating to v$version"
 
-              rm -rf ~/frappe-bench/env
-              bench setup env --python python3.7
-              bench pip install -e ./apps/payments
-              bench pip install -e ./apps/erpnext
+            # Fetch and checkout branches
+            git -C "apps/frappe" fetch --depth 1 upstream $branch_name:$branch_name
+            git -C "apps/erpnext" fetch --depth 1 upstream $branch_name:$branch_name
+            git -C "apps/frappe" checkout -q -f $branch_name
+            git -C "apps/erpnext" checkout -q -f $branch_name
 
-              bench --site test_site migrate
-          done
+            # Resetup env and install apps
+            pgrep honcho | xargs kill
+            rm -rf ~/frappe-bench/env
+            bench -v setup env
+            bench pip install -e ./apps/erpnext
+            bench start &>> ~/frappe-bench/bench_start.log &
 
+            bench --site test_site migrate
+          }
+
+          update_to_version 14
 
           echo "Updating to latest version"
           git -C "apps/frappe" checkout -q -f "${GITHUB_BASE_REF:-${GITHUB_REF##*/}}"
           git -C "apps/erpnext" checkout -q -f "$GITHUB_SHA"
 
+          pgrep honcho | xargs kill
           rm -rf ~/frappe-bench/env
-          bench -v setup env --python python3.10
-          bench pip install -e ./apps/payments
+          bench -v setup env
           bench pip install -e ./apps/erpnext
+          bench start &>> ~/frappe-bench/bench_start.log &
 
           bench --site test_site migrate
-          bench --site test_site install-app payments
+
+      - name: Show bench output
+        if: ${{ always() }}
+        run: |
+          cd ~/frappe-bench
+          cat bench_start.log || true
+          cd logs
+          for f in ./*.log*; do
+            echo "Printing log: $f";
+            cat $f
+          done

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

@@ -123,6 +123,10 @@ jobs:
           CI_BUILD_ID: ${{ github.run_id }}
           ORCHESTRATOR_URL: http://test-orchestrator.frappe.io
 
+      - name: Show bench output
+        if: ${{ always() }}
+        run: cat ~/frappe-bench/bench_start.log || true
+
       - name: Upload coverage data
         uses: actions/upload-artifact@v3
         with:

.pre-commit-config.yaml

@@ -40,6 +40,7 @@ repos:
       - id: flake8
         additional_dependencies: [
           'flake8-bugbear',
+          'flake8-tuple',
         ]
         args: ['--config', '.github/helper/.flake8_strict']
         exclude: ".*setup.py$"

erpnext/accounts/doctype/account/account.js

@@ -137,9 +137,6 @@ frappe.ui.form.on("Account", {
 					args: {
 						old: frm.doc.name,
 						new: data.name,
-						is_group: frm.doc.is_group,
-						root_type: frm.doc.root_type,
-						company: frm.doc.company,
 					},
 					callback: function (r) {
 						if (!r.exc) {

erpnext/accounts/doctype/account/account.py

@@ -18,6 +18,10 @@ class BalanceMismatchError(frappe.ValidationError):
 	pass
 
 
+class InvalidAccountMergeError(frappe.ValidationError):
+	pass
+
+
 class Account(NestedSet):
 	nsm_parent_field = "parent_account"
 
@@ -460,25 +464,34 @@ def update_account_number(name, account_name, account_number=None, from_descenda
 
 
 @frappe.whitelist()
-def merge_account(old, new, is_group, root_type, company):
+def merge_account(old, new):
 	# Validate properties before merging
 	new_account = frappe.get_cached_doc("Account", new)
+	old_account = frappe.get_cached_doc("Account", old)
 
 	if not new_account:
 		throw(_("Account {0} does not exist").format(new))
 
-	if (new_account.is_group, new_account.root_type, new_account.company) != (
-		cint(is_group),
-		root_type,
-		company,
+	if (
+		cint(new_account.is_group),
+		new_account.root_type,
+		new_account.company,
+		cstr(new_account.account_currency),
+	) != (
+		cint(old_account.is_group),
+		old_account.root_type,
+		old_account.company,
+		cstr(old_account.account_currency),
 	):
 		throw(
-			_(
-				"""Merging is only possible if following properties are same in both records. Is Group, Root Type, Company"""
-			)
+			msg=_(
+				"""Merging is only possible if following properties are same in both records. Is Group, Root Type, Company and Account Currency"""
+			),
+			title=("Invalid Accounts"),
+			exc=InvalidAccountMergeError,
 		)
 
-	if is_group and new_account.parent_account == old:
+	if old_account.is_group and new_account.parent_account == old:
 		new_account.db_set("parent_account", frappe.get_cached_value("Account", old, "parent_account"))
 
 	frappe.rename_doc("Account", old, new, merge=1, force=1)

erpnext/accounts/doctype/account/chart_of_accounts/import_from_openerp.py

@@ -1,289 +0,0 @@
-# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
-# License: GNU General Public License v3. See license.txt
-
-"""
-Import chart of accounts from OpenERP sources
-"""
-
-import ast
-import json
-import os
-from xml.etree import ElementTree as ET
-
-import frappe
-from frappe.utils.csvutils import read_csv_content
-
-path = "/Users/nabinhait/projects/odoo/addons"
-
-accounts = {}
-charts = {}
-all_account_types = []
-all_roots = {}
-
-
-def go():
-	global accounts, charts
-	default_account_types = get_default_account_types()
-
-	country_dirs = []
-	for basepath, folders, files in os.walk(path):
-		basename = os.path.basename(basepath)
-		if basename.startswith("l10n_"):
-			country_dirs.append(basename)
-
-	for country_dir in country_dirs:
-		accounts, charts = {}, {}
-		country_path = os.path.join(path, country_dir)
-		manifest = ast.literal_eval(open(os.path.join(country_path, "__openerp__.py")).read())
-		data_files = (
-			manifest.get("data", []) + manifest.get("init_xml", []) + manifest.get("update_xml", [])
-		)
-		files_path = [os.path.join(country_path, d) for d in data_files]
-		xml_roots = get_xml_roots(files_path)
-		csv_content = get_csv_contents(files_path)
-		prefix = country_dir if csv_content else None
-		account_types = get_account_types(
-			xml_roots.get("account.account.type", []), csv_content.get("account.account.type", []), prefix
-		)
-		account_types.update(default_account_types)
-
-		if xml_roots:
-			make_maps_for_xml(xml_roots, account_types, country_dir)
-
-		if csv_content:
-			make_maps_for_csv(csv_content, account_types, country_dir)
-		make_account_trees()
-		make_charts()
-
-	create_all_roots_file()
-
-
-def get_default_account_types():
-	default_types_root = []
-	default_types_root.append(
-		ET.parse(os.path.join(path, "account", "data", "data_account_type.xml")).getroot()
-	)
-	return get_account_types(default_types_root, None, prefix="account")
-
-
-def get_xml_roots(files_path):
-	xml_roots = frappe._dict()
-	for filepath in files_path:
-		fname = os.path.basename(filepath)
-		if fname.endswith(".xml"):
-			tree = ET.parse(filepath)
-			root = tree.getroot()
-			for node in root[0].findall("record"):
-				if node.get("model") in [
-					"account.account.template",
-					"account.chart.template",
-					"account.account.type",
-				]:
-					xml_roots.setdefault(node.get("model"), []).append(root)
-					break
-	return xml_roots
-
-
-def get_csv_contents(files_path):
-	csv_content = {}
-	for filepath in files_path:
-		fname = os.path.basename(filepath)
-		for file_type in ["account.account.template", "account.account.type", "account.chart.template"]:
-			if fname.startswith(file_type) and fname.endswith(".csv"):
-				with open(filepath, "r") as csvfile:
-					try:
-						csv_content.setdefault(file_type, []).append(read_csv_content(csvfile.read()))
-					except Exception as e:
-						continue
-	return csv_content
-
-
-def get_account_types(root_list, csv_content, prefix=None):
-	types = {}
-	account_type_map = {
-		"cash": "Cash",
-		"bank": "Bank",
-		"tr_cash": "Cash",
-		"tr_bank": "Bank",
-		"receivable": "Receivable",
-		"tr_receivable": "Receivable",
-		"account rec": "Receivable",
-		"payable": "Payable",
-		"tr_payable": "Payable",
-		"equity": "Equity",
-		"stocks": "Stock",
-		"stock": "Stock",
-		"tax": "Tax",
-		"tr_tax": "Tax",
-		"tax-out": "Tax",
-		"tax-in": "Tax",
-		"charges_personnel": "Chargeable",
-		"fixed asset": "Fixed Asset",
-		"cogs": "Cost of Goods Sold",
-	}
-	for root in root_list:
-		for node in root[0].findall("record"):
-			if node.get("model") == "account.account.type":
-				data = {}
-				for field in node.findall("field"):
-					if (
-						field.get("name") == "code"
-						and field.text.lower() != "none"
-						and account_type_map.get(field.text)
-					):
-						data["account_type"] = account_type_map[field.text]
-
-				node_id = prefix + "." + node.get("id") if prefix else node.get("id")
-				types[node_id] = data
-
-	if csv_content and csv_content[0][0] == "id":
-		for row in csv_content[1:]:
-			row_dict = dict(zip(csv_content[0], row))
-			data = {}
-			if row_dict.get("code") and account_type_map.get(row_dict["code"]):
-				data["account_type"] = account_type_map[row_dict["code"]]
-			if data and data.get("id"):
-				node_id = prefix + "." + data.get("id") if prefix else data.get("id")
-				types[node_id] = data
-	return types
-
-
-def make_maps_for_xml(xml_roots, account_types, country_dir):
-	"""make maps for `charts` and `accounts`"""
-	for model, root_list in xml_roots.items():
-		for root in root_list:
-			for node in root[0].findall("record"):
-				if node.get("model") == "account.account.template":
-					data = {}
-					for field in node.findall("field"):
-						if field.get("name") == "name":
-							data["name"] = field.text
-						if field.get("name") == "parent_id":
-							parent_id = field.get("ref") or field.get("eval")
-							data["parent_id"] = parent_id
-
-						if field.get("name") == "user_type":
-							value = field.get("ref")
-							if account_types.get(value, {}).get("account_type"):
-								data["account_type"] = account_types[value]["account_type"]
-								if data["account_type"] not in all_account_types:
-									all_account_types.append(data["account_type"])
-
-					data["children"] = []
-					accounts[node.get("id")] = data
-
-				if node.get("model") == "account.chart.template":
-					data = {}
-					for field in node.findall("field"):
-						if field.get("name") == "name":
-							data["name"] = field.text
-						if field.get("name") == "account_root_id":
-							data["account_root_id"] = field.get("ref")
-						data["id"] = country_dir
-					charts.setdefault(node.get("id"), {}).update(data)
-
-
-def make_maps_for_csv(csv_content, account_types, country_dir):
-	for content in csv_content.get("account.account.template", []):
-		for row in content[1:]:
-			data = dict(zip(content[0], row))
-			account = {
-				"name": data.get("name"),
-				"parent_id": data.get("parent_id:id") or data.get("parent_id/id"),
-				"children": [],
-			}
-			user_type = data.get("user_type/id") or data.get("user_type:id")
-			if account_types.get(user_type, {}).get("account_type"):
-				account["account_type"] = account_types[user_type]["account_type"]
-				if account["account_type"] not in all_account_types:
-					all_account_types.append(account["account_type"])
-
-			accounts[data.get("id")] = account
-			if not account.get("parent_id") and data.get("chart_template_id:id"):
-				chart_id = data.get("chart_template_id:id")
-				charts.setdefault(chart_id, {}).update({"account_root_id": data.get("id")})
-
-	for content in csv_content.get("account.chart.template", []):
-		for row in content[1:]:
-			if row:
-				data = dict(zip(content[0], row))
-				charts.setdefault(data.get("id"), {}).update(
-					{
-						"account_root_id": data.get("account_root_id:id") or data.get("account_root_id/id"),
-						"name": data.get("name"),
-						"id": country_dir,
-					}
-				)
-
-
-def make_account_trees():
-	"""build tree hierarchy"""
-	for id in accounts.keys():
-		account = accounts[id]
-
-		if account.get("parent_id"):
-			if accounts.get(account["parent_id"]):
-				# accounts[account["parent_id"]]["children"].append(account)
-				accounts[account["parent_id"]][account["name"]] = account
-			del account["parent_id"]
-			del account["name"]
-
-	# remove empty children
-	for id in accounts.keys():
-		if "children" in accounts[id] and not accounts[id].get("children"):
-			del accounts[id]["children"]
-
-
-def make_charts():
-	"""write chart files in app/setup/doctype/company/charts"""
-	for chart_id in charts:
-		src = charts[chart_id]
-		if not src.get("name") or not src.get("account_root_id"):
-			continue
-
-		if not src["account_root_id"] in accounts:
-			continue
-
-		filename = src["id"][5:] + "_" + chart_id
-
-		print("building " + filename)
-		chart = {}
-		chart["name"] = src["name"]
-		chart["country_code"] = src["id"][5:]
-		chart["tree"] = accounts[src["account_root_id"]]
-
-		for key, val in chart["tree"].items():
-			if key in ["name", "parent_id"]:
-				chart["tree"].pop(key)
-			if type(val) == dict:
-				val["root_type"] = ""
-		if chart:
-			fpath = os.path.join(
-				"erpnext", "erpnext", "accounts", "doctype", "account", "chart_of_accounts", filename + ".json"
-			)
-
-			with open(fpath, "r") as chartfile:
-				old_content = chartfile.read()
-				if not old_content or (
-					json.loads(old_content).get("is_active", "No") == "No"
-					and json.loads(old_content).get("disabled", "No") == "No"
-				):
-					with open(fpath, "w") as chartfile:
-						chartfile.write(json.dumps(chart, indent=4, sort_keys=True))
-
-					all_roots.setdefault(filename, chart["tree"].keys())
-
-
-def create_all_roots_file():
-	with open("all_roots.txt", "w") as f:
-		for filename, roots in sorted(all_roots.items()):
-			f.write(filename)
-			f.write("\n----------------------\n")
-			for r in sorted(roots):
-				f.write(r.encode("utf-8"))
-				f.write("\n")
-			f.write("\n\n\n")
-
-
-if __name__ == "__main__":
-	go()

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

@@ -437,12 +437,20 @@
             },
             "Sales": {
                 "Sales from Other Regions": {
-                    "Sales from Other Region": {}
+                    "Sales from Other Region": {
+                        "account_type": "Income Account"
+                    }
                 },
                 "Sales of same region": {
-                    "Management Consultancy Fees 1": {},
-                    "Sales Account": {},
-                    "Sales of I/C": {}
+                    "Management Consultancy Fees 1": {
+                        "account_type": "Income Account"
+                    },
+                    "Sales Account": {
+                        "account_type": "Income Account"
+                    },
+                    "Sales of I/C": {
+                        "account_type": "Income Account"
+                    }
                 }
             },
             "root_type": "Income"

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

@@ -69,8 +69,7 @@
                 "Persediaan Barang": {
                     "Persediaan Barang": {
                         "account_number": "1141.000", 
-                        "account_type": "Stock", 
-                        "is_group": 1
+                        "account_type": "Stock"
                     }, 
                     "Uang Muka Pembelian": {
                         "Uang Muka Pembelian": {
@@ -670,7 +669,8 @@
             }, 
             "Penjualan Barang Dagangan": {
                 "Penjualan": {
-                    "account_number": "4110.000"
+                    "account_number": "4110.000",
+                    "account_type": "Income Account"
                 }, 
                 "Potongan Penjualan": {
                     "account_number": "4130.000"

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

@@ -109,8 +109,7 @@
                     }
                 }, 
                 "INVENTARIOS": {
-                    "account_type": "Stock", 
-                    "is_group": 1
+                    "account_type": "Stock"
                 }
             }, 
             "ACTIVO LARGO PLAZO": {
@@ -398,10 +397,18 @@
                         "INGRESOS POR SERVICIOS 1": {}
                     }, 
                     "VENTAS": {
-                        "VENTAS EXPORTACION": {}, 
-                        "VENTAS INMUEBLES": {}, 
-                        "VENTAS NACIONALES": {}, 
-                        "VENTAS NACIONALES AL DETAL": {}
+                        "VENTAS EXPORTACION": {
+                            "account_type": "Income Account"
+                        }, 
+                        "VENTAS INMUEBLES": {
+                            "account_type": "Income Account"
+                        }, 
+                        "VENTAS NACIONALES": {
+                            "account_type": "Income Account"
+                        }, 
+                        "VENTAS NACIONALES AL DETAL": {
+                            "account_type": "Income Account"
+                        }
                     }
                 }
             }, 

erpnext/accounts/doctype/account/test_account.py

@@ -7,7 +7,11 @@ import unittest
 import frappe
 from frappe.test_runner import make_test_records
 
-from erpnext.accounts.doctype.account.account import merge_account, update_account_number
+from erpnext.accounts.doctype.account.account import (
+	InvalidAccountMergeError,
+	merge_account,
+	update_account_number,
+)
 from erpnext.stock import get_company_default_inventory_account, get_warehouse_account
 
 test_dependencies = ["Company"]
@@ -47,49 +51,53 @@ class TestAccount(unittest.TestCase):
 		frappe.delete_doc("Account", "1211-11-4 - 6 - Debtors 1 - Test - - _TC")
 
 	def test_merge_account(self):
-		if not frappe.db.exists("Account", "Current Assets - _TC"):
-			acc = frappe.new_doc("Account")
-			acc.account_name = "Current Assets"
-			acc.is_group = 1
-			acc.parent_account = "Application of Funds (Assets) - _TC"
-			acc.company = "_Test Company"
-			acc.insert()
-		if not frappe.db.exists("Account", "Securities and Deposits - _TC"):
-			acc = frappe.new_doc("Account")
-			acc.account_name = "Securities and Deposits"
-			acc.parent_account = "Current Assets - _TC"
-			acc.is_group = 1
-			acc.company = "_Test Company"
-			acc.insert()
-		if not frappe.db.exists("Account", "Earnest Money - _TC"):
-			acc = frappe.new_doc("Account")
-			acc.account_name = "Earnest Money"
-			acc.parent_account = "Securities and Deposits - _TC"
-			acc.company = "_Test Company"
-			acc.insert()
-		if not frappe.db.exists("Account", "Cash In Hand - _TC"):
-			acc = frappe.new_doc("Account")
-			acc.account_name = "Cash In Hand"
-			acc.is_group = 1
-			acc.parent_account = "Current Assets - _TC"
-			acc.company = "_Test Company"
-			acc.insert()
-		if not frappe.db.exists("Account", "Accumulated Depreciation - _TC"):
-			acc = frappe.new_doc("Account")
-			acc.account_name = "Accumulated Depreciation"
-			acc.parent_account = "Fixed Assets - _TC"
-			acc.company = "_Test Company"
-			acc.account_type = "Accumulated Depreciation"
-			acc.insert()
+		create_account(
+			account_name="Current Assets",
+			is_group=1,
+			parent_account="Application of Funds (Assets) - _TC",
+			company="_Test Company",
+		)
+
+		create_account(
+			account_name="Securities and Deposits",
+			is_group=1,
+			parent_account="Current Assets - _TC",
+			company="_Test Company",
+		)
+
+		create_account(
+			account_name="Earnest Money",
+			parent_account="Securities and Deposits - _TC",
+			company="_Test Company",
+		)
+
+		create_account(
+			account_name="Cash In Hand",
+			is_group=1,
+			parent_account="Current Assets - _TC",
+			company="_Test Company",
+		)
+
+		create_account(
+			account_name="Receivable INR",
+			parent_account="Current Assets - _TC",
+			company="_Test Company",
+			account_currency="INR",
+		)
+
+		create_account(
+			account_name="Receivable USD",
+			parent_account="Current Assets - _TC",
+			company="_Test Company",
+			account_currency="USD",
+		)
 
-		doc = frappe.get_doc("Account", "Securities and Deposits - _TC")
 		parent = frappe.db.get_value("Account", "Earnest Money - _TC", "parent_account")
 
 		self.assertEqual(parent, "Securities and Deposits - _TC")
 
-		merge_account(
-			"Securities and Deposits - _TC", "Cash In Hand - _TC", doc.is_group, doc.root_type, doc.company
-		)
+		merge_account("Securities and Deposits - _TC", "Cash In Hand - _TC")
+
 		parent = frappe.db.get_value("Account", "Earnest Money - _TC", "parent_account")
 
 		# Parent account of the child account changes after merging
@@ -98,30 +106,28 @@ class TestAccount(unittest.TestCase):
 		# Old account doesn't exist after merging
 		self.assertFalse(frappe.db.exists("Account", "Securities and Deposits - _TC"))
 
-		doc = frappe.get_doc("Account", "Current Assets - _TC")
-
 		# Raise error as is_group property doesn't match
 		self.assertRaises(
-			frappe.ValidationError,
+			InvalidAccountMergeError,
 			merge_account,
 			"Current Assets - _TC",
 			"Accumulated Depreciation - _TC",
-			doc.is_group,
-			doc.root_type,
-			doc.company,
 		)
 
-		doc = frappe.get_doc("Account", "Capital Stock - _TC")
-
 		# Raise error as root_type property doesn't match
 		self.assertRaises(
-			frappe.ValidationError,
+			InvalidAccountMergeError,
 			merge_account,
 			"Capital Stock - _TC",
 			"Softwares - _TC",
-			doc.is_group,
-			doc.root_type,
-			doc.company,
+		)
+
+		# Raise error as currency doesn't match
+		self.assertRaises(
+			InvalidAccountMergeError,
+			merge_account,
+			"Receivable INR - _TC",
+			"Receivable USD - _TC",
 		)
 
 	def test_account_sync(self):
@@ -400,11 +406,20 @@ def create_account(**kwargs):
 		"Account", filters={"account_name": kwargs.get("account_name"), "company": kwargs.get("company")}
 	)
 	if account:
-		return account
+		account = frappe.get_doc("Account", account)
+		account.update(
+			dict(
+				is_group=kwargs.get("is_group", 0),
+				parent_account=kwargs.get("parent_account"),
+			)
+		)
+		account.save()
+		return account.name
 	else:
 		account = frappe.get_doc(
 			dict(
 				doctype="Account",
+				is_group=kwargs.get("is_group", 0),
 				account_name=kwargs.get("account_name"),
 				account_type=kwargs.get("account_type"),
 				parent_account=kwargs.get("parent_account"),

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -265,20 +265,21 @@ def get_dimension_with_children(doctype, dimensions):
 
 @frappe.whitelist()
 def get_dimensions(with_cost_center_and_project=False):
-	dimension_filters = frappe.db.sql(
-		"""
-		SELECT label, fieldname, document_type
-		FROM `tabAccounting Dimension`
-		WHERE disabled = 0
-	""",
-		as_dict=1,
-	)
 
-	default_dimensions = frappe.db.sql(
-		"""SELECT p.fieldname, c.company, c.default_dimension
-		FROM `tabAccounting Dimension Detail` c, `tabAccounting Dimension` p
-		WHERE c.parent = p.name""",
-		as_dict=1,
+	c = frappe.qb.DocType("Accounting Dimension Detail")
+	p = frappe.qb.DocType("Accounting Dimension")
+	dimension_filters = (
+		frappe.qb.from_(p)
+		.select(p.label, p.fieldname, p.document_type)
+		.where(p.disabled == 0)
+		.run(as_dict=1)
+	)
+	default_dimensions = (
+		frappe.qb.from_(c)
+		.inner_join(p)
+		.on(c.parent == p.name)
+		.select(p.fieldname, c.company, c.default_dimension)
+		.run(as_dict=1)
 	)
 
 	if isinstance(with_cost_center_and_project, str):

erpnext/accounts/doctype/accounting_dimension/test_accounting_dimension.py

@@ -84,12 +84,22 @@ def create_dimension():
 	frappe.set_user("Administrator")
 
 	if not frappe.db.exists("Accounting Dimension", {"document_type": "Department"}):
-		frappe.get_doc(
+		dimension = frappe.get_doc(
 			{
 				"doctype": "Accounting Dimension",
 				"document_type": "Department",
 			}
-		).insert()
+		)
+		dimension.append(
+			"dimension_defaults",
+			{
+				"company": "_Test Company",
+				"reference_document": "Department",
+				"default_dimension": "_Test Department - _TC",
+			},
+		)
+		dimension.insert()
+		dimension.save()
 	else:
 		dimension = frappe.get_doc("Accounting Dimension", "Department")
 		dimension.disabled = 0

erpnext/accounts/doctype/bank_account/bank_account.json

@@ -13,6 +13,7 @@
   "account_type",
   "account_subtype",
   "column_break_7",
+  "disabled",
   "is_default",
   "is_company_account",
   "company",
@@ -199,10 +200,16 @@
    "fieldtype": "Data",
    "in_global_search": 1,
    "label": "Branch Code"
+  },
+  {
+   "default": "0",
+   "fieldname": "disabled",
+   "fieldtype": "Check",
+   "label": "Disabled"
   }
  ],
  "links": [],
- "modified": "2022-05-04 15:49:42.620630",
+ "modified": "2023-09-22 21:31:34.763977",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account",

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -7,7 +7,9 @@ import json
 import frappe
 from frappe import _
 from frappe.model.document import Document
+from frappe.query_builder.custom import ConstantColumn
 from frappe.utils import cint, flt
+from pypika.terms import Parameter
 
 from erpnext import get_default_cost_center
 from erpnext.accounts.doctype.bank_transaction.bank_transaction import get_total_allocated_amount
@@ -15,7 +17,7 @@ from erpnext.accounts.report.bank_reconciliation_statement.bank_reconciliation_s
 	get_amounts_not_reflected_in_system,
 	get_entries,
 )
-from erpnext.accounts.utils import get_balance_on
+from erpnext.accounts.utils import get_account_currency, get_balance_on
 
 
 class BankReconciliationTool(Document):
@@ -283,68 +285,68 @@ def auto_reconcile_vouchers(
 	to_reference_date=None,
 ):
 	frappe.flags.auto_reconcile_vouchers = True
-	document_types = ["payment_entry", "journal_entry"]
+	reconciled, partially_reconciled = set(), set()
+
 	bank_transactions = get_bank_transactions(bank_account)
-	matched_transaction = []
 	for transaction in bank_transactions:
 		linked_payments = get_linked_payments(
 			transaction.name,
-			document_types,
+			["payment_entry", "journal_entry"],
 			from_date,
 			to_date,
 			filter_by_reference_date,
 			from_reference_date,
 			to_reference_date,
 		)
-		vouchers = []
-		for r in linked_payments:
-			vouchers.append(
-				{
-					"payment_doctype": r[1],
-					"payment_name": r[2],
-					"amount": r[4],
-				}
-			)
-		transaction = frappe.get_doc("Bank Transaction", transaction.name)
-		account = frappe.db.get_value("Bank Account", transaction.bank_account, "account")
-		matched_trans = 0
-		for voucher in vouchers:
-			gl_entry = frappe.db.get_value(
-				"GL Entry",
-				dict(
-					account=account, voucher_type=voucher["payment_doctype"], voucher_no=voucher["payment_name"]
-				),
-				["credit", "debit"],
-				as_dict=1,
-			)
-			gl_amount, transaction_amount = (
-				(gl_entry.credit, transaction.deposit)
-				if gl_entry.credit > 0
-				else (gl_entry.debit, transaction.withdrawal)
-			)
-			allocated_amount = gl_amount if gl_amount >= transaction_amount else transaction_amount
-			transaction.append(
-				"payment_entries",
-				{
-					"payment_document": voucher["payment_doctype"],
-					"payment_entry": voucher["payment_name"],
-					"allocated_amount": allocated_amount,
+
+		if not linked_payments:
+			continue
+
+		vouchers = list(
+			map(
+				lambda entry: {
+					"payment_doctype": entry.get("doctype"),
+					"payment_name": entry.get("name"),
+					"amount": entry.get("paid_amount"),
 				},
+				linked_payments,
 			)
-			matched_transaction.append(str(transaction.name))
-		transaction.save()
-		transaction.update_allocations()
-	matched_transaction_len = len(set(matched_transaction))
-	if matched_transaction_len == 0:
-		frappe.msgprint(_("No matching references found for auto reconciliation"))
-	elif matched_transaction_len == 1:
-		frappe.msgprint(_("{0} transaction is reconcilied").format(matched_transaction_len))
-	else:
-		frappe.msgprint(_("{0} transactions are reconcilied").format(matched_transaction_len))
+		)
+
+		updated_transaction = reconcile_vouchers(transaction.name, json.dumps(vouchers))
+
+		if updated_transaction.status == "Reconciled":
+			reconciled.add(updated_transaction.name)
+		elif flt(transaction.unallocated_amount) != flt(updated_transaction.unallocated_amount):
+			# Partially reconciled (status = Unreconciled & unallocated amount changed)
+			partially_reconciled.add(updated_transaction.name)
+
+	alert_message, indicator = get_auto_reconcile_message(partially_reconciled, reconciled)
+	frappe.msgprint(title=_("Auto Reconciliation"), msg=alert_message, indicator=indicator)
 
 	frappe.flags.auto_reconcile_vouchers = False
+	return reconciled, partially_reconciled
 
-	return frappe.get_doc("Bank Transaction", transaction.name)
+
+def get_auto_reconcile_message(partially_reconciled, reconciled):
+	"""Returns alert message and indicator for auto reconciliation depending on result state."""
+	alert_message, indicator = "", "blue"
+	if not partially_reconciled and not reconciled:
+		alert_message = _("No matches occurred via auto reconciliation")
+		return alert_message, indicator
+
+	indicator = "green"
+	if reconciled:
+		alert_message += _("{0} Transaction(s) Reconciled").format(len(reconciled))
+		alert_message += "<br>"
+
+	if partially_reconciled:
+		alert_message += _("{0} {1} Partially Reconciled").format(
+			len(partially_reconciled),
+			_("Transactions") if len(partially_reconciled) > 1 else _("Transaction"),
+		)
+
+	return alert_message, indicator
 
 
 @frappe.whitelist()
@@ -390,19 +392,13 @@ def subtract_allocations(gl_account, vouchers):
 	"Look up & subtract any existing Bank Transaction allocations"
 	copied = []
 	for voucher in vouchers:
-		rows = get_total_allocated_amount(voucher[1], voucher[2])
-		amount = None
-		for row in rows:
-			if row["gl_account"] == gl_account:
-				amount = row["total"]
-				break
+		rows = get_total_allocated_amount(voucher.get("doctype"), voucher.get("name"))
+		filtered_row = list(filter(lambda row: row.get("gl_account") == gl_account, rows))
 
-		if amount:
-			l = list(voucher)
-			l[3] -= amount
-			copied.append(tuple(l))
-		else:
-			copied.append(voucher)
+		if amount := None if not filtered_row else filtered_row[0]["total"]:
+			voucher["paid_amount"] -= amount
+
+		copied.append(voucher)
 	return copied
 
 
@@ -418,6 +414,18 @@ def check_matching(
 	to_reference_date,
 ):
 	exact_match = True if "exact_match" in document_types else False
+	queries = get_queries(
+		bank_account,
+		company,
+		transaction,
+		document_types,
+		from_date,
+		to_date,
+		filter_by_reference_date,
+		from_reference_date,
+		to_reference_date,
+		exact_match,
+	)
 
 	filters = {
 		"amount": transaction.unallocated_amount,
@@ -429,30 +437,15 @@ def check_matching(
 	}
 
 	matching_vouchers = []
+	for query in queries:
+		matching_vouchers.extend(frappe.db.sql(query, filters, as_dict=True))
 
-	# get matching vouchers from all the apps
-	for method_name in frappe.get_hooks("get_matching_vouchers_for_bank_reconciliation"):
-		matching_vouchers.extend(
-			frappe.get_attr(method_name)(
-				bank_account,
-				company,
-				transaction,
-				document_types,
-				from_date,
-				to_date,
-				filter_by_reference_date,
-				from_reference_date,
-				to_reference_date,
-				exact_match,
-				filters,
-			)
-			or []
-		)
-
-	return sorted(matching_vouchers, key=lambda x: x[0], reverse=True) if matching_vouchers else []
+	return (
+		sorted(matching_vouchers, key=lambda x: x["rank"], reverse=True) if matching_vouchers else []
+	)
 
 
-def get_matching_vouchers_for_bank_reconciliation(
+def get_queries(
 	bank_account,
 	company,
 	transaction,
@@ -463,7 +456,6 @@ def get_matching_vouchers_for_bank_reconciliation(
 	from_reference_date,
 	to_reference_date,
 	exact_match,
-	filters,
 ):
 	# get queries to get matching vouchers
 	account_from_to = "paid_to" if transaction.deposit > 0.0 else "paid_from"
@@ -488,17 +480,7 @@ def get_matching_vouchers_for_bank_reconciliation(
 			or []
 		)
 
-	vouchers = []
-
-	for query in queries:
-		vouchers.extend(
-			frappe.db.sql(
-				query,
-				filters,
-			)
-		)
-
-	return vouchers
+	return queries
 
 
 def get_matching_queries(
@@ -515,6 +497,8 @@ def get_matching_queries(
 	to_reference_date,
 ):
 	queries = []
+	currency = get_account_currency(bank_account)
+
 	if "payment_entry" in document_types:
 		query = get_pe_matching_query(
 			exact_match,
@@ -541,12 +525,12 @@ def get_matching_queries(
 		queries.append(query)
 
 	if transaction.deposit > 0.0 and "sales_invoice" in document_types:
-		query = get_si_matching_query(exact_match)
+		query = get_si_matching_query(exact_match, currency)
 		queries.append(query)
 
 	if transaction.withdrawal > 0.0:
 		if "purchase_invoice" in document_types:
-			query = get_pi_matching_query(exact_match)
+			query = get_pi_matching_query(exact_match, currency)
 			queries.append(query)
 
 	if "bank_transaction" in document_types:
@@ -560,33 +544,48 @@ def get_bt_matching_query(exact_match, transaction):
 	# get matching bank transaction query
 	# find bank transactions in the same bank account with opposite sign
 	# same bank account must have same company and currency
+	bt = frappe.qb.DocType("Bank Transaction")
+
 	field = "deposit" if transaction.withdrawal > 0.0 else "withdrawal"
+	amount_equality = getattr(bt, field) == transaction.unallocated_amount
+	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(0)
+	amount_condition = amount_equality if exact_match else getattr(bt, field) > 0.0
 
-	return f"""
+	ref_rank = (
+		frappe.qb.terms.Case().when(bt.reference_number == transaction.reference_number, 1).else_(0)
+	)
+	unallocated_rank = (
+		frappe.qb.terms.Case().when(bt.unallocated_amount == transaction.unallocated_amount, 1).else_(0)
+	)
 
-		SELECT
-			(CASE WHEN reference_number = %(reference_no)s THEN 1 ELSE 0 END
-			+ CASE WHEN {field} = %(amount)s THEN 1 ELSE 0 END
-			+ CASE WHEN ( party_type = %(party_type)s AND party = %(party)s ) THEN 1 ELSE 0 END
-			+ CASE WHEN unallocated_amount = %(amount)s THEN 1 ELSE 0 END
-			+ 1) AS rank,
-			'Bank Transaction' AS doctype,
-			name,
-			unallocated_amount AS paid_amount,
-			reference_number AS reference_no,
-			date AS reference_date,
-			party,
-			party_type,
-			date AS posting_date,
-			currency
-		FROM
-			`tabBank Transaction`
-		WHERE
-			status != 'Reconciled'
-			AND name != '{transaction.name}'
-			AND bank_account = '{transaction.bank_account}'
-			AND {field} {'= %(amount)s' if exact_match else '> 0.0'}
-	"""
+	party_condition = (
+		(bt.party_type == transaction.party_type)
+		& (bt.party == transaction.party)
+		& bt.party.isnotnull()
+	)
+	party_rank = frappe.qb.terms.Case().when(party_condition, 1).else_(0)
+
+	query = (
+		frappe.qb.from_(bt)
+		.select(
+			(ref_rank + amount_rank + party_rank + unallocated_rank + 1).as_("rank"),
+			ConstantColumn("Bank Transaction").as_("doctype"),
+			bt.name,
+			bt.unallocated_amount.as_("paid_amount"),
+			bt.reference_number.as_("reference_no"),
+			bt.date.as_("reference_date"),
+			bt.party,
+			bt.party_type,
+			bt.date.as_("posting_date"),
+			bt.currency,
+		)
+		.where(bt.status != "Reconciled")
+		.where(bt.name != transaction.name)
+		.where(bt.bank_account == transaction.bank_account)
+		.where(amount_condition)
+		.where(bt.docstatus == 1)
+	)
+	return str(query)
 
 
 def get_pe_matching_query(
@@ -600,45 +599,56 @@ def get_pe_matching_query(
 	to_reference_date,
 ):
 	# get matching payment entries query
-	if transaction.deposit > 0.0:
-		currency_field = "paid_to_account_currency as currency"
-	else:
-		currency_field = "paid_from_account_currency as currency"
-	filter_by_date = f"AND posting_date between '{from_date}' and '{to_date}'"
-	order_by = " posting_date"
-	filter_by_reference_no = ""
+	to_from = "to" if transaction.deposit > 0.0 else "from"
+	currency_field = f"paid_{to_from}_account_currency"
+	payment_type = "Receive" if transaction.deposit > 0.0 else "Pay"
+	pe = frappe.qb.DocType("Payment Entry")
+
+	ref_condition = pe.reference_no == transaction.reference_number
+	ref_rank = frappe.qb.terms.Case().when(ref_condition, 1).else_(0)
+
+	amount_equality = pe.paid_amount == transaction.unallocated_amount
+	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(0)
+	amount_condition = amount_equality if exact_match else pe.paid_amount > 0.0
+
+	party_condition = (
+		(pe.party_type == transaction.party_type)
+		& (pe.party == transaction.party)
+		& pe.party.isnotnull()
+	)
+	party_rank = frappe.qb.terms.Case().when(party_condition, 1).else_(0)
+
+	filter_by_date = pe.posting_date.between(from_date, to_date)
 	if cint(filter_by_reference_date):
-		filter_by_date = f"AND reference_date between '{from_reference_date}' and '{to_reference_date}'"
-		order_by = " reference_date"
+		filter_by_date = pe.reference_date.between(from_reference_date, to_reference_date)
+
+	query = (
+		frappe.qb.from_(pe)
+		.select(
+			(ref_rank + amount_rank + party_rank + 1).as_("rank"),
+			ConstantColumn("Payment Entry").as_("doctype"),
+			pe.name,
+			pe.paid_amount,
+			pe.reference_no,
+			pe.reference_date,
+			pe.party,
+			pe.party_type,
+			pe.posting_date,
+			getattr(pe, currency_field).as_("currency"),
+		)
+		.where(pe.docstatus == 1)
+		.where(pe.payment_type.isin([payment_type, "Internal Transfer"]))
+		.where(pe.clearance_date.isnull())
+		.where(getattr(pe, account_from_to) == Parameter("%(bank_account)s"))
+		.where(amount_condition)
+		.where(filter_by_date)
+		.orderby(pe.reference_date if cint(filter_by_reference_date) else pe.posting_date)
+	)
+
 	if frappe.flags.auto_reconcile_vouchers == True:
-		filter_by_reference_no = f"AND reference_no = '{transaction.reference_number}'"
-	return f"""
-		SELECT
-			(CASE WHEN reference_no=%(reference_no)s THEN 1 ELSE 0 END
-			+ CASE WHEN (party_type = %(party_type)s AND party = %(party)s ) THEN 1 ELSE 0 END
-			+ CASE WHEN paid_amount = %(amount)s THEN 1 ELSE 0 END
-			+ 1 ) AS rank,
-			'Payment Entry' as doctype,
-			name,
-			paid_amount,
-			reference_no,
-			reference_date,
-			party,
-			party_type,
-			posting_date,
-			{currency_field}
-		FROM
-			`tabPayment Entry`
-		WHERE
-			docstatus = 1
-			AND payment_type IN (%(payment_type)s, 'Internal Transfer')
-			AND ifnull(clearance_date, '') = ""
-			AND {account_from_to} = %(bank_account)s
-			AND paid_amount {'= %(amount)s' if exact_match else '> 0.0'}
-			{filter_by_date}
-			{filter_by_reference_no}
-		order by{order_by}
-	"""
+		query = query.where(ref_condition)
+
+	return str(query)
 
 
 def get_je_matching_query(
@@ -655,100 +665,121 @@ def get_je_matching_query(
 	# So one bank could have both types of bank accounts like asset and liability
 	# So cr_or_dr should be judged only on basis of withdrawal and deposit and not account type
 	cr_or_dr = "credit" if transaction.withdrawal > 0.0 else "debit"
-	filter_by_date = f"AND je.posting_date between '{from_date}' and '{to_date}'"
-	order_by = " je.posting_date"
-	filter_by_reference_no = ""
+	je = frappe.qb.DocType("Journal Entry")
+	jea = frappe.qb.DocType("Journal Entry Account")
+
+	ref_condition = je.cheque_no == transaction.reference_number
+	ref_rank = frappe.qb.terms.Case().when(ref_condition, 1).else_(0)
+
+	amount_field = f"{cr_or_dr}_in_account_currency"
+	amount_equality = getattr(jea, amount_field) == transaction.unallocated_amount
+	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(0)
+
+	filter_by_date = je.posting_date.between(from_date, to_date)
 	if cint(filter_by_reference_date):
-		filter_by_date = f"AND je.cheque_date between '{from_reference_date}' and '{to_reference_date}'"
-		order_by = " je.cheque_date"
-	if frappe.flags.auto_reconcile_vouchers == True:
-		filter_by_reference_no = f"AND je.cheque_no = '{transaction.reference_number}'"
-	return f"""
-		SELECT
-			(CASE WHEN je.cheque_no=%(reference_no)s THEN 1 ELSE 0 END
-			+ CASE WHEN jea.{cr_or_dr}_in_account_currency = %(amount)s THEN 1 ELSE 0 END
-			+ 1) AS rank ,
-			'Journal Entry' AS doctype,
+		filter_by_date = je.cheque_date.between(from_reference_date, to_reference_date)
+
+	query = (
+		frappe.qb.from_(jea)
+		.join(je)
+		.on(jea.parent == je.name)
+		.select(
+			(ref_rank + amount_rank + 1).as_("rank"),
+			ConstantColumn("Journal Entry").as_("doctype"),
 			je.name,
-			jea.{cr_or_dr}_in_account_currency AS paid_amount,
-			je.cheque_no AS reference_no,
-			je.cheque_date AS reference_date,
-			je.pay_to_recd_from AS party,
+			getattr(jea, amount_field).as_("paid_amount"),
+			je.cheque_no.as_("reference_no"),
+			je.cheque_date.as_("reference_date"),
+			je.pay_to_recd_from.as_("party"),
 			jea.party_type,
 			je.posting_date,
-			jea.account_currency AS currency
-		FROM
-			`tabJournal Entry Account` AS jea
-		JOIN
-			`tabJournal Entry` AS je
-		ON
-			jea.parent = je.name
-		WHERE
-			je.docstatus = 1
-			AND je.voucher_type NOT IN ('Opening Entry')
-			AND (je.clearance_date IS NULL OR je.clearance_date='0000-00-00')
-			AND jea.account = %(bank_account)s
-			AND jea.{cr_or_dr}_in_account_currency {'= %(amount)s' if exact_match else '> 0.0'}
-			AND je.docstatus = 1
-			{filter_by_date}
-			{filter_by_reference_no}
-			order by {order_by}
-	"""
+			jea.account_currency.as_("currency"),
+		)
+		.where(je.docstatus == 1)
+		.where(je.voucher_type != "Opening Entry")
+		.where(je.clearance_date.isnull())
+		.where(jea.account == Parameter("%(bank_account)s"))
+		.where(amount_equality if exact_match else getattr(jea, amount_field) > 0.0)
+		.where(je.docstatus == 1)
+		.where(filter_by_date)
+		.orderby(je.cheque_date if cint(filter_by_reference_date) else je.posting_date)
+	)
+
+	if frappe.flags.auto_reconcile_vouchers == True:
+		query = query.where(ref_condition)
+
+	return str(query)
 
 
-def get_si_matching_query(exact_match):
+def get_si_matching_query(exact_match, currency):
 	# get matching sales invoice query
-	return f"""
-		SELECT
-			( CASE WHEN si.customer = %(party)s  THEN 1 ELSE 0 END
-			+ CASE WHEN sip.amount = %(amount)s THEN 1 ELSE 0 END
-			+ 1 ) AS rank,
-			'Sales Invoice' as doctype,
+	si = frappe.qb.DocType("Sales Invoice")
+	sip = frappe.qb.DocType("Sales Invoice Payment")
+
+	amount_equality = sip.amount == Parameter("%(amount)s")
+	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(0)
+	amount_condition = amount_equality if exact_match else sip.amount > 0.0
+
+	party_condition = si.customer == Parameter("%(party)s")
+	party_rank = frappe.qb.terms.Case().when(party_condition, 1).else_(0)
+
+	query = (
+		frappe.qb.from_(sip)
+		.join(si)
+		.on(sip.parent == si.name)
+		.select(
+			(party_rank + amount_rank + 1).as_("rank"),
+			ConstantColumn("Sales Invoice").as_("doctype"),
 			si.name,
-			sip.amount as paid_amount,
-			'' as reference_no,
-			'' as reference_date,
-			si.customer as party,
-			'Customer' as party_type,
+			sip.amount.as_("paid_amount"),
+			ConstantColumn("").as_("reference_no"),
+			ConstantColumn("").as_("reference_date"),
+			si.customer.as_("party"),
+			ConstantColumn("Customer").as_("party_type"),
 			si.posting_date,
-			si.currency
+			si.currency,
+		)
+		.where(si.docstatus == 1)
+		.where(sip.clearance_date.isnull())
+		.where(sip.account == Parameter("%(bank_account)s"))
+		.where(amount_condition)
+		.where(si.currency == currency)
+	)
 
-		FROM
-			`tabSales Invoice Payment` as sip
-		JOIN
-			`tabSales Invoice` as si
-		ON
-			sip.parent = si.name
-		WHERE
-			si.docstatus = 1
-			AND (sip.clearance_date is null or sip.clearance_date='0000-00-00')
-			AND sip.account = %(bank_account)s
-			AND sip.amount {'= %(amount)s' if exact_match else '> 0.0'}
-	"""
+	return str(query)
 
 
-def get_pi_matching_query(exact_match):
+def get_pi_matching_query(exact_match, currency):
 	# get matching purchase invoice query when they are also used as payment entries (is_paid)
-	return f"""
-		SELECT
-			( CASE WHEN supplier = %(party)s THEN 1 ELSE 0 END
-			+ CASE WHEN paid_amount = %(amount)s THEN 1 ELSE 0 END
-			+ 1 ) AS rank,
-			'Purchase Invoice' as doctype,
-			name,
-			paid_amount,
-			'' as reference_no,
-			'' as reference_date,
-			supplier as party,
-			'Supplier' as party_type,
-			posting_date,
-			currency
-		FROM
-			`tabPurchase Invoice`
-		WHERE
-			docstatus = 1
-			AND is_paid = 1
-			AND ifnull(clearance_date, '') = ""
-			AND cash_bank_account = %(bank_account)s
-			AND paid_amount {'= %(amount)s' if exact_match else '> 0.0'}
-	"""
+	purchase_invoice = frappe.qb.DocType("Purchase Invoice")
+
+	amount_equality = purchase_invoice.paid_amount == Parameter("%(amount)s")
+	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(0)
+	amount_condition = amount_equality if exact_match else purchase_invoice.paid_amount > 0.0
+
+	party_condition = purchase_invoice.supplier == Parameter("%(party)s")
+	party_rank = frappe.qb.terms.Case().when(party_condition, 1).else_(0)
+
+	query = (
+		frappe.qb.from_(purchase_invoice)
+		.select(
+			(party_rank + amount_rank + 1).as_("rank"),
+			ConstantColumn("Purchase Invoice").as_("doctype"),
+			purchase_invoice.name,
+			purchase_invoice.paid_amount,
+			ConstantColumn("").as_("reference_no"),
+			ConstantColumn("").as_("reference_date"),
+			purchase_invoice.supplier.as_("party"),
+			ConstantColumn("Supplier").as_("party_type"),
+			purchase_invoice.posting_date,
+			purchase_invoice.currency,
+		)
+		.where(purchase_invoice.docstatus == 1)
+		.where(purchase_invoice.is_paid == 1)
+		.where(purchase_invoice.clearance_date.isnull())
+		.where(purchase_invoice.cash_bank_account == Parameter("%(bank_account)s"))
+		.where(amount_condition)
+		.where(purchase_invoice.currency == currency)
+	)
+
+	return str(query)

erpnext/accounts/doctype/bank_reconciliation_tool/test_bank_reconciliation_tool.py

@@ -1,9 +1,100 @@
 # Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
 import unittest
 
+import frappe
+from frappe import qb
+from frappe.tests.utils import FrappeTestCase, change_settings
+from frappe.utils import add_days, flt, getdate, today
 
-class TestBankReconciliationTool(unittest.TestCase):
-	pass
+from erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool import (
+	auto_reconcile_vouchers,
+	get_bank_transactions,
+)
+from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+
+
+class TestBankReconciliationTool(AccountsTestMixin, FrappeTestCase):
+	def setUp(self):
+		self.create_company()
+		self.create_customer()
+		self.clear_old_entries()
+		bank_dt = qb.DocType("Bank")
+		q = qb.from_(bank_dt).delete().where(bank_dt.name == "HDFC").run()
+		self.create_bank_account()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def create_bank_account(self):
+		bank = frappe.get_doc(
+			{
+				"doctype": "Bank",
+				"bank_name": "HDFC",
+			}
+		).save()
+
+		self.bank_account = (
+			frappe.get_doc(
+				{
+					"doctype": "Bank Account",
+					"account_name": "HDFC _current_",
+					"bank": bank,
+					"is_company_account": True,
+					"account": self.bank,  # account from Chart of Accounts
+				}
+			)
+			.insert()
+			.name
+		)
+
+	def test_auto_reconcile(self):
+		# make payment
+		from_date = add_days(today(), -1)
+		to_date = today()
+		payment = create_payment_entry(
+			company=self.company,
+			posting_date=from_date,
+			payment_type="Receive",
+			party_type="Customer",
+			party=self.customer,
+			paid_from=self.debit_to,
+			paid_to=self.bank,
+			paid_amount=100,
+		).save()
+		payment.reference_no = "123"
+		payment = payment.save().submit()
+
+		# make bank transaction
+		bank_transaction = (
+			frappe.get_doc(
+				{
+					"doctype": "Bank Transaction",
+					"date": to_date,
+					"deposit": 100,
+					"bank_account": self.bank_account,
+					"reference_number": "123",
+				}
+			)
+			.save()
+			.submit()
+		)
+
+		# assert API output pre reconciliation
+		transactions = get_bank_transactions(self.bank_account, from_date, to_date)
+		self.assertEqual(len(transactions), 1)
+		self.assertEqual(transactions[0].name, bank_transaction.name)
+
+		# auto reconcile
+		auto_reconcile_vouchers(
+			bank_account=self.bank_account,
+			from_date=from_date,
+			to_date=to_date,
+			filter_by_reference_date=False,
+		)
+
+		# assert API output post reconciliation
+		transactions = get_bank_transactions(self.bank_account, from_date, to_date)
+		self.assertEqual(len(transactions), 0)

erpnext/accounts/doctype/bank_transaction/bank_transaction.js

@@ -13,10 +13,11 @@ frappe.ui.form.on("Bank Transaction", {
 		});
 	},
 	refresh(frm) {
-		frm.add_custom_button(__('Unreconcile Transaction'), () => {
-			frm.call('remove_payment_entries')
-			.then( () => frm.refresh() );
-		});
+		if (!frm.is_dirty() && frm.doc.payment_entries.length > 0) {
+			frm.add_custom_button(__("Unreconcile Transaction"), () => {
+				frm.call("remove_payment_entries").then(() => frm.refresh());
+			});
+		}
 	},
 	bank_account: function (frm) {
 		set_bank_statement_filter(frm);

erpnext/accounts/doctype/bank_transaction/test_bank_transaction.py

@@ -47,7 +47,7 @@ class TestBankTransaction(FrappeTestCase):
 			from_date=bank_transaction.date,
 			to_date=utils.today(),
 		)
-		self.assertTrue(linked_payments[0][6] == "Conrad Electronic")
+		self.assertTrue(linked_payments[0]["party"] == "Conrad Electronic")
 
 	# This test validates a simple reconciliation leading to the clearance of the bank transaction and the payment
 	def test_reconcile(self):
@@ -93,7 +93,7 @@ class TestBankTransaction(FrappeTestCase):
 			from_date=bank_transaction.date,
 			to_date=utils.today(),
 		)
-		self.assertTrue(linked_payments[0][3])
+		self.assertTrue(linked_payments[0]["paid_amount"])
 
 	# Check error if already reconciled
 	def test_already_reconciled(self):
@@ -188,7 +188,7 @@ class TestBankTransaction(FrappeTestCase):
 		repayment_entry = create_loan_and_repayment()
 
 		linked_payments = get_linked_payments(bank_transaction.name, ["loan_repayment", "exact_match"])
-		self.assertEqual(linked_payments[0][2], repayment_entry.name)
+		self.assertEqual(linked_payments[0]["name"], repayment_entry.name)
 
 
 @if_lending_app_installed

erpnext/accounts/doctype/exchange_rate_revaluation/test_exchange_rate_revaluation.py

@@ -3,6 +3,296 @@
 
 import unittest
 
+import frappe
+from frappe import qb
+from frappe.tests.utils import FrappeTestCase, change_settings
+from frappe.utils import add_days, flt, today
 
-class TestExchangeRateRevaluation(unittest.TestCase):
-	pass
+from erpnext import get_default_cost_center
+from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
+from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+from erpnext.accounts.party import get_party_account
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+from erpnext.stock.doctype.item.test_item import create_item
+
+
+class TestExchangeRateRevaluation(AccountsTestMixin, FrappeTestCase):
+	def setUp(self):
+		self.create_company()
+		self.create_usd_receivable_account()
+		self.create_item()
+		self.create_customer()
+		self.clear_old_entries()
+		self.set_system_and_company_settings()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def set_system_and_company_settings(self):
+		# set number and currency precision
+		system_settings = frappe.get_doc("System Settings")
+		system_settings.float_precision = 2
+		system_settings.currency_precision = 2
+		system_settings.save()
+
+		# Using Exchange Gain/Loss account for unrealized as well.
+		company_doc = frappe.get_doc("Company", self.company)
+		company_doc.unrealized_exchange_gain_loss_account = company_doc.exchange_gain_loss_account
+		company_doc.save()
+
+	@change_settings(
+		"Accounts Settings",
+		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
+	)
+	def test_01_revaluation_of_forex_balance(self):
+		"""
+		Test Forex account balance and Journal creation post Revaluation
+		"""
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debtors_usd,
+			posting_date=today(),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=100,
+			price_list_rate=100,
+			do_not_submit=1,
+		)
+		si.currency = "USD"
+		si.conversion_rate = 80
+		si.save().submit()
+
+		err = frappe.new_doc("Exchange Rate Revaluation")
+		err.company = self.company
+		err.posting_date = today()
+		accounts = err.get_accounts_data()
+		err.extend("accounts", accounts)
+		row = err.accounts[0]
+		row.new_exchange_rate = 85
+		row.new_balance_in_base_currency = flt(
+			row.new_exchange_rate * flt(row.balance_in_account_currency)
+		)
+		row.gain_loss = row.new_balance_in_base_currency - flt(row.balance_in_base_currency)
+		err.set_total_gain_loss()
+		err = err.save().submit()
+
+		# Create JV for ERR
+		err_journals = err.make_jv_entries()
+		je = frappe.get_doc("Journal Entry", err_journals.get("revaluation_jv"))
+		je = je.submit()
+
+		je.reload()
+		self.assertEqual(je.voucher_type, "Exchange Rate Revaluation")
+		self.assertEqual(je.total_debit, 8500.0)
+		self.assertEqual(je.total_credit, 8500.0)
+
+		acc_balance = frappe.db.get_all(
+			"GL Entry",
+			filters={"account": self.debtors_usd, "is_cancelled": 0},
+			fields=["sum(debit)-sum(credit) as balance"],
+		)[0]
+		self.assertEqual(acc_balance.balance, 8500.0)
+
+	@change_settings(
+		"Accounts Settings",
+		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
+	)
+	def test_02_accounts_only_with_base_currency_balance(self):
+		"""
+		Test Revaluation on Forex account with balance only in base currency
+		"""
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debtors_usd,
+			posting_date=today(),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=100,
+			price_list_rate=100,
+			do_not_submit=1,
+		)
+		si.currency = "USD"
+		si.conversion_rate = 80
+		si.save().submit()
+
+		pe = get_payment_entry(si.doctype, si.name)
+		pe.source_exchange_rate = 85
+		pe.received_amount = 8500
+		pe.save().submit()
+
+		# Cancel the auto created gain/loss JE to simulate balance only in base currency
+		je = frappe.db.get_all(
+			"Journal Entry Account", filters={"reference_name": si.name}, pluck="parent"
+		)[0]
+		frappe.get_doc("Journal Entry", je).cancel()
+
+		err = frappe.new_doc("Exchange Rate Revaluation")
+		err.company = self.company
+		err.posting_date = today()
+		err.fetch_and_calculate_accounts_data()
+		err = err.save().submit()
+
+		# Create JV for ERR
+		self.assertTrue(err.check_journal_entry_condition())
+		err_journals = err.make_jv_entries()
+		je = frappe.get_doc("Journal Entry", err_journals.get("zero_balance_jv"))
+		je = je.submit()
+
+		je.reload()
+		self.assertEqual(je.voucher_type, "Exchange Gain Or Loss")
+		self.assertEqual(len(je.accounts), 2)
+		# Only base currency fields will be posted to
+		for acc in je.accounts:
+			self.assertEqual(acc.debit_in_account_currency, 0)
+			self.assertEqual(acc.credit_in_account_currency, 0)
+
+		self.assertEqual(je.total_debit, 500.0)
+		self.assertEqual(je.total_credit, 500.0)
+
+		acc_balance = frappe.db.get_all(
+			"GL Entry",
+			filters={"account": self.debtors_usd, "is_cancelled": 0},
+			fields=[
+				"sum(debit)-sum(credit) as balance",
+				"sum(debit_in_account_currency)-sum(credit_in_account_currency) as balance_in_account_currency",
+			],
+		)[0]
+		# account shouldn't have balance in base and account currency
+		self.assertEqual(acc_balance.balance, 0.0)
+		self.assertEqual(acc_balance.balance_in_account_currency, 0.0)
+
+	@change_settings(
+		"Accounts Settings",
+		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
+	)
+	def test_03_accounts_only_with_account_currency_balance(self):
+		"""
+		Test Revaluation on Forex account with balance only in account currency
+		"""
+		precision = frappe.db.get_single_value("System Settings", "currency_precision")
+
+		# posting on previous date to make sure that ERR picks up the Payment entry's exchange
+		# rate while calculating gain/loss for account currency balance
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debtors_usd,
+			posting_date=add_days(today(), -1),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=100,
+			price_list_rate=100,
+			do_not_submit=1,
+		)
+		si.currency = "USD"
+		si.conversion_rate = 80
+		si.save().submit()
+
+		pe = get_payment_entry(si.doctype, si.name)
+		pe.paid_amount = 95
+		pe.source_exchange_rate = 84.211
+		pe.received_amount = 8000
+		pe.references = []
+		pe.save().submit()
+
+		acc_balance = frappe.db.get_all(
+			"GL Entry",
+			filters={"account": self.debtors_usd, "is_cancelled": 0},
+			fields=[
+				"sum(debit)-sum(credit) as balance",
+				"sum(debit_in_account_currency)-sum(credit_in_account_currency) as balance_in_account_currency",
+			],
+		)[0]
+		# account should have balance only in account currency
+		self.assertEqual(flt(acc_balance.balance, precision), 0.0)
+		self.assertEqual(flt(acc_balance.balance_in_account_currency, precision), 5.0)  # in USD
+
+		err = frappe.new_doc("Exchange Rate Revaluation")
+		err.company = self.company
+		err.posting_date = today()
+		err.fetch_and_calculate_accounts_data()
+		err.set_total_gain_loss()
+		err = err.save().submit()
+
+		# Create JV for ERR
+		self.assertTrue(err.check_journal_entry_condition())
+		err_journals = err.make_jv_entries()
+		je = frappe.get_doc("Journal Entry", err_journals.get("zero_balance_jv"))
+		je = je.submit()
+
+		je.reload()
+		self.assertEqual(je.voucher_type, "Exchange Gain Or Loss")
+		self.assertEqual(len(je.accounts), 2)
+		# Only account currency fields will be posted to
+		for acc in je.accounts:
+			self.assertEqual(flt(acc.debit, precision), 0.0)
+			self.assertEqual(flt(acc.credit, precision), 0.0)
+
+		row = [x for x in je.accounts if x.account == self.debtors_usd][0]
+		self.assertEqual(flt(row.credit_in_account_currency, precision), 5.0)  # in USD
+		row = [x for x in je.accounts if x.account != self.debtors_usd][0]
+		self.assertEqual(flt(row.debit_in_account_currency, precision), 421.06)  # in INR
+
+		# total_debit and total_credit will be 0.0, as JV is posting only to account currency fields
+		self.assertEqual(flt(je.total_debit, precision), 0.0)
+		self.assertEqual(flt(je.total_credit, precision), 0.0)
+
+		acc_balance = frappe.db.get_all(
+			"GL Entry",
+			filters={"account": self.debtors_usd, "is_cancelled": 0},
+			fields=[
+				"sum(debit)-sum(credit) as balance",
+				"sum(debit_in_account_currency)-sum(credit_in_account_currency) as balance_in_account_currency",
+			],
+		)[0]
+		# account shouldn't have balance in base and account currency post revaluation
+		self.assertEqual(flt(acc_balance.balance, precision), 0.0)
+		self.assertEqual(flt(acc_balance.balance_in_account_currency, precision), 0.0)
+
+	@change_settings(
+		"Accounts Settings",
+		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
+	)
+	def test_04_get_account_details_function(self):
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debtors_usd,
+			posting_date=today(),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=100,
+			price_list_rate=100,
+			do_not_submit=1,
+		)
+		si.currency = "USD"
+		si.conversion_rate = 80
+		si.save().submit()
+
+		from erpnext.accounts.doctype.exchange_rate_revaluation.exchange_rate_revaluation import (
+			get_account_details,
+		)
+
+		account_details = get_account_details(
+			self.company, si.posting_date, self.debtors_usd, "Customer", self.customer, 0.05
+		)
+		# not checking for new exchange rate and balances as it is dependent on live exchange rates
+		expected_data = {
+			"account_currency": "USD",
+			"balance_in_base_currency": 8000.0,
+			"balance_in_account_currency": 100.0,
+			"current_exchange_rate": 80.0,
+			"zero_balance": False,
+			"new_balance_in_account_currency": 100.0,
+		}
+
+		for key, val in expected_data.items():
+			self.assertEqual(expected_data.get(key), account_details.get(key))

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -50,6 +50,8 @@ frappe.ui.form.on("Journal Entry", {
 					frm.trigger("make_inter_company_journal_entry");
 				}, __('Make'));
 		}
+
+		erpnext.accounts.unreconcile_payments.add_unreconcile_btn(frm);
 	},
 
 	make_inter_company_journal_entry: function(frm) {

erpnext/accounts/doctype/ledger_merge/ledger_merge.py

@@ -48,9 +48,6 @@ def start_merge(docname):
 				merge_account(
 					row.account,
 					ledger_merge.account,
-					ledger_merge.is_group,
-					ledger_merge.root_type,
-					ledger_merge.company,
 				)
 				row.db_set("merged", 1)
 				frappe.db.commit()

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -9,7 +9,7 @@ erpnext.accounts.taxes.setup_tax_filters("Advance Taxes and Charges");
 
 frappe.ui.form.on('Payment Entry', {
 	onload: function(frm) {
-		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', 'Journal Entry', 'Repost Payment Ledger','Repost Accounting Ledger'];
+		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', 'Journal Entry', 'Repost Payment Ledger','Repost Accounting Ledger', 'Unreconcile Payments', 'Unreconcile Payment Entries'];
 
 		if(frm.doc.__islocal) {
 			if (!frm.doc.paid_from) frm.set_value("paid_from_account_currency", null);
@@ -154,6 +154,13 @@ frappe.ui.form.on('Payment Entry', {
 		frm.events.set_dynamic_labels(frm);
 		frm.events.show_general_ledger(frm);
 		erpnext.accounts.ledger_preview.show_accounting_ledger_preview(frm);
+		if(frm.doc.references.find((elem) => {return elem.exchange_gain_loss != 0})) {
+			frm.add_custom_button(__("View Exchange Gain/Loss Journals"), function() {
+				frappe.set_route("List", "Journal Entry", {"voucher_type": "Exchange Gain Or Loss", "reference_name": frm.doc.name});
+			}, __('Actions'));
+
+		}
+		erpnext.accounts.unreconcile_payments.add_unreconcile_btn(frm);
 	},
 
 	validate_company: (frm) => {
@@ -535,15 +542,21 @@ frappe.ui.form.on('Payment Entry', {
 	},
 
 	source_exchange_rate: function(frm) {
+		let company_currency = frappe.get_doc(":Company", frm.doc.company).default_currency;
 		if (frm.doc.paid_amount) {
 			frm.set_value("base_paid_amount", flt(frm.doc.paid_amount) * flt(frm.doc.source_exchange_rate));
 			// target exchange rate should always be same as source if both account currencies is same
 			if(frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency) {
 				frm.set_value("target_exchange_rate", frm.doc.source_exchange_rate);
 				frm.set_value("base_received_amount", frm.doc.base_paid_amount);
+			} else if (company_currency == frm.doc.paid_to_account_currency) {
+				frm.set_value("received_amount", frm.doc.base_paid_amount);
+				frm.set_value("base_received_amount", frm.doc.base_paid_amount);
 			}
 
-			frm.events.set_unallocated_amount(frm);
+			// set_unallocated_amount is called by below method,
+			// no need trigger separately
+			frm.events.set_total_allocated_amount(frm);
 		}
 
 		// Make read only if Accounts Settings doesn't allow stale rates
@@ -552,6 +565,7 @@ frappe.ui.form.on('Payment Entry', {
 
 	target_exchange_rate: function(frm) {
 		frm.set_paid_amount_based_on_received_amount = true;
+		let company_currency = frappe.get_doc(":Company", frm.doc.company).default_currency;
 
 		if (frm.doc.received_amount) {
 			frm.set_value("base_received_amount",
@@ -561,9 +575,14 @@ frappe.ui.form.on('Payment Entry', {
 					(frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency)) {
 				frm.set_value("source_exchange_rate", frm.doc.target_exchange_rate);
 				frm.set_value("base_paid_amount", frm.doc.base_received_amount);
+			} else if (company_currency == frm.doc.paid_from_account_currency) {
+				frm.set_value("paid_amount", frm.doc.base_received_amount);
+				frm.set_value("base_paid_amount", frm.doc.base_received_amount);
 			}
 
-			frm.events.set_unallocated_amount(frm);
+			// set_unallocated_amount is called by below method,
+			// no need trigger separately
+			frm.events.set_total_allocated_amount(frm);
 		}
 		frm.set_paid_amount_based_on_received_amount = false;
 
@@ -879,12 +898,18 @@ frappe.ui.form.on('Payment Entry', {
 	},
 
 	set_total_allocated_amount: function(frm) {
+		let exchange_rate = 1;
+		if (frm.doc.payment_type == "Receive") {
+			exchange_rate = frm.doc.source_exchange_rate;
+		} else if (frm.doc.payment_type == "Pay") {
+			exchange_rate = frm.doc.target_exchange_rate;
+		}
 		var total_allocated_amount = 0.0;
 		var base_total_allocated_amount = 0.0;
 		$.each(frm.doc.references || [], function(i, row) {
 			if (row.allocated_amount) {
 				total_allocated_amount += flt(row.allocated_amount);
-				base_total_allocated_amount += flt(flt(row.allocated_amount)*flt(row.exchange_rate),
+				base_total_allocated_amount += flt(flt(row.allocated_amount)*flt(exchange_rate),
 					precision("base_paid_amount"));
 			}
 		});

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -98,7 +98,6 @@ class PaymentEntry(AccountsController):
 		if self.difference_amount:
 			frappe.throw(_("Difference Amount must be zero"))
 		self.make_gl_entries()
-		self.make_advance_gl_entries()
 		self.update_outstanding_amounts()
 		self.update_advance_paid()
 		self.update_payment_schedule()
@@ -149,10 +148,11 @@ class PaymentEntry(AccountsController):
 			"Repost Payment Ledger Items",
 			"Repost Accounting Ledger",
 			"Repost Accounting Ledger Items",
+			"Unreconcile Payments",
+			"Unreconcile Payment Entries",
 		)
 		super(PaymentEntry, self).on_cancel()
 		self.make_gl_entries(cancel=1)
-		self.make_advance_gl_entries(cancel=1)
 		self.update_outstanding_amounts()
 		self.update_advance_paid()
 		self.delink_advance_entry_references()
@@ -856,6 +856,11 @@ class PaymentEntry(AccountsController):
 				flt(d.allocated_amount) * flt(exchange_rate), self.precision("base_paid_amount")
 			)
 
+			# on rare case, when `exchange_rate` is unset, gain/loss amount is incorrectly calculated
+			# for base currency transactions
+			if d.exchange_rate is None:
+				d.exchange_rate = 1
+
 			allocated_amount_in_pe_exchange_rate = flt(
 				flt(d.allocated_amount) * flt(d.exchange_rate), self.precision("base_paid_amount")
 			)
@@ -999,14 +1004,14 @@ class PaymentEntry(AccountsController):
 		if self.payment_type == "Internal Transfer":
 			remarks = [
 				_("Amount {0} {1} transferred from {2} to {3}").format(
-					self.paid_from_account_currency, self.paid_amount, self.paid_from, self.paid_to
+					_(self.paid_from_account_currency), self.paid_amount, self.paid_from, self.paid_to
 				)
 			]
 		else:
 
 			remarks = [
 				_("Amount {0} {1} {2} {3}").format(
-					self.party_account_currency,
+					_(self.party_account_currency),
 					self.paid_amount if self.payment_type == "Receive" else self.received_amount,
 					_("received from") if self.payment_type == "Receive" else _("to"),
 					self.party,
@@ -1023,14 +1028,14 @@ class PaymentEntry(AccountsController):
 				if d.allocated_amount:
 					remarks.append(
 						_("Amount {0} {1} against {2} {3}").format(
-							self.party_account_currency, d.allocated_amount, d.reference_doctype, d.reference_name
+							_(self.party_account_currency), d.allocated_amount, d.reference_doctype, d.reference_name
 						)
 					)
 
 		for d in self.get("deductions"):
 			if d.amount:
 				remarks.append(
-					_("Amount {0} {1} deducted against {2}").format(self.company_currency, d.amount, d.account)
+					_("Amount {0} {1} deducted against {2}").format(_(self.company_currency), d.amount, d.account)
 				)
 
 		self.set("remarks", "\n".join(remarks))
@@ -1055,6 +1060,8 @@ class PaymentEntry(AccountsController):
 		else:
 			self.make_exchange_gain_loss_journal()
 
+		self.make_advance_gl_entries(cancel=cancel)
+
 	def add_party_gl_entries(self, gl_entries):
 		if self.party_account:
 			if self.payment_type == "Receive":
@@ -1123,7 +1130,7 @@ class PaymentEntry(AccountsController):
 		if self.book_advance_payments_in_separate_party_account:
 			gl_entries = []
 			for d in self.get("references"):
-				if d.reference_doctype in ("Sales Invoice", "Purchase Invoice"):
+				if d.reference_doctype in ("Sales Invoice", "Purchase Invoice", "Journal Entry"):
 					if not (against_voucher_type and against_voucher) or (
 						d.reference_doctype == against_voucher_type and d.reference_name == against_voucher
 					):
@@ -1145,8 +1152,25 @@ class PaymentEntry(AccountsController):
 					)
 
 				make_reverse_gl_entries(gl_entries=gl_entries, partial_cancel=True)
-			else:
-				make_gl_entries(gl_entries)
+				return
+
+			# same reference added to payment entry
+			for gl_entry in gl_entries.copy():
+				if frappe.db.exists(
+					"GL Entry",
+					{
+						"account": gl_entry.account,
+						"voucher_type": gl_entry.voucher_type,
+						"voucher_no": gl_entry.voucher_no,
+						"voucher_detail_no": gl_entry.voucher_detail_no,
+						"debit": gl_entry.debit,
+						"credit": gl_entry.credit,
+						"is_cancelled": 0,
+					},
+				):
+					gl_entries.remove(gl_entry)
+
+			make_gl_entries(gl_entries)
 
 	def make_invoice_liability_entry(self, gl_entries, invoice):
 		args_dict = {
@@ -1159,6 +1183,13 @@ class PaymentEntry(AccountsController):
 			"voucher_detail_no": invoice.name,
 		}
 
+		posting_date = frappe.db.get_value(
+			invoice.reference_doctype, invoice.reference_name, "posting_date"
+		)
+
+		if getdate(posting_date) < getdate(self.posting_date):
+			posting_date = self.posting_date
+
 		dr_or_cr = "credit" if invoice.reference_doctype == "Sales Invoice" else "debit"
 		args_dict["account"] = invoice.account
 		args_dict[dr_or_cr] = invoice.allocated_amount
@@ -1167,6 +1198,7 @@ class PaymentEntry(AccountsController):
 			{
 				"against_voucher_type": invoice.reference_doctype,
 				"against_voucher": invoice.reference_name,
+				"posting_date": posting_date,
 			}
 		)
 		gle = self.get_gl_dict(
@@ -1573,6 +1605,14 @@ def get_outstanding_reference_documents(args, validate=False):
 				fieldname, args.get(date_fields[0]), args.get(date_fields[1])
 			)
 			posting_and_due_date.append(ple[fieldname][args.get(date_fields[0]) : args.get(date_fields[1])])
+		elif args.get(date_fields[0]):
+			# if only from date is supplied
+			condition += " and {0} >= '{1}'".format(fieldname, args.get(date_fields[0]))
+			posting_and_due_date.append(ple[fieldname].gte(args.get(date_fields[0])))
+		elif args.get(date_fields[1]):
+			# if only to date is supplied
+			condition += " and {0} <= '{1}'".format(fieldname, args.get(date_fields[1]))
+			posting_and_due_date.append(ple[fieldname].lte(args.get(date_fields[1])))
 
 	if args.get("company"):
 		condition += " and company = {0}".format(frappe.db.escape(args.get("company")))
@@ -1993,10 +2033,15 @@ def get_reference_details(reference_doctype, reference_name, party_account_curre
 		if not total_amount:
 			if party_account_currency == company_currency:
 				# for handling cases that don't have multi-currency (base field)
-				total_amount = ref_doc.get("base_grand_total") or ref_doc.get("grand_total")
+				total_amount = (
+					ref_doc.get("base_rounded_total")
+					or ref_doc.get("rounded_total")
+					or ref_doc.get("base_grand_total")
+					or ref_doc.get("grand_total")
+				)
 				exchange_rate = 1
 			else:
-				total_amount = ref_doc.get("grand_total")
+				total_amount = ref_doc.get("rounded_total") or ref_doc.get("grand_total")
 		if not exchange_rate:
 			# Get the exchange rate from the original ref doc
 			# or get it based on the posting date of the ref doc.
@@ -2295,7 +2340,7 @@ def set_paid_amount_and_received_amount(
 			if bank_amount:
 				received_amount = bank_amount
 			else:
-				if company_currency != bank.account_currency:
+				if bank and company_currency != bank.account_currency:
 					received_amount = paid_amount / doc.get("conversion_rate", 1)
 				else:
 					received_amount = paid_amount * doc.get("conversion_rate", 1)
@@ -2304,7 +2349,7 @@ def set_paid_amount_and_received_amount(
 			if bank_amount:
 				paid_amount = bank_amount
 			else:
-				if company_currency != bank.account_currency:
+				if bank and company_currency != bank.account_currency:
 					paid_amount = received_amount / doc.get("conversion_rate", 1)
 				else:
 					# if party account currency and bank currency is different then populate paid amount as well

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -702,7 +702,50 @@ class TestPaymentEntry(FrappeTestCase):
 		pe2.submit()
 
 		# create return entry against si1
-		create_sales_invoice(is_return=1, return_against=si1.name, qty=-1)
+		cr_note = create_sales_invoice(is_return=1, return_against=si1.name, qty=-1)
+		si1_outstanding = frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount")
+
+		# create JE(credit note) manually against si1 and cr_note
+		je = frappe.get_doc(
+			{
+				"doctype": "Journal Entry",
+				"company": si1.company,
+				"voucher_type": "Credit Note",
+				"posting_date": nowdate(),
+			}
+		)
+		je.append(
+			"accounts",
+			{
+				"account": si1.debit_to,
+				"party_type": "Customer",
+				"party": si1.customer,
+				"debit": 0,
+				"credit": 100,
+				"debit_in_account_currency": 0,
+				"credit_in_account_currency": 100,
+				"reference_type": si1.doctype,
+				"reference_name": si1.name,
+				"cost_center": si1.items[0].cost_center,
+			},
+		)
+		je.append(
+			"accounts",
+			{
+				"account": cr_note.debit_to,
+				"party_type": "Customer",
+				"party": cr_note.customer,
+				"debit": 100,
+				"credit": 0,
+				"debit_in_account_currency": 100,
+				"credit_in_account_currency": 0,
+				"reference_type": cr_note.doctype,
+				"reference_name": cr_note.name,
+				"cost_center": cr_note.items[0].cost_center,
+			},
+		)
+		je.save().submit()
+
 		si1_outstanding = frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount")
 		self.assertEqual(si1_outstanding, -100)
 
@@ -1201,6 +1244,24 @@ class TestPaymentEntry(FrappeTestCase):
 		template.allocate_payment_based_on_payment_terms = 1
 		template.save()
 
+	def test_allocation_validation_for_sales_order(self):
+		so = make_sales_order(do_not_save=True)
+		so.items[0].rate = 99.55
+		so.save().submit()
+		self.assertGreater(so.rounded_total, 0.0)
+		pe = get_payment_entry("Sales Order", so.name, bank_account="_Test Cash - _TC")
+		pe.paid_from = "Debtors - _TC"
+		pe.paid_amount = 45.55
+		pe.references[0].allocated_amount = 45.55
+		pe.save().submit()
+		pe = get_payment_entry("Sales Order", so.name, bank_account="_Test Cash - _TC")
+		pe.paid_from = "Debtors - _TC"
+		# No validation error should be thrown here.
+		pe.save().submit()
+
+		so.reload()
+		self.assertEqual(so.advance_paid, so.rounded_total)
+
 
 def create_payment_entry(**args):
 	payment_entry = frappe.new_doc("Payment Entry")

erpnext/accounts/doctype/payment_ledger_entry/test_payment_ledger_entry.py

@@ -294,7 +294,7 @@ class TestPaymentLedgerEntry(FrappeTestCase):
 		cr_note1.return_against = si3.name
 		cr_note1 = cr_note1.save().submit()
 
-		pl_entries = (
+		pl_entries_si3 = (
 			qb.from_(ple)
 			.select(
 				ple.voucher_type,
@@ -309,7 +309,24 @@ class TestPaymentLedgerEntry(FrappeTestCase):
 			.run(as_dict=True)
 		)
 
-		expected_values = [
+		pl_entries_cr_note1 = (
+			qb.from_(ple)
+			.select(
+				ple.voucher_type,
+				ple.voucher_no,
+				ple.against_voucher_type,
+				ple.against_voucher_no,
+				ple.amount,
+				ple.delinked,
+			)
+			.where(
+				(ple.against_voucher_type == cr_note1.doctype) & (ple.against_voucher_no == cr_note1.name)
+			)
+			.orderby(ple.creation)
+			.run(as_dict=True)
+		)
+
+		expected_values_for_si3 = [
 			{
 				"voucher_type": si3.doctype,
 				"voucher_no": si3.name,
@@ -317,18 +334,21 @@ class TestPaymentLedgerEntry(FrappeTestCase):
 				"against_voucher_no": si3.name,
 				"amount": amount,
 				"delinked": 0,
-			},
+			}
+		]
+		# credit/debit notes post ledger entries against itself
+		expected_values_for_cr_note1 = [
 			{
 				"voucher_type": cr_note1.doctype,
 				"voucher_no": cr_note1.name,
-				"against_voucher_type": si3.doctype,
-				"against_voucher_no": si3.name,
+				"against_voucher_type": cr_note1.doctype,
+				"against_voucher_no": cr_note1.name,
 				"amount": -amount,
 				"delinked": 0,
 			},
 		]
-		self.assertEqual(pl_entries[0], expected_values[0])
-		self.assertEqual(pl_entries[1], expected_values[1])
+		self.assertEqual(pl_entries_si3, expected_values_for_si3)
+		self.assertEqual(pl_entries_cr_note1, expected_values_for_cr_note1)
 
 	def test_je_against_inv_and_note(self):
 		ple = self.ple

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js

@@ -24,7 +24,8 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 				filters: {
 					"company": this.frm.doc.company,
 					"is_group": 0,
-					"account_type": frappe.boot.party_account_types[this.frm.doc.party_type]
+					"account_type": frappe.boot.party_account_types[this.frm.doc.party_type],
+					"root_type": this.frm.doc.party_type == 'Customer' ? "Asset" : "Liability"
 				}
 			};
 		});
@@ -163,6 +164,15 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 		this.frm.refresh();
 	}
 
+	invoice_name() {
+		this.frm.trigger("get_unreconciled_entries");
+	}
+
+	payment_name() {
+		this.frm.trigger("get_unreconciled_entries");
+	}
+
+
 	clear_child_tables() {
 		this.frm.clear_table("invoices");
 		this.frm.clear_table("payments");

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.json

@@ -27,8 +27,10 @@
   "bank_cash_account",
   "cost_center",
   "sec_break1",
+  "invoice_name",
   "invoices",
   "column_break_15",
+  "payment_name",
   "payments",
   "sec_break2",
   "allocation"
@@ -137,6 +139,7 @@
    "label": "Minimum Invoice Amount"
   },
   {
+   "default": "50",
    "description": "System will fetch all the entries if limit value is zero.",
    "fieldname": "invoice_limit",
    "fieldtype": "Int",
@@ -167,6 +170,7 @@
    "label": "Maximum Payment Amount"
   },
   {
+   "default": "50",
    "description": "System will fetch all the entries if limit value is zero.",
    "fieldname": "payment_limit",
    "fieldtype": "Int",
@@ -194,13 +198,23 @@
    "label": "Default Advance Account",
    "mandatory_depends_on": "doc.party_type",
    "options": "Account"
+  },
+  {
+   "fieldname": "invoice_name",
+   "fieldtype": "Data",
+   "label": "Filter on Invoice"
+  },
+  {
+   "fieldname": "payment_name",
+   "fieldtype": "Data",
+   "label": "Filter on Payment"
   }
  ],
  "hide_toolbar": 1,
  "icon": "icon-resize-horizontal",
  "issingle": 1,
  "links": [],
- "modified": "2023-06-09 13:02:48.718362",
+ "modified": "2023-08-15 05:35:50.109290",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation",

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -5,6 +5,7 @@
 import frappe
 from frappe import _, msgprint, qb
 from frappe.model.document import Document
+from frappe.query_builder import Criterion
 from frappe.query_builder.custom import ConstantColumn
 from frappe.utils import flt, fmt_money, get_link_to_form, getdate, nowdate, today
 
@@ -18,7 +19,7 @@ from erpnext.accounts.utils import (
 	get_outstanding_invoices,
 	reconcile_against_document,
 )
-from erpnext.controllers.accounts_controller import get_advance_payment_entries
+from erpnext.controllers.accounts_controller import get_advance_payment_entries_for_regional
 
 
 class PaymentReconciliation(Document):
@@ -74,7 +75,10 @@ class PaymentReconciliation(Document):
 			}
 		)
 
-		payment_entries = get_advance_payment_entries(
+		if self.payment_name:
+			condition.update({"name": self.payment_name})
+
+		payment_entries = get_advance_payment_entries_for_regional(
 			self.party_type,
 			self.party,
 			party_account,
@@ -89,6 +93,9 @@ class PaymentReconciliation(Document):
 	def get_jv_entries(self):
 		condition = self.get_conditions()
 
+		if self.payment_name:
+			condition += f" and t1.name like '%%{self.payment_name}%%'"
+
 		if self.get("cost_center"):
 			condition += f" and t2.cost_center = '{self.cost_center}' "
 
@@ -109,7 +116,7 @@ class PaymentReconciliation(Document):
 				"Journal Entry" as reference_type, t1.name as reference_name,
 				t1.posting_date, t1.remark as remarks, t2.name as reference_row,
 				{dr_or_cr} as amount, t2.is_advance, t2.exchange_rate,
-				t2.account_currency as currency
+				t2.account_currency as currency, t2.cost_center as cost_center
 			from
 				`tabJournal Entry` t1, `tabJournal Entry Account` t2
 			where
@@ -146,6 +153,15 @@ class PaymentReconciliation(Document):
 	def get_return_invoices(self):
 		voucher_type = "Sales Invoice" if self.party_type == "Customer" else "Purchase Invoice"
 		doc = qb.DocType(voucher_type)
+
+		conditions = []
+		conditions.append(doc.docstatus == 1)
+		conditions.append(doc[frappe.scrub(self.party_type)] == self.party)
+		conditions.append(doc.is_return == 1)
+
+		if self.payment_name:
+			conditions.append(doc.name.like(f"%{self.payment_name}%"))
+
 		self.return_invoices = (
 			qb.from_(doc)
 			.select(
@@ -153,11 +169,7 @@ class PaymentReconciliation(Document):
 				doc.name.as_("voucher_no"),
 				doc.return_against,
 			)
-			.where(
-				(doc.docstatus == 1)
-				& (doc[frappe.scrub(self.party_type)] == self.party)
-				& (doc.is_return == 1)
-			)
+			.where(Criterion.all(conditions))
 			.run(as_dict=True)
 		)
 
@@ -174,15 +186,12 @@ class PaymentReconciliation(Document):
 		self.common_filter_conditions.append(ple.account == self.receivable_payable_account)
 
 		self.get_return_invoices()
-		return_invoices = [
-			x for x in self.return_invoices if x.return_against == None or x.return_against == ""
-		]
 
 		outstanding_dr_or_cr = []
-		if return_invoices:
+		if self.return_invoices:
 			ple_query = QueryPaymentLedger()
 			return_outstanding = ple_query.get_voucher_outstandings(
-				vouchers=return_invoices,
+				vouchers=self.return_invoices,
 				common_filter=self.common_filter_conditions,
 				posting_date=self.ple_posting_date_filter,
 				min_outstanding=-(self.minimum_payment_amount) if self.minimum_payment_amount else None,
@@ -200,6 +209,7 @@ class PaymentReconciliation(Document):
 								"amount": -(inv.outstanding_in_account_currency),
 								"posting_date": inv.posting_date,
 								"currency": inv.currency,
+								"cost_center": inv.cost_center,
 							}
 						)
 					)
@@ -226,6 +236,8 @@ class PaymentReconciliation(Document):
 			min_outstanding=self.minimum_invoice_amount if self.minimum_invoice_amount else None,
 			max_outstanding=self.maximum_invoice_amount if self.maximum_invoice_amount else None,
 			accounting_dimensions=self.accounting_dimension_filter_conditions,
+			limit=self.invoice_limit,
+			voucher_no=self.invoice_name,
 		)
 
 		cr_dr_notes = (
@@ -346,10 +358,12 @@ class PaymentReconciliation(Document):
 				"allocated_amount": allocated_amount,
 				"difference_amount": pay.get("difference_amount"),
 				"currency": inv.get("currency"),
+				"cost_center": pay.get("cost_center"),
 			}
 		)
 
 	def reconcile_allocations(self, skip_ref_details_update_for_pe=False):
+		adjust_allocations_for_taxes(self)
 		dr_or_cr = (
 			"credit_in_account_currency"
 			if erpnext.get_party_account_type(self.party_type) == "Receivable"
@@ -401,59 +415,6 @@ class PaymentReconciliation(Document):
 
 		self.get_unreconciled_entries()
 
-	def make_difference_entry(self, row):
-		journal_entry = frappe.new_doc("Journal Entry")
-		journal_entry.voucher_type = "Exchange Gain Or Loss"
-		journal_entry.company = self.company
-		journal_entry.posting_date = nowdate()
-		journal_entry.multi_currency = 1
-
-		party_account_currency = frappe.get_cached_value(
-			"Account", self.receivable_payable_account, "account_currency"
-		)
-		difference_account_currency = frappe.get_cached_value(
-			"Account", row.difference_account, "account_currency"
-		)
-
-		# Account Currency has balance
-		dr_or_cr = "debit" if self.party_type == "Customer" else "credit"
-		reverse_dr_or_cr = "debit" if dr_or_cr == "credit" else "credit"
-
-		journal_account = frappe._dict(
-			{
-				"account": self.receivable_payable_account,
-				"party_type": self.party_type,
-				"party": self.party,
-				"account_currency": party_account_currency,
-				"exchange_rate": 0,
-				"cost_center": erpnext.get_default_cost_center(self.company),
-				"reference_type": row.against_voucher_type,
-				"reference_name": row.against_voucher,
-				dr_or_cr: flt(row.difference_amount),
-				dr_or_cr + "_in_account_currency": 0,
-			}
-		)
-
-		journal_entry.append("accounts", journal_account)
-
-		journal_account = frappe._dict(
-			{
-				"account": row.difference_account,
-				"account_currency": difference_account_currency,
-				"exchange_rate": 1,
-				"cost_center": erpnext.get_default_cost_center(self.company),
-				reverse_dr_or_cr + "_in_account_currency": flt(row.difference_amount),
-				reverse_dr_or_cr: flt(row.difference_amount),
-			}
-		)
-
-		journal_entry.append("accounts", journal_account)
-
-		journal_entry.save()
-		journal_entry.submit()
-
-		return journal_entry
-
 	def get_payment_details(self, row, dr_or_cr):
 		return frappe._dict(
 			{
@@ -473,6 +434,7 @@ class PaymentReconciliation(Document):
 				"allocated_amount": flt(row.get("allocated_amount")),
 				"difference_amount": flt(row.get("difference_amount")),
 				"difference_account": row.get("difference_account"),
+				"cost_center": row.get("cost_center"),
 			}
 		)
 
@@ -619,16 +581,6 @@ class PaymentReconciliation(Document):
 
 
 def reconcile_dr_cr_note(dr_cr_notes, company):
-	def get_difference_row(inv):
-		if inv.difference_amount != 0 and inv.difference_account:
-			difference_row = {
-				"account": inv.difference_account,
-				inv.dr_or_cr: abs(inv.difference_amount) if inv.difference_amount > 0 else 0,
-				reconcile_dr_or_cr: abs(inv.difference_amount) if inv.difference_amount < 0 else 0,
-				"cost_center": erpnext.get_default_cost_center(company),
-			}
-			return difference_row
-
 	for inv in dr_cr_notes:
 		voucher_type = "Credit Note" if inv.voucher_type == "Sales Invoice" else "Debit Note"
 
@@ -655,7 +607,7 @@ def reconcile_dr_cr_note(dr_cr_notes, company):
 						inv.dr_or_cr: abs(inv.allocated_amount),
 						"reference_type": inv.against_voucher_type,
 						"reference_name": inv.against_voucher,
-						"cost_center": erpnext.get_default_cost_center(company),
+						"cost_center": inv.cost_center or erpnext.get_default_cost_center(company),
 						"exchange_rate": inv.exchange_rate,
 						"user_remark": f"{fmt_money(flt(inv.allocated_amount), currency=company_currency)} against {inv.against_voucher}",
 					},
@@ -670,7 +622,7 @@ def reconcile_dr_cr_note(dr_cr_notes, company):
 						),
 						"reference_type": inv.voucher_type,
 						"reference_name": inv.voucher_no,
-						"cost_center": erpnext.get_default_cost_center(company),
+						"cost_center": inv.cost_center or erpnext.get_default_cost_center(company),
 						"exchange_rate": inv.exchange_rate,
 						"user_remark": f"{fmt_money(flt(inv.allocated_amount), currency=company_currency)} from {inv.voucher_no}",
 					},
@@ -696,6 +648,7 @@ def reconcile_dr_cr_note(dr_cr_notes, company):
 
 			create_gain_loss_journal(
 				company,
+				today(),
 				inv.party_type,
 				inv.party,
 				inv.account,
@@ -709,4 +662,10 @@ def reconcile_dr_cr_note(dr_cr_notes, company):
 				inv.against_voucher_type,
 				inv.against_voucher,
 				None,
+				inv.cost_center,
 			)
+
+
+@erpnext.allow_regional
+def adjust_allocations_for_taxes(doc):
+	pass

erpnext/accounts/doctype/payment_reconciliation_allocation/payment_reconciliation_allocation.json

@@ -22,7 +22,8 @@
   "column_break_7",
   "difference_account",
   "exchange_rate",
-  "currency"
+  "currency",
+  "cost_center"
  ],
  "fields": [
   {
@@ -144,11 +145,17 @@
    "fieldtype": "Float",
    "label": "Exchange Rate",
    "read_only": 1
+  },
+  {
+   "fieldname": "cost_center",
+   "fieldtype": "Link",
+   "label": "Cost Center",
+   "options": "Cost Center"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2022-12-24 21:01:14.882747",
+ "modified": "2023-09-03 07:52:33.684217",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Allocation",

erpnext/accounts/doctype/payment_reconciliation_payment/payment_reconciliation_payment.json

@@ -16,7 +16,8 @@
   "sec_break1",
   "remark",
   "currency",
-  "exchange_rate"
+  "exchange_rate",
+  "cost_center"
  ],
  "fields": [
   {
@@ -98,11 +99,17 @@
    "fieldtype": "Float",
    "hidden": 1,
    "label": "Exchange Rate"
+  },
+  {
+   "fieldname": "cost_center",
+   "fieldtype": "Link",
+   "label": "Cost Center",
+   "options": "Cost Center"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2022-11-08 18:18:36.268760",
+ "modified": "2023-09-03 07:43:29.965353",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Payment",

erpnext/accounts/doctype/payment_request/payment_request.json

@@ -230,6 +230,28 @@
    "fieldtype": "Read Only",
    "label": "SWIFT Number"
   },
+  {
+   "collapsible": 1,
+   "fieldname": "accounting_dimensions_section",
+   "fieldtype": "Section Break",
+   "label": "Accounting Dimensions"
+  },
+  {
+   "fieldname": "cost_center",
+   "fieldtype": "Link",
+   "label": "Cost Center",
+   "options": "Cost Center"
+  },
+  {
+   "fieldname": "dimension_col_break",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "project",
+   "fieldtype": "Link",
+   "label": "Project",
+   "options": "Project"
+  },
   {
    "depends_on": "eval: doc.payment_request_type == 'Inward'",
    "fieldname": "recipient_and_message",
@@ -317,9 +339,10 @@
   },
   {
    "fieldname": "payment_url",
-   "fieldtype": "Small Text",
+   "fieldtype": "Data",
    "hidden": 1,
-   "label": "payment_url",
+   "length": 500,
+   "options": "URL",
    "read_only": 1
   },
   {
@@ -343,6 +366,14 @@
    "label": "Payment Account",
    "read_only": 1
   },
+  {
+   "fetch_from": "payment_gateway_account.payment_channel",
+   "fieldname": "payment_channel",
+   "fieldtype": "Select",
+   "label": "Payment Channel",
+   "options": "\nEmail\nPhone",
+   "read_only": 1
+  },
   {
    "fieldname": "payment_order",
    "fieldtype": "Link",
@@ -358,43 +389,13 @@
    "options": "Payment Request",
    "print_hide": 1,
    "read_only": 1
-  },
-  {
-   "fetch_from": "payment_gateway_account.payment_channel",
-   "fieldname": "payment_channel",
-   "fieldtype": "Select",
-   "label": "Payment Channel",
-   "options": "\nEmail\nPhone",
-   "read_only": 1
-  },
-  {
-   "collapsible": 1,
-   "fieldname": "accounting_dimensions_section",
-   "fieldtype": "Section Break",
-   "label": "Accounting Dimensions"
-  },
-  {
-   "fieldname": "cost_center",
-   "fieldtype": "Link",
-   "label": "Cost Center",
-   "options": "Cost Center"
-  },
-  {
-   "fieldname": "dimension_col_break",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "project",
-   "fieldtype": "Link",
-   "label": "Project",
-   "options": "Project"
   }
  ],
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-12-21 16:56:40.115737",
+ "modified": "2023-09-27 09:51:42.277638",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Request",

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.json

@@ -8,6 +8,7 @@
   "transaction_date",
   "posting_date",
   "fiscal_year",
+  "year_start_date",
   "amended_from",
   "company",
   "column_break1",
@@ -100,16 +101,22 @@
    "fieldtype": "Text",
    "label": "Error Message",
    "read_only": 1
+  },
+  {
+   "fieldname": "year_start_date",
+   "fieldtype": "Date",
+   "label": "Year Start Date"
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-07-20 14:51:04.714154",
+ "modified": "2023-09-11 20:19:11.810533",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Period Closing Voucher",
+ "naming_rule": "Expression (old style)",
  "owner": "Administrator",
  "permissions": [
   {
@@ -144,5 +151,6 @@
  "search_fields": "posting_date, fiscal_year",
  "sort_field": "modified",
  "sort_order": "DESC",
+ "states": [],
  "title_field": "closing_account_head"
 }

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -33,7 +33,7 @@ class PeriodClosingVoucher(AccountsController):
 	def on_cancel(self):
 		self.validate_future_closing_vouchers()
 		self.db_set("gle_processing_status", "In Progress")
-		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry")
+		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry", "Payment Ledger Entry")
 		gle_count = frappe.db.count(
 			"GL Entry",
 			{"voucher_type": "Period Closing Voucher", "voucher_no": self.name, "is_cancelled": 0},
@@ -95,15 +95,23 @@ class PeriodClosingVoucher(AccountsController):
 
 		self.check_if_previous_year_closed()
 
-		pce = frappe.db.sql(
-			"""select name from `tabPeriod Closing Voucher`
-			where posting_date > %s and fiscal_year = %s and docstatus = 1 and company = %s""",
-			(self.posting_date, self.fiscal_year, self.company),
+		pcv = frappe.qb.DocType("Period Closing Voucher")
+		existing_entry = (
+			frappe.qb.from_(pcv)
+			.select(pcv.name)
+			.where(
+				(pcv.posting_date >= self.posting_date)
+				& (pcv.fiscal_year == self.fiscal_year)
+				& (pcv.docstatus == 1)
+				& (pcv.company == self.company)
+			)
+			.run()
 		)
-		if pce and pce[0][0]:
+
+		if existing_entry and existing_entry[0][0]:
 			frappe.throw(
 				_("Another Period Closing Entry {0} has been made after {1}").format(
-					pce[0][0], self.posting_date
+					existing_entry[0][0], self.posting_date
 				)
 			)
 
@@ -126,22 +134,31 @@ class PeriodClosingVoucher(AccountsController):
 	def make_gl_entries(self, get_opening_entries=False):
 		gl_entries = self.get_gl_entries()
 		closing_entries = self.get_grouped_gl_entries(get_opening_entries=get_opening_entries)
-		if len(gl_entries) > 5000:
+		if len(gl_entries + closing_entries) > 3000:
 			frappe.enqueue(
 				process_gl_entries,
 				gl_entries=gl_entries,
+				voucher_name=self.name,
+				timeout=3000,
+			)
+
+			frappe.enqueue(
+				process_closing_entries,
+				gl_entries=gl_entries,
 				closing_entries=closing_entries,
 				voucher_name=self.name,
 				company=self.company,
 				closing_date=self.posting_date,
-				queue="long",
+				timeout=3000,
 			)
+
 			frappe.msgprint(
 				_("The GL Entries will be processed in the background, it can take a few minutes."),
 				alert=True,
 			)
 		else:
-			process_gl_entries(gl_entries, closing_entries, self.name, self.company, self.posting_date)
+			process_gl_entries(gl_entries, self.name)
+			process_closing_entries(gl_entries, closing_entries, self.name, self.company, self.posting_date)
 
 	def get_grouped_gl_entries(self, get_opening_entries=False):
 		closing_entries = []
@@ -322,17 +339,12 @@ class PeriodClosingVoucher(AccountsController):
 		return query.run(as_dict=1)
 
 
-def process_gl_entries(gl_entries, closing_entries, voucher_name, company, closing_date):
-	from erpnext.accounts.doctype.account_closing_balance.account_closing_balance import (
-		make_closing_entries,
-	)
+def process_gl_entries(gl_entries, voucher_name):
 	from erpnext.accounts.general_ledger import make_gl_entries
 
 	try:
 		if gl_entries:
 			make_gl_entries(gl_entries, merge_entries=False)
-
-		make_closing_entries(gl_entries + closing_entries, voucher_name, company, closing_date)
 		frappe.db.set_value("Period Closing Voucher", voucher_name, "gle_processing_status", "Completed")
 	except Exception as e:
 		frappe.db.rollback()
@@ -340,6 +352,19 @@ def process_gl_entries(gl_entries, closing_entries, voucher_name, company, closi
 		frappe.db.set_value("Period Closing Voucher", voucher_name, "gle_processing_status", "Failed")
 
 
+def process_closing_entries(gl_entries, closing_entries, voucher_name, company, closing_date):
+	from erpnext.accounts.doctype.account_closing_balance.account_closing_balance import (
+		make_closing_entries,
+	)
+
+	try:
+		if gl_entries + closing_entries:
+			make_closing_entries(gl_entries + closing_entries, voucher_name, company, closing_date)
+	except Exception as e:
+		frappe.db.rollback()
+		frappe.log_error(e)
+
+
 def make_reverse_gl_entries(voucher_type, voucher_no):
 	from erpnext.accounts.general_ledger import make_reverse_gl_entries
 

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -10,7 +10,7 @@ from frappe.utils import today
 from erpnext.accounts.doctype.finance_book.test_finance_book import create_finance_book
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-from erpnext.accounts.utils import get_fiscal_year, now
+from erpnext.accounts.utils import get_fiscal_year
 
 
 class TestPeriodClosingVoucher(unittest.TestCase):

erpnext/accounts/doctype/pos_closing_entry/test_pos_closing_entry.py

@@ -5,6 +5,10 @@ import unittest
 
 import frappe
 
+from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension import (
+	create_dimension,
+	disable_dimension,
+)
 from erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry import (
 	make_closing_entry_from_opening,
 )
@@ -140,6 +144,43 @@ class TestPOSClosingEntry(unittest.TestCase):
 		pos_inv1.load_from_db()
 		self.assertEqual(pos_inv1.status, "Paid")
 
+	def test_pos_closing_for_required_accounting_dimension_in_pos_profile(self):
+		"""
+		test case to check whether we can create POS Closing Entry without mandatory accounting dimension
+		"""
+
+		create_dimension()
+		pos_profile = make_pos_profile(do_not_insert=1, do_not_set_accounting_dimension=1)
+
+		self.assertRaises(frappe.ValidationError, pos_profile.insert)
+
+		pos_profile.location = "Block 1"
+		pos_profile.insert()
+		self.assertTrue(frappe.db.exists("POS Profile", pos_profile.name))
+
+		test_user = init_user_and_profile(do_not_create_pos_profile=1)
+
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
+		pos_inv1 = create_pos_invoice(rate=350, do_not_submit=1, pos_profile=pos_profile.name)
+		pos_inv1.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3500})
+		pos_inv1.submit()
+
+		# if in between a mandatory accounting dimension is added to the POS Profile then
+		accounting_dimension_department = frappe.get_doc("Accounting Dimension", {"name": "Department"})
+		accounting_dimension_department.dimension_defaults[0].mandatory_for_bs = 1
+		accounting_dimension_department.save()
+
+		pcv_doc = make_closing_entry_from_opening(opening_entry)
+		# will assert coz the new mandatory accounting dimension bank is not set in POS Profile
+		self.assertRaises(frappe.ValidationError, pcv_doc.submit)
+
+		accounting_dimension_department = frappe.get_doc(
+			"Accounting Dimension Detail", {"parent": "Department"}
+		)
+		accounting_dimension_department.mandatory_for_bs = 0
+		accounting_dimension_department.save()
+		disable_dimension()
+
 
 def init_user_and_profile(**args):
 	user = "test@example.com"
@@ -149,6 +190,9 @@ def init_user_and_profile(**args):
 	test_user.add_roles(*roles)
 	frappe.set_user(user)
 
+	if args.get("do_not_create_pos_profile"):
+		return test_user
+
 	pos_profile = make_pos_profile(**args)
 	pos_profile.append("applicable_for_users", {"default": 1, "user": user})
 

erpnext/accounts/doctype/pos_invoice/pos_invoice.js

@@ -131,6 +131,7 @@ erpnext.selling.POSInvoiceController = class POSInvoiceController extends erpnex
 			args: { "pos_profile": frm.pos_profile },
 			callback: ({ message: profile }) => {
 				this.update_customer_groups_settings(profile?.customer_groups);
+				this.frm.set_value("company", profile?.company);
 			},
 		});
 	}

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -49,6 +49,7 @@ class POSInvoice(SalesInvoice):
 		self.validate_pos()
 		self.validate_payment_amount()
 		self.validate_loyalty_transaction()
+		self.validate_company_with_pos_company()
 		if self.coupon_code:
 			from erpnext.accounts.doctype.pricing_rule.utils import validate_coupon_code
 
@@ -281,6 +282,14 @@ class POSInvoice(SalesInvoice):
 			if total_amount_in_payments and total_amount_in_payments < invoice_total:
 				frappe.throw(_("Total payments amount can't be greater than {}").format(-invoice_total))
 
+	def validate_company_with_pos_company(self):
+		if self.company != frappe.db.get_value("POS Profile", self.pos_profile, "company"):
+			frappe.throw(
+				_("Company {} does not match with POS Profile Company {}").format(
+					self.company, frappe.db.get_value("POS Profile", self.pos_profile, "company")
+				)
+			)
+
 	def validate_loyalty_transaction(self):
 		if self.redeem_loyalty_points and (
 			not self.loyalty_redemption_account or not self.loyalty_redemption_cost_center
@@ -359,6 +368,7 @@ class POSInvoice(SalesInvoice):
 		profile = {}
 		if self.pos_profile:
 			profile = frappe.get_doc("POS Profile", self.pos_profile)
+			self.company = profile.get("company")
 
 		if not self.get("payments") and not for_validate:
 			update_multi_mode_option(self, profile)
@@ -404,7 +414,7 @@ class POSInvoice(SalesInvoice):
 				selling_price_list = (
 					customer_price_list or customer_group_price_list or profile.get("selling_price_list")
 				)
-				if customer_currency != profile.get("currency"):
+				if customer_currency and customer_currency != profile.get("currency"):
 					self.set("currency", customer_currency)
 
 			else:

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -12,6 +12,8 @@ from frappe.utils import cint, flt, get_time, getdate, nowdate, nowtime
 from frappe.utils.background_jobs import enqueue, is_job_enqueued
 from frappe.utils.scheduler import is_scheduler_inactive
 
+from erpnext.accounts.doctype.pos_profile.pos_profile import required_accounting_dimensions
+
 
 class POSInvoiceMergeLog(Document):
 	def validate(self):
@@ -163,7 +165,8 @@ class POSInvoiceMergeLog(Document):
 				for i in items:
 					if (
 						i.item_code == item.item_code
-						and not i.serial_and_batch_bundle
+						and not i.serial_no
+						and not i.batch_no
 						and i.uom == item.uom
 						and i.net_rate == item.net_rate
 						and i.warehouse == item.warehouse
@@ -238,6 +241,22 @@ class POSInvoiceMergeLog(Document):
 		invoice.disable_rounded_total = cint(
 			frappe.db.get_value("POS Profile", invoice.pos_profile, "disable_rounded_total")
 		)
+		accounting_dimensions = required_accounting_dimensions()
+		dimension_values = frappe.db.get_value(
+			"POS Profile", {"name": invoice.pos_profile}, accounting_dimensions, as_dict=1
+		)
+		for dimension in accounting_dimensions:
+			dimension_value = dimension_values.get(dimension)
+
+			if not dimension_value:
+				frappe.throw(
+					_("Please set Accounting Dimension {} in {}").format(
+						frappe.bold(frappe.unscrub(dimension)),
+						frappe.get_desk_link("POS Profile", invoice.pos_profile),
+					)
+				)
+
+			invoice.set(dimension, dimension_value)
 
 		if self.merge_invoices_based_on == "Customer Group":
 			invoice.flags.ignore_pos_profile = True
@@ -424,11 +443,9 @@ def create_merge_logs(invoice_by_customer, closing_entry=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)
 				merge_log.save(ignore_permissions=True)
 				merge_log.submit()
-
 		if closing_entry:
 			closing_entry.set_status(update=True, status="Submitted")
 			closing_entry.db_set("error_message", "")

erpnext/accounts/doctype/pos_profile/pos_profile.js

@@ -1,6 +1,5 @@
 // Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
 // License: GNU General Public License v3. See license.txt
-
 frappe.ui.form.on('POS Profile', {
 	setup: function(frm) {
 		frm.set_query("selling_price_list", function() {
@@ -140,6 +139,7 @@ frappe.ui.form.on('POS Profile', {
 	company: function(frm) {
 		frm.trigger("toggle_display_account_head");
 		erpnext.accounts.dimensions.update_dimension(frm, frm.doctype);
+
 	},
 
 	toggle_display_account_head: function(frm) {

erpnext/accounts/doctype/pos_profile/pos_profile.py

@@ -3,7 +3,7 @@
 
 
 import frappe
-from frappe import _, msgprint
+from frappe import _, msgprint, scrub, unscrub
 from frappe.model.document import Document
 from frappe.utils import get_link_to_form, now
 
@@ -14,6 +14,21 @@ class POSProfile(Document):
 		self.validate_all_link_fields()
 		self.validate_duplicate_groups()
 		self.validate_payment_methods()
+		self.validate_accounting_dimensions()
+
+	def validate_accounting_dimensions(self):
+		acc_dim_names = required_accounting_dimensions()
+		for acc_dim in acc_dim_names:
+			if not self.get(acc_dim):
+				frappe.throw(
+					_(
+						"{0} is a mandatory Accounting Dimension. <br>"
+						"Please set a value for {0} in Accounting Dimensions section."
+					).format(
+						unscrub(frappe.bold(acc_dim)),
+					),
+					title=_("Mandatory Accounting Dimension"),
+				)
 
 	def validate_default_profile(self):
 		for row in self.applicable_for_users:
@@ -152,6 +167,24 @@ def get_child_nodes(group_type, root):
 	)
 
 
+def required_accounting_dimensions():
+
+	p = frappe.qb.DocType("Accounting Dimension")
+	c = frappe.qb.DocType("Accounting Dimension Detail")
+
+	acc_dim_doc = (
+		frappe.qb.from_(p)
+		.inner_join(c)
+		.on(p.name == c.parent)
+		.select(c.parent)
+		.where((c.mandatory_for_bs == 1) | (c.mandatory_for_pl == 1))
+		.where(p.disabled == 0)
+	).run(as_dict=1)
+
+	acc_dim_names = [scrub(d.parent) for d in acc_dim_doc]
+	return acc_dim_names
+
+
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def pos_profile_query(doctype, txt, searchfield, start, page_len, filters):

erpnext/accounts/doctype/pos_profile/test_pos_profile.py

@@ -5,7 +5,10 @@ import unittest
 
 import frappe
 
-from erpnext.accounts.doctype.pos_profile.pos_profile import get_child_nodes
+from erpnext.accounts.doctype.pos_profile.pos_profile import (
+	get_child_nodes,
+	required_accounting_dimensions,
+)
 from erpnext.stock.get_item_details import get_pos_profile
 
 test_dependencies = ["Item"]
@@ -118,6 +121,7 @@ def make_pos_profile(**args):
 			"warehouse": args.warehouse or "_Test Warehouse - _TC",
 			"write_off_account": args.write_off_account or "_Test Write Off - _TC",
 			"write_off_cost_center": args.write_off_cost_center or "_Test Write Off Cost Center - _TC",
+			"location": "Block 1" if not args.do_not_set_accounting_dimension else None,
 		}
 	)
 
@@ -132,6 +136,7 @@ def make_pos_profile(**args):
 	pos_profile.append("payments", {"mode_of_payment": "Cash", "default": 1})
 
 	if not frappe.db.exists("POS Profile", args.name or "_Test POS Profile"):
-		pos_profile.insert()
+		if not args.get("do_not_insert"):
+			pos_profile.insert()
 
 	return pos_profile

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.py

@@ -129,7 +129,7 @@ def trigger_job_for_doc(docname: str | None = None):
 			frappe.db.set_value("Process Payment Reconciliation", docname, "status", "Running")
 			job_name = f"start_processing_{docname}"
 			if not is_job_running(job_name):
-				job = frappe.enqueue(
+				frappe.enqueue(
 					method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.reconcile_based_on_filters",
 					queue="long",
 					is_async=True,
@@ -147,7 +147,7 @@ def trigger_job_for_doc(docname: str | None = None):
 			# Resume tasks for running doc
 			job_name = f"start_processing_{docname}"
 			if not is_job_running(job_name):
-				job = frappe.enqueue(
+				frappe.enqueue(
 					method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.reconcile_based_on_filters",
 					queue="long",
 					is_async=True,
@@ -224,7 +224,7 @@ def reconcile_based_on_filters(doc: None | str = None) -> None:
 
 			job_name = f"process_{doc}_fetch_and_allocate"
 			if not is_job_running(job_name):
-				job = frappe.enqueue(
+				frappe.enqueue(
 					method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.fetch_and_allocate",
 					queue="long",
 					timeout="3600",
@@ -245,7 +245,7 @@ def reconcile_based_on_filters(doc: None | str = None) -> None:
 			if not allocated:
 				job_name = f"process__{doc}_fetch_and_allocate"
 				if not is_job_running(job_name):
-					job = frappe.enqueue(
+					frappe.enqueue(
 						method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.fetch_and_allocate",
 						queue="long",
 						timeout="3600",
@@ -263,7 +263,7 @@ def reconcile_based_on_filters(doc: None | str = None) -> None:
 				else:
 					reconcile_job_name = f"process_{doc}_reconcile"
 				if not is_job_running(reconcile_job_name):
-					job = frappe.enqueue(
+					frappe.enqueue(
 						method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.reconcile",
 						queue="long",
 						timeout="3600",
@@ -350,7 +350,7 @@ def fetch_and_allocate(doc: str) -> None:
 					reconcile_job_name = f"process_{doc}_reconcile"
 
 				if not is_job_running(reconcile_job_name):
-					job = frappe.enqueue(
+					frappe.enqueue(
 						method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.reconcile",
 						queue="long",
 						timeout="3600",
@@ -462,7 +462,7 @@ def reconcile(doc: None | str = None) -> None:
 								reconcile_job_name = f"process_{doc}_reconcile"
 
 							if not is_job_running(reconcile_job_name):
-								job = frappe.enqueue(
+								frappe.enqueue(
 									method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.reconcile",
 									queue="long",
 									timeout="3600",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -51,6 +51,7 @@
   "column_break_21",
   "start_date",
   "section_break_33",
+  "pdf_name",
   "subject",
   "column_break_28",
   "cc_to",
@@ -275,7 +276,7 @@
    "fieldname": "help_text",
    "fieldtype": "HTML",
    "label": "Help Text",
-   "options": "<br>\n<h4>Note</h4>\n<ul>\n<li>\nYou can use <a href=\"https://jinja.palletsprojects.com/en/2.11.x/\" target=\"_blank\">Jinja tags</a> in <b>Subject</b> and <b>Body</b> fields for dynamic values.\n</li><li>\n    All fields in this doctype are available under the <b>doc</b> object and all fields for the customer to whom the mail will go to is available under the  <b>customer</b> object.\n</li></ul>\n<h4> Examples</h4>\n<!-- {% raw %} -->\n<ul>\n    <li><b>Subject</b>:<br><br><pre><code>Statement Of Accounts for {{ customer.name }}</code></pre><br></li>\n    <li><b>Body</b>: <br><br>\n<pre><code>Hello {{ customer.name }},<br>PFA your Statement Of Accounts from {{ doc.from_date }} to {{ doc.to_date }}.</code> </pre></li>\n</ul>\n<!-- {% endraw %} -->"
+   "options": "<br>\n<h4>Note</h4>\n<ul>\n<li>\nYou can use <a href=\"https://jinja.palletsprojects.com/en/2.11.x/\" target=\"_blank\">Jinja tags</a> in <b>Subject</b> and <b>Body</b> fields for dynamic values.\n</li><li>\n    All fields in this doctype are available under the <b>doc</b> object and all fields for the customer to whom the mail will go to is available under the  <b>customer</b> object.\n</li></ul>\n<h4> Examples</h4>\n<!-- {% raw %} -->\n<ul>\n    <li><b>Subject</b>:<br><br><pre><code>Statement Of Accounts for {{ customer.customer_name }}</code></pre><br></li>\n    <li><b>Body</b>: <br><br>\n<pre><code>Hello {{ customer.customer_name }},<br>PFA your Statement Of Accounts from {{ doc.from_date }} to {{ doc.to_date }}.</code> </pre></li>\n</ul>\n<!-- {% endraw %} -->"
   },
   {
    "fieldname": "subject",
@@ -370,10 +371,15 @@
    "fieldname": "based_on_payment_terms",
    "fieldtype": "Check",
    "label": "Based On Payment Terms"
+  },
+  {
+   "fieldname": "pdf_name",
+   "fieldtype": "Data",
+   "label": "PDF Name"
   }
  ],
  "links": [],
- "modified": "2023-06-23 10:13:15.051950",
+ "modified": "2023-08-28 12:59:53.071334",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -27,7 +27,13 @@ class ProcessStatementOfAccounts(Document):
 		if not self.subject:
 			self.subject = "Statement Of Accounts for {{ customer.customer_name }}"
 		if not self.body:
-			self.body = "Hello {{ customer.name }},<br>PFA your Statement Of Accounts from {{ doc.from_date }} to {{ doc.to_date }}."
+			if self.report == "General Ledger":
+				body_str = " from {{ doc.from_date }} to {{ doc.to_date }}."
+			else:
+				body_str = " until {{ doc.posting_date }}."
+			self.body = "Hello {{ customer.customer_name }},<br>PFA your Statement Of Accounts" + body_str
+		if not self.pdf_name:
+			self.pdf_name = "{{ customer.customer_name }}"
 
 		validate_template(self.subject)
 		validate_template(self.body)
@@ -60,18 +66,17 @@ def get_report_pdf(doc, consolidated=True):
 
 		if doc.report == "General Ledger":
 			filters.update(get_gl_filters(doc, entry, tax_id, presentation_currency))
-		else:
-			filters.update(get_ar_filters(doc, entry))
-
-		if doc.report == "General Ledger":
 			col, res = get_soa(filters)
 			for x in [0, -2, -1]:
 				res[x]["account"] = res[x]["account"].replace("'", "")
 			if len(res) == 3:
 				continue
 		else:
+			filters.update(get_ar_filters(doc, entry))
 			ar_res = get_ar_soa(filters)
 			col, res = ar_res[0], ar_res[1]
+			if not res:
+				continue
 
 		statement_dict[entry.customer] = get_html(doc, filters, entry, col, res, ageing)
 
@@ -140,7 +145,9 @@ def get_gl_filters(doc, entry, tax_id, presentation_currency):
 def get_ar_filters(doc, entry):
 	return {
 		"report_date": doc.posting_date if doc.posting_date else None,
-		"customer": entry.customer,
+		"party_type": "Customer",
+		"party": entry.customer,
+		"customer_name": entry.customer_name if entry.customer_name else None,
 		"payment_terms_template": doc.payment_terms_template if doc.payment_terms_template else None,
 		"sales_partner": doc.sales_partner if doc.sales_partner else None,
 		"sales_person": doc.sales_person if doc.sales_person else None,
@@ -366,18 +373,20 @@ def download_statements(document_name):
 
 
 @frappe.whitelist()
-def send_emails(document_name, from_scheduler=False):
+def send_emails(document_name, from_scheduler=False, posting_date=None):
 	doc = frappe.get_doc("Process Statement Of Accounts", document_name)
 	report = get_report_pdf(doc, consolidated=False)
 
 	if report:
 		for customer, report_pdf in report.items():
-			attachments = [{"fname": customer + ".pdf", "fcontent": report_pdf}]
+			context = get_context(customer, doc)
+			filename = frappe.render_template(doc.pdf_name, context)
+			attachments = [{"fname": filename + ".pdf", "fcontent": report_pdf}]
 
 			recipients, cc = get_recipients_and_cc(customer, doc)
 			if not recipients:
 				continue
-			context = get_context(customer, doc)
+
 			subject = frappe.render_template(doc.subject, context)
 			message = frappe.render_template(doc.body, context)
 
@@ -396,7 +405,7 @@ def send_emails(document_name, from_scheduler=False):
 			)
 
 		if doc.enable_auto_email and from_scheduler:
-			new_to_date = getdate(today())
+			new_to_date = getdate(posting_date or today())
 			if doc.frequency == "Weekly":
 				new_to_date = add_days(new_to_date, 7)
 			else:
@@ -405,8 +414,11 @@ def send_emails(document_name, from_scheduler=False):
 			doc.add_comment(
 				"Comment", "Emails sent on: " + frappe.utils.format_datetime(frappe.utils.now())
 			)
-			doc.db_set("to_date", new_to_date, commit=True)
-			doc.db_set("from_date", new_from_date, commit=True)
+			if doc.report == "General Ledger":
+				doc.db_set("to_date", new_to_date, commit=True)
+				doc.db_set("from_date", new_from_date, commit=True)
+			else:
+				doc.db_set("posting_date", new_to_date, commit=True)
 		return True
 	else:
 		return False
@@ -416,7 +428,8 @@ def send_emails(document_name, from_scheduler=False):
 def send_auto_email():
 	selected = frappe.get_list(
 		"Process Statement Of Accounts",
-		filters={"to_date": format_date(today()), "enable_auto_email": 1},
+		filters={"enable_auto_email": 1},
+		or_filters={"to_date": format_date(today()), "posting_date": format_date(today())},
 	)
 	for entry in selected:
 		send_emails(entry.name, from_scheduler=True)

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts_accounts_receivable.html

@@ -8,9 +8,24 @@
 	}
 	</style>
 
+	<div id="header-html" class="hidden-pdf">
+		{% if letter_head.content %}
+		<div class="letter-head text-center">{{ letter_head.content }}</div>
+		<hr style="height:2px;border-width:0;color:black;background-color:black;">
+		{% endif %}
+	</div>
+	<div id="footer-html" class="visible-pdf">
+		{% if letter_head.footer %}
+		<div class="letter-head-footer">
+			<hr style="border-width:0;color:black;background-color:black;padding-bottom:2px;">
+			{{ letter_head.footer }}
+		</div>
+		{% endif %}
+	</div>
+
 	<h2 class="text-center" style="margin-top:0">{{ _(report.report_name) }}</h2>
 	<h4 class="text-center">
-		{{ filters.customer }}
+		{{ filters.customer_name }}
 	</h4>
 	<h6 class="text-center">
 		{% if (filters.tax_id) %}
@@ -341,4 +356,9 @@
 		</tbody>
 	</table>
 	{% endif %}
+	{% if terms_and_conditions %}
+	<div>
+		{{ terms_and_conditions }}
+	</div>
+	{% endif %}
 	<p class="text-right text-muted">{{ _("Printed On ") }}{{ frappe.utils.now() }}</p>

erpnext/accounts/doctype/process_statement_of_accounts/test_process_statement_of_accounts.py

@@ -1,9 +1,42 @@
 # Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
 import unittest
 
+import frappe
+from frappe.utils import add_days, getdate, today
+
+from erpnext.accounts.doctype.process_statement_of_accounts.process_statement_of_accounts import (
+	send_emails,
+)
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+
 
 class TestProcessStatementOfAccounts(unittest.TestCase):
-	pass
+	def setUp(self):
+		self.si = create_sales_invoice()
+		self.process_soa = create_process_soa()
+
+	def test_auto_email_for_process_soa_ar(self):
+		send_emails(self.process_soa.name, from_scheduler=True)
+		self.process_soa.load_from_db()
+		self.assertEqual(self.process_soa.posting_date, getdate(add_days(today(), 7)))
+
+	def tearDown(self):
+		frappe.delete_doc_if_exists("Process Statement Of Accounts", "Test Process SOA")
+
+
+def create_process_soa():
+	frappe.delete_doc_if_exists("Process Statement Of Accounts", "Test Process SOA")
+	process_soa = frappe.new_doc("Process Statement Of Accounts")
+	soa_dict = {
+		"name": "Test Process SOA",
+		"company": "_Test Company",
+	}
+	process_soa.update(soa_dict)
+	process_soa.set("customers", [{"customer": "_Test Customer"}])
+	process_soa.enable_auto_email = 1
+	process_soa.frequency = "Weekly"
+	process_soa.report = "Accounts Receivable"
+	process_soa.save()
+	return process_soa

erpnext/accounts/doctype/process_subscription/process_subscription.js

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

erpnext/accounts/doctype/process_subscription/process_subscription.json

@@ -0,0 +1,90 @@
+{
+ "actions": [],
+ "allow_rename": 1,
+ "creation": "2023-09-17 15:40:59.724177",
+ "default_view": "List",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "posting_date",
+  "subscription",
+  "amended_from"
+ ],
+ "fields": [
+  {
+   "fieldname": "amended_from",
+   "fieldtype": "Link",
+   "label": "Amended From",
+   "no_copy": 1,
+   "options": "Process Subscription",
+   "print_hide": 1,
+   "read_only": 1
+  },
+  {
+   "fieldname": "posting_date",
+   "fieldtype": "Date",
+   "in_list_view": 1,
+   "label": "Posting Date",
+   "reqd": 1
+  },
+  {
+   "fieldname": "subscription",
+   "fieldtype": "Link",
+   "label": "Subscription",
+   "options": "Subscription"
+  }
+ ],
+ "index_web_pages_for_search": 1,
+ "is_submittable": 1,
+ "links": [],
+ "modified": "2023-09-17 17:33:37.974166",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Process Subscription",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "System Manager",
+   "share": 1,
+   "submit": 1,
+   "write": 1
+  },
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "Accounts Manager",
+   "share": 1,
+   "submit": 1,
+   "write": 1
+  },
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "Accounts User",
+   "share": 1,
+   "submit": 1,
+   "write": 1
+  }
+ ],
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "states": []
+}

erpnext/accounts/doctype/process_subscription/process_subscription.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+from datetime import datetime
+from typing import Union
+
+import frappe
+from frappe.model.document import Document
+from frappe.utils import getdate
+
+from erpnext.accounts.doctype.subscription.subscription import process_all
+
+
+class ProcessSubscription(Document):
+	def on_submit(self):
+		process_all(subscription=self.subscription, posting_date=self.posting_date)
+
+
+def create_subscription_process(
+	subscription: str | None, posting_date: Union[str, datetime.date] | None
+):
+	"""Create a new Process Subscription document"""
+	doc = frappe.new_doc("Process Subscription")
+	doc.subscription = subscription
+	doc.posting_date = getdate(posting_date)
+	doc.insert(ignore_permissions=True)
+	doc.submit()

erpnext/accounts/doctype/process_subscription/test_process_subscription.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+# import frappe
+from frappe.tests.utils import FrappeTestCase
+
+
+class TestProcessSubscription(FrappeTestCase):
+	pass

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -65,6 +65,25 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 			erpnext.accounts.ledger_preview.show_stock_ledger_preview(this.frm);
 		}
 
+		if (this.frm.doc.repost_required && this.frm.doc.docstatus===1) {
+			this.frm.set_intro(__("Accounting entries for this invoice need to be reposted. Please click on 'Repost' button to update."));
+			this.frm.add_custom_button(__('Repost Accounting Entries'),
+				() => {
+					this.frm.call({
+						doc: this.frm.doc,
+						method: 'repost_accounting_entries',
+						freeze: true,
+						freeze_message: __('Reposting...'),
+						callback: (r) => {
+							if (!r.exc) {
+								frappe.msgprint(__('Accounting Entries are reposted.'));
+								me.frm.refresh();
+							}
+						}
+					});
+				}).removeClass('btn-default').addClass('btn-warning');
+		}
+
 		if(!doc.is_return && doc.docstatus == 1 && doc.outstanding_amount != 0){
 			if(doc.on_hold) {
 				this.frm.add_custom_button(
@@ -86,8 +105,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 			}
 		}
 
-		if(doc.docstatus == 1 && doc.outstanding_amount != 0
-			&& !(doc.is_return && doc.return_against) && !doc.on_hold) {
+		if(doc.docstatus == 1 && doc.outstanding_amount != 0 && !doc.on_hold) {
 			this.frm.add_custom_button(
 				__('Payment'),
 				() => this.make_payment_entry(),
@@ -162,6 +180,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		}
 
 		this.frm.set_df_property("tax_withholding_category", "hidden", doc.apply_tds ? 0 : 1);
+		erpnext.accounts.unreconcile_payments.add_unreconcile_btn(me.frm);
 	}
 
 	unblock_invoice() {

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -166,6 +166,7 @@
   "against_expense_account",
   "column_break_63",
   "unrealized_profit_loss_account",
+  "repost_required",
   "subscription_section",
   "subscription",
   "auto_repeat",
@@ -191,8 +192,7 @@
   "inter_company_invoice_reference",
   "is_old_subcontracting_flow",
   "remarks",
-  "connections_tab",
-  "column_break_38"
+  "connections_tab"
  ],
  "fields": [
   {
@@ -990,6 +990,7 @@
    "print_hide": 1
   },
   {
+   "allow_on_submit": 1,
    "fieldname": "cash_bank_account",
    "fieldtype": "Link",
    "label": "Cash/Bank Account",
@@ -1053,6 +1054,7 @@
    "fieldtype": "Column Break"
   },
   {
+   "allow_on_submit": 1,
    "depends_on": "eval:flt(doc.write_off_amount)!=0",
    "fieldname": "write_off_account",
    "fieldtype": "Link",
@@ -1217,6 +1219,7 @@
    "read_only": 1
   },
   {
+   "allow_on_submit": 1,
    "default": "No",
    "fieldname": "is_opening",
    "fieldtype": "Select",
@@ -1349,6 +1352,7 @@
    "options": "Project"
   },
   {
+   "allow_on_submit": 1,
    "depends_on": "eval:doc.is_internal_supplier",
    "description": "Unrealized Profit/Loss account for intra-company transfers",
    "fieldname": "unrealized_profit_loss_account",
@@ -1504,10 +1508,6 @@
    "fieldname": "column_break_6",
    "fieldtype": "Column Break"
   },
-  {
-   "fieldname": "column_break_38",
-   "fieldtype": "Column Break"
-  },
   {
    "fieldname": "column_break_50",
    "fieldtype": "Column Break"
@@ -1578,13 +1578,22 @@
    "fieldname": "use_company_roundoff_cost_center",
    "fieldtype": "Check",
    "label": "Use Company Default Round Off Cost Center"
+  },
+  {
+   "default": "0",
+   "fieldname": "repost_required",
+   "fieldtype": "Check",
+   "hidden": 1,
+   "label": "Repost Required",
+   "options": "Account",
+   "read_only": 1
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-07-25 17:22:59.145031",
+ "modified": "2023-09-21 12:22:04.545106",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -11,6 +11,9 @@ from frappe.utils import cint, cstr, flt, formatdate, get_link_to_form, getdate,
 import erpnext
 from erpnext.accounts.deferred_revenue import validate_service_stop_date
 from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
+from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger import (
+	validate_docs_for_deferred_accounting,
+)
 from erpnext.accounts.doctype.sales_invoice.sales_invoice import (
 	check_if_return_invoice_linked_with_payment_entry,
 	get_total_in_party_account_currency,
@@ -266,9 +269,7 @@ class PurchaseInvoice(BuyingController):
 			stock_not_billed_account = self.get_company_default("stock_received_but_not_billed")
 			stock_items = self.get_stock_items()
 
-		asset_items = [d.is_fixed_asset for d in self.items if d.is_fixed_asset]
-		if len(asset_items) > 0:
-			asset_received_but_not_billed = self.get_company_default("asset_received_but_not_billed")
+		asset_received_but_not_billed = None
 
 		if self.update_stock:
 			self.validate_item_code()
@@ -362,6 +363,8 @@ class PurchaseInvoice(BuyingController):
 					)
 				item.expense_account = asset_category_account
 			elif item.is_fixed_asset and item.pr_detail:
+				if not asset_received_but_not_billed:
+					asset_received_but_not_billed = self.get_company_default("asset_received_but_not_billed")
 				item.expense_account = asset_received_but_not_billed
 			elif not item.expense_account and for_validate:
 				throw(_("Expense account is mandatory for item {0}").format(item.item_code or item.item_name))
@@ -484,6 +487,11 @@ class PurchaseInvoice(BuyingController):
 						_("Stock cannot be updated against Purchase Receipt {0}").format(item.purchase_receipt)
 					)
 
+	def validate_for_repost(self):
+		self.validate_write_off_account()
+		self.validate_expense_account()
+		validate_docs_for_deferred_accounting([], [self.name])
+
 	def on_submit(self):
 		super(PurchaseInvoice, self).on_submit()
 
@@ -522,6 +530,18 @@ class PurchaseInvoice(BuyingController):
 
 		self.process_common_party_accounting()
 
+	def on_update_after_submit(self):
+		if hasattr(self, "repost_required"):
+			fields_to_check = [
+				"cash_bank_account",
+				"write_off_account",
+				"unrealized_profit_loss_account",
+			]
+			child_tables = {"items": ("expense_account",), "taxes": ("account_head",)}
+			self.needs_repost = self.check_if_fields_updated(fields_to_check, child_tables)
+			self.validate_for_repost()
+			self.db_set("repost_required", self.needs_repost)
+
 	def make_gl_entries(self, gl_entries=None, from_repost=False):
 		if not gl_entries:
 			gl_entries = self.get_gl_entries()
@@ -628,9 +648,7 @@ class PurchaseInvoice(BuyingController):
 						"credit_in_account_currency": base_grand_total
 						if self.party_account_currency == self.company_currency
 						else grand_total,
-						"against_voucher": self.return_against
-						if cint(self.is_return) and self.return_against
-						else self.name,
+						"against_voucher": self.name,
 						"against_voucher_type": self.doctype,
 						"project": self.project,
 						"cost_center": self.cost_center,
@@ -761,21 +779,22 @@ class PurchaseInvoice(BuyingController):
 
 					# Amount added through landed-cost-voucher
 					if landed_cost_entries:
-						for account, amount in landed_cost_entries[(item.item_code, item.name)].items():
-							gl_entries.append(
-								self.get_gl_dict(
-									{
-										"account": account,
-										"against": item.expense_account,
-										"cost_center": item.cost_center,
-										"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
-										"credit": flt(amount["base_amount"]),
-										"credit_in_account_currency": flt(amount["amount"]),
-										"project": item.project or self.project,
-									},
-									item=item,
+						if (item.item_code, item.name) in landed_cost_entries:
+							for account, amount in landed_cost_entries[(item.item_code, item.name)].items():
+								gl_entries.append(
+									self.get_gl_dict(
+										{
+											"account": account,
+											"against": item.expense_account,
+											"cost_center": item.cost_center,
+											"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+											"credit": flt(amount["base_amount"]),
+											"credit_in_account_currency": flt(amount["amount"]),
+											"project": item.project or self.project,
+										},
+										item=item,
+									)
 								)
-							)
 
 					# sub-contracting warehouse
 					if flt(item.rm_supp_cost):
@@ -970,8 +989,9 @@ class PurchaseInvoice(BuyingController):
 						)
 
 	def get_asset_gl_entry(self, gl_entries):
-		arbnb_account = self.get_company_default("asset_received_but_not_billed")
-		eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
+		arbnb_account = None
+		eiiav_account = None
+		asset_eiiav_currency = None
 
 		for item in self.get("items"):
 			if item.is_fixed_asset:
@@ -983,6 +1003,8 @@ class PurchaseInvoice(BuyingController):
 					"Asset Received But Not Billed",
 					"Fixed Asset",
 				]:
+					if not arbnb_account:
+						arbnb_account = self.get_company_default("asset_received_but_not_billed")
 					item.expense_account = arbnb_account
 
 				if not self.update_stock:
@@ -1005,7 +1027,10 @@ class PurchaseInvoice(BuyingController):
 					)
 
 					if item.item_tax_amount:
-						asset_eiiav_currency = get_account_currency(eiiav_account)
+						if not eiiav_account or not asset_eiiav_currency:
+							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
+							asset_eiiav_currency = get_account_currency(eiiav_account)
+
 						gl_entries.append(
 							self.get_gl_dict(
 								{
@@ -1048,7 +1073,10 @@ class PurchaseInvoice(BuyingController):
 					)
 
 					if item.item_tax_amount and not cint(erpnext.is_perpetual_inventory_enabled(self.company)):
-						asset_eiiav_currency = get_account_currency(eiiav_account)
+						if not eiiav_account or not asset_eiiav_currency:
+							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
+							asset_eiiav_currency = get_account_currency(eiiav_account)
+
 						gl_entries.append(
 							self.get_gl_dict(
 								{
@@ -1068,47 +1096,46 @@ class PurchaseInvoice(BuyingController):
 							)
 						)
 
-					# When update stock is checked
 					# Assets are bought through this document then it will be linked to this document
-					if self.update_stock:
-						if flt(item.landed_cost_voucher_amount):
-							gl_entries.append(
-								self.get_gl_dict(
-									{
-										"account": eiiav_account,
-										"against": cwip_account,
-										"cost_center": item.cost_center,
-										"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
-										"credit": flt(item.landed_cost_voucher_amount),
-										"project": item.project or self.project,
-									},
-									item=item,
-								)
-							)
+					if flt(item.landed_cost_voucher_amount):
+						if not eiiav_account:
+							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
 
-							gl_entries.append(
-								self.get_gl_dict(
-									{
-										"account": cwip_account,
-										"against": eiiav_account,
-										"cost_center": item.cost_center,
-										"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
-										"debit": flt(item.landed_cost_voucher_amount),
-										"project": item.project or self.project,
-									},
-									item=item,
-								)
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": eiiav_account,
+									"against": cwip_account,
+									"cost_center": item.cost_center,
+									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+									"credit": flt(item.landed_cost_voucher_amount),
+									"project": item.project or self.project,
+								},
+								item=item,
 							)
-
-						# update gross amount of assets bought through this document
-						assets = frappe.db.get_all(
-							"Asset", filters={"purchase_invoice": self.name, "item_code": item.item_code}
 						)
-						for asset in assets:
-							frappe.db.set_value("Asset", asset.name, "gross_purchase_amount", flt(item.valuation_rate))
-							frappe.db.set_value(
-								"Asset", asset.name, "purchase_receipt_amount", flt(item.valuation_rate)
+
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": cwip_account,
+									"against": eiiav_account,
+									"cost_center": item.cost_center,
+									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+									"debit": flt(item.landed_cost_voucher_amount),
+									"project": item.project or self.project,
+								},
+								item=item,
 							)
+						)
+
+					# update gross amount of assets bought through this document
+					assets = frappe.db.get_all(
+						"Asset", filters={"purchase_invoice": self.name, "item_code": item.item_code}
+					)
+					for asset in assets:
+						frappe.db.set_value("Asset", asset.name, "gross_purchase_amount", flt(item.valuation_rate))
+						frappe.db.set_value("Asset", asset.name, "purchase_receipt_amount", flt(item.valuation_rate))
 
 		return gl_entries
 
@@ -1644,12 +1671,8 @@ class PurchaseInvoice(BuyingController):
 				elif outstanding_amount > 0 and getdate(self.due_date) >= getdate():
 					self.status = "Unpaid"
 				# Check if outstanding amount is 0 due to debit note issued against invoice
-				elif (
-					outstanding_amount <= 0
-					and self.is_return == 0
-					and frappe.db.get_value(
-						"Purchase Invoice", {"is_return": 1, "return_against": self.name, "docstatus": 1}
-					)
+				elif self.is_return == 0 and frappe.db.get_value(
+					"Purchase Invoice", {"is_return": 1, "return_against": self.name, "docstatus": 1}
 				):
 					self.status = "Debit Note Issued"
 				elif self.is_return == 1:

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -1164,7 +1164,7 @@ class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 
 		item = create_item("_Test Item for Deferred Accounting", is_purchase_item=True)
 		item.enable_deferred_expense = 1
-		item.deferred_expense_account = deferred_account
+		item.item_defaults[0].deferred_expense_account = deferred_account
 		item.save()
 
 		pi = make_purchase_invoice(item=item.name, qty=1, rate=100, do_not_save=True)
@@ -1744,7 +1744,6 @@ class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 
 		pi = make_purchase_invoice(
 			company="_Test Company",
-			customer="_Test Supplier",
 			do_not_save=True,
 			do_not_submit=True,
 			rate=1000,
@@ -1862,7 +1861,6 @@ class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 
 		pi = make_purchase_invoice(
 			company="_Test Company",
-			customer="_Test Supplier",
 			do_not_save=True,
 			do_not_submit=True,
 			rate=1000,
@@ -1892,6 +1890,32 @@ class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 		clear_dimension_defaults("Branch")
 		disable_dimension()
 
+	def test_repost_accounting_entries(self):
+		pi = make_purchase_invoice(
+			rate=1000,
+			price_list_rate=1000,
+			qty=1,
+		)
+		expected_gle = [
+			["_Test Account Cost for Goods Sold - _TC", 1000, 0.0, nowdate()],
+			["Creditors - _TC", 0.0, 1000, nowdate()],
+		]
+		check_gl_entries(self, pi.name, expected_gle, nowdate())
+
+		pi.items[0].expense_account = "Service - _TC"
+		pi.save()
+		pi.load_from_db()
+		self.assertTrue(pi.repost_required)
+		pi.repost_accounting_entries()
+
+		expected_gle = [
+			["Creditors - _TC", 0.0, 1000, nowdate()],
+			["Service - _TC", 1000, 0.0, nowdate()],
+		]
+		check_gl_entries(self, pi.name, expected_gle, nowdate())
+		pi.load_from_db()
+		self.assertFalse(pi.repost_required)
+
 
 def set_advance_flag(company, flag, default_account):
 	frappe.db.set_value(

erpnext/accounts/doctype/purchase_invoice_item/purchase_invoice_item.json

@@ -473,6 +473,7 @@
    "label": "Accounting"
   },
   {
+   "allow_on_submit": 1,
    "fieldname": "expense_account",
    "fieldtype": "Link",
    "label": "Expense Head",

erpnext/accounts/doctype/purchase_taxes_and_charges/purchase_taxes_and_charges.json

@@ -86,6 +86,7 @@
    "fieldtype": "Column Break"
   },
   {
+   "allow_on_submit": 1,
    "columns": 2,
    "fieldname": "account_head",
    "fieldtype": "Link",
@@ -97,6 +98,7 @@
    "reqd": 1
   },
   {
+   "allow_on_submit": 1,
    "default": ":Company",
    "fieldname": "cost_center",
    "fieldtype": "Link",

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.json

@@ -55,7 +55,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-07-27 15:47:58.975034",
+ "modified": "2023-09-26 14:21:27.362567",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Repost Accounting Ledger",
@@ -77,5 +77,6 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": []
+ "states": [],
+ "track_changes": 1
 }

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.py

@@ -21,29 +21,8 @@ class RepostAccountingLedger(Document):
 
 	def validate_for_deferred_accounting(self):
 		sales_docs = [x.voucher_no for x in self.vouchers if x.voucher_type == "Sales Invoice"]
-		docs_with_deferred_revenue = frappe.db.get_all(
-			"Sales Invoice Item",
-			filters={"parent": ["in", sales_docs], "docstatus": 1, "enable_deferred_revenue": True},
-			fields=["parent"],
-			as_list=1,
-		)
-
 		purchase_docs = [x.voucher_no for x in self.vouchers if x.voucher_type == "Purchase Invoice"]
-		docs_with_deferred_expense = frappe.db.get_all(
-			"Purchase Invoice Item",
-			filters={"parent": ["in", purchase_docs], "docstatus": 1, "enable_deferred_expense": 1},
-			fields=["parent"],
-			as_list=1,
-		)
-
-		if docs_with_deferred_revenue or docs_with_deferred_expense:
-			frappe.throw(
-				_("Documents: {0} have deferred revenue/expense enabled for them. Cannot repost.").format(
-					frappe.bold(
-						comma_and([x[0] for x in docs_with_deferred_expense + docs_with_deferred_revenue])
-					)
-				)
-			)
+		validate_docs_for_deferred_accounting(sales_docs, purchase_docs)
 
 	def validate_for_closed_fiscal_year(self):
 		if self.vouchers:
@@ -139,14 +118,17 @@ class RepostAccountingLedger(Document):
 		return rendered_page
 
 	def on_submit(self):
-		job_name = "repost_accounting_ledger_" + self.name
-		frappe.enqueue(
-			method="erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger.start_repost",
-			account_repost_doc=self.name,
-			is_async=True,
-			job_name=job_name,
-		)
-		frappe.msgprint(_("Repost has started in the background"))
+		if len(self.vouchers) > 1:
+			job_name = "repost_accounting_ledger_" + self.name
+			frappe.enqueue(
+				method="erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger.start_repost",
+				account_repost_doc=self.name,
+				is_async=True,
+				job_name=job_name,
+			)
+			frappe.msgprint(_("Repost has started in the background"))
+		else:
+			start_repost(self.name)
 
 
 @frappe.whitelist()
@@ -181,3 +163,26 @@ def start_repost(account_repost_doc=str) -> None:
 					doc.make_gl_entries()
 
 				frappe.db.commit()
+
+
+def validate_docs_for_deferred_accounting(sales_docs, purchase_docs):
+	docs_with_deferred_revenue = frappe.db.get_all(
+		"Sales Invoice Item",
+		filters={"parent": ["in", sales_docs], "docstatus": 1, "enable_deferred_revenue": True},
+		fields=["parent"],
+		as_list=1,
+	)
+
+	docs_with_deferred_expense = frappe.db.get_all(
+		"Purchase Invoice Item",
+		filters={"parent": ["in", purchase_docs], "docstatus": 1, "enable_deferred_expense": 1},
+		fields=["parent"],
+		as_list=1,
+	)
+
+	if docs_with_deferred_revenue or docs_with_deferred_expense:
+		frappe.throw(
+			_("Documents: {0} have deferred revenue/expense enabled for them. Cannot repost.").format(
+				frappe.bold(comma_and([x[0] for x in docs_with_deferred_expense + docs_with_deferred_revenue]))
+			)
+		)

erpnext/accounts/doctype/repost_payment_ledger/repost_payment_ledger.json

@@ -99,7 +99,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-11-08 07:38:40.079038",
+ "modified": "2023-09-26 14:21:35.719727",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Repost Payment Ledger",
@@ -155,5 +155,6 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": []
+ "states": [],
+ "track_changes": 1
 }

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -37,7 +37,7 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 		super.onload();
 
 		this.frm.ignore_doctypes_on_cancel_all = ['POS Invoice', 'Timesheet', 'POS Invoice Merge Log',
-							  'POS Closing Entry', 'Journal Entry', 'Payment Entry', "Repost Payment Ledger", "Repost Accounting Ledger"];
+							  'POS Closing Entry', 'Journal Entry', 'Payment Entry', "Repost Payment Ledger", "Repost Accounting Ledger", "Unreconcile Payments", "Unreconcile Payment Entries"];
 
 		if(!this.frm.doc.__islocal && !this.frm.doc.customer && this.frm.doc.debit_to) {
 			// show debit_to in print format
@@ -98,8 +98,7 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 			erpnext.accounts.ledger_preview.show_stock_ledger_preview(this.frm);
 		}
 
-		if (doc.docstatus == 1 && doc.outstanding_amount!=0
-			&& !(cint(doc.is_return) && doc.return_against)) {
+		if (doc.docstatus == 1 && doc.outstanding_amount!=0) {
 			this.frm.add_custom_button(
 				__('Payment'),
 				() => this.make_payment_entry(),
@@ -184,8 +183,11 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 				}, __('Create'));
 			}
 		}
+
+		erpnext.accounts.unreconcile_payments.add_unreconcile_btn(me.frm);
 	}
 
+
 	make_maintenance_schedule() {
 		frappe.model.open_mapped_doc({
 			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.make_maintenance_schedule",

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -716,6 +716,7 @@
    "fieldtype": "Table",
    "hide_days": 1,
    "hide_seconds": 1,
+   "label": "Items",
    "oldfieldname": "entries",
    "oldfieldtype": "Table",
    "options": "Sales Invoice Item",

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -11,13 +11,13 @@ from frappe.utils import add_days, cint, cstr, flt, formatdate, get_link_to_form
 
 import erpnext
 from erpnext.accounts.deferred_revenue import validate_service_stop_date
-from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
-	get_accounting_dimensions,
-)
 from erpnext.accounts.doctype.loyalty_program.loyalty_program import (
 	get_loyalty_program_details_with_points,
 	validate_loyalty_points,
 )
+from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger import (
+	validate_docs_for_deferred_accounting,
+)
 from erpnext.accounts.doctype.tax_withholding_category.tax_withholding_category import (
 	get_party_tax_withholding_details,
 )
@@ -168,6 +168,12 @@ class SalesInvoice(SellingController):
 		self.validate_account_for_change_amount()
 		self.validate_income_account()
 
+	def validate_for_repost(self):
+		self.validate_write_off_account()
+		self.validate_account_for_change_amount()
+		self.validate_income_account()
+		validate_docs_for_deferred_accounting([self.name], [])
+
 	def validate_fixed_asset(self):
 		for d in self.get("items"):
 			if d.is_fixed_asset and d.meta.get_field("asset") and d.asset:
@@ -388,6 +394,8 @@ class SalesInvoice(SellingController):
 			"Repost Payment Ledger Items",
 			"Repost Accounting Ledger",
 			"Repost Accounting Ledger Items",
+			"Unreconcile Payments",
+			"Unreconcile Payment Entries",
 			"Payment Ledger Entry",
 			"Serial and Batch Bundle",
 		)
@@ -515,90 +523,21 @@ class SalesInvoice(SellingController):
 
 	def on_update_after_submit(self):
 		if hasattr(self, "repost_required"):
-			needs_repost = 0
-
-			# Check if any field affecting accounting entry is altered
-			doc_before_update = self.get_doc_before_save()
-			accounting_dimensions = get_accounting_dimensions() + ["cost_center", "project"]
-
-			# Check if opening entry check updated
-			if doc_before_update.get("is_opening") != self.is_opening:
-				needs_repost = 1
-
-			if not needs_repost:
-				# Parent Level Accounts excluding party account
-				for field in (
-					"additional_discount_account",
-					"cash_bank_account",
-					"account_for_change_amount",
-					"write_off_account",
-					"loyalty_redemption_account",
-					"unrealized_profit_loss_account",
-				):
-					if doc_before_update.get(field) != self.get(field):
-						needs_repost = 1
-						break
-
-				# Check for parent accounting dimensions
-				for dimension in accounting_dimensions:
-					if doc_before_update.get(dimension) != self.get(dimension):
-						needs_repost = 1
-						break
-
-				# Check for child tables
-				if self.check_if_child_table_updated(
-					"items",
-					doc_before_update,
-					("income_account", "expense_account", "discount_account"),
-					accounting_dimensions,
-				):
-					needs_repost = 1
-
-				if self.check_if_child_table_updated(
-					"taxes", doc_before_update, ("account_head",), accounting_dimensions
-				):
-					needs_repost = 1
-
-			self.validate_accounts()
-
-			# validate if deferred revenue is enabled for any item
-			# Don't allow to update the invoice if deferred revenue is enabled
-			if needs_repost:
-				for item in self.get("items"):
-					if item.enable_deferred_revenue:
-						frappe.throw(
-							_(
-								"Deferred Revenue is enabled for item {0}. You cannot update the invoice after submission."
-							).format(item.item_code)
-						)
-
-			self.db_set("repost_required", needs_repost)
-
-	def check_if_child_table_updated(
-		self, child_table, doc_before_update, fields_to_check, accounting_dimensions
-	):
-		# Check if any field affecting accounting entry is altered
-		for index, item in enumerate(self.get(child_table)):
-			for field in fields_to_check:
-				if doc_before_update.get(child_table)[index].get(field) != item.get(field):
-					return True
-
-			for dimension in accounting_dimensions:
-				if doc_before_update.get(child_table)[index].get(dimension) != item.get(dimension):
-					return True
-
-		return False
-
-	@frappe.whitelist()
-	def repost_accounting_entries(self):
-		if self.repost_required:
-			self.docstatus = 2
-			self.make_gl_entries_on_cancel()
-			self.docstatus = 1
-			self.make_gl_entries()
-			self.db_set("repost_required", 0)
-		else:
-			frappe.throw(_("No updates pending for reposting"))
+			fields_to_check = [
+				"additional_discount_account",
+				"cash_bank_account",
+				"account_for_change_amount",
+				"write_off_account",
+				"loyalty_redemption_account",
+				"unrealized_profit_loss_account",
+			]
+			child_tables = {
+				"items": ("income_account", "expense_account", "discount_account"),
+				"taxes": ("account_head",),
+			}
+			self.needs_repost = self.check_if_fields_updated(fields_to_check, child_tables)
+			self.validate_for_repost()
+			self.db_set("repost_required", self.needs_repost)
 
 	def set_paid_amount(self):
 		paid_amount = 0.0
@@ -1104,9 +1043,7 @@ class SalesInvoice(SellingController):
 						"debit_in_account_currency": base_grand_total
 						if self.party_account_currency == self.company_currency
 						else grand_total,
-						"against_voucher": self.return_against
-						if cint(self.is_return) and self.return_against
-						else self.name,
+						"against_voucher": self.name,
 						"against_voucher_type": self.doctype,
 						"cost_center": self.cost_center,
 						"project": self.project,
@@ -1732,12 +1669,8 @@ class SalesInvoice(SellingController):
 				elif outstanding_amount > 0 and getdate(self.due_date) >= getdate():
 					self.status = "Unpaid"
 				# Check if outstanding amount is 0 due to credit note issued against invoice
-				elif (
-					outstanding_amount <= 0
-					and self.is_return == 0
-					and frappe.db.get_value(
-						"Sales Invoice", {"is_return": 1, "return_against": self.name, "docstatus": 1}
-					)
+				elif self.is_return == 0 and frappe.db.get_value(
+					"Sales Invoice", {"is_return": 1, "return_against": self.name, "docstatus": 1}
 				):
 					self.status = "Credit Note Issued"
 				elif self.is_return == 1:

erpnext/accounts/doctype/sales_invoice/sales_invoice_dashboard.py

@@ -15,9 +15,11 @@ def get_data():
 		},
 		"internal_links": {
 			"Sales Order": ["items", "sales_order"],
-			"Delivery Note": ["items", "delivery_note"],
 			"Timesheet": ["timesheets", "time_sheet"],
 		},
+		"internal_and_external_links": {
+			"Delivery Note": ["items", "delivery_note"],
+		},
 		"transactions": [
 			{
 				"label": _("Payment"),

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -1500,8 +1500,8 @@ class TestSalesInvoice(unittest.TestCase):
 		self.assertEqual(party_credited, 1000)
 
 		# Check outstanding amount
-		self.assertFalse(si1.outstanding_amount)
-		self.assertEqual(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"), 1500)
+		self.assertEqual(frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount"), -1000)
+		self.assertEqual(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"), 2500)
 
 	def test_gle_made_when_asset_is_returned(self):
 		create_asset_data()
@@ -1801,6 +1801,10 @@ class TestSalesInvoice(unittest.TestCase):
 		)
 
 	def test_outstanding_amount_after_advance_payment_entry_cancellation(self):
+		"""Test impact of advance PE submission/cancellation on SI and SO."""
+		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+
+		sales_order = make_sales_order(item_code="138-CMS Shoe", qty=1, price_list_rate=500)
 		pe = frappe.get_doc(
 			{
 				"doctype": "Payment Entry",
@@ -1820,10 +1824,25 @@ class TestSalesInvoice(unittest.TestCase):
 				"paid_to": "_Test Cash - _TC",
 			}
 		)
+		pe.append(
+			"references",
+			{
+				"reference_doctype": "Sales Order",
+				"reference_name": sales_order.name,
+				"total_amount": sales_order.grand_total,
+				"outstanding_amount": sales_order.grand_total,
+				"allocated_amount": 300,
+			},
+		)
 		pe.insert()
 		pe.submit()
 
+		sales_order.reload()
+		self.assertEqual(sales_order.advance_paid, 300)
+
 		si = frappe.copy_doc(test_records[0])
+		si.items[0].sales_order = sales_order.name
+		si.items[0].so_detail = sales_order.get("items")[0].name
 		si.is_pos = 0
 		si.append(
 			"advances",
@@ -1831,6 +1850,7 @@ class TestSalesInvoice(unittest.TestCase):
 				"doctype": "Sales Invoice Advance",
 				"reference_type": "Payment Entry",
 				"reference_name": pe.name,
+				"reference_row": pe.references[0].name,
 				"advance_amount": 300,
 				"allocated_amount": 300,
 				"remarks": pe.remarks,
@@ -1839,7 +1859,13 @@ class TestSalesInvoice(unittest.TestCase):
 		si.insert()
 		si.submit()
 
-		si.load_from_db()
+		si.reload()
+		pe.reload()
+		sales_order.reload()
+
+		# Check if SO is unlinked/replaced by SI in PE & if SO advance paid is 0
+		self.assertEqual(pe.references[0].reference_name, si.name)
+		self.assertEqual(sales_order.advance_paid, 0.0)
 
 		# check outstanding after advance allocation
 		self.assertEqual(
@@ -1847,11 +1873,9 @@ class TestSalesInvoice(unittest.TestCase):
 			flt(si.rounded_total - si.total_advance, si.precision("outstanding_amount")),
 		)
 
-		# added to avoid Document has been modified exception
-		pe = frappe.get_doc("Payment Entry", pe.name)
 		pe.cancel()
+		si.reload()
 
-		si.load_from_db()
 		# check outstanding after advance cancellation
 		self.assertEqual(
 			flt(si.outstanding_amount),
@@ -2322,7 +2346,7 @@ class TestSalesInvoice(unittest.TestCase):
 
 		item = create_item("_Test Item for Deferred Accounting")
 		item.enable_deferred_revenue = 1
-		item.deferred_revenue_account = deferred_account
+		item.item_defaults[0].deferred_revenue_account = deferred_account
 		item.no_of_months = 12
 		item.save()
 
@@ -3102,7 +3126,7 @@ class TestSalesInvoice(unittest.TestCase):
 
 		item = create_item("_Test Item for Deferred Accounting")
 		item.enable_deferred_expense = 1
-		item.deferred_revenue_account = deferred_account
+		item.item_defaults[0].deferred_revenue_account = deferred_account
 		item.save()
 
 		si = create_sales_invoice(

erpnext/accounts/doctype/subscription/subscription.json

@@ -24,8 +24,9 @@
   "current_invoice_start",
   "current_invoice_end",
   "days_until_due",
+  "generate_invoice_at",
+  "number_of_days",
   "cancel_at_period_end",
-  "generate_invoice_at_period_start",
   "sb_4",
   "plans",
   "sb_1",
@@ -86,12 +87,14 @@
    "fieldname": "current_invoice_start",
    "fieldtype": "Date",
    "label": "Current Invoice Start Date",
+   "no_copy": 1,
    "read_only": 1
   },
   {
    "fieldname": "current_invoice_end",
    "fieldtype": "Date",
    "label": "Current Invoice End Date",
+   "no_copy": 1,
    "read_only": 1
   },
   {
@@ -107,12 +110,6 @@
    "fieldtype": "Check",
    "label": "Cancel At End Of Period"
   },
-  {
-   "default": "0",
-   "fieldname": "generate_invoice_at_period_start",
-   "fieldtype": "Check",
-   "label": "Generate Invoice At Beginning Of Period"
-  },
   {
    "allow_on_submit": 1,
    "fieldname": "sb_4",
@@ -240,6 +237,21 @@
    "fieldname": "submit_invoice",
    "fieldtype": "Check",
    "label": "Submit Generated Invoices"
+  },
+  {
+   "default": "End of the current subscription period",
+   "fieldname": "generate_invoice_at",
+   "fieldtype": "Select",
+   "label": "Generate Invoice At",
+   "options": "End of the current subscription period\nBeginning of the current subscription period\nDays before the current subscription period",
+   "reqd": 1
+  },
+  {
+   "depends_on": "eval:doc.generate_invoice_at === \"Days before the current subscription period\"",
+   "fieldname": "number_of_days",
+   "fieldtype": "Int",
+   "label": "Number of Days",
+   "mandatory_depends_on": "eval:doc.generate_invoice_at === \"Days before the current subscription period\""
   }
  ],
  "index_web_pages_for_search": 1,
@@ -255,7 +267,7 @@
    "link_fieldname": "subscription"
   }
  ],
- "modified": "2022-02-18 23:24:57.185054",
+ "modified": "2023-09-18 17:48:21.900252",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Subscription",

erpnext/accounts/doctype/subscription/subscription.py

@@ -36,12 +36,15 @@ class InvoiceNotCancelled(frappe.ValidationError):
 	pass
 
 
+DateTimeLikeObject = Union[str, datetime.date]
+
+
 class Subscription(Document):
 	def before_insert(self):
 		# update start just before the subscription doc is created
 		self.update_subscription_period(self.start_date)
 
-	def update_subscription_period(self, date: Optional[Union[datetime.date, str]] = None):
+	def update_subscription_period(self, date: Optional["DateTimeLikeObject"] = None):
 		"""
 		Subscription period is the period to be billed. This method updates the
 		beginning of the billing period and end of the billing period.
@@ -52,14 +55,14 @@ class Subscription(Document):
 		self.current_invoice_start = self.get_current_invoice_start(date)
 		self.current_invoice_end = self.get_current_invoice_end(self.current_invoice_start)
 
-	def _get_subscription_period(self, date: Optional[Union[datetime.date, str]] = None):
+	def _get_subscription_period(self, date: Optional["DateTimeLikeObject"] = None):
 		_current_invoice_start = self.get_current_invoice_start(date)
 		_current_invoice_end = self.get_current_invoice_end(_current_invoice_start)
 
 		return _current_invoice_start, _current_invoice_end
 
 	def get_current_invoice_start(
-		self, date: Optional[Union[datetime.date, str]] = None
+		self, date: Optional["DateTimeLikeObject"] = None
 	) -> Union[datetime.date, str]:
 		"""
 		This returns the date of the beginning of the current billing period.
@@ -84,7 +87,7 @@ class Subscription(Document):
 		return _current_invoice_start
 
 	def get_current_invoice_end(
-		self, date: Optional[Union[datetime.date, str]] = None
+		self, date: Optional["DateTimeLikeObject"] = None
 	) -> Union[datetime.date, str]:
 		"""
 		This returns the date of the end of the current billing period.
@@ -179,30 +182,24 @@ class Subscription(Document):
 
 		return data
 
-	def set_subscription_status(self) -> None:
+	def set_subscription_status(self, posting_date: Optional["DateTimeLikeObject"] = None) -> None:
 		"""
 		Sets the status of the `Subscription`
 		"""
 		if self.is_trialling():
 			self.status = "Trialling"
 		elif (
-			self.status == "Active"
-			and self.end_date
-			and getdate(frappe.flags.current_date) > getdate(self.end_date)
+			self.status == "Active" and self.end_date and getdate(posting_date) > getdate(self.end_date)
 		):
 			self.status = "Completed"
 		elif self.is_past_grace_period():
 			self.status = self.get_status_for_past_grace_period()
-			self.cancelation_date = (
-				getdate(frappe.flags.current_date) if self.status == "Cancelled" else None
-			)
+			self.cancelation_date = getdate(posting_date) if self.status == "Cancelled" else None
 		elif self.current_invoice_is_past_due() and not self.is_past_grace_period():
 			self.status = "Past Due Date"
 		elif not self.has_outstanding_invoice() or self.is_new_subscription():
 			self.status = "Active"
 
-		self.save()
-
 	def is_trialling(self) -> bool:
 		"""
 		Returns `True` if the `Subscription` is in trial period.
@@ -210,7 +207,9 @@ class Subscription(Document):
 		return not self.period_has_passed(self.trial_period_end) and self.is_new_subscription()
 
 	@staticmethod
-	def period_has_passed(end_date: Union[str, datetime.date]) -> bool:
+	def period_has_passed(
+		end_date: Union[str, datetime.date], posting_date: Optional["DateTimeLikeObject"] = None
+	) -> bool:
 		"""
 		Returns true if the given `end_date` has passed
 		"""
@@ -218,7 +217,7 @@ class Subscription(Document):
 		if not end_date:
 			return True
 
-		return getdate(frappe.flags.current_date) > getdate(end_date)
+		return getdate(posting_date) > getdate(end_date)
 
 	def get_status_for_past_grace_period(self) -> str:
 		cancel_after_grace = cint(frappe.get_value("Subscription Settings", None, "cancel_after_grace"))
@@ -229,7 +228,7 @@ class Subscription(Document):
 
 		return status
 
-	def is_past_grace_period(self) -> bool:
+	def is_past_grace_period(self, posting_date: Optional["DateTimeLikeObject"] = None) -> bool:
 		"""
 		Returns `True` if the grace period for the `Subscription` has passed
 		"""
@@ -237,18 +236,18 @@ class Subscription(Document):
 			return
 
 		grace_period = cint(frappe.get_value("Subscription Settings", None, "grace_period"))
-		return getdate(frappe.flags.current_date) >= getdate(
-			add_days(self.current_invoice.due_date, grace_period)
-		)
+		return getdate(posting_date) >= getdate(add_days(self.current_invoice.due_date, grace_period))
 
-	def current_invoice_is_past_due(self) -> bool:
+	def current_invoice_is_past_due(
+		self, posting_date: Optional["DateTimeLikeObject"] = None
+	) -> bool:
 		"""
 		Returns `True` if the current generated invoice is overdue
 		"""
 		if not self.current_invoice or self.is_paid(self.current_invoice):
 			return False
 
-		return getdate(frappe.flags.current_date) >= getdate(self.current_invoice.due_date)
+		return getdate(posting_date) >= getdate(self.current_invoice.due_date)
 
 	@property
 	def invoice_document_type(self) -> str:
@@ -270,6 +269,9 @@ class Subscription(Document):
 		if not self.cost_center:
 			self.cost_center = get_default_cost_center(self.get("company"))
 
+		if self.is_new():
+			self.set_subscription_status()
+
 	def validate_trial_period(self) -> None:
 		"""
 		Runs sanity checks on trial period dates for the `Subscription`
@@ -305,10 +307,6 @@ class Subscription(Document):
 		if billing_info[0]["billing_interval"] != "Month":
 			frappe.throw(_("Billing Interval in Subscription Plan must be Month to follow calendar months"))
 
-	def after_insert(self) -> None:
-		# todo: deal with users who collect prepayments. Maybe a new Subscription Invoice doctype?
-		self.set_subscription_status()
-
 	def generate_invoice(
 		self,
 		from_date: Optional[Union[str, datetime.date]] = None,
@@ -344,7 +342,7 @@ class Subscription(Document):
 		invoice.set_posting_time = 1
 		invoice.posting_date = (
 			self.current_invoice_start
-			if self.generate_invoice_at_period_start
+			if self.generate_invoice_at == "Beginning of the current subscription period"
 			else self.current_invoice_end
 		)
 
@@ -438,7 +436,7 @@ class Subscription(Document):
 			prorate_factor = get_prorata_factor(
 				self.current_invoice_end,
 				self.current_invoice_start,
-				cint(self.generate_invoice_at_period_start),
+				cint(self.generate_invoice_at == "Beginning of the current subscription period"),
 			)
 
 		items = []
@@ -503,42 +501,45 @@ class Subscription(Document):
 		return items
 
 	@frappe.whitelist()
-	def process(self) -> bool:
+	def process(self, posting_date: Optional["DateTimeLikeObject"] = None) -> bool:
 		"""
 		To be called by task periodically. It checks the subscription and takes appropriate action
 		as need be. It calls either of these methods depending the `Subscription` status:
 		1. `process_for_active`
 		2. `process_for_past_due`
 		"""
-		if (
-			not self.is_current_invoice_generated(self.current_invoice_start, self.current_invoice_end)
-			and self.can_generate_new_invoice()
-		):
+		if not self.is_current_invoice_generated(
+			self.current_invoice_start, self.current_invoice_end
+		) and self.can_generate_new_invoice(posting_date):
 			self.generate_invoice()
 			self.update_subscription_period(add_days(self.current_invoice_end, 1))
 
 		if self.cancel_at_period_end and (
-			getdate(frappe.flags.current_date) >= getdate(self.current_invoice_end)
-			or getdate(frappe.flags.current_date) >= getdate(self.end_date)
+			getdate(posting_date) >= getdate(self.current_invoice_end)
+			or getdate(posting_date) >= getdate(self.end_date)
 		):
 			self.cancel_subscription()
 
-		self.set_subscription_status()
+		self.set_subscription_status(posting_date=posting_date)
 
 		self.save()
 
-	def can_generate_new_invoice(self) -> bool:
+	def can_generate_new_invoice(self, posting_date: Optional["DateTimeLikeObject"] = None) -> bool:
 		if self.cancelation_date:
 			return False
-		elif self.generate_invoice_at_period_start and (
-			getdate(frappe.flags.current_date) == getdate(self.current_invoice_start)
-			or self.is_new_subscription()
+
+		if self.has_outstanding_invoice() and not self.generate_new_invoices_past_due_date:
+			return False
+
+		if self.generate_invoice_at == "Beginning of the current subscription period" and (
+			getdate(posting_date) == getdate(self.current_invoice_start) or self.is_new_subscription()
 		):
 			return True
-		elif getdate(frappe.flags.current_date) == getdate(self.current_invoice_end):
-			if self.has_outstanding_invoice() and not self.generate_new_invoices_past_due_date:
-				return False
-
+		elif self.generate_invoice_at == "Days before the current subscription period" and (
+			getdate(posting_date) == getdate(add_days(self.current_invoice_start, -1 * self.number_of_days))
+		):
+			return True
+		elif getdate(posting_date) == getdate(self.current_invoice_end):
 			return True
 		else:
 			return False
@@ -628,7 +629,10 @@ class Subscription(Document):
 			frappe.throw(_("subscription is already cancelled."), InvoiceCancelled)
 
 		to_generate_invoice = (
-			True if self.status == "Active" and not self.generate_invoice_at_period_start else False
+			True
+			if self.status == "Active"
+			and not self.generate_invoice_at == "Beginning of the current subscription period"
+			else False
 		)
 		self.status = "Cancelled"
 		self.cancelation_date = nowdate()
@@ -639,7 +643,7 @@ class Subscription(Document):
 		self.save()
 
 	@frappe.whitelist()
-	def restart_subscription(self) -> None:
+	def restart_subscription(self, posting_date: Optional["DateTimeLikeObject"] = None) -> None:
 		"""
 		This sets the subscription as active. The subscription will be made to be like a new
 		subscription and the `Subscription` will lose all the history of generated invoices
@@ -650,7 +654,7 @@ class Subscription(Document):
 
 		self.status = "Active"
 		self.cancelation_date = None
-		self.update_subscription_period(frappe.flags.current_date or nowdate())
+		self.update_subscription_period(posting_date or nowdate())
 		self.save()
 
 
@@ -671,14 +675,21 @@ def get_prorata_factor(
 	return diff / plan_days
 
 
-def process_all() -> None:
+def process_all(
+	subscription: str | None, posting_date: Optional["DateTimeLikeObject"] = None
+) -> None:
 	"""
 	Task to updates the status of all `Subscription` apart from those that are cancelled
 	"""
-	for subscription in frappe.get_all("Subscription", {"status": ("!=", "Cancelled")}, pluck="name"):
+	filters = {"status": ("!=", "Cancelled")}
+
+	if subscription:
+		filters["name"] = subscription
+
+	for subscription in frappe.get_all("Subscription", filters, pluck="name"):
 		try:
 			subscription = frappe.get_doc("Subscription", subscription)
-			subscription.process()
+			subscription.process(posting_date)
 			frappe.db.commit()
 		except frappe.ValidationError:
 			frappe.db.rollback()

erpnext/accounts/doctype/subscription/test_subscription.py

@@ -8,6 +8,7 @@ from frappe.utils.data import (
 	add_days,
 	add_months,
 	add_to_date,
+	cint,
 	date_diff,
 	flt,
 	get_date_str,
@@ -20,99 +21,16 @@ from erpnext.accounts.doctype.subscription.subscription import get_prorata_facto
 test_dependencies = ("UOM", "Item Group", "Item")
 
 
-def create_plan():
-	if not frappe.db.exists("Subscription Plan", "_Test Plan Name"):
-		plan = frappe.new_doc("Subscription Plan")
-		plan.plan_name = "_Test Plan Name"
-		plan.item = "_Test Non Stock Item"
-		plan.price_determination = "Fixed Rate"
-		plan.cost = 900
-		plan.billing_interval = "Month"
-		plan.billing_interval_count = 1
-		plan.insert()
-
-	if not frappe.db.exists("Subscription Plan", "_Test Plan Name 2"):
-		plan = frappe.new_doc("Subscription Plan")
-		plan.plan_name = "_Test Plan Name 2"
-		plan.item = "_Test Non Stock Item"
-		plan.price_determination = "Fixed Rate"
-		plan.cost = 1999
-		plan.billing_interval = "Month"
-		plan.billing_interval_count = 1
-		plan.insert()
-
-	if not frappe.db.exists("Subscription Plan", "_Test Plan Name 3"):
-		plan = frappe.new_doc("Subscription Plan")
-		plan.plan_name = "_Test Plan Name 3"
-		plan.item = "_Test Non Stock Item"
-		plan.price_determination = "Fixed Rate"
-		plan.cost = 1999
-		plan.billing_interval = "Day"
-		plan.billing_interval_count = 14
-		plan.insert()
-
-	# Defined a quarterly Subscription Plan
-	if not frappe.db.exists("Subscription Plan", "_Test Plan Name 4"):
-		plan = frappe.new_doc("Subscription Plan")
-		plan.plan_name = "_Test Plan Name 4"
-		plan.item = "_Test Non Stock Item"
-		plan.price_determination = "Monthly Rate"
-		plan.cost = 20000
-		plan.billing_interval = "Month"
-		plan.billing_interval_count = 3
-		plan.insert()
-
-	if not frappe.db.exists("Subscription Plan", "_Test Plan Multicurrency"):
-		plan = frappe.new_doc("Subscription Plan")
-		plan.plan_name = "_Test Plan Multicurrency"
-		plan.item = "_Test Non Stock Item"
-		plan.price_determination = "Fixed Rate"
-		plan.cost = 50
-		plan.currency = "USD"
-		plan.billing_interval = "Month"
-		plan.billing_interval_count = 1
-		plan.insert()
-
-
-def create_parties():
-	if not frappe.db.exists("Supplier", "_Test Supplier"):
-		supplier = frappe.new_doc("Supplier")
-		supplier.supplier_name = "_Test Supplier"
-		supplier.supplier_group = "All Supplier Groups"
-		supplier.insert()
-
-	if not frappe.db.exists("Customer", "_Test Subscription Customer"):
-		customer = frappe.new_doc("Customer")
-		customer.customer_name = "_Test Subscription Customer"
-		customer.billing_currency = "USD"
-		customer.append(
-			"accounts", {"company": "_Test Company", "account": "_Test Receivable USD - _TC"}
-		)
-		customer.insert()
-
-
-def reset_settings():
-	settings = frappe.get_single("Subscription Settings")
-	settings.grace_period = 0
-	settings.cancel_after_grace = 0
-	settings.save()
-
-
 class TestSubscription(unittest.TestCase):
 	def setUp(self):
-		create_plan()
+		make_plans()
 		create_parties()
 		reset_settings()
 
 	def test_create_subscription_with_trial_with_correct_period(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.trial_period_start = nowdate()
-		subscription.trial_period_end = add_months(nowdate(), 1)
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
-
+		subscription = create_subscription(
+			trial_period_start=nowdate(), trial_period_end=add_months(nowdate(), 1)
+		)
 		self.assertEqual(subscription.trial_period_start, nowdate())
 		self.assertEqual(subscription.trial_period_end, add_months(nowdate(), 1))
 		self.assertEqual(
@@ -126,12 +44,7 @@ class TestSubscription(unittest.TestCase):
 		self.assertEqual(subscription.status, "Trialling")
 
 	def test_create_subscription_without_trial_with_correct_period(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
-
+		subscription = create_subscription()
 		self.assertEqual(subscription.trial_period_start, None)
 		self.assertEqual(subscription.trial_period_end, None)
 		self.assertEqual(subscription.current_invoice_start, nowdate())
@@ -141,55 +54,28 @@ class TestSubscription(unittest.TestCase):
 		self.assertEqual(subscription.status, "Active")
 
 	def test_create_subscription_trial_with_wrong_dates(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.trial_period_end = nowdate()
-		subscription.trial_period_start = add_days(nowdate(), 30)
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-
-		self.assertRaises(frappe.ValidationError, subscription.save)
-
-	def test_create_subscription_multi_with_different_billing_fails(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.trial_period_end = nowdate()
-		subscription.trial_period_start = add_days(nowdate(), 30)
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.append("plans", {"plan": "_Test Plan Name 3", "qty": 1})
-
+		subscription = create_subscription(
+			trial_period_start=add_days(nowdate(), 30), trial_period_end=nowdate(), do_not_save=True
+		)
 		self.assertRaises(frappe.ValidationError, subscription.save)
 
 	def test_invoice_is_generated_at_end_of_billing_period(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.start_date = "2018-01-01"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.insert()
-
+		subscription = create_subscription(start_date="2018-01-01")
 		self.assertEqual(subscription.status, "Active")
 		self.assertEqual(subscription.current_invoice_start, "2018-01-01")
 		self.assertEqual(subscription.current_invoice_end, "2018-01-31")
-		frappe.flags.current_date = "2018-01-31"
-		subscription.process()
 
+		subscription.process(posting_date="2018-01-31")
 		self.assertEqual(len(subscription.invoices), 1)
 		self.assertEqual(subscription.current_invoice_start, "2018-02-01")
 		self.assertEqual(subscription.current_invoice_end, "2018-02-28")
 		self.assertEqual(subscription.status, "Unpaid")
 
 	def test_status_goes_back_to_active_after_invoice_is_paid(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.start_date = "2018-01-01"
-		subscription.generate_invoice_at_period_start = True
-		subscription.insert()
-		frappe.flags.current_date = "2018-01-01"
-		subscription.process()  # generate first invoice
+		subscription = create_subscription(
+			start_date="2018-01-01", generate_invoice_at="Beginning of the current subscription period"
+		)
+		subscription.process(posting_date="2018-01-01")  # generate first invoice
 		self.assertEqual(len(subscription.invoices), 1)
 
 		# Status is unpaid as Days until Due is zero and grace period is Zero
@@ -213,18 +99,10 @@ class TestSubscription(unittest.TestCase):
 		settings.cancel_after_grace = 1
 		settings.save()
 
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		# subscription.generate_invoice_at_period_start = True
-		subscription.start_date = "2018-01-01"
-		subscription.insert()
-
+		subscription = create_subscription(start_date="2018-01-01")
 		self.assertEqual(subscription.status, "Active")
 
-		frappe.flags.current_date = "2018-01-31"
-		subscription.process()  # generate first invoice
+		subscription.process(posting_date="2018-01-31")  # generate first invoice
 		# This should change status to Cancelled since grace period is 0
 		# And is backdated subscription so subscription will be cancelled after processing
 		self.assertEqual(subscription.status, "Cancelled")
@@ -235,13 +113,8 @@ class TestSubscription(unittest.TestCase):
 		settings.cancel_after_grace = 0
 		settings.save()
 
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.start_date = "2018-01-01"
-		subscription.insert()
-		subscription.process()  # generate first invoice
+		subscription = create_subscription(start_date="2018-01-01")
+		subscription.process(posting_date="2018-01-31")  # generate first invoice
 
 		# Status is unpaid as Days until Due is zero and grace period is Zero
 		self.assertEqual(subscription.status, "Unpaid")
@@ -251,21 +124,9 @@ class TestSubscription(unittest.TestCase):
 
 	def test_subscription_invoice_days_until_due(self):
 		_date = add_months(nowdate(), -1)
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.days_until_due = 10
-		subscription.start_date = _date
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.insert()
+		subscription = create_subscription(start_date=_date, days_until_due=10)
 
-		frappe.flags.current_date = subscription.current_invoice_end
-
-		subscription.process()  # generate first invoice
-		self.assertEqual(len(subscription.invoices), 1)
-		self.assertEqual(subscription.status, "Active")
-
-		frappe.flags.current_date = add_days(subscription.current_invoice_end, 3)
+		subscription.process(posting_date=subscription.current_invoice_end)  # generate first invoice
 		self.assertEqual(len(subscription.invoices), 1)
 		self.assertEqual(subscription.status, "Active")
 
@@ -275,16 +136,9 @@ class TestSubscription(unittest.TestCase):
 		settings.grace_period = 1000
 		settings.save()
 
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.start_date = add_days(nowdate(), -1000)
-		subscription.insert()
-
-		frappe.flags.current_date = subscription.current_invoice_end
-		subscription.process()  # generate first invoice
+		subscription = create_subscription(start_date=add_days(nowdate(), -1000))
 
+		subscription.process(posting_date=subscription.current_invoice_end)  # generate first invoice
 		self.assertEqual(subscription.status, "Past Due Date")
 
 		subscription.process()
@@ -301,12 +155,7 @@ class TestSubscription(unittest.TestCase):
 		settings.save()
 
 	def test_subscription_remains_active_during_invoice_period(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
-		subscription.process()  # no changes expected
+		subscription = create_subscription()  # no changes expected
 
 		self.assertEqual(subscription.status, "Active")
 		self.assertEqual(subscription.current_invoice_start, nowdate())
@@ -325,12 +174,8 @@ class TestSubscription(unittest.TestCase):
 		self.assertEqual(subscription.current_invoice_end, add_to_date(nowdate(), months=1, days=-1))
 		self.assertEqual(len(subscription.invoices), 0)
 
-	def test_subscription_cancelation(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
+	def test_subscription_cancellation(self):
+		subscription = create_subscription()
 		subscription.cancel_subscription()
 
 		self.assertEqual(subscription.status, "Cancelled")
@@ -341,11 +186,7 @@ class TestSubscription(unittest.TestCase):
 		settings.prorate = 1
 		settings.save()
 
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
+		subscription = create_subscription()
 
 		self.assertEqual(subscription.status, "Active")
 
@@ -365,7 +206,7 @@ class TestSubscription(unittest.TestCase):
 				get_prorata_factor(
 					subscription.current_invoice_end,
 					subscription.current_invoice_start,
-					subscription.generate_invoice_at_period_start,
+					cint(subscription.generate_invoice_at == "Beginning of the current subscription period"),
 				),
 				2,
 			),
@@ -383,11 +224,7 @@ class TestSubscription(unittest.TestCase):
 		settings.prorate = 0
 		settings.save()
 
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
+		subscription = create_subscription()
 		subscription.cancel_subscription()
 		invoice = subscription.get_current_invoice()
 
@@ -402,11 +239,7 @@ class TestSubscription(unittest.TestCase):
 		settings.prorate = 1
 		settings.save()
 
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
+		subscription = create_subscription()
 		subscription.cancel_subscription()
 
 		invoice = subscription.get_current_invoice()
@@ -421,18 +254,13 @@ class TestSubscription(unittest.TestCase):
 		settings.prorate = to_prorate
 		settings.save()
 
-	def test_subcription_cancellation_and_process(self):
+	def test_subscription_cancellation_and_process(self):
 		settings = frappe.get_single("Subscription Settings")
 		default_grace_period_action = settings.cancel_after_grace
 		settings.cancel_after_grace = 1
 		settings.save()
 
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.start_date = "2018-01-01"
-		subscription.insert()
+		subscription = create_subscription(start_date="2018-01-01")
 		subscription.process()  # generate first invoice
 
 		# Generate an invoice for the cancelled period
@@ -458,14 +286,8 @@ class TestSubscription(unittest.TestCase):
 		settings.cancel_after_grace = 0
 		settings.save()
 
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.start_date = "2018-01-01"
-		subscription.insert()
-		frappe.flags.current_date = "2018-01-31"
-		subscription.process()  # generate first invoice
+		subscription = create_subscription(start_date="2018-01-01")
+		subscription.process(posting_date="2018-01-31")  # generate first invoice
 
 		# Status is unpaid as Days until Due is zero and grace period is Zero
 		self.assertEqual(subscription.status, "Unpaid")
@@ -494,17 +316,10 @@ class TestSubscription(unittest.TestCase):
 		settings.cancel_after_grace = 0
 		settings.save()
 
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.start_date = "2018-01-01"
-		subscription.generate_invoice_at_period_start = True
-		subscription.insert()
-
-		frappe.flags.current_date = subscription.current_invoice_start
-
-		subscription.process()  # generate first invoice
+		subscription = create_subscription(
+			start_date="2018-01-01", generate_invoice_at="Beginning of the current subscription period"
+		)
+		subscription.process(subscription.current_invoice_start)  # generate first invoice
 		# This should change status to Unpaid since grace period is 0
 		self.assertEqual(subscription.status, "Unpaid")
 
@@ -516,29 +331,18 @@ class TestSubscription(unittest.TestCase):
 		self.assertEqual(subscription.status, "Active")
 
 		# A new invoice is generated
-		frappe.flags.current_date = subscription.current_invoice_start
-		subscription.process()
+		subscription.process(posting_date=subscription.current_invoice_start)
 		self.assertEqual(subscription.status, "Unpaid")
 
 		settings.cancel_after_grace = default_grace_period_action
 		settings.save()
 
 	def test_restart_active_subscription(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
-
+		subscription = create_subscription()
 		self.assertRaises(frappe.ValidationError, subscription.restart_subscription)
 
 	def test_subscription_invoice_discount_percentage(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.additional_discount_percentage = 10
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
+		subscription = create_subscription(additional_discount_percentage=10)
 		subscription.cancel_subscription()
 
 		invoice = subscription.get_current_invoice()
@@ -547,12 +351,7 @@ class TestSubscription(unittest.TestCase):
 		self.assertEqual(invoice.apply_discount_on, "Grand Total")
 
 	def test_subscription_invoice_discount_amount(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.additional_discount_amount = 11
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
+		subscription = create_subscription(additional_discount_amount=11)
 		subscription.cancel_subscription()
 
 		invoice = subscription.get_current_invoice()
@@ -563,18 +362,13 @@ class TestSubscription(unittest.TestCase):
 	def test_prepaid_subscriptions(self):
 		# Create a non pre-billed subscription, processing should not create
 		# invoices.
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
+		subscription = create_subscription()
 		subscription.process()
-
 		self.assertEqual(len(subscription.invoices), 0)
 
 		# Change the subscription type to prebilled and process it.
 		# Prepaid invoice should be generated
-		subscription.generate_invoice_at_period_start = True
+		subscription.generate_invoice_at = "Beginning of the current subscription period"
 		subscription.save()
 		subscription.process()
 
@@ -586,12 +380,9 @@ class TestSubscription(unittest.TestCase):
 		settings.prorate = 1
 		settings.save()
 
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.generate_invoice_at_period_start = True
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
+		subscription = create_subscription(
+			generate_invoice_at="Beginning of the current subscription period"
+		)
 		subscription.process()
 		subscription.cancel_subscription()
 
@@ -609,9 +400,10 @@ class TestSubscription(unittest.TestCase):
 
 	def test_subscription_with_follow_calendar_months(self):
 		subscription = frappe.new_doc("Subscription")
+		subscription.company = "_Test Company"
 		subscription.party_type = "Supplier"
 		subscription.party = "_Test Supplier"
-		subscription.generate_invoice_at_period_start = 1
+		subscription.generate_invoice_at = "Beginning of the current subscription period"
 		subscription.follow_calendar_months = 1
 
 		# select subscription start date as "2018-01-15"
@@ -625,39 +417,33 @@ class TestSubscription(unittest.TestCase):
 		self.assertEqual(get_date_str(subscription.current_invoice_end), "2018-03-31")
 
 	def test_subscription_generate_invoice_past_due(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Supplier"
-		subscription.party = "_Test Supplier"
-		subscription.generate_invoice_at_period_start = 1
-		subscription.generate_new_invoices_past_due_date = 1
-		# select subscription start date as "2018-01-15"
-		subscription.start_date = "2018-01-01"
-		subscription.append("plans", {"plan": "_Test Plan Name 4", "qty": 1})
-		subscription.save()
+		subscription = create_subscription(
+			start_date="2018-01-01",
+			party_type="Supplier",
+			party="_Test Supplier",
+			generate_invoice_at="Beginning of the current subscription period",
+			generate_new_invoices_past_due_date=1,
+			plans=[{"plan": "_Test Plan Name 4", "qty": 1}],
+		)
 
-		frappe.flags.current_date = "2018-01-01"
 		# Process subscription and create first invoice
 		# Subscription status will be unpaid since due date has already passed
-		subscription.process()
+		subscription.process(posting_date="2018-01-01")
 		self.assertEqual(len(subscription.invoices), 1)
 		self.assertEqual(subscription.status, "Unpaid")
 
 		# Now the Subscription is unpaid
 		# Even then new invoice should be created as we have enabled `generate_new_invoices_past_due_date` in
 		# subscription and the interval between the subscriptions is 3 months
-		frappe.flags.current_date = "2018-04-01"
-		subscription.process()
+		subscription.process(posting_date="2018-04-01")
 		self.assertEqual(len(subscription.invoices), 2)
 
 	def test_subscription_without_generate_invoice_past_due(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Supplier"
-		subscription.party = "_Test Supplier"
-		subscription.generate_invoice_at_period_start = 1
-		# select subscription start date as "2018-01-15"
-		subscription.start_date = "2018-01-01"
-		subscription.append("plans", {"plan": "_Test Plan Name 4", "qty": 1})
-		subscription.save()
+		subscription = create_subscription(
+			start_date="2018-01-01",
+			generate_invoice_at="Beginning of the current subscription period",
+			plans=[{"plan": "_Test Plan Name 4", "qty": 1}],
+		)
 
 		# Process subscription and create first invoice
 		# Subscription status will be unpaid since due date has already passed
@@ -668,16 +454,13 @@ class TestSubscription(unittest.TestCase):
 		subscription.process()
 		self.assertEqual(len(subscription.invoices), 1)
 
-	def test_multicurrency_subscription(self):
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Subscription Customer"
-		subscription.generate_invoice_at_period_start = 1
-		subscription.company = "_Test Company"
-		# select subscription start date as "2018-01-15"
-		subscription.start_date = "2018-01-01"
-		subscription.append("plans", {"plan": "_Test Plan Multicurrency", "qty": 1})
-		subscription.save()
+	def test_multi_currency_subscription(self):
+		subscription = create_subscription(
+			start_date="2018-01-01",
+			generate_invoice_at="Beginning of the current subscription period",
+			plans=[{"plan": "_Test Plan Multicurrency", "qty": 1}],
+			party="_Test Subscription Customer",
+		)
 
 		subscription.process()
 		self.assertEqual(len(subscription.invoices), 1)
@@ -689,42 +472,135 @@ class TestSubscription(unittest.TestCase):
 
 	def test_subscription_recovery(self):
 		"""Test if Subscription recovers when start/end date run out of sync with created invoices."""
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Subscription Customer"
-		subscription.company = "_Test Company"
-		subscription.start_date = "2021-12-01"
-		subscription.generate_new_invoices_past_due_date = 1
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.submit_invoice = 0
-		subscription.save()
+		subscription = create_subscription(
+			start_date="2021-01-01",
+			submit_invoice=0,
+			generate_new_invoices_past_due_date=1,
+			party="_Test Subscription Customer",
+		)
 
 		# create invoices for the first two moths
-		frappe.flags.current_date = "2021-12-31"
-		subscription.process()
+		subscription.process(posting_date="2021-01-31")
 
-		frappe.flags.current_date = "2022-01-31"
-		subscription.process()
+		subscription.process(posting_date="2021-02-28")
 
 		self.assertEqual(len(subscription.invoices), 2)
 		self.assertEqual(
 			getdate(frappe.db.get_value("Sales Invoice", subscription.invoices[0].name, "from_date")),
-			getdate("2021-12-01"),
+			getdate("2021-01-01"),
 		)
 		self.assertEqual(
 			getdate(frappe.db.get_value("Sales Invoice", subscription.invoices[1].name, "from_date")),
-			getdate("2022-01-01"),
+			getdate("2021-02-01"),
 		)
 
 		# recreate most recent invoice
-		subscription.process()
+		subscription.process(posting_date="2022-01-31")
 
 		self.assertEqual(len(subscription.invoices), 2)
 		self.assertEqual(
 			getdate(frappe.db.get_value("Sales Invoice", subscription.invoices[0].name, "from_date")),
-			getdate("2021-12-01"),
+			getdate("2021-01-01"),
 		)
 		self.assertEqual(
 			getdate(frappe.db.get_value("Sales Invoice", subscription.invoices[1].name, "from_date")),
-			getdate("2022-01-01"),
+			getdate("2021-02-01"),
 		)
+
+	def test_subscription_invoice_generation_before_days(self):
+		subscription = create_subscription(
+			start_date="2023-01-01",
+			generate_invoice_at="Days before the current subscription period",
+			number_of_days=10,
+			generate_new_invoices_past_due_date=1,
+		)
+
+		subscription.process(posting_date="2022-12-22")
+		self.assertEqual(len(subscription.invoices), 1)
+
+		subscription.process(posting_date="2023-01-22")
+		self.assertEqual(len(subscription.invoices), 2)
+
+
+def make_plans():
+	create_plan(plan_name="_Test Plan Name", cost=900)
+	create_plan(plan_name="_Test Plan Name 2", cost=1999)
+	create_plan(
+		plan_name="_Test Plan Name 3", cost=1999, billing_interval="Day", billing_interval_count=14
+	)
+	create_plan(
+		plan_name="_Test Plan Name 4", cost=20000, billing_interval="Month", billing_interval_count=3
+	)
+	create_plan(
+		plan_name="_Test Plan Multicurrency", cost=50, billing_interval="Month", currency="USD"
+	)
+
+
+def create_plan(**kwargs):
+	if not frappe.db.exists("Subscription Plan", kwargs.get("plan_name")):
+		plan = frappe.new_doc("Subscription Plan")
+		plan.plan_name = kwargs.get("plan_name") or "_Test Plan Name"
+		plan.item = kwargs.get("item") or "_Test Non Stock Item"
+		plan.price_determination = kwargs.get("price_determination") or "Fixed Rate"
+		plan.cost = kwargs.get("cost") or 1000
+		plan.billing_interval = kwargs.get("billing_interval") or "Month"
+		plan.billing_interval_count = kwargs.get("billing_interval_count") or 1
+		plan.currency = kwargs.get("currency")
+		plan.insert()
+
+
+def create_parties():
+	if not frappe.db.exists("Supplier", "_Test Supplier"):
+		supplier = frappe.new_doc("Supplier")
+		supplier.supplier_name = "_Test Supplier"
+		supplier.supplier_group = "All Supplier Groups"
+		supplier.insert()
+
+	if not frappe.db.exists("Customer", "_Test Subscription Customer"):
+		customer = frappe.new_doc("Customer")
+		customer.customer_name = "_Test Subscription Customer"
+		customer.billing_currency = "USD"
+		customer.append(
+			"accounts", {"company": "_Test Company", "account": "_Test Receivable USD - _TC"}
+		)
+		customer.insert()
+
+
+def reset_settings():
+	settings = frappe.get_single("Subscription Settings")
+	settings.grace_period = 0
+	settings.cancel_after_grace = 0
+	settings.save()
+
+
+def create_subscription(**kwargs):
+	subscription = frappe.new_doc("Subscription")
+	subscription.party_type = (kwargs.get("party_type") or "Customer",)
+	subscription.company = kwargs.get("company") or "_Test Company"
+	subscription.party = kwargs.get("party") or "_Test Customer"
+	subscription.trial_period_start = kwargs.get("trial_period_start")
+	subscription.trial_period_end = kwargs.get("trial_period_end")
+	subscription.start_date = kwargs.get("start_date")
+	subscription.generate_invoice_at = kwargs.get("generate_invoice_at")
+	subscription.additional_discount_percentage = kwargs.get("additional_discount_percentage")
+	subscription.additional_discount_amount = kwargs.get("additional_discount_amount")
+	subscription.follow_calendar_months = kwargs.get("follow_calendar_months")
+	subscription.generate_new_invoices_past_due_date = kwargs.get(
+		"generate_new_invoices_past_due_date"
+	)
+	subscription.submit_invoice = kwargs.get("submit_invoice")
+	subscription.days_until_due = kwargs.get("days_until_due")
+	subscription.number_of_days = kwargs.get("number_of_days")
+
+	if not kwargs.get("plans"):
+		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
+	else:
+		for plan in kwargs.get("plans"):
+			subscription.append("plans", plan)
+
+	if kwargs.get("do_not_save"):
+		return subscription
+
+	subscription.save()
+
+	return subscription

erpnext/accounts/doctype/subscription_plan/subscription_plan.py

@@ -57,18 +57,17 @@ def get_plan_rate(
 		prorate = frappe.db.get_single_value("Subscription Settings", "prorate")
 
 		if prorate:
-			prorate_factor = flt(
-				date_diff(start_date, get_first_day(start_date))
-				/ date_diff(get_last_day(start_date), get_first_day(start_date)),
-				1,
-			)
-
-			prorate_factor += flt(
-				date_diff(get_last_day(end_date), end_date)
-				/ date_diff(get_last_day(end_date), get_first_day(end_date)),
-				1,
-			)
-
-			cost -= plan.cost * prorate_factor
-
+			cost -= plan.cost * get_prorate_factor(start_date, end_date)
 		return cost
+
+
+def get_prorate_factor(start_date, end_date):
+	total_days_to_skip = date_diff(start_date, get_first_day(start_date))
+	total_days_in_month = int(get_last_day(start_date).strftime("%d"))
+	prorate_factor = flt(total_days_to_skip / total_days_in_month)
+
+	total_days_to_skip = date_diff(get_last_day(end_date), end_date)
+	total_days_in_month = int(get_last_day(end_date).strftime("%d"))
+	prorate_factor += flt(total_days_to_skip / total_days_in_month)
+
+	return prorate_factor

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py

@@ -271,9 +271,9 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 						net_total, limit_consumed, ldc.certificate_limit, ldc.rate, tax_details
 					)
 				else:
-					tax_amount = net_total * tax_details.rate / 100 if net_total > 0 else 0
+					tax_amount = net_total * tax_details.rate / 100
 			else:
-				tax_amount = net_total * tax_details.rate / 100 if net_total > 0 else 0
+				tax_amount = net_total * tax_details.rate / 100
 
 			# once tds is deducted, not need to add vouchers in the invoice
 			voucher_wise_amount = {}

erpnext/accounts/doctype/unreconcile_payment_entries/unreconcile_payment_entries.json

@@ -0,0 +1,83 @@
+{
+ "actions": [],
+ "allow_rename": 1,
+ "creation": "2023-08-22 10:28:10.196712",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "account",
+  "party_type",
+  "party",
+  "reference_doctype",
+  "reference_name",
+  "allocated_amount",
+  "account_currency",
+  "unlinked"
+ ],
+ "fields": [
+  {
+   "fieldname": "reference_name",
+   "fieldtype": "Dynamic Link",
+   "in_list_view": 1,
+   "label": "Reference Name",
+   "options": "reference_doctype"
+  },
+  {
+   "fieldname": "allocated_amount",
+   "fieldtype": "Currency",
+   "in_list_view": 1,
+   "label": "Allocated Amount",
+   "options": "account_currency"
+  },
+  {
+   "default": "0",
+   "fieldname": "unlinked",
+   "fieldtype": "Check",
+   "in_list_view": 1,
+   "label": "Unlinked",
+   "read_only": 1
+  },
+  {
+   "fieldname": "reference_doctype",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "Reference Type",
+   "options": "DocType"
+  },
+  {
+   "fieldname": "account",
+   "fieldtype": "Data",
+   "label": "Account"
+  },
+  {
+   "fieldname": "party_type",
+   "fieldtype": "Data",
+   "label": "Party Type"
+  },
+  {
+   "fieldname": "party",
+   "fieldtype": "Data",
+   "label": "Party"
+  },
+  {
+   "fieldname": "account_currency",
+   "fieldtype": "Link",
+   "label": "Account Currency",
+   "options": "Currency",
+   "read_only": 1
+  }
+ ],
+ "index_web_pages_for_search": 1,
+ "istable": 1,
+ "links": [],
+ "modified": "2023-09-05 09:33:28.620149",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Unreconcile Payment Entries",
+ "owner": "Administrator",
+ "permissions": [],
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "states": []
+}

erpnext/accounts/doctype/unreconcile_payment_entries/unreconcile_payment_entries.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+# import frappe
+from frappe.model.document import Document
+
+
+class UnreconcilePaymentEntries(Document):
+	pass

erpnext/accounts/doctype/unreconcile_payments/test_unreconcile_payments.py

@@ -0,0 +1,316 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import today
+
+from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+
+
+class TestUnreconcilePayments(AccountsTestMixin, FrappeTestCase):
+	def setUp(self):
+		self.create_company()
+		self.create_customer()
+		self.create_usd_receivable_account()
+		self.create_item()
+		self.clear_old_entries()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def create_sales_invoice(self, do_not_submit=False):
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debit_to,
+			posting_date=today(),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=100,
+			price_list_rate=100,
+			do_not_submit=do_not_submit,
+		)
+		return si
+
+	def create_payment_entry(self):
+		pe = create_payment_entry(
+			company=self.company,
+			payment_type="Receive",
+			party_type="Customer",
+			party=self.customer,
+			paid_from=self.debit_to,
+			paid_to=self.cash,
+			paid_amount=200,
+			save=True,
+		)
+		return pe
+
+	def test_01_unreconcile_invoice(self):
+		si1 = self.create_sales_invoice()
+		si2 = self.create_sales_invoice()
+
+		pe = self.create_payment_entry()
+		pe.append(
+			"references",
+			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 100},
+		)
+		pe.append(
+			"references",
+			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 100},
+		)
+		# Allocation payment against both invoices
+		pe.save().submit()
+
+		# Assert outstanding
+		[doc.reload() for doc in [si1, si2, pe]]
+		self.assertEqual(si1.outstanding_amount, 0)
+		self.assertEqual(si2.outstanding_amount, 0)
+		self.assertEqual(pe.unallocated_amount, 0)
+
+		unreconcile = frappe.get_doc(
+			{
+				"doctype": "Unreconcile Payments",
+				"company": self.company,
+				"voucher_type": pe.doctype,
+				"voucher_no": pe.name,
+			}
+		)
+		unreconcile.add_references()
+		self.assertEqual(len(unreconcile.allocations), 2)
+		allocations = [x.reference_name for x in unreconcile.allocations]
+		self.assertEquals([si1.name, si2.name], allocations)
+		# unreconcile si1
+		for x in unreconcile.allocations:
+			if x.reference_name != si1.name:
+				unreconcile.remove(x)
+		unreconcile.save().submit()
+
+		# Assert outstanding
+		[doc.reload() for doc in [si1, si2, pe]]
+		self.assertEqual(si1.outstanding_amount, 100)
+		self.assertEqual(si2.outstanding_amount, 0)
+		self.assertEqual(len(pe.references), 1)
+		self.assertEqual(pe.unallocated_amount, 100)
+
+	def test_02_unreconcile_one_payment_from_multi_payments(self):
+		"""
+		Scenario: 2 payments, both split against 2 different invoices
+		Unreconcile only one payment from one invoice
+		"""
+		si1 = self.create_sales_invoice()
+		si2 = self.create_sales_invoice()
+		pe1 = self.create_payment_entry()
+		pe1.paid_amount = 100
+		# Allocate payment against both invoices
+		pe1.append(
+			"references",
+			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 50},
+		)
+		pe1.append(
+			"references",
+			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 50},
+		)
+		pe1.save().submit()
+
+		pe2 = self.create_payment_entry()
+		pe2.paid_amount = 100
+		# Allocate payment against both invoices
+		pe2.append(
+			"references",
+			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 50},
+		)
+		pe2.append(
+			"references",
+			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 50},
+		)
+		pe2.save().submit()
+
+		# Assert outstanding and unallocated
+		[doc.reload() for doc in [si1, si2, pe1, pe2]]
+		self.assertEqual(si1.outstanding_amount, 0.0)
+		self.assertEqual(si2.outstanding_amount, 0.0)
+		self.assertEqual(pe1.unallocated_amount, 0.0)
+		self.assertEqual(pe2.unallocated_amount, 0.0)
+
+		unreconcile = frappe.get_doc(
+			{
+				"doctype": "Unreconcile Payments",
+				"company": self.company,
+				"voucher_type": pe2.doctype,
+				"voucher_no": pe2.name,
+			}
+		)
+		unreconcile.add_references()
+		self.assertEqual(len(unreconcile.allocations), 2)
+		allocations = [x.reference_name for x in unreconcile.allocations]
+		self.assertEquals([si1.name, si2.name], allocations)
+		# unreconcile si1 from pe2
+		for x in unreconcile.allocations:
+			if x.reference_name != si1.name:
+				unreconcile.remove(x)
+		unreconcile.save().submit()
+
+		# Assert outstanding and unallocated
+		[doc.reload() for doc in [si1, si2, pe1, pe2]]
+		self.assertEqual(si1.outstanding_amount, 50)
+		self.assertEqual(si2.outstanding_amount, 0)
+		self.assertEqual(len(pe1.references), 2)
+		self.assertEqual(len(pe2.references), 1)
+		self.assertEqual(pe1.unallocated_amount, 0)
+		self.assertEqual(pe2.unallocated_amount, 50)
+
+	def test_03_unreconciliation_on_multi_currency_invoice(self):
+		self.create_customer("_Test MC Customer USD", "USD")
+		si1 = self.create_sales_invoice(do_not_submit=True)
+		si1.currency = "USD"
+		si1.debit_to = self.debtors_usd
+		si1.conversion_rate = 80
+		si1.save().submit()
+
+		si2 = self.create_sales_invoice(do_not_submit=True)
+		si2.currency = "USD"
+		si2.debit_to = self.debtors_usd
+		si2.conversion_rate = 80
+		si2.save().submit()
+
+		pe = self.create_payment_entry()
+		pe.paid_from = self.debtors_usd
+		pe.paid_from_account_currency = "USD"
+		pe.source_exchange_rate = 75
+		pe.received_amount = 75 * 200
+		pe.save()
+		# Allocate payment against both invoices
+		pe.append(
+			"references",
+			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 100},
+		)
+		pe.append(
+			"references",
+			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 100},
+		)
+		pe.save().submit()
+
+		unreconcile = frappe.get_doc(
+			{
+				"doctype": "Unreconcile Payments",
+				"company": self.company,
+				"voucher_type": pe.doctype,
+				"voucher_no": pe.name,
+			}
+		)
+		unreconcile.add_references()
+		self.assertEqual(len(unreconcile.allocations), 2)
+		allocations = [x.reference_name for x in unreconcile.allocations]
+		self.assertEquals([si1.name, si2.name], allocations)
+		# unreconcile si1 from pe
+		for x in unreconcile.allocations:
+			if x.reference_name != si1.name:
+				unreconcile.remove(x)
+		unreconcile.save().submit()
+
+		# Assert outstanding and unallocated
+		[doc.reload() for doc in [si1, si2, pe]]
+		self.assertEqual(si1.outstanding_amount, 100)
+		self.assertEqual(si2.outstanding_amount, 0)
+		self.assertEqual(len(pe.references), 1)
+		self.assertEqual(pe.unallocated_amount, 100)
+
+		# Exc gain/loss JE should've been cancelled as well
+		self.assertEqual(
+			frappe.db.count(
+				"Journal Entry Account",
+				filters={"reference_type": si1.doctype, "reference_name": si1.name, "docstatus": 1},
+			),
+			0,
+		)
+
+	def test_04_unreconciliation_on_multi_currency_invoice(self):
+		"""
+		2 payments split against 2 foreign currency invoices
+		"""
+		self.create_customer("_Test MC Customer USD", "USD")
+		si1 = self.create_sales_invoice(do_not_submit=True)
+		si1.currency = "USD"
+		si1.debit_to = self.debtors_usd
+		si1.conversion_rate = 80
+		si1.save().submit()
+
+		si2 = self.create_sales_invoice(do_not_submit=True)
+		si2.currency = "USD"
+		si2.debit_to = self.debtors_usd
+		si2.conversion_rate = 80
+		si2.save().submit()
+
+		pe1 = self.create_payment_entry()
+		pe1.paid_from = self.debtors_usd
+		pe1.paid_from_account_currency = "USD"
+		pe1.source_exchange_rate = 75
+		pe1.received_amount = 75 * 100
+		pe1.save()
+		# Allocate payment against both invoices
+		pe1.append(
+			"references",
+			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 50},
+		)
+		pe1.append(
+			"references",
+			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 50},
+		)
+		pe1.save().submit()
+
+		pe2 = self.create_payment_entry()
+		pe2.paid_from = self.debtors_usd
+		pe2.paid_from_account_currency = "USD"
+		pe2.source_exchange_rate = 75
+		pe2.received_amount = 75 * 100
+		pe2.save()
+		# Allocate payment against both invoices
+		pe2.append(
+			"references",
+			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 50},
+		)
+		pe2.append(
+			"references",
+			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 50},
+		)
+		pe2.save().submit()
+
+		unreconcile = frappe.get_doc(
+			{
+				"doctype": "Unreconcile Payments",
+				"company": self.company,
+				"voucher_type": pe2.doctype,
+				"voucher_no": pe2.name,
+			}
+		)
+		unreconcile.add_references()
+		self.assertEqual(len(unreconcile.allocations), 2)
+		allocations = [x.reference_name for x in unreconcile.allocations]
+		self.assertEquals([si1.name, si2.name], allocations)
+		# unreconcile si1 from pe2
+		for x in unreconcile.allocations:
+			if x.reference_name != si1.name:
+				unreconcile.remove(x)
+		unreconcile.save().submit()
+
+		# Assert outstanding and unallocated
+		[doc.reload() for doc in [si1, si2, pe1, pe2]]
+		self.assertEqual(si1.outstanding_amount, 50)
+		self.assertEqual(si2.outstanding_amount, 0)
+		self.assertEqual(len(pe1.references), 2)
+		self.assertEqual(len(pe2.references), 1)
+		self.assertEqual(pe1.unallocated_amount, 0)
+		self.assertEqual(pe2.unallocated_amount, 50)
+
+		# Exc gain/loss JE from PE1 should be available
+		self.assertEqual(
+			frappe.db.count(
+				"Journal Entry Account",
+				filters={"reference_type": si1.doctype, "reference_name": si1.name, "docstatus": 1},
+			),
+			1,
+		)

erpnext/accounts/doctype/unreconcile_payments/unreconcile_payments.js

@@ -0,0 +1,41 @@
+// Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
+// For license information, please see license.txt
+
+frappe.ui.form.on("Unreconcile Payments", {
+	refresh(frm) {
+		frm.set_query("voucher_type", function() {
+			return {
+				filters: {
+					name: ["in", ["Payment Entry", "Journal Entry"]]
+				}
+			}
+		});
+
+
+		frm.set_query("voucher_no", function(doc) {
+			return {
+				filters: {
+					company: doc.company,
+					docstatus: 1
+				}
+			}
+		});
+
+	},
+	get_allocations: function(frm) {
+		frm.clear_table("allocations");
+		frappe.call({
+			method: "get_allocations_from_payment",
+			doc: frm.doc,
+			callback: function(r) {
+				if (r.message) {
+					r.message.forEach(x => {
+						frm.add_child("allocations", x)
+					})
+					frm.refresh_fields();
+				}
+			}
+		})
+
+	}
+});

erpnext/accounts/doctype/unreconcile_payments/unreconcile_payments.json

@@ -0,0 +1,93 @@
+{
+ "actions": [],
+ "allow_rename": 1,
+ "autoname": "format:UNREC-{#####}",
+ "creation": "2023-08-22 10:26:34.421423",
+ "default_view": "List",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "company",
+  "voucher_type",
+  "voucher_no",
+  "get_allocations",
+  "allocations",
+  "amended_from"
+ ],
+ "fields": [
+  {
+   "fieldname": "amended_from",
+   "fieldtype": "Link",
+   "label": "Amended From",
+   "no_copy": 1,
+   "options": "Unreconcile Payments",
+   "print_hide": 1,
+   "read_only": 1
+  },
+  {
+   "fieldname": "company",
+   "fieldtype": "Link",
+   "label": "Company",
+   "options": "Company"
+  },
+  {
+   "fieldname": "voucher_type",
+   "fieldtype": "Link",
+   "label": "Voucher Type",
+   "options": "DocType"
+  },
+  {
+   "fieldname": "voucher_no",
+   "fieldtype": "Dynamic Link",
+   "label": "Voucher No",
+   "options": "voucher_type"
+  },
+  {
+   "fieldname": "get_allocations",
+   "fieldtype": "Button",
+   "label": "Get Allocations"
+  },
+  {
+   "fieldname": "allocations",
+   "fieldtype": "Table",
+   "label": "Allocations",
+   "options": "Unreconcile Payment Entries"
+  }
+ ],
+ "index_web_pages_for_search": 1,
+ "is_submittable": 1,
+ "links": [],
+ "modified": "2023-08-28 17:42:50.261377",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Unreconcile Payments",
+ "naming_rule": "Expression",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "read": 1,
+   "role": "Accounts Manager",
+   "select": 1,
+   "share": 1,
+   "submit": 1,
+   "write": 1
+  },
+  {
+   "create": 1,
+   "delete": 1,
+   "read": 1,
+   "role": "Accounts User",
+   "select": 1,
+   "share": 1,
+   "submit": 1,
+   "write": 1
+  }
+ ],
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "states": [],
+ "track_changes": 1
+}

erpnext/accounts/doctype/unreconcile_payments/unreconcile_payments.py

@@ -0,0 +1,158 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+import frappe
+from frappe import _, qb
+from frappe.model.document import Document
+from frappe.query_builder import Criterion
+from frappe.query_builder.functions import Abs, Sum
+from frappe.utils.data import comma_and
+
+from erpnext.accounts.utils import (
+	cancel_exchange_gain_loss_journal,
+	unlink_ref_doc_from_payment_entries,
+	update_voucher_outstanding,
+)
+
+
+class UnreconcilePayments(Document):
+	def validate(self):
+		self.supported_types = ["Payment Entry", "Journal Entry"]
+		if not self.voucher_type in self.supported_types:
+			frappe.throw(_("Only {0} are supported").format(comma_and(self.supported_types)))
+
+	@frappe.whitelist()
+	def get_allocations_from_payment(self):
+		allocated_references = []
+		ple = qb.DocType("Payment Ledger Entry")
+		allocated_references = (
+			qb.from_(ple)
+			.select(
+				ple.account,
+				ple.party_type,
+				ple.party,
+				ple.against_voucher_type.as_("reference_doctype"),
+				ple.against_voucher_no.as_("reference_name"),
+				Abs(Sum(ple.amount_in_account_currency)).as_("allocated_amount"),
+				ple.account_currency,
+			)
+			.where(
+				(ple.docstatus == 1)
+				& (ple.voucher_type == self.voucher_type)
+				& (ple.voucher_no == self.voucher_no)
+				& (ple.voucher_no != ple.against_voucher_no)
+			)
+			.groupby(ple.against_voucher_type, ple.against_voucher_no)
+			.run(as_dict=True)
+		)
+
+		return allocated_references
+
+	def add_references(self):
+		allocations = self.get_allocations_from_payment()
+
+		for alloc in allocations:
+			self.append("allocations", alloc)
+
+	def on_submit(self):
+		# todo: more granular unreconciliation
+		for alloc in self.allocations:
+			doc = frappe.get_doc(alloc.reference_doctype, alloc.reference_name)
+			unlink_ref_doc_from_payment_entries(doc, self.voucher_no)
+			cancel_exchange_gain_loss_journal(doc, self.voucher_type, self.voucher_no)
+			update_voucher_outstanding(
+				alloc.reference_doctype, alloc.reference_name, alloc.account, alloc.party_type, alloc.party
+			)
+			frappe.db.set_value("Unreconcile Payment Entries", alloc.name, "unlinked", True)
+
+
+@frappe.whitelist()
+def doc_has_references(doctype: str = None, docname: str = None):
+	if doctype in ["Sales Invoice", "Purchase Invoice"]:
+		return frappe.db.count(
+			"Payment Ledger Entry",
+			filters={"delinked": 0, "against_voucher_no": docname, "amount": ["<", 0]},
+		)
+	else:
+		return frappe.db.count(
+			"Payment Ledger Entry",
+			filters={"delinked": 0, "voucher_no": docname, "against_voucher_no": ["!=", docname]},
+		)
+
+
+@frappe.whitelist()
+def get_linked_payments_for_doc(
+	company: str = None, doctype: str = None, docname: str = None
+) -> list:
+	if company and doctype and docname:
+		_dt = doctype
+		_dn = docname
+		ple = qb.DocType("Payment Ledger Entry")
+		if _dt in ["Sales Invoice", "Purchase Invoice"]:
+			criteria = [
+				(ple.company == company),
+				(ple.delinked == 0),
+				(ple.against_voucher_no == _dn),
+				(ple.amount < 0),
+			]
+
+			res = (
+				qb.from_(ple)
+				.select(
+					ple.company,
+					ple.voucher_type,
+					ple.voucher_no,
+					Abs(Sum(ple.amount_in_account_currency)).as_("allocated_amount"),
+					ple.account_currency,
+				)
+				.where(Criterion.all(criteria))
+				.groupby(ple.voucher_no, ple.against_voucher_no)
+				.having(qb.Field("allocated_amount") > 0)
+				.run(as_dict=True)
+			)
+			return res
+		else:
+			criteria = [
+				(ple.company == company),
+				(ple.delinked == 0),
+				(ple.voucher_no == _dn),
+				(ple.against_voucher_no != _dn),
+			]
+
+			query = (
+				qb.from_(ple)
+				.select(
+					ple.company,
+					ple.against_voucher_type.as_("voucher_type"),
+					ple.against_voucher_no.as_("voucher_no"),
+					Abs(Sum(ple.amount_in_account_currency)).as_("allocated_amount"),
+					ple.account_currency,
+				)
+				.where(Criterion.all(criteria))
+				.groupby(ple.against_voucher_no)
+			)
+			res = query.run(as_dict=True)
+			return res
+	return []
+
+
+@frappe.whitelist()
+def create_unreconcile_doc_for_selection(selections=None):
+	if selections:
+		selections = frappe.json.loads(selections)
+		# assuming each row is a unique voucher
+		for row in selections:
+			unrecon = frappe.new_doc("Unreconcile Payments")
+			unrecon.company = row.get("company")
+			unrecon.voucher_type = row.get("voucher_type")
+			unrecon.voucher_no = row.get("voucher_no")
+			unrecon.add_references()
+
+			# remove unselected references
+			unrecon.allocations = [
+				x
+				for x in unrecon.allocations
+				if x.reference_doctype == row.get("against_voucher_type")
+				and x.reference_name == row.get("against_voucher_no")
+			]
+			unrecon.save().submit()

erpnext/accounts/general_ledger.py

@@ -539,6 +539,10 @@ def get_round_off_account_and_cost_center(
 		"Company", company, ["round_off_account", "round_off_cost_center"]
 	) or [None, None]
 
+	# Use expense account as fallback
+	if not round_off_account:
+		round_off_account = frappe.get_cached_value("Company", company, "default_expense_account")
+
 	meta = frappe.get_meta(voucher_type)
 
 	# Give first preference to parent cost center for round off GLE

erpnext/accounts/party.py

@@ -14,7 +14,7 @@ from frappe.contacts.doctype.address.address import (
 from frappe.contacts.doctype.contact.contact import get_contact_details
 from frappe.core.doctype.user_permission.user_permission import get_permitted_documents
 from frappe.model.utils import get_fetch_values
-from frappe.query_builder.functions import Date, Sum
+from frappe.query_builder.functions import Abs, Date, Sum
 from frappe.utils import (
 	add_days,
 	add_months,
@@ -409,7 +409,7 @@ def get_party_account(party_type, party=None, company=None, include_advance=Fals
 		if (account and account_currency != existing_gle_currency) or not account:
 			account = get_party_gle_account(party_type, party, company)
 
-	if include_advance and party_type in ["Customer", "Supplier"]:
+	if include_advance and party_type in ["Customer", "Supplier", "Student"]:
 		advance_account = get_party_advance_account(party_type, party, company)
 		if advance_account:
 			return [account, advance_account]
@@ -922,35 +922,34 @@ def get_party_shipping_address(doctype: str, name: str) -> Optional[str]:
 
 
 def get_partywise_advanced_payment_amount(
-	party_type, posting_date=None, future_payment=0, company=None, party=None, account_type=None
+	party_type, posting_date=None, future_payment=0, company=None, party=None
 ):
-	gle = frappe.qb.DocType("GL Entry")
+	ple = frappe.qb.DocType("Payment Ledger Entry")
 	query = (
-		frappe.qb.from_(gle)
-		.select(gle.party)
+		frappe.qb.from_(ple)
+		.select(ple.party, Abs(Sum(ple.amount).as_("amount")))
 		.where(
-			(gle.party_type.isin(party_type)) & (gle.against_voucher.isnull()) & (gle.is_cancelled == 0)
+			(ple.party_type.isin(party_type))
+			& (ple.amount < 0)
+			& (ple.against_voucher_no == ple.voucher_no)
+			& (ple.delinked == 0)
 		)
-		.groupby(gle.party)
+		.groupby(ple.party)
 	)
-	if account_type == "Receivable":
-		query = query.select(Sum(gle.credit).as_("amount"))
-	else:
-		query = query.select(Sum(gle.debit).as_("amount"))
 
 	if posting_date:
 		if future_payment:
-			query = query.where((gle.posting_date <= posting_date) | (Date(gle.creation) <= posting_date))
+			query = query.where((ple.posting_date <= posting_date) | (Date(ple.creation) <= posting_date))
 		else:
-			query = query.where(gle.posting_date <= posting_date)
+			query = query.where(ple.posting_date <= posting_date)
 
 	if company:
-		query = query.where(gle.company == company)
+		query = query.where(ple.company == company)
 
 	if party:
-		query = query.where(gle.party == party)
+		query = query.where(ple.party == party)
 
-	data = query.run(as_dict=True)
+	data = query.run()
 	if data:
 		return frappe._dict(data)
 

erpnext/accounts/report/accounts_payable/accounts_payable.js

@@ -37,24 +37,6 @@ frappe.query_reports["Accounts Payable"] = {
 				}
 			}
 		},
-		{
-			"fieldname": "supplier",
-			"label": __("Supplier"),
-			"fieldtype": "Link",
-			"options": "Supplier",
-			on_change: () => {
-				var supplier = frappe.query_report.get_filter_value('supplier');
-				if (supplier) {
-					frappe.db.get_value('Supplier', supplier, "tax_id", function(value) {
-						frappe.query_report.set_filter_value('tax_id', value["tax_id"]);
-					});
-				} else {
-					frappe.query_report.set_filter_value('tax_id', "");
-				}
-
-				frappe.query_report.refresh();
-			}
-		},
 		{
 			"fieldname": "party_account",
 			"label": __("Payable Account"),
@@ -112,11 +94,35 @@ frappe.query_reports["Accounts Payable"] = {
 			"fieldtype": "Link",
 			"options": "Payment Terms Template"
 		},
+		{
+			"fieldname": "party_type",
+			"label": __("Party Type"),
+			"fieldtype": "Link",
+			"options": "Party Type",
+			get_query: () => {
+				return {
+					filters: {
+						'account_type': 'Payable'
+					}
+				};
+			},
+			on_change: () => {
+				frappe.query_report.set_filter_value('party', "");
+				frappe.query_report.toggle_filter_display('supplier_group', frappe.query_report.get_filter_value('party_type') !== "Supplier");
+			}
+		},
+		{
+			"fieldname":"party",
+			"label": __("Party"),
+			"fieldtype": "Dynamic Link",
+			"options": "party_type",
+		},
 		{
 			"fieldname": "supplier_group",
 			"label": __("Supplier Group"),
 			"fieldtype": "Link",
-			"options": "Supplier Group"
+			"options": "Supplier Group",
+			"hidden": 1
 		},
 		{
 			"fieldname": "group_by_party",
@@ -133,12 +139,6 @@ frappe.query_reports["Accounts Payable"] = {
 			"label": __("Show Remarks"),
 			"fieldtype": "Check",
 		},
-		{
-			"fieldname": "tax_id",
-			"label": __("Tax Id"),
-			"fieldtype": "Data",
-			"hidden": 1
-		},
 		{
 			"fieldname": "show_future_payments",
 			"label": __("Show Future Payments"),

erpnext/accounts/report/accounts_payable/test_accounts_payable.py

@@ -0,0 +1,67 @@
+import unittest
+
+import frappe
+from frappe.tests.utils import FrappeTestCase, change_settings
+from frappe.utils import add_days, flt, getdate, today
+
+from erpnext import get_default_cost_center
+from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+from erpnext.accounts.report.accounts_payable.accounts_payable import execute
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+
+
+class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
+	def setUp(self):
+		self.create_company()
+		self.create_customer()
+		self.create_item()
+		self.create_supplier(currency="USD", supplier_name="Test Supplier2")
+		self.create_usd_payable_account()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def test_accounts_payable_for_foreign_currency_supplier(self):
+		pi = self.create_purchase_invoice(do_not_submit=True)
+		pi.currency = "USD"
+		pi.conversion_rate = 80
+		pi.credit_to = self.creditors_usd
+		pi = pi.save().submit()
+
+		filters = {
+			"company": self.company,
+			"party_type": "Supplier",
+			"party": self.supplier,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+		}
+
+		data = execute(filters)
+		self.assertEqual(data[1][0].get("outstanding"), 300)
+		self.assertEqual(data[1][0].get("currency"), "USD")
+
+	def create_purchase_invoice(self, do_not_submit=False):
+		frappe.set_user("Administrator")
+		pi = make_purchase_invoice(
+			item=self.item,
+			company=self.company,
+			supplier=self.supplier,
+			is_return=False,
+			update_stock=False,
+			posting_date=frappe.utils.datetime.date(2021, 5, 1),
+			do_not_save=1,
+			rate=300,
+			price_list_rate=300,
+			qty=1,
+		)
+
+		pi = pi.save()
+		if not do_not_submit:
+			pi = pi.submit()
+		return pi

erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.js

@@ -72,10 +72,27 @@ frappe.query_reports["Accounts Payable Summary"] = {
 			}
 		},
 		{
-			"fieldname":"supplier",
-			"label": __("Supplier"),
+			"fieldname": "party_type",
+			"label": __("Party Type"),
 			"fieldtype": "Link",
-			"options": "Supplier"
+			"options": "Party Type",
+			get_query: () => {
+				return {
+					filters: {
+						'account_type': 'Payable'
+					}
+				};
+			},
+			on_change: () => {
+				frappe.query_report.set_filter_value('party', "");
+				frappe.query_report.toggle_filter_display('supplier_group', frappe.query_report.get_filter_value('party_type') !== "Supplier");
+			}
+		},
+		{
+			"fieldname":"party",
+			"label": __("Party"),
+			"fieldtype": "Dynamic Link",
+			"options": "party_type",
 		},
 		{
 			"fieldname":"payment_terms_template",

erpnext/accounts/report/accounts_receivable/accounts_receivable.js

@@ -38,34 +38,29 @@ frappe.query_reports["Accounts Receivable"] = {
 			}
 		},
 		{
-			"fieldname": "customer",
-			"label": __("Customer"),
+			"fieldname": "party_type",
+			"label": __("Party Type"),
 			"fieldtype": "Link",
-			"options": "Customer",
+			"options": "Party Type",
+			"Default": "Customer",
+			get_query: () => {
+				return {
+					filters: {
+						'account_type': 'Receivable'
+					}
+				};
+			},
 			on_change: () => {
-				var customer = frappe.query_report.get_filter_value('customer');
-				var company = frappe.query_report.get_filter_value('company');
-				if (customer) {
-					frappe.db.get_value('Customer', customer, ["tax_id", "customer_name", "payment_terms"], function(value) {
-						frappe.query_report.set_filter_value('tax_id', value["tax_id"]);
-						frappe.query_report.set_filter_value('customer_name', value["customer_name"]);
-						frappe.query_report.set_filter_value('payment_terms', value["payment_terms"]);
-					});
-
-					frappe.db.get_value('Customer Credit Limit', {'parent': customer, 'company': company},
-						["credit_limit"], function(value) {
-						if (value) {
-							frappe.query_report.set_filter_value('credit_limit', value["credit_limit"]);
-						}
-					}, "Customer");
-				} else {
-					frappe.query_report.set_filter_value('tax_id', "");
-					frappe.query_report.set_filter_value('customer_name', "");
-					frappe.query_report.set_filter_value('credit_limit', "");
-					frappe.query_report.set_filter_value('payment_terms', "");
-				}
+				frappe.query_report.set_filter_value('party', "");
+				frappe.query_report.toggle_filter_display('customer_group', frappe.query_report.get_filter_value('party_type') !== "Customer");
 			}
 		},
+		{
+			"fieldname":"party",
+			"label": __("Party"),
+			"fieldtype": "Dynamic Link",
+			"options": "party_type",
+		},
 		{
 			"fieldname": "party_account",
 			"label": __("Receivable Account"),
@@ -172,34 +167,10 @@ frappe.query_reports["Accounts Receivable"] = {
 			"label": __("Show Sales Person"),
 			"fieldtype": "Check",
 		},
-		{
-			"fieldname": "tax_id",
-			"label": __("Tax Id"),
-			"fieldtype": "Data",
-			"hidden": 1
-		},
 		{
 			"fieldname": "show_remarks",
 			"label": __("Show Remarks"),
 			"fieldtype": "Check",
-		},
-		{
-			"fieldname": "customer_name",
-			"label": __("Customer Name"),
-			"fieldtype": "Data",
-			"hidden": 1
-		},
-		{
-			"fieldname": "payment_terms",
-			"label": __("Payment Tems"),
-			"fieldtype": "Data",
-			"hidden": 1
-		},
-		{
-			"fieldname": "credit_limit",
-			"label": __("Credit Limit"),
-			"fieldtype": "Currency",
-			"hidden": 1
 		}
 	],
 

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -211,9 +211,8 @@ class ReceivablePayableReport(object):
 			return
 
 		# amount in "Party Currency", if its supplied. If not, amount in company currency
-		for party_type in self.party_type:
-			if self.filters.get(scrub(party_type)):
-				amount = ple.amount_in_account_currency
+		if self.filters.get("party_type") and self.filters.get("party"):
+			amount = ple.amount_in_account_currency
 		else:
 			amount = ple.amount
 		amount_in_account_currency = ple.amount_in_account_currency
@@ -426,10 +425,9 @@ class ReceivablePayableReport(object):
 		# customer / supplier name
 		party_details = self.get_party_details(row.party) or {}
 		row.update(party_details)
-		for party_type in self.party_type:
-			if self.filters.get(scrub(party_type)):
-				row.currency = row.account_currency
-				break
+
+		if self.filters.get("party_type") and self.filters.get("party"):
+			row.currency = row.account_currency
 		else:
 			row.currency = self.company_currency
 
@@ -469,6 +467,10 @@ class ReceivablePayableReport(object):
 		original_row = frappe._dict(row)
 		row.payment_terms = []
 
+		# Cr Note's don't have Payment Terms
+		if not payment_terms_details:
+			return
+
 		# Advance allocated during invoicing is not considered in payment terms
 		# Deduct that from paid amount pre allocation
 		row.paid -= flt(payment_terms_details[0].total_advance)
@@ -765,16 +767,14 @@ class ReceivablePayableReport(object):
 	def prepare_conditions(self):
 		self.qb_selection_filter = []
 		self.or_filters = []
+
 		for party_type in self.party_type:
-			party_type_field = scrub(party_type)
-			self.or_filters.append(self.ple.party_type == party_type)
+			self.add_common_filters()
 
-			self.add_common_filters(party_type_field=party_type_field)
-
-			if party_type_field == "customer":
+			if self.account_type == "Receivable":
 				self.add_customer_filters()
 
-			elif party_type_field == "supplier":
+			elif self.account_type == "Payable":
 				self.add_supplier_filters()
 
 		if self.filters.cost_center:
@@ -790,15 +790,18 @@ class ReceivablePayableReport(object):
 		]
 		self.qb_selection_filter.append(self.ple.cost_center.isin(cost_center_list))
 
-	def add_common_filters(self, party_type_field):
+	def add_common_filters(self):
 		if self.filters.company:
 			self.qb_selection_filter.append(self.ple.company == self.filters.company)
 
 		if self.filters.finance_book:
 			self.qb_selection_filter.append(self.ple.finance_book == self.filters.finance_book)
 
-		if self.filters.get(party_type_field):
-			self.qb_selection_filter.append(self.ple.party == self.filters.get(party_type_field))
+		if self.filters.get("party_type"):
+			self.qb_selection_filter.append(self.filters.party_type == self.ple.party_type)
+
+		if self.filters.get("party"):
+			self.qb_selection_filter.append(self.filters.party == self.ple.party)
 
 		if self.filters.party_account:
 			self.qb_selection_filter.append(self.ple.account == self.filters.party_account)
@@ -960,6 +963,20 @@ class ReceivablePayableReport(object):
 				fieldtype="Link",
 				options="Contact",
 			)
+		if self.filters.party_type == "Customer":
+			self.add_column(
+				_("Customer Name"),
+				fieldname="customer_name",
+				fieldtype="Link",
+				options="Customer",
+			)
+		elif self.filters.party_type == "Supplier":
+			self.add_column(
+				_("Supplier Name"),
+				fieldname="supplier_name",
+				fieldtype="Link",
+				options="Supplier",
+			)
 
 		self.add_column(label=_("Cost Center"), fieldname="cost_center", fieldtype="Data")
 		self.add_column(label=_("Voucher Type"), fieldname="voucher_type", fieldtype="Data")
@@ -1090,7 +1107,10 @@ class ReceivablePayableReport(object):
 			.where(
 				(je.company == self.filters.company)
 				& (je.posting_date.lte(self.filters.report_date))
-				& (je.voucher_type == "Exchange Rate Revaluation")
+				& (
+					(je.voucher_type == "Exchange Rate Revaluation")
+					| (je.voucher_type == "Exchange Gain Or Loss")
+				)
 			)
 			.run()
 		)

erpnext/accounts/report/accounts_receivable/test_accounts_receivable.py

@@ -8,20 +8,17 @@ from erpnext import get_default_cost_center
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.report.accounts_receivable.accounts_receivable import execute
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 
 
-class TestAccountsReceivable(FrappeTestCase):
+class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 	def setUp(self):
-		frappe.db.sql("delete from `tabSales Invoice` where company='_Test Company 2'")
-		frappe.db.sql("delete from `tabSales Order` where company='_Test Company 2'")
-		frappe.db.sql("delete from `tabPayment Entry` where company='_Test Company 2'")
-		frappe.db.sql("delete from `tabGL Entry` where company='_Test Company 2'")
-		frappe.db.sql("delete from `tabPayment Ledger Entry` where company='_Test Company 2'")
-		frappe.db.sql("delete from `tabJournal Entry` where company='_Test Company 2'")
-		frappe.db.sql("delete from `tabExchange Rate Revaluation` where company='_Test Company 2'")
-
-		self.create_usd_account()
+		self.create_company()
+		self.create_customer()
+		self.create_item()
+		self.create_usd_receivable_account()
+		self.clear_old_entries()
 
 	def tearDown(self):
 		frappe.db.rollback()
@@ -49,29 +46,84 @@ class TestAccountsReceivable(FrappeTestCase):
 			debtors_usd.account_type = debtors.account_type
 			self.debtors_usd = debtors_usd.save().name
 
+	def create_sales_invoice(self, no_payment_schedule=False, do_not_submit=False):
+		frappe.set_user("Administrator")
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debit_to,
+			posting_date=today(),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=100,
+			price_list_rate=100,
+			do_not_save=1,
+		)
+		if not no_payment_schedule:
+			si.append(
+				"payment_schedule",
+				dict(due_date=getdate(add_days(today(), 30)), invoice_portion=30.00, payment_amount=30),
+			)
+			si.append(
+				"payment_schedule",
+				dict(due_date=getdate(add_days(today(), 60)), invoice_portion=50.00, payment_amount=50),
+			)
+			si.append(
+				"payment_schedule",
+				dict(due_date=getdate(add_days(today(), 90)), invoice_portion=20.00, payment_amount=20),
+			)
+		si = si.save()
+		if not do_not_submit:
+			si = si.submit()
+		return si
+
+	def create_payment_entry(self, docname):
+		pe = get_payment_entry("Sales Invoice", docname, bank_account=self.cash, party_amount=40)
+		pe.paid_from = self.debit_to
+		pe.insert()
+		pe.submit()
+
+	def create_credit_note(self, docname):
+		credit_note = create_sales_invoice(
+			company=self.company,
+			customer=self.customer,
+			item=self.item,
+			qty=-1,
+			debit_to=self.debit_to,
+			cost_center=self.cost_center,
+			is_return=1,
+			return_against=docname,
+		)
+
+		return credit_note
+
 	def test_accounts_receivable(self):
 		filters = {
-			"company": "_Test Company 2",
+			"company": self.company,
 			"based_on_payment_terms": 1,
 			"report_date": today(),
 			"range1": 30,
 			"range2": 60,
 			"range3": 90,
 			"range4": 120,
+			"show_remarks": True,
 		}
 
 		# check invoice grand total and invoiced column's value for 3 payment terms
-		name = make_sales_invoice().name
+		si = self.create_sales_invoice()
+		name = si.name
+
 		report = execute(filters)
 
-		expected_data = [[100, 30], [100, 50], [100, 20]]
+		expected_data = [[100, 30, "No Remarks"], [100, 50, "No Remarks"], [100, 20, "No Remarks"]]
 
 		for i in range(3):
 			row = report[1][i - 1]
-			self.assertEqual(expected_data[i - 1], [row.invoice_grand_total, row.invoiced])
+			self.assertEqual(expected_data[i - 1], [row.invoice_grand_total, row.invoiced, row.remarks])
 
 		# check invoice grand total, invoiced, paid and outstanding column's value after payment
-		make_payment(name)
+		self.create_payment_entry(si.name)
 		report = execute(filters)
 
 		expected_data_after_payment = [[100, 50, 10, 40], [100, 20, 0, 20]]
@@ -84,10 +136,10 @@ class TestAccountsReceivable(FrappeTestCase):
 			)
 
 		# check invoice grand total, invoiced, paid and outstanding column's value after credit note
-		make_credit_note(name)
+		self.create_credit_note(si.name)
 		report = execute(filters)
 
-		expected_data_after_credit_note = [100, 0, 0, 40, -40, "Debtors - _TC2"]
+		expected_data_after_credit_note = [100, 0, 0, 40, -40, self.debit_to]
 
 		row = report[1][0]
 		self.assertEqual(
@@ -108,21 +160,20 @@ class TestAccountsReceivable(FrappeTestCase):
 		"""
 
 		so = make_sales_order(
-			company="_Test Company 2",
-			customer="_Test Customer 2",
-			warehouse="Finished Goods - _TC2",
-			currency="EUR",
-			debit_to="Debtors - _TC2",
-			income_account="Sales - _TC2",
-			expense_account="Cost of Goods Sold - _TC2",
-			cost_center="Main - _TC2",
+			company=self.company,
+			customer=self.customer,
+			warehouse=self.warehouse,
+			debit_to=self.debit_to,
+			income_account=self.income_account,
+			expense_account=self.expense_account,
+			cost_center=self.cost_center,
 		)
 
 		pe = get_payment_entry(so.doctype, so.name)
 		pe = pe.save().submit()
 
 		filters = {
-			"company": "_Test Company 2",
+			"company": self.company,
 			"based_on_payment_terms": 0,
 			"report_date": today(),
 			"range1": 30,
@@ -147,34 +198,32 @@ class TestAccountsReceivable(FrappeTestCase):
 		)
 
 	@change_settings(
-		"Accounts Settings", {"allow_multi_currency_invoices_against_single_party_account": 1}
+		"Accounts Settings",
+		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
 	)
 	def test_exchange_revaluation_for_party(self):
 		"""
-		Exchange Revaluation for party on Receivable/Payable shoule be included
+		Exchange Revaluation for party on Receivable/Payable should be included
 		"""
 
-		company = "_Test Company 2"
-		customer = "_Test Customer 2"
-
 		# Using Exchange Gain/Loss account for unrealized as well.
-		company_doc = frappe.get_doc("Company", company)
+		company_doc = frappe.get_doc("Company", self.company)
 		company_doc.unrealized_exchange_gain_loss_account = company_doc.exchange_gain_loss_account
 		company_doc.save()
 
-		si = make_sales_invoice(no_payment_schedule=True, do_not_submit=True)
+		si = self.create_sales_invoice(no_payment_schedule=True, do_not_submit=True)
 		si.currency = "USD"
-		si.conversion_rate = 0.90
+		si.conversion_rate = 80
 		si.debit_to = self.debtors_usd
 		si = si.save().submit()
 
 		# Exchange Revaluation
 		err = frappe.new_doc("Exchange Rate Revaluation")
-		err.company = company
+		err.company = self.company
 		err.posting_date = today()
 		accounts = err.get_accounts_data()
 		err.extend("accounts", accounts)
-		err.accounts[0].new_exchange_rate = 0.95
+		err.accounts[0].new_exchange_rate = 85
 		row = err.accounts[0]
 		row.new_balance_in_base_currency = flt(
 			row.new_exchange_rate * flt(row.balance_in_account_currency)
@@ -189,7 +238,7 @@ class TestAccountsReceivable(FrappeTestCase):
 		je = je.submit()
 
 		filters = {
-			"company": company,
+			"company": self.company,
 			"report_date": today(),
 			"range1": 30,
 			"range2": 60,
@@ -198,7 +247,7 @@ class TestAccountsReceivable(FrappeTestCase):
 		}
 		report = execute(filters)
 
-		expected_data_for_err = [0, -5, 0, 5]
+		expected_data_for_err = [0, -500, 0, 500]
 		row = [x for x in report[1] if x.voucher_type == je.doctype and x.voucher_no == je.name][0]
 		self.assertEqual(
 			expected_data_for_err,
@@ -214,46 +263,43 @@ class TestAccountsReceivable(FrappeTestCase):
 		"""
 		Payment against credit/debit note should be considered against the parent invoice
 		"""
-		company = "_Test Company 2"
-		customer = "_Test Customer 2"
 
-		si1 = make_sales_invoice()
+		si1 = self.create_sales_invoice()
 
-		pe = get_payment_entry("Sales Invoice", si1.name, bank_account="Cash - _TC2")
-		pe.paid_from = "Debtors - _TC2"
+		pe = get_payment_entry(si1.doctype, si1.name, bank_account=self.cash)
+		pe.paid_from = self.debit_to
 		pe.insert()
 		pe.submit()
 
-		cr_note = make_credit_note(si1.name)
+		cr_note = self.create_credit_note(si1.name)
 
-		si2 = make_sales_invoice()
+		si2 = self.create_sales_invoice()
 
 		# manually link cr_note with si2 using journal entry
 		je = frappe.new_doc("Journal Entry")
-		je.company = company
+		je.company = self.company
 		je.voucher_type = "Credit Note"
 		je.posting_date = today()
 
-		debit_account = "Debtors - _TC2"
 		debit_entry = {
-			"account": debit_account,
+			"account": self.debit_to,
 			"party_type": "Customer",
-			"party": customer,
+			"party": self.customer,
 			"debit": 100,
 			"debit_in_account_currency": 100,
 			"reference_type": cr_note.doctype,
 			"reference_name": cr_note.name,
-			"cost_center": "Main - _TC2",
+			"cost_center": self.cost_center,
 		}
 		credit_entry = {
-			"account": debit_account,
+			"account": self.debit_to,
 			"party_type": "Customer",
-			"party": customer,
+			"party": self.customer,
 			"credit": 100,
 			"credit_in_account_currency": 100,
 			"reference_type": si2.doctype,
 			"reference_name": si2.name,
-			"cost_center": "Main - _TC2",
+			"cost_center": self.cost_center,
 		}
 
 		je.append("accounts", debit_entry)
@@ -261,7 +307,7 @@ class TestAccountsReceivable(FrappeTestCase):
 		je = je.save().submit()
 
 		filters = {
-			"company": company,
+			"company": self.company,
 			"report_date": today(),
 			"range1": 30,
 			"range2": 60,
@@ -271,64 +317,291 @@ class TestAccountsReceivable(FrappeTestCase):
 		report = execute(filters)
 		self.assertEqual(report[1], [])
 
+	def test_group_by_party(self):
+		si1 = self.create_sales_invoice(do_not_submit=True)
+		si1.posting_date = add_days(today(), -1)
+		si1.save().submit()
+		si2 = self.create_sales_invoice(do_not_submit=True)
+		si2.items[0].rate = 85
+		si2.save().submit()
 
-def make_sales_invoice(no_payment_schedule=False, do_not_submit=False):
-	frappe.set_user("Administrator")
+		filters = {
+			"company": self.company,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+			"group_by_party": True,
+		}
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 5)
 
-	si = create_sales_invoice(
-		company="_Test Company 2",
-		customer="_Test Customer 2",
-		currency="EUR",
-		warehouse="Finished Goods - _TC2",
-		debit_to="Debtors - _TC2",
-		income_account="Sales - _TC2",
-		expense_account="Cost of Goods Sold - _TC2",
-		cost_center="Main - _TC2",
-		do_not_save=1,
-	)
+		# assert voucher rows
+		expected_voucher_rows = [
+			[100.0, 100.0, 100.0, 100.0],
+			[85.0, 85.0, 85.0, 85.0],
+		]
+		voucher_rows = []
+		for x in report[0:2]:
+			voucher_rows.append(
+				[x.invoiced, x.outstanding, x.invoiced_in_account_currency, x.outstanding_in_account_currency]
+			)
+		self.assertEqual(expected_voucher_rows, voucher_rows)
 
-	if not no_payment_schedule:
-		si.append(
-			"payment_schedule",
-			dict(due_date=getdate(add_days(today(), 30)), invoice_portion=30.00, payment_amount=30),
+		# assert total rows
+		expected_total_rows = [
+			[self.customer, 185.0, 185.0],  # party total
+			{},  # empty row for padding
+			["Total", 185.0, 185.0],  # grand total
+		]
+		party_total_row = report[2]
+		self.assertEqual(
+			expected_total_rows[0],
+			[
+				party_total_row.get("party"),
+				party_total_row.get("invoiced"),
+				party_total_row.get("outstanding"),
+			],
 		)
-		si.append(
-			"payment_schedule",
-			dict(due_date=getdate(add_days(today(), 60)), invoice_portion=50.00, payment_amount=50),
-		)
-		si.append(
-			"payment_schedule",
-			dict(due_date=getdate(add_days(today(), 90)), invoice_portion=20.00, payment_amount=20),
+		empty_row = report[3]
+		self.assertEqual(expected_total_rows[1], empty_row)
+		grand_total_row = report[4]
+		self.assertEqual(
+			expected_total_rows[2],
+			[
+				grand_total_row.get("party"),
+				grand_total_row.get("invoiced"),
+				grand_total_row.get("outstanding"),
+			],
 		)
 
-	si = si.save()
+	def test_future_payments(self):
+		si = self.create_sales_invoice()
+		pe = get_payment_entry(si.doctype, si.name)
+		pe.posting_date = add_days(today(), 1)
+		pe.paid_amount = 90.0
+		pe.references[0].allocated_amount = 90.0
+		pe.save().submit()
+		filters = {
+			"company": self.company,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+			"show_future_payments": True,
+		}
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
 
-	if not do_not_submit:
-		si = si.submit()
+		expected_data = [100.0, 100.0, 10.0, 90.0]
 
-	return si
+		row = report[0]
+		self.assertEqual(
+			expected_data, [row.invoiced, row.outstanding, row.remaining_balance, row.future_amount]
+		)
 
+		pe.cancel()
+		# full payment in future date
+		pe = get_payment_entry(si.doctype, si.name)
+		pe.posting_date = add_days(today(), 1)
+		pe.save().submit()
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
+		expected_data = [100.0, 100.0, 0.0, 100.0]
+		row = report[0]
+		self.assertEqual(
+			expected_data, [row.invoiced, row.outstanding, row.remaining_balance, row.future_amount]
+		)
 
-def make_payment(docname):
-	pe = get_payment_entry("Sales Invoice", docname, bank_account="Cash - _TC2", party_amount=40)
-	pe.paid_from = "Debtors - _TC2"
-	pe.insert()
-	pe.submit()
+		pe.cancel()
+		# over payment in future date
+		pe = get_payment_entry(si.doctype, si.name)
+		pe.posting_date = add_days(today(), 1)
+		pe.paid_amount = 110
+		pe.save().submit()
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 2)
+		expected_data = [[100.0, 0.0, 100.0, 0.0, 100.0], [0.0, 10.0, -10.0, -10.0, 0.0]]
+		for idx, row in enumerate(report):
+			self.assertEqual(
+				expected_data[idx],
+				[row.invoiced, row.paid, row.outstanding, row.remaining_balance, row.future_amount],
+			)
 
+	def test_sales_person(self):
+		sales_person = (
+			frappe.get_doc({"doctype": "Sales Person", "sales_person_name": "John Clark", "enabled": True})
+			.insert()
+			.submit()
+		)
+		si = self.create_sales_invoice(do_not_submit=True)
+		si.append("sales_team", {"sales_person": sales_person.name, "allocated_percentage": 100})
+		si.save().submit()
 
-def make_credit_note(docname):
-	credit_note = create_sales_invoice(
-		company="_Test Company 2",
-		customer="_Test Customer 2",
-		currency="EUR",
-		qty=-1,
-		warehouse="Finished Goods - _TC2",
-		debit_to="Debtors - _TC2",
-		income_account="Sales - _TC2",
-		expense_account="Cost of Goods Sold - _TC2",
-		cost_center="Main - _TC2",
-		is_return=1,
-		return_against=docname,
-	)
+		filters = {
+			"company": self.company,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+			"sales_person": sales_person.name,
+			"show_sales_person": True,
+		}
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
 
-	return credit_note
+		expected_data = [100.0, 100.0, sales_person.name]
+
+		row = report[0]
+		self.assertEqual(expected_data, [row.invoiced, row.outstanding, row.sales_person])
+
+	def test_cost_center_filter(self):
+		si = self.create_sales_invoice()
+		filters = {
+			"company": self.company,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+			"cost_center": self.cost_center,
+		}
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
+		expected_data = [100.0, 100.0, self.cost_center]
+		row = report[0]
+		self.assertEqual(expected_data, [row.invoiced, row.outstanding, row.cost_center])
+
+	def test_customer_group_filter(self):
+		si = self.create_sales_invoice()
+		cus_group = frappe.db.get_value("Customer", self.customer, "customer_group")
+		filters = {
+			"company": self.company,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+			"customer_group": cus_group,
+		}
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
+		expected_data = [100.0, 100.0, cus_group]
+		row = report[0]
+		self.assertEqual(expected_data, [row.invoiced, row.outstanding, row.customer_group])
+
+		filters.update({"customer_group": "Individual"})
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 0)
+
+	def test_party_account_filter(self):
+		si1 = self.create_sales_invoice()
+		self.customer2 = (
+			frappe.get_doc(
+				{
+					"doctype": "Customer",
+					"customer_name": "Jane Doe",
+					"type": "Individual",
+					"default_currency": "USD",
+				}
+			)
+			.insert()
+			.submit()
+		)
+
+		si2 = self.create_sales_invoice(do_not_submit=True)
+		si2.posting_date = add_days(today(), -1)
+		si2.customer = self.customer2
+		si2.currency = "USD"
+		si2.conversion_rate = 80
+		si2.debit_to = self.debtors_usd
+		si2.save().submit()
+
+		# Filter on company currency receivable account
+		filters = {
+			"company": self.company,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+			"party_account": self.debit_to,
+		}
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
+		expected_data = [100.0, 100.0, self.debit_to, si1.currency]
+		row = report[0]
+		self.assertEqual(
+			expected_data, [row.invoiced, row.outstanding, row.party_account, row.account_currency]
+		)
+
+		# Filter on USD receivable account
+		filters.update({"party_account": self.debtors_usd})
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 1)
+		expected_data = [8000.0, 8000.0, self.debtors_usd, si2.currency]
+		row = report[0]
+		self.assertEqual(
+			expected_data, [row.invoiced, row.outstanding, row.party_account, row.account_currency]
+		)
+
+		# without filter on party account
+		filters.pop("party_account")
+		report = execute(filters)[1]
+		self.assertEqual(len(report), 2)
+		expected_data = [
+			[8000.0, 8000.0, 100.0, 100.0, self.debtors_usd, si2.currency],
+			[100.0, 100.0, 100.0, 100.0, self.debit_to, si1.currency],
+		]
+		for idx, row in enumerate(report):
+			self.assertEqual(
+				expected_data[idx],
+				[
+					row.invoiced,
+					row.outstanding,
+					row.invoiced_in_account_currency,
+					row.outstanding_in_account_currency,
+					row.party_account,
+					row.account_currency,
+				],
+			)
+
+	def test_usd_customer_filter(self):
+		filters = {
+			"company": self.company,
+			"party_type": "Customer",
+			"party": self.customer,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+		}
+
+		si = self.create_sales_invoice(no_payment_schedule=True, do_not_submit=True)
+		si.currency = "USD"
+		si.conversion_rate = 80
+		si.debit_to = self.debtors_usd
+		si.save().submit()
+		name = si.name
+
+		# check invoice grand total and invoiced column's value for 3 payment terms
+		report = execute(filters)
+
+		expected = {
+			"voucher_type": si.doctype,
+			"voucher_no": si.name,
+			"party_account": self.debtors_usd,
+			"customer_name": self.customer,
+			"invoiced": 100.0,
+			"outstanding": 100.0,
+			"account_currency": "USD",
+		}
+		self.assertEqual(len(report[1]), 1)
+		report_output = report[1][0]
+		for field in expected:
+			with self.subTest(field=field):
+				self.assertEqual(report_output.get(field), expected.get(field))

erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.js

@@ -72,10 +72,28 @@ frappe.query_reports["Accounts Receivable Summary"] = {
 			}
 		},
 		{
-			"fieldname":"customer",
-			"label": __("Customer"),
+			"fieldname": "party_type",
+			"label": __("Party Type"),
 			"fieldtype": "Link",
-			"options": "Customer"
+			"options": "Party Type",
+			"Default": "Customer",
+			get_query: () => {
+				return {
+					filters: {
+						'account_type': 'Receivable'
+					}
+				};
+			},
+			on_change: () => {
+				frappe.query_report.set_filter_value('party', "");
+				frappe.query_report.toggle_filter_display('customer_group', frappe.query_report.get_filter_value('party_type') !== "Customer");
+			}
+		},
+		{
+			"fieldname":"party",
+			"label": __("Party"),
+			"fieldtype": "Dynamic Link",
+			"options": "party_type",
 		},
 		{
 			"fieldname":"customer_group",

erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py

@@ -50,13 +50,12 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 				self.filters.show_future_payments,
 				self.filters.company,
 				party=party,
-				account_type=self.account_type,
 			)
 			or {}
 		)
 
 		if self.filters.show_gl_balance:
-			gl_balance_map = get_gl_balance(self.filters.report_date)
+			gl_balance_map = get_gl_balance(self.filters.report_date, self.filters.company)
 
 		for party, party_dict in self.party_total.items():
 			if party_dict.outstanding == 0:
@@ -233,12 +232,12 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 		self.add_column(label="Total Amount Due", fieldname="total_due")
 
 
-def get_gl_balance(report_date):
+def get_gl_balance(report_date, company):
 	return frappe._dict(
 		frappe.db.get_all(
 			"GL Entry",
 			fields=["party", "sum(debit -  credit)"],
-			filters={"posting_date": ("<=", report_date), "is_cancelled": 0},
+			filters={"posting_date": ("<=", report_date), "is_cancelled": 0, "company": company},
 			group_by="party",
 			as_list=1,
 		)

erpnext/accounts/report/accounts_receivable_summary/test_accounts_receivable_summary.py

@@ -0,0 +1,203 @@
+import unittest
+
+import frappe
+from frappe.tests.utils import FrappeTestCase, change_settings
+from frappe.utils import today
+
+from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+from erpnext.accounts.report.accounts_receivable_summary.accounts_receivable_summary import execute
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+
+
+class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
+	def setUp(self):
+		self.maxDiff = None
+		self.create_company()
+		self.create_customer()
+		self.create_item()
+		self.clear_old_entries()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def test_01_receivable_summary_output(self):
+		"""
+		Test for Invoices, Paid, Advance and Outstanding
+		"""
+		filters = {
+			"company": self.company,
+			"customer": self.customer,
+			"posting_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+		}
+
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debit_to,
+			posting_date=today(),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=200,
+			price_list_rate=200,
+		)
+
+		customer_group, customer_territory = frappe.db.get_all(
+			"Customer",
+			filters={"name": self.customer},
+			fields=["customer_group", "territory"],
+			as_list=True,
+		)[0]
+
+		report = execute(filters)
+		rpt_output = report[1]
+		expected_data = {
+			"party_type": "Customer",
+			"advance": 0,
+			"party": self.customer,
+			"invoiced": 200.0,
+			"paid": 0.0,
+			"credit_note": 0.0,
+			"outstanding": 200.0,
+			"range1": 200.0,
+			"range2": 0.0,
+			"range3": 0.0,
+			"range4": 0.0,
+			"range5": 0.0,
+			"total_due": 200.0,
+			"future_amount": 0.0,
+			"sales_person": [],
+			"currency": si.currency,
+			"territory": customer_territory,
+			"customer_group": customer_group,
+		}
+
+		self.assertEqual(len(rpt_output), 1)
+		self.assertDictEqual(rpt_output[0], expected_data)
+
+		# simulate advance payment
+		pe = get_payment_entry(si.doctype, si.name)
+		pe.paid_amount = 50
+		pe.references[0].allocated_amount = 0  # this essitially removes the reference
+		pe.save().submit()
+
+		# update expected data with advance
+		expected_data.update(
+			{
+				"advance": 50.0,
+				"outstanding": 150.0,
+				"range1": 150.0,
+				"total_due": 150.0,
+			}
+		)
+
+		report = execute(filters)
+		rpt_output = report[1]
+		self.assertEqual(len(rpt_output), 1)
+		self.assertDictEqual(rpt_output[0], expected_data)
+
+		# make partial payment
+		pe = get_payment_entry(si.doctype, si.name)
+		pe.paid_amount = 125
+		pe.references[0].allocated_amount = 125
+		pe.save().submit()
+
+		# update expected data after advance and partial payment
+		expected_data.update(
+			{"advance": 50.0, "paid": 125.0, "outstanding": 25.0, "range1": 25.0, "total_due": 25.0}
+		)
+
+		report = execute(filters)
+		rpt_output = report[1]
+		self.assertEqual(len(rpt_output), 1)
+		self.assertDictEqual(rpt_output[0], expected_data)
+
+	@change_settings("Selling Settings", {"cust_master_name": "Naming Series"})
+	def test_02_various_filters_and_output(self):
+		filters = {
+			"company": self.company,
+			"customer": self.customer,
+			"posting_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+		}
+
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debit_to,
+			posting_date=today(),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=200,
+			price_list_rate=200,
+		)
+		# make partial payment
+		pe = get_payment_entry(si.doctype, si.name)
+		pe.paid_amount = 150
+		pe.references[0].allocated_amount = 150
+		pe.save().submit()
+
+		customer_group, customer_territory = frappe.db.get_all(
+			"Customer",
+			filters={"name": self.customer},
+			fields=["customer_group", "territory"],
+			as_list=True,
+		)[0]
+
+		report = execute(filters)
+		rpt_output = report[1]
+		expected_data = {
+			"party_type": "Customer",
+			"advance": 0,
+			"party": self.customer,
+			"party_name": self.customer,
+			"invoiced": 200.0,
+			"paid": 150.0,
+			"credit_note": 0.0,
+			"outstanding": 50.0,
+			"range1": 50.0,
+			"range2": 0.0,
+			"range3": 0.0,
+			"range4": 0.0,
+			"range5": 0.0,
+			"total_due": 50.0,
+			"future_amount": 0.0,
+			"sales_person": [],
+			"currency": si.currency,
+			"territory": customer_territory,
+			"customer_group": customer_group,
+		}
+
+		self.assertEqual(len(rpt_output), 1)
+		self.assertDictEqual(rpt_output[0], expected_data)
+
+		# with gl balance filter
+		filters.update({"show_gl_balance": True})
+		expected_data.update({"gl_balance": 50.0, "diff": 0.0})
+		report = execute(filters)
+		rpt_output = report[1]
+		self.assertEqual(len(rpt_output), 1)
+		self.assertDictEqual(rpt_output[0], expected_data)
+
+		# with gl balance and future payments filter
+		filters.update({"show_future_payments": True})
+		expected_data.update({"remaining_balance": 50.0})
+		report = execute(filters)
+		rpt_output = report[1]
+		self.assertEqual(len(rpt_output), 1)
+		self.assertDictEqual(rpt_output[0], expected_data)
+
+		# invoice fully paid
+		pe = get_payment_entry(si.doctype, si.name).save().submit()
+		report = execute(filters)
+		rpt_output = report[1]
+		self.assertEqual(len(rpt_output), 0)

erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py

@@ -58,6 +58,9 @@ def get_data(filters):
 
 
 def get_asset_categories(filters):
+	condition = ""
+	if filters.get("asset_category"):
+		condition += " and asset_category = %(asset_category)s"
 	return frappe.db.sql(
 		"""
 		SELECT asset_category,
@@ -98,15 +101,25 @@ def get_asset_categories(filters):
 								0
 						   end), 0) as cost_of_scrapped_asset
 		from `tabAsset`
-		where docstatus=1 and company=%(company)s and purchase_date <= %(to_date)s
+		where docstatus=1 and company=%(company)s and purchase_date <= %(to_date)s {}
 		group by asset_category
-	""",
-		{"to_date": filters.to_date, "from_date": filters.from_date, "company": filters.company},
+	""".format(
+			condition
+		),
+		{
+			"to_date": filters.to_date,
+			"from_date": filters.from_date,
+			"company": filters.company,
+			"asset_category": filters.get("asset_category"),
+		},
 		as_dict=1,
 	)
 
 
 def get_assets(filters):
+	condition = ""
+	if filters.get("asset_category"):
+		condition = " and a.asset_category = '{}'".format(filters.get("asset_category"))
 	return frappe.db.sql(
 		"""
 		SELECT results.asset_category,
@@ -138,7 +151,7 @@ def get_assets(filters):
 				aca.parent = a.asset_category and aca.company_name = %(company)s
 			join `tabCompany` company on
 				company.name = %(company)s
-			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s and gle.debit != 0 and gle.is_cancelled = 0 and gle.account = ifnull(aca.depreciation_expense_account, company.depreciation_expense_account)
+			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s and gle.debit != 0 and gle.is_cancelled = 0 and gle.account = ifnull(aca.depreciation_expense_account, company.depreciation_expense_account) {0}
 			group by a.asset_category
 			union
 			SELECT a.asset_category,
@@ -154,10 +167,12 @@ def get_assets(filters):
 							  end), 0) as depreciation_eliminated_during_the_period,
 				   0 as depreciation_amount_during_the_period
 			from `tabAsset` a
-			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s
+			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s {0}
 			group by a.asset_category) as results
 		group by results.asset_category
-		""",
+		""".format(
+			condition
+		),
 		{"to_date": filters.to_date, "from_date": filters.from_date, "company": filters.company},
 		as_dict=1,
 	)

erpnext/accounts/report/balance_sheet/balance_sheet.js

@@ -15,7 +15,6 @@ frappe.require("assets/erpnext/js/financial_statements.js", function () {
 		fieldtype: "Check",
 		default: 1,
 	});
-	console.log(frappe.query_reports["Balance Sheet"]["filters"]);
 
 	frappe.query_reports["Balance Sheet"]["filters"].push({
 		fieldname: "include_default_book_entries",

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py

@@ -744,13 +744,18 @@ def get_additional_conditions(from_date, ignore_closing_entries, filters, d):
 	if from_date:
 		additional_conditions.append(gle.posting_date >= from_date)
 
-	finance_book = filters.get("finance_book")
-	company_fb = frappe.get_cached_value("Company", d.name, "default_finance_book")
+	finance_books = []
+	finance_books.append("")
+	if filter_fb := filters.get("finance_book"):
+		finance_books.append(filter_fb)
 
 	if filters.get("include_default_book_entries"):
-		additional_conditions.append((gle.finance_book.isin([finance_book, company_fb, "", None])))
+		if company_fb := frappe.get_cached_value("Company", d.name, "default_finance_book"):
+			finance_books.append(company_fb)
+
+		additional_conditions.append((gle.finance_book.isin(finance_books)) | gle.finance_book.isnull())
 	else:
-		additional_conditions.append((gle.finance_book.isin([finance_book, "", None])))
+		additional_conditions.append((gle.finance_book.isin(finance_books)) | gle.finance_book.isnull())
 
 	return additional_conditions
 

erpnext/accounts/report/deferred_revenue_and_expense/test_deferred_revenue_and_expense.py

@@ -81,7 +81,7 @@ class TestDeferredRevenueAndExpense(FrappeTestCase, AccountsTestMixin):
 		self.create_item("_Test Internet Subscription", 0, self.warehouse, self.company)
 		item = frappe.get_doc("Item", self.item)
 		item.enable_deferred_revenue = 1
-		item.deferred_revenue_account = self.deferred_revenue_account
+		item.item_defaults[0].deferred_revenue_account = self.deferred_revenue_account
 		item.no_of_months = 3
 		item.save()
 
@@ -150,7 +150,7 @@ class TestDeferredRevenueAndExpense(FrappeTestCase, AccountsTestMixin):
 		self.create_item("_Test Office Desk", 0, self.warehouse, self.company)
 		item = frappe.get_doc("Item", self.item)
 		item.enable_deferred_expense = 1
-		item.deferred_expense_account = self.deferred_expense_account
+		item.item_defaults[0].deferred_expense_account = self.deferred_expense_account
 		item.no_of_months_exp = 3
 		item.save()
 

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -279,20 +279,19 @@ def get_conditions(filters):
 	if match_conditions:
 		conditions.append(match_conditions)
 
-	if filters.get("include_dimensions"):
-		accounting_dimensions = get_accounting_dimensions(as_list=False)
+	accounting_dimensions = get_accounting_dimensions(as_list=False)
 
-		if accounting_dimensions:
-			for dimension in accounting_dimensions:
-				if not dimension.disabled:
-					if filters.get(dimension.fieldname):
-						if frappe.get_cached_value("DocType", dimension.document_type, "is_tree"):
-							filters[dimension.fieldname] = get_dimension_with_children(
-								dimension.document_type, filters.get(dimension.fieldname)
-							)
-							conditions.append("{0} in %({0})s".format(dimension.fieldname))
-						else:
-							conditions.append("{0} in %({0})s".format(dimension.fieldname))
+	if accounting_dimensions:
+		for dimension in accounting_dimensions:
+			if not dimension.disabled:
+				if filters.get(dimension.fieldname):
+					if frappe.get_cached_value("DocType", dimension.document_type, "is_tree"):
+						filters[dimension.fieldname] = get_dimension_with_children(
+							dimension.document_type, filters.get(dimension.fieldname)
+						)
+						conditions.append("{0} in %({0})s".format(dimension.fieldname))
+					else:
+						conditions.append("{0} in %({0})s".format(dimension.fieldname))
 
 	return "and {}".format(" and ".join(conditions)) if conditions else ""
 
@@ -435,6 +434,7 @@ def get_accountwise_gle(filters, accounting_dimensions, gl_entries, gle_map):
 
 	for gle in gl_entries:
 		group_by_value = gle.get(group_by)
+		gle.voucher_type = _(gle.voucher_type)
 
 		if gle.posting_date < from_date or (cstr(gle.is_opening) == "Yes" and not show_opening_entries):
 			if not group_by_voucher_consolidated:

erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.js

@@ -23,6 +23,12 @@ frappe.query_reports["Item-wise Purchase Register"] = {
 			"fieldtype": "Link",
 			"options": "Item",
 		},
+		{
+			"fieldname": "item_group",
+			"label": __("Item Group"),
+			"fieldtype": "Link",
+			"options": "Item Group",
+		},
 		{
 			"fieldname":"supplier",
 			"label": __("Supplier"),

erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py

@@ -287,12 +287,13 @@ def get_conditions(filters):
 	conditions = ""
 
 	for opts in (
-		("company", " and company=%(company)s"),
+		("company", " and `tabPurchase Invoice`.company=%(company)s"),
 		("supplier", " and `tabPurchase Invoice`.supplier = %(supplier)s"),
 		("item_code", " and `tabPurchase Invoice Item`.item_code = %(item_code)s"),
 		("from_date", " and `tabPurchase Invoice`.posting_date>=%(from_date)s"),
 		("to_date", " and `tabPurchase Invoice`.posting_date<=%(to_date)s"),
 		("mode_of_payment", " and ifnull(mode_of_payment, '') = %(mode_of_payment)s"),
+		("item_group", " and ifnull(`tabPurchase Invoice Item`.item_group, '') = %(item_group)s"),
 	):
 		if filters.get(opts[0]):
 			conditions += opts[1]

erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py

@@ -332,7 +332,7 @@ def get_conditions(filters, additional_conditions=None):
 	conditions = ""
 
 	for opts in (
-		("company", " and company=%(company)s"),
+		("company", " and `tabSales Invoice`.company=%(company)s"),
 		("customer", " and `tabSales Invoice`.customer = %(customer)s"),
 		("item_code", " and `tabSales Invoice Item`.item_code = %(item_code)s"),
 		("from_date", " and `tabSales Invoice`.posting_date>=%(from_date)s"),

erpnext/accounts/report/purchase_register/purchase_register.py

@@ -10,8 +10,8 @@ from pypika import Order
 
 from erpnext.accounts.party import get_party_account
 from erpnext.accounts.report.utils import (
+	apply_common_conditions,
 	get_advance_taxes_and_charges,
-	get_conditions,
 	get_journal_entries,
 	get_opening_row,
 	get_party_details,
@@ -378,11 +378,8 @@ def get_account_columns(invoice_list, include_payments):
 
 def get_invoices(filters, additional_query_columns):
 	pi = frappe.qb.DocType("Purchase Invoice")
-	invoice_item = frappe.qb.DocType("Purchase Invoice Item")
 	query = (
 		frappe.qb.from_(pi)
-		.inner_join(invoice_item)
-		.on(pi.name == invoice_item.parent)
 		.select(
 			ConstantColumn("Purchase Invoice").as_("doctype"),
 			pi.name,
@@ -396,29 +393,46 @@ def get_invoices(filters, additional_query_columns):
 			pi.remarks,
 			pi.base_net_total,
 			pi.base_grand_total,
+			pi.base_rounded_total,
 			pi.outstanding_amount,
 			pi.mode_of_payment,
 		)
 		.where((pi.docstatus == 1))
 		.orderby(pi.posting_date, pi.name, order=Order.desc)
 	)
+
 	if additional_query_columns:
 		for col in additional_query_columns:
 			query = query.select(col)
+
 	if filters.get("supplier"):
 		query = query.where(pi.supplier == filters.supplier)
-	query = get_conditions(
+
+	query = get_conditions(filters, query, "Purchase Invoice")
+
+	query = apply_common_conditions(
 		filters, query, doctype="Purchase Invoice", child_doctype="Purchase Invoice Item"
 	)
+
 	if filters.get("include_payments"):
 		party_account = get_party_account(
 			"Supplier", filters.get("supplier"), filters.get("company"), include_advance=True
 		)
 		query = query.where(pi.credit_to.isin(party_account))
+
 	invoices = query.run(as_dict=True)
 	return invoices
 
 
+def get_conditions(filters, query, doctype):
+	parent_doc = frappe.qb.DocType(doctype)
+
+	if filters.get("mode_of_payment"):
+		query = query.where(parent_doc.mode_of_payment == filters.mode_of_payment)
+
+	return query
+
+
 def get_payments(filters):
 	args = frappe._dict(
 		account="credit_to",

erpnext/accounts/report/sales_register/sales_register.py

@@ -11,8 +11,8 @@ from pypika import Order
 
 from erpnext.accounts.party import get_party_account
 from erpnext.accounts.report.utils import (
+	apply_common_conditions,
 	get_advance_taxes_and_charges,
-	get_conditions,
 	get_journal_entries,
 	get_opening_row,
 	get_party_details,
@@ -38,7 +38,7 @@ def _execute(filters, additional_table_columns=None):
 	if filters.get("include_payments"):
 		invoice_list += get_payments(filters)
 
-	columns, income_accounts, tax_accounts, unrealized_profit_loss_accounts = get_columns(
+	columns, income_accounts, unrealized_profit_loss_accounts, tax_accounts = get_columns(
 		invoice_list, additional_table_columns, include_payments
 	)
 
@@ -415,14 +415,8 @@ def get_account_columns(invoice_list, include_payments):
 
 def get_invoices(filters, additional_query_columns):
 	si = frappe.qb.DocType("Sales Invoice")
-	invoice_item = frappe.qb.DocType("Sales Invoice Item")
-	invoice_payment = frappe.qb.DocType("Sales Invoice Payment")
 	query = (
 		frappe.qb.from_(si)
-		.inner_join(invoice_item)
-		.on(si.name == invoice_item.parent)
-		.left_join(invoice_payment)
-		.on(si.name == invoice_payment.parent)
 		.select(
 			ConstantColumn("Sales Invoice").as_("doctype"),
 			si.name,
@@ -447,18 +441,36 @@ def get_invoices(filters, additional_query_columns):
 		.where((si.docstatus == 1))
 		.orderby(si.posting_date, si.name, order=Order.desc)
 	)
+
 	if additional_query_columns:
 		for col in additional_query_columns:
 			query = query.select(col)
+
 	if filters.get("customer"):
 		query = query.where(si.customer == filters.customer)
-	query = get_conditions(
+
+	query = get_conditions(filters, query, "Sales Invoice")
+	query = apply_common_conditions(
 		filters, query, doctype="Sales Invoice", child_doctype="Sales Invoice Item"
 	)
+
 	invoices = query.run(as_dict=True)
 	return invoices
 
 
+def get_conditions(filters, query, doctype):
+	parent_doc = frappe.qb.DocType(doctype)
+	if filters.get("owner"):
+		query = query.where(parent_doc.owner == filters.owner)
+
+	if filters.get("mode_of_payment"):
+		payment_doc = frappe.qb.DocType("Sales Invoice Payment")
+		query = query.inner_join(payment_doc).on(parent_doc.name == payment_doc.parent)
+		query = query.where(payment_doc.mode_of_payment == filters.mode_of_payment).distinct()
+
+	return query
+
+
 def get_payments(filters):
 	args = frappe._dict(
 		account="debit_to",

erpnext/accounts/report/tax_withholding_details/tax_withholding_details.py

@@ -257,7 +257,7 @@ def get_tds_docs(filters):
 	}
 
 	party = frappe.get_all(filters.get("party_type"), pluck="name")
-	query_filters.update({"against": ("in", party)})
+	or_filters.update({"against": ("in", party), "voucher_type": "Journal Entry"})
 
 	if filters.get("party"):
 		del query_filters["account"]
@@ -294,7 +294,7 @@ def get_tds_docs(filters):
 
 	if journal_entries:
 		journal_entry_party_map = get_journal_entry_party_map(journal_entries)
-		get_doc_info(journal_entries, "Journal Entry", tax_category_map)
+		get_doc_info(journal_entries, "Journal Entry", tax_category_map, net_total_map)
 
 	return (
 		tds_documents,
@@ -309,7 +309,11 @@ def get_journal_entry_party_map(journal_entries):
 	journal_entry_party_map = {}
 	for d in frappe.db.get_all(
 		"Journal Entry Account",
-		{"parent": ("in", journal_entries), "party_type": "Supplier", "party": ("is", "set")},
+		{
+			"parent": ("in", journal_entries),
+			"party_type": ("in", ("Supplier", "Customer")),
+			"party": ("is", "set"),
+		},
 		["parent", "party"],
 	):
 		if d.parent not in journal_entry_party_map:
@@ -320,41 +324,39 @@ def get_journal_entry_party_map(journal_entries):
 
 
 def get_doc_info(vouchers, doctype, tax_category_map, net_total_map=None):
-	if doctype == "Purchase Invoice":
-		fields = [
-			"name",
+	common_fields = ["name"]
+	fields_dict = {
+		"Purchase Invoice": [
 			"tax_withholding_category",
 			"base_tax_withholding_net_total",
 			"grand_total",
 			"base_total",
-		]
-	elif doctype == "Sales Invoice":
-		fields = ["name", "base_net_total", "grand_total", "base_total"]
-	elif doctype == "Payment Entry":
-		fields = [
-			"name",
+		],
+		"Sales Invoice": ["base_net_total", "grand_total", "base_total"],
+		"Payment Entry": [
 			"tax_withholding_category",
 			"paid_amount",
 			"paid_amount_after_tax",
 			"base_paid_amount",
-		]
-	else:
-		fields = ["name", "tax_withholding_category"]
+		],
+		"Journal Entry": ["tax_withholding_category", "total_amount"],
+	}
 
-	entries = frappe.get_all(doctype, filters={"name": ("in", vouchers)}, fields=fields)
+	entries = frappe.get_all(
+		doctype, filters={"name": ("in", vouchers)}, fields=common_fields + fields_dict[doctype]
+	)
 
 	for entry in entries:
 		tax_category_map.update({entry.name: entry.tax_withholding_category})
 		if doctype == "Purchase Invoice":
-			net_total_map.update(
-				{entry.name: [entry.base_tax_withholding_net_total, entry.grand_total, entry.base_total]}
-			)
+			value = [entry.base_tax_withholding_net_total, entry.grand_total, entry.base_total]
 		elif doctype == "Sales Invoice":
-			net_total_map.update({entry.name: [entry.base_net_total, entry.grand_total, entry.base_total]})
+			value = [entry.base_net_total, entry.grand_total, entry.base_total]
 		elif doctype == "Payment Entry":
-			net_total_map.update(
-				{entry.name: [entry.paid_amount, entry.paid_amount_after_tax, entry.base_paid_amount]}
-			)
+			value = [entry.paid_amount, entry.paid_amount_after_tax, entry.base_paid_amount]
+		else:
+			value = [entry.total_amount] * 3
+		net_total_map.update({entry.name: value})
 
 
 def get_tax_rate_map(filters):