style: Pre-commit

- Actions panel = actions panel manager + create tab + match tab +details tab
- Better file names to reduce long name length

.github/helper/install.sh

@@ -4,9 +4,7 @@ set -e
 
 cd ~ || exit
 
-sudo apt update
-sudo apt remove mysql-server mysql-client
-sudo apt install libcups2-dev redis-server mariadb-client-10.6
+sudo apt update && sudo apt install redis-server libcups2-dev
 
 pip install frappe-bench
 
@@ -27,14 +25,14 @@ fi
 
 
 if [ "$DB" == "mariadb" ];then
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL character_set_server = 'utf8mb4'"
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL collation_server = 'utf8mb4_unicode_ci'"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL character_set_server = 'utf8mb4'"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL collation_server = 'utf8mb4_unicode_ci'"
 
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE USER 'test_frappe'@'localhost' IDENTIFIED BY 'test_frappe'"
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE DATABASE test_frappe"
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "GRANT ALL PRIVILEGES ON \`test_frappe\`.* TO 'test_frappe'@'localhost'"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE USER 'test_frappe'@'localhost' IDENTIFIED BY 'test_frappe'"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE DATABASE test_frappe"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "GRANT ALL PRIVILEGES ON \`test_frappe\`.* TO 'test_frappe'@'localhost'"
 
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "FLUSH PRIVILEGES"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "FLUSH PRIVILEGES"
 fi
 
 if [ "$DB" == "postgres" ];then
@@ -70,6 +68,6 @@ if [ "$TYPE" == "server" ]; then bench setup requirements --dev; fi
 
 wait $wkpid
 
-bench start &>> ~/frappe-bench/bench_start.log &
+bench start &> bench_run_logs.txt &
 CI=Yes bench build --app frappe &
 bench --site test_site reinstall --yes

.github/helper/translation.py

@@ -0,0 +1,60 @@
+import re
+import sys
+
+errors_encounter = 0
+pattern = re.compile(r"_\(([\"']{,3})(?P<message>((?!\1).)*)\1(\s*,\s*context\s*=\s*([\"'])(?P<py_context>((?!\5).)*)\5)*(\s*,(\s*?.*?\n*?)*(,\s*([\"'])(?P<js_context>((?!\11).)*)\11)*)*\)")
+words_pattern = re.compile(r"_{1,2}\([\"'`]{1,3}.*?[a-zA-Z]")
+start_pattern = re.compile(r"_{1,2}\([f\"'`]{1,3}")
+f_string_pattern = re.compile(r"_\(f[\"']")
+starts_with_f_pattern = re.compile(r"_\(f")
+
+# skip first argument
+files = sys.argv[1:]
+files_to_scan = [_file for _file in files if _file.endswith(('.py', '.js'))]
+
+for _file in files_to_scan:
+	with open(_file, 'r') as f:
+		print(f'Checking: {_file}')
+		file_lines = f.readlines()
+		for line_number, line in enumerate(file_lines, 1):
+			if 'frappe-lint: disable-translate' in line:
+				continue
+
+			start_matches = start_pattern.search(line)
+			if start_matches:
+				starts_with_f = starts_with_f_pattern.search(line)
+
+				if starts_with_f:
+					has_f_string = f_string_pattern.search(line)
+					if has_f_string:
+						errors_encounter += 1
+						print(f'\nF-strings are not supported for translations at line number {line_number}\n{line.strip()[:100]}')
+						continue
+					else:
+						continue
+
+				match = pattern.search(line)
+				error_found = False
+
+				if not match and line.endswith((',\n', '[\n')):
+					# concat remaining text to validate multiline pattern
+					line = "".join(file_lines[line_number - 1:])
+					line = line[start_matches.start() + 1:]
+					match = pattern.match(line)
+
+				if not match:
+					error_found = True
+					print(f'\nTranslation syntax error at line number {line_number}\n{line.strip()[:100]}')
+
+				if not error_found and not words_pattern.search(line):
+					error_found = True
+					print(f'\nTranslation is useless because it has no words at line number {line_number}\n{line.strip()[:100]}')
+
+				if error_found:
+					errors_encounter += 1
+
+if errors_encounter > 0:
+	print('\nVisit "https://frappeframework.com/docs/user/en/translations" to learn about valid translation strings.')
+	sys.exit(1)
+else:
+	print('\nGood To Go!')

.github/workflows/backport.yml

@@ -0,0 +1,26 @@
+name: Backport
+on:
+  pull_request_target:
+    types:
+      - closed
+      - labeled
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - name: Checkout Actions
+        uses: actions/checkout@v2
+        with:
+          repository: "frappe/backport"
+          path: ./actions
+          ref: develop
+      - name: Install Actions
+        run: npm install --production --prefix ./actions
+      - name: Run backport
+        uses: ./actions/backport
+        with:
+          token: ${{secrets.BACKPORT_BOT_TOKEN}}
+          labelsToAdd: "backport"
+          title: "{{originalTitle}}"

.github/workflows/initiate_release.yml

@@ -0,0 +1,52 @@
+# This workflow is agnostic to branches. Only maintain on develop branch.
+# To add/remove versions just modify the matrix.
+
+name: Create weekly release pull requests
+on:
+  schedule:
+    # 9:30 UTC => 3 PM IST Tuesday
+    - cron: "30 9 * * 2"
+  workflow_dispatch:
+
+jobs:
+  stable-release:
+    name: Release
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        version: ["13", "14"]
+
+    steps:
+      - uses: octokit/request-action@v2.x
+        with:
+          route: POST /repos/{owner}/{repo}/pulls
+          owner: frappe
+          repo: erpnext
+          title: |-
+            "chore: release v${{ matrix.version }}"
+          body: "Automated weekly release."
+          base: version-${{ matrix.version }}
+          head: version-${{ matrix.version }}-hotfix
+        env:
+          GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+
+  beta-release:
+    name: Release
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: octokit/request-action@v2.x
+        with:
+          route: POST /repos/{owner}/{repo}/pulls
+          owner: frappe
+          repo: erpnext
+          title: |-
+            "chore: release v15 beta"
+          body: "Automated beta release."
+          base: version-15-beta
+          head: develop
+        env:
+          GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}

.github/workflows/patch.yml

@@ -23,12 +23,12 @@ jobs:
 
     services:
       mysql:
-        image: mariadb:10.6
+        image: mariadb:10.3
         env:
           MARIADB_ROOT_PASSWORD: 'root'
         ports:
           - 3306:3306
-        options: --health-cmd="mariadb-admin ping" --health-interval=5s --health-timeout=2s --health-retries=3
+        options: --health-cmd="mysqladmin ping" --health-interval=5s --health-timeout=2s --health-retries=3
 
     steps:
       - name: Clone
@@ -45,7 +45,9 @@ jobs:
       - name: Setup Python
         uses: "actions/setup-python@v4"
         with:
-          python-version: '3.10'
+          python-version: |
+              3.7
+              3.10
 
       - name: Setup Node
         uses: actions/setup-node@v2
@@ -100,60 +102,40 @@ jobs:
       - name: Run Patch Tests
         run: |
           cd ~/frappe-bench/
-          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
+          wget https://erpnext.com/files/v10-erpnext.sql.gz
+          bench --site test_site --force restore ~/frappe-bench/v10-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"
 
-          function update_to_version() {
-            version=$1
+              git -C "apps/frappe" fetch --depth 1 upstream $branch_name:$branch_name
+              git -C "apps/erpnext" fetch --depth 1 upstream $branch_name:$branch_name
 
-            branch_name="version-$version-hotfix"
-            echo "Updating to v$version"
+              git -C "apps/frappe" checkout -q -f $branch_name
+              git -C "apps/erpnext" checkout -q -f $branch_name
 
-            # 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
+              rm -rf ~/frappe-bench/env
+              bench setup env --python python3.7
+              bench pip install -e ./apps/payments
+              bench pip install -e ./apps/erpnext
 
-            # 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
+          done
 
-            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
+          bench -v setup env --python python3.10
+          bench pip install -e ./apps/payments
           bench pip install -e ./apps/erpnext
-          bench start &>> ~/frappe-bench/bench_start.log &
 
           bench --site test_site migrate
-
-      - 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
+          bench --site test_site install-app payments

.github/workflows/release.yml

@@ -2,23 +2,21 @@ name: Generate Semantic Release
 on:
   push:
     branches:
-      - version-15
+      - version-13
 jobs:
   release:
     name: Release
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Entire Repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
         with:
           fetch-depth: 0
           persist-credentials: false
-
       - name: Setup Node.js
         uses: actions/setup-node@v2
         with:
-          node-version: 20
-
+          node-version: 18
       - name: Setup dependencies
         run: |
           npm install @semantic-release/git @semantic-release/exec --no-save

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

@@ -47,7 +47,7 @@ jobs:
           MARIADB_ROOT_PASSWORD: 'root'
         ports:
           - 3306:3306
-        options: --health-cmd="mariadb-admin ping" --health-interval=5s --health-timeout=2s --health-retries=3
+        options: --health-cmd="mysqladmin ping" --health-interval=5s --health-timeout=2s --health-retries=3
 
     steps:
       - name: Clone
@@ -117,12 +117,32 @@ jobs:
           FRAPPE_BRANCH: ${{ github.event.inputs.branch }}
 
       - name: Run Tests
-        run: 'cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --app erpnext --total-builds 4 --build-number ${{ matrix.container }}'
+        run: 'cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --app erpnext --with-coverage --total-builds 4 --build-number ${{ matrix.container }}'
         env:
           TYPE: server
           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:
+          name: coverage-${{ matrix.container }}
+          path: /home/runner/frappe-bench/sites/coverage.xml
+
+  coverage:
+    name: Coverage Wrap Up
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone
+        uses: actions/checkout@v2
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v3
+
+      - name: Upload coverage data
+        uses: codecov/codecov-action@v2
+        with:
+          name: MariaDB
+          fail_ci_if_error: true
+          verbose: true

.pre-commit-config.yaml

@@ -5,7 +5,7 @@ fail_fast: false
 
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.3.0
+    rev: v4.0.1
     hooks:
       - id: trailing-whitespace
         files: "erpnext.*"
@@ -15,10 +15,6 @@ repos:
         args: ['--branch', 'develop']
       - id: check-merge-conflict
       - id: check-ast
-      - id: check-json
-      - id: check-toml
-      - id: check-yaml
-      - id: debug-statements
 
   - repo: https://github.com/pre-commit/mirrors-eslint
     rev: v8.44.0
@@ -44,7 +40,6 @@ repos:
       - id: flake8
         additional_dependencies: [
           'flake8-bugbear',
-          'flake8-tuple',
         ]
         args: ['--config', '.github/helper/.flake8_strict']
         exclude: ".*setup.py$"

.releaserc

@@ -1,5 +1,5 @@
 {
-	"branches": ["version-15"],
+	"branches": ["version-13"],
 	"plugins": [
 		"@semantic-release/commit-analyzer", {
 			"preset": "angular",
@@ -21,4 +21,4 @@
 		],
 		"@semantic-release/github"
 	]
-}
+}

erpnext/__init__.py

@@ -3,7 +3,7 @@ import inspect
 
 import frappe
 
-__version__ = "15.10.1"
+__version__ = "15.0.0-dev"
 
 
 def get_default_company(user=None):

erpnext/accounts/doctype/account/account.js

@@ -137,6 +137,9 @@ 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,70 +18,7 @@ class BalanceMismatchError(frappe.ValidationError):
 	pass
 
 
-class InvalidAccountMergeError(frappe.ValidationError):
-	pass
-
-
 class Account(NestedSet):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account_currency: DF.Link | None
-		account_name: DF.Data
-		account_number: DF.Data | None
-		account_type: DF.Literal[
-			"",
-			"Accumulated Depreciation",
-			"Asset Received But Not Billed",
-			"Bank",
-			"Cash",
-			"Chargeable",
-			"Capital Work in Progress",
-			"Cost of Goods Sold",
-			"Current Asset",
-			"Current Liability",
-			"Depreciation",
-			"Direct Expense",
-			"Direct Income",
-			"Equity",
-			"Expense Account",
-			"Expenses Included In Asset Valuation",
-			"Expenses Included In Valuation",
-			"Fixed Asset",
-			"Income Account",
-			"Indirect Expense",
-			"Indirect Income",
-			"Liability",
-			"Payable",
-			"Receivable",
-			"Round Off",
-			"Stock",
-			"Stock Adjustment",
-			"Stock Received But Not Billed",
-			"Service Received But Not Billed",
-			"Tax",
-			"Temporary",
-		]
-		balance_must_be: DF.Literal["", "Debit", "Credit"]
-		company: DF.Link
-		disabled: DF.Check
-		freeze_account: DF.Literal["No", "Yes"]
-		include_in_gross: DF.Check
-		is_group: DF.Check
-		lft: DF.Int
-		old_parent: DF.Data | None
-		parent_account: DF.Link
-		report_type: DF.Literal["", "Balance Sheet", "Profit and Loss"]
-		rgt: DF.Int
-		root_type: DF.Literal["", "Asset", "Liability", "Income", "Expense", "Equity"]
-		tax_rate: DF.Float
-	# end: auto-generated types
-
 	nsm_parent_field = "parent_account"
 
 	def on_update(self):
@@ -523,34 +460,25 @@ def update_account_number(name, account_name, account_number=None, from_descenda
 
 
 @frappe.whitelist()
-def merge_account(old, new):
+def merge_account(old, new, is_group, root_type, company):
 	# 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 (
-		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),
+	if (new_account.is_group, new_account.root_type, new_account.company) != (
+		cint(is_group),
+		root_type,
+		company,
 	):
 		throw(
-			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,
+			_(
+				"""Merging is only possible if following properties are same in both records. Is Group, Root Type, Company"""
+			)
 		)
 
-	if old_account.is_group and new_account.parent_account == old:
+	if 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

@@ -0,0 +1,289 @@
+# 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/unverified/at_austria_chart_template.json

@@ -26,7 +26,7 @@
 				"0360 Bauliche Investitionen in fremden (gepachteten) Betriebs- und Geschäftsgebäuden": {"account_type": "Fixed Asset"},
 				"0370 Bauliche Investitionen in fremden (gepachteten) Wohn- und Sozialgebäuden": {"account_type": "Fixed Asset"},
 				"0390 Kumulierte Abschreibungen zu Grundstücken ": {"account_type": "Fixed Asset"},
-				"0400 Maschinen und Geräte ": {"account_type": "Fixed Asset"},
+				"0400 Maschinen und Geräte ": {"account_type": "Fixed Asset"},				
 				"0500 Maschinenwerkzeuge ": {"account_type": "Fixed Asset"},
 				"0510 Allgemeine Werkzeuge und Handwerkzeuge ": {"account_type": "Fixed Asset"},
 				"0520 Prototypen, Formen, Modelle ": {"account_type": "Fixed Asset"},
@@ -65,41 +65,42 @@
 				"0980 Geleistete Anzahlungen auf Finanzanlagen ": {"account_type": "Fixed Asset"},
 				"0990 Kumulierte Abschreibungen zu Finanzanlagen ": {"account_type": "Fixed Asset"},
             "root_type": "Asset"
-        },
+        },    
         "Klasse 1 Aktiva: Vorr\u00e4te": {
             "1000 Bezugsverrechnung": {"account_type": "Stock"},
             "1100 Rohstoffe": {"account_type": "Stock"},
             "1200 Bezogene Teile": {"account_type": "Stock"},
             "1300 Hilfsstoffe": {"account_type": "Stock"},
             "1350 Betriebsstoffe": {"account_type": "Stock"},
-            "1360 Vorrat Energietraeger": {"account_type": "Stock"},
+            "1360 Vorrat Energietraeger": {"account_type": "Stock"},            
             "1400 Unfertige Erzeugnisse": {"account_type": "Stock"},
             "1500 Fertige Erzeugnisse": {"account_type": "Stock"},
             "1600 Handelswarenvorrat": {"account_type": "Stock Received But Not Billed"},
             "1700 Noch nicht abrechenbare Leistungen": {"account_type": "Stock"},
+            "1900 Wertberichtigungen": {"account_type": "Stock"},
             "1800 Geleistete Anzahlungen": {"account_type": "Stock"},
             "1900 Wertberichtigungen": {"account_type": "Stock"},
             "root_type": "Asset"
-        },
+        },    
         "Klasse 3 Passiva: Verbindlichkeiten": {
             "3000 Allgemeine Verbindlichkeiten (Schuld)": {"account_type": "Payable"},
             "3010 R\u00fcckstellungen f\u00fcr Pensionen": {"account_type": "Payable"},
             "3020 Steuerr\u00fcckstellungen": {"account_type": "Tax"},
-            "3041 Sonstige R\u00fcckstellungen": {"account_type": "Payable"},
+            "3041 Sonstige R\u00fcckstellungen": {"account_type": "Payable"},            
             "3110 Verbindlichkeiten gegen\u00fcber Bank": {"account_type": "Payable"},
             "3150 Verbindlichkeiten Darlehen": {"account_type": "Payable"},
-            "3185 Verbindlichkeiten Kreditkarte": {"account_type": "Payable"},
+            "3185 Verbindlichkeiten Kreditkarte": {"account_type": "Payable"},            
             "3380 Verbindlichkeiten aus der Annahme gezogener Wechsel u. d. Ausstellungen eigener Wechsel": {
                 "account_type": "Payable"
             },
             "3400 Verbindlichkeiten gegen\u00fc. verb. Untern., Verbindl. gegen\u00fc. Untern., mit denen eine Beteiligungsverh\u00e4lnis besteht": {},
             "3460 Verbindlichkeiten gegenueber Gesellschaftern": {"account_type": "Payable"},
             "3470 Einlagen stiller Gesellschafter": {"account_type": "Payable"},
-            "3585 Verbindlichkeiten Lohnsteuer": {"account_type": "Tax"},
-            "3590 Verbindlichkeiten Kommunalabgaben": {"account_type": "Tax"},
-            "3595 Verbindlichkeiten Dienstgeberbeitrag": {"account_type": "Tax"},
+            "3585 Verbindlichkeiten Lohnsteuer": {"account_type": "Tax"},             
+            "3590 Verbindlichkeiten Kommunalabgaben": {"account_type": "Tax"},  
+            "3595 Verbindlichkeiten Dienstgeberbeitrag": {"account_type": "Tax"},                       
             "3600 Verbindlichkeiten Sozialversicherung": {"account_type": "Payable"},
-            "3640 Verbindlichkeiten Loehne und Gehaelter": {"account_type": "Payable"},
+            "3640 Verbindlichkeiten Loehne und Gehaelter": {"account_type": "Payable"},            
             "3700 Sonstige Verbindlichkeiten": {"account_type": "Payable"},
             "3900 Passive Rechnungsabgrenzungsposten": {"account_type": "Payable"},
             "3100 Anleihen (einschlie\u00dflich konvertibler)": {"account_type": "Payable"},
@@ -118,13 +119,13 @@
             },
             "3515 Umsatzsteuer Inland 10%": {
                 "account_type": "Tax"
-            },
+            },            
             "3520 Umsatzsteuer aus i.g. Erwerb 20%": {
                 "account_type": "Tax"
             },
             "3525 Umsatzsteuer aus i.g. Erwerb 10%": {
                 "account_type": "Tax"
-            },
+            },            
             "3560 Umsatzsteuer-Evidenzkonto f\u00fcr erhaltene Anzahlungen auf Bestellungen": {},
             "3360 Verbindlichkeiten aus Lieferungen u. Leistungen EU": {
                 "account_type": "Payable"
@@ -140,7 +141,7 @@
                 "account_type": "Tax"
             },
             "root_type": "Liability"
