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

@@ -41,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
 
@@ -65,8 +60,6 @@ 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

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

@@ -4,7 +4,7 @@
 # the repo. Unless a later match takes precedence,
 
 erpnext/accounts/               @nextchamp-saqib @deepeshgarg007 @ruthra-kumar
-erpnext/assets/                 @anandbaburajan @deepeshgarg007
+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
@@ -16,7 +16,6 @@ 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/crm/                    @NagariaHussain
 erpnext/education/              @rutwikhdev

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_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/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/accounts_settings/accounts_settings.json

@@ -56,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": [
   {
@@ -349,17 +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"
   }
  ],
  "icon": "icon-cog",
@@ -367,7 +354,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-01-02 12:07:42.434214",
+ "modified": "2022-11-27 21:49:52.538655",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

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_reconciliation_tool/bank_reconciliation_tool.js

@@ -21,22 +21,13 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 		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) {
 		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",
@@ -58,20 +49,6 @@ 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,
-				},
-			})
-		});
 	},
 
 	after_save: function (frm) {
@@ -183,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,9 +10,6 @@
   "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_opening_balance",
   "bank_statement_closing_balance",
@@ -39,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"
@@ -84,33 +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"
+   "fieldtype": "HTML"
   }
  ],
  "hide_toolbar": 1,
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-01-13 13:00:02.022919",
+ "modified": "2021-04-21 11:13:49.831769",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Reconciliation Tool",
@@ -129,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,7 +8,7 @@ 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_paid_amount
 from erpnext.accounts.report.bank_reconciliation_statement.bank_reconciliation_statement import (
@@ -50,7 +50,6 @@ def get_bank_transactions(bank_account, from_date=None, to_date=None):
 			"party",
 		],
 		filters=filters,
-		order_by="date",
 	)
 	return transactions
 
@@ -266,80 +265,6 @@ def create_payment_entry_bts(
 	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)
-
-
 @frappe.whitelist()
 def reconcile_vouchers(bank_transaction_name, vouchers):
 	# updated clear date of all the vouchers based on the bank transaction
@@ -377,7 +302,7 @@ def reconcile_vouchers(bank_transaction_name, vouchers):
 			dict(
 				account=account, voucher_type=voucher["payment_doctype"], voucher_no=voucher["payment_name"]
 			),
-			["credit_in_account_currency as credit", "debit_in_account_currency as debit"],
+			["credit", "debit"],
 			as_dict=1,
 		)
 		gl_amount, transaction_amount = (
@@ -402,58 +327,20 @@ def reconcile_vouchers(bank_transaction_name, vouchers):
 
 
 @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]
 	(account, company) = (bank_account.account, bank_account.company)
-	matching = check_matching(
-		account,
-		company,
-		transaction,
-		document_types,
-		from_date,
-		to_date,
-		filter_by_reference_date,
-		from_reference_date,
-		to_reference_date,
-	)
+	matching = check_matching(account, company, transaction, document_types)
 	return matching
 
 
-def check_matching(
-	bank_account,
-	company,
-	transaction,
-	document_types,
-	from_date,
-	to_date,
-	filter_by_reference_date,
-	from_reference_date,
-	to_reference_date,
-):
+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,
-	)
+	subquery = get_queries(bank_account, company, transaction, document_types)
 	filters = {
 		"amount": transaction.unallocated_amount,
 		"payment_type": "Receive" if transaction.deposit > 0 else "Pay",
@@ -474,20 +361,11 @@ 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,
-):
+def get_queries(bank_account, company, transaction, document_types):
 	# get queries to get matching vouchers
 	amount_condition = "=" if "exact_match" in document_types else "<="
 	account_from_to = "paid_to" if transaction.deposit > 0 else "paid_from"
@@ -503,11 +381,6 @@ def get_queries(
 				document_types,
 				amount_condition,
 				account_from_to,
-				from_date,
-				to_date,
-				filter_by_reference_date,
-				from_reference_date,
-				to_reference_date,
 			)
 			or []
 		)
@@ -516,42 +389,15 @@ def get_queries(
 
 
 def get_matching_queries(
-	bank_account,
-	company,
-	transaction,
-	document_types,
-	amount_condition,
-	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:
-		pe_amount_matching = get_pe_matching_query(
-			amount_condition,
-			account_from_to,
-			transaction,
-			from_date,
-			to_date,
-			filter_by_reference_date,
-			from_reference_date,
-			to_reference_date,
-		)
+		pe_amount_matching = get_pe_matching_query(amount_condition, account_from_to, transaction)
 		queries.extend([pe_amount_matching])
 
 	if "journal_entry" in document_types:
-		je_amount_matching = get_je_matching_query(
-			amount_condition,
-			transaction,
-			from_date,
-			to_date,
-			filter_by_reference_date,
-			from_reference_date,
-			to_reference_date,
-		)
+		je_amount_matching = get_je_matching_query(amount_condition, transaction)
 		queries.extend([je_amount_matching])
 
 	if transaction.deposit > 0 and "sales_invoice" in document_types:
@@ -658,81 +504,47 @@ def get_lr_matching_query(bank_account, amount_condition, filters):
 	return vouchers
 
 
-def get_pe_matching_query(
-	amount_condition,
-	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:
 		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
-			+ 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
-			{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(
-	amount_condition,
-	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 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}'"
+
 	return f"""
+
 		SELECT
 			(CASE WHEN je.cheque_no=%(reference_no)s THEN 1 ELSE 0 END
 			+ 1) AS rank ,
@@ -756,9 +568,6 @@ def get_je_matching_query(
 			AND jea.account = %(bank_account)s
 			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}
 	"""
 
 

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -137,7 +137,7 @@ def get_paid_amount(payment_entry, currency, 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(

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

@@ -485,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,206 +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]:
-
-				# TODO: Set new balance in Base/Account currency
-				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")
@@ -258,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"
 		)
@@ -266,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"
@@ -398,7 +154,7 @@ class ExchangeRateRevaluation(Document):
 		journal_entry.multi_currency = 1
 
 		journal_entry_accounts = []
-		for d in accounts:
+		for d in self.accounts:
 			dr_or_cr = (
 				"debit_in_account_currency"
 				if d.get("balance_in_account_currency") > 0
@@ -423,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,
@@ -441,7 +196,6 @@ 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,
@@ -452,11 +206,8 @@ class ExchangeRateRevaluation(Document):
 			{
 				"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,
@@ -466,90 +217,42 @@ class ExchangeRateRevaluation(Document):
 		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)
-		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'];
+		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
   },
@@ -137,7 +137,8 @@
    "fieldname": "finance_book",
    "fieldtype": "Link",
    "label": "Finance Book",
-   "options": "Finance Book"
+   "options": "Finance Book",
+   "read_only": 1
   },
   {
    "fieldname": "2_add_edit_gl_entries",
@@ -538,7 +539,7 @@
  "idx": 176,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-01-17 12:53:53.280620",
+ "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"
@@ -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()
 
@@ -226,34 +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.db.get_value(
-					"Asset", d.reference_name, ["calculate_depreciation", "value_after_depreciation"], as_dict=1
-				)
-
-				if asset.calculate_depreciation:
-					continue
-
-				depr_value = d.debit or d.credit
-
-				frappe.db.set_value(
-					"Asset",
-					d.reference_name,
-					"value_after_depreciation",
-					asset.value_after_depreciation - depr_value,
-				)
-
 	def update_inter_company_jv(self):
 		if (
 			self.voucher_type == "Inter Company Journal Entry"
@@ -312,48 +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
-
-					frappe.db.set_value(
-						"Asset",
-						d.reference_name,
-						"value_after_depreciation",
-						asset.value_after_depreciation + depr_value,
-					)
+						asset.set_status()
 
 	def unlink_inter_company_jv(self):
 		if (
@@ -650,30 +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):
 		self.set_total_debit_credit()
-		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)
-				)
+		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
@@ -711,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"):
@@ -820,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"]:
@@ -850,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)
@@ -898,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:
@@ -913,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.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

@@ -247,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:
@@ -622,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
@@ -632,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)
@@ -684,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.
@@ -1187,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
@@ -1217,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"],
@@ -1243,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)
@@ -1640,7 +1639,7 @@ def get_payment_entry(
 ):
 	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:
@@ -1758,8 +1757,6 @@ 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()
@@ -1777,18 +1774,6 @@ def get_payment_entry(
 	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

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,

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,26 +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 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
+		dr_or_cr = (
+			"credit_in_account_currency"
+			if erpnext.get_party_account_type(self.party_type) == "Receivable"
+			else "debit_in_account_currency"
+		)
+
+		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")})
@@ -252,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)
@@ -288,7 +276,6 @@ class PaymentReconciliation(Document):
 				"amount": pay.get("amount"),
 				"allocated_amount": allocated_amount,
 				"difference_amount": pay.get("difference_amount"),
-				"currency": inv.get("currency"),
 			}
 		)
 
@@ -311,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)
@@ -326,56 +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),
-			}
-		)
-
-		journal_entry.append("accounts", journal_account)
-
-		journal_entry.save()
-		journal_entry.submit()
-
 	def get_payment_details(self, row, dr_or_cr):
 		return frappe._dict(
 			{
@@ -385,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"),
@@ -410,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()
 
@@ -486,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

@@ -6,10 +6,8 @@ import unittest
 import frappe
 from frappe import qb
 from frappe.tests.utils import FrappeTestCase
-from frappe.utils import add_days, flt, nowdate
+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)
@@ -473,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()
@@ -511,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
@@ -585,255 +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])
-
-
-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
 

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -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/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

@@ -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/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",
@@ -1426,7 +1425,6 @@
   },
   {
    "default": "0",
-   "depends_on": "apply_tds",
    "fieldname": "tax_withholding_net_total",
    "fieldtype": "Currency",
    "hidden": 1,
@@ -1436,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
   },
@@ -1544,19 +1541,13 @@
    "fieldtype": "Link",
    "label": "Incoterm",
    "options": "Incoterm"
-  },
-  {
-   "depends_on": "incoterm",
-   "fieldname": "named_place",
-   "fieldtype": "Data",
-   "label": "Named Place"
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-01-28 19:18:56.586321",
+ "modified": "2022-11-25 12:44:29.935567",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -231,9 +231,7 @@ class PurchaseInvoice(BuyingController):
 		)
 
 		if (
-			cint(frappe.db.get_single_value("Buying Settings", "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(
 				[

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

@@ -61,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",
@@ -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,
@@ -2125,12 +2121,6 @@
    "fieldtype": "Link",
    "label": "Incoterm",
    "options": "Incoterm"
-  },
-  {
-   "depends_on": "incoterm",
-   "fieldname": "named_place",
-   "fieldtype": "Data",
-   "label": "Named Place"
   }
  ],
  "icon": "fa fa-file-text",
@@ -2143,7 +2133,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2023-01-28 19:45:47.538163",
+ "modified": "2022-11-17 17:17:10.883487",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -1185,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
@@ -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()
 
@@ -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
 
@@ -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",

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)
 
@@ -357,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):

erpnext/accounts/party.py

@@ -211,13 +211,7 @@ def set_address_details(
 	else:
 		party_details.update(get_company_address(company))
 
-	if doctype and doctype in [
-		"Delivery Note",
-		"Sales Invoice",
-		"Sales Order",
-		"Quotation",
-		"POS Invoice",
-	]:
+	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)
@@ -550,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")
+					)
 				)
 			)
 
@@ -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_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/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

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py

@@ -268,12 +268,10 @@ def get_cash_flow_data(fiscal_year, companies, filters):
 def get_account_type_based_data(account_type, companies, fiscal_year, filters):
 	data = {}
 	total = 0
-	filters.account_type = account_type
-	filters.start_date = fiscal_year.year_start_date
-	filters.end_date = fiscal_year.year_end_date
-
 	for company in companies:
-		amount = get_account_type_based_gl_data(company, filters)
+		amount = get_account_type_based_gl_data(
+			company, fiscal_year.year_start_date, fiscal_year.year_end_date, account_type, filters
+		)
 
 		if amount and account_type == "Depreciation":
 			amount *= -1
@@ -535,13 +533,12 @@ def get_accounts(root_type, companies):
 			],
 			filters={"company": company, "root_type": root_type},
 		):
-			if account.account_number:
-				account_key = account.account_number + "-" + account.account_name
-			else:
-				account_key = account.account_name
-
-			if account_key not in added_accounts:
+			if account.account_name not in added_accounts:
 				accounts.append(account)
+				if account.account_number:
+					account_key = account.account_number + "-" + account.account_name
+				else:
+					account_key = account.account_name
 				added_accounts.append(account_key)
 
 	return accounts

erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py

@@ -26,7 +26,6 @@ class PartyLedgerSummaryReport(object):
 		)
 
 		self.get_gl_entries()
-		self.get_additional_columns()
 		self.get_return_invoices()
 		self.get_party_adjustment_amounts()
 
@@ -34,42 +33,6 @@ class PartyLedgerSummaryReport(object):
 		data = self.get_data()
 		return columns, data
 
-	def get_additional_columns(self):
-		"""
-		Additional Columns for 'User Permission' based access control
-		"""
-		from frappe import qb
-
-		if self.filters.party_type == "Customer":
-			self.territories = frappe._dict({})
-			self.customer_group = frappe._dict({})
-
-			customer = qb.DocType("Customer")
-			result = (
-				frappe.qb.from_(customer)
-				.select(
-					customer.name, customer.territory, customer.customer_group, customer.default_sales_partner
-				)
-				.where((customer.disabled == 0))
-				.run(as_dict=True)
-			)
-
-			for x in result:
-				self.territories[x.name] = x.territory
-				self.customer_group[x.name] = x.customer_group
-		else:
-			self.supplier_group = frappe._dict({})
-			supplier = qb.DocType("Supplier")
-			result = (
-				frappe.qb.from_(supplier)
-				.select(supplier.name, supplier.supplier_group)
-				.where((supplier.disabled == 0))
-				.run(as_dict=True)
-			)
-
-			for x in result:
-				self.supplier_group[x.name] = x.supplier_group
-
 	def get_columns(self):
 		columns = [
 			{
@@ -153,35 +116,6 @@ class PartyLedgerSummaryReport(object):
 			},
 		]
 
-		# Hidden columns for handling 'User Permissions'
-		if self.filters.party_type == "Customer":
-			columns += [
-				{
-					"label": _("Territory"),
-					"fieldname": "territory",
-					"fieldtype": "Link",
-					"options": "Territory",
-					"hidden": 1,
-				},
-				{
-					"label": _("Customer Group"),
-					"fieldname": "customer_group",
-					"fieldtype": "Link",
-					"options": "Customer Group",
-					"hidden": 1,
-				},
-			]
-		else:
-			columns += [
-				{
-					"label": _("Supplier Group"),
-					"fieldname": "supplier_group",
-					"fieldtype": "Link",
-					"options": "Supplier Group",
-					"hidden": 1,
-				}
-			]
-
 		return columns
 
 	def get_data(self):
@@ -209,12 +143,6 @@ class PartyLedgerSummaryReport(object):
 				),
 			)
 
-			if self.filters.party_type == "Customer":
-				self.party_data[gle.party].update({"territory": self.territories.get(gle.party)})
-				self.party_data[gle.party].update({"customer_group": self.customer_group.get(gle.party)})
-			else:
-				self.party_data[gle.party].update({"supplier_group": self.supplier_group.get(gle.party)})
-
 			amount = gle.get(invoice_dr_or_cr) - gle.get(reverse_dr_or_cr)
 			self.party_data[gle.party].closing_balance += amount
 

erpnext/accounts/report/deferred_revenue_and_expense/deferred_revenue_and_expense.py

@@ -378,14 +378,15 @@ class Deferred_Revenue_and_Expense_Report(object):
 		ret += [{}]
 
 		# add total row
-		if self.filters.type == "Revenue":
-			total_row = frappe._dict({"name": "Total Deferred Income"})
-		elif self.filters.type == "Expense":
-			total_row = frappe._dict({"name": "Total Deferred Expense"})
+		if ret is not []:
+			if self.filters.type == "Revenue":
+				total_row = frappe._dict({"name": "Total Deferred Income"})
+			elif self.filters.type == "Expense":
+				total_row = frappe._dict({"name": "Total Deferred Expense"})
 
-		for idx, period in enumerate(self.period_list, 0):
-			total_row[period.key] = self.period_total[idx].total
-		ret.append(total_row)
+			for idx, period in enumerate(self.period_list, 0):
+				total_row[period.key] = self.period_total[idx].total
+			ret.append(total_row)
 
 		return ret
 

erpnext/accounts/report/general_ledger/general_ledger.html

@@ -25,8 +25,8 @@
 	<thead>
 		<tr>
 			<th style="width: 12%">{%= __("Date") %}</th>
-			<th style="width: 15%">{%= __("Reference") %}</th>
-			<th style="width: 25%">{%= __("Remarks") %}</th>
+			<th style="width: 15%">{%= __("Ref") %}</th>
+			<th style="width: 25%">{%= __("Party") %}</th>
 			<th style="width: 15%">{%= __("Debit") %}</th>
 			<th style="width: 15%">{%= __("Credit") %}</th>
 			<th style="width: 18%">{%= __("Balance (Dr - Cr)") %}</th>
@@ -45,6 +45,7 @@
 						<br>
 					{% } %}
 
+					{{ __("Against") }}: {%= data[i].against %}
 					<br>{%= __("Remarks") %}: {%= data[i].remarks %}
 					{% if(data[i].bill_no) { %}
 						<br>{%= __("Supplier Invoice No") %}: {%= data[i].bill_no %}

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -239,7 +239,7 @@ def get_conditions(filters):
 	):
 		conditions.append("(posting_date >=%(from_date)s or is_opening = 'Yes')")
 
-	conditions.append("(posting_date <=%(to_date)s or is_opening = 'Yes')")
+	conditions.append("(posting_date <=%(to_date)s)")
 
 	if filters.get("project"):
 		conditions.append("project in %(project)s")
@@ -526,7 +526,7 @@ def get_columns(filters):
 			"options": "GL Entry",
 			"hidden": 1,
 		},
-		{"label": _("Posting Date"), "fieldname": "posting_date", "fieldtype": "Date", "width": 100},
+		{"label": _("Posting Date"), "fieldname": "posting_date", "fieldtype": "Date", "width": 90},
 		{
 			"label": _("Account"),
 			"fieldname": "account",
@@ -538,13 +538,13 @@ def get_columns(filters):
 			"label": _("Debit ({0})").format(currency),
 			"fieldname": "debit",
 			"fieldtype": "Float",
-			"width": 130,
+			"width": 100,
 		},
 		{
 			"label": _("Credit ({0})").format(currency),
 			"fieldname": "credit",
 			"fieldtype": "Float",
-			"width": 130,
+			"width": 100,
 		},
 		{
 			"label": _("Balance ({0})").format(currency),

erpnext/accounts/report/general_ledger/test_general_ledger.py

@@ -109,7 +109,8 @@ class TestGeneralLedger(FrappeTestCase):
 		frappe.db.set_value(
 			"Company", company, "unrealized_exchange_gain_loss_account", "_Test Exchange Gain/Loss - _TC"
 		)
-		revaluation_jv = revaluation.make_jv_for_revaluation()
+		revaluation_jv = revaluation.make_jv_entry()
+		revaluation_jv = frappe.get_doc(revaluation_jv)
 		revaluation_jv.cost_center = "_Test Cost Center - _TC"
 		for acc in revaluation_jv.get("accounts"):
 			acc.cost_center = "_Test Cost Center - _TC"

erpnext/accounts/report/gross_profit/gross_profit.js

@@ -50,20 +50,6 @@ frappe.query_reports["Gross Profit"] = {
 			"fieldtype": "Link",
 			"options": "Sales Person"
 		},
-		{
-			"fieldname": "warehouse",
-			"label": __("Warehouse"),
-			"fieldtype": "Link",
-			"options": "Warehouse",
-			"get_query": function () {
-				var company = frappe.query_report.get_filter_value('company');
-				return {
-					filters: [
-						["Warehouse", "company", "=", company]
-					]
-				};
-			},
-		},
 	],
 	"tree": true,
 	"name_field": "parent",

