Revert "fix: Updating SO throws ordered_qty not allowed to change after submission"

fix: asset value in fixed asset register

.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

@@ -24,15 +24,14 @@ fi
 
 
 if [ "$DB" == "mariadb" ];then
-    mysql --host 127.0.0.1 --port 3306 -u root -e "SET GLOBAL character_set_server = 'utf8mb4'"
-    mysql --host 127.0.0.1 --port 3306 -u root -e "SET GLOBAL collation_server = 'utf8mb4_unicode_ci'"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL character_set_server = 'utf8mb4'"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL collation_server = 'utf8mb4_unicode_ci'"
 
-    mysql --host 127.0.0.1 --port 3306 -u root -e "CREATE USER 'test_frappe'@'localhost' IDENTIFIED BY 'test_frappe'"
-    mysql --host 127.0.0.1 --port 3306 -u root -e "CREATE DATABASE test_frappe"
-    mysql --host 127.0.0.1 --port 3306 -u root -e "GRANT ALL PRIVILEGES ON \`test_frappe\`.* TO 'test_frappe'@'localhost'"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE USER 'test_frappe'@'localhost' IDENTIFIED BY 'test_frappe'"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE DATABASE test_frappe"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "GRANT ALL PRIVILEGES ON \`test_frappe\`.* TO 'test_frappe'@'localhost'"
 
-    mysql --host 127.0.0.1 --port 3306 -u root -e "UPDATE mysql.user SET Password=PASSWORD('travis') WHERE User='root'"
-    mysql --host 127.0.0.1 --port 3306 -u root -e "FLUSH PRIVILEGES"
+    mysql --host 127.0.0.1 --port 3306 -u root -proot -e "FLUSH PRIVILEGES"
 fi
 
 if [ "$DB" == "postgres" ];then
@@ -42,12 +41,17 @@ fi
 
 
 install_whktml() {
-    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
+    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
 }
 install_whktml &
+wkpid=$!
+
 
 cd ~/frappe-bench || exit
 
@@ -61,6 +65,8 @@ 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

@@ -9,7 +9,7 @@
  "mail_password": "test",
  "admin_password": "admin",
  "root_login": "root",
- "root_password": "travis",
+ "root_password": "root",
  "host_name": "http://test_site:8000",
  "install_apps": ["payments", "erpnext"],
  "throttle_user_limit": 100

.github/workflows/initiate_release.yml

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

.github/workflows/patch.yml

@@ -11,7 +11,7 @@ on:
   workflow_dispatch:
 
 concurrency:
-  group: patch-develop-${{ github.event.number }}
+  group: patch-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
   cancel-in-progress: true
 
 jobs:
@@ -25,7 +25,7 @@ jobs:
       mysql:
         image: mariadb:10.3
         env:
-          MYSQL_ALLOW_EMPTY_PASSWORD: YES
+          MARIADB_ROOT_PASSWORD: 'root'
         ports:
           - 3306:3306
         options: --health-cmd="mysqladmin ping" --health-interval=5s --health-timeout=2s --health-retries=3

.github/workflows/release.yml

@@ -2,7 +2,7 @@ name: Generate Semantic Release
 on:
   push:
     branches:
-      - version-14
+      - version-13
 jobs:
   release:
     name: Release
@@ -13,12 +13,10 @@ jobs:
         with:
           fetch-depth: 0
           persist-credentials: false
-
       - name: Setup Node.js
         uses: actions/setup-node@v2
         with:
           node-version: 18
-
       - name: Setup dependencies
         run: |
           npm install @semantic-release/git @semantic-release/exec --no-save

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

@@ -16,18 +16,18 @@ on:
   workflow_dispatch:
     inputs:
       user:
-        description: 'user'
+        description: 'Frappe Framework repository user (add your username for forks)'
         required: true
         default: 'frappe'
         type: string
       branch:
-        description: 'Branch name'
+        description: 'Frappe Framework branch'
         default: 'develop'
         required: false
         type: string
 
 concurrency:
-  group: server-mariadb-develop-${{ github.event.number }}
+  group: server-mariadb-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
   cancel-in-progress: true
 
 jobs:
@@ -39,15 +39,15 @@ jobs:
       fail-fast: false
 
       matrix:
-        container: [1, 2, 3]
+        container: [1, 2, 3, 4]
 
     name: Python Unit Tests
 
     services:
       mysql:
-        image: mariadb:10.3
+        image: mariadb:10.6
         env:
-          MYSQL_ALLOW_EMPTY_PASSWORD: YES
+          MARIADB_ROOT_PASSWORD: 'root'
         ports:
           - 3306:3306
         options: --health-cmd="mysqladmin ping" --health-interval=5s --health-timeout=2s --health-retries=3
@@ -59,7 +59,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v2
         with:
-          python-version: '3.10'
+          python-version: '3.11'
 
       - name: Check for valid Python & Merge Conflicts
         run: |
@@ -120,7 +120,32 @@ jobs:
           FRAPPE_BRANCH: ${{ github.event.inputs.branch }}
 
       - name: Run Tests
-        run: 'cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --app erpnext --total-builds 3 --build-number ${{ matrix.container }}'
+        run: 'cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --app erpnext --with-coverage --total-builds 4 --build-number ${{ matrix.container }}'
         env:
           TYPE: server
           CI_BUILD_ID: ${{ github.run_id }}
+          ORCHESTRATOR_URL: http://test-orchestrator.frappe.io
+
+      - name: Upload coverage data
+        uses: actions/upload-artifact@v3
+        with:
+          name: coverage-${{ matrix.container }}
+          path: /home/runner/frappe-bench/sites/coverage.xml
+
+  coverage:
+    name: Coverage Wrap Up
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone
+        uses: actions/checkout@v2
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v3
+
+      - name: Upload coverage data
+        uses: codecov/codecov-action@v2
+        with:
+          name: MariaDB
+          fail_ci_if_error: true
+          verbose: true

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

@@ -9,7 +9,7 @@ on:
     types: [opened, labelled, synchronize, reopened]
 
 concurrency:
-  group: server-postgres-develop-${{ github.event.number }}
+  group: server-postgres-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
   cancel-in-progress: true
 
 jobs:

.mergify.yml

@@ -9,6 +9,7 @@ pull_request_rules:
           - author!=nabinhait
           - author!=ankush
           - author!=deepeshgarg007
+          - author!=frappe-pr-bot
           - author!=mergify[bot]
 
         - or:

.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$"

.releaserc

@@ -1,5 +1,5 @@
 {
-	"branches": ["version-14"],
+	"branches": ["version-13"],
 	"plugins": [
 		"@semantic-release/commit-analyzer", {
 			"preset": "angular",
@@ -10,7 +10,7 @@
 		"@semantic-release/release-notes-generator",
 		[
 			"@semantic-release/exec", {
-				"prepareCmd": 'sed -ir -E "s/\"[0-9]+\.[0-9]+\.[0-9]+\"/\"${nextRelease.version}\"/" erpnext/__init__.py'
+				"prepareCmd": 'sed -ir "s/[0-9]*\.[0-9]*\.[0-9]*/${nextRelease.version}/" erpnext/__init__.py'
 			}
 		],
 		[
@@ -21,4 +21,4 @@
 		],
 		"@semantic-release/github"
 	]
-}
+}

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,10 +16,9 @@ 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/crm/                    @NagariaHussain
+erpnext/education/              @rutwikhdev
 erpnext/projects/               @ruchamahabal
 
 erpnext/controllers/            @deepeshgarg007 @nextchamp-saqib @rohitwaghchaure

erpnext/__init__.py

@@ -2,7 +2,7 @@ import inspect
 
 import frappe
 
-__version__ = "14.17.0"
+__version__ = "14.0.0-dev"
 
 
 def get_default_company(user=None):

erpnext/accounts/dashboard_chart_source/account_balance_timeline/account_balance_timeline.py