-        },
+        },      
         "Klasse 2 Aktiva: Umlaufverm\u00f6gen, Rechnungsabgrenzungen": {
             "2030 Forderungen aus Lieferungen und Leistungen Inland (0% USt, umsatzsteuerfrei)": {
                 "account_type": "Receivable"
@@ -153,7 +154,7 @@
             },
             "2040 Forderungen aus Lieferungen und Leistungen Inland (sonstiger USt-Satz)": {
                 "account_type": "Receivable"
-            },
+            },                                    
             "2100 Forderungen aus Lieferungen und Leistungen EU": {
                 "account_type": "Receivable"
             },
@@ -191,7 +192,7 @@
                 "account_type": "Receivable"
             },
             "2570 Einfuhrumsatzsteuer (bezahlt)": {"account_type": "Tax"},
-
+            
             "2460 Eingeforderte aber noch nicht eingezahlte Einlagen": {
                 "account_type": "Receivable"
             },
@@ -242,10 +243,10 @@
             },
             "2800 Guthaben bei Bank": {
                 "account_type": "Bank"
-            },
+            },  
             "2801 Guthaben bei Bank - Sparkonto": {
                 "account_type": "Bank"
-            },
+            },                      
             "2810 Guthaben bei Paypal": {
                 "account_type": "Bank"
             },
@@ -263,19 +264,19 @@
             },
             "2895 Schwebende Geldbewegugen": {
                 "account_type": "Bank"
-            },
+            },            
             "2513 Vorsteuer Inland 5%": {
                 "account_type": "Tax"
             },
             "2515 Vorsteuer Inland 20%": {
                 "account_type": "Tax"
-            },
+            },                        
             "2520 Vorsteuer aus innergemeinschaftlichem Erwerb 10%": {
                 "account_type": "Tax"
             },
             "2525 Vorsteuer aus innergemeinschaftlichem Erwerb 20%": {
                 "account_type": "Tax"
-            },
+            },            
             "2530 Vorsteuer \u00a719/Art 19 ( reverse charge ) ": {
                 "account_type": "Tax"
             },
@@ -285,16 +286,16 @@
             "root_type": "Asset"
         },
           "Klasse 4: Betriebliche Erträge": {
-            "4000 Erlöse 20 %": {"account_type": "Income Account"},
-            "4020 Erl\u00f6se 0 % steuerbefreit": {"account_type": "Income Account"},
+            "4000 Erlöse 20 %": {"account_type": "Income Account"},          
+            "4020 Erl\u00f6se 0 % steuerbefreit": {"account_type": "Income Account"},            
             "4010 Erl\u00f6se 10 %": {"account_type": "Income Account"},
-            "4030 Erl\u00f6se 13 %": {"account_type": "Income Account"},
-            "4040 Erl\u00f6se 0 % innergemeinschaftliche Lieferungen": {"account_type": "Income Account"},
-            "4400 Erl\u00f6sreduktion 0 % steuerbefreit": {"account_type": "Expense Account"},
+            "4030 Erl\u00f6se 13 %": {"account_type": "Income Account"},            
+            "4040 Erl\u00f6se 0 % innergemeinschaftliche Lieferungen": {"account_type": "Income Account"},      
+            "4400 Erl\u00f6sreduktion 0 % steuerbefreit": {"account_type": "Expense Account"},            
             "4410 Erl\u00f6sreduktion 10 %": {"account_type": "Expense Account"},
             "4420 Erl\u00f6sreduktion 20 %": {"account_type": "Expense Account"},
-            "4430 Erl\u00f6sreduktion 13 %": {"account_type": "Expense Account"},
-            "4440 Erl\u00f6sreduktion 0 % innergemeinschaftliche Lieferungen": {"account_type": "Expense Account"},
+            "4430 Erl\u00f6sreduktion 13 %": {"account_type": "Expense Account"},            
+            "4440 Erl\u00f6sreduktion 0 % innergemeinschaftliche Lieferungen": {"account_type": "Expense Account"}, 
             "4500 Ver\u00e4nderungen des Bestandes an fertigen und unfertigen Erzeugn. sowie an noch nicht abrechenbaren Leistungen": {"account_type": "Income Account"},
             "4580 Aktivierte Eigenleistungen": {"account_type": "Income Account"},
             "4600 Erl\u00f6se aus dem Abgang vom Anlageverm\u00f6gen, ausgen. Finanzanlagen": {"account_type": "Income Account"},
@@ -303,15 +304,15 @@
             "4700 Ertr\u00e4ge aus der Aufl\u00f6sung von R\u00fcckstellungen": {"account_type": "Income Account"},
             "4800 \u00dcbrige betriebliche Ertr\u00e4ge": {"account_type": "Income Account"},
             "root_type": "Income"
-        },
+        },        
         "Klasse 5: Aufwand f\u00fcr Material und Leistungen": {
-            "5000 Einkauf Partnerleistungen": {"account_type": "Cost of Goods Sold"},
+            "5000 Einkauf Partnerleistungen": {"account_type": "Cost of Goods Sold"},        
             "5100 Verbrauch an Rohstoffen": {"account_type": "Cost of Goods Sold"},
             "5200 Verbrauch von bezogenen Fertig- und Einzelteilen": {"account_type": "Cost of Goods Sold"},
             "5300 Verbrauch von Hilfsstoffen": {"account_type": "Cost of Goods Sold"},
             "5340 Verbrauch Verpackungsmaterial": {"account_type": "Cost of Goods Sold"},
             "5470 Verbrauch von Kleinmaterial": {"account_type": "Cost of Goods Sold"},
-            "5450 Verbrauch von Reinigungsmaterial": {"account_type": "Cost of Goods Sold"},
+            "5450 Verbrauch von Reinigungsmaterial": {"account_type": "Cost of Goods Sold"},                                  
             "5400 Verbrauch von Betriebsstoffen": {"account_type": "Cost of Goods Sold"},
             "5500 Verbrauch von Werkzeugen und anderen Erzeugungshilfsmittel": {"account_type": "Cost of Goods Sold"},
             "5600 Verbrauch von Brenn- und Treibstoffen, Energie und Wasser": {"account_type": "Cost of Goods Sold"},
@@ -339,7 +340,7 @@
             "6700 Sonstige Sozialaufwendungen": {"account_type": "Payable"},
             "6900 Aufwandsstellenrechnung Personal": {"account_type": "Payable"},
             "root_type": "Expense"
-        },
+        },       
          "Klasse 7: Abschreibungen und sonstige betriebliche Aufwendungen": {
             "7010 Abschreibungen auf das Anlageverm\u00f6gen (ausgenommen Finanzanlagen)": {"account_type": "Depreciation"},
             "7100 Sonstige Steuern und Geb\u00fchren": {"account_type": "Tax"},
@@ -348,7 +349,7 @@
             "7310 Fahrrad - Aufwand": {"account_type": "Expense Account"},
             "7320 Kfz - Aufwand": {"account_type": "Expense Account"},
             "7330 LKW - Aufwand": {"account_type": "Expense Account"},
-            "7340 Lastenrad - Aufwand": {"account_type": "Expense Account"},
+            "7340 Lastenrad - Aufwand": {"account_type": "Expense Account"},            
             "7350 Reise- und Fahraufwand": {"account_type": "Expense Account"},
             "7360 Tag- und N\u00e4chtigungsgelder": {"account_type": "Expense Account"},
             "7380 Nachrichtenaufwand": {"account_type": "Expense Account"},
@@ -408,7 +409,7 @@
             "8990 Gewinnabfuhr bzw. Verlust\u00fcberrechnung aus Ergebnisabf\u00fchrungsvertr\u00e4gen": {"account_type": "Expense Account"},
             "8350 nicht ausgenutzte Lieferantenskonti": {"account_type": "Expense Account"},
             "root_type": "Income"
-        },
+        },       
         "Klasse 9 Passiva: Eigenkapital, R\u00fccklagen, stille Einlagen, Abschlusskonten": {
             "9000 Gezeichnetes bzw. gewidmetes Kapital": {
                 "account_type": "Equity"
@@ -434,5 +435,5 @@
             },
             "root_type": "Equity"
         }
-     }
+     }   
   }

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

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

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