erpnext/accounts/report/gross_profit/gross_profit.py

@@ -439,18 +439,6 @@ class GrossProfitGenerator(object):
 					row.delivery_note, frappe._dict()
 				)
 				row.item_row = row.dn_detail
-				# Update warehouse and base_amount from 'Packed Item' List
-				if product_bundles and not row.parent:
-					# For Packed Items, row.parent_invoice will be the Bundle name
-					product_bundle = product_bundles.get(row.parent_invoice)
-					if product_bundle:
-						for packed_item in product_bundle:
-							if (
-								packed_item.get("item_code") == row.item_code
-								and packed_item.get("parent_detail_docname") == row.item_row
-							):
-								row.warehouse = packed_item.warehouse
-								row.base_amount = packed_item.base_amount
 
 			# get buying amount
 			if row.item_code in product_bundles:
@@ -515,7 +503,7 @@ class GrossProfitGenerator(object):
 						invoice_portion = 100
 					elif row.invoice_portion:
 						invoice_portion = row.invoice_portion
-					elif row.payment_amount:
+					else:
 						invoice_portion = row.payment_amount * 100 / row.base_net_amount
 
 					if i == 0:
@@ -601,9 +589,7 @@ class GrossProfitGenerator(object):
 		buying_amount = 0.0
 		for packed_item in product_bundle:
 			if packed_item.get("parent_detail_docname") == row.item_row:
-				packed_item_row = row.copy()
-				packed_item_row.warehouse = packed_item.warehouse
-				buying_amount += self.get_buying_amount(packed_item_row, packed_item.item_code)
+				buying_amount += self.get_buying_amount(row, packed_item.item_code)
 
 		return flt(buying_amount, self.currency_precision)
 
@@ -621,7 +607,6 @@ class GrossProfitGenerator(object):
 					return abs(previous_stock_value - flt(sle.stock_value)) * flt(row.qty) / abs(flt(sle.qty))
 				else:
 					return flt(row.qty) * self.get_average_buying_rate(row, item_code)
-		return 0.0
 
 	def get_buying_amount(self, row, item_code):
 		# IMP NOTE
@@ -655,35 +640,10 @@ class GrossProfitGenerator(object):
 				return self.calculate_buying_amount_from_sle(
 					row, my_sle, parenttype, parent, item_row, item_code
 				)
-			elif row.sales_order and row.so_detail:
-				incoming_amount = self.get_buying_amount_from_so_dn(row.sales_order, row.so_detail, item_code)
-				if incoming_amount:
-					return incoming_amount
 			else:
 				return flt(row.qty) * self.get_average_buying_rate(row, item_code)
 
-		return flt(row.qty) * self.get_average_buying_rate(row, item_code)
-
-	def get_buying_amount_from_so_dn(self, sales_order, so_detail, item_code):
-		from frappe.query_builder.functions import Sum
-
-		delivery_note = frappe.qb.DocType("Delivery Note")
-		delivery_note_item = frappe.qb.DocType("Delivery Note Item")
-
-		query = (
-			frappe.qb.from_(delivery_note)
-			.inner_join(delivery_note_item)
-			.on(delivery_note.name == delivery_note_item.parent)
-			.select(Sum(delivery_note_item.incoming_rate * delivery_note_item.stock_qty))
-			.where(delivery_note.docstatus == 1)
-			.where(delivery_note_item.item_code == item_code)
-			.where(delivery_note_item.against_sales_order == sales_order)
-			.where(delivery_note_item.so_detail == so_detail)
-			.groupby(delivery_note_item.item_code)
-		)
-
-		incoming_amount = query.run()
-		return flt(incoming_amount[0][0]) if incoming_amount else 0
+		return 0.0
 
 	def get_average_buying_rate(self, row, item_code):
 		args = row
@@ -775,13 +735,6 @@ class GrossProfitGenerator(object):
 		if self.filters.get("item_code"):
 			conditions += " and `tabSales Invoice Item`.item_code = %(item_code)s"
 
