perf: avoid full table scan in sle count check

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

.mergify.yml

@@ -15,8 +15,6 @@ pull_request_rules:
         - or:
           - base=version-13
           - base=version-12
-          - base=version-14
-          - base=version-15
     actions:
       close:
       comment:

.pre-commit-config.yaml

@@ -40,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.1.0"
+__version__ = "15.0.0-dev"
 
 
 def get_default_company(user=None):

erpnext/accounts/deferred_revenue.py

@@ -341,7 +341,7 @@ def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 		"enable_deferred_revenue" if doc.doctype == "Sales Invoice" else "enable_deferred_expense"
 	)
 
-	accounts_frozen_upto = frappe.db.get_single_value("Accounts Settings", "acc_frozen_upto")
+	accounts_frozen_upto = frappe.get_cached_value("Accounts Settings", "None", "acc_frozen_upto")
 
 	def _book_deferred_revenue_or_expense(
 		item,

erpnext/accounts/doctype/account/account.js

@@ -1,83 +1,67 @@
 // Copyright (c) 2017, Frappe Technologies Pvt. Ltd. and Contributors
 // License: GNU General Public License v3. See license.txt
 
-frappe.ui.form.on("Account", {
-	setup: function (frm) {
-		frm.add_fetch("parent_account", "report_type", "report_type");
-		frm.add_fetch("parent_account", "root_type", "root_type");
+frappe.ui.form.on('Account', {
+	setup: function(frm) {
+		frm.add_fetch('parent_account', 'report_type', 'report_type');
+		frm.add_fetch('parent_account', 'root_type', 'root_type');
 	},
-	onload: function (frm) {
-		frm.set_query("parent_account", function (doc) {
+	onload: function(frm) {
+		frm.set_query('parent_account', function(doc) {
 			return {
 				filters: {
-					is_group: 1,
-					company: doc.company,
-				},
+					"is_group": 1,
+					"company": doc.company
+				}
 			};
 		});
 	},
-	refresh: function (frm) {
-		frm.toggle_display("account_name", frm.is_new());
+	refresh: function(frm) {
+		frm.toggle_display('account_name', frm.is_new());
 
 		// hide fields if group
-		frm.toggle_display(["tax_rate"], cint(frm.doc.is_group) == 0);
+		frm.toggle_display(['account_type', 'tax_rate'], cint(frm.doc.is_group) == 0);
 
 		// disable fields
-		frm.toggle_enable(["is_group", "company"], false);
+		frm.toggle_enable(['is_group', 'company'], false);
 
 		if (cint(frm.doc.is_group) == 0) {
-			frm.toggle_display(
-				"freeze_account",
-				frm.doc.__onload && frm.doc.__onload.can_freeze_account
-			);
+			frm.toggle_display('freeze_account', frm.doc.__onload
+				&& frm.doc.__onload.can_freeze_account);
 		}
 
 		// read-only for root accounts
 		if (!frm.is_new()) {
 			if (!frm.doc.parent_account) {
 				frm.set_read_only();
-				frm.set_intro(
-					__("This is a root account and cannot be edited.")
-				);
+				frm.set_intro(__("This is a root account and cannot be edited."));
 			} else {
 				// credit days and type if customer or supplier
 				frm.set_intro(null);
-				frm.trigger("account_type");
+				frm.trigger('account_type');
 				// show / hide convert buttons
-				frm.trigger("add_toolbar_buttons");
+				frm.trigger('add_toolbar_buttons');
 			}
-			if (frm.has_perm("write")) {
-				frm.add_custom_button(
-					__("Merge Account"),
-					function () {
-						frm.trigger("merge_account");
-					},
-					__("Actions")
-				);
-				frm.add_custom_button(
-					__("Update Account Name / Number"),
-					function () {
-						frm.trigger("update_account_number");
-					},
-					__("Actions")
-				);
+			if (frm.has_perm('write')) {
+				frm.add_custom_button(__('Merge Account'), function () {
+					frm.trigger("merge_account");
+				}, __('Actions'));
+				frm.add_custom_button(__('Update Account Name / Number'), function () {
+					frm.trigger("update_account_number");
+				}, __('Actions'));
 			}
 		}
 	},
 	account_type: function (frm) {
 		if (frm.doc.is_group == 0) {
-			frm.toggle_display(["tax_rate"], frm.doc.account_type == "Tax");
-			frm.toggle_display("warehouse", frm.doc.account_type == "Stock");
+			frm.toggle_display(['tax_rate'], frm.doc.account_type == 'Tax');
+			frm.toggle_display('warehouse', frm.doc.account_type == 'Stock');
 		}
 	},
-	add_toolbar_buttons: function (frm) {
-		frm.add_custom_button(
-			__("Chart of Accounts"),
-			() => {
-				frappe.set_route("Tree", "Account");
-			},
-			__("View")
-		);
+	add_toolbar_buttons: function(frm) {
+		frm.add_custom_button(__('Chart of Accounts'), () => {
+			frappe.set_route("Tree", "Account");
+		}, __('View'));
 
 		if (frm.doc.is_group == 1) {
 			frm.add_custom_button(__('Convert to Non-Group'), function () {
@@ -102,81 +86,77 @@ frappe.ui.form.on("Account", {
 				frappe.set_route("query-report", "General Ledger");
 			}, __('View'));
 
-			frm.add_custom_button(
-				__("Convert to Group"),
-				function () {
-					return frappe.call({
-						doc: frm.doc,
-						method: "convert_ledger_to_group",
-						callback: function () {
-							frm.refresh();
-						},
-					});
-				},
-				__("Actions")
-			);
+			frm.add_custom_button(__('Convert to Group'), function () {
+				return frappe.call({
+					doc: frm.doc,
+					method: 'convert_ledger_to_group',
+					callback: function() {
+						frm.refresh();
+					}
+				});
+			}, __('Actions'));
 		}
 	},
 
-	merge_account: function (frm) {
+	merge_account: function(frm) {
 		var d = new frappe.ui.Dialog({
-			title: __("Merge with Existing Account"),
+			title: __('Merge with Existing Account'),
 			fields: [
 				{
-					label: "Name",
-					fieldname: "name",
-					fieldtype: "Data",
-					reqd: 1,
-					default: frm.doc.name,
-				},
+					"label" : "Name",
+					"fieldname": "name",
+					"fieldtype": "Data",
+					"reqd": 1,
+					"default": frm.doc.name
+				}
 			],
-			primary_action: function () {
+			primary_action: function() {
 				var data = d.get_values();
 				frappe.call({
 					method: "erpnext.accounts.doctype.account.account.merge_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) {
-							if (r.message) {
+					callback: function(r) {
+						if(!r.exc) {
+							if(r.message) {
 								frappe.set_route("Form", "Account", r.message);
 							}
 							d.hide();
 						}
-					},
+					}
 				});
 			},
-			primary_action_label: __("Merge"),
+			primary_action_label: __('Merge')
 		});
 		d.show();
 	},
 
-	update_account_number: function (frm) {
+	update_account_number: function(frm) {
 		var d = new frappe.ui.Dialog({
-			title: __("Update Account Number / Name"),
+			title: __('Update Account Number / Name'),
 			fields: [
 				{
-					label: "Account Name",
-					fieldname: "account_name",
-					fieldtype: "Data",
-					reqd: 1,
-					default: frm.doc.account_name,
+					"label": "Account Name",
+					"fieldname": "account_name",
+					"fieldtype": "Data",
+					"reqd": 1,
+					"default": frm.doc.account_name
 				},
 				{
-					label: "Account Number",
-					fieldname: "account_number",
-					fieldtype: "Data",
-					default: frm.doc.account_number,
-				},
+					"label": "Account Number",
+					"fieldname": "account_number",
+					"fieldtype": "Data",
+					"default": frm.doc.account_number
+				}
 			],
-			primary_action: function () {
+			primary_action: function() {
 				var data = d.get_values();
-				if (
-					data.account_number === frm.doc.account_number &&
-					data.account_name === frm.doc.account_name
-				) {
+				if(data.account_number === frm.doc.account_number && data.account_name === frm.doc.account_name) {
 					d.hide();
 					return;
 				}
@@ -186,29 +166,23 @@ frappe.ui.form.on("Account", {
 					args: {
 						account_number: data.account_number,
 						account_name: data.account_name,
-						name: frm.doc.name,
+						name: frm.doc.name
 					},
-					callback: function (r) {
-						if (!r.exc) {
-							if (r.message) {
+					callback: function(r) {
+						if(!r.exc) {
+							if(r.message) {
 								frappe.set_route("Form", "Account", r.message);
 							} else {
-								frm.set_value(
-									"account_number",
-									data.account_number
-								);
-								frm.set_value(
-									"account_name",
-									data.account_name
-								);
+								frm.set_value("account_number", data.account_number);
+								frm.set_value("account_name", data.account_name);
 							}
 							d.hide();
 						}
-					},
+					}
 				});
 			},
-			primary_action_label: __("Update"),
+			primary_action_label: __('Update')
 		});
 		d.show();
-	},
+	}
 });

erpnext/accounts/doctype/account/account.json

@@ -123,7 +123,7 @@
    "label": "Account Type",
    "oldfieldname": "account_type",
    "oldfieldtype": "Select",
-   "options": "\nAccumulated Depreciation\nAsset Received But Not Billed\nBank\nCash\nChargeable\nCapital Work in Progress\nCost of Goods Sold\nCurrent Asset\nCurrent Liability\nDepreciation\nDirect Expense\nDirect Income\nEquity\nExpense Account\nExpenses Included In Asset Valuation\nExpenses Included In Valuation\nFixed Asset\nIncome Account\nIndirect Expense\nIndirect Income\nLiability\nPayable\nReceivable\nRound Off\nStock\nStock Adjustment\nStock Received But Not Billed\nService Received But Not Billed\nTax\nTemporary"
+   "options": "\nAccumulated Depreciation\nAsset Received But Not Billed\nBank\nCash\nChargeable\nCapital Work in Progress\nCost of Goods Sold\nDepreciation\nEquity\nExpense Account\nExpenses Included In Asset Valuation\nExpenses Included In Valuation\nFixed Asset\nIncome Account\nPayable\nReceivable\nRound Off\nStock\nStock Adjustment\nStock Received But Not Billed\nService Received But Not Billed\nTax\nTemporary"
   },
   {
    "description": "Rate at which this tax is applied",
@@ -192,7 +192,7 @@
  "idx": 1,
  "is_tree": 1,
  "links": [],
- "modified": "2023-07-20 18:18:44.405723",
+ "modified": "2023-04-11 16:08:46.983677",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Account",
@@ -243,6 +243,7 @@
    "read": 1,
    "report": 1,
    "role": "Accounts Manager",
+   "set_user_permissions": 1,
    "share": 1,
    "write": 1
   }

erpnext/accounts/doctype/account/account.py

@@ -18,10 +18,6 @@ class BalanceMismatchError(frappe.ValidationError):
 	pass
 
 
-class InvalidAccountMergeError(frappe.ValidationError):
-	pass
-
-
 class Account(NestedSet):
 	nsm_parent_field = "parent_account"
 
@@ -49,7 +45,6 @@ class Account(NestedSet):
 		if frappe.local.flags.allow_unverified_charts:
 			return
 		self.validate_parent()
-		self.validate_parent_child_account_type()
 		self.validate_root_details()
 		validate_field_number("Account", self.name, self.account_number, self.company, "account_number")
 		self.validate_group_or_ledger()
@@ -60,20 +55,6 @@ class Account(NestedSet):
 		self.validate_account_currency()
 		self.validate_root_company_and_sync_account_to_children()
 
-	def validate_parent_child_account_type(self):
-		if self.parent_account:
-			if self.account_type in [
-				"Direct Income",
-				"Indirect Income",
-				"Current Asset",
-				"Current Liability",
-				"Direct Expense",
-				"Indirect Expense",
-			]:
-				parent_account_type = frappe.db.get_value("Account", self.parent_account, ["account_type"])
-				if parent_account_type == self.account_type:
-					throw(_("Only Parent can be of type {0}").format(self.account_type))
-
 	def validate_parent(self):
 		"""Fetch Parent Details and validate parent account"""
 		if self.parent_account:
@@ -464,34 +445,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/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/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

@@ -37,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

@@ -265,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):
@@ -302,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/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",
@@ -415,13 +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"
   }
  ],
  "icon": "icon-cog",
@@ -429,7 +421,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-08-28 00:12:02.740633",
+ "modified": "2023-07-27 15:05:34.000264",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

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_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_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,7 +15,7 @@ from erpnext.accounts.report.bank_reconciliation_statement.bank_reconciliation_s
 	get_amounts_not_reflected_in_system,
 	get_entries,
 )
-from erpnext.accounts.utils import get_account_currency, get_balance_on
+from erpnext.accounts.utils import get_balance_on
 
 
 class BankReconciliationTool(Document):
@@ -285,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()
@@ -392,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
 
 
@@ -414,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,
@@ -437,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,
@@ -456,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"
@@ -480,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(
@@ -497,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,
@@ -525,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:
@@ -544,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(
@@ -599,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(
@@ -665,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_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_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.py

@@ -89,6 +89,7 @@ class BankTransaction(StatusUpdater):
 		    - 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
 		for payment_entry in self.payment_entries:
 			if payment_entry.allocated_amount == 0.0:

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/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
@@ -295,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
@@ -307,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",
@@ -333,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
 
@@ -434,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/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

@@ -18,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/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/gl_entry/gl_entry.json

@@ -32,11 +32,7 @@
   "finance_book",
   "to_rename",
   "due_date",
-  "is_cancelled",
-  "transaction_currency",
-  "debit_in_transaction_currency",
-  "credit_in_transaction_currency",
-  "transaction_exchange_rate"
+  "is_cancelled"
  ],
  "fields": [
   {
@@ -257,40 +253,15 @@
    "fieldname": "is_cancelled",
    "fieldtype": "Check",
    "label": "Is Cancelled"
-  },
-  {
-   "fieldname": "transaction_currency",
-   "fieldtype": "Link",
-   "label": "Transaction Currency",
-   "options": "Currency"
-  },
-  {
-   "fieldname": "transaction_exchange_rate",
-   "fieldtype": "Float",
-   "label": "Transaction Exchange Rate"
-  },
-  {
-   "fieldname": "debit_in_transaction_currency",
-   "fieldtype": "Currency",
-   "label": "Debit Amount in Transaction Currency",
-   "options": "transaction_currency"
-  },
-  {
-   "fieldname": "credit_in_transaction_currency",
-   "fieldtype": "Currency",
-   "label": "Credit Amount in Transaction Currency",
-   "options": "transaction_currency"
   }
  ],
  "icon": "fa fa-list",
  "idx": 1,
  "in_create": 1,
- "links": [],
- "modified": "2023-08-16 21:38:44.072267",
+ "modified": "2020-04-07 16:22:33.766994",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "GL Entry",
- "naming_rule": "Expression (old style)",
  "owner": "Administrator",
  "permissions": [
   {
@@ -319,6 +290,5 @@
  "quick_entry": 1,
  "search_fields": "voucher_no,account,posting_date,against_voucher",
  "sort_field": "modified",
- "sort_order": "DESC",
- "states": []
+ "sort_order": "DESC"
 }

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -58,13 +58,6 @@ class GLEntry(Document):
 			validate_balance_type(self.account, adv_adj)
 			validate_frozen_account(self.account, adv_adj)
 
-			if (
-				self.voucher_type == "Journal Entry"
-				and frappe.get_cached_value("Journal Entry", self.voucher_no, "voucher_type")
-				== "Exchange Gain Or Loss"
-			):
-				return
-
 			if frappe.get_cached_value("Account", self.account, "account_type") not in [
 				"Receivable",
 				"Payable",

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"];
+		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', 'Journal Entry', "Repost Payment Ledger", 'Asset', 'Asset Movement', 'Asset Depreciation Schedule'];
 	},
 
 	refresh: function(frm) {
@@ -50,18 +50,8 @@ frappe.ui.form.on("Journal Entry", {
 					frm.trigger("make_inter_company_journal_entry");
 				}, __('Make'));
 		}
+	},
 
-		erpnext.accounts.unreconcile_payments.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

@@ -9,7 +9,6 @@
  "engine": "InnoDB",
  "field_order": [
   "entry_type_and_date",
-  "is_system_generated",
   "title",
   "voucher_type",
   "naming_series",
@@ -534,22 +533,13 @@
    "label": "Process Deferred Accounting",
    "options": "Process Deferred Accounting",
    "read_only": 1
-  },
-  {
-   "default": "0",
-   "depends_on": "eval:doc.is_system_generated == 1;",
-   "fieldname": "is_system_generated",
-   "fieldtype": "Check",
-   "label": "Is System Generated",
-   "no_copy": 1,
-   "read_only": 1
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 176,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-08-10 14:32:22.366895",
+ "modified": "2023-03-01 14:58:59.286591",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry",

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -18,7 +18,6 @@ from erpnext.accounts.doctype.tax_withholding_category.tax_withholding_category
 )
 from erpnext.accounts.party import get_party_account
 from erpnext.accounts.utils import (
-	cancel_exchange_gain_loss_journal,
 	get_account_currency,
 	get_balance_on,
 	get_stock_accounts,
@@ -88,16 +87,15 @@ class JournalEntry(AccountsController):
 		self.update_invoice_discounting()
 
 	def on_cancel(self):
-		# References for this Journal are removed on the `on_cancel` event in accounts_controller
-		super(JournalEntry, self).on_cancel()
+		from erpnext.accounts.utils import unlink_ref_doc_from_payment_entries
+
+		unlink_ref_doc_from_payment_entries(self)
 		self.ignore_linked_doctypes = (
 			"GL Entry",
 			"Stock Ledger Entry",
 			"Payment Ledger Entry",
 			"Repost Payment Ledger",
 			"Repost Payment Ledger Items",
-			"Repost Accounting Ledger",
-			"Repost Accounting Ledger Items",
 		)
 		self.make_gl_entries(1)
 		self.update_advance_paid()
@@ -501,12 +499,11 @@ class JournalEntry(AccountsController):
 				)
 
 				if not against_entries:
-					if self.voucher_type != "Exchange Gain Or Loss":
-						frappe.throw(
-							_(
-								"Journal Entry {0} does not have account {1} or already matched against other voucher"
-							).format(d.reference_name, d.account)
-						)
+					frappe.throw(
+						_(
+							"Journal Entry {0} does not have account {1} or already matched against other voucher"
+						).format(d.reference_name, d.account)
+					)
 				else:
 					dr_or_cr = "debit" if d.credit > 0 else "credit"
 					valid = False
@@ -589,9 +586,7 @@ class JournalEntry(AccountsController):
 						else:
 							party_account = against_voucher[1]
 
-					if (
-						against_voucher[0] != cstr(d.party) or party_account != d.account
-					) and self.voucher_type != "Exchange Gain Or Loss":
+					if against_voucher[0] != cstr(d.party) or party_account != d.account:
 						frappe.throw(
 							_("Row {0}: Party / Account does not match with {1} / {2} in {3} {4}").format(
 								d.idx,
@@ -773,23 +768,18 @@ class JournalEntry(AccountsController):
 				)
 			):
 
-				ignore_exchange_rate = False
-				if self.get("flags") and self.flags.get("ignore_exchange_rate"):
-					ignore_exchange_rate = True
-
-				if not ignore_exchange_rate:
-					# Modified to include the posting date for which to retreive the exchange rate
-					d.exchange_rate = get_exchange_rate(
-						self.posting_date,
-						d.account,
-						d.account_currency,
-						self.company,
-						d.reference_type,
-						d.reference_name,
-						d.debit,
-						d.credit,
-						d.exchange_rate,
-					)
+				# Modified to include the posting date for which to retreive the exchange rate
+				d.exchange_rate = get_exchange_rate(
+					self.posting_date,
+					d.account,
+					d.account_currency,
+					self.company,
+					d.reference_type,
+					d.reference_name,
+					d.debit,
+					d.credit,
+					d.exchange_rate,
+				)
 
 			if not d.exchange_rate:
 				frappe.throw(_("Row {0}: Exchange Rate is mandatory").format(d.idx))
@@ -797,9 +787,6 @@ class JournalEntry(AccountsController):
 	def create_remarks(self):
 		r = []
 
-		if self.flags.skip_remarks_creation:
-			return
-
 		if self.user_remark:
 			r.append(_("Note: {0}").format(self.user_remark))
 
@@ -948,8 +935,6 @@ class JournalEntry(AccountsController):
 				merge_entries=merge_entries,
 				update_outstanding=update_outstanding,
 			)
-			if cancel:
-				cancel_exchange_gain_loss_journal(frappe._dict(doctype=self.doctype, name=self.name))
 
 	@frappe.whitelist()
 	def get_balance(self, difference_account=None):

erpnext/accounts/doctype/journal_entry/test_journal_entry.py

@@ -5,7 +5,6 @@
 import unittest
 
 import frappe
-from frappe.tests.utils import change_settings
 from frappe.utils import flt, nowdate
 
 from erpnext.accounts.doctype.account.test_account import get_inventory_account
@@ -14,7 +13,6 @@ from erpnext.exceptions import InvalidAccountCurrency
 
 
 class TestJournalEntry(unittest.TestCase):
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_journal_entry_with_against_jv(self):
 		jv_invoice = frappe.copy_doc(test_records[2])
 		base_jv = frappe.copy_doc(test_records[0])

erpnext/accounts/doctype/journal_entry_account/journal_entry_account.json

@@ -203,7 +203,7 @@
    "fieldtype": "Select",
    "label": "Reference Type",
    "no_copy": 1,
-   "options": "\nSales Invoice\nPurchase Invoice\nJournal Entry\nSales Order\nPurchase Order\nExpense Claim\nAsset\nLoan\nPayroll Entry\nEmployee Advance\nExchange Rate Revaluation\nInvoice Discounting\nFees\nFull and Final Statement\nPayment Entry"
+   "options": "\nSales Invoice\nPurchase Invoice\nJournal Entry\nSales Order\nPurchase Order\nExpense Claim\nAsset\nLoan\nPayroll Entry\nEmployee Advance\nExchange Rate Revaluation\nInvoice Discounting\nFees\nFull and Final Statement"
   },
   {
    "fieldname": "reference_name",
@@ -284,7 +284,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-06-16 14:11:13.507807",
+ "modified": "2022-10-26 20:03:10.906259",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry Account",

erpnext/accounts/doctype/ledger_merge/ledger_merge.py

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

erpnext/accounts/doctype/loyalty_program/loyalty_program.py

@@ -141,12 +141,12 @@ def validate_loyalty_points(ref_doc, points_to_redeem):
 		)
 
 		if points_to_redeem > loyalty_program_details.loyalty_points:
-			frappe.throw(_("You don't have enough Loyalty Points to redeem"))
+			frappe.throw(_("You don't have enought Loyalty Points to redeem"))
 
 		loyalty_amount = flt(points_to_redeem * loyalty_program_details.conversion_factor)
 
-		if loyalty_amount > ref_doc.rounded_total:
-			frappe.throw(_("You can't redeem Loyalty Points having more value than the Rounded Total."))
+		if loyalty_amount > ref_doc.grand_total:
+			frappe.throw(_("You can't redeem Loyalty Points having more value than the Grand Total."))
 
 		if not ref_doc.loyalty_amount and ref_doc.loyalty_amount != loyalty_amount:
 			ref_doc.loyalty_amount = loyalty_amount

erpnext/accounts/doctype/opening_invoice_creation_tool/test_opening_invoice_creation_tool.py

@@ -218,7 +218,6 @@ def make_customer(customer=None):
 			"territory": "All Territories",
 		}
 	)
-
 	if not frappe.db.exists("Customer", customer_name):
 		customer.insert(ignore_permissions=True)
 		return customer.name

erpnext/accounts/doctype/payment_entry/payment_entry.js

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

erpnext/accounts/doctype/payment_entry/payment_entry.json

@@ -595,7 +595,6 @@
    "fieldname": "status",
    "fieldtype": "Select",
    "label": "Status",
-   "no_copy": 1,
    "options": "\nDraft\nSubmitted\nCancelled",
    "read_only": 1
   },
@@ -751,7 +750,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-11-08 21:51:03.482709",
+ "modified": "2023-06-23 18:07:38.023010",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry",

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -28,13 +28,7 @@ from erpnext.accounts.general_ledger import (
 	process_gl_map,
 )
 from erpnext.accounts.party import get_party_account
-from erpnext.accounts.utils import (
-	cancel_exchange_gain_loss_journal,
-	get_account_currency,
-	get_balance_on,
-	get_outstanding_invoices,
-	get_party_types_from_account_type,
-)
+from erpnext.accounts.utils import get_account_currency, get_balance_on, get_outstanding_invoices
 from erpnext.controllers.accounts_controller import (
 	AccountsController,
 	get_supplier_block_status,
@@ -72,7 +66,7 @@ class PaymentEntry(AccountsController):
 		self.setup_party_account_field()
 		self.set_missing_values()
 		self.set_liability_account()
-		self.set_missing_ref_details(force=True)
+		self.set_missing_ref_details()
 		self.validate_payment_type()
 		self.validate_party_details()
 		self.set_exchange_rate()
@@ -84,6 +78,7 @@ class PaymentEntry(AccountsController):
 		self.apply_taxes()
 		self.set_amounts_after_tax()
 		self.clear_unallocated_reference_document_rows()
+		self.validate_payment_against_negative_invoice()
 		self.validate_transaction_reference()
 		self.set_title()
 		self.set_remarks()
@@ -98,6 +93,7 @@ class PaymentEntry(AccountsController):
 		if self.difference_amount:
 			frappe.throw(_("Difference Amount must be zero"))
 		self.make_gl_entries()
+		self.make_advance_gl_entries()
 		self.update_outstanding_amounts()
 		self.update_advance_paid()
 		self.update_payment_schedule()
@@ -146,13 +142,9 @@ class PaymentEntry(AccountsController):
 			"Payment Ledger Entry",
 			"Repost Payment Ledger",
 			"Repost Payment Ledger Items",
-			"Repost Accounting Ledger",
-			"Repost Accounting Ledger Items",
-			"Unreconcile Payments",
-			"Unreconcile Payment Entries",
 		)
-		super(PaymentEntry, self).on_cancel()
 		self.make_gl_entries(cancel=1)
+		self.make_advance_gl_entries(cancel=1)
 		self.update_outstanding_amounts()
 		self.update_advance_paid()
 		self.delink_advance_entry_references()
@@ -230,90 +222,79 @@ class PaymentEntry(AccountsController):
 		return False
 
 	def validate_allocated_amount_with_latest_data(self):
-		if self.references:
-			uniq_vouchers = set([(x.reference_doctype, x.reference_name) for x in self.references])
-			vouchers = [frappe._dict({"voucher_type": x[0], "voucher_no": x[1]}) for x in uniq_vouchers]
-			latest_references = get_outstanding_reference_documents(
-				{
-					"posting_date": self.posting_date,
-					"company": self.company,
-					"party_type": self.party_type,
-					"payment_type": self.payment_type,
-					"party": self.party,
-					"party_account": self.paid_from if self.payment_type == "Receive" else self.paid_to,
-					"get_outstanding_invoices": True,
-					"get_orders_to_be_billed": True,
-					"vouchers": vouchers,
-				},
-				validate=True,
-			)
+		latest_references = get_outstanding_reference_documents(
+			{
+				"posting_date": self.posting_date,
+				"company": self.company,
+				"party_type": self.party_type,
+				"payment_type": self.payment_type,
+				"party": self.party,
+				"party_account": self.paid_from if self.payment_type == "Receive" else self.paid_to,
+				"get_outstanding_invoices": True,
+				"get_orders_to_be_billed": True,
+			},
+			validate=True,
+		)
 
-			# Group latest_references by (voucher_type, voucher_no)
-			latest_lookup = {}
-			for d in latest_references:
-				d = frappe._dict(d)
-				latest_lookup.setdefault((d.voucher_type, d.voucher_no), frappe._dict())[d.payment_term] = d
+		# Group latest_references by (voucher_type, voucher_no)
+		latest_lookup = {}
+		for d in latest_references:
+			d = frappe._dict(d)
+			latest_lookup.setdefault((d.voucher_type, d.voucher_no), frappe._dict())[d.payment_term] = d
 
-			for idx, d in enumerate(self.get("references"), start=1):
-				latest = latest_lookup.get((d.reference_doctype, d.reference_name)) or frappe._dict()
+		for idx, d in enumerate(self.get("references"), start=1):
+			latest = latest_lookup.get((d.reference_doctype, d.reference_name)) or frappe._dict()
 
-				# If term based allocation is enabled, throw
-				if (
-					d.payment_term is None or d.payment_term == ""
-				) and self.term_based_allocation_enabled_for_reference(
-					d.reference_doctype, d.reference_name
-				):
-					frappe.throw(
-						_(
-							"{0} has Payment Term based allocation enabled. Select a Payment Term for Row #{1} in Payment References section"
-						).format(frappe.bold(d.reference_name), frappe.bold(idx))
+			# If term based allocation is enabled, throw
+			if (
+				d.payment_term is None or d.payment_term == ""
+			) and self.term_based_allocation_enabled_for_reference(
+				d.reference_doctype, d.reference_name
+			):
+				frappe.throw(
+					_(
+						"{0} has Payment Term based allocation enabled. Select a Payment Term for Row #{1} in Payment References section"
+					).format(frappe.bold(d.reference_name), frappe.bold(idx))
+				)
+
+			# if no payment template is used by invoice and has a custom term(no `payment_term`), then invoice outstanding will be in 'None' key
+			latest = latest.get(d.payment_term) or latest.get(None)
+
+			# The reference has already been fully paid
+			if not latest:
+				frappe.throw(
+					_("{0} {1} has already been fully paid.").format(_(d.reference_doctype), d.reference_name)
+				)
+			# The reference has already been partly paid
+			elif latest.outstanding_amount < latest.invoice_amount and flt(
+				d.outstanding_amount, d.precision("outstanding_amount")
+			) != flt(latest.outstanding_amount, d.precision("outstanding_amount")):
+				frappe.throw(
+					_(
+						"{0} {1} has already been partly paid. Please use the 'Get Outstanding Invoice' or the 'Get Outstanding Orders' button to get the latest outstanding amounts."
+					).format(_(d.reference_doctype), d.reference_name)
+				)
+
+			fail_message = _("Row #{0}: Allocated Amount cannot be greater than outstanding amount.")
+
+			if (flt(d.allocated_amount)) > 0 and flt(d.allocated_amount) > flt(latest.outstanding_amount):
+				frappe.throw(fail_message.format(d.idx))
+
+			if d.payment_term and (
+				(flt(d.allocated_amount)) > 0
+				and flt(d.allocated_amount) > flt(latest.payment_term_outstanding)
+			):
+				frappe.throw(
+					_(
+						"Row #{0}: Allocated amount:{1} is greater than outstanding amount:{2} for Payment Term {3}"
+					).format(
+						d.idx, d.allocated_amount, latest.payment_term_outstanding, d.payment_term
 					)
+				)
 
-				# if no payment template is used by invoice and has a custom term(no `payment_term`), then invoice outstanding will be in 'None' key
-				latest = latest.get(d.payment_term) or latest.get(None)
-				# The reference has already been fully paid
-				if not latest:
-					frappe.throw(
-						_("{0} {1} has already been fully paid.").format(_(d.reference_doctype), d.reference_name)
-					)
-				# The reference has already been partly paid
-				elif (
-					latest.outstanding_amount < latest.invoice_amount
-					and flt(d.outstanding_amount, d.precision("outstanding_amount"))
-					!= flt(latest.outstanding_amount, d.precision("outstanding_amount"))
-					and d.payment_term == ""
-				):
-					frappe.throw(
-						_(
-							"{0} {1} has already been partly paid. Please use the 'Get Outstanding Invoice' or the 'Get Outstanding Orders' button to get the latest outstanding amounts."
-						).format(_(d.reference_doctype), d.reference_name)
-					)
-
-				fail_message = _("Row #{0}: Allocated Amount cannot be greater than outstanding amount.")
-
-				if (
-					d.payment_term
-					and (
-						(flt(d.allocated_amount)) > 0
-						and latest.payment_term_outstanding
-						and (flt(d.allocated_amount) > flt(latest.payment_term_outstanding))
-					)
-					and self.term_based_allocation_enabled_for_reference(d.reference_doctype, d.reference_name)
-				):
-					frappe.throw(
-						_(
-							"Row #{0}: Allocated amount:{1} is greater than outstanding amount:{2} for Payment Term {3}"
-						).format(
-							d.idx, d.allocated_amount, latest.payment_term_outstanding, d.payment_term
-						)
-					)
-
-				if (flt(d.allocated_amount)) > 0 and flt(d.allocated_amount) > flt(latest.outstanding_amount):
-					frappe.throw(fail_message.format(d.idx))
-
-				# Check for negative outstanding invoices as well
-				if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(latest.outstanding_amount):
-					frappe.throw(fail_message.format(d.idx))
+			# Check for negative outstanding invoices as well
+			if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(latest.outstanding_amount):
+				frappe.throw(fail_message.format(d.idx))
 
 	def delink_advance_entry_references(self):
 		for reference in self.references:
@@ -418,7 +399,7 @@ class PaymentEntry(AccountsController):
 			else:
 				if ref_doc:
 					if self.paid_from_account_currency == ref_doc.currency:
-						self.source_exchange_rate = ref_doc.get("exchange_rate") or ref_doc.get("conversion_rate")
+						self.source_exchange_rate = ref_doc.get("exchange_rate")
 
 			if not self.source_exchange_rate:
 				self.source_exchange_rate = get_exchange_rate(
@@ -431,7 +412,7 @@ class PaymentEntry(AccountsController):
 		elif self.paid_to and not self.target_exchange_rate:
 			if ref_doc:
 				if self.paid_to_account_currency == ref_doc.currency:
-					self.target_exchange_rate = ref_doc.get("exchange_rate") or ref_doc.get("conversion_rate")
+					self.target_exchange_rate = ref_doc.get("exchange_rate")
 
 			if not self.target_exchange_rate:
 				self.target_exchange_rate = get_exchange_rate(
@@ -696,9 +677,7 @@ class PaymentEntry(AccountsController):
 		if not self.apply_tax_withholding_amount:
 			return
 
-		order_amount = self.get_order_net_total()
-
-		net_total = flt(order_amount) + flt(self.unallocated_amount)
+		net_total = self.paid_amount
 
 		# Adding args as purchase invoice to get TDS amount
 		args = frappe._dict(
@@ -743,20 +722,6 @@ class PaymentEntry(AccountsController):
 		for d in to_remove:
 			self.remove(d)
 
-	def get_order_net_total(self):
-		if self.party_type == "Supplier":
-			doctype = "Purchase Order"
-		else:
-			doctype = "Sales Order"
-
-		docnames = [d.reference_name for d in self.references if d.reference_doctype == doctype]
-
-		tax_withholding_net_total = frappe.db.get_value(
-			doctype, {"name": ["in", docnames]}, ["sum(base_tax_withholding_net_total)"]
-		)
-
-		return tax_withholding_net_total
-
 	def apply_taxes(self):
 		self.initialize_taxes()
 		self.determine_exclusive_rate()
@@ -843,30 +808,10 @@ class PaymentEntry(AccountsController):
 				flt(d.allocated_amount) * flt(exchange_rate), self.precision("base_paid_amount")
 			)
 		else:
-
-			# Use source/target exchange rate, so no difference amount is calculated.
-			# then update exchange gain/loss amount in reference table
-			# if there is an exchange gain/loss amount in reference table, submit a JE for that
-
-			exchange_rate = 1
-			if self.payment_type == "Receive":
-				exchange_rate = self.source_exchange_rate
-			elif self.payment_type == "Pay":
-				exchange_rate = self.target_exchange_rate
-
 			base_allocated_amount += flt(
-				flt(d.allocated_amount) * flt(exchange_rate), self.precision("base_paid_amount")
-			)
-
-			# on rare case, when `exchange_rate` is unset, gain/loss amount is incorrectly calculated
-			# for base currency transactions
-			if d.exchange_rate is None:
-				d.exchange_rate = 1
-
-			allocated_amount_in_pe_exchange_rate = flt(
 				flt(d.allocated_amount) * flt(d.exchange_rate), self.precision("base_paid_amount")
 			)
-			d.exchange_gain_loss = base_allocated_amount - allocated_amount_in_pe_exchange_rate
+
 		return base_allocated_amount
 
 	def set_total_allocated_amount(self):
@@ -952,6 +897,35 @@ class PaymentEntry(AccountsController):
 			self.name,
 		)
 
+	def validate_payment_against_negative_invoice(self):
+		if (self.payment_type != "Pay" or self.party_type != "Customer") and (
+			self.payment_type != "Receive" or self.party_type != "Supplier"
+		):
+			return
+
+		total_negative_outstanding = sum(
+			abs(flt(d.outstanding_amount)) for d in self.get("references") if flt(d.outstanding_amount) < 0
+		)
+
+		paid_amount = self.paid_amount if self.payment_type == "Receive" else self.received_amount
+		additional_charges = sum(flt(d.amount) for d in self.deductions)
+
+		if not total_negative_outstanding:
+			if self.party_type == "Customer":
+				msg = _("Cannot pay to Customer without any negative outstanding invoice")
+			else:
+				msg = _("Cannot receive from Supplier without any negative outstanding invoice")
+
+			frappe.throw(msg, InvalidPaymentEntry)
+
+		elif paid_amount - additional_charges > total_negative_outstanding:
+			frappe.throw(
+				_("Paid Amount cannot be greater than total negative outstanding amount {0}").format(
+					fmt_money(total_negative_outstanding)
+				),
+				InvalidPaymentEntry,
+			)
+
 	def set_title(self):
 		if frappe.flags.in_import and self.title:
 			# do not set title dynamically if title exists during data import.
@@ -977,14 +951,14 @@ class PaymentEntry(AccountsController):
 		if self.payment_type == "Internal Transfer":
 			remarks = [
 				_("Amount {0} {1} transferred from {2} to {3}").format(
-					_(self.paid_from_account_currency), self.paid_amount, self.paid_from, self.paid_to
+					self.paid_from_account_currency, self.paid_amount, self.paid_from, self.paid_to
 				)
 			]
 		else:
 
 			remarks = [
 				_("Amount {0} {1} {2} {3}").format(
-					_(self.party_account_currency),
+					self.party_account_currency,
 					self.paid_amount if self.payment_type == "Receive" else self.received_amount,
 					_("received from") if self.payment_type == "Receive" else _("to"),
 					self.party,
@@ -1001,14 +975,14 @@ class PaymentEntry(AccountsController):
 				if d.allocated_amount:
 					remarks.append(
 						_("Amount {0} {1} against {2} {3}").format(
-							_(self.party_account_currency), d.allocated_amount, d.reference_doctype, d.reference_name
+							self.party_account_currency, d.allocated_amount, d.reference_doctype, d.reference_name
 						)
 					)
 
 		for d in self.get("deductions"):
 			if d.amount:
 				remarks.append(
-					_("Amount {0} {1} deducted against {2}").format(_(self.company_currency), d.amount, d.account)
+					_("Amount {0} {1} deducted against {2}").format(self.company_currency, d.amount, d.account)
 				)
 
 		self.set("remarks", "\n".join(remarks))
@@ -1028,12 +1002,6 @@ class PaymentEntry(AccountsController):
 		gl_entries = self.build_gl_map()
 		gl_entries = process_gl_map(gl_entries)
 		make_gl_entries(gl_entries, cancel=cancel, adv_adj=adv_adj)
-		if cancel:
-			cancel_exchange_gain_loss_journal(frappe._dict(doctype=self.doctype, name=self.name))
-		else:
-			self.make_exchange_gain_loss_journal()
-
-		self.make_advance_gl_entries(cancel=cancel)
 
 	def add_party_gl_entries(self, gl_entries):
 		if self.party_account:
@@ -1054,7 +1022,9 @@ class PaymentEntry(AccountsController):
 				item=self,
 			)
 
-			dr_or_cr = "credit" if self.payment_type == "Receive" else "debit"
+			dr_or_cr = (
+				"credit" if erpnext.get_party_account_type(self.party_type) == "Receivable" else "debit"
+			)
 
 			for d in self.get("references"):
 				cost_center = self.cost_center
@@ -1072,27 +1042,10 @@ class PaymentEntry(AccountsController):
 					against_voucher_type = d.reference_doctype
 					against_voucher = d.reference_name
 
-				reverse_dr_or_cr, standalone_note = 0, 0
-				if d.reference_doctype in ["Sales Invoice", "Purchase Invoice"]:
-					is_return, return_against = frappe.db.get_value(
-						d.reference_doctype, d.reference_name, ["is_return", "return_against"]
-					)
-					payable_party_types = get_party_types_from_account_type("Payable")
-					receivable_party_types = get_party_types_from_account_type("Receivable")
-					if is_return and self.party_type in receivable_party_types and (self.payment_type == "Pay"):
-						reverse_dr_or_cr = 1
-					elif (
-						is_return and self.party_type in payable_party_types and (self.payment_type == "Receive")
-					):
-						reverse_dr_or_cr = 1
-
-					if is_return and not return_against and not reverse_dr_or_cr:
-						dr_or_cr = "debit" if dr_or_cr == "credit" else "credit"
-
 				gle.update(
 					{
-						dr_or_cr: abs(allocated_amount_in_company_currency),
-						dr_or_cr + "_in_account_currency": abs(d.allocated_amount),
+						dr_or_cr: allocated_amount_in_company_currency,
+						dr_or_cr + "_in_account_currency": d.allocated_amount,
 						"against_voucher_type": against_voucher_type,
 						"against_voucher": against_voucher,
 						"cost_center": cost_center,
@@ -1118,7 +1071,7 @@ class PaymentEntry(AccountsController):
 		if self.book_advance_payments_in_separate_party_account:
 			gl_entries = []
 			for d in self.get("references"):
-				if d.reference_doctype in ("Sales Invoice", "Purchase Invoice", "Journal Entry"):
+				if d.reference_doctype in ("Sales Invoice", "Purchase Invoice"):
 					if not (against_voucher_type and against_voucher) or (
 						d.reference_doctype == against_voucher_type and d.reference_name == against_voucher
 					):
@@ -1140,25 +1093,8 @@ class PaymentEntry(AccountsController):
 					)
 
 				make_reverse_gl_entries(gl_entries=gl_entries, partial_cancel=True)
-				return
-
-			# same reference added to payment entry
-			for gl_entry in gl_entries.copy():
-				if frappe.db.exists(
-					"GL Entry",
-					{
-						"account": gl_entry.account,
-						"voucher_type": gl_entry.voucher_type,
-						"voucher_no": gl_entry.voucher_no,
-						"voucher_detail_no": gl_entry.voucher_detail_no,
-						"debit": gl_entry.debit,
-						"credit": gl_entry.credit,
-						"is_cancelled": 0,
-					},
-				):
-					gl_entries.remove(gl_entry)
-
-			make_gl_entries(gl_entries)
+			else:
+				make_gl_entries(gl_entries)
 
 	def make_invoice_liability_entry(self, gl_entries, invoice):
 		args_dict = {
@@ -1171,13 +1107,6 @@ class PaymentEntry(AccountsController):
 			"voucher_detail_no": invoice.name,
 		}
 
-		posting_date = frappe.db.get_value(
-			invoice.reference_doctype, invoice.reference_name, "posting_date"
-		)
-
-		if getdate(posting_date) < getdate(self.posting_date):
-			posting_date = self.posting_date
-
 		dr_or_cr = "credit" if invoice.reference_doctype == "Sales Invoice" else "debit"
 		args_dict["account"] = invoice.account
 		args_dict[dr_or_cr] = invoice.allocated_amount
@@ -1186,7 +1115,6 @@ class PaymentEntry(AccountsController):
 			{
 				"against_voucher_type": invoice.reference_doctype,
 				"against_voucher": invoice.reference_name,
-				"posting_date": posting_date,
 			}
 		)
 		gle = self.get_gl_dict(
@@ -1593,14 +1521,6 @@ def get_outstanding_reference_documents(args, validate=False):
 				fieldname, args.get(date_fields[0]), args.get(date_fields[1])
 			)
 			posting_and_due_date.append(ple[fieldname][args.get(date_fields[0]) : args.get(date_fields[1])])
-		elif args.get(date_fields[0]):
-			# if only from date is supplied
-			condition += " and {0} >= '{1}'".format(fieldname, args.get(date_fields[0]))
-			posting_and_due_date.append(ple[fieldname].gte(args.get(date_fields[0])))
-		elif args.get(date_fields[1]):
-			# if only to date is supplied
-			condition += " and {0} <= '{1}'".format(fieldname, args.get(date_fields[1]))
-			posting_and_due_date.append(ple[fieldname].lte(args.get(date_fields[1])))
 
 	if args.get("company"):
 		condition += " and company = {0}".format(frappe.db.escape(args.get("company")))
@@ -1619,7 +1539,6 @@ def get_outstanding_reference_documents(args, validate=False):
 			min_outstanding=args.get("outstanding_amt_greater_than"),
 			max_outstanding=args.get("outstanding_amt_less_than"),
 			accounting_dimensions=accounting_dimensions_filter,
-			vouchers=args.get("vouchers") or None,
 		)
 
 		outstanding_invoices = split_invoices_based_on_payment_terms(
@@ -1739,10 +1658,11 @@ def split_invoices_based_on_payment_terms(outstanding_invoices, company):
 										"voucher_type": d.voucher_type,
 										"posting_date": d.posting_date,
 										"invoice_amount": flt(d.invoice_amount),
-										"outstanding_amount": payment_term_outstanding
+										"outstanding_amount": flt(d.outstanding_amount),
+										"payment_term_outstanding": payment_term_outstanding,
+										"allocated_amount": payment_term_outstanding
 										if payment_term_outstanding
 										else d.outstanding_amount,
-										"payment_term_outstanding": payment_term_outstanding,
 										"payment_amount": payment_term.payment_amount,
 										"payment_term": payment_term.payment_term,
 										"account": d.account,
@@ -2020,15 +1940,10 @@ def get_reference_details(reference_doctype, reference_name, party_account_curre
 		if not total_amount:
 			if party_account_currency == company_currency:
 				# for handling cases that don't have multi-currency (base field)
-				total_amount = (
-					ref_doc.get("base_rounded_total")
-					or ref_doc.get("rounded_total")
-					or ref_doc.get("base_grand_total")
-					or ref_doc.get("grand_total")
-				)
+				total_amount = ref_doc.get("base_grand_total") or ref_doc.get("grand_total")
 				exchange_rate = 1
 			else:
-				total_amount = ref_doc.get("rounded_total") or ref_doc.get("grand_total")
+				total_amount = ref_doc.get("grand_total")
 		if not exchange_rate:
 			# Get the exchange rate from the original ref doc
 			# or get it based on the posting date of the ref doc.
@@ -2073,6 +1988,7 @@ def get_payment_entry(
 	payment_type=None,
 	reference_date=None,
 ):
+	reference_doc = None
 	doc = frappe.get_doc(dt, dn)
 	over_billing_allowance = frappe.db.get_single_value("Accounts Settings", "over_billing_allowance")
 	if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) >= (
@@ -2212,7 +2128,7 @@ def get_payment_entry(
 	update_accounting_dimensions(pe, doc)
 
 	if party_account and bank:
-		pe.set_exchange_rate(ref_doc=doc)
+		pe.set_exchange_rate(ref_doc=reference_doc)
 		pe.set_amounts()
 
 		if discount_amount:
@@ -2327,7 +2243,7 @@ def set_paid_amount_and_received_amount(
 			if bank_amount:
 				received_amount = bank_amount
 			else:
-				if bank and company_currency != bank.account_currency:
+				if company_currency != bank.account_currency:
 					received_amount = paid_amount / doc.get("conversion_rate", 1)
 				else:
 					received_amount = paid_amount * doc.get("conversion_rate", 1)
@@ -2336,7 +2252,7 @@ def set_paid_amount_and_received_amount(
 			if bank_amount:
 				paid_amount = bank_amount
 			else:
-				if bank and company_currency != bank.account_currency:
+				if company_currency != bank.account_currency:
 					paid_amount = received_amount / doc.get("conversion_rate", 1)
 				else:
 					# if party account currency and bank currency is different then populate paid amount as well

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -31,16 +31,6 @@ class TestPaymentEntry(FrappeTestCase):
 	def tearDown(self):
 		frappe.db.rollback()
 
-	def get_journals_for(self, voucher_type: str, voucher_no: str) -> list:
-		journals = []
-		if voucher_type and voucher_no:
-			journals = frappe.db.get_all(
-				"Journal Entry Account",
-				filters={"reference_type": voucher_type, "reference_name": voucher_no, "docstatus": 1},
-				fields=["parent"],
-			)
-		return journals
-
 	def test_payment_entry_against_order(self):
 		so = make_sales_order()
 		pe = get_payment_entry("Sales Order", so.name, bank_account="_Test Cash - _TC")
@@ -601,15 +591,21 @@ class TestPaymentEntry(FrappeTestCase):
 		pe.target_exchange_rate = 45.263
 		pe.reference_no = "1"
 		pe.reference_date = "2016-01-01"
+
+		pe.append(
+			"deductions",
+			{
+				"account": "_Test Exchange Gain/Loss - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"amount": 94.80,
+			},
+		)
+
 		pe.save()
 
 		self.assertEqual(flt(pe.difference_amount, 2), 0.0)
 		self.assertEqual(flt(pe.unallocated_amount, 2), 0.0)
 
-		# the exchange gain/loss amount is captured in reference table and a separate Journal will be submitted for them
-		# payment entry will not be generating difference amount
-		self.assertEqual(flt(pe.references[0].exchange_gain_loss, 2), -94.74)
-
 	def test_payment_entry_retrieves_last_exchange_rate(self):
 		from erpnext.setup.doctype.currency_exchange.test_currency_exchange import (
 			save_new_records,
@@ -683,6 +679,17 @@ class TestPaymentEntry(FrappeTestCase):
 		self.validate_gl_entries(pe.name, expected_gle)
 
 	def test_payment_against_negative_sales_invoice(self):
+		pe1 = frappe.new_doc("Payment Entry")
+		pe1.payment_type = "Pay"
+		pe1.company = "_Test Company"
+		pe1.party_type = "Customer"
+		pe1.party = "_Test Customer"
+		pe1.paid_from = "_Test Cash - _TC"
+		pe1.paid_amount = 100
+		pe1.received_amount = 100
+
+		self.assertRaises(InvalidPaymentEntry, pe1.validate)
+
 		si1 = create_sales_invoice()
 
 		# create full payment entry against si1
@@ -691,55 +698,14 @@ class TestPaymentEntry(FrappeTestCase):
 		pe2.submit()
 
 		# create return entry against si1
-		cr_note = create_sales_invoice(is_return=1, return_against=si1.name, qty=-1)
-		si1_outstanding = frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount")
-
-		# create JE(credit note) manually against si1 and cr_note
-		je = frappe.get_doc(
-			{
-				"doctype": "Journal Entry",
-				"company": si1.company,
-				"voucher_type": "Credit Note",
-				"posting_date": nowdate(),
-			}
-		)
-		je.append(
-			"accounts",
-			{
-				"account": si1.debit_to,
-				"party_type": "Customer",
-				"party": si1.customer,
-				"debit": 0,
-				"credit": 100,
-				"debit_in_account_currency": 0,
-				"credit_in_account_currency": 100,
-				"reference_type": si1.doctype,
-				"reference_name": si1.name,
-				"cost_center": si1.items[0].cost_center,
-			},
-		)
-		je.append(
-			"accounts",
-			{
-				"account": cr_note.debit_to,
-				"party_type": "Customer",
-				"party": cr_note.customer,
-				"debit": 100,
-				"credit": 0,
-				"debit_in_account_currency": 100,
-				"credit_in_account_currency": 0,
-				"reference_type": cr_note.doctype,
-				"reference_name": cr_note.name,
-				"cost_center": cr_note.items[0].cost_center,
-			},
-		)
-		je.save().submit()
-
+		create_sales_invoice(is_return=1, return_against=si1.name, qty=-1)
 		si1_outstanding = frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount")
 		self.assertEqual(si1_outstanding, -100)
 
 		# pay more than outstanding against si1
 		pe3 = get_payment_entry("Sales Invoice", si1.name, bank_account="_Test Cash - _TC")
+		pe3.paid_amount = pe3.received_amount = 300
+		self.assertRaises(InvalidPaymentEntry, pe3.validate)
 
 		# pay negative outstanding against si1
 		pe3.paid_to = "Debtors - _TC"
@@ -826,28 +792,33 @@ class TestPaymentEntry(FrappeTestCase):
 		pe.reference_no = "1"
 		pe.reference_date = "2016-01-01"
 		pe.source_exchange_rate = 55
+
+		pe.append(
+			"deductions",
+			{
+				"account": "_Test Exchange Gain/Loss - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"amount": -500,
+			},
+		)
 		pe.save()
 
 		self.assertEqual(pe.unallocated_amount, 0)
 		self.assertEqual(pe.difference_amount, 0)
-		self.assertEqual(pe.references[0].exchange_gain_loss, 500)
+
 		pe.submit()
 
 		expected_gle = dict(
 			(d[0], d)
 			for d in [
-				["_Test Receivable USD - _TC", 0, 5500, si.name],
+				["_Test Receivable USD - _TC", 0, 5000, si.name],
 				["_Test Bank USD - _TC", 5500, 0, None],
+				["_Test Exchange Gain/Loss - _TC", 0, 500, None],
 			]
 		)
 
 		self.validate_gl_entries(pe.name, expected_gle)
 
-		# Exchange gain/loss should have been posted through a journal
-		exc_je_for_si = self.get_journals_for(si.doctype, si.name)
-		exc_je_for_pe = self.get_journals_for(pe.doctype, pe.name)
-
-		self.assertEqual(exc_je_for_si, exc_je_for_pe)
 		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"))
 		self.assertEqual(outstanding_amount, 0)
 
@@ -1185,103 +1156,6 @@ class TestPaymentEntry(FrappeTestCase):
 		si3.cancel()
 		si3.delete()
 
-	@change_settings(
-		"Accounts Settings",
-		{
-			"unlink_payment_on_cancellation_of_invoice": 1,
-			"delete_linked_ledger_entries": 1,
-			"allow_multi_currency_invoices_against_single_party_account": 1,
-		},
-	)
-	def test_overallocation_validation_shouldnt_misfire(self):
-		"""
-		Overallocation validation shouldn't fire for Template without "Allocate Payment based on Payment Terms" enabled
-
-		"""
-		customer = create_customer()
-		create_payment_terms_template()
-
-		template = frappe.get_doc("Payment Terms Template", "Test Receivable Template")
-		template.allocate_payment_based_on_payment_terms = 0
-		template.save()
-
-		# Validate allocation on base/company currency
-		si = create_sales_invoice(do_not_save=1, qty=1, rate=200)
-		si.payment_terms_template = "Test Receivable Template"
-		si.save().submit()
-
-		si.reload()
-		pe = get_payment_entry(si.doctype, si.name).save()
-		# There will no term based allocation
-		self.assertEqual(len(pe.references), 1)
-		self.assertEqual(pe.references[0].payment_term, None)
-		self.assertEqual(flt(pe.references[0].allocated_amount), flt(si.grand_total))
-		pe.save()
-
-		# specify a term
-		pe.references[0].payment_term = template.terms[0].payment_term
-		# no validation error should be thrown
-		pe.save()
-
-		pe.paid_amount = si.grand_total + 1
-		pe.references[0].allocated_amount = si.grand_total + 1
-		self.assertRaises(frappe.ValidationError, pe.save)
-
-		template = frappe.get_doc("Payment Terms Template", "Test Receivable Template")
-		template.allocate_payment_based_on_payment_terms = 1
-		template.save()
-
-	def test_allocation_validation_for_sales_order(self):
-		so = make_sales_order(do_not_save=True)
-		so.items[0].rate = 99.55
-		so.save().submit()
-		self.assertGreater(so.rounded_total, 0.0)
-		pe = get_payment_entry("Sales Order", so.name, bank_account="_Test Cash - _TC")
-		pe.paid_from = "Debtors - _TC"
-		pe.paid_amount = 45.55
-		pe.references[0].allocated_amount = 45.55
-		pe.save().submit()
-		pe = get_payment_entry("Sales Order", so.name, bank_account="_Test Cash - _TC")
-		pe.paid_from = "Debtors - _TC"
-		# No validation error should be thrown here.
-		pe.save().submit()
-
-		so.reload()
-		self.assertEqual(so.advance_paid, so.rounded_total)
-
-	def test_receive_payment_from_payable_party_type(self):
-		pe = create_payment_entry(
-			party_type="Supplier",
-			party="_Test Supplier",
-			payment_type="Receive",
-			paid_from="Creditors - _TC",
-			paid_to="_Test Cash - _TC",
-			save=True,
-			submit=True,
-		)
-		self.voucher_no = pe.name
-		self.expected_gle = [
-			{"account": "_Test Cash - _TC", "debit": 1000.0, "credit": 0.0},
-			{"account": "Creditors - _TC", "debit": 0.0, "credit": 1000.0},
-		]
-		self.check_gl_entries()
-
-	def check_gl_entries(self):
-		gle = frappe.qb.DocType("GL Entry")
-		gl_entries = (
-			frappe.qb.from_(gle)
-			.select(
-				gle.account,
-				gle.debit,
-				gle.credit,
-			)
-			.where((gle.voucher_no == self.voucher_no) & (gle.is_cancelled == 0))
-			.orderby(gle.account)
-		).run(as_dict=True)
-		for row in range(len(self.expected_gle)):
-			for field in ["account", "debit", "credit"]:
-				self.assertEqual(self.expected_gle[row][field], gl_entries[row][field])
-
 
 def create_payment_entry(**args):
 	payment_entry = frappe.new_doc("Payment Entry")

erpnext/accounts/doctype/payment_ledger_entry/payment_ledger_entry.json

@@ -30,8 +30,7 @@
   {
    "fieldname": "posting_date",
    "fieldtype": "Date",
-   "label": "Posting Date",
-   "search_index": 1
+   "label": "Posting Date"
   },
   {
    "fieldname": "account_type",
@@ -65,8 +64,7 @@
    "fieldtype": "Link",
    "in_standard_filter": 1,
    "label": "Voucher Type",
-   "options": "DocType",
-   "search_index": 1
+   "options": "DocType"
   },
   {
    "fieldname": "voucher_no",
@@ -74,16 +72,14 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Voucher No",
-   "options": "voucher_type",
-   "search_index": 1
+   "options": "voucher_type"
   },
   {
    "fieldname": "against_voucher_type",
    "fieldtype": "Link",
    "in_standard_filter": 1,
    "label": "Against Voucher Type",
-   "options": "DocType",
-   "search_index": 1
+   "options": "DocType"
   },
   {
    "fieldname": "against_voucher_no",
@@ -91,8 +87,7 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Against Voucher No",
-   "options": "against_voucher_type",
-   "search_index": 1
+   "options": "against_voucher_type"
   },
   {
    "fieldname": "amount",
@@ -152,14 +147,13 @@
   {
    "fieldname": "voucher_detail_no",
    "fieldtype": "Data",
-   "label": "Voucher Detail No",
-   "search_index": 1
+   "label": "Voucher Detail No"
   }
  ],
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2023-11-03 16:39:58.904113",
+ "modified": "2023-06-29 12:24:20.500632",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Ledger Entry",

erpnext/accounts/doctype/payment_ledger_entry/test_payment_ledger_entry.py

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

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js

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

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.json

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

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -5,9 +5,8 @@
 import frappe
 from frappe import _, msgprint, qb
 from frappe.model.document import Document
-from frappe.query_builder import Criterion
 from frappe.query_builder.custom import ConstantColumn
-from frappe.utils import flt, fmt_money, get_link_to_form, getdate, nowdate, today
+from frappe.utils import flt, get_link_to_form, getdate, nowdate, today
 
 import erpnext
 from erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation import (
@@ -15,11 +14,10 @@ from erpnext.accounts.doctype.process_payment_reconciliation.process_payment_rec
 )
 from erpnext.accounts.utils import (
 	QueryPaymentLedger,
-	create_gain_loss_journal,
 	get_outstanding_invoices,
 	reconcile_against_document,
 )
-from erpnext.controllers.accounts_controller import get_advance_payment_entries_for_regional
+from erpnext.controllers.accounts_controller import get_advance_payment_entries
 
 
 class PaymentReconciliation(Document):
@@ -75,10 +73,7 @@ class PaymentReconciliation(Document):
 			}
 		)
 
-		if self.payment_name:
-			condition.update({"name": self.payment_name})
-
-		payment_entries = get_advance_payment_entries_for_regional(
+		payment_entries = get_advance_payment_entries(
 			self.party_type,
 			self.party,
 			party_account,
@@ -93,9 +88,6 @@ class PaymentReconciliation(Document):
 	def get_jv_entries(self):
 		condition = self.get_conditions()
 
-		if self.payment_name:
-			condition += f" and t1.name like '%%{self.payment_name}%%'"
-
 		if self.get("cost_center"):
 			condition += f" and t2.cost_center = '{self.cost_center}' "
 
@@ -109,8 +101,6 @@ class PaymentReconciliation(Document):
 			"t2.against_account like %(bank_cash_account)s" if self.bank_cash_account else "1=1"
 		)
 
-		limit = f"limit {self.payment_limit}" if self.payment_limit else " "
-
 		# nosemgrep
 		journal_entries = frappe.db.sql(
 			"""
@@ -118,7 +108,7 @@ class PaymentReconciliation(Document):
 				"Journal Entry" as reference_type, t1.name as reference_name,
 				t1.posting_date, t1.remark as remarks, t2.name as reference_row,
 				{dr_or_cr} as amount, t2.is_advance, t2.exchange_rate,
-				t2.account_currency as currency, t2.cost_center as cost_center
+				t2.account_currency as currency
 			from
 				`tabJournal Entry` t1, `tabJournal Entry Account` t2
 			where
@@ -134,13 +124,11 @@ class PaymentReconciliation(Document):
 					ELSE {bank_account_condition}
 				END)
 			order by t1.posting_date
-			{limit}
 			""".format(
 				**{
 					"dr_or_cr": dr_or_cr,
 					"bank_account_condition": bank_account_condition,
 					"condition": condition,
-					"limit": limit,
 				}
 			),
 			{
@@ -157,28 +145,20 @@ class PaymentReconciliation(Document):
 	def get_return_invoices(self):
 		voucher_type = "Sales Invoice" if self.party_type == "Customer" else "Purchase Invoice"
 		doc = qb.DocType(voucher_type)
-
-		conditions = []
-		conditions.append(doc.docstatus == 1)
-		conditions.append(doc[frappe.scrub(self.party_type)] == self.party)
-		conditions.append(doc.is_return == 1)
-
-		if self.payment_name:
-			conditions.append(doc.name.like(f"%{self.payment_name}%"))
-
-		self.return_invoices_query = (
+		self.return_invoices = (
 			qb.from_(doc)
 			.select(
 				ConstantColumn(voucher_type).as_("voucher_type"),
 				doc.name.as_("voucher_no"),
 				doc.return_against,
 			)
-			.where(Criterion.all(conditions))
+			.where(
+				(doc.docstatus == 1)
+				& (doc[frappe.scrub(self.party_type)] == self.party)
+				& (doc.is_return == 1)
+			)
+			.run(as_dict=True)
 		)
-		if self.payment_limit:
-			self.return_invoices_query = self.return_invoices_query.limit(self.payment_limit)
-
-		self.return_invoices = self.return_invoices_query.run(as_dict=True)
 
 	def get_dr_or_cr_notes(self):
 
@@ -193,12 +173,15 @@ class PaymentReconciliation(Document):
 		self.common_filter_conditions.append(ple.account == self.receivable_payable_account)
 
 		self.get_return_invoices()
+		return_invoices = [
+			x for x in self.return_invoices if x.return_against == None or x.return_against == ""
+		]
 
 		outstanding_dr_or_cr = []
-		if self.return_invoices:
+		if return_invoices:
 			ple_query = QueryPaymentLedger()
 			return_outstanding = ple_query.get_voucher_outstandings(
-				vouchers=self.return_invoices,
+				vouchers=return_invoices,
 				common_filter=self.common_filter_conditions,
 				posting_date=self.ple_posting_date_filter,
 				min_outstanding=-(self.minimum_payment_amount) if self.minimum_payment_amount else None,
@@ -216,7 +199,6 @@ class PaymentReconciliation(Document):
 								"amount": -(inv.outstanding_in_account_currency),
 								"posting_date": inv.posting_date,
 								"currency": inv.currency,
-								"cost_center": inv.cost_center,
 							}
 						)
 					)
@@ -243,8 +225,6 @@ class PaymentReconciliation(Document):
 			min_outstanding=self.minimum_invoice_amount if self.minimum_invoice_amount else None,
 			max_outstanding=self.maximum_invoice_amount if self.maximum_invoice_amount else None,
 			accounting_dimensions=self.accounting_dimension_filter_conditions,
-			limit=self.invoice_limit,
-			voucher_no=self.invoice_name,
 		)
 
 		cr_dr_notes = (
@@ -296,11 +276,6 @@ class PaymentReconciliation(Document):
 	def calculate_difference_on_allocation_change(self, payment_entry, invoice, allocated_amount):
 		invoice_exchange_map = self.get_invoice_exchange_map(invoice, payment_entry)
 		invoice[0]["exchange_rate"] = invoice_exchange_map.get(invoice[0].get("invoice_number"))
-		if payment_entry[0].get("reference_type") in ["Sales Invoice", "Purchase Invoice"]:
-			payment_entry[0]["exchange_rate"] = invoice_exchange_map.get(
-				payment_entry[0].get("reference_name")
-			)
-
 		new_difference_amount = self.get_difference_amount(
 			payment_entry[0], invoice[0], allocated_amount
 		)
@@ -365,12 +340,10 @@ class PaymentReconciliation(Document):
 				"allocated_amount": allocated_amount,
 				"difference_amount": pay.get("difference_amount"),
 				"currency": inv.get("currency"),
-				"cost_center": pay.get("cost_center"),
 			}
 		)
 
 	def reconcile_allocations(self, skip_ref_details_update_for_pe=False):
-		adjust_allocations_for_taxes(self)
 		dr_or_cr = (
 			"credit_in_account_currency"
 			if erpnext.get_party_account_type(self.party_type) == "Receivable"
@@ -390,6 +363,12 @@ class PaymentReconciliation(Document):
 				payment_details = self.get_payment_details(row, dr_or_cr)
 				reconciled_entry.append(payment_details)
 
+				if payment_details.difference_amount and row.reference_type not in [
+					"Sales Invoice",
+					"Purchase Invoice",
+				]:
+					self.make_difference_entry(payment_details)
+
 		if entry_list:
 			reconcile_against_document(entry_list, skip_ref_details_update_for_pe)
 
@@ -422,6 +401,59 @@ class PaymentReconciliation(Document):
 
 		self.get_unreconciled_entries()
 
+	def make_difference_entry(self, row):
+		journal_entry = frappe.new_doc("Journal Entry")
+		journal_entry.voucher_type = "Exchange Gain Or Loss"
+		journal_entry.company = self.company
+		journal_entry.posting_date = nowdate()
+		journal_entry.multi_currency = 1
+
+		party_account_currency = frappe.get_cached_value(
+			"Account", self.receivable_payable_account, "account_currency"
+		)
+		difference_account_currency = frappe.get_cached_value(
+			"Account", row.difference_account, "account_currency"
+		)
+
+		# Account Currency has balance
+		dr_or_cr = "debit" if self.party_type == "Customer" else "credit"
+		reverse_dr_or_cr = "debit" if dr_or_cr == "credit" else "credit"
+
+		journal_account = frappe._dict(
+			{
+				"account": self.receivable_payable_account,
+				"party_type": self.party_type,
+				"party": self.party,
+				"account_currency": party_account_currency,
+				"exchange_rate": 0,
+				"cost_center": erpnext.get_default_cost_center(self.company),
+				"reference_type": row.against_voucher_type,
+				"reference_name": row.against_voucher,
+				dr_or_cr: flt(row.difference_amount),
+				dr_or_cr + "_in_account_currency": 0,
+			}
+		)
+
+		journal_entry.append("accounts", journal_account)
+
+		journal_account = frappe._dict(
+			{
+				"account": row.difference_account,
+				"account_currency": difference_account_currency,
+				"exchange_rate": 1,
+				"cost_center": erpnext.get_default_cost_center(self.company),
+				reverse_dr_or_cr + "_in_account_currency": flt(row.difference_amount),
+				reverse_dr_or_cr: flt(row.difference_amount),
+			}
+		)
+
+		journal_entry.append("accounts", journal_account)
+
+		journal_entry.save()
+		journal_entry.submit()
+
+		return journal_entry
+
 	def get_payment_details(self, row, dr_or_cr):
 		return frappe._dict(
 			{
@@ -441,7 +473,6 @@ class PaymentReconciliation(Document):
 				"allocated_amount": flt(row.get("allocated_amount")),
 				"difference_amount": flt(row.get("difference_amount")),
 				"difference_account": row.get("difference_account"),
-				"cost_center": row.get("cost_center"),
 			}
 		)
 
@@ -588,6 +619,16 @@ class PaymentReconciliation(Document):
 
 
 def reconcile_dr_cr_note(dr_cr_notes, company):
+	def get_difference_row(inv):
+		if inv.difference_amount != 0 and inv.difference_account:
+			difference_row = {
+				"account": inv.difference_account,
+				inv.dr_or_cr: abs(inv.difference_amount) if inv.difference_amount > 0 else 0,
+				reconcile_dr_or_cr: abs(inv.difference_amount) if inv.difference_amount < 0 else 0,
+				"cost_center": erpnext.get_default_cost_center(company),
+			}
+			return difference_row
+
 	for inv in dr_cr_notes:
 		voucher_type = "Credit Note" if inv.voucher_type == "Sales Invoice" else "Debit Note"
 
@@ -614,9 +655,7 @@ def reconcile_dr_cr_note(dr_cr_notes, company):
 						inv.dr_or_cr: abs(inv.allocated_amount),
 						"reference_type": inv.against_voucher_type,
 						"reference_name": inv.against_voucher,
-						"cost_center": inv.cost_center or erpnext.get_default_cost_center(company),
-						"exchange_rate": inv.exchange_rate,
-						"user_remark": f"{fmt_money(flt(inv.allocated_amount), currency=company_currency)} against {inv.against_voucher}",
+						"cost_center": erpnext.get_default_cost_center(company),
 					},
 					{
 						"account": inv.account,
@@ -629,50 +668,14 @@ def reconcile_dr_cr_note(dr_cr_notes, company):
 						),
 						"reference_type": inv.voucher_type,
 						"reference_name": inv.voucher_no,
-						"cost_center": inv.cost_center or erpnext.get_default_cost_center(company),
-						"exchange_rate": inv.exchange_rate,
-						"user_remark": f"{fmt_money(flt(inv.allocated_amount), currency=company_currency)} from {inv.voucher_no}",
+						"cost_center": erpnext.get_default_cost_center(company),
 					},
 				],
 			}
 		)
 
+		if difference_entry := get_difference_row(inv):
+			jv.append("accounts", difference_entry)
+
 		jv.flags.ignore_mandatory = True
-		jv.flags.ignore_exchange_rate = True
-		jv.remark = None
-		jv.flags.skip_remarks_creation = True
-		jv.is_system_generated = True
 		jv.submit()
-
-		if inv.difference_amount != 0:
-			# make gain/loss journal
-			if inv.party_type == "Customer":
-				dr_or_cr = "credit" if inv.difference_amount < 0 else "debit"
-			else:
-				dr_or_cr = "debit" if inv.difference_amount < 0 else "credit"
-
-			reverse_dr_or_cr = "debit" if dr_or_cr == "credit" else "credit"
-
-			create_gain_loss_journal(
-				company,
-				today(),
-				inv.party_type,
-				inv.party,
-				inv.account,
-				inv.difference_account,
-				inv.difference_amount,
-				dr_or_cr,
-				reverse_dr_or_cr,
-				inv.voucher_type,
-				inv.voucher_no,
-				None,
-				inv.against_voucher_type,
-				inv.against_voucher,
-				None,
-				inv.cost_center,
-			)
-
-
-@erpnext.allow_regional
-def adjust_allocations_for_taxes(doc):
-	pass

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -686,24 +686,14 @@ class TestPaymentReconciliation(FrappeTestCase):
 
 		# Check if difference journal entry gets generated for difference amount after reconciliation
 		pr.reconcile()
-		total_credit_amount = frappe.db.get_all(
+		total_debit_amount = frappe.db.get_all(
 			"Journal Entry Account",
 			{"account": self.debtors_eur, "docstatus": 1, "reference_name": si.name},
-			"sum(credit) as amount",
+			"sum(debit) as amount",
 			group_by="reference_name",
 		)[0].amount
 
-		# total credit includes the exchange gain/loss amount
-		self.assertEqual(flt(total_credit_amount, 2), 8500)
-
-		jea_parent = frappe.db.get_all(
-			"Journal Entry Account",
-			filters={"account": self.debtors_eur, "docstatus": 1, "reference_name": si.name, "credit": 500},
-			fields=["parent"],
-		)[0]
-		self.assertEqual(
-			frappe.db.get_value("Journal Entry", jea_parent.parent, "voucher_type"), "Exchange Gain Or Loss"
-		)
+		self.assertEqual(flt(total_debit_amount, 2), -500)
 
 	def test_difference_amount_via_payment_entry(self):
 		# Make Sale Invoice

erpnext/accounts/doctype/payment_reconciliation_allocation/payment_reconciliation_allocation.json

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

erpnext/accounts/doctype/payment_reconciliation_payment/payment_reconciliation_payment.json

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

erpnext/accounts/doctype/payment_request/payment_request.json

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

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -1,9 +1,13 @@
+# Copyright (c) 2015, 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.utils import flt, nowdate
+from frappe.utils import flt, get_url, nowdate
 from frappe.utils.background_jobs import enqueue
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
@@ -16,6 +20,7 @@ from erpnext.accounts.doctype.payment_entry.payment_entry import (
 from erpnext.accounts.doctype.subscription_plan.subscription_plan import get_plan_rate
 from erpnext.accounts.party import get_party_account, get_party_bank_account
 from erpnext.accounts.utils import get_account_currency
+from erpnext.erpnext_integrations.stripe_integration import create_stripe_subscription
 from erpnext.utilities import payment_app_import_guard
 
 
@@ -244,7 +249,7 @@ class PaymentRequest(Document):
 		if (
 			party_account_currency == ref_doc.company_currency and party_account_currency != self.currency
 		):
-			party_amount = ref_doc.get("base_rounded_total") or ref_doc.get("base_grand_total")
+			party_amount = ref_doc.base_grand_total
 		else:
 			party_amount = self.grand_total
 
@@ -359,11 +364,35 @@ class PaymentRequest(Document):
 	def get_payment_success_url(self):
 		return self.payment_success_url
 
+	def on_payment_authorized(self, status=None):
+		if not status:
+			return
+
+		shopping_cart_settings = frappe.get_doc("E Commerce Settings")
+
+		if status in ["Authorized", "Completed"]:
+			redirect_to = None
+			self.set_as_paid()
+
+			# if shopping cart enabled and in session
+			if (
+				shopping_cart_settings.enabled
+				and hasattr(frappe.local, "session")
+				and frappe.local.session.user != "Guest"
+			) and self.payment_channel != "Phone":
+
+				success_url = shopping_cart_settings.payment_success_url
+				if success_url:
+					redirect_to = ({"Orders": "/orders", "Invoices": "/invoices", "My Account": "/me"}).get(
+						success_url, "/me"
+					)
+				else:
+					redirect_to = get_url("/orders/{0}".format(self.reference_name))
+
+			return redirect_to
+
 	def create_subscription(self, payment_provider, gateway_controller, data):
 		if payment_provider == "stripe":
-			with payment_app_import_guard():
-				from payments.payment_gateways.stripe_integration import create_stripe_subscription
-
 			return create_stripe_subscription(gateway_controller, data)
 
 
@@ -515,12 +544,13 @@ def get_existing_payment_request_amount(ref_dt, ref_dn):
 
 
 def get_gateway_details(args):  # nosemgrep
-	"""
-	Return gateway and payment account of default payment gateway
-	"""
-	gateway_account = args.get("payment_gateway_account", {"is_default": 1})
-	if gateway_account:
-		return get_payment_gateway_account(gateway_account)
+	"""return gateway and payment account of default payment gateway"""
+	if args.get("payment_gateway_account"):
+		return get_payment_gateway_account(args.get("payment_gateway_account"))
+
+	if args.order_type == "Shopping Cart":
+		payment_gateway_account = frappe.get_doc("E Commerce Settings").payment_gateway_account
+		return get_payment_gateway_account(payment_gateway_account)
 
 	gateway_account = get_payment_gateway_account({"is_default": 1})
 

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -144,7 +144,8 @@ class TestPaymentRequest(unittest.TestCase):
 			(d[0], d)
 			for d in [
 				["_Test Receivable USD - _TC", 0, 5000, si_usd.name],
-				[pr.payment_account, 5000.0, 0, None],
+				[pr.payment_account, 6290.0, 0, None],
+				["_Test Exchange Gain/Loss - _TC", 0, 1290, None],
 			]
 		)
 

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.json

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

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

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

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

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

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.js

@@ -153,7 +153,7 @@ frappe.ui.form.on('POS Closing Entry', {
 frappe.ui.form.on('POS Closing Entry Detail', {
 	closing_amount: (frm, cdt, cdn) => {
 		const row = locals[cdt][cdn];
-		frappe.model.set_value(cdt, cdn, "difference", flt(row.closing_amount - row.expected_amount));
+		frappe.model.set_value(cdt, cdn, "difference", flt(row.expected_amount - row.closing_amount));
 	}
 })
 
@@ -185,7 +185,6 @@ function refresh_payments(d, frm) {
 		}
 		if (payment) {
 			payment.expected_amount += flt(p.amount);
-			payment.closing_amount = payment.expected_amount;
 			payment.difference = payment.closing_amount - payment.expected_amount;
 		} else {
 			frm.add_child("payment_reconciliation", {

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.json

@@ -221,7 +221,6 @@
    "read_only": 1
   },
   {
-   "default": "Now",
    "fieldname": "posting_time",
    "fieldtype": "Time",
    "label": "Posting Time",
@@ -236,7 +235,7 @@
    "link_fieldname": "pos_closing_entry"
   }
  ],
- "modified": "2023-08-10 16:25:49.322697",
+ "modified": "2022-08-01 11:37:14.991228",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Closing Entry",

erpnext/accounts/doctype/pos_closing_entry/test_pos_closing_entry.py

@@ -5,18 +5,12 @@ import unittest
 
 import frappe
 
-from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension import (
-	create_dimension,
-	disable_dimension,
-)
 from erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry import (
 	make_closing_entry_from_opening,
 )
-from erpnext.accounts.doctype.pos_invoice.pos_invoice import make_sales_return
 from erpnext.accounts.doctype.pos_invoice.test_pos_invoice import create_pos_invoice
 from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
 from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
-from erpnext.selling.page.point_of_sale.point_of_sale import get_items
 from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
 
 
@@ -73,36 +67,6 @@ class TestPOSClosingEntry(unittest.TestCase):
 
 		self.assertTrue(pcv_doc.name)
 
-	def test_pos_qty_for_item(self):
-		"""
-		Test if quantity is calculated correctly for an item in POS Closing Entry
-		"""
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-
-		test_item_qty = get_test_item_qty(pos_profile)
-
-		pos_inv1 = create_pos_invoice(rate=3500, do_not_submit=1)
-		pos_inv1.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3500})
-		pos_inv1.submit()
-
-		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
-		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
-		pos_inv2.submit()
-
-		# make return entry of pos_inv2
-		pos_return = make_sales_return(pos_inv2.name)
-		pos_return.paid_amount = pos_return.grand_total
-		pos_return.save()
-		pos_return.submit()
-
-		pcv_doc = make_closing_entry_from_opening(opening_entry)
-		pcv_doc.submit()
-
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-		test_item_qty_after_sales = get_test_item_qty(pos_profile)
-		self.assertEqual(test_item_qty_after_sales, test_item_qty - 1)
-
 	def test_cancelling_of_pos_closing_entry(self):
 		test_user, pos_profile = init_user_and_profile()
 		opening_entry = create_opening_entry(pos_profile, test_user.name)
@@ -144,43 +108,6 @@ class TestPOSClosingEntry(unittest.TestCase):
 		pos_inv1.load_from_db()
 		self.assertEqual(pos_inv1.status, "Paid")
 
-	def test_pos_closing_for_required_accounting_dimension_in_pos_profile(self):
-		"""
-		test case to check whether we can create POS Closing Entry without mandatory accounting dimension
-		"""
-
-		create_dimension()
-		pos_profile = make_pos_profile(do_not_insert=1, do_not_set_accounting_dimension=1)
-
-		self.assertRaises(frappe.ValidationError, pos_profile.insert)
-
-		pos_profile.location = "Block 1"
-		pos_profile.insert()
-		self.assertTrue(frappe.db.exists("POS Profile", pos_profile.name))
-
-		test_user = init_user_and_profile(do_not_create_pos_profile=1)
-
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-		pos_inv1 = create_pos_invoice(rate=350, do_not_submit=1, pos_profile=pos_profile.name)
-		pos_inv1.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3500})
-		pos_inv1.submit()
-
-		# if in between a mandatory accounting dimension is added to the POS Profile then
-		accounting_dimension_department = frappe.get_doc("Accounting Dimension", {"name": "Department"})
-		accounting_dimension_department.dimension_defaults[0].mandatory_for_bs = 1
-		accounting_dimension_department.save()
-
-		pcv_doc = make_closing_entry_from_opening(opening_entry)
-		# will assert coz the new mandatory accounting dimension bank is not set in POS Profile
-		self.assertRaises(frappe.ValidationError, pcv_doc.submit)
-
-		accounting_dimension_department = frappe.get_doc(
-			"Accounting Dimension Detail", {"parent": "Department"}
-		)
-		accounting_dimension_department.mandatory_for_bs = 0
-		accounting_dimension_department.save()
-		disable_dimension()
-
 
 def init_user_and_profile(**args):
 	user = "test@example.com"
@@ -190,28 +117,9 @@ def init_user_and_profile(**args):
 	test_user.add_roles(*roles)
 	frappe.set_user(user)
 
-	if args.get("do_not_create_pos_profile"):
-		return test_user
-
 	pos_profile = make_pos_profile(**args)
 	pos_profile.append("applicable_for_users", {"default": 1, "user": user})
 
 	pos_profile.save()
 
 	return test_user, pos_profile
-
-
-def get_test_item_qty(pos_profile):
-	test_item_pos = get_items(
-		start=0,
-		page_length=5,
-		price_list="Standard Selling",
-		pos_profile=pos_profile.name,
-		search_term="_Test Item",
-		item_group="All Item Groups",
-	)
-
-	test_item_qty = [item for item in test_item_pos["items"] if item["item_code"] == "_Test Item"][
-		0
-	].get("actual_qty")
-	return test_item_qty

erpnext/accounts/doctype/pos_invoice/pos_invoice.js

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

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -49,7 +49,6 @@ class POSInvoice(SalesInvoice):
 		self.validate_pos()
 		self.validate_payment_amount()
 		self.validate_loyalty_transaction()
-		self.validate_company_with_pos_company()
 		if self.coupon_code:
 			from erpnext.accounts.doctype.pricing_rule.utils import validate_coupon_code
 
@@ -282,14 +281,6 @@ class POSInvoice(SalesInvoice):
 			if total_amount_in_payments and total_amount_in_payments < invoice_total:
 				frappe.throw(_("Total payments amount can't be greater than {}").format(-invoice_total))
 
-	def validate_company_with_pos_company(self):
-		if self.company != frappe.db.get_value("POS Profile", self.pos_profile, "company"):
-			frappe.throw(
-				_("Company {} does not match with POS Profile Company {}").format(
-					self.company, frappe.db.get_value("POS Profile", self.pos_profile, "company")
-				)
-			)
-
 	def validate_loyalty_transaction(self):
 		if self.redeem_loyalty_points and (
 			not self.loyalty_redemption_account or not self.loyalty_redemption_cost_center
@@ -368,7 +359,6 @@ class POSInvoice(SalesInvoice):
 		profile = {}
 		if self.pos_profile:
 			profile = frappe.get_doc("POS Profile", self.pos_profile)
-			self.company = profile.get("company")
 
 		if not self.get("payments") and not for_validate:
 			update_multi_mode_option(self, profile)
@@ -414,7 +404,7 @@ class POSInvoice(SalesInvoice):
 				selling_price_list = (
 					customer_price_list or customer_group_price_list or profile.get("selling_price_list")
 				)
-				if customer_currency and customer_currency != profile.get("currency"):
+				if customer_currency != profile.get("currency"):
 					self.set("currency", customer_currency)
 
 			else:
@@ -552,7 +542,6 @@ def get_stock_availability(item_code, warehouse):
 		is_stock_item = True
 		bin_qty = get_bin_qty(item_code, warehouse)
 		pos_sales_qty = get_pos_reserved_qty(item_code, warehouse)
-
 		return bin_qty - pos_sales_qty, is_stock_item
 	else:
 		is_stock_item = True
@@ -606,6 +595,7 @@ def get_pos_reserved_qty(item_code, warehouse):
 		.where(
 			(p_inv.name == p_item.parent)
 			& (IfNull(p_inv.consolidated_invoice, "") == "")
+			& (p_inv.is_return == 0)
 			& (p_item.docstatus == 1)
 			& (p_item.item_code == item_code)
 			& (p_item.warehouse == warehouse)

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -776,28 +776,19 @@ class TestPOSInvoice(unittest.TestCase):
 		)
 
 		create_batch_item_with_batch("_BATCH ITEM Test For Reserve", "TestBatch-RS 02")
-		se = make_stock_entry(
+		make_stock_entry(
 			target="_Test Warehouse - _TC",
 			item_code="_BATCH ITEM Test For Reserve",
-			qty=30,
+			qty=20,
 			basic_rate=100,
+			batch_no="TestBatch-RS 02",
 		)
 
-		se.reload()
-
-		batch_no = get_batch_from_bundle(se.items[0].serial_and_batch_bundle)
-
-		# POS Invoice 1, for the batch without bundle
 		pos_inv1 = create_pos_invoice(
-			item="_BATCH ITEM Test For Reserve", rate=300, qty=15, do_not_save=1
+			item="_BATCH ITEM Test For Reserve", rate=300, qty=15, batch_no="TestBatch-RS 02"
 		)
-
-		pos_inv1.items[0].batch_no = batch_no
 		pos_inv1.save()
 		pos_inv1.submit()
-		pos_inv1.reload()
-
-		self.assertFalse(pos_inv1.items[0].serial_and_batch_bundle)
 
 		batches = get_auto_batch_nos(
 			frappe._dict(
@@ -806,24 +797,7 @@ class TestPOSInvoice(unittest.TestCase):
 		)
 
 		for batch in batches:
-			if batch.batch_no == batch_no and batch.warehouse == "_Test Warehouse - _TC":
-				self.assertEqual(batch.qty, 15)
-
-		# POS Invoice 2, for the batch with bundle
-		pos_inv2 = create_pos_invoice(
-			item="_BATCH ITEM Test For Reserve", rate=300, qty=10, batch_no=batch_no
-		)
-		pos_inv2.reload()
-		self.assertTrue(pos_inv2.items[0].serial_and_batch_bundle)
-
-		batches = get_auto_batch_nos(
-			frappe._dict(
-				{"item_code": "_BATCH ITEM Test For Reserve", "warehouse": "_Test Warehouse - _TC"}
-			)
-		)
-
-		for batch in batches:
-			if batch.batch_no == batch_no and batch.warehouse == "_Test Warehouse - _TC":
+			if batch.batch_no == "TestBatch-RS 02" and batch.warehouse == "_Test Warehouse - _TC":
 				self.assertEqual(batch.qty, 5)
 
 	def test_pos_batch_item_qty_validation(self):

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -12,8 +12,6 @@ from frappe.utils import cint, flt, get_time, getdate, nowdate, nowtime
 from frappe.utils.background_jobs import enqueue, is_job_enqueued
 from frappe.utils.scheduler import is_scheduler_inactive
 
-from erpnext.accounts.doctype.pos_profile.pos_profile import required_accounting_dimensions
-
 
 class POSInvoiceMergeLog(Document):
 	def validate(self):
@@ -97,6 +95,7 @@ class POSInvoiceMergeLog(Document):
 			sales_invoice = self.process_merging_into_sales_invoice(sales)
 
 		self.save()  # save consolidated_sales_invoice & consolidated_credit_note ref in merge log
+
 		self.update_pos_invoices(pos_invoice_docs, sales_invoice, credit_note)
 
 	def on_cancel(self):
@@ -109,6 +108,7 @@ class POSInvoiceMergeLog(Document):
 
 	def process_merging_into_sales_invoice(self, data):
 		sales_invoice = self.get_new_sales_invoice()
+
 		sales_invoice = self.merge_pos_invoice_into(sales_invoice, data)
 
 		sales_invoice.is_consolidated = 1
@@ -241,22 +241,6 @@ class POSInvoiceMergeLog(Document):
 		invoice.disable_rounded_total = cint(
 			frappe.db.get_value("POS Profile", invoice.pos_profile, "disable_rounded_total")
 		)
-		accounting_dimensions = required_accounting_dimensions()
-		dimension_values = frappe.db.get_value(
-			"POS Profile", {"name": invoice.pos_profile}, accounting_dimensions, as_dict=1
-		)
-		for dimension in accounting_dimensions:
-			dimension_value = dimension_values.get(dimension)
-
-			if not dimension_value:
-				frappe.throw(
-					_("Please set Accounting Dimension {} in {}").format(
-						frappe.bold(frappe.unscrub(dimension)),
-						frappe.get_desk_link("POS Profile", invoice.pos_profile),
-					)
-				)
-
-			invoice.set(dimension, dimension_value)
 
 		if self.merge_invoices_based_on == "Customer Group":
 			invoice.flags.ignore_pos_profile = True
@@ -401,7 +385,6 @@ def split_invoices(invoices):
 		for d in invoices
 		if d.is_return and d.return_against
 	]
-
 	for pos_invoice in pos_return_docs:
 		for item in pos_invoice.items:
 			if not item.serial_no and not item.serial_and_batch_bundle:
@@ -443,9 +426,11 @@ def create_merge_logs(invoice_by_customer, closing_entry=None):
 				)
 				merge_log.customer = customer
 				merge_log.pos_closing_entry = closing_entry.get("name") if closing_entry else None
+
 				merge_log.set("pos_invoices", _invoices)
 				merge_log.save(ignore_permissions=True)
 				merge_log.submit()
+
 		if closing_entry:
 			closing_entry.set_status(update=True, status="Submitted")
 			closing_entry.db_set("error_message", "")
@@ -454,7 +439,7 @@ def create_merge_logs(invoice_by_customer, closing_entry=None):
 	except Exception as e:
 		frappe.db.rollback()
 		message_log = frappe.message_log.pop() if frappe.message_log else str(e)
-		error_message = get_error_message(message_log)
+		error_message = safe_load_json(message_log)
 
 		if closing_entry:
 			closing_entry.set_status(update=True, status="Failed")
@@ -483,7 +468,7 @@ def cancel_merge_logs(merge_logs, closing_entry=None):
 	except Exception as e:
 		frappe.db.rollback()
 		message_log = frappe.message_log.pop() if frappe.message_log else str(e)
-		error_message = get_error_message(message_log)
+		error_message = safe_load_json(message_log)
 
 		if closing_entry:
 			closing_entry.set_status(update=True, status="Submitted")
@@ -525,8 +510,10 @@ def check_scheduler_status():
 		frappe.throw(_("Scheduler is inactive. Cannot enqueue job."), title=_("Scheduler Inactive"))
 
 
-def get_error_message(message) -> str:
+def safe_load_json(message):
 	try:
-		return message["message"]
+		json_message = json.loads(message).get("message")
 	except Exception:
-		return str(message)
+		json_message = message
+
+	return json_message

erpnext/accounts/doctype/pos_profile/pos_profile.js

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

erpnext/accounts/doctype/pos_profile/pos_profile.py

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

erpnext/accounts/doctype/pos_profile/test_pos_profile.py

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

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.json

@@ -146,7 +146,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-08-11 10:56:51.699137",
+ "modified": "2023-04-21 17:19:30.912953",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Payment Reconciliation",
@@ -154,25 +154,15 @@
  "owner": "Administrator",
  "permissions": [
   {
-   "amend": 1,
-   "cancel": 1,
    "create": 1,
    "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
    "read": 1,
-   "role": "Accounts Manager",
+   "report": 1,
+   "role": "System Manager",
    "share": 1,
-   "submit": 1,
-   "write": 1
-  },
-  {
-   "amend": 1,
-   "cancel": 1,
-   "create": 1,
-   "delete": 1,
-   "read": 1,
-   "role": "Accounts User",
-   "share": 1,
-   "submit": 1,
    "write": 1
   }
  ],

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.py

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

erpnext/accounts/doctype/process_payment_reconciliation_log/process_payment_reconciliation_log.json

@@ -110,7 +110,7 @@
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2023-11-02 11:32:12.254018",
+ "modified": "2023-04-21 17:36:26.642617",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Payment Reconciliation Log",
@@ -125,19 +125,7 @@
    "print": 1,
    "read": 1,
    "report": 1,
-   "role": "Accounts Manager",
-   "share": 1,
-   "write": 1
-  },
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "Accounts User",
+   "role": "System Manager",
    "share": 1,
    "write": 1
   }

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

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

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -27,13 +27,7 @@ class ProcessStatementOfAccounts(Document):
 		if not self.subject:
 			self.subject = "Statement Of Accounts for {{ customer.customer_name }}"
 		if not self.body:
-			if self.report == "General Ledger":
-				body_str = " from {{ doc.from_date }} to {{ doc.to_date }}."
-			else:
-				body_str = " until {{ doc.posting_date }}."
-			self.body = "Hello {{ customer.customer_name }},<br>PFA your Statement Of Accounts" + body_str
-		if not self.pdf_name:
-			self.pdf_name = "{{ customer.customer_name }}"
+			self.body = "Hello {{ customer.name }},<br>PFA your Statement Of Accounts from {{ doc.from_date }} to {{ doc.to_date }}."
 
 		validate_template(self.subject)
 		validate_template(self.body)
@@ -48,20 +42,6 @@ class ProcessStatementOfAccounts(Document):
 
 
 def get_report_pdf(doc, consolidated=True):
-	statement_dict = get_statement_dict(doc)
-	if not bool(statement_dict):
-		return False
-	elif consolidated:
-		delimiter = '<div style="page-break-before: always;"></div>' if doc.include_break else ""
-		result = delimiter.join(list(statement_dict.values()))
-		return get_pdf(result, {"orientation": doc.orientation})
-	else:
-		for customer, statement_html in statement_dict.items():
-			statement_dict[customer] = get_pdf(statement_html, {"orientation": doc.orientation})
-		return statement_dict
-
-
-def get_statement_dict(doc, get_statement_dict=False):
 	statement_dict = {}
 	ageing = ""
 
@@ -80,23 +60,31 @@ def get_statement_dict(doc, get_statement_dict=False):
 
 		if doc.report == "General Ledger":
 			filters.update(get_gl_filters(doc, entry, tax_id, presentation_currency))
+		else:
+			filters.update(get_ar_filters(doc, entry))
+
+		if doc.report == "General Ledger":
 			col, res = get_soa(filters)
 			for x in [0, -2, -1]:
 				res[x]["account"] = res[x]["account"].replace("'", "")
 			if len(res) == 3:
 				continue
 		else:
-			filters.update(get_ar_filters(doc, entry))
 			ar_res = get_ar_soa(filters)
 			col, res = ar_res[0], ar_res[1]
-			if not res:
-				continue
 
-		statement_dict[entry.customer] = (
-			[res, ageing] if get_statement_dict else get_html(doc, filters, entry, col, res, ageing)
-		)
+		statement_dict[entry.customer] = get_html(doc, filters, entry, col, res, ageing)
 
-	return statement_dict
+	if not bool(statement_dict):
+		return False
+	elif consolidated:
+		delimiter = '<div style="page-break-before: always;"></div>' if doc.include_break else ""
+		result = delimiter.join(list(statement_dict.values()))
+		return get_pdf(result, {"orientation": doc.orientation})
+	else:
+		for customer, statement_html in statement_dict.items():
+			statement_dict[customer] = get_pdf(statement_html, {"orientation": doc.orientation})
+		return statement_dict
 
 
 def set_ageing(doc, entry):
@@ -109,8 +97,7 @@ def set_ageing(doc, entry):
 			"range2": 60,
 			"range3": 90,
 			"range4": 120,
-			"party_type": "Customer",
-			"party": [entry.customer],
+			"customer": entry.customer,
 		}
 	)
 	col1, ageing = get_ageing(ageing_filters)
@@ -153,9 +140,7 @@ def get_gl_filters(doc, entry, tax_id, presentation_currency):
 def get_ar_filters(doc, entry):
 	return {
 		"report_date": doc.posting_date if doc.posting_date else None,
-		"party_type": "Customer",
-		"party": [entry.customer],
-		"customer_name": entry.customer_name if entry.customer_name else None,
+		"customer": entry.customer,
 		"payment_terms_template": doc.payment_terms_template if doc.payment_terms_template else None,
 		"sales_partner": doc.sales_partner if doc.sales_partner else None,
 		"sales_person": doc.sales_person if doc.sales_person else None,
@@ -381,20 +366,18 @@ def download_statements(document_name):
 
 
 @frappe.whitelist()
-def send_emails(document_name, from_scheduler=False, posting_date=None):
+def send_emails(document_name, from_scheduler=False):
 	doc = frappe.get_doc("Process Statement Of Accounts", document_name)
 	report = get_report_pdf(doc, consolidated=False)
 
 	if report:
 		for customer, report_pdf in report.items():
-			context = get_context(customer, doc)
-			filename = frappe.render_template(doc.pdf_name, context)
-			attachments = [{"fname": filename + ".pdf", "fcontent": report_pdf}]
+			attachments = [{"fname": customer + ".pdf", "fcontent": report_pdf}]
 
 			recipients, cc = get_recipients_and_cc(customer, doc)
 			if not recipients:
 				continue
-
+			context = get_context(customer, doc)
 			subject = frappe.render_template(doc.subject, context)
 			message = frappe.render_template(doc.body, context)
 
@@ -413,7 +396,7 @@ def send_emails(document_name, from_scheduler=False, posting_date=None):
 			)
 
 		if doc.enable_auto_email and from_scheduler:
-			new_to_date = getdate(posting_date or today())
+			new_to_date = getdate(today())
 			if doc.frequency == "Weekly":
 				new_to_date = add_days(new_to_date, 7)
 			else:
@@ -422,11 +405,8 @@ def send_emails(document_name, from_scheduler=False, posting_date=None):
 			doc.add_comment(
 				"Comment", "Emails sent on: " + frappe.utils.format_datetime(frappe.utils.now())
 			)
-			if doc.report == "General Ledger":
-				doc.db_set("to_date", new_to_date, commit=True)
-				doc.db_set("from_date", new_from_date, commit=True)
-			else:
-				doc.db_set("posting_date", new_to_date, commit=True)
+			doc.db_set("to_date", new_to_date, commit=True)
+			doc.db_set("from_date", new_from_date, commit=True)
 		return True
 	else:
 		return False
@@ -436,8 +416,7 @@ def send_emails(document_name, from_scheduler=False, posting_date=None):
 def send_auto_email():
 	selected = frappe.get_list(
 		"Process Statement Of Accounts",
-		filters={"enable_auto_email": 1},
-		or_filters={"to_date": format_date(today()), "posting_date": format_date(today())},
+		filters={"to_date": format_date(today()), "enable_auto_email": 1},
 	)
 	for entry in selected:
 		send_emails(entry.name, from_scheduler=True)

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts_accounts_receivable.html

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

erpnext/accounts/doctype/process_statement_of_accounts/test_process_statement_of_accounts.py

@@ -1,110 +1,9 @@
 # Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+# import frappe
 import unittest
 
-import frappe
-from frappe.tests.utils import FrappeTestCase
-from frappe.utils import add_days, getdate, today
 
-from erpnext.accounts.doctype.process_statement_of_accounts.process_statement_of_accounts import (
-	get_statement_dict,
-	send_emails,
-)
-from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
-
-
-class TestProcessStatementOfAccounts(AccountsTestMixin, FrappeTestCase):
-	def setUp(self):
-		self.create_company()
-		self.create_customer()
-		self.create_customer(customer_name="Other Customer")
-		self.clear_old_entries()
-		self.si = create_sales_invoice()
-		create_sales_invoice(customer="Other Customer")
-
-	def test_process_soa_for_gl(self):
-		"""Tests the utils for Statement of Accounts(General Ledger)"""
-		process_soa = create_process_soa(
-			name="_Test Process SOA for GL",
-			customers=[{"customer": "_Test Customer"}, {"customer": "Other Customer"}],
-		)
-		statement_dict = get_statement_dict(process_soa, get_statement_dict=True)
-
-		# Checks if the statements are filtered based on the Customer
-		self.assertIn("Other Customer", statement_dict)
-		self.assertIn("_Test Customer", statement_dict)
-
-		# Checks if the correct number of receivable entries exist
-		# 3 rows for opening and closing and 1 row for SI
-		receivable_entries = statement_dict["_Test Customer"][0]
-		self.assertEqual(len(receivable_entries), 4)
-
-		# Checks the amount for the receivable entry
-		self.assertEqual(receivable_entries[1].voucher_no, self.si.name)
-		self.assertEqual(receivable_entries[1].balance, 100)
-
-	def test_process_soa_for_ar(self):
-		"""Tests the utils for Statement of Accounts(Accounts Receivable)"""
-		process_soa = create_process_soa(name="_Test Process SOA for AR", report="Accounts Receivable")
-		statement_dict = get_statement_dict(process_soa, get_statement_dict=True)
-
-		# Checks if the statements are filtered based on the Customer
-		self.assertNotIn("Other Customer", statement_dict)
-		self.assertIn("_Test Customer", statement_dict)
-
-		# Checks if the correct number of receivable entries exist
-		receivable_entries = statement_dict["_Test Customer"][0]
-		self.assertEqual(len(receivable_entries), 1)
-
-		# Checks the amount for the receivable entry
-		self.assertEqual(receivable_entries[0].voucher_no, self.si.name)
-		self.assertEqual(receivable_entries[0].total_due, 100)
-
-		# Checks the ageing summary for AR
-		ageing_summary = statement_dict["_Test Customer"][1][0]
-		expected_summary = frappe._dict(
-			range1=100,
-			range2=0,
-			range3=0,
-			range4=0,
-			range5=0,
-		)
-		self.check_ageing_summary(ageing_summary, expected_summary)
-
-	def test_auto_email_for_process_soa_ar(self):
-		process_soa = create_process_soa(
-			name="_Test Process SOA", enable_auto_email=1, report="Accounts Receivable"
-		)
-		send_emails(process_soa.name, from_scheduler=True)
-		process_soa.load_from_db()
-		self.assertEqual(process_soa.posting_date, getdate(add_days(today(), 7)))
-
-	def check_ageing_summary(self, ageing, expected_ageing):
-		for age_range in expected_ageing:
-			self.assertEqual(expected_ageing[age_range], ageing.get(age_range))
-
-	def tearDown(self):
-		frappe.db.rollback()
-
-
-def create_process_soa(**args):
-	args = frappe._dict(args)
-	frappe.delete_doc_if_exists("Process Statement Of Accounts", args.name)
-	process_soa = frappe.new_doc("Process Statement Of Accounts")
-	soa_dict = frappe._dict(
-		name=args.name,
-		company=args.company or "_Test Company",
-		customers=args.customers or [{"customer": "_Test Customer"}],
-		enable_auto_email=1 if args.enable_auto_email else 0,
-		frequency=args.frequency or "Weekly",
-		report=args.report or "General Ledger",
-		from_date=args.from_date or getdate(today()),
-		to_date=args.to_date or getdate(today()),
-		posting_date=args.posting_date or getdate(today()),
-		include_ageing=1,
-	)
-	process_soa.update(soa_dict)
-	process_soa.save()
-	return process_soa
+class TestProcessStatementOfAccounts(unittest.TestCase):
+	pass

erpnext/accounts/doctype/process_subscription/process_subscription.js

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

erpnext/accounts/doctype/process_subscription/process_subscription.json

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

erpnext/accounts/doctype/process_subscription/process_subscription.py

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

erpnext/accounts/doctype/process_subscription/test_process_subscription.py

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

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -35,7 +35,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		super.onload();
 
 		// Ignore linked advances
-		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry', 'Purchase Invoice', "Repost Payment Ledger", "Repost Accounting Ledger"];
+		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry', 'Purchase Invoice', "Repost Payment Ledger"];
 
 		if(!this.frm.doc.__islocal) {
 			// show credit_to in print format
@@ -65,25 +65,6 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 			erpnext.accounts.ledger_preview.show_stock_ledger_preview(this.frm);
 		}
 
-		if (this.frm.doc.repost_required && this.frm.doc.docstatus===1) {
-			this.frm.set_intro(__("Accounting entries for this invoice need to be reposted. Please click on 'Repost' button to update."));
-			this.frm.add_custom_button(__('Repost Accounting Entries'),
-				() => {
-					this.frm.call({
-						doc: this.frm.doc,
-						method: 'repost_accounting_entries',
-						freeze: true,
-						freeze_message: __('Reposting...'),
-						callback: (r) => {
-							if (!r.exc) {
-								frappe.msgprint(__('Accounting Entries are reposted.'));
-								me.frm.refresh();
-							}
-						}
-					});
-				}).removeClass('btn-default').addClass('btn-warning');
-		}
-
 		if(!doc.is_return && doc.docstatus == 1 && doc.outstanding_amount != 0){
 			if(doc.on_hold) {
 				this.frm.add_custom_button(
@@ -105,7 +86,8 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 			}
 		}
 
-		if(doc.docstatus == 1 && doc.outstanding_amount != 0 && !doc.on_hold) {
+		if(doc.docstatus == 1 && doc.outstanding_amount != 0
+			&& !(doc.is_return && doc.return_against) && !doc.on_hold) {
 			this.frm.add_custom_button(
 				__('Payment'),
 				() => this.make_payment_entry(),
@@ -180,7 +162,6 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		}
 
 		this.frm.set_df_property("tax_withholding_category", "hidden", doc.apply_tds ? 0 : 1);
-		erpnext.accounts.unreconcile_payments.add_unreconcile_btn(me.frm);
 	}
 
 	unblock_invoice() {
@@ -479,12 +460,6 @@ cur_frm.set_query("expense_account", "items", function(doc) {
 	}
 });
 
-cur_frm.set_query("wip_composite_asset", "items", function() {
-	return {
-		filters: {'is_composite_asset': 1, 'docstatus': 0 }
-	}
-});
-
 cur_frm.cscript.expense_account = function(doc, cdt, cdn){
 	var d = locals[cdt][cdn];
 	if(d.idx == 1 && d.expense_account){

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -36,7 +36,6 @@
   "currency_and_price_list",
   "currency",
   "conversion_rate",
-  "use_transaction_date_exchange_rate",
   "column_break2",
   "buying_price_list",
   "price_list_currency",
@@ -167,9 +166,7 @@
   "against_expense_account",
   "column_break_63",
   "unrealized_profit_loss_account",
-  "repost_required",
   "subscription_section",
-  "subscription",
   "auto_repeat",
   "update_auto_repeat_reference",
   "column_break_114",
@@ -193,7 +190,8 @@
   "inter_company_invoice_reference",
   "is_old_subcontracting_flow",
   "remarks",
-  "connections_tab"
+  "connections_tab",
+  "column_break_38"
  ],
  "fields": [
   {
@@ -384,8 +382,7 @@
    "label": "Supplier Invoice No",
    "oldfieldname": "bill_no",
    "oldfieldtype": "Data",
-   "print_hide": 1,
-   "search_index": 1
+   "print_hide": 1
   },
   {
    "fieldname": "column_break_15",
@@ -408,8 +405,7 @@
    "no_copy": 1,
    "options": "Purchase Invoice",
    "print_hide": 1,
-   "read_only": 1,
-   "search_index": 1
+   "read_only": 1
   },
   {
    "fieldname": "section_addresses",
@@ -993,7 +989,6 @@
    "print_hide": 1
   },
   {
-   "allow_on_submit": 1,
    "fieldname": "cash_bank_account",
    "fieldtype": "Link",
    "label": "Cash/Bank Account",
@@ -1057,7 +1052,6 @@
    "fieldtype": "Column Break"
   },
   {
-   "allow_on_submit": 1,
    "depends_on": "eval:flt(doc.write_off_amount)!=0",
    "fieldname": "write_off_account",
    "fieldtype": "Link",
@@ -1222,7 +1216,6 @@
    "read_only": 1
   },
   {
-   "allow_on_submit": 1,
    "default": "No",
    "fieldname": "is_opening",
    "fieldtype": "Select",
@@ -1355,7 +1348,6 @@
    "options": "Project"
   },
   {
-   "allow_on_submit": 1,
    "depends_on": "eval:doc.is_internal_supplier",
    "description": "Unrealized Profit/Loss account for intra-company transfers",
    "fieldname": "unrealized_profit_loss_account",
@@ -1388,7 +1380,6 @@
    "depends_on": "eval:doc.is_subcontracted",
    "fieldname": "supplier_warehouse",
    "fieldtype": "Link",
-   "ignore_user_permissions": 1,
    "label": "Supplier Warehouse",
    "no_copy": 1,
    "options": "Warehouse",
@@ -1432,12 +1423,6 @@
    "options": "Advance Tax",
    "read_only": 1
   },
-  {
-   "fieldname": "subscription",
-   "fieldtype": "Link",
-   "label": "Subscription",
-   "options": "Subscription"
-  },
   {
    "default": "0",
    "fieldname": "is_old_subcontracting_flow",
@@ -1512,6 +1497,10 @@
    "fieldname": "column_break_6",
    "fieldtype": "Column Break"
   },
+  {
+   "fieldname": "column_break_38",
+   "fieldtype": "Column Break"
+  },
   {
    "fieldname": "column_break_50",
    "fieldtype": "Column Break"
@@ -1582,29 +1571,13 @@
    "fieldname": "use_company_roundoff_cost_center",
    "fieldtype": "Check",
    "label": "Use Company Default Round Off Cost Center"
-  },
-  {
-   "default": "0",
-   "fieldname": "repost_required",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Repost Required",
-   "options": "Account",
-   "read_only": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "use_transaction_date_exchange_rate",
-   "fieldtype": "Check",
-   "label": "Use Transaction Date Exchange Rate",
-   "read_only": 1
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-11-03 15:47:30.319200",
+ "modified": "2023-07-04 17:22:59.145031",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",
@@ -1667,4 +1640,4 @@
  "timeline_field": "supplier",
  "title_field": "title",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -11,9 +11,6 @@ from frappe.utils import cint, cstr, flt, formatdate, get_link_to_form, getdate,
 import erpnext
 from erpnext.accounts.deferred_revenue import validate_service_stop_date
 from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
-from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger import (
-	validate_docs_for_deferred_accounting,
-)
 from erpnext.accounts.doctype.sales_invoice.sales_invoice import (
 	check_if_return_invoice_linked_with_payment_entry,
 	get_total_in_party_account_currency,
@@ -232,7 +229,7 @@ class PurchaseInvoice(BuyingController):
 		)
 
 		if (
-			cint(frappe.db.get_single_value("Buying Settings", "maintain_same_rate"))
+			cint(frappe.get_cached_value("Buying Settings", "None", "maintain_same_rate"))
 			and not self.is_return
 			and not self.is_internal_supplier
 		):
@@ -269,7 +266,9 @@ class PurchaseInvoice(BuyingController):
 			stock_not_billed_account = self.get_company_default("stock_received_but_not_billed")
 			stock_items = self.get_stock_items()
 
-		asset_received_but_not_billed = None
+		asset_items = [d.is_fixed_asset for d in self.items if d.is_fixed_asset]
+		if len(asset_items) > 0:
+			asset_received_but_not_billed = self.get_company_default("asset_received_but_not_billed")
 
 		if self.update_stock:
 			self.validate_item_code()
@@ -363,8 +362,6 @@ class PurchaseInvoice(BuyingController):
 					)
 				item.expense_account = asset_category_account
 			elif item.is_fixed_asset and item.pr_detail:
-				if not asset_received_but_not_billed:
-					asset_received_but_not_billed = self.get_company_default("asset_received_but_not_billed")
 				item.expense_account = asset_received_but_not_billed
 			elif not item.expense_account and for_validate:
 				throw(_("Expense account is mandatory for item {0}").format(item.item_code or item.item_name))
@@ -487,11 +484,6 @@ class PurchaseInvoice(BuyingController):
 						_("Stock cannot be updated against Purchase Receipt {0}").format(item.purchase_receipt)
 					)
 
-	def validate_for_repost(self):
-		self.validate_write_off_account()
-		self.validate_expense_account()
-		validate_docs_for_deferred_accounting([], [self.name])
-
 	def on_submit(self):
 		super(PurchaseInvoice, self).on_submit()
 
@@ -530,19 +522,6 @@ class PurchaseInvoice(BuyingController):
 
 		self.process_common_party_accounting()
 
-	def on_update_after_submit(self):
-		if hasattr(self, "repost_required"):
-			fields_to_check = [
-				"cash_bank_account",
-				"write_off_account",
-				"unrealized_profit_loss_account",
-			]
-			child_tables = {"items": ("expense_account",), "taxes": ("account_head",)}
-			self.needs_repost = self.check_if_fields_updated(fields_to_check, child_tables)
-			if self.needs_repost:
-				self.validate_for_repost()
-				self.db_set("repost_required", self.needs_repost)
-
 	def make_gl_entries(self, gl_entries=None, from_repost=False):
 		if not gl_entries:
 			gl_entries = self.get_gl_entries()
@@ -557,7 +536,6 @@ class PurchaseInvoice(BuyingController):
 					merge_entries=False,
 					from_repost=from_repost,
 				)
-				self.make_exchange_gain_loss_journal()
 			elif self.docstatus == 2:
 				provisional_entries = [a for a in gl_entries if a.voucher_type == "Purchase Receipt"]
 				make_reverse_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
@@ -602,6 +580,7 @@ class PurchaseInvoice(BuyingController):
 			self.get_asset_gl_entry(gl_entries)
 
 		self.make_tax_gl_entries(gl_entries)
+		self.make_exchange_gain_loss_gl_entries(gl_entries)
 		self.make_internal_transfer_gl_entries(gl_entries)
 
 		gl_entries = make_regional_gl_entries(gl_entries, self)
@@ -649,7 +628,9 @@ class PurchaseInvoice(BuyingController):
 						"credit_in_account_currency": base_grand_total
 						if self.party_account_currency == self.company_currency
 						else grand_total,
-						"against_voucher": self.name,
+						"against_voucher": self.return_against
+						if cint(self.is_return) and self.return_against
+						else self.name,
 						"against_voucher_type": self.doctype,
 						"project": self.project,
 						"cost_center": self.cost_center,
@@ -780,22 +761,21 @@ class PurchaseInvoice(BuyingController):
 
 					# Amount added through landed-cost-voucher
 					if landed_cost_entries:
-						if (item.item_code, item.name) in landed_cost_entries:
-							for account, amount in landed_cost_entries[(item.item_code, item.name)].items():
-								gl_entries.append(
-									self.get_gl_dict(
-										{
-											"account": account,
-											"against": item.expense_account,
-											"cost_center": item.cost_center,
-											"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
-											"credit": flt(amount["base_amount"]),
-											"credit_in_account_currency": flt(amount["amount"]),
-											"project": item.project or self.project,
-										},
-										item=item,
-									)
+						for account, amount in landed_cost_entries[(item.item_code, item.name)].items():
+							gl_entries.append(
+								self.get_gl_dict(
+									{
+										"account": account,
+										"against": item.expense_account,
+										"cost_center": item.cost_center,
+										"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+										"credit": flt(amount["base_amount"]),
+										"credit_in_account_currency": flt(amount["amount"]),
+										"project": item.project or self.project,
+									},
+									item=item,
 								)
+							)
 
 					# sub-contracting warehouse
 					if flt(item.rm_supp_cost):
@@ -989,10 +969,33 @@ class PurchaseInvoice(BuyingController):
 							item.item_tax_amount, item.precision("item_tax_amount")
 						)
 
+	def make_precision_loss_gl_entry(self, gl_entries):
+		round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(
+			self.company, "Purchase Invoice", self.name, self.use_company_roundoff_cost_center
+		)
+
+		precision_loss = self.get("base_net_total") - flt(
+			self.get("net_total") * self.conversion_rate, self.precision("net_total")
+		)
+
+		if precision_loss:
+			gl_entries.append(
+				self.get_gl_dict(
+					{
+						"account": round_off_account,
+						"against": self.supplier,
+						"credit": precision_loss,
+						"cost_center": round_off_cost_center
+						if self.use_company_roundoff_cost_center
+						else self.cost_center or round_off_cost_center,
+						"remarks": _("Net total calculation precision loss"),
+					}
+				)
+			)
+
 	def get_asset_gl_entry(self, gl_entries):
-		arbnb_account = None
-		eiiav_account = None
-		asset_eiiav_currency = None
+		arbnb_account = self.get_company_default("asset_received_but_not_billed")
+		eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
 
 		for item in self.get("items"):
 			if item.is_fixed_asset:
@@ -1004,8 +1007,6 @@ class PurchaseInvoice(BuyingController):
 					"Asset Received But Not Billed",
 					"Fixed Asset",
 				]:
-					if not arbnb_account:
-						arbnb_account = self.get_company_default("asset_received_but_not_billed")
 					item.expense_account = arbnb_account
 
 				if not self.update_stock:
@@ -1028,10 +1029,7 @@ class PurchaseInvoice(BuyingController):
 					)
 
 					if item.item_tax_amount:
-						if not eiiav_account or not asset_eiiav_currency:
-							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
-							asset_eiiav_currency = get_account_currency(eiiav_account)
-
+						asset_eiiav_currency = get_account_currency(eiiav_account)
 						gl_entries.append(
 							self.get_gl_dict(
 								{
@@ -1066,7 +1064,7 @@ class PurchaseInvoice(BuyingController):
 								"debit_in_account_currency": (
 									base_asset_amount if cwip_account_currency == self.company_currency else asset_amount
 								),
-								"cost_center": item.cost_center or self.cost_center,
+								"cost_center": self.cost_center,
 								"project": item.project or self.project,
 							},
 							item=item,
@@ -1074,10 +1072,7 @@ class PurchaseInvoice(BuyingController):
 					)
 
 					if item.item_tax_amount and not cint(erpnext.is_perpetual_inventory_enabled(self.company)):
-						if not eiiav_account or not asset_eiiav_currency:
-							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
-							asset_eiiav_currency = get_account_currency(eiiav_account)
-
+						asset_eiiav_currency = get_account_currency(eiiav_account)
 						gl_entries.append(
 							self.get_gl_dict(
 								{
@@ -1097,46 +1092,47 @@ class PurchaseInvoice(BuyingController):
 							)
 						)
 
+					# When update stock is checked
 					# Assets are bought through this document then it will be linked to this document
-					if flt(item.landed_cost_voucher_amount):
-						if not eiiav_account:
-							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
-
-						gl_entries.append(
-							self.get_gl_dict(
-								{
-									"account": eiiav_account,
-									"against": cwip_account,
-									"cost_center": item.cost_center,
-									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
-									"credit": flt(item.landed_cost_voucher_amount),
-									"project": item.project or self.project,
-								},
-								item=item,
+					if self.update_stock:
+						if flt(item.landed_cost_voucher_amount):
+							gl_entries.append(
+								self.get_gl_dict(
+									{
+										"account": eiiav_account,
+										"against": cwip_account,
+										"cost_center": item.cost_center,
+										"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+										"credit": flt(item.landed_cost_voucher_amount),
+										"project": item.project or self.project,
+									},
+									item=item,
+								)
 							)
-						)
 
-						gl_entries.append(
-							self.get_gl_dict(
-								{
-									"account": cwip_account,
-									"against": eiiav_account,
-									"cost_center": item.cost_center,
-									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
-									"debit": flt(item.landed_cost_voucher_amount),
-									"project": item.project or self.project,
-								},
-								item=item,
+							gl_entries.append(
+								self.get_gl_dict(
+									{
+										"account": cwip_account,
+										"against": eiiav_account,
+										"cost_center": item.cost_center,
+										"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+										"debit": flt(item.landed_cost_voucher_amount),
+										"project": item.project or self.project,
+									},
+									item=item,
+								)
 							)
-						)
 
-					# update gross amount of assets bought through this document
-					assets = frappe.db.get_all(
-						"Asset", filters={"purchase_invoice": self.name, "item_code": item.item_code}
-					)
-					for asset in assets:
-						frappe.db.set_value("Asset", asset.name, "gross_purchase_amount", flt(item.valuation_rate))
-						frappe.db.set_value("Asset", asset.name, "purchase_receipt_amount", flt(item.valuation_rate))
+						# update gross amount of assets bought through this document
+						assets = frappe.db.get_all(
+							"Asset", filters={"purchase_invoice": self.name, "item_code": item.item_code}
+						)
+						for asset in assets:
+							frappe.db.set_value("Asset", asset.name, "gross_purchase_amount", flt(item.valuation_rate))
+							frappe.db.set_value(
+								"Asset", asset.name, "purchase_receipt_amount", flt(item.valuation_rate)
+							)
 
 		return gl_entries
 
@@ -1443,8 +1439,6 @@ class PurchaseInvoice(BuyingController):
 			"Repost Item Valuation",
 			"Repost Payment Ledger",
 			"Repost Payment Ledger Items",
-			"Repost Accounting Ledger",
-			"Repost Accounting Ledger Items",
 			"Payment Ledger Entry",
 			"Tax Withheld Vouchers",
 			"Serial and Batch Bundle",
@@ -1672,8 +1666,12 @@ class PurchaseInvoice(BuyingController):
 				elif outstanding_amount > 0 and getdate(self.due_date) >= getdate():
 					self.status = "Unpaid"
 				# Check if outstanding amount is 0 due to debit note issued against invoice
-				elif self.is_return == 0 and frappe.db.get_value(
-					"Purchase Invoice", {"is_return": 1, "return_against": self.name, "docstatus": 1}
+				elif (
+					outstanding_amount <= 0
+					and self.is_return == 0
+					and frappe.db.get_value(
+						"Purchase Invoice", {"is_return": 1, "return_against": self.name, "docstatus": 1}
+					)
 				):
 					self.status = "Debit Note Issued"
 				elif self.is_return == 1:
@@ -1837,7 +1835,6 @@ def make_purchase_receipt(source_name, target_doc=None):
 					"po_detail": "purchase_order_item",
 					"material_request": "material_request",
 					"material_request_item": "material_request_item",
-					"wip_composite_asset": "wip_composite_asset",
 				},
 				"postprocess": update_item,
 				"condition": lambda doc: abs(doc.received_qty) < abs(doc.qty),

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -5,7 +5,7 @@
 import unittest
 
 import frappe
-from frappe.tests.utils import FrappeTestCase, change_settings
+from frappe.tests.utils import change_settings
 from frappe.utils import add_days, cint, flt, getdate, nowdate, today
 
 import erpnext
@@ -38,7 +38,7 @@ test_dependencies = ["Item", "Cost Center", "Payment Term", "Payment Terms Templ
 test_ignore = ["Serial No"]
 
 
-class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
+class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 	@classmethod
 	def setUpClass(self):
 		unlink_payment_on_cancel_of_invoice()
@@ -48,9 +48,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 	def tearDownClass(self):
 		unlink_payment_on_cancel_of_invoice(0)
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def test_purchase_invoice_received_qty(self):
 		"""
 		1. Test if received qty is validated against accepted + rejected
@@ -425,7 +422,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 			self.assertEqual(tax.tax_amount, expected_values[i][1])
 			self.assertEqual(tax.total, expected_values[i][2])
 
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_purchase_invoice_with_advance(self):
 		from erpnext.accounts.doctype.journal_entry.test_journal_entry import (
 			test_records as jv_test_records,
@@ -480,7 +476,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 			)
 		)
 
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_invoice_with_advance_and_multi_payment_terms(self):
 		from erpnext.accounts.doctype.journal_entry.test_journal_entry import (
 			test_records as jv_test_records,
@@ -1169,7 +1164,7 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 
 		item = create_item("_Test Item for Deferred Accounting", is_purchase_item=True)
 		item.enable_deferred_expense = 1
-		item.item_defaults[0].deferred_expense_account = deferred_account
+		item.deferred_expense_account = deferred_account
 		item.save()
 
 		pi = make_purchase_invoice(item=item.name, qty=1, rate=100, do_not_save=True)
@@ -1225,7 +1220,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		acc_settings.submit_journal_entriessubmit_journal_entries = 0
 		acc_settings.save()
 
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_gain_loss_with_advance_entry(self):
 		unlink_enabled = frappe.db.get_value(
 			"Accounts Settings", "Accounts Settings", "unlink_payment_on_cancel_of_invoice"
@@ -1279,11 +1273,10 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		pi.save()
 		pi.submit()
 
-		creditors_account = pi.credit_to
-
 		expected_gle = [
 			["_Test Account Cost for Goods Sold - _TC", 37500.0],
-			["_Test Payable USD - _TC", -37500.0],
+			["_Test Payable USD - _TC", -35000.0],
+			["Exchange Gain/Loss - _TC", -2500.0],
 		]
 
 		gl_entries = frappe.db.sql(
@@ -1300,31 +1293,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 			self.assertEqual(expected_gle[i][0], gle.account)
 			self.assertEqual(expected_gle[i][1], gle.balance)
 
-		pi.reload()
-		self.assertEqual(pi.outstanding_amount, 0)
-
-		total_debit_amount = frappe.db.get_all(
-			"Journal Entry Account",
-			{"account": creditors_account, "docstatus": 1, "reference_name": pi.name},
-			"sum(debit) as amount",
-			group_by="reference_name",
-		)[0].amount
-		self.assertEqual(flt(total_debit_amount, 2), 2500)
-		jea_parent = frappe.db.get_all(
-			"Journal Entry Account",
-			filters={
-				"account": creditors_account,
-				"docstatus": 1,
-				"reference_name": pi.name,
-				"debit": 2500,
-				"debit_in_account_currency": 0,
-			},
-			fields=["parent"],
-		)[0]
-		self.assertEqual(
-			frappe.db.get_value("Journal Entry", jea_parent.parent, "voucher_type"), "Exchange Gain Or Loss"
-		)
-
 		pi_2 = make_purchase_invoice(
 			supplier="_Test Supplier USD",
 			currency="USD",
@@ -1349,12 +1317,10 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		pi_2.save()
 		pi_2.submit()
 
-		pi_2.reload()
-		self.assertEqual(pi_2.outstanding_amount, 0)
-
 		expected_gle = [
 			["_Test Account Cost for Goods Sold - _TC", 36500.0],
-			["_Test Payable USD - _TC", -36500.0],
+			["_Test Payable USD - _TC", -35000.0],
+			["Exchange Gain/Loss - _TC", -1500.0],
 		]
 
 		gl_entries = frappe.db.sql(
@@ -1385,39 +1351,12 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 			self.assertEqual(expected_gle[i][0], gle.account)
 			self.assertEqual(expected_gle[i][1], gle.balance)
 
-		total_debit_amount = frappe.db.get_all(
-			"Journal Entry Account",
-			{"account": creditors_account, "docstatus": 1, "reference_name": pi_2.name},
-			"sum(debit) as amount",
-			group_by="reference_name",
-		)[0].amount
-		self.assertEqual(flt(total_debit_amount, 2), 1500)
-		jea_parent_2 = frappe.db.get_all(
-			"Journal Entry Account",
-			filters={
-				"account": creditors_account,
-				"docstatus": 1,
-				"reference_name": pi_2.name,
-				"debit": 1500,
-				"debit_in_account_currency": 0,
-			},
-			fields=["parent"],
-		)[0]
-		self.assertEqual(
-			frappe.db.get_value("Journal Entry", jea_parent_2.parent, "voucher_type"),
-			"Exchange Gain Or Loss",
-		)
-
 		pi.reload()
 		pi.cancel()
 
-		self.assertEqual(frappe.db.get_value("Journal Entry", jea_parent.parent, "docstatus"), 2)
-
 		pi_2.reload()
 		pi_2.cancel()
 
-		self.assertEqual(frappe.db.get_value("Journal Entry", jea_parent_2.parent, "docstatus"), 2)
-
 		pay.reload()
 		pay.cancel()
 
@@ -1426,7 +1365,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		)
 		frappe.db.set_value("Company", "_Test Company", "exchange_gain_loss_account", original_account)
 
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_purchase_invoice_advance_taxes(self):
 		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 
@@ -1751,6 +1689,7 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 
 		pi = make_purchase_invoice(
 			company="_Test Company",
+			customer="_Test Supplier",
 			do_not_save=True,
 			do_not_submit=True,
 			rate=1000,
@@ -1783,14 +1722,9 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		set_advance_flag(company="_Test Company", flag=0, default_account="")
 
 	def test_gl_entries_for_standalone_debit_note(self):
-		from erpnext.stock.doctype.item.test_item import make_item
+		make_purchase_invoice(qty=5, rate=500, update_stock=True)
 
-		item_code = make_item(properties={"is_stock_item": 1})
-		make_purchase_invoice(item_code=item_code, qty=5, rate=500, update_stock=True)
-
-		returned_inv = make_purchase_invoice(
-			item_code=item_code, qty=-5, rate=5, update_stock=True, is_return=True
-		)
+		returned_inv = make_purchase_invoice(qty=-5, rate=5, update_stock=True, is_return=True)
 
 		# override the rate with valuation rate
 		sle = frappe.get_all(
@@ -1800,53 +1734,7 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		)[0]
 
 		rate = flt(sle.stock_value_difference) / flt(sle.actual_qty)
-		self.assertAlmostEqual(rate, 500)
-
-	def test_payment_allocation_for_payment_terms(self):
-		from erpnext.buying.doctype.purchase_order.test_purchase_order import (
-			create_pr_against_po,
-			create_purchase_order,
-		)
-		from erpnext.selling.doctype.sales_order.test_sales_order import (
-			automatically_fetch_payment_terms,
-		)
-		from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
-			make_purchase_invoice as make_pi_from_pr,
-		)
-
-		automatically_fetch_payment_terms()
-		frappe.db.set_value(
-			"Payment Terms Template",
-			"_Test Payment Term Template",
-			"allocate_payment_based_on_payment_terms",
-			0,
-		)
-
-		po = create_purchase_order(do_not_save=1)
-		po.payment_terms_template = "_Test Payment Term Template"
-		po.save()
-		po.submit()
-
-		pr = create_pr_against_po(po.name, received_qty=4)
-		pi = make_pi_from_pr(pr.name)
-		self.assertEqual(pi.payment_schedule[0].payment_amount, 1000)
-
-		frappe.db.set_value(
-			"Payment Terms Template",
-			"_Test Payment Term Template",
-			"allocate_payment_based_on_payment_terms",
-			1,
-		)
-		pi = make_pi_from_pr(pr.name)
-		self.assertEqual(pi.payment_schedule[0].payment_amount, 2500)
-
-		automatically_fetch_payment_terms(enable=0)
-		frappe.db.set_value(
-			"Payment Terms Template",
-			"_Test Payment Term Template",
-			"allocate_payment_based_on_payment_terms",
-			0,
-		)
+		self.assertAlmostEqual(returned_inv.items[0].rate, rate)
 
 	def test_offsetting_entries_for_accounting_dimensions(self):
 		from erpnext.accounts.doctype.account.test_account import create_account
@@ -1873,6 +1761,7 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 
 		pi = make_purchase_invoice(
 			company="_Test Company",
+			customer="_Test Supplier",
 			do_not_save=True,
 			do_not_submit=True,
 			rate=1000,
@@ -1902,88 +1791,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		clear_dimension_defaults("Branch")
 		disable_dimension()
 
-	def test_repost_accounting_entries(self):
-		# update repost settings
-		settings = frappe.get_doc("Repost Accounting Ledger Settings")
-		if not [x for x in settings.allowed_types if x.document_type == "Purchase Invoice"]:
-			settings.append("allowed_types", {"document_type": "Purchase Invoice", "allowed": True})
-		settings.save()
-
-		pi = make_purchase_invoice(
-			rate=1000,
-			price_list_rate=1000,
-			qty=1,
-		)
-		expected_gle = [
-			["_Test Account Cost for Goods Sold - _TC", 1000, 0.0, nowdate()],
-			["Creditors - _TC", 0.0, 1000, nowdate()],
-		]
-		check_gl_entries(self, pi.name, expected_gle, nowdate())
-
-		pi.items[0].expense_account = "Service - _TC"
-		pi.save()
-		pi.load_from_db()
-		self.assertTrue(pi.repost_required)
-		pi.repost_accounting_entries()
-
-		expected_gle = [
-			["Creditors - _TC", 0.0, 1000, nowdate()],
-			["Service - _TC", 1000, 0.0, nowdate()],
-		]
-		check_gl_entries(self, pi.name, expected_gle, nowdate())
-		pi.load_from_db()
-		self.assertFalse(pi.repost_required)
-
-	@change_settings("Buying Settings", {"supplier_group": None})
-	def test_purchase_invoice_without_supplier_group(self):
-		# Create a Supplier
-		test_supplier_name = "_Test Supplier Without Supplier Group"
-		if not frappe.db.exists("Supplier", test_supplier_name):
-			supplier = frappe.get_doc(
-				{
-					"doctype": "Supplier",
-					"supplier_name": test_supplier_name,
-				}
-			).insert(ignore_permissions=True)
-
-			self.assertEqual(supplier.supplier_group, None)
-
-		po = create_purchase_order(
-			supplier=test_supplier_name,
-			rate=3000,
-			item="_Test Non Stock Item",
-			posting_date="2021-09-15",
-		)
-
-		pi = make_purchase_invoice(supplier=test_supplier_name)
-
-		self.assertEqual(po.docstatus, 1)
-		self.assertEqual(pi.docstatus, 1)
-
-	def test_default_cost_center_for_purchase(self):
-		from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
-
-		for c_center in ["_Test Cost Center Selling", "_Test Cost Center Buying"]:
-			create_cost_center(cost_center_name=c_center)
-
-		item = create_item(
-			"_Test Cost Center Item For Purchase",
-			is_stock_item=1,
-			buying_cost_center="_Test Cost Center Buying - _TC",
-			selling_cost_center="_Test Cost Center Selling - _TC",
-		)
-
-		pi = make_purchase_invoice(
-			item=item.name, qty=1, rate=1000, update_stock=True, do_not_submit=True, cost_center=""
-		)
-
-		pi.items[0].cost_center = ""
-		pi.set_missing_values()
-		pi.calculate_taxes_and_totals()
-		pi.save()
-
-		self.assertEqual(pi.items[0].cost_center, "_Test Cost Center Buying - _TC")
-
 
 def set_advance_flag(company, flag, default_account):
 	frappe.db.set_value(

erpnext/accounts/doctype/purchase_invoice_item/purchase_invoice_item.json

@@ -77,7 +77,6 @@
   "manufacturer_part_no",
   "accounting",
   "expense_account",
-  "wip_composite_asset",
   "col_break5",
   "is_fixed_asset",
   "asset_location",
@@ -474,7 +473,6 @@
    "label": "Accounting"
   },
   {
-   "allow_on_submit": 1,
    "fieldname": "expense_account",
    "fieldtype": "Link",
    "label": "Expense Head",
@@ -904,18 +902,12 @@
    "no_copy": 1,
    "options": "Serial and Batch Bundle",
    "print_hide": 1
-  },
-  {
-   "fieldname": "wip_composite_asset",
-   "fieldtype": "Link",
-   "label": "WIP Composite Asset",
-   "options": "Asset"
   }
  ],
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-10-03 21:01:01.824892",
+ "modified": "2023-07-26 12:54:53.178156",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice Item",

erpnext/accounts/doctype/purchase_taxes_and_charges/purchase_taxes_and_charges.json

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

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.html

@@ -1,44 +0,0 @@
-<style>
-	.print-format {
-		padding: 4mm;
-		font-size: 8.0pt !important;
-	}
-	.print-format td {
-		vertical-align:middle !important;
-	}
-	.old {
-	    background-color: #FFB3C0;
-	}
-	.new {
-	    background-color: #B3FFCC;
-	}
-</style>
-
-
-<table class="table table-bordered table-condensed">
-  <colgroup>
-  {% for col in gl_columns%}
-  <col style="width: 18mm;">
-  {% endfor %}
-  </colgroup>
-  <thead>
-    <tr>
-    {% for col in gl_columns%}
-    <td>{{ col.label }}</td>
-    {% endfor %}
-    </tr>
-  </thead>
-{% for gl in gl_data%}
-{% if gl["old"]%}
-<tr class="old">
-{% else %}
-<tr class="new">
-{% endif %}
-  {% for col in gl_columns %}
-  <td class="text-right">
-    {{ gl[col.fieldname] }}
-  </td>
-  {% endfor %}
-</tr>
-{% endfor %}
-</table>

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.js

@@ -1,48 +0,0 @@
-// Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
-// For license information, please see license.txt
-
-frappe.ui.form.on("Repost Accounting Ledger", {
-	setup: function(frm) {
-		frm.fields_dict['vouchers'].grid.get_field('voucher_type').get_query = function(doc) {
-			return {
-				query: "erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger.get_repost_allowed_types"
-			}
-		}
-
-		frm.fields_dict['vouchers'].grid.get_field('voucher_no').get_query = function(doc) {
-			if (doc.company) {
-				return {
-					filters: {
-						company: doc.company,
-						docstatus: 1
-					}
-				}
-			}
-		}
-	},
-
-	refresh: function(frm) {
-		frm.add_custom_button(__('Show Preview'), () => {
-			frm.call({
-				method: 'generate_preview',
-				doc: frm.doc,
-				freeze: true,
-				freeze_message: __('Generating Preview'),
-				callback: function(r) {
-					if (r && r.message) {
-						let content = r.message;
-						let opts = {
-							title: "Preview",
-							subtitle: "preview",
-							content: content,
-							print_settings: {orientation: "landscape"},
-							columns: [],
-							data: [],
-						}
-						frappe.render_grid(opts);
-					}
-				}
-			});
-		});
-	}
-});

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.json

@@ -1,82 +0,0 @@
-{
- "actions": [],
- "allow_rename": 1,
- "autoname": "format:ACC-REPOST-{#####}",
- "creation": "2023-07-04 13:07:32.923675",
- "default_view": "List",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "company",
-  "column_break_vpup",
-  "delete_cancelled_entries",
-  "section_break_metl",
-  "vouchers",
-  "amended_from"
- ],
- "fields": [
-  {
-   "fieldname": "company",
-   "fieldtype": "Link",
-   "label": "Company",
-   "options": "Company"
-  },
-  {
-   "fieldname": "amended_from",
-   "fieldtype": "Link",
-   "label": "Amended From",
-   "no_copy": 1,
-   "options": "Repost Accounting Ledger",
-   "print_hide": 1,
-   "read_only": 1
-  },
-  {
-   "fieldname": "vouchers",
-   "fieldtype": "Table",
-   "label": "Vouchers",
-   "options": "Repost Accounting Ledger Items"
-  },
-  {
-   "fieldname": "column_break_vpup",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "section_break_metl",
-   "fieldtype": "Section Break"
-  },
-  {
-   "default": "0",
-   "fieldname": "delete_cancelled_entries",
-   "fieldtype": "Check",
-   "label": "Delete Cancelled Ledger Entries"
-  }
- ],
- "index_web_pages_for_search": 1,
- "is_submittable": 1,
- "links": [],
- "modified": "2023-09-26 14:21:27.362567",
- "modified_by": "Administrator",
- "module": "Accounts",
- "name": "Repost Accounting Ledger",
- "naming_rule": "Expression",
- "owner": "Administrator",
- "permissions": [
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "System Manager",
-   "share": 1,
-   "write": 1
-  }
- ],
- "sort_field": "modified",
- "sort_order": "DESC",
- "states": [],
- "track_changes": 1
-}

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.py

@@ -1,206 +0,0 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
-# For license information, please see license.txt
-
-import frappe
-from frappe import _, qb
-from frappe.model.document import Document
-from frappe.utils.data import comma_and
-
-
-class RepostAccountingLedger(Document):
-	def __init__(self, *args, **kwargs):
-		super(RepostAccountingLedger, self).__init__(*args, **kwargs)
-		self._allowed_types = [
-			x.document_type
-			for x in frappe.db.get_all(
-				"Repost Allowed Types", filters={"allowed": True}, fields=["distinct(document_type)"]
-			)
-		]
-
-	def validate(self):
-		self.validate_vouchers()
-		self.validate_for_closed_fiscal_year()
-		self.validate_for_deferred_accounting()
-
-	def validate_for_deferred_accounting(self):
-		sales_docs = [x.voucher_no for x in self.vouchers if x.voucher_type == "Sales Invoice"]
-		purchase_docs = [x.voucher_no for x in self.vouchers if x.voucher_type == "Purchase Invoice"]
-		validate_docs_for_deferred_accounting(sales_docs, purchase_docs)
-
-	def validate_for_closed_fiscal_year(self):
-		if self.vouchers:
-			latest_pcv = (
-				frappe.db.get_all(
-					"Period Closing Voucher",
-					filters={"company": self.company},
-					order_by="posting_date desc",
-					pluck="posting_date",
-					limit=1,
-				)
-				or None
-			)
-			if not latest_pcv:
-				return
-
-			for vtype in self._allowed_types:
-				if names := [x.voucher_no for x in self.vouchers if x.voucher_type == vtype]:
-					latest_voucher = frappe.db.get_all(
-						vtype,
-						filters={"name": ["in", names]},
-						pluck="posting_date",
-						order_by="posting_date desc",
-						limit=1,
-					)[0]
-					if latest_voucher and latest_pcv[0] >= latest_voucher:
-						frappe.throw(_("Cannot Resubmit Ledger entries for vouchers in Closed fiscal year."))
-
-	def validate_vouchers(self):
-		if self.vouchers:
-			# Validate voucher types
-			voucher_types = set([x.voucher_type for x in self.vouchers])
-			if disallowed_types := voucher_types.difference(self._allowed_types):
-				frappe.throw(
-					_("{0} types are not allowed. Only {1} are.").format(
-						frappe.bold(comma_and(list(disallowed_types))),
-						frappe.bold(comma_and(list(self._allowed_types))),
-					)
-				)
-
-	def get_existing_ledger_entries(self):
-		vouchers = [x.voucher_no for x in self.vouchers]
-		gl = qb.DocType("GL Entry")
-		existing_gles = (
-			qb.from_(gl)
-			.select(gl.star)
-			.where((gl.voucher_no.isin(vouchers)) & (gl.is_cancelled == 0))
-			.run(as_dict=True)
-		)
-		self.gles = frappe._dict({})
-
-		for gle in existing_gles:
-			self.gles.setdefault((gle.voucher_type, gle.voucher_no), frappe._dict({})).setdefault(
-				"existing", []
-			).append(gle.update({"old": True}))
-
-	def generate_preview_data(self):
-		self.gl_entries = []
-		self.get_existing_ledger_entries()
-		for x in self.vouchers:
-			doc = frappe.get_doc(x.voucher_type, x.voucher_no)
-			if doc.doctype in ["Payment Entry", "Journal Entry"]:
-				gle_map = doc.build_gl_map()
-			else:
-				gle_map = doc.get_gl_entries()
-
-			old_entries = self.gles.get((x.voucher_type, x.voucher_no))
-			if old_entries:
-				self.gl_entries.extend(old_entries.existing)
-			self.gl_entries.extend(gle_map)
-
-	@frappe.whitelist()
-	def generate_preview(self):
-		from erpnext.accounts.report.general_ledger.general_ledger import get_columns as get_gl_columns
-
-		gl_columns = []
-		gl_data = []
-
-		self.generate_preview_data()
-		if self.gl_entries:
-			filters = {"company": self.company, "include_dimensions": 1}
-			for x in get_gl_columns(filters):
-				if x["fieldname"] == "gl_entry":
-					x["fieldname"] = "name"
-				gl_columns.append(x)
-
-			gl_data = self.gl_entries
-		rendered_page = frappe.render_template(
-			"erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.html",
-			{"gl_columns": gl_columns, "gl_data": gl_data},
-		)
-
-		return rendered_page
-
-	def on_submit(self):
-		if len(self.vouchers) > 1:
-			job_name = "repost_accounting_ledger_" + self.name
-			frappe.enqueue(
-				method="erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger.start_repost",
-				account_repost_doc=self.name,
-				is_async=True,
-				job_name=job_name,
-			)
-			frappe.msgprint(_("Repost has started in the background"))
-		else:
-			start_repost(self.name)
-
-
-@frappe.whitelist()
-def start_repost(account_repost_doc=str) -> None:
-	if account_repost_doc:
-		repost_doc = frappe.get_doc("Repost Accounting Ledger", account_repost_doc)
-
-		if repost_doc.docstatus == 1:
-			# Prevent repost on invoices with deferred accounting
-			repost_doc.validate_for_deferred_accounting()
-
-			for x in repost_doc.vouchers:
-				doc = frappe.get_doc(x.voucher_type, x.voucher_no)
-
-				if repost_doc.delete_cancelled_entries:
-					frappe.db.delete("GL Entry", filters={"voucher_type": doc.doctype, "voucher_no": doc.name})
-					frappe.db.delete(
-						"Payment Ledger Entry", filters={"voucher_type": doc.doctype, "voucher_no": doc.name}
-					)
-
-				if doc.doctype in ["Sales Invoice", "Purchase Invoice"]:
-					if not repost_doc.delete_cancelled_entries:
-						doc.docstatus = 2
-						doc.make_gl_entries_on_cancel()
-
-					doc.docstatus = 1
-					doc.make_gl_entries()
-
-				elif doc.doctype in ["Payment Entry", "Journal Entry", "Expense Claim"]:
-					if not repost_doc.delete_cancelled_entries:
-						doc.make_gl_entries(1)
-					doc.make_gl_entries()
-
-				frappe.db.commit()
-
-
-def validate_docs_for_deferred_accounting(sales_docs, purchase_docs):
-	docs_with_deferred_revenue = frappe.db.get_all(
-		"Sales Invoice Item",
-		filters={"parent": ["in", sales_docs], "docstatus": 1, "enable_deferred_revenue": True},
-		fields=["parent"],
-		as_list=1,
-	)
-
-	docs_with_deferred_expense = frappe.db.get_all(
-		"Purchase Invoice Item",
-		filters={"parent": ["in", purchase_docs], "docstatus": 1, "enable_deferred_expense": 1},
-		fields=["parent"],
-		as_list=1,
-	)
-
-	if docs_with_deferred_revenue or docs_with_deferred_expense:
-		frappe.throw(
-			_("Documents: {0} have deferred revenue/expense enabled for them. Cannot repost.").format(
-				frappe.bold(comma_and([x[0] for x in docs_with_deferred_expense + docs_with_deferred_revenue]))
-			)
-		)
-
-
-@frappe.whitelist()
-@frappe.validate_and_sanitize_search_inputs
-def get_repost_allowed_types(doctype, txt, searchfield, start, page_len, filters):
-	filters = {"allowed": True}
-
-	if txt:
-		filters.update({"document_type": ("like", f"%{txt}%")})
-
-	if allowed_types := frappe.db.get_all(
-		"Repost Allowed Types", filters=filters, fields=["distinct(document_type)"], as_list=1
-	):
-		return allowed_types
-	return []

erpnext/accounts/doctype/repost_accounting_ledger/test_repost_accounting_ledger.py

@@ -1,210 +0,0 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
-# See license.txt
-
-import frappe
-from frappe import qb
-from frappe.query_builder.functions import Sum
-from frappe.tests.utils import FrappeTestCase, change_settings
-from frappe.utils import add_days, nowdate, today
-
-from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
-from erpnext.accounts.doctype.payment_request.payment_request import make_payment_request
-from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger import start_repost
-from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
-from erpnext.accounts.utils import get_fiscal_year
-
-
-class TestRepostAccountingLedger(AccountsTestMixin, FrappeTestCase):
-	def setUp(self):
-		self.create_company()
-		self.create_customer()
-		self.create_item()
-		self.update_repost_settings()
-
-	def teadDown(self):
-		frappe.db.rollback()
-
-	def update_repost_settings(self):
-		allowed_types = ["Sales Invoice", "Purchase Invoice", "Payment Entry", "Journal Entry"]
-		repost_settings = frappe.get_doc("Repost Accounting Ledger Settings")
-		for x in allowed_types:
-			repost_settings.append("allowed_types", {"document_type": x, "allowed": True})
-			repost_settings.save()
-
-	def test_01_basic_functions(self):
-		si = create_sales_invoice(
-			item=self.item,
-			company=self.company,
-			customer=self.customer,
-			debit_to=self.debit_to,
-			parent_cost_center=self.cost_center,
-			cost_center=self.cost_center,
-			rate=100,
-		)
-
-		preq = frappe.get_doc(
-			make_payment_request(
-				dt=si.doctype,
-				dn=si.name,
-				payment_request_type="Inward",
-				party_type="Customer",
-				party=si.customer,
-			)
-		)
-		preq.save().submit()
-
-		# Test Validation Error
-		ral = frappe.new_doc("Repost Accounting Ledger")
-		ral.company = self.company
-		ral.delete_cancelled_entries = True
-		ral.append("vouchers", {"voucher_type": si.doctype, "voucher_no": si.name})
-		ral.append(
-			"vouchers", {"voucher_type": preq.doctype, "voucher_no": preq.name}
-		)  # this should throw validation error
-		self.assertRaises(frappe.ValidationError, ral.save)
-		ral.vouchers.pop()
-		preq.cancel()
-		preq.delete()
-
-		pe = get_payment_entry(si.doctype, si.name)
-		pe.save().submit()
-		ral.append("vouchers", {"voucher_type": pe.doctype, "voucher_no": pe.name})
-		ral.save()
-
-		# manually set an incorrect debit amount in DB
-		gle = frappe.db.get_all("GL Entry", filters={"voucher_no": si.name, "account": self.debit_to})
-		frappe.db.set_value("GL Entry", gle[0], "debit", 90)
-
-		gl = qb.DocType("GL Entry")
-		res = (
-			qb.from_(gl)
-			.select(gl.voucher_no, Sum(gl.debit).as_("debit"), Sum(gl.credit).as_("credit"))
-			.where((gl.voucher_no == si.name) & (gl.is_cancelled == 0))
-			.run()
-		)
-
-		# Assert incorrect ledger balance
-		self.assertNotEqual(res[0], (si.name, 100, 100))
-
-		# Submit repost document
-		ral.save().submit()
-
-		# background jobs don't run on test cases. Manually triggering repost function.
-		start_repost(ral.name)
-
-		res = (
-			qb.from_(gl)
-			.select(gl.voucher_no, Sum(gl.debit).as_("debit"), Sum(gl.credit).as_("credit"))
-			.where((gl.voucher_no == si.name) & (gl.is_cancelled == 0))
-			.run()
-		)
-
-		# Ledger should reflect correct amount post repost
-		self.assertEqual(res[0], (si.name, 100, 100))
-
-	def test_02_deferred_accounting_valiations(self):
-		si = create_sales_invoice(
-			item=self.item,
-			company=self.company,
-			customer=self.customer,
-			debit_to=self.debit_to,
-			parent_cost_center=self.cost_center,
-			cost_center=self.cost_center,
-			rate=100,
-			do_not_submit=True,
-		)
-		si.items[0].enable_deferred_revenue = True
-		si.items[0].deferred_revenue_account = self.deferred_revenue
-		si.items[0].service_start_date = nowdate()
-		si.items[0].service_end_date = add_days(nowdate(), 90)
-		si.save().submit()
-
-		ral = frappe.new_doc("Repost Accounting Ledger")
-		ral.company = self.company
-		ral.append("vouchers", {"voucher_type": si.doctype, "voucher_no": si.name})
-		self.assertRaises(frappe.ValidationError, ral.save)
-
-	@change_settings("Accounts Settings", {"delete_linked_ledger_entries": 1})
-	def test_04_pcv_validation(self):
-		# Clear old GL entries so PCV can be submitted.
-		gl = frappe.qb.DocType("GL Entry")
-		qb.from_(gl).delete().where(gl.company == self.company).run()
-
-		si = create_sales_invoice(
-			item=self.item,
-			company=self.company,
-			customer=self.customer,
-			debit_to=self.debit_to,
-			parent_cost_center=self.cost_center,
-			cost_center=self.cost_center,
-			rate=100,
-		)
-		pcv = frappe.get_doc(
-			{
-				"doctype": "Period Closing Voucher",
-				"transaction_date": today(),
-				"posting_date": today(),
-				"company": self.company,
-				"fiscal_year": get_fiscal_year(today(), company=self.company)[0],
-				"cost_center": self.cost_center,
-				"closing_account_head": self.retained_earnings,
-				"remarks": "test",
-			}
-		)
-		pcv.save().submit()
-
-		ral = frappe.new_doc("Repost Accounting Ledger")
-		ral.company = self.company
-		ral.append("vouchers", {"voucher_type": si.doctype, "voucher_no": si.name})
-		self.assertRaises(frappe.ValidationError, ral.save)
-
-		pcv.reload()
-		pcv.cancel()
-		pcv.delete()
-
-	def test_03_deletion_flag_and_preview_function(self):
-		si = create_sales_invoice(
-			item=self.item,
-			company=self.company,
-			customer=self.customer,
-			debit_to=self.debit_to,
-			parent_cost_center=self.cost_center,
-			cost_center=self.cost_center,
-			rate=100,
-		)
-
-		pe = get_payment_entry(si.doctype, si.name)
-		pe.save().submit()
-
-		# without deletion flag set
-		ral = frappe.new_doc("Repost Accounting Ledger")
-		ral.company = self.company
-		ral.delete_cancelled_entries = False
-		ral.append("vouchers", {"voucher_type": si.doctype, "voucher_no": si.name})
-		ral.append("vouchers", {"voucher_type": pe.doctype, "voucher_no": pe.name})
-		ral.save()
-
-		# assert preview data is generated
-		preview = ral.generate_preview()
-		self.assertIsNotNone(preview)
-
-		ral.save().submit()
-
-		# background jobs don't run on test cases. Manually triggering repost function.
-		start_repost(ral.name)
-
-		self.assertIsNotNone(frappe.db.exists("GL Entry", {"voucher_no": si.name, "is_cancelled": 1}))
-		self.assertIsNotNone(frappe.db.exists("GL Entry", {"voucher_no": pe.name, "is_cancelled": 1}))
-
-		# with deletion flag set
-		ral = frappe.new_doc("Repost Accounting Ledger")
-		ral.company = self.company
-		ral.delete_cancelled_entries = True
-		ral.append("vouchers", {"voucher_type": si.doctype, "voucher_no": si.name})
-		ral.append("vouchers", {"voucher_type": pe.doctype, "voucher_no": pe.name})
-		ral.save().submit()
-
-		start_repost(ral.name)
-		self.assertIsNone(frappe.db.exists("GL Entry", {"voucher_no": si.name, "is_cancelled": 1}))
-		self.assertIsNone(frappe.db.exists("GL Entry", {"voucher_no": pe.name, "is_cancelled": 1}))

erpnext/accounts/doctype/repost_accounting_ledger_items/repost_accounting_ledger_items.json

@@ -1,40 +0,0 @@
-{
- "actions": [],
- "allow_rename": 1,
- "creation": "2023-07-04 14:14:01.243848",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "voucher_type",
-  "voucher_no"
- ],
- "fields": [
-  {
-   "fieldname": "voucher_type",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Voucher Type",
-   "options": "DocType"
-  },
-  {
-   "fieldname": "voucher_no",
-   "fieldtype": "Dynamic Link",
-   "in_list_view": 1,
-   "label": "Voucher No",
-   "options": "voucher_type"
-  }
- ],
- "index_web_pages_for_search": 1,
- "istable": 1,
- "links": [],
- "modified": "2023-07-04 14:15:51.165584",
- "modified_by": "Administrator",
- "module": "Accounts",
- "name": "Repost Accounting Ledger Items",
- "owner": "Administrator",
- "permissions": [],
- "sort_field": "modified",
- "sort_order": "DESC",
- "states": []
-}

erpnext/accounts/doctype/repost_accounting_ledger_items/repost_accounting_ledger_items.py

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