@@ -33,9 +33,7 @@
                 }, 
                 "Stocks": {
                     "Mati\u00e8res premi\u00e8res": {}, 
-                    "Stock de produits fini": {
-                        "account_type": "Stock"
-                    }, 
+                    "Stock de produits fini": {}, 
                     "Stock exp\u00e9di\u00e9 non-factur\u00e9": {}, 
                     "Travaux en cours": {}, 
                     "account_type": "Stock"
@@ -397,11 +395,9 @@
         }, 
         "Produits": {
             "Revenus de ventes": {
-                "Escomptes de volume sur ventes": {}, 
+                " Escomptes de volume sur ventes": {}, 
                 "Autres produits d'exploitation": {}, 
-                "Ventes": {
-                    "account_type": "Income Account"
-                }, 
+                "Ventes": {}, 
                 "Ventes avec des provinces harmonis\u00e9es": {}, 
                 "Ventes avec des provinces non-harmonis\u00e9es": {}, 
                 "Ventes \u00e0 l'\u00e9tranger": {}

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

@@ -53,13 +53,8 @@
 				},
 				"II. Forderungen und sonstige Vermögensgegenstände": {
 					"is_group": 1,
-					"Forderungen aus Lieferungen und Leistungen mit Kontokorrent": {
+					"Ford. a. Lieferungen und Leistungen": {
 						"account_number": "1400",
-						"account_type": "Receivable",
-						"is_group": 1
-					},
-					"Forderungen aus Lieferungen und Leistungen ohne Kontokorrent": {
-						"account_number": "1410",
 						"account_type": "Receivable"
 					},
 					"Durchlaufende Posten": {
@@ -185,13 +180,8 @@
 				},
 				"IV. Verbindlichkeiten aus Lieferungen und Leistungen": {
 					"is_group": 1,
-					"Verbindlichkeiten aus Lieferungen und Leistungen mit Kontokorrent": {
+					"Verbindlichkeiten aus Lieferungen u. Leistungen": {
 						"account_number": "1600",
-						"account_type": "Payable",
-						"is_group": 1
-					},
-					"Verbindlichkeiten aus Lieferungen und Leistungen ohne Kontokorrent": {
-						"account_number": "1610",
 						"account_type": "Payable"
 					}
 				},

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

@@ -407,10 +407,13 @@
                         "Bewertungskorrektur zu Forderungen aus Lieferungen und Leistungen": {
                             "account_number": "9960"
                         },
-                        "Forderungen aus Lieferungen und Leistungen mit Kontokorrent": {
+                        "Debitoren": {
+                            "is_group": 1,
+                            "account_number": "10000"
+                        },
+                        "Forderungen aus Lieferungen und Leistungen": {
                             "account_number": "1200",
-                            "account_type": "Receivable",
-                            "is_group": 1
+                            "account_type": "Receivable"
                         },
                         "Forderungen aus Lieferungen und Leistungen ohne Kontokorrent": {
                             "account_number": "1210"
@@ -1135,15 +1138,18 @@
                     "Bewertungskorrektur zu Verb. aus Lieferungen und Leistungen": {
                         "account_number": "9964"
                     },
-                    "Verb. aus Lieferungen und Leistungen mit Kontokorrent": {
-                        "account_number": "3300",
-                        "account_type": "Payable",
+                    "Kreditoren": {
+                        "account_number": "70000",
                         "is_group": 1,
-                        "Wareneingangs-Verrechnungskonto" : {
+                        "Wareneingangs-­Verrechnungskonto" : {
                             "account_number": "70001",
                             "account_type": "Stock Received But Not Billed"
                         }
                     },
+                    "Verb. aus Lieferungen und Leistungen": {
+                        "account_number": "3300",
+                        "account_type": "Payable"
+                    },
                     "Verb. aus Lieferungen und Leistungen ohne Kontokorrent": {
                         "account_number": "3310"
                     },

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

@@ -1,6 +1,4 @@
 {
-  "country_code": "hu", 
-  "name": "Hungary - Chart of Accounts for Microenterprises", 
   "tree": {
     "SZ\u00c1MLAOSZT\u00c1LY BEFEKTETETT ESZK\u00d6Z\u00d6K": {
       "account_number": 1,

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

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

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

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

erpnext/accounts/doctype/account/test_account.py

@@ -7,11 +7,7 @@ import unittest
 import frappe
 from frappe.test_runner import make_test_records
 
-from erpnext.accounts.doctype.account.account import (
-	InvalidAccountMergeError,
-	merge_account,
-	update_account_number,
-)
+from erpnext.accounts.doctype.account.account import merge_account, update_account_number
 from erpnext.stock import get_company_default_inventory_account, get_warehouse_account
 
 test_dependencies = ["Company"]
@@ -51,53 +47,49 @@ class TestAccount(unittest.TestCase):
 		frappe.delete_doc("Account", "1211-11-4 - 6 - Debtors 1 - Test - - _TC")
 
 	def test_merge_account(self):
-		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",
-		)
+		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()
 
+		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")
-
+		merge_account(
+			"Securities and Deposits - _TC", "Cash In Hand - _TC", doc.is_group, doc.root_type, doc.company
+		)
 		parent = frappe.db.get_value("Account", "Earnest Money - _TC", "parent_account")
 
 		# Parent account of the child account changes after merging
@@ -106,28 +98,30 @@ 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(
-			InvalidAccountMergeError,
+			frappe.ValidationError,
 			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(
-			InvalidAccountMergeError,
+			frappe.ValidationError,
 			merge_account,
 			"Capital Stock - _TC",
 			"Softwares - _TC",
-		)
-
-		# Raise error as currency doesn't match
-		self.assertRaises(
-			InvalidAccountMergeError,
-			merge_account,
-			"Receivable INR - _TC",
-			"Receivable USD - _TC",
+			doc.is_group,
+			doc.root_type,
+			doc.company,
 		)
 
 	def test_account_sync(self):
@@ -406,20 +400,11 @@ def create_account(**kwargs):
 		"Account", filters={"account_name": kwargs.get("account_name"), "company": kwargs.get("company")}
 	)
 	if 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
+		return account
 	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/account_closing_balance/account_closing_balance.py

@@ -11,29 +11,6 @@ from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 
 
 class AccountClosingBalance(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account: DF.Link | None
-		account_currency: DF.Link | None
-		closing_date: DF.Date | None
-		company: DF.Link | None
-		cost_center: DF.Link | None
-		credit: DF.Currency
-		credit_in_account_currency: DF.Currency
-		debit: DF.Currency
-		debit_in_account_currency: DF.Currency
-		finance_book: DF.Link | None
-		is_period_closing_voucher_entry: DF.Check
-		period_closing_voucher: DF.Link | None
-		project: DF.Link | None
-	# end: auto-generated types
-
 	pass
 
 
@@ -60,7 +37,6 @@ def make_closing_entries(closing_entries, voucher_name, company, closing_date):
 			}
 		)
 		cle.flags.ignore_permissions = True
-		cle.flags.ignore_links = True
 		cle.submit()
 
 

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -13,25 +13,6 @@ from frappe.utils import cstr
 
 
 class AccountingDimension(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.accounting_dimension_detail.accounting_dimension_detail import (
-			AccountingDimensionDetail,
-		)
-
-		dimension_defaults: DF.Table[AccountingDimensionDetail]
-		disabled: DF.Check
-		document_type: DF.Link
-		fieldname: DF.Data | None
-		label: DF.Data | None
-	# end: auto-generated types
-
 	def before_insert(self):
 		self.set_fieldname_and_label()
 
@@ -284,21 +265,20 @@ def get_dimension_with_children(doctype, dimensions):
 
 @frappe.whitelist()
 def get_dimensions(with_cost_center_and_project=False):
-
-	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)
+	dimension_filters = frappe.db.sql(
+		"""
+		SELECT label, fieldname, document_type
+		FROM `tabAccounting Dimension`
+		WHERE disabled = 0
+	""",
+		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)
+
+	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,
 	)
 
 	if isinstance(with_cost_center_and_project, str):
@@ -321,30 +301,3 @@ def get_dimensions(with_cost_center_and_project=False):
 		default_dimensions_map[dimension.company][dimension.fieldname] = dimension.default_dimension
 
 	return dimension_filters, default_dimensions_map
-
-
-def create_accounting_dimensions_for_doctype(doctype):
-	accounting_dimensions = frappe.db.get_all(
-		"Accounting Dimension", fields=["fieldname", "label", "document_type", "disabled"]
-	)
-
-	if not accounting_dimensions:
-		return
-
-	for d in accounting_dimensions:
-		field = frappe.db.get_value("Custom Field", {"dt": doctype, "fieldname": d.fieldname})
-
-		if field:
-			continue
-
-		df = {
-			"fieldname": d.fieldname,
-			"label": d.label,
-			"fieldtype": "Link",
-			"options": d.document_type,
-			"insert_after": "accounting_dimensions_section",
-		}
-
-		create_custom_field(doctype, df, ignore_validate=True)
-
-	frappe.clear_cache(doctype=doctype)

erpnext/accounts/doctype/accounting_dimension/test_accounting_dimension.py

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

erpnext/accounts/doctype/accounting_dimension_detail/accounting_dimension_detail.py

@@ -7,24 +7,4 @@ from frappe.model.document import Document
 
 
 class AccountingDimensionDetail(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		automatically_post_balancing_accounting_entry: DF.Check
-		company: DF.Link | None
-		default_dimension: DF.DynamicLink | None
-		mandatory_for_bs: DF.Check
-		mandatory_for_pl: DF.Check
-		offsetting_account: DF.Link | None
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-		reference_document: DF.Link | None
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/accounting_dimension_filter/accounting_dimension_filter.py

@@ -8,28 +8,6 @@ from frappe.model.document import Document
 
 
 class AccountingDimensionFilter(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.allowed_dimension.allowed_dimension import AllowedDimension
-		from erpnext.accounts.doctype.applicable_on_account.applicable_on_account import (
-			ApplicableOnAccount,
-		)
-
-		accounting_dimension: DF.Literal
-		accounts: DF.Table[ApplicableOnAccount]
-		allow_or_restrict: DF.Literal["Allow", "Restrict"]
-		apply_restriction_on_values: DF.Check
-		company: DF.Link
-		dimensions: DF.Table[AllowedDimension]
-		disabled: DF.Check
-	# end: auto-generated types
-
 	def before_save(self):
 		# If restriction is not applied on values, then remove all the dimensions and set allow_or_restrict to Restrict
 		if not self.apply_restriction_on_values:

erpnext/accounts/doctype/accounting_period/accounting_period.py

@@ -16,23 +16,6 @@ class ClosedAccountingPeriod(frappe.ValidationError):
 
 
 class AccountingPeriod(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.closed_document.closed_document import ClosedDocument
-
-		closed_documents: DF.Table[ClosedDocument]
-		company: DF.Link
-		end_date: DF.Date
-		period_name: DF.Data
-		start_date: DF.Date
-	# end: auto-generated types
-
 	def validate(self):
 		self.validate_overlap()
 

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -32,7 +32,6 @@
   "column_break_19",
   "add_taxes_from_item_tax_template",
   "book_tax_discount_loss",
-  "round_row_wise_tax",
   "print_settings",
   "show_inclusive_tax_in_print",
   "show_taxes_as_table_in_print",
@@ -66,12 +65,7 @@
   "show_balance_in_coa",
   "banking_tab",
   "enable_party_matching",
-  "enable_fuzzy_matching",
-  "reports_tab",
-  "remarks_section",
-  "general_ledger_remarks_length",
-  "column_break_lvjk",
-  "receivable_payable_remarks_length"
+  "enable_fuzzy_matching"
  ],
  "fields": [
   {
@@ -420,41 +414,6 @@
    "fieldname": "ignore_account_closing_balance",
    "fieldtype": "Check",
    "label": "Ignore Account Closing Balance"
-  },
-  {
-   "default": "0",
-   "description": "Tax Amount will be rounded on a row(items) level",
-   "fieldname": "round_row_wise_tax",
-   "fieldtype": "Check",
-   "label": "Round Tax Amount Row-wise"
-  },
-  {
-   "fieldname": "reports_tab",
-   "fieldtype": "Tab Break",
-   "label": "Reports"
-  },
-  {
-   "default": "0",
-   "description": "Truncates 'Remarks' column to set character length",
-   "fieldname": "general_ledger_remarks_length",
-   "fieldtype": "Int",
-   "label": "General Ledger"
-  },
-  {
-   "default": "0",
-   "description": "Truncates 'Remarks' column to set character length",
-   "fieldname": "receivable_payable_remarks_length",
-   "fieldtype": "Int",
-   "label": "Accounts Receivable/Payable"
-  },
-  {
-   "fieldname": "column_break_lvjk",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "remarks_section",
-   "fieldtype": "Section Break",
-   "label": "Remarks Column Length"
   }
  ],
  "icon": "icon-cog",
@@ -462,7 +421,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-11-20 09:37:47.650347",
+ "modified": "2023-07-27 15:05:34.000264",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -14,52 +14,6 @@ from erpnext.stock.utils import check_pending_reposting
 
 
 class AccountsSettings(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		acc_frozen_upto: DF.Date | None
-		add_taxes_from_item_tax_template: DF.Check
-		allow_multi_currency_invoices_against_single_party_account: DF.Check
-		allow_stale: DF.Check
-		auto_reconcile_payments: DF.Check
-		automatically_fetch_payment_terms: DF.Check
-		automatically_process_deferred_accounting_entry: DF.Check
-		book_asset_depreciation_entry_automatically: DF.Check
-		book_deferred_entries_based_on: DF.Literal["Days", "Months"]
-		book_deferred_entries_via_journal_entry: DF.Check
-		book_tax_discount_loss: DF.Check
-		check_supplier_invoice_uniqueness: DF.Check
-		credit_controller: DF.Link | None
-		delete_linked_ledger_entries: DF.Check
-		determine_address_tax_category_from: DF.Literal["Billing Address", "Shipping Address"]
-		enable_common_party_accounting: DF.Check
-		enable_fuzzy_matching: DF.Check
-		enable_party_matching: DF.Check
-		frozen_accounts_modifier: DF.Link | None
-		general_ledger_remarks_length: DF.Int
-		ignore_account_closing_balance: DF.Check
-		make_payment_via_journal_entry: DF.Check
-		merge_similar_account_heads: DF.Check
-		over_billing_allowance: DF.Currency
-		post_change_gl_entries: DF.Check
-		receivable_payable_remarks_length: DF.Int
-		role_allowed_to_over_bill: DF.Link | None
-		round_row_wise_tax: DF.Check
-		show_balance_in_coa: DF.Check
-		show_inclusive_tax_in_print: DF.Check
-		show_payment_schedule_in_print: DF.Check
-		show_taxes_as_table_in_print: DF.Check
-		stale_days: DF.Int
-		submit_journal_entries: DF.Check
-		unlink_advance_payment_on_cancelation_of_order: DF.Check
-		unlink_payment_on_cancellation_of_invoice: DF.Check
-	# end: auto-generated types
-
 	def validate(self):
 		old_doc = self.get_doc_before_save()
 		clear_cache = False

erpnext/accounts/doctype/advance_tax/advance_tax.py

@@ -6,22 +6,4 @@ from frappe.model.document import Document
 
 
 class AdvanceTax(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account_head: DF.Link | None
-		allocated_amount: DF.Currency
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-		reference_detail: DF.Data | None
-		reference_name: DF.DynamicLink | None
-		reference_type: DF.Link | None
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/advance_taxes_and_charges/advance_taxes_and_charges.py

@@ -7,33 +7,4 @@ from frappe.model.document import Document
 
 
 class AdvanceTaxesandCharges(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account_head: DF.Link
-		add_deduct_tax: DF.Literal["Add", "Deduct"]
-		allocated_amount: DF.Currency
-		base_tax_amount: DF.Currency
-		base_total: DF.Currency
-		charge_type: DF.Literal[
-			"", "Actual", "On Paid Amount", "On Previous Row Amount", "On Previous Row Total"
-		]
-		cost_center: DF.Link | None
-		currency: DF.Link | None
-		description: DF.SmallText
-		included_in_paid_amount: DF.Check
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-		rate: DF.Float
-		row_id: DF.Data | None
-		tax_amount: DF.Currency
-		total: DF.Currency
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/allowed_dimension/allowed_dimension.py

@@ -7,19 +7,4 @@ from frappe.model.document import Document
 
 
 class AllowedDimension(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		accounting_dimension: DF.Link | None
-		dimension_value: DF.DynamicLink | None
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/allowed_to_transact_with/allowed_to_transact_with.json

@@ -11,7 +11,6 @@
   {
    "fieldname": "company",
    "fieldtype": "Link",
-   "ignore_user_permissions": 1,
    "in_list_view": 1,
    "label": "Company",
    "options": "Company",
@@ -20,7 +19,7 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2024-01-03 11:13:02.669632",
+ "modified": "2020-05-01 12:32:34.044911",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Allowed To Transact With",
@@ -29,6 +28,5 @@
  "quick_entry": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/allowed_to_transact_with/allowed_to_transact_with.py

@@ -6,18 +6,4 @@ from frappe.model.document import Document
 
 
 class AllowedToTransactWith(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		company: DF.Link
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/applicable_on_account/applicable_on_account.py

@@ -7,19 +7,4 @@ from frappe.model.document import Document
 
 
 class ApplicableOnAccount(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		applicable_on_account: DF.Link
-		is_mandatory: DF.Check
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/bank/bank.py

@@ -10,25 +10,6 @@ from frappe.model.document import Document
 
 
 class Bank(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.bank_transaction_mapping.bank_transaction_mapping import (
-			BankTransactionMapping,
-		)
-
-		bank_name: DF.Data
-		bank_transaction_mapping: DF.Table[BankTransactionMapping]
-		plaid_access_token: DF.Data | None
-		swift_number: DF.Data | None
-		website: DF.Data | None
-	# end: auto-generated types
-
 	def onload(self):
 		"""Load address and contacts in `__onload`"""
 		load_address_and_contact(self)

erpnext/accounts/doctype/bank_account/bank_account.json

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

erpnext/accounts/doctype/bank_account/bank_account.py

@@ -12,33 +12,6 @@ from frappe.model.document import Document
 
 
 class BankAccount(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account: DF.Link | None
-		account_name: DF.Data
-		account_subtype: DF.Link | None
-		account_type: DF.Link | None
-		bank: DF.Link
-		bank_account_no: DF.Data | None
-		branch_code: DF.Data | None
-		company: DF.Link | None
-		disabled: DF.Check
-		iban: DF.Data | None
-		integration_id: DF.Data | None
-		is_company_account: DF.Check
-		is_default: DF.Check
-		last_integration_date: DF.Date | None
-		mask: DF.Data | None
-		party: DF.DynamicLink | None
-		party_type: DF.Link | None
-	# end: auto-generated types
-
 	def onload(self):
 		"""Load address and contacts in `__onload`"""
 		load_address_and_contact(self)

erpnext/accounts/doctype/bank_account_subtype/bank_account_subtype.py

@@ -6,15 +6,4 @@ from frappe.model.document import Document
 
 
 class BankAccountSubtype(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account_subtype: DF.Data | None
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/bank_account_type/bank_account_type.py

@@ -7,15 +7,4 @@ from frappe.model.document import Document
 
 
 class BankAccountType(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account_type: DF.Data | None
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -13,28 +13,6 @@ form_grid_templates = {"journal_entries": "templates/form_grid/bank_reconciliati
 
 
 class BankClearance(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.bank_clearance_detail.bank_clearance_detail import (
-			BankClearanceDetail,
-		)
-
-		account: DF.Link
-		account_currency: DF.Link | None
-		bank_account: DF.Link | None
-		from_date: DF.Date
-		include_pos_transactions: DF.Check
-		include_reconciled_entries: DF.Check
-		payment_entries: DF.Table[BankClearanceDetail]
-		to_date: DF.Date
-	# end: auto-generated types
-
 	@frappe.whitelist()
 	def get_payment_entries(self):
 		if not (self.from_date and self.to_date):

erpnext/accounts/doctype/bank_clearance/test_bank_clearance.py

@@ -35,14 +35,13 @@ class TestBankClearance(unittest.TestCase):
 		from lending.loan_management.doctype.loan.test_loan import (
 			create_loan,
 			create_loan_accounts,
-			create_loan_product,
+			create_loan_type,
 			create_repayment_entry,
 			make_loan_disbursement_entry,
 		)
 
 		def create_loan_masters():
-			create_loan_product(
-				"Clearance Loan",
+			create_loan_type(
 				"Clearance Loan",
 				2000000,
 				13.5,

erpnext/accounts/doctype/bank_clearance_detail/bank_clearance_detail.py

@@ -6,25 +6,4 @@ from frappe.model.document import Document
 
 
 class BankClearanceDetail(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		against_account: DF.Data | None
-		amount: DF.Data | None
-		cheque_date: DF.Date | None
-		cheque_number: DF.Data | None
-		clearance_date: DF.Date | None
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-		payment_document: DF.Link | None
-		payment_entry: DF.DynamicLink | None
-		posting_date: DF.Date | None
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py

@@ -8,40 +8,6 @@ from frappe.model.document import Document
 
 
 class BankGuarantee(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account: DF.Link | None
-		amended_from: DF.Link | None
-		amount: DF.Currency
-		bank: DF.Link | None
-		bank_account: DF.Link | None
-		bank_account_no: DF.Data | None
-		bank_guarantee_number: DF.Data | None
-		bg_type: DF.Literal["", "Receiving", "Providing"]
-		branch_code: DF.Data | None
-		charges: DF.Currency
-		customer: DF.Link | None
-		end_date: DF.Date | None
-		fixed_deposit_number: DF.Data | None
-		iban: DF.Data | None
-		margin_money: DF.Currency
-		more_information: DF.TextEditor | None
-		name_of_beneficiary: DF.Data | None
-		project: DF.Link | None
-		reference_docname: DF.DynamicLink | None
-		reference_doctype: DF.Link | None
-		start_date: DF.Date
-		supplier: DF.Link | None
-		swift_number: DF.Data | None
-		validity: DF.Int
-	# end: auto-generated types
-
 	def validate(self):
 		if not (self.customer or self.supplier):
 			frappe.throw(_("Select the customer or supplier."))

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.js

@@ -137,7 +137,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 					"erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.get_account_balance",
 				args: {
 					bank_account: frm.doc.bank_account,
-					till_date: frappe.datetime.add_days(frm.doc.bank_statement_from_date, -1)
+					till_date: frm.doc.bank_statement_from_date,
 				},
 				callback: (response) => {
 					frm.set_value("account_opening_balance", response.message);

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -7,9 +7,7 @@ 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
@@ -17,31 +15,10 @@ from erpnext.accounts.report.bank_reconciliation_statement.bank_reconciliation_s
 	get_amounts_not_reflected_in_system,
 	get_entries,
 )
-from erpnext.accounts.utils import get_account_currency, get_balance_on
-from erpnext.setup.utils import get_exchange_rate
+from erpnext.accounts.utils import get_balance_on
 
 
 class BankReconciliationTool(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account_currency: DF.Link | None
-		account_opening_balance: DF.Currency
-		bank_account: DF.Link | None
-		bank_statement_closing_balance: DF.Currency
-		bank_statement_from_date: DF.Date | None
-		bank_statement_to_date: DF.Date | None
-		company: DF.Link | None
-		filter_by_reference_date: DF.Check
-		from_reference_date: DF.Date | None
-		to_reference_date: DF.Date | None
-	# end: auto-generated types
-
 	pass
 
 
@@ -151,7 +128,7 @@ def create_journal_entry_bts(
 	bank_transaction = frappe.db.get_values(
 		"Bank Transaction",
 		bank_transaction_name,
-		fieldname=["name", "deposit", "withdrawal", "bank_account", "currency"],
+		fieldname=["name", "deposit", "withdrawal", "bank_account"],
 		as_dict=True,
 	)[0]
 	company_account = frappe.get_value("Bank Account", bank_transaction.bank_account, "account")
@@ -165,94 +142,29 @@ def create_journal_entry_bts(
 			)
 
 	company = frappe.get_value("Account", company_account, "company")
-	company_default_currency = frappe.get_cached_value("Company", company, "default_currency")
-	company_account_currency = frappe.get_cached_value("Account", company_account, "account_currency")
-	second_account_currency = frappe.get_cached_value("Account", second_account, "account_currency")
-
-	# determine if multi-currency Journal or not
-	is_multi_currency = (
-		True
-		if company_default_currency != company_account_currency
-		or company_default_currency != second_account_currency
-		or company_default_currency != bank_transaction.currency
-		else False
-	)
 
 	accounts = []
-	second_account_dict = {
-		"account": second_account,
-		"account_currency": second_account_currency,
-		"credit_in_account_currency": bank_transaction.deposit,
-		"debit_in_account_currency": bank_transaction.withdrawal,
-		"party_type": party_type,
-		"party": party,
-		"cost_center": get_default_cost_center(company),
-	}
+	# Multi Currency?
+	accounts.append(
+		{
+			"account": second_account,
+			"credit_in_account_currency": bank_transaction.deposit,
+			"debit_in_account_currency": bank_transaction.withdrawal,
+			"party_type": party_type,
+			"party": party,
+			"cost_center": get_default_cost_center(company),
+		}
+	)
 
-	company_account_dict = {
-		"account": company_account,
-		"account_currency": company_account_currency,
-		"bank_account": bank_transaction.bank_account,
-		"credit_in_account_currency": bank_transaction.withdrawal,
-		"debit_in_account_currency": bank_transaction.deposit,
-		"cost_center": get_default_cost_center(company),
-	}
-
-	# convert transaction amount to company currency
-	if is_multi_currency:
-		exc_rate = get_exchange_rate(bank_transaction.currency, company_default_currency, posting_date)
-		withdrawal_in_company_currency = flt(exc_rate * abs(bank_transaction.withdrawal))
-		deposit_in_company_currency = flt(exc_rate * abs(bank_transaction.deposit))
-	else:
-		withdrawal_in_company_currency = bank_transaction.withdrawal
-		deposit_in_company_currency = bank_transaction.deposit
-
-	# if second account is of foreign currency, convert and set debit and credit fields.
-	if second_account_currency != company_default_currency:
-		exc_rate = get_exchange_rate(second_account_currency, company_default_currency, posting_date)
-		second_account_dict.update(
-			{
-				"exchange_rate": exc_rate,
-				"credit": deposit_in_company_currency,
-				"debit": withdrawal_in_company_currency,
-				"credit_in_account_currency": flt(deposit_in_company_currency / exc_rate) or 0,
-				"debit_in_account_currency": flt(withdrawal_in_company_currency / exc_rate) or 0,
-			}
-		)
-	else:
-		second_account_dict.update(
-			{
-				"exchange_rate": 1,
-				"credit": deposit_in_company_currency,
-				"debit": withdrawal_in_company_currency,
-				"credit_in_account_currency": deposit_in_company_currency,
-				"debit_in_account_currency": withdrawal_in_company_currency,
-			}
-		)
-
-	# if company account is of foreign currency, convert and set debit and credit fields.
-	if company_account_currency != company_default_currency:
-		exc_rate = get_exchange_rate(company_account_currency, company_default_currency, posting_date)
-		company_account_dict.update(
-			{
-				"exchange_rate": exc_rate,
-				"credit": withdrawal_in_company_currency,
-				"debit": deposit_in_company_currency,
-			}
-		)
-	else:
-		company_account_dict.update(
-			{
-				"exchange_rate": 1,
-				"credit": withdrawal_in_company_currency,
-				"debit": deposit_in_company_currency,
-				"credit_in_account_currency": withdrawal_in_company_currency,
-				"debit_in_account_currency": deposit_in_company_currency,
-			}
-		)
-
-	accounts.append(second_account_dict)
-	accounts.append(company_account_dict)
+	accounts.append(
+		{
+			"account": company_account,
+			"bank_account": bank_transaction.bank_account,
+			"credit_in_account_currency": bank_transaction.withdrawal,
+			"debit_in_account_currency": bank_transaction.deposit,
+			"cost_center": get_default_cost_center(company),
+		}
+	)
 
 	journal_entry_dict = {
 		"voucher_type": entry_type,
@@ -262,9 +174,6 @@ def create_journal_entry_bts(
 		"cheque_no": reference_number,
 		"mode_of_payment": mode_of_payment,
 	}
-	if is_multi_currency:
-		journal_entry_dict.update({"multi_currency": True})
-
 	journal_entry = frappe.new_doc("Journal Entry")
 	journal_entry.update(journal_entry_dict)
 	journal_entry.set("accounts", accounts)
@@ -374,68 +283,68 @@ def auto_reconcile_vouchers(
 	to_reference_date=None,
 ):
 	frappe.flags.auto_reconcile_vouchers = True
-	reconciled, partially_reconciled = set(), set()
-
+	document_types = ["payment_entry", "journal_entry"]
 	bank_transactions = get_bank_transactions(bank_account)
+	matched_transaction = []
 	for transaction in bank_transactions:
 		linked_payments = get_linked_payments(
 			transaction.name,
-			["payment_entry", "journal_entry"],
+			document_types,
 			from_date,
 			to_date,
 			filter_by_reference_date,
 			from_reference_date,
 			to_reference_date,
 		)
-
-		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,
+		vouchers = []
+		for r in linked_payments:
+			vouchers.append(
+				{
+					"payment_doctype": r[1],
+					"payment_name": r[2],
+					"amount": r[4],
+				}
 			)
-		)
-
-		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)
+		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,
+				},
+			)
+			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))
 
 	frappe.flags.auto_reconcile_vouchers = False
-	return reconciled, partially_reconciled
 
-
-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
+	return frappe.get_doc("Bank Transaction", transaction.name)
 
 
 @frappe.whitelist()
@@ -444,13 +353,7 @@ def reconcile_vouchers(bank_transaction_name, vouchers):
 	vouchers = json.loads(vouchers)
 	transaction = frappe.get_doc("Bank Transaction", bank_transaction_name)
 	transaction.add_payment_entries(vouchers)
-	transaction.validate_duplicate_references()
-	transaction.allocate_payment_entries()
-	transaction.update_allocated_amount()
-	transaction.set_status()
-	transaction.save()
-
-	return transaction
+	return frappe.get_doc("Bank Transaction", bank_transaction_name)
 
 
 @frappe.whitelist()
@@ -487,13 +390,19 @@ 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.get("doctype"), voucher.get("name"))
-		filtered_row = list(filter(lambda row: row.get("gl_account") == gl_account, rows))
+		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
 
-		if amount := None if not filtered_row else filtered_row[0]["total"]:
-			voucher["paid_amount"] -= amount
-
-		copied.append(voucher)
+		if amount:
+			l = list(voucher)
+			l[3] -= amount
+			copied.append(tuple(l))
+		else:
+			copied.append(voucher)
 	return copied
 
 
@@ -509,18 +418,6 @@ 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,
@@ -532,15 +429,30 @@ def check_matching(
 	}
 
 	matching_vouchers = []
-	for query in queries:
-		matching_vouchers.extend(frappe.db.sql(query, filters, as_dict=True))
 
-	return (
-		sorted(matching_vouchers, key=lambda x: x["rank"], reverse=True) if matching_vouchers else []
-	)
+	# 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 []
 
 
-def get_queries(
+def get_matching_vouchers_for_bank_reconciliation(
 	bank_account,
 	company,
 	transaction,
@@ -551,6 +463,7 @@ def get_queries(
 	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"
@@ -575,7 +488,17 @@ def get_queries(
 			or []
 		)
 
-	return queries
+	vouchers = []
+
+	for query in queries:
+		vouchers.extend(
+			frappe.db.sql(
+				query,
+				filters,
+			)
+		)
+
+	return vouchers
 
 
 def get_matching_queries(
@@ -592,8 +515,6 @@ 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,
@@ -620,12 +541,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, currency)
+		query = get_si_matching_query(exact_match)
 		queries.append(query)
 
 	if transaction.withdrawal > 0.0:
 		if "purchase_invoice" in document_types:
-			query = get_pi_matching_query(exact_match, currency)
+			query = get_pi_matching_query(exact_match)
 			queries.append(query)
 
 	if "bank_transaction" in document_types:
@@ -639,48 +560,33 @@ 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
 
-	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)
-	)
+	return f"""
 
-	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)
+		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'}
+	"""
 
 
 def get_pe_matching_query(
@@ -694,56 +600,45 @@ def get_pe_matching_query(
 	to_reference_date,
 ):
 	# get matching payment entries query
-	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 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 = ""
 	if cint(filter_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)
-	)
-
+		filter_by_date = f"AND reference_date between '{from_reference_date}' and '{to_reference_date}'"
+		order_by = " reference_date"
 	if frappe.flags.auto_reconcile_vouchers == True:
-		query = query.where(ref_condition)
-
-	return str(query)
+		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}
+	"""
 
 
 def get_je_matching_query(
@@ -760,121 +655,100 @@ 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"
-	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)
+	filter_by_date = f"AND je.posting_date between '{from_date}' and '{to_date}'"
+	order_by = " je.posting_date"
+	filter_by_reference_no = ""
 	if cint(filter_by_reference_date):
-		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"),
+		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,
 			je.name,
-			getattr(jea, amount_field).as_("paid_amount"),
-			je.cheque_no.as_("reference_no"),
-			je.cheque_date.as_("reference_date"),
-			je.pay_to_recd_from.as_("party"),
+			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,
 			jea.party_type,
 			je.posting_date,
-			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)
+			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}
+	"""
 
 
-def get_si_matching_query(exact_match, currency):
+def get_si_matching_query(exact_match):
 	# get matching sales invoice query
-	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"),
+	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.name,
-			sip.amount.as_("paid_amount"),
-			ConstantColumn("").as_("reference_no"),
-			ConstantColumn("").as_("reference_date"),
-			si.customer.as_("party"),
-			ConstantColumn("Customer").as_("party_type"),
+			sip.amount as paid_amount,
+			'' as reference_no,
+			'' as reference_date,
+			si.customer as party,
+			'Customer' as party_type,
 			si.posting_date,
-			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)
-	)
+			si.currency
 
-	return str(query)
+		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'}
+	"""
 
 
-def get_pi_matching_query(exact_match, currency):
+def get_pi_matching_query(exact_match):
 	# get matching purchase invoice query when they are also used as payment entries (is_paid)
-	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)
+	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'}
+	"""

erpnext/accounts/doctype/bank_reconciliation_tool/test_bank_reconciliation_tool.py

@@ -1,100 +1,9 @@
 # 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
 
-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)
+class TestBankReconciliationTool(unittest.TestCase):
+	pass

erpnext/accounts/doctype/bank_reconciliation_tool_beta/bank_reconciliation_tool_beta.js

@@ -0,0 +1,238 @@
+// Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
+// For license information, please see license.txt
+
+frappe.ui.form.on("Bank Reconciliation Tool Beta", {
+	setup: function (frm) {
+		frm.set_query("bank_account", function () {
+			return {
+				filters: {
+					company: frm.doc.company,
+					"is_company_account": 1
+				},
+			};
+		});
+
+		frm.set_query("party_type", function () {
+			return {
+				filters: {
+					name: [
+						"in", Object.keys(frappe.boot.party_account_types),
+					],
+				},
+			};
+		});
+
+	},
+
+	onload: function (frm) {
+		// Set default filter dates
+		let today = frappe.datetime.get_today();
+		frm.doc.bank_statement_from_date = frappe.datetime.add_months(today, -1);
+		frm.doc.bank_statement_to_date = today;
+	},
+
+	filter_by_reference_date: function (frm) {
+		if (frm.doc.filter_by_reference_date) {
+			frm.set_value("bank_statement_from_date", "");
+			frm.set_value("bank_statement_to_date", "");
+		} else {
+			frm.set_value("from_reference_date", "");
+			frm.set_value("to_reference_date", "");
+		}
+	},
+
+	refresh: function(frm) {
+		frm.disable_save();
+		frm.fields_dict["filters_section"].collapse(false);
+
+		frm.add_custom_button(__("Get Bank Transactions"), function() {
+			if (!frm.doc.bank_account) {
+				frappe.throw(
+					{
+						message: __("Please set the 'Bank Account' filter"),
+						title: __("Filter Required")
+					}
+				);
+			}
+
+			frm.events.add_upload_statement_button(frm);
+			frm.events.build_reconciliation_area(frm);
+		});
+		frm.change_custom_button_type("Get Bank Transactions", null, "primary");
+
+		frm.add_custom_button(__("Auto Reconcile"), function() {
+			frappe.call({
+				method: "erpnext.accounts.doctype.bank_reconciliation_tool_beta.bank_reconciliation_tool_beta.auto_reconcile_vouchers",
+				args: {
+					bank_account: frm.doc.bank_account,
+					from_date: frm.doc.bank_statement_from_date,
+					to_date: frm.doc.bank_statement_to_date,
+					filter_by_reference_date: frm.doc.filter_by_reference_date,
+					from_reference_date: frm.doc.from_reference_date,
+					to_reference_date: frm.doc.to_reference_date,
+				},
+				callback: function(r) {
+					if (!r.exc) frm.refresh();
+				}
+			});
+		});
+
+		frm.$reconciliation_area = frm.get_field("reconciliation_action_area").$wrapper;
+		frm.events.setup_empty_state(frm);
+
+		frm.events.build_reconciliation_area(frm);
+	},
+
+	add_upload_statement_button: function(frm) {
+		frm.remove_custom_button(__("Upload a Bank Statement"));
+		frm.add_custom_button(
+			__("Upload a Bank Statement"),
+			() => frm.events.route_to_bank_statement_import(frm),
+		);
+	},
+
+	route_to_bank_statement_import(frm) {
+		frappe.open_in_new_tab = true;
+
+		if (!frm.doc.bank_account || !frm.doc.company) {
+			frappe.new_doc("Bank Statement Import");
+			return;
+		}
+
+		// Route to saved Import Record in new tab
+		frappe.call({
+			method:
+				"erpnext.accounts.doctype.bank_statement_import.bank_statement_import.upload_bank_statement",
+			args: {
+				dt: frm.doc.doctype,
+				dn: frm.doc.name,
+				company: frm.doc.company,
+				bank_account: frm.doc.bank_account,
+			},
+			callback: function (r) {
+				if (!r.exc) {
+					var doc = frappe.model.sync(r.message);
+					frappe.open_in_new_tab = true;
+					frappe.set_route("Form", doc[0].doctype, doc[0].name);
+				}
+			},
+		})
+	},
+
+	bank_account: function (frm) {
+		frappe.db.get_value(
+			"Bank Account",
+			frm.doc.bank_account,
+			"account",
+			(r) => {
+				frappe.db.get_value(
+					"Account",
+					r.account,
+					"account_currency",
+					(r) => {
+						frm.doc.account_currency = r.account_currency;
+						frm.trigger("bank_statement_from_date");
+						frm.trigger("bank_statement_to_date");
+					}
+				);
+			}
+		);
+
+	},
+
+	bank_statement_from_date: function (frm) {
+		frm.trigger("get_account_opening_balance");
+	},
+
+	bank_statement_to_date: function (frm) {
+		frm.trigger("get_account_closing_balance");
+		frm.trigger("render_summary");
+	},
+
+	bank_statement_closing_balance: function (frm) {
+		frm.trigger("render_summary");
+	},
+
+	get_account_opening_balance(frm) {
+		if (frm.doc.bank_account && frm.doc.bank_statement_from_date) {
+			frappe.call({
+				method:
+					"erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.get_account_balance",
+				args: {
+					bank_account: frm.doc.bank_account,
+					till_date: frm.doc.bank_statement_from_date,
+				},
+				callback: (response) => {
+					frm.set_value("account_opening_balance", response.message);
+				},
+			});
+		}
+	},
+
+	get_account_closing_balance(frm) {
+		if (frm.doc.bank_account && frm.doc.bank_statement_to_date) {
+			return frappe.call({
+				method:
+					"erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.get_account_balance",
+				args: {
+					bank_account: frm.doc.bank_account,
+					till_date: frm.doc.bank_statement_to_date,
+				},
+				callback: (response) => {
+					frm.cleared_balance = response.message;
+				},
+			});
+		}
+	},
+
+	setup_empty_state: function(frm) {
+		frm.$reconciliation_area.empty();
+		let empty_area = frm.$reconciliation_area.append(`
+			<div class="bank-reco-beta-empty-state">
+				<p>
+					${__("Set Filters and Get Bank Transactions")}
+				</p>
+				<p>${__("Or")}</p>
+			</div>
+		`).find(".bank-reco-beta-empty-state");
+
+		frappe.utils.add_custom_button(
+			__("Upload a Bank Statement"),
+			() => frm.events.route_to_bank_statement_import(frm),
+			"",
+			__("Upload a Bank Statement"),
+			"btn-primary",
+			$(empty_area),
+		)
+	},
+
+	render_summary: function(frm) {
+		frm.get_field("reconciliation_tool_cards").$wrapper.empty();
+
+		frappe.require("bank-reconciliation-tool-beta.bundle.js", () => {
+			let difference = flt(frm.doc.bank_statement_closing_balance) - flt(frm.cleared_balance);
+			let difference_color = difference >= 0 ?  "text-success" : "text-danger";
+
+			frm.summary_card = new erpnext.accounts.bank_reconciliation.SummaryCard({
+				$wrapper: frm.get_field("reconciliation_tool_cards").$wrapper,
+				values: {
+					"Bank Closing Balance": [frm.doc.bank_statement_closing_balance],
+					"ERP Closing Balance": [frm.cleared_balance],
+					"Difference": [difference, difference_color]
+				},
+				currency: frm.doc.account_currency,
+			})
+		});
+	},
+
+	build_reconciliation_area: function(frm) {
+		if (!frm.doc.bank_account) return;
+
+		frappe.require("bank-reconciliation-tool-beta.bundle.js", () =>
+			frm.panel_manager = new erpnext.accounts.bank_reconciliation.PanelManager({
+				doc: frm.doc,
+				$wrapper: frm.$reconciliation_area,
+			})
+		);
+	},
+});

erpnext/accounts/doctype/bank_reconciliation_tool_beta/bank_reconciliation_tool_beta.json

@@ -0,0 +1,144 @@
+{
+ "actions": [],
+ "allow_rename": 1,
+ "creation": "2023-08-24 15:15:48.714131",
+ "default_view": "List",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "filters_section",
+  "company",
+  "bank_account",
+  "account_currency",
+  "column_break_oojl",
+  "account_opening_balance",
+  "bank_statement_closing_balance",
+  "column_break_sdit",
+  "bank_statement_from_date",
+  "bank_statement_to_date",
+  "from_reference_date",
+  "to_reference_date",
+  "filter_by_reference_date",
+  "section_break_dyil",
+  "reconciliation_tool_cards",
+  "reconciliation_action_area"
+ ],
+ "fields": [
+  {
+   "collapsible": 1,
+   "fieldname": "filters_section",
+   "fieldtype": "Section Break",
+   "label": "Filters"
+  },
+  {
+   "fieldname": "company",
+   "fieldtype": "Link",
+   "label": "Company",
+   "options": "Company"
+  },
+  {
+   "fieldname": "bank_account",
+   "fieldtype": "Link",
+   "label": "Bank Account",
+   "options": "Bank Account"
+  },
+  {
+   "fieldname": "account_currency",
+   "fieldtype": "Link",
+   "hidden": 1,
+   "label": "Account Currency",
+   "options": "Currency"
+  },
+  {
+   "fieldname": "column_break_oojl",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "column_break_sdit",
+   "fieldtype": "Column Break"
+  },
+  {
+   "depends_on": "bank_account",
+   "fieldname": "account_opening_balance",
+   "fieldtype": "Currency",
+   "label": "Account Opening Balance",
+   "options": "account_currency",
+   "read_only": 1
+  },
+  {
+   "depends_on": "bank_account",
+   "fieldname": "bank_statement_closing_balance",
+   "fieldtype": "Currency",
+   "label": "Closing Balance",
+   "options": "account_currency"
+  },
+  {
+   "depends_on": "eval: doc.bank_account && !doc.filter_by_reference_date",
+   "fieldname": "bank_statement_from_date",
+   "fieldtype": "Date",
+   "label": "From Date"
+  },
+  {
+   "depends_on": "eval: doc.bank_account && !doc.filter_by_reference_date",
+   "fieldname": "bank_statement_to_date",
+   "fieldtype": "Date",
+   "label": "To Date"
+  },
+  {
+   "depends_on": "eval:doc.filter_by_reference_date",
+   "fieldname": "from_reference_date",
+   "fieldtype": "Date",
+   "label": "From Reference Date"
+  },
+  {
+   "depends_on": "eval:doc.filter_by_reference_date",
+   "fieldname": "to_reference_date",
+   "fieldtype": "Date",
+   "label": "To Reference Date"
+  },
+  {
+   "default": "0",
+   "depends_on": "eval:doc.bank_account",
+   "fieldname": "filter_by_reference_date",
+   "fieldtype": "Check",
+   "label": "Filter by Reference Date"
+  },
+  {
+   "fieldname": "section_break_dyil",
+   "fieldtype": "Section Break"
+  },
+  {
+   "fieldname": "reconciliation_tool_cards",
+   "fieldtype": "HTML"
+  },
+  {
+   "fieldname": "reconciliation_action_area",
+   "fieldtype": "HTML"
+  }
+ ],
+ "hide_toolbar": 1,
+ "index_web_pages_for_search": 1,
+ "issingle": 1,
+ "links": [],
+ "modified": "2023-08-31 16:18:36.244114",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Bank Reconciliation Tool Beta",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "print": 1,
+   "read": 1,
+   "role": "System Manager",
+   "share": 1,
+   "write": 1
+  }
+ ],
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "states": []
+}

erpnext/accounts/doctype/bank_reconciliation_tool_beta/bank_reconciliation_tool_beta.py

@@ -0,0 +1,859 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+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_reconciliation_tool.bank_reconciliation_tool import (
+	reconcile_vouchers,
+)
+from erpnext.accounts.doctype.bank_transaction.bank_transaction import get_total_allocated_amount
+from erpnext.accounts.utils import get_account_currency
+
+
+class BankReconciliationToolBeta(Document):
+	pass
+
+
+@frappe.whitelist()
+def get_bank_transactions(bank_account, from_date=None, to_date=None, order_by="date asc"):
+	# returns bank transactions for a bank account
+	filters = []
+	filters.append(["bank_account", "=", bank_account])
+	filters.append(["docstatus", "=", 1])
+	filters.append(["unallocated_amount", ">", 0.0])
+	if to_date:
+		filters.append(["date", "<=", to_date])
+	if from_date:
+		filters.append(["date", ">=", from_date])
+	transactions = frappe.get_all(
+		"Bank Transaction",
+		fields=[
+			"date",
+			"deposit",
+			"withdrawal",
+			"currency",
+			"description",
+			"name",
+			"bank_account",
+			"company",
+			"unallocated_amount",
+			"reference_number",
+			"party_type",
+			"party",
+			"bank_party_name",
+			"bank_party_account_number",
+			"bank_party_iban",
+		],
+		filters=filters,
+		order_by=order_by,
+	)
+	return transactions
+
+
+@frappe.whitelist()
+def create_journal_entry_bts(
+	bank_transaction_name,
+	reference_number=None,
+	reference_date=None,
+	posting_date=None,
+	entry_type=None,
+	second_account=None,
+	mode_of_payment=None,
+	party_type=None,
+	party=None,
+	allow_edit=None,
+):
+	# Create a new journal entry based on the bank transaction
+	bank_transaction = frappe.db.get_values(
+		"Bank Transaction",
+		bank_transaction_name,
+		fieldname=["name", "deposit", "withdrawal", "bank_account"],
+		as_dict=True,
+	)[0]
+	company_account = frappe.get_value("Bank Account", bank_transaction.bank_account, "account")
+	account_type = frappe.db.get_value("Account", second_account, "account_type")
+	if account_type in ["Receivable", "Payable"]:
+		if not (party_type and party):
+			frappe.throw(
+				_("Party Type and Party is required for Receivable / Payable account {0}").format(
+					second_account
+				)
+			)
+
+	company = frappe.get_value("Account", company_account, "company")
+
+	accounts = []
+	# Multi Currency?
+	accounts.append(
+		{
+			"account": second_account,
+			"credit_in_account_currency": bank_transaction.deposit,
+			"debit_in_account_currency": bank_transaction.withdrawal,
+			"party_type": party_type,
+			"party": party,
+			"cost_center": get_default_cost_center(company),
+		}
+	)
+
+	accounts.append(
+		{
+			"account": company_account,
+			"bank_account": bank_transaction.bank_account,
+			"credit_in_account_currency": bank_transaction.withdrawal,
+			"debit_in_account_currency": bank_transaction.deposit,
+			"cost_center": get_default_cost_center(company),
+		}
+	)
+
+	journal_entry_dict = {
+		"voucher_type": entry_type,
+		"company": company,
+		"posting_date": posting_date,
+		"cheque_date": reference_date,
+		"cheque_no": reference_number,
+		"mode_of_payment": mode_of_payment,
+	}
+	journal_entry = frappe.new_doc("Journal Entry")
+	journal_entry.update(journal_entry_dict)
+	journal_entry.set("accounts", accounts)
+	journal_entry.insert()
+
+	if allow_edit:
+		return journal_entry  # Return saved document
+
+	journal_entry.submit()
+
+	if bank_transaction.deposit > 0.0:
+		paid_amount = bank_transaction.deposit
+	else:
+		paid_amount = bank_transaction.withdrawal
+
+	vouchers = json.dumps(
+		[
+			{
+				"payment_doctype": "Journal Entry",
+				"payment_name": journal_entry.name,
+				"amount": paid_amount,
+			}
+		]
+	)
+
+	return reconcile_vouchers(bank_transaction_name, vouchers)
+
+
+@frappe.whitelist()
+def create_payment_entry_bts(
+	bank_transaction_name,
+	reference_number=None,
+	reference_date=None,
+	party_type=None,
+	party=None,
+	posting_date=None,
+	mode_of_payment=None,
+	project=None,
+	cost_center=None,
+	allow_edit=None,
+):
+	# Create a new payment entry based on the bank transaction
+	bank_transaction = frappe.db.get_values(
+		"Bank Transaction",
+		bank_transaction_name,
+		fieldname=["name", "unallocated_amount", "deposit", "bank_account"],
+		as_dict=True,
+	)[0]
+	paid_amount = bank_transaction.unallocated_amount
+	payment_type = "Receive" if bank_transaction.deposit > 0.0 else "Pay"
+
+	company_account = frappe.get_value("Bank Account", bank_transaction.bank_account, "account")
+	company = frappe.get_value("Account", company_account, "company")
+	payment_entry_dict = {
+		"company": company,
+		"payment_type": payment_type,
+		"reference_no": reference_number,
+		"reference_date": reference_date,
+		"party_type": party_type,
+		"party": party,
+		"posting_date": posting_date,
+		"paid_amount": paid_amount,
+		"received_amount": paid_amount,
+	}
+	payment_entry = frappe.new_doc("Payment Entry")
+
+	payment_entry.update(payment_entry_dict)
+
+	if mode_of_payment:
+		payment_entry.mode_of_payment = mode_of_payment
+	if project:
+		payment_entry.project = project
+	if cost_center:
+		payment_entry.cost_center = cost_center
+	if payment_type == "Receive":
+		payment_entry.paid_to = company_account
+	else:
+		payment_entry.paid_from = company_account
+
+	payment_entry.validate()
+	payment_entry.insert()
+
+	if allow_edit:
+		return payment_entry  # Return saved document
+
+	payment_entry.submit()
+	vouchers = json.dumps(
+		[
+			{
+				"payment_doctype": "Payment Entry",
+				"payment_name": payment_entry.name,
+				"amount": paid_amount,
+			}
+		]
+	)
+	return reconcile_vouchers(bank_transaction_name, vouchers)
+
+
+@frappe.whitelist()
+def auto_reconcile_vouchers(
+	bank_account,
+	from_date=None,
+	to_date=None,
+	filter_by_reference_date=None,
+	from_reference_date=None,
+	to_reference_date=None,
+):
+	# Auto reconcile vouchers with matching reference numbers
+	frappe.flags.auto_reconcile_vouchers = True
+	reconciled, partially_reconciled = set(), set()
+
+	bank_transactions = get_bank_transactions(bank_account, from_date, to_date)
+	for transaction in bank_transactions:
+		linked_payments = get_linked_payments(
+			transaction.name,
+			["payment_entry", "journal_entry"],
+			from_date,
+			to_date,
+			filter_by_reference_date,
+			from_reference_date,
+			to_reference_date,
+		)
+
+		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,
+			)
+		)
+
+		unallocated_before = transaction.unallocated_amount
+		transaction = reconcile_vouchers(transaction.name, json.dumps(vouchers))
+
+		if transaction.status == "Reconciled":
+			reconciled.add(transaction.name)
+		elif flt(unallocated_before) != flt(transaction.unallocated_amount):
+			partially_reconciled.add(transaction.name)  # Partially reconciled
+
+	alert_message, indicator = "", "blue"
+	if not partially_reconciled and not reconciled:
+		alert_message = _("No matches occurred via auto reconciliation")
+
+	if reconciled:
+		alert_message += _("{0} Transaction(s) Reconciled").format(len(reconciled))
+		alert_message += "<br>"
+		indicator = "green"
+
+	if partially_reconciled:
+		alert_message += _("{0} {1} Partially Reconciled").format(
+			len(partially_reconciled),
+			_("Transactions") if len(partially_reconciled) > 1 else _("Transaction"),
+		)
+		indicator = "green"
+
+	frappe.msgprint(title=_("Auto Reconciliation"), msg=alert_message, indicator=indicator)
+	frappe.flags.auto_reconcile_vouchers = False
+	return reconciled, partially_reconciled
+
+
+@frappe.whitelist()
+def get_linked_payments(
+	bank_transaction_name,
+	document_types=None,
+	from_date=None,
+	to_date=None,
+	filter_by_reference_date=None,
+	from_reference_date=None,
+	to_reference_date=None,
+):
+	# get all matching payments for a bank transaction
+	transaction = frappe.get_doc("Bank Transaction", bank_transaction_name)
+	gl_account, company = frappe.db.get_value(
+		"Bank Account", transaction.bank_account, ["account", "company"]
+	)
+	matching = check_matching(
+		gl_account,
+		company,
+		transaction,
+		document_types,
+		from_date,
+		to_date,
+		filter_by_reference_date,
+		from_reference_date,
+		to_reference_date,
+	)
+	return subtract_allocations(gl_account, matching)
+
+
+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.get("doctype"), voucher.get("name"))
+		amount = None
+		for row in rows:
+			if row["gl_account"] == gl_account:
+				amount = row["total"]
+				break
+
+		if amount:
+			voucher["paid_amount"] -= amount
+
+		copied.append(voucher)
+	return copied
+
+
+def check_matching(
+	bank_account,
+	company,
+	transaction,
+	document_types,
+	from_date,
+	to_date,
+	filter_by_reference_date,
+	from_reference_date,
+	to_reference_date,
+):
+	# combine all types of vouchers
+	filters = {
+		"amount": transaction.unallocated_amount,
+		"payment_type": "Receive" if transaction.deposit > 0.0 else "Pay",
+		"reference_no": transaction.reference_number,
+		"party_type": transaction.party_type,
+		"party": transaction.party,
+		"bank_account": bank_account,
+	}
+
+	matching_vouchers = []
+
+	matching_voucher_methods = frappe.get_hooks("get_matching_vouchers_for_bank_reconciliation")
+	matching_voucher_methods.append(
+		"erpnext.accounts.doctype.bank_reconciliation_tool_beta.bank_reconciliation_tool_beta.get_matching_vouchers_for_bank_reconciliation"
+	)
+
+	for method_name in matching_voucher_methods[1:]:
+		# get matching vouchers from all the apps (except erpnext, to override)
+		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,
+				filters,
+			)
+		)
+
+	if not matching_vouchers:
+		return []
+
+	for voucher in matching_vouchers:
+		# higher rank if voucher name is in bank transaction
+		if voucher["name"] in transaction.description:
+			voucher["rank"] += 1
+			voucher["name_in_desc_match"] = 1
+
+	return sorted(matching_vouchers, key=lambda x: x["rank"], reverse=True)
+
+
+def get_matching_vouchers_for_bank_reconciliation(
+	bank_account,
+	company,
+	transaction,
+	document_types,
+	from_date,
+	to_date,
+	filter_by_reference_date,
+	from_reference_date,
+	to_reference_date,
+	filters,
+):
+	# get queries to get matching vouchers
+	account_from_to = "paid_to" if transaction.deposit > 0.0 else "paid_from"
+	exact_match = "exact_match" in document_types
+	queries = []
+
+	# get matching queries from all the apps (except erpnext, to override)
+	matching_queries_method = frappe.get_hooks("get_matching_queries")
+	matching_queries_method.append(
+		"erpnext.accounts.doctype.bank_reconciliation_tool_beta.bank_reconciliation_tool_beta.get_matching_queries"
+	)
+
+	for method_name in frappe.get_hooks("get_matching_queries")[1:]:
+		queries.extend(
+			frappe.get_attr(method_name)(
+				bank_account,
+				company,
+				transaction,
+				document_types,
+				exact_match,
+				account_from_to,
+				from_date,
+				to_date,
+				filter_by_reference_date,
+				from_reference_date,
+				to_reference_date,
+			)
+			or []
+		)
+
+	vouchers = []
+	for query in queries:
+		vouchers.extend(
+			frappe.db.sql(
+				query,
+				filters,
+				as_dict=1,
+			)
+		)
+
+	return vouchers
+
+
+def get_matching_queries(
+	bank_account,
+	company,
+	transaction,
+	document_types,
+	exact_match,
+	account_from_to,
+	from_date,
+	to_date,
+	filter_by_reference_date,
+	from_reference_date,
+	to_reference_date,
+):
+	queries = []
+	exact_party_match = "exact_party_match" in document_types
+	currency = get_account_currency(bank_account)
+
+	if "payment_entry" in document_types:
+		query = get_pe_matching_query(
+			exact_match,
+			account_from_to,
+			transaction,
+			from_date,
+			to_date,
+			filter_by_reference_date,
+			from_reference_date,
+			to_reference_date,
+			exact_party_match,
+		)
+		queries.append(query)
+
+	if "journal_entry" in document_types:
+		query = get_je_matching_query(
+			exact_match,
+			transaction,
+			from_date,
+			to_date,
+			filter_by_reference_date,
+			from_reference_date,
+			to_reference_date,
+		)
+		queries.append(query)
+
+	if transaction.deposit > 0.0 and "sales_invoice" in document_types:
+		if "unpaid_invoices" in document_types:
+			query = get_unpaid_si_matching_query(exact_match, exact_party_match, currency)
+			queries.append(query)
+		else:
+			query = get_si_matching_query(exact_match, exact_party_match, currency)
+			queries.append(query)
+
+	if transaction.withdrawal > 0.0 and "purchase_invoice" in document_types:
+		if "unpaid_invoices" in document_types:
+			query = get_unpaid_pi_matching_query(exact_match, exact_party_match, currency)
+			queries.append(query)
+		else:
+			query = get_pi_matching_query(exact_match, exact_party_match, currency)
+			queries.append(query)
+
+	if "bank_transaction" in document_types:
+		query = get_bt_matching_query(exact_match, transaction, exact_party_match)
+		queries.append(query)
+
+	return queries
+
+
+def get_bt_matching_query(exact_match, transaction, exact_party_match):
+	# 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"
+
+	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)
+	)
+
+	amount_equality = getattr(bt, field) == transaction.unallocated_amount
+	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(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)
+	amount_condition = amount_equality if exact_match else getattr(bt, field) > 0.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,
+			ref_rank.as_("reference_number_match"),
+			amount_rank.as_("amount_match"),
+			party_rank.as_("party_match"),
+			unallocated_rank.as_("unallocated_amount_match"),
+		)
+		.where(bt.status != "Reconciled")
+		.where(bt.name != transaction.name)
+		.where(bt.bank_account == transaction.bank_account)
+		.where(amount_condition)
+		.where(bt.docstatus == 1)
+	)
+
+	if exact_party_match:
+		query = query.where(party_condition)
+
+	return str(query)
+
+
+def get_pe_matching_query(
+	exact_match,
+	account_from_to,
+	transaction,
+	from_date,
+	to_date,
+	filter_by_reference_date,
+	from_reference_date,
+	to_reference_date,
+	exact_party_match,
+):
+	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 = 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"),
+			ref_rank.as_("reference_number_match"),
+			amount_rank.as_("amount_match"),
+			party_rank.as_("party_match"),
+		)
+		.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:
+		query = query.where(ref_condition)
+	if exact_party_match:
+		query = query.where(party_condition)
+
+	return str(query)
+
+
+def get_je_matching_query(
+	exact_match,
+	transaction,
+	from_date,
+	to_date,
+	filter_by_reference_date,
+	from_reference_date,
+	to_reference_date,
+):
+	# get matching journal entry query
+	# We have mapping at the bank level
+	# 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"
+	je = frappe.qb.DocType("Journal Entry")
+	jea = frappe.qb.DocType("Journal Entry Account")
+
+	ref_condition = je.cheque_no == transaction.reference_number
+	ref_rank = frappe.qb.terms.Case().when(ref_condition, 1).else_(0)
+
+	amount_field = f"{cr_or_dr}_in_account_currency"
+	amount_equality = getattr(jea, amount_field) == transaction.unallocated_amount
+	amount_rank = frappe.qb.terms.Case().when(amount_equality, 1).else_(0)
+
+	filter_by_date = je.posting_date.between(from_date, to_date)
+	if cint(filter_by_reference_date):
+		filter_by_date = je.cheque_date.between(from_reference_date, to_reference_date)
+
+	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,
+			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"),
+			ref_rank.as_("reference_number_match"),
+			amount_rank.as_("amount_match"),
+		)
+		.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, exact_party_match, currency):
+	# get matching paid sales invoice query
+	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"),
+			si.name.as_("reference_no"),
+			ConstantColumn("").as_("reference_date"),
+			si.customer.as_("party"),
+			ConstantColumn("Customer").as_("party_type"),
+			si.posting_date,
+			si.currency,
+			party_rank.as_("party_match"),
+			amount_rank.as_("amount_match"),
+		)
+		.where(si.docstatus == 1)
+		.where(sip.clearance_date.isnull())
+		.where(sip.account == Parameter("%(bank_account)s"))
+		.where(amount_condition)
+		.where(si.currency == currency)
+	)
+
+	if exact_party_match:
+		query = query.where(party_condition)
+
+	return str(query)
+
+
+def get_unpaid_si_matching_query(exact_match, exact_party_match, currency):
+	sales_invoice = frappe.qb.DocType("Sales Invoice")
+
+	party_condition = sales_invoice.customer == Parameter("%(party)s")
+	party_match = frappe.qb.terms.Case().when(party_condition, 1).else_(0)
+
+	grand_total_condition = sales_invoice.grand_total == Parameter("%(amount)s")
+	amount_match = frappe.qb.terms.Case().when(grand_total_condition, 1).else_(0)
+
+	query = (
+		frappe.qb.from_(sales_invoice)
+		.select(
+			(party_match + amount_match + 1).as_("rank"),
+			ConstantColumn("Sales Invoice").as_("doctype"),
+			sales_invoice.name.as_("name"),
+			sales_invoice.outstanding_amount.as_("paid_amount"),
+			sales_invoice.name.as_("reference_no"),
+			ConstantColumn("").as_("reference_date"),
+			sales_invoice.customer.as_("party"),
+			ConstantColumn("Customer").as_("party_type"),
+			sales_invoice.posting_date,
+			sales_invoice.currency,
+			party_match.as_("party_match"),
+			amount_match.as_("amount_match"),
+		)
+		.where(sales_invoice.docstatus == 1)
+		.where(sales_invoice.is_return == 0)
+		.where(sales_invoice.outstanding_amount > 0.0)
+		.where(sales_invoice.currency == currency)
+	)
+
+	if exact_match:
+		query = query.where(grand_total_condition)
+
+	if exact_party_match:
+		query = query.where(party_condition)
+
+	return str(query)
+
+
+def get_pi_matching_query(exact_match, exact_party_match, currency):
+	# get matching purchase invoice query when they are also used as payment entries (is_paid)
+	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,
+			purchase_invoice.name.as_("reference_no"),
+			ConstantColumn("").as_("reference_date"),
+			purchase_invoice.supplier.as_("party"),
+			ConstantColumn("Supplier").as_("party_type"),
+			purchase_invoice.posting_date,
+			purchase_invoice.currency,
+			party_rank.as_("party_match"),
+			amount_rank.as_("amount_match"),
+		)
+		.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)
+	)
+
+	if exact_party_match:
+		query = query.where(party_condition)
+
+	return str(query)
+
+
+def get_unpaid_pi_matching_query(exact_match, exact_party_match, currency):
+	purchase_invoice = frappe.qb.DocType("Purchase Invoice")
+
+	party_condition = purchase_invoice.supplier == Parameter("%(party)s")
+	party_match = frappe.qb.terms.Case().when(party_condition, 1).else_(0)
+
+	grand_total_condition = purchase_invoice.grand_total == Parameter("%(amount)s")
+	amount_match = frappe.qb.terms.Case().when(grand_total_condition, 1).else_(0)
+
+	query = (
+		frappe.qb.from_(purchase_invoice)
+		.select(
+			(party_match + amount_match + 1).as_("rank"),
+			ConstantColumn("Purchase Invoice").as_("doctype"),
+			purchase_invoice.name.as_("name"),
+			purchase_invoice.outstanding_amount.as_("paid_amount"),
+			purchase_invoice.name.as_("reference_no"),
+			ConstantColumn("").as_("reference_date"),
+			purchase_invoice.supplier.as_("party"),
+			ConstantColumn("Supplier").as_("party_type"),
+			purchase_invoice.posting_date,
+			purchase_invoice.currency,
+			party_match.as_("party_match"),
+			amount_match.as_("amount_match"),
+		)
+		.where(purchase_invoice.docstatus == 1)
+		.where(purchase_invoice.is_return == 0)
+		.where(purchase_invoice.outstanding_amount > 0.0)
+		.where(purchase_invoice.currency == currency)
+	)
+
+	if exact_match:
+		query = query.where(grand_total_condition)
+	if exact_party_match:
+		query = query.where(party_condition)
+
+	return str(query)