-		if self.filters.get("warehouse"):
-			warehouse_details = frappe.db.get_value(
-				"Warehouse", self.filters.get("warehouse"), ["lft", "rgt"], as_dict=1
-			)
-			if warehouse_details:
-				conditions += f" and `tabSales Invoice Item`.warehouse in (select name from `tabWarehouse` wh where wh.lft >= {warehouse_details.lft} and wh.rgt <= {warehouse_details.rgt} and warehouse = wh.name)"
-
 		self.si_list = frappe.db.sql(
 			"""
 			select
@@ -792,8 +745,7 @@ class GrossProfitGenerator(object):
 				`tabSales Invoice`.territory, `tabSales Invoice Item`.item_code,
 				`tabSales Invoice Item`.item_name, `tabSales Invoice Item`.description,
 				`tabSales Invoice Item`.warehouse, `tabSales Invoice Item`.item_group,
-				`tabSales Invoice Item`.brand, `tabSales Invoice Item`.so_detail,
-				`tabSales Invoice Item`.sales_order, `tabSales Invoice Item`.dn_detail,
+				`tabSales Invoice Item`.brand, `tabSales Invoice Item`.dn_detail,
 				`tabSales Invoice Item`.delivery_note, `tabSales Invoice Item`.stock_qty as qty,
 				`tabSales Invoice Item`.base_net_rate, `tabSales Invoice Item`.base_net_amount,
 				`tabSales Invoice Item`.name as "item_row", `tabSales Invoice`.is_return,
@@ -969,25 +921,12 @@ class GrossProfitGenerator(object):
 	def load_product_bundle(self):
 		self.product_bundles = {}
 
-		pki = qb.DocType("Packed Item")
-
-		pki_query = (
-			frappe.qb.from_(pki)
-			.select(
-				pki.parenttype,
-				pki.parent,
-				pki.parent_item,
-				pki.item_code,
-				pki.warehouse,
-				(-1 * pki.qty).as_("total_qty"),
-				pki.rate,
-				(pki.rate * pki.qty).as_("base_amount"),
-				pki.parent_detail_docname,
-			)
-			.where(pki.docstatus == 1)
-		)
-
-		for d in pki_query.run(as_dict=True):
+		for d in frappe.db.sql(
+			"""select parenttype, parent, parent_item,
+			item_code, warehouse, -1*qty as total_qty, parent_detail_docname
+			from `tabPacked Item` where docstatus=1""",
+			as_dict=True,
+		):
 			self.product_bundles.setdefault(d.parenttype, frappe._dict()).setdefault(
 				d.parent, frappe._dict()
 			).setdefault(d.parent_item, []).append(d)

erpnext/accounts/report/gross_profit/test_gross_profit.py

@@ -6,8 +6,6 @@ from frappe.utils import add_days, flt, nowdate
 from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_delivery_note
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.report.gross_profit.gross_profit import execute
-from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_invoice
-from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
 from erpnext.stock.doctype.item.test_item import create_item
 from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry
 
@@ -16,7 +14,6 @@ class TestGrossProfit(FrappeTestCase):
 	def setUp(self):
 		self.create_company()
 		self.create_item()
-		self.create_bundle()
 		self.create_customer()
 		self.create_sales_invoice()
 		self.clear_old_entries()
@@ -45,7 +42,6 @@ class TestGrossProfit(FrappeTestCase):
 		self.company = company.name
 		self.cost_center = company.cost_center
 		self.warehouse = "Stores - " + abbr
-		self.finished_warehouse = "Finished Goods - " + abbr
 		self.income_account = "Sales - " + abbr
 		self.expense_account = "Cost of Goods Sold - " + abbr
 		self.debit_to = "Debtors - " + abbr
@@ -57,23 +53,6 @@ class TestGrossProfit(FrappeTestCase):
 		)
 		self.item = item if isinstance(item, str) else item.item_code
 
-	def create_bundle(self):
-		from erpnext.selling.doctype.product_bundle.test_product_bundle import make_product_bundle
-
-		item2 = create_item(
-			item_code="_Test GP Item 2", is_stock_item=1, company=self.company, warehouse=self.warehouse
-		)
-		self.item2 = item2 if isinstance(item2, str) else item2.item_code
-
-		# This will be parent item
-		bundle = create_item(
-			item_code="_Test GP bundle", is_stock_item=0, company=self.company, warehouse=self.warehouse
-		)
-		self.bundle = bundle if isinstance(bundle, str) else bundle.item_code
-
-		# Create Product Bundle
-		self.product_bundle = make_product_bundle(parent=self.bundle, items=[self.item, self.item2])
-
 	def create_customer(self):
 		name = "_Test GP Customer"
 		if frappe.db.exists("Customer", name):
@@ -114,28 +93,6 @@ class TestGrossProfit(FrappeTestCase):
 		)
 		return sinv
 
-	def create_delivery_note(
-		self, item=None, qty=1, rate=100, posting_date=nowdate(), do_not_save=False, do_not_submit=False
-	):
-		"""
-		Helper function to populate default values in Delivery Note
-		"""
-		dnote = create_delivery_note(
-			company=self.company,
-			customer=self.customer,
-			currency="INR",
-			item=item or self.item,
-			qty=qty,
-			rate=rate,
-			cost_center=self.cost_center,
-			warehouse=self.warehouse,
-			return_against=None,
-			expense_account=self.expense_account,
-			do_not_save=do_not_save,
-			do_not_submit=do_not_submit,
-		)
-		return dnote
-
 	def clear_old_entries(self):
 		doctype_list = [
 			"Sales Invoice",
@@ -250,134 +207,3 @@ class TestGrossProfit(FrappeTestCase):
 		}
 		gp_entry = [x for x in data if x.parent_invoice == sinv.name]
 		self.assertDictContainsSubset(expected_entry_with_dn, gp_entry[0])
-
-	def test_bundled_delivery_note_with_different_warehouses(self):
-		"""
-		Test Delivery Note with bundled item. Packed Item from the bundle having different warehouses
-		"""
-		se = make_stock_entry(
-			company=self.company,
-			item_code=self.item,
-			target=self.warehouse,
-			qty=1,
-			basic_rate=100,
-			do_not_submit=True,
-		)
-		item = se.items[0]
-		se.append(
-			"items",
-			{
-				"item_code": self.item2,
-				"s_warehouse": "",
-				"t_warehouse": self.finished_warehouse,
-				"qty": 1,
-				"basic_rate": 100,
-				"conversion_factor": item.conversion_factor or 1.0,
-				"transfer_qty": flt(item.qty) * (flt(item.conversion_factor) or 1.0),
-				"serial_no": item.serial_no,
-				"batch_no": item.batch_no,
-				"cost_center": item.cost_center,
-				"expense_account": item.expense_account,
-			},
-		)
-		se = se.save().submit()
-
-		# Make a Delivery note with Product bundle
-		# Packed Items will have different warehouses
-		dnote = self.create_delivery_note(item=self.bundle, qty=1, rate=200, do_not_submit=True)
-		dnote.packed_items[1].warehouse = self.finished_warehouse
-		dnote = dnote.submit()
-
-		# make Sales Invoice for above delivery note
-		sinv = make_sales_invoice(dnote.name)
-		sinv = sinv.save().submit()
-
-		filters = frappe._dict(
-			company=self.company,
-			from_date=nowdate(),
-			to_date=nowdate(),
-			group_by="Invoice",
-			sales_invoice=sinv.name,
-		)
-
-		columns, data = execute(filters=filters)
-		self.assertGreater(len(data), 0)
-
-	def test_order_connected_dn_and_inv(self):
-		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
-
-		"""
-			Test gp calculation when invoice and delivery note aren't directly connected.
-			SO -- INV
-			|
-			DN
-		"""
-		se = make_stock_entry(
-			company=self.company,
-			item_code=self.item,
-			target=self.warehouse,
-			qty=3,
-			basic_rate=100,
-			do_not_submit=True,
-		)
-		item = se.items[0]
-		se.append(
-			"items",
-			{
-				"item_code": item.item_code,
-				"s_warehouse": item.s_warehouse,
-				"t_warehouse": item.t_warehouse,
-				"qty": 10,
-				"basic_rate": 200,
-				"conversion_factor": item.conversion_factor or 1.0,
-				"transfer_qty": flt(item.qty) * (flt(item.conversion_factor) or 1.0),
-				"serial_no": item.serial_no,
-				"batch_no": item.batch_no,
-				"cost_center": item.cost_center,
-				"expense_account": item.expense_account,
-			},
-		)
-		se = se.save().submit()
-
-		so = make_sales_order(
-			customer=self.customer,
-			company=self.company,
-			warehouse=self.warehouse,
-			item=self.item,
-			qty=4,
-			do_not_save=False,
-			do_not_submit=False,
-		)
-
-		from erpnext.selling.doctype.sales_order.sales_order import (
-			make_delivery_note,
-			make_sales_invoice,
-		)
-
-		make_delivery_note(so.name).submit()
-		sinv = make_sales_invoice(so.name).submit()
-
-		filters = frappe._dict(
-			company=self.company, from_date=nowdate(), to_date=nowdate(), group_by="Invoice"
-		)
-
-		columns, data = execute(filters=filters)
-		expected_entry = {
-			"parent_invoice": sinv.name,
-			"currency": "INR",
-			"sales_invoice": self.item,
-			"customer": self.customer,
-			"posting_date": frappe.utils.datetime.date.fromisoformat(nowdate()),
-			"item_code": self.item,
-			"item_name": self.item,
-			"warehouse": "Stores - _GP",
-			"qty": 4.0,
-			"avg._selling_rate": 100.0,
-			"valuation_rate": 125.0,
-			"selling_amount": 400.0,
-			"buying_amount": 500.0,
-			"gross_profit": -100.0,
-			"gross_profit_%": -25.0,
-		}
-		gp_entry = [x for x in data if x.parent_invoice == sinv.name]
-		self.assertDictContainsSubset(expected_entry, gp_entry[0])

erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py

@@ -53,6 +53,9 @@ def _execute(filters=None, additional_table_columns=None, additional_query_colum
 	item_details = get_item_details()
 
 	for d in item_list:
+		if not d.stock_qty:
+			continue
+
 		item_record = item_details.get(d.item_code)
 
 		purchase_receipt = None
@@ -91,7 +94,7 @@ def _execute(filters=None, additional_table_columns=None, additional_query_colum
 				"expense_account": expense_account,
 				"stock_qty": d.stock_qty,
 				"stock_uom": d.stock_uom,
-				"rate": d.base_net_amount / d.stock_qty if d.stock_qty else d.base_net_amount,
+				"rate": d.base_net_amount / d.stock_qty,
 				"amount": d.base_net_amount,
 			}
 		)

erpnext/accounts/report/supplier_ledger_summary/supplier_ledger_summary.js

@@ -63,6 +63,24 @@ frappe.query_reports["Supplier Ledger Summary"] = {
 			"fieldtype": "Link",
 			"options": "Payment Terms Template"
 		},
+		{
+			"fieldname":"territory",
+			"label": __("Territory"),
+			"fieldtype": "Link",
+			"options": "Territory"
+		},
+		{
+			"fieldname":"sales_partner",
+			"label": __("Sales Partner"),
+			"fieldtype": "Link",
+			"options": "Sales Partner"
+		},
+		{
+			"fieldname":"sales_person",
+			"label": __("Sales Person"),
+			"fieldtype": "Link",
+			"options": "Sales Person"
+		},
 		{
 			"fieldname":"tax_id",
 			"label": __("Tax Id"),

erpnext/accounts/report/tax_detail/tax_detail.py

@@ -234,11 +234,8 @@ def modify_report_columns(doctype, field, column):
 		if field in ["item_tax_rate", "base_net_amount"]:
 			return None
 
-	if doctype == "GL Entry":
-		if field in ["debit", "credit"]:
-			column.update({"label": _("Amount"), "fieldname": "amount"})
-		elif field == "voucher_type":
-			column.update({"fieldtype": "Data", "options": ""})
+	if doctype == "GL Entry" and field in ["debit", "credit"]:
+		column.update({"label": _("Amount"), "fieldname": "amount"})
 
 	if field == "taxes_and_charges":
 		column.update({"label": _("Taxes and Charges Template")})

erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py

@@ -4,7 +4,6 @@
 
 import frappe
 from frappe import _
-from frappe.utils import flt
 
 
 def execute(filters=None):
@@ -66,12 +65,6 @@ def get_result(
 			else:
 				total_amount_credited += entry.credit
 
-		## Check if ldc is applied and show rate as per ldc
-		actual_rate = (tds_deducted / total_amount_credited) * 100
-
-		if flt(actual_rate) < flt(rate):
-			rate = actual_rate
-
 		if tds_deducted:
 			row = {
 				"pan"

erpnext/accounts/report/utils.py

@@ -28,7 +28,7 @@ def get_currency(filters):
 		filters["presentation_currency"] if filters.get("presentation_currency") else company_currency
 	)
 
-	report_date = filters.get("to_date") or filters.get("period_end_date")
+	report_date = filters.get("to_date")
 
 	if not report_date:
 		fiscal_year_to_date = get_from_and_to_date(filters.get("to_fiscal_year"))["to_date"]
@@ -101,8 +101,11 @@ def convert_to_presentation_currency(gl_entries, currency_info, company):
 		account_currency = entry["account_currency"]
 
 		if len(account_currencies) == 1 and account_currency == presentation_currency:
-			entry["debit"] = debit_in_account_currency
-			entry["credit"] = credit_in_account_currency
+			if debit_in_account_currency:
+				entry["debit"] = debit_in_account_currency
+
+			if credit_in_account_currency:
+				entry["credit"] = credit_in_account_currency
 		else:
 			date = currency_info["report_date"]
 			converted_debit_value = convert(debit, presentation_currency, company_currency, date)

erpnext/accounts/test/test_utils.py

@@ -3,14 +3,11 @@ import unittest
 import frappe
 from frappe.test_runner import make_test_objects
 
-from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
-from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 from erpnext.accounts.party import get_party_shipping_address
 from erpnext.accounts.utils import (
 	get_future_stock_vouchers,
 	get_voucherwise_gl_entries,
 	sort_stock_vouchers_by_posting_date,
-	update_reference_in_payment_entry,
 )
 from erpnext.stock.doctype.item.test_item import make_item
 from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
@@ -76,47 +73,6 @@ class TestUtils(unittest.TestCase):
 		sorted_vouchers = sort_stock_vouchers_by_posting_date(list(reversed(vouchers)))
 		self.assertEqual(sorted_vouchers, vouchers)
 
-	def test_update_reference_in_payment_entry(self):
-		item = make_item().name
-
-		purchase_invoice = make_purchase_invoice(
-			item=item, supplier="_Test Supplier USD", currency="USD", conversion_rate=82.32
-		)
-		purchase_invoice.submit()
-
-		payment_entry = get_payment_entry(purchase_invoice.doctype, purchase_invoice.name)
-		payment_entry.target_exchange_rate = 62.9
-		payment_entry.paid_amount = 15725
-		payment_entry.deductions = []
-		payment_entry.insert()
-
-		self.assertEqual(payment_entry.difference_amount, -4855.00)
-		payment_entry.references = []
-		payment_entry.submit()
-
-		payment_reconciliation = frappe.new_doc("Payment Reconciliation")
-		payment_reconciliation.company = payment_entry.company
-		payment_reconciliation.party_type = "Supplier"
-		payment_reconciliation.party = purchase_invoice.supplier
-		payment_reconciliation.receivable_payable_account = payment_entry.paid_to
-		payment_reconciliation.get_unreconciled_entries()
-		payment_reconciliation.allocate_entries(
-			{
-				"payments": [d.__dict__ for d in payment_reconciliation.payments],
-				"invoices": [d.__dict__ for d in payment_reconciliation.invoices],
-			}
-		)
-		for d in payment_reconciliation.invoices:
-			# Reset invoice outstanding_amount because allocate_entries will zero this value out.
-			d.outstanding_amount = d.amount
-		for d in payment_reconciliation.allocation:
-			d.difference_account = "Exchange Gain/Loss - _TC"
-		payment_reconciliation.reconcile()
-
-		payment_entry.load_from_db()
-		self.assertEqual(len(payment_entry.references), 1)
-		self.assertEqual(payment_entry.difference_amount, 0)
-
 
 ADDRESS_RECORDS = [
 	{

erpnext/accounts/utils.py

@@ -439,7 +439,8 @@ def reconcile_against_document(args):  # nosemgrep
 		# cancel advance entry
 		doc = frappe.get_doc(voucher_type, voucher_no)
 		frappe.flags.ignore_party_validation = True
-		_delete_pl_entries(voucher_type, voucher_no)
+		gl_map = doc.build_gl_map()
+		create_payment_ledger_entry(gl_map, cancel=1, adv_adj=1)
 
 		for entry in entries:
 			check_if_advance_entry_modified(entry)
@@ -451,23 +452,11 @@ def reconcile_against_document(args):  # nosemgrep
 			else:
 				update_reference_in_payment_entry(entry, doc, do_not_save=True)
 
-		if doc.doctype == "Journal Entry":
-			try:
-				doc.validate_total_debit_and_credit()
-			except Exception as validation_exception:
-				raise frappe.ValidationError(_(f"Validation Error for {doc.name}")) from validation_exception
-
 		doc.save(ignore_permissions=True)
 		# re-submit advance entry
 		doc = frappe.get_doc(entry.voucher_type, entry.voucher_no)
 		gl_map = doc.build_gl_map()
-		create_payment_ledger_entry(gl_map, update_outstanding="No", cancel=0, adv_adj=1)
-
-		# Only update outstanding for newly linked vouchers
-		for entry in entries:
-			update_voucher_outstanding(
-				entry.against_voucher_type, entry.against_voucher, entry.account, entry.party_type, entry.party
-			)
+		create_payment_ledger_entry(gl_map, cancel=0, adv_adj=1)
 
 		frappe.flags.ignore_party_validation = False
 
@@ -622,6 +611,11 @@ def update_reference_in_payment_entry(d, payment_entry, do_not_save=False):
 		new_row.docstatus = 1
 		new_row.update(reference_details)
 
+	payment_entry.flags.ignore_validate_update_after_submit = True
+	payment_entry.setup_party_account_field()
+	payment_entry.set_missing_values()
+	payment_entry.set_amounts()
+
 	if d.difference_amount and d.difference_account:
 		account_details = {
 			"account": d.difference_account,
@@ -633,11 +627,6 @@ def update_reference_in_payment_entry(d, payment_entry, do_not_save=False):
 
 		payment_entry.set_gain_or_loss(account_details=account_details)
 
-	payment_entry.flags.ignore_validate_update_after_submit = True
-	payment_entry.setup_party_account_field()
-	payment_entry.set_missing_values()
-	payment_entry.set_amounts()
-
 	if not do_not_save:
 		payment_entry.save(ignore_permissions=True)
 
@@ -847,7 +836,6 @@ def get_outstanding_invoices(
 	posting_date=None,
 	min_outstanding=None,
 	max_outstanding=None,
-	accounting_dimensions=None,
 ):
 
 	ple = qb.DocType("Payment Ledger Entry")
@@ -878,7 +866,6 @@ def get_outstanding_invoices(
 		min_outstanding=min_outstanding,
 		max_outstanding=max_outstanding,
 		get_invoices=True,
-		accounting_dimensions=accounting_dimensions or [],
 	)
 
 	for d in invoice_list:
@@ -1512,12 +1499,9 @@ def update_voucher_outstanding(voucher_type, voucher_no, account, party_type, pa
 		ref_doc = frappe.get_doc(voucher_type, voucher_no)
 
 		# Didn't use db_set for optimisation purpose
-		ref_doc.outstanding_amount = outstanding["outstanding_in_account_currency"] or 0.0
+		ref_doc.outstanding_amount = outstanding["outstanding_in_account_currency"]
 		frappe.db.set_value(
-			voucher_type,
-			voucher_no,
-			"outstanding_amount",
-			outstanding["outstanding_in_account_currency"] or 0.0,
+			voucher_type, voucher_no, "outstanding_amount", outstanding["outstanding_in_account_currency"]
 		)
 
 		ref_doc.set_status(update=True)
@@ -1631,7 +1615,6 @@ class QueryPaymentLedger(object):
 			.where(ple.delinked == 0)
 			.where(Criterion.all(filter_on_voucher_no))
 			.where(Criterion.all(self.common_filter))
-			.where(Criterion.all(self.dimensions_filter))
 			.where(Criterion.all(self.voucher_posting_date))
 			.groupby(ple.voucher_type, ple.voucher_no, ple.party_type, ple.party)
 		)
@@ -1719,7 +1702,6 @@ class QueryPaymentLedger(object):
 		max_outstanding=None,
 		get_payments=False,
 		get_invoices=False,
-		accounting_dimensions=None,
 	):
 		"""
 		Fetch voucher amount and outstanding amount from Payment Ledger using Database CTE
@@ -1735,7 +1717,6 @@ class QueryPaymentLedger(object):
 		self.reset()
 		self.vouchers = vouchers
 		self.common_filter = common_filter or []
-		self.dimensions_filter = accounting_dimensions or []
 		self.voucher_posting_date = posting_date or []
 		self.min_outstanding = min_outstanding
 		self.max_outstanding = max_outstanding

erpnext/assets/doctype/asset/asset.js

@@ -76,6 +76,7 @@ frappe.ui.form.on('Asset', {
 	refresh: function(frm) {
 		frappe.ui.form.trigger("Asset", "is_existing_asset");
 		frm.toggle_display("next_depreciation_date", frm.doc.docstatus < 1);
+		frm.events.make_schedules_editable(frm);
 
 		if (frm.doc.docstatus==1) {
 			if (in_list(["Submitted", "Partially Depreciated", "Fully Depreciated"], frm.doc.status)) {
@@ -135,10 +136,6 @@ frappe.ui.form.on('Asset', {
 				}, __("Manage"));
 			}
 
-			if (frm.doc.depr_entry_posting_status === "Failed") {
-				frm.trigger("set_depr_posting_failure_alert");
-			}
-
 			frm.trigger("setup_chart");
 		}
 
@@ -149,19 +146,6 @@ frappe.ui.form.on('Asset', {
 		}
 	},
 
-	set_depr_posting_failure_alert: function (frm) {
-		const alert = `
-			<div class="row">
-				<div class="col-xs-12 col-sm-6">
-					<span class="indicator whitespace-nowrap red">
-						<span>Failed to post depreciation entries</span>
-					</span>
-				</div>
-			</div>`;
-
-		frm.dashboard.set_headline_alert(alert);
-	},
-
 	toggle_reference_doc: function(frm) {
 		if (frm.doc.purchase_receipt && frm.doc.purchase_invoice && frm.doc.docstatus === 1) {
 			frm.set_df_property('purchase_invoice', 'read_only', 1);
@@ -204,67 +188,39 @@ frappe.ui.form.on('Asset', {
 		})
 	},
 
-	setup_chart: async function(frm) {
-		if(frm.doc.finance_books.length > 1) {
-			return
-		}
-
-		var x_intervals = [frappe.format(frm.doc.purchase_date, { fieldtype: 'Date' })];
+	setup_chart: function(frm) {
+		var x_intervals = [frm.doc.purchase_date];
 		var asset_values = [frm.doc.gross_purchase_amount];
+		var last_depreciation_date = frm.doc.purchase_date;
 
-		if(frm.doc.calculate_depreciation) {
-			if(frm.doc.opening_accumulated_depreciation) {
-				var depreciation_date = frappe.datetime.add_months(
-					frm.doc.finance_books[0].depreciation_start_date,
-					-1 * frm.doc.finance_books[0].frequency_of_depreciation
-				);
-				x_intervals.push(frappe.format(depreciation_date, { fieldtype: 'Date' }));
-				asset_values.push(flt(frm.doc.gross_purchase_amount - frm.doc.opening_accumulated_depreciation, precision('gross_purchase_amount')));
-			}
+		if(frm.doc.opening_accumulated_depreciation) {
+			last_depreciation_date = frappe.datetime.add_months(frm.doc.next_depreciation_date,
+				-1*frm.doc.frequency_of_depreciation);
 
-			let depr_schedule = (await frappe.call(
-				"erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule.get_depr_schedule",
-				{
-					asset_name: frm.doc.name,
-					status: frm.doc.docstatus ? "Active" : "Draft",
-					finance_book: frm.doc.finance_books[0].finance_book || null
-				}
-			)).message;
-
-			$.each(depr_schedule || [], function(i, v) {
-				x_intervals.push(frappe.format(v.schedule_date, { fieldtype: 'Date' }));
-				var asset_value = flt(frm.doc.gross_purchase_amount - v.accumulated_depreciation_amount, precision('gross_purchase_amount'));
-				if(v.journal_entry) {
-					asset_values.push(asset_value);
-				} else {
-					if (in_list(["Scrapped", "Sold"], frm.doc.status)) {
-						asset_values.push(null);
-					} else {
-						asset_values.push(asset_value)
-					}
-				}
-			});
-		} else {
-			if(frm.doc.opening_accumulated_depreciation) {
-				x_intervals.push(frappe.format(frm.doc.creation.split(" ")[0], { fieldtype: 'Date' }));
-				asset_values.push(flt(frm.doc.gross_purchase_amount - frm.doc.opening_accumulated_depreciation, precision('gross_purchase_amount')));
-			}
-
-			let depr_entries = (await frappe.call({
-				method: "get_manual_depreciation_entries",
-				doc: frm.doc,
-			})).message;
-
-			$.each(depr_entries || [], function(i, v) {
-				x_intervals.push(frappe.format(v.posting_date, { fieldtype: 'Date' }));
-				let last_asset_value = asset_values[asset_values.length - 1]
-				asset_values.push(last_asset_value - v.value);
-			});
+			x_intervals.push(last_depreciation_date);
+			asset_values.push(flt(frm.doc.gross_purchase_amount) -
+				flt(frm.doc.opening_accumulated_depreciation));
 		}
 
+		$.each(frm.doc.schedules || [], function(i, v) {
+			x_intervals.push(v.schedule_date);
+			var asset_value = flt(frm.doc.gross_purchase_amount) - flt(v.accumulated_depreciation_amount);
+			if(v.journal_entry) {
+				last_depreciation_date = v.schedule_date;
+				asset_values.push(asset_value);
+			} else {
+				if (in_list(["Scrapped", "Sold"], frm.doc.status)) {
+					asset_values.push(null);
+				} else {
+					asset_values.push(asset_value)
+				}
+			}
+		});
+
 		if(in_list(["Scrapped", "Sold"], frm.doc.status)) {
-			x_intervals.push(frappe.format(frm.doc.disposal_date, { fieldtype: 'Date' }));
+			x_intervals.push(frm.doc.disposal_date);
 			asset_values.push(0);
+			last_depreciation_date = frm.doc.disposal_date;
 		}
 
 		frm.dashboard.render_graph({
@@ -310,6 +266,21 @@ frappe.ui.form.on('Asset', {
 		// frm.toggle_reqd("next_depreciation_date", (!frm.doc.is_existing_asset && frm.doc.calculate_depreciation));
 	},
 
+	opening_accumulated_depreciation: function(frm) {
+		erpnext.asset.set_accumulated_depreciation(frm);
+	},
+
+	make_schedules_editable: function(frm) {
+		if (frm.doc.finance_books) {
+			var is_editable = frm.doc.finance_books.filter(d => d.depreciation_method == "Manual").length > 0
+				? true : false;
+
+			frm.toggle_enable("schedules", is_editable);
+			frm.fields_dict["schedules"].grid.toggle_enable("schedule_date", is_editable);
+			frm.fields_dict["schedules"].grid.toggle_enable("depreciation_amount", is_editable);
+		}
+	},
+
 	make_sales_invoice: function(frm) {
 		frappe.call({
 			args: {
@@ -505,6 +476,7 @@ frappe.ui.form.on('Asset Finance Book', {
 	depreciation_method: function(frm, cdt, cdn) {
 		const row = locals[cdt][cdn];
 		frm.events.set_depreciation_rate(frm, row);
+		frm.events.make_schedules_editable(frm);
 	},
 
 	expected_value_after_useful_life: function(frm, cdt, cdn) {
@@ -540,6 +512,41 @@ frappe.ui.form.on('Asset Finance Book', {
 	}
 });
 
+frappe.ui.form.on('Depreciation Schedule', {
+	make_depreciation_entry: function(frm, cdt, cdn) {
+		var row = locals[cdt][cdn];
+		if (!row.journal_entry) {
+			frappe.call({
+				method: "erpnext.assets.doctype.asset.depreciation.make_depreciation_entry",
+				args: {
+					"asset_name": frm.doc.name,
+					"date": row.schedule_date
+				},
+				callback: function(r) {
+					frappe.model.sync(r.message);
+					frm.refresh();
+				}
+			})
+		}
+	},
+
+	depreciation_amount: function(frm, cdt, cdn) {
+		erpnext.asset.set_accumulated_depreciation(frm);
+	}
+
+})
+
+erpnext.asset.set_accumulated_depreciation = function(frm) {
+	if(frm.doc.depreciation_method != "Manual") return;
+
+	var accumulated_depreciation = flt(frm.doc.opening_accumulated_depreciation);
+	$.each(frm.doc.schedules || [], function(i, row) {
+		accumulated_depreciation  += flt(row.depreciation_amount);
+		frappe.model.set_value(row.doctype, row.name,
+			"accumulated_depreciation_amount", accumulated_depreciation);
+	})
+};
+
 erpnext.asset.scrap_asset = function(frm) {
 	frappe.confirm(__("Do you really want to scrap this asset?"), function () {
 		frappe.call({

erpnext/assets/doctype/asset/asset.json

@@ -52,6 +52,8 @@
   "column_break_24",
   "frequency_of_depreciation",
   "next_depreciation_date",
+  "section_break_14",
+  "schedules",
   "insurance_details",
   "policy_number",
   "insurer",
@@ -68,7 +70,6 @@
   "column_break_51",
   "purchase_receipt_amount",
   "default_finance_book",
-  "depr_entry_posting_status",
   "amended_from"
  ],
  "fields": [
@@ -306,6 +307,19 @@
    "label": "Next Depreciation Date",
    "no_copy": 1
   },
+  {
+   "depends_on": "calculate_depreciation",
+   "fieldname": "section_break_14",
+   "fieldtype": "Section Break",
+   "label": "Depreciation Schedule"
+  },
+  {
+   "fieldname": "schedules",
+   "fieldtype": "Table",
+   "label": "Depreciation Schedule",
+   "no_copy": 1,
+   "options": "Depreciation Schedule"
+  },
   {
    "collapsible": 1,
    "fieldname": "insurance_details",
@@ -474,16 +488,6 @@
    "fieldtype": "Int",
    "label": "Asset Quantity",
    "read_only_depends_on": "eval:!doc.is_existing_asset"
-  },
-  {
-   "fieldname": "depr_entry_posting_status",
-   "fieldtype": "Select",
-   "hidden": 1,
-   "label": "Depreciation Entry Posting Status",
-   "no_copy": 1,
-   "options": "\nSuccessful\nFailed",
-   "print_hide": 1,
-   "read_only": 1
   }
  ],
  "idx": 72,
@@ -498,26 +502,15 @@
   {
    "group": "Repair",
    "link_doctype": "Asset Repair",
-   "link_fieldname": "asset"
+   "link_fieldname": "asset_name"
   },
   {
    "group": "Value",
    "link_doctype": "Asset Value Adjustment",
    "link_fieldname": "asset"
-  },
-  {
-   "group": "Depreciation",
-   "link_doctype": "Asset Depreciation Schedule",
-   "link_fieldname": "asset"
-  },
-  {
-   "group": "Journal Entry",
-   "link_doctype": "Journal Entry",
-   "link_fieldname": "reference_name",
-   "table_fieldname": "accounts"
   }
  ],
- "modified": "2023-02-02 00:03:11.706427",
+ "modified": "2022-07-20 10:15:12.887372",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset",

erpnext/assets/doctype/asset/asset.py

@@ -8,15 +8,14 @@ import math
 import frappe
 from frappe import _
 from frappe.utils import (
+	add_days,
 	add_months,
 	cint,
 	date_diff,
 	flt,
 	get_datetime,
 	get_last_day,
-	get_link_to_form,
 	getdate,
-	is_last_day_of_the_month,
 	month_diff,
 	nowdate,
 	today,
@@ -29,15 +28,6 @@ from erpnext.assets.doctype.asset.depreciation import (
 	get_disposal_account_and_cost_center,
 )
 from erpnext.assets.doctype.asset_category.asset_category import get_asset_category_account
-from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
-	cancel_asset_depr_schedules,
-	convert_draft_asset_depr_schedules_into_active,
-	get_asset_depr_schedule_doc,
-	get_depr_schedule,
-	make_draft_asset_depr_schedules,
-	make_draft_asset_depr_schedules_if_not_present,
-	update_draft_asset_depr_schedules,
-)
 from erpnext.controllers.accounts_controller import AccountsController
 
 
@@ -50,9 +40,9 @@ class Asset(AccountsController):
 		self.set_missing_values()
 		if not self.split_from:
 			self.prepare_depreciation_data()
-			update_draft_asset_depr_schedules(self)
 		self.validate_gross_and_purchase_amount()
-		self.validate_expected_value_after_useful_life()
+		if self.get("schedules"):
+			self.validate_expected_value_after_useful_life()
 
 		self.status = self.get_status()
 
@@ -62,24 +52,16 @@ class Asset(AccountsController):
 		self.make_asset_movement()
 		if not self.booked_fixed_asset and self.validate_make_gl_entry():
 			self.make_gl_entries()
-		if not self.split_from:
-			make_draft_asset_depr_schedules_if_not_present(self)
-			convert_draft_asset_depr_schedules_into_active(self)
 
 	def on_cancel(self):
 		self.validate_cancellation()
 		self.cancel_movement_entries()
 		self.delete_depreciation_entries()
-		cancel_asset_depr_schedules(self)
 		self.set_status()
 		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry")
 		make_reverse_gl_entries(voucher_type="Asset", voucher_no=self.name)
 		self.db_set("booked_fixed_asset", 0)
 
-	def after_insert(self):
-		if not self.split_from:
-			make_draft_asset_depr_schedules(self)
-
 	def validate_asset_and_reference(self):
 		if self.purchase_invoice or self.purchase_receipt:
 			reference_doc = "Purchase Invoice" if self.purchase_invoice else "Purchase Receipt"
@@ -97,10 +79,12 @@ class Asset(AccountsController):
 				_("Purchase Invoice cannot be made against an existing asset {0}").format(self.name)
 			)
 
-	def prepare_depreciation_data(self):
+	def prepare_depreciation_data(self, date_of_disposal=None, date_of_return=None):
 		if self.calculate_depreciation:
 			self.value_after_depreciation = 0
 			self.set_depreciation_rate()
+			self.make_depreciation_schedule(date_of_disposal)
+			self.set_accumulated_depreciation(date_of_disposal, date_of_return)
 		else:
 			self.finance_books = []
 			self.value_after_depreciation = flt(self.gross_purchase_amount) - flt(
@@ -239,6 +223,211 @@ class Asset(AccountsController):
 				self.get_depreciation_rate(d, on_validate=True), d.precision("rate_of_depreciation")
 			)
 
+	def make_depreciation_schedule(self, date_of_disposal):
+		if "Manual" not in [d.depreciation_method for d in self.finance_books] and not self.get(
+			"schedules"
+		):
+			self.schedules = []
+
+		if not self.available_for_use_date:
+			return
+
+		start = self.clear_depreciation_schedule()
+
+		for finance_book in self.get("finance_books"):
+			self._make_depreciation_schedule(finance_book, start, date_of_disposal)
+
+	def _make_depreciation_schedule(self, finance_book, start, date_of_disposal):
+		self.validate_asset_finance_books(finance_book)
+
+		value_after_depreciation = self._get_value_after_depreciation(finance_book)
+		finance_book.value_after_depreciation = value_after_depreciation
+
+		number_of_pending_depreciations = cint(finance_book.total_number_of_depreciations) - cint(
+			self.number_of_depreciations_booked
+		)
+
+		has_pro_rata = self.check_is_pro_rata(finance_book)
+		if has_pro_rata:
+			number_of_pending_depreciations += 1
+
+		skip_row = False
+		should_get_last_day = is_last_day_of_the_month(finance_book.depreciation_start_date)
+
+		for n in range(start[finance_book.idx - 1], number_of_pending_depreciations):
+			# If depreciation is already completed (for double declining balance)
+			if skip_row:
+				continue
+
+			depreciation_amount = get_depreciation_amount(self, value_after_depreciation, finance_book)
+
+			if not has_pro_rata or n < cint(number_of_pending_depreciations) - 1:
+				schedule_date = add_months(
+					finance_book.depreciation_start_date, n * cint(finance_book.frequency_of_depreciation)
+				)
+
+				if should_get_last_day:
+					schedule_date = get_last_day(schedule_date)
+
+				# schedule date will be a year later from start date
+				# so monthly schedule date is calculated by removing 11 months from it
+				monthly_schedule_date = add_months(schedule_date, -finance_book.frequency_of_depreciation + 1)
+
+			# if asset is being sold
+			if date_of_disposal:
+				from_date = self.get_from_date(finance_book.finance_book)
+				depreciation_amount, days, months = self.get_pro_rata_amt(
+					finance_book, depreciation_amount, from_date, date_of_disposal
+				)
+
+				if depreciation_amount > 0:
+					self._add_depreciation_row(
+						date_of_disposal,
+						depreciation_amount,
+						finance_book.depreciation_method,
+						finance_book.finance_book,
+						finance_book.idx,
+					)
+
+				break
+
+			# For first row
+			if has_pro_rata and not self.opening_accumulated_depreciation and n == 0:
+				from_date = add_days(
+					self.available_for_use_date, -1
+				)  # needed to calc depr amount for available_for_use_date too
+				depreciation_amount, days, months = self.get_pro_rata_amt(
+					finance_book, depreciation_amount, from_date, finance_book.depreciation_start_date
+				)
+
+				# For first depr schedule date will be the start date
+				# so monthly schedule date is calculated by removing month difference between use date and start date
+				monthly_schedule_date = add_months(finance_book.depreciation_start_date, -months + 1)
+
+			# For last row
+			elif has_pro_rata and n == cint(number_of_pending_depreciations) - 1:
+				if not self.flags.increase_in_asset_life:
+					# In case of increase_in_asset_life, the self.to_date is already set on asset_repair submission
+					self.to_date = add_months(
+						self.available_for_use_date,
+						(n + self.number_of_depreciations_booked) * cint(finance_book.frequency_of_depreciation),
+					)
+
+				depreciation_amount_without_pro_rata = depreciation_amount
+
+				depreciation_amount, days, months = self.get_pro_rata_amt(
+					finance_book, depreciation_amount, schedule_date, self.to_date
+				)
+
+				depreciation_amount = self.get_adjusted_depreciation_amount(
+					depreciation_amount_without_pro_rata, depreciation_amount, finance_book.finance_book
+				)
+
+				monthly_schedule_date = add_months(schedule_date, 1)
+				schedule_date = add_days(schedule_date, days)
+				last_schedule_date = schedule_date
+
+			if not depreciation_amount:
+				continue
+			value_after_depreciation -= flt(depreciation_amount, self.precision("gross_purchase_amount"))
+
+			# Adjust depreciation amount in the last period based on the expected value after useful life
+			if finance_book.expected_value_after_useful_life and (
+				(
+					n == cint(number_of_pending_depreciations) - 1
+					and value_after_depreciation != finance_book.expected_value_after_useful_life
+				)
+				or value_after_depreciation < finance_book.expected_value_after_useful_life
+			):
+				depreciation_amount += value_after_depreciation - finance_book.expected_value_after_useful_life
+				skip_row = True
+
+			if depreciation_amount > 0:
+				self._add_depreciation_row(
+					schedule_date,
+					depreciation_amount,
+					finance_book.depreciation_method,
+					finance_book.finance_book,
+					finance_book.idx,
+				)
+
+	def _add_depreciation_row(
+		self, schedule_date, depreciation_amount, depreciation_method, finance_book, finance_book_id
+	):
+		self.append(
+			"schedules",
+			{
+				"schedule_date": schedule_date,
+				"depreciation_amount": depreciation_amount,
+				"depreciation_method": depreciation_method,
+				"finance_book": finance_book,
+				"finance_book_id": finance_book_id,
+			},
+		)
+
+	def _get_value_after_depreciation(self, finance_book):
+		# value_after_depreciation - current Asset value
+		if self.docstatus == 1 and finance_book.value_after_depreciation:
+			value_after_depreciation = flt(finance_book.value_after_depreciation)
+		else:
+			value_after_depreciation = flt(self.gross_purchase_amount) - flt(
+				self.opening_accumulated_depreciation
+			)
+
+		return value_after_depreciation
+
+	# depreciation schedules need to be cleared before modification due to increase in asset life/asset sales
+	# JE: Journal Entry, FB: Finance Book
+	def clear_depreciation_schedule(self):
+		start = []
+		num_of_depreciations_completed = 0
+		depr_schedule = []
+
+		for schedule in self.get("schedules"):
+			# to update start when there are JEs linked with all the schedule rows corresponding to an FB
+			if len(start) == (int(schedule.finance_book_id) - 2):
+				start.append(num_of_depreciations_completed)
+				num_of_depreciations_completed = 0
+
+			# to ensure that start will only be updated once for each FB
+			if len(start) == (int(schedule.finance_book_id) - 1):
+				if schedule.journal_entry:
+					num_of_depreciations_completed += 1
+					depr_schedule.append(schedule)
+				else:
+					start.append(num_of_depreciations_completed)
+					num_of_depreciations_completed = 0
+
+		# to update start when all the schedule rows corresponding to the last FB are linked with JEs
+		if len(start) == (len(self.finance_books) - 1):
+			start.append(num_of_depreciations_completed)
+
+		# when the Depreciation Schedule is being created for the first time
+		if start == []:
+			start = [0] * len(self.finance_books)
+		else:
+			self.schedules = depr_schedule
+
+		return start
+
+	def get_from_date(self, finance_book):
+		if not self.get("schedules"):
+			return self.available_for_use_date
+
+		if len(self.finance_books) == 1:
+			return self.schedules[-1].schedule_date
+
+		from_date = ""
+		for schedule in self.get("schedules"):
+			if schedule.finance_book == finance_book:
+				from_date = schedule.schedule_date
+
+		if from_date:
+			return from_date
+
+		# since depr for available_for_use_date is not yet booked
+		return add_days(self.available_for_use_date, -1)
+
 	# if it returns True, depreciation_amount will not be equal for the first and last rows
 	def check_is_pro_rata(self, row):
 		has_pro_rata = False
@@ -323,15 +512,83 @@ class Asset(AccountsController):
 				).format(row.idx)
 			)
 
-	def validate_expected_value_after_useful_life(self):
-		for row in self.get("finance_books"):
-			depr_schedule = get_depr_schedule(self.name, "Draft", row.finance_book)
+	# to ensure that final accumulated depreciation amount is accurate
+	def get_adjusted_depreciation_amount(
+		self, depreciation_amount_without_pro_rata, depreciation_amount_for_last_row, finance_book
+	):
+		if not self.opening_accumulated_depreciation:
+			depreciation_amount_for_first_row = self.get_depreciation_amount_for_first_row(finance_book)
 
-			if not depr_schedule:
+			if (
+				depreciation_amount_for_first_row + depreciation_amount_for_last_row
+				!= depreciation_amount_without_pro_rata
+			):
+				depreciation_amount_for_last_row = (
+					depreciation_amount_without_pro_rata - depreciation_amount_for_first_row
+				)
+
+		return depreciation_amount_for_last_row
+
+	def get_depreciation_amount_for_first_row(self, finance_book):
+		if self.has_only_one_finance_book():
+			return self.schedules[0].depreciation_amount
+		else:
+			for schedule in self.schedules:
+				if schedule.finance_book == finance_book:
+					return schedule.depreciation_amount
+
+	def has_only_one_finance_book(self):
+		if len(self.finance_books) == 1:
+			return True
+
+	def set_accumulated_depreciation(
+		self, date_of_sale=None, date_of_return=None, ignore_booked_entry=False
+	):
+		straight_line_idx = [
+			d.idx for d in self.get("schedules") if d.depreciation_method == "Straight Line"
+		]
+		finance_books = []
+
+		for i, d in enumerate(self.get("schedules")):
+			if ignore_booked_entry and d.journal_entry:
 				continue
 
+			if int(d.finance_book_id) not in finance_books:
+				accumulated_depreciation = flt(self.opening_accumulated_depreciation)
+				value_after_depreciation = flt(self.get_value_after_depreciation(d.finance_book_id))
+				finance_books.append(int(d.finance_book_id))
+
+			depreciation_amount = flt(d.depreciation_amount, d.precision("depreciation_amount"))
+			value_after_depreciation -= flt(depreciation_amount)
+
+			# for the last row, if depreciation method = Straight Line
+			if (
+				straight_line_idx
+				and i == max(straight_line_idx) - 1
+				and not date_of_sale
+				and not date_of_return
+			):
+				book = self.get("finance_books")[cint(d.finance_book_id) - 1]
+				depreciation_amount += flt(
+					value_after_depreciation - flt(book.expected_value_after_useful_life),
+					d.precision("depreciation_amount"),
+				)
+
+			d.depreciation_amount = depreciation_amount
+			accumulated_depreciation += d.depreciation_amount
+			d.accumulated_depreciation_amount = flt(
+				accumulated_depreciation, d.precision("accumulated_depreciation_amount")
+			)
+
+	def get_value_after_depreciation(self, idx):
+		return flt(self.get("finance_books")[cint(idx) - 1].value_after_depreciation)
+
+	def validate_expected_value_after_useful_life(self):
+		for row in self.get("finance_books"):
 			accumulated_depreciation_after_full_schedule = [
-				d.accumulated_depreciation_amount for d in depr_schedule
+				d.accumulated_depreciation_amount
+				for d in self.get("schedules")
+				if cint(d.finance_book_id) == row.idx
 			]
 
 			if accumulated_depreciation_after_full_schedule:
@@ -380,23 +637,15 @@ class Asset(AccountsController):
 			movement.cancel()
 
 	def delete_depreciation_entries(self):
-		if self.calculate_depreciation:
-			for row in self.get("finance_books"):
-				depr_schedule = get_depr_schedule(self.name, "Active", row.finance_book)
+		for d in self.get("schedules"):
+			if d.journal_entry:
+				frappe.get_doc("Journal Entry", d.journal_entry).cancel()
+				d.db_set("journal_entry", None)
 
-				for d in depr_schedule or []:
-					if d.journal_entry:
-						frappe.get_doc("Journal Entry", d.journal_entry).cancel()
-		else:
-			depr_entries = self.get_manual_depreciation_entries()
-
-			for depr_entry in depr_entries or []:
-				frappe.get_doc("Journal Entry", depr_entry.name).cancel()
-
-			self.db_set(
-				"value_after_depreciation",
-				(flt(self.gross_purchase_amount) - flt(self.opening_accumulated_depreciation)),
-			)
+		self.db_set(
+			"value_after_depreciation",
+			(flt(self.gross_purchase_amount) - flt(self.opening_accumulated_depreciation)),
+		)
 
 	def set_status(self, status=None):
 		"""Get and update status"""
@@ -427,19 +676,6 @@ class Asset(AccountsController):
 			status = "Cancelled"
 		return status
 
-	def get_value_after_depreciation(self, finance_book=None):
-		if not self.calculate_depreciation:
-			return flt(self.value_after_depreciation, self.precision("gross_purchase_amount"))
-
-		if not finance_book:
-			return flt(
-				self.get("finance_books")[0].value_after_depreciation, self.precision("gross_purchase_amount")
-			)
-
-		for row in self.get("finance_books"):
-			if finance_book == row.finance_book:
-				return flt(row.value_after_depreciation, self.precision("gross_purchase_amount"))
-
 	def get_default_finance_book_idx(self):
 		if not self.get("default_finance_book") and self.company:
 			self.default_finance_book = erpnext.get_default_finance_book(self.company)
@@ -449,43 +685,6 @@ class Asset(AccountsController):
 				if d.finance_book == self.default_finance_book:
 					return cint(d.idx) - 1
 
-	@frappe.whitelist()
-	def get_manual_depreciation_entries(self):
-		(_, _, depreciation_expense_account) = get_depreciation_accounts(self)
-
-		gle = frappe.qb.DocType("GL Entry")
-
-		records = (
-			frappe.qb.from_(gle)
-			.select(gle.voucher_no.as_("name"), gle.debit.as_("value"), gle.posting_date)
-			.where(gle.against_voucher == self.name)
-			.where(gle.account == depreciation_expense_account)
-			.where(gle.debit != 0)
-			.where(gle.is_cancelled == 0)
-			.orderby(gle.posting_date)
-		).run(as_dict=True)
-
-		return records
-
-	@erpnext.allow_regional
-	def get_depreciation_amount(self, depreciable_value, fb_row):
-		if fb_row.depreciation_method in ("Straight Line", "Manual"):
-			# if the Depreciation Schedule is being prepared for the first time
-			if not self.flags.increase_in_asset_life:
-				depreciation_amount = (
-					flt(self.gross_purchase_amount) - flt(fb_row.expected_value_after_useful_life)
-				) / flt(fb_row.total_number_of_depreciations)
-
-			# if the Depreciation Schedule is being modified after Asset Repair
-			else:
-				depreciation_amount = (
-					flt(fb_row.value_after_depreciation) - flt(fb_row.expected_value_after_useful_life)
-				) / (date_diff(self.to_date, self.available_for_use_date) / 365)
-		else:
-			depreciation_amount = flt(depreciable_value * (flt(fb_row.rate_of_depreciation) / 100))
-
-		return depreciation_amount
-
 	def validate_make_gl_entry(self):
 		purchase_document = self.get_purchase_document()
 		if not purchase_document:
@@ -646,6 +845,7 @@ def update_maintenance_status():
 
 
 def make_post_gl_entry():
+
 	asset_categories = frappe.db.get_all("Asset Category", fields=["name", "enable_cwip_accounting"])
 
 	for asset_category in asset_categories:
@@ -798,7 +998,7 @@ def make_journal_entry(asset_name):
 		depreciation_expense_account,
 	) = get_depreciation_accounts(asset)
 
-	depreciation_cost_center, depreciation_series = frappe.get_cached_value(
+	depreciation_cost_center, depreciation_series = frappe.db.get_value(
 		"Company", asset.company, ["depreciation_cost_center", "series_for_depreciation_entry"]
 	)
 	depreciation_cost_center = asset.cost_center or depreciation_cost_center
@@ -863,13 +1063,6 @@ def is_cwip_accounting_enabled(asset_category):
 	return cint(frappe.db.get_value("Asset Category", asset_category, "enable_cwip_accounting"))
 
 
-@frappe.whitelist()
-def get_asset_value_after_depreciation(asset_name, finance_book=None):
-	asset = frappe.get_doc("Asset", asset_name)
-
-	return asset.get_value_after_depreciation(finance_book)
-
-
 def get_total_days(date, frequency):
 	period_start_date = add_months(date, cint(frequency) * -1)
 
@@ -879,6 +1072,32 @@ def get_total_days(date, frequency):
 	return date_diff(date, period_start_date)
 
 
+def is_last_day_of_the_month(date):
+	last_day_of_the_month = get_last_day(date)
+
+	return getdate(last_day_of_the_month) == getdate(date)
+
+
+@erpnext.allow_regional
+def get_depreciation_amount(asset, depreciable_value, row):
+	if row.depreciation_method in ("Straight Line", "Manual"):
+		# if the Depreciation Schedule is being prepared for the first time
+		if not asset.flags.increase_in_asset_life:
+			depreciation_amount = (
+				flt(asset.gross_purchase_amount) - flt(row.expected_value_after_useful_life)
+			) / flt(row.total_number_of_depreciations)
+
+		# if the Depreciation Schedule is being modified after Asset Repair
+		else:
+			depreciation_amount = (
+				flt(row.value_after_depreciation) - flt(row.expected_value_after_useful_life)
+			) / (date_diff(asset.to_date, asset.available_for_use_date) / 365)
+	else:
+		depreciation_amount = flt(depreciable_value * (flt(row.rate_of_depreciation) / 100))
+
+	return depreciation_amount
+
+
 @frappe.whitelist()
 def split_asset(asset_name, split_qty):
 	asset = frappe.get_doc("Asset", asset_name)
@@ -890,12 +1109,12 @@ def split_asset(asset_name, split_qty):
 	remaining_qty = asset.asset_quantity - split_qty
 
 	new_asset = create_new_asset_after_split(asset, split_qty)
-	update_existing_asset(asset, remaining_qty, new_asset.name)
+	update_existing_asset(asset, remaining_qty)
 
 	return new_asset
 
 
-def update_existing_asset(asset, remaining_qty, new_asset_name):
+def update_existing_asset(asset, remaining_qty):
 	remaining_gross_purchase_amount = flt(
 		(asset.gross_purchase_amount * remaining_qty) / asset.asset_quantity
 	)
@@ -913,49 +1132,34 @@ def update_existing_asset(asset, remaining_qty, new_asset_name):
 		},
 	)
 
-	for row in asset.get("finance_books"):
+	for finance_book in asset.get("finance_books"):
 		value_after_depreciation = flt(
-			(row.value_after_depreciation * remaining_qty) / asset.asset_quantity
+			(finance_book.value_after_depreciation * remaining_qty) / asset.asset_quantity
 		)
 		expected_value_after_useful_life = flt(
-			(row.expected_value_after_useful_life * remaining_qty) / asset.asset_quantity
+			(finance_book.expected_value_after_useful_life * remaining_qty) / asset.asset_quantity
 		)
 		frappe.db.set_value(
-			"Asset Finance Book", row.name, "value_after_depreciation", value_after_depreciation
+			"Asset Finance Book", finance_book.name, "value_after_depreciation", value_after_depreciation
 		)
 		frappe.db.set_value(
 			"Asset Finance Book",
-			row.name,
+			finance_book.name,
 			"expected_value_after_useful_life",
 			expected_value_after_useful_life,
 		)
 
-		current_asset_depr_schedule_doc = get_asset_depr_schedule_doc(
-			asset.name, "Active", row.finance_book
+	accumulated_depreciation = 0
+
+	for term in asset.get("schedules"):
+		depreciation_amount = flt((term.depreciation_amount * remaining_qty) / asset.asset_quantity)
+		frappe.db.set_value(
+			"Depreciation Schedule", term.name, "depreciation_amount", depreciation_amount
 		)
-		new_asset_depr_schedule_doc = frappe.copy_doc(current_asset_depr_schedule_doc)
-
-		new_asset_depr_schedule_doc.set_draft_asset_depr_schedule_details(asset, row)
-
-		accumulated_depreciation = 0
-
-		for term in new_asset_depr_schedule_doc.get("depreciation_schedule"):
-			depreciation_amount = flt((term.depreciation_amount * remaining_qty) / asset.asset_quantity)
-			term.depreciation_amount = depreciation_amount
-			accumulated_depreciation += depreciation_amount
-			term.accumulated_depreciation_amount = accumulated_depreciation
-
-		notes = _(
-			"This schedule was created when Asset {0} was updated after being split into new Asset {1}."
-		).format(
-			get_link_to_form(asset.doctype, asset.name), get_link_to_form(asset.doctype, new_asset_name)
+		accumulated_depreciation += depreciation_amount
+		frappe.db.set_value(
+			"Depreciation Schedule", term.name, "accumulated_depreciation_amount", accumulated_depreciation
 		)
-		new_asset_depr_schedule_doc.notes = notes
-
-		current_asset_depr_schedule_doc.flags.should_not_cancel_depreciation_entries = True
-		current_asset_depr_schedule_doc.cancel()
-
-		new_asset_depr_schedule_doc.submit()
 
 
 def create_new_asset_after_split(asset, split_qty):
@@ -969,49 +1173,31 @@ def create_new_asset_after_split(asset, split_qty):
 	new_asset.opening_accumulated_depreciation = opening_accumulated_depreciation
 	new_asset.asset_quantity = split_qty
 	new_asset.split_from = asset.name
+	accumulated_depreciation = 0
 
-	for row in new_asset.get("finance_books"):
-		row.value_after_depreciation = flt(
-			(row.value_after_depreciation * split_qty) / asset.asset_quantity
+	for finance_book in new_asset.get("finance_books"):
+		finance_book.value_after_depreciation = flt(
+			(finance_book.value_after_depreciation * split_qty) / asset.asset_quantity
 		)
-		row.expected_value_after_useful_life = flt(
-			(row.expected_value_after_useful_life * split_qty) / asset.asset_quantity
+		finance_book.expected_value_after_useful_life = flt(
+			(finance_book.expected_value_after_useful_life * split_qty) / asset.asset_quantity
 		)
 
+	for term in new_asset.get("schedules"):
+		depreciation_amount = flt((term.depreciation_amount * split_qty) / asset.asset_quantity)
+		term.depreciation_amount = depreciation_amount
+		accumulated_depreciation += depreciation_amount
+		term.accumulated_depreciation_amount = accumulated_depreciation
+
 	new_asset.submit()
 	new_asset.set_status()
 
-	for row in new_asset.get("finance_books"):
-		current_asset_depr_schedule_doc = get_asset_depr_schedule_doc(
-			asset.name, "Active", row.finance_book
-		)
-		new_asset_depr_schedule_doc = frappe.copy_doc(current_asset_depr_schedule_doc)
-
-		new_asset_depr_schedule_doc.set_draft_asset_depr_schedule_details(new_asset, row)
-
-		accumulated_depreciation = 0
-
-		for term in new_asset_depr_schedule_doc.get("depreciation_schedule"):
-			depreciation_amount = flt((term.depreciation_amount * split_qty) / asset.asset_quantity)
-			term.depreciation_amount = depreciation_amount
-			accumulated_depreciation += depreciation_amount
-			term.accumulated_depreciation_amount = accumulated_depreciation
-
-		notes = _("This schedule was created when new Asset {0} was split from Asset {1}.").format(
-			get_link_to_form(new_asset.doctype, new_asset.name), get_link_to_form(asset.doctype, asset.name)
-		)
-		new_asset_depr_schedule_doc.notes = notes
-
-		new_asset_depr_schedule_doc.submit()
-
-	for row in new_asset.get("finance_books"):
-		depr_schedule = get_depr_schedule(new_asset.name, "Active", row.finance_book)
-		for term in depr_schedule:
-			# Update references in JV
-			if term.journal_entry:
-				add_reference_in_jv_on_split(
-					term.journal_entry, new_asset.name, asset.name, term.depreciation_amount
-				)
+	for term in new_asset.get("schedules"):
+		# Update references in JV
+		if term.journal_entry:
+			add_reference_in_jv_on_split(
+				term.journal_entry, new_asset.name, asset.name, term.depreciation_amount
+			)
 
 	return new_asset
 

erpnext/assets/doctype/asset/depreciation.py

@@ -4,32 +4,15 @@
 
 import frappe
 from frappe import _
-from frappe.utils import (
-	add_months,
-	cint,
-	flt,
-	get_last_day,
-	get_link_to_form,
-	getdate,
-	is_last_day_of_the_month,
-	nowdate,
-	today,
-)
-from frappe.utils.user import get_users_with_role
+from frappe.utils import add_months, cint, flt, getdate, nowdate, today
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_checks_for_pl_and_bs_accounts,
 )
 from erpnext.accounts.doctype.journal_entry.journal_entry import make_reverse_journal_entry
-from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
-	get_asset_depr_schedule_doc,
-	get_asset_depr_schedule_name,
-	get_temp_asset_depr_schedule_doc,
-	make_new_active_asset_depr_schedules_and_cancel_current_ones,
-)
 
 
-def post_depreciation_entries(date=None):
+def post_depreciation_entries(date=None, commit=True):
 	# Return if automatic booking of asset depreciation is disabled
 	if not cint(
 		frappe.db.get_value("Accounts Settings", None, "book_asset_depreciation_entry_automatically")
@@ -38,58 +21,30 @@ def post_depreciation_entries(date=None):
 
 	if not date:
 		date = today()
-
-	failed_asset_names = []
-
-	for asset_name in get_depreciable_assets(date):
-		asset_doc = frappe.get_doc("Asset", asset_name)
-
-		try:
-			make_depreciation_entry_for_all_asset_depr_schedules(asset_doc, date)
+	for asset in get_depreciable_assets(date):
+		make_depreciation_entry(asset, date)
+		if commit:
 			frappe.db.commit()
-		except Exception as e:
-			frappe.db.rollback()
-			failed_asset_names.append(asset_name)
-
-	if failed_asset_names:
-		set_depr_entry_posting_status_for_failed_assets(failed_asset_names)
-		notify_depr_entry_posting_error(failed_asset_names)
-
-	frappe.db.commit()
 
 
 def get_depreciable_assets(date):
 	return frappe.db.sql_list(
 		"""select distinct a.name
-		from tabAsset a, `tabAsset Depreciation Schedule` ads, `tabDepreciation Schedule` ds
-		where a.name = ads.asset and ads.name = ds.parent and a.docstatus=1 and ads.docstatus=1
+		from tabAsset a, `tabDepreciation Schedule` ds
+		where a.name = ds.parent and a.docstatus=1 and ds.schedule_date<=%s and a.calculate_depreciation = 1
 			and a.status in ('Submitted', 'Partially Depreciated')
-			and a.calculate_depreciation = 1
-			and ds.schedule_date<=%s
 			and ifnull(ds.journal_entry, '')=''""",
 		date,
 	)
 
 
-def make_depreciation_entry_for_all_asset_depr_schedules(asset_doc, date=None):
-	for row in asset_doc.get("finance_books"):
-		asset_depr_schedule_name = get_asset_depr_schedule_name(
-			asset_doc.name, "Active", row.finance_book
-		)
-		make_depreciation_entry(asset_depr_schedule_name, date)
-
-
 @frappe.whitelist()
-def make_depreciation_entry(asset_depr_schedule_name, date=None):
+def make_depreciation_entry(asset_name, date=None):
 	frappe.has_permission("Journal Entry", throw=True)
 
 	if not date:
 		date = today()
 
-	asset_depr_schedule_doc = frappe.get_doc("Asset Depreciation Schedule", asset_depr_schedule_name)
-
-	asset_name = asset_depr_schedule_doc.asset
-
 	asset = frappe.get_doc("Asset", asset_name)
 	(
 		fixed_asset_account,
@@ -105,14 +60,14 @@ def make_depreciation_entry(asset_depr_schedule_name, date=None):
 
 	accounting_dimensions = get_checks_for_pl_and_bs_accounts()
 
-	for d in asset_depr_schedule_doc.get("depreciation_schedule"):
+	for d in asset.get("schedules"):
 		if not d.journal_entry and getdate(d.schedule_date) <= getdate(date):
 			je = frappe.new_doc("Journal Entry")
 			je.voucher_type = "Depreciation Entry"
 			je.naming_series = depreciation_series
 			je.posting_date = d.schedule_date
 			je.company = asset.company
-			je.finance_book = asset_depr_schedule_doc.finance_book
+			je.finance_book = d.finance_book
 			je.remark = "Depreciation Entry against {0} worth {1}".format(asset_name, d.depreciation_amount)
 
 			credit_account, debit_account = get_credit_and_debit_accounts(
@@ -163,16 +118,14 @@ def make_depreciation_entry(asset_depr_schedule_name, date=None):
 
 			d.db_set("journal_entry", je.name)
 
-			idx = cint(asset_depr_schedule_doc.finance_book_id)
-			row = asset.get("finance_books")[idx - 1]
-			row.value_after_depreciation -= d.depreciation_amount
-			row.db_update()
-
-	frappe.db.set_value("Asset", asset_name, "depr_entry_posting_status", "Successful")
+			idx = cint(d.finance_book_id)
+			finance_books = asset.get("finance_books")[idx - 1]
+			finance_books.value_after_depreciation -= d.depreciation_amount
+			finance_books.db_update()
 
 	asset.set_status()
 
-	return asset_depr_schedule_doc
+	return asset
 
 
 def get_depreciation_accounts(asset):
@@ -233,42 +186,6 @@ def get_credit_and_debit_accounts(accumulated_depreciation_account, depreciation
 	return credit_account, debit_account
 
 
-def set_depr_entry_posting_status_for_failed_assets(failed_asset_names):
-	for asset_name in failed_asset_names:
-		frappe.db.set_value("Asset", asset_name, "depr_entry_posting_status", "Failed")
-
-
-def notify_depr_entry_posting_error(failed_asset_names):
-	recipients = get_users_with_role("Accounts Manager")
-
-	if not recipients:
-		recipients = get_users_with_role("System Manager")
-
-	subject = _("Error while posting depreciation entries")
-
-	asset_links = get_comma_separated_asset_links(failed_asset_names)
-
-	message = (
-		_("Hi,")
-		+ "<br>"
-		+ _("The following assets have failed to post depreciation entries: {0}").format(asset_links)
-		+ "."
-	)
-
-	frappe.sendmail(recipients=recipients, subject=subject, message=message)
-
-
-def get_comma_separated_asset_links(asset_names):
-	asset_links = []
-
-	for asset_name in asset_names:
-		asset_links.append(get_link_to_form("Asset", asset_name))
-
-	asset_links = ", ".join(asset_links)
-
-	return asset_links
-
-
 @frappe.whitelist()
 def scrap_asset(asset_name):
 	asset = frappe.get_doc("Asset", asset_name)
@@ -282,11 +199,7 @@ def scrap_asset(asset_name):
 
 	date = today()
 
-	notes = _("This schedule was created when Asset {0} was scrapped.").format(
-		get_link_to_form(asset.doctype, asset.name)
-	)
-
-	depreciate_asset(asset, date, notes)
+	depreciate_asset(asset, date)
 	asset.reload()
 
 	depreciation_series = frappe.get_cached_value(
@@ -319,15 +232,10 @@ def restore_asset(asset_name):
 	asset = frappe.get_doc("Asset", asset_name)
 
 	reverse_depreciation_entry_made_after_disposal(asset, asset.disposal_date)
+	reset_depreciation_schedule(asset, asset.disposal_date)
 
 	je = asset.journal_entry_for_scrap
 
-	notes = _("This schedule was created when Asset {0} was restored.").format(
-		get_link_to_form(asset.doctype, asset.name)
-	)
-
-	reset_depreciation_schedule(asset, asset.disposal_date, notes)
-
 	asset.db_set("disposal_date", None)
 	asset.db_set("journal_entry_for_scrap", None)
 
@@ -336,31 +244,25 @@ def restore_asset(asset_name):
 	asset.set_status()
 
 
-def depreciate_asset(asset_doc, date, notes):
-	asset_doc.flags.ignore_validate_update_after_submit = True
+def depreciate_asset(asset, date):
+	asset.flags.ignore_validate_update_after_submit = True
+	asset.prepare_depreciation_data(date_of_disposal=date)
+	asset.save()
 
-	make_new_active_asset_depr_schedules_and_cancel_current_ones(
-		asset_doc, notes, date_of_disposal=date
-	)
-
-	asset_doc.save()
-
-	make_depreciation_entry_for_all_asset_depr_schedules(asset_doc, date)
+	make_depreciation_entry(asset.name, date)
 
 
-def reset_depreciation_schedule(asset_doc, date, notes):
-	asset_doc.flags.ignore_validate_update_after_submit = True
+def reset_depreciation_schedule(asset, date):
+	asset.flags.ignore_validate_update_after_submit = True
 
-	make_new_active_asset_depr_schedules_and_cancel_current_ones(
-		asset_doc, notes, date_of_return=date
-	)
+	# recreate original depreciation schedule of the asset
+	asset.prepare_depreciation_data(date_of_return=date)
 
-	modify_depreciation_schedule_for_asset_repairs(asset_doc, notes)
-
-	asset_doc.save()
+	modify_depreciation_schedule_for_asset_repairs(asset)
+	asset.save()
 
 
-def modify_depreciation_schedule_for_asset_repairs(asset, notes):
+def modify_depreciation_schedule_for_asset_repairs(asset):
 	asset_repairs = frappe.get_all(
 		"Asset Repair", filters={"asset": asset.name}, fields=["name", "increase_in_asset_life"]
 	)
@@ -369,32 +271,35 @@ def modify_depreciation_schedule_for_asset_repairs(asset, notes):
 		if repair.increase_in_asset_life:
 			asset_repair = frappe.get_doc("Asset Repair", repair.name)
 			asset_repair.modify_depreciation_schedule()
-			make_new_active_asset_depr_schedules_and_cancel_current_ones(asset, notes)
+			asset.prepare_depreciation_data()
 
 
 def reverse_depreciation_entry_made_after_disposal(asset, date):
-	for row in asset.get("finance_books"):
-		asset_depr_schedule_doc = get_asset_depr_schedule_doc(asset.name, "Active", row.finance_book)
+	row = -1
+	finance_book = asset.get("schedules")[0].get("finance_book")
+	for schedule in asset.get("schedules"):
+		if schedule.finance_book != finance_book:
+			row = 0
+			finance_book = schedule.finance_book
+		else:
+			row += 1
 
-		for schedule_idx, schedule in enumerate(asset_depr_schedule_doc.get("depreciation_schedule")):
-			if schedule.schedule_date == date:
-				if not disposal_was_made_on_original_schedule_date(
-					schedule_idx, row, date
-				) or disposal_happens_in_the_future(date):
+		if schedule.schedule_date == date:
+			if not disposal_was_made_on_original_schedule_date(
+				asset, schedule, row, date
+			) or disposal_happens_in_the_future(date):
 
-					reverse_journal_entry = make_reverse_journal_entry(schedule.journal_entry)
-					reverse_journal_entry.posting_date = nowdate()
-					frappe.flags.is_reverse_depr_entry = True
-					reverse_journal_entry.submit()
+				reverse_journal_entry = make_reverse_journal_entry(schedule.journal_entry)
+				reverse_journal_entry.posting_date = nowdate()
+				frappe.flags.is_reverse_depr_entry = True
+				reverse_journal_entry.submit()
 
-					frappe.flags.is_reverse_depr_entry = False
-					asset_depr_schedule_doc.flags.ignore_validate_update_after_submit = True
-					asset.flags.ignore_validate_update_after_submit = True
-					schedule.journal_entry = None
-					depreciation_amount = get_depreciation_amount_in_je(reverse_journal_entry)
-					row.value_after_depreciation += depreciation_amount
-					asset_depr_schedule_doc.save()
-					asset.save()
+				frappe.flags.is_reverse_depr_entry = False
+				asset.flags.ignore_validate_update_after_submit = True
+				schedule.journal_entry = None
+				depreciation_amount = get_depreciation_amount_in_je(reverse_journal_entry)
+				asset.finance_books[0].value_after_depreciation += depreciation_amount
+				asset.save()
 
 
 def get_depreciation_amount_in_je(journal_entry):
@@ -405,17 +310,15 @@ def get_depreciation_amount_in_je(journal_entry):
 
 
 # if the invoice had been posted on the date the depreciation was initially supposed to happen, the depreciation shouldn't be undone
-def disposal_was_made_on_original_schedule_date(schedule_idx, row, posting_date_of_disposal):
-	orginal_schedule_date = add_months(
-		row.depreciation_start_date, schedule_idx * cint(row.frequency_of_depreciation)
-	)
-
-	if is_last_day_of_the_month(row.depreciation_start_date):
-		orginal_schedule_date = get_last_day(orginal_schedule_date)
-
-	if orginal_schedule_date == posting_date_of_disposal:
-		return True
+def disposal_was_made_on_original_schedule_date(asset, schedule, row, posting_date_of_disposal):
+	for finance_book in asset.get("finance_books"):
+		if schedule.finance_book == finance_book.finance_book:
+			orginal_schedule_date = add_months(
+				finance_book.depreciation_start_date, row * cint(finance_book.frequency_of_depreciation)
+			)
 
+			if orginal_schedule_date == posting_date_of_disposal:
+				return True
 	return False
 
 
@@ -533,8 +436,18 @@ def get_asset_details(asset, finance_book=None):
 	disposal_account, depreciation_cost_center = get_disposal_account_and_cost_center(asset.company)
 	depreciation_cost_center = asset.cost_center or depreciation_cost_center
 
-	value_after_depreciation = asset.get_value_after_depreciation(finance_book)
+	idx = 1
+	if finance_book:
+		for d in asset.finance_books:
+			if d.finance_book == finance_book:
+				idx = d.idx
+				break
 
+	value_after_depreciation = (
+		asset.finance_books[idx - 1].value_after_depreciation
+		if asset.calculate_depreciation
+		else asset.value_after_depreciation
+	)
 	accumulated_depr_amount = flt(asset.gross_purchase_amount) - flt(value_after_depreciation)
 
 	return (
@@ -586,27 +499,24 @@ def get_disposal_account_and_cost_center(company):
 def get_value_after_depreciation_on_disposal_date(asset, disposal_date, finance_book=None):
 	asset_doc = frappe.get_doc("Asset", asset)
 
-	if not asset_doc.calculate_depreciation:
+	if asset_doc.calculate_depreciation:
+		asset_doc.prepare_depreciation_data(getdate(disposal_date))
+
+		finance_book_id = 1
+		if finance_book:
+			for fb in asset_doc.finance_books:
+				if fb.finance_book == finance_book:
+					finance_book_id = fb.idx
+					break
+
+		asset_schedules = [
+			sch for sch in asset_doc.schedules if cint(sch.finance_book_id) == finance_book_id
+		]
+		accumulated_depr_amount = asset_schedules[-1].accumulated_depreciation_amount
+
+		return flt(
+			flt(asset_doc.gross_purchase_amount) - accumulated_depr_amount,
+			asset_doc.precision("gross_purchase_amount"),
+		)
+	else:
 		return flt(asset_doc.value_after_depreciation)
-
-	idx = 1
-	if finance_book:
-		for d in asset.finance_books:
-			if d.finance_book == finance_book:
-				idx = d.idx
-				break
-
-	row = asset_doc.finance_books[idx - 1]
-
-	temp_asset_depreciation_schedule = get_temp_asset_depr_schedule_doc(
-		asset_doc, row, getdate(disposal_date)
-	)
-
-	accumulated_depr_amount = temp_asset_depreciation_schedule.get("depreciation_schedule")[
-		-1
-	].accumulated_depreciation_amount
-
-	return flt(
-		flt(asset_doc.gross_purchase_amount) - accumulated_depr_amount,
-		asset_doc.precision("gross_purchase_amount"),
-	)

erpnext/assets/doctype/asset/test_asset.py

@@ -16,7 +16,6 @@ from frappe.utils import (
 	nowdate,
 )
 
-from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 from erpnext.assets.doctype.asset.asset import (
 	make_sales_invoice,
@@ -28,10 +27,6 @@ from erpnext.assets.doctype.asset.depreciation import (
 	restore_asset,
 	scrap_asset,
 )
-from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
-	get_asset_depr_schedule_doc,
-	get_depr_schedule,
-)
 from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
 	make_purchase_invoice as make_invoice,
 )
@@ -210,9 +205,6 @@ class TestAsset(AssetSetup):
 			submit=1,
 		)
 
-		first_asset_depr_schedule = get_asset_depr_schedule_doc(asset.name, "Active")
-		self.assertEquals(first_asset_depr_schedule.status, "Active")
-
 		post_depreciation_entries(date=add_months(purchase_date, 2))
 		asset.load_from_db()
 
@@ -224,11 +216,6 @@ class TestAsset(AssetSetup):
 
 		scrap_asset(asset.name)
 		asset.load_from_db()
-		first_asset_depr_schedule.load_from_db()
-
-		second_asset_depr_schedule = get_asset_depr_schedule_doc(asset.name, "Active")
-		self.assertEquals(second_asset_depr_schedule.status, "Active")
-		self.assertEquals(first_asset_depr_schedule.status, "Cancelled")
 
 		accumulated_depr_amount = flt(
 			asset.gross_purchase_amount - asset.finance_books[0].value_after_depreciation,
@@ -269,11 +256,6 @@ class TestAsset(AssetSetup):
 		self.assertSequenceEqual(gle, expected_gle)
 
 		restore_asset(asset.name)
-		second_asset_depr_schedule.load_from_db()
-
-		third_asset_depr_schedule = get_asset_depr_schedule_doc(asset.name, "Active")
-		self.assertEquals(third_asset_depr_schedule.status, "Active")
-		self.assertEquals(second_asset_depr_schedule.status, "Cancelled")
 
 		asset.load_from_db()
 		self.assertFalse(asset.journal_entry_for_scrap)
@@ -301,9 +283,6 @@ class TestAsset(AssetSetup):
 			submit=1,
 		)
 
-		first_asset_depr_schedule = get_asset_depr_schedule_doc(asset.name, "Active")
-		self.assertEquals(first_asset_depr_schedule.status, "Active")
-
 		post_depreciation_entries(date=add_months(purchase_date, 2))
 
 		si = make_sales_invoice(asset=asset.name, item_code="Macbook Pro", company="_Test Company")
@@ -315,12 +294,6 @@ class TestAsset(AssetSetup):
 
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "status"), "Sold")
 
-		first_asset_depr_schedule.load_from_db()
-
-		second_asset_depr_schedule = get_asset_depr_schedule_doc(asset.name, "Active")
-		self.assertEquals(second_asset_depr_schedule.status, "Active")
-		self.assertEquals(first_asset_depr_schedule.status, "Cancelled")
-
 		pro_rata_amount, _, _ = asset.get_pro_rata_amt(
 			asset.finance_books[0], 9000, get_last_day(add_months(purchase_date, 1)), date
 		)
@@ -397,9 +370,6 @@ class TestAsset(AssetSetup):
 			submit=1,
 		)
 
-		first_asset_depr_schedule = get_asset_depr_schedule_doc(asset.name, "Active")
-		self.assertEquals(first_asset_depr_schedule.status, "Active")
-
 		post_depreciation_entries(date="2021-01-01")
 
 		self.assertEqual(asset.asset_quantity, 10)
@@ -408,31 +378,21 @@ class TestAsset(AssetSetup):
 
 		new_asset = split_asset(asset.name, 2)
 		asset.load_from_db()
-		first_asset_depr_schedule.load_from_db()
-
-		second_asset_depr_schedule = get_asset_depr_schedule_doc(asset.name, "Active")
-		first_asset_depr_schedule_of_new_asset = get_asset_depr_schedule_doc(new_asset.name, "Active")
-		self.assertEquals(second_asset_depr_schedule.status, "Active")
-		self.assertEquals(first_asset_depr_schedule_of_new_asset.status, "Active")
-		self.assertEquals(first_asset_depr_schedule.status, "Cancelled")
-
-		depr_schedule_of_asset = second_asset_depr_schedule.get("depreciation_schedule")
-		depr_schedule_of_new_asset = first_asset_depr_schedule_of_new_asset.get("depreciation_schedule")
 
 		self.assertEqual(new_asset.asset_quantity, 2)
 		self.assertEqual(new_asset.gross_purchase_amount, 24000)
 		self.assertEqual(new_asset.opening_accumulated_depreciation, 4000)
 		self.assertEqual(new_asset.split_from, asset.name)
-		self.assertEqual(depr_schedule_of_new_asset[0].depreciation_amount, 4000)
-		self.assertEqual(depr_schedule_of_new_asset[1].depreciation_amount, 4000)
+		self.assertEqual(new_asset.schedules[0].depreciation_amount, 4000)
+		self.assertEqual(new_asset.schedules[1].depreciation_amount, 4000)
 
 		self.assertEqual(asset.asset_quantity, 8)
 		self.assertEqual(asset.gross_purchase_amount, 96000)
 		self.assertEqual(asset.opening_accumulated_depreciation, 16000)
-		self.assertEqual(depr_schedule_of_asset[0].depreciation_amount, 16000)
-		self.assertEqual(depr_schedule_of_asset[1].depreciation_amount, 16000)
+		self.assertEqual(asset.schedules[0].depreciation_amount, 16000)
+		self.assertEqual(asset.schedules[1].depreciation_amount, 16000)
 
-		journal_entry = depr_schedule_of_asset[0].journal_entry
+		journal_entry = asset.schedules[0].journal_entry
 
 		jv = frappe.get_doc("Journal Entry", journal_entry)
 		self.assertEqual(jv.accounts[0].credit_in_account_currency, 16000)
@@ -669,7 +629,7 @@ class TestDepreciationMethods(AssetSetup):
 
 		schedules = [
 			[cstr(d.schedule_date), d.depreciation_amount, d.accumulated_depreciation_amount]
-			for d in get_depr_schedule(asset.name, "Draft")
+			for d in asset.get("schedules")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -691,7 +651,7 @@ class TestDepreciationMethods(AssetSetup):
 		expected_schedules = [["2032-12-31", 30000.0, 77095.89], ["2033-06-06", 12904.11, 90000.0]]
 		schedules = [
 			[cstr(d.schedule_date), flt(d.depreciation_amount, 2), d.accumulated_depreciation_amount]
-			for d in get_depr_schedule(asset.name, "Draft")
+			for d in asset.get("schedules")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -718,7 +678,7 @@ class TestDepreciationMethods(AssetSetup):
 
 		schedules = [
 			[cstr(d.schedule_date), d.depreciation_amount, d.accumulated_depreciation_amount]
-			for d in get_depr_schedule(asset.name, "Draft")
+			for d in asset.get("schedules")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -743,7 +703,7 @@ class TestDepreciationMethods(AssetSetup):
 
 		schedules = [
 			[cstr(d.schedule_date), d.depreciation_amount, d.accumulated_depreciation_amount]
-			for d in get_depr_schedule(asset.name, "Draft")
+			for d in asset.get("schedules")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -773,7 +733,7 @@ class TestDepreciationMethods(AssetSetup):
 				flt(d.depreciation_amount, 2),
 				flt(d.accumulated_depreciation_amount, 2),
 			]
-			for d in get_depr_schedule(asset.name, "Draft")
+			for d in asset.get("schedules")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -805,7 +765,7 @@ class TestDepreciationMethods(AssetSetup):
 				flt(d.depreciation_amount, 2),
 				flt(d.accumulated_depreciation_amount, 2),
 			]
-			for d in get_depr_schedule(asset.name, "Draft")
+			for d in asset.get("schedules")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -838,7 +798,7 @@ class TestDepreciationMethods(AssetSetup):
 				flt(d.depreciation_amount, 2),
 				flt(d.accumulated_depreciation_amount, 2),
 			]
-			for d in get_depr_schedule(asset.name, "Draft")
+			for d in asset.get("schedules")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -871,7 +831,7 @@ class TestDepreciationMethods(AssetSetup):
 				flt(d.depreciation_amount, 2),
 				flt(d.accumulated_depreciation_amount, 2),
 			]
-			for d in get_depr_schedule(asset.name, "Draft")
+			for d in asset.get("schedules")
 		]
 		self.assertEqual(schedules, expected_schedules)
 
@@ -894,7 +854,7 @@ class TestDepreciationBasics(AssetSetup):
 			["2022-12-31", 30000, 90000],
 		]
 
-		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)
@@ -917,13 +877,16 @@ class TestDepreciationBasics(AssetSetup):
 			["2023-01-01", 15000, 90000],
 		]
 
-		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)
 
 	def test_get_depreciation_amount(self):
 		"""Tests if get_depreciation_amount() returns the right value."""
+
+		from erpnext.assets.doctype.asset.asset import get_depreciation_amount
+
 		asset = create_asset(item_code="Macbook Pro", available_for_use_date="2019-12-31")
 
 		asset.calculate_depreciation = 1
@@ -938,11 +901,11 @@ class TestDepreciationBasics(AssetSetup):
 			},
 		)
 
-		depreciation_amount = asset.get_depreciation_amount(100000, asset.finance_books[0])
+		depreciation_amount = get_depreciation_amount(asset, 100000, asset.finance_books[0])
 		self.assertEqual(depreciation_amount, 30000)
 
-	def test_make_depr_schedule(self):
-		"""Tests if make_depr_schedule() returns the right values."""
+	def test_make_depreciation_schedule(self):
+		"""Tests if make_depreciation_schedule() returns the right values."""
 
 		asset = create_asset(
 			item_code="Macbook Pro",
@@ -957,7 +920,7 @@ class TestDepreciationBasics(AssetSetup):
 
 		expected_values = [["2020-12-31", 30000.0], ["2021-12-31", 30000.0], ["2022-12-31", 30000.0]]
 
-		for i, schedule in enumerate(get_depr_schedule(asset.name, "Draft")):
+		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)
 
@@ -977,7 +940,7 @@ class TestDepreciationBasics(AssetSetup):
 
 		expected_values = [30000.0, 60000.0, 90000.0]
 
-		for i, schedule in enumerate(get_depr_schedule(asset.name, "Draft")):
+		for i, schedule in enumerate(asset.schedules):
 			self.assertEqual(expected_values[i], schedule.accumulated_depreciation_amount)
 
 	def test_check_is_pro_rata(self):
@@ -1157,11 +1120,9 @@ class TestDepreciationBasics(AssetSetup):
 		post_depreciation_entries(date="2021-06-01")
 		asset.load_from_db()
 
-		depr_schedule = get_depr_schedule(asset.name, "Active")
-
-		self.assertTrue(depr_schedule[0].journal_entry)
-		self.assertFalse(depr_schedule[1].journal_entry)
-		self.assertFalse(depr_schedule[2].journal_entry)
+		self.assertTrue(asset.schedules[0].journal_entry)
+		self.assertFalse(asset.schedules[1].journal_entry)
+		self.assertFalse(asset.schedules[2].journal_entry)
 
 	def test_depr_entry_posting_when_depr_expense_account_is_an_expense_account(self):
 		"""Tests if the Depreciation Expense Account gets debited and the Accumulated Depreciation Account gets credited when the former's an Expense Account."""
@@ -1180,7 +1141,7 @@ class TestDepreciationBasics(AssetSetup):
 		post_depreciation_entries(date="2021-06-01")
 		asset.load_from_db()
 
-		je = frappe.get_doc("Journal Entry", get_depr_schedule(asset.name, "Active")[0].journal_entry)
+		je = frappe.get_doc("Journal Entry", asset.schedules[0].journal_entry)
 		accounting_entries = [
 			{"account": entry.account, "debit": entry.debit, "credit": entry.credit}
 			for entry in je.accounts
@@ -1216,7 +1177,7 @@ class TestDepreciationBasics(AssetSetup):
 		post_depreciation_entries(date="2021-06-01")
 		asset.load_from_db()
 
-		je = frappe.get_doc("Journal Entry", get_depr_schedule(asset.name, "Active")[0].journal_entry)
+		je = frappe.get_doc("Journal Entry", asset.schedules[0].journal_entry)
 		accounting_entries = [
 			{"account": entry.account, "debit": entry.debit, "credit": entry.credit}
 			for entry in je.accounts
@@ -1235,8 +1196,8 @@ class TestDepreciationBasics(AssetSetup):
 		depr_expense_account.parent_account = "Expenses - _TC"
 		depr_expense_account.save()
 
-	def test_clear_depr_schedule(self):
-		"""Tests if clear_depr_schedule() works as expected."""
+	def test_clear_depreciation_schedule(self):
+		"""Tests if clear_depreciation_schedule() works as expected."""
 
 		asset = create_asset(
 			item_code="Macbook Pro",
@@ -1252,20 +1213,17 @@ class TestDepreciationBasics(AssetSetup):
 		post_depreciation_entries(date="2021-06-01")
 		asset.load_from_db()
 
-		asset_depr_schedule_doc = get_asset_depr_schedule_doc(asset.name, "Active")
+		asset.clear_depreciation_schedule()
 
-		asset_depr_schedule_doc.clear_depr_schedule()
+		self.assertEqual(len(asset.schedules), 1)
 
-		self.assertEqual(len(asset_depr_schedule_doc.get("depreciation_schedule")), 1)
-
-	def test_clear_depr_schedule_for_multiple_finance_books(self):
+	def test_clear_depreciation_schedule_for_multiple_finance_books(self):
 		asset = create_asset(item_code="Macbook Pro", available_for_use_date="2019-12-31", do_not_save=1)
 
 		asset.calculate_depreciation = 1
 		asset.append(
 			"finance_books",
 			{
-				"finance_book": "Test Finance Book 1",
 				"depreciation_method": "Straight Line",
 				"frequency_of_depreciation": 1,
 				"total_number_of_depreciations": 3,
@@ -1276,7 +1234,6 @@ class TestDepreciationBasics(AssetSetup):
 		asset.append(
 			"finance_books",
 			{
-				"finance_book": "Test Finance Book 2",
 				"depreciation_method": "Straight Line",
 				"frequency_of_depreciation": 1,
 				"total_number_of_depreciations": 6,
@@ -1287,7 +1244,6 @@ class TestDepreciationBasics(AssetSetup):
 		asset.append(
 			"finance_books",
 			{
-				"finance_book": "Test Finance Book 3",
 				"depreciation_method": "Straight Line",
 				"frequency_of_depreciation": 12,
 				"total_number_of_depreciations": 3,
@@ -1300,23 +1256,15 @@ class TestDepreciationBasics(AssetSetup):
 		post_depreciation_entries(date="2020-04-01")
 		asset.load_from_db()
 
-		asset_depr_schedule_doc_1 = get_asset_depr_schedule_doc(
-			asset.name, "Active", "Test Finance Book 1"
-		)
-		asset_depr_schedule_doc_1.clear_depr_schedule()
-		self.assertEqual(len(asset_depr_schedule_doc_1.get("depreciation_schedule")), 3)
+		asset.clear_depreciation_schedule()
 
-		asset_depr_schedule_doc_2 = get_asset_depr_schedule_doc(
-			asset.name, "Active", "Test Finance Book 2"
-		)
-		asset_depr_schedule_doc_2.clear_depr_schedule()
-		self.assertEqual(len(asset_depr_schedule_doc_2.get("depreciation_schedule")), 3)
+		self.assertEqual(len(asset.schedules), 6)
 
-		asset_depr_schedule_doc_3 = get_asset_depr_schedule_doc(
-			asset.name, "Active", "Test Finance Book 3"
-		)
-		asset_depr_schedule_doc_3.clear_depr_schedule()
-		self.assertEqual(len(asset_depr_schedule_doc_3.get("depreciation_schedule")), 0)
+		for schedule in asset.schedules:
+			if schedule.idx <= 3:
+				self.assertEqual(schedule.finance_book_id, "1")
+			else:
+				self.assertEqual(schedule.finance_book_id, "2")
 
 	def test_depreciation_schedules_are_set_up_for_multiple_finance_books(self):
 		asset = create_asset(item_code="Macbook Pro", available_for_use_date="2019-12-31", do_not_save=1)
@@ -1325,7 +1273,6 @@ class TestDepreciationBasics(AssetSetup):
 		asset.append(
 			"finance_books",
 			{
-				"finance_book": "Test Finance Book 1",
 				"depreciation_method": "Straight Line",
 				"frequency_of_depreciation": 12,
 				"total_number_of_depreciations": 3,
@@ -1336,7 +1283,6 @@ class TestDepreciationBasics(AssetSetup):
 		asset.append(
 			"finance_books",
 			{
-				"finance_book": "Test Finance Book 2",
 				"depreciation_method": "Straight Line",
 				"frequency_of_depreciation": 12,
 				"total_number_of_depreciations": 6,
@@ -1346,15 +1292,13 @@ class TestDepreciationBasics(AssetSetup):
 		)
 		asset.save()
 
-		asset_depr_schedule_doc_1 = get_asset_depr_schedule_doc(
-			asset.name, "Draft", "Test Finance Book 1"
-		)
-		self.assertEqual(len(asset_depr_schedule_doc_1.get("depreciation_schedule")), 3)
+		self.assertEqual(len(asset.schedules), 9)
 
-		asset_depr_schedule_doc_2 = get_asset_depr_schedule_doc(
-			asset.name, "Draft", "Test Finance Book 2"
-		)
-		self.assertEqual(len(asset_depr_schedule_doc_2.get("depreciation_schedule")), 6)
+		for schedule in asset.schedules:
+			if schedule.idx <= 3:
+				self.assertEqual(schedule.finance_book_id, 1)
+			else:
+				self.assertEqual(schedule.finance_book_id, 2)
 
 	def test_depreciation_entry_cancellation(self):
 		asset = create_asset(
@@ -1374,12 +1318,12 @@ class TestDepreciationBasics(AssetSetup):
 		asset.load_from_db()
 
 		# cancel depreciation entry
-		depr_entry = get_depr_schedule(asset.name, "Active")[0].journal_entry
+		depr_entry = asset.get("schedules")[0].journal_entry
 		self.assertTrue(depr_entry)
-
 		frappe.get_doc("Journal Entry", depr_entry).cancel()
 
-		depr_entry = get_depr_schedule(asset.name, "Active")[0].journal_entry
+		asset.load_from_db()
+		depr_entry = asset.get("schedules")[0].journal_entry
 		self.assertFalse(depr_entry)
 
 	def test_asset_expected_value_after_useful_life(self):
@@ -1394,7 +1338,7 @@ class TestDepreciationBasics(AssetSetup):
 		)
 
 		accumulated_depreciation_after_full_schedule = max(
-			d.accumulated_depreciation_amount for d in get_depr_schedule(asset.name, "Draft")
+			d.accumulated_depreciation_amount for d in asset.get("schedules")
 		)
 
 		asset_value_after_full_schedule = flt(asset.gross_purchase_amount) - flt(
@@ -1425,7 +1369,7 @@ class TestDepreciationBasics(AssetSetup):
 		asset.load_from_db()
 
 		# check depreciation entry series
-		self.assertEqual(get_depr_schedule(asset.name, "Active")[0].journal_entry[:4], "DEPR")
+		self.assertEqual(asset.get("schedules")[0].journal_entry[:4], "DEPR")
 
 		expected_gle = (
 			("_Test Accumulated Depreciations - _TC", 0.0, 30000.0),
@@ -1495,39 +1439,9 @@ class TestDepreciationBasics(AssetSetup):
 			"2020-07-15",
 		]
 
-		for i, schedule in enumerate(get_depr_schedule(asset.name, "Active")):
+		for i, schedule in enumerate(asset.schedules):
 			self.assertEqual(getdate(expected_dates[i]), getdate(schedule.schedule_date))
 
-	def test_manual_depreciation_for_existing_asset(self):
-		asset = create_asset(
-			item_code="Macbook Pro",
-			is_existing_asset=1,
-			purchase_date="2020-01-30",
-			available_for_use_date="2020-01-30",
-			submit=1,
-		)
-
-		self.assertEqual(asset.status, "Submitted")
-		self.assertEqual(asset.get("value_after_depreciation"), 100000)
-
-		jv = make_journal_entry(
-			"_Test Depreciations - _TC", "_Test Accumulated Depreciations - _TC", 100, save=False
-		)
-		for d in jv.accounts:
-			d.reference_type = "Asset"
-			d.reference_name = asset.name
-		jv.voucher_type = "Depreciation Entry"
-		jv.insert()
-		jv.submit()
-
-		asset.reload()
-		self.assertEqual(asset.get("value_after_depreciation"), 99900)
-
-		jv.cancel()
-
-		asset.reload()
-		self.assertEqual(asset.get("value_after_depreciation"), 100000)
-
 
 def create_asset_data():
 	if not frappe.db.exists("Asset Category", "Computers"):
@@ -1539,15 +1453,6 @@ def create_asset_data():
 	if not frappe.db.exists("Location", "Test Location"):
 		frappe.get_doc({"doctype": "Location", "location_name": "Test Location"}).insert()
 
-	if not frappe.db.exists("Finance Book", "Test Finance Book 1"):
-		frappe.get_doc({"doctype": "Finance Book", "finance_book_name": "Test Finance Book 1"}).insert()
-
-	if not frappe.db.exists("Finance Book", "Test Finance Book 2"):
-		frappe.get_doc({"doctype": "Finance Book", "finance_book_name": "Test Finance Book 2"}).insert()
-
-	if not frappe.db.exists("Finance Book", "Test Finance Book 3"):
-		frappe.get_doc({"doctype": "Finance Book", "finance_book_name": "Test Finance Book 3"}).insert()
-
 
 def create_asset(**args):
 	args = frappe._dict(args)
@@ -1574,7 +1479,6 @@ def create_asset(**args):
 			"asset_owner": args.asset_owner or "Company",
 			"is_existing_asset": args.is_existing_asset or 1,
 			"asset_quantity": args.get("asset_quantity") or 1,
-			"depr_entry_posting_status": args.depr_entry_posting_status or "",
 		}
 	)
 

erpnext/assets/doctype/asset_capitalization/asset_capitalization.py

@@ -7,10 +7,10 @@ import frappe
 
 # import erpnext
 from frappe import _
-from frappe.utils import cint, flt, get_link_to_form
+from frappe.utils import cint, flt
+from six import string_types
 
 import erpnext
-from erpnext.assets.doctype.asset.asset import get_asset_value_after_depreciation
 from erpnext.assets.doctype.asset.depreciation import (
 	depreciate_asset,
 	get_gl_entries_on_asset_disposal,
@@ -19,8 +19,8 @@ from erpnext.assets.doctype.asset.depreciation import (
 	reverse_depreciation_entry_made_after_disposal,
 )
 from erpnext.assets.doctype.asset_category.asset_category import get_asset_category_account
-from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
-	make_new_active_asset_depr_schedules_and_cancel_current_ones,
+from erpnext.assets.doctype.asset_value_adjustment.asset_value_adjustment import (
+	get_current_asset_value,
 )
 from erpnext.controllers.stock_controller import StockController
 from erpnext.setup.doctype.brand.brand import get_brand_defaults
@@ -259,9 +259,7 @@ class AssetCapitalization(StockController):
 		for d in self.get("asset_items"):
 			if d.asset:
 				finance_book = d.get("finance_book") or self.get("finance_book")
-				d.current_asset_value = flt(
-					get_asset_value_after_depreciation(d.asset, finance_book=finance_book)
-				)
+				d.current_asset_value = flt(get_current_asset_value(d.asset, finance_book=finance_book))
 				d.asset_value = get_value_after_depreciation_on_disposal_date(
 					d.asset, self.posting_date, finance_book=finance_book
 				)
@@ -429,12 +427,7 @@ class AssetCapitalization(StockController):
 			asset = self.get_asset(item)
 
 			if asset.calculate_depreciation:
-				notes = _(
-					"This schedule was created when Asset {0} was consumed through Asset Capitalization {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(
@@ -520,12 +513,7 @@ class AssetCapitalization(StockController):
 			asset_doc.purchase_date = self.posting_date
 			asset_doc.gross_purchase_amount = total_target_asset_value
 			asset_doc.purchase_receipt_amount = total_target_asset_value
-			notes = _(
-				"This schedule was created when target Asset {0} was updated through Asset Capitalization {1}."
-			).format(
-				get_link_to_form(asset_doc.doctype, asset_doc.name), get_link_to_form(self.doctype, self.name)
-			)
-			make_new_active_asset_depr_schedules_and_cancel_current_ones(asset_doc, notes)
+			asset_doc.prepare_depreciation_data()
 			asset_doc.flags.ignore_validate_update_after_submit = True
 			asset_doc.save()
 		elif self.docstatus == 2:
@@ -536,12 +524,7 @@ class AssetCapitalization(StockController):
 
 				if asset.calculate_depreciation:
 					reverse_depreciation_entry_made_after_disposal(asset, self.posting_date)
-					notes = _(
-						"This schedule was created when Asset {0} was restored on Asset Capitalization {1}'s cancellation."
-					).format(
-						get_link_to_form(asset.doctype, asset.name), get_link_to_form(self.doctype, self.name)
-					)
-					reset_depreciation_schedule(asset, self.posting_date, notes)
+					reset_depreciation_schedule(asset, self.posting_date)
 
 	def get_asset(self, item):
 		asset = frappe.get_doc("Asset", item.asset)
@@ -625,7 +608,7 @@ def get_target_asset_details(asset=None, company=None):
 
 @frappe.whitelist()
 def get_consumed_stock_item_details(args):
-	if isinstance(args, str):
+	if isinstance(args, string_types):
 		args = json.loads(args)
 
 	args = frappe._dict(args)
@@ -677,7 +660,7 @@ def get_consumed_stock_item_details(args):
 
 @frappe.whitelist()
 def get_warehouse_details(args):
-	if isinstance(args, str):
+	if isinstance(args, string_types):
 		args = json.loads(args)
 
 	args = frappe._dict(args)
@@ -693,7 +676,7 @@ def get_warehouse_details(args):
 
 @frappe.whitelist()
 def get_consumed_asset_details(args):
-	if isinstance(args, str):
+	if isinstance(args, string_types):
 		args = json.loads(args)
 
 	args = frappe._dict(args)
@@ -713,7 +696,7 @@ def get_consumed_asset_details(args):
 
 	if args.asset:
 		out.current_asset_value = flt(
-			get_asset_value_after_depreciation(args.asset, finance_book=args.finance_book)
+			get_current_asset_value(args.asset, finance_book=args.finance_book)
 		)
 		out.asset_value = get_value_after_depreciation_on_disposal_date(
 			args.asset, args.posting_date, finance_book=args.finance_book
@@ -745,7 +728,7 @@ def get_consumed_asset_details(args):
 
 @frappe.whitelist()
 def get_service_item_details(args):
-	if isinstance(args, str):
+	if isinstance(args, string_types):
 		args = json.loads(args)
 
 	args = frappe._dict(args)

erpnext/assets/doctype/asset_capitalization/test_asset_capitalization.py

@@ -12,9 +12,6 @@ from erpnext.assets.doctype.asset.test_asset import (
 	create_asset_data,
 	set_depreciation_settings_in_company,
 )
-from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
-	get_asset_depr_schedule_doc,
-)
 from erpnext.stock.doctype.item.test_item import create_item
 
 
@@ -256,9 +253,6 @@ class TestAssetCapitalization(unittest.TestCase):
 			submit=1,
 		)
 
-		first_asset_depr_schedule = get_asset_depr_schedule_doc(consumed_asset.name, "Active")
-		self.assertEquals(first_asset_depr_schedule.status, "Active")
-
 		# Create and submit Asset Captitalization
 		asset_capitalization = create_asset_capitalization(
 			entry_type="Decapitalization",
@@ -288,18 +282,8 @@ class TestAssetCapitalization(unittest.TestCase):
 		consumed_asset.reload()
 		self.assertEqual(consumed_asset.status, "Decapitalized")
 
-		first_asset_depr_schedule.load_from_db()
-
-		second_asset_depr_schedule = get_asset_depr_schedule_doc(consumed_asset.name, "Active")
-		self.assertEquals(second_asset_depr_schedule.status, "Active")
-		self.assertEquals(first_asset_depr_schedule.status, "Cancelled")
-
-		depr_schedule_of_consumed_asset = second_asset_depr_schedule.get("depreciation_schedule")
-
 		consumed_depreciation_schedule = [
-			d
-			for d in depr_schedule_of_consumed_asset
-			if getdate(d.schedule_date) == getdate(capitalization_date)
+			d for d in consumed_asset.schedules if getdate(d.schedule_date) == getdate(capitalization_date)
 		]
 		self.assertTrue(
 			consumed_depreciation_schedule and consumed_depreciation_schedule[0].journal_entry

erpnext/assets/doctype/asset_depreciation_schedule/asset_depreciation_schedule.js

@@ -1,51 +0,0 @@
-// Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
-// For license information, please see license.txt
-frappe.provide("erpnext.asset");
-
-frappe.ui.form.on('Asset Depreciation Schedule', {
-	onload: function(frm) {
-		frm.events.make_schedules_editable(frm);
-	},
-
-	make_schedules_editable: function(frm) {
-		var is_editable = frm.doc.depreciation_method == "Manual" ? true : false;
-
-		frm.toggle_enable("depreciation_schedule", is_editable);
-		frm.fields_dict["depreciation_schedule"].grid.toggle_enable("schedule_date", is_editable);
-		frm.fields_dict["depreciation_schedule"].grid.toggle_enable("depreciation_amount", is_editable);
-	}
-});
-
-frappe.ui.form.on('Depreciation Schedule', {
-	make_depreciation_entry: function(frm, cdt, cdn) {
-		var row = locals[cdt][cdn];
-		if (!row.journal_entry) {
-			frappe.call({
-				method: "erpnext.assets.doctype.asset.depreciation.make_depreciation_entry",
-				args: {
-					"asset_depr_schedule_name": frm.doc.name,
-					"date": row.schedule_date
-				},
-				callback: function(r) {
-					frappe.model.sync(r.message);
-					frm.refresh();
-				}
-			})
-		}
-	},
-
-	depreciation_amount: function(frm, cdt, cdn) {
-		erpnext.asset.set_accumulated_depreciation(frm);
-	}
-});
-
-erpnext.asset.set_accumulated_depreciation = function(frm) {
-	if(frm.doc.depreciation_method != "Manual") return;
-
-	var accumulated_depreciation = flt(frm.doc.opening_accumulated_depreciation);
-	$.each(frm.doc.schedules || [], function(i, row) {
-		accumulated_depreciation  += flt(row.depreciation_amount);
-		frappe.model.set_value(row.doctype, row.name,
-			"accumulated_depreciation_amount", accumulated_depreciation);
-	})
-};

erpnext/assets/doctype/asset_depreciation_schedule/asset_depreciation_schedule.json

@@ -1,202 +0,0 @@
-{
- "actions": [],
- "allow_rename": 1,
- "autoname": "naming_series:",
- "creation": "2022-10-31 15:03:35.424877",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "asset",
-  "naming_series",
-  "column_break_2",
-  "opening_accumulated_depreciation",
-  "finance_book",
-  "finance_book_id",
-  "depreciation_details_section",
-  "depreciation_method",
-  "total_number_of_depreciations",
-  "rate_of_depreciation",
-  "column_break_8",
-  "frequency_of_depreciation",
-  "expected_value_after_useful_life",
-  "depreciation_schedule_section",
-  "depreciation_schedule",
-  "details_section",
-  "notes",
-  "status",
-  "amended_from"
- ],
- "fields": [
-  {
-   "fieldname": "asset",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Asset",
-   "options": "Asset",
-   "reqd": 1
-  },
-  {
-   "fieldname": "naming_series",
-   "fieldtype": "Select",
-   "label": "Naming Series",
-   "options": "ACC-ADS-.YYYY.-"
-  },
-  {
-   "fieldname": "amended_from",
-   "fieldtype": "Link",
-   "label": "Amended From",
-   "no_copy": 1,
-   "options": "Asset Depreciation Schedule",
-   "print_hide": 1,
-   "read_only": 1
-  },
-  {
-   "fieldname": "column_break_2",
-   "fieldtype": "Column Break"
-  },
-  {
-   "collapsible": 1,
-   "fieldname": "depreciation_details_section",
-   "fieldtype": "Section Break",
-   "label": "Depreciation Details"
-  },
-  {
-   "fieldname": "finance_book",
-   "fieldtype": "Link",
-   "label": "Finance Book",
-   "options": "Finance Book"
-  },
-  {
-   "fieldname": "depreciation_method",
-   "fieldtype": "Select",
-   "label": "Depreciation Method",
-   "options": "\nStraight Line\nDouble Declining Balance\nWritten Down Value\nManual",
-   "read_only": 1
-  },
-  {
-   "depends_on": "eval:doc.depreciation_method == 'Written Down Value'",
-   "description": "In Percentage",
-   "fieldname": "rate_of_depreciation",
-   "fieldtype": "Percent",
-   "label": "Rate of Depreciation",
-   "read_only": 1
-  },
-  {
-   "fieldname": "column_break_8",
-   "fieldtype": "Column Break"
-  },
-  {
-   "depends_on": "total_number_of_depreciations",
-   "fieldname": "total_number_of_depreciations",
-   "fieldtype": "Int",
-   "label": "Total Number of Depreciations",
-   "read_only": 1
-  },
-  {
-   "fieldname": "depreciation_schedule_section",
-   "fieldtype": "Section Break",
-   "label": "Depreciation Schedule"
-  },
-  {
-   "fieldname": "depreciation_schedule",
-   "fieldtype": "Table",
-   "label": "Depreciation Schedule",
-   "options": "Depreciation Schedule"
-  },
-  {
-   "collapsible": 1,
-   "collapsible_depends_on": "notes",
-   "fieldname": "details_section",
-   "fieldtype": "Section Break",
-   "label": "Details"
-  },
-  {
-   "fieldname": "notes",
-   "fieldtype": "Small Text",
-   "label": "Notes",
-   "read_only": 1
-  },
-  {
-   "fieldname": "status",
-   "fieldtype": "Select",
-   "hidden": 1,
-   "label": "Status",
-   "options": "Draft\nActive\nCancelled",
-   "read_only": 1
-  },
-  {
-   "depends_on": "frequency_of_depreciation",
-   "fieldname": "frequency_of_depreciation",
-   "fieldtype": "Int",
-   "label": "Frequency of Depreciation (Months)",
-   "read_only": 1
-  },
-  {
-   "fieldname": "expected_value_after_useful_life",
-   "fieldtype": "Currency",
-   "label": "Expected Value After Useful Life",
-   "options": "Company:company:default_currency",
-   "read_only": 1
-  },
-  {
-   "fieldname": "finance_book_id",
-   "fieldtype": "Int",
-   "hidden": 1,
-   "label": "Finance Book Id",
-   "print_hide": 1,
-   "read_only": 1
-  },
-  {
-   "depends_on": "opening_accumulated_depreciation",
-   "fieldname": "opening_accumulated_depreciation",
-   "fieldtype": "Currency",
-   "label": "Opening Accumulated Depreciation",
-   "options": "Company:company:default_currency",
-   "read_only": 1
-  }
- ],
- "index_web_pages_for_search": 1,
- "is_submittable": 1,
- "links": [],
- "modified": "2023-01-16 21:08:21.421260",
- "modified_by": "Administrator",
- "module": "Assets",
- "name": "Asset Depreciation Schedule",
- "naming_rule": "By \"Naming Series\" field",
- "owner": "Administrator",
- "permissions": [
-  {
-   "amend": 1,
-   "cancel": 1,
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "Accounts User",
-   "share": 1,
-   "submit": 1,
-   "write": 1
-  },
-  {
-   "cancel": 1,
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "Quality Manager",
-   "share": 1,
-   "submit": 1,
-   "write": 1
-  }
- ],
- "sort_field": "modified",
- "sort_order": "DESC",
- "states": []
-}

erpnext/assets/doctype/asset_depreciation_schedule/asset_depreciation_schedule.py

@@ -1,475 +0,0 @@
-# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
-# For license information, please see license.txt
-
-import frappe
-from frappe import _
-from frappe.model.document import Document
-from frappe.utils import add_days, add_months, cint, flt, get_last_day, is_last_day_of_the_month
-
-
-class AssetDepreciationSchedule(Document):
-	def before_save(self):
-		if not self.finance_book_id:
-			self.prepare_draft_asset_depr_schedule_data_from_asset_name_and_fb_name(
-				self.asset, self.finance_book
-			)
-
-	def validate(self):
-		self.validate_another_asset_depr_schedule_does_not_exist()
-
-	def validate_another_asset_depr_schedule_does_not_exist(self):
-		finance_book_filter = ["finance_book", "is", "not set"]
-		if self.finance_book:
-			finance_book_filter = ["finance_book", "=", self.finance_book]
-
-		asset_depr_schedule = frappe.db.exists(
-			"Asset Depreciation Schedule",
-			[
-				["asset", "=", self.asset],
-				finance_book_filter,
-				["docstatus", "<", 2],
-			],
-		)
-
-		if asset_depr_schedule and asset_depr_schedule != self.name:
-			if self.finance_book:
-				frappe.throw(
-					_(
-						"Asset Depreciation Schedule {0} for Asset {1} and Finance Book {2} already exists."
-					).format(asset_depr_schedule, self.asset, self.finance_book)
-				)
-			else:
-				frappe.throw(
-					_("Asset Depreciation Schedule {0} for Asset {1} already exists.").format(
-						asset_depr_schedule, self.asset
-					)
-				)
-
-	def on_submit(self):
-		self.db_set("status", "Active")
-
-	def before_cancel(self):
-		if not self.flags.should_not_cancel_depreciation_entries:
-			self.cancel_depreciation_entries()
-
-	def cancel_depreciation_entries(self):
-		for d in self.get("depreciation_schedule"):
-			if d.journal_entry:
-				frappe.get_doc("Journal Entry", d.journal_entry).cancel()
-
-	def on_cancel(self):
-		self.db_set("status", "Cancelled")
-
-	def prepare_draft_asset_depr_schedule_data_from_asset_name_and_fb_name(self, asset_name, fb_name):
-		asset_doc = frappe.get_doc("Asset", asset_name)
-
-		finance_book_filter = ["finance_book", "is", "not set"]
-		if fb_name:
-			finance_book_filter = ["finance_book", "=", fb_name]
-
-		asset_finance_book_name = frappe.db.get_value(
-			doctype="Asset Finance Book",
-			filters=[["parent", "=", asset_name], finance_book_filter],
-		)
-		asset_finance_book_doc = frappe.get_doc("Asset Finance Book", asset_finance_book_name)
-
-		self.prepare_draft_asset_depr_schedule_data(asset_doc, asset_finance_book_doc)
-
-	def prepare_draft_asset_depr_schedule_data(
-		self,
-		asset_doc,
-		row,
-		date_of_disposal=None,
-		date_of_return=None,
-		update_asset_finance_book_row=True,
-	):
-		self.set_draft_asset_depr_schedule_details(asset_doc, row)
-		self.make_depr_schedule(asset_doc, row, date_of_disposal, update_asset_finance_book_row)
-		self.set_accumulated_depreciation(row, date_of_disposal, date_of_return)
-
-	def set_draft_asset_depr_schedule_details(self, asset_doc, row):
-		self.asset = asset_doc.name
-		self.finance_book = row.finance_book
-		self.finance_book_id = row.idx
-		self.opening_accumulated_depreciation = asset_doc.opening_accumulated_depreciation
-		self.depreciation_method = row.depreciation_method
-		self.total_number_of_depreciations = row.total_number_of_depreciations
-		self.frequency_of_depreciation = row.frequency_of_depreciation
-		self.rate_of_depreciation = row.rate_of_depreciation
-		self.expected_value_after_useful_life = row.expected_value_after_useful_life
-		self.status = "Draft"
-
-	def make_depr_schedule(
-		self, asset_doc, row, date_of_disposal, update_asset_finance_book_row=True
-	):
-		if row.depreciation_method != "Manual" and not self.get("depreciation_schedule"):
-			self.depreciation_schedule = []
-
-		if not asset_doc.available_for_use_date:
-			return
-
-		start = self.clear_depr_schedule()
-
-		self._make_depr_schedule(asset_doc, row, start, date_of_disposal, update_asset_finance_book_row)
-
-	def clear_depr_schedule(self):
-		start = 0
-		num_of_depreciations_completed = 0
-		depr_schedule = []
-
-		for schedule in self.get("depreciation_schedule"):
-			if schedule.journal_entry:
-				num_of_depreciations_completed += 1
-				depr_schedule.append(schedule)
-			else:
-				start = num_of_depreciations_completed
-				break
-
-		self.depreciation_schedule = depr_schedule
-
-		return start
-
-	def _make_depr_schedule(
-		self, asset_doc, row, start, date_of_disposal, update_asset_finance_book_row
-	):
-		asset_doc.validate_asset_finance_books(row)
-
-		value_after_depreciation = _get_value_after_depreciation_for_making_schedule(asset_doc, row)
-		row.value_after_depreciation = value_after_depreciation
-
-		if update_asset_finance_book_row:
-			row.db_update()
-
-		number_of_pending_depreciations = cint(row.total_number_of_depreciations) - cint(
-			asset_doc.number_of_depreciations_booked
-		)
-
-		has_pro_rata = asset_doc.check_is_pro_rata(row)
-		if has_pro_rata:
-			number_of_pending_depreciations += 1
-
-		skip_row = False
-		should_get_last_day = is_last_day_of_the_month(row.depreciation_start_date)
-
-		for n in range(start, number_of_pending_depreciations):
-			# If depreciation is already completed (for double declining balance)
-			if skip_row:
-				continue
-
-			depreciation_amount = asset_doc.get_depreciation_amount(value_after_depreciation, row)
-
-			if not has_pro_rata or n < cint(number_of_pending_depreciations) - 1:
-				schedule_date = add_months(
-					row.depreciation_start_date, n * cint(row.frequency_of_depreciation)
-				)
-
-				if should_get_last_day:
-					schedule_date = get_last_day(schedule_date)
-
-				# schedule date will be a year later from start date
-				# so monthly schedule date is calculated by removing 11 months from it
-				monthly_schedule_date = add_months(schedule_date, -row.frequency_of_depreciation + 1)
-
-			# if asset is being sold or scrapped
-			if date_of_disposal:
-				from_date = asset_doc.available_for_use_date
-				if self.depreciation_schedule:
-					from_date = self.depreciation_schedule[-1].schedule_date
-
-				depreciation_amount, days, months = asset_doc.get_pro_rata_amt(
-					row, depreciation_amount, from_date, date_of_disposal
-				)
-
-				if depreciation_amount > 0:
-					self.add_depr_schedule_row(
-						date_of_disposal,
-						depreciation_amount,
-						row.depreciation_method,
-					)
-
-				break
-
-			# For first row
-			if has_pro_rata and not asset_doc.opening_accumulated_depreciation and n == 0:
-				from_date = add_days(
-					asset_doc.available_for_use_date, -1
-				)  # needed to calc depr amount for available_for_use_date too
-				depreciation_amount, days, months = asset_doc.get_pro_rata_amt(
-					row, depreciation_amount, from_date, row.depreciation_start_date
-				)
-
-				# For first depr schedule date will be the start date
-				# so monthly schedule date is calculated by removing
-				# month difference between use date and start date
-				monthly_schedule_date = add_months(row.depreciation_start_date, -months + 1)
-
-			# For last row
-			elif has_pro_rata and n == cint(number_of_pending_depreciations) - 1:
-				if not asset_doc.flags.increase_in_asset_life:
-					# In case of increase_in_asset_life, the asset.to_date is already set on asset_repair submission
-					asset_doc.to_date = add_months(
-						asset_doc.available_for_use_date,
-						(n + asset_doc.number_of_depreciations_booked) * cint(row.frequency_of_depreciation),
-					)
-
-				depreciation_amount_without_pro_rata = depreciation_amount
-
-				depreciation_amount, days, months = asset_doc.get_pro_rata_amt(
-					row, depreciation_amount, schedule_date, asset_doc.to_date
-				)
-
-				depreciation_amount = self.get_adjusted_depreciation_amount(
-					depreciation_amount_without_pro_rata, depreciation_amount
-				)
-
-				monthly_schedule_date = add_months(schedule_date, 1)
-				schedule_date = add_days(schedule_date, days)
-				last_schedule_date = schedule_date
-
-			if not depreciation_amount:
-				continue
-			value_after_depreciation -= flt(
-				depreciation_amount, asset_doc.precision("gross_purchase_amount")
-			)
-
-			# Adjust depreciation amount in the last period based on the expected value after useful life
-			if row.expected_value_after_useful_life and (
-				(
-					n == cint(number_of_pending_depreciations) - 1
-					and value_after_depreciation != row.expected_value_after_useful_life
-				)
-				or value_after_depreciation < row.expected_value_after_useful_life
-			):
-				depreciation_amount += value_after_depreciation - row.expected_value_after_useful_life
-				skip_row = True
-
-			if depreciation_amount > 0:
-				self.add_depr_schedule_row(
-					schedule_date,
-					depreciation_amount,
-					row.depreciation_method,
-				)
-
-	# to ensure that final accumulated depreciation amount is accurate
-	def get_adjusted_depreciation_amount(
-		self, depreciation_amount_without_pro_rata, depreciation_amount_for_last_row
-	):
-		if not self.opening_accumulated_depreciation:
-			depreciation_amount_for_first_row = self.get_depreciation_amount_for_first_row()
-
-			if (
-				depreciation_amount_for_first_row + depreciation_amount_for_last_row
-				!= depreciation_amount_without_pro_rata
-			):
-				depreciation_amount_for_last_row = (
-					depreciation_amount_without_pro_rata - depreciation_amount_for_first_row
-				)
-
-		return depreciation_amount_for_last_row
-
-	def get_depreciation_amount_for_first_row(self):
-		return self.get("depreciation_schedule")[0].depreciation_amount
-
-	def add_depr_schedule_row(
-		self,
-		schedule_date,
-		depreciation_amount,
-		depreciation_method,
-	):
-		self.append(
-			"depreciation_schedule",
-			{
-				"schedule_date": schedule_date,
-				"depreciation_amount": depreciation_amount,
-				"depreciation_method": depreciation_method,
-			},
-		)
-
-	def set_accumulated_depreciation(
-		self,
-		row,
-		date_of_disposal=None,
-		date_of_return=None,
-		ignore_booked_entry=False,
-	):
-		straight_line_idx = [
-			d.idx for d in self.get("depreciation_schedule") if d.depreciation_method == "Straight Line"
-		]
-
-		accumulated_depreciation = flt(self.opening_accumulated_depreciation)
-		value_after_depreciation = flt(row.value_after_depreciation)
-
-		for i, d in enumerate(self.get("depreciation_schedule")):
-			if ignore_booked_entry and d.journal_entry:
-				continue
-
-			depreciation_amount = flt(d.depreciation_amount, d.precision("depreciation_amount"))
-			value_after_depreciation -= flt(depreciation_amount)
-
-			# for the last row, if depreciation method = Straight Line
-			if (
-				straight_line_idx
-				and i == max(straight_line_idx) - 1
-				and not date_of_disposal
-				and not date_of_return
-			):
-				depreciation_amount += flt(
-					value_after_depreciation - flt(row.expected_value_after_useful_life),
-					d.precision("depreciation_amount"),
-				)
-
-			d.depreciation_amount = depreciation_amount
-			accumulated_depreciation += d.depreciation_amount
-			d.accumulated_depreciation_amount = flt(
-				accumulated_depreciation, d.precision("accumulated_depreciation_amount")
-			)
-
-
-def _get_value_after_depreciation_for_making_schedule(asset_doc, fb_row):
-	if asset_doc.docstatus == 1 and fb_row.value_after_depreciation:
-		value_after_depreciation = flt(fb_row.value_after_depreciation)
-	else:
-		value_after_depreciation = flt(asset_doc.gross_purchase_amount) - flt(
-			asset_doc.opening_accumulated_depreciation
-		)
-
-	return value_after_depreciation
-
-
-def make_draft_asset_depr_schedules_if_not_present(asset_doc):
-	for row in asset_doc.get("finance_books"):
-		draft_asset_depr_schedule_name = get_asset_depr_schedule_name(
-			asset_doc.name, "Draft", row.finance_book
-		)
-
-		active_asset_depr_schedule_name = get_asset_depr_schedule_name(
-			asset_doc.name, "Active", row.finance_book
-		)
-
-		if not draft_asset_depr_schedule_name and not active_asset_depr_schedule_name:
-			make_draft_asset_depr_schedule(asset_doc, row)
-
-
-def make_draft_asset_depr_schedules(asset_doc):
-	for row in asset_doc.get("finance_books"):
-		make_draft_asset_depr_schedule(asset_doc, row)
-
-
-def make_draft_asset_depr_schedule(asset_doc, row):
-	asset_depr_schedule_doc = frappe.new_doc("Asset Depreciation Schedule")
-
-	asset_depr_schedule_doc.prepare_draft_asset_depr_schedule_data(asset_doc, row)
-
-	asset_depr_schedule_doc.insert()
-
-
-def update_draft_asset_depr_schedules(asset_doc):
-	for row in asset_doc.get("finance_books"):
-		asset_depr_schedule_doc = get_asset_depr_schedule_doc(asset_doc.name, "Draft", row.finance_book)
-
-		if not asset_depr_schedule_doc:
-			continue
-
-		asset_depr_schedule_doc.prepare_draft_asset_depr_schedule_data(asset_doc, row)
-
-		asset_depr_schedule_doc.save()
-
-
-def convert_draft_asset_depr_schedules_into_active(asset_doc):
-	for row in asset_doc.get("finance_books"):
-		asset_depr_schedule_doc = get_asset_depr_schedule_doc(asset_doc.name, "Draft", row.finance_book)
-
-		if not asset_depr_schedule_doc:
-			continue
-
-		asset_depr_schedule_doc.submit()
-
-
-def cancel_asset_depr_schedules(asset_doc):
-	for row in asset_doc.get("finance_books"):
-		asset_depr_schedule_doc = get_asset_depr_schedule_doc(asset_doc.name, "Active", row.finance_book)
-
-		if not asset_depr_schedule_doc:
-			continue
-
-		asset_depr_schedule_doc.cancel()
-
-
-def make_new_active_asset_depr_schedules_and_cancel_current_ones(
-	asset_doc, notes, date_of_disposal=None, date_of_return=None
-):
-	for row in asset_doc.get("finance_books"):
-		current_asset_depr_schedule_doc = get_asset_depr_schedule_doc(
-			asset_doc.name, "Active", row.finance_book
-		)
-
-		if not current_asset_depr_schedule_doc:
-			frappe.throw(
-				_("Asset Depreciation Schedule not found for Asset {0} and Finance Book {1}").format(
-					asset_doc.name, row.finance_book
-				)
-			)
-
-		new_asset_depr_schedule_doc = frappe.copy_doc(current_asset_depr_schedule_doc)
-
-		new_asset_depr_schedule_doc.make_depr_schedule(asset_doc, row, date_of_disposal)
-		new_asset_depr_schedule_doc.set_accumulated_depreciation(row, date_of_disposal, date_of_return)
-
-		new_asset_depr_schedule_doc.notes = notes
-
-		current_asset_depr_schedule_doc.flags.should_not_cancel_depreciation_entries = True
-		current_asset_depr_schedule_doc.cancel()
-
-		new_asset_depr_schedule_doc.submit()
-
-
-def get_temp_asset_depr_schedule_doc(
-	asset_doc, row, date_of_disposal=None, date_of_return=None, update_asset_finance_book_row=False
-):
-	asset_depr_schedule_doc = frappe.new_doc("Asset Depreciation Schedule")
-
-	asset_depr_schedule_doc.prepare_draft_asset_depr_schedule_data(
-		asset_doc,
-		row,
-		date_of_disposal,
-		date_of_return,
-		update_asset_finance_book_row,
-	)
-
-	return asset_depr_schedule_doc
-
-
-@frappe.whitelist()
-def get_depr_schedule(asset_name, status, finance_book=None):
-	asset_depr_schedule_doc = get_asset_depr_schedule_doc(asset_name, status, finance_book)
-
-	if not asset_depr_schedule_doc:
-		return
-
-	return asset_depr_schedule_doc.get("depreciation_schedule")
-
-
-def get_asset_depr_schedule_doc(asset_name, status, finance_book=None):
-	asset_depr_schedule_name = get_asset_depr_schedule_name(asset_name, status, finance_book)
-
-	if not asset_depr_schedule_name:
-		return
-
-	asset_depr_schedule_doc = frappe.get_doc("Asset Depreciation Schedule", asset_depr_schedule_name)
-
-	return asset_depr_schedule_doc
-
-
-def get_asset_depr_schedule_name(asset_name, status, finance_book=None):
-	finance_book_filter = ["finance_book", "is", "not set"]
-	if finance_book:
-		finance_book_filter = ["finance_book", "=", finance_book]
-
-	return frappe.db.get_value(
-		doctype="Asset Depreciation Schedule",
-		filters=[
-			["asset", "=", asset_name],
-			finance_book_filter,
-			["status", "=", status],
-		],
-	)

erpnext/assets/doctype/asset_depreciation_schedule/test_asset_depreciation_schedule.py

@@ -1,27 +0,0 @@
-# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and Contributors
-# See license.txt
-
-import frappe
-from frappe.tests.utils import FrappeTestCase
-
-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_asset_depr_schedule_doc,
-)
-
-
-class TestAssetDepreciationSchedule(FrappeTestCase):
-	def setUp(self):
-		create_asset_data()
-
-	def test_throw_error_if_another_asset_depr_schedule_exist(self):
-		asset = create_asset(item_code="Macbook Pro", calculate_depreciation=1, submit=1)
-
-		first_asset_depr_schedule = get_asset_depr_schedule_doc(asset.name, "Active")
-		self.assertEquals(first_asset_depr_schedule.status, "Active")
-
-		second_asset_depr_schedule = frappe.get_doc(
-			{"doctype": "Asset Depreciation Schedule", "asset": asset.name, "finance_book": None}
-		)
-
-		self.assertRaises(frappe.ValidationError, second_asset_depr_schedule.insert)