ci: use mariadb 10.6

https://github.com/frappe/frappe/pull/19116/files

.github/helper/.flake8_strict

@@ -66,8 +66,7 @@ ignore =
     F841,
     E713,
     E712,
-    B023,
-    B028
+    B023
 
 
 max-line-length = 200

.github/helper/documentation.py

@@ -3,71 +3,52 @@ import requests
 from urllib.parse import urlparse
 
 
-WEBSITE_REPOS = [
+docs_repos = [
+	"frappe_docs",
+	"erpnext_documentation",
 	"erpnext_com",
 	"frappe_io",
 ]
 
-DOCUMENTATION_DOMAINS = [
-	"docs.erpnext.com",
-	"frappeframework.com",
-]
 
+def uri_validator(x):
+	result = urlparse(x)
+	return all([result.scheme, result.netloc, result.path])
 
-def is_valid_url(url: str) -> bool:
-	parts = urlparse(url)
-	return all((parts.scheme, parts.netloc, parts.path))
-
-
-def is_documentation_link(word: str) -> bool:
-	if not word.startswith("http") or not is_valid_url(word):
-		return False
-
-	parsed_url = urlparse(word)
-	if parsed_url.netloc in DOCUMENTATION_DOMAINS:
-		return True
-
-	if parsed_url.netloc == "github.com":
-		parts = parsed_url.path.split("/")
-		if len(parts) == 5 and parts[1] == "frappe" and parts[2] in WEBSITE_REPOS:
-			return True
-
-	return False
-
-
-def contains_documentation_link(body: str) -> bool:
-	return any(
-		is_documentation_link(word)
-		for line in body.splitlines()
-		for word in line.split()
-	)
-
-
-def check_pull_request(number: str) -> "tuple[int, str]":
-	response = requests.get(f"https://api.github.com/repos/frappe/erpnext/pulls/{number}")
-	if not response.ok:
-		return 1, "Pull Request Not Found! ⚠️"
-
-	payload = response.json()
-	title = (payload.get("title") or "").lower().strip()
-	head_sha = (payload.get("head") or {}).get("sha")
-	body = (payload.get("body") or "").lower()
-
-	if (
-		not title.startswith("feat")
-		or not head_sha
-		or "no-docs" in body
-		or "backport" in body
-	):
-		return 0, "Skipping documentation checks... 🏃"
-
-	if contains_documentation_link(body):
-		return 0, "Documentation Link Found. You're Awesome! 🎉"
-
-	return 1, "Documentation Link Not Found! ⚠️"
+def docs_link_exists(body):
+	for line in body.splitlines():
+		for word in line.split():
+			if word.startswith('http') and uri_validator(word):
+				parsed_url = urlparse(word)
+				if parsed_url.netloc == "github.com":
+					parts = parsed_url.path.split('/')
+					if len(parts) == 5 and parts[1] == "frappe" and parts[2] in docs_repos:
+						return True
+				elif parsed_url.netloc == "docs.erpnext.com":
+					return True
 
 
 if __name__ == "__main__":
-	exit_code, message = check_pull_request(sys.argv[1])
-	print(message)
-	sys.exit(exit_code)
+	pr = sys.argv[1]
+	response = requests.get("https://api.github.com/repos/frappe/erpnext/pulls/{}".format(pr))
+
+	if response.ok:
+		payload = response.json()
+		title = (payload.get("title") or "").lower().strip()
+		head_sha = (payload.get("head") or {}).get("sha")
+		body = (payload.get("body") or "").lower()
+
+		if (title.startswith("feat")
+			and head_sha
+			and "no-docs" not in body
+			and "backport" not in body
+		):
+			if docs_link_exists(body):
+				print("Documentation Link Found. You're Awesome! 🎉")
+
+			else:
+				print("Documentation Link Not Found! ⚠️")
+				sys.exit(1)
+
+		else:
+			print("Skipping documentation checks... 🏃")

.github/helper/install.sh

@@ -8,9 +8,8 @@ sudo apt update && sudo apt install redis-server libcups2-dev
 
 pip install frappe-bench
 
-githubbranch=${GITHUB_BASE_REF:-${GITHUB_REF##*/}}
 frappeuser=${FRAPPE_USER:-"frappe"}
-frappebranch=${FRAPPE_BRANCH:-$githubbranch}
+frappebranch=${FRAPPE_BRANCH:-${GITHUB_BASE_REF:-${GITHUB_REF##*/}}}
 
 git clone "https://github.com/${frappeuser}/frappe" --branch "${frappebranch}" --depth 1
 bench init --skip-assets --frappe-path ~/frappe --python "$(which python)" frappe-bench
@@ -42,17 +41,12 @@ fi
 
 
 install_whktml() {
-    if [ "$(lsb_release -rs)" = "22.04" ]; then
-        wget -O /tmp/wkhtmltox.deb https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
-        sudo apt install /tmp/wkhtmltox.deb
-    else
-        echo "Please update this script to support wkhtmltopdf for $(lsb_release -ds)"
-        exit 1
-    fi
+    wget -O /tmp/wkhtmltox.tar.xz https://github.com/frappe/wkhtmltopdf/raw/master/wkhtmltox-0.12.3_linux-generic-amd64.tar.xz
+    tar -xf /tmp/wkhtmltox.tar.xz -C /tmp
+    sudo mv /tmp/wkhtmltox/bin/wkhtmltopdf /usr/local/bin/wkhtmltopdf
+    sudo chmod o+x /usr/local/bin/wkhtmltopdf
 }
 install_whktml &
-wkpid=$!
-
 
 cd ~/frappe-bench || exit
 
@@ -61,13 +55,11 @@ sed -i 's/schedule:/# schedule:/g' Procfile
 sed -i 's/socketio:/# socketio:/g' Procfile
 sed -i 's/redis_socketio:/# redis_socketio:/g' Procfile
 
-bench get-app payments --branch ${githubbranch%"-hotfix"}
+bench get-app payments
 bench get-app erpnext "${GITHUB_WORKSPACE}"
 
 if [ "$TYPE" == "server" ]; then bench setup requirements --dev; fi
 
-wait $wkpid
-
 bench start &> bench_run_logs.txt &
 CI=Yes bench build --app frappe &
 bench --site test_site reinstall --yes

.github/helper/site_config_mariadb.json

@@ -11,6 +11,6 @@
  "root_login": "root",
  "root_password": "root",
  "host_name": "http://test_site:8000",
- "install_apps": ["payments", "erpnext"],
+ "install_apps": ["erpnext"],
  "throttle_user_limit": 100
 }

.github/workflows/release.yml

@@ -13,10 +13,10 @@ jobs:
         with:
           fetch-depth: 0
           persist-credentials: false
-      - name: Setup Node.js
+      - name: Setup Node.js v14
         uses: actions/setup-node@v2
         with:
-          node-version: 18
+          node-version: 14
       - name: Setup dependencies
         run: |
           npm install @semantic-release/git @semantic-release/exec --no-save
@@ -28,4 +28,4 @@ jobs:
           GIT_AUTHOR_EMAIL: "developers@frappe.io"
           GIT_COMMITTER_NAME: "Frappe PR Bot"
           GIT_COMMITTER_EMAIL: "developers@frappe.io"
-        run: npx semantic-release
+        run: npx semantic-release

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

@@ -7,6 +7,7 @@ on:
       - '**.css'
       - '**.md'
       - '**.html'
+      - '**.csv'
   push:
     branches: [ develop ]
     paths-ignore:
@@ -15,12 +16,12 @@ on:
   workflow_dispatch:
     inputs:
       user:
-        description: 'Frappe Framework repository user (add your username for forks)'
+        description: 'user'
         required: true
         default: 'frappe'
         type: string
       branch:
-        description: 'Frappe Framework branch'
+        description: 'Branch name'
         default: 'develop'
         required: false
         type: string

.pre-commit-config.yaml

@@ -32,8 +32,8 @@ repos:
       - id: black
         additional_dependencies: ['click==8.0.4']
 
-  - repo: https://github.com/PyCQA/isort
-    rev: 5.12.0
+  - repo: https://github.com/timothycrosley/isort
+    rev: 5.9.1
     hooks:
       - id: isort
         exclude: ".*setup.py$"

CODEOWNERS

@@ -3,23 +3,26 @@
 # These owners will be the default owners for everything in
 # the repo. Unless a later match takes precedence,
 
-erpnext/accounts/               @deepeshgarg007 @ruthra-kumar
-erpnext/assets/                 @anandbaburajan @deepeshgarg007
-erpnext/loan_management/        @deepeshgarg007
-erpnext/regional                @deepeshgarg007 @ruthra-kumar
-erpnext/selling                 @deepeshgarg007 @ruthra-kumar
-erpnext/support/                @deepeshgarg007
-pos*                            
+erpnext/accounts/               @nextchamp-saqib @deepeshgarg007 @ruthra-kumar
+erpnext/assets/                 @nextchamp-saqib @deepeshgarg007 @ruthra-kumar
+erpnext/loan_management/        @nextchamp-saqib @deepeshgarg007
+erpnext/regional                @nextchamp-saqib @deepeshgarg007 @ruthra-kumar
+erpnext/selling                 @nextchamp-saqib @deepeshgarg007 @ruthra-kumar
+erpnext/support/                @nextchamp-saqib @deepeshgarg007
+pos*                            @nextchamp-saqib
 
 erpnext/buying/                 @rohitwaghchaure @s-aga-r
 erpnext/maintenance/            @rohitwaghchaure @s-aga-r
 erpnext/manufacturing/          @rohitwaghchaure @s-aga-r
 erpnext/quality_management/     @rohitwaghchaure @s-aga-r
 erpnext/stock/                  @rohitwaghchaure @s-aga-r
-erpnext/subcontracting          @rohitwaghchaure @s-aga-r
 
-erpnext/controllers/            @deepeshgarg007 @rohitwaghchaure
-erpnext/patches/                @deepeshgarg007 
+erpnext/crm/                    @NagariaHussain
+erpnext/education/              @rutwikhdev
+erpnext/projects/               @ruchamahabal
 
-.github/                        @deepeshgarg007
+erpnext/controllers/            @deepeshgarg007 @nextchamp-saqib @rohitwaghchaure
+erpnext/patches/                @deepeshgarg007 @nextchamp-saqib
+
+.github/                        @ankush
 pyproject.toml                  @ankush

README.md

@@ -65,7 +65,7 @@ New passwords will be created for the ERPNext "Administrator" user, the MariaDB
 1. [Frappe School](https://frappe.school) - Learn Frappe Framework and ERPNext from the various courses by the maintainers or from the community.
 2. [Official documentation](https://docs.erpnext.com/) - Extensive documentation for ERPNext.
 3. [Discussion Forum](https://discuss.erpnext.com/) - Engage with community of ERPNext users and service providers.
-4. [Telegram Group](https://erpnext_public.t.me) - Get instant help from huge community of users.
+4. [Telegram Group](https://t.me/erpnexthelp) - Get instant help from huge community of users.
 
 
 ## Contributing

erpnext/accounts/deferred_revenue.py

@@ -378,7 +378,7 @@ def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 			return
 
 		# check if books nor frozen till endate:
-		if accounts_frozen_upto and getdate(end_date) <= getdate(accounts_frozen_upto):
+		if accounts_frozen_upto and (end_date) <= getdate(accounts_frozen_upto):
 			end_date = get_last_day(add_days(accounts_frozen_upto, 1))
 
 		if via_journal_entry:

erpnext/accounts/doctype/account/account.py

@@ -394,13 +394,7 @@ def update_account_number(name, account_name, account_number=None, from_descenda
 
 	if ancestors and not allow_independent_account_creation:
 		for ancestor in ancestors:
-			old_name = frappe.db.get_value(
-				"Account",
-				{"account_number": old_acc_number, "account_name": old_acc_name, "company": ancestor},
-				"name",
-			)
-
-			if old_name:
+			if frappe.db.get_value("Account", {"account_name": old_acc_name, "company": ancestor}, "name"):
 				# same account in parent company exists
 				allow_child_account_creation = _("Allow Account Creation Against Child Company")
 

erpnext/accounts/doctype/account/account_tree.js

@@ -56,41 +56,36 @@ frappe.treeview_settings["Account"] = {
 			accounts = nodes;
 		}
 
-		frappe.db.get_single_value("Accounts Settings", "show_balance_in_coa").then((value) => {
-			if(value) {
+		const get_balances = frappe.call({
+			method: 'erpnext.accounts.utils.get_account_balances',
+			args: {
+				accounts: accounts,
+				company: cur_tree.args.company
+			},
+		});
 
-				const get_balances = frappe.call({
-					method: 'erpnext.accounts.utils.get_account_balances',
-					args: {
-						accounts: accounts,
-						company: cur_tree.args.company
-					},
-				});
+		get_balances.then(r => {
+			if (!r.message || r.message.length == 0) return;
 
-				get_balances.then(r => {
-					if (!r.message || r.message.length == 0) return;
+			for (let account of r.message) {
 
-					for (let account of r.message) {
+				const node = cur_tree.nodes && cur_tree.nodes[account.value];
+				if (!node || node.is_root) continue;
 
-						const node = cur_tree.nodes && cur_tree.nodes[account.value];
-						if (!node || node.is_root) continue;
+				// show Dr if positive since balance is calculated as debit - credit else show Cr
+				const balance = account.balance_in_account_currency || account.balance;
+				const dr_or_cr = balance > 0 ? "Dr": "Cr";
+				const format = (value, currency) => format_currency(Math.abs(value), currency);
 
-						// show Dr if positive since balance is calculated as debit - credit else show Cr
-						const balance = account.balance_in_account_currency || account.balance;
-						const dr_or_cr = balance > 0 ? "Dr": "Cr";
-						const format = (value, currency) => format_currency(Math.abs(value), currency);
-
-						if (account.balance!==undefined) {
-							node.parent && node.parent.find('.balance-area').remove();
-							$('<span class="balance-area pull-right">'
-							  + (account.balance_in_account_currency ?
-							     (format(account.balance_in_account_currency, account.account_currency) + " / ") : "")
-							  + format(account.balance, account.company_currency)
-							  + " " + dr_or_cr
-							  + '</span>').insertBefore(node.$ul);
-						}
-					}
-				});
+				if (account.balance!==undefined) {
+					node.parent && node.parent.find('.balance-area').remove();
+					$('<span class="balance-area pull-right">'
+						+ (account.balance_in_account_currency ?
+							(format(account.balance_in_account_currency, account.account_currency) + " / ") : "")
+						+ format(account.balance, account.company_currency)
+						+ " " + dr_or_cr
+						+ '</span>').insertBefore(node.$ul);
+				}
 			}
 		});
 	},

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

@@ -29,7 +29,6 @@ def create_charts(
 					"root_type",
 					"is_group",
 					"tax_rate",
-					"account_currency",
 				]:
 
 					account_number = cstr(child.get("account_number")).strip()
@@ -96,17 +95,7 @@ def identify_is_group(child):
 		is_group = child.get("is_group")
 	elif len(
 		set(child.keys())
-		- set(
-			[
-				"account_name",
-				"account_type",
-				"root_type",
-				"is_group",
-				"tax_rate",
-				"account_number",
-				"account_currency",
-			]
-		)
+		- set(["account_name", "account_type", "root_type", "is_group", "tax_rate", "account_number"])
 	):
 		is_group = 1
 	else:
@@ -196,7 +185,6 @@ def get_account_tree_from_existing_company(existing_company):
 			"root_type",
 			"tax_rate",
 			"account_number",
-			"account_currency",
 		],
 		order_by="lft, rgt",
 	)
@@ -279,7 +267,6 @@ def build_tree_from_json(chart_template, chart_data=None, from_coa_importer=Fals
 				"root_type",
 				"is_group",
 				"tax_rate",
-				"account_currency",
 			]:
 				continue
 

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

@@ -1,38 +1,38 @@
 {
-	"country_code": "de",
-	"name": "SKR03 mit Kontonummern",
-	"tree": {
-		"Aktiva": {
-			"is_group": 1,
+    "country_code": "de",
+    "name": "SKR03 mit Kontonummern",
+    "tree": {
+        "Aktiva": {
+            "is_group": 1,
 			"root_type": "Asset",
-			"A - Anlagevermögen": {
-				"is_group": 1,
-				"EDV-Software": {
-					"account_number": "0027",
-					"account_type": "Fixed Asset"
-				},
-				"Geschäftsausstattung": {
-					"account_number": "0410",
-					"account_type": "Fixed Asset"
-				},
-				"Büroeinrichtung": {
-					"account_number": "0420",
-					"account_type": "Fixed Asset"
-				},
-				"Darlehen": {
-					"account_number": "0565"
-				},
-				"Maschinen": {
-					"account_number": "0210",
-					"account_type": "Fixed Asset"
-				},
-				"Betriebsausstattung": {
-					"account_number": "0400",
-					"account_type": "Fixed Asset"
-				},
-				"Ladeneinrichtung": {
-					"account_number": "0430",
-					"account_type": "Fixed Asset"
+            "A - Anlagevermögen": {
+                "is_group": 1,
+                "EDV-Software": {
+                    "account_number": "0027",
+                    "account_type": "Fixed Asset"
+                },
+                "Gesch\u00e4ftsausstattung": {
+                    "account_number": "0410",
+                    "account_type": "Fixed Asset"
+                },
+                "B\u00fcroeinrichtung": {
+                    "account_number": "0420",
+                    "account_type": "Fixed Asset"
+                },
+                "Darlehen": {
+                    "account_number": "0565"
+                },
+                "Maschinen": {
+                    "account_number": "0210",
+                    "account_type": "Fixed Asset"
+                },
+                "Betriebsausstattung": {
+                    "account_number": "0400",
+                    "account_type": "Fixed Asset"
+                },
+                "Ladeneinrichtung": {
+                    "account_number": "0430",
+                    "account_type": "Fixed Asset"
 				},
 				"Accumulated Depreciation": {
 					"account_type": "Accumulated Depreciation"
@@ -60,46 +60,36 @@
 					"Durchlaufende Posten": {
 						"account_number": "1590"
 					},
-					"Verrechnungskonto Gewinnermittlung § 4 Abs. 3 EStG, nicht ergebniswirksam": {
+					"Gewinnermittlung \u00a74/3 nicht Ergebniswirksam": {
 						"account_number": "1371"
 					},
 					"Abziehbare Vorsteuer": {
+						"account_type": "Tax",
 						"is_group": 1,
-						"Abziehbare Vorsteuer 7 %": {
-							"account_number": "1571",
-							"account_type": "Tax",
-							"tax_rate": 7.0
+						"Abziehbare Vorsteuer 7%": {
+							"account_number": "1571"
 						},
-						"Abziehbare Vorsteuer 19 %": {
-							"account_number": "1576",
-							"account_type": "Tax",
-							"tax_rate": 19.0
+						"Abziehbare Vorsteuer 19%": {
+							"account_number": "1576"
 						},
-						"Abziehbare Vorsteuer nach § 13b UStG 19 %": {
-							"account_number": "1577",
-							"account_type": "Tax",
-							"tax_rate": 19.0
+						"Abziehbare Vorsteuer nach \u00a713b UStG 19%": {
+							"account_number": "1577"
+						},
+						"Leistungen \u00a713b UStG 19% Vorsteuer, 19% Umsatzsteuer": {
+							"account_number": "3120"
 						}
 					}
 				},
 				"III. Wertpapiere": {
-					"is_group": 1,
-					"Anteile an verbundenen Unternehmen (Umlaufvermögen)": {
-						"account_number": "1340"
-					},
-					"Anteile an herrschender oder mit Mehrheit beteiligter Gesellschaft": {
-						"account_number": "1344"
-					},
-					"Sonstige Wertpapiere": {
-						"account_number": "1348"
-					}
+					"is_group": 1
 				},
 				"IV. Kassenbestand, Bundesbankguthaben, Guthaben bei Kreditinstituten und Schecks.": {
 					"is_group": 1,
 					"Kasse": {
-						"is_group": 1,
 						"account_type": "Cash",
+						"is_group": 1,
 						"Kasse": {
+							"is_group": 1,
 							"account_number": "1000",
 							"account_type": "Cash"
 						}
@@ -121,21 +111,21 @@
 			"C - Rechnungsabgrenzungsposten": {
 				"is_group": 1,
 				"Aktive Rechnungsabgrenzung": {
-					"account_number": "0980"
+                    "account_number": "0980"
 				}
 			},
 			"D - Aktive latente Steuern": {
 				"is_group": 1,
 				"Aktive latente Steuern": {
-					"account_number": "0983"
+                    "account_number": "0983"
 				}
 			},
 			"E - Aktiver Unterschiedsbetrag aus der Vermögensverrechnung": {
 				"is_group": 1
 			}
-		},
-		"Passiva": {
-			"is_group": 1,
+        },
+        "Passiva": {
+            "is_group": 1,
 			"root_type": "Liability",
 			"A. Eigenkapital": {
 				"is_group": 1,
@@ -210,32 +200,26 @@
 					},
 					"Umsatzsteuer": {
 						"is_group": 1,
-						"Umsatzsteuer 7 %": {
-							"account_number": "1771",
-							"account_type": "Tax",
-							"tax_rate": 7.0
+						"account_type": "Tax",
+						"Umsatzsteuer 7%": {
+							"account_number": "1771"
 						},
-						"Umsatzsteuer 19 %": {
-							"account_number": "1776",
-							"account_type": "Tax",
-							"tax_rate": 19.0
+						"Umsatzsteuer 19%": {
+							"account_number": "1776"
 						},
 						"Umsatzsteuer-Vorauszahlung": {
-							"account_number": "1780",
-							"account_type": "Tax"
+							"account_number": "1780"
 						},
 						"Umsatzsteuer-Vorauszahlung 1/11": {
 							"account_number": "1781"
 						},
-						"Umsatzsteuer nach § 13b UStG 19 %": {
-							"account_number": "1787",
-							"account_type": "Tax",
-							"tax_rate": 19.0
+						"Umsatzsteuer \u00a7 13b UStG 19%": {
+							"account_number": "1787"
 						},
 						"Umsatzsteuer Vorjahr": {
 							"account_number": "1790"
 						},
-						"Umsatzsteuer frühere Jahre": {
+						"Umsatzsteuer fr\u00fchere Jahre": {
 							"account_number": "1791"
 						}
 					}
@@ -250,56 +234,44 @@
 			"E. Passive latente Steuern": {
 				"is_group": 1
 			}
-		},
-		"Erlöse u. Erträge 2/8": {
-			"is_group": 1,
-			"root_type": "Income",
-			"Erlöskonten 8": {
+        },
+        "Erl\u00f6se u. Ertr\u00e4ge 2/8": {
+            "is_group": 1,
+            "root_type": "Income",
+            "Erl\u00f6skonten 8": {
 				"is_group": 1,
-				"Erlöse": {
-					"account_number": "8200",
-					"account_type": "Income Account"
-				},
-				"Erlöse USt. 19 %": {
-					"account_number": "8400",
-					"account_type": "Income Account"
-				},
-				"Erlöse USt. 7 %": {
-					"account_number": "8300",
-					"account_type": "Income Account"
-				}
-			},
-			"Ertragskonten 2": {
-				"is_group": 1,
-				"sonstige Zinsen und ähnliche Erträge": {
-					"account_number": "2650",
-					"account_type": "Income Account"
-				},
-				"Außerordentliche Erträge": {
-					"account_number": "2500",
-					"account_type": "Income Account"
-				},
-				"Sonstige Erträge": {
-					"account_number": "2700",
-					"account_type": "Income Account"
-				}
-			}
-		},
-		"Aufwendungen 2/4": {
-			"is_group": 1,
+				"Erl\u00f6se": {
+                    "account_number": "8200",
+                    "account_type": "Income Account"
+                },
+                "Erl\u00f6se USt. 19%": {
+                    "account_number": "8400",
+                    "account_type": "Income Account"
+                },
+                "Erl\u00f6se USt. 7%": {
+                    "account_number": "8300",
+                    "account_type": "Income Account"
+                }
+            },
+            "Ertragskonten 2": {
+                "is_group": 1,
+                "sonstige Zinsen und \u00e4hnliche Ertr\u00e4ge": {
+                    "account_number": "2650",
+                    "account_type": "Income Account"
+                },
+                "Au\u00dferordentliche Ertr\u00e4ge": {
+                    "account_number": "2500",
+                    "account_type": "Income Account"
+                },
+                "Sonstige Ertr\u00e4ge": {
+                    "account_number": "2700",
+                    "account_type": "Income Account"
+                }
+            }
+        },
+        "Aufwendungen 2/4": {
+            "is_group": 1,
 			"root_type": "Expense",
-			"Fremdleistungen": {
-				"account_number": "3100",
-				"account_type": "Expense Account"
-			},
-			"Fremdleistungen ohne Vorsteuer": {
-				"account_number": "3109",
-				"account_type": "Expense Account"
-			},
-			"Bauleistungen eines im Inland ansässigen Unternehmers 19 % Vorsteuer und 19 % Umsatzsteuer": {
-				"account_number": "3120",
-				"account_type": "Expense Account"
-			},
 			"Wareneingang": {
 				"account_number": "3200"
 			},
@@ -326,234 +298,234 @@
 			"Gegenkonto 4996-4998": {
 				"account_number": "4999"
 			},
-			"Abschreibungen": {
-				"is_group": 1,
+            "Abschreibungen": {
+                "is_group": 1,
 				"Abschreibungen auf Sachanlagen (ohne AfA auf Kfz und Gebäude)": {
-					"account_number": "4830",
-					"account_type": "Accumulated Depreciation"
+                    "account_number": "4830",
+                    "account_type": "Accumulated Depreciation"
 				},
 				"Abschreibungen auf Gebäude": {
-					"account_number": "4831",
-					"account_type": "Depreciation"
+                    "account_number": "4831",
+                    "account_type": "Depreciation"
 				},
 				"Abschreibungen auf Kfz": {
-					"account_number": "4832",
-					"account_type": "Depreciation"
+                    "account_number": "4832",
+                    "account_type": "Depreciation"
 				},
 				"Sofortabschreibung GWG": {
-					"account_number": "4855",
-					"account_type": "Expense Account"
+                    "account_number": "4855",
+                    "account_type": "Expense Account"
 				}
-			},
-			"Kfz-Kosten": {
-				"is_group": 1,
-				"Kfz-Steuer": {
-					"account_number": "4510",
-					"account_type": "Expense Account"
-				},
-				"Kfz-Versicherungen": {
-					"account_number": "4520",
-					"account_type": "Expense Account"
-				},
-				"laufende Kfz-Betriebskosten": {
-					"account_number": "4530",
-					"account_type": "Expense Account"
-				},
-				"Kfz-Reparaturen": {
-					"account_number": "4540",
-					"account_type": "Expense Account"
-				},
-				"Fremdfahrzeuge": {
-					"account_number": "4570",
-					"account_type": "Expense Account"
-				},
-				"sonstige Kfz-Kosten": {
-					"account_number": "4580",
-					"account_type": "Expense Account"
-				}
-			},
-			"Personalkosten": {
-				"is_group": 1,
-				"Gehälter": {
-					"account_number": "4120",
-					"account_type": "Expense Account"
-				},
-				"gesetzliche soziale Aufwendungen": {
-					"account_number": "4130",
-					"account_type": "Expense Account"
-				},
-				"Aufwendungen für Altersvorsorge": {
-					"account_number": "4165",
-					"account_type": "Expense Account"
-				},
-				"Vermögenswirksame Leistungen": {
-					"account_number": "4170",
-					"account_type": "Expense Account"
-				},
-				"Aushilfslöhne": {
-					"account_number": "4190",
-					"account_type": "Expense Account"
-				}
-			},
-			"Raumkosten": {
-				"is_group": 1,
-				"Miete und Nebenkosten": {
-					"account_number": "4210",
-					"account_type": "Expense Account"
-				},
-				"Gas, Wasser, Strom (Verwaltung, Vertrieb)": {
-					"account_number": "4240",
-					"account_type": "Expense Account"
-				},
-				"Reinigung": {
-					"account_number": "4250",
-					"account_type": "Expense Account"
-				}
-			},
-			"Reparatur/Instandhaltung": {
-				"is_group": 1,
-				"Reparaturen und Instandhaltungen von anderen Anlagen und Betriebs- und Geschäftsausstattung": {
-					"account_number": "4805",
-					"account_type": "Expense Account"
-				}
-			},
-			"Versicherungsbeiträge": {
-				"is_group": 1,
-				"Versicherungen": {
-					"account_number": "4360",
-					"account_type": "Expense Account"
-				},
-				"Beiträge": {
-					"account_number": "4380",
-					"account_type": "Expense Account"
-				},
-				"sonstige Ausgaben": {
-					"account_number": "4390",
-					"account_type": "Expense Account"
-				},
-				"steuerlich abzugsfähige Verspätungszuschläge und Zwangsgelder": {
-					"account_number": "4396",
-					"account_type": "Expense Account"
-				}
-			},
-			"Werbe-/Reisekosten": {
-				"is_group": 1,
-				"Werbekosten": {
-					"account_number": "4610",
-					"account_type": "Expense Account"
-				},
-				"Aufmerksamkeiten": {
-					"account_number": "4653",
-					"account_type": "Expense Account"
-				},
-				"nicht abzugsfähige Betriebsausg. aus Werbe-, Repräs.- u. Reisekosten": {
-					"account_number": "4665",
-					"account_type": "Expense Account"
-				},
-				"Reisekosten Unternehmer": {
-					"account_number": "4670",
-					"account_type": "Expense Account"
-				}
-			},
-			"verschiedene Kosten": {
-				"is_group": 1,
-				"Porto": {
-					"account_number": "4910",
-					"account_type": "Expense Account"
-				},
-				"Telekom": {
-					"account_number": "4920",
-					"account_type": "Expense Account"
-				},
-				"Mobilfunk D2": {
-					"account_number": "4921",
-					"account_type": "Expense Account"
-				},
-				"Internet": {
-					"account_number": "4922",
-					"account_type": "Expense Account"
-				},
-				"Bürobedarf": {
-					"account_number": "4930",
-					"account_type": "Expense Account"
-				},
-				"Zeitschriften, Bücher": {
-					"account_number": "4940",
-					"account_type": "Expense Account"
-				},
-				"Fortbildungskosten": {
-					"account_number": "4945",
-					"account_type": "Expense Account"
-				},
-				"Buchführungskosten": {
-					"account_number": "4955",
-					"account_type": "Expense Account"
-				},
-				"Abschluß- u. Prüfungskosten": {
-					"account_number": "4957",
-					"account_type": "Expense Account"
-				},
-				"Nebenkosten des Geldverkehrs": {
-					"account_number": "4970",
-					"account_type": "Expense Account"
-				},
-				"Werkzeuge und Kleingeräte": {
-					"account_number": "4985",
-					"account_type": "Expense Account"
-				}
-			},
-			"Zinsaufwendungen": {
-				"is_group": 1,
-				"Zinsaufwendungen für kurzfristige Verbindlichkeiten": {
-					"account_number": "2110",
-					"account_type": "Expense Account"
-				},
-				"Zinsaufwendungen für KFZ Finanzierung": {
-					"account_number": "2121",
-					"account_type": "Expense Account"
-				}
-			}
-		},
-		"Anfangsbestand 9": {
-			"is_group": 1,
-			"root_type": "Equity",
-			"Saldenvortragskonten": {
-				"is_group": 1,
-				"Saldenvortrag Sachkonten": {
-					"account_number": "9000"
-				},
-				"Saldenvorträge Debitoren": {
-					"account_number": "9008"
-				},
-				"Saldenvorträge Kreditoren": {
-					"account_number": "9009"
-				}
-			}
-		},
-		"Privatkonten 1": {
-			"is_group": 1,
-			"root_type": "Equity",
-			"Privatentnahmen/-einlagen": {
-				"is_group": 1,
-				"Privatentnahme allgemein": {
-					"account_number": "1800"
-				},
-				"Privatsteuern": {
-					"account_number": "1810"
-				},
-				"Sonderausgaben beschränkt abzugsfähig": {
-					"account_number": "1820"
-				},
-				"Sonderausgaben unbeschränkt abzugsfähig": {
-					"account_number": "1830"
-				},
-				"Außergewöhnliche Belastungen": {
-					"account_number": "1850"
-				},
-				"Privateinlagen": {
-					"account_number": "1890"
-				}
-			}
-		}
-	}
+            },
+            "Kfz-Kosten": {
+                "is_group": 1,
+                "Kfz-Steuer": {
+                    "account_number": "4510",
+                    "account_type": "Expense Account"
+                },
+                "Kfz-Versicherungen": {
+                    "account_number": "4520",
+                    "account_type": "Expense Account"
+                },
+                "laufende Kfz-Betriebskosten": {
+                    "account_number": "4530",
+                    "account_type": "Expense Account"
+                },
+                "Kfz-Reparaturen": {
+                    "account_number": "4540",
+                    "account_type": "Expense Account"
+                },
+                "Fremdfahrzeuge": {
+                    "account_number": "4570",
+                    "account_type": "Expense Account"
+                },
+                "sonstige Kfz-Kosten": {
+                    "account_number": "4580",
+                    "account_type": "Expense Account"
+                }
+            },
+            "Personalkosten": {
+                "is_group": 1,
+                "Geh\u00e4lter": {
+                    "account_number": "4120",
+                    "account_type": "Expense Account"
+                },
+                "gesetzliche soziale Aufwendungen": {
+                    "account_number": "4130",
+                    "account_type": "Expense Account"
+                },
+                "Aufwendungen f\u00fcr Altersvorsorge": {
+                    "account_number": "4165",
+                    "account_type": "Expense Account"
+                },
+                "Verm\u00f6genswirksame Leistungen": {
+                    "account_number": "4170",
+                    "account_type": "Expense Account"
+                },
+                "Aushilfsl\u00f6hne": {
+                    "account_number": "4190",
+                    "account_type": "Expense Account"
+                }
+            },
+            "Raumkosten": {
+                "is_group": 1,
+                "Miete und Nebenkosten": {
+                    "account_number": "4210",
+                    "account_type": "Expense Account"
+                },
+                "Gas, Wasser, Strom (Verwaltung, Vertrieb)": {
+                    "account_number": "4240",
+                    "account_type": "Expense Account"
+                },
+                "Reinigung": {
+                    "account_number": "4250",
+                    "account_type": "Expense Account"
+                }
+            },
+            "Reparatur/Instandhaltung": {
+                "is_group": 1,
+                "Reparatur u. Instandh. von Anlagen/Maschinen u. Betriebs- u. Gesch\u00e4ftsausst.": {
+                    "account_number": "4805",
+                    "account_type": "Expense Account"
+                }
+            },
+            "Versicherungsbeitr\u00e4ge": {
+                "is_group": 1,
+                "Versicherungen": {
+                    "account_number": "4360",
+                    "account_type": "Expense Account"
+                },
+                "Beitr\u00e4ge": {
+                    "account_number": "4380",
+                    "account_type": "Expense Account"
+                },
+                "sonstige Ausgaben": {
+                    "account_number": "4390",
+                    "account_type": "Expense Account"
+                },
+                "steuerlich abzugsf\u00e4hige Versp\u00e4tungszuschl\u00e4ge und Zwangsgelder": {
+                    "account_number": "4396",
+                    "account_type": "Expense Account"
+                }
+            },
+            "Werbe-/Reisekosten": {
+                "is_group": 1,
+                "Werbekosten": {
+                    "account_number": "4610",
+                    "account_type": "Expense Account"
+                },
+                "Aufmerksamkeiten": {
+                    "account_number": "4653",
+                    "account_type": "Expense Account"
+                },
+                "nicht abzugsf\u00e4hige Betriebsausg. aus Werbe-, Repr\u00e4s.- u. Reisekosten": {
+                    "account_number": "4665",
+                    "account_type": "Expense Account"
+                },
+                "Reisekosten Unternehmer": {
+                    "account_number": "4670",
+                    "account_type": "Expense Account"
+                }
+            },
+            "verschiedene Kosten": {
+                "is_group": 1,
+                "Porto": {
+                    "account_number": "4910",
+                    "account_type": "Expense Account"
+                },
+                "Telekom": {
+                    "account_number": "4920",
+                    "account_type": "Expense Account"
+                },
+                "Mobilfunk D2": {
+                    "account_number": "4921",
+                    "account_type": "Expense Account"
+                },
+                "Internet": {
+                    "account_number": "4922",
+                    "account_type": "Expense Account"
+                },
+                "B\u00fcrobedarf": {
+                    "account_number": "4930",
+                    "account_type": "Expense Account"
+                },
+                "Zeitschriften, B\u00fccher": {
+                    "account_number": "4940",
+                    "account_type": "Expense Account"
+                },
+                "Fortbildungskosten": {
+                    "account_number": "4945",
+                    "account_type": "Expense Account"
+                },
+                "Buchf\u00fchrungskosten": {
+                    "account_number": "4955",
+                    "account_type": "Expense Account"
+                },
+                "Abschlu\u00df- u. Pr\u00fcfungskosten": {
+                    "account_number": "4957",
+                    "account_type": "Expense Account"
+                },
+                "Nebenkosten des Geldverkehrs": {
+                    "account_number": "4970",
+                    "account_type": "Expense Account"
+                },
+                "Werkzeuge und Kleinger\u00e4te": {
+                    "account_number": "4985",
+                    "account_type": "Expense Account"
+                }
+            },
+            "Zinsaufwendungen": {
+                "is_group": 1,
+                "Zinsaufwendungen f\u00fcr kurzfristige Verbindlichkeiten": {
+                    "account_number": "2110",
+                    "account_type": "Expense Account"
+                },
+                "Zinsaufwendungen f\u00fcr KFZ Finanzierung": {
+                    "account_number": "2121",
+                    "account_type": "Expense Account"
+                }
+            }
+        },
+        "Anfangsbestand 9": {
+            "is_group": 1,
+            "root_type": "Equity",
+            "Saldenvortragskonten": {
+                "is_group": 1,
+                "Saldenvortrag Sachkonten": {
+                    "account_number": "9000"
+                },
+                "Saldenvortr\u00e4ge Debitoren": {
+                    "account_number": "9008"
+                },
+                "Saldenvortr\u00e4ge Kreditoren": {
+                    "account_number": "9009"
+                }
+            }
+        },
+        "Privatkonten 1": {
+            "is_group": 1,
+            "root_type": "Equity",
+            "Privatentnahmen/-einlagen": {
+                "is_group": 1,
+                "Privatentnahme allgemein": {
+                    "account_number": "1800"
+                },
+                "Privatsteuern": {
+                    "account_number": "1810"
+                },
+                "Sonderausgaben beschr\u00e4nkt abzugsf\u00e4hig": {
+                    "account_number": "1820"
+                },
+                "Sonderausgaben unbeschr\u00e4nkt abzugsf\u00e4hig": {
+                    "account_number": "1830"
+                },
+                "Au\u00dfergew\u00f6hnliche Belastungen": {
+                    "account_number": "1850"
+                },
+                "Privateinlagen": {
+                    "account_number": "1890"
+                }
+            }
+        }
+    }
 }

erpnext/accounts/doctype/account_closing_balance/account_closing_balance.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("Account Closing Balance", {
-// 	refresh(frm) {
-
-// 	},
-// });

erpnext/accounts/doctype/account_closing_balance/account_closing_balance.json

@@ -1,164 +0,0 @@
-{
- "actions": [],
- "creation": "2023-02-21 15:20:59.586811",
- "default_view": "List",
- "doctype": "DocType",
- "document_type": "Document",
- "engine": "InnoDB",
- "field_order": [
-  "closing_date",
-  "account",
-  "cost_center",
-  "debit",
-  "credit",
-  "account_currency",
-  "debit_in_account_currency",
-  "credit_in_account_currency",
-  "project",
-  "company",
-  "finance_book",
-  "period_closing_voucher",
-  "is_period_closing_voucher_entry"
- ],
- "fields": [
-  {
-   "fieldname": "closing_date",
-   "fieldtype": "Date",
-   "in_filter": 1,
-   "in_list_view": 1,
-   "label": "Closing Date",
-   "oldfieldname": "posting_date",
-   "oldfieldtype": "Date",
-   "search_index": 1
-  },
-  {
-   "fieldname": "account",
-   "fieldtype": "Link",
-   "in_filter": 1,
-   "in_list_view": 1,
-   "in_standard_filter": 1,
-   "label": "Account",
-   "oldfieldname": "account",
-   "oldfieldtype": "Link",
-   "options": "Account",
-   "search_index": 1
-  },
-  {
-   "fieldname": "cost_center",
-   "fieldtype": "Link",
-   "in_filter": 1,
-   "in_list_view": 1,
-   "label": "Cost Center",
-   "oldfieldname": "cost_center",
-   "oldfieldtype": "Link",
-   "options": "Cost Center"
-  },
-  {
-   "fieldname": "debit",
-   "fieldtype": "Currency",
-   "label": "Debit Amount",
-   "oldfieldname": "debit",
-   "oldfieldtype": "Currency",
-   "options": "Company:company:default_currency"
-  },
-  {
-   "fieldname": "credit",
-   "fieldtype": "Currency",
-   "label": "Credit Amount",
-   "oldfieldname": "credit",
-   "oldfieldtype": "Currency",
-   "options": "Company:company:default_currency"
-  },
-  {
-   "fieldname": "account_currency",
-   "fieldtype": "Link",
-   "label": "Account Currency",
-   "options": "Currency"
-  },
-  {
-   "fieldname": "debit_in_account_currency",
-   "fieldtype": "Currency",
-   "label": "Debit Amount in Account Currency",
-   "options": "account_currency"
-  },
-  {
-   "fieldname": "credit_in_account_currency",
-   "fieldtype": "Currency",
-   "label": "Credit Amount in Account Currency",
-   "options": "account_currency"
-  },
-  {
-   "fieldname": "project",
-   "fieldtype": "Link",
-   "label": "Project",
-   "options": "Project"
-  },
-  {
-   "fieldname": "company",
-   "fieldtype": "Link",
-   "in_filter": 1,
-   "in_list_view": 1,
-   "in_standard_filter": 1,
-   "label": "Company",
-   "oldfieldname": "company",
-   "oldfieldtype": "Link",
-   "options": "Company",
-   "search_index": 1
-  },
-  {
-   "fieldname": "finance_book",
-   "fieldtype": "Link",
-   "label": "Finance Book",
-   "options": "Finance Book"
-  },
-  {
-   "fieldname": "period_closing_voucher",
-   "fieldtype": "Link",
-   "in_standard_filter": 1,
-   "label": "Period Closing Voucher",
-   "options": "Period Closing Voucher",
-   "search_index": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "is_period_closing_voucher_entry",
-   "fieldtype": "Check",
-   "label": "Is Period Closing Voucher Entry"
-  }
- ],
- "icon": "fa fa-list",
- "in_create": 1,
- "links": [],
- "modified": "2023-03-06 08:56:36.393237",
- "modified_by": "Administrator",
- "module": "Accounts",
- "name": "Account Closing Balance",
- "owner": "Administrator",
- "permissions": [
-  {
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "Accounts User"
-  },
-  {
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "Accounts Manager"
-  },
-  {
-   "export": 1,
-   "read": 1,
-   "report": 1,
-   "role": "Auditor"
-  }
- ],
- "sort_field": "modified",
- "sort_order": "DESC",
- "states": []
-}

erpnext/accounts/doctype/account_closing_balance/account_closing_balance.py

@@ -1,127 +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
-from frappe.utils import cint, cstr
-
-from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
-	get_accounting_dimensions,
-)
-
-
-class AccountClosingBalance(Document):
-	pass
-
-
-def make_closing_entries(closing_entries, voucher_name):
-	accounting_dimensions = get_accounting_dimensions()
-	company = closing_entries[0].get("company")
-	closing_date = closing_entries[0].get("closing_date")
-
-	previous_closing_entries = get_previous_closing_entries(
-		company, closing_date, accounting_dimensions
-	)
-	combined_entries = closing_entries + previous_closing_entries
-
-	merged_entries = aggregate_with_last_account_closing_balance(
-		combined_entries, accounting_dimensions
-	)
-
-	for key, value in merged_entries.items():
-		cle = frappe.new_doc("Account Closing Balance")
-		cle.update(value)
-		cle.update(value["dimensions"])
-		cle.update(
-			{
-				"period_closing_voucher": voucher_name,
-				"closing_date": closing_date,
-			}
-		)
-		cle.submit()
-
-
-def aggregate_with_last_account_closing_balance(entries, accounting_dimensions):
-	merged_entries = {}
-	for entry in entries:
-		key, key_values = generate_key(entry, accounting_dimensions)
-		merged_entries.setdefault(
-			key,
-			{
-				"debit": 0,
-				"credit": 0,
-				"debit_in_account_currency": 0,
-				"credit_in_account_currency": 0,
-			},
-		)
-
-		merged_entries[key]["dimensions"] = key_values
-		merged_entries[key]["debit"] += entry.get("debit")
-		merged_entries[key]["credit"] += entry.get("credit")
-		merged_entries[key]["debit_in_account_currency"] += entry.get("debit_in_account_currency")
-		merged_entries[key]["credit_in_account_currency"] += entry.get("credit_in_account_currency")
-
-	return merged_entries
-
-
-def generate_key(entry, accounting_dimensions):
-	key = [
-		cstr(entry.get("account")),
-		cstr(entry.get("account_currency")),
-		cstr(entry.get("cost_center")),
-		cstr(entry.get("project")),
-		cstr(entry.get("finance_book")),
-		cint(entry.get("is_period_closing_voucher_entry")),
-	]
-
-	key_values = {
-		"company": cstr(entry.get("company")),
-		"account": cstr(entry.get("account")),
-		"account_currency": cstr(entry.get("account_currency")),
-		"cost_center": cstr(entry.get("cost_center")),
-		"project": cstr(entry.get("project")),
-		"finance_book": cstr(entry.get("finance_book")),
-		"is_period_closing_voucher_entry": cint(entry.get("is_period_closing_voucher_entry")),
-	}
-	for dimension in accounting_dimensions:
-		key.append(cstr(entry.get(dimension)))
-		key_values[dimension] = cstr(entry.get(dimension))
-
-	return tuple(key), key_values
-
-
-def get_previous_closing_entries(company, closing_date, accounting_dimensions):
-	entries = []
-	last_period_closing_voucher = frappe.db.get_all(
-		"Period Closing Voucher",
-		filters={"docstatus": 1, "company": company, "posting_date": ("<", closing_date)},
-		fields=["name"],
-		order_by="posting_date desc",
-		limit=1,
-	)
-
-	if last_period_closing_voucher:
-		account_closing_balance = frappe.qb.DocType("Account Closing Balance")
-		query = frappe.qb.from_(account_closing_balance).select(
-			account_closing_balance.company,
-			account_closing_balance.account,
-			account_closing_balance.account_currency,
-			account_closing_balance.debit,
-			account_closing_balance.credit,
-			account_closing_balance.debit_in_account_currency,
-			account_closing_balance.credit_in_account_currency,
-			account_closing_balance.cost_center,
-			account_closing_balance.project,
-			account_closing_balance.finance_book,
-			account_closing_balance.is_period_closing_voucher_entry,
-		)
-
-		for dimension in accounting_dimensions:
-			query = query.select(account_closing_balance[dimension])
-
-		query = query.where(
-			account_closing_balance.period_closing_voucher == last_period_closing_voucher[0].name
-		)
-		entries = query.run(as_dict=1)
-
-	return entries

erpnext/accounts/doctype/account_closing_balance/test_account_closing_balance.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 TestAccountClosingBalance(FrappeTestCase):
-	pass

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -31,7 +31,6 @@
   "determine_address_tax_category_from",
   "column_break_19",
   "add_taxes_from_item_tax_template",
-  "book_tax_discount_loss",
   "print_settings",
   "show_inclusive_tax_in_print",
   "column_break_12",
@@ -57,9 +56,7 @@
   "acc_frozen_upto",
   "column_break_25",
   "frozen_accounts_modifier",
-  "report_settings_sb",
-  "tab_break_dpet",
-  "show_balance_in_coa"
+  "report_settings_sb"
  ],
  "fields": [
   {
@@ -350,24 +347,6 @@
    "fieldname": "allow_multi_currency_invoices_against_single_party_account",
    "fieldtype": "Check",
    "label": "Allow multi-currency invoices against single party account "
-  },
-  {
-   "fieldname": "tab_break_dpet",
-   "fieldtype": "Tab Break",
-   "label": "Chart Of Accounts"
-  },
-  {
-   "default": "1",
-   "fieldname": "show_balance_in_coa",
-   "fieldtype": "Check",
-   "label": "Show Balances in Chart Of Accounts"
-  },
-  {
-   "default": "0",
-   "description": "Split Early Payment Discount Loss into Income and Tax Loss",
-   "fieldname": "book_tax_discount_loss",
-   "fieldtype": "Check",
-   "label": "Book Tax Loss on Early Payment Discount"
   }
  ],
  "icon": "icon-cog",
@@ -375,7 +354,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-03-28 09:50:20.375233",
+ "modified": "2022-11-27 21:49:52.538655",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/bank/bank.js

@@ -118,10 +118,6 @@ erpnext.integrations.refreshPlaidLink = class refreshPlaidLink {
 	}
 
 	plaid_success(token, response) {
-		frappe.xcall('erpnext.erpnext_integrations.doctype.plaid_settings.plaid_settings.update_bank_account_ids', {
-			response: response,
-		}).then(() => {
-			frappe.show_alert({ message: __('Plaid Link Updated'), indicator: 'green' });
-		});
+		frappe.show_alert({ message: __('Plaid Link Updated'), indicator: 'green' });
 	}
 };

erpnext/accounts/doctype/bank_clearance/bank_clearance.js

@@ -37,11 +37,14 @@ frappe.ui.form.on("Bank Clearance", {
 
 	refresh: function(frm) {
 		frm.disable_save();
-		frm.add_custom_button(__('Get Payment Entries'), () =>
-			frm.trigger("get_payment_entries")
-		);
 
-		frm.change_custom_button_type('Get Payment Entries', null, 'primary');
+		if (frm.doc.account && frm.doc.from_date && frm.doc.to_date) {
+			frm.add_custom_button(__('Get Payment Entries'), () =>
+				frm.trigger("get_payment_entries")
+			);
+
+			frm.change_custom_button_type('Get Payment Entries', null, 'primary');
+		}
 	},
 
 	update_clearance_date: function(frm) {

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -81,7 +81,7 @@ class BankClearance(Document):
 
 		loan_disbursement = frappe.qb.DocType("Loan Disbursement")
 
-		query = (
+		loan_disbursements = (
 			frappe.qb.from_(loan_disbursement)
 			.select(
 				ConstantColumn("Loan Disbursement").as_("payment_document"),
@@ -90,22 +90,17 @@ class BankClearance(Document):
 				ConstantColumn(0).as_("debit"),
 				loan_disbursement.reference_number.as_("cheque_number"),
 				loan_disbursement.reference_date.as_("cheque_date"),
-				loan_disbursement.clearance_date.as_("clearance_date"),
 				loan_disbursement.disbursement_date.as_("posting_date"),
 				loan_disbursement.applicant.as_("against_account"),
 			)
 			.where(loan_disbursement.docstatus == 1)
 			.where(loan_disbursement.disbursement_date >= self.from_date)
 			.where(loan_disbursement.disbursement_date <= self.to_date)
+			.where(loan_disbursement.clearance_date.isnull())
 			.where(loan_disbursement.disbursement_account.isin([self.bank_account, self.account]))
 			.orderby(loan_disbursement.disbursement_date)
 			.orderby(loan_disbursement.name, order=frappe.qb.desc)
-		)
-
-		if not self.include_reconciled_entries:
-			query = query.where(loan_disbursement.clearance_date.isnull())
-
-		loan_disbursements = query.run(as_dict=1)
+		).run(as_dict=1)
 
 		loan_repayment = frappe.qb.DocType("Loan Repayment")
 
@@ -118,19 +113,16 @@ class BankClearance(Document):
 				ConstantColumn(0).as_("credit"),
 				loan_repayment.reference_number.as_("cheque_number"),
 				loan_repayment.reference_date.as_("cheque_date"),
-				loan_repayment.clearance_date.as_("clearance_date"),
 				loan_repayment.applicant.as_("against_account"),
 				loan_repayment.posting_date,
 			)
 			.where(loan_repayment.docstatus == 1)
+			.where(loan_repayment.clearance_date.isnull())
 			.where(loan_repayment.posting_date >= self.from_date)
 			.where(loan_repayment.posting_date <= self.to_date)
 			.where(loan_repayment.payment_account.isin([self.bank_account, self.account]))
 		)
 
-		if not self.include_reconciled_entries:
-			query = query.where(loan_repayment.clearance_date.isnull())
-
 		if frappe.db.has_column("Loan Repayment", "repay_from_salary"):
 			query = query.where((loan_repayment.repay_from_salary == 0))
 

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.js

@@ -18,30 +18,16 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 	},
 
 	onload: function (frm) {
-		// Set default filter dates
-		today = frappe.datetime.get_today()
-		frm.doc.bank_statement_from_date = frappe.datetime.add_months(today, -1);
-		frm.doc.bank_statement_to_date = today;
 		frm.trigger('bank_account');
 	},
 
-	filter_by_reference_date: function (frm) {
-		if (frm.doc.filter_by_reference_date) {
-			frm.set_value("bank_statement_from_date", "");
-			frm.set_value("bank_statement_to_date", "");
-		} else {
-			frm.set_value("from_reference_date", "");
-			frm.set_value("to_reference_date", "");
-		}
-	},
-
 	refresh: function (frm) {
-		frm.disable_save();
 		frappe.require("bank-reconciliation-tool.bundle.js", () =>
 			frm.trigger("make_reconciliation_tool")
 		);
-
-		frm.add_custom_button(__("Upload Bank Statement"), () =>
+		frm.upload_statement_button = frm.page.set_secondary_action(
+			__("Upload Bank Statement"),
+			() =>
 				frappe.call({
 					method:
 						"erpnext.accounts.doctype.bank_statement_import.bank_statement_import.upload_bank_statement",
@@ -63,26 +49,10 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 					},
 				})
 		);
+	},
 
-		frm.add_custom_button(__('Auto Reconcile'), function() {
-			frappe.call({
-				method: "erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.auto_reconcile_vouchers",
-				args: {
-					bank_account: frm.doc.bank_account,
-					from_date: frm.doc.bank_statement_from_date,
-					to_date: frm.doc.bank_statement_to_date,
-					filter_by_reference_date: frm.doc.filter_by_reference_date,
-					from_reference_date: frm.doc.from_reference_date,
-					to_reference_date: frm.doc.to_reference_date,
-				},
-			})
-		});
-
-		frm.add_custom_button(__('Get Unreconciled Entries'), function() {
-			frm.trigger("make_reconciliation_tool");
-		});
-		frm.change_custom_button_type('Get Unreconciled Entries', null, 'primary');
-
+	after_save: function (frm) {
+		frm.trigger("make_reconciliation_tool");
 	},
 
 	bank_account: function (frm) {
@@ -96,7 +66,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 					r.account,
 					"account_currency",
 					(r) => {
-						frm.doc.account_currency = r.account_currency;
+						frm.currency = r.account_currency;
 						frm.trigger("render_chart");
 					}
 				);
@@ -162,19 +132,19 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 		}
 	},
 
-	render_chart(frm) {
+	render_chart: frappe.utils.debounce((frm) => {
 		frm.cards_manager = new erpnext.accounts.bank_reconciliation.NumberCardManager(
 			{
 				$reconciliation_tool_cards: frm.get_field(
 					"reconciliation_tool_cards"
 				).$wrapper,
 				bank_statement_closing_balance:
-				frm.doc.bank_statement_closing_balance,
+					frm.doc.bank_statement_closing_balance,
 				cleared_balance: frm.cleared_balance,
-				currency: frm.doc.account_currency,
+				currency: frm.currency,
 			}
 		);
-	},
+	}, 500),
 
 	render(frm) {
 		if (frm.doc.bank_account) {
@@ -190,9 +160,6 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 					).$wrapper,
 					bank_statement_from_date: frm.doc.bank_statement_from_date,
 					bank_statement_to_date: frm.doc.bank_statement_to_date,
-					filter_by_reference_date: frm.doc.filter_by_reference_date,
-					from_reference_date: frm.doc.from_reference_date,
-					to_reference_date: frm.doc.to_reference_date,
 					bank_statement_closing_balance:
 						frm.doc.bank_statement_closing_balance,
 					cards_manager: frm.cards_manager,

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.json

@@ -10,11 +10,7 @@
   "column_break_1",
   "bank_statement_from_date",
   "bank_statement_to_date",
-  "from_reference_date",
-  "to_reference_date",
-  "filter_by_reference_date",
   "column_break_2",
-  "account_currency",
   "account_opening_balance",
   "bank_statement_closing_balance",
   "section_break_1",
@@ -40,13 +36,13 @@
    "fieldtype": "Column Break"
   },
   {
-   "depends_on": "eval: doc.bank_account && !doc.filter_by_reference_date",
+   "depends_on": "eval: doc.bank_account",
    "fieldname": "bank_statement_from_date",
    "fieldtype": "Date",
    "label": "From Date"
   },
   {
-   "depends_on": "eval: doc.bank_account && !doc.filter_by_reference_date",
+   "depends_on": "eval: doc.bank_statement_from_date",
    "fieldname": "bank_statement_to_date",
    "fieldtype": "Date",
    "label": "To Date"
@@ -60,7 +56,7 @@
    "fieldname": "account_opening_balance",
    "fieldtype": "Currency",
    "label": "Account Opening Balance",
-   "options": "account_currency",
+   "options": "Currency",
    "read_only": 1
   },
   {
@@ -68,7 +64,7 @@
    "fieldname": "bank_statement_closing_balance",
    "fieldtype": "Currency",
    "label": "Closing Balance",
-   "options": "account_currency"
+   "options": "Currency"
   },
   {
    "fieldname": "section_break_1",
@@ -85,40 +81,14 @@
   },
   {
    "fieldname": "no_bank_transactions",
-   "fieldtype": "HTML",
-   "options": "<div class=\"text-muted text-center\">No Matching Bank Transactions Found</div>"
-  },
-  {
-   "depends_on": "eval:doc.filter_by_reference_date",
-   "fieldname": "from_reference_date",
-   "fieldtype": "Date",
-   "label": "From Reference Date"
-  },
-  {
-   "depends_on": "eval:doc.filter_by_reference_date",
-   "fieldname": "to_reference_date",
-   "fieldtype": "Date",
-   "label": "To Reference Date"
-  },
-  {
-   "default": "0",
-   "fieldname": "filter_by_reference_date",
-   "fieldtype": "Check",
-   "label": "Filter by Reference Date"
-  },
-  {
-   "fieldname": "account_currency",
-   "fieldtype": "Link",
-   "hidden": 1,
-   "label": "Account Currency",
-   "options": "Currency"
+   "fieldtype": "HTML"
   }
  ],
  "hide_toolbar": 1,
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-03-07 11:02:24.535714",
+ "modified": "2021-04-21 11:13:49.831769",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Reconciliation Tool",
@@ -137,6 +107,5 @@
  ],
  "quick_entry": 1,
  "sort_field": "modified",
- "sort_order": "DESC",
- "states": []
-}
+ "sort_order": "DESC"
+}

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -8,9 +8,9 @@ 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 frappe.utils import flt
 
-from erpnext.accounts.doctype.bank_transaction.bank_transaction import get_total_allocated_amount
+from erpnext.accounts.doctype.bank_transaction.bank_transaction import get_paid_amount
 from erpnext.accounts.report.bank_reconciliation_statement.bank_reconciliation_statement import (
 	get_amounts_not_reflected_in_system,
 	get_entries,
@@ -28,7 +28,7 @@ def get_bank_transactions(bank_account, from_date=None, to_date=None):
 	filters = []
 	filters.append(["bank_account", "=", bank_account])
 	filters.append(["docstatus", "=", 1])
-	filters.append(["unallocated_amount", ">", 0.0])
+	filters.append(["unallocated_amount", ">", 0])
 	if to_date:
 		filters.append(["date", "<=", to_date])
 	if from_date:
@@ -50,7 +50,6 @@ def get_bank_transactions(bank_account, from_date=None, to_date=None):
 			"party",
 		],
 		filters=filters,
-		order_by="date",
 	)
 	return transactions
 
@@ -58,7 +57,7 @@ def get_bank_transactions(bank_account, from_date=None, to_date=None):
 @frappe.whitelist()
 def get_account_balance(bank_account, till_date):
 	# returns account balance till the specified date
-	account = frappe.db.get_value("Bank Account", bank_account, "account")
+	account = frappe.get_cached_value("Bank Account", bank_account, "account")
 	filters = frappe._dict(
 		{"account": account, "report_date": till_date, "include_pos_transactions": 1}
 	)
@@ -66,7 +65,7 @@ def get_account_balance(bank_account, till_date):
 
 	balance_as_per_system = get_balance_on(filters["account"], filters["report_date"])
 
-	total_debit, total_credit = 0.0, 0.0
+	total_debit, total_credit = 0, 0
 	for d in data:
 		total_debit += flt(d.debit)
 		total_credit += flt(d.credit)
@@ -131,8 +130,10 @@ def create_journal_entry_bts(
 		fieldname=["name", "deposit", "withdrawal", "bank_account"],
 		as_dict=True,
 	)[0]
-	company_account = frappe.get_value("Bank Account", bank_transaction.bank_account, "account")
-	account_type = frappe.db.get_value("Account", second_account, "account_type")
+	company_account = frappe.get_cached_value(
+		"Bank Account", bank_transaction.bank_account, "account"
+	)
+	account_type = frappe.get_cached_value("Account", second_account, "account_type")
 	if account_type in ["Receivable", "Payable"]:
 		if not (party_type and party):
 			frappe.throw(
@@ -145,8 +146,10 @@ def create_journal_entry_bts(
 	accounts.append(
 		{
 			"account": second_account,
-			"credit_in_account_currency": bank_transaction.deposit,
-			"debit_in_account_currency": bank_transaction.withdrawal,
+			"credit_in_account_currency": bank_transaction.deposit if bank_transaction.deposit > 0 else 0,
+			"debit_in_account_currency": bank_transaction.withdrawal
+			if bank_transaction.withdrawal > 0
+			else 0,
 			"party_type": party_type,
 			"party": party,
 		}
@@ -156,12 +159,14 @@ def create_journal_entry_bts(
 		{
 			"account": company_account,
 			"bank_account": bank_transaction.bank_account,
-			"credit_in_account_currency": bank_transaction.withdrawal,
-			"debit_in_account_currency": bank_transaction.deposit,
+			"credit_in_account_currency": bank_transaction.withdrawal
+			if bank_transaction.withdrawal > 0
+			else 0,
+			"debit_in_account_currency": bank_transaction.deposit if bank_transaction.deposit > 0 else 0,
 		}
 	)
 
-	company = frappe.get_value("Account", company_account, "company")
+	company = frappe.get_cached_value("Account", company_account, "company")
 
 	journal_entry_dict = {
 		"voucher_type": entry_type,
@@ -181,22 +186,16 @@ def create_journal_entry_bts(
 	journal_entry.insert()
 	journal_entry.submit()
 
-	if bank_transaction.deposit > 0.0:
+	if bank_transaction.deposit > 0:
 		paid_amount = bank_transaction.deposit
 	else:
 		paid_amount = bank_transaction.withdrawal
 
 	vouchers = json.dumps(
-		[
-			{
-				"payment_doctype": "Journal Entry",
-				"payment_name": journal_entry.name,
-				"amount": paid_amount,
-			}
-		]
+		[{"payment_doctype": "Journal Entry", "payment_name": journal_entry.name, "amount": paid_amount}]
 	)
 
-	return reconcile_vouchers(bank_transaction_name, vouchers)
+	return reconcile_vouchers(bank_transaction.name, vouchers)
 
 
 @frappe.whitelist()
@@ -220,10 +219,12 @@ def create_payment_entry_bts(
 		as_dict=True,
 	)[0]
 	paid_amount = bank_transaction.unallocated_amount
-	payment_type = "Receive" if bank_transaction.deposit > 0.0 else "Pay"
+	payment_type = "Receive" if bank_transaction.deposit > 0 else "Pay"
 
-	company_account = frappe.get_value("Bank Account", bank_transaction.bank_account, "account")
-	company = frappe.get_value("Account", company_account, "company")
+	company_account = frappe.get_cached_value(
+		"Bank Account", bank_transaction.bank_account, "account"
+	)
+	company = frappe.get_cached_value("Account", company_account, "company")
 	payment_entry_dict = {
 		"company": company,
 		"payment_type": payment_type,
@@ -259,89 +260,9 @@ def create_payment_entry_bts(
 
 	payment_entry.submit()
 	vouchers = json.dumps(
-		[
-			{
-				"payment_doctype": "Payment Entry",
-				"payment_name": payment_entry.name,
-				"amount": paid_amount,
-			}
-		]
+		[{"payment_doctype": "Payment Entry", "payment_name": payment_entry.name, "amount": paid_amount}]
 	)
-	return reconcile_vouchers(bank_transaction_name, vouchers)
-
-
-@frappe.whitelist()
-def auto_reconcile_vouchers(
-	bank_account,
-	from_date=None,
-	to_date=None,
-	filter_by_reference_date=None,
-	from_reference_date=None,
-	to_reference_date=None,
-):
-	frappe.flags.auto_reconcile_vouchers = True
-	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,
-			document_types,
-			from_date,
-			to_date,
-			filter_by_reference_date,
-			from_reference_date,
-			to_reference_date,
-		)
-		vouchers = []
-		for r in linked_payments:
-			vouchers.append(
-				{
-					"payment_doctype": r[1],
-					"payment_name": r[2],
-					"amount": r[4],
-				}
-			)
-		transaction = frappe.get_doc("Bank Transaction", transaction.name)
-		account = frappe.db.get_value("Bank Account", transaction.bank_account, "account")
-		matched_trans = 0
-		for voucher in vouchers:
-			gl_entry = frappe.db.get_value(
-				"GL Entry",
-				dict(
-					account=account, voucher_type=voucher["payment_doctype"], voucher_no=voucher["payment_name"]
-				),
-				["credit", "debit"],
-				as_dict=1,
-			)
-			gl_amount, transaction_amount = (
-				(gl_entry.credit, transaction.deposit)
-				if gl_entry.credit > 0
-				else (gl_entry.debit, transaction.withdrawal)
-			)
-			allocated_amount = gl_amount if gl_amount >= transaction_amount else transaction_amount
-			transaction.append(
-				"payment_entries",
-				{
-					"payment_document": voucher["payment_doctype"],
-					"payment_entry": voucher["payment_name"],
-					"allocated_amount": allocated_amount,
-				},
-			)
-			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 frappe.get_doc("Bank Transaction", transaction.name)
+	return reconcile_vouchers(bank_transaction.name, vouchers)
 
 
 @frappe.whitelist()
@@ -349,88 +270,80 @@ def reconcile_vouchers(bank_transaction_name, vouchers):
 	# updated clear date of all the vouchers based on the bank transaction
 	vouchers = json.loads(vouchers)
 	transaction = frappe.get_doc("Bank Transaction", bank_transaction_name)
-	transaction.add_payment_entries(vouchers)
+	company_account = frappe.get_cached_value("Bank Account", transaction.bank_account, "account")
+
+	if transaction.unallocated_amount == 0:
+		frappe.throw(_("This bank transaction is already fully reconciled"))
+	total_amount = 0
+	for voucher in vouchers:
+		voucher["payment_entry"] = frappe.get_doc(voucher["payment_doctype"], voucher["payment_name"])
+		total_amount += get_paid_amount(
+			frappe._dict(
+				{
+					"payment_document": voucher["payment_doctype"],
+					"payment_entry": voucher["payment_name"],
+				}
+			),
+			transaction.currency,
+			company_account,
+		)
+
+	if total_amount > transaction.unallocated_amount:
+		frappe.throw(
+			_(
+				"The sum total of amounts of all selected vouchers should be less than the unallocated amount of the bank transaction"
+			)
+		)
+	account = frappe.get_cached_value("Bank Account", transaction.bank_account, "account")
+
+	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_entry"].doctype,
+				"payment_entry": voucher["payment_entry"].name,
+				"allocated_amount": allocated_amount,
+			},
+		)
+
+	transaction.save()
+	transaction.update_allocations()
 	return frappe.get_doc("Bank Transaction", bank_transaction_name)
 
 
 @frappe.whitelist()
-def get_linked_payments(
-	bank_transaction_name,
-	document_types=None,
-	from_date=None,
-	to_date=None,
-	filter_by_reference_date=None,
-	from_reference_date=None,
-	to_reference_date=None,
-):
+def get_linked_payments(bank_transaction_name, document_types=None):
 	# get all matching payments for a bank transaction
 	transaction = frappe.get_doc("Bank Transaction", bank_transaction_name)
 	bank_account = frappe.db.get_values(
 		"Bank Account", transaction.bank_account, ["account", "company"], as_dict=True
 	)[0]
-	(gl_account, company) = (bank_account.account, bank_account.company)
-	matching = check_matching(
-		gl_account,
-		company,
-		transaction,
-		document_types,
-		from_date,
-		to_date,
-		filter_by_reference_date,
-		from_reference_date,
-		to_reference_date,
-	)
-	return subtract_allocations(gl_account, matching)
+	(account, company) = (bank_account.account, bank_account.company)
+	matching = check_matching(account, company, transaction, document_types)
+	return matching
 
 
-def subtract_allocations(gl_account, vouchers):
-	"Look up & subtract any existing Bank Transaction allocations"
-	copied = []
-	for voucher in vouchers:
-		rows = get_total_allocated_amount(voucher[1], voucher[2])
-		amount = None
-		for row in rows:
-			if row["gl_account"] == gl_account:
-				amount = row["total"]
-				break
-
-		if amount:
-			l = list(voucher)
-			l[3] -= amount
-			copied.append(tuple(l))
-		else:
-			copied.append(voucher)
-	return copied
-
-
-def check_matching(
-	bank_account,
-	company,
-	transaction,
-	document_types,
-	from_date,
-	to_date,
-	filter_by_reference_date,
-	from_reference_date,
-	to_reference_date,
-):
-	exact_match = True if "exact_match" in document_types else False
+def check_matching(bank_account, company, transaction, document_types):
 	# combine all types of vouchers
-	subquery = get_queries(
-		bank_account,
-		company,
-		transaction,
-		document_types,
-		from_date,
-		to_date,
-		filter_by_reference_date,
-		from_reference_date,
-		to_reference_date,
-		exact_match,
-	)
+	subquery = get_queries(bank_account, company, transaction, document_types)
 	filters = {
 		"amount": transaction.unallocated_amount,
-		"payment_type": "Receive" if transaction.deposit > 0.0 else "Pay",
+		"payment_type": "Receive" if transaction.deposit > 0 else "Pay",
 		"reference_no": transaction.reference_number,
 		"party_type": transaction.party_type,
 		"party": transaction.party,
@@ -439,9 +352,7 @@ def check_matching(
 
 	matching_vouchers = []
 
-	matching_vouchers.extend(
-		get_loan_vouchers(bank_account, transaction, document_types, filters, exact_match)
-	)
+	matching_vouchers.extend(get_loan_vouchers(bank_account, transaction, document_types, filters))
 
 	for query in subquery:
 		matching_vouchers.extend(
@@ -450,23 +361,14 @@ def check_matching(
 				filters,
 			)
 		)
+
 	return sorted(matching_vouchers, key=lambda x: x[0], reverse=True) if matching_vouchers else []
 
 
-def get_queries(
-	bank_account,
-	company,
-	transaction,
-	document_types,
-	from_date,
-	to_date,
-	filter_by_reference_date,
-	from_reference_date,
-	to_reference_date,
-	exact_match,
-):
+def get_queries(bank_account, company, transaction, document_types):
 	# get queries to get matching vouchers
-	account_from_to = "paid_to" if transaction.deposit > 0.0 else "paid_from"
+	amount_condition = "=" if "exact_match" in document_types else "<="
+	account_from_to = "paid_to" if transaction.deposit > 0 else "paid_from"
 	queries = []
 
 	# get matching queries from all the apps
@@ -477,13 +379,8 @@ def get_queries(
 				company,
 				transaction,
 				document_types,
-				exact_match,
+				amount_condition,
 				account_from_to,
-				from_date,
-				to_date,
-				filter_by_reference_date,
-				from_reference_date,
-				to_reference_date,
 			)
 			or []
 		)
@@ -492,106 +389,43 @@ def get_queries(
 
 
 def get_matching_queries(
-	bank_account,
-	company,
-	transaction,
-	document_types,
-	exact_match,
-	account_from_to,
-	from_date,
-	to_date,
-	filter_by_reference_date,
-	from_reference_date,
-	to_reference_date,
+	bank_account, company, transaction, document_types, amount_condition, account_from_to
 ):
 	queries = []
 	if "payment_entry" in document_types:
-		query = get_pe_matching_query(
-			exact_match,
-			account_from_to,
-			transaction,
-			from_date,
-			to_date,
-			filter_by_reference_date,
-			from_reference_date,
-			to_reference_date,
-		)
-		queries.append(query)
+		pe_amount_matching = get_pe_matching_query(amount_condition, account_from_to, transaction)
+		queries.extend([pe_amount_matching])
 
 	if "journal_entry" in document_types:
-		query = get_je_matching_query(
-			exact_match,
-			transaction,
-			from_date,
-			to_date,
-			filter_by_reference_date,
-			from_reference_date,
-			to_reference_date,
-		)
-		queries.append(query)
+		je_amount_matching = get_je_matching_query(amount_condition, transaction)
+		queries.extend([je_amount_matching])
 
-	if transaction.deposit > 0.0 and "sales_invoice" in document_types:
-		query = get_si_matching_query(exact_match)
-		queries.append(query)
+	if transaction.deposit > 0 and "sales_invoice" in document_types:
+		si_amount_matching = get_si_matching_query(amount_condition)
+		queries.extend([si_amount_matching])
 
-	if transaction.withdrawal > 0.0:
+	if transaction.withdrawal > 0:
 		if "purchase_invoice" in document_types:
-			query = get_pi_matching_query(exact_match)
-			queries.append(query)
-
-	if "bank_transaction" in document_types:
-		query = get_bt_matching_query(exact_match, transaction)
-		queries.append(query)
+			pi_amount_matching = get_pi_matching_query(amount_condition)
+			queries.extend([pi_amount_matching])
 
 	return queries
 
 
-def get_loan_vouchers(bank_account, transaction, document_types, filters, exact_match):
+def get_loan_vouchers(bank_account, transaction, document_types, filters):
 	vouchers = []
+	amount_condition = True if "exact_match" in document_types else False
 
-	if transaction.withdrawal > 0.0 and "loan_disbursement" in document_types:
-		vouchers.extend(get_ld_matching_query(bank_account, exact_match, filters))
+	if transaction.withdrawal > 0 and "loan_disbursement" in document_types:
+		vouchers.extend(get_ld_matching_query(bank_account, amount_condition, filters))
 
-	if transaction.deposit > 0.0 and "loan_repayment" in document_types:
-		vouchers.extend(get_lr_matching_query(bank_account, exact_match, filters))
+	if transaction.deposit > 0 and "loan_repayment" in document_types:
+		vouchers.extend(get_lr_matching_query(bank_account, amount_condition, filters))
 
 	return vouchers
 
 
-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
-	field = "deposit" if transaction.withdrawal > 0.0 else "withdrawal"
-
-	return f"""
-
-		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_ld_matching_query(bank_account, exact_match, filters):
+def get_ld_matching_query(bank_account, amount_condition, filters):
 	loan_disbursement = frappe.qb.DocType("Loan Disbursement")
 	matching_reference = loan_disbursement.reference_number == filters.get("reference_number")
 	matching_party = loan_disbursement.applicant_type == filters.get(
@@ -619,17 +453,17 @@ def get_ld_matching_query(bank_account, exact_match, filters):
 		.where(loan_disbursement.disbursement_account == bank_account)
 	)
 
-	if exact_match:
+	if amount_condition:
 		query.where(loan_disbursement.disbursed_amount == filters.get("amount"))
 	else:
-		query.where(loan_disbursement.disbursed_amount > 0.0)
+		query.where(loan_disbursement.disbursed_amount <= filters.get("amount"))
 
 	vouchers = query.run(as_list=True)
 
 	return vouchers
 
 
-def get_lr_matching_query(bank_account, exact_match, filters):
+def get_lr_matching_query(bank_account, amount_condition, filters):
 	loan_repayment = frappe.qb.DocType("Loan Repayment")
 	matching_reference = loan_repayment.reference_number == filters.get("reference_number")
 	matching_party = loan_repayment.applicant_type == filters.get(
@@ -660,129 +494,88 @@ def get_lr_matching_query(bank_account, exact_match, filters):
 	if frappe.db.has_column("Loan Repayment", "repay_from_salary"):
 		query = query.where((loan_repayment.repay_from_salary == 0))
 
-	if exact_match:
+	if amount_condition:
 		query.where(loan_repayment.amount_paid == filters.get("amount"))
 	else:
-		query.where(loan_repayment.amount_paid > 0.0)
+		query.where(loan_repayment.amount_paid <= filters.get("amount"))
 
 	vouchers = query.run()
 
 	return vouchers
 
 
-def get_pe_matching_query(
-	exact_match,
-	account_from_to,
-	transaction,
-	from_date,
-	to_date,
-	filter_by_reference_date,
-	from_reference_date,
-	to_reference_date,
-):
+def get_pe_matching_query(amount_condition, account_from_to, transaction):
 	# get matching payment entries query
-	if transaction.deposit > 0.0:
+	if transaction.deposit > 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 = f"AND reference_date between '{from_reference_date}' and '{to_reference_date}'"
-		order_by = " reference_date"
-	if frappe.flags.auto_reconcile_vouchers == True:
-		filter_by_reference_no = f"AND reference_no = '{transaction.reference_number}'"
 	return f"""
-		SELECT
-			(CASE WHEN reference_no=%(reference_no)s THEN 1 ELSE 0 END
-			+ CASE WHEN (party_type = %(party_type)s AND party = %(party)s ) THEN 1 ELSE 0 END
-			+ CASE WHEN paid_amount = %(amount)s THEN 1 ELSE 0 END
-			+ 1 ) AS rank,
-			'Payment Entry' as doctype,
-			name,
-			paid_amount,
-			reference_no,
-			reference_date,
-			party,
-			party_type,
-			posting_date,
-			{currency_field}
-		FROM
-			`tabPayment Entry`
-		WHERE
-			docstatus = 1
-			AND payment_type IN (%(payment_type)s, 'Internal Transfer')
-			AND ifnull(clearance_date, '') = ""
-			AND {account_from_to} = %(bank_account)s
-			AND paid_amount {'= %(amount)s' if exact_match else '> 0.0'}
-			{filter_by_date}
-			{filter_by_reference_no}
-		order by{order_by}
+	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
+		+ 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
+		paid_amount {amount_condition} %(amount)s
+		AND docstatus = 1
+		AND payment_type IN (%(payment_type)s, 'Internal Transfer')
+		AND ifnull(clearance_date, '') = ""
+		AND {account_from_to} = %(bank_account)s
 	"""
 
 
-def get_je_matching_query(
-	exact_match,
-	transaction,
-	from_date,
-	to_date,
-	filter_by_reference_date,
-	from_reference_date,
-	to_reference_date,
-):
+def get_je_matching_query(amount_condition, transaction):
 	# get matching journal entry query
+
 	# We have mapping at the bank level
 	# So one bank could have both types of bank accounts like asset and liability
 	# So cr_or_dr should be judged only on basis of withdrawal and deposit and not account type
-	cr_or_dr = "credit" if transaction.withdrawal > 0.0 else "debit"
-	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 = 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}'"
+	cr_or_dr = "credit" if transaction.withdrawal > 0 else "debit"
+
 	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,
+			'Journal Entry' as doctype,
 			je.name,
-			jea.{cr_or_dr}_in_account_currency AS paid_amount,
-			je.cheque_no AS reference_no,
-			je.cheque_date AS reference_date,
-			je.pay_to_recd_from AS party,
+			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
+			jea.account_currency as currency
 		FROM
-			`tabJournal Entry Account` AS jea
+			`tabJournal Entry Account` as jea
 		JOIN
-			`tabJournal Entry` AS je
+			`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')
+			(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 jea.{cr_or_dr}_in_account_currency {amount_condition} %(amount)s
 			AND je.docstatus = 1
-			{filter_by_date}
-			{filter_by_reference_no}
-			order by {order_by}
 	"""
 
 
-def get_si_matching_query(exact_match):
-	# get matching sales invoice query
+def get_si_matching_query(amount_condition):
+	# get matchin sales invoice query
 	return f"""
 		SELECT
-			( CASE WHEN si.customer = %(party)s  THEN 1 ELSE 0 END
-			+ CASE WHEN sip.amount = %(amount)s THEN 1 ELSE 0 END
+			( CASE WHEN si.customer = %(party)s  THEN 1 ELSE 0  END
 			+ 1 ) AS rank,
 			'Sales Invoice' as doctype,
 			si.name,
@@ -800,20 +593,18 @@ def get_si_matching_query(exact_match):
 			`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')
+		WHERE (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'}
+			AND sip.amount {amount_condition} %(amount)s
+			AND si.docstatus = 1
 	"""
 
 
-def get_pi_matching_query(exact_match):
-	# get matching purchase invoice query when they are also used as payment entries (is_paid)
+def get_pi_matching_query(amount_condition):
+	# get matching purchase invoice 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,
@@ -827,9 +618,9 @@ def get_pi_matching_query(exact_match):
 		FROM
 			`tabPurchase Invoice`
 		WHERE
-			docstatus = 1
+			paid_amount {amount_condition} %(amount)s
+			AND 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'}
+			AND cash_bank_account  = %(bank_account)s
 	"""

erpnext/accounts/doctype/bank_transaction/bank_transaction.js

@@ -12,13 +12,8 @@ frappe.ui.form.on("Bank Transaction", {
 			};
 		});
 	},
-	refresh(frm) {
-		frm.add_custom_button(__('Unreconcile Transaction'), () => {
-			frm.call('remove_payment_entries')
-			.then( () => frm.refresh() );
-		});
-	},
-	bank_account: function (frm) {
+
+	bank_account: function(frm) {
 		set_bank_statement_filter(frm);
 	},
 
@@ -39,7 +34,6 @@ frappe.ui.form.on("Bank Transaction", {
 			"Journal Entry",
 			"Sales Invoice",
 			"Purchase Invoice",
-			"Bank Transaction",
 		];
 	}
 });
@@ -55,7 +49,7 @@ const update_clearance_date = (frm, cdt, cdn) => {
 		frappe
 			.xcall(
 				"erpnext.accounts.doctype.bank_transaction.bank_transaction.unclear_reference_payment",
-				{ doctype: cdt, docname: cdn, bt_name: frm.doc.name }
+				{ doctype: cdt, docname: cdn }
 			)
 			.then((e) => {
 				if (e == "success") {

erpnext/accounts/doctype/bank_transaction/bank_transaction.json

@@ -20,11 +20,9 @@
   "currency",
   "section_break_10",
   "description",
-  "reference_number",
-  "column_break_10",
-  "transaction_id",
-  "transaction_type",
   "section_break_14",
+  "reference_number",
+  "transaction_id",
   "payment_entries",
   "section_break_18",
   "allocated_amount",
@@ -192,21 +190,11 @@
    "label": "Withdrawal",
    "oldfieldname": "credit",
    "options": "currency"
-  },
-  {
-   "fieldname": "column_break_10",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "transaction_type",
-   "fieldtype": "Data",
-   "label": "Transaction Type",
-   "length": 50
   }
  ],
  "is_submittable": 1,
  "links": [],
- "modified": "2022-05-29 18:36:50.475964",
+ "modified": "2022-03-21 19:05:04.208222",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Transaction",
@@ -260,4 +248,4 @@
  "states": [],
  "title_field": "bank_account",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -1,6 +1,9 @@
 # Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
 # For license information, please see license.txt
 
+
+from functools import reduce
+
 import frappe
 from frappe.utils import flt
 
@@ -15,135 +18,72 @@ class BankTransaction(StatusUpdater):
 		self.clear_linked_payment_entries()
 		self.set_status()
 
-	_saving_flag = False
-
-	# nosemgrep: frappe-semgrep-rules.rules.frappe-modifying-but-not-comitting
 	def on_update_after_submit(self):
-		"Run on save(). Avoid recursion caused by multiple saves"
-		if not self._saving_flag:
-			self._saving_flag = True
-			self.clear_linked_payment_entries()
-			self.update_allocations()
-			self._saving_flag = False
+		self.update_allocations()
+		self.clear_linked_payment_entries()
+		self.set_status(update=True)
 
 	def on_cancel(self):
 		self.clear_linked_payment_entries(for_cancel=True)
 		self.set_status(update=True)
 
 	def update_allocations(self):
-		"The doctype does not allow modifications after submission, so write to the db direct"
 		if self.payment_entries:
-			allocated_amount = sum(p.allocated_amount for p in self.payment_entries)
+			allocated_amount = reduce(
+				lambda x, y: flt(x) + flt(y), [x.allocated_amount for x in self.payment_entries]
+			)
 		else:
-			allocated_amount = 0.0
+			allocated_amount = 0
 
-		amount = abs(flt(self.withdrawal) - flt(self.deposit))
-		self.db_set("allocated_amount", flt(allocated_amount))
-		self.db_set("unallocated_amount", amount - flt(allocated_amount))
-		self.reload()
-		self.set_status(update=True)
+		if allocated_amount:
+			frappe.db.set_value(self.doctype, self.name, "allocated_amount", flt(allocated_amount))
+			frappe.db.set_value(
+				self.doctype,
+				self.name,
+				"unallocated_amount",
+				abs(flt(self.withdrawal) - flt(self.deposit)) - flt(allocated_amount),
+			)
 
-	def add_payment_entries(self, vouchers):
-		"Add the vouchers with zero allocation. Save() will perform the allocations and clearance"
-		if 0.0 >= self.unallocated_amount:
-			frappe.throw(frappe._("Bank Transaction {0} is already fully reconciled").format(self.name))
+		else:
+			frappe.db.set_value(self.doctype, self.name, "allocated_amount", 0)
+			frappe.db.set_value(
+				self.doctype, self.name, "unallocated_amount", abs(flt(self.withdrawal) - flt(self.deposit))
+			)
 
-		added = False
-		for voucher in vouchers:
-			# Can't add same voucher twice
-			found = False
-			for pe in self.payment_entries:
-				if (
-					pe.payment_document == voucher["payment_doctype"]
-					and pe.payment_entry == voucher["payment_name"]
-				):
-					found = True
-
-			if not found:
-				pe = {
-					"payment_document": voucher["payment_doctype"],
-					"payment_entry": voucher["payment_name"],
-					"allocated_amount": 0.0,  # Temporary
-				}
-				child = self.append("payment_entries", pe)
-				added = True
-
-		# runs on_update_after_submit
-		if added:
-			self.save()
-
-	def allocate_payment_entries(self):
-		"""Refactored from bank reconciliation tool.
-		Non-zero allocations must be amended/cleared manually
-		Get the bank transaction amount (b) and remove as we allocate
-		For each payment_entry if allocated_amount == 0:
-		- get the amount already allocated against all transactions (t), need latest date
-		- get the voucher amount (from gl) (v)
-		- allocate (a = v - t)
-		    - a = 0: should already be cleared, so clear & remove payment_entry
-		    - 0 < a <= u: allocate a & clear
-		    - 0 < a, a > u: allocate u
-		    - 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:
-				unallocated_amount, should_clear, latest_transaction = get_clearance_details(
-					self, payment_entry
-				)
-
-				if 0.0 == unallocated_amount:
-					if should_clear:
-						latest_transaction.clear_linked_payment_entry(payment_entry)
-					self.db_delete_payment_entry(payment_entry)
-
-				elif remaining_amount <= 0.0:
-					self.db_delete_payment_entry(payment_entry)
-
-				elif 0.0 < unallocated_amount and unallocated_amount <= remaining_amount:
-					payment_entry.db_set("allocated_amount", unallocated_amount)
-					remaining_amount -= unallocated_amount
-					if should_clear:
-						latest_transaction.clear_linked_payment_entry(payment_entry)
-
-				elif 0.0 < unallocated_amount and unallocated_amount > remaining_amount:
-					payment_entry.db_set("allocated_amount", remaining_amount)
-					remaining_amount = 0.0
-
-				elif 0.0 > unallocated_amount:
-					self.db_delete_payment_entry(payment_entry)
-					frappe.throw(frappe._("Voucher {0} is over-allocated by {1}").format(unallocated_amount))
+		amount = self.deposit or self.withdrawal
+		if amount == self.allocated_amount:
+			frappe.db.set_value(self.doctype, self.name, "status", "Reconciled")
 
 		self.reload()
 
-	def db_delete_payment_entry(self, payment_entry):
-		frappe.db.delete("Bank Transaction Payments", {"name": payment_entry.name})
-
-	@frappe.whitelist()
-	def remove_payment_entries(self):
-		for payment_entry in self.payment_entries:
-			self.remove_payment_entry(payment_entry)
-		# runs on_update_after_submit
-		self.save()
-
-	def remove_payment_entry(self, payment_entry):
-		"Clear payment entry and clearance"
-		self.clear_linked_payment_entry(payment_entry, for_cancel=True)
-		self.remove(payment_entry)
-
 	def clear_linked_payment_entries(self, for_cancel=False):
-		if for_cancel:
-			for payment_entry in self.payment_entries:
-				self.clear_linked_payment_entry(payment_entry, for_cancel)
-		else:
-			self.allocate_payment_entries()
+		for payment_entry in self.payment_entries:
+			if payment_entry.payment_document == "Sales Invoice":
+				self.clear_sales_invoice(payment_entry, for_cancel=for_cancel)
+			elif payment_entry.payment_document in get_doctypes_for_bank_reconciliation():
+				self.clear_simple_entry(payment_entry, for_cancel=for_cancel)
 
-	def clear_linked_payment_entry(self, payment_entry, for_cancel=False):
-		clearance_date = None if for_cancel else self.date
-		set_voucher_clearance(
-			payment_entry.payment_document, payment_entry.payment_entry, clearance_date, self
+	def clear_simple_entry(self, payment_entry, for_cancel=False):
+		if payment_entry.payment_document == "Payment Entry":
+			if (
+				frappe.db.get_value("Payment Entry", payment_entry.payment_entry, "payment_type")
+				== "Internal Transfer"
+			):
+				if len(get_reconciled_bank_transactions(payment_entry)) < 2:
+					return
+
+		clearance_date = self.date if not for_cancel else None
+		frappe.db.set_value(
+			payment_entry.payment_document, payment_entry.payment_entry, "clearance_date", clearance_date
+		)
+
+	def clear_sales_invoice(self, payment_entry, for_cancel=False):
+		clearance_date = self.date if not for_cancel else None
+		frappe.db.set_value(
+			"Sales Invoice Payment",
+			dict(parenttype=payment_entry.payment_document, parent=payment_entry.payment_entry),
+			"clearance_date",
+			clearance_date,
 		)
 
 
@@ -153,114 +93,38 @@ def get_doctypes_for_bank_reconciliation():
 	return frappe.get_hooks("bank_reconciliation_doctypes")
 
 
-def get_clearance_details(transaction, payment_entry):
-	"""
-	There should only be one bank gle for a voucher.
-	Could be none for a Bank Transaction.
-	But if a JE, could affect two banks.
-	Should only clear the voucher if all bank gles are allocated.
-	"""
-	gl_bank_account = frappe.db.get_value("Bank Account", transaction.bank_account, "account")
-	gles = get_related_bank_gl_entries(payment_entry.payment_document, payment_entry.payment_entry)
-	bt_allocations = get_total_allocated_amount(
-		payment_entry.payment_document, payment_entry.payment_entry
+def get_reconciled_bank_transactions(payment_entry):
+	reconciled_bank_transactions = frappe.get_all(
+		"Bank Transaction Payments",
+		filters={"payment_entry": payment_entry.payment_entry},
+		fields=["parent"],
 	)
 
-	unallocated_amount = min(
-		transaction.unallocated_amount,
-		get_paid_amount(payment_entry, transaction.currency, gl_bank_account),
-	)
-	unmatched_gles = len(gles)
-	latest_transaction = transaction
-	for gle in gles:
-		if gle["gl_account"] == gl_bank_account:
-			if gle["amount"] <= 0.0:
-				frappe.throw(
-					frappe._("Voucher {0} value is broken: {1}").format(
-						payment_entry.payment_entry, gle["amount"]
-					)
-				)
-
-			unmatched_gles -= 1
-			unallocated_amount = gle["amount"]
-			for a in bt_allocations:
-				if a["gl_account"] == gle["gl_account"]:
-					unallocated_amount = gle["amount"] - a["total"]
-					if frappe.utils.getdate(transaction.date) < a["latest_date"]:
-						latest_transaction = frappe.get_doc("Bank Transaction", a["latest_name"])
-		else:
-			# Must be a Journal Entry affecting more than one bank
-			for a in bt_allocations:
-				if a["gl_account"] == gle["gl_account"] and a["total"] == gle["amount"]:
-					unmatched_gles -= 1
-
-	return unallocated_amount, unmatched_gles == 0, latest_transaction
+	return reconciled_bank_transactions
 
 
-def get_related_bank_gl_entries(doctype, docname):
-	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
-	result = frappe.db.sql(
+def get_total_allocated_amount(payment_entry):
+	return frappe.db.sql(
 		"""
 		SELECT
-			ABS(gle.credit_in_account_currency - gle.debit_in_account_currency) AS amount,
-			gle.account AS gl_account
+			SUM(btp.allocated_amount) as allocated_amount,
+			bt.name
 		FROM
-			`tabGL Entry` gle
+			`tabBank Transaction Payments` as btp
 		LEFT JOIN
-			`tabAccount` ac ON ac.name=gle.account
+			`tabBank Transaction` bt ON bt.name=btp.parent
 		WHERE
-			ac.account_type = 'Bank'
-			AND gle.voucher_type = %(doctype)s
-			AND gle.voucher_no = %(docname)s
-			AND is_cancelled = 0
-		""",
-		dict(doctype=doctype, docname=docname),
+			btp.payment_document = %s
+		AND
+			btp.payment_entry = %s
+		AND
+			bt.docstatus = 1""",
+		(payment_entry.payment_document, payment_entry.payment_entry),
 		as_dict=True,
 	)
-	return result
 
 
-def get_total_allocated_amount(doctype, docname):
-	"""
-	Gets the sum of allocations for a voucher on each bank GL account
-	along with the latest bank transaction name & date
-	NOTE: query may also include just saved vouchers/payments but with zero allocated_amount
-	"""
-	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
-	result = frappe.db.sql(
-		"""
-		SELECT total, latest_name, latest_date, gl_account FROM (
-			SELECT
-				ROW_NUMBER() OVER w AS rownum,
-				SUM(btp.allocated_amount) OVER(PARTITION BY ba.account) AS total,
-				FIRST_VALUE(bt.name) OVER w AS latest_name,
-				FIRST_VALUE(bt.date) OVER w AS latest_date,
-				ba.account AS gl_account
-			FROM
-				`tabBank Transaction Payments` btp
-			LEFT JOIN `tabBank Transaction` bt ON bt.name=btp.parent
-			LEFT JOIN `tabBank Account` ba ON ba.name=bt.bank_account
-			WHERE
-				btp.payment_document = %(doctype)s
-				AND btp.payment_entry = %(docname)s
-				AND bt.docstatus = 1
-			WINDOW w AS (PARTITION BY ba.account ORDER BY bt.date desc)
-		) temp
-		WHERE
-			rownum = 1
-		""",
-		dict(doctype=doctype, docname=docname),
-		as_dict=True,
-	)
-	for row in result:
-		# Why is this *sometimes* a byte string?
-		if isinstance(row["latest_name"], bytes):
-			row["latest_name"] = row["latest_name"].decode()
-		row["latest_date"] = frappe.utils.getdate(row["latest_date"])
-	return result
-
-
-def get_paid_amount(payment_entry, currency, gl_bank_account):
+def get_paid_amount(payment_entry, currency, bank_account):
 	if payment_entry.payment_document in ["Payment Entry", "Sales Invoice", "Purchase Invoice"]:
 
 		paid_amount_field = "paid_amount"
@@ -273,7 +137,7 @@ def get_paid_amount(payment_entry, currency, gl_bank_account):
 				)
 			elif doc.payment_type == "Pay":
 				paid_amount_field = (
-					"paid_amount" if doc.paid_from_account_currency == currency else "base_paid_amount"
+					"paid_amount" if doc.paid_to_account_currency == currency else "base_paid_amount"
 				)
 
 		return frappe.db.get_value(
@@ -283,7 +147,7 @@ def get_paid_amount(payment_entry, currency, gl_bank_account):
 	elif payment_entry.payment_document == "Journal Entry":
 		return frappe.db.get_value(
 			"Journal Entry Account",
-			{"parent": payment_entry.payment_entry, "account": gl_bank_account},
+			{"parent": payment_entry.payment_entry, "account": bank_account},
 			"sum(credit_in_account_currency)",
 		)
 
@@ -302,12 +166,6 @@ def get_paid_amount(payment_entry, currency, gl_bank_account):
 			payment_entry.payment_document, payment_entry.payment_entry, "amount_paid"
 		)
 
-	elif payment_entry.payment_document == "Bank Transaction":
-		dep, wth = frappe.db.get_value(
-			"Bank Transaction", payment_entry.payment_entry, ("deposit", "withdrawal")
-		)
-		return abs(flt(wth) - flt(dep))
-
 	else:
 		frappe.throw(
 			"Please reconcile {0}: {1} manually".format(
@@ -316,55 +174,18 @@ def get_paid_amount(payment_entry, currency, gl_bank_account):
 		)
 
 
-def set_voucher_clearance(doctype, docname, clearance_date, self):
-	if doctype in [
-		"Payment Entry",
-		"Journal Entry",
-		"Purchase Invoice",
-		"Expense Claim",
-		"Loan Repayment",
-		"Loan Disbursement",
-	]:
-		if (
-			doctype == "Payment Entry"
-			and frappe.db.get_value("Payment Entry", docname, "payment_type") == "Internal Transfer"
-			and len(get_reconciled_bank_transactions(doctype, docname)) < 2
-		):
-			return
-		frappe.db.set_value(doctype, docname, "clearance_date", clearance_date)
-
-	elif doctype == "Sales Invoice":
-		frappe.db.set_value(
-			"Sales Invoice Payment",
-			dict(parenttype=doctype, parent=docname),
-			"clearance_date",
-			clearance_date,
-		)
-
-	elif doctype == "Bank Transaction":
-		# For when a second bank transaction has fixed another, e.g. refund
-		bt = frappe.get_doc(doctype, docname)
-		if clearance_date:
-			vouchers = [{"payment_doctype": "Bank Transaction", "payment_name": self.name}]
-			bt.add_payment_entries(vouchers)
-		else:
-			for pe in bt.payment_entries:
-				if pe.payment_document == self.doctype and pe.payment_entry == self.name:
-					bt.remove(pe)
-					bt.save()
-					break
-
-
-def get_reconciled_bank_transactions(doctype, docname):
-	return frappe.get_all(
-		"Bank Transaction Payments",
-		filters={"payment_document": doctype, "payment_entry": docname},
-		pluck="parent",
-	)
-
-
 @frappe.whitelist()
-def unclear_reference_payment(doctype, docname, bt_name):
-	bt = frappe.get_doc("Bank Transaction", bt_name)
-	set_voucher_clearance(doctype, docname, None, bt)
-	return docname
+def unclear_reference_payment(doctype, docname):
+	if frappe.db.exists(doctype, docname):
+		doc = frappe.get_doc(doctype, docname)
+		if doctype == "Sales Invoice":
+			frappe.db.set_value(
+				"Sales Invoice Payment",
+				dict(parenttype=doc.payment_document, parent=doc.payment_entry),
+				"clearance_date",
+				None,
+			)
+		else:
+			frappe.db.set_value(doc.payment_document, doc.payment_entry, "clearance_date", None)
+
+		return doc.payment_entry

erpnext/accounts/doctype/bank_transaction/test_bank_transaction.py

@@ -5,7 +5,6 @@ import json
 import unittest
 
 import frappe
-from frappe import utils
 from frappe.tests.utils import FrappeTestCase
 
 from erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool import (
@@ -41,12 +40,7 @@ class TestBankTransaction(FrappeTestCase):
 			"Bank Transaction",
 			dict(description="Re 95282925234 FE/000002917 AT171513000281183046 Conrad Electronic"),
 		)
-		linked_payments = get_linked_payments(
-			bank_transaction.name,
-			["payment_entry", "exact_match"],
-			from_date=bank_transaction.date,
-			to_date=utils.today(),
-		)
+		linked_payments = get_linked_payments(bank_transaction.name, ["payment_entry", "exact_match"])
 		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
@@ -87,12 +81,7 @@ class TestBankTransaction(FrappeTestCase):
 			"Bank Transaction",
 			dict(description="Auszahlung Karte MC/000002916 AUTOMAT 698769 K002 27.10. 14:07"),
 		)
-		linked_payments = get_linked_payments(
-			bank_transaction.name,
-			["payment_entry", "exact_match"],
-			from_date=bank_transaction.date,
-			to_date=utils.today(),
-		)
+		linked_payments = get_linked_payments(bank_transaction.name, ["payment_entry", "exact_match"])
 		self.assertTrue(linked_payments[0][3])
 
 	# Check error if already reconciled

erpnext/accounts/doctype/budget/budget.py

@@ -184,11 +184,6 @@ def validate_budget_records(args, budget_records, expense_amount):
 			amount = expense_amount or get_amount(args, budget)
 			yearly_action, monthly_action = get_actions(args, budget)
 
-			if yearly_action in ("Stop", "Warn"):
-				compare_expense_with_budget(
-					args, flt(budget.budget_amount), _("Annual"), yearly_action, budget.budget_against, amount
-				)
-
 			if monthly_action in ["Stop", "Warn"]:
 				budget_amount = get_accumulated_monthly_budget(
 					budget.monthly_distribution, args.posting_date, args.fiscal_year, budget.budget_amount
@@ -200,28 +195,28 @@ def validate_budget_records(args, budget_records, expense_amount):
 					args, budget_amount, _("Accumulated Monthly"), monthly_action, budget.budget_against, amount
 				)
 
+			if (
+				yearly_action in ("Stop", "Warn")
+				and monthly_action != "Stop"
+				and yearly_action != monthly_action
+			):
+				compare_expense_with_budget(
+					args, flt(budget.budget_amount), _("Annual"), yearly_action, budget.budget_against, amount
+				)
+
 
 def compare_expense_with_budget(args, budget_amount, action_for, action, budget_against, amount=0):
-	actual_expense = get_actual_expense(args)
-	total_expense = actual_expense + amount
-
-	if total_expense > budget_amount:
-		if actual_expense > budget_amount:
-			error_tense = _("is already")
-			diff = actual_expense - budget_amount
-		else:
-			error_tense = _("will be")
-			diff = total_expense - budget_amount
-
+	actual_expense = amount or get_actual_expense(args)
+	if actual_expense > budget_amount:
+		diff = actual_expense - budget_amount
 		currency = frappe.get_cached_value("Company", args.company, "default_currency")
 
-		msg = _("{0} Budget for Account {1} against {2} {3} is {4}. It {5} exceed by {6}").format(
+		msg = _("{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5}").format(
 			_(action_for),
 			frappe.bold(args.account),
-			frappe.unscrub(args.budget_against_field),
+			args.budget_against_field,
 			frappe.bold(budget_against),
 			frappe.bold(fmt_money(budget_amount, currency=currency)),
-			error_tense,
 			frappe.bold(fmt_money(diff, currency=currency)),
 		)
 
@@ -232,9 +227,9 @@ def compare_expense_with_budget(args, budget_amount, action_for, action, budget_
 			action = "Warn"
 
 		if action == "Stop":
-			frappe.throw(msg, BudgetError, title=_("Budget Exceeded"))
+			frappe.throw(msg, BudgetError)
 		else:
-			frappe.msgprint(msg, indicator="orange", title=_("Budget Exceeded"))
+			frappe.msgprint(msg, indicator="orange")
 
 
 def get_actions(args, budget):
@@ -356,9 +351,7 @@ def get_actual_expense(args):
 			"""
 		select sum(gle.debit) - sum(gle.credit)
 		from `tabGL Entry` gle
-		where
-			is_cancelled = 0
-			and gle.account=%(account)s
+		where gle.account=%(account)s
 			{condition1}
 			and gle.fiscal_year=%(fiscal_year)s
 			and gle.company=%(company)s

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -36,7 +36,7 @@ def validate_columns(data):
 
 	no_of_columns = max([len(d) for d in data])
 
-	if no_of_columns > 8:
+	if no_of_columns > 7:
 		frappe.throw(
 			_("More columns found than expected. Please compare the uploaded file with standard template"),
 			title=(_("Wrong Template")),
@@ -233,7 +233,6 @@ def build_forest(data):
 			is_group,
 			account_type,
 			root_type,
-			account_currency,
 		) = i
 
 		if not account_name:
@@ -254,8 +253,6 @@ def build_forest(data):
 			charts_map[account_name]["account_type"] = account_type
 		if root_type:
 			charts_map[account_name]["root_type"] = root_type
-		if account_currency:
-			charts_map[account_name]["account_currency"] = account_currency
 		path = return_parent(data, account_name)[::-1]
 		paths.append(path)  # List of path is created
 		line_no += 1
@@ -318,21 +315,20 @@ def get_template(template_type):
 		"Is Group",
 		"Account Type",
 		"Root Type",
-		"Account Currency",
 	]
 	writer = UnicodeWriter()
 	writer.writerow(fields)
 
 	if template_type == "Blank Template":
 		for root_type in get_root_types():
-			writer.writerow(["", "", "", "", 1, "", root_type])
+			writer.writerow(["", "", "", 1, "", root_type])
 
 		for account in get_mandatory_group_accounts():
-			writer.writerow(["", "", "", "", 1, account, "Asset"])
+			writer.writerow(["", "", "", 1, account, "Asset"])
 
 		for account_type in get_mandatory_account_types():
 			writer.writerow(
-				["", "", "", "", 0, account_type.get("account_type"), account_type.get("root_type")]
+				["", "", "", 0, account_type.get("account_type"), account_type.get("root_type")]
 			)
 	else:
 		writer = get_sample_template(writer)
@@ -489,10 +485,6 @@ def set_default_accounts(company):
 			"default_payable_account": frappe.db.get_value(
 				"Account", {"company": company.name, "account_type": "Payable", "is_group": 0}
 			),
-			"default_provisional_account": frappe.db.get_value(
-				"Account",
-				{"company": company.name, "account_type": "Service Received But Not Billed", "is_group": 0},
-			),
 		}
 	)
 

erpnext/accounts/doctype/cost_center_allocation/cost_center_allocation.py

@@ -28,14 +28,9 @@ class InvalidDateError(frappe.ValidationError):
 
 
 class CostCenterAllocation(Document):
-	def __init__(self, *args, **kwargs):
-		super(CostCenterAllocation, self).__init__(*args, **kwargs)
-		self._skip_from_date_validation = False
-
 	def validate(self):
 		self.validate_total_allocation_percentage()
-		if not self._skip_from_date_validation:
-			self.validate_from_date_based_on_existing_gle()
+		self.validate_from_date_based_on_existing_gle()
 		self.validate_backdated_allocation()
 		self.validate_main_cost_center()
 		self.validate_child_cost_centers()

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.json

@@ -6,7 +6,6 @@
  "engine": "InnoDB",
  "field_order": [
   "api_details_section",
-  "disabled",
   "service_provider",
   "api_endpoint",
   "url",
@@ -78,18 +77,12 @@
    "label": "Service Provider",
    "options": "frankfurter.app\nexchangerate.host\nCustom",
    "reqd": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "disabled",
-   "fieldtype": "Check",
-   "label": "Disabled"
   }
  ],
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-01-09 12:19:03.955906",
+ "modified": "2022-01-10 15:51:14.521174",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Currency Exchange Settings",

erpnext/accounts/doctype/dunning/dunning.py

@@ -40,7 +40,7 @@ class Dunning(AccountsController):
 
 	def on_cancel(self):
 		if self.dunning_amount:
-			self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry", "Payment Ledger Entry")
+			self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry")
 			make_reverse_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
 
 	def make_gl_entries(self):

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js

@@ -26,7 +26,7 @@ frappe.ui.form.on('Exchange Rate Revaluation', {
 				doc: frm.doc,
 				callback: function(r) {
 					if (r.message) {
-						frm.add_custom_button(__('Journal Entries'), function() {
+						frm.add_custom_button(__('Journal Entry'), function() {
 							return frm.events.make_jv(frm);
 						}, __('Create'));
 					}
@@ -35,11 +35,10 @@ frappe.ui.form.on('Exchange Rate Revaluation', {
 		}
 	},
 
-	get_entries: function(frm, account) {
+	get_entries: function(frm) {
 		frappe.call({
 			method: "get_accounts_data",
 			doc: cur_frm.doc,
-			account: account,
 			callback: function(r){
 				frappe.model.clear_table(frm.doc, "accounts");
 				if(r.message) {
@@ -58,6 +57,7 @@ frappe.ui.form.on('Exchange Rate Revaluation', {
 
 		let total_gain_loss = 0;
 		frm.doc.accounts.forEach((d) => {
+			d.gain_loss = flt(d.new_balance_in_base_currency, precision("new_balance_in_base_currency", d)) - flt(d.balance_in_base_currency, precision("balance_in_base_currency", d));
 			total_gain_loss += flt(d.gain_loss, precision("gain_loss", d));
 		});
 
@@ -66,19 +66,13 @@ frappe.ui.form.on('Exchange Rate Revaluation', {
 	},
 
 	make_jv : function(frm) {
-		let revaluation_journal = null;
-		let zero_balance_journal = null;
 		frappe.call({
-			method: "make_jv_entries",
+			method: "make_jv_entry",
 			doc: frm.doc,
-			freeze: true,
-			freeze_message: "Making Journal Entries...",
 			callback: function(r){
 				if (r.message) {
-					let response = r.message;
-					if(response['revaluation_jv'] || response['zero_balance_jv']) {
-						frappe.msgprint(__("Journals have been created"));
-					}
+					var doc = frappe.model.sync(r.message)[0];
+					frappe.set_route("Form", doc.doctype, doc.name);
 				}
 			}
 		});

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.json

@@ -14,9 +14,6 @@
   "get_entries",
   "accounts",
   "section_break_6",
-  "gain_loss_unbooked",
-  "gain_loss_booked",
-  "column_break_10",
   "total_gain_loss",
   "amended_from"
  ],
@@ -62,30 +59,6 @@
    "fieldname": "section_break_6",
    "fieldtype": "Section Break"
   },
-  {
-   "fieldname": "amended_from",
-   "fieldtype": "Link",
-   "label": "Amended From",
-   "no_copy": 1,
-   "options": "Exchange Rate Revaluation",
-   "print_hide": 1,
-   "read_only": 1
-  },
-  {
-   "fieldname": "gain_loss_unbooked",
-   "fieldtype": "Currency",
-   "label": "Gain/Loss from Revaluation",
-   "options": "Company:company:default_currency",
-   "read_only": 1
-  },
-  {
-   "description": "Gain/Loss accumulated in foreign currency account. Accounts with '0' balance in either Base or Account currency",
-   "fieldname": "gain_loss_booked",
-   "fieldtype": "Currency",
-   "label": "Gain/Loss already booked",
-   "options": "Company:company:default_currency",
-   "read_only": 1
-  },
   {
    "fieldname": "total_gain_loss",
    "fieldtype": "Currency",
@@ -94,13 +67,18 @@
    "read_only": 1
   },
   {
-   "fieldname": "column_break_10",
-   "fieldtype": "Column Break"
+   "fieldname": "amended_from",
+   "fieldtype": "Link",
+   "label": "Amended From",
+   "no_copy": 1,
+   "options": "Exchange Rate Revaluation",
+   "print_hide": 1,
+   "read_only": 1
   }
  ],
  "is_submittable": 1,
  "links": [],
- "modified": "2022-12-29 19:38:24.416529",
+ "modified": "2022-11-17 10:28:03.911554",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Exchange Rate Revaluation",

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -3,12 +3,10 @@
 
 
 import frappe
-from frappe import _, qb
+from frappe import _
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
-from frappe.query_builder import Criterion, Order
-from frappe.query_builder.functions import NullIf, Sum
-from frappe.utils import flt, get_link_to_form
+from frappe.utils import flt
 
 import erpnext
 from erpnext.accounts.doctype.journal_entry.journal_entry import get_balance_on
@@ -21,25 +19,11 @@ class ExchangeRateRevaluation(Document):
 
 	def set_total_gain_loss(self):
 		total_gain_loss = 0
-
-		gain_loss_booked = 0
-		gain_loss_unbooked = 0
-
 		for d in self.accounts:
-			if not d.zero_balance:
-				d.gain_loss = flt(
-					d.new_balance_in_base_currency, d.precision("new_balance_in_base_currency")
-				) - flt(d.balance_in_base_currency, d.precision("balance_in_base_currency"))
-
-			if d.zero_balance:
-				gain_loss_booked += flt(d.gain_loss, d.precision("gain_loss"))
-			else:
-				gain_loss_unbooked += flt(d.gain_loss, d.precision("gain_loss"))
-
+			d.gain_loss = flt(
+				d.new_balance_in_base_currency, d.precision("new_balance_in_base_currency")
+			) - flt(d.balance_in_base_currency, d.precision("balance_in_base_currency"))
 			total_gain_loss += flt(d.gain_loss, d.precision("gain_loss"))
-
-		self.gain_loss_booked = gain_loss_booked
-		self.gain_loss_unbooked = gain_loss_unbooked
 		self.total_gain_loss = flt(total_gain_loss, self.precision("total_gain_loss"))
 
 	def validate_mandatory(self):
@@ -51,205 +35,98 @@ class ExchangeRateRevaluation(Document):
 
 	@frappe.whitelist()
 	def check_journal_entry_condition(self):
-		exchange_gain_loss_account = self.get_for_unrealized_gain_loss_account()
-
-		jea = qb.DocType("Journal Entry Account")
-		journals = (
-			qb.from_(jea)
-			.select(jea.parent)
-			.distinct()
-			.where(
-				(jea.reference_type == "Exchange Rate Revaluation")
-				& (jea.reference_name == self.name)
-				& (jea.docstatus == 1)
-			)
-			.run()
+		total_debit = frappe.db.get_value(
+			"Journal Entry Account",
+			{"reference_type": "Exchange Rate Revaluation", "reference_name": self.name, "docstatus": 1},
+			"sum(debit) as sum",
 		)
 
-		if journals:
-			gle = qb.DocType("GL Entry")
-			total_amt = (
-				qb.from_(gle)
-				.select((Sum(gle.credit) - Sum(gle.debit)).as_("total_amount"))
-				.where(
-					(gle.voucher_type == "Journal Entry")
-					& (gle.voucher_no.isin(journals))
-					& (gle.account == exchange_gain_loss_account)
-					& (gle.is_cancelled == 0)
-				)
-				.run()
-			)
+		total_amt = 0
+		for d in self.accounts:
+			total_amt = total_amt + d.new_balance_in_base_currency
 
-			if total_amt and total_amt[0][0] != self.total_gain_loss:
-				return True
-			else:
-				return False
+		if total_amt != total_debit:
+			return True
 
-		return True
+		return False
 
 	@frappe.whitelist()
-	def get_accounts_data(self):
-		self.validate_mandatory()
-		account_details = self.get_account_balance_from_gle(
-			company=self.company, posting_date=self.posting_date, account=None, party_type=None, party=None
-		)
-		accounts_with_new_balance = self.calculate_new_account_balance(
-			self.company, self.posting_date, account_details
-		)
-
-		if not accounts_with_new_balance:
-			self.throw_invalid_response_message(account_details)
-
-		return accounts_with_new_balance
-
-	@staticmethod
-	def get_account_balance_from_gle(company, posting_date, account, party_type, party):
-		account_details = []
-
-		if company and posting_date:
-			company_currency = erpnext.get_company_currency(company)
-
-			acc = qb.DocType("Account")
-			if account:
-				accounts = [account]
-			else:
-				res = (
-					qb.from_(acc)
-					.select(acc.name)
-					.where(
-						(acc.is_group == 0)
-						& (acc.report_type == "Balance Sheet")
-						& (acc.root_type.isin(["Asset", "Liability", "Equity"]))
-						& (acc.account_type != "Stock")
-						& (acc.company == company)
-						& (acc.account_currency != company_currency)
-					)
-					.orderby(acc.name)
-					.run(as_list=True)
-				)
-				accounts = [x[0] for x in res]
-
-			if accounts:
-				having_clause = (qb.Field("balance") != qb.Field("balance_in_account_currency")) & (
-					(qb.Field("balance_in_account_currency") != 0) | (qb.Field("balance") != 0)
-				)
-
-				gle = qb.DocType("GL Entry")
-
-				# conditions
-				conditions = []
-				conditions.append(gle.account.isin(accounts))
-				conditions.append(gle.posting_date.lte(posting_date))
-				conditions.append(gle.is_cancelled == 0)
-
-				if party_type:
-					conditions.append(gle.party_type == party_type)
-				if party:
-					conditions.append(gle.party == party)
-
-				account_details = (
-					qb.from_(gle)
-					.select(
-						gle.account,
-						gle.party_type,
-						gle.party,
-						gle.account_currency,
-						(Sum(gle.debit_in_account_currency) - Sum(gle.credit_in_account_currency)).as_(
-							"balance_in_account_currency"
-						),
-						(Sum(gle.debit) - Sum(gle.credit)).as_("balance"),
-						(Sum(gle.debit) - Sum(gle.credit) == 0)
-						^ (Sum(gle.debit_in_account_currency) - Sum(gle.credit_in_account_currency) == 0).as_(
-							"zero_balance"
-						),
-					)
-					.where(Criterion.all(conditions))
-					.groupby(gle.account, NullIf(gle.party_type, ""), NullIf(gle.party, ""))
-					.having(having_clause)
-					.orderby(gle.account)
-					.run(as_dict=True)
-				)
-
-		return account_details
-
-	@staticmethod
-	def calculate_new_account_balance(company, posting_date, account_details):
+	def get_accounts_data(self, account=None):
 		accounts = []
-		company_currency = erpnext.get_company_currency(company)
+		self.validate_mandatory()
+		company_currency = erpnext.get_company_currency(self.company)
 		precision = get_field_precision(
 			frappe.get_meta("Exchange Rate Revaluation Account").get_field("new_balance_in_base_currency"),
 			company_currency,
 		)
 
-		if account_details:
-			# Handle Accounts with balance in both Account/Base Currency
-			for d in [x for x in account_details if not x.zero_balance]:
-				current_exchange_rate = (
-					d.balance / d.balance_in_account_currency if d.balance_in_account_currency else 0
+		account_details = self.get_accounts_from_gle()
+		for d in account_details:
+			current_exchange_rate = (
+				d.balance / d.balance_in_account_currency if d.balance_in_account_currency else 0
+			)
+			new_exchange_rate = get_exchange_rate(d.account_currency, company_currency, self.posting_date)
+			new_balance_in_base_currency = flt(d.balance_in_account_currency * new_exchange_rate)
+			gain_loss = flt(new_balance_in_base_currency, precision) - flt(d.balance, precision)
+			if gain_loss:
+				accounts.append(
+					{
+						"account": d.account,
+						"party_type": d.party_type,
+						"party": d.party,
+						"account_currency": d.account_currency,
+						"balance_in_base_currency": d.balance,
+						"balance_in_account_currency": d.balance_in_account_currency,
+						"current_exchange_rate": current_exchange_rate,
+						"new_exchange_rate": new_exchange_rate,
+						"new_balance_in_base_currency": new_balance_in_base_currency,
+					}
 				)
-				new_exchange_rate = get_exchange_rate(d.account_currency, company_currency, posting_date)
-				new_balance_in_base_currency = flt(d.balance_in_account_currency * new_exchange_rate)
-				gain_loss = flt(new_balance_in_base_currency, precision) - flt(d.balance, precision)
-				if gain_loss:
-					accounts.append(
-						{
-							"account": d.account,
-							"party_type": d.party_type,
-							"party": d.party,
-							"account_currency": d.account_currency,
-							"balance_in_base_currency": d.balance,
-							"balance_in_account_currency": d.balance_in_account_currency,
-							"zero_balance": d.zero_balance,
-							"current_exchange_rate": current_exchange_rate,
-							"new_exchange_rate": new_exchange_rate,
-							"new_balance_in_base_currency": new_balance_in_base_currency,
-							"new_balance_in_account_currency": d.balance_in_account_currency,
-							"gain_loss": gain_loss,
-						}
-					)
 
-			# Handle Accounts with '0' balance in Account/Base Currency
-			for d in [x for x in account_details if x.zero_balance]:
-
-				if d.balance != 0:
-					current_exchange_rate = new_exchange_rate = 0
-
-					new_balance_in_account_currency = 0  # this will be '0'
-					new_balance_in_base_currency = 0  # this will be '0'
-					gain_loss = flt(new_balance_in_base_currency, precision) - flt(d.balance, precision)
-				else:
-					new_exchange_rate = 0
-					new_balance_in_base_currency = 0
-					new_balance_in_account_currency = 0
-
-					current_exchange_rate = calculate_exchange_rate_using_last_gle(
-						company, d.account, d.party_type, d.party
-					)
-
-					gain_loss = new_balance_in_account_currency - (
-						current_exchange_rate * d.balance_in_account_currency
-					)
-
-				if gain_loss:
-					accounts.append(
-						{
-							"account": d.account,
-							"party_type": d.party_type,
-							"party": d.party,
-							"account_currency": d.account_currency,
-							"balance_in_base_currency": d.balance,
-							"balance_in_account_currency": d.balance_in_account_currency,
-							"zero_balance": d.zero_balance,
-							"current_exchange_rate": current_exchange_rate,
-							"new_exchange_rate": new_exchange_rate,
-							"new_balance_in_base_currency": new_balance_in_base_currency,
-							"new_balance_in_account_currency": new_balance_in_account_currency,
-							"gain_loss": gain_loss,
-						}
-					)
+		if not accounts:
+			self.throw_invalid_response_message(account_details)
 
 		return accounts
 
+	def get_accounts_from_gle(self):
+		company_currency = erpnext.get_company_currency(self.company)
+		accounts = frappe.db.sql_list(
+			"""
+			select name
+			from tabAccount
+			where is_group = 0
+				and report_type = 'Balance Sheet'
+				and root_type in ('Asset', 'Liability', 'Equity')
+				and account_type != 'Stock'
+				and company=%s
+				and account_currency != %s
+			order by name""",
+			(self.company, company_currency),
+		)
+
+		account_details = []
+		if accounts:
+			account_details = frappe.db.sql(
+				"""
+				select
+					account, party_type, party, account_currency,
+					sum(debit_in_account_currency) - sum(credit_in_account_currency) as balance_in_account_currency,
+					sum(debit) - sum(credit) as balance
+				from `tabGL Entry`
+				where account in (%s)
+				and posting_date <= %s
+				and is_cancelled = 0
+				group by account, NULLIF(party_type,''), NULLIF(party,'')
+				having sum(debit) != sum(credit)
+				order by account
+			"""
+				% (", ".join(["%s"] * len(accounts)), "%s"),
+				tuple(accounts + [self.posting_date]),
+				as_dict=1,
+			)
+
+		return account_details
+
 	def throw_invalid_response_message(self, account_details):
 		if account_details:
 			message = _("No outstanding invoices require exchange rate revaluation")
@@ -257,7 +134,11 @@ class ExchangeRateRevaluation(Document):
 			message = _("No outstanding invoices found")
 		frappe.msgprint(message)
 
-	def get_for_unrealized_gain_loss_account(self):
+	@frappe.whitelist()
+	def make_jv_entry(self):
+		if self.total_gain_loss == 0:
+			return
+
 		unrealized_exchange_gain_loss_account = frappe.get_cached_value(
 			"Company", self.company, "unrealized_exchange_gain_loss_account"
 		)
@@ -265,130 +146,6 @@ class ExchangeRateRevaluation(Document):
 			frappe.throw(
 				_("Please set Unrealized Exchange Gain/Loss Account in Company {0}").format(self.company)
 			)
-		return unrealized_exchange_gain_loss_account
-
-	@frappe.whitelist()
-	def make_jv_entries(self):
-		zero_balance_jv = self.make_jv_for_zero_balance()
-		if zero_balance_jv:
-			frappe.msgprint(
-				f"Zero Balance Journal: {get_link_to_form('Journal Entry', zero_balance_jv.name)}"
-			)
-
-		revaluation_jv = self.make_jv_for_revaluation()
-		if revaluation_jv:
-			frappe.msgprint(
-				f"Revaluation Journal: {get_link_to_form('Journal Entry', revaluation_jv.name)}"
-			)
-
-		return {
-			"revaluation_jv": revaluation_jv.name if revaluation_jv else None,
-			"zero_balance_jv": zero_balance_jv.name if zero_balance_jv else None,
-		}
-
-	def make_jv_for_zero_balance(self):
-		if self.gain_loss_booked == 0:
-			return
-
-		accounts = [x for x in self.accounts if x.zero_balance]
-
-		if not accounts:
-			return
-
-		unrealized_exchange_gain_loss_account = self.get_for_unrealized_gain_loss_account()
-
-		journal_entry = frappe.new_doc("Journal Entry")
-		journal_entry.voucher_type = "Exchange Gain Or Loss"
-		journal_entry.company = self.company
-		journal_entry.posting_date = self.posting_date
-		journal_entry.multi_currency = 1
-
-		journal_entry_accounts = []
-		for d in accounts:
-			journal_account = frappe._dict(
-				{
-					"account": d.get("account"),
-					"party_type": d.get("party_type"),
-					"party": d.get("party"),
-					"account_currency": d.get("account_currency"),
-					"balance": flt(
-						d.get("balance_in_account_currency"), d.precision("balance_in_account_currency")
-					),
-					"exchange_rate": 0,
-					"cost_center": erpnext.get_default_cost_center(self.company),
-					"reference_type": "Exchange Rate Revaluation",
-					"reference_name": self.name,
-				}
-			)
-
-			# Account Currency has balance
-			if d.get("balance_in_account_currency") and not d.get("new_balance_in_account_currency"):
-				dr_or_cr = (
-					"credit_in_account_currency"
-					if d.get("balance_in_account_currency") > 0
-					else "debit_in_account_currency"
-				)
-				reverse_dr_or_cr = (
-					"debit_in_account_currency"
-					if dr_or_cr == "credit_in_account_currency"
-					else "credit_in_account_currency"
-				)
-				journal_account.update(
-					{
-						dr_or_cr: flt(
-							abs(d.get("balance_in_account_currency")), d.precision("balance_in_account_currency")
-						),
-						reverse_dr_or_cr: 0,
-						"debit": 0,
-						"credit": 0,
-					}
-				)
-			elif d.get("balance_in_base_currency") and not d.get("new_balance_in_base_currency"):
-				# Base currency has balance
-				dr_or_cr = "credit" if d.get("balance_in_base_currency") > 0 else "debit"
-				reverse_dr_or_cr = "debit" if dr_or_cr == "credit" else "credit"
-				journal_account.update(
-					{
-						dr_or_cr: flt(
-							abs(d.get("balance_in_base_currency")), d.precision("balance_in_base_currency")
-						),
-						reverse_dr_or_cr: 0,
-						"debit_in_account_currency": 0,
-						"credit_in_account_currency": 0,
-					}
-				)
-
-			journal_entry_accounts.append(journal_account)
-
-		journal_entry_accounts.append(
-			{
-				"account": unrealized_exchange_gain_loss_account,
-				"balance": get_balance_on(unrealized_exchange_gain_loss_account),
-				"debit": abs(self.gain_loss_booked) if self.gain_loss_booked < 0 else 0,
-				"credit": abs(self.gain_loss_booked) if self.gain_loss_booked > 0 else 0,
-				"debit_in_account_currency": abs(self.gain_loss_booked) if self.gain_loss_booked < 0 else 0,
-				"credit_in_account_currency": self.gain_loss_booked if self.gain_loss_booked > 0 else 0,
-				"cost_center": erpnext.get_default_cost_center(self.company),
-				"exchange_rate": 1,
-				"reference_type": "Exchange Rate Revaluation",
-				"reference_name": self.name,
-			}
-		)
-
-		journal_entry.set("accounts", journal_entry_accounts)
-		journal_entry.set_total_debit_credit()
-		journal_entry.save()
-		return journal_entry
-
-	def make_jv_for_revaluation(self):
-		if self.gain_loss_unbooked == 0:
-			return
-
-		accounts = [x for x in self.accounts if not x.zero_balance]
-		if not accounts:
-			return
-
-		unrealized_exchange_gain_loss_account = self.get_for_unrealized_gain_loss_account()
 
 		journal_entry = frappe.new_doc("Journal Entry")
 		journal_entry.voucher_type = "Exchange Rate Revaluation"
@@ -397,10 +154,7 @@ class ExchangeRateRevaluation(Document):
 		journal_entry.multi_currency = 1
 
 		journal_entry_accounts = []
-		for d in accounts:
-			if not flt(d.get("balance_in_account_currency"), d.precision("balance_in_account_currency")):
-				continue
-
+		for d in self.accounts:
 			dr_or_cr = (
 				"debit_in_account_currency"
 				if d.get("balance_in_account_currency") > 0
@@ -425,7 +179,6 @@ class ExchangeRateRevaluation(Document):
 					dr_or_cr: flt(
 						abs(d.get("balance_in_account_currency")), d.precision("balance_in_account_currency")
 					),
-					"cost_center": erpnext.get_default_cost_center(self.company),
 					"exchange_rate": flt(d.get("new_exchange_rate"), d.precision("new_exchange_rate")),
 					"reference_type": "Exchange Rate Revaluation",
 					"reference_name": self.name,
@@ -443,122 +196,63 @@ class ExchangeRateRevaluation(Document):
 					reverse_dr_or_cr: flt(
 						abs(d.get("balance_in_account_currency")), d.precision("balance_in_account_currency")
 					),
-					"cost_center": erpnext.get_default_cost_center(self.company),
 					"exchange_rate": flt(d.get("current_exchange_rate"), d.precision("current_exchange_rate")),
 					"reference_type": "Exchange Rate Revaluation",
 					"reference_name": self.name,
 				}
 			)
 
-		journal_entry.set("accounts", journal_entry_accounts)
-		journal_entry.set_amounts_in_company_currency()
-		journal_entry.set_total_debit_credit()
-
-		self.gain_loss_unbooked += journal_entry.difference - self.gain_loss_unbooked
-		journal_entry.append(
-			"accounts",
+		journal_entry_accounts.append(
 			{
 				"account": unrealized_exchange_gain_loss_account,
 				"balance": get_balance_on(unrealized_exchange_gain_loss_account),
-				"debit_in_account_currency": abs(self.gain_loss_unbooked)
-				if self.gain_loss_unbooked < 0
-				else 0,
-				"credit_in_account_currency": self.gain_loss_unbooked if self.gain_loss_unbooked > 0 else 0,
-				"cost_center": erpnext.get_default_cost_center(self.company),
+				"debit_in_account_currency": abs(self.total_gain_loss) if self.total_gain_loss < 0 else 0,
+				"credit_in_account_currency": self.total_gain_loss if self.total_gain_loss > 0 else 0,
 				"exchange_rate": 1,
 				"reference_type": "Exchange Rate Revaluation",
 				"reference_name": self.name,
-			},
+			}
 		)
 
+		journal_entry.set("accounts", journal_entry_accounts)
 		journal_entry.set_amounts_in_company_currency()
 		journal_entry.set_total_debit_credit()
-		journal_entry.save()
-		return journal_entry
-
-
-def calculate_exchange_rate_using_last_gle(company, account, party_type, party):
-	"""
-	Use last GL entry to calculate exchange rate
-	"""
-	last_exchange_rate = None
-	if company and account:
-		gl = qb.DocType("GL Entry")
-
-		# build conditions
-		conditions = []
-		conditions.append(gl.company == company)
-		conditions.append(gl.account == account)
-		conditions.append(gl.is_cancelled == 0)
-		conditions.append((gl.debit > 0) | (gl.credit > 0))
-		conditions.append((gl.debit_in_account_currency > 0) | (gl.credit_in_account_currency > 0))
-		if party_type:
-			conditions.append(gl.party_type == party_type)
-		if party:
-			conditions.append(gl.party == party)
-
-		voucher_type, voucher_no = (
-			qb.from_(gl)
-			.select(gl.voucher_type, gl.voucher_no)
-			.where(Criterion.all(conditions))
-			.orderby(gl.posting_date, order=Order.desc)
-			.limit(1)
-			.run()[0]
-		)
-
-		last_exchange_rate = (
-			qb.from_(gl)
-			.select((gl.debit - gl.credit) / (gl.debit_in_account_currency - gl.credit_in_account_currency))
-			.where(
-				(gl.voucher_type == voucher_type) & (gl.voucher_no == voucher_no) & (gl.account == account)
-			)
-			.orderby(gl.posting_date, order=Order.desc)
-			.limit(1)
-			.run()[0][0]
-		)
-
-	return last_exchange_rate
+		return journal_entry.as_dict()
 
 
 @frappe.whitelist()
-def get_account_details(company, posting_date, account, party_type=None, party=None):
-	if not (company and posting_date):
-		frappe.throw(_("Company and Posting Date is mandatory"))
-
+def get_account_details(account, company, posting_date, party_type=None, party=None):
 	account_currency, account_type = frappe.get_cached_value(
 		"Account", account, ["account_currency", "account_type"]
 	)
-
 	if account_type in ["Receivable", "Payable"] and not (party_type and party):
 		frappe.throw(_("Party Type and Party is mandatory for {0} account").format(account_type))
 
 	account_details = {}
 	company_currency = erpnext.get_company_currency(company)
-
+	balance = get_balance_on(
+		account, date=posting_date, party_type=party_type, party=party, in_account_currency=False
+	)
 	account_details = {
 		"account_currency": account_currency,
 	}
-	account_balance = ExchangeRateRevaluation.get_account_balance_from_gle(
-		company=company, posting_date=posting_date, account=account, party_type=party_type, party=party
-	)
 
-	if account_balance and (
-		account_balance[0].balance or account_balance[0].balance_in_account_currency
-	):
-		account_with_new_balance = ExchangeRateRevaluation.calculate_new_account_balance(
-			company, posting_date, account_balance
+	if balance:
+		balance_in_account_currency = get_balance_on(
+			account, date=posting_date, party_type=party_type, party=party
 		)
-		row = account_with_new_balance[0]
-		account_details.update(
+		current_exchange_rate = (
+			balance / balance_in_account_currency if balance_in_account_currency else 0
+		)
+		new_exchange_rate = get_exchange_rate(account_currency, company_currency, posting_date)
+		new_balance_in_base_currency = balance_in_account_currency * new_exchange_rate
+		account_details = account_details.update(
 			{
-				"balance_in_base_currency": row["balance_in_base_currency"],
-				"balance_in_account_currency": row["balance_in_account_currency"],
-				"current_exchange_rate": row["current_exchange_rate"],
-				"new_exchange_rate": row["new_exchange_rate"],
-				"new_balance_in_base_currency": row["new_balance_in_base_currency"],
-				"new_balance_in_account_currency": row["new_balance_in_account_currency"],
-				"zero_balance": row["zero_balance"],
-				"gain_loss": row["gain_loss"],
+				"balance_in_base_currency": balance,
+				"balance_in_account_currency": balance_in_account_currency,
+				"current_exchange_rate": current_exchange_rate,
+				"new_exchange_rate": new_exchange_rate,
+				"new_balance_in_base_currency": new_balance_in_base_currency,
 			}
 		)
 

erpnext/accounts/doctype/exchange_rate_revaluation_account/exchange_rate_revaluation_account.json

@@ -10,21 +10,14 @@
   "party",
   "column_break_2",
   "account_currency",
-  "account_balances",
   "balance_in_account_currency",
-  "column_break_46yz",
-  "new_balance_in_account_currency",
   "balances",
   "current_exchange_rate",
-  "column_break_xown",
-  "new_exchange_rate",
-  "column_break_9",
   "balance_in_base_currency",
-  "column_break_ukce",
+  "column_break_9",
+  "new_exchange_rate",
   "new_balance_in_base_currency",
-  "section_break_ngrs",
-  "gain_loss",
-  "zero_balance"
+  "gain_loss"
  ],
  "fields": [
   {
@@ -85,7 +78,7 @@
   },
   {
    "fieldname": "column_break_9",
-   "fieldtype": "Section Break"
+   "fieldtype": "Column Break"
   },
   {
    "fieldname": "new_exchange_rate",
@@ -109,45 +102,11 @@
    "label": "Gain/Loss",
    "options": "Company:company:default_currency",
    "read_only": 1
-  },
-  {
-   "default": "0",
-   "description": "This Account has '0' balance in either Base Currency or Account Currency",
-   "fieldname": "zero_balance",
-   "fieldtype": "Check",
-   "label": "Zero Balance"
-  },
-  {
-   "fieldname": "new_balance_in_account_currency",
-   "fieldtype": "Currency",
-   "label": "New Balance In Account Currency",
-   "options": "account_currency",
-   "read_only": 1
-  },
-  {
-   "fieldname": "account_balances",
-   "fieldtype": "Section Break"
-  },
-  {
-   "fieldname": "column_break_46yz",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "column_break_xown",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "column_break_ukce",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "section_break_ngrs",
-   "fieldtype": "Section Break"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2022-12-29 19:38:52.915295",
+ "modified": "2022-11-17 10:26:18.302728",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Exchange Rate Revaluation Account",

erpnext/accounts/doctype/fiscal_year/fiscal_year.py

@@ -9,6 +9,10 @@ from frappe.model.document import Document
 from frappe.utils import add_days, add_years, cstr, getdate
 
 
+class FiscalYearIncorrectDate(frappe.ValidationError):
+	pass
+
+
 class FiscalYear(Document):
 	@frappe.whitelist()
 	def set_as_default(self):
@@ -49,18 +53,23 @@ class FiscalYear(Document):
 					)
 
 	def validate_dates(self):
-		self.validate_from_to_dates("year_start_date", "year_end_date")
 		if self.is_short_year:
 			# Fiscal Year can be shorter than one year, in some jurisdictions
 			# under certain circumstances. For example, in the USA and Germany.
 			return
 
+		if getdate(self.year_start_date) > getdate(self.year_end_date):
+			frappe.throw(
+				_("Fiscal Year Start Date should be one year earlier than Fiscal Year End Date"),
+				FiscalYearIncorrectDate,
+			)
+
 		date = getdate(self.year_start_date) + relativedelta(years=1) - relativedelta(days=1)
 
 		if getdate(self.year_end_date) != date:
 			frappe.throw(
 				_("Fiscal Year End Date should be one year after Fiscal Year Start Date"),
-				frappe.exceptions.InvalidDates,
+				FiscalYearIncorrectDate,
 			)
 
 	def on_update(self):
@@ -160,6 +169,5 @@ def auto_create_fiscal_year():
 
 
 def get_from_and_to_date(fiscal_year):
-	fields = ["year_start_date", "year_end_date"]
-	cached_results = frappe.get_cached_value("Fiscal Year", fiscal_year, fields, as_dict=1)
-	return dict(from_date=cached_results.year_start_date, to_date=cached_results.year_end_date)
+	fields = ["year_start_date as from_date", "year_end_date as to_date"]
+	return frappe.get_cached_value("Fiscal Year", fiscal_year, fields, as_dict=1)

erpnext/accounts/doctype/fiscal_year/test_fiscal_year.py

@@ -7,6 +7,8 @@ import unittest
 import frappe
 from frappe.utils import now_datetime
 
+from erpnext.accounts.doctype.fiscal_year.fiscal_year import FiscalYearIncorrectDate
+
 test_ignore = ["Company"]
 
 
@@ -24,7 +26,7 @@ class TestFiscalYear(unittest.TestCase):
 			}
 		)
 
-		self.assertRaises(frappe.exceptions.InvalidDates, fy.insert)
+		self.assertRaises(FiscalYearIncorrectDate, fy.insert)
 
 
 def test_record_generator():
@@ -33,8 +35,8 @@ def test_record_generator():
 			"doctype": "Fiscal Year",
 			"year": "_Test Short Fiscal Year 2011",
 			"is_short_year": 1,
-			"year_start_date": "2011-04-01",
-			"year_end_date": "2011-12-31",
+			"year_end_date": "2011-04-01",
+			"year_start_date": "2011-12-31",
 		}
 	]
 

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -95,15 +95,7 @@ class GLEntry(Document):
 				)
 
 		# Zero value transaction is not allowed
-		if not (
-			flt(self.debit, self.precision("debit"))
-			or flt(self.credit, self.precision("credit"))
-			or (
-				self.voucher_type == "Journal Entry"
-				and frappe.get_cached_value("Journal Entry", self.voucher_no, "voucher_type")
-				== "Exchange Gain Or Loss"
-			)
-		):
+		if not (flt(self.debit, self.precision("debit")) or flt(self.credit, self.precision("credit"))):
 			frappe.throw(
 				_("{0} {1}: Either debit or credit amount is required for {2}").format(
 					self.voucher_type, self.voucher_no, self.account

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"];
+		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice'];
 	},
 
 	refresh: function(frm) {

erpnext/accounts/doctype/journal_entry/journal_entry.json

@@ -88,7 +88,7 @@
    "label": "Entry Type",
    "oldfieldname": "voucher_type",
    "oldfieldtype": "Select",
-   "options": "Journal Entry\nInter Company Journal Entry\nBank Entry\nCash Entry\nCredit Card Entry\nDebit Note\nCredit Note\nContra Entry\nExcise Entry\nWrite Off Entry\nOpening Entry\nDepreciation Entry\nExchange Rate Revaluation\nExchange Gain Or Loss\nDeferred Revenue\nDeferred Expense",
+   "options": "Journal Entry\nInter Company Journal Entry\nBank Entry\nCash Entry\nCredit Card Entry\nDebit Note\nCredit Note\nContra Entry\nExcise Entry\nWrite Off Entry\nOpening Entry\nDepreciation Entry\nExchange Rate Revaluation\nDeferred Revenue\nDeferred Expense",
    "reqd": 1,
    "search_index": 1
   },
@@ -539,7 +539,7 @@
  "idx": 176,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-03-01 14:58:59.286591",
+ "modified": "2022-06-23 22:01:32.348337",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry",

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -6,7 +6,7 @@ import json
 
 import frappe
 from frappe import _, msgprint, scrub
-from frappe.utils import cstr, flt, fmt_money, formatdate, get_link_to_form, nowdate
+from frappe.utils import cint, cstr, flt, fmt_money, formatdate, get_link_to_form, nowdate
 
 import erpnext
 from erpnext.accounts.deferred_revenue import get_deferred_booking_accounts
@@ -23,9 +23,6 @@ from erpnext.accounts.utils import (
 	get_stock_accounts,
 	get_stock_and_account_balance,
 )
-from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
-	get_depr_schedule,
-)
 from erpnext.controllers.accounts_controller import AccountsController
 
 
@@ -37,6 +34,9 @@ class JournalEntry(AccountsController):
 	def __init__(self, *args, **kwargs):
 		super(JournalEntry, self).__init__(*args, **kwargs)
 
+	def get_feed(self):
+		return self.voucher_type
+
 	def validate(self):
 		if self.voucher_type == "Opening Entry":
 			self.is_opening = "Yes"
@@ -51,7 +51,7 @@ class JournalEntry(AccountsController):
 		self.validate_multi_currency()
 		self.set_amounts_in_company_currency()
 		self.validate_debit_credit_amount()
-		self.set_total_debit_credit()
+
 		# Do not validate while importing via data import
 		if not frappe.flags.in_import:
 			self.validate_total_debit_and_credit()
@@ -81,7 +81,6 @@ class JournalEntry(AccountsController):
 		self.check_credit_limit()
 		self.make_gl_entries()
 		self.update_advance_paid()
-		self.update_asset_value()
 		self.update_inter_company_jv()
 		self.update_invoice_discounting()
 
@@ -89,13 +88,7 @@ class JournalEntry(AccountsController):
 		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",
-		)
+		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry", "Payment Ledger Entry")
 		self.make_gl_entries(1)
 		self.update_advance_paid()
 		self.unlink_advance_entry_reference()
@@ -232,29 +225,6 @@ class JournalEntry(AccountsController):
 		for d in to_remove:
 			self.remove(d)
 
-	def update_asset_value(self):
-		if self.voucher_type != "Depreciation Entry":
-			return
-
-		processed_assets = []
-
-		for d in self.get("accounts"):
-			if (
-				d.reference_type == "Asset" and d.reference_name and d.reference_name not in processed_assets
-			):
-				processed_assets.append(d.reference_name)
-
-				asset = frappe.get_doc("Asset", d.reference_name)
-
-				if asset.calculate_depreciation:
-					continue
-
-				depr_value = d.debit or d.credit
-
-				asset.db_set("value_after_depreciation", asset.value_after_depreciation - depr_value)
-
-				asset.set_status()
-
 	def update_inter_company_jv(self):
 		if (
 			self.voucher_type == "Inter Company Journal Entry"
@@ -313,45 +283,19 @@ class JournalEntry(AccountsController):
 				d.db_update()
 
 	def unlink_asset_reference(self):
-		if self.voucher_type != "Depreciation Entry":
-			return
-
-		processed_assets = []
-
 		for d in self.get("accounts"):
-			if (
-				d.reference_type == "Asset" and d.reference_name and d.reference_name not in processed_assets
-			):
-				processed_assets.append(d.reference_name)
-
+			if d.reference_type == "Asset" and d.reference_name:
 				asset = frappe.get_doc("Asset", d.reference_name)
+				for s in asset.get("schedules"):
+					if s.journal_entry == self.name:
+						s.db_set("journal_entry", None)
 
-				if asset.calculate_depreciation:
-					je_found = False
+						idx = cint(s.finance_book_id) or 1
+						finance_books = asset.get("finance_books")[idx - 1]
+						finance_books.value_after_depreciation += s.depreciation_amount
+						finance_books.db_update()
 
-					for row in asset.get("finance_books"):
-						if je_found:
-							break
-
-						depr_schedule = get_depr_schedule(asset.name, "Active", row.finance_book)
-
-						for s in depr_schedule or []:
-							if s.journal_entry == self.name:
-								s.db_set("journal_entry", None)
-
-								row.value_after_depreciation += s.depreciation_amount
-								row.db_update()
-
-								asset.set_status()
-
-								je_found = True
-								break
-				else:
-					depr_value = d.debit or d.credit
-
-					asset.db_set("value_after_depreciation", asset.value_after_depreciation + depr_value)
-
-					asset.set_status()
+						asset.set_status()
 
 	def unlink_inter_company_jv(self):
 		if (
@@ -648,29 +592,28 @@ class JournalEntry(AccountsController):
 				d.against_account = frappe.db.get_value(d.reference_type, d.reference_name, field)
 		else:
 			for d in self.get("accounts"):
-				if flt(d.debit) > 0:
+				if flt(d.debit > 0):
 					accounts_debited.append(d.party or d.account)
 				if flt(d.credit) > 0:
 					accounts_credited.append(d.party or d.account)
 
 			for d in self.get("accounts"):
-				if flt(d.debit) > 0:
+				if flt(d.debit > 0):
 					d.against_account = ", ".join(list(set(accounts_credited)))
-				if flt(d.credit) > 0:
+				if flt(d.credit > 0):
 					d.against_account = ", ".join(list(set(accounts_debited)))
 
 	def validate_debit_credit_amount(self):
-		if not (self.voucher_type == "Exchange Gain Or Loss" and self.multi_currency):
-			for d in self.get("accounts"):
-				if not flt(d.debit) and not flt(d.credit):
-					frappe.throw(_("Row {0}: Both Debit and Credit values cannot be zero").format(d.idx))
+		for d in self.get("accounts"):
+			if not flt(d.debit) and not flt(d.credit):
+				frappe.throw(_("Row {0}: Both Debit and Credit values cannot be zero").format(d.idx))
 
 	def validate_total_debit_and_credit(self):
-		if not (self.voucher_type == "Exchange Gain Or Loss" and self.multi_currency):
-			if self.difference:
-				frappe.throw(
-					_("Total Debit must be equal to Total Credit. The difference is {0}").format(self.difference)
-				)
+		self.set_total_debit_credit()
+		if self.difference:
+			frappe.throw(
+				_("Total Debit must be equal to Total Credit. The difference is {0}").format(self.difference)
+			)
 
 	def set_total_debit_credit(self):
 		self.total_debit, self.total_credit, self.difference = 0, 0, 0
@@ -708,17 +651,16 @@ class JournalEntry(AccountsController):
 		self.set_exchange_rate()
 
 	def set_amounts_in_company_currency(self):
-		if not (self.voucher_type == "Exchange Gain Or Loss" and self.multi_currency):
-			for d in self.get("accounts"):
-				d.debit_in_account_currency = flt(
-					d.debit_in_account_currency, d.precision("debit_in_account_currency")
-				)
-				d.credit_in_account_currency = flt(
-					d.credit_in_account_currency, d.precision("credit_in_account_currency")
-				)
+		for d in self.get("accounts"):
+			d.debit_in_account_currency = flt(
+				d.debit_in_account_currency, d.precision("debit_in_account_currency")
+			)
+			d.credit_in_account_currency = flt(
+				d.credit_in_account_currency, d.precision("credit_in_account_currency")
+			)
 
-				d.debit = flt(d.debit_in_account_currency * flt(d.exchange_rate), d.precision("debit"))
-				d.credit = flt(d.credit_in_account_currency * flt(d.exchange_rate), d.precision("credit"))
+			d.debit = flt(d.debit_in_account_currency * flt(d.exchange_rate), d.precision("debit"))
+			d.credit = flt(d.credit_in_account_currency * flt(d.exchange_rate), d.precision("credit"))
 
 	def set_exchange_rate(self):
 		for d in self.get("accounts"):
@@ -817,7 +759,7 @@ class JournalEntry(AccountsController):
 					pay_to_recd_from = d.party
 
 				if pay_to_recd_from and pay_to_recd_from == d.party:
-					party_amount += flt(d.debit_in_account_currency) or flt(d.credit_in_account_currency)
+					party_amount += d.debit_in_account_currency or d.credit_in_account_currency
 					party_account_currency = d.account_currency
 
 			elif frappe.get_cached_value("Account", d.account, "account_type") in ["Bank", "Cash"]:
@@ -847,7 +789,7 @@ class JournalEntry(AccountsController):
 	def build_gl_map(self):
 		gl_map = []
 		for d in self.get("accounts"):
-			if d.debit or d.credit or (self.voucher_type == "Exchange Gain Or Loss"):
+			if d.debit or d.credit:
 				r = [d.user_remark, self.remark]
 				r = [x for x in r if x]
 				remarks = "\n".join(r)
@@ -895,7 +837,7 @@ class JournalEntry(AccountsController):
 			make_gl_entries(gl_map, cancel=cancel, adv_adj=adv_adj, update_outstanding=update_outstanding)
 
 	@frappe.whitelist()
-	def get_balance(self, difference_account=None):
+	def get_balance(self):
 		if not self.get("accounts"):
 			msgprint(_("'Entries' cannot be empty"), raise_exception=True)
 		else:
@@ -910,13 +852,7 @@ class JournalEntry(AccountsController):
 						blank_row = d
 
 				if not blank_row:
-					blank_row = self.append(
-						"accounts",
-						{
-							"account": difference_account,
-							"cost_center": erpnext.get_default_cost_center(self.company),
-						},
-					)
+					blank_row = self.append("accounts", {})
 
 				blank_row.exchange_rate = 1
 				if diff > 0:

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -7,7 +7,7 @@ cur_frm.cscript.tax_table = "Advance Taxes and Charges";
 
 frappe.ui.form.on('Payment Entry', {
 	onload: function(frm) {
-		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', "Repost Payment Ledger"];
+		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice'];
 
 		if(frm.doc.__islocal) {
 			if (!frm.doc.paid_from) frm.set_value("paid_from_account_currency", null);
@@ -217,6 +217,7 @@ frappe.ui.form.on('Payment Entry', {
 		frm.toggle_display("set_exchange_gain_loss",
 			frm.doc.paid_amount && frm.doc.received_amount && frm.doc.difference_amount);
 
+		frm.refresh_fields();
 	},
 
 	set_dynamic_labels: function(frm) {
@@ -244,6 +245,8 @@ frappe.ui.form.on('Payment Entry', {
 		frm.set_currency_labels(["total_amount", "outstanding_amount", "allocated_amount"],
 			party_account_currency, "references");
 
+		frm.set_currency_labels(["amount"], company_currency, "deductions");
+
 		cur_frm.set_df_property("source_exchange_rate", "description",
 			("1 " + frm.doc.paid_from_account_currency + " = [?] " + company_currency));
 

erpnext/accounts/doctype/payment_entry/payment_entry.json

@@ -239,7 +239,7 @@
    "depends_on": "paid_from",
    "fieldname": "paid_from_account_currency",
    "fieldtype": "Link",
-   "label": "Account Currency (From)",
+   "label": "Account Currency",
    "options": "Currency",
    "print_hide": 1,
    "read_only": 1,
@@ -249,7 +249,7 @@
    "depends_on": "paid_from",
    "fieldname": "paid_from_account_balance",
    "fieldtype": "Currency",
-   "label": "Account Balance (From)",
+   "label": "Account Balance",
    "options": "paid_from_account_currency",
    "print_hide": 1,
    "read_only": 1
@@ -272,7 +272,7 @@
    "depends_on": "paid_to",
    "fieldname": "paid_to_account_currency",
    "fieldtype": "Link",
-   "label": "Account Currency (To)",
+   "label": "Account Currency",
    "options": "Currency",
    "print_hide": 1,
    "read_only": 1,
@@ -282,7 +282,7 @@
    "depends_on": "paid_to",
    "fieldname": "paid_to_account_balance",
    "fieldtype": "Currency",
-   "label": "Account Balance (To)",
+   "label": "Account Balance",
    "options": "paid_to_account_currency",
    "print_hide": 1,
    "read_only": 1
@@ -304,8 +304,7 @@
   {
    "fieldname": "source_exchange_rate",
    "fieldtype": "Float",
-   "label": "Source Exchange Rate",
-   "precision": "9",
+   "label": "Exchange Rate",
    "print_hide": 1,
    "reqd": 1
   },
@@ -334,8 +333,7 @@
   {
    "fieldname": "target_exchange_rate",
    "fieldtype": "Float",
-   "label": "Target Exchange Rate",
-   "precision": "9",
+   "label": "Exchange Rate",
    "print_hide": 1,
    "reqd": 1
   },
@@ -633,14 +631,14 @@
    "depends_on": "eval:doc.party_type == 'Supplier'",
    "fieldname": "purchase_taxes_and_charges_template",
    "fieldtype": "Link",
-   "label": "Purchase Taxes and Charges Template",
+   "label": "Taxes and Charges Template",
    "options": "Purchase Taxes and Charges Template"
   },
   {
    "depends_on": "eval: doc.party_type == 'Customer'",
    "fieldname": "sales_taxes_and_charges_template",
    "fieldtype": "Link",
-   "label": "Sales Taxes and Charges Template",
+   "label": "Taxes and Charges Template",
    "options": "Sales Taxes and Charges Template"
   },
   {
@@ -733,7 +731,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-02-14 04:52:30.478523",
+ "modified": "2022-02-23 20:08:39.559814",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry",

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -92,13 +92,7 @@ class PaymentEntry(AccountsController):
 		self.set_status()
 
 	def on_cancel(self):
-		self.ignore_linked_doctypes = (
-			"GL Entry",
-			"Stock Ledger Entry",
-			"Payment Ledger Entry",
-			"Repost Payment Ledger",
-			"Repost Payment Ledger Items",
-		)
+		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry", "Payment Ledger Entry")
 		self.make_gl_entries(cancel=1)
 		self.update_outstanding_amounts()
 		self.update_advance_paid()
@@ -253,7 +247,7 @@ class PaymentEntry(AccountsController):
 		self.set_target_exchange_rate(ref_doc)
 
 	def set_source_exchange_rate(self, ref_doc=None):
-		if self.paid_from:
+		if self.paid_from and not self.source_exchange_rate:
 			if self.paid_from_account_currency == self.company_currency:
 				self.source_exchange_rate = 1
 			else:
@@ -416,7 +410,7 @@ class PaymentEntry(AccountsController):
 
 		for ref in self.get("references"):
 			if ref.payment_term and ref.reference_name:
-				key = (ref.payment_term, ref.reference_name, ref.reference_doctype)
+				key = (ref.payment_term, ref.reference_name)
 				invoice_payment_amount_map.setdefault(key, 0.0)
 				invoice_payment_amount_map[key] += ref.allocated_amount
 
@@ -424,37 +418,20 @@ class PaymentEntry(AccountsController):
 					payment_schedule = frappe.get_all(
 						"Payment Schedule",
 						filters={"parent": ref.reference_name},
-						fields=[
-							"paid_amount",
-							"payment_amount",
-							"payment_term",
-							"discount",
-							"outstanding",
-							"discount_type",
-						],
+						fields=["paid_amount", "payment_amount", "payment_term", "discount", "outstanding"],
 					)
 					for term in payment_schedule:
-						invoice_key = (term.payment_term, ref.reference_name, ref.reference_doctype)
+						invoice_key = (term.payment_term, ref.reference_name)
 						invoice_paid_amount_map.setdefault(invoice_key, {})
 						invoice_paid_amount_map[invoice_key]["outstanding"] = term.outstanding
-						if not (term.discount_type and term.discount):
-							continue
-
-						if term.discount_type == "Percentage":
-							invoice_paid_amount_map[invoice_key]["discounted_amt"] = ref.total_amount * (
-								term.discount / 100
-							)
-						else:
-							invoice_paid_amount_map[invoice_key]["discounted_amt"] = term.discount
+						invoice_paid_amount_map[invoice_key]["discounted_amt"] = ref.total_amount * (
+							term.discount / 100
+						)
 
 		for idx, (key, allocated_amount) in enumerate(invoice_payment_amount_map.items(), 1):
 			if not invoice_paid_amount_map.get(key):
 				frappe.throw(_("Payment term {0} not used in {1}").format(key[0], key[1]))
 
-			allocated_amount = self.get_allocated_amount_in_transaction_currency(
-				allocated_amount, key[2], key[1]
-			)
-
 			outstanding = flt(invoice_paid_amount_map.get(key, {}).get("outstanding"))
 			discounted_amt = flt(invoice_paid_amount_map.get(key, {}).get("discounted_amt"))
 
@@ -489,33 +466,6 @@ class PaymentEntry(AccountsController):
 						(allocated_amount - discounted_amt, discounted_amt, allocated_amount, key[1], key[0]),
 					)
 
-	def get_allocated_amount_in_transaction_currency(
-		self, allocated_amount, reference_doctype, reference_docname
-	):
-		"""
-		Payment Entry could be in base currency while reference's payment schedule
-		is always in transaction currency.
-		E.g.
-		* SI with base=INR and currency=USD
-		* SI with payment schedule in USD
-		* PE in INR (accounting done in base currency)
-		"""
-		ref_currency, ref_exchange_rate = frappe.db.get_value(
-			reference_doctype, reference_docname, ["currency", "conversion_rate"]
-		)
-		is_single_currency = self.paid_from_account_currency == self.paid_to_account_currency
-		# PE in different currency
-		reference_is_multi_currency = self.paid_from_account_currency != ref_currency
-
-		if not (is_single_currency and reference_is_multi_currency):
-			return allocated_amount
-
-		allocated_amount = flt(
-			allocated_amount / ref_exchange_rate, self.precision("total_allocated_amount")
-		)
-
-		return allocated_amount
-
 	def set_status(self):
 		if self.docstatus == 2:
 			self.status = "Cancelled"
@@ -672,7 +622,7 @@ class PaymentEntry(AccountsController):
 				self.payment_type == "Receive"
 				and self.base_total_allocated_amount < self.base_received_amount + total_deductions
 				and self.total_allocated_amount
-				< flt(self.paid_amount) + (total_deductions / self.source_exchange_rate)
+				< self.paid_amount + (total_deductions / self.source_exchange_rate)
 			):
 				self.unallocated_amount = (
 					self.base_received_amount + total_deductions - self.base_total_allocated_amount
@@ -682,7 +632,7 @@ class PaymentEntry(AccountsController):
 				self.payment_type == "Pay"
 				and self.base_total_allocated_amount < (self.base_paid_amount - total_deductions)
 				and self.total_allocated_amount
-				< flt(self.received_amount) + (total_deductions / self.target_exchange_rate)
+				< self.received_amount + (total_deductions / self.target_exchange_rate)
 			):
 				self.unallocated_amount = (
 					self.base_paid_amount - (total_deductions + self.base_total_allocated_amount)
@@ -734,34 +684,35 @@ class PaymentEntry(AccountsController):
 		)
 
 	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"
+		if (self.payment_type == "Pay" and self.party_type == "Customer") or (
+			self.payment_type == "Receive" and 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(
-					total_negative_outstanding
-				),
-				InvalidPaymentEntry,
+			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:
+				frappe.throw(
+					_("Cannot {0} {1} {2} without any negative outstanding invoice").format(
+						_(self.payment_type),
+						(_("to") if self.party_type == "Customer" else _("from")),
+						self.party_type,
+					),
+					InvalidPaymentEntry,
+				)
+
+			elif paid_amount - additional_charges > total_negative_outstanding:
+				frappe.throw(
+					_("Paid Amount cannot be greater than total negative outstanding amount {0}").format(
+						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.
@@ -1237,7 +1188,6 @@ def get_outstanding_reference_documents(args):
 
 	ple = qb.DocType("Payment Ledger Entry")
 	common_filter = []
-	accounting_dimensions_filter = []
 	posting_and_due_date = []
 
 	# confirm that Supplier is not blocked
@@ -1267,7 +1217,7 @@ def get_outstanding_reference_documents(args):
 	# Add cost center condition
 	if args.get("cost_center"):
 		condition += " and cost_center='%s'" % args.get("cost_center")
-		accounting_dimensions_filter.append(ple.cost_center == args.get("cost_center"))
+		common_filter.append(ple.cost_center == args.get("cost_center"))
 
 	date_fields_dict = {
 		"posting_date": ["from_posting_date", "to_posting_date"],
@@ -1293,7 +1243,6 @@ def get_outstanding_reference_documents(args):
 		posting_date=posting_and_due_date,
 		min_outstanding=args.get("outstanding_amt_greater_than"),
 		max_outstanding=args.get("outstanding_amt_less_than"),
-		accounting_dimensions=accounting_dimensions_filter,
 	)
 
 	outstanding_invoices = split_invoices_based_on_payment_terms(outstanding_invoices)
@@ -1686,18 +1635,11 @@ def get_reference_details(reference_doctype, reference_name, party_account_curre
 
 @frappe.whitelist()
 def get_payment_entry(
-	dt,
-	dn,
-	party_amount=None,
-	bank_account=None,
-	bank_amount=None,
-	party_type=None,
-	payment_type=None,
-	reference_date=None,
+	dt, dn, party_amount=None, bank_account=None, bank_amount=None, party_type=None, payment_type=None
 ):
 	reference_doc = None
 	doc = frappe.get_doc(dt, dn)
-	if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) >= 99.99:
+	if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) > 0:
 		frappe.throw(_("Can only make payment against unbilled {0}").format(dt))
 
 	if not party_type:
@@ -1720,9 +1662,8 @@ def get_payment_entry(
 		dt, party_account_currency, bank, outstanding_amount, payment_type, bank_amount, doc
 	)
 
-	reference_date = getdate(reference_date)
-	paid_amount, received_amount, discount_amount, valid_discounts = apply_early_payment_discount(
-		paid_amount, received_amount, doc, party_account_currency, reference_date
+	paid_amount, received_amount, discount_amount = apply_early_payment_discount(
+		paid_amount, received_amount, doc
 	)
 
 	pe = frappe.new_doc("Payment Entry")
@@ -1730,7 +1671,6 @@ def get_payment_entry(
 	pe.company = doc.company
 	pe.cost_center = doc.get("cost_center")
 	pe.posting_date = nowdate()
-	pe.reference_date = reference_date
 	pe.mode_of_payment = doc.get("mode_of_payment")
 	pe.party_type = party_type
 	pe.party = doc.get(scrub(party_type))
@@ -1771,7 +1711,7 @@ def get_payment_entry(
 		):
 
 			for reference in get_reference_as_per_payment_terms(
-				doc.payment_schedule, dt, dn, doc, grand_total, outstanding_amount, party_account_currency
+				doc.payment_schedule, dt, dn, doc, grand_total, outstanding_amount
 			):
 				pe.append("references", reference)
 		else:
@@ -1817,38 +1757,23 @@ def get_payment_entry(
 	pe.setup_party_account_field()
 	pe.set_missing_values()
 
-	update_accounting_dimensions(pe, doc)
-
 	if party_account and bank:
 		pe.set_exchange_rate(ref_doc=reference_doc)
 		pe.set_amounts()
-
 		if discount_amount:
-			base_total_discount_loss = 0
-			if frappe.db.get_single_value("Accounts Settings", "book_tax_discount_loss"):
-				base_total_discount_loss = split_early_payment_discount_loss(pe, doc, valid_discounts)
-
-			set_pending_discount_loss(
-				pe, doc, discount_amount, base_total_discount_loss, party_account_currency
+			pe.set_gain_or_loss(
+				account_details={
+					"account": frappe.get_cached_value("Company", pe.company, "default_discount_account"),
+					"cost_center": pe.cost_center
+					or frappe.get_cached_value("Company", pe.company, "cost_center"),
+					"amount": discount_amount * (-1 if payment_type == "Pay" else 1),
+				}
 			)
-
-		pe.set_difference_amount()
+			pe.set_difference_amount()
 
 	return pe
 
 
-def update_accounting_dimensions(pe, doc):
-	"""
-	Updates accounting dimensions in Payment Entry based on the accounting dimensions in the reference document
-	"""
-	from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
-		get_accounting_dimensions,
-	)
-
-	for dimension in get_accounting_dimensions():
-		pe.set(dimension, doc.get(dimension))
-
-
 def get_bank_cash_account(doc, bank_account):
 	bank = get_default_bank_cash_account(
 		doc.company, "Bank", mode_of_payment=doc.get("mode_of_payment"), account=bank_account
@@ -1943,28 +1868,20 @@ def set_paid_amount_and_received_amount(
 	return paid_amount, received_amount
 
 
-def apply_early_payment_discount(
-	paid_amount, received_amount, doc, party_account_currency, reference_date
-):
+def apply_early_payment_discount(paid_amount, received_amount, doc):
 	total_discount = 0
-	valid_discounts = []
 	eligible_for_payments = ["Sales Order", "Sales Invoice", "Purchase Order", "Purchase Invoice"]
 	has_payment_schedule = hasattr(doc, "payment_schedule") and doc.payment_schedule
-	is_multi_currency = party_account_currency != doc.company_currency
 
 	if doc.doctype in eligible_for_payments and has_payment_schedule:
 		for term in doc.payment_schedule:
-			if not term.discounted_amount and term.discount and reference_date <= term.discount_date:
-
+			if not term.discounted_amount and term.discount and getdate(nowdate()) <= term.discount_date:
 				if term.discount_type == "Percentage":
-					grand_total = doc.get("grand_total") if is_multi_currency else doc.get("base_grand_total")
-					discount_amount = flt(grand_total) * (term.discount / 100)
+					discount_amount = flt(doc.get("grand_total")) * (term.discount / 100)
 				else:
 					discount_amount = term.discount
 
-				# if accounting is done in the same currency, paid_amount = received_amount
-				conversion_rate = doc.get("conversion_rate", 1) if is_multi_currency else 1
-				discount_amount_in_foreign_currency = discount_amount * conversion_rate
+				discount_amount_in_foreign_currency = discount_amount * doc.get("conversion_rate", 1)
 
 				if doc.doctype == "Sales Invoice":
 					paid_amount -= discount_amount
@@ -1973,151 +1890,23 @@ def apply_early_payment_discount(
 					received_amount -= discount_amount
 					paid_amount -= discount_amount_in_foreign_currency
 
-				valid_discounts.append({"type": term.discount_type, "discount": term.discount})
 				total_discount += discount_amount
 
 		if total_discount:
-			currency = doc.get("currency") if is_multi_currency else doc.company_currency
-			money = frappe.utils.fmt_money(total_discount, currency=currency)
+			money = frappe.utils.fmt_money(total_discount, currency=doc.get("currency"))
 			frappe.msgprint(_("Discount of {} applied as per Payment Term").format(money), alert=1)
 
-	return paid_amount, received_amount, total_discount, valid_discounts
-
-
-def set_pending_discount_loss(
-	pe, doc, discount_amount, base_total_discount_loss, party_account_currency
-):
-	# If multi-currency, get base discount amount to adjust with base currency deductions/losses
-	if party_account_currency != doc.company_currency:
-		discount_amount = discount_amount * doc.get("conversion_rate", 1)
-
-	# Avoid considering miniscule losses
-	discount_amount = flt(discount_amount - base_total_discount_loss, doc.precision("grand_total"))
-
-	# Set base discount amount (discount loss/pending rounding loss) in deductions
-	if discount_amount > 0.0:
-		positive_negative = -1 if pe.payment_type == "Pay" else 1
-
-		# If tax loss booking is enabled, pending loss will be rounding loss.
-		# Otherwise it will be the total discount loss.
-		book_tax_loss = frappe.db.get_single_value("Accounts Settings", "book_tax_discount_loss")
-		account_type = "round_off_account" if book_tax_loss else "default_discount_account"
-
-		pe.set_gain_or_loss(
-			account_details={
-				"account": frappe.get_cached_value("Company", pe.company, account_type),
-				"cost_center": pe.cost_center or frappe.get_cached_value("Company", pe.company, "cost_center"),
-				"amount": discount_amount * positive_negative,
-			}
-		)
-
-
-def split_early_payment_discount_loss(pe, doc, valid_discounts) -> float:
-	"""Split early payment discount into Income Loss & Tax Loss."""
-	total_discount_percent = get_total_discount_percent(doc, valid_discounts)
-
-	if not total_discount_percent:
-		return 0.0
-
-	base_loss_on_income = add_income_discount_loss(pe, doc, total_discount_percent)
-	base_loss_on_taxes = add_tax_discount_loss(pe, doc, total_discount_percent)
-
-	# Round off total loss rather than individual losses to reduce rounding error
-	return flt(base_loss_on_income + base_loss_on_taxes, doc.precision("grand_total"))
-
-
-def get_total_discount_percent(doc, valid_discounts) -> float:
-	"""Get total percentage and amount discount applied as a percentage."""
-	total_discount_percent = (
-		sum(
-			discount.get("discount") for discount in valid_discounts if discount.get("type") == "Percentage"
-		)
-		or 0.0
-	)
-
-	# Operate in percentages only as it makes the income & tax split easier
-	total_discount_amount = (
-		sum(discount.get("discount") for discount in valid_discounts if discount.get("type") == "Amount")
-		or 0.0
-	)
-
-	if total_discount_amount:
-		discount_percentage = (total_discount_amount / doc.get("grand_total")) * 100
-		total_discount_percent += discount_percentage
-		return total_discount_percent
-
-	return total_discount_percent
-
-
-def add_income_discount_loss(pe, doc, total_discount_percent) -> float:
-	"""Add loss on income discount in base currency."""
-	precision = doc.precision("total")
-	base_loss_on_income = doc.get("base_total") * (total_discount_percent / 100)
-
-	pe.append(
-		"deductions",
-		{
-			"account": frappe.get_cached_value("Company", pe.company, "default_discount_account"),
-			"cost_center": pe.cost_center or frappe.get_cached_value("Company", pe.company, "cost_center"),
-			"amount": flt(base_loss_on_income, precision),
-		},
-	)
-
-	return base_loss_on_income  # Return loss without rounding
-
-
-def add_tax_discount_loss(pe, doc, total_discount_percentage) -> float:
-	"""Add loss on tax discount in base currency."""
-	tax_discount_loss = {}
-	base_total_tax_loss = 0
-	precision = doc.precision("tax_amount_after_discount_amount", "taxes")
-
-	# The same account head could be used more than once
-	for tax in doc.get("taxes", []):
-		base_tax_loss = tax.get("base_tax_amount_after_discount_amount") * (
-			total_discount_percentage / 100
-		)
-
-		account = tax.get("account_head")
-		if not tax_discount_loss.get(account):
-			tax_discount_loss[account] = base_tax_loss
-		else:
-			tax_discount_loss[account] += base_tax_loss
-
-	for account, loss in tax_discount_loss.items():
-		base_total_tax_loss += loss
-		if loss == 0.0:
-			continue
-
-		pe.append(
-			"deductions",
-			{
-				"account": account,
-				"cost_center": pe.cost_center or frappe.get_cached_value("Company", pe.company, "cost_center"),
-				"amount": flt(loss, precision),
-			},
-		)
-
-	return base_total_tax_loss  # Return loss without rounding
+	return paid_amount, received_amount, total_discount
 
 
 def get_reference_as_per_payment_terms(
-	payment_schedule, dt, dn, doc, grand_total, outstanding_amount, party_account_currency
+	payment_schedule, dt, dn, doc, grand_total, outstanding_amount
 ):
 	references = []
-	is_multi_currency_acc = (doc.currency != doc.company_currency) and (
-		party_account_currency != doc.company_currency
-	)
-
 	for payment_term in payment_schedule:
 		payment_term_outstanding = flt(
 			payment_term.payment_amount - payment_term.paid_amount, payment_term.precision("payment_amount")
 		)
-		if not is_multi_currency_acc:
-			# If accounting is done in company currency for multi-currency transaction
-			payment_term_outstanding = flt(
-				payment_term_outstanding * doc.get("conversion_rate"), payment_term.precision("payment_amount")
-			)
 
 		if payment_term_outstanding:
 			references.append(

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -5,7 +5,7 @@ import unittest
 
 import frappe
 from frappe import qb
-from frappe.tests.utils import FrappeTestCase, change_settings
+from frappe.tests.utils import FrappeTestCase
 from frappe.utils import flt, nowdate
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import (
@@ -256,25 +256,10 @@ class TestPaymentEntry(FrappeTestCase):
 			},
 		)
 		si.save()
+
 		si.submit()
 
-		frappe.db.set_single_value("Accounts Settings", "book_tax_discount_loss", 1)
-		pe_with_tax_loss = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Cash - _TC")
-
-		self.assertEqual(pe_with_tax_loss.references[0].payment_term, "30 Credit Days with 10% Discount")
-		self.assertEqual(pe_with_tax_loss.references[0].allocated_amount, 236.0)
-		self.assertEqual(pe_with_tax_loss.paid_amount, 212.4)
-		self.assertEqual(pe_with_tax_loss.deductions[0].amount, 20.0)  # Loss on Income
-		self.assertEqual(pe_with_tax_loss.deductions[1].amount, 3.6)  # Loss on Tax
-		self.assertEqual(pe_with_tax_loss.deductions[1].account, "_Test Account Service Tax - _TC")
-
-		frappe.db.set_single_value("Accounts Settings", "book_tax_discount_loss", 0)
 		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Cash - _TC")
-
-		self.assertEqual(pe.references[0].allocated_amount, 236.0)
-		self.assertEqual(pe.paid_amount, 212.4)
-		self.assertEqual(pe.deductions[0].amount, 23.6)
-
 		pe.submit()
 		si.load_from_db()
 
@@ -284,190 +269,6 @@ class TestPaymentEntry(FrappeTestCase):
 		self.assertEqual(si.payment_schedule[0].outstanding, 0)
 		self.assertEqual(si.payment_schedule[0].discounted_amount, 23.6)
 
-	def test_payment_entry_against_payment_terms_with_discount_amount(self):
-		si = create_sales_invoice(do_not_save=1, qty=1, rate=200)
-
-		si.payment_terms_template = "Test Discount Amount Template"
-		create_payment_terms_template_with_discount(
-			name="30 Credit Days with Rs.50 Discount",
-			discount_type="Amount",
-			discount=50,
-			template_name="Test Discount Amount Template",
-		)
-		frappe.db.set_value("Company", si.company, "default_discount_account", "Write Off - _TC")
-
-		si.append(
-			"taxes",
-			{
-				"charge_type": "On Net Total",
-				"account_head": "_Test Account Service Tax - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"description": "Service Tax",
-				"rate": 18,
-			},
-		)
-		si.save()
-		si.submit()
-
-		# Set reference date past discount cut off date
-		pe_1 = get_payment_entry(
-			"Sales Invoice",
-			si.name,
-			bank_account="_Test Cash - _TC",
-			reference_date=frappe.utils.add_days(si.posting_date, 2),
-		)
-		self.assertEqual(pe_1.paid_amount, 236.0)  # discount not applied
-
-		# Test if tax loss is booked on enabling configuration
-		frappe.db.set_single_value("Accounts Settings", "book_tax_discount_loss", 1)
-		pe_with_tax_loss = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Cash - _TC")
-		self.assertEqual(pe_with_tax_loss.deductions[0].amount, 42.37)  # Loss on Income
-		self.assertEqual(pe_with_tax_loss.deductions[1].amount, 7.63)  # Loss on Tax
-		self.assertEqual(pe_with_tax_loss.deductions[1].account, "_Test Account Service Tax - _TC")
-
-		frappe.db.set_single_value("Accounts Settings", "book_tax_discount_loss", 0)
-		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Cash - _TC")
-		self.assertEqual(pe.references[0].allocated_amount, 236.0)
-		self.assertEqual(pe.paid_amount, 186)
-		self.assertEqual(pe.deductions[0].amount, 50.0)
-
-		pe.submit()
-		si.load_from_db()
-
-		self.assertEqual(si.payment_schedule[0].payment_amount, 236.0)
-		self.assertEqual(si.payment_schedule[0].paid_amount, 186)
-		self.assertEqual(si.payment_schedule[0].outstanding, 0)
-		self.assertEqual(si.payment_schedule[0].discounted_amount, 50)
-
-	@change_settings(
-		"Accounts Settings",
-		{
-			"allow_multi_currency_invoices_against_single_party_account": 1,
-			"book_tax_discount_loss": 1,
-		},
-	)
-	def test_payment_entry_multicurrency_si_with_base_currency_accounting_early_payment_discount(
-		self,
-	):
-		"""
-		1. Multi-currency SI with single currency accounting (company currency)
-		2. PE with early payment discount
-		3. Test if Paid Amount is calculated in company currency
-		4. Test if deductions are calculated in company currency
-
-		SI is in USD to document agreed amounts that are in USD, but the accounting is in base currency.
-		"""
-		si = create_sales_invoice(
-			customer="_Test Customer",
-			currency="USD",
-			conversion_rate=50,
-			do_not_save=1,
-		)
-		create_payment_terms_template_with_discount()
-		si.payment_terms_template = "Test Discount Template"
-
-		frappe.db.set_value("Company", si.company, "default_discount_account", "Write Off - _TC")
-		si.save()
-		si.submit()
-
-		pe = get_payment_entry(
-			"Sales Invoice",
-			si.name,
-			bank_account="_Test Bank - _TC",
-		)
-		pe.reference_no = si.name
-		pe.reference_date = nowdate()
-
-		# Early payment discount loss on income
-		self.assertEqual(pe.paid_amount, 4500.0)  # Amount in company currency
-		self.assertEqual(pe.received_amount, 4500.0)
-		self.assertEqual(pe.deductions[0].amount, 500.0)
-		self.assertEqual(pe.deductions[0].account, "Write Off - _TC")
-		self.assertEqual(pe.difference_amount, 0.0)
-
-		pe.insert()
-		pe.submit()
-
-		expected_gle = dict(
-			(d[0], d)
-			for d in [
-				["Debtors - _TC", 0, 5000, si.name],
-				["_Test Bank - _TC", 4500, 0, None],
-				["Write Off - _TC", 500.0, 0, None],
-			]
-		)
-
-		self.validate_gl_entries(pe.name, expected_gle)
-
-		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"))
-		self.assertEqual(outstanding_amount, 0)
-
-	def test_payment_entry_multicurrency_accounting_si_with_early_payment_discount(self):
-		"""
-		1. Multi-currency SI with multi-currency accounting
-		2. PE with early payment discount and also exchange loss
-		3. Test if Paid Amount is calculated in transaction currency
-		4. Test if deductions are calculated in base/company currency
-		5. Test if exchange loss is reflected in difference
-		"""
-		si = create_sales_invoice(
-			customer="_Test Customer USD",
-			debit_to="_Test Receivable USD - _TC",
-			currency="USD",
-			conversion_rate=50,
-			do_not_save=1,
-		)
-		create_payment_terms_template_with_discount()
-		si.payment_terms_template = "Test Discount Template"
-
-		frappe.db.set_value("Company", si.company, "default_discount_account", "Write Off - _TC")
-		si.save()
-		si.submit()
-
-		pe = get_payment_entry(
-			"Sales Invoice", si.name, bank_account="_Test Bank - _TC", bank_amount=4700
-		)
-		pe.reference_no = si.name
-		pe.reference_date = nowdate()
-
-		# Early payment discount loss on income
-		self.assertEqual(pe.paid_amount, 90.0)
-		self.assertEqual(pe.received_amount, 4200.0)  # 5000 - 500 (discount) - 300 (exchange loss)
-		self.assertEqual(pe.deductions[0].amount, 500.0)
-		self.assertEqual(pe.deductions[0].account, "Write Off - _TC")
-
-		# Exchange loss
-		self.assertEqual(pe.difference_amount, 300.0)
-
-		pe.append(
-			"deductions",
-			{
-				"account": "_Test Exchange Gain/Loss - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"amount": 300.0,
-			},
-		)
-
-		pe.insert()
-		pe.submit()
-
-		self.assertEqual(pe.difference_amount, 0.0)
-
-		expected_gle = dict(
-			(d[0], d)
-			for d in [
-				["_Test Receivable USD - _TC", 0, 5000, si.name],
-				["_Test Bank - _TC", 4200, 0, None],
-				["Write Off - _TC", 500.0, 0, None],
-				["_Test Exchange Gain/Loss - _TC", 300.0, 0, None],
-			]
-		)
-
-		self.validate_gl_entries(pe.name, expected_gle)
-
-		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"))
-		self.assertEqual(outstanding_amount, 0)
-
 	def test_payment_against_purchase_invoice_to_check_status(self):
 		pi = make_purchase_invoice(
 			supplier="_Test Supplier USD",
@@ -1038,27 +839,24 @@ def create_payment_terms_template():
 		).insert()
 
 
-def create_payment_terms_template_with_discount(
-	name=None, discount_type=None, discount=None, template_name=None
-):
-	create_payment_term(name or "30 Credit Days with 10% Discount")
-	template_name = template_name or "Test Discount Template"
+def create_payment_terms_template_with_discount():
 
-	if not frappe.db.exists("Payment Terms Template", template_name):
-		frappe.get_doc(
+	create_payment_term("30 Credit Days with 10% Discount")
+
+	if not frappe.db.exists("Payment Terms Template", "Test Discount Template"):
+		payment_term_template = frappe.get_doc(
 			{
 				"doctype": "Payment Terms Template",
-				"template_name": template_name,
+				"template_name": "Test Discount Template",
 				"allocate_payment_based_on_payment_terms": 1,
 				"terms": [
 					{
 						"doctype": "Payment Terms Template Detail",
-						"payment_term": name or "30 Credit Days with 10% Discount",
+						"payment_term": "30 Credit Days with 10% Discount",
 						"invoice_portion": 100,
 						"credit_days_based_on": "Day(s) after invoice date",
 						"credit_days": 2,
-						"discount_type": discount_type or "Percentage",
-						"discount": discount or 10,
+						"discount": 10,
 						"discount_validity_based_on": "Day(s) after invoice date",
 						"discount_validity": 1,
 					}

erpnext/accounts/doctype/payment_entry_deduction/payment_entry_deduction.json

@@ -3,7 +3,6 @@
  "creation": "2016-06-15 15:56:30.815503",
  "doctype": "DocType",
  "editable_grid": 1,
- "engine": "InnoDB",
  "field_order": [
   "account",
   "cost_center",
@@ -18,7 +17,9 @@
    "in_list_view": 1,
    "label": "Account",
    "options": "Account",
-   "reqd": 1
+   "reqd": 1,
+   "show_days": 1,
+   "show_seconds": 1
   },
   {
    "fieldname": "cost_center",
@@ -27,30 +28,37 @@
    "label": "Cost Center",
    "options": "Cost Center",
    "print_hide": 1,
-   "reqd": 1
+   "reqd": 1,
+   "show_days": 1,
+   "show_seconds": 1
   },
   {
    "fieldname": "amount",
    "fieldtype": "Currency",
    "in_list_view": 1,
-   "label": "Amount (Company Currency)",
-   "options": "Company:company:default_currency",
-   "reqd": 1
+   "label": "Amount",
+   "reqd": 1,
+   "show_days": 1,
+   "show_seconds": 1
   },
   {
    "fieldname": "column_break_2",
-   "fieldtype": "Column Break"
+   "fieldtype": "Column Break",
+   "show_days": 1,
+   "show_seconds": 1
   },
   {
    "fieldname": "description",
    "fieldtype": "Small Text",
-   "label": "Description"
+   "label": "Description",
+   "show_days": 1,
+   "show_seconds": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-03-06 07:11:57.739619",
+ "modified": "2020-09-12 20:38:08.110674",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry Deduction",
@@ -58,6 +66,5 @@
  "permissions": [],
  "quick_entry": 1,
  "sort_field": "modified",
- "sort_order": "DESC",
- "states": []
+ "sort_order": "DESC"
 }

erpnext/accounts/doctype/payment_entry_reference/payment_entry_reference.json

@@ -25,8 +25,7 @@
    "in_list_view": 1,
    "label": "Type",
    "options": "DocType",
-   "reqd": 1,
-   "search_index": 1
+   "reqd": 1
   },
   {
    "columns": 2,
@@ -36,8 +35,7 @@
    "in_list_view": 1,
    "label": "Name",
    "options": "reference_doctype",
-   "reqd": 1,
-   "search_index": 1
+   "reqd": 1
   },
   {
    "fieldname": "due_date",
@@ -106,7 +104,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2022-12-12 12:31:44.919895",
+ "modified": "2021-09-26 17:06:55.597389",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry Reference",
@@ -115,6 +113,5 @@
  "quick_entry": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/payment_gateway_account/payment_gateway_account.js

@@ -3,7 +3,6 @@
 
 frappe.ui.form.on('Payment Gateway Account', {
 	refresh(frm) {
-		erpnext.utils.check_payments_app();
 		if(!frm.doc.__islocal) {
 			frm.set_df_property('payment_gateway', 'read_only', 1);
 		}

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js

@@ -170,7 +170,7 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 	}
 
 	reconcile() {
-		var show_dialog = this.frm.doc.allocation.filter(d => d.difference_amount);
+		var show_dialog = this.frm.doc.allocation.filter(d => d.difference_amount && !d.difference_account);
 
 		if (show_dialog && show_dialog.length) {
 
@@ -179,12 +179,8 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 				title: __("Select Difference Account"),
 				fields: [
 					{
-						fieldname: "allocation",
-						fieldtype: "Table",
-						label: __("Allocation"),
-						data: this.data,
-						in_place_edit: true,
-						cannot_add_rows: true,
+						fieldname: "allocation", fieldtype: "Table", label: __("Allocation"),
+						data: this.data, in_place_edit: true,
 						get_data: () => {
 							return this.data;
 						},
@@ -222,10 +218,6 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 							read_only: 1
 						}]
 					},
-					{
-						fieldtype: 'HTML',
-						options: "<b> New Journal Entry will be posted for the difference amount </b>"
-					}
 				],
 				primary_action: () => {
 					const args = dialog.get_values()["allocation"];
@@ -242,7 +234,7 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 			});
 
 			this.frm.doc.allocation.forEach(d => {
-				if (d.difference_amount) {
+				if (d.difference_amount && !d.difference_account) {
 					dialog.fields_dict.allocation.df.data.push({
 						'docname': d.name,
 						'reference_name': d.reference_name,
@@ -272,32 +264,4 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 	}
 };
 
-frappe.ui.form.on('Payment Reconciliation Allocation', {
-	allocated_amount: function(frm, cdt, cdn) {
-		let row = locals[cdt][cdn];
-		// filter invoice
-		let invoice = frm.doc.invoices.filter((x) => (x.invoice_number == row.invoice_number));
-		// filter payment
-		let payment = frm.doc.payments.filter((x) => (x.reference_name == row.reference_name));
-
-		frm.call({
-			doc: frm.doc,
-			method: 'calculate_difference_on_allocation_change',
-			args: {
-				payment_entry: payment,
-				invoice: invoice,
-				allocated_amount: row.allocated_amount
-			},
-			callback: (r) => {
-				if (r.message) {
-					row.difference_amount = r.message;
-					frm.refresh();
-				}
-			}
-		});
-	}
-});
-
-
-
 extend_cscript(cur_frm.cscript, new erpnext.accounts.PaymentReconciliationController({frm: cur_frm}));

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -14,6 +14,7 @@ from erpnext.accounts.utils import (
 	QueryPaymentLedger,
 	get_outstanding_invoices,
 	reconcile_against_document,
+	update_reference_in_payment_entry,
 )
 from erpnext.controllers.accounts_controller import get_advance_payment_entries
 
@@ -22,7 +23,6 @@ class PaymentReconciliation(Document):
 	def __init__(self, *args, **kwargs):
 		super(PaymentReconciliation, self).__init__(*args, **kwargs)
 		self.common_filter_conditions = []
-		self.accounting_dimension_filter_conditions = []
 		self.ple_posting_date_filter = []
 
 	@frappe.whitelist()
@@ -69,10 +69,6 @@ class PaymentReconciliation(Document):
 
 	def get_jv_entries(self):
 		condition = self.get_conditions()
-
-		if self.get("cost_center"):
-			condition += f" and t2.cost_center = '{self.cost_center}' "
-
 		dr_or_cr = (
 			"credit_in_account_currency"
 			if erpnext.get_party_account_type(self.party_type) == "Receivable"
@@ -83,13 +79,12 @@ class PaymentReconciliation(Document):
 			"t2.against_account like %(bank_cash_account)s" if self.bank_cash_account else "1=1"
 		)
 
-		# nosemgrep
 		journal_entries = frappe.db.sql(
 			"""
 			select
 				"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,
+				{dr_or_cr} as amount, t2.is_advance,
 				t2.account_currency as currency
 			from
 				`tabJournal Entry` t1, `tabJournal Entry Account` t2
@@ -198,7 +193,6 @@ class PaymentReconciliation(Document):
 			posting_date=self.ple_posting_date_filter,
 			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,
 		)
 
 		if self.invoice_limit:
@@ -219,38 +213,26 @@ class PaymentReconciliation(Document):
 			inv.currency = entry.get("currency")
 			inv.outstanding_amount = flt(entry.get("outstanding_amount"))
 
-	def get_difference_amount(self, payment_entry, invoice, allocated_amount):
-		difference_amount = 0
-		if frappe.get_cached_value(
-			"Account", self.receivable_payable_account, "account_currency"
-		) != frappe.get_cached_value("Company", self.company, "default_currency"):
-			if invoice.get("exchange_rate") and payment_entry.get("exchange_rate", 1) != invoice.get(
-				"exchange_rate", 1
-			):
-				allocated_amount_in_ref_rate = payment_entry.get("exchange_rate", 1) * allocated_amount
-				allocated_amount_in_inv_rate = invoice.get("exchange_rate", 1) * allocated_amount
-				difference_amount = allocated_amount_in_ref_rate - allocated_amount_in_inv_rate
+	def get_difference_amount(self, allocated_entry):
+		if allocated_entry.get("reference_type") != "Payment Entry":
+			return
 
-		return difference_amount
-
-	@frappe.whitelist()
-	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"))
-		new_difference_amount = self.get_difference_amount(
-			payment_entry[0], invoice[0], allocated_amount
+		dr_or_cr = (
+			"credit_in_account_currency"
+			if erpnext.get_party_account_type(self.party_type) == "Receivable"
+			else "debit_in_account_currency"
 		)
-		return new_difference_amount
+
+		row = self.get_payment_details(allocated_entry, dr_or_cr)
+
+		doc = frappe.get_doc(allocated_entry.reference_type, allocated_entry.reference_name)
+		update_reference_in_payment_entry(row, doc, do_not_save=True)
+
+		return doc.difference_amount
 
 	@frappe.whitelist()
 	def allocate_entries(self, args):
 		self.validate_entries()
-
-		invoice_exchange_map = self.get_invoice_exchange_map(args.get("invoices"), args.get("payments"))
-		default_exchange_gain_loss_account = frappe.get_cached_value(
-			"Company", self.company, "exchange_gain_loss_account"
-		)
-
 		entries = []
 		for pay in args.get("payments"):
 			pay.update({"unreconciled_amount": pay.get("amount")})
@@ -264,13 +246,7 @@ class PaymentReconciliation(Document):
 					inv["outstanding_amount"] = flt(inv.get("outstanding_amount")) - flt(pay.get("amount"))
 					pay["amount"] = 0
 
-				inv["exchange_rate"] = invoice_exchange_map.get(inv.get("invoice_number"))
-				if pay.get("reference_type") in ["Sales Invoice", "Purchase Invoice"]:
-					pay["exchange_rate"] = invoice_exchange_map.get(pay.get("reference_name"))
-
-				res.difference_amount = self.get_difference_amount(pay, inv, res["allocated_amount"])
-				res.difference_account = default_exchange_gain_loss_account
-				res.exchange_rate = inv.get("exchange_rate")
+				res.difference_amount = self.get_difference_amount(res)
 
 				if pay.get("amount") == 0:
 					entries.append(res)
@@ -300,7 +276,6 @@ class PaymentReconciliation(Document):
 				"amount": pay.get("amount"),
 				"allocated_amount": allocated_amount,
 				"difference_amount": pay.get("difference_amount"),
-				"currency": inv.get("currency"),
 			}
 		)
 
@@ -323,11 +298,7 @@ class PaymentReconciliation(Document):
 				else:
 					reconciled_entry = entry_list
 
-				payment_details = self.get_payment_details(row, dr_or_cr)
-				reconciled_entry.append(payment_details)
-
-				if payment_details.difference_amount:
-					self.make_difference_entry(payment_details)
+				reconciled_entry.append(self.get_payment_details(row, dr_or_cr))
 
 		if entry_list:
 			reconcile_against_document(entry_list)
@@ -338,57 +309,6 @@ class PaymentReconciliation(Document):
 		msgprint(_("Successfully Reconciled"))
 		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()
-
 	def get_payment_details(self, row, dr_or_cr):
 		return frappe._dict(
 			{
@@ -398,7 +318,6 @@ class PaymentReconciliation(Document):
 				"against_voucher_type": row.get("invoice_type"),
 				"against_voucher": row.get("invoice_number"),
 				"account": self.receivable_payable_account,
-				"exchange_rate": row.get("exchange_rate"),
 				"party_type": self.party_type,
 				"party": self.party,
 				"is_advance": row.get("is_advance"),
@@ -423,49 +342,6 @@ class PaymentReconciliation(Document):
 		if not self.get("payments"):
 			frappe.throw(_("No records found in the Payments table"))
 
-	def get_invoice_exchange_map(self, invoices, payments):
-		sales_invoices = [
-			d.get("invoice_number") for d in invoices if d.get("invoice_type") == "Sales Invoice"
-		]
-
-		sales_invoices.extend(
-			[d.get("reference_name") for d in payments if d.get("reference_type") == "Sales Invoice"]
-		)
-		purchase_invoices = [
-			d.get("invoice_number") for d in invoices if d.get("invoice_type") == "Purchase Invoice"
-		]
-		purchase_invoices.extend(
-			[d.get("reference_name") for d in payments if d.get("reference_type") == "Purchase Invoice"]
-		)
-
-		invoice_exchange_map = frappe._dict()
-
-		if sales_invoices:
-			sales_invoice_map = frappe._dict(
-				frappe.db.get_all(
-					"Sales Invoice",
-					filters={"name": ("in", sales_invoices)},
-					fields=["name", "conversion_rate"],
-					as_list=1,
-				)
-			)
-
-			invoice_exchange_map.update(sales_invoice_map)
-
-		if purchase_invoices:
-			purchase_invoice_map = frappe._dict(
-				frappe.db.get_all(
-					"Purchase Invoice",
-					filters={"name": ("in", purchase_invoices)},
-					fields=["name", "conversion_rate"],
-					as_list=1,
-				)
-			)
-
-			invoice_exchange_map.update(purchase_invoice_map)
-
-		return invoice_exchange_map
-
 	def validate_allocation(self):
 		unreconciled_invoices = frappe._dict()
 
@@ -499,14 +375,13 @@ class PaymentReconciliation(Document):
 
 	def build_qb_filter_conditions(self, get_invoices=False, get_return_invoices=False):
 		self.common_filter_conditions.clear()
-		self.accounting_dimension_filter_conditions.clear()
 		self.ple_posting_date_filter.clear()
 		ple = qb.DocType("Payment Ledger Entry")
 
 		self.common_filter_conditions.append(ple.company == self.company)
 
 		if self.get("cost_center") and (get_invoices or get_return_invoices):
-			self.accounting_dimension_filter_conditions.append(ple.cost_center == self.cost_center)
+			self.common_filter_conditions.append(ple.cost_center == self.cost_center)
 
 		if get_invoices:
 			if self.from_invoice_date:

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -5,11 +5,9 @@ import unittest
 
 import frappe
 from frappe import qb
-from frappe.tests.utils import FrappeTestCase, change_settings
-from frappe.utils import add_days, flt, nowdate
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import add_days, nowdate
 
-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.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.party import get_party_account
@@ -22,7 +20,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		self.create_item()
 		self.create_customer()
 		self.create_account()
-		self.create_cost_center()
 		self.clear_old_entries()
 
 	def tearDown(self):
@@ -75,11 +72,33 @@ class TestPaymentReconciliation(FrappeTestCase):
 		self.item = item if isinstance(item, str) else item.item_code
 
 	def create_customer(self):
-		self.customer = make_customer("_Test PR Customer")
-		self.customer2 = make_customer("_Test PR Customer 2")
-		self.customer3 = make_customer("_Test PR Customer 3", "EUR")
-		self.customer4 = make_customer("_Test PR Customer 4", "EUR")
-		self.customer5 = make_customer("_Test PR Customer 5", "EUR")
+		if frappe.db.exists("Customer", "_Test PR Customer"):
+			self.customer = "_Test PR Customer"
+		else:
+			customer = frappe.new_doc("Customer")
+			customer.customer_name = "_Test PR Customer"
+			customer.type = "Individual"
+			customer.save()
+			self.customer = customer.name
+
+		if frappe.db.exists("Customer", "_Test PR Customer 2"):
+			self.customer2 = "_Test PR Customer 2"
+		else:
+			customer = frappe.new_doc("Customer")
+			customer.customer_name = "_Test PR Customer 2"
+			customer.type = "Individual"
+			customer.save()
+			self.customer2 = customer.name
+
+		if frappe.db.exists("Customer", "_Test PR Customer 3"):
+			self.customer3 = "_Test PR Customer 3"
+		else:
+			customer = frappe.new_doc("Customer")
+			customer.customer_name = "_Test PR Customer 3"
+			customer.type = "Individual"
+			customer.default_currency = "EUR"
+			customer.save()
+			self.customer3 = customer.name
 
 	def create_account(self):
 		account_name = "Debtors EUR"
@@ -197,22 +216,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		)
 		return je
 
-	def create_cost_center(self):
-		# Setup cost center
-		cc_name = "Sub"
-
-		self.main_cc = frappe.get_doc("Cost Center", get_default_cost_center(self.company))
-
-		cc_exists = frappe.db.get_list("Cost Center", filters={"cost_center_name": cc_name})
-		if cc_exists:
-			self.sub_cc = frappe.get_doc("Cost Center", cc_exists[0].name)
-		else:
-			sub_cc = frappe.new_doc("Cost Center")
-			sub_cc.cost_center_name = "Sub"
-			sub_cc.parent_cost_center = self.main_cc.parent_cost_center
-			sub_cc.company = self.main_cc.company
-			self.sub_cc = sub_cc.save()
-
 	def test_filter_min_max(self):
 		# check filter condition minimum and maximum amount
 		self.create_sales_invoice(qty=1, rate=300)
@@ -349,11 +352,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		invoices = [x.as_dict() for x in pr.get("invoices")]
 		payments = [x.as_dict() for x in pr.get("payments")]
 		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Difference amount should not be calculated for base currency accounts
-		for row in pr.allocation:
-			self.assertEqual(flt(row.get("difference_amount")), 0.0)
-
 		pr.reconcile()
 
 		si.reload()
@@ -395,11 +393,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		invoices = [x.as_dict() for x in pr.get("invoices")]
 		payments = [x.as_dict() for x in pr.get("payments")]
 		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Difference amount should not be calculated for base currency accounts
-		for row in pr.allocation:
-			self.assertEqual(flt(row.get("difference_amount")), 0.0)
-
 		pr.reconcile()
 
 		# check PR tool output
@@ -424,11 +417,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		invoices = [x.as_dict() for x in pr.get("invoices")]
 		payments = [x.as_dict() for x in pr.get("payments")]
 		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Difference amount should not be calculated for base currency accounts
-		for row in pr.allocation:
-			self.assertEqual(flt(row.get("difference_amount")), 0.0)
-
 		pr.reconcile()
 
 		# assert outstanding
@@ -465,11 +453,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		invoices = [x.as_dict() for x in pr.get("invoices")]
 		payments = [x.as_dict() for x in pr.get("payments")]
 		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Difference amount should not be calculated for base currency accounts
-		for row in pr.allocation:
-			self.assertEqual(flt(row.get("difference_amount")), 0.0)
-
 		pr.reconcile()
 
 		self.assertEqual(pr.get("invoices"), [])
@@ -493,11 +476,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		invoices = [x.as_dict() for x in pr.get("invoices")]
 		payments = [x.as_dict() for x in pr.get("payments")]
 		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Cr Note and Invoice are of the same currency. There shouldn't any difference amount.
-		for row in pr.allocation:
-			self.assertEqual(flt(row.get("difference_amount")), 0.0)
-
 		pr.reconcile()
 
 		pr.get_unreconciled_entries()
@@ -531,11 +509,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		payments = [x.as_dict() for x in pr.get("payments")]
 		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
 		pr.allocation[0].allocated_amount = allocated_amount
-
-		# Cr Note and Invoice are of the same currency. There shouldn't any difference amount.
-		for row in pr.allocation:
-			self.assertEqual(flt(row.get("difference_amount")), 0.0)
-
 		pr.reconcile()
 
 		# assert outstanding
@@ -605,301 +578,3 @@ class TestPaymentReconciliation(FrappeTestCase):
 		self.assertEqual(len(pr.payments), 1)
 		self.assertEqual(pr.payments[0].amount, amount)
 		self.assertEqual(pr.payments[0].currency, "EUR")
-
-	def test_difference_amount_via_journal_entry(self):
-		# Make Sale Invoice
-		si = self.create_sales_invoice(
-			qty=1, rate=100, posting_date=nowdate(), do_not_save=True, do_not_submit=True
-		)
-		si.customer = self.customer4
-		si.currency = "EUR"
-		si.conversion_rate = 85
-		si.debit_to = self.debtors_eur
-		si.save().submit()
-
-		# Make payment using Journal Entry
-		je1 = self.create_journal_entry("HDFC - _PR", self.debtors_eur, 100, nowdate())
-		je1.multi_currency = 1
-		je1.accounts[0].exchange_rate = 1
-		je1.accounts[0].credit_in_account_currency = 0
-		je1.accounts[0].credit = 0
-		je1.accounts[0].debit_in_account_currency = 8000
-		je1.accounts[0].debit = 8000
-		je1.accounts[1].party_type = "Customer"
-		je1.accounts[1].party = self.customer4
-		je1.accounts[1].exchange_rate = 80
-		je1.accounts[1].credit_in_account_currency = 100
-		je1.accounts[1].credit = 8000
-		je1.accounts[1].debit_in_account_currency = 0
-		je1.accounts[1].debit = 0
-		je1.save()
-		je1.submit()
-
-		je2 = self.create_journal_entry("HDFC - _PR", self.debtors_eur, 200, nowdate())
-		je2.multi_currency = 1
-		je2.accounts[0].exchange_rate = 1
-		je2.accounts[0].credit_in_account_currency = 0
-		je2.accounts[0].credit = 0
-		je2.accounts[0].debit_in_account_currency = 16000
-		je2.accounts[0].debit = 16000
-		je2.accounts[1].party_type = "Customer"
-		je2.accounts[1].party = self.customer4
-		je2.accounts[1].exchange_rate = 80
-		je2.accounts[1].credit_in_account_currency = 200
-		je1.accounts[1].credit = 16000
-		je1.accounts[1].debit_in_account_currency = 0
-		je1.accounts[1].debit = 0
-		je2.save()
-		je2.submit()
-
-		pr = self.create_payment_reconciliation()
-		pr.party = self.customer4
-		pr.receivable_payable_account = self.debtors_eur
-		pr.get_unreconciled_entries()
-
-		self.assertEqual(len(pr.invoices), 1)
-		self.assertEqual(len(pr.payments), 2)
-
-		# Test exact payment allocation
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [pr.payments[0].as_dict()]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		self.assertEqual(pr.allocation[0].allocated_amount, 100)
-		self.assertEqual(pr.allocation[0].difference_amount, -500)
-
-		# Test partial payment allocation (with excess payment entry)
-		pr.set("allocation", [])
-		pr.get_unreconciled_entries()
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [pr.payments[1].as_dict()]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-		pr.allocation[0].difference_account = "Exchange Gain/Loss - _PR"
-
-		self.assertEqual(pr.allocation[0].allocated_amount, 100)
-		self.assertEqual(pr.allocation[0].difference_amount, -500)
-
-		# Check if difference journal entry gets generated for difference amount after reconciliation
-		pr.reconcile()
-		total_debit_amount = frappe.db.get_all(
-			"Journal Entry Account",
-			{"account": self.debtors_eur, "docstatus": 1, "reference_name": si.name},
-			"sum(debit) as amount",
-			group_by="reference_name",
-		)[0].amount
-
-		self.assertEqual(flt(total_debit_amount, 2), -500)
-
-	def test_difference_amount_via_payment_entry(self):
-		# Make Sale Invoice
-		si = self.create_sales_invoice(
-			qty=1, rate=100, posting_date=nowdate(), do_not_save=True, do_not_submit=True
-		)
-		si.customer = self.customer5
-		si.currency = "EUR"
-		si.conversion_rate = 85
-		si.debit_to = self.debtors_eur
-		si.save().submit()
-
-		# Make payment using Payment Entry
-		pe1 = create_payment_entry(
-			company=self.company,
-			payment_type="Receive",
-			party_type="Customer",
-			party=self.customer5,
-			paid_from=self.debtors_eur,
-			paid_to=self.bank,
-			paid_amount=100,
-		)
-
-		pe1.source_exchange_rate = 80
-		pe1.received_amount = 8000
-		pe1.save()
-		pe1.submit()
-
-		pe2 = create_payment_entry(
-			company=self.company,
-			payment_type="Receive",
-			party_type="Customer",
-			party=self.customer5,
-			paid_from=self.debtors_eur,
-			paid_to=self.bank,
-			paid_amount=200,
-		)
-
-		pe2.source_exchange_rate = 80
-		pe2.received_amount = 16000
-		pe2.save()
-		pe2.submit()
-
-		pr = self.create_payment_reconciliation()
-		pr.party = self.customer5
-		pr.receivable_payable_account = self.debtors_eur
-		pr.get_unreconciled_entries()
-
-		self.assertEqual(len(pr.invoices), 1)
-		self.assertEqual(len(pr.payments), 2)
-
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [pr.payments[0].as_dict()]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		self.assertEqual(pr.allocation[0].allocated_amount, 100)
-		self.assertEqual(pr.allocation[0].difference_amount, -500)
-
-		pr.set("allocation", [])
-		pr.get_unreconciled_entries()
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [pr.payments[1].as_dict()]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		self.assertEqual(pr.allocation[0].allocated_amount, 100)
-		self.assertEqual(pr.allocation[0].difference_amount, -500)
-
-	def test_differing_cost_center_on_invoice_and_payment(self):
-		"""
-		Cost Center filter should not affect outstanding amount calculation
-		"""
-
-		si = self.create_sales_invoice(qty=1, rate=100, do_not_submit=True)
-		si.cost_center = self.main_cc.name
-		si.submit()
-		pr = get_payment_entry(si.doctype, si.name)
-		pr.cost_center = self.sub_cc.name
-		pr = pr.save().submit()
-
-		pr = self.create_payment_reconciliation()
-		pr.cost_center = self.main_cc.name
-
-		pr.get_unreconciled_entries()
-
-		# check PR tool output
-		self.assertEqual(len(pr.get("invoices")), 0)
-		self.assertEqual(len(pr.get("payments")), 0)
-
-	def test_cost_center_filter_on_vouchers(self):
-		"""
-		Test Cost Center filter is applied on Invoices, Payment Entries and Journals
-		"""
-		transaction_date = nowdate()
-		rate = 100
-
-		# 'Main - PR' Cost Center
-		si1 = self.create_sales_invoice(
-			qty=1, rate=rate, posting_date=transaction_date, do_not_submit=True
-		)
-		si1.cost_center = self.main_cc.name
-		si1.submit()
-
-		pe1 = self.create_payment_entry(posting_date=transaction_date, amount=rate)
-		pe1.cost_center = self.main_cc.name
-		pe1 = pe1.save().submit()
-
-		je1 = self.create_journal_entry(self.bank, self.debit_to, 100, transaction_date)
-		je1.accounts[0].cost_center = self.main_cc.name
-		je1.accounts[1].cost_center = self.main_cc.name
-		je1.accounts[1].party_type = "Customer"
-		je1.accounts[1].party = self.customer
-		je1 = je1.save().submit()
-
-		# 'Sub - PR' Cost Center
-		si2 = self.create_sales_invoice(
-			qty=1, rate=rate, posting_date=transaction_date, do_not_submit=True
-		)
-		si2.cost_center = self.sub_cc.name
-		si2.submit()
-
-		pe2 = self.create_payment_entry(posting_date=transaction_date, amount=rate)
-		pe2.cost_center = self.sub_cc.name
-		pe2 = pe2.save().submit()
-
-		je2 = self.create_journal_entry(self.bank, self.debit_to, 100, transaction_date)
-		je2.accounts[0].cost_center = self.sub_cc.name
-		je2.accounts[1].cost_center = self.sub_cc.name
-		je2.accounts[1].party_type = "Customer"
-		je2.accounts[1].party = self.customer
-		je2 = je2.save().submit()
-
-		pr = self.create_payment_reconciliation()
-		pr.cost_center = self.main_cc.name
-
-		pr.get_unreconciled_entries()
-
-		# check PR tool output
-		self.assertEqual(len(pr.get("invoices")), 1)
-		self.assertEqual(pr.get("invoices")[0].get("invoice_number"), si1.name)
-		self.assertEqual(len(pr.get("payments")), 2)
-		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
-		self.assertCountEqual(payment_vouchers, [pe1.name, je1.name])
-
-		# Change cost center
-		pr.cost_center = self.sub_cc.name
-
-		pr.get_unreconciled_entries()
-
-		# check PR tool output
-		self.assertEqual(len(pr.get("invoices")), 1)
-		self.assertEqual(pr.get("invoices")[0].get("invoice_number"), si2.name)
-		self.assertEqual(len(pr.get("payments")), 2)
-		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
-		self.assertCountEqual(payment_vouchers, [je2.name, pe2.name])
-
-	@change_settings(
-		"Accounts Settings",
-		{
-			"allow_multi_currency_invoices_against_single_party_account": 1,
-		},
-	)
-	def test_no_difference_amount_for_base_currency_accounts(self):
-		# Make Sale Invoice
-		si = self.create_sales_invoice(
-			qty=1, rate=1, posting_date=nowdate(), do_not_save=True, do_not_submit=True
-		)
-		si.customer = self.customer
-		si.currency = "EUR"
-		si.conversion_rate = 85
-		si.debit_to = self.debit_to
-		si.save().submit()
-
-		# Make payment using Payment Entry
-		pe1 = create_payment_entry(
-			company=self.company,
-			payment_type="Receive",
-			party_type="Customer",
-			party=self.customer,
-			paid_from=self.debit_to,
-			paid_to=self.bank,
-			paid_amount=100,
-		)
-
-		pe1.save()
-		pe1.submit()
-
-		pr = self.create_payment_reconciliation()
-		pr.party = self.customer
-		pr.receivable_payable_account = self.debit_to
-		pr.get_unreconciled_entries()
-
-		self.assertEqual(len(pr.invoices), 1)
-		self.assertEqual(len(pr.payments), 1)
-
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [pr.payments[0].as_dict()]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		self.assertEqual(pr.allocation[0].allocated_amount, 85)
-		self.assertEqual(pr.allocation[0].difference_amount, 0)
-
-
-def make_customer(customer_name, currency=None):
-	if not frappe.db.exists("Customer", customer_name):
-		customer = frappe.new_doc("Customer")
-		customer.customer_name = customer_name
-		customer.type = "Individual"
-
-		if currency:
-			customer.default_currency = currency
-		customer.save()
-		return customer.name
-	else:
-		return customer_name

erpnext/accounts/doctype/payment_reconciliation_allocation/payment_reconciliation_allocation.json

@@ -20,9 +20,7 @@
   "section_break_5",
   "difference_amount",
   "column_break_7",
-  "difference_account",
-  "exchange_rate",
-  "currency"
+  "difference_account"
  ],
  "fields": [
   {
@@ -39,7 +37,7 @@
    "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Allocated Amount",
-   "options": "currency",
+   "options": "Currency",
    "reqd": 1
   },
   {
@@ -114,7 +112,7 @@
    "fieldtype": "Currency",
    "hidden": 1,
    "label": "Unreconciled Amount",
-   "options": "currency",
+   "options": "Currency",
    "read_only": 1
   },
   {
@@ -122,7 +120,7 @@
    "fieldtype": "Currency",
    "hidden": 1,
    "label": "Amount",
-   "options": "currency",
+   "options": "Currency",
    "read_only": 1
   },
   {
@@ -131,24 +129,11 @@
    "hidden": 1,
    "label": "Reference Row",
    "read_only": 1
-  },
-  {
-   "fieldname": "currency",
-   "fieldtype": "Link",
-   "hidden": 1,
-   "label": "Currency",
-   "options": "Currency"
-  },
-  {
-   "fieldname": "exchange_rate",
-   "fieldtype": "Float",
-   "label": "Exchange Rate",
-   "read_only": 1
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2022-12-24 21:01:14.882747",
+ "modified": "2021-10-06 11:48:59.616562",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Allocation",
@@ -156,6 +141,5 @@
  "permissions": [],
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/payment_reconciliation_invoice/payment_reconciliation_invoice.json

@@ -11,8 +11,7 @@
   "col_break1",
   "amount",
   "outstanding_amount",
-  "currency",
-  "exchange_rate"
+  "currency"
  ],
  "fields": [
   {
@@ -63,17 +62,11 @@
    "hidden": 1,
    "label": "Currency",
    "options": "Currency"
-  },
-  {
-   "fieldname": "exchange_rate",
-   "fieldtype": "Float",
-   "hidden": 1,
-   "label": "Exchange Rate"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2022-11-08 18:18:02.502149",
+ "modified": "2021-08-24 22:42:40.923179",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Invoice",
@@ -82,6 +75,5 @@
  "quick_entry": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/payment_reconciliation_payment/payment_reconciliation_payment.json

@@ -15,8 +15,7 @@
   "difference_amount",
   "sec_break1",
   "remark",
-  "currency",
-  "exchange_rate"
+  "currency"
  ],
  "fields": [
   {
@@ -92,17 +91,11 @@
    "label": "Difference Amount",
    "options": "currency",
    "read_only": 1
-  },
-  {
-   "fieldname": "exchange_rate",
-   "fieldtype": "Float",
-   "hidden": 1,
-   "label": "Exchange Rate"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2022-11-08 18:18:36.268760",
+ "modified": "2021-08-30 10:51:48.140062",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Payment",
@@ -110,6 +103,5 @@
  "permissions": [],
  "quick_entry": 1,
  "sort_field": "modified",
- "sort_order": "DESC",
- "states": []
+ "sort_order": "DESC"
 }

erpnext/accounts/doctype/payment_request/payment_request.js

@@ -42,7 +42,7 @@ frappe.ui.form.on("Payment Request", "refresh", function(frm) {
 		});
 	}
 
-	if((!frm.doc.payment_gateway_account || frm.doc.payment_request_type == "Outward") && frm.doc.status == "Initiated") {
+	if(!frm.doc.payment_gateway_account && frm.doc.status == "Initiated") {
 		frm.add_custom_button(__('Create Payment Entry'), function(){
 			frappe.call({
 				method: "erpnext.accounts.doctype.payment_request.payment_request.make_payment_entry",

erpnext/accounts/doctype/payment_request/payment_request.json

@@ -32,10 +32,6 @@
   "iban",
   "branch_code",
   "swift_number",
-  "accounting_dimensions_section",
-  "cost_center",
-  "dimension_col_break",
-  "project",
   "recipient_and_message",
   "print_format",
   "email_to",
@@ -366,35 +362,13 @@
    "label": "Payment Channel",
    "options": "\nEmail\nPhone",
    "read_only": 1
-  },
-  {
-   "collapsible": 1,
-   "fieldname": "accounting_dimensions_section",
-   "fieldtype": "Section Break",
-   "label": "Accounting Dimensions"
-  },
-  {
-   "fieldname": "cost_center",
-   "fieldtype": "Link",
-   "label": "Cost Center",
-   "options": "Cost Center"
-  },
-  {
-   "fieldname": "dimension_col_break",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "project",
-   "fieldtype": "Link",
-   "label": "Project",
-   "options": "Project"
   }
  ],
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-12-21 16:56:40.115737",
+ "modified": "2022-09-30 16:19:43.680025",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Request",

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -9,10 +9,8 @@ from frappe import _
 from frappe.model.document import Document
 from frappe.utils import flt, get_url, nowdate
 from frappe.utils.background_jobs import enqueue
+from payments.utils import get_payment_gateway_controller
 
-from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
-	get_accounting_dimensions,
-)
 from erpnext.accounts.doctype.payment_entry.payment_entry import (
 	get_company_defaults,
 	get_payment_entry,
@@ -21,14 +19,6 @@ from erpnext.accounts.doctype.subscription_plan.subscription_plan import get_pla
 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
-
-
-def _get_payment_gateway_controller(*args, **kwargs):
-	with payment_app_import_guard():
-		from payments.utils import get_payment_gateway_controller
-
-	return get_payment_gateway_controller(*args, **kwargs)
 
 
 class PaymentRequest(Document):
@@ -45,20 +35,21 @@ class PaymentRequest(Document):
 			frappe.throw(_("To create a Payment Request reference document is required"))
 
 	def validate_payment_request_amount(self):
-		existing_payment_request_amount = flt(
-			get_existing_payment_request_amount(self.reference_doctype, self.reference_name)
+		existing_payment_request_amount = get_existing_payment_request_amount(
+			self.reference_doctype, self.reference_name
 		)
 
-		ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
-		if not hasattr(ref_doc, "order_type") or getattr(ref_doc, "order_type") != "Shopping Cart":
-			ref_amount = get_amount(ref_doc, self.payment_account)
+		if existing_payment_request_amount:
+			ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
+			if hasattr(ref_doc, "order_type") and getattr(ref_doc, "order_type") != "Shopping Cart":
+				ref_amount = get_amount(ref_doc, self.payment_account)
 
-			if existing_payment_request_amount + flt(self.grand_total) > ref_amount:
-				frappe.throw(
-					_("Total Payment Request amount cannot be greater than {0} amount").format(
-						self.reference_doctype
+				if existing_payment_request_amount + flt(self.grand_total) > ref_amount:
+					frappe.throw(
+						_("Total Payment Request amount cannot be greater than {0} amount").format(
+							self.reference_doctype
+						)
 					)
-				)
 
 	def validate_currency(self):
 		ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
@@ -116,7 +107,7 @@ class PaymentRequest(Document):
 			self.request_phone_payment()
 
 	def request_phone_payment(self):
-		controller = _get_payment_gateway_controller(self.payment_gateway)
+		controller = get_payment_gateway_controller(self.payment_gateway)
 		request_amount = self.get_request_amount()
 
 		payment_record = dict(
@@ -165,7 +156,7 @@ class PaymentRequest(Document):
 
 	def payment_gateway_validation(self):
 		try:
-			controller = _get_payment_gateway_controller(self.payment_gateway)
+			controller = get_payment_gateway_controller(self.payment_gateway)
 			if hasattr(controller, "on_payment_request_submission"):
 				return controller.on_payment_request_submission(self)
 			else:
@@ -198,7 +189,7 @@ class PaymentRequest(Document):
 			)
 			data.update({"company": frappe.defaults.get_defaults().company})
 
-		controller = _get_payment_gateway_controller(self.payment_gateway)
+		controller = get_payment_gateway_controller(self.payment_gateway)
 		controller.validate_transaction_currency(self.currency)
 
 		if hasattr(controller, "validate_minimum_transaction_amount"):
@@ -263,7 +254,6 @@ class PaymentRequest(Document):
 
 		payment_entry.update(
 			{
-				"mode_of_payment": self.mode_of_payment,
 				"reference_no": self.name,
 				"reference_date": nowdate(),
 				"remarks": "Payment Entry against {0} {1} via Payment Request {2}".format(
@@ -272,17 +262,6 @@ class PaymentRequest(Document):
 			}
 		)
 
-		# Update dimensions
-		payment_entry.update(
-			{
-				"cost_center": self.get("cost_center"),
-				"project": self.get("project"),
-			}
-		)
-
-		for dimension in get_accounting_dimensions():
-			payment_entry.update({dimension: self.get(dimension)})
-
 		if payment_entry.difference_amount:
 			company_details = get_company_defaults(ref_doc.company)
 
@@ -424,22 +403,25 @@ def make_payment_request(**args):
 		else ""
 	)
 
-	draft_payment_request = frappe.db.get_value(
-		"Payment Request",
-		{"reference_doctype": args.dt, "reference_name": args.dn, "docstatus": 0},
-	)
-
-	existing_payment_request_amount = get_existing_payment_request_amount(args.dt, args.dn)
-
-	if existing_payment_request_amount:
-		grand_total -= existing_payment_request_amount
-
-	if draft_payment_request:
-		frappe.db.set_value(
-			"Payment Request", draft_payment_request, "grand_total", grand_total, update_modified=False
+	existing_payment_request = None
+	if args.order_type == "Shopping Cart":
+		existing_payment_request = frappe.db.get_value(
+			"Payment Request",
+			{"reference_doctype": args.dt, "reference_name": args.dn, "docstatus": ("!=", 2)},
 		)
-		pr = frappe.get_doc("Payment Request", draft_payment_request)
+
+	if existing_payment_request:
+		frappe.db.set_value(
+			"Payment Request", existing_payment_request, "grand_total", grand_total, update_modified=False
+		)
+		pr = frappe.get_doc("Payment Request", existing_payment_request)
 	else:
+		if args.order_type != "Shopping Cart":
+			existing_payment_request_amount = get_existing_payment_request_amount(args.dt, args.dn)
+
+			if existing_payment_request_amount:
+				grand_total -= existing_payment_request_amount
+
 		pr = frappe.new_doc("Payment Request")
 		pr.update(
 			{
@@ -462,17 +444,6 @@ def make_payment_request(**args):
 			}
 		)
 
-		# Update dimensions
-		pr.update(
-			{
-				"cost_center": ref_doc.get("cost_center"),
-				"project": ref_doc.get("project"),
-			}
-		)
-
-		for dimension in get_accounting_dimensions():
-			pr.update({dimension: ref_doc.get(dimension)})
-
 		if args.order_type == "Shopping Cart" or args.mute_email:
 			pr.flags.mute_email = True
 
@@ -495,28 +466,26 @@ def get_amount(ref_doc, payment_account=None):
 	"""get amount based on doctype"""
 	dt = ref_doc.doctype
 	if dt in ["Sales Order", "Purchase Order"]:
-		grand_total = flt(ref_doc.rounded_total) or flt(ref_doc.grand_total)
+		grand_total = flt(ref_doc.grand_total) - flt(ref_doc.advance_paid)
+
 	elif dt in ["Sales Invoice", "Purchase Invoice"]:
-		if not ref_doc.get("is_pos"):
-			if ref_doc.party_account_currency == ref_doc.currency:
-				grand_total = flt(ref_doc.outstanding_amount)
-			else:
-				grand_total = flt(ref_doc.outstanding_amount) / ref_doc.conversion_rate
-		elif dt == "Sales Invoice":
-			for pay in ref_doc.payments:
-				if pay.type == "Phone" and pay.account == payment_account:
-					grand_total = pay.amount
-					break
+		if ref_doc.party_account_currency == ref_doc.currency:
+			grand_total = flt(ref_doc.outstanding_amount)
+		else:
+			grand_total = flt(ref_doc.outstanding_amount) / ref_doc.conversion_rate
+
 	elif dt == "POS Invoice":
 		for pay in ref_doc.payments:
 			if pay.type == "Phone" and pay.account == payment_account:
 				grand_total = pay.amount
 				break
+
 	elif dt == "Fees":
 		grand_total = ref_doc.outstanding_amount
 
 	if grand_total > 0:
 		return grand_total
+
 	else:
 		frappe.throw(_("Payment Entry is already created"))
 

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -6,7 +6,6 @@ import unittest
 import frappe
 
 from erpnext.accounts.doctype.payment_request.payment_request import make_payment_request
-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.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.setup.utils import get_exchange_rate
@@ -46,10 +45,7 @@ class TestPaymentRequest(unittest.TestCase):
 				frappe.get_doc(method).insert(ignore_permissions=True)
 
 	def test_payment_request_linkings(self):
-		so_inr = make_sales_order(currency="INR", do_not_save=True)
-		so_inr.disable_rounded_total = 1
-		so_inr.save()
-
+		so_inr = make_sales_order(currency="INR")
 		pr = make_payment_request(
 			dt="Sales Order",
 			dn=so_inr.name,
@@ -75,29 +71,6 @@ class TestPaymentRequest(unittest.TestCase):
 		self.assertEqual(pr.reference_name, si_usd.name)
 		self.assertEqual(pr.currency, "USD")
 
-	def test_payment_entry_against_purchase_invoice(self):
-		si_usd = make_purchase_invoice(
-			customer="_Test Supplier USD",
-			debit_to="_Test Payable USD - _TC",
-			currency="USD",
-			conversion_rate=50,
-		)
-
-		pr = make_payment_request(
-			dt="Purchase Invoice",
-			dn=si_usd.name,
-			recipient_id="user@example.com",
-			mute_email=1,
-			payment_gateway_account="_Test Gateway - USD",
-			submit_doc=1,
-			return_doc=1,
-		)
-
-		pe = pr.create_payment_entry()
-		pr.load_from_db()
-
-		self.assertEqual(pr.status, "Paid")
-
 	def test_payment_entry(self):
 		frappe.db.set_value(
 			"Company", "_Test Company", "exchange_gain_loss_account", "_Test Exchange Gain/Loss - _TC"

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -4,13 +4,12 @@
 
 import frappe
 from frappe import _
-from frappe.query_builder.functions import Sum
-from frappe.utils import add_days, flt
+from frappe.utils import flt
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
 )
-from erpnext.accounts.utils import get_account_currency, get_fiscal_year, validate_fiscal_year
+from erpnext.accounts.utils import get_account_currency
 from erpnext.controllers.accounts_controller import AccountsController
 
 
@@ -21,17 +20,9 @@ class PeriodClosingVoucher(AccountsController):
 
 	def on_submit(self):
 		self.db_set("gle_processing_status", "In Progress")
-		get_opening_entries = False
-
-		if not frappe.db.exists(
-			"Period Closing Voucher", {"company": self.company, "docstatus": 1, "name": ("!=", self.name)}
-		):
-			get_opening_entries = True
-
-		self.make_gl_entries(get_opening_entries=get_opening_entries)
+		self.make_gl_entries()
 
 	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")
 		gle_count = frappe.db.count(
@@ -51,25 +42,6 @@ class PeriodClosingVoucher(AccountsController):
 		else:
 			make_reverse_gl_entries(voucher_type="Period Closing Voucher", voucher_no=self.name)
 
-		self.delete_closing_entries()
-
-	def validate_future_closing_vouchers(self):
-		if frappe.db.exists(
-			"Period Closing Voucher",
-			{"posting_date": (">", self.posting_date), "docstatus": 1, "company": self.company},
-		):
-			frappe.throw(
-				_(
-					"You can not cancel this Period Closing Voucher, please cancel the future Period Closing Vouchers first"
-				)
-			)
-
-	def delete_closing_entries(self):
-		closing_balance = frappe.qb.DocType("Account Closing Balance")
-		frappe.qb.from_(closing_balance).delete().where(
-			closing_balance.period_closing_voucher == self.name
-		).run()
-
 	def validate_account_head(self):
 		closing_account_type = frappe.get_cached_value("Account", self.closing_account_head, "root_type")
 
@@ -84,6 +56,8 @@ class PeriodClosingVoucher(AccountsController):
 			frappe.throw(_("Currency of the Closing Account must be {0}").format(company_currency))
 
 	def validate_posting_date(self):
+		from erpnext.accounts.utils import get_fiscal_year, validate_fiscal_year
+
 		validate_fiscal_year(
 			self.posting_date, self.fiscal_year, self.company, label=_("Posting Date"), doc=self
 		)
@@ -92,8 +66,6 @@ class PeriodClosingVoucher(AccountsController):
 			self.posting_date, self.fiscal_year, company=self.company
 		)[1]
 
-		self.check_if_previous_year_closed()
-
 		pce = frappe.db.sql(
 			"""select name from `tabPeriod Closing Voucher`
 			where posting_date > %s and fiscal_year = %s and docstatus = 1 and company = %s""",
@@ -106,64 +78,28 @@ class PeriodClosingVoucher(AccountsController):
 				)
 			)
 
-	def check_if_previous_year_closed(self):
-		last_year_closing = add_days(self.year_start_date, -1)
-
-		previous_fiscal_year = get_fiscal_year(last_year_closing, company=self.company, boolean=True)
-
-		if previous_fiscal_year and not frappe.db.exists(
-			"GL Entry", {"posting_date": ("<=", last_year_closing), "company": self.company}
-		):
-			return
-
-		if previous_fiscal_year and not frappe.db.exists(
-			"Period Closing Voucher",
-			{"posting_date": ("<=", last_year_closing), "docstatus": 1, "company": self.company},
-		):
-			frappe.throw(_("Previous Year is not closed, please close it first"))
-
-	def make_gl_entries(self, get_opening_entries=False):
+	def make_gl_entries(self):
 		gl_entries = self.get_gl_entries()
-		closing_entries = self.get_grouped_gl_entries(get_opening_entries=get_opening_entries)
 		if gl_entries:
 			if len(gl_entries) > 5000:
-				frappe.enqueue(
-					process_gl_entries,
-					gl_entries=gl_entries,
-					closing_entries=closing_entries,
-					voucher_name=self.name,
-					queue="long",
-				)
+				frappe.enqueue(process_gl_entries, gl_entries=gl_entries, 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, closing_entries, voucher_name=self.name)
-
-	def get_grouped_gl_entries(self, get_opening_entries=False):
-		closing_entries = []
-		for acc in self.get_balances_based_on_dimensions(
-			group_by_account=True, for_aggregation=True, get_opening_entries=get_opening_entries
-		):
-			closing_entries.append(self.get_closing_entries(acc))
-
-		return closing_entries
+				process_gl_entries(gl_entries)
 
 	def get_gl_entries(self):
 		gl_entries = []
 
 		# pl account
-		for acc in self.get_balances_based_on_dimensions(
-			group_by_account=True, report_type="Profit and Loss"
-		):
+		for acc in self.get_pl_balances_based_on_dimensions(group_by_account=True):
 			if flt(acc.bal_in_company_currency):
 				gl_entries.append(self.get_gle_for_pl_account(acc))
 
 		# closing liability account
-		for acc in self.get_balances_based_on_dimensions(
-			group_by_account=False, report_type="Profit and Loss"
-		):
+		for acc in self.get_pl_balances_based_on_dimensions(group_by_account=False):
 			if flt(acc.bal_in_company_currency):
 				gl_entries.append(self.get_gle_for_closing_account(acc))
 
@@ -172,8 +108,6 @@ class PeriodClosingVoucher(AccountsController):
 	def get_gle_for_pl_account(self, acc):
 		gl_entry = self.get_gl_dict(
 			{
-				"company": self.company,
-				"closing_date": self.posting_date,
 				"account": acc.account,
 				"cost_center": acc.cost_center,
 				"finance_book": acc.finance_book,
@@ -186,7 +120,6 @@ class PeriodClosingVoucher(AccountsController):
 				if flt(acc.bal_in_account_currency) > 0
 				else 0,
 				"credit": abs(flt(acc.bal_in_company_currency)) if flt(acc.bal_in_company_currency) > 0 else 0,
-				"is_period_closing_voucher_entry": 1,
 			},
 			item=acc,
 		)
@@ -196,8 +129,6 @@ class PeriodClosingVoucher(AccountsController):
 	def get_gle_for_closing_account(self, acc):
 		gl_entry = self.get_gl_dict(
 			{
-				"company": self.company,
-				"closing_date": self.posting_date,
 				"account": self.closing_account_head,
 				"cost_center": acc.cost_center,
 				"finance_book": acc.finance_book,
@@ -210,36 +141,12 @@ class PeriodClosingVoucher(AccountsController):
 				if flt(acc.bal_in_account_currency) < 0
 				else 0,
 				"credit": abs(flt(acc.bal_in_company_currency)) if flt(acc.bal_in_company_currency) < 0 else 0,
-				"is_period_closing_voucher_entry": 1,
 			},
 			item=acc,
 		)
 		self.update_default_dimensions(gl_entry, acc)
 		return gl_entry
 
-	def get_closing_entries(self, acc):
-		closing_entry = self.get_gl_dict(
-			{
-				"company": self.company,
-				"closing_date": self.posting_date,
-				"period_closing_voucher": self.name,
-				"account": acc.account,
-				"cost_center": acc.cost_center,
-				"finance_book": acc.finance_book,
-				"account_currency": acc.account_currency,
-				"debit_in_account_currency": flt(acc.debit_in_account_currency),
-				"debit": flt(acc.debit),
-				"credit_in_account_currency": flt(acc.credit_in_account_currency),
-				"credit": flt(acc.credit),
-			},
-			item=acc,
-		)
-
-		for dimension in self.accounting_dimensions:
-			closing_entry.update({dimension: acc.get(dimension)})
-
-		return closing_entry
-
 	def update_default_dimensions(self, gl_entry, acc):
 		if not self.accounting_dimensions:
 			self.accounting_dimensions = get_accounting_dimensions()
@@ -247,88 +154,47 @@ class PeriodClosingVoucher(AccountsController):
 		for dimension in self.accounting_dimensions:
 			gl_entry.update({dimension: acc.get(dimension)})
 
-	def get_balances_based_on_dimensions(
-		self, group_by_account=False, report_type=None, for_aggregation=False, get_opening_entries=False
-	):
+	def get_pl_balances_based_on_dimensions(self, group_by_account=False):
 		"""Get balance for dimension-wise pl accounts"""
 
-		qb_dimension_fields = ["cost_center", "finance_book", "project"]
+		dimension_fields = ["t1.cost_center", "t1.finance_book"]
 
 		self.accounting_dimensions = get_accounting_dimensions()
 		for dimension in self.accounting_dimensions:
-			qb_dimension_fields.append(dimension)
+			dimension_fields.append("t1.{0}".format(dimension))
 
 		if group_by_account:
-			qb_dimension_fields.append("account")
+			dimension_fields.append("t1.account")
 
-		account_filters = {
-			"company": self.company,
-			"is_group": 0,
-		}
-
-		if report_type:
-			account_filters.update({"report_type": report_type})
-
-		accounts = frappe.get_all("Account", filters=account_filters, pluck="name")
-
-		gl_entry = frappe.qb.DocType("GL Entry")
-		query = frappe.qb.from_(gl_entry).select(gl_entry.account, gl_entry.account_currency)
-
-		if not for_aggregation:
-			query = query.select(
-				(Sum(gl_entry.debit_in_account_currency) - Sum(gl_entry.credit_in_account_currency)).as_(
-					"bal_in_account_currency"
-				),
-				(Sum(gl_entry.debit) - Sum(gl_entry.credit)).as_("bal_in_company_currency"),
-			)
-		else:
-			query = query.select(
-				(Sum(gl_entry.debit_in_account_currency)).as_("debit_in_account_currency"),
-				(Sum(gl_entry.credit_in_account_currency)).as_("credit_in_account_currency"),
-				(Sum(gl_entry.debit)).as_("debit"),
-				(Sum(gl_entry.credit)).as_("credit"),
-			)
-
-		for dimension in qb_dimension_fields:
-			query = query.select(gl_entry[dimension])
-
-		query = query.where(
-			(gl_entry.company == self.company)
-			& (gl_entry.is_cancelled == 0)
-			& (gl_entry.account.isin(accounts))
+		return frappe.db.sql(
+			"""
+			select
+				t2.account_currency,
+				{dimension_fields},
+				sum(t1.debit_in_account_currency) - sum(t1.credit_in_account_currency) as bal_in_account_currency,
+				sum(t1.debit) - sum(t1.credit) as bal_in_company_currency
+			from `tabGL Entry` t1, `tabAccount` t2
+			where
+				t1.is_cancelled = 0
+				and t1.account = t2.name
+				and t2.report_type = 'Profit and Loss'
+				and t2.docstatus < 2
+				and t2.company = %s
+				and t1.posting_date between %s and %s
+			group by {dimension_fields}
+		""".format(
+				dimension_fields=", ".join(dimension_fields)
+			),
+			(self.company, self.get("year_start_date"), self.posting_date),
+			as_dict=1,
 		)
 
-		if get_opening_entries:
-			query = query.where(
-				gl_entry.posting_date.between(self.get("year_start_date"), self.posting_date)
-				| gl_entry.is_opening
-				== "Yes"
-			)
-		else:
-			query = query.where(
-				gl_entry.posting_date.between(self.get("year_start_date"), self.posting_date)
-				& gl_entry.is_opening
-				== "No"
-			)
 
-		if for_aggregation:
-			query = query.where(gl_entry.voucher_type != "Period Closing Voucher")
-
-		for dimension in qb_dimension_fields:
-			query = query.groupby(gl_entry[dimension])
-
-		return query.run(as_dict=1)
-
-
-def process_gl_entries(gl_entries, closing_entries, voucher_name=None):
-	from erpnext.accounts.doctype.account_closing_balance.account_closing_balance import (
-		make_closing_entries,
-	)
+def process_gl_entries(gl_entries):
 	from erpnext.accounts.general_ledger import make_gl_entries
 
 	try:
 		make_gl_entries(gl_entries, merge_entries=False)
-		make_closing_entries(gl_entries + closing_entries, voucher_name=voucher_name)
 		frappe.db.set_value(
 			"Period Closing Voucher", gl_entries[0].get("voucher_no"), "gle_processing_status", "Completed"
 		)

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -16,17 +16,16 @@ from erpnext.accounts.utils import get_fiscal_year, now
 class TestPeriodClosingVoucher(unittest.TestCase):
 	def test_closing_entry(self):
 		frappe.db.sql("delete from `tabGL Entry` where company='Test PCV Company'")
-		frappe.db.sql("delete from `tabPeriod Closing Voucher` where company='Test PCV Company'")
 
 		company = create_company()
 		cost_center = create_cost_center("Test Cost Center 1")
 
 		jv1 = make_journal_entry(
-			posting_date="2021-03-15",
 			amount=400,
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center,
+			posting_date=now(),
 			save=False,
 		)
 		jv1.company = company
@@ -34,18 +33,18 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 		jv1.submit()
 
 		jv2 = make_journal_entry(
-			posting_date="2021-03-15",
 			amount=600,
 			account1="Cost of Goods Sold - TPC",
 			account2="Cash - TPC",
 			cost_center=cost_center,
+			posting_date=now(),
 			save=False,
 		)
 		jv2.company = company
 		jv2.save()
 		jv2.submit()
 
-		pcv = self.make_period_closing_voucher(posting_date="2021-03-31")
+		pcv = self.make_period_closing_voucher()
 		surplus_account = pcv.closing_account_head
 
 		expected_gle = (
@@ -66,7 +65,6 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 
 	def test_cost_center_wise_posting(self):
 		frappe.db.sql("delete from `tabGL Entry` where company='Test PCV Company'")
-		frappe.db.sql("delete from `tabPeriod Closing Voucher` where company='Test PCV Company'")
 
 		company = create_company()
 		surplus_account = create_account()
@@ -83,7 +81,6 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			debit_to="Debtors - TPC",
 			currency="USD",
 			customer="_Test Customer USD",
-			posting_date="2021-03-15",
 		)
 		create_sales_invoice(
 			company=company,
@@ -94,10 +91,9 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			debit_to="Debtors - TPC",
 			currency="USD",
 			customer="_Test Customer USD",
-			posting_date="2021-03-15",
 		)
 
-		pcv = self.make_period_closing_voucher(posting_date="2021-03-31", submit=False)
+		pcv = self.make_period_closing_voucher(submit=False)
 		pcv.save()
 		pcv.submit()
 		surplus_account = pcv.closing_account_head
@@ -132,13 +128,12 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 
 	def test_period_closing_with_finance_book_entries(self):
 		frappe.db.sql("delete from `tabGL Entry` where company='Test PCV Company'")
-		frappe.db.sql("delete from `tabPeriod Closing Voucher` where company='Test PCV Company'")
 
 		company = create_company()
 		surplus_account = create_account()
 		cost_center = create_cost_center("Test Cost Center 1")
 
-		create_sales_invoice(
+		si = create_sales_invoice(
 			company=company,
 			income_account="Sales - TPC",
 			expense_account="Cost of Goods Sold - TPC",
@@ -147,7 +142,6 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			debit_to="Debtors - TPC",
 			currency="USD",
 			customer="_Test Customer USD",
-			posting_date="2021-03-15",
 		)
 
 		jv = make_journal_entry(
@@ -155,14 +149,14 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			account2="Sales - TPC",
 			amount=400,
 			cost_center=cost_center,
-			posting_date="2021-03-15",
+			posting_date=now(),
 		)
 		jv.company = company
 		jv.finance_book = create_finance_book().name
 		jv.save()
 		jv.submit()
 
-		pcv = self.make_period_closing_voucher(posting_date="2021-03-31")
+		pcv = self.make_period_closing_voucher()
 		surplus_account = pcv.closing_account_head
 
 		expected_gle = (
@@ -183,130 +177,14 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 
 		self.assertSequenceEqual(pcv_gle, expected_gle)
 
-	def test_gl_entries_restrictions(self):
-		frappe.db.sql("delete from `tabGL Entry` where company='Test PCV Company'")
-		frappe.db.sql("delete from `tabPeriod Closing Voucher` where company='Test PCV Company'")
-
-		company = create_company()
-		cost_center = create_cost_center("Test Cost Center 1")
-
-		self.make_period_closing_voucher(posting_date="2021-03-31")
-
-		jv1 = make_journal_entry(
-			posting_date="2021-03-15",
-			amount=400,
-			account1="Cash - TPC",
-			account2="Sales - TPC",
-			cost_center=cost_center,
-			save=False,
-		)
-		jv1.company = company
-		jv1.save()
-
-		self.assertRaises(frappe.ValidationError, jv1.submit)
-
-	def test_closing_balance_with_dimensions(self):
-		frappe.db.sql("delete from `tabGL Entry` where company='Test PCV Company'")
-		frappe.db.sql("delete from `tabPeriod Closing Voucher` where company='Test PCV Company'")
-		frappe.db.sql("delete from `tabAccount Closing Balance` where company='Test PCV Company'")
-
-		company = create_company()
-		cost_center1 = create_cost_center("Test Cost Center 1")
-		cost_center2 = create_cost_center("Test Cost Center 2")
-
-		jv1 = make_journal_entry(
-			posting_date="2021-03-15",
-			amount=400,
-			account1="Cash - TPC",
-			account2="Sales - TPC",
-			cost_center=cost_center1,
-			save=False,
-		)
-		jv1.company = company
-		jv1.save()
-		jv1.submit()
-
-		jv2 = make_journal_entry(
-			posting_date="2021-03-15",
-			amount=200,
-			account1="Cash - TPC",
-			account2="Sales - TPC",
-			cost_center=cost_center2,
-			save=False,
-		)
-		jv2.company = company
-		jv2.save()
-		jv2.submit()
-
-		pcv1 = self.make_period_closing_voucher(posting_date="2021-03-31")
-
-		closing_balance = frappe.db.get_value(
-			"Account Closing Balance",
-			{
-				"account": "Sales - TPC",
-				"cost_center": cost_center1,
-				"period_closing_voucher": pcv1.name,
-				"is_period_closing_voucher_entry": 0,
-			},
-			["credit", "credit_in_account_currency"],
-			as_dict=1,
-		)
-
-		self.assertEqual(closing_balance.credit, 400)
-		self.assertEqual(closing_balance.credit_in_account_currency, 400)
-
-		jv3 = make_journal_entry(
-			posting_date="2022-03-15",
-			amount=300,
-			account1="Cash - TPC",
-			account2="Sales - TPC",
-			cost_center=cost_center2,
-			save=False,
-		)
-
-		jv3.company = company
-		jv3.save()
-		jv3.submit()
-
-		pcv2 = self.make_period_closing_voucher(posting_date="2022-03-31")
-
-		cc1_closing_balance = frappe.db.get_value(
-			"Account Closing Balance",
-			{
-				"account": "Sales - TPC",
-				"cost_center": cost_center1,
-				"period_closing_voucher": pcv2.name,
-				"is_period_closing_voucher_entry": 0,
-			},
-			["credit", "credit_in_account_currency"],
-			as_dict=1,
-		)
-
-		cc2_closing_balance = frappe.db.get_value(
-			"Account Closing Balance",
-			{
-				"account": "Sales - TPC",
-				"cost_center": cost_center2,
-				"period_closing_voucher": pcv2.name,
-				"is_period_closing_voucher_entry": 0,
-			},
-			["credit", "credit_in_account_currency"],
-			as_dict=1,
-		)
-
-		self.assertEqual(cc1_closing_balance.credit, 400)
-		self.assertEqual(cc1_closing_balance.credit_in_account_currency, 400)
-		self.assertEqual(cc2_closing_balance.credit, 500)
-		self.assertEqual(cc2_closing_balance.credit_in_account_currency, 500)
-
-	def make_period_closing_voucher(self, posting_date=None, submit=True):
+	def make_period_closing_voucher(self, submit=True):
 		surplus_account = create_account()
 		cost_center = create_cost_center("Test Cost Center 1")
 		pcv = frappe.get_doc(
 			{
 				"doctype": "Period Closing Voucher",
-				"transaction_date": posting_date or today(),
-				"posting_date": posting_date or today(),
+				"transaction_date": today(),
+				"posting_date": today(),
 				"company": "Test PCV Company",
 				"fiscal_year": get_fiscal_year(today(), company="Test PCV Company")[0],
 				"cost_center": cost_center,

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.py

@@ -21,24 +21,8 @@ class POSClosingEntry(StatusUpdater):
 		if frappe.db.get_value("POS Opening Entry", self.pos_opening_entry, "status") != "Open":
 			frappe.throw(_("Selected POS Opening Entry should be open."), title=_("Invalid Opening Entry"))
 
-		self.validate_duplicate_pos_invoices()
 		self.validate_pos_invoices()
 
-	def validate_duplicate_pos_invoices(self):
-		pos_occurences = {}
-		for idx, inv in enumerate(self.pos_transactions, 1):
-			pos_occurences.setdefault(inv.pos_invoice, []).append(idx)
-
-		error_list = []
-		for key, value in pos_occurences.items():
-			if len(value) > 1:
-				error_list.append(
-					_("{} is added multiple times on rows: {}".format(frappe.bold(key), frappe.bold(value)))
-				)
-
-		if error_list:
-			frappe.throw(error_list, title=_("Duplicate POS Invoices found"), as_list=True)
-
 	def validate_pos_invoices(self):
 		invalid_rows = []
 		for d in self.pos_transactions:

erpnext/accounts/doctype/pos_invoice/pos_invoice.js

@@ -112,8 +112,7 @@ erpnext.selling.POSInvoiceController = class POSInvoiceController extends erpnex
 				party_type: "Customer",
 				account: this.frm.doc.debit_to,
 				price_list: this.frm.doc.selling_price_list,
-				pos_profile: pos_profile,
-				company_address: this.frm.doc.company_address
+				pos_profile: pos_profile
 			}, () => {
 				this.apply_pricing_rule();
 			});

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -161,7 +161,7 @@ class POSInvoice(SalesInvoice):
 
 		bold_item_name = frappe.bold(item.item_name)
 		bold_extra_batch_qty_needed = frappe.bold(
-			abs(available_batch_qty - reserved_batch_qty - item.stock_qty)
+			abs(available_batch_qty - reserved_batch_qty - item.qty)
 		)
 		bold_invalid_batch_no = frappe.bold(item.batch_no)
 
@@ -172,7 +172,7 @@ class POSInvoice(SalesInvoice):
 				).format(item.idx, bold_invalid_batch_no, bold_item_name),
 				title=_("Item Unavailable"),
 			)
-		elif (available_batch_qty - reserved_batch_qty - item.stock_qty) < 0:
+		elif (available_batch_qty - reserved_batch_qty - item.qty) < 0:
 			frappe.throw(
 				_(
 					"Row #{}: Batch No. {} of item {} has less than required stock available, {} more required"
@@ -246,7 +246,7 @@ class POSInvoice(SalesInvoice):
 						),
 						title=_("Item Unavailable"),
 					)
-				elif is_stock_item and flt(available_stock) < flt(d.stock_qty):
+				elif is_stock_item and flt(available_stock) < flt(d.qty):
 					frappe.throw(
 						_(
 							"Row #{}: Stock quantity not enough for Item Code: {} under warehouse {}. Available quantity {}."
@@ -651,7 +651,7 @@ def get_bundle_availability(bundle_item_code, warehouse):
 		item_pos_reserved_qty = get_pos_reserved_qty(item.item_code, warehouse)
 		available_qty = item_bin_qty - item_pos_reserved_qty
 
-		max_available_bundles = available_qty / item.stock_qty
+		max_available_bundles = available_qty / item.qty
 		if bundle_bin_qty > max_available_bundles and frappe.get_value(
 			"Item", item.item_code, "is_stock_item"
 		):
@@ -675,7 +675,7 @@ def get_bin_qty(item_code, warehouse):
 
 def get_pos_reserved_qty(item_code, warehouse):
 	reserved_qty = frappe.db.sql(
-		"""select sum(p_item.stock_qty) as qty
+		"""select sum(p_item.qty) as qty
 		from `tabPOS Invoice` p, `tabPOS Invoice Item` p_item
 		where p.name = p_item.parent
 		and ifnull(p.consolidated_invoice, '') = ''

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -17,22 +17,6 @@ class POSInvoiceMergeLog(Document):
 	def validate(self):
 		self.validate_customer()
 		self.validate_pos_invoice_status()
-		self.validate_duplicate_pos_invoices()
-
-	def validate_duplicate_pos_invoices(self):
-		pos_occurences = {}
-		for idx, inv in enumerate(self.pos_invoices, 1):
-			pos_occurences.setdefault(inv.pos_invoice, []).append(idx)
-
-		error_list = []
-		for key, value in pos_occurences.items():
-			if len(value) > 1:
-				error_list.append(
-					_("{} is added multiple times on rows: {}".format(frappe.bold(key), frappe.bold(value)))
-				)
-
-		if error_list:
-			frappe.throw(error_list, title=_("Duplicate POS Invoices found"), as_list=True)
 
 	def validate_customer(self):
 		if self.merge_invoices_based_on == "Customer Group":
@@ -441,8 +425,6 @@ def create_merge_logs(invoice_by_customer, closing_entry=None):
 
 		if closing_entry:
 			closing_entry.set_status(update=True, status="Failed")
-			if type(error_message) == list:
-				error_message = frappe.json.dumps(error_message)
 			closing_entry.db_set("error_message", error_message)
 		raise
 

erpnext/accounts/doctype/pricing_rule/pricing_rule.json

@@ -472,7 +472,7 @@
    "description": "If rate is zero them item will be treated as \"Free Item\"",
    "fieldname": "free_item_rate",
    "fieldtype": "Currency",
-   "label": "Free Item Rate"
+   "label": "Rate"
   },
   {
    "collapsible": 1,
@@ -608,7 +608,7 @@
  "icon": "fa fa-gift",
  "idx": 1,
  "links": [],
- "modified": "2023-02-14 04:53:34.887358",
+ "modified": "2022-10-13 19:05:35.056304",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Pricing Rule",

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -10,7 +10,7 @@ import re
 import frappe
 from frappe import _, throw
 from frappe.model.document import Document
-from frappe.utils import cint, flt
+from frappe.utils import cint, flt, getdate
 
 apply_on_dict = {"Item Code": "items", "Item Group": "item_groups", "Brand": "brands"}
 
@@ -184,7 +184,8 @@ class PricingRule(Document):
 		if self.is_cumulative and not (self.valid_from and self.valid_upto):
 			frappe.throw(_("Valid from and valid upto fields are mandatory for the cumulative"))
 
-		self.validate_from_to_dates("valid_from", "valid_upto")
+		if self.valid_from and self.valid_upto and getdate(self.valid_from) > getdate(self.valid_upto):
+			frappe.throw(_("Valid from date must be less than valid upto date"))
 
 	def validate_condition(self):
 		if (
@@ -255,7 +256,7 @@ def apply_pricing_rule(args, doc=None):
 	for item in item_list:
 		args_copy = copy.deepcopy(args)
 		args_copy.update(item)
-		data = get_pricing_rule_for_item(args_copy, doc=doc)
+		data = get_pricing_rule_for_item(args_copy, item.get("price_list_rate"), doc=doc)
 		out.append(data)
 
 		if (
@@ -292,7 +293,7 @@ def update_pricing_rule_uom(pricing_rule, args):
 			pricing_rule.uom = row.uom
 
 
-def get_pricing_rule_for_item(args, doc=None, for_validate=False):
+def get_pricing_rule_for_item(args, price_list_rate=0, doc=None, for_validate=False):
 	from erpnext.accounts.doctype.pricing_rule.utils import (
 		get_applied_pricing_rules,
 		get_pricing_rule_items,

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -1123,7 +1123,7 @@ def make_pricing_rule(**args):
 			"apply_on": args.apply_on or "Item Code",
 			"applicable_for": args.applicable_for,
 			"selling": args.selling or 0,
-			"currency": "INR",
+			"currency": "USD",
 			"apply_discount_on_rate": args.apply_discount_on_rate or 0,
 			"buying": args.buying or 0,
 			"min_qty": args.min_qty or 0.0,

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -250,22 +250,6 @@ def get_other_conditions(conditions, values, args):
 			and ifnull(`tabPricing Rule`.valid_upto, '2500-12-31')"""
 		values["transaction_date"] = args.get("transaction_date")
 
-	if args.get("doctype") in [
-		"Quotation",
-		"Quotation Item",
-		"Sales Order",
-		"Sales Order Item",
-		"Delivery Note",
-		"Delivery Note Item",
-		"Sales Invoice",
-		"Sales Invoice Item",
-		"POS Invoice",
-		"POS Invoice Item",
-	]:
-		conditions += """ and ifnull(`tabPricing Rule`.selling, 0) = 1"""
-	else:
-		conditions += """ and ifnull(`tabPricing Rule`.buying, 0) = 1"""
-
 	return conditions
 
 
@@ -685,23 +669,13 @@ def get_product_discount_rule(pricing_rule, item_details, args=None, doc=None):
 	item_details.free_item_data.append(free_item_data_args)
 
 
-def apply_pricing_rule_for_free_items(doc, pricing_rule_args):
+def apply_pricing_rule_for_free_items(doc, pricing_rule_args, set_missing_values=False):
 	if pricing_rule_args:
-		args = {(d["item_code"], d["pricing_rules"]): d for d in pricing_rule_args}
+		items = tuple((d.item_code, d.pricing_rules) for d in doc.items if d.is_free_item)
 
-		for item in doc.items:
-			if not item.is_free_item:
-				continue
-
-			free_item_data = args.get((item.item_code, item.pricing_rules))
-			if free_item_data:
-				free_item_data.pop("item_name")
-				free_item_data.pop("description")
-				item.update(free_item_data)
-				args.pop((item.item_code, item.pricing_rules))
-
-		for free_item in args.values():
-			doc.append("items", free_item)
+		for args in pricing_rule_args:
+			if not items or (args.get("item_code"), args.get("pricing_rules")) not in items:
+				doc.append("items", args)
 
 
 def get_pricing_rule_items(pr_doc, other_items=False) -> list:

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html

@@ -15,7 +15,7 @@
 	</div>
 	<h2 class="text-center">{{ _("STATEMENTS OF ACCOUNTS") }}</h2>
 	<div>
-		<h5 style="float: left;">{{ _("Customer: ") }} <b>{{filters.party_name[0] }}</b></h5>
+		<h5 style="float: left;">{{ _("Customer: ") }} <b>{{filters.party[0] }}</b></h5>
 		<h5 style="float: right;">
 			{{ _("Date: ") }}
 			<b>{{ frappe.format(filters.from_date, 'Date')}}
@@ -49,6 +49,7 @@
 						<br>
 					{% endif %}
 
+					{{ _("Against") }}: {{ row.against }}
 					<br>{{ _("Remarks") }}: {{ row.remarks }}
 					{% if row.bill_no %}
 						<br>{{ _("Supplier Invoice No") }}: {{ row.bill_no }}

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -24,7 +24,7 @@ from erpnext.accounts.report.general_ledger.general_ledger import execute as get
 class ProcessStatementOfAccounts(Document):
 	def validate(self):
 		if not self.subject:
-			self.subject = "Statement Of Accounts for {{ customer.customer_name }}"
+			self.subject = "Statement Of Accounts for {{ customer.name }}"
 		if not self.body:
 			self.body = "Hello {{ customer.name }},<br>PFA your Statement Of Accounts from {{ doc.from_date }} to {{ doc.to_date }}."
 
@@ -87,7 +87,6 @@ def get_report_pdf(doc, consolidated=True):
 				"account": [doc.account] if doc.account else None,
 				"party_type": "Customer",
 				"party": [entry.customer],
-				"party_name": [entry.customer_name] if entry.customer_name else None,
 				"presentation_currency": presentation_currency,
 				"group_by": doc.group_by,
 				"currency": doc.currency,
@@ -157,7 +156,7 @@ def get_customers_based_on_territory_or_customer_group(customer_collection, coll
 	]
 	return frappe.get_list(
 		"Customer",
-		fields=["name", "customer_name", "email_id"],
+		fields=["name", "email_id"],
 		filters=[[fields_dict[customer_collection], "IN", selected]],
 	)
 
@@ -180,7 +179,7 @@ def get_customers_based_on_sales_person(sales_person):
 	if sales_person_records.get("Customer"):
 		return frappe.get_list(
 			"Customer",
-			fields=["name", "customer_name", "email_id"],
+			fields=["name", "email_id"],
 			filters=[["name", "in", list(sales_person_records["Customer"])]],
 		)
 	else:
@@ -229,7 +228,7 @@ def fetch_customers(customer_collection, collection_name, primary_mandatory):
 		if customer_collection == "Sales Partner":
 			customers = frappe.get_list(
 				"Customer",
-				fields=["name", "customer_name", "email_id"],
+				fields=["name", "email_id"],
 				filters=[["default_sales_partner", "=", collection_name]],
 			)
 		else:
@@ -246,12 +245,7 @@ def fetch_customers(customer_collection, collection_name, primary_mandatory):
 				continue
 
 		customer_list.append(
-			{
-				"name": customer.name,
-				"customer_name": customer.customer_name,
-				"primary_email": primary_email,
-				"billing_email": billing_email,
-			}
+			{"name": customer.name, "primary_email": primary_email, "billing_email": billing_email}
 		)
 	return customer_list
 

erpnext/accounts/doctype/process_statement_of_accounts_customer/process_statement_of_accounts_customer.json

@@ -1,12 +1,12 @@
 {
  "actions": [],
+ "allow_workflow": 1,
  "creation": "2020-08-03 16:35:21.852178",
  "doctype": "DocType",
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
   "customer",
-  "customer_name",
   "billing_email",
   "primary_email"
  ],
@@ -30,18 +30,11 @@
    "fieldtype": "Read Only",
    "in_list_view": 1,
    "label": "Billing Email"
-  },
-  {
-   "fetch_from": "customer.customer_name",
-   "fieldname": "customer_name",
-   "fieldtype": "Data",
-   "label": "Customer Name",
-   "read_only": 1
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2023-03-13 00:12:34.508086",
+ "modified": "2020-08-03 22:55:38.875601",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts Customer",
@@ -50,6 +43,5 @@
  "quick_entry": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -31,7 +31,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"];
+		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry', 'Purchase Invoice'];
 
 		if(!this.frm.doc.__islocal) {
 			// show credit_to in print format
@@ -82,11 +82,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 
 		if(doc.docstatus == 1 && doc.outstanding_amount != 0
 			&& !(doc.is_return && doc.return_against) && !doc.on_hold) {
-			this.frm.add_custom_button(
-				__('Payment'),
-				() => this.make_payment_entry(),
-				__('Create')
-			);
+			this.frm.add_custom_button(__('Payment'), this.make_payment_entry, __('Create'));
 			cur_frm.page.set_inner_btn_group_as_primary(__('Create'));
 		}
 

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -64,13 +64,12 @@
   "tax_withholding_net_total",
   "base_tax_withholding_net_total",
   "taxes_section",
-  "tax_category",
   "taxes_and_charges",
   "column_break_58",
-  "shipping_rule",
+  "tax_category",
   "column_break_49",
+  "shipping_rule",
   "incoterm",
-  "named_place",
   "section_break_51",
   "taxes",
   "totals",
@@ -118,7 +117,6 @@
   "paid_amount",
   "advances_section",
   "allocate_advances_automatically",
-  "only_include_allocated_payments",
   "get_advances",
   "advances",
   "advance_tax",
@@ -1427,7 +1425,6 @@
   },
   {
    "default": "0",
-   "depends_on": "apply_tds",
    "fieldname": "tax_withholding_net_total",
    "fieldtype": "Currency",
    "hidden": 1,
@@ -1437,13 +1434,12 @@
    "read_only": 1
   },
   {
-   "depends_on": "apply_tds",
    "fieldname": "base_tax_withholding_net_total",
    "fieldtype": "Currency",
    "hidden": 1,
    "label": "Base Tax Withholding Net Total",
    "no_copy": 1,
-   "options": "Company:company:default_currency",
+   "options": "currency",
    "print_hide": 1,
    "read_only": 1
   },
@@ -1545,30 +1541,17 @@
    "fieldtype": "Link",
    "label": "Incoterm",
    "options": "Incoterm"
-  },
-  {
-   "depends_on": "incoterm",
-   "fieldname": "named_place",
-   "fieldtype": "Data",
-   "label": "Named Place"
-  },
-  {
-   "default": "0",
-   "depends_on": "allocate_advances_automatically",
-   "description": "Advance payments allocated against orders will only be fetched",
-   "fieldname": "only_include_allocated_payments",
-   "fieldtype": "Check",
-   "label": "Only Include Allocated Payments"
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-04-03 22:57:14.074982",
+ "modified": "2022-11-25 12:44:29.935567",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",
+ "name_case": "Title Case",
  "naming_rule": "By \"Naming Series\" field",
  "owner": "Administrator",
  "permissions": [

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -5,7 +5,6 @@
 import frappe
 from frappe import _, throw
 from frappe.model.mapper import get_mapped_doc
-from frappe.query_builder.functions import Sum
 from frappe.utils import cint, cstr, flt, formatdate, get_link_to_form, getdate, nowdate
 
 import erpnext
@@ -117,7 +116,7 @@ class PurchaseInvoice(BuyingController):
 		self.validate_expense_account()
 		self.set_against_expense_account()
 		self.validate_write_off_account()
-		self.validate_multiple_billing("Purchase Receipt", "pr_detail", "amount")
+		self.validate_multiple_billing("Purchase Receipt", "pr_detail", "amount", "items")
 		self.create_remarks()
 		self.set_status()
 		self.validate_purchase_receipt_if_update_stock()
@@ -232,9 +231,7 @@ class PurchaseInvoice(BuyingController):
 		)
 
 		if (
-			cint(frappe.get_cached_value("Buying Settings", "None", "maintain_same_rate"))
-			and not self.is_return
-			and not self.is_internal_supplier
+			cint(frappe.db.get_single_value("Buying Settings", "maintain_same_rate")) and not self.is_return
 		):
 			self.validate_rate_with_reference_doc(
 				[
@@ -581,7 +578,6 @@ class PurchaseInvoice(BuyingController):
 
 		self.make_supplier_gl_entry(gl_entries)
 		self.make_item_gl_entries(gl_entries)
-		self.make_precision_loss_gl_entry(gl_entries)
 
 		if self.check_asset_cwip_enabled():
 			self.get_asset_gl_entry(gl_entries)
@@ -976,28 +972,6 @@ 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
-		)
-
-		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": self.cost_center or round_off_cost_center,
-						"remarks": _("Net total calculation precision loss"),
-					}
-				)
-			)
-
 	def get_asset_gl_entry(self, gl_entries):
 		arbnb_account = self.get_company_default("asset_received_but_not_billed")
 		eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
@@ -1440,8 +1414,6 @@ class PurchaseInvoice(BuyingController):
 			"GL Entry",
 			"Stock Ledger Entry",
 			"Repost Item Valuation",
-			"Repost Payment Ledger",
-			"Repost Payment Ledger Items",
 			"Payment Ledger Entry",
 			"Tax Withheld Vouchers",
 		)
@@ -1489,16 +1461,19 @@ class PurchaseInvoice(BuyingController):
 	def update_billing_status_in_pr(self, update_modified=True):
 		updated_pr = []
 		po_details = []
-
-		pr_details_billed_amt = self.get_pr_details_billed_amt()
-
 		for d in self.get("items"):
 			if d.pr_detail:
+				billed_amt = frappe.db.sql(
+					"""select sum(amount) from `tabPurchase Invoice Item`
+					where pr_detail=%s and docstatus=1""",
+					d.pr_detail,
+				)
+				billed_amt = billed_amt and billed_amt[0][0] or 0
 				frappe.db.set_value(
 					"Purchase Receipt Item",
 					d.pr_detail,
 					"billed_amt",
-					flt(pr_details_billed_amt.get(d.pr_detail)),
+					billed_amt,
 					update_modified=update_modified,
 				)
 				updated_pr.append(d.purchase_receipt)
@@ -1508,35 +1483,11 @@ class PurchaseInvoice(BuyingController):
 		if po_details:
 			updated_pr += update_billed_amount_based_on_po(po_details, update_modified)
 
-		adjust_incoming_rate = frappe.db.get_single_value(
-			"Buying Settings", "set_landed_cost_based_on_purchase_invoice_rate"
-		)
-
 		for pr in set(updated_pr):
 			from erpnext.stock.doctype.purchase_receipt.purchase_receipt import update_billing_percentage
 
 			pr_doc = frappe.get_doc("Purchase Receipt", pr)
-			update_billing_percentage(
-				pr_doc, update_modified=update_modified, adjust_incoming_rate=adjust_incoming_rate
-			)
-
-	def get_pr_details_billed_amt(self):
-		# Get billed amount based on purchase receipt item reference (pr_detail) in purchase invoice
-
-		pr_details_billed_amt = {}
-		pr_details = [d.get("pr_detail") for d in self.get("items") if d.get("pr_detail")]
-		if pr_details:
-			doctype = frappe.qb.DocType("Purchase Invoice Item")
-			query = (
-				frappe.qb.from_(doctype)
-				.select(doctype.pr_detail, Sum(doctype.amount))
-				.where(doctype.pr_detail.isin(pr_details) & doctype.docstatus == 1)
-				.groupby(doctype.pr_detail)
-			)
-
-			pr_details_billed_amt = frappe._dict(query.run(as_list=1))
-
-		return pr_details_billed_amt
+			update_billing_percentage(pr_doc, update_modified=update_modified)
 
 	def on_recurring(self, reference_doc, auto_repeat_doc):
 		self.due_date = None

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -1523,94 +1523,6 @@ class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 		company.enable_provisional_accounting_for_non_stock_items = 0
 		company.save()
 
-	def test_adjust_incoming_rate(self):
-		frappe.db.set_single_value("Buying Settings", "maintain_same_rate", 0)
-
-		frappe.db.set_single_value(
-			"Buying Settings", "set_landed_cost_based_on_purchase_invoice_rate", 1
-		)
-
-		# Increase the cost of the item
-
-		pr = make_purchase_receipt(qty=1, rate=100)
-
-		stock_value_difference = frappe.db.get_value(
-			"Stock Ledger Entry",
-			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
-			"stock_value_difference",
-		)
-		self.assertEqual(stock_value_difference, 100)
-
-		pi = create_purchase_invoice_from_receipt(pr.name)
-		for row in pi.items:
-			row.rate = 150
-
-		pi.save()
-		pi.submit()
-
-		stock_value_difference = frappe.db.get_value(
-			"Stock Ledger Entry",
-			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
-			"stock_value_difference",
-		)
-		self.assertEqual(stock_value_difference, 150)
-
-		# Reduce the cost of the item
-
-		pr = make_purchase_receipt(qty=1, rate=100)
-
-		stock_value_difference = frappe.db.get_value(
-			"Stock Ledger Entry",
-			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
-			"stock_value_difference",
-		)
-		self.assertEqual(stock_value_difference, 100)
-
-		pi = create_purchase_invoice_from_receipt(pr.name)
-		for row in pi.items:
-			row.rate = 50
-
-		pi.save()
-		pi.submit()
-
-		stock_value_difference = frappe.db.get_value(
-			"Stock Ledger Entry",
-			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
-			"stock_value_difference",
-		)
-		self.assertEqual(stock_value_difference, 50)
-
-		frappe.db.set_single_value(
-			"Buying Settings", "set_landed_cost_based_on_purchase_invoice_rate", 0
-		)
-
-		# Don't adjust incoming rate
-
-		pr = make_purchase_receipt(qty=1, rate=100)
-
-		stock_value_difference = frappe.db.get_value(
-			"Stock Ledger Entry",
-			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
-			"stock_value_difference",
-		)
-		self.assertEqual(stock_value_difference, 100)
-
-		pi = create_purchase_invoice_from_receipt(pr.name)
-		for row in pi.items:
-			row.rate = 50
-
-		pi.save()
-		pi.submit()
-
-		stock_value_difference = frappe.db.get_value(
-			"Stock Ledger Entry",
-			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
-			"stock_value_difference",
-		)
-		self.assertEqual(stock_value_difference, 100)
-
-		frappe.db.set_single_value("Buying Settings", "maintain_same_rate", 1)
-
 	def test_item_less_defaults(self):
 
 		pi = frappe.new_doc("Purchase Invoice")

erpnext/accounts/doctype/repost_payment_ledger/repost_payment_ledger.py

@@ -7,6 +7,7 @@ import frappe
 from frappe import _, qb
 from frappe.model.document import Document
 from frappe.query_builder.custom import ConstantColumn
+from frappe.utils.background_jobs import is_job_queued
 
 from erpnext.accounts.utils import _delete_pl_entries, create_payment_ledger_entry
 
@@ -26,7 +27,7 @@ def start_payment_ledger_repost(docname=None):
 	"""
 	if docname:
 		repost_doc = frappe.get_doc("Repost Payment Ledger", docname)
-		if repost_doc.docstatus.is_submitted() and repost_doc.repost_status in ["Queued", "Failed"]:
+		if repost_doc.docstatus == 1 and repost_doc.repost_status in ["Queued", "Failed"]:
 			try:
 				for entry in repost_doc.repost_vouchers:
 					doc = frappe.get_doc(entry.voucher_type, entry.voucher_no)
@@ -101,9 +102,10 @@ def execute_repost_payment_ledger(docname):
 
 	job_name = "payment_ledger_repost_" + docname
 
-	frappe.enqueue(
-		method="erpnext.accounts.doctype.repost_payment_ledger.repost_payment_ledger.start_payment_ledger_repost",
-		docname=docname,
-		is_async=True,
-		job_name=job_name,
-	)
+	if not is_job_queued(job_name):
+		frappe.enqueue(
+			method="erpnext.accounts.doctype.repost_payment_ledger.repost_payment_ledger.start_payment_ledger_repost",
+			docname=docname,
+			is_async=True,
+			job_name=job_name,
+		)

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -34,7 +34,7 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 		super.onload();
 
 		this.frm.ignore_doctypes_on_cancel_all = ['POS Invoice', 'Timesheet', 'POS Invoice Merge Log',
-							  'POS Closing Entry', 'Journal Entry', 'Payment Entry', "Repost Payment Ledger"];
+			'POS Closing Entry', 'Journal Entry', 'Payment Entry'];
 
 		if(!this.frm.doc.__islocal && !this.frm.doc.customer && this.frm.doc.debit_to) {
 			// show debit_to in print format
@@ -93,12 +93,9 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 
 		if (doc.docstatus == 1 && doc.outstanding_amount!=0
 			&& !(cint(doc.is_return) && doc.return_against)) {
-			this.frm.add_custom_button(
-				__('Payment'),
-				() => this.make_payment_entry(),
-				__('Create')
-			);
-			this.frm.page.set_inner_btn_group_as_primary(__('Create'));
+			cur_frm.add_custom_button(__('Payment'),
+				this.make_payment_entry, __('Create'));
+			cur_frm.page.set_inner_btn_group_as_primary(__('Create'));
 		}
 
 		if(doc.docstatus==1 && !doc.is_return) {

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -32,6 +32,9 @@
   "cost_center",
   "dimension_col_break",
   "project",
+  "column_break_27",
+  "campaign",
+  "source",
   "currency_and_price_list",
   "currency",
   "conversion_rate",
@@ -58,13 +61,12 @@
   "total",
   "net_total",
   "taxes_section",
-  "tax_category",
   "taxes_and_charges",
   "column_break_38",
   "shipping_rule",
-  "column_break_55",
   "incoterm",
-  "named_place",
+  "column_break_55",
+  "tax_category",
   "section_break_40",
   "taxes",
   "section_break_43",
@@ -120,7 +122,6 @@
   "account_for_change_amount",
   "advances_section",
   "allocate_advances_automatically",
-  "only_include_allocated_payments",
   "get_advances",
   "advances",
   "write_off_section",
@@ -201,9 +202,7 @@
   "more_information",
   "status",
   "inter_company_invoice_reference",
-  "campaign",
   "represents_company",
-  "source",
   "customer_group",
   "col_break23",
   "is_internal_customer",
@@ -922,7 +921,6 @@
    "fieldtype": "Table",
    "hide_days": 1,
    "hide_seconds": 1,
-   "label": "Sales Taxes and Charges",
    "oldfieldname": "other_charges",
    "oldfieldtype": "Table",
    "options": "Sales Taxes and Charges"
@@ -1776,8 +1774,6 @@
    "width": "50%"
   },
   {
-   "fetch_from": "sales_partner.commission_rate",
-   "fetch_if_empty": 1,
    "fieldname": "commission_rate",
    "fieldtype": "Float",
    "hide_days": 1,
@@ -2083,6 +2079,10 @@
    "fieldname": "company_addr_col_break",
    "fieldtype": "Column Break"
   },
+  {
+   "fieldname": "column_break_27",
+   "fieldtype": "Column Break"
+  },
   {
    "fieldname": "column_break_52",
    "fieldtype": "Column Break"
@@ -2121,20 +2121,6 @@
    "fieldtype": "Link",
    "label": "Incoterm",
    "options": "Incoterm"
-  },
-  {
-   "depends_on": "incoterm",
-   "fieldname": "named_place",
-   "fieldtype": "Data",
-   "label": "Named Place"
-  },
-  {
-   "default": "0",
-   "depends_on": "allocate_advances_automatically",
-   "description": "Advance payments allocated against orders will only be fetched",
-   "fieldname": "only_include_allocated_payments",
-   "fieldtype": "Check",
-   "label": "Only Include Allocated Payments"
   }
  ],
  "icon": "fa fa-file-text",
@@ -2147,10 +2133,11 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2023-04-03 22:55:14.206473",
+ "modified": "2022-11-17 17:17:10.883487",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",
+ "name_case": "Title Case",
  "naming_rule": "By \"Naming Series\" field",
  "owner": "Administrator",
  "permissions": [

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -145,7 +145,7 @@ class SalesInvoice(SellingController):
 
 		self.set_against_income_account()
 		self.validate_time_sheets_are_submitted()
-		self.validate_multiple_billing("Delivery Note", "dn_detail", "amount")
+		self.validate_multiple_billing("Delivery Note", "dn_detail", "amount", "items")
 		if not self.is_return:
 			self.validate_serial_numbers()
 		else:
@@ -397,8 +397,6 @@ class SalesInvoice(SellingController):
 			"GL Entry",
 			"Stock Ledger Entry",
 			"Repost Item Valuation",
-			"Repost Payment Ledger",
-			"Repost Payment Ledger Items",
 			"Payment Ledger Entry",
 		)
 
@@ -1187,24 +1185,11 @@ class SalesInvoice(SellingController):
 						if asset.calculate_depreciation:
 							posting_date = frappe.db.get_value("Sales Invoice", self.return_against, "posting_date")
 							reverse_depreciation_entry_made_after_disposal(asset, posting_date)
-							notes = _(
-								"This schedule was created when Asset {0} was returned after being sold through Sales Invoice {1}."
-							).format(
-								get_link_to_form(asset.doctype, asset.name),
-								get_link_to_form(self.doctype, self.get("name")),
-							)
-							reset_depreciation_schedule(asset, self.posting_date, notes)
-							asset.reload()
+							reset_depreciation_schedule(asset, self.posting_date)
 
 					else:
 						if asset.calculate_depreciation:
-							notes = _(
-								"This schedule was created when Asset {0} was sold through Sales Invoice {1}."
-							).format(
-								get_link_to_form(asset.doctype, asset.name),
-								get_link_to_form(self.doctype, self.get("name")),
-							)
-							depreciate_asset(asset, self.posting_date, notes)
+							depreciate_asset(asset, self.posting_date)
 							asset.reload()
 
 						fixed_asset_gl_entries = get_gl_entries_on_asset_disposal(

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -21,9 +21,6 @@ from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_inter_comp
 from erpnext.accounts.utils import PaymentEntryUnlinkError
 from erpnext.assets.doctype.asset.depreciation import post_depreciation_entries
 from erpnext.assets.doctype.asset.test_asset import create_asset, create_asset_data
-from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
-	get_depr_schedule,
-)
 from erpnext.controllers.accounts_controller import update_invoice_status
 from erpnext.controllers.taxes_and_totals import get_itemised_tax_breakup_data
 from erpnext.exceptions import InvalidAccountCurrency, InvalidCurrency
@@ -266,16 +263,16 @@ class TestSalesInvoice(unittest.TestCase):
 			"_Test Account Education Cess - _TC": [3, 1618, 0.06, 32.36],
 			"_Test Account S&H Education Cess - _TC": [1.5, 1619.5, 0.03, 32.39],
 			"_Test Account CST - _TC": [32.5, 1652, 0.65, 33.04],
-			"_Test Account VAT - _TC": [156.0, 1808.0, 3.12, 36.16],
-			"_Test Account Discount - _TC": [-181.0, 1627.0, -3.62, 32.54],
+			"_Test Account VAT - _TC": [156.5, 1808.5, 3.13, 36.17],
+			"_Test Account Discount - _TC": [-181.0, 1627.5, -3.62, 32.55],
 		}
 
 		for d in si.get("taxes"):
 			for i, k in enumerate(expected_values["keys"]):
 				self.assertEqual(d.get(k), expected_values[d.account_head][i])
 
-		self.assertEqual(si.base_grand_total, 1627.0)
-		self.assertEqual(si.grand_total, 32.54)
+		self.assertEqual(si.base_grand_total, 1627.5)
+		self.assertEqual(si.grand_total, 32.55)
 
 	def test_sales_invoice_with_discount_and_inclusive_tax(self):
 		si = create_sales_invoice(qty=100, rate=50, do_not_save=True)
@@ -401,10 +398,10 @@ class TestSalesInvoice(unittest.TestCase):
 			"_Test Account S&H Education Cess - _TC": [1.4, 1.30, 1297.67],
 			"_Test Account CST - _TC": [27.88, 25.95, 1323.62],
 			"_Test Account VAT - _TC": [156.25, 145.43, 1469.05],
-			"_Test Account Customs Duty - _TC": [125, 116.34, 1585.39],
-			"_Test Account Shipping Charges - _TC": [100, 100, 1685.39],
-			"_Test Account Discount - _TC": [-180.33, -168.54, 1516.85],
-			"_Test Account Service Tax - _TC": [-18.03, -16.85, 1500.00],
+			"_Test Account Customs Duty - _TC": [125, 116.35, 1585.40],
+			"_Test Account Shipping Charges - _TC": [100, 100, 1685.40],
+			"_Test Account Discount - _TC": [-180.33, -168.54, 1516.86],
+			"_Test Account Service Tax - _TC": [-18.03, -16.85, 1500.01],
 		}
 
 		for d in si.get("taxes"):
@@ -413,7 +410,7 @@ class TestSalesInvoice(unittest.TestCase):
 
 		self.assertEqual(si.base_grand_total, 1500)
 		self.assertEqual(si.grand_total, 1500)
-		self.assertEqual(si.rounding_adjustment, 0.0)
+		self.assertEqual(si.rounding_adjustment, -0.01)
 
 	def test_discount_amount_gl_entry(self):
 		frappe.db.set_value("Company", "_Test Company", "round_off_account", "Round Off - _TC")
@@ -454,7 +451,7 @@ class TestSalesInvoice(unittest.TestCase):
 				[test_records[3]["taxes"][2]["account_head"], 0.0, 1.30],
 				[test_records[3]["taxes"][3]["account_head"], 0.0, 25.95],
 				[test_records[3]["taxes"][4]["account_head"], 0.0, 145.43],
-				[test_records[3]["taxes"][5]["account_head"], 0.0, 116.34],
+				[test_records[3]["taxes"][5]["account_head"], 0.0, 116.35],
 				[test_records[3]["taxes"][6]["account_head"], 0.0, 100],
 				[test_records[3]["taxes"][7]["account_head"], 168.54, 0.0],
 				["_Test Account Service Tax - _TC", 16.85, 0.0],
@@ -1169,46 +1166,6 @@ class TestSalesInvoice(unittest.TestCase):
 
 		frappe.db.sql("delete from `tabPOS Profile`")
 
-	def test_bin_details_of_packed_item(self):
-		from erpnext.selling.doctype.product_bundle.test_product_bundle import make_product_bundle
-		from erpnext.stock.doctype.item.test_item import make_item
-
-		# test Update Items with product bundle
-		if not frappe.db.exists("Item", "_Test Product Bundle Item New"):
-			bundle_item = make_item("_Test Product Bundle Item New", {"is_stock_item": 0})
-			bundle_item.append(
-				"item_defaults", {"company": "_Test Company", "default_warehouse": "_Test Warehouse - _TC"}
-			)
-			bundle_item.save(ignore_permissions=True)
-
-		make_item("_Packed Item New 1", {"is_stock_item": 1})
-		make_product_bundle("_Test Product Bundle Item New", ["_Packed Item New 1"], 2)
-
-		si = create_sales_invoice(
-			item_code="_Test Product Bundle Item New",
-			update_stock=1,
-			warehouse="_Test Warehouse - _TC",
-			transaction_date=add_days(nowdate(), -1),
-			do_not_submit=1,
-		)
-
-		make_stock_entry(item="_Packed Item New 1", target="_Test Warehouse - _TC", qty=120, rate=100)
-
-		bin_details = frappe.db.get_value(
-			"Bin",
-			{"item_code": "_Packed Item New 1", "warehouse": "_Test Warehouse - _TC"},
-			["actual_qty", "projected_qty", "ordered_qty"],
-			as_dict=1,
-		)
-
-		si.transaction_date = nowdate()
-		si.save()
-
-		packed_item = si.packed_items[0]
-		self.assertEqual(flt(bin_details.actual_qty), flt(packed_item.actual_qty))
-		self.assertEqual(flt(bin_details.projected_qty), flt(packed_item.projected_qty))
-		self.assertEqual(flt(bin_details.ordered_qty), flt(packed_item.ordered_qty))
-
 	def test_pos_si_without_payment(self):
 		make_pos_profile()
 
@@ -1614,7 +1571,7 @@ class TestSalesInvoice(unittest.TestCase):
 			"_Test Account Education Cess - _TC": [1.4, 1.4, 1.4],
 			"_Test Account S&H Education Cess - _TC": [0.7, 0.7, 0.7],
 			"_Test Account CST - _TC": [17.19, 17.19, 17.19],
-			"_Test Account VAT - _TC": [78.12, 78.12, 78.12],
+			"_Test Account VAT - _TC": [78.13, 78.13, 78.13],
 			"_Test Account Discount - _TC": [-95.49, -95.49, -95.49],
 		}
 
@@ -1623,9 +1580,9 @@ class TestSalesInvoice(unittest.TestCase):
 				if expected_values.get(d.account_head):
 					self.assertEqual(d.get(k), expected_values[d.account_head][i])
 
-		self.assertEqual(si.total_taxes_and_charges, 234.42)
-		self.assertEqual(si.base_grand_total, 859.42)
-		self.assertEqual(si.grand_total, 859.42)
+		self.assertEqual(si.total_taxes_and_charges, 234.43)
+		self.assertEqual(si.base_grand_total, 859.43)
+		self.assertEqual(si.grand_total, 859.43)
 
 	def test_multi_currency_gle(self):
 		si = create_sales_invoice(
@@ -1985,17 +1942,17 @@ class TestSalesInvoice(unittest.TestCase):
 			)
 		si.save()
 		si.submit()
-		self.assertEqual(si.net_total, 19453.12)
+		self.assertEqual(si.net_total, 19453.13)
 		self.assertEqual(si.grand_total, 24900)
 		self.assertEqual(si.total_taxes_and_charges, 5446.88)
-		self.assertEqual(si.rounding_adjustment, 0.0)
+		self.assertEqual(si.rounding_adjustment, -0.01)
 
 		expected_values = dict(
 			(d[0], d)
 			for d in [
 				[si.debit_to, 24900, 0.0],
 				["_Test Account Service Tax - _TC", 0.0, 5446.88],
-				["Sales - _TC", 0.0, 19453.12],
+				["Sales - _TC", 0.0, 19453.13],
 				["Round Off - _TC", 0.01, 0.0],
 			]
 		)
@@ -2817,7 +2774,7 @@ class TestSalesInvoice(unittest.TestCase):
 			["2021-09-30", 5041.1, 26407.22],
 		]
 
-		for i, schedule in enumerate(get_depr_schedule(asset.name, "Active")):
+		for i, schedule in enumerate(asset.schedules):
 			self.assertEqual(getdate(expected_values[i][0]), schedule.schedule_date)
 			self.assertEqual(expected_values[i][1], schedule.depreciation_amount)
 			self.assertEqual(expected_values[i][2], schedule.accumulated_depreciation_amount)
@@ -2848,7 +2805,7 @@ class TestSalesInvoice(unittest.TestCase):
 
 		expected_values = [["2020-12-31", 30000, 30000], ["2021-12-31", 30000, 60000]]
 
-		for i, schedule in enumerate(get_depr_schedule(asset.name, "Active")):
+		for i, schedule in enumerate(asset.schedules):
 			self.assertEqual(getdate(expected_values[i][0]), schedule.schedule_date)
 			self.assertEqual(expected_values[i][1], schedule.depreciation_amount)
 			self.assertEqual(expected_values[i][2], schedule.accumulated_depreciation_amount)
@@ -2877,7 +2834,7 @@ class TestSalesInvoice(unittest.TestCase):
 			["2025-06-06", 18633.88, 100000.0, False],
 		]
 
-		for i, schedule in enumerate(get_depr_schedule(asset.name, "Active")):
+		for i, schedule in enumerate(asset.schedules):
 			self.assertEqual(getdate(expected_values[i][0]), schedule.schedule_date)
 			self.assertEqual(expected_values[i][1], schedule.depreciation_amount)
 			self.assertEqual(expected_values[i][2], schedule.accumulated_depreciation_amount)

erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.json

@@ -890,7 +890,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2022-12-28 16:17:33.484531",
+ "modified": "2022-11-02 12:53:12.693217",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Item",

erpnext/accounts/doctype/subscription/subscription.py

@@ -280,8 +280,7 @@ class Subscription(Document):
 		self.validate_plans_billing_cycle(self.get_billing_cycle_and_interval())
 		self.validate_end_date()
 		self.validate_to_follow_calendar_months()
-		if not self.cost_center:
-			self.cost_center = erpnext.get_default_cost_center(self.get("company"))
+		self.cost_center = erpnext.get_default_cost_center(self.get("company"))
 
 	def validate_trial_period(self):
 		"""

erpnext/accounts/doctype/subscription_plan/subscription_plan.js

@@ -5,9 +5,5 @@ frappe.ui.form.on('Subscription Plan', {
 	price_determination: function(frm) {
 		frm.toggle_reqd("cost", frm.doc.price_determination === 'Fixed rate');
 		frm.toggle_reqd("price_list", frm.doc.price_determination === 'Based on price list');
-	},
-
-	subscription_plan: function (frm) {
-		erpnext.utils.check_payments_app();
-	},
+	}
 });

erpnext/accounts/doctype/tax_rule/tax_rule.py

@@ -32,7 +32,7 @@ class TaxRule(Document):
 
 	def validate(self):
 		self.validate_tax_template()
-		self.validate_from_to_dates("from_date", "to_date")
+		self.validate_date()
 		self.validate_filters()
 		self.validate_use_for_shopping_cart()
 
@@ -51,6 +51,10 @@ class TaxRule(Document):
 		if not (self.sales_tax_template or self.purchase_tax_template):
 			frappe.throw(_("Tax Template is mandatory."))
 
+	def validate_date(self):
+		if self.from_date and self.to_date and self.from_date > self.to_date:
+			frappe.throw(_("From Date cannot be greater than To Date"))
+
 	def validate_filters(self):
 		filters = {
 			"tax_type": self.tax_type,

erpnext/accounts/doctype/tax_withheld_vouchers/tax_withheld_vouchers.json

@@ -1,6 +1,6 @@
 {
  "actions": [],
- "autoname": "hash",
+ "autoname": "autoincrement",
  "creation": "2022-09-13 16:18:59.404842",
  "doctype": "DocType",
  "editable_grid": 1,
@@ -36,11 +36,11 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-01-13 13:40:41.479208",
+ "modified": "2022-09-13 23:40:41.479208",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Tax Withheld Vouchers",
- "naming_rule": "Random",
+ "naming_rule": "Autoincrement",
  "owner": "Administrator",
  "permissions": [],
  "sort_field": "modified",

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py

@@ -121,24 +121,12 @@ def get_party_tax_withholding_details(inv, tax_withholding_category=None):
 	else:
 		tax_row = get_tax_row_for_tcs(inv, tax_details, tax_amount, tax_deducted)
 
-	cost_center = get_cost_center(inv)
-	tax_row.update({"cost_center": cost_center})
-
 	if inv.doctype == "Purchase Invoice":
 		return tax_row, tax_deducted_on_advances, voucher_wise_amount
 	else:
 		return tax_row
 
 
-def get_cost_center(inv):
-	cost_center = frappe.get_cached_value("Company", inv.company, "cost_center")
-
-	if len(inv.get("taxes", [])) > 0:
-		cost_center = inv.get("taxes")[0].cost_center
-
-	return cost_center
-
-
 def get_tax_withholding_details(tax_withholding_category, posting_date, company):
 	tax_withholding = frappe.get_doc("Tax Withholding Category", tax_withholding_category)
 
@@ -259,7 +247,9 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 		if tax_deducted:
 			net_total = inv.tax_withholding_net_total
 			if ldc:
-				tax_amount = get_tds_amount_from_ldc(ldc, parties, tax_details, posting_date, net_total)
+				tax_amount = get_tds_amount_from_ldc(
+					ldc, parties, pan_no, tax_details, posting_date, net_total
+				)
 			else:
 				tax_amount = net_total * tax_details.rate / 100 if net_total > 0 else 0
 
@@ -278,7 +268,7 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 			tax_amount = get_tcs_amount(parties, inv, tax_details, vouchers, advance_vouchers)
 
 	if cint(tax_details.round_off_tax_amount):
-		tax_amount = normal_round(tax_amount)
+		tax_amount = round(tax_amount)
 
 	return tax_amount, tax_deducted, tax_deducted_on_advances, voucher_wise_amount
 
@@ -410,26 +400,12 @@ def get_tds_amount(ldc, parties, inv, tax_details, tax_deducted, vouchers):
 	tds_amount = 0
 	invoice_filters = {"name": ("in", vouchers), "docstatus": 1, "apply_tds": 1}
 
-	## for TDS to be deducted on advances
-	payment_entry_filters = {
-		"party_type": "Supplier",
-		"party": ("in", parties),
-		"docstatus": 1,
-		"apply_tax_withholding_amount": 1,
-		"unallocated_amount": (">", 0),
-		"posting_date": ["between", (tax_details.from_date, tax_details.to_date)],
-		"tax_withholding_category": tax_details.get("tax_withholding_category"),
-	}
-
 	field = "sum(tax_withholding_net_total)"
 
 	if cint(tax_details.consider_party_ledger_amount):
 		invoice_filters.pop("apply_tds", None)
 		field = "sum(grand_total)"
 
-		payment_entry_filters.pop("apply_tax_withholding_amount", None)
-		payment_entry_filters.pop("tax_withholding_category", None)
-
 	supp_credit_amt = frappe.db.get_value("Purchase Invoice", invoice_filters, field) or 0.0
 
 	supp_jv_credit_amt = (
@@ -441,28 +417,14 @@ def get_tds_amount(ldc, parties, inv, tax_details, tax_deducted, vouchers):
 				"party": ("in", parties),
 				"reference_type": ("!=", "Purchase Invoice"),
 			},
-			"sum(credit_in_account_currency - debit_in_account_currency)",
+			"sum(credit_in_account_currency)",
 		)
 		or 0.0
 	)
 
-	# Get Amount via payment entry
-	payment_entry_amounts = frappe.db.get_all(
-		"Payment Entry",
-		filters=payment_entry_filters,
-		fields=["sum(unallocated_amount) as amount", "payment_type"],
-		group_by="payment_type",
-	)
-
 	supp_credit_amt += supp_jv_credit_amt
 	supp_credit_amt += inv.tax_withholding_net_total
 
-	for type in payment_entry_amounts:
-		if type.payment_type == "Pay":
-			supp_credit_amt += type.amount
-		else:
-			supp_credit_amt -= type.amount
-
 	threshold = tax_details.get("threshold", 0)
 	cumulative_threshold = tax_details.get("cumulative_threshold", 0)
 
@@ -564,7 +526,7 @@ def get_invoice_total_without_tcs(inv, tax_details):
 	return inv.grand_total - tcs_tax_row_amount
 
 
-def get_tds_amount_from_ldc(ldc, parties, tax_details, posting_date, net_total):
+def get_tds_amount_from_ldc(ldc, parties, pan_no, tax_details, posting_date, net_total):
 	tds_amount = 0
 	limit_consumed = frappe.db.get_value(
 		"Purchase Invoice",
@@ -603,20 +565,3 @@ def is_valid_certificate(
 		valid = True
 
 	return valid
-
-
-def normal_round(number):
-	"""
-	Rounds a number to the nearest integer.
-	:param number: The number to round.
-	"""
-	decimal_part = number - int(number)
-
-	if decimal_part >= 0.5:
-		decimal_part = 1
-	else:
-		decimal_part = 0
-
-	number = int(number) + decimal_part
-
-	return number

erpnext/accounts/doctype/tax_withholding_category/test_tax_withholding_category.py

@@ -16,7 +16,7 @@ class TestTaxWithholdingCategory(unittest.TestCase):
 	def setUpClass(self):
 		# create relevant supplier, etc
 		create_records()
-		create_tax_withholding_category_records()
+		create_tax_with_holding_category()
 
 	def tearDown(self):
 		cancel_invoices()
@@ -38,7 +38,7 @@ class TestTaxWithholdingCategory(unittest.TestCase):
 		pi = create_purchase_invoice(supplier="Test TDS Supplier")
 		pi.submit()
 
-		# assert equal tax deduction on total invoice amount until now
+		# assert equal tax deduction on total invoice amount uptil now
 		self.assertEqual(pi.taxes_and_charges_deducted, 3000)
 		self.assertEqual(pi.grand_total, 7000)
 		invoices.append(pi)
@@ -47,7 +47,7 @@ class TestTaxWithholdingCategory(unittest.TestCase):
 		pi = create_purchase_invoice(supplier="Test TDS Supplier", rate=5000)
 		pi.submit()
 
-		# assert equal tax deduction on total invoice amount until now
+		# assert equal tax deduction on total invoice amount uptil now
 		self.assertEqual(pi.taxes_and_charges_deducted, 500)
 		invoices.append(pi)
 
@@ -130,7 +130,7 @@ class TestTaxWithholdingCategory(unittest.TestCase):
 			invoices.append(si)
 
 		# create another invoice whose total when added to previously created invoice,
-		# surpasses cumulative threshold
+		# surpasses cumulative threshhold
 		si = create_sales_invoice(customer="Test TCS Customer", rate=12000)
 		si.submit()
 
@@ -329,38 +329,6 @@ class TestTaxWithholdingCategory(unittest.TestCase):
 		for d in reversed(invoices):
 			d.cancel()
 
-	def test_tax_withholding_via_payment_entry_for_advances(self):
-		frappe.db.set_value(
-			"Supplier", "Test TDS Supplier7", "tax_withholding_category", "Advance TDS Category"
-		)
-
-		# create payment entry
-		pe1 = create_payment_entry(
-			payment_type="Pay", party_type="Supplier", party="Test TDS Supplier7", paid_amount=4000
-		)
-		pe1.submit()
-
-		self.assertFalse(pe1.get("taxes"))
-
-		pe2 = create_payment_entry(
-			payment_type="Pay", party_type="Supplier", party="Test TDS Supplier7", paid_amount=4000
-		)
-		pe2.submit()
-
-		self.assertFalse(pe2.get("taxes"))
-
-		pe3 = create_payment_entry(
-			payment_type="Pay", party_type="Supplier", party="Test TDS Supplier7", paid_amount=4000
-		)
-		pe3.apply_tax_withholding_amount = 1
-		pe3.save()
-		pe3.submit()
-
-		self.assertEquals(pe3.get("taxes")[0].tax_amount, 1200)
-		pe1.cancel()
-		pe2.cancel()
-		pe3.cancel()
-
 
 def cancel_invoices():
 	purchase_invoices = frappe.get_all(
@@ -482,32 +450,6 @@ def create_sales_invoice(**args):
 	return si
 
 
-def create_payment_entry(**args):
-	# return payment entry doc object
-	args = frappe._dict(args)
-	pe = frappe.get_doc(
-		{
-			"doctype": "Payment Entry",
-			"posting_date": today(),
-			"payment_type": args.payment_type,
-			"party_type": args.party_type,
-			"party": args.party,
-			"company": "_Test Company",
-			"paid_from": "Cash - _TC",
-			"paid_to": "Creditors - _TC",
-			"paid_amount": args.paid_amount or 10000,
-			"received_amount": args.paid_amount or 10000,
-			"reference_no": args.reference_no or "12345",
-			"reference_date": today(),
-			"paid_from_account_currency": "INR",
-			"paid_to_account_currency": "INR",
-		}
-	)
-
-	pe.save()
-	return pe
-
-
 def create_records():
 	# create a new suppliers
 	for name in [
@@ -518,7 +460,6 @@ def create_records():
 		"Test TDS Supplier4",
 		"Test TDS Supplier5",
 		"Test TDS Supplier6",
-		"Test TDS Supplier7",
 	]:
 		if frappe.db.exists("Supplier", name):
 			continue
@@ -589,129 +530,142 @@ def create_records():
 		).insert()
 
 
-def create_tax_withholding_category_records():
+def create_tax_with_holding_category():
 	fiscal_year = get_fiscal_year(today(), company="_Test Company")
-	from_date = fiscal_year[1]
-	to_date = fiscal_year[2]
-
 	# Cumulative threshold
-	create_tax_withholding_category(
-		category_name="Cumulative Threshold TDS",
-		rate=10,
-		from_date=from_date,
-		to_date=to_date,
-		account="TDS - _TC",
-		single_threshold=0,
-		cumulative_threshold=30000.00,
-	)
-
-	# Category for TCS
-	create_tax_withholding_category(
-		category_name="Cumulative Threshold TCS",
-		rate=10,
-		from_date=from_date,
-		to_date=to_date,
-		account="TCS - _TC",
-		single_threshold=0,
-		cumulative_threshold=30000.00,
-	)
-
-	# Single threshold
-	create_tax_withholding_category(
-		category_name="Single Threshold TDS",
-		rate=10,
-		from_date=from_date,
-		to_date=to_date,
-		account="TDS - _TC",
-		single_threshold=20000,
-		cumulative_threshold=0,
-	)
-
-	create_tax_withholding_category(
-		category_name="New TDS Category",
-		rate=10,
-		from_date=from_date,
-		to_date=to_date,
-		account="TDS - _TC",
-		single_threshold=0,
-		cumulative_threshold=30000,
-		round_off_tax_amount=1,
-		consider_party_ledger_amount=1,
-		tax_on_excess_amount=1,
-	)
-
-	create_tax_withholding_category(
-		category_name="Test Service Category",
-		rate=10,
-		from_date=from_date,
-		to_date=to_date,
-		account="TDS - _TC",
-		single_threshold=2000,
-		cumulative_threshold=2000,
-	)
-
-	create_tax_withholding_category(
-		category_name="Test Goods Category",
-		rate=10,
-		from_date=from_date,
-		to_date=to_date,
-		account="TDS - _TC",
-		single_threshold=2000,
-		cumulative_threshold=2000,
-	)
-
-	create_tax_withholding_category(
-		category_name="Test Multi Invoice Category",
-		rate=10,
-		from_date=from_date,
-		to_date=to_date,
-		account="TDS - _TC",
-		single_threshold=5000,
-		cumulative_threshold=10000,
-	)
-
-	create_tax_withholding_category(
-		category_name="Advance TDS Category",
-		rate=10,
-		from_date=from_date,
-		to_date=to_date,
-		account="TDS - _TC",
-		single_threshold=5000,
-		cumulative_threshold=10000,
-		consider_party_ledger_amount=1,
-	)
-
-
-def create_tax_withholding_category(
-	category_name,
-	rate,
-	from_date,
-	to_date,
-	account,
-	single_threshold=0,
-	cumulative_threshold=0,
-	round_off_tax_amount=0,
-	consider_party_ledger_amount=0,
-	tax_on_excess_amount=0,
-):
-	if not frappe.db.exists("Tax Withholding Category", category_name):
+	if not frappe.db.exists("Tax Withholding Category", "Cumulative Threshold TDS"):
 		frappe.get_doc(
 			{
 				"doctype": "Tax Withholding Category",
-				"name": category_name,
-				"category_name": category_name,
-				"round_off_tax_amount": round_off_tax_amount,
-				"consider_party_ledger_amount": consider_party_ledger_amount,
-				"tax_on_excess_amount": tax_on_excess_amount,
+				"name": "Cumulative Threshold TDS",
+				"category_name": "10% TDS",
 				"rates": [
 					{
-						"from_date": from_date,
-						"to_date": to_date,
-						"tax_withholding_rate": rate,
-						"single_threshold": single_threshold,
-						"cumulative_threshold": cumulative_threshold,
+						"from_date": fiscal_year[1],
+						"to_date": fiscal_year[2],
+						"tax_withholding_rate": 10,
+						"single_threshold": 0,
+						"cumulative_threshold": 30000.00,
 					}
 				],
-				"accounts": [{"company": "_Test Company", "account": account}],
+				"accounts": [{"company": "_Test Company", "account": "TDS - _TC"}],
+			}
+		).insert()
+
+	if not frappe.db.exists("Tax Withholding Category", "Cumulative Threshold TCS"):
+		frappe.get_doc(
+			{
+				"doctype": "Tax Withholding Category",
+				"name": "Cumulative Threshold TCS",
+				"category_name": "10% TCS",
+				"rates": [
+					{
+						"from_date": fiscal_year[1],
+						"to_date": fiscal_year[2],
+						"tax_withholding_rate": 10,
+						"single_threshold": 0,
+						"cumulative_threshold": 30000.00,
+					}
+				],
+				"accounts": [{"company": "_Test Company", "account": "TCS - _TC"}],
+			}
+		).insert()
+
+	# Single thresold
+	if not frappe.db.exists("Tax Withholding Category", "Single Threshold TDS"):
+		frappe.get_doc(
+			{
+				"doctype": "Tax Withholding Category",
+				"name": "Single Threshold TDS",
+				"category_name": "10% TDS",
+				"rates": [
+					{
+						"from_date": fiscal_year[1],
+						"to_date": fiscal_year[2],
+						"tax_withholding_rate": 10,
+						"single_threshold": 20000.00,
+						"cumulative_threshold": 0,
+					}
+				],
+				"accounts": [{"company": "_Test Company", "account": "TDS - _TC"}],
+			}
+		).insert()
+
+	if not frappe.db.exists("Tax Withholding Category", "New TDS Category"):
+		frappe.get_doc(
+			{
+				"doctype": "Tax Withholding Category",
+				"name": "New TDS Category",
+				"category_name": "New TDS Category",
+				"round_off_tax_amount": 1,
+				"consider_party_ledger_amount": 1,
+				"tax_on_excess_amount": 1,
+				"rates": [
+					{
+						"from_date": fiscal_year[1],
+						"to_date": fiscal_year[2],
+						"tax_withholding_rate": 10,
+						"single_threshold": 0,
+						"cumulative_threshold": 30000,
+					}
+				],
+				"accounts": [{"company": "_Test Company", "account": "TDS - _TC"}],
+			}
+		).insert()
+
+	if not frappe.db.exists("Tax Withholding Category", "Test Service Category"):
+		frappe.get_doc(
+			{
+				"doctype": "Tax Withholding Category",
+				"name": "Test Service Category",
+				"category_name": "Test Service Category",
+				"rates": [
+					{
+						"from_date": fiscal_year[1],
+						"to_date": fiscal_year[2],
+						"tax_withholding_rate": 10,
+						"single_threshold": 2000,
+						"cumulative_threshold": 2000,
+					}
+				],
+				"accounts": [{"company": "_Test Company", "account": "TDS - _TC"}],
+			}
+		).insert()
+
+	if not frappe.db.exists("Tax Withholding Category", "Test Goods Category"):
+		frappe.get_doc(
+			{
+				"doctype": "Tax Withholding Category",
+				"name": "Test Goods Category",
+				"category_name": "Test Goods Category",
+				"rates": [
+					{
+						"from_date": fiscal_year[1],
+						"to_date": fiscal_year[2],
+						"tax_withholding_rate": 10,
+						"single_threshold": 2000,
+						"cumulative_threshold": 2000,
+					}
+				],
+				"accounts": [{"company": "_Test Company", "account": "TDS - _TC"}],
+			}
+		).insert()
+
+	if not frappe.db.exists("Tax Withholding Category", "Test Multi Invoice Category"):
+		frappe.get_doc(
+			{
+				"doctype": "Tax Withholding Category",
+				"name": "Test Multi Invoice Category",
+				"category_name": "Test Multi Invoice Category",
+				"rates": [
+					{
+						"from_date": fiscal_year[1],
+						"to_date": fiscal_year[2],
+						"tax_withholding_rate": 10,
+						"single_threshold": 5000,
+						"cumulative_threshold": 10000,
+					}
+				],
+				"accounts": [{"company": "_Test Company", "account": "TDS - _TC"}],
 			}
 		).insert()

erpnext/accounts/general_ledger.py

@@ -199,14 +199,7 @@ def merge_similar_entries(gl_map, precision=None):
 
 	# filter zero debit and credit entries
 	merged_gl_map = filter(
-		lambda x: flt(x.debit, precision) != 0
-		or flt(x.credit, precision) != 0
-		or (
-			x.voucher_type == "Journal Entry"
-			and frappe.get_cached_value("Journal Entry", x.voucher_no, "voucher_type")
-			== "Exchange Gain Or Loss"
-		),
-		merged_gl_map,
+		lambda x: flt(x.debit, precision) != 0 or flt(x.credit, precision) != 0, merged_gl_map
 	)
 	merged_gl_map = list(merged_gl_map)
 
@@ -300,9 +293,6 @@ def save_entries(gl_map, adv_adj, update_outstanding, from_repost=False):
 
 	if gl_map:
 		check_freezing_date(gl_map[0]["posting_date"], adv_adj)
-		is_opening = any(d.get("is_opening") == "Yes" for d in gl_map)
-		if gl_map[0]["voucher_type"] != "Period Closing Voucher":
-			validate_against_pcv(is_opening, gl_map[0]["posting_date"], gl_map[0]["company"])
 
 	for entry in gl_map:
 		make_entry(entry, adv_adj, update_outstanding, from_repost)
@@ -360,26 +350,15 @@ def process_debit_credit_difference(gl_map):
 	allowance = get_debit_credit_allowance(voucher_type, precision)
 
 	debit_credit_diff = get_debit_credit_difference(gl_map, precision)
-
 	if abs(debit_credit_diff) > allowance:
-		if not (
-			voucher_type == "Journal Entry"
-			and frappe.get_cached_value("Journal Entry", voucher_no, "voucher_type")
-			== "Exchange Gain Or Loss"
-		):
-			raise_debit_credit_not_equal_error(debit_credit_diff, voucher_type, voucher_no)
+		raise_debit_credit_not_equal_error(debit_credit_diff, voucher_type, voucher_no)
 
 	elif abs(debit_credit_diff) >= (1.0 / (10**precision)):
 		make_round_off_gle(gl_map, debit_credit_diff, precision)
 
 	debit_credit_diff = get_debit_credit_difference(gl_map, precision)
 	if abs(debit_credit_diff) > allowance:
-		if not (
-			voucher_type == "Journal Entry"
-			and frappe.get_cached_value("Journal Entry", voucher_no, "voucher_type")
-			== "Exchange Gain Or Loss"
-		):
-			raise_debit_credit_not_equal_error(debit_credit_diff, voucher_type, voucher_no)
+		raise_debit_credit_not_equal_error(debit_credit_diff, voucher_type, voucher_no)
 
 
 def get_debit_credit_difference(gl_map, precision):
@@ -522,9 +501,6 @@ def make_reverse_gl_entries(
 		)
 		validate_accounting_period(gl_entries)
 		check_freezing_date(gl_entries[0]["posting_date"], adv_adj)
-
-		is_opening = any(d.get("is_opening") == "Yes" for d in gl_entries)
-		validate_against_pcv(is_opening, gl_entries[0]["posting_date"], gl_entries[0]["company"])
 		set_as_cancel(gl_entries[0]["voucher_type"], gl_entries[0]["voucher_no"])
 
 		for entry in gl_entries:
@@ -572,28 +548,6 @@ def check_freezing_date(posting_date, adv_adj=False):
 				)
 
 
-def validate_against_pcv(is_opening, posting_date, company):
-	if is_opening and frappe.db.exists(
-		"Period Closing Voucher", {"docstatus": 1, "company": company}
-	):
-		frappe.throw(
-			_("Opening Entry can not be created after Period Closing Voucher is created."),
-			title=_("Invalid Opening Entry"),
-		)
-
-	last_pcv_date = frappe.db.get_value(
-		"Period Closing Voucher", {"docstatus": 1, "company": company}, "max(posting_date)"
-	)
-
-	if last_pcv_date and getdate(posting_date) <= getdate(last_pcv_date):
-		message = _("Books have been closed till the period ending on {0}").format(
-			formatdate(last_pcv_date)
-		)
-		message += "</br >"
-		message += _("You cannot create/amend any accounting entries till this date.")
-		frappe.throw(message, title=_("Period Closed"))
-
-
 def set_as_cancel(voucher_type, voucher_no):
 	"""
 	Set is_cancelled=1 in all original gl entries for the voucher

erpnext/accounts/party.py

@@ -32,16 +32,6 @@ from erpnext import get_company_currency
 from erpnext.accounts.utils import get_fiscal_year
 from erpnext.exceptions import InvalidAccountCurrency, PartyDisabled, PartyFrozen
 
-PURCHASE_TRANSACTION_TYPES = {"Purchase Order", "Purchase Receipt", "Purchase Invoice"}
-SALES_TRANSACTION_TYPES = {
-	"Quotation",
-	"Sales Order",
-	"Delivery Note",
-	"Sales Invoice",
-	"POS Invoice",
-}
-TRANSACTION_TYPES = PURCHASE_TRANSACTION_TYPES | SALES_TRANSACTION_TYPES
-
 
 class DuplicatePartyAccountError(frappe.ValidationError):
 	pass
@@ -134,6 +124,12 @@ def _get_party_details(
 	set_other_values(party_details, party, party_type)
 	set_price_list(party_details, party, party_type, price_list, pos_profile)
 
+	party_details["tax_category"] = get_address_tax_category(
+		party.get("tax_category"),
+		party_address,
+		shipping_address if party_type != "Supplier" else party_address,
+	)
+
 	tax_template = set_taxes(
 		party.name,
 		party_type,
@@ -174,9 +170,6 @@ def _get_party_details(
 			party_type, party.name, "tax_withholding_category"
 		)
 
-	if not party_details.get("tax_category") and pos_profile:
-		party_details["tax_category"] = frappe.get_value("POS Profile", pos_profile, "tax_category")
-
 	return party_details
 
 
@@ -218,10 +211,14 @@ def set_address_details(
 	else:
 		party_details.update(get_company_address(company))
 
-	if doctype in SALES_TRANSACTION_TYPES and party_details.company_address:
-		party_details.update(get_fetch_values(doctype, "company_address", party_details.company_address))
+	if doctype and doctype in ["Delivery Note", "Sales Invoice", "Sales Order", "Quotation"]:
+		if party_details.company_address:
+			party_details.update(
+				get_fetch_values(doctype, "company_address", party_details.company_address)
+			)
+		get_regional_address_details(party_details, doctype, company)
 
-	if doctype in PURCHASE_TRANSACTION_TYPES:
+	elif doctype and doctype in ["Purchase Invoice", "Purchase Order", "Purchase Receipt"]:
 		if shipping_address:
 			party_details.update(
 				shipping_address=shipping_address,
@@ -247,21 +244,9 @@ def set_address_details(
 					**get_fetch_values(doctype, "shipping_address", party_details.billing_address)
 				)
 
-	party_address, shipping_address = (
-		party_details.get(billing_address_field),
-		party_details.shipping_address_name,
-	)
-
-	party_details["tax_category"] = get_address_tax_category(
-		party.get("tax_category"),
-		party_address,
-		shipping_address if party_type != "Supplier" else party_address,
-	)
-
-	if doctype in TRANSACTION_TYPES:
 		get_regional_address_details(party_details, doctype, company)
 
-	return party_address, shipping_address
+	return party_details.get(billing_address_field), party_details.shipping_address_name
 
 
 @erpnext.allow_regional
@@ -559,7 +544,7 @@ def get_due_date_from_template(template_name, posting_date, bill_date):
 		elif term.due_date_based_on == "Day(s) after the end of the invoice month":
 			due_date = max(due_date, add_days(get_last_day(due_date), term.credit_days))
 		else:
-			due_date = max(due_date, get_last_day(add_months(due_date, term.credit_months)))
+			due_date = max(due_date, add_months(get_last_day(due_date), term.credit_months))
 	return due_date
 
 

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -99,9 +99,6 @@ class ReceivablePayableReport(object):
 		# Get return entries
 		self.get_return_entries()
 
-		# Get Exchange Rate Revaluations
-		self.get_exchange_rate_revaluations()
-
 		self.data = []
 
 		for ple in self.ple_entries:
@@ -254,8 +251,7 @@ class ReceivablePayableReport(object):
 			row.invoice_grand_total = row.invoiced
 
 			if (abs(row.outstanding) > 1.0 / 10**self.currency_precision) and (
-				(abs(row.outstanding_in_account_currency) > 1.0 / 10**self.currency_precision)
-				or (row.voucher_no in self.err_journals)
+				abs(row.outstanding_in_account_currency) > 1.0 / 10**self.currency_precision
 			):
 
 				# non-zero oustanding, we must consider this row
@@ -798,19 +794,19 @@ class ReceivablePayableReport(object):
 
 		if self.filters.get("payment_terms_template"):
 			self.qb_selection_filter.append(
-				self.ple.party.isin(
-					qb.from_(self.customer)
-					.select(self.customer.name)
-					.where(self.customer.payment_terms == self.filters.get("payment_terms_template"))
+				self.ple.party_isin(
+					qb.from_(self.customer).where(
+						self.customer.payment_terms == self.filters.get("payment_terms_template")
+					)
 				)
 			)
 
 		if self.filters.get("sales_partner"):
 			self.qb_selection_filter.append(
-				self.ple.party.isin(
-					qb.from_(self.customer)
-					.select(self.customer.name)
-					.where(self.customer.default_sales_partner == self.filters.get("sales_partner"))
+				self.ple.party_isin(
+					qb.from_(self.customer).where(
+						self.customer.default_sales_partner == self.filters.get("payment_terms_template")
+					)
 				)
 			)
 
@@ -859,7 +855,7 @@ class ReceivablePayableReport(object):
 						)
 					else:
 						self.qb_selection_filter.append(
-							self.ple[dimension.fieldname].isin(self.filters[dimension.fieldname])
+							self.ple[dimension.fieldname] == self.filters[dimension.fieldname]
 						)
 
 	def is_invoice(self, ple):
@@ -869,15 +865,10 @@ class ReceivablePayableReport(object):
 	def get_party_details(self, party):
 		if not party in self.party_details:
 			if self.party_type == "Customer":
-				fields = ["customer_name", "territory", "customer_group", "customer_primary_contact"]
-
-				if self.filters.get("sales_partner"):
-					fields.append("default_sales_partner")
-
 				self.party_details[party] = frappe.db.get_value(
 					"Customer",
 					party,
-					fields,
+					["customer_name", "territory", "customer_group", "customer_primary_contact"],
 					as_dict=True,
 				)
 			else:
@@ -978,9 +969,6 @@ class ReceivablePayableReport(object):
 			if self.filters.show_sales_person:
 				self.add_column(label=_("Sales Person"), fieldname="sales_person", fieldtype="Data")
 
-			if self.filters.sales_partner:
-				self.add_column(label=_("Sales Partner"), fieldname="default_sales_partner", fieldtype="Data")
-
 		if self.filters.party_type == "Supplier":
 			self.add_column(
 				label=_("Supplier Group"),
@@ -1040,17 +1028,3 @@ class ReceivablePayableReport(object):
 			"data": {"labels": self.ageing_column_labels, "datasets": rows},
 			"type": "percentage",
 		}
-
-	def get_exchange_rate_revaluations(self):
-		je = qb.DocType("Journal Entry")
-		results = (
-			qb.from_(je)
-			.select(je.name)
-			.where(
-				(je.company == self.filters.company)
-				& (je.posting_date.lte(self.filters.report_date))
-				& (je.voucher_type == "Exchange Rate Revaluation")
-			)
-			.run()
-		)
-		self.err_journals = [x[0] for x in results] if results else []

erpnext/accounts/report/accounts_receivable/test_accounts_receivable.py

@@ -1,10 +1,9 @@
 import unittest
 
 import frappe
-from frappe.tests.utils import FrappeTestCase, change_settings
-from frappe.utils import add_days, flt, getdate, today
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import add_days, getdate, today
 
-from erpnext import get_default_cost_center
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.report.accounts_receivable.accounts_receivable import execute
@@ -18,37 +17,10 @@ class TestAccountsReceivable(FrappeTestCase):
 		frappe.db.sql("delete from `tabPayment Entry` where company='_Test Company 2'")
 		frappe.db.sql("delete from `tabGL Entry` where company='_Test Company 2'")
 		frappe.db.sql("delete from `tabPayment Ledger Entry` where company='_Test Company 2'")
-		frappe.db.sql("delete from `tabJournal Entry` where company='_Test Company 2'")
-		frappe.db.sql("delete from `tabExchange Rate Revaluation` where company='_Test Company 2'")
-
-		self.create_usd_account()
 
 	def tearDown(self):
 		frappe.db.rollback()
 
-	def create_usd_account(self):
-		name = "Debtors USD"
-		exists = frappe.db.get_list(
-			"Account", filters={"company": "_Test Company 2", "account_name": "Debtors USD"}
-		)
-		if exists:
-			self.debtors_usd = exists[0].name
-		else:
-			debtors = frappe.get_doc(
-				"Account",
-				frappe.db.get_list(
-					"Account", filters={"company": "_Test Company 2", "account_name": "Debtors"}
-				)[0].name,
-			)
-
-			debtors_usd = frappe.new_doc("Account")
-			debtors_usd.company = debtors.company
-			debtors_usd.account_name = "Debtors USD"
-			debtors_usd.account_currency = "USD"
-			debtors_usd.parent_account = debtors.parent_account
-			debtors_usd.account_type = debtors.account_type
-			self.debtors_usd = debtors_usd.save().name
-
 	def test_accounts_receivable(self):
 		filters = {
 			"company": "_Test Company 2",
@@ -61,7 +33,7 @@ class TestAccountsReceivable(FrappeTestCase):
 		}
 
 		# check invoice grand total and invoiced column's value for 3 payment terms
-		name = make_sales_invoice().name
+		name = make_sales_invoice()
 		report = execute(filters)
 
 		expected_data = [[100, 30], [100, 50], [100, 20]]
@@ -146,72 +118,8 @@ class TestAccountsReceivable(FrappeTestCase):
 			],
 		)
 
-	@change_settings(
-		"Accounts Settings", {"allow_multi_currency_invoices_against_single_party_account": 1}
-	)
-	def test_exchange_revaluation_for_party(self):
-		"""
-		Exchange Revaluation for party on Receivable/Payable shoule be included
-		"""
 
-		company = "_Test Company 2"
-		customer = "_Test Customer 2"
-
-		# Using Exchange Gain/Loss account for unrealized as well.
-		company_doc = frappe.get_doc("Company", company)
-		company_doc.unrealized_exchange_gain_loss_account = company_doc.exchange_gain_loss_account
-		company_doc.save()
-
-		si = make_sales_invoice(no_payment_schedule=True, do_not_submit=True)
-		si.currency = "USD"
-		si.conversion_rate = 0.90
-		si.debit_to = self.debtors_usd
-		si = si.save().submit()
-
-		# Exchange Revaluation
-		err = frappe.new_doc("Exchange Rate Revaluation")
-		err.company = company
-		err.posting_date = today()
-		accounts = err.get_accounts_data()
-		err.extend("accounts", accounts)
-		err.accounts[0].new_exchange_rate = 0.95
-		row = err.accounts[0]
-		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()
-
-		# Submit JV for ERR
-		err_journals = err.make_jv_entries()
-		je = frappe.get_doc("Journal Entry", err_journals.get("revaluation_jv"))
-		je = je.submit()
-
-		filters = {
-			"company": company,
-			"report_date": today(),
-			"range1": 30,
-			"range2": 60,
-			"range3": 90,
-			"range4": 120,
-		}
-		report = execute(filters)
-
-		expected_data_for_err = [0, -5, 0, 5]
-		row = [x for x in report[1] if x.voucher_type == je.doctype and x.voucher_no == je.name][0]
-		self.assertEqual(
-			expected_data_for_err,
-			[
-				row.invoiced,
-				row.paid,
-				row.credit_note,
-				row.outstanding,
-			],
-		)
-
-
-def make_sales_invoice(no_payment_schedule=False, do_not_submit=False):
+def make_sales_invoice():
 	frappe.set_user("Administrator")
 
 	si = create_sales_invoice(
@@ -226,26 +134,22 @@ def make_sales_invoice(no_payment_schedule=False, do_not_submit=False):
 		do_not_save=1,
 	)
 
-	if not no_payment_schedule:
-		si.append(
-			"payment_schedule",
-			dict(due_date=getdate(add_days(today(), 30)), invoice_portion=30.00, payment_amount=30),
-		)
-		si.append(
-			"payment_schedule",
-			dict(due_date=getdate(add_days(today(), 60)), invoice_portion=50.00, payment_amount=50),
-		)
-		si.append(
-			"payment_schedule",
-			dict(due_date=getdate(add_days(today(), 90)), invoice_portion=20.00, payment_amount=20),
-		)
+	si.append(
+		"payment_schedule",
+		dict(due_date=getdate(add_days(today(), 30)), invoice_portion=30.00, payment_amount=30),
+	)
+	si.append(
+		"payment_schedule",
+		dict(due_date=getdate(add_days(today(), 60)), invoice_portion=50.00, payment_amount=50),
+	)
+	si.append(
+		"payment_schedule",
+		dict(due_date=getdate(add_days(today(), 90)), invoice_portion=20.00, payment_amount=20),
+	)
 
-	si = si.save()
+	si.submit()
 
-	if not do_not_submit:
-		si = si.submit()
-
-	return si
+	return si.name
 
 
 def make_payment(docname):

erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py

@@ -121,9 +121,6 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 		if row.sales_person:
 			self.party_total[row.party].sales_person.append(row.sales_person)
 
-		if self.filters.sales_partner:
-			self.party_total[row.party]["default_sales_partner"] = row.get("default_sales_partner")
-
 	def get_columns(self):
 		self.columns = []
 		self.add_column(
@@ -163,10 +160,6 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 			)
 			if self.filters.show_sales_person:
 				self.add_column(label=_("Sales Person"), fieldname="sales_person", fieldtype="Data")
-
-			if self.filters.sales_partner:
-				self.add_column(label=_("Sales Partner"), fieldname="default_sales_partner", fieldtype="Data")
-
 		else:
 			self.add_column(
 				label=_("Supplier Group"),

erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py

@@ -25,7 +25,6 @@ def get_data(filters):
 		["posting_date", "<=", filters.get("to_date")],
 		["against_voucher_type", "=", "Asset"],
 		["account", "in", depreciation_accounts],
-		["is_cancelled", "=", 0],
 	]
 
 	if filters.get("asset"):

erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py

@@ -131,36 +131,8 @@ def get_assets(filters):
 							  else
 								   0
 							  end), 0) as depreciation_amount_during_the_period
-			from `tabAsset` a, `tabAsset Depreciation Schedule` ads, `tabDepreciation Schedule` ds
-			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s and ads.asset = a.name and ads.docstatus=1 and ads.name = ds.parent and ifnull(ds.journal_entry, '') != ''
-			group by a.asset_category
-			union
-			SELECT a.asset_category,
-				   ifnull(sum(case when gle.posting_date < %(from_date)s and (ifnull(a.disposal_date, 0) = 0 or a.disposal_date >= %(from_date)s) then
-								   gle.debit
-							  else
-								   0
-							  end), 0) as accumulated_depreciation_as_on_from_date,
-				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date >= %(from_date)s
-										and a.disposal_date <= %(to_date)s and gle.posting_date <= a.disposal_date then
-								   gle.debit
-							  else
-								   0
-							  end), 0) as depreciation_eliminated_during_the_period,
-				   ifnull(sum(case when gle.posting_date >= %(from_date)s and gle.posting_date <= %(to_date)s
-										and (ifnull(a.disposal_date, 0) = 0 or gle.posting_date <= a.disposal_date) then
-								   gle.debit
-							  else
-								   0
-							  end), 0) as depreciation_amount_during_the_period
-			from `tabGL Entry` gle
-			join `tabAsset` a on
-				gle.against_voucher = a.name
-			join `tabAsset Category Account` aca on
-				aca.parent = a.asset_category and aca.company_name = %(company)s
-			join `tabCompany` company on
-				company.name = %(company)s
-			where a.docstatus=1 and a.company=%(company)s and a.calculate_depreciation=0 and a.purchase_date <= %(to_date)s and gle.debit != 0 and gle.is_cancelled = 0 and gle.account = ifnull(aca.depreciation_expense_account, company.depreciation_expense_account)
+			from `tabAsset` a, `tabDepreciation Schedule` ds
+			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s and a.name = ds.parent and ifnull(ds.journal_entry, '') != ''
 			group by a.asset_category
 			union
 			SELECT a.asset_category,

erpnext/accounts/report/balance_sheet/balance_sheet.py

@@ -25,8 +25,6 @@ def execute(filters=None):
 		company=filters.company,
 	)
 
-	filters.period_start_date = period_list[0]["year_start_date"]
-
 	currency = filters.presentation_currency or frappe.get_cached_value(
 		"Company", filters.company, "default_currency"
 	)
@@ -98,7 +96,7 @@ def execute(filters=None):
 	chart = get_chart_data(filters, columns, asset, liability, equity)
 
 	report_summary = get_report_summary(
-		period_list, asset, liability, equity, provisional_profit_loss, currency, filters
+		period_list, asset, liability, equity, provisional_profit_loss, total_credit, currency, filters
 	)
 
 	return columns, data, message, chart, report_summary
@@ -176,6 +174,7 @@ def get_report_summary(
 	liability,
 	equity,
 	provisional_profit_loss,
+	total_credit,
 	currency,
 	filters,
 	consolidated=False,

erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py

@@ -4,7 +4,6 @@
 
 import frappe
 from frappe import _
-from frappe.query_builder.custom import ConstantColumn
 from frappe.utils import getdate, nowdate
 
 
@@ -92,65 +91,4 @@ def get_entries(filters):
 		as_list=1,
 	)
 
-	# Loan Disbursement
-	loan_disbursement = frappe.qb.DocType("Loan Disbursement")
-
-	query = (
-		frappe.qb.from_(loan_disbursement)
-		.select(
-			ConstantColumn("Loan Disbursement").as_("payment_document_type"),
-			loan_disbursement.name.as_("payment_entry"),
-			loan_disbursement.disbursement_date.as_("posting_date"),
-			loan_disbursement.reference_number.as_("cheque_no"),
-			loan_disbursement.clearance_date.as_("clearance_date"),
-			loan_disbursement.applicant.as_("against"),
-			-loan_disbursement.disbursed_amount.as_("amount"),
-		)
-		.where(loan_disbursement.docstatus == 1)
-		.where(loan_disbursement.disbursement_date >= filters["from_date"])
-		.where(loan_disbursement.disbursement_date <= filters["to_date"])
-		.where(loan_disbursement.disbursement_account == filters["account"])
-		.orderby(loan_disbursement.disbursement_date, order=frappe.qb.desc)
-		.orderby(loan_disbursement.name, order=frappe.qb.desc)
-	)
-
-	if filters.get("from_date"):
-		query = query.where(loan_disbursement.disbursement_date >= filters["from_date"])
-	if filters.get("to_date"):
-		query = query.where(loan_disbursement.disbursement_date <= filters["to_date"])
-
-	loan_disbursements = query.run(as_list=1)
-
-	# Loan Repayment
-	loan_repayment = frappe.qb.DocType("Loan Repayment")
-
-	query = (
-		frappe.qb.from_(loan_repayment)
-		.select(
-			ConstantColumn("Loan Repayment").as_("payment_document_type"),
-			loan_repayment.name.as_("payment_entry"),
-			loan_repayment.posting_date.as_("posting_date"),
-			loan_repayment.reference_number.as_("cheque_no"),
-			loan_repayment.clearance_date.as_("clearance_date"),
-			loan_repayment.applicant.as_("against"),
-			loan_repayment.amount_paid.as_("amount"),
-		)
-		.where(loan_repayment.docstatus == 1)
-		.where(loan_repayment.posting_date >= filters["from_date"])
-		.where(loan_repayment.posting_date <= filters["to_date"])
-		.where(loan_repayment.payment_account == filters["account"])
-		.orderby(loan_repayment.posting_date, order=frappe.qb.desc)
-		.orderby(loan_repayment.name, order=frappe.qb.desc)
-	)
-
-	if filters.get("from_date"):
-		query = query.where(loan_repayment.posting_date >= filters["from_date"])
-	if filters.get("to_date"):
-		query = query.where(loan_repayment.posting_date <= filters["to_date"])
-
-	loan_repayments = query.run(as_list=1)
-
-	return sorted(
-		journal_entries + payment_entries + loan_disbursements + loan_repayments,
-		key=lambda k: k[2] or getdate(nowdate()),
-	)
+	return sorted(journal_entries + payment_entries, key=lambda k: k[2] or getdate(nowdate()))

erpnext/accounts/report/cash_flow/cash_flow.py

@@ -8,7 +8,6 @@ from frappe.utils import cint, cstr
 
 from erpnext.accounts.report.financial_statements import (
 	get_columns,
-	get_cost_centers_with_children,
 	get_data,
 	get_filtered_list_for_consolidated_report,
 	get_period_list,
@@ -161,11 +160,10 @@ def get_account_type_based_data(company, account_type, period_list, accumulated_
 	total = 0
 	for period in period_list:
 		start_date = get_start_date(period, accumulated_values, company)
-		filters.start_date = start_date
-		filters.end_date = period["to_date"]
-		filters.account_type = account_type
 
-		amount = get_account_type_based_gl_data(company, filters)
+		amount = get_account_type_based_gl_data(
+			company, start_date, period["to_date"], account_type, filters
+		)
 
 		if amount and account_type == "Depreciation":
 			amount *= -1
@@ -177,7 +175,7 @@ def get_account_type_based_data(company, account_type, period_list, accumulated_
 	return data
 
 
-def get_account_type_based_gl_data(company, filters=None):
+def get_account_type_based_gl_data(company, start_date, end_date, account_type, filters=None):
 	cond = ""
 	filters = frappe._dict(filters or {})
 
@@ -193,21 +191,17 @@ def get_account_type_based_gl_data(company, filters=None):
 			frappe.db.escape(cstr(filters.finance_book))
 		)
 
-	if filters.get("cost_center"):
-		filters.cost_center = get_cost_centers_with_children(filters.cost_center)
-		cond += " and cost_center in %(cost_center)s"
-
 	gl_sum = frappe.db.sql_list(
 		"""
 		select sum(credit) - sum(debit)
 		from `tabGL Entry`
-		where company=%(company)s and posting_date >= %(start_date)s and posting_date <= %(end_date)s
+		where company=%s and posting_date >= %s and posting_date <= %s
 			and voucher_type != 'Period Closing Voucher'
-			and account in ( SELECT name FROM tabAccount WHERE account_type = %(account_type)s) {cond}
+			and account in ( SELECT name FROM tabAccount WHERE account_type = %s) {cond}
 	""".format(
 			cond=cond
 		),
-		filters,
+		(company, start_date, end_date, account_type),
 	)
 
 	return gl_sum[0] if gl_sum and gl_sum[0] else 0