erpnext/accounts/doctype/bank_reconciliation_tool_beta/test_bank_reconciliation_tool_beta.py

@@ -5,5 +5,5 @@
 from frappe.tests.utils import FrappeTestCase
 
 
-class TestProcessSubscription(FrappeTestCase):
+class TestBankReconciliationToolBeta(FrappeTestCase):
 	pass

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.js

@@ -352,11 +352,10 @@ frappe.ui.form.on("Bank Statement Import", {
 
 	export_errored_rows(frm) {
 		open_url_post(
-			"/api/method/erpnext.accounts.doctype.bank_statement_import.bank_statement_import.download_errored_template",
+			"/api/method/frappe.core.doctype.data_import.data_import.download_errored_template",
 			{
 				data_import_name: frm.doc.name,
-			},
-			true
+			}
 		);
 	},
 

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.py

@@ -20,30 +20,6 @@ INVALID_VALUES = ("", None)
 
 
 class BankStatementImport(DataImport):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		bank: DF.Link | None
-		bank_account: DF.Link
-		company: DF.Link
-		google_sheets_url: DF.Data | None
-		import_file: DF.Attach | None
-		import_type: DF.Literal["", "Insert New Records", "Update Existing Records"]
-		mute_emails: DF.Check
-		reference_doctype: DF.Link
-		show_failed_logs: DF.Check
-		statement_import_log: DF.Code | None
-		status: DF.Literal["Pending", "Success", "Partial Success", "Error"]
-		submit_after_import: DF.Check
-		template_options: DF.Code | None
-		template_warnings: DF.Code | None
-	# end: auto-generated types
-
 	def __init__(self, *args, **kwargs):
 		super(BankStatementImport, self).__init__(*args, **kwargs)
 

erpnext/accounts/doctype/bank_transaction/bank_transaction.js

@@ -13,11 +13,10 @@ frappe.ui.form.on("Bank Transaction", {
 		});
 	},
 	refresh(frm) {
-		if (!frm.is_dirty() && frm.doc.payment_entries.length > 0) {
-			frm.add_custom_button(__("Unreconcile Transaction"), () => {
-				frm.call("remove_payment_entries").then(() => frm.refresh());
-			});
-		}
+		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/bank_transaction.json

@@ -13,7 +13,6 @@
   "status",
   "bank_account",
   "company",
-  "amended_from",
   "section_break_4",
   "deposit",
   "withdrawal",
@@ -26,10 +25,10 @@
   "transaction_id",
   "transaction_type",
   "section_break_14",
-  "column_break_oufv",
   "payment_entries",
   "section_break_18",
   "allocated_amount",
+  "amended_from",
   "column_break_17",
   "unallocated_amount",
   "party_section",
@@ -139,12 +138,10 @@
    "fieldtype": "Section Break"
   },
   {
-   "allow_on_submit": 1,
    "fieldname": "allocated_amount",
    "fieldtype": "Currency",
    "label": "Allocated Amount",
-   "options": "currency",
-   "read_only": 1
+   "options": "currency"
   },
   {
    "fieldname": "amended_from",
@@ -160,12 +157,10 @@
    "fieldtype": "Column Break"
   },
   {
-   "allow_on_submit": 1,
    "fieldname": "unallocated_amount",
    "fieldtype": "Currency",
    "label": "Unallocated Amount",
-   "options": "currency",
-   "read_only": 1
+   "options": "currency"
   },
   {
    "fieldname": "party_section",
@@ -230,15 +225,11 @@
    "fieldname": "bank_party_account_number",
    "fieldtype": "Data",
    "label": "Party Account No. (Bank Statement)"
-  },
-  {
-   "fieldname": "column_break_oufv",
-   "fieldtype": "Column Break"
   }
  ],
  "is_submittable": 1,
  "links": [],