@@ -76,7 +76,7 @@ def get(
 
 def build_result(account, dates, gl_entries):
 	result = [[getdate(date), 0.0] for date in dates]
-	root_type = frappe.db.get_value("Account", account, "root_type")
+	root_type = frappe.get_cached_value("Account", account, "root_type")
 
 	# start with the first date
 	date_index = 0

erpnext/accounts/doctype/account/account.py

@@ -58,7 +58,7 @@ class Account(NestedSet):
 	def validate_parent(self):
 		"""Fetch Parent Details and validate parent account"""
 		if self.parent_account:
-			par = frappe.db.get_value(
+			par = frappe.get_cached_value(
 				"Account", self.parent_account, ["name", "is_group", "company"], as_dict=1
 			)
 			if not par:
@@ -82,7 +82,7 @@ class Account(NestedSet):
 
 	def set_root_and_report_type(self):
 		if self.parent_account:
-			par = frappe.db.get_value(
+			par = frappe.get_cached_value(
 				"Account", self.parent_account, ["report_type", "root_type"], as_dict=1
 			)
 
@@ -92,7 +92,7 @@ class Account(NestedSet):
 				self.root_type = par.root_type
 
 		if self.is_group:
-			db_value = frappe.db.get_value("Account", self.name, ["report_type", "root_type"], as_dict=1)
+			db_value = self.get_doc_before_save()
 			if db_value:
 				if self.report_type != db_value.report_type:
 					frappe.db.sql(
@@ -111,13 +111,13 @@ class Account(NestedSet):
 			)
 
 	def validate_root_details(self):
-		# does not exists parent
-		if frappe.db.exists("Account", self.name):
-			if not frappe.db.get_value("Account", self.name, "parent_account"):
-				throw(_("Root cannot be edited."), RootNotEditable)
+		doc_before_save = self.get_doc_before_save()
+
+		if doc_before_save and not doc_before_save.parent_account:
+			throw(_("Root cannot be edited."), RootNotEditable)
 
 		if not self.parent_account and not self.is_group:
-			frappe.throw(_("The root account {0} must be a group").format(frappe.bold(self.name)))
+			throw(_("The root account {0} must be a group").format(frappe.bold(self.name)))
 
 	def validate_root_company_and_sync_account_to_children(self):
 		# ignore validation while creating new compnay or while syncing to child companies
@@ -127,7 +127,9 @@ class Account(NestedSet):
 			return
 		ancestors = get_root_company(self.company)
 		if ancestors:
-			if frappe.get_value("Company", self.company, "allow_account_creation_against_child_company"):
+			if frappe.get_cached_value(
+				"Company", self.company, "allow_account_creation_against_child_company"
+			):
 				return
 			if not frappe.db.get_value(
 				"Account", {"account_name": self.account_name, "company": ancestors[0]}, "name"
@@ -138,7 +140,7 @@ class Account(NestedSet):
 			if not descendants:
 				return
 			parent_acc_name_map = {}
-			parent_acc_name, parent_acc_number = frappe.db.get_value(
+			parent_acc_name, parent_acc_number = frappe.get_cached_value(
 				"Account", self.parent_account, ["account_name", "account_number"]
 			)
 			filters = {
@@ -159,27 +161,28 @@ class Account(NestedSet):
 			self.create_account_for_child_company(parent_acc_name_map, descendants, parent_acc_name)
 
 	def validate_group_or_ledger(self):
-		if self.get("__islocal"):
+		doc_before_save = self.get_doc_before_save()
+		if not doc_before_save or cint(doc_before_save.is_group) == cint(self.is_group):
 			return
 
-		existing_is_group = frappe.db.get_value("Account", self.name, "is_group")
-		if cint(self.is_group) != cint(existing_is_group):
-			if self.check_gle_exists():
-				throw(_("Account with existing transaction cannot be converted to ledger"))
-			elif self.is_group:
-				if self.account_type and not self.flags.exclude_account_type_check:
-					throw(_("Cannot covert to Group because Account Type is selected."))
-			elif self.check_if_child_exists():
-				throw(_("Account with child nodes cannot be set as ledger"))
+		if self.check_gle_exists():
+			throw(_("Account with existing transaction cannot be converted to ledger"))
+		elif self.is_group:
+			if self.account_type and not self.flags.exclude_account_type_check:
+				throw(_("Cannot covert to Group because Account Type is selected."))
+		elif self.check_if_child_exists():
+			throw(_("Account with child nodes cannot be set as ledger"))
 
 	def validate_frozen_accounts_modifier(self):
-		old_value = frappe.db.get_value("Account", self.name, "freeze_account")
-		if old_value and old_value != self.freeze_account:
-			frozen_accounts_modifier = frappe.db.get_value(
-				"Accounts Settings", None, "frozen_accounts_modifier"
-			)
-			if not frozen_accounts_modifier or frozen_accounts_modifier not in frappe.get_roles():
-				throw(_("You are not authorized to set Frozen value"))
+		doc_before_save = self.get_doc_before_save()
+		if not doc_before_save or doc_before_save.freeze_account == self.freeze_account:
+			return
+
+		frozen_accounts_modifier = frappe.get_cached_value(
+			"Accounts Settings", "Accounts Settings", "frozen_accounts_modifier"
+		)
+		if not frozen_accounts_modifier or frozen_accounts_modifier not in frappe.get_roles():
+			throw(_("You are not authorized to set Frozen value"))
 
 	def validate_balance_must_be_debit_or_credit(self):
 		from erpnext.accounts.utils import get_balance_on
@@ -223,9 +226,9 @@ class Account(NestedSet):
 				)
 
 			# validate if parent of child company account to be added is a group
-			if frappe.db.get_value("Account", self.parent_account, "is_group") and not frappe.db.get_value(
-				"Account", parent_acc_name_map[company], "is_group"
-			):
+			if frappe.get_cached_value(
+				"Account", self.parent_account, "is_group"
+			) and not frappe.get_cached_value("Account", parent_acc_name_map[company], "is_group"):
 				msg = _(
 					"While creating account for Child Company {0}, parent account {1} found as a ledger account."
 				).format(company_bold, parent_acc_name_bold)
@@ -377,17 +380,15 @@ def validate_account_number(name, account_number, company):
 
 @frappe.whitelist()
 def update_account_number(name, account_name, account_number=None, from_descendant=False):
-	account = frappe.db.get_value("Account", name, "company", as_dict=True)
+	account = frappe.get_cached_doc("Account", name)
 	if not account:
 		return
 
-	old_acc_name, old_acc_number = frappe.db.get_value(
-		"Account", name, ["account_name", "account_number"]
-	)
+	old_acc_name, old_acc_number = account.account_name, account.account_number
 
 	# check if account exists in parent company
 	ancestors = get_ancestors_of("Company", account.company)
-	allow_independent_account_creation = frappe.get_value(
+	allow_independent_account_creation = frappe.get_cached_value(
 		"Company", account.company, "allow_account_creation_against_child_company"
 	)
 
@@ -435,22 +436,24 @@ def update_account_number(name, account_name, account_number=None, from_descenda
 @frappe.whitelist()
 def merge_account(old, new, is_group, root_type, company):
 	# Validate properties before merging
-	if not frappe.db.exists("Account", new):
+	new_account = frappe.get_cached_doc("Account", new)
+
+	if not new_account:
 		throw(_("Account {0} does not exist").format(new))
 
-	val = list(frappe.db.get_value("Account", new, ["is_group", "root_type", "company"]))
-
-	if val != [cint(is_group), root_type, company]:
+	if (new_account.is_group, new_account.root_type, new_account.company) != (
+		cint(is_group),
+		root_type,
+		company,
+	):
 		throw(
 			_(
 				"""Merging is only possible if following properties are same in both records. Is Group, Root Type, Company"""
 			)
 		)
 
-	if is_group and frappe.db.get_value("Account", new, "parent_account") == old:
-		frappe.db.set_value(
-			"Account", new, "parent_account", frappe.db.get_value("Account", old, "parent_account")
-		)
+	if is_group and new_account.parent_account == old:
+		new_account.db_set("parent_account", frappe.get_cached_value("Account", old, "parent_account"))
 
 	frappe.rename_doc("Account", old, new, merge=1, force=1)
 

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

@@ -53,7 +53,7 @@ def create_charts(
 							"account_number": account_number,
 							"account_type": child.get("account_type"),
 							"account_currency": child.get("account_currency")
-							or frappe.db.get_value("Company", company, "default_currency"),
+							or frappe.get_cached_value("Company", company, "default_currency"),
 							"tax_rate": child.get("tax_rate"),
 						}
 					)
@@ -148,7 +148,7 @@ def get_charts_for_country(country, with_standard=False):
 			) or frappe.local.flags.allow_unverified_charts:
 				charts.append(content["name"])
 
-	country_code = frappe.db.get_value("Country", country, "code")
+	country_code = frappe.get_cached_value("Country", country, "code")
 	if country_code:
 		folders = ("verified",)
 		if frappe.local.flags.allow_unverified_charts:

erpnext/accounts/doctype/account/chart_of_accounts/unverified/at_austria_chart_template.json

@@ -2,397 +2,438 @@
     "country_code": "at",
     "name": "Austria - Chart of Accounts",
     "tree": {
-        "Summe Abschreibungen und Aufwendungen": {
-            "7010 bis 7080 Abschreibungen auf das Anlageverm\u00f6gen (ausgenommen Finanzanlagen)": {},
-            "7100 bis 7190 Sonstige Steuern": {
-                "account_type": "Tax"
-            },
-            "7200 bis 7290 Instandhaltung u. Reinigung durh Dritte, Entsorgung, Beleuchtung": {},
-            "7300 bis 7310 Transporte durch Dritte": {},
-            "7320 bis 7330 Kfz - Aufwand": {},
-            "7340 bis 7350 Reise- und Fahraufwand": {},
-            "7360 bis 7370 Tag- und N\u00e4chtigungsgelder": {},
-            "7380 bis 7390 Nachrichtenaufwand": {},
-            "7400 bis 7430 Miet- und Pachtaufwand": {},
-            "7440 bis 7470 Leasingaufwand": {},
-            "7480 bis 7490 Lizenzaufwand": {},
-            "7500 bis 7530 Aufwand f\u00fcr beigestelltes Personal": {},
-            "7540 bis 7570 Provisionen an Dritte": {},
-            "7580 bis 7590 Aufsichtsratsverg\u00fctungen": {},
-            "7610 bis 7620 Druckerzeugnisse und Vervielf\u00e4ltigungen": {},
-            "7650 bis 7680 Werbung und Repr\u00e4sentationen": {},
-            "7700 bis 7740 Versicherungen": {},
-            "7750 bis 7760 Beratungs- und Pr\u00fcfungsaufwand": {},
-            "7800 bis 7810 Schadensf\u00e4lle": {},
-            "7840 bis 7880 Verschiedene betriebliche Aufwendungen": {},
-            "7910 bis 7950 Aufwandsstellenrechung der Hersteller": {},
-            "Abschreibungen auf aktivierte Aufwendungen f\u00fcr das Ingangs. u. Erweitern des Betriebes": {},
-            "Abschreibungen vom Umlaufverm\u00f6gen, soweit diese die im Unternehmen \u00fcblichen Abschreibungen \u00fcbersteigen": {},
-            "Aufwandsstellenrechnung": {},
-            "Aus- und Fortbildung": {},
-            "Buchwert abgegangener Anlagen, ausgenommen Finanzanlagen": {},
-            "B\u00fcromaterial und Drucksorten": {},
-            "Fachliteratur und Zeitungen ": {},
-            "Herstellungskosten der zur Erzielung der Umsatzerl\u00f6se erbrachten Leistungen": {},
-            "Mitgliedsbeitr\u00e4ge": {},
-            "Skontoertr\u00e4ge auf sonstige betriebliche Aufwendungen": {},
-            "Sonstige betrieblichen Aufwendungen": {},
-            "Spenden und Trinkgelder": {},
-            "Spesen des Geldverkehrs": {},
-            "Verluste aus dem Abgang vom Anlageverm\u00f6gen, ausgenommen Finanzanlagen": {},
-            "Vertriebskosten": {},
-            "Verwaltungskosten": {},
-            "root_type": "Expense"
-        },
-        "Summe Betriebliche Ertr\u00e4ge": {
-            "4400 bis 4490 Erl\u00f6sschm\u00e4lerungen": {},
-            "4500 bis 4570 Ver\u00e4nderungen des Bestandes an fertigen und unfertigen Erzeugn. sowie an noch nicht abrechenbaren Leistungen": {},
-            "4580 bis 4590 andere aktivierte Eigenleistungen": {},
-            "4600 bis 4620 Erl\u00f6se aus dem Abgang vom Anlageverm\u00f6gen, ausgen. Finanzanlagen": {},
-            "4630 bis 4650 Ertr\u00e4ge aus dem Abgang vom Anlageverm\u00f6gen, ausgen. Finanzanlagen": {},
-            "4660 bis 4670 Ertr\u00e4ge aus der Zuschreibung zum Anlageverm\u00f6gen, ausgen. Finanzanlagen": {},
-            "4700 bis 4790 Ertr\u00e4ge aus der Aufl\u00f6sung von R\u00fcckstellungen": {},
-            "4800 bis 4990 \u00dcbrige betriebliche Ertr\u00e4ge": {},
-            "Erl\u00f6se 0 % Ausfuhrlieferungen/Drittl\u00e4nder": {},
-            "Erl\u00f6se 10 %": {},
-            "Erl\u00f6se 20 %": {},
-            "Erl\u00f6se aus im Inland stpfl. EG Lieferungen 10 % USt": {},
-            "Erl\u00f6se aus im Inland stpfl. EG Lieferungen 20 % USt": {},
-            "Erl\u00f6se i.g. Lieferungen (stfr)": {},
-            "root_type": "Income"
-        },
-        "Summe Eigenkapital R\u00fccklagen Abschlusskonten": {
-            "9000 bis 9180 Gezeichnetes bzw. gewidmetes Kapital": {
-                "account_type": "Equity"
-            },
-            "9200 bis 9290 Kapitalr\u00fccklagen": {
-                "account_type": "Equity"
-            },
-            "9300 bis 9380 Gewinnr\u00fccklagen": {
-                "account_type": "Equity"
-            },
-            "9400 bis 9590 Bewertungsreserven uns sonst. unversteuerte R\u00fccklagen": {
-                "account_type": "Equity"
-            },
-            "9600 bis 9690 Privat und Verrechnungskonten bei Einzelunternehmen und Personengesellschaften": {},
-            "9700 bis 9790 Einlagen stiller Gesellschafter ": {},
-            "9900 bis 9999 Evidenzkonten": {},
-            "Bilanzgewinn (-verlust )": {
-                "account_type": "Equity"
-            },
-            "Er\u00f6ffnungsbilanz": {},
-            "Gewinn- und Verlustrechnung": {},
-            "Schlussbilanz": {},
-            "nicht eingeforderte ausstehende Einlagen": {
-                "account_type": "Equity"
-            },
-            "root_type": "Equity"
-        },
-        "Summe Finanzertr\u00e4ge und Aufwendungen": {
-            "8000 bis 8040 Ertr\u00e4ge aus Beteiligungen": {},
-            "8050 bis 8090 Ertr\u00e4ge aus anderen Wertpapieren und Ausleihungen des Finanzanlageverm\u00f6gens": {},
-            "8100 bis 8130 Sonstige Zinsen und \u00e4hnliche Ertr\u00e4ge": {},
-            "8220 bis 8250 Aufwendungen aus Beteiligungen": {},
-            "8260 bis 8270 Aufwendungen aus sonst. Fiananzanlagen und aus Wertpapieren des Umlaufverm\u00f6gens": {},
-            "8280 bis 8340 Zinsen und \u00e4hnliche Aufwendungem": {},
-            "8400 bis 8440 Au\u00dferordentliche Ertr\u00e4ge": {},
-            "8450 bis 8490 Au\u00dferordentliche Aufwendungen": {},
-            "8500 bis 8590 Steuern vom Einkommen und vom Ertrag": {
-                "account_type": "Tax"
-            },
-            "8600 bis 8690 Aufl\u00f6sung unversteuerten R\u00fccklagen": {},
-            "8700 bis 8740 Aufl\u00f6sung von Kapitalr\u00fccklagen": {},
-            "8750 bis 8790 Aufl\u00f6sung von Gewinnr\u00fccklagen": {},
-            "8800 bis 8890 Zuweisung von unversteuerten R\u00fccklagen": {},
-            "Buchwert abgegangener Beteiligungen": {},
-            "Buchwert abgegangener Wertpapiere des Umlaufverm\u00f6gens": {},
-            "Buchwert abgegangener sonstiger Finanzanlagen": {},
-            "Erl\u00f6se aus dem Abgang von Beteiligungen": {},
-            "Erl\u00f6se aus dem Abgang von Wertpapieren des Umlaufverm\u00f6gens": {},
-            "Erl\u00f6se aus dem Abgang von sonstigen Finanzanlagen": {},
-            "Ertr\u00e4ge aus dem Abgang von und der Zuschreibung zu Finanzanlagen": {},
-            "Ertr\u00e4ge aus dem Abgang von und der Zuschreibung zu Wertpapieren des Umlaufverm\u00f6gens": {},
-            "Gewinabfuhr bzw. Verlust\u00fcberrechnung aus Ergebnisabf\u00fchrungsvertr\u00e4gen": {},
-            "nicht ausgenutzte Lieferantenskonti": {},
-            "root_type": "Income"
-        },
-        "Summe Fremdkapital": {
-            "3020 bis 3030 Steuerr\u00fcckstellungen": {},
-            "3040 bis 3090 Sonstige R\u00fcckstellungen": {},
-            "3110 bis 3170 Verbindlichkeiten gegen\u00fcber Kredidinstituten": {},
-            "3180 bis 3190 Verbindlichkeiten gegen\u00fcber Finanzinstituten": {},
-            "3380 bis 3390 Verbindlichkeiten aus der Annahme gezogener Wechsel u. d. Ausstellungen eigener Wechsel": {
+        "Klasse 0 Aktiva: Anlageverm\u00f6gen": {
+				"0100 Konzessionen ": {"account_type": "Fixed Asset"},
+				"0110 Patentrechte und Lizenzen ": {"account_type": "Fixed Asset"},
+				"0120 Datenverarbeitungsprogramme ": {"account_type": "Fixed Asset"},
+				"0130 Marken, Warenzeichen und Musterschutzrechte, sonstige Urheberrechte ": {"account_type": "Fixed Asset"},
+				"0140 Pacht- und Mietrechte ": {"account_type": "Fixed Asset"},
+				"0150 Bezugs- und ähnliche Rechte ": {"account_type": "Fixed Asset"},
+				"0160 Geschäfts-/Firmenwert ": {"account_type": "Fixed Asset"},
+				"0170 Umgründungsmehrwert ": {"account_type": "Fixed Asset"},
+				"0180 Geleistete Anzahlungen auf immaterielle Vermögensgegenstände": {"account_type": "Fixed Asset"},
+				"0190 Kumulierte Abschreibungen zu immateriellen Vermögensgegenständen ": {"account_type": "Fixed Asset"},
+				"0200 Unbebaute Grundstücke, soweit nicht landwirtschaftlich genutzt ": {"account_type": "Fixed Asset"},
+				"0210 Bebaute Grundstücke (Grundwert) ": {"account_type": "Fixed Asset"},
+				"0220 Landwirtschaftlich genutzte Grundstücke ": {"account_type": "Fixed Asset"},
+				"0230 Grundstücksgleiche Rechte ": {"account_type": "Fixed Asset"},
+				"0300 Betriebs- und Geschäftsgebäude auf eigenem Grund ": {"account_type": "Fixed Asset"},
+				"0310 Wohn- und Sozialgebäude auf eigenem Grund ": {"account_type": "Fixed Asset"},
+				"0320 Betriebs- und Geschäftsgebäude auf fremdem Grund ": {"account_type": "Fixed Asset"},
+				"0330 Wohn- und Sozialgebäude auf fremdem Grund ": {"account_type": "Fixed Asset"},
+				"0340 Grundstückseinrichtungen auf eigenem Grund ": {"account_type": "Fixed Asset"},
+				"0350 Grundstückseinrichtungen auf fremdem Grund ": {"account_type": "Fixed Asset"},
+				"0360 Bauliche Investitionen in fremden (gepachteten) Betriebs- und Geschäftsgebäuden": {"account_type": "Fixed Asset"},
+				"0370 Bauliche Investitionen in fremden (gepachteten) Wohn- und Sozialgebäuden": {"account_type": "Fixed Asset"},
+				"0390 Kumulierte Abschreibungen zu Grundstücken ": {"account_type": "Fixed Asset"},
+				"0400 Maschinen und Geräte ": {"account_type": "Fixed Asset"},				
+				"0500 Maschinenwerkzeuge ": {"account_type": "Fixed Asset"},
+				"0510 Allgemeine Werkzeuge und Handwerkzeuge ": {"account_type": "Fixed Asset"},
+				"0520 Prototypen, Formen, Modelle ": {"account_type": "Fixed Asset"},
+				"0530 Andere Erzeugungshilfsmittel (auch Softwarewerkzeuge)": {"account_type": "Fixed Asset"},
+				"0540 Hebezeuge und Montageanlagen ": {"account_type": "Fixed Asset"},
+				"0550 Geringwertige Vermögensgegenstände, soweit im Erzeugungsprozess ": {"account_type": "Fixed Asset"},
+				"0560 Festwerte technische Anlagen und Maschinen ": {"account_type": "Fixed Asset"},
+				"0590 Kumulierte Abschreibungen zu technischen Anlagen und Maschinen ": {"account_type": "Fixed Asset"},
+				"0600 Betriebs- und Geschäftsausstattung, soweit nicht gesondert angeführt ": {"account_type": "Fixed Asset"},
+				"0610 Andere Anlagen, soweit nicht gesondert angeführt ": {"account_type": "Fixed Asset"},
+				"0620 Büromaschinen, EDV-Anlagen ": {"account_type": "Fixed Asset"},
+				"0630 PKW und Kombis ": {"account_type": "Fixed Asset"},
+				"0640 LKW ": {"account_type": "Fixed Asset"},
+				"0650 Andere Beförderungsmittel ": {"account_type": "Fixed Asset"},
+				"0660 Gebinde ": {"account_type": "Fixed Asset"},
+				"0670 Geringwertige Vermögensgegenstände, soweit nicht im Erzeugungssprozess verwendet": {"account_type": "Fixed Asset"},
+				"0680 Festwerte außer technische Anlagen und Maschinen ": {"account_type": "Fixed Asset"},
+				"0690 Kumulierte Abschreibungen zu anderen Anlagen, Betriebs- und Geschäftsausstattung": {"account_type": "Fixed Asset"},
+				"0700 Geleistete Anzahlungen auf Sachanlagen ": {"account_type": "Fixed Asset"},
+				"0710 Anlagen in Bau ": {"account_type": "Fixed Asset"},
+				"0790 Kumulierte Abschreibungen zu geleisteten Anzahlungen auf Sachanlagen ": {"account_type": "Fixed Asset"},
+				"0800 Anteile an verbundenen Unternehmen ": {"account_type": "Fixed Asset"},
+				"0810 Beteiligungen an Gemeinschaftsunternehmen ": {"account_type": "Fixed Asset"},
+				"0820 Beteiligungen an angeschlossenen (assoziierten) Unternehmen ": {"account_type": "Fixed Asset"},
+				"0830 Eigene Anteile, Anteile an herrschenden oder mit Mehrheit beteiligten ": {"account_type": "Fixed Asset"},
+				"0840 Sonstige Beteiligungen ": {"account_type": "Fixed Asset"},
+				"0850 Ausleihungen an verbundene Unternehmen ": {"account_type": "Fixed Asset"},
+				"0860 Ausleihungen an Unternehmen mit Beteiligungsverhältnis": {"account_type": "Fixed Asset"},
+				"0870 Ausleihungen an Gesellschafter ": {"account_type": "Fixed Asset"},
+				"0880 Sonstige Ausleihungen ": {"account_type": "Fixed Asset"},
+				"0890 Anteile an Kapitalgesellschaften ohne Beteiligungscharakter ": {"account_type": "Fixed Asset"},
+				"0900 Anteile an Personengesellschaften ohne Beteiligungscharakter ": {"account_type": "Fixed Asset"},
+				"0910 Genossenschaftsanteile ohne Beteiligungscharakter ": {"account_type": "Fixed Asset"},
+				"0920 Anteile an Investmentfonds ": {"account_type": "Fixed Asset"},
+				"0930 Festverzinsliche Wertpapiere des Anlagevermögens ": {"account_type": "Fixed Asset"},
+				"0980 Geleistete Anzahlungen auf Finanzanlagen ": {"account_type": "Fixed Asset"},
+				"0990 Kumulierte Abschreibungen zu Finanzanlagen ": {"account_type": "Fixed Asset"},
+            "root_type": "Asset"
+        },    
+        "Klasse 1 Aktiva: Vorr\u00e4te": {
+            "1000 Bezugsverrechnung": {"account_type": "Stock"},
+            "1100 Rohstoffe": {"account_type": "Stock"},
+            "1200 Bezogene Teile": {"account_type": "Stock"},
+            "1300 Hilfsstoffe": {"account_type": "Stock"},
+            "1350 Betriebsstoffe": {"account_type": "Stock"},
+            "1360 Vorrat Energietraeger": {"account_type": "Stock"},            
+            "1400 Unfertige Erzeugnisse": {"account_type": "Stock"},
+            "1500 Fertige Erzeugnisse": {"account_type": "Stock"},
+            "1600 Handelswarenvorrat": {"account_type": "Stock Received But Not Billed"},
+            "1700 Noch nicht abrechenbare Leistungen": {"account_type": "Stock"},
+            "1900 Wertberichtigungen": {"account_type": "Stock"},
+            "1800 Geleistete Anzahlungen": {"account_type": "Stock"},
+            "1900 Wertberichtigungen": {"account_type": "Stock"},
+            "root_type": "Asset"
+        },    
+        "Klasse 3 Passiva: Verbindlichkeiten": {
+            "3000 Allgemeine Verbindlichkeiten (Schuld)": {"account_type": "Payable"},
+            "3010 R\u00fcckstellungen f\u00fcr Pensionen": {"account_type": "Payable"},
+            "3020 Steuerr\u00fcckstellungen": {"account_type": "Tax"},
+            "3041 Sonstige R\u00fcckstellungen": {"account_type": "Payable"},            
+            "3110 Verbindlichkeiten gegen\u00fcber Bank": {"account_type": "Payable"},
+            "3150 Verbindlichkeiten Darlehen": {"account_type": "Payable"},
+            "3185 Verbindlichkeiten Kreditkarte": {"account_type": "Payable"},            
+            "3380 Verbindlichkeiten aus der Annahme gezogener Wechsel u. d. Ausstellungen eigener Wechsel": {
                 "account_type": "Payable"
             },
-            "3400 bis 3470 Verbindlichkeiten gegen\u00fc. verb. Untern., Verbindl. gegen\u00fc. Untern., mit denen eine Beteiligungsverh\u00e4lnis besteht": {},
-            "3600 bis 3690 Verbindlichkeiten im Rahmen der sozialen Sicherheit": {},
-            "3700 bis 3890 \u00dcbrige sonstige Verbindlichkeiten": {},
-            "3900 bis 3990 Passive Rechnungsabgrenzungsposten": {},
-            "Anleihen (einschlie\u00dflich konvertibler)": {},
-            "Erhaltene Anzahlungenauf Bestellungen": {},
-            "R\u00fcckstellungen f\u00fcr Abfertigung": {},
-            "R\u00fcckstellungen f\u00fcr Pensionen": {},
-            "USt. \u00a719 /art (reverse charge)": {
+            "3400 Verbindlichkeiten gegen\u00fc. verb. Untern., Verbindl. gegen\u00fc. Untern., mit denen eine Beteiligungsverh\u00e4lnis besteht": {},
+            "3460 Verbindlichkeiten gegenueber Gesellschaftern": {"account_type": "Payable"},
+            "3470 Einlagen stiller Gesellschafter": {"account_type": "Payable"},
+            "3585 Verbindlichkeiten Lohnsteuer": {"account_type": "Tax"},             
+            "3590 Verbindlichkeiten Kommunalabgaben": {"account_type": "Tax"},  
+            "3595 Verbindlichkeiten Dienstgeberbeitrag": {"account_type": "Tax"},                       
+            "3600 Verbindlichkeiten Sozialversicherung": {"account_type": "Payable"},
+            "3640 Verbindlichkeiten Loehne und Gehaelter": {"account_type": "Payable"},            
+            "3700 Sonstige Verbindlichkeiten": {"account_type": "Payable"},
+            "3900 Passive Rechnungsabgrenzungsposten": {"account_type": "Payable"},
+            "3100 Anleihen (einschlie\u00dflich konvertibler)": {"account_type": "Payable"},
+            "3200 Erhaltene Anzahlungen auf Bestellungen": {"account_type": "Payable"},
+            "3040 R\u00fcckstellungen f\u00fcr Abfertigung": {"account_type": "Payable"},
+
+            "3530 USt. \u00a719 (reverse charge)": {
                 "account_type": "Tax"
             },
-            "Umsatzsteuer": {},
-            "Umsatzsteuer Zahllast": {
+            "3500 Verbindlichkeiten aus Umsatzsteuer": {"account_type": "Tax"},
+            "3580 Umsatzsteuer Zahllast": {
                 "account_type": "Tax"
             },
-            "Umsatzsteuer aus i.g. Erwerb 10%": {
+            "3510 Umsatzsteuer Inland 20%": {
                 "account_type": "Tax"
             },
-            "Umsatzsteuer aus i.g. Erwerb 20%": {
+            "3515 Umsatzsteuer Inland 10%": {
+                "account_type": "Tax"
+            },            
+            "3520 Umsatzsteuer aus i.g. Erwerb 20%": {
                 "account_type": "Tax"
             },
-            "Umsatzsteuer aus i.g. Lieferungen 10%": {
+            "3525 Umsatzsteuer aus i.g. Erwerb 10%": {
                 "account_type": "Tax"
-            },
-            "Umsatzsteuer aus i.g. Lieferungen 20%": {
-                "account_type": "Tax"
-            },
-            "Umsatzsteuer-Evidenzkonto f\u00fcr erhaltene Anzahlungen auf Bestellungen": {},
-            "Verbindlichkeiten aus Lieferungen u. Leistungen EU": {
+            },            
+            "3560 Umsatzsteuer-Evidenzkonto f\u00fcr erhaltene Anzahlungen auf Bestellungen": {},
+            "3360 Verbindlichkeiten aus Lieferungen u. Leistungen EU": {
                 "account_type": "Payable"
             },
-            "Verbindlichkeiten aus Lieferungen u. Leistungen Inland": {
+            "3000 Verbindlichkeiten aus Lieferungen u. Leistungen Inland": {
                 "account_type": "Payable"
             },
-            "Verbindlichkeiten aus Lieferungen u. Leistungen sonst. Ausland": {
+            "3370 Verbindlichkeiten aus Lieferungen u. Leistungen sonst. Ausland": {
                 "account_type": "Payable"
             },
-            "Verbindlichkeiten gegen\u00fcber Gesellschaften": {},
-            "Verrechnung Finanzamt": {
+            "3400 Verbindlichkeiten gegen\u00fcber verbundenen Unternehmen": {},
+            "3570 Verrechnung Finanzamt": {
                 "account_type": "Tax"
             },
             "root_type": "Liability"
-        },
-        "Summe Kontoklasse 0 Anlageverm\u00f6gen": {
-            "44 bis 49 Sonstige Maschinen und maschinelle Anlagen": {},
-            "920 bis 930 Festverzinsliche Wertpapiere des Anlageverm\u00f6gens": {},
-            "940 bis 970 Sonstige Finanzanlagen, Wertrechte": {},
-            "Allgemeine Werkzeuge und Handwerkzeuge": {},
-            "Andere Bef\u00f6rderungsmittel": {},
-            "Andere Betriebs- und Gesch\u00e4ftsausstattung": {},
-            "Andere Erzeugungshilfsmittel": {},
-            "Anlagen im Bau": {},
-            "Anteile an Investmentfonds": {},
-            "Anteile an Kapitalgesellschaften ohne Beteiligungscharakter": {},
-            "Anteile an Personengesellschaften ohne Beteiligungscharakter": {},
-            "Anteile an verbundenen Unternehmen": {},
-            "Antriebsmaschinen": {},
-            "Aufwendungen f\u00fcs das Ingangssetzen u. Erweitern eines Betriebes": {},
-            "Ausleihungen an  verbundene Unternehmen": {},
-            "Ausleihungen an  verbundene Unternehmen, mit denen ein Beteiligungsverh\u00e4lnis besteht": {},
-            "Bauliche Investitionen in fremden (gepachteten) Betriebs- und Gesch\u00e4ftsgeb\u00e4uden": {},
-            "Bauliche Investitionen in fremden (gepachteten) Wohn- und Sozialgeb\u00e4uden": {},
-            "Bebaute Grundst\u00fccke (Grundwert)": {},
-            "Beheizungs- und Beleuchtungsanlagen": {},
-            "Beteiligungen an Gemeinschaftunternehmen": {},
-            "Beteiligungen an angeschlossenen (assoziierten) Unternehmen": {},
-            "Betriebs- und Gesch\u00e4ftsgeb\u00e4ude auf eigenem Grund": {},
-            "Betriebs- und Gesch\u00e4ftsgeb\u00e4ude auf fremdem Grund": {},
-            "B\u00fcromaschinen, EDV - Anlagen": {},
-            "Datenverarbeitungsprogramme": {},
-            "Energieversorgungsanlagen": {},
-            "Fertigungsmaschinen": {},
-            "Gebinde": {},
-            "Geleistete Anzahlungen": {},
-            "Genossenschaften ohne Beteiligungscharakter": {},
-            "Geringwertige Verm\u00f6gensgegenst\u00e4nde, soweit im Erzeugerprozess verwendet": {},
-            "Geringwertige Verm\u00f6gensgegenst\u00e4nde, soweit nicht im Erzeugungsprozess verwendet": {},
-            "Gesch\u00e4fts(Firmen)wert": {},
-            "Grundst\u00fcckseinrichtunten auf eigenem Grund": {},
-            "Grundst\u00fcckseinrichtunten auf fremdem Grund": {},
-            "Grundst\u00fccksgleiche Rechte": {},
-            "Hebezeuge und Montageanlagen": {},
-            "Konzessionen": {},
-            "Kumulierte Abschreibungen": {},
-            "LKW": {},
-            "Marken, Warenzeichen und Musterschutzrechte": {},
-            "Maschinenwerkzeuge": {},
-            "Nachrichten- und Kontrollanlagen": {},
-            "PKW": {},
-            "Pacht- und Mietrechte": {},
-            "Patentrechte und Lizenzen": {},
-            "Sonstige Ausleihungen": {},
-            "Sonstige Beteiligungen": {},
-            "Transportanlagen": {},
-            "Unbebaute Grundst\u00fccke": {},
-            "Vorrichtungen, Formen und Modelle": {},
-            "Wohn- und Sozialgeb\u00e4ude auf eigenem Grund": {},
-            "Wohn- und Sozialgeb\u00e4ude auf fremdem Grund": {},
+        },      
+        "Klasse 2 Aktiva: Umlaufverm\u00f6gen, Rechnungsabgrenzungen": {
+            "2030 Forderungen aus Lieferungen und Leistungen Inland (0% USt, umsatzsteuerfrei)": {
+                "account_type": "Receivable"
+            },
+            "2010 Forderungen aus Lieferungen und Leistungen Inland (10% USt, umsatzsteuerfrei)": {
+                "account_type": "Receivable"
+            },
+            "2000 Forderungen aus Lieferungen und Leistungen Inland (20% USt, umsatzsteuerfrei)": {
+                "account_type": "Receivable"
+            },
+            "2040 Forderungen aus Lieferungen und Leistungen Inland (sonstiger USt-Satz)": {
+                "account_type": "Receivable"
+            },                                    
+            "2100 Forderungen aus Lieferungen und Leistungen EU": {
+                "account_type": "Receivable"
+            },
+            "2150 Forderungen aus Lieferungen und Leistungen Ausland (Nicht-EU)": {
+                "account_type": "Receivable"
+            },
+            "2200 Forderungen gegen\u00fcber verbundenen Unternehmen": {
+                "account_type": "Receivable"
+            },
+            "2250 Forderungen gegen\u00fcber Unternehmen, mit denen ein Beteiligungsverh\u00e4ltnis besteht": {
+                "account_type": "Receivable"
+            },
+            "2300 Sonstige Forderungen und Verm\u00f6gensgegenst\u00e4nde": {
+                "account_type": "Receivable"
+            },
+            "2630 Sonstige Wertpapiere": {
+                "account_type": "Stock"
+            },
+            "2750 Kassenbest\u00e4nde in Fremdw\u00e4hrung": {
+                "account_type": "Cash"
+            },
+            "2900 Aktive Rechnungsabrenzungsposten": {
+                "account_type": "Receivable"
+            },
+            "2600 Anteile an verbundenen Unternehmen": {
+                "account_type": "Equity"
+            },
+            "2680 Besitzwechsel ohne Forderungen": {
+                "account_type": "Receivable"
+            },
+            "2950 Aktiviertes Disagio": {
+                "account_type": "Receivable"
+            },
+            "2610 Eigene Anteile und Wertpapiere an mit Mehrheit beteiligten Unternehmen": {
+                "account_type": "Receivable"
+            },
+            "2570 Einfuhrumsatzsteuer (bezahlt)": {"account_type": "Tax"},
+            
+            "2460 Eingeforderte aber noch nicht eingezahlte Einlagen": {
+                "account_type": "Receivable"
+            },
+            "2180 Einzelwertberichtigungen zu Forderungen aus Lief. und Leist. Ausland": {
+                "account_type": "Receivable"
+            },
+            "2130 Einzelwertberichtigungen zu Forderungen aus Lief. und Leist. EU": {
+                "account_type": "Receivable"
+            },
+            "2080 Einzelwertberichtigungen zu Forderungen aus Lief. und Leist. Inland ": {
+                "account_type": "Receivable"
+            },
+            "2270 Einzelwertberichtigungen zu Forderungen gegen\u00fcber Unternehmen mit denen ein Beteiligungsverh\u00e4ltnis besteht": {
+                "account_type": "Receivable"
+            },
+            "2230 Einzelwertberichtigungen zu Forderungen gegen\u00fcber verbundenen Unternehmen": {
+                "account_type": "Receivable"
+            },
+            "2470 Einzelwertberichtigungen zu sonstigen Forderungen und Verm\u00f6gensgegenst\u00e4nden": {
+                "account_type": "Receivable"
+            },
+            "2700 Kassenbestand": {
+                "account_type": "Cash"
+            },
+            "2190 Pauschalwertberichtigungen zu Forderungen aus Lief. und Leist. sonstiges Ausland": {
+                "account_type": "Receivable"
+            },
+            "2130 Pauschalwertberichtigungen zu Forderungen aus Lief. und Leist. EU": {
+                "account_type": "Receivable"
+            },
+            "2100 Pauschalwertberichtigungen zu Forderungen aus Lief. und Leist. Inland ": {
+                "account_type": "Receivable"
+            },
+            "2280 Pauschalwertberichtigungen zu Forderungen gegen\u00fcber Unternehmen mit denen ein Beteiligungsverh\u00e4ltnis besteht": {
+                "account_type": "Receivable"
+            },
+            "2240 Pauschalwertberichtigungen zu Forderungen gegen\u00fcber verbundenen Unternehmen": {
+                "account_type": "Receivable"
+            },
+            "2480 Pauschalwertberichtigungen zu sonstigen Forderungen und Verm\u00f6gensgegenst\u00e4nden": {
+                "account_type": "Receivable"
+            },
+            "2740 Postwertzeichen": {
+                "account_type": "Cash"
+            },
+            "2780 Schecks in Euro": {
+                "account_type": "Cash"
+            },
+            "2800 Guthaben bei Bank": {
+                "account_type": "Bank"
+            },  
+            "2801 Guthaben bei Bank - Sparkonto": {
+                "account_type": "Bank"
+            },                      
+            "2810 Guthaben bei Paypal": {
+                "account_type": "Bank"
+            },
+            "2930 Mietvorauszahlungen": {
+                "account_type": "Receivable"
+            },
+            "2980 Abgrenzung latenter Steuern": {
+                "account_type": "Receivable"
+            },
+            "2500 Vorsteuer": {
+                "account_type": "Receivable"
+            },
+            "2510 Vorsteuer Inland 10%": {
+                "account_type": "Tax"
+            },
+            "2895 Schwebende Geldbewegugen": {
+                "account_type": "Bank"
+            },            
+            "2513 Vorsteuer Inland 5%": {
+                "account_type": "Tax"
+            },
+            "2515 Vorsteuer Inland 20%": {
+                "account_type": "Tax"
+            },                        
+            "2520 Vorsteuer aus innergemeinschaftlichem Erwerb 10%": {
+                "account_type": "Tax"
+            },
+            "2525 Vorsteuer aus innergemeinschaftlichem Erwerb 20%": {
+                "account_type": "Tax"
+            },            
+            "2530 Vorsteuer \u00a719/Art 19 ( reverse charge ) ": {
+                "account_type": "Tax"
+            },
+            "2690 Wertberichtigungen zu Wertpapieren und Anteilen": {
+                "account_type": "Receivable"
+            },
             "root_type": "Asset"
         },
-        "Summe Personalaufwand": {
-            "6000 bis 6190 L\u00f6hne": {},
-            "6200 bis 6390 Geh\u00e4lter": {},
-            "6400 bis 6440 Aufwendungen f\u00fcr Abfertigungen": {},
-            "6450 bis 6490 Aufwendungen f\u00fcr Altersversorgung": {},
-            "6500 bis 6550 Gesetzlicher Sozialaufwand Arbeiter": {},
-            "6560 bis 6590 Gesetzlicher Sozialaufwand Angestellte": {},
-            "6600 bis 6650 Lohnabh\u00e4ngige Abgaben und Pflichtbeitr\u00e4gte": {},
-            "6660 bis 6690 Gehaltsabh\u00e4ngige Abgaben und Pflichtbeitr\u00e4gte": {},
-            "6700 bis 6890 Sonstige Sozialaufwendungen": {},
-            "Aufwandsstellenrechnung": {},
+          "Klasse 4: Betriebliche Erträge": {
+            "4000 Erlöse 20 %": {"account_type": "Income Account"},          
+            "4020 Erl\u00f6se 0 % steuerbefreit": {"account_type": "Income Account"},            
+            "4010 Erl\u00f6se 10 %": {"account_type": "Income Account"},
+            "4030 Erl\u00f6se 13 %": {"account_type": "Income Account"},            
+            "4040 Erl\u00f6se 0 % innergemeinschaftliche Lieferungen": {"account_type": "Income Account"},      
+            "4400 Erl\u00f6sreduktion 0 % steuerbefreit": {"account_type": "Expense Account"},            
+            "4410 Erl\u00f6sreduktion 10 %": {"account_type": "Expense Account"},
+            "4420 Erl\u00f6sreduktion 20 %": {"account_type": "Expense Account"},
+            "4430 Erl\u00f6sreduktion 13 %": {"account_type": "Expense Account"},            
+            "4440 Erl\u00f6sreduktion 0 % innergemeinschaftliche Lieferungen": {"account_type": "Expense Account"}, 
+            "4500 Ver\u00e4nderungen des Bestandes an fertigen und unfertigen Erzeugn. sowie an noch nicht abrechenbaren Leistungen": {"account_type": "Income Account"},
+            "4580 Aktivierte Eigenleistungen": {"account_type": "Income Account"},
+            "4600 Erl\u00f6se aus dem Abgang vom Anlageverm\u00f6gen, ausgen. Finanzanlagen": {"account_type": "Income Account"},
+            "4630 Ertr\u00e4ge aus dem Abgang vom Anlageverm\u00f6gen, ausgen. Finanzanlagen": {"account_type": "Income Account"},
+            "4660 Ertr\u00e4ge aus der Zuschreibung zum Anlageverm\u00f6gen, ausgen. Finanzanlagen": {"account_type": "Income Account"},
+            "4700 Ertr\u00e4ge aus der Aufl\u00f6sung von R\u00fcckstellungen": {"account_type": "Income Account"},
+            "4800 \u00dcbrige betriebliche Ertr\u00e4ge": {"account_type": "Income Account"},
+            "root_type": "Income"
+        },        
+        "Klasse 5: Aufwand f\u00fcr Material und Leistungen": {
+            "5000 Einkauf Partnerleistungen": {"account_type": "Cost of Goods Sold"},        
+            "5100 Verbrauch an Rohstoffen": {"account_type": "Cost of Goods Sold"},
+            "5200 Verbrauch von bezogenen Fertig- und Einzelteilen": {"account_type": "Cost of Goods Sold"},
+            "5300 Verbrauch von Hilfsstoffen": {"account_type": "Cost of Goods Sold"},
+            "5340 Verbrauch Verpackungsmaterial": {"account_type": "Cost of Goods Sold"},
+            "5470 Verbrauch von Kleinmaterial": {"account_type": "Cost of Goods Sold"},
+            "5450 Verbrauch von Reinigungsmaterial": {"account_type": "Cost of Goods Sold"},                                  
+            "5400 Verbrauch von Betriebsstoffen": {"account_type": "Cost of Goods Sold"},
+            "5500 Verbrauch von Werkzeugen und anderen Erzeugungshilfsmittel": {"account_type": "Cost of Goods Sold"},
+            "5600 Verbrauch von Brenn- und Treibstoffen, Energie und Wasser": {"account_type": "Cost of Goods Sold"},
+            "5700 Bearbeitung durch Dritte": {"account_type": "Cost of Goods Sold"},
+            "5900 Aufwandsstellenrechnung Material": {"account_type": "Cost of Goods Sold"},
+            "5820 Skontoertr\u00e4ge (20% USt.)": {"account_type": "Income Account"},
+            "5810 Skontoertr\u00e4ge (10% USt.)": {"account_type": "Income Account"},
+            "5010 Handelswareneinkauf 10 %": {"account_type": "Cost of Goods Sold"},
+            "5020 Handelswareneinkauf 20 %": {"account_type": "Cost of Goods Sold"},
+            "5040 Handelswareneinkauf innergemeinschaftlicher Erwerb 10 % VSt/10 % USt": {"account_type": "Cost of Goods Sold"},
+            "5050 Handelswareneinkauf innergemeinschaftlicher Erwerb 20 % VSt/20 % USt": {"account_type": "Cost of Goods Sold"},
+            "5070 Handelswareneinkauf innergemeinschaftlicher Erwerb ohne Vorsteuerabzug und 10 % USt": {"account_type": "Cost of Goods Sold"},
+            "5080 Handelswareneinkauf innergemeinschaftlicher Erwerb ohne Vorsteuerabzug und 20 % USt": {"account_type": "Cost of Goods Sold"},
             "root_type": "Expense"
         },
-        "Summe Umlaufverm\u00f6gen": {
-            "2000 bis 2007 Forderungen aus Lief. und Leist. Inland": {
-                "account_type": "Receivable"
-            },
-            "2100 bis 2120 Forderungen aus Lief. und Leist. EU": {
-                "account_type": "Receivable"
-            },
-            "2150 bis 2170 Forderungen aus Lief. und Leist. Ausland": {
-                "account_type": "Receivable"
-            },
-            "2200 bis 2220 Forderungen gegen\u00fcber verbundenen Unternehmen": {
-                "account_type": "Receivable"
-            },
-            "2250 bis 2270 Forderungen gegen\u00fcber Unternehmen, mit denen ein Beteiligungsverh\u00e4ltnis besteht": {
-                "account_type": "Receivable"
-            },
-            "2300 bis 2460 Sonstige Forderungen und Verm\u00f6gensgegenst\u00e4nde": {
-                "account_type": "Receivable"
-            },
-            "2630 bis 2670 Sonstige Wertpapiere": {
-                "account_type": "Receivable"
-            },
-            "2750 bis 2770 Kassenbest\u00e4nde in Fremdw\u00e4hrung": {
-                "account_type": "Receivable"
-            },
-            "Aktive Rechnungsabrenzungsposten": {
-                "account_type": "Receivable"
-            },
-            "Anteile an verbundenen Unternehmen": {
-                "account_type": "Receivable"
-            },
-            "Bank / Guthaben bei Kreditinstituten": {
-                "account_type": "Receivable"
-            },
-            "Besitzwechsel ...": {
-                "account_type": "Receivable"
-            },
-            "Disagio": {
-                "account_type": "Receivable"
-            },
-            "Eigene Anteile (Wertpapiere)": {
-                "account_type": "Receivable"
-            },
-            "Einfuhrumsatzsteuer (bezahlt)": {},
-            "Eingeforderte aber noch nicht eingezahlte Einlagen": {
-                "account_type": "Receivable"
-            },
-            "Einzelwertberichtigungen zu Forderungen aus Lief. und Leist. Ausland": {
-                "account_type": "Receivable"
-            },
-            "Einzelwertberichtigungen zu Forderungen aus Lief. und Leist. EU": {
-                "account_type": "Receivable"
-            },
-            "Einzelwertberichtigungen zu Forderungen aus Lief. und Leist. Inland ": {
-                "account_type": "Receivable"
-            },
-            "Einzelwertberichtigungen zu Forderungen gegen\u00fcber Unternehmen mit denen ein Beteiligungsverh\u00e4ltnis besteht": {
-                "account_type": "Receivable"
-            },
-            "Einzelwertberichtigungen zu Forderungen gegen\u00fcber verbundenen Unternehmen": {
-                "account_type": "Receivable"
-            },
-            "Einzelwertberichtigungen zu sonstigen Forderungen und Verm\u00f6gensgegenst\u00e4nden": {
-                "account_type": "Receivable"
-            },
-            "Kassenbestand": {
-                "account_type": "Receivable"
-            },
-            "Pauschalwertberichtigungen zu Forderungen aus Lief. und Leist. Ausland": {
-                "account_type": "Receivable"
-            },
-            "Pauschalwertberichtigungen zu Forderungen aus Lief. und Leist. EU": {
-                "account_type": "Receivable"
-            },
-            "Pauschalwertberichtigungen zu Forderungen aus Lief. und Leist. Inland ": {
-                "account_type": "Receivable"
-            },
-            "Pauschalwertberichtigungen zu Forderungen gegen\u00fcber Unternehmen mit denen ein Beteiligungsverh\u00e4ltnis besteht": {
-                "account_type": "Receivable"
-            },
-            "Pauschalwertberichtigungen zu Forderungen gegen\u00fcber verbundenen Unternehmen": {
-                "account_type": "Receivable"
-            },
-            "Pauschalwertberichtigungen zu sonstigen Forderungen und Verm\u00f6gensgegenst\u00e4nden": {
-                "account_type": "Receivable"
-            },
-            "Postwertzeichen": {
-                "account_type": "Receivable"
-            },
-            "Schecks in Inlandsw\u00e4hrung": {
-                "account_type": "Receivable"
-            },
-            "Sonstige Anteile": {
-                "account_type": "Receivable"
-            },
-            "Stempelmarken": {
-                "account_type": "Receivable"
-            },
-            "Steuerabgrenzung": {
-                "account_type": "Receivable"
-            },
-            "Unterschiedsbetrag gem. Abschnitt XII Pensionskassengesetz": {
-                "account_type": "Receivable"
-            },
-            "Unterschiedsbetrag zur gebotenen Pensionsr\u00fcckstellung": {
-                "account_type": "Receivable"
-            },
-            "Vorsteuer": {
-                "account_type": "Receivable"
-            },
-            "Vorsteuer aus ig. Erwerb 10%": {
-                "account_type": "Tax"
-            },
-            "Vorsteuer aus ig. Erwerb 20%": {
-                "account_type": "Tax"
-            },
-            "Vorsteuer \u00a719/Art 19 ( reverse charge ) ": {
-                "account_type": "Tax"
-            },
-            "Wertberichtigungen": {
-                "account_type": "Receivable"
-            },
-            "root_type": "Asset"
-        },
-        "Summe Vorr\u00e4te": {
-            "1000 bis 1090 Bezugsverrechnung": {},
-            "1100 bis 1190 Rohstoffe": {},
-            "1200 bis 1290 Bezogene Teile": {},
-            "1300 bis 1340 Hilfsstoffe": {},
-            "1350 bis 1390 Betriebsstoffe": {},
-            "1400 bis 1490 Unfertige Erzeugniss": {},
-            "1500 bis 1590 Fertige Erzeugniss": {},
-            "1600 bis 1690 Waren": {},
-            "1700 bis 1790 Noch nicht abgerechenbare Leistungen": {},
-            "1900 bis 1990 Wertberichtigungen": {},
-            "geleistete Anzahlungen": {},
-            "root_type": "Asset"
-        },
-        "Summe Wareneinsatz": {
-            "5100 bis 5190 Verbrauch an Rohstoffen": {},
-            "5200 bis 5290 Verbrauch von bezogenen Fertig- und Einzelteilen": {},
-            "5300 bis 5390 Verbrauch von Hilfsstoffen": {},
-            "5400 bis 5490 Verbrauch von Betriebsstoffen": {},
-            "5500 bis 5590 Verbrauch von Werkzeugen und anderen Erzeugungshilfsmittel": {},
-            "5600 bis 5690 Verbrauch von Brenn- und Treibstoffen, Energie und Wasser": {},
-            "5700 bis 5790 Sonstige bezogene Herstellungsleistungen": {},
-            "Aufwandsstellenrechnung": {},
-            "Skontoertr\u00e4ge auf Materialaufwand": {},
-            "Skontoertr\u00e4ge auf sonstige bezogene Herstellungsleistungen": {},
-            "Wareneinkauf 10 %": {},
-            "Wareneinkauf 20 %": {},
-            "Wareneinkauf igErwerb 10 % VSt/10 % USt": {},
-            "Wareneinkauf igErwerb 20 % VSt/20 % USt": {},
-            "Wareneinkauf igErwerb ohne Vorsteuerabzug und 10 % USt": {},
-            "Wareneinkauf igErwerb ohne Vorsteuerabzug und 20 % USt": {},
+        "Klasse 6: Personalaufwand": {
+            "6000 L\u00f6hne": {"account_type": "Payable"},
+            "6200 Geh\u00e4lter": {"account_type": "Payable"},
+            "6400 Aufwendungen f\u00fcr Abfertigungen": {"account_type": "Payable"},
+            "6450 Aufwendungen f\u00fcr Altersversorgung": {"account_type": "Payable"},
+            "6500 Gesetzlicher Sozialaufwand Arbeiter": {"account_type": "Payable"},
+            "6560 Gesetzlicher Sozialaufwand Angestellte": {"account_type": "Payable"},
+            "6600 Lohnabh\u00e4ngige Abgaben und Pflichtbeitr\u00e4gte": {"account_type": "Payable"},
+            "6660 Gehaltsabh\u00e4ngige Abgaben und Pflichtbeitr\u00e4gte": {"account_type": "Payable"},
+            "6700 Sonstige Sozialaufwendungen": {"account_type": "Payable"},
+            "6900 Aufwandsstellenrechnung Personal": {"account_type": "Payable"},
             "root_type": "Expense"
+        },       
+         "Klasse 7: Abschreibungen und sonstige betriebliche Aufwendungen": {
+            "7010 Abschreibungen auf das Anlageverm\u00f6gen (ausgenommen Finanzanlagen)": {"account_type": "Depreciation"},
+            "7100 Sonstige Steuern und Geb\u00fchren": {"account_type": "Tax"},
+            "7200 Instandhaltung u. Reinigung durch Dritte, Entsorgung, Energie": {"account_type": "Expense Account"},
+            "7300 Transporte durch Dritte": {"account_type": "Expense Account"},
+            "7310 Fahrrad - Aufwand": {"account_type": "Expense Account"},
+            "7320 Kfz - Aufwand": {"account_type": "Expense Account"},
+            "7330 LKW - Aufwand": {"account_type": "Expense Account"},
+            "7340 Lastenrad - Aufwand": {"account_type": "Expense Account"},            
+            "7350 Reise- und Fahraufwand": {"account_type": "Expense Account"},
+            "7360 Tag- und N\u00e4chtigungsgelder": {"account_type": "Expense Account"},
+            "7380 Nachrichtenaufwand": {"account_type": "Expense Account"},
+            "7400 Miet- und Pachtaufwand": {"account_type": "Expense Account"},
+            "7440 Leasingaufwand": {"account_type": "Expense Account"},
+            "7480 Lizenzaufwand": {"account_type": "Expense Account"},
+            "7500 Aufwand f\u00fcr beigestelltes Personal": {"account_type": "Expense Account"},
+            "7540 Provisionen an Dritte": {"account_type": "Expense Account"},
+            "7580 Aufsichtsratsverg\u00fctungen": {"account_type": "Expense Account"},
+            "7610 Druckerzeugnisse und Vervielf\u00e4ltigungen": {"account_type": "Expense Account"},
+            "7650 Werbung und Repr\u00e4sentationen": {"account_type": "Expense Account"},
+            "7700 Versicherungen": {"account_type": "Expense Account"},
+            "7750 Beratungs- und Pr\u00fcfungsaufwand": {"account_type": "Expense Account"},
+            "7800 Forderungsverluste und Schadensf\u00e4lle": {"account_type": "Expense Account"},
+            "7840 Verschiedene betriebliche Aufwendungen": {"account_type": "Expense Account"},
+            "7910 Aufwandsstellenrechung der Hersteller": {"account_type": "Expense Account"},
+            "7060 Sofortabschreibungen geringwertig": {"account_type": "Expense Account"},
+            "7070 Abschreibungen vom Umlaufverm\u00f6gen, soweit diese die im Unternehmen \u00fcblichen Abschreibungen \u00fcbersteigen": {"account_type": "Depreciation"},
+            "7900 Aufwandsstellenrechnung": {"account_type": "Expense Account"},
+            "7770 Aus- und Fortbildung": {"account_type": "Expense Account"},
+            "7820 Buchwert abgegangener Anlagen, ausgenommen Finanzanlagen": {"account_type": "Expense Account"},
+            "7600 B\u00fcromaterial und Drucksorten": {"account_type": "Expense Account"},
+            "7630 Fachliteratur und Zeitungen ": {"account_type": "Expense Account"},
+            "7960 Herstellungskosten der zur Erzielung der Umsatzerl\u00f6se erbrachten Leistungen": {"account_type": "Expense Account"},
+            "7780 Mitgliedsbeitr\u00e4ge": {"account_type": "Expense Account"},
+            "7880 Skontoertr\u00e4ge auf sonstige betriebliche Aufwendungen": {"account_type": "Expense Account"},
+            "7990 Sonstige betrieblichen Aufwendungen": {"account_type": "Expense Account"},
+            "7680 Spenden und Trinkgelder": {"account_type": "Expense Account"},
+            "7790 Spesen des Geldverkehrs": {"account_type": "Expense Account"},
+            "7830 Verluste aus dem Abgang vom Anlageverm\u00f6gen, ausgenommen Finanzanlagen": {"account_type": "Expense Account"},
+            "7970 Vertriebskosten": {"account_type": "Expense Account"},
+            "7980 Verwaltungskosten": {"account_type": "Expense Account"},
+            "root_type": "Expense"
+        },
+         "Klasse 8: Finanz- und ausserordentliche Ertr\u00e4ge und Aufwendungen": {
+            "8000 Ertr\u00e4ge aus Beteiligungen": {"account_type": "Income Account"},
+            "8050 Ertr\u00e4ge aus anderen Wertpapieren und Ausleihungen des Finanzanlageverm\u00f6gens": {"account_type": "Income Account"},
+            "8100 Zinsen aus Bankguthaben": {"account_type": "Income Account"},
+            "8110 Zinsen aus gewaehrten Darlehen": {"account_type": "Income Account"},
+            "8130 Verzugszinsenertraege": {"account_type": "Income Account"},
+            "8220 Aufwendungen aus Beteiligungen": {"account_type": "Expense Account"},
+            "8260 Aufwendungen aus sonst. Fiananzanlagen und aus Wertpapieren des Umlaufverm\u00f6gens": {},
+            "8280 Zinsen und \u00e4hnliche Aufwendungem": {"account_type": "Expense Account"},
+            "8400 Au\u00dferordentliche Ertr\u00e4ge": {"account_type": "Income Account"},
+            "8450 Au\u00dferordentliche Aufwendungen": {"account_type": "Expense Account"},
+            "8500 Steuern vom Einkommen und vom Ertrag": {
+                "account_type": "Tax"
+            },
+            "8600 Aufl\u00f6sung unversteuerten R\u00fccklagen": {"account_type": "Income Account"},
+            "8700 Aufl\u00f6sung von Kapitalr\u00fccklagen": {"account_type": "Income Account"},
+            "8750 Aufl\u00f6sung von Gewinnr\u00fccklagen": {"account_type": "Income Account"},
+            "8800 Zuweisung zu unversteuerten R\u00fccklagen": {"account_type": "Expense Account"},
+            "8900 Zuweisung zu Gewinnr\u00fccklagen": {"account_type": "Expense Account"},
+            "8100 Buchwert abgegangener Beteiligungen": {"account_type": "Expense Account"},
+            "8130 Buchwert abgegangener Wertpapiere des Umlaufverm\u00f6gens": {"account_type": "Expense Account"},
+            "8120 Buchwert abgegangener sonstiger Finanzanlagen": {"account_type": "Expense Account"},
+            "8990 Gewinnabfuhr bzw. Verlust\u00fcberrechnung aus Ergebnisabf\u00fchrungsvertr\u00e4gen": {"account_type": "Expense Account"},
+            "8350 nicht ausgenutzte Lieferantenskonti": {"account_type": "Expense Account"},
+            "root_type": "Income"
+        },       
+        "Klasse 9 Passiva: Eigenkapital, R\u00fccklagen, stille Einlagen, Abschlusskonten": {
+            "9000 Gezeichnetes bzw. gewidmetes Kapital": {
+                "account_type": "Equity"
+            },
+            "9200 Kapitalr\u00fccklagen": {
+                "account_type": "Equity"
+            },
+            "9300 Gewinnr\u00fccklagen": {
+                "account_type": "Equity"
+            },
+            "9400 Bewertungsreserven uns sonst. unversteuerte R\u00fccklagen": {
+                "account_type": "Equity"
+            },
+            "9600 Private Entnahmen": {"account_type": "Equity"},
+            "9610 Privatsteuern": {"account_type": "Equity"},
+            "9700 Einlagen stiller Gesellschafter ": {"account_type": "Equity"},
+            "9900 Evidenzkonto": {"account_type": "Equity"},
+            "9800 Er\u00f6ffnungsbilanzkonto (EBK)": {"account_type": "Equity"},
+            "9880 Jahresergebnis laut Gewinn- und Verlustrechnung (G+V)": {"account_type": "Equity"},
+            "9850 Schlussbilanzkonto (SBK)": {"account_type": "Round Off"},
+            "9190 nicht eingeforderte ausstehende Einlagen und berechtigte Entnahmen von Gesellschaftern": {
+                "account_type": "Equity"
+            },
+            "root_type": "Equity"
         }
-    }
-}
+     }   
+  }

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/bank_account/bank_account.py

@@ -77,6 +77,6 @@ def get_party_bank_account(party_type, party):
 
 @frappe.whitelist()
 def get_bank_account_details(bank_account):
-	return frappe.db.get_value(
+	return frappe.get_cached_value(
 		"Bank Account", bank_account, ["account", "bank", "bank_account_no"], as_dict=1
 	)

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -58,7 +58,7 @@ def get_bank_transactions(bank_account, from_date=None, to_date=None):
 @frappe.whitelist()
 def get_account_balance(bank_account, till_date):
 	# returns account balance till the specified date
-	account = frappe.db.get_value("Bank Account", bank_account, "account")
+	account = frappe.get_cached_value("Bank Account", bank_account, "account")
 	filters = frappe._dict(
 		{"account": account, "report_date": till_date, "include_pos_transactions": 1}
 	)
@@ -131,8 +131,10 @@ def create_journal_entry_bts(
 		fieldname=["name", "deposit", "withdrawal", "bank_account"],
 		as_dict=True,
 	)[0]
-	company_account = frappe.get_value("Bank Account", bank_transaction.bank_account, "account")
-	account_type = frappe.db.get_value("Account", second_account, "account_type")
+	company_account = frappe.get_cached_value(
+		"Bank Account", bank_transaction.bank_account, "account"
+	)
+	account_type = frappe.get_cached_value("Account", second_account, "account_type")
 	if account_type in ["Receivable", "Payable"]:
 		if not (party_type and party):
 			frappe.throw(
@@ -165,7 +167,7 @@ def create_journal_entry_bts(
 		}
 	)
 
-	company = frappe.get_value("Account", company_account, "company")
+	company = frappe.get_cached_value("Account", company_account, "company")
 
 	journal_entry_dict = {
 		"voucher_type": entry_type,
@@ -220,8 +222,10 @@ def create_payment_entry_bts(
 	paid_amount = bank_transaction.unallocated_amount
 	payment_type = "Receive" if bank_transaction.deposit > 0 else "Pay"
 
-	company_account = frappe.get_value("Bank Account", bank_transaction.bank_account, "account")
-	company = frappe.get_value("Account", company_account, "company")
+	company_account = frappe.get_cached_value(
+		"Bank Account", bank_transaction.bank_account, "account"
+	)
+	company = frappe.get_cached_value("Account", company_account, "company")
 	payment_entry_dict = {
 		"company": company,
 		"payment_type": payment_type,
@@ -341,7 +345,7 @@ def reconcile_vouchers(bank_transaction_name, vouchers):
 	# updated clear date of all the vouchers based on the bank transaction
 	vouchers = json.loads(vouchers)
 	transaction = frappe.get_doc("Bank Transaction", bank_transaction_name)
-	company_account = frappe.db.get_value("Bank Account", transaction.bank_account, "account")
+	company_account = frappe.get_cached_value("Bank Account", transaction.bank_account, "account")
 
 	if transaction.unallocated_amount == 0:
 		frappe.throw(_("This bank transaction is already fully reconciled"))
@@ -365,7 +369,7 @@ def reconcile_vouchers(bank_transaction_name, vouchers):
 				"The sum total of amounts of all selected vouchers should be less than the unallocated amount of the bank transaction"
 			)
 		)
-	account = frappe.db.get_value("Bank Account", transaction.bank_account, "account")
+	account = frappe.get_cached_value("Bank Account", transaction.bank_account, "account")
 
 	for voucher in vouchers:
 		gl_entry = frappe.db.get_value(

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.py

@@ -53,15 +53,13 @@ class BankStatementImport(DataImport):
 		if "Bank Account" not in json.dumps(preview["columns"]):
 			frappe.throw(_("Please add the Bank Account column"))
 
-		from frappe.core.page.background_jobs.background_jobs import get_info
+		from frappe.utils.background_jobs import is_job_queued
 		from frappe.utils.scheduler import is_scheduler_inactive
 
 		if is_scheduler_inactive() and not frappe.flags.in_test:
 			frappe.throw(_("Scheduler is inactive. Cannot import data."), title=_("Scheduler Inactive"))
 
-		enqueued_jobs = [d.get("job_name") for d in get_info()]
-
-		if self.name not in enqueued_jobs:
+		if not is_job_queued(self.name):
 			enqueue(
 				start_import,
 				queue="default",

erpnext/accounts/doctype/bank_transaction/bank_transaction_upload.py

@@ -74,7 +74,7 @@ def get_header_mapping(columns, bank_account):
 
 
 def get_bank_mapping(bank_account):
-	bank_name = frappe.db.get_value("Bank Account", bank_account, "bank")
+	bank_name = frappe.get_cached_value("Bank Account", bank_account, "bank")
 	bank = frappe.get_doc("Bank", bank_name)
 
 	mapping = {row.file_field: row.bank_transaction_field for row in bank.bank_transaction_mapping}

erpnext/accounts/doctype/budget/budget.py

@@ -59,7 +59,7 @@ class Budget(Document):
 		account_list = []
 		for d in self.get("accounts"):
 			if d.account:
-				account_details = frappe.db.get_value(
+				account_details = frappe.get_cached_value(
 					"Account", d.account, ["is_group", "company", "report_type"], as_dict=1
 				)
 
@@ -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):
@@ -311,7 +306,7 @@ def get_other_condition(args, budget, for_doc):
 
 	if args.get("fiscal_year"):
 		date_field = "schedule_date" if for_doc == "Material Request" else "transaction_date"
-		start_date, end_date = frappe.db.get_value(
+		start_date, end_date = frappe.get_cached_value(
 			"Fiscal Year", args.get("fiscal_year"), ["year_start_date", "year_end_date"]
 		)
 
@@ -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
@@ -386,7 +379,7 @@ def get_accumulated_monthly_budget(monthly_distribution, posting_date, fiscal_ye
 		):
 			distribution.setdefault(d.month, d.percentage_allocation)
 
-	dt = frappe.db.get_value("Fiscal Year", fiscal_year, "year_start_date")
+	dt = frappe.get_cached_value("Fiscal Year", fiscal_year, "year_start_date")
 	accumulated_percentage = 0.0
 
 	while dt <= getdate(posting_date):

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -45,8 +45,8 @@ def validate_columns(data):
 
 @frappe.whitelist()
 def validate_company(company):
-	parent_company, allow_account_creation_against_child_company = frappe.db.get_value(
-		"Company", {"name": company}, ["parent_company", "allow_account_creation_against_child_company"]
+	parent_company, allow_account_creation_against_child_company = frappe.get_cached_value(
+		"Company", company, ["parent_company", "allow_account_creation_against_child_company"]
 	)
 
 	if parent_company and (not allow_account_creation_against_child_company):

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/dunning/dunning.py

@@ -19,7 +19,7 @@ class Dunning(AccountsController):
 		self.validate_overdue_days()
 		self.validate_amount()
 		if not self.income_account:
-			self.income_account = frappe.db.get_value("Company", self.company, "default_income_account")
+			self.income_account = frappe.get_cached_value("Company", self.company, "default_income_account")
 
 	def validate_overdue_days(self):
 		self.overdue_days = (getdate(self.posting_date) - getdate(self.due_date)).days or 0
@@ -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/fiscal_year/fiscal_year.py

@@ -9,10 +9,6 @@ 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):
@@ -53,23 +49,18 @@ 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"),
-				FiscalYearIncorrectDate,
+				frappe.exceptions.InvalidDates,
 			)
 
 	def on_update(self):

erpnext/accounts/doctype/fiscal_year/test_fiscal_year.py

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

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -58,7 +58,7 @@ class GLEntry(Document):
 			validate_balance_type(self.account, adv_adj)
 			validate_frozen_account(self.account, adv_adj)
 
-			if frappe.db.get_value("Account", self.account, "account_type") not in [
+			if frappe.get_cached_value("Account", self.account, "account_type") not in [
 				"Receivable",
 				"Payable",
 			]:
@@ -128,7 +128,7 @@ class GLEntry(Document):
 			frappe.throw(msg, title=_("Missing Cost Center"))
 
 	def validate_dimensions_for_pl_and_bs(self):
-		account_type = frappe.db.get_value("Account", self.account, "report_type")
+		account_type = frappe.get_cached_value("Account", self.account, "report_type")
 
 		for dimension in get_checks_for_pl_and_bs_accounts():
 			if (
@@ -196,7 +196,7 @@ class GLEntry(Document):
 	def check_pl_account(self):
 		if (
 			self.is_opening == "Yes"
-			and frappe.db.get_value("Account", self.account, "report_type") == "Profit and Loss"
+			and frappe.get_cached_value("Account", self.account, "report_type") == "Profit and Loss"
 			and not self.is_cancelled
 		):
 			frappe.throw(
@@ -289,7 +289,7 @@ class GLEntry(Document):
 
 def validate_balance_type(account, adv_adj=False):
 	if not adv_adj and account:
-		balance_must_be = frappe.db.get_value("Account", account, "balance_must_be")
+		balance_must_be = frappe.get_cached_value("Account", account, "balance_must_be")
 		if balance_must_be:
 			balance = frappe.db.sql(
 				"""select sum(debit) - sum(credit)

erpnext/accounts/doctype/item_tax_template/item_tax_template.py

@@ -21,7 +21,7 @@ class ItemTaxTemplate(Document):
 		check_list = []
 		for d in self.get("taxes"):
 			if d.tax_type:
-				account_type = frappe.db.get_value("Account", d.tax_type, "account_type")
+				account_type = frappe.get_cached_value("Account", d.tax_type, "account_type")
 
 				if account_type not in [
 					"Tax",

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -8,7 +8,7 @@ frappe.provide("erpnext.journal_entry");
 frappe.ui.form.on("Journal Entry", {
 	setup: function(frm) {
 		frm.add_fetch("bank_account", "account", "account");
-		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', 'Journal Entry', "Repost Payment Ledger"];
+		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice'];
 	},
 
 	refresh: function(frm) {

erpnext/accounts/doctype/journal_entry/journal_entry.json

@@ -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-11-28 17:40:01.241908",
  "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 cint, cstr, flt, fmt_money, formatdate, get_link_to_form, nowdate
+from frappe.utils import cstr, flt, fmt_money, formatdate, get_link_to_form, nowdate
 
 import erpnext
 from erpnext.accounts.deferred_revenue import get_deferred_booking_accounts
@@ -23,6 +23,9 @@ 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
 
 
@@ -34,9 +37,6 @@ 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()
 
@@ -89,13 +88,7 @@ class JournalEntry(AccountsController):
 		from erpnext.accounts.utils import unlink_ref_doc_from_payment_entries
 
 		unlink_ref_doc_from_payment_entries(self)
-		self.ignore_linked_doctypes = (
-			"GL Entry",
-			"Stock Ledger Entry",
-			"Payment Ledger Entry",
-			"Repost Payment Ledger",
-			"Repost Payment Ledger Items",
-		)
+		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry", "Payment Ledger Entry")
 		self.make_gl_entries(1)
 		self.update_advance_paid()
 		self.unlink_advance_entry_reference()
@@ -232,29 +225,6 @@ class JournalEntry(AccountsController):
 		for d in to_remove:
 			self.remove(d)
 
-	def update_asset_value(self):
-		if self.voucher_type != "Depreciation Entry":
-			return
-
-		processed_assets = []
-
-		for d in self.get("accounts"):
-			if (
-				d.reference_type == "Asset" and d.reference_name and d.reference_name not in processed_assets
-			):
-				processed_assets.append(d.reference_name)
-
-				asset = frappe.get_doc("Asset", d.reference_name)
-
-				if asset.calculate_depreciation:
-					continue
-
-				depr_value = d.debit or d.credit
-
-				asset.db_set("value_after_depreciation", asset.value_after_depreciation - depr_value)
-
-				asset.set_status()
-
 	def update_inter_company_jv(self):
 		if (
 			self.voucher_type == "Inter Company Journal Entry"
@@ -313,39 +283,21 @@ 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 row in asset.get("finance_books"):
+					depr_schedule = get_depr_schedule(asset.name, "Active", row.finance_book)
 
-				if asset.calculate_depreciation:
-					for s in asset.get("schedules"):
+					for s in depr_schedule or []:
 						if s.journal_entry == self.name:
 							s.db_set("journal_entry", None)
 
-							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()
+							row.value_after_depreciation += s.depreciation_amount
+							row.db_update()
 
 							asset.set_status()
 
-							break
-				else:
-					depr_value = d.debit or d.credit
-
-					asset.db_set("value_after_depreciation", asset.value_after_depreciation + depr_value)
-
-					asset.set_status()
-
 	def unlink_inter_company_jv(self):
 		if (
 			self.voucher_type == "Inter Company Journal Entry"
@@ -368,7 +320,7 @@ class JournalEntry(AccountsController):
 
 	def validate_party(self):
 		for d in self.get("accounts"):
-			account_type = frappe.db.get_value("Account", d.account, "account_type")
+			account_type = frappe.get_cached_value("Account", d.account, "account_type")
 			if account_type in ["Receivable", "Payable"]:
 				if not (d.party_type and d.party):
 					frappe.throw(
@@ -431,7 +383,7 @@ class JournalEntry(AccountsController):
 	def validate_against_jv(self):
 		for d in self.get("accounts"):
 			if d.reference_type == "Journal Entry":
-				account_root_type = frappe.db.get_value("Account", d.account, "root_type")
+				account_root_type = frappe.get_cached_value("Account", d.account, "root_type")
 				if account_root_type == "Asset" and flt(d.debit) > 0:
 					frappe.throw(
 						_(
@@ -682,7 +634,7 @@ class JournalEntry(AccountsController):
 	def validate_multi_currency(self):
 		alternate_currency = []
 		for d in self.get("accounts"):
-			account = frappe.db.get_value(
+			account = frappe.get_cached_value(
 				"Account", d.account, ["account_currency", "account_type"], as_dict=1
 			)
 			if account:
@@ -814,7 +766,7 @@ class JournalEntry(AccountsController):
 					party_amount += flt(d.debit_in_account_currency) or flt(d.credit_in_account_currency)
 					party_account_currency = d.account_currency
 
-			elif frappe.db.get_value("Account", d.account, "account_type") in ["Bank", "Cash"]:
+			elif frappe.get_cached_value("Account", d.account, "account_type") in ["Bank", "Cash"]:
 				bank_amount += d.debit_in_account_currency or d.credit_in_account_currency
 				bank_account_currency = d.account_currency
 
@@ -1045,7 +997,7 @@ def get_default_bank_cash_account(company, account_type=None, mode_of_payment=No
 					account = account_list[0].name
 
 	if account:
-		account_details = frappe.db.get_value(
+		account_details = frappe.get_cached_value(
 			"Account", account, ["account_currency", "account_type"], as_dict=1
 		)
 
@@ -1174,7 +1126,7 @@ def get_payment_entry(ref_doc, args):
 			"party_type": args.get("party_type"),
 			"party": ref_doc.get(args.get("party_type").lower()),
 			"cost_center": cost_center,
-			"account_type": frappe.db.get_value("Account", args.get("party_account"), "account_type"),
+			"account_type": frappe.get_cached_value("Account", args.get("party_account"), "account_type"),
 			"account_currency": args.get("party_account_currency")
 			or get_account_currency(args.get("party_account")),
 			"balance": get_balance_on(args.get("party_account")),
@@ -1341,7 +1293,7 @@ def get_party_account_and_balance(company, party_type, party, cost_center=None):
 		"account": account,
 		"balance": account_balance,
 		"party_balance": party_balance,
-		"account_currency": frappe.db.get_value("Account", account, "account_currency"),
+		"account_currency": frappe.get_cached_value("Account", account, "account_currency"),
 	}
 
 
@@ -1354,7 +1306,7 @@ def get_account_balance_and_party_type(
 		frappe.msgprint(_("No Permission"), raise_exception=1)
 
 	company_currency = erpnext.get_company_currency(company)
-	account_details = frappe.db.get_value(
+	account_details = frappe.get_cached_value(
 		"Account", account, ["account_type", "account_currency"], as_dict=1
 	)
 
@@ -1407,7 +1359,7 @@ def get_exchange_rate(
 ):
 	from erpnext.setup.utils import get_exchange_rate
 
-	account_details = frappe.db.get_value(
+	account_details = frappe.get_cached_value(
 		"Account", account, ["account_type", "root_type", "account_currency", "company"], as_dict=1
 	)
 

erpnext/accounts/doctype/ledger_merge/ledger_merge.py

@@ -4,22 +4,20 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
+from frappe.utils.background_jobs import is_job_queued
 
 from erpnext.accounts.doctype.account.account import merge_account
 
 
 class LedgerMerge(Document):
 	def start_merge(self):
-		from frappe.core.page.background_jobs.background_jobs import get_info
 		from frappe.utils.background_jobs import enqueue
 		from frappe.utils.scheduler import is_scheduler_inactive
 
 		if is_scheduler_inactive() and not frappe.flags.in_test:
 			frappe.throw(_("Scheduler is inactive. Cannot merge accounts."), title=_("Scheduler Inactive"))
 
-		enqueued_jobs = [d.get("job_name") for d in get_info()]
-
-		if self.name not in enqueued_jobs:
+		if not is_job_queued(self.name):
 			enqueue(
 				start_merge,
 				queue="default",

erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py

@@ -25,7 +25,7 @@ class ModeofPayment(Document):
 	def validate_accounts(self):
 		for entry in self.accounts:
 			"""Error when Company of Ledger account doesn't match with Company Selected"""
-			if frappe.db.get_value("Account", entry.default_account, "company") != entry.company:
+			if frappe.get_cached_value("Account", entry.default_account, "company") != entry.company:
 				frappe.throw(
 					_("Account {0} does not match with Company {1} in Mode of Account: {2}").format(
 						entry.default_account, entry.company, self.name

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py

@@ -6,7 +6,7 @@ import frappe
 from frappe import _, scrub
 from frappe.model.document import Document
 from frappe.utils import flt, nowdate
-from frappe.utils.background_jobs import enqueue
+from frappe.utils.background_jobs import enqueue, is_job_queued
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
@@ -207,14 +207,12 @@ class OpeningInvoiceCreationTool(Document):
 		if len(invoices) < 50:
 			return start_import(invoices)
 		else:
-			from frappe.core.page.background_jobs.background_jobs import get_info
 			from frappe.utils.scheduler import is_scheduler_inactive
 
 			if is_scheduler_inactive() and not frappe.flags.in_test:
 				frappe.throw(_("Scheduler is inactive. Cannot import data."), title=_("Scheduler Inactive"))
 
-			enqueued_jobs = [d.get("job_name") for d in get_info()]
-			if self.name not in enqueued_jobs:
+			if not is_job_queued(self.name):
 				enqueue(
 					start_import,
 					queue="default",

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -7,7 +7,7 @@ cur_frm.cscript.tax_table = "Advance Taxes and Charges";
 
 frappe.ui.form.on('Payment Entry', {
 	onload: function(frm) {
-		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', "Repost Payment Ledger"];
+		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice'];
 
 		if(frm.doc.__islocal) {
 			if (!frm.doc.paid_from) frm.set_value("paid_from_account_currency", null);

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,7 +304,7 @@
   {
    "fieldname": "source_exchange_rate",
    "fieldtype": "Float",
-   "label": "Source Exchange Rate",
+   "label": "Exchange Rate",
    "precision": "9",
    "print_hide": 1,
    "reqd": 1
@@ -334,7 +334,7 @@
   {
    "fieldname": "target_exchange_rate",
    "fieldtype": "Float",
-   "label": "Target Exchange Rate",
+   "label": "Exchange Rate",
    "precision": "9",
    "print_hide": 1,
    "reqd": 1
@@ -633,14 +633,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 +733,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-02-14 04:52:30.478523",
+ "modified": "2022-12-08 16:25:43.824051",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry",

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -92,13 +92,7 @@ class PaymentEntry(AccountsController):
 		self.set_status()
 
 	def on_cancel(self):
-		self.ignore_linked_doctypes = (
-			"GL Entry",
-			"Stock Ledger Entry",
-			"Payment Ledger Entry",
-			"Repost Payment Ledger",
-			"Repost Payment Ledger Items",
-		)
+		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry", "Payment Ledger Entry")
 		self.make_gl_entries(cancel=1)
 		self.update_outstanding_amounts()
 		self.update_advance_paid()
@@ -730,7 +724,7 @@ class PaymentEntry(AccountsController):
 
 	def validate_transaction_reference(self):
 		bank_account = self.paid_to if self.payment_type == "Receive" else self.paid_from
-		bank_account_type = frappe.db.get_value("Account", bank_account, "account_type")
+		bank_account_type = frappe.get_cached_value("Account", bank_account, "account_type")
 
 		if bank_account_type == "Bank":
 			if not self.reference_no or not self.reference_date:
@@ -1310,7 +1304,7 @@ def split_invoices_based_on_payment_terms(outstanding_invoices):
 				d.voucher_type, d.voucher_no, "payment_terms_template"
 			)
 			if payment_term_template:
-				allocate_payment_based_on_payment_terms = frappe.db.get_value(
+				allocate_payment_based_on_payment_terms = frappe.get_cached_value(
 					"Payment Terms Template", payment_term_template, "allocate_payment_based_on_payment_terms"
 				)
 				if allocate_payment_based_on_payment_terms:
@@ -1542,7 +1536,7 @@ def get_account_details(account, date, cost_center=None):
 		{
 			"account_currency": get_account_currency(account),
 			"account_balance": account_balance,
-			"account_type": frappe.db.get_value("Account", account, "account_type"),
+			"account_type": frappe.get_cached_value("Account", account, "account_type"),
 		}
 	)
 
@@ -1711,9 +1705,9 @@ def get_payment_entry(
 	if doc.doctype == "Purchase Invoice" and doc.invoice_is_blocked():
 		frappe.msgprint(_("{0} is on hold till {1}").format(doc.name, doc.release_date))
 	else:
-		if doc.doctype in ("Sales Invoice", "Purchase Invoice") and frappe.get_value(
+		if doc.doctype in ("Sales Invoice", "Purchase Invoice") and frappe.get_cached_value(
 			"Payment Terms Template",
-			{"name": doc.payment_terms_template},
+			doc.payment_terms_template,
 			"allocate_payment_based_on_payment_terms",
 		):
 

erpnext/accounts/doctype/payment_gateway_account/payment_gateway_account.py

@@ -11,7 +11,7 @@ class PaymentGatewayAccount(Document):
 		self.name = self.payment_gateway + " - " + self.currency
 
 	def validate(self):
-		self.currency = frappe.db.get_value("Account", self.payment_account, "account_currency")
+		self.currency = frappe.get_cached_value("Account", self.payment_account, "account_currency")
 
 		self.update_default_payment_gateway()
 		self.set_as_default_if_not_set()

erpnext/accounts/doctype/payment_ledger_entry/payment_ledger_entry.py

@@ -97,7 +97,7 @@ class PaymentLedgerEntry(Document):
 						)
 
 	def validate_dimensions_for_pl_and_bs(self):
-		account_type = frappe.db.get_value("Account", self.account, "report_type")
+		account_type = frappe.get_cached_value("Account", self.account, "report_type")
 
 		for dimension in get_checks_for_pl_and_bs_accounts():
 			if (

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -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"
@@ -234,7 +230,7 @@ class PaymentReconciliation(Document):
 	def allocate_entries(self, args):
 		self.validate_entries()
 
-		invoice_exchange_map = self.get_invoice_exchange_map(args.get("invoices"), args.get("payments"))
+		invoice_exchange_map = self.get_invoice_exchange_map(args.get("invoices"))
 		default_exchange_gain_loss_account = frappe.get_cached_value(
 			"Company", self.company, "exchange_gain_loss_account"
 		)
@@ -253,9 +249,6 @@ class PaymentReconciliation(Document):
 					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")
@@ -341,7 +334,7 @@ class PaymentReconciliation(Document):
 		)
 
 		# Account Currency has balance
-		dr_or_cr = "debit" if self.party_type == "Customer" else "credit"
+		dr_or_cr = "debit" if self.party_type == "Customer" else "debit"
 		reverse_dr_or_cr = "debit" if dr_or_cr == "credit" else "credit"
 
 		journal_account = frappe._dict(
@@ -368,7 +361,6 @@ class PaymentReconciliation(Document):
 				"exchange_rate": 1,
 				"cost_center": erpnext.get_default_cost_center(self.company),
 				reverse_dr_or_cr + "_in_account_currency": flt(row.difference_amount),
-				reverse_dr_or_cr: flt(row.difference_amount),
 			}
 		)
 
@@ -411,21 +403,13 @@ 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):
+	def get_invoice_exchange_map(self, invoices):
 		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:
@@ -487,7 +471,6 @@ 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")
 

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -473,11 +473,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 +506,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
@@ -757,73 +747,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		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):

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -45,24 +45,25 @@ 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)
-		if self.payment_account and ref_doc.currency != frappe.db.get_value(
+		if self.payment_account and ref_doc.currency != frappe.get_cached_value(
 			"Account", self.payment_account, "account_currency"
 		):
 			frappe.throw(_("Transaction currency must be same as Payment Gateway currency"))
@@ -495,7 +496,7 @@ def get_amount(ref_doc, payment_account=None):
 	"""get amount based on doctype"""
 	dt = ref_doc.doctype
 	if dt in ["Sales Order", "Purchase Order"]:
-		grand_total = flt(ref_doc.rounded_total) - flt(ref_doc.advance_paid)
+		grand_total = flt(ref_doc.grand_total) - flt(ref_doc.advance_paid)
 
 	elif dt in ["Sales Invoice", "Purchase Invoice"]:
 		if ref_doc.party_account_currency == ref_doc.currency:

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -43,7 +43,7 @@ class PeriodClosingVoucher(AccountsController):
 			make_reverse_gl_entries(voucher_type="Period Closing Voucher", voucher_no=self.name)
 
 	def validate_account_head(self):
-		closing_account_type = frappe.db.get_value("Account", self.closing_account_head, "root_type")
+		closing_account_type = frappe.get_cached_value("Account", self.closing_account_head, "root_type")
 
 		if closing_account_type not in ["Liability", "Equity"]:
 			frappe.throw(

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.py

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

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -335,7 +335,8 @@ class POSInvoice(SalesInvoice):
 		if (
 			self.change_amount
 			and self.account_for_change_amount
-			and frappe.db.get_value("Account", self.account_for_change_amount, "company") != self.company
+			and frappe.get_cached_value("Account", self.account_for_change_amount, "company")
+			!= self.company
 		):
 			frappe.throw(
 				_("The selected change account {} doesn't belongs to Company {}.").format(
@@ -486,7 +487,7 @@ class POSInvoice(SalesInvoice):
 				customer_price_list, customer_group, customer_currency = frappe.db.get_value(
 					"Customer", self.customer, ["default_price_list", "customer_group", "default_currency"]
 				)
-				customer_group_price_list = frappe.db.get_value(
+				customer_group_price_list = frappe.get_cached_value(
 					"Customer Group", customer_group, "default_price_list"
 				)
 				selling_price_list = (
@@ -532,8 +533,8 @@ class POSInvoice(SalesInvoice):
 
 		if not self.debit_to:
 			self.debit_to = get_party_account("Customer", self.customer, self.company)
-			self.party_account_currency = frappe.db.get_value(
-				"Account", self.debit_to, "account_currency", cache=True
+			self.party_account_currency = frappe.get_cached_value(
+				"Account", self.debit_to, "account_currency"
 			)
 		if not self.due_date and self.customer:
 			self.due_date = get_due_date(self.posting_date, "Customer", self.customer, self.company)

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -6,11 +6,10 @@ import json
 
 import frappe
 from frappe import _
-from frappe.core.page.background_jobs.background_jobs import get_info
 from frappe.model.document import Document
 from frappe.model.mapper import map_child_doc, map_doc
 from frappe.utils import cint, flt, get_time, getdate, nowdate, nowtime
-from frappe.utils.background_jobs import enqueue
+from frappe.utils.background_jobs import enqueue, is_job_queued
 from frappe.utils.scheduler import is_scheduler_inactive
 
 
@@ -18,22 +17,6 @@ class POSInvoiceMergeLog(Document):
 	def validate(self):
 		self.validate_customer()
 		self.validate_pos_invoice_status()
-		self.validate_duplicate_pos_invoices()
-
-	def validate_duplicate_pos_invoices(self):
-		pos_occurences = {}
-		for idx, inv in enumerate(self.pos_invoices, 1):
-			pos_occurences.setdefault(inv.pos_invoice, []).append(idx)
-
-		error_list = []
-		for key, value in pos_occurences.items():
-			if len(value) > 1:
-				error_list.append(
-					_("{} is added multiple times on rows: {}".format(frappe.bold(key), frappe.bold(value)))
-				)
-
-		if error_list:
-			frappe.throw(error_list, title=_("Duplicate POS Invoices found"), as_list=True)
 
 	def validate_customer(self):
 		if self.merge_invoices_based_on == "Customer Group":
@@ -442,8 +425,6 @@ def create_merge_logs(invoice_by_customer, closing_entry=None):
 
 		if closing_entry:
 			closing_entry.set_status(update=True, status="Failed")
-			if type(error_message) == list:
-				error_message = frappe.json.dumps(error_message)
 			closing_entry.db_set("error_message", error_message)
 		raise
 
@@ -485,7 +466,7 @@ def enqueue_job(job, **kwargs):
 	closing_entry = kwargs.get("closing_entry") or {}
 
 	job_name = closing_entry.get("name")
-	if not job_already_enqueued(job_name):
+	if not is_job_queued(job_name):
 		enqueue(
 			job,
 			**kwargs,
@@ -509,12 +490,6 @@ def check_scheduler_status():
 		frappe.throw(_("Scheduler is inactive. Cannot enqueue job."), title=_("Scheduler Inactive"))
 
 
-def job_already_enqueued(job_name):
-	enqueued_jobs = [d.get("job_name") for d in get_info()]
-	if job_name in enqueued_jobs:
-		return True
-
-
 def safe_load_json(message):
 	try:
 		json_message = json.loads(message).get("message")

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, getdate
+from frappe.utils import cint, flt
 
 apply_on_dict = {"Item Code": "items", "Item Group": "item_groups", "Brand": "brands"}
 
@@ -184,8 +184,7 @@ 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"))
 
-		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"))
+		self.validate_from_to_dates("valid_from", "valid_upto")
 
 	def validate_condition(self):
 		if (

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -710,6 +710,132 @@ class TestPricingRule(unittest.TestCase):
 
 		item.delete()
 
+	def test_item_group_price_with_blank_uom_pricing_rule(self):
+		group = frappe.get_doc(doctype="Item Group", item_group_name="_Test Pricing Rule Item Group")
+		group.save()
+		properties = {
+			"item_code": "Item with Group Blank UOM",
+			"item_group": "_Test Pricing Rule Item Group",
+			"stock_uom": "Nos",
+			"sales_uom": "Box",
+			"uoms": [dict(uom="Box", conversion_factor=10)],
+		}
+		item = make_item(properties=properties)
+
+		make_item_price("Item with Group Blank UOM", "_Test Price List", 100)
+
+		pricing_rule_record = {
+			"doctype": "Pricing Rule",
+			"title": "_Test Item with Group Blank UOM Rule",
+			"apply_on": "Item Group",
+			"item_groups": [
+				{
+					"item_group": "_Test Pricing Rule Item Group",
+				}
+			],
+			"selling": 1,
+			"currency": "INR",
+			"rate_or_discount": "Rate",
+			"rate": 101,
+			"company": "_Test Company",
+		}
+		rule = frappe.get_doc(pricing_rule_record)
+		rule.insert()
+
+		si = create_sales_invoice(
+			do_not_save=True, item_code="Item with Group Blank UOM", uom="Box", conversion_factor=10
+		)
+		si.selling_price_list = "_Test Price List"
+		si.save()
+
+		# If UOM is blank consider it as stock UOM and apply pricing_rule on all UOM.
+		# rate is 101, Selling UOM is Box that have conversion_factor of 10 so 101 * 10 = 1010
+		self.assertEqual(si.items[0].price_list_rate, 1010)
+		self.assertEqual(si.items[0].rate, 1010)
+
+		si.delete()
+
+		si = create_sales_invoice(do_not_save=True, item_code="Item with Group Blank UOM", uom="Nos")
+		si.selling_price_list = "_Test Price List"
+		si.save()
+
+		# UOM is blank so consider it as stock UOM and apply pricing_rule on all UOM.
+		# rate is 101, Selling UOM is Nos that have conversion_factor of 1 so 101 * 1 = 101
+		self.assertEqual(si.items[0].price_list_rate, 101)
+		self.assertEqual(si.items[0].rate, 101)
+
+		si.delete()
+		rule.delete()
+		frappe.get_doc("Item Price", {"item_code": "Item with Group Blank UOM"}).delete()
+		item.delete()
+		group.delete()
+
+	def test_item_group_price_with_selling_uom_pricing_rule(self):
+		group = frappe.get_doc(doctype="Item Group", item_group_name="_Test Pricing Rule Item Group UOM")
+		group.save()
+		properties = {
+			"item_code": "Item with Group UOM other than Stock",
+			"item_group": "_Test Pricing Rule Item Group UOM",
+			"stock_uom": "Nos",
+			"sales_uom": "Box",
+			"uoms": [dict(uom="Box", conversion_factor=10)],
+		}
+		item = make_item(properties=properties)
+
+		make_item_price("Item with Group UOM other than Stock", "_Test Price List", 100)
+
+		pricing_rule_record = {
+			"doctype": "Pricing Rule",
+			"title": "_Test Item with Group UOM other than Stock Rule",
+			"apply_on": "Item Group",
+			"item_groups": [
+				{
+					"item_group": "_Test Pricing Rule Item Group UOM",
+					"uom": "Box",
+				}
+			],
+			"selling": 1,
+			"currency": "INR",
+			"rate_or_discount": "Rate",
+			"rate": 101,
+			"company": "_Test Company",
+		}
+		rule = frappe.get_doc(pricing_rule_record)
+		rule.insert()
+
+		si = create_sales_invoice(
+			do_not_save=True,
+			item_code="Item with Group UOM other than Stock",
+			uom="Box",
+			conversion_factor=10,
+		)
+		si.selling_price_list = "_Test Price List"
+		si.save()
+
+		# UOM is Box so apply pricing_rule only on Box UOM.
+		# Selling UOM is Box and as both UOM are same no need to multiply by conversion_factor.
+		self.assertEqual(si.items[0].price_list_rate, 101)
+		self.assertEqual(si.items[0].rate, 101)
+
+		si.delete()
+
+		si = create_sales_invoice(
+			do_not_save=True, item_code="Item with Group UOM other than Stock", uom="Nos"
+		)
+		si.selling_price_list = "_Test Price List"
+		si.save()
+
+		# UOM is Box so pricing_rule won't apply as selling_uom is Nos.
+		# As Pricing Rule is not applied price of 100 will be fetched from Item Price List.
+		self.assertEqual(si.items[0].price_list_rate, 100)
+		self.assertEqual(si.items[0].rate, 100)
+
+		si.delete()
+		rule.delete()
+		frappe.get_doc("Item Price", {"item_code": "Item with Group UOM other than Stock"}).delete()
+		item.delete()
+		group.delete()
+
 	def test_pricing_rule_for_different_currency(self):
 		make_item("Test Sanitizer Item")
 

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -127,6 +127,12 @@ def _get_pricing_rules(apply_on, args, values):
 				values["variant_of"] = args.variant_of
 	elif apply_on_field == "item_group":
 		item_conditions = _get_tree_conditions(args, "Item Group", child_doc, False)
+		if args.get("uom", None):
+			item_conditions += (
+				" and ({child_doc}.uom='{item_uom}' or IFNULL({child_doc}.uom, '')='')".format(
+					child_doc=child_doc, item_uom=args.get("uom")
+				)
+			)
 
 	conditions += get_other_conditions(conditions, values, args)
 	warehouse_conditions = _get_tree_conditions(args, "Warehouse", "`tabPricing Rule`")
@@ -681,21 +687,11 @@ def get_product_discount_rule(pricing_rule, item_details, args=None, doc=None):
 
 def apply_pricing_rule_for_free_items(doc, pricing_rule_args):
 	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/process_statement_of_accounts/process_statement_of_accounts.js

@@ -9,6 +9,7 @@ frappe.ui.form.on('Process Statement Of Accounts', {
 	refresh: function(frm){
 		if(!frm.doc.__islocal) {
 			frm.add_custom_button(__('Send Emails'), function(){
+				if (frm.is_dirty()) frappe.throw(__("Please save before proceeding."))
 				frappe.call({
 					method: "erpnext.accounts.doctype.process_statement_of_accounts.process_statement_of_accounts.send_emails",
 					args: {
@@ -25,7 +26,8 @@ frappe.ui.form.on('Process Statement Of Accounts', {
 				});
 			});
 			frm.add_custom_button(__('Download'), function(){
-				var url = frappe.urllib.get_full_url(
+				if (frm.is_dirty()) frappe.throw(__("Please save before proceeding."))
+				let url = frappe.urllib.get_full_url(
 					'/api/method/erpnext.accounts.doctype.process_statement_of_accounts.process_statement_of_accounts.download_statements?'
 					+ 'document_name='+encodeURIComponent(frm.doc.name))
 				$.ajax({

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -23,10 +23,12 @@
   "fetch_customers",
   "column_break_6",
   "primary_mandatory",
+  "show_net_values_in_party_account",
   "column_break_17",
   "customers",
   "preferences",
   "orientation",
+  "include_break",
   "include_ageing",
   "ageing_based_on",
   "section_break_14",
@@ -284,10 +286,22 @@
    "fieldtype": "Link",
    "label": "Terms and Conditions",
    "options": "Terms and Conditions"
+  },
+  {
+   "default": "1",
+   "fieldname": "include_break",
+   "fieldtype": "Check",
+   "label": "Page Break After Each SoA"
+  },
+  {
+   "default": "0",
+   "fieldname": "show_net_values_in_party_account",
+   "fieldtype": "Check",
+   "label": "Show Net Values in Party Account"
   }
  ],
  "links": [],
- "modified": "2021-09-06 21:00:45.732505",
+ "modified": "2022-11-10 17:44:17.165991",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",
@@ -321,5 +335,6 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
+ "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -6,6 +6,7 @@ import copy
 
 import frappe
 from frappe import _
+from frappe.desk.reportview import get_match_cond
 from frappe.model.document import Document
 from frappe.utils import add_days, add_months, format_date, getdate, today
 from frappe.utils.jinja import validate_template
@@ -94,6 +95,7 @@ def get_report_pdf(doc, consolidated=True):
 				"show_opening_entries": 0,
 				"include_default_book_entries": 0,
 				"tax_id": tax_id if tax_id else None,
+				"show_net_values_in_party_account": doc.show_net_values_in_party_account,
 			}
 		)
 		col, res = get_soa(filters)
@@ -128,7 +130,8 @@ def get_report_pdf(doc, consolidated=True):
 	if not bool(statement_dict):
 		return False
 	elif consolidated:
-		result = "".join(list(statement_dict.values()))
+		delimiter = '<div style="page-break-before: always;"></div>' if doc.include_break else ""
+		result = delimiter.join(list(statement_dict.values()))
 		return get_pdf(result, {"orientation": doc.orientation})
 	else:
 		for customer, statement_html in statement_dict.items():
@@ -240,8 +243,6 @@ def fetch_customers(customer_collection, collection_name, primary_mandatory):
 		if int(primary_mandatory):
 			if primary_email == "":
 				continue
-		elif (billing_email == "") and (primary_email == ""):
-			continue
 
 		customer_list.append(
 			{"name": customer.name, "primary_email": primary_email, "billing_email": billing_email}
@@ -273,8 +274,12 @@ def get_customer_emails(customer_name, primary_mandatory, billing_and_primary=Tr
 			link.link_doctype='Customer'
 			and link.link_name=%s
 			and contact.is_billing_contact=1
+			{mcond}
 		ORDER BY
-			contact.creation desc""",
+			contact.creation desc
+		""".format(
+			mcond=get_match_cond("Contact")
+		),
 		customer_name,
 	)
 
@@ -313,6 +318,8 @@ def send_emails(document_name, from_scheduler=False):
 			attachments = [{"fname": customer + ".pdf", "fcontent": report_pdf}]
 
 			recipients, cc = get_recipients_and_cc(customer, doc)
+			if not recipients:
+				continue
 			context = get_context(customer, doc)
 			subject = frappe.render_template(doc.subject, context)
 			message = frappe.render_template(doc.body, context)

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -31,7 +31,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		super.onload();
 
 		// Ignore linked advances
-		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry', 'Purchase Invoice', "Repost Payment Ledger"];
+		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry', 'Purchase Invoice'];
 
 		if(!this.frm.doc.__islocal) {
 			// show credit_to in print format

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -1426,7 +1426,6 @@
   },
   {
    "default": "0",
-   "depends_on": "apply_tds",
    "fieldname": "tax_withholding_net_total",
    "fieldtype": "Currency",
    "hidden": 1,
@@ -1436,13 +1435,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
   },
@@ -1556,7 +1554,7 @@
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-01-28 19:18:56.586321",
+ "modified": "2022-12-12 18:37:38.142688",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",
@@ -1620,4 +1618,4 @@
  "timeline_field": "supplier",
  "title_field": "title",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -5,7 +5,6 @@
 import frappe
 from frappe import _, throw
 from frappe.model.mapper import get_mapped_doc
-from frappe.query_builder.functions import Sum
 from frappe.utils import cint, cstr, flt, formatdate, get_link_to_form, getdate, nowdate
 
 import erpnext
@@ -154,8 +153,8 @@ class PurchaseInvoice(BuyingController):
 	def set_missing_values(self, for_validate=False):
 		if not self.credit_to:
 			self.credit_to = get_party_account("Supplier", self.supplier, self.company)
-			self.party_account_currency = frappe.db.get_value(
-				"Account", self.credit_to, "account_currency", cache=True
+			self.party_account_currency = frappe.get_cached_value(
+				"Account", self.credit_to, "account_currency"
 			)
 		if not self.due_date:
 			self.due_date = get_due_date(
@@ -176,7 +175,7 @@ class PurchaseInvoice(BuyingController):
 			if not self.credit_to:
 				self.raise_missing_debit_credit_account_error("Supplier", self.supplier)
 
-		account = frappe.db.get_value(
+		account = frappe.get_cached_value(
 			"Account", self.credit_to, ["account_type", "report_type", "account_currency"], as_dict=True
 		)
 
@@ -676,7 +675,7 @@ class PurchaseInvoice(BuyingController):
 		exchange_rate_map, net_rate_map = get_purchase_document_details(self)
 
 		provisional_accounting_for_non_stock_items = cint(
-			frappe.db.get_value(
+			frappe.get_cached_value(
 				"Company", self.company, "enable_provisional_accounting_for_non_stock_items"
 			)
 		)
@@ -984,7 +983,7 @@ class PurchaseInvoice(BuyingController):
 				asset_amount = flt(item.net_amount) + flt(item.item_tax_amount / self.conversion_rate)
 				base_asset_amount = flt(item.base_net_amount + item.item_tax_amount)
 
-				item_exp_acc_type = frappe.db.get_value("Account", item.expense_account, "account_type")
+				item_exp_acc_type = frappe.get_cached_value("Account", item.expense_account, "account_type")
 				if not item.expense_account or item_exp_acc_type not in [
 					"Asset Received But Not Billed",
 					"Fixed Asset",
@@ -1417,8 +1416,6 @@ class PurchaseInvoice(BuyingController):
 			"GL Entry",
 			"Stock Ledger Entry",
 			"Repost Item Valuation",
-			"Repost Payment Ledger",
-			"Repost Payment Ledger Items",
 			"Payment Ledger Entry",
 			"Tax Withheld Vouchers",
 		)
@@ -1466,16 +1463,19 @@ class PurchaseInvoice(BuyingController):
 	def update_billing_status_in_pr(self, update_modified=True):
 		updated_pr = []
 		po_details = []
-
-		pr_details_billed_amt = self.get_pr_details_billed_amt()
-
 		for d in self.get("items"):
 			if d.pr_detail:
+				billed_amt = frappe.db.sql(
+					"""select sum(amount) from `tabPurchase Invoice Item`
+					where pr_detail=%s and docstatus=1""",
+					d.pr_detail,
+				)
+				billed_amt = billed_amt and billed_amt[0][0] or 0
 				frappe.db.set_value(
 					"Purchase Receipt Item",
 					d.pr_detail,
 					"billed_amt",
-					flt(pr_details_billed_amt.get(d.pr_detail)),
+					billed_amt,
 					update_modified=update_modified,
 				)
 				updated_pr.append(d.purchase_receipt)
@@ -1491,24 +1491,6 @@ class PurchaseInvoice(BuyingController):
 			pr_doc = frappe.get_doc("Purchase Receipt", pr)
 			update_billing_percentage(pr_doc, update_modified=update_modified)
 
-	def get_pr_details_billed_amt(self):
-		# Get billed amount based on purchase receipt item reference (pr_detail) in purchase invoice
-
-		pr_details_billed_amt = {}
-		pr_details = [d.get("pr_detail") for d in self.get("items") if d.get("pr_detail")]
-		if pr_details:
-			doctype = frappe.qb.DocType("Purchase Invoice Item")
-			query = (
-				frappe.qb.from_(doctype)
-				.select(doctype.pr_detail, Sum(doctype.amount))
-				.where(doctype.pr_detail.isin(pr_details) & doctype.docstatus == 1)
-				.groupby(doctype.pr_detail)
-			)
-
-			pr_details_billed_amt = frappe._dict(query.run(as_list=1))
-
-		return pr_details_billed_amt
-
 	def on_recurring(self, reference_doc, auto_repeat_doc):
 		self.due_date = None
 

erpnext/accounts/doctype/repost_payment_ledger/repost_payment_ledger.py

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

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -34,7 +34,7 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 		super.onload();
 
 		this.frm.ignore_doctypes_on_cancel_all = ['POS Invoice', 'Timesheet', 'POS Invoice Merge Log',
-							  'POS Closing Entry', 'Journal Entry', 'Payment Entry', "Repost Payment Ledger"];
+			'POS Closing Entry', 'Journal Entry', 'Payment Entry'];
 
 		if(!this.frm.doc.__islocal && !this.frm.doc.customer && this.frm.doc.debit_to) {
 			// show debit_to in print format
@@ -1047,7 +1047,7 @@ var select_loyalty_program = function(frm, loyalty_programs) {
 		]
 	});
 
-	dialog.set_primary_action(__("Set"), function() {
+	dialog.set_primary_action(__("Set Loyalty Program"), function() {
 		dialog.hide();
 		return frappe.call({
 			method: "frappe.client.set_value",

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -1776,8 +1776,6 @@
    "width": "50%"
   },
   {
-   "fetch_from": "sales_partner.commission_rate",
-   "fetch_if_empty": 1,
    "fieldname": "commission_rate",
    "fieldtype": "Float",
    "hide_days": 1,
@@ -2111,6 +2109,15 @@
    "label": "Write Off",
    "width": "50%"
   },
+  {
+   "default": "0",
+   "fieldname": "repost_required",
+   "fieldtype": "Check",
+   "hidden": 1,
+   "label": "Repost Required",
+   "no_copy": 1,
+   "read_only": 1
+  },
   {
    "fieldname": "incoterm",
    "fieldtype": "Link",
@@ -2122,15 +2129,6 @@
    "fieldname": "named_place",
    "fieldtype": "Data",
    "label": "Named Place"
-  },
-  {
-   "default": "0",
-   "fieldname": "repost_required",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Repost Required",
-   "no_copy": 1,
-   "read_only": 1
   }
  ],
  "icon": "fa fa-file-text",
@@ -2143,7 +2141,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2022-11-07 16:02:07.972258",
+ "modified": "2022-12-12 18:34:33.409895",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",
@@ -2199,4 +2197,4 @@
  "title_field": "title",
  "track_changes": 1,
  "track_seen": 1
-}
+}

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -397,8 +397,6 @@ class SalesInvoice(SellingController):
 			"GL Entry",
 			"Stock Ledger Entry",
 			"Repost Item Valuation",
-			"Repost Payment Ledger",
-			"Repost Payment Ledger Items",
 			"Payment Ledger Entry",
 		)
 
@@ -573,13 +571,14 @@ class SalesInvoice(SellingController):
 
 			# validate if deferred revenue is enabled for any item
 			# Don't allow to update the invoice if deferred revenue is enabled
-			for item in self.get("items"):
-				if item.enable_deferred_revenue:
-					frappe.throw(
-						_(
-							"Deferred Revenue is enabled for item {0}. You cannot update the invoice after submission."
-						).format(item.item_code)
-					)
+			if needs_repost:
+				for item in self.get("items"):
+					if item.enable_deferred_revenue:
+						frappe.throw(
+							_(
+								"Deferred Revenue is enabled for item {0}. You cannot update the invoice after submission."
+							).format(item.item_code)
+						)
 
 			self.db_set("repost_required", needs_repost)
 
@@ -1186,11 +1185,24 @@ 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)
-							reset_depreciation_schedule(asset, self.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()
 
 					else:
 						if asset.calculate_depreciation:
-							depreciate_asset(asset, self.posting_date)
+							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)
 							asset.reload()
 
 						fixed_asset_gl_entries = get_gl_entries_on_asset_disposal(

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -21,6 +21,9 @@ 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
@@ -1166,46 +1169,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()
 
@@ -2814,7 +2777,7 @@ class TestSalesInvoice(unittest.TestCase):
 			["2021-09-30", 5041.1, 26407.22],
 		]
 
-		for i, schedule in enumerate(asset.schedules):
+		for i, schedule in enumerate(get_depr_schedule(asset.name, "Active")):
 			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)
@@ -2845,7 +2808,7 @@ class TestSalesInvoice(unittest.TestCase):
 
 		expected_values = [["2020-12-31", 30000, 30000], ["2021-12-31", 30000, 60000]]
 
-		for i, schedule in enumerate(asset.schedules):
+		for i, schedule in enumerate(get_depr_schedule(asset.name, "Active")):
 			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)
@@ -2874,7 +2837,7 @@ class TestSalesInvoice(unittest.TestCase):
 			["2025-06-06", 18633.88, 100000.0, False],
 		]
 
-		for i, schedule in enumerate(asset.schedules):
+		for i, schedule in enumerate(get_depr_schedule(asset.name, "Active")):
 			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-10-17 12:51:44.825398",
+ "modified": "2022-12-28 16:17:33.484531",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Item",

erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py

@@ -27,7 +27,7 @@ class SalesTaxesandChargesTemplate(Document):
 	def set_missing_values(self):
 		for data in self.taxes:
 			if data.charge_type == "On Net Total" and flt(data.rate) == 0.0:
-				data.rate = frappe.db.get_value("Account", data.account_head, "tax_rate")
+				data.rate = frappe.get_cached_value("Account", data.account_head, "tax_rate")
 
 
 def valdiate_taxes_and_charges_template(doc):

erpnext/accounts/doctype/subscription/subscription.py

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

erpnext/accounts/doctype/tax_rule/tax_rule.py

@@ -32,7 +32,7 @@ class TaxRule(Document):
 
 	def validate(self):
 		self.validate_tax_template()
-		self.validate_date()
+		self.validate_from_to_dates("from_date", "to_date")
 		self.validate_filters()
 		self.validate_use_for_shopping_cart()
 
@@ -51,10 +51,6 @@ 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

@@ -259,7 +259,9 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 		if tax_deducted:
 			net_total = inv.tax_withholding_net_total
 			if ldc:
-				tax_amount = get_tds_amount_from_ldc(ldc, parties, tax_details, posting_date, net_total)
+				tax_amount = get_tds_amount_from_ldc(
+					ldc, parties, pan_no, tax_details, posting_date, net_total
+				)
 			else:
 				tax_amount = net_total * tax_details.rate / 100 if net_total > 0 else 0
 
@@ -278,7 +280,7 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 			tax_amount = get_tcs_amount(parties, inv, tax_details, vouchers, advance_vouchers)
 
 	if cint(tax_details.round_off_tax_amount):
-		tax_amount = normal_round(tax_amount)
+		tax_amount = round(tax_amount)
 
 	return tax_amount, tax_deducted, tax_deducted_on_advances, voucher_wise_amount
 
@@ -410,26 +412,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 +429,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 +538,7 @@ def get_invoice_total_without_tcs(inv, tax_details):
 	return inv.grand_total - tcs_tax_row_amount
 
 
-def get_tds_amount_from_ldc(ldc, parties, tax_details, posting_date, net_total):
+def get_tds_amount_from_ldc(ldc, parties, pan_no, tax_details, posting_date, net_total):
 	tds_amount = 0
 	limit_consumed = frappe.db.get_value(
 		"Purchase Invoice",
@@ -603,20 +577,3 @@ def is_valid_certificate(
 		valid = True
 
 	return valid
-
-
-def normal_round(number):
-	"""
-	Rounds a number to the nearest integer.
-	:param number: The number to round.
-	"""
-	decimal_part = number - int(number)
-
-	if decimal_part >= 0.5:
-		decimal_part = 1
-	else:
-		decimal_part = 0
-
-	number = int(number) + decimal_part
-
-	return number

erpnext/accounts/doctype/tax_withholding_category/test_tax_withholding_category.py

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

erpnext/accounts/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)
@@ -302,7 +296,7 @@ def get_default_price_list(party):
 		return party.default_price_list
 
 	if party.doctype == "Customer":
-		return frappe.db.get_value("Customer Group", party.customer_group, "default_price_list")
+		return frappe.get_cached_value("Customer Group", party.customer_group, "default_price_list")
 
 
 def set_price_list(party_details, party, party_type, given_price_list, pos=None):
@@ -391,7 +385,7 @@ def get_party_account(party_type, party=None, company=None):
 	existing_gle_currency = get_party_gle_currency(party_type, party, company)
 	if existing_gle_currency:
 		if account:
-			account_currency = frappe.db.get_value("Account", account, "account_currency", cache=True)
+			account_currency = frappe.get_cached_value("Account", account, "account_currency")
 		if (account and account_currency != existing_gle_currency) or not account:
 			account = get_party_gle_account(party_type, party, company)
 
@@ -408,7 +402,7 @@ def get_party_bank_account(party_type, party):
 def get_party_account_currency(party_type, party, company):
 	def generator():
 		party_account = get_party_account(party_type, party, company)
-		return frappe.db.get_value("Account", party_account, "account_currency", cache=True)
+		return frappe.get_cached_value("Account", party_account, "account_currency")
 
 	return frappe.local_cache("party_account_currency", (party_type, party, company), generator)
 
@@ -480,15 +474,15 @@ def validate_party_accounts(doc):
 		else:
 			companies.append(account.company)
 
-		party_account_currency = frappe.db.get_value(
-			"Account", account.account, "account_currency", cache=True
-		)
+		party_account_currency = frappe.get_cached_value("Account", account.account, "account_currency")
 		if frappe.db.get_default("Company"):
 			company_default_currency = frappe.get_cached_value(
 				"Company", frappe.db.get_default("Company"), "default_currency"
 			)
 		else:
-			company_default_currency = frappe.db.get_value("Company", account.company, "default_currency")
+			company_default_currency = frappe.get_cached_value(
+				"Company", account.company, "default_currency"
+			)
 
 		validate_party_gle_currency(doc.doctype, doc.name, account.company, party_account_currency)
 
@@ -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
 
 
@@ -807,7 +801,7 @@ def get_dashboard_info(party_type, party, loyalty_program=None):
 	)
 
 	for d in companies:
-		company_default_currency = frappe.db.get_value("Company", d.company, "default_currency")
+		company_default_currency = frappe.get_cached_value("Company", d.company, "default_currency")
 		party_account_currency = get_party_account_currency(party_type, party, d.company)
 
 		if party_account_currency == company_default_currency:

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, `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,
-				   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, `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,

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py

@@ -21,7 +21,7 @@ def execute(filters=None):
 	if not filters.get("account"):
 		return columns, []
 
-	account_currency = frappe.db.get_value("Account", filters.account, "account_currency")
+	account_currency = frappe.get_cached_value("Account", filters.account, "account_currency")
 
 	data = get_entries(filters)
 

erpnext/accounts/report/cash_flow/cash_flow.py

@@ -182,7 +182,7 @@ def get_account_type_based_gl_data(company, filters=None):
 	filters = frappe._dict(filters or {})
 
 	if filters.include_default_book_entries:
-		company_fb = frappe.db.get_value("Company", company, "default_finance_book")
+		company_fb = frappe.get_cached_value("Company", company, "default_finance_book")
 		cond = """ AND (finance_book in (%s, %s, '') OR finance_book IS NULL)
 			""" % (
 			frappe.db.escape(filters.finance_book),

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py

@@ -644,7 +644,7 @@ def set_gl_entries_by_account(
 				"rgt": root_rgt,
 				"company": d.name,
 				"finance_book": filters.get("finance_book"),
-				"company_fb": frappe.db.get_value("Company", d.name, "default_finance_book"),
+				"company_fb": frappe.get_cached_value("Company", d.name, "default_finance_book"),
 			},
 			as_dict=True,
 		)

erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py

@@ -292,8 +292,8 @@ class PartyLedgerSummaryReport(object):
 
 		if self.filters.party_type == "Customer":
 			if self.filters.get("customer_group"):
-				lft, rgt = frappe.db.get_value(
-					"Customer Group", self.filters.get("customer_group"), ["lft", "rgt"]
+				lft, rgt = frappe.get_cached_value(
+					"Customer Group", self.filters["customer_group"], ["lft", "rgt"]
 				)
 
 				conditions.append(

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/dimension_wise_accounts_balance_report/dimension_wise_accounts_balance_report.py

@@ -90,7 +90,7 @@ def set_gl_entries_by_account(dimension_list, filters, account, gl_entries_by_ac
 	gl_filters["dimensions"] = set(dimension_list)
 
 	if filters.get("include_default_book_entries"):
-		gl_filters["company_fb"] = frappe.db.get_value(
+		gl_filters["company_fb"] = frappe.get_cached_value(
 			"Company", filters.company, "default_finance_book"
 		)
 

erpnext/accounts/report/financial_statements.py

@@ -440,7 +440,7 @@ def set_gl_entries_by_account(
 		}
 
 		if filters.get("include_default_book_entries"):
-			gl_filters["company_fb"] = frappe.db.get_value("Company", company, "default_finance_book")
+			gl_filters["company_fb"] = frappe.get_cached_value("Company", company, "default_finance_book")
 
 		for key, value in filters.items():
 			if value:

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

@@ -174,7 +174,7 @@ def get_gl_entries(filters, accounting_dimensions):
 		order_by_statement = "order by account, posting_date, creation"
 
 	if filters.get("include_default_book_entries"):
-		filters["company_fb"] = frappe.db.get_value(
+		filters["company_fb"] = frappe.get_cached_value(
 			"Company", filters.get("company"), "default_finance_book"
 		)
 
@@ -286,9 +286,11 @@ def get_accounts_with_children(accounts):
 
 	all_accounts = []
 	for d in accounts:
-		if frappe.db.exists("Account", d):
-			lft, rgt = frappe.db.get_value("Account", d, ["lft", "rgt"])
-			children = frappe.get_all("Account", filters={"lft": [">=", lft], "rgt": ["<=", rgt]})
+		account = frappe.get_cached_doc("Account", d)
+		if account:
+			children = frappe.get_all(
+				"Account", filters={"lft": [">=", account.lft], "rgt": ["<=", account.rgt]}
+			)
 			all_accounts += [c.name for c in children]
 		else:
 			frappe.throw(_("Account: {0} does not exist").format(d))
@@ -524,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",
@@ -536,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/gross_profit/gross_profit.py

@@ -515,7 +515,7 @@ class GrossProfitGenerator(object):
 						invoice_portion = 100
 					elif row.invoice_portion:
 						invoice_portion = row.invoice_portion
-					else:
+					elif row.payment_amount:
 						invoice_portion = row.payment_amount * 100 / row.base_net_amount
 
 					if i == 0:
@@ -655,35 +655,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
@@ -785,8 +760,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,

erpnext/accounts/report/gross_profit/test_gross_profit.py

@@ -302,82 +302,3 @@ class TestGrossProfit(FrappeTestCase):
 
 		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/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/trial_balance/trial_balance.py

@@ -38,7 +38,7 @@ def validate_filters(filters):
 	if not filters.fiscal_year:
 		frappe.throw(_("Fiscal Year {0} is required").format(filters.fiscal_year))
 
-	fiscal_year = frappe.db.get_value(
+	fiscal_year = frappe.get_cached_value(
 		"Fiscal Year", filters.fiscal_year, ["year_start_date", "year_end_date"], as_dict=True
 	)
 	if not fiscal_year:
@@ -177,7 +177,7 @@ def get_rootwise_opening_balances(filters, report_type):
 		"year_start_date": filters.year_start_date,
 		"project": filters.project,
 		"finance_book": filters.finance_book,
-		"company_fb": frappe.db.get_value("Company", filters.company, "default_finance_book"),
+		"company_fb": frappe.get_cached_value("Company", filters.company, "default_finance_book"),
 	}
 
 	if accounting_dimensions:

erpnext/accounts/test/test_utils.py

@@ -3,11 +3,14 @@ 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
@@ -73,6 +76,47 @@ 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,11 +611,6 @@ 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,
@@ -638,6 +622,11 @@ 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)
 
@@ -988,7 +977,7 @@ def get_account_balances(accounts, company):
 def create_payment_gateway_account(gateway, payment_channel="Email"):
 	from erpnext.setup.setup_wizard.operations.install_fixtures import create_bank_account
 
-	company = frappe.db.get_value("Global Defaults", None, "default_company")
+	company = frappe.get_cached_value("Global Defaults", "Global Defaults", "default_company")
 	if not company:
 		return
 
@@ -1512,12 +1501,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)

erpnext/assets/doctype/asset/asset.js

@@ -76,7 +76,6 @@ 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)) {
@@ -136,10 +135,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");
 		}
 
@@ -150,19 +145,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);
@@ -210,53 +192,51 @@ frappe.ui.form.on('Asset', {
 			return
 		}
 
-		var x_intervals = [frappe.format(frm.doc.purchase_date, { fieldtype: 'Date' })];
+		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);
 
-			$.each(frm.doc.schedules || [], 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(flt(last_asset_value - v.value, precision('gross_purchase_amount')));
-			});
+			x_intervals.push(last_depreciation_date);
+			asset_values.push(flt(frm.doc.gross_purchase_amount) -
+				flt(frm.doc.opening_accumulated_depreciation));
 		}
 
+		let depr_schedule = [];
+
+		if (frm.doc.finance_books.length == 1) {
+			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(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({
@@ -302,21 +282,6 @@ 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: {
@@ -512,7 +477,6 @@ 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) {
@@ -548,41 +512,6 @@ 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,8 +52,6 @@
   "column_break_24",
   "frequency_of_depreciation",
   "next_depreciation_date",
-  "section_break_14",
-  "schedules",
   "insurance_details",
   "policy_number",
   "insurer",
@@ -70,7 +68,6 @@
   "column_break_51",
   "purchase_receipt_amount",
   "default_finance_book",
-  "depr_entry_posting_status",
   "amended_from"
  ],
  "fields": [
@@ -308,19 +305,6 @@
    "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",
@@ -489,16 +473,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,
@@ -513,7 +487,7 @@
   {
    "group": "Repair",
    "link_doctype": "Asset Repair",
-   "link_fieldname": "asset"
+   "link_fieldname": "asset_name"
   },
   {
    "group": "Value",
@@ -521,13 +495,12 @@
    "link_fieldname": "asset"
   },
   {
-   "group": "Journal Entry",
-   "link_doctype": "Journal Entry",
-   "link_fieldname": "reference_name",
-   "table_fieldname": "accounts"
+   "group": "Depreciation",
+   "link_doctype": "Asset Depreciation Schedule",
+   "link_fieldname": "asset"
   }
  ],
- "modified": "2023-01-25 17:45:48.649543",
+ "modified": "2022-11-25 12:47:19.689702",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset",

erpnext/assets/doctype/asset/asset.py

@@ -8,14 +8,15 @@ 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,
@@ -26,9 +27,18 @@ from erpnext.accounts.general_ledger import make_reverse_gl_entries
 from erpnext.assets.doctype.asset.depreciation import (
 	get_depreciation_accounts,
 	get_disposal_account_and_cost_center,
-	is_last_day_of_the_month,
 )
 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,
+	set_draft_asset_depr_schedule_details,
+	update_draft_asset_depr_schedules,
+)
 from erpnext.controllers.accounts_controller import AccountsController
 
 
@@ -41,9 +51,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()
-		if self.get("schedules"):
-			self.validate_expected_value_after_useful_life()
+		self.validate_expected_value_after_useful_life()
 
 		self.status = self.get_status()
 
@@ -53,16 +63,24 @@ 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"
@@ -80,12 +98,10 @@ class Asset(AccountsController):
 				_("Purchase Invoice cannot be made against an existing asset {0}").format(self.name)
 			)
 
-	def prepare_depreciation_data(self, date_of_disposal=None, date_of_return=None):
+	def prepare_depreciation_data(self):
 		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(
@@ -224,160 +240,8 @@ 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)
-
-		if len(self.get("finance_books")) > 1 and any(start):
-			self.sort_depreciation_schedule()
-
-	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_for_making_schedule(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 sort_depreciation_schedule(self):
-		self.schedules = sorted(
-			self.schedules, key=lambda s: (int(s.finance_book_id), getdate(s.schedule_date))
-		)
-
-		for idx, s in enumerate(self.schedules, 1):
-			s.idx = idx
-
-	def _get_value_after_depreciation_for_making_schedule(self, finance_book):
+	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:
@@ -387,58 +251,6 @@ class Asset(AccountsController):
 
 		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
@@ -523,82 +335,15 @@ class Asset(AccountsController):
 				).format(row.idx)
 			)
 
-	# 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 (
-				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_disposal=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("finance_books")[cint(d.finance_book_id) - 1].value_after_depreciation
-				)
-				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_disposal
-				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 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)
+
+			if not depr_schedule:
+				continue
+
 			accumulated_depreciation_after_full_schedule = [
-				d.accumulated_depreciation_amount
-				for d in self.get("schedules")
-				if cint(d.finance_book_id) == row.idx
+				d.accumulated_depreciation_amount for d in depr_schedule
 			]
 
 			if accumulated_depreciation_after_full_schedule:
@@ -647,20 +392,18 @@ class Asset(AccountsController):
 			movement.cancel()
 
 	def delete_depreciation_entries(self):
-		if self.calculate_depreciation:
-			for d in self.get("schedules"):
+		for row in self.get("finance_books"):
+			depr_schedule = get_depr_schedule(self.name, "Active", row.finance_book)
+
+			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()
+					d.db_set("journal_entry", None)
 
-			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"""
@@ -677,15 +420,11 @@ class Asset(AccountsController):
 
 			if self.journal_entry_for_scrap:
 				status = "Scrapped"
-			else:
-				expected_value_after_useful_life = 0
-				value_after_depreciation = self.value_after_depreciation
+			elif self.finance_books:
+				idx = self.get_default_finance_book_idx() or 0
 
-				if self.calculate_depreciation:
-					idx = self.get_default_finance_book_idx() or 0
-
-					expected_value_after_useful_life = self.finance_books[idx].expected_value_after_useful_life
-					value_after_depreciation = self.finance_books[idx].value_after_depreciation
+				expected_value_after_useful_life = self.finance_books[idx].expected_value_after_useful_life
+				value_after_depreciation = self.finance_books[idx].value_after_depreciation
 
 				if flt(value_after_depreciation) <= expected_value_after_useful_life:
 					status = "Fully Depreciated"
@@ -695,19 +434,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)
@@ -833,25 +559,6 @@ class Asset(AccountsController):
 			make_gl_entries(gl_entries)
 			self.db_set("booked_fixed_asset", 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)
-			.orderby(gle.creation)
-		).run(as_dict=True)
-
-		return records
-
 	@frappe.whitelist()
 	def get_depreciation_rate(self, args, on_validate=False):
 		if isinstance(args, str):
@@ -896,6 +603,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:
@@ -1048,7 +756,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
@@ -1113,13 +821,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)
 
@@ -1129,26 +830,6 @@ def get_total_days(date, frequency):
 	return date_diff(date, period_start_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)
@@ -1160,12 +841,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)
+	update_existing_asset(asset, remaining_qty, new_asset.name)
 
 	return new_asset
 
 
-def update_existing_asset(asset, remaining_qty):
+def update_existing_asset(asset, remaining_qty, new_asset_name):
 	remaining_gross_purchase_amount = flt(
 		(asset.gross_purchase_amount * remaining_qty) / asset.asset_quantity
 	)
@@ -1183,38 +864,49 @@ def update_existing_asset(asset, remaining_qty):
 		},
 	)
 
-	for finance_book in asset.get("finance_books"):
+	for row in asset.get("finance_books"):
 		value_after_depreciation = flt(
-			(finance_book.value_after_depreciation * remaining_qty) / asset.asset_quantity
+			(row.value_after_depreciation * remaining_qty) / asset.asset_quantity
 		)
 		expected_value_after_useful_life = flt(
-			(finance_book.expected_value_after_useful_life * remaining_qty) / asset.asset_quantity
+			(row.expected_value_after_useful_life * remaining_qty) / asset.asset_quantity
 		)
 		frappe.db.set_value(
-			"Asset Finance Book", finance_book.name, "value_after_depreciation", value_after_depreciation
+			"Asset Finance Book", row.name, "value_after_depreciation", value_after_depreciation
 		)
 		frappe.db.set_value(
 			"Asset Finance Book",
-			finance_book.name,
+			row.name,
 			"expected_value_after_useful_life",
 			expected_value_after_useful_life,
 		)
 
-	processed_finance_books = []
-
-	for term in asset.get("schedules"):
-		if int(term.finance_book_id) not in processed_finance_books:
-			accumulated_depreciation = 0
-			processed_finance_books.append(int(term.finance_book_id))
-
-		depreciation_amount = flt((term.depreciation_amount * remaining_qty) / asset.asset_quantity)
-		frappe.db.set_value(
-			"Depreciation Schedule", term.name, "depreciation_amount", depreciation_amount
+		current_asset_depr_schedule_doc = get_asset_depr_schedule_doc(
+			asset.name, "Active", row.finance_book
 		)
-		accumulated_depreciation += depreciation_amount
-		frappe.db.set_value(
-			"Depreciation Schedule", term.name, "accumulated_depreciation_amount", accumulated_depreciation
+		new_asset_depr_schedule_doc = frappe.copy_doc(current_asset_depr_schedule_doc)
+
+		set_draft_asset_depr_schedule_details(new_asset_depr_schedule_doc, 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)
 		)
+		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):
@@ -1229,35 +921,48 @@ def create_new_asset_after_split(asset, split_qty):
 	new_asset.asset_quantity = split_qty
 	new_asset.split_from = asset.name
 
-	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
+	for row in new_asset.get("finance_books"):
+		row.value_after_depreciation = flt(
+			(row.value_after_depreciation * 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
+		row.expected_value_after_useful_life = flt(
+			(row.expected_value_after_useful_life * split_qty) / asset.asset_quantity
 		)
 
-	processed_finance_books = []
-
-	for term in new_asset.get("schedules"):
-		if int(term.finance_book_id) not in processed_finance_books:
-			accumulated_depreciation = 0
-			processed_finance_books.append(int(term.finance_book_id))
-
-		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 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
-			)
+	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)
+
+		set_draft_asset_depr_schedule_details(new_asset_depr_schedule_doc, 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
+				)
 
 	return new_asset
 

erpnext/assets/doctype/asset/depreciation.py

@@ -4,17 +4,21 @@
 
 import frappe
 from frappe import _
-from frappe.utils import add_months, cint, flt, get_last_day, getdate, nowdate, today
-from frappe.utils.data import get_link_to_form
-from frappe.utils.user import get_users_with_role
+from frappe.utils import add_months, cint, flt, get_link_to_form, 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")
@@ -23,42 +27,47 @@ def post_depreciation_entries(date=None):
 
 	if not date:
 		date = today()
-
-	failed_asset_names = []
-
 	for asset_name in get_depreciable_assets(date):
-		try:
-			make_depreciation_entry(asset_name, date)
+		asset_doc = frappe.get_doc("Asset", asset_name)
+
+		make_depreciation_entry_for_all_asset_depr_schedules(asset_doc, 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, `tabDepreciation Schedule` ds
-		where a.name = ds.parent and a.docstatus=1 and ds.schedule_date<=%s and a.calculate_depreciation = 1
+		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
 			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_name, date=None):
+def make_depreciation_entry(asset_depr_schedule_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,
@@ -74,14 +83,14 @@ def make_depreciation_entry(asset_name, date=None):
 
 	accounting_dimensions = get_checks_for_pl_and_bs_accounts()
 
-	for d in asset.get("schedules"):
+	for d in asset_depr_schedule_doc.get("depreciation_schedule"):
 		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 = d.finance_book
+			je.finance_book = asset_depr_schedule_doc.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(
@@ -132,16 +141,14 @@ def make_depreciation_entry(asset_name, date=None):
 
 			d.db_set("journal_entry", je.name)
 
-			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.db_set("depr_entry_posting_status", "Successful")
+			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()
 
 	asset.set_status()
 
-	return asset
+	return asset_depr_schedule_doc
 
 
 def get_depreciation_accounts(asset):
@@ -202,42 +209,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)
@@ -251,7 +222,11 @@ def scrap_asset(asset_name):
 
 	date = today()
 
-	depreciate_asset(asset, date)
+	notes = _("This schedule was created when Asset {0} was scrapped.").format(
+		get_link_to_form(asset.doctype, asset.name)
+	)
+
+	depreciate_asset(asset, date, notes)
 	asset.reload()
 
 	depreciation_series = frappe.get_cached_value(
@@ -284,10 +259,15 @@ 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)
 
@@ -296,22 +276,28 @@ def restore_asset(asset_name):
 	asset.set_status()
 
 
-def depreciate_asset(asset, date):
-	asset.flags.ignore_validate_update_after_submit = True
-	asset.prepare_depreciation_data(date_of_disposal=date)
-	asset.save()
+def depreciate_asset(asset_doc, date, notes):
+	asset_doc.flags.ignore_validate_update_after_submit = True
 
-	make_depreciation_entry(asset.name, date)
+	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)
 
 
-def reset_depreciation_schedule(asset, date):
-	asset.flags.ignore_validate_update_after_submit = True
+def reset_depreciation_schedule(asset_doc, date, notes):
+	asset_doc.flags.ignore_validate_update_after_submit = True
 
-	# recreate original depreciation schedule of the asset
-	asset.prepare_depreciation_data(date_of_return=date)
+	make_new_active_asset_depr_schedules_and_cancel_current_ones(
+		asset_doc, notes, date_of_return=date
+	)
 
-	modify_depreciation_schedule_for_asset_repairs(asset)
-	asset.save()
+	modify_depreciation_schedule_for_asset_repairs(asset_doc)
+
+	asset_doc.save()
 
 
 def modify_depreciation_schedule_for_asset_repairs(asset):
@@ -323,38 +309,36 @@ def modify_depreciation_schedule_for_asset_repairs(asset):
 		if repair.increase_in_asset_life:
 			asset_repair = frappe.get_doc("Asset Repair", repair.name)
 			asset_repair.modify_depreciation_schedule()
-			asset.prepare_depreciation_data()
+			notes = _("This schedule was created when Asset {0} went through Asset Repair {1}.").format(
+				get_link_to_form(asset.doctype, asset.name),
+				get_link_to_form(asset_repair.doctype, asset_repair.name),
+			)
+			make_new_active_asset_depr_schedules_and_cancel_current_ones(asset, notes)
 
 
 def reverse_depreciation_entry_made_after_disposal(asset, date):
-	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 row in asset.get("finance_books"):
+		asset_depr_schedule_doc = get_asset_depr_schedule_doc(asset.name, "Active", row.finance_book)
 
-		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):
+		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):
 
-				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.flags.ignore_validate_update_after_submit = True
-				schedule.journal_entry = None
-				depreciation_amount = get_depreciation_amount_in_je(reverse_journal_entry)
-
-				idx = cint(schedule.finance_book_id)
-				asset.finance_books[idx - 1].value_after_depreciation += depreciation_amount
-
-				asset.save()
+					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()
 
 
 def get_depreciation_amount_in_je(journal_entry):
@@ -365,18 +349,14 @@ 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(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)
-			)
+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(finance_book.depreciation_start_date):
-				orginal_schedule_date = get_last_day(orginal_schedule_date)
+	if orginal_schedule_date == posting_date_of_disposal:
+		return True
 
-			if orginal_schedule_date == posting_date_of_disposal:
-				return True
 	return False
 
 
@@ -494,8 +474,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 (
@@ -547,30 +537,27 @@ 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 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:
+	if not asset_doc.calculate_depreciation:
 		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
 
-def is_last_day_of_the_month(date):
-	last_day_of_the_month = get_last_day(date)
+	row = asset_doc.finance_books[idx - 1]
 
-	return getdate(last_day_of_the_month) == getdate(date)
+	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

@@ -12,10 +12,10 @@ from frappe.utils import (
 	get_first_day,
 	get_last_day,
 	getdate,
+	is_last_day_of_the_month,
 	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,
@@ -23,11 +23,15 @@ from erpnext.assets.doctype.asset.asset import (
 	update_maintenance_status,
 )
 from erpnext.assets.doctype.asset.depreciation import (
-	is_last_day_of_the_month,
 	post_depreciation_entries,
 	restore_asset,
 	scrap_asset,
 )
+from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
+	clear_depr_schedule,
+	get_asset_depr_schedule_doc,
+	get_depr_schedule,
+)
 from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
 	make_purchase_invoice as make_invoice,
 )
@@ -206,6 +210,9 @@ 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()
 
@@ -217,6 +224,11 @@ 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,
@@ -257,6 +269,11 @@ 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)
@@ -284,6 +301,9 @@ 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")
@@ -295,6 +315,12 @@ 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
 		)
@@ -371,6 +397,9 @@ 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)
@@ -379,21 +408,31 @@ 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(new_asset.schedules[0].depreciation_amount, 4000)
-		self.assertEqual(new_asset.schedules[1].depreciation_amount, 4000)
+		self.assertEqual(depr_schedule_of_new_asset[0].depreciation_amount, 4000)
+		self.assertEqual(depr_schedule_of_new_asset[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(asset.schedules[0].depreciation_amount, 16000)
-		self.assertEqual(asset.schedules[1].depreciation_amount, 16000)
+		self.assertEqual(depr_schedule_of_asset[0].depreciation_amount, 16000)
+		self.assertEqual(depr_schedule_of_asset[1].depreciation_amount, 16000)
 
-		journal_entry = asset.schedules[0].journal_entry
+		journal_entry = depr_schedule_of_asset[0].journal_entry
 
 		jv = frappe.get_doc("Journal Entry", journal_entry)
 		self.assertEqual(jv.accounts[0].credit_in_account_currency, 16000)
@@ -630,7 +669,7 @@ class TestDepreciationMethods(AssetSetup):
 
 		schedules = [
 			[cstr(d.schedule_date), d.depreciation_amount, d.accumulated_depreciation_amount]
-			for d in asset.get("schedules")
+			for d in get_depr_schedule(asset.name, "Draft")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -652,7 +691,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 asset.get("schedules")
+			for d in get_depr_schedule(asset.name, "Draft")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -679,7 +718,7 @@ class TestDepreciationMethods(AssetSetup):
 
 		schedules = [
 			[cstr(d.schedule_date), d.depreciation_amount, d.accumulated_depreciation_amount]
-			for d in asset.get("schedules")
+			for d in get_depr_schedule(asset.name, "Draft")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -704,7 +743,7 @@ class TestDepreciationMethods(AssetSetup):
 
 		schedules = [
 			[cstr(d.schedule_date), d.depreciation_amount, d.accumulated_depreciation_amount]
-			for d in asset.get("schedules")
+			for d in get_depr_schedule(asset.name, "Draft")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -734,7 +773,7 @@ class TestDepreciationMethods(AssetSetup):
 				flt(d.depreciation_amount, 2),
 				flt(d.accumulated_depreciation_amount, 2),
 			]
-			for d in asset.get("schedules")
+			for d in get_depr_schedule(asset.name, "Draft")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -766,7 +805,7 @@ class TestDepreciationMethods(AssetSetup):
 				flt(d.depreciation_amount, 2),
 				flt(d.accumulated_depreciation_amount, 2),
 			]
-			for d in asset.get("schedules")
+			for d in get_depr_schedule(asset.name, "Draft")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -799,7 +838,7 @@ class TestDepreciationMethods(AssetSetup):
 				flt(d.depreciation_amount, 2),
 				flt(d.accumulated_depreciation_amount, 2),
 			]
-			for d in asset.get("schedules")
+			for d in get_depr_schedule(asset.name, "Draft")
 		]
 
 		self.assertEqual(schedules, expected_schedules)
@@ -832,7 +871,7 @@ class TestDepreciationMethods(AssetSetup):
 				flt(d.depreciation_amount, 2),
 				flt(d.accumulated_depreciation_amount, 2),
 			]
-			for d in asset.get("schedules")
+			for d in get_depr_schedule(asset.name, "Draft")
 		]
 		self.assertEqual(schedules, expected_schedules)
 
@@ -855,7 +894,7 @@ class TestDepreciationBasics(AssetSetup):
 			["2022-12-31", 30000, 90000],
 		]
 
-		for i, schedule in enumerate(asset.schedules):
+		for i, schedule in enumerate(get_depr_schedule(asset.name, "Active")):
 			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)
@@ -878,7 +917,7 @@ class TestDepreciationBasics(AssetSetup):
 			["2023-01-01", 15000, 90000],
 		]
 
-		for i, schedule in enumerate(asset.schedules):
+		for i, schedule in enumerate(get_depr_schedule(asset.name, "Active")):
 			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)
@@ -886,7 +925,9 @@ class TestDepreciationBasics(AssetSetup):
 	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
+		from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
+			get_depreciation_amount,
+		)
 
 		asset = create_asset(item_code="Macbook Pro", available_for_use_date="2019-12-31")
 
@@ -905,8 +946,8 @@ class TestDepreciationBasics(AssetSetup):
 		depreciation_amount = get_depreciation_amount(asset, 100000, asset.finance_books[0])
 		self.assertEqual(depreciation_amount, 30000)
 
-	def test_make_depreciation_schedule(self):
-		"""Tests if make_depreciation_schedule() returns the right values."""
+	def test_make_depr_schedule(self):
+		"""Tests if make_depr_schedule() returns the right values."""
 
 		asset = create_asset(
 			item_code="Macbook Pro",
@@ -921,7 +962,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(asset.schedules):
+		for i, schedule in enumerate(get_depr_schedule(asset.name, "Draft")):
 			self.assertEqual(getdate(expected_values[i][0]), schedule.schedule_date)
 			self.assertEqual(expected_values[i][1], schedule.depreciation_amount)
 
@@ -941,7 +982,7 @@ class TestDepreciationBasics(AssetSetup):
 
 		expected_values = [30000.0, 60000.0, 90000.0]
 
-		for i, schedule in enumerate(asset.schedules):
+		for i, schedule in enumerate(get_depr_schedule(asset.name, "Draft")):
 			self.assertEqual(expected_values[i], schedule.accumulated_depreciation_amount)
 
 	def test_check_is_pro_rata(self):
@@ -1121,9 +1162,11 @@ class TestDepreciationBasics(AssetSetup):
 		post_depreciation_entries(date="2021-06-01")
 		asset.load_from_db()
 
-		self.assertTrue(asset.schedules[0].journal_entry)
-		self.assertFalse(asset.schedules[1].journal_entry)
-		self.assertFalse(asset.schedules[2].journal_entry)
+		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)
 
 	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."""
@@ -1142,7 +1185,7 @@ class TestDepreciationBasics(AssetSetup):
 		post_depreciation_entries(date="2021-06-01")
 		asset.load_from_db()
 
-		je = frappe.get_doc("Journal Entry", asset.schedules[0].journal_entry)
+		je = frappe.get_doc("Journal Entry", get_depr_schedule(asset.name, "Active")[0].journal_entry)
 		accounting_entries = [
 			{"account": entry.account, "debit": entry.debit, "credit": entry.credit}
 			for entry in je.accounts
@@ -1178,7 +1221,7 @@ class TestDepreciationBasics(AssetSetup):
 		post_depreciation_entries(date="2021-06-01")
 		asset.load_from_db()
 
-		je = frappe.get_doc("Journal Entry", asset.schedules[0].journal_entry)
+		je = frappe.get_doc("Journal Entry", get_depr_schedule(asset.name, "Active")[0].journal_entry)
 		accounting_entries = [
 			{"account": entry.account, "debit": entry.debit, "credit": entry.credit}
 			for entry in je.accounts
@@ -1197,8 +1240,8 @@ class TestDepreciationBasics(AssetSetup):
 		depr_expense_account.parent_account = "Expenses - _TC"
 		depr_expense_account.save()
 
-	def test_clear_depreciation_schedule(self):
-		"""Tests if clear_depreciation_schedule() works as expected."""
+	def test_clear_depr_schedule(self):
+		"""Tests if clear_depr_schedule() works as expected."""
 
 		asset = create_asset(
 			item_code="Macbook Pro",
@@ -1214,17 +1257,20 @@ class TestDepreciationBasics(AssetSetup):
 		post_depreciation_entries(date="2021-06-01")
 		asset.load_from_db()
 
-		asset.clear_depreciation_schedule()
+		asset_depr_schedule_doc = get_asset_depr_schedule_doc(asset.name, "Active")
 
-		self.assertEqual(len(asset.schedules), 1)
+		clear_depr_schedule(asset_depr_schedule_doc)
 
-	def test_clear_depreciation_schedule_for_multiple_finance_books(self):
+		self.assertEqual(len(asset_depr_schedule_doc.get("depreciation_schedule")), 1)
+
+	def test_clear_depr_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,
@@ -1235,6 +1281,7 @@ 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,
@@ -1245,6 +1292,7 @@ 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,
@@ -1257,15 +1305,23 @@ class TestDepreciationBasics(AssetSetup):
 		post_depreciation_entries(date="2020-04-01")
 		asset.load_from_db()
 
-		asset.clear_depreciation_schedule()
+		asset_depr_schedule_doc_1 = get_asset_depr_schedule_doc(
+			asset.name, "Active", "Test Finance Book 1"
+		)
+		clear_depr_schedule(asset_depr_schedule_doc_1)
+		self.assertEqual(len(asset_depr_schedule_doc_1.get("depreciation_schedule")), 3)
 
-		self.assertEqual(len(asset.schedules), 6)
+		asset_depr_schedule_doc_2 = get_asset_depr_schedule_doc(
+			asset.name, "Active", "Test Finance Book 2"
+		)
+		clear_depr_schedule(asset_depr_schedule_doc_2)
+		self.assertEqual(len(asset_depr_schedule_doc_2.get("depreciation_schedule")), 3)
 
-		for schedule in asset.schedules:
-			if schedule.idx <= 3:
-				self.assertEqual(schedule.finance_book_id, "1")
-			else:
-				self.assertEqual(schedule.finance_book_id, "2")
+		asset_depr_schedule_doc_3 = get_asset_depr_schedule_doc(
+			asset.name, "Active", "Test Finance Book 3"
+		)
+		clear_depr_schedule(asset_depr_schedule_doc_3)
+		self.assertEqual(len(asset_depr_schedule_doc_3.get("depreciation_schedule")), 0)
 
 	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)
@@ -1274,6 +1330,7 @@ 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,
@@ -1284,6 +1341,7 @@ 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,
@@ -1293,13 +1351,15 @@ class TestDepreciationBasics(AssetSetup):
 		)
 		asset.save()
 
-		self.assertEqual(len(asset.schedules), 9)
+		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)
 
-		for schedule in asset.schedules:
-			if schedule.idx <= 3:
-				self.assertEqual(schedule.finance_book_id, 1)
-			else:
-				self.assertEqual(schedule.finance_book_id, 2)
+		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)
 
 	def test_depreciation_entry_cancellation(self):
 		asset = create_asset(
@@ -1319,12 +1379,12 @@ class TestDepreciationBasics(AssetSetup):
 		asset.load_from_db()
 
 		# cancel depreciation entry
-		depr_entry = asset.get("schedules")[0].journal_entry
+		depr_entry = get_depr_schedule(asset.name, "Active")[0].journal_entry
 		self.assertTrue(depr_entry)
+
 		frappe.get_doc("Journal Entry", depr_entry).cancel()
 
-		asset.load_from_db()
-		depr_entry = asset.get("schedules")[0].journal_entry
+		depr_entry = get_depr_schedule(asset.name, "Active")[0].journal_entry
 		self.assertFalse(depr_entry)
 
 	def test_asset_expected_value_after_useful_life(self):
@@ -1339,7 +1399,7 @@ class TestDepreciationBasics(AssetSetup):
 		)
 
 		accumulated_depreciation_after_full_schedule = max(
-			d.accumulated_depreciation_amount for d in asset.get("schedules")
+			d.accumulated_depreciation_amount for d in get_depr_schedule(asset.name, "Draft")
 		)
 
 		asset_value_after_full_schedule = flt(asset.gross_purchase_amount) - flt(
@@ -1370,7 +1430,7 @@ class TestDepreciationBasics(AssetSetup):
 		asset.load_from_db()
 
 		# check depreciation entry series
-		self.assertEqual(asset.get("schedules")[0].journal_entry[:4], "DEPR")
+		self.assertEqual(get_depr_schedule(asset.name, "Active")[0].journal_entry[:4], "DEPR")
 
 		expected_gle = (
 			("_Test Accumulated Depreciations - _TC", 0.0, 30000.0),
@@ -1440,39 +1500,9 @@ class TestDepreciationBasics(AssetSetup):
 			"2020-07-15",
 		]
 
-		for i, schedule in enumerate(asset.schedules):
+		for i, schedule in enumerate(get_depr_schedule(asset.name, "Active")):
 			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"):
@@ -1484,6 +1514,15 @@ 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)
@@ -1510,7 +1549,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,11 +7,10 @@ import frappe
 
 # import erpnext
 from frappe import _
-from frappe.utils import cint, flt
+from frappe.utils import cint, flt, get_link_to_form
 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,
@@ -20,6 +19,12 @@ 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
 from erpnext.setup.doctype.item_group.item_group import get_item_group_defaults
@@ -257,9 +262,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
 				)
@@ -427,7 +430,12 @@ class AssetCapitalization(StockController):
 			asset = self.get_asset(item)
 
 			if asset.calculate_depreciation:
-				depreciate_asset(asset, self.posting_date)
+				notes = _(
+					"This schedule was created when Asset {0} was consumed when Asset Capitalization {1} was submitted."
+				).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)
 				asset.reload()
 
 			fixed_asset_gl_entries = get_gl_entries_on_asset_disposal(
@@ -513,7 +521,12 @@ 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
-			asset_doc.prepare_depreciation_data()
+			notes = _(
+				"This schedule was created when target Asset {0} was updated when Asset Capitalization {1} was submitted."
+			).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.flags.ignore_validate_update_after_submit = True
 			asset_doc.save()
 		elif self.docstatus == 2:
@@ -524,7 +537,12 @@ class AssetCapitalization(StockController):
 
 				if asset.calculate_depreciation:
 					reverse_depreciation_entry_made_after_disposal(asset, self.posting_date)
-					reset_depreciation_schedule(asset, self.posting_date)
+					notes = _(
+						"This schedule was created when Asset {0} was restored when Asset Capitalization {1} was cancelled."
+					).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)
 
 	def get_asset(self, item):
 		asset = frappe.get_doc("Asset", item.asset)
@@ -696,7 +714,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

erpnext/assets/doctype/asset_capitalization/test_asset_capitalization.py

@@ -12,6 +12,9 @@ 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
 
 
@@ -253,6 +256,9 @@ 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",
@@ -282,8 +288,18 @@ 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 consumed_asset.schedules if getdate(d.schedule_date) == getdate(capitalization_date)
+			d
+			for d in depr_schedule_of_consumed_asset
+			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

@@ -0,0 +1,51 @@
+// 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

@@ -0,0 +1,202 @@
+{
+ "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-02 15:38:30.766779",
+ "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": []
+}