- "modified": "2023-11-18 18:32:47.203694",
+ "modified": "2023-06-06 13:58:12.821411",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Transaction",

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -2,117 +2,101 @@
 # For license information, please see license.txt
 
 import frappe
-from frappe import _
-from frappe.model.document import Document
 from frappe.utils import flt
 
+from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+from erpnext.controllers.status_updater import StatusUpdater
 
-class BankTransaction(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
 
-	from typing import TYPE_CHECKING
+class BankTransaction(StatusUpdater):
+	def after_insert(self):
+		self.unallocated_amount = abs(flt(self.withdrawal) - flt(self.deposit))
 
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.bank_transaction_payments.bank_transaction_payments import (
-			BankTransactionPayments,
-		)
-
-		allocated_amount: DF.Currency
-		amended_from: DF.Link | None
-		bank_account: DF.Link | None
-		bank_party_account_number: DF.Data | None
-		bank_party_iban: DF.Data | None
-		bank_party_name: DF.Data | None
-		company: DF.Link | None
-		currency: DF.Link | None
-		date: DF.Date | None
-		deposit: DF.Currency
-		description: DF.SmallText | None
-		naming_series: DF.Literal["ACC-BTN-.YYYY.-"]
-		party: DF.DynamicLink | None
-		party_type: DF.Link | None
-		payment_entries: DF.Table[BankTransactionPayments]
-		reference_number: DF.Data | None
-		status: DF.Literal["", "Pending", "Settled", "Unreconciled", "Reconciled", "Cancelled"]
-		transaction_id: DF.Data | None
-		transaction_type: DF.Data | None
-		unallocated_amount: DF.Currency
-		withdrawal: DF.Currency
-	# end: auto-generated types
-
-	def before_validate(self):
-		self.update_allocated_amount()
-
-	def validate(self):
-		self.validate_duplicate_references()
-
-	def set_status(self):
-		if self.docstatus == 2:
-			self.db_set("status", "Cancelled")
-		elif self.docstatus == 1:
-			if self.unallocated_amount > 0:
-				self.db_set("status", "Unreconciled")
-			elif self.unallocated_amount <= 0:
-				self.db_set("status", "Reconciled")
-
-	def validate_duplicate_references(self):
-		"""Make sure the same voucher is not allocated twice within the same Bank Transaction"""
-		if not self.payment_entries:
-			return
-
-		pe = []
-		for row in self.payment_entries:
-			reference = (row.payment_document, row.payment_entry)
-			if reference in pe:
-				frappe.throw(
-					_("{0} {1} is allocated twice in this Bank Transaction").format(
-						row.payment_document, row.payment_entry
-					)
-				)
-			pe.append(reference)
-
-	def update_allocated_amount(self):
-		self.allocated_amount = (
-			sum(p.allocated_amount for p in self.payment_entries) if self.payment_entries else 0.0
-		)
-		self.unallocated_amount = abs(flt(self.withdrawal) - flt(self.deposit)) - self.allocated_amount
-
-	def before_submit(self):
-		self.allocate_payment_entries()
+	def on_submit(self):
+		self.clear_linked_payment_entries()
 		self.set_status()
 
 		if frappe.db.get_single_value("Accounts Settings", "enable_party_matching"):
 			self.auto_set_party()
 
-	def before_update_after_submit(self):
-		self.validate_duplicate_references()
-		self.allocate_payment_entries()
-		self.update_allocated_amount()
-		self.set_status()
+	_saving_flag = False
+
+	# nosemgrep: frappe-semgrep-rules.rules.frappe-modifying-but-not-comitting
+	def on_update_after_submit(self):
+		"Run on save(). Avoid recursion caused by multiple saves"
+		if not self._saving_flag:
+			self._saving_flag = True
+			self.clear_linked_payment_entries()
+			self.update_allocations()
+			self._saving_flag = False
 
 	def on_cancel(self):
-		for payment_entry in self.payment_entries:
-			self.clear_linked_payment_entry(payment_entry, for_cancel=True)
+		self.clear_linked_payment_entries(for_cancel=True)
+		self.set_status(update=True)
 
-		self.set_status()
+	def update_allocations(self):
+		"The doctype does not allow modifications after submission, so write to the db direct"
+		if self.payment_entries:
+			allocated_amount = sum(p.allocated_amount for p in self.payment_entries)
+		else:
+			allocated_amount = 0.0
+
+		amount = abs(flt(self.withdrawal) - flt(self.deposit))
+		self.db_set("allocated_amount", flt(allocated_amount))
+		self.db_set("unallocated_amount", amount - flt(allocated_amount))
+		self.reload()
+		self.set_status(update=True)
 
 	def add_payment_entries(self, vouchers):
 		"Add the vouchers with zero allocation. Save() will perform the allocations and clearance"
 		if 0.0 >= self.unallocated_amount:
-			frappe.throw(_("Bank Transaction {0} is already fully reconciled").format(self.name))
+			frappe.throw(frappe._("Bank Transaction {0} is already fully reconciled").format(self.name))
 
+		added = False
 		for voucher in vouchers:
-			self.append(
-				"payment_entries",
-				{
-					"payment_document": voucher["payment_doctype"],
-					"payment_entry": voucher["payment_name"],
+			# Can't add same voucher twice
+			found = False
+			for pe in self.payment_entries:
+				if (
+					pe.payment_document == voucher["payment_doctype"]
+					and pe.payment_entry == voucher["payment_name"]
+				):
+					found = True
+
+			if not found:
+				payment_doctype, payment_name = voucher["payment_doctype"], voucher["payment_name"]
+
+				if self.is_unpaid_invoice(payment_doctype, payment_name):
+					# Make Payment Entry against the unpaid invoice, link PE to Bank Transaction
+					payment_name = self.make_pe_against_invoice(payment_doctype, payment_name)
+					payment_doctype = "Payment Entry"  # Change doctype to PE
+
+				pe = {
+					"payment_document": payment_doctype,
+					"payment_entry": payment_name,
 					"allocated_amount": 0.0,  # Temporary
-				},
-			)
+				}
+				self.append("payment_entries", pe)
+				added = True
+
+		# runs on_update_after_submit
+		if added:
+			self.save()
+
+	def is_unpaid_invoice(self, payment_doctype, payment_name):
+		is_invoice = payment_doctype in ("Sales Invoice", "Purchase Invoice")
+		if not is_invoice:
+			return False
+
+		# Check if the invoice is unpaid
+		return flt(frappe.db.get_value(payment_doctype, payment_name, "outstanding_amount")) > 0
+
+	def make_pe_against_invoice(self, payment_doctype, payment_name):
+		bank_account = frappe.db.get_value("Bank Account", self.bank_account, "account")
+		payment_entry = get_payment_entry(payment_doctype, payment_name, bank_account=bank_account)
+		payment_entry.reference_no = self.reference_number or payment_name
+		payment_entry.submit()
+		return payment_entry.name
 
 	def allocate_payment_entries(self):
 		"""Refactored from bank reconciliation tool.
@@ -128,8 +112,8 @@ class BankTransaction(Document):
 		    - 0 > a: Error: already over-allocated
 		- clear means: set the latest transaction date as clearance date
 		"""
+		gl_bank_account = frappe.db.get_value("Bank Account", self.bank_account, "account")
 		remaining_amount = self.unallocated_amount
-		to_remove = []
 		for payment_entry in self.payment_entries:
 			if payment_entry.allocated_amount == 0.0:
 				unallocated_amount, should_clear, latest_transaction = get_clearance_details(
@@ -139,39 +123,49 @@ class BankTransaction(Document):
 				if 0.0 == unallocated_amount:
 					if should_clear:
 						latest_transaction.clear_linked_payment_entry(payment_entry)
-					to_remove.append(payment_entry)
+					self.db_delete_payment_entry(payment_entry)
 
 				elif remaining_amount <= 0.0:
-					to_remove.append(payment_entry)
+					self.db_delete_payment_entry(payment_entry)
 
-				elif 0.0 < unallocated_amount <= remaining_amount:
-					payment_entry.allocated_amount = unallocated_amount
+				elif 0.0 < unallocated_amount and unallocated_amount <= remaining_amount:
+					payment_entry.db_set("allocated_amount", unallocated_amount)
 					remaining_amount -= unallocated_amount
 					if should_clear:
 						latest_transaction.clear_linked_payment_entry(payment_entry)
 
-				elif 0.0 < unallocated_amount:
-					payment_entry.allocated_amount = remaining_amount
+				elif 0.0 < unallocated_amount and unallocated_amount > remaining_amount:
+					payment_entry.db_set("allocated_amount", remaining_amount)
 					remaining_amount = 0.0
 
 				elif 0.0 > unallocated_amount:
-					frappe.throw(_("Voucher {0} is over-allocated by {1}").format(unallocated_amount))
+					self.db_delete_payment_entry(payment_entry)
+					frappe.throw(frappe._("Voucher {0} is over-allocated by {1}").format(unallocated_amount))
 
-		for payment_entry in to_remove:
-			self.remove(to_remove)
+		self.reload()
+
+	def db_delete_payment_entry(self, payment_entry):
+		frappe.db.delete("Bank Transaction Payments", {"name": payment_entry.name})
 
 	@frappe.whitelist()
 	def remove_payment_entries(self):
 		for payment_entry in self.payment_entries:
 			self.remove_payment_entry(payment_entry)
-
-		self.save()  # runs before_update_after_submit
+		# runs on_update_after_submit
+		self.save()
 
 	def remove_payment_entry(self, payment_entry):
 		"Clear payment entry and clearance"
 		self.clear_linked_payment_entry(payment_entry, for_cancel=True)
 		self.remove(payment_entry)
 
+	def clear_linked_payment_entries(self, for_cancel=False):
+		if for_cancel:
+			for payment_entry in self.payment_entries:
+				self.clear_linked_payment_entry(payment_entry, for_cancel)
+		else:
+			self.allocate_payment_entries()
+
 	def clear_linked_payment_entry(self, payment_entry, for_cancel=False):
 		clearance_date = None if for_cancel else self.date
 		set_voucher_clearance(
@@ -192,10 +186,11 @@ class BankTransaction(Document):
 			deposit=self.deposit,
 		).match()
 
-		if not result:
-			return
-
-		self.party_type, self.party = result
+		if result:
+			party_type, party = result
+			frappe.db.set_value(
+				"Bank Transaction", self.name, field={"party_type": party_type, "party": party}
+			)
 
 
 @frappe.whitelist()
@@ -227,7 +222,9 @@ def get_clearance_details(transaction, payment_entry):
 		if gle["gl_account"] == gl_bank_account:
 			if gle["amount"] <= 0.0:
 				frappe.throw(
-					_("Voucher {0} value is broken: {1}").format(payment_entry.payment_entry, gle["amount"])
+					frappe._("Voucher {0} value is broken: {1}").format(
+						payment_entry.payment_entry, gle["amount"]
+					)
 				)
 
 			unmatched_gles -= 1
@@ -248,7 +245,7 @@ def get_clearance_details(transaction, payment_entry):
 
 def get_related_bank_gl_entries(doctype, docname):
 	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
-	return frappe.db.sql(
+	result = frappe.db.sql(
 		"""
 		SELECT
 			ABS(gle.credit_in_account_currency - gle.debit_in_account_currency) AS amount,
@@ -266,6 +263,7 @@ def get_related_bank_gl_entries(doctype, docname):
 		dict(doctype=doctype, docname=docname),
 		as_dict=True,
 	)
+	return result
 
 
 def get_total_allocated_amount(doctype, docname):
@@ -375,25 +373,22 @@ def set_voucher_clearance(doctype, docname, clearance_date, self):
 			and len(get_reconciled_bank_transactions(doctype, docname)) < 2
 		):
 			return
-
-		if doctype == "Sales Invoice":
-			frappe.db.set_value(
-				"Sales Invoice Payment",
-				dict(parenttype=doctype, parent=docname),
-				"clearance_date",
-				clearance_date,
-			)
-			return
-
 		frappe.db.set_value(doctype, docname, "clearance_date", clearance_date)
 
+	elif doctype == "Sales Invoice":
+		frappe.db.set_value(
+			"Sales Invoice Payment",
+			dict(parenttype=doctype, parent=docname),
+			"clearance_date",
+			clearance_date,
+		)
+
 	elif doctype == "Bank Transaction":
 		# For when a second bank transaction has fixed another, e.g. refund
 		bt = frappe.get_doc(doctype, docname)
 		if clearance_date:
 			vouchers = [{"payment_doctype": "Bank Transaction", "payment_name": self.name}]
 			bt.add_payment_entries(vouchers)
-			bt.save()
 		else:
 			for pe in bt.payment_entries:
 				if pe.payment_document == self.doctype and pe.payment_entry == self.name:

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]["party"] == "Conrad Electronic")
+		self.assertTrue(linked_payments[0][6] == "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]["paid_amount"])
+		self.assertTrue(linked_payments[0][3])
 
 	# 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]["name"], repayment_entry.name)
+		self.assertEqual(linked_payments[0][2], repayment_entry.name)
 
 
 @if_lending_app_installed
@@ -410,7 +410,7 @@ def add_vouchers():
 def create_loan_and_repayment():
 	from lending.loan_management.doctype.loan.test_loan import (
 		create_loan,
-		create_loan_product,
+		create_loan_type,
 		create_repayment_entry,
 		make_loan_disbursement_entry,
 	)
@@ -420,8 +420,7 @@ def create_loan_and_repayment():
 
 	from erpnext.setup.doctype.employee.test_employee import make_employee
 
-	create_loan_product(
-		"Personal Loan",
+	create_loan_type(
 		"Personal Loan",
 		500000,
 		8.4,
@@ -442,7 +441,7 @@ def create_loan_and_repayment():
 			"applicant_type": "Employee",
 			"company": "_Test Company",
 			"applicant": applicant,
-			"loan_product": "Personal Loan",
+			"loan_type": "Personal Loan",
 			"loan_amount": 5000,
 			"repayment_method": "Repay Fixed Amount per Period",
 			"monthly_repayment_amount": 500,

erpnext/accounts/doctype/bank_transaction_mapping/bank_transaction_mapping.py

@@ -6,19 +6,4 @@ from frappe.model.document import Document
 
 
 class BankTransactionMapping(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		bank_transaction_field: DF.Literal
-		file_field: DF.Data
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/bank_transaction_payments/bank_transaction_payments.py

@@ -6,21 +6,4 @@ from frappe.model.document import Document
 
 
 class BankTransactionPayments(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		allocated_amount: DF.Currency
-		clearance_date: DF.Date | None
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-		payment_document: DF.Link
-		payment_entry: DF.DynamicLink
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/budget/budget.py

@@ -22,36 +22,6 @@ class DuplicateBudgetError(frappe.ValidationError):
 
 
 class Budget(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.budget_account.budget_account import BudgetAccount
-
-		accounts: DF.Table[BudgetAccount]
-		action_if_accumulated_monthly_budget_exceeded: DF.Literal["", "Stop", "Warn", "Ignore"]
-		action_if_accumulated_monthly_budget_exceeded_on_mr: DF.Literal["", "Stop", "Warn", "Ignore"]
-		action_if_accumulated_monthly_budget_exceeded_on_po: DF.Literal["", "Stop", "Warn", "Ignore"]
-		action_if_annual_budget_exceeded: DF.Literal["", "Stop", "Warn", "Ignore"]
-		action_if_annual_budget_exceeded_on_mr: DF.Literal["", "Stop", "Warn", "Ignore"]
-		action_if_annual_budget_exceeded_on_po: DF.Literal["", "Stop", "Warn", "Ignore"]
-		amended_from: DF.Link | None
-		applicable_on_booking_actual_expenses: DF.Check
-		applicable_on_material_request: DF.Check
-		applicable_on_purchase_order: DF.Check
-		budget_against: DF.Literal["", "Cost Center", "Project"]
-		company: DF.Link
-		cost_center: DF.Link | None
-		fiscal_year: DF.Link
-		monthly_distribution: DF.Link | None
-		naming_series: DF.Data | None
-		project: DF.Link | None
-	# end: auto-generated types
-
 	def validate(self):
 		if not self.get(frappe.scrub(self.budget_against)):
 			frappe.throw(_("{0} is mandatory").format(self.budget_against))

erpnext/accounts/doctype/budget_account/budget_account.py

@@ -6,19 +6,4 @@ from frappe.model.document import Document
 
 
 class BudgetAccount(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account: DF.Link
-		budget_amount: DF.Currency
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/campaign_item/campaign_item.py

@@ -6,18 +6,4 @@ from frappe.model.document import Document
 
 
 class CampaignItem(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		campaign: DF.Link | None
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/cashier_closing/cashier_closing.json

@@ -1,152 +1,457 @@
 {
- "actions": [],
+ "allow_copy": 0,
+ "allow_events_in_timeline": 0,
+ "allow_guest_to_view": 0,
+ "allow_import": 0,
+ "allow_rename": 0,
  "autoname": "naming_series:",
+ "beta": 0,
  "creation": "2018-06-18 16:51:49.994750",
+ "custom": 0,
+ "docstatus": 0,
  "doctype": "DocType",
+ "document_type": "",
  "editable_grid": 1,
  "engine": "InnoDB",
- "field_order": [
-  "naming_series",
-  "user",
-  "date",
-  "from_time",
-  "time",
-  "expense",
-  "custody",
-  "returns",
-  "outstanding_amount",
-  "payments",
-  "net_amount",
-  "amended_from"
- ],
  "fields": [
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "POS-CLO-",
    "fieldname": "naming_series",
    "fieldtype": "Select",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
    "in_global_search": 1,
+   "in_list_view": 0,
    "in_standard_filter": 1,
    "label": "Series",
+   "length": 0,
+   "no_copy": 0,
    "options": "POS-CLO-",
-   "read_only": 1
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 1,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "fieldname": "user",
    "fieldtype": "Link",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "User",
+   "length": 0,
+   "no_copy": 0,
    "options": "User",
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
    "read_only": 1,
-   "reqd": 1
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 1,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "Today",
    "fieldname": "date",
    "fieldtype": "Date",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
+   "in_list_view": 0,
    "in_standard_filter": 1,
    "label": "Date",
-   "read_only": 1
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 1,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "fieldname": "from_time",
    "fieldtype": "Time",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
+   "in_list_view": 0,
    "in_standard_filter": 1,
    "label": "From Time",
-   "reqd": 1
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 1,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
+   "default": "",
    "fieldname": "time",
    "fieldtype": "Time",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
+   "in_list_view": 0,
    "in_standard_filter": 1,
    "label": "To Time",
-   "reqd": 1
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 1,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "0.00",
    "fieldname": "expense",
    "fieldtype": "Float",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
-   "label": "Expense"
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
+   "label": "Expense",
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "0.00",
    "fieldname": "custody",
    "fieldtype": "Float",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
-   "label": "Custody"
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
+   "label": "Custody",
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "0.00",
    "fieldname": "returns",
    "fieldtype": "Float",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
    "label": "Returns",
-   "precision": "2"
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "2",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "0.00",
    "fieldname": "outstanding_amount",
    "fieldtype": "Float",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
+   "in_filter": 0,
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
    "label": "Outstanding Amount",
-   "read_only": 1
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 1,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
+   "default": "0.0",
    "fieldname": "payments",
    "fieldtype": "Table",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
    "label": "Payments",
-   "options": "Cashier Closing Payments"
+   "length": 0,
+   "no_copy": 0,
+   "options": "Cashier Closing Payments",
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "fieldname": "net_amount",
    "fieldtype": "Float",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Net Amount",
-   "read_only": 1
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 1,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "fieldname": "amended_from",
    "fieldtype": "Link",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
+   "in_filter": 0,
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
    "label": "Amended From",
+   "length": 0,
    "no_copy": 1,
    "options": "Cashier Closing",
+   "permlevel": 0,
    "print_hide": 1,
-   "read_only": 1
+   "print_hide_if_no_value": 0,
+   "read_only": 1,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   }
  ],
+ "has_web_view": 0,
+ "hide_heading": 0,
+ "hide_toolbar": 0,
+ "idx": 0,
+ "image_view": 0,
+ "in_create": 0,
  "is_submittable": 1,
- "links": [],
- "modified": "2023-12-28 13:15:46.858427",
+ "issingle": 0,
+ "istable": 0,
+ "max_attachments": 0,
+ "modified": "2019-02-19 08:35:24.157327",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Cashier Closing",
- "naming_rule": "By \"Naming Series\" field",
+ "name_case": "",
  "owner": "Administrator",
  "permissions": [
   {
+   "amend": 0,
+   "cancel": 0,
    "create": 1,
    "delete": 1,
    "email": 1,
    "export": 1,
+   "if_owner": 0,
+   "import": 0,
+   "permlevel": 0,
    "print": 1,
    "read": 1,
    "report": 1,
    "role": "System Manager",
+   "set_user_permissions": 0,
    "share": 1,
    "submit": 1,
    "write": 1
   }
  ],
+ "quick_entry": 0,
+ "read_only": 0,
+ "read_only_onload": 0,
+ "show_name_in_global_search": 0,
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
- "track_changes": 1
-}
+ "track_changes": 1,
+ "track_seen": 0,
+ "track_views": 0
+}

erpnext/accounts/doctype/cashier_closing/cashier_closing.py

@@ -9,32 +9,6 @@ from frappe.utils import flt
 
 
 class CashierClosing(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.cashier_closing_payments.cashier_closing_payments import (
-			CashierClosingPayments,
-		)
-
-		amended_from: DF.Link | None
-		custody: DF.Float
-		date: DF.Date | None
-		expense: DF.Float
-		from_time: DF.Time
-		naming_series: DF.Literal["POS-CLO-"]
-		net_amount: DF.Float
-		outstanding_amount: DF.Float
-		payments: DF.Table[CashierClosingPayments]
-		returns: DF.Float
-		time: DF.Time
-		user: DF.Link
-	# end: auto-generated types
-
 	def validate(self):
 		self.validate_time()
 

erpnext/accounts/doctype/cashier_closing_payments/cashier_closing_payments.py

@@ -6,19 +6,4 @@ from frappe.model.document import Document
 
 
 class CashierClosingPayments(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		amount: DF.Float
-		mode_of_payment: DF.Link
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js

@@ -53,18 +53,10 @@ frappe.ui.form.on('Chart of Accounts Importer', {
 								of Accounts. Please enter the account names and add more rows as per your requirement.`);
 						}
 					}
-				},
-				{
-					label : "Company",
-					fieldname: "company",
-					fieldtype: "Link",
-					reqd: 1,
-					hidden: 1,
-					default: frm.doc.company,
-				},
+				}
 			],
 			primary_action: function() {
-				let data = d.get_values();
+				var data = d.get_values();
 
 				if (!data.template_type) {
 					frappe.throw(__('Please select <b>Template Type</b> to download template'));
@@ -74,8 +66,7 @@ frappe.ui.form.on('Chart of Accounts Importer', {
 					'/api/method/erpnext.accounts.doctype.chart_of_accounts_importer.chart_of_accounts_importer.download_template',
 					{
 						file_type: data.file_type,
-						template_type: data.template_type,
-						company: data.company
+						template_type: data.template_type
 					}
 				);
 

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -8,7 +8,6 @@ from functools import reduce
 
 import frappe
 from frappe import _
-from frappe.desk.form.linked_with import get_linked_fields
 from frappe.model.document import Document
 from frappe.utils import cint, cstr
 from frappe.utils.csvutils import UnicodeWriter
@@ -24,18 +23,6 @@ from erpnext.accounts.doctype.account.chart_of_accounts.chart_of_accounts import
 
 
 class ChartofAccountsImporter(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		company: DF.Link | None
-		import_file: DF.Attach | None
-	# end: auto-generated types
-
 	def validate(self):
 		if self.import_file:
 			get_coa(
@@ -125,7 +112,7 @@ def generate_data_from_csv(file_doc, as_dict=False):
 			if as_dict:
 				data.append({frappe.scrub(header): row[index] for index, header in enumerate(headers)})
 			else:
-				if not row[1] and len(row) > 1:
+				if not row[1]:
 					row[1] = row[0]
 					row[3] = row[2]
 				data.append(row)
@@ -307,8 +294,10 @@ def build_response_as_excel(writer):
 
 
 @frappe.whitelist()
-def download_template(file_type, template_type, company):
-	writer = get_template(template_type, company)
+def download_template(file_type, template_type):
+	data = frappe._dict(frappe.local.form_dict)
+
+	writer = get_template(template_type)
 
 	if file_type == "CSV":
 		# download csv file
@@ -319,7 +308,8 @@ def download_template(file_type, template_type, company):
 		build_response_as_excel(writer)
 
 
-def get_template(template_type, company):
+def get_template(template_type):
+
 	fields = [
 		"Account Name",
 		"Parent Account",
@@ -345,17 +335,34 @@ def get_template(template_type, company):
 				["", "", "", "", 0, account_type.get("account_type"), account_type.get("root_type")]
 			)
 	else:
-		writer = get_sample_template(writer, company)
+		writer = get_sample_template(writer)
 
 	return writer
 
 
-def get_sample_template(writer, company):
-	currency = frappe.db.get_value("Company", company, "default_currency")
-	with open(os.path.join(os.path.dirname(__file__), "coa_sample_template.csv"), "r") as f:
-		for row in f:
-			row = row.strip().split(",") + [currency]
-			writer.writerow(row)
+def get_sample_template(writer):
+	template = [
+		["Application Of Funds(Assets)", "", "", "", 1, "", "Asset"],
+		["Sources Of Funds(Liabilities)", "", "", "", 1, "", "Liability"],
+		["Equity", "", "", "", 1, "", "Equity"],
+		["Expenses", "", "", "", 1, "", "Expense"],
+		["Income", "", "", "", 1, "", "Income"],
+		["Bank Accounts", "Application Of Funds(Assets)", "", "", 1, "Bank", "Asset"],
+		["Cash In Hand", "Application Of Funds(Assets)", "", "", 1, "Cash", "Asset"],
+		["Stock Assets", "Application Of Funds(Assets)", "", "", 1, "Stock", "Asset"],
+		["Cost Of Goods Sold", "Expenses", "", "", 0, "Cost of Goods Sold", "Expense"],
+		["Asset Depreciation", "Expenses", "", "", 0, "Depreciation", "Expense"],
+		["Fixed Assets", "Application Of Funds(Assets)", "", "", 0, "Fixed Asset", "Asset"],
+		["Accounts Payable", "Sources Of Funds(Liabilities)", "", "", 0, "Payable", "Liability"],
+		["Accounts Receivable", "Application Of Funds(Assets)", "", "", 1, "Receivable", "Asset"],
+		["Stock Expenses", "Expenses", "", "", 0, "Stock Adjustment", "Expense"],
+		["Sample Bank", "Bank Accounts", "", "", 0, "Bank", "Asset"],
+		["Cash", "Cash In Hand", "", "", 0, "Cash", "Asset"],
+		["Stores", "Stock Assets", "", "", 0, "Stock", "Asset"],
+	]
+
+	for row in template:
+		writer.writerow(row)
 
 	return writer
 
@@ -446,11 +453,14 @@ def get_mandatory_account_types():
 
 
 def unset_existing_data(company):
-	# remove accounts data from company
+	linked = frappe.db.sql(
+		'''select fieldname from tabDocField
+		where fieldtype="Link" and options="Account" and parent="Company"''',
+		as_dict=True,
+	)
 
-	fieldnames = get_linked_fields("Account").get("Company", {}).get("fieldname", [])
-	linked = [{"fieldname": name} for name in fieldnames]
-	update_values = {d.get("fieldname"): "" for d in linked}
+	# remove accounts data from company
+	update_values = {d.fieldname: "" for d in linked}
 	frappe.db.set_value("Company", company, update_values, update_values)
 
 	# remove accounts data from various doctypes

erpnext/accounts/doctype/chart_of_accounts_importer/coa_sample_template.csv

@@ -1,17 +0,0 @@
-Application Of Funds(Assets),,,,1,,Asset
-Sources Of Funds(Liabilities),,,,1,,Liability
-Equity,,,,1,,Equity
-Expenses,,,,1,Expense Account,Expense
-Income,,,,1,Income Account,Income
-Bank Accounts,Application Of Funds(Assets),,,1,Bank,Asset
-Cash In Hand,Application Of Funds(Assets),,,1,Cash,Asset
-Stock Assets,Application Of Funds(Assets),,,1,Stock,Asset
-Cost Of Goods Sold,Expenses,,,0,Cost of Goods Sold,Expense
-Asset Depreciation,Expenses,,,0,Depreciation,Expense
-Fixed Assets,Application Of Funds(Assets),,,0,Fixed Asset,Asset
-Accounts Payable,Sources Of Funds(Liabilities),,,0,Payable,Liability
-Accounts Receivable,Application Of Funds(Assets),,,1,Receivable,Asset
-Stock Expenses,Expenses,,,0,Stock Adjustment,Expense
-Sample Bank,Bank Accounts,,,0,Bank,Asset
-Cash,Cash In Hand,,,0,Cash,Asset
-Stores,Stock Assets,,,0,Stock,Asset

erpnext/accounts/doctype/cheque_print_template/cheque_print_template.py

@@ -8,41 +8,6 @@ from frappe.model.document import Document
 
 
 class ChequePrintTemplate(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		acc_no_dist_from_left_edge: DF.Float
-		acc_no_dist_from_top_edge: DF.Float
-		acc_pay_dist_from_left_edge: DF.Float
-		acc_pay_dist_from_top_edge: DF.Float
-		amt_in_figures_from_left_edge: DF.Float
-		amt_in_figures_from_top_edge: DF.Float
-		amt_in_word_width: DF.Float
-		amt_in_words_from_left_edge: DF.Float
-		amt_in_words_from_top_edge: DF.Float
-		amt_in_words_line_spacing: DF.Float
-		bank_name: DF.Data
-		cheque_height: DF.Float
-		cheque_size: DF.Literal["", "Regular", "A4"]
-		cheque_width: DF.Float
-		date_dist_from_left_edge: DF.Float
-		date_dist_from_top_edge: DF.Float
-		has_print_format: DF.Check
-		is_account_payable: DF.Check
-		message_to_show: DF.Data | None
-		payer_name_from_left_edge: DF.Float
-		payer_name_from_top_edge: DF.Float
-		scanned_cheque: DF.Attach | None
-		signatory_from_left_edge: DF.Float
-		signatory_from_top_edge: DF.Float
-		starting_position_from_top_edge: DF.Float
-	# end: auto-generated types
-
 	pass
 
 

erpnext/accounts/doctype/closed_document/closed_document.py

@@ -6,19 +6,4 @@ from frappe.model.document import Document
 
 
 class ClosedDocument(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		closed: DF.Check
-		document_type: DF.Link
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/cost_center/cost_center.py

@@ -10,25 +10,6 @@ from erpnext.accounts.utils import validate_field_number
 
 
 class CostCenter(NestedSet):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		company: DF.Link
-		cost_center_name: DF.Data
-		cost_center_number: DF.Data | None
-		disabled: DF.Check
-		is_group: DF.Check
-		lft: DF.Int
-		old_parent: DF.Link | None
-		parent_cost_center: DF.Link
-		rgt: DF.Int
-	# end: auto-generated types
-
 	nsm_parent_field = "parent_cost_center"
 
 	def autoname(self):

erpnext/accounts/doctype/cost_center_allocation/cost_center_allocation.py

@@ -28,25 +28,6 @@ class InvalidDateError(frappe.ValidationError):
 
 
 class CostCenterAllocation(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.cost_center_allocation_percentage.cost_center_allocation_percentage import (
-			CostCenterAllocationPercentage,
-		)
-
-		allocation_percentages: DF.Table[CostCenterAllocationPercentage]
-		amended_from: DF.Link | None
-		company: DF.Link
-		main_cost_center: DF.Link
-		valid_from: DF.Date
-	# end: auto-generated types
-
 	def __init__(self, *args, **kwargs):
 		super(CostCenterAllocation, self).__init__(*args, **kwargs)
 		self._skip_from_date_validation = False

erpnext/accounts/doctype/cost_center_allocation_percentage/cost_center_allocation_percentage.py

@@ -6,19 +6,4 @@ from frappe.model.document import Document
 
 
 class CostCenterAllocationPercentage(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		cost_center: DF.Link
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-		percentage: DF.Percent
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/coupon_code/coupon_code.py

@@ -9,27 +9,6 @@ from frappe.utils import strip
 
 
 class CouponCode(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		amended_from: DF.Link | None
-		coupon_code: DF.Data | None
-		coupon_name: DF.Data
-		coupon_type: DF.Literal["Promotional", "Gift Card"]
-		customer: DF.Link | None
-		description: DF.TextEditor | None
-		maximum_use: DF.Int
-		pricing_rule: DF.Link
-		used: DF.Int
-		valid_from: DF.Date | None
-		valid_upto: DF.Date | None
-	# end: auto-generated types
-
 	def autoname(self):
 		self.coupon_name = strip(self.coupon_name)
 		self.name = self.coupon_name

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.json

@@ -9,7 +9,6 @@
   "disabled",
   "service_provider",
   "api_endpoint",
-  "access_key",
   "url",
   "column_break_3",
   "help",
@@ -85,18 +84,12 @@
    "fieldname": "disabled",
    "fieldtype": "Check",
    "label": "Disabled"
-  },
-  {
-   "depends_on": "eval:doc.service_provider == 'exchangerate.host';",
-   "fieldname": "access_key",
-   "fieldtype": "Data",
-   "label": "Access Key"
   }
  ],
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-10-04 15:30:25.333860",
+ "modified": "2023-01-09 12:19:03.955906",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Currency Exchange Settings",

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.py

@@ -9,30 +9,6 @@ from frappe.utils import nowdate
 
 
 class CurrencyExchangeSettings(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.currency_exchange_settings_details.currency_exchange_settings_details import (
-			CurrencyExchangeSettingsDetails,
-		)
-		from erpnext.accounts.doctype.currency_exchange_settings_result.currency_exchange_settings_result import (
-			CurrencyExchangeSettingsResult,
-		)
-
-		access_key: DF.Data | None
-		api_endpoint: DF.Data
-		disabled: DF.Check
-		req_params: DF.Table[CurrencyExchangeSettingsDetails]
-		result_key: DF.Table[CurrencyExchangeSettingsResult]
-		service_provider: DF.Literal["frankfurter.app", "exchangerate.host", "Custom"]
-		url: DF.Data | None
-	# end: auto-generated types
-
 	def validate(self):
 		self.set_parameters_and_result()
 		if frappe.flags.in_test or frappe.flags.in_install or frappe.flags.in_setup_wizard:
@@ -42,21 +18,11 @@ class CurrencyExchangeSettings(Document):
 
 	def set_parameters_and_result(self):
 		if self.service_provider == "exchangerate.host":
-
-			if not self.access_key:
-				frappe.throw(
-					_("Access Key is required for Service Provider: {0}").format(
-						frappe.bold(self.service_provider)
-					)
-				)
-
 			self.set("result_key", [])
 			self.set("req_params", [])
 
 			self.api_endpoint = "https://api.exchangerate.host/convert"
 			self.append("result_key", {"key": "result"})
-			self.append("req_params", {"key": "access_key", "value": self.access_key})
-			self.append("req_params", {"key": "amount", "value": "1"})
 			self.append("req_params", {"key": "date", "value": "{transaction_date}"})
 			self.append("req_params", {"key": "from", "value": "{from_currency}"})
 			self.append("req_params", {"key": "to", "value": "{to_currency}"})

erpnext/accounts/doctype/currency_exchange_settings_details/currency_exchange_settings_details.py

@@ -6,19 +6,4 @@ from frappe.model.document import Document
 
 
 class CurrencyExchangeSettingsDetails(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		key: DF.Data
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-		value: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/currency_exchange_settings_result/currency_exchange_settings_result.py

@@ -6,18 +6,4 @@ from frappe.model.document import Document
 
 
 class CurrencyExchangeSettingsResult(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		key: DF.Data
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/customer_group_item/customer_group_item.py

@@ -6,18 +6,4 @@ from frappe.model.document import Document
 
 
 class CustomerGroupItem(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		customer_group: DF.Link | None
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/customer_item/customer_item.py

@@ -6,18 +6,4 @@ from frappe.model.document import Document
 
 
 class CustomerItem(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		customer: DF.Link | None
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/discounted_invoice/discounted_invoice.py

@@ -7,22 +7,4 @@ from frappe.model.document import Document
 
 
 class DiscountedInvoice(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		customer: DF.Link | None
-		debit_to: DF.Link | None
-		outstanding_amount: DF.Currency
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-		posting_date: DF.Date | None
-		sales_invoice: DF.Link
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/dunning/dunning.py

@@ -22,52 +22,6 @@ from erpnext.controllers.accounts_controller import AccountsController
 
 
 class Dunning(AccountsController):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.overdue_payment.overdue_payment import OverduePayment
-
-		address_display: DF.SmallText | None
-		amended_from: DF.Link | None
-		base_dunning_amount: DF.Currency
-		body_text: DF.TextEditor | None
-		closing_text: DF.TextEditor | None
-		company: DF.Link
-		company_address: DF.Link | None
-		company_address_display: DF.SmallText | None
-		contact_display: DF.SmallText | None
-		contact_email: DF.Data | None
-		contact_mobile: DF.SmallText | None
-		contact_person: DF.Link | None
-		conversion_rate: DF.Float
-		cost_center: DF.Link | None
-		currency: DF.Link | None
-		customer: DF.Link
-		customer_address: DF.Link | None
-		customer_name: DF.Data | None
-		dunning_amount: DF.Currency
-		dunning_fee: DF.Currency
-		dunning_type: DF.Link | None
-		grand_total: DF.Currency
-		income_account: DF.Link | None
-		language: DF.Link | None
-		letter_head: DF.Link | None
-		naming_series: DF.Literal["DUNN-.MM.-.YY.-"]
-		overdue_payments: DF.Table[OverduePayment]
-		posting_date: DF.Date
-		posting_time: DF.Time | None
-		rate_of_interest: DF.Float
-		spacer: DF.Data | None
-		status: DF.Literal["Draft", "Resolved", "Unresolved", "Cancelled"]
-		total_interest: DF.Currency
-		total_outstanding: DF.Currency
-	# end: auto-generated types
-
 	def validate(self):
 		self.validate_same_currency()
 		self.validate_overdue_payments()

erpnext/accounts/doctype/dunning_letter_text/dunning_letter_text.py

@@ -7,21 +7,4 @@ from frappe.model.document import Document
 
 
 class DunningLetterText(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		body_text: DF.TextEditor | None
-		closing_text: DF.TextEditor | None
-		is_default_language: DF.Check
-		language: DF.Link | None
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/dunning_type/dunning_type.py

@@ -7,26 +7,6 @@ from frappe.model.document import Document
 
 
 class DunningType(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.dunning_letter_text.dunning_letter_text import DunningLetterText
-
-		company: DF.Link
-		cost_center: DF.Link | None
-		dunning_fee: DF.Currency
-		dunning_letter_text: DF.Table[DunningLetterText]
-		dunning_type: DF.Data
-		income_account: DF.Link | None
-		is_default: DF.Check
-		rate_of_interest: DF.Float
-	# end: auto-generated types
-
 	def autoname(self):
 		company_abbr = frappe.get_value("Company", self.company, "abbr")
 		self.name = f"{self.dunning_type} - {company_abbr}"

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -17,28 +17,6 @@ from erpnext.setup.utils import get_exchange_rate
 
 
 class ExchangeRateRevaluation(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.exchange_rate_revaluation_account.exchange_rate_revaluation_account import (
-			ExchangeRateRevaluationAccount,
-		)
-
-		accounts: DF.Table[ExchangeRateRevaluationAccount]
-		amended_from: DF.Link | None
-		company: DF.Link
-		gain_loss_booked: DF.Currency
-		gain_loss_unbooked: DF.Currency
-		posting_date: DF.Date
-		rounding_loss_allowance: DF.Float
-		total_gain_loss: DF.Currency
-	# end: auto-generated types
-
 	def validate(self):
 		self.validate_rounding_loss_allowance()
 		self.set_total_gain_loss()
@@ -214,7 +192,7 @@ class ExchangeRateRevaluation(Document):
 				# round off balance based on currency precision
 				# and consider debit-credit difference allowance
 				currency_precision = get_currency_precision()
-				rounding_loss_allowance = float(rounding_loss_allowance)
+				rounding_loss_allowance = float(rounding_loss_allowance) or 0.05
 				for acc in account_details:
 					acc.balance_in_account_currency = flt(acc.balance_in_account_currency, currency_precision)
 					if abs(acc.balance_in_account_currency) <= rounding_loss_allowance:

erpnext/accounts/doctype/exchange_rate_revaluation/test_exchange_rate_revaluation.py

@@ -3,296 +3,6 @@
 
 import unittest
 
-import frappe
-from frappe import qb
-from frappe.tests.utils import FrappeTestCase, change_settings
-from frappe.utils import add_days, flt, today
 
-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))
+class TestExchangeRateRevaluation(unittest.TestCase):
+	pass

erpnext/accounts/doctype/exchange_rate_revaluation_account/exchange_rate_revaluation_account.py

@@ -6,29 +6,4 @@ from frappe.model.document import Document
 
 
 class ExchangeRateRevaluationAccount(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account: DF.Link
-		account_currency: DF.Link | None
-		balance_in_account_currency: DF.Currency
-		balance_in_base_currency: DF.Currency
-		current_exchange_rate: DF.Float
-		gain_loss: DF.Currency
-		new_balance_in_account_currency: DF.Currency
-		new_balance_in_base_currency: DF.Currency
-		new_exchange_rate: DF.Float
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-		party: DF.DynamicLink | None
-		party_type: DF.Link | None
-		zero_balance: DF.Check
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/finance_book/finance_book.py

@@ -6,15 +6,4 @@ from frappe.model.document import Document
 
 
 class FinanceBook(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		finance_book_name: DF.Data | None
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/fiscal_year/fiscal_year.py

@@ -10,25 +10,6 @@ from frappe.utils import add_days, add_years, cstr, getdate
 
 
 class FiscalYear(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.fiscal_year_company.fiscal_year_company import FiscalYearCompany
-
-		auto_created: DF.Check
-		companies: DF.Table[FiscalYearCompany]
-		disabled: DF.Check
-		is_short_year: DF.Check
-		year: DF.Data
-		year_end_date: DF.Date
-		year_start_date: DF.Date
-	# end: auto-generated types
-
 	def validate(self):
 		self.validate_dates()
 		self.validate_overlap()

erpnext/accounts/doctype/fiscal_year_company/fiscal_year_company.py

@@ -6,18 +6,4 @@ from frappe.model.document import Document
 
 
 class FiscalYearCompany(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		company: DF.Link | None
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/gl_entry/gl_entry.json

@@ -21,7 +21,6 @@
   "against_voucher_type",
   "against_voucher",
   "voucher_type",
-  "voucher_subtype",
   "voucher_no",
   "voucher_detail_no",
   "project",
@@ -143,7 +142,8 @@
    "label": "Against Voucher Type",
    "oldfieldname": "against_voucher_type",
    "oldfieldtype": "Data",
-   "options": "DocType"
+   "options": "DocType",
+   "search_index": 1
   },
   {
    "fieldname": "against_voucher",
@@ -162,7 +162,8 @@
    "label": "Voucher Type",
    "oldfieldname": "voucher_type",
    "oldfieldtype": "Select",
-   "options": "DocType"
+   "options": "DocType",
+   "search_index": 1
   },
   {
    "fieldname": "voucher_no",
@@ -279,18 +280,13 @@
    "fieldtype": "Currency",
    "label": "Credit Amount in Transaction Currency",
    "options": "transaction_currency"
-  },
-  {
-   "fieldname": "voucher_subtype",
-   "fieldtype": "Small Text",
-   "label": "Voucher Subtype"
   }
  ],
  "icon": "fa fa-list",
  "idx": 1,
  "in_create": 1,
  "links": [],
- "modified": "2023-12-18 15:38:14.006208",
+ "modified": "2023-08-16 21:38:44.072267",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "GL Entry",
@@ -325,4 +321,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -28,50 +28,6 @@ exclude_from_linked_with = True
 
 
 class GLEntry(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		account: DF.Link | None
-		account_currency: DF.Link | None
-		against: DF.Text | None
-		against_link: DF.DynamicLink | None
-		against_type: DF.Link | None
-		against_voucher: DF.DynamicLink | None
-		against_voucher_type: DF.Link | None
-		company: DF.Link | None
-		cost_center: DF.Link | None
-		credit: DF.Currency
-		credit_in_account_currency: DF.Currency
-		credit_in_transaction_currency: DF.Currency
-		debit: DF.Currency
-		debit_in_account_currency: DF.Currency
-		debit_in_transaction_currency: DF.Currency
-		due_date: DF.Date | None
-		finance_book: DF.Link | None
-		fiscal_year: DF.Link | None
-		is_advance: DF.Literal["No", "Yes"]
-		is_cancelled: DF.Check
-		is_opening: DF.Literal["No", "Yes"]
-		party: DF.DynamicLink | None
-		party_type: DF.Link | None
-		posting_date: DF.Date | None
-		project: DF.Link | None
-		remarks: DF.Text | None
-		to_rename: DF.Check
-		transaction_currency: DF.Link | None
-		transaction_date: DF.Date | None
-		transaction_exchange_rate: DF.Float
-		voucher_detail_no: DF.Data | None
-		voucher_no: DF.DynamicLink | None
-		voucher_subtype: DF.SmallText | None
-		voucher_type: DF.Link | None
-	# end: auto-generated types
-
 	def autoname(self):
 		"""
 		Temporarily name doc for fast insertion

erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py

@@ -17,34 +17,6 @@ from erpnext.controllers.accounts_controller import AccountsController
 
 
 class InvoiceDiscounting(AccountsController):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.discounted_invoice.discounted_invoice import DiscountedInvoice
-
-		accounts_receivable_credit: DF.Link
-		accounts_receivable_discounted: DF.Link
-		accounts_receivable_unpaid: DF.Link
-		amended_from: DF.Link | None
-		bank_account: DF.Link
-		bank_charges: DF.Currency
-		bank_charges_account: DF.Link
-		company: DF.Link
-		invoices: DF.Table[DiscountedInvoice]
-		loan_end_date: DF.Date | None
-		loan_period: DF.Int
-		loan_start_date: DF.Date | None
-		posting_date: DF.Date
-		short_term_loan: DF.Link
-		status: DF.Literal["Draft", "Sanctioned", "Disbursed", "Settled", "Cancelled"]
-		total_amount: DF.Currency
-	# end: auto-generated types
-
 	def validate(self):
 		self.validate_mandatory()
 		self.validate_invoices()

erpnext/accounts/doctype/item_tax_template/item_tax_template.py

@@ -8,24 +8,6 @@ from frappe.model.document import Document
 
 
 class ItemTaxTemplate(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.item_tax_template_detail.item_tax_template_detail import (
-			ItemTaxTemplateDetail,
-		)
-
-		company: DF.Link
-		disabled: DF.Check
-		taxes: DF.Table[ItemTaxTemplateDetail]
-		title: DF.Data
-	# end: auto-generated types
-
 	def validate(self):
 		self.validate_tax_accounts()
 

erpnext/accounts/doctype/item_tax_template_detail/item_tax_template_detail.py

@@ -6,19 +6,4 @@ from frappe.model.document import Document
 
 
 class ItemTaxTemplateDetail(Document):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		parent: DF.Data
-		parentfield: DF.Data
-		parenttype: DF.Data
-		tax_rate: DF.Float
-		tax_type: DF.Link
-	# end: auto-generated types
-
 	pass

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -8,7 +8,7 @@ frappe.provide("erpnext.journal_entry");
 frappe.ui.form.on("Journal Entry", {
 	setup: function(frm) {
 		frm.add_fetch("bank_account", "account", "account");
-		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', 'Journal Entry', "Repost Payment Ledger", 'Asset', 'Asset Movement', 'Asset Depreciation Schedule', "Repost Accounting Ledger", "Unreconcile Payment", "Unreconcile Payment Entries"];
+		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', 'Journal Entry', "Repost Payment Ledger", 'Asset', 'Asset Movement', 'Asset Depreciation Schedule', "Repost Accounting Ledger"];
 	},
 
 	refresh: function(frm) {
@@ -50,18 +50,8 @@ frappe.ui.form.on("Journal Entry", {
 					frm.trigger("make_inter_company_journal_entry");
 				}, __('Make'));
 		}
+	},
 
-		erpnext.accounts.unreconcile_payment.add_unreconcile_btn(frm);
-	},
-	before_save: function(frm) {
-		if ((frm.doc.docstatus == 0) && (!frm.doc.is_system_generated)) {
-			let payment_entry_references = frm.doc.accounts.filter(elem => (elem.reference_type == "Payment Entry"));
-			if (payment_entry_references.length > 0) {
-				let rows = payment_entry_references.map(x => "#"+x.idx);
-				frappe.throw(__("Rows: {0} have 'Payment Entry' as reference_type. This should not be set manually.", [frappe.utils.comma_and(rows)]));
-			}
-		}
-	},
 	make_inter_company_journal_entry: function(frm) {
 		var d = new frappe.ui.Dialog({
 			title: __("Select Company"),

erpnext/accounts/doctype/journal_entry/journal_entry.json

@@ -548,16 +548,8 @@
  "icon": "fa fa-file-text",
  "idx": 176,
  "is_submittable": 1,
- "links": [
-  {
-   "is_child_table": 1,
-   "link_doctype": "Bank Transaction Payments",
-   "link_fieldname": "payment_entry",
-   "parent_doctype": "Bank Transaction",
-   "table_fieldname": "payment_entries"
-  }
- ],
- "modified": "2023-11-23 12:11:04.128015",
+ "links": [],
+ "modified": "2023-08-10 14:32:22.366895",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry",

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -35,78 +35,6 @@ class StockAccountInvalidTransaction(frappe.ValidationError):
 
 
 class JournalEntry(AccountsController):
-	# begin: auto-generated types
-	# This code is auto-generated. Do not modify anything in this block.
-
-	from typing import TYPE_CHECKING
-
-	if TYPE_CHECKING:
-		from frappe.types import DF
-
-		from erpnext.accounts.doctype.journal_entry_account.journal_entry_account import (
-			JournalEntryAccount,
-		)
-
-		accounts: DF.Table[JournalEntryAccount]
-		amended_from: DF.Link | None
-		apply_tds: DF.Check
-		auto_repeat: DF.Link | None
-		bill_date: DF.Date | None
-		bill_no: DF.Data | None
-		cheque_date: DF.Date | None
-		cheque_no: DF.Data | None
-		clearance_date: DF.Date | None
-		company: DF.Link
-		difference: DF.Currency
-		due_date: DF.Date | None
-		finance_book: DF.Link | None
-		from_template: DF.Link | None
-		inter_company_journal_entry_reference: DF.Link | None
-		is_opening: DF.Literal["No", "Yes"]
-		is_system_generated: DF.Check
-		letter_head: DF.Link | None
-		mode_of_payment: DF.Link | None
-		multi_currency: DF.Check
-		naming_series: DF.Literal["ACC-JV-.YYYY.-"]
-		paid_loan: DF.Data | None
-		pay_to_recd_from: DF.Data | None
-		payment_order: DF.Link | None
-		posting_date: DF.Date
-		process_deferred_accounting: DF.Link | None
-		remark: DF.SmallText | None
-		reversal_of: DF.Link | None
-		select_print_heading: DF.Link | None
-		stock_entry: DF.Link | None
-		tax_withholding_category: DF.Link | None
-		title: DF.Data | None
-		total_amount: DF.Currency
-		total_amount_currency: DF.Link | None
-		total_amount_in_words: DF.Data | None
-		total_credit: DF.Currency
-		total_debit: DF.Currency
-		user_remark: DF.SmallText | None
-		voucher_type: DF.Literal[
-			"Journal Entry",
-			"Inter Company Journal Entry",
-			"Bank Entry",
-			"Cash Entry",
-			"Credit Card Entry",
-			"Debit Note",
-			"Credit Note",
-			"Contra Entry",
-			"Excise Entry",
-			"Write Off Entry",
-			"Opening Entry",
-			"Depreciation Entry",
-			"Exchange Rate Revaluation",
-			"Exchange Gain Or Loss",
-			"Deferred Revenue",
-			"Deferred Expense",
-		]
-		write_off_amount: DF.Currency
-		write_off_based_on: DF.Literal["Accounts Receivable", "Accounts Payable"]
-	# end: auto-generated types
-
 	def __init__(self, *args, **kwargs):
 		super(JournalEntry, self).__init__(*args, **kwargs)
 
@@ -170,8 +98,6 @@ class JournalEntry(AccountsController):
 			"Repost Payment Ledger Items",
 			"Repost Accounting Ledger",
 			"Repost Accounting Ledger Items",
-			"Unreconcile Payment",
-			"Unreconcile Payment Entries",
 		)
 		self.make_gl_entries(1)
 		self.update_advance_paid()
@@ -582,7 +508,7 @@ class JournalEntry(AccountsController):
 							).format(d.reference_name, d.account)
 						)
 				else:
-					dr_or_cr = "debit" if flt(d.credit) > 0 else "credit"
+					dr_or_cr = "debit" if d.credit > 0 else "credit"
 					valid = False
 					for jvd in against_entries:
 						if flt(jvd[dr_or_cr]) > 0:
@@ -942,7 +868,7 @@ class JournalEntry(AccountsController):
 					party_account_currency = d.account_currency
 
 			elif frappe.get_cached_value("Account", d.account, "account_type") in ["Bank", "Cash"]:
-				bank_amount += flt(d.debit_in_account_currency) or flt(d.credit_in_account_currency)
+				bank_amount += d.debit_in_account_currency or d.credit_in_account_currency
 				bank_account_currency = d.account_currency
 
 		if party_type and pay_to_recd_from: