chore(release): Bumped to Version 13.36.3

## [13.36.3](https://github.com/frappe/erpnext/compare/v13.36.2...v13.36.3) (2022-08-09)

### Bug Fixes

* (india) HSN wise report ([08c69c7](08c69c7a76))
* add asset repair to accounting dimension list ([809d5ca](809d5caf80))
* consider precision while validating advance amount against sanctioned amount ([63cd434](63cd4349a6))
* **ecommerce:** remove query to non-existing field (backport [#31771](https://github.com/frappe/erpnext/issues/31771)) ([#31774](https://github.com/frappe/erpnext/issues/31774)) ([0e46b33](0e46b33ee3))
* f-string and where clause ([42b3959](42b395916d))
* getting error to show sales invoice group or print rep… (backport [#31756](https://github.com/frappe/erpnext/issues/31756)) ([#31768](https://github.com/frappe/erpnext/issues/31768)) ([473a43b](473a43b6b1))
* incorrect incoming rate set for inter transfer purchase receipt ([4e8b39a](4e8b39ab3f))
* incorrect tax calculation in case of reduced payment days ([80981d0](80981d025f))
* intercompany SO throws exception ([a17acfd](a17acfdaa2))
* minor changed link ([e9e53a7](e9e53a74c9))
* Payment Entry button is visible even when claim is fully paid ([d820757](d820757359))
* pending principal- amount ([16c94d2](16c94d292c))
* **pos:** validate product bundles while submitting pos invoice (backport [#31615](https://github.com/frappe/erpnext/issues/31615)) ([#31657](https://github.com/frappe/erpnext/issues/31657)) ([b145fe3](b145fe3b3e))
* specify allowed doctype in queries ([#31765](https://github.com/frappe/erpnext/issues/31765)) ([0dbfb15](0dbfb1589e))
* statistical component showing up in salary slip ([#31746](https://github.com/frappe/erpnext/issues/31746)) ([26aef4f](26aef4fb1c))
* sum stock_value and group by warehouse ([18d93f8](18d93f8398))
* taxable_value and gst_account_heads ([6c574fb](6c574fbf33))
* update To Date in Employee Work History ([#31811](https://github.com/frappe/erpnext/issues/31811)) ([0057c10](0057c10a7d))

.flake8

@@ -31,6 +31,7 @@ ignore =
     E124, # closing bracket, irritating while writing QB code
     E131, # continuation line unaligned for hanging indent
     E123, # closing bracket does not match indentation of opening bracket's line
+    E101, # ensured by use of black
 
 max-line-length = 200
 exclude=.github/helper/semgrep_rules

.github/helper/.flake8_strict

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

.github/helper/install.sh

@@ -2,9 +2,16 @@
 
 set -e
 
+# Check for merge conflicts before proceeding
+python -m compileall -f "${GITHUB_WORKSPACE}"
+if grep -lr --exclude-dir=node_modules "^<<<<<<< " "${GITHUB_WORKSPACE}"
+    then echo "Found merge conflicts"
+    exit 1
+fi
+
 cd ~ || exit
 
-sudo apt-get install redis-server libcups2-dev
+sudo apt update && sudo apt install redis-server libcups2-dev
 
 pip install frappe-bench
 

.github/workflows/release.yml

@@ -0,0 +1,31 @@
+name: Generate Semantic Release
+on:
+  push:
+    branches:
+      - version-13
+jobs:
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Entire Repository
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Setup Node.js v14
+        uses: actions/setup-node@v2
+        with:
+          node-version: 14
+      - name: Setup dependencies
+        run: |
+          npm install @semantic-release/git @semantic-release/exec --no-save
+      - name: Create Release
+        env:
+          GH_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+          GIT_AUTHOR_NAME: "Frappe PR Bot"
+          GIT_AUTHOR_EMAIL: "developers@frappe.io"
+          GIT_COMMITTER_NAME: "Frappe PR Bot"
+          GIT_COMMITTER_EMAIL: "developers@frappe.io"
+        run: npx semantic-release

.github/workflows/server-tests.yml

@@ -25,7 +25,7 @@ jobs:
       fail-fast: false
 
       matrix:
-        container: [1, 2, 3]
+        container: [1, 2]
 
     name: Python Unit Tests
 

.github/workflows/ui-tests.yml

@@ -1,117 +0,0 @@
-name: UI
-
-on:
-  pull_request:
-    paths-ignore:
-      - '**.md'
-  workflow_dispatch:
-
-concurrency:
-  group: ui-v13-${{ github.event.number }}
-  cancel-in-progress: true
-
-jobs:
-  test:
-    runs-on: ubuntu-18.04
-    timeout-minutes: 60
-
-    strategy:
-      fail-fast: false
-
-    name: UI Tests (Cypress)
-
-    services:
-      mysql:
-        image: mariadb:10.3
-        env:
-          MYSQL_ALLOW_EMPTY_PASSWORD: YES
-        ports:
-          - 3306:3306
-        options: --health-cmd="mysqladmin ping" --health-interval=5s --health-timeout=2s --health-retries=3
-
-    steps:
-      - name: Clone
-        uses: actions/checkout@v2
-
-      - name: Setup Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: 3.7
-
-      - uses: actions/setup-node@v2
-        with:
-          node-version: 14
-          check-latest: true
-
-      - name: Add to Hosts
-        run: |
-          echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
-
-      - name: Cache pip
-        uses: actions/cache@v2
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-          restore-keys: |
-            ${{ runner.os }}-pip-
-            ${{ runner.os }}-
-
-      - name: Cache node modules
-        uses: actions/cache@v2
-        env:
-          cache-name: cache-node-modules
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
-
-      - name: Get yarn cache directory path
-        id: yarn-cache-dir-path
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - uses: actions/cache@v2
-        id: yarn-cache
-        with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
-
-      - name: Cache cypress binary
-        uses: actions/cache@v2
-        with:
-          path: ~/.cache
-          key: ${{ runner.os }}-cypress-
-          restore-keys: |
-            ${{ runner.os }}-cypress-
-            ${{ runner.os }}-
-
-      - name: Install
-        run: bash ${GITHUB_WORKSPACE}/.github/helper/install.sh
-        env:
-          DB: mariadb
-          TYPE: ui
-
-      - name: Site Setup
-        run: cd ~/frappe-bench/ && bench --site test_site execute erpnext.setup.utils.before_tests
-
-      - name: cypress pre-requisites
-        run: cd ~/frappe-bench/apps/frappe && yarn add cypress-file-upload@^5 @testing-library/cypress@^8 --no-lockfile
-
-
-      - name: Build Assets
-        run: cd ~/frappe-bench/ && bench build
-        env:
-          CI: Yes
-
-      - name: UI Tests
-        run: cd ~/frappe-bench/ && bench --site test_site run-ui-tests erpnext --headless
-        env:
-          CYPRESS_RECORD_KEY: 60a8e3bf-08f5-45b1-9269-2b207d7d30cd
-
-      - name: Show bench console if tests failed
-        if: ${{ failure() }}
-        run: cat ~/frappe-bench/bench_run_logs.txt

.releaserc

@@ -0,0 +1,24 @@
+{
+	"branches": ["version-13"],
+	"plugins": [
+		"@semantic-release/commit-analyzer", {
+			"preset": "angular",
+			"releaseRules": [
+				{"breaking": true, "release": false}
+			]
+		},
+		"@semantic-release/release-notes-generator",
+		[
+			"@semantic-release/exec", {
+				"prepareCmd": 'sed -ir -E "s/\"[0-9]+\.[0-9]+\.[0-9]+\"/\"${nextRelease.version}\"/" erpnext/__init__.py'
+			}
+		],
+		[
+			"@semantic-release/git", {
+				"assets": ["erpnext/__init__.py"],
+				"message": "chore(release): Bumped to Version ${nextRelease.version}\n\n${nextRelease.notes}"
+			}
+		],
+		"@semantic-release/github"
+	]
+}

CODEOWNERS

@@ -3,33 +3,35 @@
 # These owners will be the default owners for everything in
 # the repo. Unless a later match takes precedence,
 
-erpnext/accounts/               @nextchamp-saqib @deepeshgarg007
-erpnext/assets/                 @nextchamp-saqib @deepeshgarg007
+erpnext/accounts/               @nextchamp-saqib @deepeshgarg007 @ruthra-kumar
+erpnext/assets/                 @nextchamp-saqib @deepeshgarg007 @ruthra-kumar
 erpnext/erpnext_integrations/   @nextchamp-saqib
 erpnext/loan_management/        @nextchamp-saqib @deepeshgarg007
-erpnext/regional                @nextchamp-saqib @deepeshgarg007
-erpnext/selling                 @nextchamp-saqib @deepeshgarg007
+erpnext/regional                @nextchamp-saqib @deepeshgarg007 @ruthra-kumar
+erpnext/selling                 @nextchamp-saqib @deepeshgarg007 @ruthra-kumar
 erpnext/support/                @nextchamp-saqib @deepeshgarg007
 pos*                            @nextchamp-saqib
 
-erpnext/buying/                 @marination @rohitwaghchaure @ankush
+erpnext/buying/                 @marination @rohitwaghchaure @s-aga-r
 erpnext/e_commerce/             @marination
-erpnext/maintenance/            @marination @rohitwaghchaure
-erpnext/manufacturing/          @marination @rohitwaghchaure @ankush
+erpnext/maintenance/            @marination @rohitwaghchaure @s-aga-r
+erpnext/manufacturing/          @marination @rohitwaghchaure @s-aga-r
 erpnext/portal/                 @marination
-erpnext/quality_management/     @marination @rohitwaghchaure
+erpnext/quality_management/     @marination @rohitwaghchaure @s-aga-r
 erpnext/shopping_cart/          @marination
-erpnext/stock/                  @marination @rohitwaghchaure @ankush
+erpnext/stock/                  @marination @rohitwaghchaure @s-aga-r
 
-erpnext/crm/                    @ruchamahabal @pateljannat
-erpnext/education/              @ruchamahabal @pateljannat
-erpnext/healthcare/             @ruchamahabal @pateljannat @chillaranand
-erpnext/hr/                     @ruchamahabal @pateljannat
+erpnext/crm/                    @NagariaHussain
+erpnext/education/              @rutwikhdev
+erpnext/healthcare/             @chillaranand
+erpnext/hr/                     @ruchamahabal
 erpnext/non_profit/             @ruchamahabal
-erpnext/payroll                 @ruchamahabal @pateljannat
-erpnext/projects/               @ruchamahabal @pateljannat
+erpnext/payroll                 @ruchamahabal
+erpnext/projects/               @ruchamahabal
 
 erpnext/controllers             @deepeshgarg007 @nextchamp-saqib @rohitwaghchaure @marination
+erpnext/patches/                @deepeshgarg007 @nextchamp-saqib @marination rohitwaghchaure
+erpnext/public/                 @nextchamp-saqib @marination
 
-.github/                        @surajshetty3416 @ankush
-requirements.txt                @gavindsouza
+.github/                        @ankush
+requirements.txt                @gavindsouza @ankush

erpnext/__init__.py

@@ -4,7 +4,8 @@ import frappe
 
 from erpnext.hooks import regional_overrides
 
-__version__ = '13.25.2'
+__version__ = "13.36.3"
+
 
 def get_default_company(user=None):
 	"""Get default company for user"""
@@ -148,6 +149,7 @@ def allow_regional(fn):
 	return caller
 
 
+@frappe.whitelist()
 def get_last_membership(member):
 	"""Returns last membership if exists"""
 	last_membership = frappe.get_all(

erpnext/accounts/deferred_revenue.py

@@ -386,7 +386,6 @@ def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 				doc,
 				credit_account,
 				debit_account,
-				against,
 				amount,
 				base_amount,
 				end_date,
@@ -570,7 +569,6 @@ def book_revenue_via_journal_entry(
 	doc,
 	credit_account,
 	debit_account,
-	against,
 	amount,
 	base_amount,
 	posting_date,
@@ -591,6 +589,7 @@ def book_revenue_via_journal_entry(
 	journal_entry.voucher_type = (
 		"Deferred Revenue" if doc.doctype == "Sales Invoice" else "Deferred Expense"
 	)
+	journal_entry.process_deferred_accounting = deferred_process
 
 	debit_entry = {
 		"account": credit_account,

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -99,7 +99,7 @@ def make_dimension_in_accounting_doctypes(doc, doclist=None):
 			if doctype == "Budget":
 				add_dimension_to_budget_doctype(df.copy(), doc)
 			else:
-				create_custom_field(doctype, df)
+				create_custom_field(doctype, df, ignore_validate=True)
 
 		count += 1
 
@@ -115,7 +115,7 @@ def add_dimension_to_budget_doctype(df, doc):
 		}
 	)
 
-	create_custom_field("Budget", df)
+	create_custom_field("Budget", df, ignore_validate=True)
 
 	property_setter = frappe.db.exists("Property Setter", "Budget-budget_against-options")
 
@@ -205,10 +205,16 @@ def get_doctypes_with_dimensions():
 	return frappe.get_hooks("accounting_dimension_doctypes")
 
 
-def get_accounting_dimensions(as_list=True):
+def get_accounting_dimensions(as_list=True, filters=None):
+
+	if not filters:
+		filters = {"disabled": 0}
+
 	if frappe.flags.accounting_dimensions is None:
 		frappe.flags.accounting_dimensions = frappe.get_all(
-			"Accounting Dimension", fields=["label", "fieldname", "disabled", "document_type"]
+			"Accounting Dimension",
+			fields=["label", "fieldname", "disabled", "document_type"],
+			filters=filters,
 		)
 
 	if as_list:
@@ -228,17 +234,19 @@ def get_checks_for_pl_and_bs_accounts():
 	return dimensions
 
 
-def get_dimension_with_children(doctype, dimension):
+def get_dimension_with_children(doctype, dimensions):
 
-	if isinstance(dimension, list):
-		dimension = dimension[0]
+	if isinstance(dimensions, str):
+		dimensions = [dimensions]
 
 	all_dimensions = []
-	lft, rgt = frappe.db.get_value(doctype, dimension, ["lft", "rgt"])
-	children = frappe.get_all(
-		doctype, filters={"lft": [">=", lft], "rgt": ["<=", rgt]}, order_by="lft"
-	)
-	all_dimensions += [c.name for c in children]
+
+	for dimension in dimensions:
+		lft, rgt = frappe.db.get_value(doctype, dimension, ["lft", "rgt"])
+		children = frappe.get_all(
+			doctype, filters={"lft": [">=", lft], "rgt": ["<=", rgt]}, order_by="lft"
+		)
+		all_dimensions += [c.name for c in children]
 
 	return all_dimensions
 

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -19,6 +19,7 @@
   "book_asset_depreciation_entry_automatically",
   "unlink_advance_payment_on_cancelation_of_order",
   "enable_common_party_accounting",
+  "allow_multi_currency_invoices_against_single_party_account",
   "post_change_gl_entries",
   "enable_discount_accounting",
   "tax_settings_section",
@@ -276,14 +277,21 @@
    "fieldname": "enable_common_party_accounting",
    "fieldtype": "Check",
    "label": "Enable Common Party Accounting"
-  }
+  },
+  {
+    "default": "0",
+    "description": "Enabling this will allow creation of multi-currency invoices against single party account in company currency",
+    "fieldname": "allow_multi_currency_invoices_against_single_party_account",
+    "fieldtype": "Check",
+    "label": "Allow multi-currency invoices against single party account"
+   }
  ],
  "icon": "icon-cog",
  "idx": 1,
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2021-10-11 17:42:36.427699",
+ "modified": "2022-07-11 13:37:50.605141",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -5,7 +5,10 @@
 import frappe
 from frappe import _, msgprint
 from frappe.model.document import Document
-from frappe.utils import flt, fmt_money, getdate, nowdate
+from frappe.query_builder.custom import ConstantColumn
+from frappe.utils import flt, fmt_money, getdate
+
+import erpnext
 
 form_grid_templates = {"journal_entries": "templates/form_grid/bank_reconciliation_grid.html"}
 
@@ -76,6 +79,53 @@ class BankClearance(Document):
 			as_dict=1,
 		)
 
+		loan_disbursement = frappe.qb.DocType("Loan Disbursement")
+
+		loan_disbursements = (
+			frappe.qb.from_(loan_disbursement)
+			.select(
+				ConstantColumn("Loan Disbursement").as_("payment_document"),
+				loan_disbursement.name.as_("payment_entry"),
+				loan_disbursement.disbursed_amount.as_("credit"),
+				ConstantColumn(0).as_("debit"),
+				loan_disbursement.reference_number.as_("cheque_number"),
+				loan_disbursement.reference_date.as_("cheque_date"),
+				loan_disbursement.disbursement_date.as_("posting_date"),
+				loan_disbursement.applicant.as_("against_account"),
+			)
+			.where(loan_disbursement.docstatus == 1)
+			.where(loan_disbursement.disbursement_date >= self.from_date)
+			.where(loan_disbursement.disbursement_date <= self.to_date)
+			.where(loan_disbursement.clearance_date.isnull())
+			.where(loan_disbursement.disbursement_account.isin([self.bank_account, self.account]))
+			.orderby(loan_disbursement.disbursement_date)
+			.orderby(loan_disbursement.name, frappe.qb.desc)
+		).run(as_dict=1)
+
+		loan_repayment = frappe.qb.DocType("Loan Repayment")
+
+		loan_repayments = (
+			frappe.qb.from_(loan_repayment)
+			.select(
+				ConstantColumn("Loan Repayment").as_("payment_document"),
+				loan_repayment.name.as_("payment_entry"),
+				loan_repayment.amount_paid.as_("debit"),
+				ConstantColumn(0).as_("credit"),
+				loan_repayment.reference_number.as_("cheque_number"),
+				loan_repayment.reference_date.as_("cheque_date"),
+				loan_repayment.applicant.as_("against_account"),
+				loan_repayment.posting_date,
+			)
+			.where(loan_repayment.docstatus == 1)
+			.where(loan_repayment.clearance_date.isnull())
+			.where(loan_repayment.repay_from_salary == 0)
+			.where(loan_repayment.posting_date >= self.from_date)
+			.where(loan_repayment.posting_date <= self.to_date)
+			.where(loan_repayment.payment_account.isin([self.bank_account, self.account]))
+			.orderby(loan_repayment.posting_date)
+			.orderby(loan_repayment.name, frappe.qb.desc)
+		).run(as_dict=1)
+
 		pos_sales_invoices, pos_purchase_invoices = [], []
 		if self.include_pos_transactions:
 			pos_sales_invoices = frappe.db.sql(
@@ -114,20 +164,29 @@ class BankClearance(Document):
 
 		entries = sorted(
 			list(payment_entries)
-			+ list(journal_entries + list(pos_sales_invoices) + list(pos_purchase_invoices)),
-			key=lambda k: k["posting_date"] or getdate(nowdate()),
+			+ list(journal_entries)
+			+ list(pos_sales_invoices)
+			+ list(pos_purchase_invoices)
+			+ list(loan_disbursements)
+			+ list(loan_repayments),
+			key=lambda k: getdate(k["posting_date"]),
 		)
 
 		self.set("payment_entries", [])
 		self.total_amount = 0.0
+		default_currency = erpnext.get_default_currency()
 
 		for d in entries:
 			row = self.append("payment_entries", {})
 
 			amount = flt(d.get("debit", 0)) - flt(d.get("credit", 0))
 
+			if not d.get("account_currency"):
+				d.account_currency = default_currency
+
 			formatted_amount = fmt_money(abs(amount), 2, d.account_currency)
 			d.amount = formatted_amount + " " + (_("Dr") if amount > 0 else _("Cr"))
+			d.posting_date = getdate(d.posting_date)
 
 			d.pop("credit")
 			d.pop("debit")

erpnext/accounts/doctype/bank_clearance/test_bank_clearance.py

@@ -1,9 +1,96 @@
 # Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
 import unittest
 
+import frappe
+from frappe.utils import add_months, getdate
+
+from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
+from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
+from erpnext.loan_management.doctype.loan.test_loan import (
+	create_loan,
+	create_loan_accounts,
+	create_loan_type,
+	create_repayment_entry,
+	make_loan_disbursement_entry,
+)
+
 
 class TestBankClearance(unittest.TestCase):
-	pass
+	@classmethod
+	def setUpClass(cls):
+		make_bank_account()
+		create_loan_accounts()
+		create_loan_masters()
+		add_transactions()
+
+	# Basic test case to test if bank clearance tool doesn't break
+	# Detailed test can be added later
+	def test_bank_clearance(self):
+		bank_clearance = frappe.get_doc("Bank Clearance")
+		bank_clearance.account = "_Test Bank Clearance - _TC"
+		bank_clearance.from_date = add_months(getdate(), -1)
+		bank_clearance.to_date = getdate()
+		bank_clearance.get_payment_entries()
+		self.assertEqual(len(bank_clearance.payment_entries), 3)
+
+
+def make_bank_account():
+	if not frappe.db.get_value("Account", "_Test Bank Clearance - _TC"):
+		frappe.get_doc(
+			{
+				"doctype": "Account",
+				"account_type": "Bank",
+				"account_name": "_Test Bank Clearance",
+				"company": "_Test Company",
+				"parent_account": "Bank Accounts - _TC",
+			}
+		).insert()
+
+
+def create_loan_masters():
+	create_loan_type(
+		"Clearance Loan",
+		2000000,
+		13.5,
+		25,
+		0,
+		5,
+		"Cash",
+		"_Test Bank Clearance - _TC",
+		"_Test Bank Clearance - _TC",
+		"Loan Account - _TC",
+		"Interest Income Account - _TC",
+		"Penalty Income Account - _TC",
+	)
+
+
+def add_transactions():
+	make_payment_entry()
+	make_loan()
+
+
+def make_loan():
+	loan = create_loan(
+		"_Test Customer",
+		"Clearance Loan",
+		280000,
+		"Repay Over Number of Periods",
+		20,
+		applicant_type="Customer",
+	)
+	loan.submit()
+	make_loan_disbursement_entry(loan.name, loan.loan_amount, disbursement_date=getdate())
+	repayment_entry = create_repayment_entry(loan.name, "_Test Customer", getdate(), loan.loan_amount)
+	repayment_entry.save()
+	repayment_entry.submit()
+
+
+def make_payment_entry():
+	pi = make_purchase_invoice(supplier="_Test Supplier", qty=1, rate=690)
+	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank Clearance - _TC")
+	pe.reference_no = "Conrad Oct 18"
+	pe.reference_date = "2018-10-24"
+	pe.insert()
+	pe.submit()

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -467,6 +467,7 @@ def get_lr_matching_query(bank_account, amount_condition, filters):
 			loan_repayment.posting_date,
 		)
 		.where(loan_repayment.docstatus == 1)
+		.where(loan_repayment.repay_from_salary == 0)
 		.where(loan_repayment.clearance_date.isnull())
 		.where(loan_repayment.payment_account == bank_account)
 	)

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -43,7 +43,7 @@ class GLEntry(Document):
 		self.validate_and_set_fiscal_year()
 		self.pl_must_have_cost_center()
 
-		if not self.flags.from_repost:
+		if not self.flags.from_repost and self.voucher_type != "Period Closing Voucher":
 			self.check_mandatory()
 			self.validate_cost_center()
 			self.check_pl_account()
@@ -52,7 +52,7 @@ class GLEntry(Document):
 
 	def on_update(self):
 		adv_adj = self.flags.adv_adj
-		if not self.flags.from_repost:
+		if not self.flags.from_repost and self.voucher_type != "Period Closing Voucher":
 			self.validate_account_details(adv_adj)
 			self.validate_dimensions_for_pl_and_bs()
 			self.validate_allowed_dimensions()

erpnext/accounts/doctype/gst_account/gst_account.json

@@ -10,6 +10,7 @@
   "sgst_account",
   "igst_account",
   "cess_account",
+  "utgst_account",
   "is_reverse_charge_account"
  ],
  "fields": [
@@ -64,12 +65,18 @@
    "fieldtype": "Check",
    "in_list_view": 1,
    "label": "Is Reverse Charge Account"
+  },
+  {
+   "fieldname": "utgst_account",
+   "fieldtype": "Link",
+   "label": "UTGST Account",
+   "options": "Account"
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2021-04-09 12:30:25.889993",
+ "modified": "2022-04-07 12:59:14.039768",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "GST Account",
@@ -78,5 +85,6 @@
  "quick_entry": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
+ "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -149,22 +149,6 @@ frappe.ui.form.on("Journal Entry", {
 					}
 				});
 			}
-			else if(frm.doc.voucher_type=="Opening Entry") {
-				return frappe.call({
-					type:"GET",
-					method: "erpnext.accounts.doctype.journal_entry.journal_entry.get_opening_accounts",
-					args: {
-						"company": frm.doc.company
-					},
-					callback: function(r) {
-						frappe.model.clear_table(frm.doc, "accounts");
-						if(r.message) {
-							update_jv_details(frm.doc, r.message);
-						}
-						cur_frm.set_value("is_opening", "Yes");
-					}
-				});
-			}
 		}
 	},
 

erpnext/accounts/doctype/journal_entry/journal_entry.json

@@ -3,7 +3,7 @@
  "allow_auto_repeat": 1,
  "allow_import": 1,
  "autoname": "naming_series:",
- "creation": "2013-03-25 10:53:52",
+ "creation": "2022-01-25 10:29:58.717206",
  "doctype": "DocType",
  "document_type": "Document",
  "engine": "InnoDB",
@@ -13,6 +13,7 @@
   "voucher_type",
   "naming_series",
   "finance_book",
+  "process_deferred_accounting",
   "reversal_of",
   "tax_withholding_category",
   "column_break1",
@@ -136,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",
@@ -524,13 +526,20 @@
    "label": "Reversal Of",
    "options": "Journal Entry",
    "read_only": 1
+  },
+  {
+   "fieldname": "process_deferred_accounting",
+   "fieldtype": "Link",
+   "label": "Process Deferred Accounting",
+   "options": "Process Deferred Accounting",
+   "read_only": 1
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 176,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-01-04 13:39:36.485954",
+ "modified": "2022-06-23 22:01:32.348337",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry",
@@ -578,6 +587,7 @@
  "search_fields": "voucher_type,posting_date, due_date, cheque_no",
  "sort_field": "modified",
  "sort_order": "DESC",
+ "states": [],
  "title_field": "title",
  "track_changes": 1
 }

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -19,14 +19,16 @@ from erpnext.accounts.doctype.tax_withholding_category.tax_withholding_category
 )
 from erpnext.accounts.party import get_party_account
 from erpnext.accounts.utils import (
-	check_if_stock_and_account_balance_synced,
 	get_account_currency,
 	get_balance_on,
 	get_stock_accounts,
 	get_stock_and_account_balance,
 )
 from erpnext.controllers.accounts_controller import AccountsController
-from erpnext.hr.doctype.expense_claim.expense_claim import update_reimbursed_amount
+from erpnext.hr.doctype.expense_claim.expense_claim import (
+	get_outstanding_amount_for_claim,
+	update_reimbursed_amount,
+)
 
 
 class StockAccountInvalidTransaction(frappe.ValidationError):
@@ -88,9 +90,6 @@ class JournalEntry(AccountsController):
 		self.update_expense_claim()
 		self.update_inter_company_jv()
 		self.update_invoice_discounting()
-		check_if_stock_and_account_balance_synced(
-			self.posting_date, self.company, self.doctype, self.name
-		)
 
 	def on_cancel(self):
 		from erpnext.accounts.utils import unlink_ref_doc_from_payment_entries
@@ -939,15 +938,12 @@ class JournalEntry(AccountsController):
 	def validate_expense_claim(self):
 		for d in self.accounts:
 			if d.reference_type == "Expense Claim":
-				sanctioned_amount, reimbursed_amount = frappe.db.get_value(
-					"Expense Claim", d.reference_name, ("total_sanctioned_amount", "total_amount_reimbursed")
-				)
-				pending_amount = flt(sanctioned_amount) - flt(reimbursed_amount)
-				if d.debit > pending_amount:
+				outstanding_amt = get_outstanding_amount_for_claim(d.reference_name)
+				if d.debit > outstanding_amt:
 					frappe.throw(
 						_(
-							"Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2}"
-						).format(d.idx, d.reference_name, pending_amount)
+							"Row No {0}: Amount cannot be greater than the Outstanding Amount against Expense Claim {1}. Outstanding Amount is {2}"
+						).format(d.idx, d.reference_name, outstanding_amt)
 					)
 
 	def validate_credit_debit_note(self):
@@ -1196,24 +1192,6 @@ def get_payment_entry(ref_doc, args):
 	return je if args.get("journal_entry") else je.as_dict()
 
 
-@frappe.whitelist()
-def get_opening_accounts(company):
-	"""get all balance sheet accounts for opening entry"""
-	accounts = frappe.db.sql_list(
-		"""select
-			name from tabAccount
-		where
-			is_group=0 and report_type='Balance Sheet' and company={0} and
-			name not in (select distinct account from tabWarehouse where
-			account is not null and account != '')
-		order by name asc""".format(
-			frappe.db.escape(company)
-		)
-	)
-
-	return [{"account": a, "balance": get_balance_on(a)} for a in accounts]
-
-
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def get_against_jv(doctype, txt, searchfield, start, page_len, filters):

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js

@@ -49,7 +49,15 @@ frappe.ui.form.on('Opening Invoice Creation Tool', {
 				doc: frm.doc,
 				btn: $(btn_primary),
 				method: "make_invoices",
-				freeze_message: __("Creating {0} Invoice", [frm.doc.invoice_type])
+				freeze: 1,
+				freeze_message: __("Creating {0} Invoice", [frm.doc.invoice_type]),
+				callback: function(r) {
+					if (r.message.length == 1) {
+						frappe.msgprint(__("{0} Invoice created successfully.", [frm.doc.invoice_type]));
+					} else if (r.message.length < 50) {
+						frappe.msgprint(__("{0} Invoices created successfully.", [frm.doc.invoice_type]));
+					}
+				}
 			});
 		});
 

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py

@@ -114,10 +114,13 @@ class OpeningInvoiceCreationTool(Document):
 				)
 				or {}
 			)
+
+			default_currency = frappe.db.get_value(row.party_type, row.party, "default_currency")
+
 			if company_details:
 				invoice.update(
 					{
-						"currency": company_details.get("default_currency"),
+						"currency": default_currency or company_details.get("default_currency"),
 						"letter_head": company_details.get("default_letter_head"),
 					}
 				)

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -226,10 +226,7 @@ frappe.ui.form.on('Payment Entry', {
 			(frm.doc.total_allocated_amount > party_amount)));
 
 		frm.toggle_display("set_exchange_gain_loss",
-			(frm.doc.paid_amount && frm.doc.received_amount && frm.doc.difference_amount &&
-				((frm.doc.paid_from_account_currency != company_currency ||
-					frm.doc.paid_to_account_currency != company_currency) &&
-					frm.doc.paid_from_account_currency != frm.doc.paid_to_account_currency)));
+			frm.doc.paid_amount && frm.doc.received_amount && frm.doc.difference_amount);
 
 		frm.refresh_fields();
 	},

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -30,7 +30,10 @@ from erpnext.controllers.accounts_controller import (
 	get_supplier_block_status,
 	validate_taxes_and_charges,
 )
-from erpnext.hr.doctype.expense_claim.expense_claim import update_reimbursed_amount
+from erpnext.hr.doctype.expense_claim.expense_claim import (
+	get_outstanding_amount_for_claim,
+	update_reimbursed_amount,
+)
 from erpnext.setup.utils import get_exchange_rate
 
 
@@ -302,7 +305,7 @@ class PaymentEntry(AccountsController):
 
 	def validate_reference_documents(self):
 		if self.party_type == "Student":
-			valid_reference_doctypes = "Fees"
+			valid_reference_doctypes = ("Fees", "Journal Entry")
 		elif self.party_type == "Customer":
 			valid_reference_doctypes = ("Sales Order", "Sales Invoice", "Journal Entry", "Dunning")
 		elif self.party_type == "Supplier":
@@ -357,6 +360,12 @@ class PaymentEntry(AccountsController):
 								)
 							)
 
+						if ref_doc.doctype == "Purchase Invoice" and ref_doc.get("on_hold"):
+							frappe.throw(
+								_("{0} {1} is on hold").format(d.reference_doctype, d.reference_name),
+								title=_("Invalid Invoice"),
+							)
+
 					if ref_doc.docstatus != 1:
 						frappe.throw(_("{0} {1} must be submitted").format(d.reference_doctype, d.reference_name))
 
@@ -1643,12 +1652,7 @@ def get_reference_details(reference_doctype, reference_name, party_account_curre
 			outstanding_amount = ref_doc.get("outstanding_amount")
 			bill_no = ref_doc.get("bill_no")
 		elif reference_doctype == "Expense Claim":
-			outstanding_amount = (
-				flt(ref_doc.get("total_sanctioned_amount"))
-				+ flt(ref_doc.get("total_taxes_and_charges"))
-				- flt(ref_doc.get("total_amount_reimbursed"))
-				- flt(ref_doc.get("total_advance_amount"))
-			)
+			outstanding_amount = get_outstanding_amount_for_claim(ref_doc)
 		elif reference_doctype == "Employee Advance":
 			outstanding_amount = flt(ref_doc.advance_amount) - flt(ref_doc.paid_amount)
 			if party_account_currency != ref_doc.currency:

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -743,6 +743,21 @@ class TestPaymentEntry(unittest.TestCase):
 			flt(payment_entry.total_taxes_and_charges, 2), flt(10 / payment_entry.target_exchange_rate, 2)
 		)
 
+	def test_payment_entry_against_onhold_purchase_invoice(self):
+		pi = make_purchase_invoice()
+
+		pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank USD - _TC")
+		pe.reference_no = "1"
+		pe.reference_date = "2016-01-01"
+
+		# block invoice after creating payment entry
+		# since `get_payment_entry` will not attach blocked invoice to payment
+		pi.block_invoice()
+		with self.assertRaises(frappe.ValidationError) as err:
+			pe.save()
+
+		self.assertTrue("is on hold" in str(err.exception).lower())
+
 
 def create_payment_entry(**args):
 	payment_entry = frappe.new_doc("Payment Entry")

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
+// Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and Contributors
 // For license information, please see license.txt
 
 frappe.provide("erpnext.accounts");
@@ -38,6 +38,15 @@ erpnext.accounts.PaymentReconciliationController = frappe.ui.form.Controller.ext
 				]
 			};
 		});
+
+		this.frm.set_query("cost_center", () => {
+			return {
+				"filters": {
+					"company": this.frm.doc.company,
+					"is_group": 0
+				}
+			}
+		});
 	},
 
 	refresh: function() {

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.json

@@ -24,6 +24,7 @@
   "invoice_limit",
   "payment_limit",
   "bank_cash_account",
+  "cost_center",
   "sec_break1",
   "invoices",
   "column_break_15",
@@ -178,13 +179,19 @@
   {
    "fieldname": "column_break_11",
    "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "cost_center",
+   "fieldtype": "Link",
+   "label": "Cost Center",
+   "options": "Cost Center"
   }
  ],
  "hide_toolbar": 1,
  "icon": "icon-resize-horizontal",
  "issingle": 1,
  "links": [],
- "modified": "2021-10-04 20:27:11.114194",
+ "modified": "2022-04-29 15:37:10.246831",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation",
@@ -209,5 +216,6 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
+ "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -332,6 +332,9 @@ class PaymentReconciliation(Document):
 	def get_conditions(self, get_invoices=False, get_payments=False, get_return_invoices=False):
 		condition = " and company = '{0}' ".format(self.company)
 
+		if self.get("cost_center") and (get_invoices or get_payments or get_return_invoices):
+			condition = " and cost_center = '{0}' ".format(self.cost_center)
+
 		if get_invoices:
 			condition += (
 				" and posting_date >= {0}".format(frappe.db.escape(self.from_invoice_date))
@@ -350,9 +353,13 @@ class PaymentReconciliation(Document):
 			)
 
 			if self.minimum_invoice_amount:
-				condition += " and `{0}` >= {1}".format(dr_or_cr, flt(self.minimum_invoice_amount))
+				condition += " and {dr_or_cr} >= {amount}".format(
+					dr_or_cr=dr_or_cr, amount=flt(self.minimum_invoice_amount)
+				)
 			if self.maximum_invoice_amount:
-				condition += " and `{0}` <= {1}".format(dr_or_cr, flt(self.maximum_invoice_amount))
+				condition += " and {dr_or_cr} <= {amount}".format(
+					dr_or_cr=dr_or_cr, amount=flt(self.maximum_invoice_amount)
+				)
 
 		elif get_return_invoices:
 			condition = " and doc.company = '{0}' ".format(self.company)
@@ -367,15 +374,19 @@ class PaymentReconciliation(Document):
 				else ""
 			)
 			dr_or_cr = (
-				"gl.debit_in_account_currency"
+				"debit_in_account_currency"
 				if erpnext.get_party_account_type(self.party_type) == "Receivable"
-				else "gl.credit_in_account_currency"
+				else "credit_in_account_currency"
 			)
 
 			if self.minimum_invoice_amount:
-				condition += " and `{0}` >= {1}".format(dr_or_cr, flt(self.minimum_payment_amount))
+				condition += " and gl.{dr_or_cr} >= {amount}".format(
+					dr_or_cr=dr_or_cr, amount=flt(self.minimum_payment_amount)
+				)
 			if self.maximum_invoice_amount:
-				condition += " and `{0}` <= {1}".format(dr_or_cr, flt(self.maximum_payment_amount))
+				condition += " and gl.{dr_or_cr} <= {amount}".format(
+					dr_or_cr=dr_or_cr, amount=flt(self.maximum_payment_amount)
+				)
 
 		else:
 			condition += (

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -1,9 +1,96 @@
 # Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
 import unittest
 
+import frappe
+from frappe.utils import add_days, getdate
+
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+
 
 class TestPaymentReconciliation(unittest.TestCase):
-	pass
+	@classmethod
+	def setUpClass(cls):
+		make_customer()
+		make_invoice_and_payment()
+
+	def test_payment_reconciliation(self):
+		payment_reco = frappe.get_doc("Payment Reconciliation")
+		payment_reco.company = "_Test Company"
+		payment_reco.party_type = "Customer"
+		payment_reco.party = "_Test Payment Reco Customer"
+		payment_reco.receivable_payable_account = "Debtors - _TC"
+		payment_reco.from_invoice_date = add_days(getdate(), -1)
+		payment_reco.to_invoice_date = getdate()
+		payment_reco.from_payment_date = add_days(getdate(), -1)
+		payment_reco.to_payment_date = getdate()
+		payment_reco.maximum_invoice_amount = 1000
+		payment_reco.maximum_payment_amount = 1000
+		payment_reco.invoice_limit = 10
+		payment_reco.payment_limit = 10
+		payment_reco.bank_cash_account = "_Test Bank - _TC"
+		payment_reco.cost_center = "_Test Cost Center - _TC"
+		payment_reco.get_unreconciled_entries()
+
+		self.assertEqual(len(payment_reco.get("invoices")), 1)
+		self.assertEqual(len(payment_reco.get("payments")), 1)
+
+		payment_entry = payment_reco.get("payments")[0].reference_name
+		invoice = payment_reco.get("invoices")[0].invoice_number
+
+		payment_reco.allocate_entries(
+			{
+				"payments": [payment_reco.get("payments")[0].as_dict()],
+				"invoices": [payment_reco.get("invoices")[0].as_dict()],
+			}
+		)
+		payment_reco.reconcile()
+
+		payment_entry_doc = frappe.get_doc("Payment Entry", payment_entry)
+		self.assertEqual(payment_entry_doc.get("references")[0].reference_name, invoice)
+
+
+def make_customer():
+	if not frappe.db.get_value("Customer", "_Test Payment Reco Customer"):
+		frappe.get_doc(
+			{
+				"doctype": "Customer",
+				"customer_name": "_Test Payment Reco Customer",
+				"customer_type": "Individual",
+				"customer_group": "_Test Customer Group",
+				"territory": "_Test Territory",
+			}
+		).insert()
+
+
+def make_invoice_and_payment():
+	si = create_sales_invoice(
+		customer="_Test Payment Reco Customer", qty=1, rate=690, do_not_save=True
+	)
+	si.cost_center = "_Test Cost Center - _TC"
+	si.save()
+	si.submit()
+
+	pe = frappe.get_doc(
+		{
+			"doctype": "Payment Entry",
+			"payment_type": "Receive",
+			"party_type": "Customer",
+			"party": "_Test Payment Reco Customer",
+			"company": "_Test Company",
+			"paid_from_account_currency": "INR",
+			"paid_to_account_currency": "INR",
+			"source_exchange_rate": 1,
+			"target_exchange_rate": 1,
+			"reference_no": "1",
+			"reference_date": getdate(),
+			"received_amount": 690,
+			"paid_amount": 690,
+			"paid_from": "Debtors - _TC",
+			"paid_to": "_Test Bank - _TC",
+			"cost_center": "_Test Cost Center - _TC",
+		}
+	)
+	pe.insert()
+	pe.submit()

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.json

@@ -10,10 +10,11 @@
   "fiscal_year",
   "amended_from",
   "company",
-  "cost_center_wise_pnl",
   "column_break1",
   "closing_account_head",
-  "remarks"
+  "remarks",
+  "gle_processing_status",
+  "error_message"
  ],
  "fields": [
   {
@@ -86,17 +87,26 @@
    "reqd": 1
   },
   {
-   "default": "0",
-   "fieldname": "cost_center_wise_pnl",
-   "fieldtype": "Check",
-   "label": "Book Cost Center Wise Profit/Loss"
+   "depends_on": "eval:doc.docstatus!=0",
+   "fieldname": "gle_processing_status",
+   "fieldtype": "Select",
+   "label": "GL Entry Processing Status",
+   "options": "In Progress\nCompleted\nFailed",
+   "read_only": 1
+  },
+  {
+   "depends_on": "eval:doc.gle_processing_status=='Failed'",
+   "fieldname": "error_message",
+   "fieldtype": "Text",
+   "label": "Error Message",
+   "read_only": 1
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2021-05-20 15:27:37.210458",
+ "modified": "2022-07-20 14:51:04.714154",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Period Closing Voucher",

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -8,7 +8,6 @@ from frappe.utils import flt
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
-	get_dimensions,
 )
 from erpnext.accounts.utils import get_account_currency
 from erpnext.controllers.accounts_controller import AccountsController
@@ -20,13 +19,28 @@ class PeriodClosingVoucher(AccountsController):
 		self.validate_posting_date()
 
 	def on_submit(self):
+		self.db_set("gle_processing_status", "In Progress")
 		self.make_gl_entries()
 
 	def on_cancel(self):
+		self.db_set("gle_processing_status", "In Progress")
 		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry")
-		from erpnext.accounts.general_ledger import make_reverse_gl_entries
-
-		make_reverse_gl_entries(voucher_type="Period Closing Voucher", voucher_no=self.name)
+		gle_count = frappe.db.count(
+			"GL Entry",
+			{"voucher_type": "Period Closing Voucher", "voucher_no": self.name, "is_cancelled": 0},
+		)
+		if gle_count > 5000:
+			frappe.enqueue(
+				make_reverse_gl_entries,
+				voucher_type="Period Closing Voucher",
+				voucher_no=self.name,
+				queue="long",
+			)
+			frappe.msgprint(
+				_("The GL Entries will be cancelled in the background, it can take a few minutes."), alert=True
+			)
+		else:
+			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")
@@ -54,8 +68,8 @@ class PeriodClosingVoucher(AccountsController):
 
 		pce = frappe.db.sql(
 			"""select name from `tabPeriod Closing Voucher`
-			where posting_date > %s and fiscal_year = %s and docstatus = 1""",
-			(self.posting_date, self.fiscal_year),
+			where posting_date > %s and fiscal_year = %s and docstatus = 1 and company = %s""",
+			(self.posting_date, self.fiscal_year, self.company),
 		)
 		if pce and pce[0][0]:
 			frappe.throw(
@@ -67,90 +81,80 @@ class PeriodClosingVoucher(AccountsController):
 	def make_gl_entries(self):
 		gl_entries = self.get_gl_entries()
 		if gl_entries:
-			from erpnext.accounts.general_ledger import make_gl_entries
-
-			make_gl_entries(gl_entries)
+			if len(gl_entries) > 5000:
+				frappe.enqueue(process_gl_entries, gl_entries=gl_entries, queue="long")
+				frappe.msgprint(
+					_("The GL Entries will be processed in the background, it can take a few minutes."),
+					alert=True,
+				)
+			else:
+				process_gl_entries(gl_entries)
 
 	def get_gl_entries(self):
 		gl_entries = []
-		pl_accounts = self.get_pl_balances()
 
-		for acc in pl_accounts:
+		# pl account
+		for acc in self.get_pl_balances_based_on_dimensions(group_by_account=True):
 			if flt(acc.bal_in_company_currency):
-				gl_entries.append(
-					self.get_gl_dict(
-						{
-							"account": acc.account,
-							"cost_center": acc.cost_center,
-							"finance_book": acc.finance_book,
-							"account_currency": acc.account_currency,
-							"debit_in_account_currency": abs(flt(acc.bal_in_account_currency))
-							if flt(acc.bal_in_account_currency) < 0
-							else 0,
-							"debit": abs(flt(acc.bal_in_company_currency))
-							if flt(acc.bal_in_company_currency) < 0
-							else 0,
-							"credit_in_account_currency": abs(flt(acc.bal_in_account_currency))
-							if flt(acc.bal_in_account_currency) > 0
-							else 0,
-							"credit": abs(flt(acc.bal_in_company_currency))
-							if flt(acc.bal_in_company_currency) > 0
-							else 0,
-						},
-						item=acc,
-					)
-				)
+				gl_entries.append(self.get_gle_for_pl_account(acc))
 
-		if gl_entries:
-			gle_for_net_pl_bal = self.get_pnl_gl_entry(pl_accounts)
-			gl_entries += gle_for_net_pl_bal
+		# closing liability account
+		for acc in self.get_pl_balances_based_on_dimensions(group_by_account=False):
+			if flt(acc.bal_in_company_currency):
+				gl_entries.append(self.get_gle_for_closing_account(acc))
 
 		return gl_entries
 
-	def get_pnl_gl_entry(self, pl_accounts):
-		company_cost_center = frappe.db.get_value("Company", self.company, "cost_center")
-		gl_entries = []
+	def get_gle_for_pl_account(self, acc):
+		gl_entry = self.get_gl_dict(
+			{
+				"account": acc.account,
+				"cost_center": acc.cost_center,
+				"finance_book": acc.finance_book,
+				"account_currency": acc.account_currency,
+				"debit_in_account_currency": abs(flt(acc.bal_in_account_currency))
+				if flt(acc.bal_in_account_currency) < 0
+				else 0,
+				"debit": abs(flt(acc.bal_in_company_currency)) if flt(acc.bal_in_company_currency) < 0 else 0,
+				"credit_in_account_currency": abs(flt(acc.bal_in_account_currency))
+				if flt(acc.bal_in_account_currency) > 0
+				else 0,
+				"credit": abs(flt(acc.bal_in_company_currency)) if flt(acc.bal_in_company_currency) > 0 else 0,
+			},
+			item=acc,
+		)
+		self.update_default_dimensions(gl_entry, acc)
+		return gl_entry
 
-		for acc in pl_accounts:
-			if flt(acc.bal_in_company_currency):
-				cost_center = acc.cost_center if self.cost_center_wise_pnl else company_cost_center
-				gl_entry = self.get_gl_dict(
-					{
-						"account": self.closing_account_head,
-						"cost_center": cost_center,
-						"finance_book": acc.finance_book,
-						"account_currency": acc.account_currency,
-						"debit_in_account_currency": abs(flt(acc.bal_in_account_currency))
-						if flt(acc.bal_in_account_currency) > 0
-						else 0,
-						"debit": abs(flt(acc.bal_in_company_currency))
-						if flt(acc.bal_in_company_currency) > 0
-						else 0,
-						"credit_in_account_currency": abs(flt(acc.bal_in_account_currency))
-						if flt(acc.bal_in_account_currency) < 0
-						else 0,
-						"credit": abs(flt(acc.bal_in_company_currency))
-						if flt(acc.bal_in_company_currency) < 0
-						else 0,
-					},
-					item=acc,
-				)
+	def get_gle_for_closing_account(self, acc):
+		gl_entry = self.get_gl_dict(
+			{
+				"account": self.closing_account_head,
+				"cost_center": acc.cost_center,
+				"finance_book": acc.finance_book,
+				"account_currency": acc.account_currency,
+				"debit_in_account_currency": abs(flt(acc.bal_in_account_currency))
+				if flt(acc.bal_in_account_currency) > 0
+				else 0,
+				"debit": abs(flt(acc.bal_in_company_currency)) if flt(acc.bal_in_company_currency) > 0 else 0,
+				"credit_in_account_currency": abs(flt(acc.bal_in_account_currency))
+				if flt(acc.bal_in_account_currency) < 0
+				else 0,
+				"credit": abs(flt(acc.bal_in_company_currency)) if flt(acc.bal_in_company_currency) < 0 else 0,
+			},
+			item=acc,
+		)
+		self.update_default_dimensions(gl_entry, acc)
+		return gl_entry
 
-				self.update_default_dimensions(gl_entry)
-
-				gl_entries.append(gl_entry)
-
-		return gl_entries
-
-	def update_default_dimensions(self, gl_entry):
+	def update_default_dimensions(self, gl_entry, acc):
 		if not self.accounting_dimensions:
 			self.accounting_dimensions = get_accounting_dimensions()
 
-		_, default_dimensions = get_dimensions()
 		for dimension in self.accounting_dimensions:
-			gl_entry.update({dimension: default_dimensions.get(self.company, {}).get(dimension)})
+			gl_entry.update({dimension: acc.get(dimension)})
 
-	def get_pl_balances(self):
+	def get_pl_balances_based_on_dimensions(self, group_by_account=False):
 		"""Get balance for dimension-wise pl accounts"""
 
 		dimension_fields = ["t1.cost_center", "t1.finance_book"]
@@ -159,20 +163,56 @@ class PeriodClosingVoucher(AccountsController):
 		for dimension in self.accounting_dimensions:
 			dimension_fields.append("t1.{0}".format(dimension))
 
+		if group_by_account:
+			dimension_fields.append("t1.account")
+
 		return frappe.db.sql(
 			"""
 			select
-				t1.account, t2.account_currency, {dimension_fields},
+				t2.account_currency,
+				{dimension_fields},
 				sum(t1.debit_in_account_currency) - sum(t1.credit_in_account_currency) as bal_in_account_currency,
 				sum(t1.debit) - sum(t1.credit) as bal_in_company_currency
 			from `tabGL Entry` t1, `tabAccount` t2
-			where t1.account = t2.name and t2.report_type = 'Profit and Loss'
-			and t2.docstatus < 2 and t2.company = %s
-			and t1.posting_date between %s and %s
-			group by t1.account, {dimension_fields}
+			where
+				t1.is_cancelled = 0
+				and t1.account = t2.name
+				and t2.report_type = 'Profit and Loss'
+				and t2.docstatus < 2
+				and t2.company = %s
+				and t1.posting_date between %s and %s
+			group by {dimension_fields}
 		""".format(
 				dimension_fields=", ".join(dimension_fields)
 			),
 			(self.company, self.get("year_start_date"), self.posting_date),
 			as_dict=1,
 		)
+
+
+def process_gl_entries(gl_entries):
+	from erpnext.accounts.general_ledger import make_gl_entries
+
+	try:
+		make_gl_entries(gl_entries, merge_entries=False)
+		frappe.db.set_value(
+			"Period Closing Voucher", gl_entries[0].get("voucher_no"), "gle_processing_status", "Completed"
+		)
+	except Exception as e:
+		frappe.db.rollback()
+		frappe.log_error(e)
+		frappe.db.set_value(
+			"Period Closing Voucher", gl_entries[0].get("voucher_no"), "gle_processing_status", "Failed"
+		)
+
+
+def make_reverse_gl_entries(voucher_type, voucher_no):
+	from erpnext.accounts.general_ledger import make_reverse_gl_entries
+
+	try:
+		make_reverse_gl_entries(voucher_type=voucher_type, voucher_no=voucher_no)
+		frappe.db.set_value("Period Closing Voucher", voucher_no, "gle_processing_status", "Completed")
+	except Exception as e:
+		frappe.db.rollback()
+		frappe.log_error(e)
+		frappe.db.set_value("Period Closing Voucher", voucher_no, "gle_processing_status", "Failed")

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -49,7 +49,7 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 
 		expected_gle = (
 			("Cost of Goods Sold - TPC", 0.0, 600.0),
-			(surplus_account, 600.0, 400.0),
+			(surplus_account, 200.0, 0.0),
 			("Sales - TPC", 400.0, 0.0),
 		)
 
@@ -59,7 +59,8 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 		""",
 			(pcv.name),
 		)
-
+		pcv.reload()
+		self.assertEqual(pcv.gle_processing_status, "Completed")
 		self.assertEqual(pcv_gle, expected_gle)
 
 	def test_cost_center_wise_posting(self):
@@ -78,7 +79,10 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			expense_account="Cost of Goods Sold - TPC",
 			rate=400,
 			debit_to="Debtors - TPC",
+			currency="USD",
+			customer="_Test Customer USD",
 		)
+
 		create_sales_invoice(
 			company=company,
 			cost_center=cost_center2,
@@ -86,10 +90,11 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			expense_account="Cost of Goods Sold - TPC",
 			rate=200,
 			debit_to="Debtors - TPC",
+			currency="USD",
+			customer="_Test Customer USD",
 		)
 
 		pcv = self.make_period_closing_voucher(submit=False)
-		pcv.cost_center_wise_pnl = 1
 		pcv.save()
 		pcv.submit()
 		surplus_account = pcv.closing_account_head
@@ -112,6 +117,16 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 
 		self.assertEqual(pcv_gle, expected_gle)
 
+		pcv.reload()
+		pcv.cancel()
+
+		self.assertFalse(
+			frappe.db.get_value(
+				"GL Entry",
+				{"voucher_type": "Period Closing Voucher", "voucher_no": pcv.name, "is_cancelled": 0},
+			)
+		)
+
 	def test_period_closing_with_finance_book_entries(self):
 		frappe.db.sql("delete from `tabGL Entry` where company='Test PCV Company'")
 
@@ -119,14 +134,17 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 		surplus_account = create_account()
 		cost_center = create_cost_center("Test Cost Center 1")
 
-		create_sales_invoice(
+		si = create_sales_invoice(
 			company=company,
 			income_account="Sales - TPC",
 			expense_account="Cost of Goods Sold - TPC",
 			cost_center=cost_center,
 			rate=400,
 			debit_to="Debtors - TPC",
+			currency="USD",
+			customer="_Test Customer USD",
 		)
+
 		jv = make_journal_entry(
 			account1="Cash - TPC",
 			account2="Sales - TPC",

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.js

@@ -64,13 +64,15 @@ frappe.ui.form.on('POS Closing Entry', {
 	pos_opening_entry(frm) {
 		if (frm.doc.pos_opening_entry && frm.doc.period_start_date && frm.doc.period_end_date && frm.doc.user) {
 			reset_values(frm);
-			frm.trigger("set_opening_amounts");
-			frm.trigger("get_pos_invoices");
+			frappe.run_serially([
+				() => frm.trigger("set_opening_amounts"),
+				() => frm.trigger("get_pos_invoices")
+			]);
 		}
 	},
 
 	set_opening_amounts(frm) {
-		frappe.db.get_doc("POS Opening Entry", frm.doc.pos_opening_entry)
+		return frappe.db.get_doc("POS Opening Entry", frm.doc.pos_opening_entry)
 			.then(({ balance_details }) => {
 				balance_details.forEach(detail => {
 					frm.add_child("payment_reconciliation", {
@@ -83,7 +85,7 @@ frappe.ui.form.on('POS Closing Entry', {
 	},
 
 	get_pos_invoices(frm) {
-		frappe.call({
+		return frappe.call({
 			method: 'erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry.get_pos_invoices',
 			args: {
 				start: frappe.datetime.get_datetime_as_string(frm.doc.period_start_date),
@@ -100,7 +102,9 @@ frappe.ui.form.on('POS Closing Entry', {
 		});
 	},
 
-	before_save: function(frm) {
+	before_save: async function(frm) {
+		frappe.dom.freeze(__('Processing Sales! Please Wait...'));
+
 		frm.set_value("grand_total", 0);
 		frm.set_value("net_total", 0);
 		frm.set_value("total_quantity", 0);
@@ -110,17 +114,23 @@ frappe.ui.form.on('POS Closing Entry', {
 			row.expected_amount = row.opening_amount;
 		}
 
-		for (let row of frm.doc.pos_transactions) {
-			frappe.db.get_doc("POS Invoice", row.pos_invoice).then(doc => {
-				frm.doc.grand_total += flt(doc.grand_total);
-				frm.doc.net_total += flt(doc.net_total);
-				frm.doc.total_quantity += flt(doc.total_qty);
-				refresh_payments(doc, frm);
-				refresh_taxes(doc, frm);
-				refresh_fields(frm);
-				set_html_data(frm);
-			});
+		const pos_inv_promises = frm.doc.pos_transactions.map(
+			row => frappe.db.get_doc("POS Invoice", row.pos_invoice)
+		);
+
+		const pos_invoices = await Promise.all(pos_inv_promises);
+
+		for (let doc of pos_invoices) {
+			frm.doc.grand_total += flt(doc.grand_total);
+			frm.doc.net_total += flt(doc.net_total);
+			frm.doc.total_quantity += flt(doc.total_qty);
+			refresh_payments(doc, frm);
+			refresh_taxes(doc, frm);
+			refresh_fields(frm);
+			set_html_data(frm);
 		}
+
+		frappe.dom.unfreeze();
 	}
 });
 

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -222,9 +222,6 @@ class POSInvoice(SalesInvoice):
 		allow_negative_stock = frappe.db.get_single_value("Stock Settings", "allow_negative_stock")
 
 		for d in self.get("items"):
-			is_service_item = not (frappe.db.get_value("Item", d.get("item_code"), "is_stock_item"))
-			if is_service_item:
-				return
 			if d.serial_no:
 				self.validate_pos_reserved_serial_nos(d)
 				self.validate_delivered_serial_nos(d)

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -9,7 +9,7 @@ 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 flt, getdate, nowdate
+from frappe.utils import cint, flt, getdate, nowdate
 from frappe.utils.background_jobs import enqueue
 from frappe.utils.scheduler import is_scheduler_inactive
 
@@ -219,6 +219,9 @@ class POSInvoiceMergeLog(Document):
 		invoice.taxes_and_charges = None
 		invoice.ignore_pricing_rule = 1
 		invoice.customer = self.customer
+		invoice.disable_rounded_total = cint(
+			frappe.db.get_value("POS Profile", invoice.pos_profile, "disable_rounded_total")
+		)
 
 		if self.merge_invoices_based_on == "Customer Group":
 			invoice.flags.ignore_pos_profile = True

erpnext/accounts/doctype/pos_profile/pos_profile.json

@@ -44,6 +44,7 @@
   "write_off_account",
   "write_off_cost_center",
   "account_for_change_amount",
+  "disable_rounded_total",
   "column_break_23",
   "income_account",
   "expense_account",
@@ -358,6 +359,13 @@
    "fieldname": "validate_stock_on_save",
    "fieldtype": "Check",
    "label": "Validate Stock on Save"
+  },
+  {
+   "default": "0",
+   "description": "If enabled, the consolidated invoices will have rounded total disabled",
+   "fieldname": "disable_rounded_total",
+   "fieldtype": "Check",
+   "label": "Disable Rounded Total"
   }
  ],
  "icon": "icon-cog",
@@ -385,7 +393,7 @@
    "link_fieldname": "pos_profile"
   }
  ],
- "modified": "2022-03-21 13:29:28.480533",
+ "modified": "2022-07-21 11:16:46.911173",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Profile",

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -36,10 +36,15 @@ class PricingRule(Document):
 			self.margin_rate_or_amount = 0.0
 
 	def validate_duplicate_apply_on(self):
-		field = apply_on_dict.get(self.apply_on)
-		values = [d.get(frappe.scrub(self.apply_on)) for d in self.get(field) if field]
-		if len(values) != len(set(values)):
-			frappe.throw(_("Duplicate {0} found in the table").format(self.apply_on))
+		if self.apply_on != "Transaction":
+			apply_on_table = apply_on_dict.get(self.apply_on)
+			if not apply_on_table:
+				return
+
+			apply_on_field = frappe.scrub(self.apply_on)
+			values = [d.get(apply_on_field) for d in self.get(apply_on_table) if d.get(apply_on_field)]
+			if len(values) != len(set(values)):
+				frappe.throw(_("Duplicate {0} found in the table").format(self.apply_on))
 
 	def validate_mandatory(self):
 		for apply_on, field in apply_on_dict.items():

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -712,7 +712,7 @@ class TestPricingRule(unittest.TestCase):
 			title="_Test Pricing Rule with Min Qty - 2",
 		)
 
-		si = create_sales_invoice(do_not_submit=True, customer="_Test Customer 1", qty=1, currency="USD")
+		si = create_sales_invoice(do_not_submit=True, customer="_Test Customer 1", qty=1)
 		item = si.items[0]
 		item.stock_qty = 1
 		si.save()

erpnext/accounts/doctype/process_deferred_accounting/process_deferred_accounting.py

@@ -11,7 +11,7 @@ from erpnext.accounts.deferred_revenue import (
 	convert_deferred_expense_to_expense,
 	convert_deferred_revenue_to_income,
 )
-from erpnext.accounts.general_ledger import make_reverse_gl_entries
+from erpnext.accounts.general_ledger import make_gl_entries
 
 
 class ProcessDeferredAccounting(Document):
@@ -34,4 +34,4 @@ class ProcessDeferredAccounting(Document):
 			filters={"against_voucher_type": self.doctype, "against_voucher": self.name},
 		)
 
-		make_reverse_gl_entries(gl_entries=gl_entries)
+		make_gl_entries(gl_entries=gl_entries, cancel=1)

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -34,8 +34,9 @@ class ProcessStatementOfAccounts(Document):
 			frappe.throw(_("Customers not selected."))
 
 		if self.enable_auto_email:
-			self.to_date = self.start_date
-			self.from_date = add_months(self.to_date, -1 * self.filter_duration)
+			if self.start_date and getdate(self.start_date) >= getdate(today()):
+				self.to_date = self.start_date
+				self.from_date = add_months(self.to_date, -1 * self.filter_duration)
 
 
 def get_report_pdf(doc, consolidated=True):

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -30,6 +30,9 @@ erpnext.accounts.PurchaseInvoice = erpnext.buying.BuyingController.extend({
 	onload: function() {
 		this._super();
 
+		// Ignore linked advances
+		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry'];
+
 		if(!this.frm.doc.__islocal) {
 			// show credit_to in print format
 			if(!this.frm.doc.supplier && this.frm.doc.credit_to) {
@@ -42,8 +45,6 @@ erpnext.accounts.PurchaseInvoice = erpnext.buying.BuyingController.extend({
 		if (this.frm.doc.supplier && this.frm.doc.__islocal) {
 			this.frm.trigger('supplier');
 		}
-
-		erpnext.accounts.dimensions.setup_dimension_filters(this.frm, this.frm.doctype);
 	},
 
 	refresh: function(doc) {

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -158,20 +158,10 @@ class PurchaseInvoice(BuyingController):
 		if tds_category and not for_validate:
 			self.apply_tds = 1
 			self.tax_withholding_category = tds_category
+			self.set_onload("supplier_tds", tds_category)
 
 		super(PurchaseInvoice, self).set_missing_values(for_validate)
 
-	def check_conversion_rate(self):
-		default_currency = erpnext.get_company_currency(self.company)
-		if not default_currency:
-			throw(_("Please enter default currency in Company Master"))
-		if (
-			(self.currency == default_currency and flt(self.conversion_rate) != 1.00)
-			or not self.conversion_rate
-			or (self.currency != default_currency and flt(self.conversion_rate) == 1.00)
-		):
-			throw(_("Conversion rate cannot be 0 or 1"))
-
 	def validate_credit_to_acc(self):
 		if not self.credit_to:
 			self.credit_to = get_party_account("Supplier", self.supplier, self.company)
@@ -540,7 +530,16 @@ class PurchaseInvoice(BuyingController):
 					from_repost=from_repost,
 				)
 			elif self.docstatus == 2:
+				provisional_entries = [a for a in gl_entries if a.voucher_type == "Purchase Receipt"]
 				make_reverse_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
+				if provisional_entries:
+					for entry in provisional_entries:
+						frappe.db.set_value(
+							"GL Entry",
+							{"voucher_type": "Purchase Receipt", "voucher_detail_no": entry.voucher_detail_no},
+							"is_cancelled",
+							1,
+						)
 
 			if update_outstanding == "No":
 				update_outstanding_amt(
@@ -801,7 +800,9 @@ class PurchaseInvoice(BuyingController):
 
 					if provisional_accounting_for_non_stock_items:
 						if item.purchase_receipt:
-							provisional_account = self.get_company_default("default_provisional_account")
+							provisional_account = frappe.db.get_value(
+								"Purchase Receipt Item", item.pr_detail, "provisional_expense_account"
+							) or self.get_company_default("default_provisional_account")
 							purchase_receipt_doc = purchase_receipt_doc_map.get(item.purchase_receipt)
 
 							if not purchase_receipt_doc:
@@ -824,7 +825,7 @@ class PurchaseInvoice(BuyingController):
 							if expense_booked_in_pr:
 								# Intentionally passing purchase invoice item to handle partial billing
 								purchase_receipt_doc.add_provisional_gl_entry(
-									item, gl_entries, self.posting_date, reverse=1
+									item, gl_entries, self.posting_date, provisional_account, reverse=1
 								)
 
 					if not self.is_internal_transfer():
@@ -1076,7 +1077,7 @@ class PurchaseInvoice(BuyingController):
 		# Stock ledger value is not matching with the warehouse amount
 		if (
 			self.update_stock
-			and voucher_wise_stock_value.get(item.name)
+			and voucher_wise_stock_value.get((item.name, item.warehouse))
 			and warehouse_debit_amount
 			!= flt(voucher_wise_stock_value.get((item.name, item.warehouse)), net_amt_precision)
 		):
@@ -1315,7 +1316,9 @@ class PurchaseInvoice(BuyingController):
 		if (
 			not self.is_internal_transfer() and self.rounding_adjustment and self.base_rounding_adjustment
 		):
-			round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(self.company)
+			round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(
+				self.company, "Purchase Invoice", self.name
+			)
 
 			gl_entries.append(
 				self.get_gl_dict(

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -26,12 +26,13 @@ from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import (
 	make_purchase_receipt,
 )
 from erpnext.stock.doctype.stock_entry.test_stock_entry import get_qty_after_transaction
+from erpnext.stock.tests.test_utils import StockTestMixin
 
 test_dependencies = ["Item", "Cost Center", "Payment Term", "Payment Terms Template"]
 test_ignore = ["Serial No"]
 
 
-class TestPurchaseInvoice(unittest.TestCase):
+class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 	@classmethod
 	def setUpClass(self):
 		unlink_payment_on_cancel_of_invoice()
@@ -659,6 +660,80 @@ class TestPurchaseInvoice(unittest.TestCase):
 			self.assertEqual(expected_values[gle.account][0], gle.debit)
 			self.assertEqual(expected_values[gle.account][1], gle.credit)
 
+	def test_standalone_return_using_pi(self):
+		from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
+
+		item = self.make_item().name
+		company = "_Test Company with perpetual inventory"
+		warehouse = "Stores - TCP1"
+
+		make_stock_entry(item_code=item, target=warehouse, qty=50, rate=120)
+
+		return_pi = make_purchase_invoice(
+			is_return=1,
+			item=item,
+			qty=-10,
+			update_stock=1,
+			rate=100,
+			company=company,
+			warehouse=warehouse,
+			cost_center="Main - TCP1",
+		)
+
+		# assert that stock consumption is with actual rate
+		self.assertGLEs(
+			return_pi,
+			[{"credit": 1200, "debit": 0}],
+			gle_filters={"account": "Stock In Hand - TCP1"},
+		)
+
+		# assert loss booked in COGS
+		self.assertGLEs(
+			return_pi,
+			[{"credit": 0, "debit": 200}],
+			gle_filters={"account": "Cost of Goods Sold - TCP1"},
+		)
+
+	def test_return_with_lcv(self):
+		from erpnext.controllers.sales_and_purchase_return import make_return_doc
+		from erpnext.stock.doctype.landed_cost_voucher.test_landed_cost_voucher import (
+			create_landed_cost_voucher,
+		)
+
+		item = self.make_item().name
+		company = "_Test Company with perpetual inventory"
+		warehouse = "Stores - TCP1"
+		cost_center = "Main - TCP1"
+
+		pi = make_purchase_invoice(
+			item=item,
+			company=company,
+			warehouse=warehouse,
+			cost_center=cost_center,
+			update_stock=1,
+			qty=10,
+			rate=100,
+		)
+
+		# Create landed cost voucher - will increase valuation of received item by 10
+		create_landed_cost_voucher("Purchase Invoice", pi.name, pi.company, charges=100)
+		return_pi = make_return_doc(pi.doctype, pi.name)
+		return_pi.save().submit()
+
+		# assert that stock consumption is with actual in rate
+		self.assertGLEs(
+			return_pi,
+			[{"credit": 1100, "debit": 0}],
+			gle_filters={"account": "Stock In Hand - TCP1"},
+		)
+
+		# assert loss booked in COGS
+		self.assertGLEs(
+			return_pi,
+			[{"credit": 0, "debit": 100}],
+			gle_filters={"account": "Cost of Goods Sold - TCP1"},
+		)
+
 	def test_multi_currency_gle(self):
 		pi = make_purchase_invoice(
 			supplier="_Test Supplier USD",
@@ -1449,7 +1524,8 @@ class TestPurchaseInvoice(unittest.TestCase):
 		self.assertEqual(payment_entry.taxes[0].allocated_amount, 0)
 
 	def test_provisional_accounting_entry(self):
-		item = create_item("_Test Non Stock Item", is_stock_item=0)
+		create_item("_Test Non Stock Item", is_stock_item=0)
+
 		provisional_account = create_account(
 			account_name="Provision Account",
 			parent_account="Current Liabilities - _TC",
@@ -1472,6 +1548,8 @@ class TestPurchaseInvoice(unittest.TestCase):
 		pi.save()
 		pi.submit()
 
+		self.assertEquals(pr.items[0].provisional_expense_account, "Provision Account - _TC")
+
 		# Check GLE for Purchase Invoice
 		expected_gle = [
 			["Cost of Goods Sold - _TC", 250, 0, add_days(pr.posting_date, -1)],
@@ -1489,9 +1567,41 @@ class TestPurchaseInvoice(unittest.TestCase):
 
 		check_gl_entries(self, pr.name, expected_gle_for_purchase_receipt, pr.posting_date)
 
+		# Cancel purchase invoice to check reverse provisional entry cancellation
+		pi.cancel()
+
+		expected_gle_for_purchase_receipt_post_pi_cancel = [
+			["Provision Account - _TC", 0, 250, pi.posting_date],
+			["_Test Account Cost for Goods Sold - _TC", 250, 0, pi.posting_date],
+		]
+
+		check_gl_entries(
+			self, pr.name, expected_gle_for_purchase_receipt_post_pi_cancel, pr.posting_date
+		)
+
 		company.enable_provisional_accounting_for_non_stock_items = 0
 		company.save()
 
+	def test_item_less_defaults(self):
+
+		pi = frappe.new_doc("Purchase Invoice")
+		pi.supplier = "_Test Supplier"
+		pi.company = "_Test Company"
+		pi.append(
+			"items",
+			{
+				"item_name": "Opening item",
+				"qty": 1,
+				"uom": "Tonne",
+				"stock_uom": "Kg",
+				"rate": 1000,
+				"expense_account": "Stock Received But Not Billed - _TC",
+			},
+		)
+
+		pi.save()
+		self.assertEqual(pi.items[0].conversion_factor, 1000)
+
 
 def check_gl_entries(doc, voucher_no, expected_gle, posting_date):
 	gl_entries = frappe.db.sql(

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -34,7 +34,9 @@ erpnext.accounts.SalesInvoiceController = erpnext.selling.SellingController.exte
 		var me = this;
 		this._super();
 
-		this.frm.ignore_doctypes_on_cancel_all = ['POS Invoice', 'Timesheet', 'POS Invoice Merge Log', 'POS Closing Entry'];
+		this.frm.ignore_doctypes_on_cancel_all = ['POS Invoice', 'Timesheet', 'POS Invoice Merge Log',
+			'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
 			this.frm.set_df_property("debit_to", "print_hide", 0);
@@ -51,7 +53,6 @@ erpnext.accounts.SalesInvoiceController = erpnext.selling.SellingController.exte
 			me.frm.refresh_fields();
 		}
 		erpnext.queries.setup_warehouse_query(this.frm);
-		erpnext.accounts.dimensions.setup_dimension_filters(this.frm, this.frm.doctype);
 	},
 
 	refresh: function(doc, dt, dn) {
@@ -473,9 +474,17 @@ erpnext.accounts.SalesInvoiceController = erpnext.selling.SellingController.exte
 				let row = frappe.get_doc(d.doctype, d.name)
 				set_timesheet_detail_rate(row.doctype, row.name, me.frm.doc.currency, row.timesheet_detail)
 			});
-			frm.trigger("calculate_timesheet_totals");
+			this.frm.trigger("calculate_timesheet_totals");
+		}
+	},
+
+	is_cash_or_non_trade_discount() {
+		this.frm.set_df_property("additional_discount_account", "hidden", 1 - this.frm.doc.is_cash_or_non_trade_discount);
+		if (!this.frm.doc.is_cash_or_non_trade_discount) {
+			this.frm.set_value("additional_discount_account", "");
 		}
 	}
+
 });
 
 // for backward compatibility: combine new and previous states
@@ -883,27 +892,44 @@ frappe.ui.form.on('Sales Invoice', {
 
 	set_timesheet_data: function(frm, timesheets) {
 		frm.clear_table("timesheets")
-		timesheets.forEach(timesheet => {
+		timesheets.forEach(async (timesheet) => {
 			if (frm.doc.currency != timesheet.currency) {
-				frappe.call({
-					method: "erpnext.setup.utils.get_exchange_rate",
-					args: {
-						from_currency: timesheet.currency,
-						to_currency: frm.doc.currency
-					},
-					callback: function(r) {
-						if (r.message) {
-							exchange_rate = r.message;
-							frm.events.append_time_log(frm, timesheet, exchange_rate);
-						}
-					}
-				});
+				const exchange_rate = await frm.events.get_exchange_rate(
+					frm, timesheet.currency, frm.doc.currency
+				)
+				frm.events.append_time_log(frm, timesheet, exchange_rate)
 			} else {
 				frm.events.append_time_log(frm, timesheet, 1.0);
 			}
 		});
 	},
 
+	async get_exchange_rate(frm, from_currency, to_currency) {
+		if (
+			frm.exchange_rates
+			&& frm.exchange_rates[from_currency]
+			&& frm.exchange_rates[from_currency][to_currency]
+		) {
+			return frm.exchange_rates[from_currency][to_currency];
+		}
+
+		return frappe.call({
+			method: "erpnext.setup.utils.get_exchange_rate",
+			args: {
+				from_currency,
+				to_currency
+			},
+			callback: function(r) {
+				if (r.message) {
+					// cache exchange rates
+					frm.exchange_rates = frm.exchange_rates || {};
+					frm.exchange_rates[from_currency] = frm.exchange_rates[from_currency] || {};
+					frm.exchange_rates[from_currency][to_currency] = r.message;
+				}
+			}
+		});
+	},
+
 	append_time_log: function(frm, time_log, exchange_rate) {
 		const row = frm.add_child("timesheets");
 		row.activity_type = time_log.activity_type;
@@ -914,7 +940,7 @@ frappe.ui.form.on('Sales Invoice', {
 		row.billing_hours = time_log.billing_hours;
 		row.billing_amount = flt(time_log.billing_amount) * flt(exchange_rate);
 		row.timesheet_detail = time_log.name;
-    row.project_name = time_log.project_name;
+		row.project_name = time_log.project_name;
 
 		frm.refresh_field("timesheets");
 		frm.trigger("calculate_timesheet_totals");

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -106,6 +106,7 @@
   "loyalty_redemption_cost_center",
   "section_break_49",
   "apply_discount_on",
+  "is_cash_or_non_trade_discount",
   "base_discount_amount",
   "additional_discount_account",
   "column_break_51",
@@ -413,7 +414,7 @@
   },
   {
    "default": "0",
-   "depends_on": "eval: doc.is_return && doc.return_against",
+   "depends_on": "eval: doc.is_return",
    "fieldname": "update_billed_amount_in_sales_order",
    "fieldtype": "Check",
    "hide_days": 1,
@@ -1988,7 +1989,7 @@
   {
    "fieldname": "additional_discount_account",
    "fieldtype": "Link",
-   "label": "Additional Discount Account",
+   "label": "Discount Account",
    "options": "Account"
   },
   {
@@ -2026,6 +2027,13 @@
    "fieldtype": "Currency",
    "label": "Amount Eligible for Commission",
    "read_only": 1
+  },
+  {
+   "default": "0",
+   "depends_on": "eval: doc.apply_discount_on == \"Grand Total\"",
+   "fieldname": "is_cash_or_non_trade_discount",
+   "fieldtype": "Check",
+   "label": "Is Cash or Non Trade Discount"
   }
  ],
  "icon": "fa fa-file-text",
@@ -2038,7 +2046,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2022-03-08 16:08:53.517903",
+ "modified": "2022-07-11 17:43:56.435382",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -116,6 +116,7 @@ class SalesInvoice(SellingController):
 		self.set_income_account_for_fixed_assets()
 		self.validate_item_cost_centers()
 		self.validate_income_account()
+		self.check_conversion_rate()
 
 		validate_inter_company_party(
 			self.doctype, self.customer, self.company, self.inter_company_invoice_reference
@@ -1039,7 +1040,7 @@ class SalesInvoice(SellingController):
 		)
 
 		if grand_total and not self.is_internal_transfer():
-			# Didnot use base_grand_total to book rounding loss gle
+			# Did not use base_grand_total to book rounding loss gle
 			gl_entries.append(
 				self.get_gl_dict(
 					{
@@ -1064,6 +1065,22 @@ class SalesInvoice(SellingController):
 				)
 			)
 
+		if self.apply_discount_on == "Grand Total" and self.get("is_cash_or_discount_account"):
+			gl_entries.append(
+				self.get_gl_dict(
+					{
+						"account": self.additional_discount_account,
+						"against": self.debit_to,
+						"debit": self.base_discount_amount,
+						"debit_in_account_currency": self.discount_amount,
+						"cost_center": self.cost_center,
+						"project": self.project,
+					},
+					self.currency,
+					item=self,
+				)
+			)
+
 	def make_tax_gl_entries(self, gl_entries):
 		for tax in self.get("taxes"):
 			amount, base_amount = self.get_tax_amounts(tax, self.enable_discount_accounting)
@@ -1113,24 +1130,24 @@ class SalesInvoice(SellingController):
 					asset = self.get_asset(item)
 
 					if self.is_return:
+						if asset.calculate_depreciation:
+							self.reverse_depreciation_entry_made_after_sale(asset)
+							self.reset_depreciation_schedule(asset)
+
 						fixed_asset_gl_entries = get_gl_entries_on_asset_regain(
 							asset, item.base_net_amount, item.finance_book
 						)
 						asset.db_set("disposal_date", None)
 
-						if asset.calculate_depreciation:
-							self.reverse_depreciation_entry_made_after_sale(asset)
-							self.reset_depreciation_schedule(asset)
-
 					else:
+						if asset.calculate_depreciation:
+							self.depreciate_asset(asset)
+
 						fixed_asset_gl_entries = get_gl_entries_on_asset_disposal(
 							asset, item.base_net_amount, item.finance_book
 						)
 						asset.db_set("disposal_date", self.posting_date)
 
-						if asset.calculate_depreciation:
-							self.depreciate_asset(asset)
-
 					for gle in fixed_asset_gl_entries:
 						gle["against"] = self.customer
 						gl_entries.append(self.get_gl_dict(gle, item=item))
@@ -1198,6 +1215,7 @@ class SalesInvoice(SellingController):
 		asset.save()
 
 		make_depreciation_entry(asset.name, self.posting_date)
+		asset.load_from_db()
 
 	def reset_depreciation_schedule(self, asset):
 		asset.flags.ignore_validate_update_after_submit = True
@@ -1207,6 +1225,7 @@ class SalesInvoice(SellingController):
 
 		self.modify_depreciation_schedule_for_asset_repairs(asset)
 		asset.save()
+		asset.load_from_db()
 
 	def modify_depreciation_schedule_for_asset_repairs(self, asset):
 		asset_repairs = frappe.get_all(
@@ -1473,7 +1492,9 @@ class SalesInvoice(SellingController):
 			and self.base_rounding_adjustment
 			and not self.is_internal_transfer()
 		):
-			round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(self.company)
+			round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(
+				self.company, "Sales Invoice", self.name
+			)
 
 			gl_entries.append(
 				self.get_gl_dict(
@@ -2152,11 +2173,13 @@ def make_inter_company_transaction(doctype, source_name, target_doc=None):
 		target_detail_field = "sales_invoice_item" if doctype == "Sales Invoice" else "sales_order_item"
 		source_document_warehouse_field = "target_warehouse"
 		target_document_warehouse_field = "from_warehouse"
+		received_items = get_received_items(source_name, target_doctype, target_detail_field)
 	else:
 		source_doc = frappe.get_doc(doctype, source_name)
 		target_doctype = "Sales Invoice" if doctype == "Purchase Invoice" else "Sales Order"
 		source_document_warehouse_field = "from_warehouse"
 		target_document_warehouse_field = "target_warehouse"
+		received_items = {}
 
 	validate_inter_company_transaction(source_doc, doctype)
 	details = get_inter_company_details(source_doc, doctype)
@@ -2222,12 +2245,17 @@ def make_inter_company_transaction(doctype, source_name, target_doc=None):
 				shipping_address_name=target_doc.shipping_address_name,
 			)
 
+	def update_item(source, target, source_parent):
+		target.qty = flt(source.qty) - received_items.get(source.name, 0.0)
+
 	item_field_map = {
 		"doctype": target_doctype + " Item",
 		"field_no_map": ["income_account", "expense_account", "cost_center", "warehouse"],
 		"field_map": {
 			"rate": "rate",
 		},
+		"postprocess": update_item,
+		"condition": lambda doc: doc.qty > 0,
 	}
 
 	if doctype in ["Sales Invoice", "Sales Order"]:
@@ -2265,6 +2293,28 @@ def make_inter_company_transaction(doctype, source_name, target_doc=None):
 	return doclist
 
 
+def get_received_items(reference_name, doctype, reference_fieldname):
+	target_doctypes = frappe.get_all(
+		doctype,
+		filters={"inter_company_invoice_reference": reference_name, "docstatus": 1},
+		as_list=True,
+	)
+
+	if target_doctypes:
+		target_doctypes = list(target_doctypes[0])
+
+	received_items_map = frappe._dict(
+		frappe.get_all(
+			doctype + " Item",
+			filters={"parent": ("in", target_doctypes)},
+			fields=[reference_fieldname, "qty"],
+			as_list=1,
+		)
+	)
+
+	return received_items_map
+
+
 def set_purchase_references(doc):
 	# add internal PO or PR links if any
 	if doc.is_internal_transfer():

erpnext/accounts/doctype/sales_invoice/sales_invoice_dashboard.py

@@ -11,8 +11,12 @@ def get_data():
 			"Payment Request": "reference_name",
 			"Sales Invoice": "return_against",
 			"Auto Repeat": "reference_document",
+			"Purchase Invoice": "inter_company_invoice_reference",
+		},
+		"internal_links": {
+			"Sales Order": ["items", "sales_order"],
+			"Timesheet": ["timesheets", "time_sheet"],
 		},
-		"internal_links": {"Sales Order": ["items", "sales_order"]},
 		"transactions": [
 			{
 				"label": _("Payment"),
@@ -27,5 +31,6 @@ def get_data():
 			{"label": _("Reference"), "items": ["Timesheet", "Delivery Note", "Sales Order"]},
 			{"label": _("Returns"), "items": ["Sales Invoice"]},
 			{"label": _("Subscription"), "items": ["Auto Repeat"]},
+			{"label": _("Internal Transfers"), "items": ["Purchase Invoice"]},
 		],
 	}

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -1612,6 +1612,17 @@ class TestSalesInvoice(unittest.TestCase):
 
 		self.assertTrue(gle)
 
+	def test_invoice_exchange_rate(self):
+		si = create_sales_invoice(
+			customer="_Test Customer USD",
+			debit_to="_Test Receivable USD - _TC",
+			currency="USD",
+			conversion_rate=1,
+			do_not_save=1,
+		)
+
+		self.assertRaises(frappe.ValidationError, si.save)
+
 	def test_invalid_currency(self):
 		# Customer currency = USD
 
@@ -2007,6 +2018,13 @@ class TestSalesInvoice(unittest.TestCase):
 			self.assertEqual(expected_values[gle.account][2], gle.credit)
 
 	def test_rounding_adjustment_3(self):
+		from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension import (
+			create_dimension,
+			disable_dimension,
+		)
+
+		create_dimension()
+
 		si = create_sales_invoice(do_not_save=True)
 		si.items = []
 		for d in [(1122, 2), (1122.01, 1), (1122.01, 1)]:
@@ -2034,6 +2052,10 @@ class TestSalesInvoice(unittest.TestCase):
 					"included_in_print_rate": 1,
 				},
 			)
+
+		si.cost_center = "_Test Cost Center 2 - _TC"
+		si.location = "Block 1"
+
 		si.save()
 		si.submit()
 		self.assertEqual(si.net_total, 4007.16)
@@ -2069,6 +2091,18 @@ class TestSalesInvoice(unittest.TestCase):
 
 		self.assertEqual(debit_credit_diff, 0)
 
+		round_off_gle = frappe.db.get_value(
+			"GL Entry",
+			{"voucher_type": "Sales Invoice", "voucher_no": si.name, "account": "Round Off - _TC"},
+			["cost_center", "location"],
+			as_dict=1,
+		)
+
+		self.assertEqual(round_off_gle.cost_center, "_Test Cost Center 2 - _TC")
+		self.assertEqual(round_off_gle.location, "Block 1")
+
+		disable_dimension()
+
 	def test_sales_invoice_with_shipping_rule(self):
 		from erpnext.accounts.doctype.shipping_rule.test_shipping_rule import create_shipping_rule
 
@@ -2270,6 +2304,14 @@ class TestSalesInvoice(unittest.TestCase):
 
 		check_gl_entries(self, si.name, expected_gle, "2019-01-30")
 
+	def test_deferred_revenue_missing_account(self):
+		si = create_sales_invoice(posting_date="2019-01-10", do_not_submit=True)
+		si.items[0].enable_deferred_revenue = 1
+		si.items[0].service_start_date = "2019-01-10"
+		si.items[0].service_end_date = "2019-03-15"
+
+		self.assertRaises(frappe.ValidationError, si.save)
+
 	def test_fixed_deferred_revenue(self):
 		deferred_account = create_account(
 			account_name="Deferred Revenue",
@@ -2554,6 +2596,7 @@ class TestSalesInvoice(unittest.TestCase):
 		# reset
 		einvoice_settings = frappe.get_doc("E Invoice Settings")
 		einvoice_settings.enable = 0
+		einvoice_settings.save()
 		frappe.flags.country = country
 
 	def test_einvoice_json(self):
@@ -2577,6 +2620,216 @@ class TestSalesInvoice(unittest.TestCase):
 		einvoice = make_einvoice(si)
 		validate_totals(einvoice)
 
+	def test_einvoice_discounts(self):
+		from erpnext.regional.india.e_invoice.utils import make_einvoice, validate_totals
+
+		frappe.db.set_single_value("E Invoice Settings", "dont_show_discounts_in_e_invoice", False)
+
+		# Normal Itemized Discount
+		si = get_sales_invoice_for_e_invoice()
+		si.apply_discount_on = ""
+		si.items[0].price_list_rate = 12
+		si.items[0].discount_percentage = 16.6666666667
+		si.items[0].rate = 10
+
+		si.items[1].price_list_rate = 15
+		si.items[1].discount_amount = 5
+		si.items[1].rate = 10
+		si.save()
+
+		einvoice = make_einvoice(si)
+		validate_totals(einvoice)
+
+		self.assertEqual(einvoice["ItemList"][0]["Discount"], 4000)
+		self.assertEqual(einvoice["ItemList"][1]["Discount"], 2100)
+		self.assertEqual(einvoice["ItemList"][2]["Discount"], 222)
+		self.assertEqual(einvoice["ItemList"][3]["Discount"], 5555)
+		self.assertEqual(einvoice["ValDtls"]["Discount"], 0)
+
+		self.assertEqual(einvoice["ItemList"][0]["UnitPrice"], 12)
+		self.assertEqual(einvoice["ItemList"][1]["UnitPrice"], 15)
+		self.assertEqual(einvoice["ItemList"][2]["UnitPrice"], 20)
+		self.assertEqual(einvoice["ItemList"][3]["UnitPrice"], 10)
+
+		# Invoice Discount on net total
+		si = get_sales_invoice_for_e_invoice()
+		si.apply_discount_on = "Net Total"
+		si.discount_amount = 400
+		si.save()
+
+		einvoice = make_einvoice(si)
+		validate_totals(einvoice)
+
+		self.assertEqual(einvoice["ItemList"][0]["Discount"], 253.61)
+		self.assertEqual(einvoice["ItemList"][1]["Discount"], 66.57)
+		self.assertEqual(einvoice["ItemList"][2]["Discount"], 243.11)
+		self.assertEqual(einvoice["ItemList"][3]["Discount"], 5613.71)
+		self.assertEqual(einvoice["ValDtls"]["Discount"], 0)
+
+		self.assertEqual(einvoice["ItemList"][0]["UnitPrice"], 12)
+		self.assertEqual(einvoice["ItemList"][1]["UnitPrice"], 15)
+		self.assertEqual(einvoice["ItemList"][2]["UnitPrice"], 20)
+		self.assertEqual(einvoice["ItemList"][3]["UnitPrice"], 10)
+
+		# Invoice Discount on grand total (Itemized Discount)
+		si = get_sales_invoice_for_e_invoice()
+		si.apply_discount_on = "Grand Total"
+		si.discount_amount = 400
+		si.save()
+
+		einvoice = make_einvoice(si)
+		validate_totals(einvoice)
+
+		self.assertEqual(einvoice["ItemList"][0]["Discount"], 214.93)
+		self.assertEqual(einvoice["ItemList"][1]["Discount"], 56.42)
+		self.assertEqual(einvoice["ItemList"][2]["Discount"], 239.89)
+		self.assertEqual(einvoice["ItemList"][3]["Discount"], 5604.75)
+		self.assertEqual(einvoice["ValDtls"]["Discount"], 0)
+
+		self.assertEqual(einvoice["ItemList"][0]["UnitPrice"], 12)
+		self.assertEqual(einvoice["ItemList"][1]["UnitPrice"], 15)
+		self.assertEqual(einvoice["ItemList"][2]["UnitPrice"], 20)
+		self.assertEqual(einvoice["ItemList"][3]["UnitPrice"], 10)
+
+		# Invoice Discount on grand total (Cash/Non-Trade Discount)
+		si = get_sales_invoice_for_e_invoice()
+		si.apply_discount_on = "Grand Total"
+		si.is_cash_or_non_trade_discount = 1
+		si.discount_amount = 400
+		si.save()
+
+		einvoice = make_einvoice(si)
+		validate_totals(einvoice)
+
+		self.assertEqual(einvoice["ItemList"][0]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][1]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][2]["Discount"], 222.0)
+		self.assertEqual(einvoice["ItemList"][3]["Discount"], 5555.0)
+		self.assertEqual(einvoice["ValDtls"]["Discount"], 400)
+
+		self.assertEqual(einvoice["ItemList"][0]["UnitPrice"], 12)
+		self.assertEqual(einvoice["ItemList"][1]["UnitPrice"], 15)
+		self.assertEqual(einvoice["ItemList"][2]["UnitPrice"], 20)
+		self.assertEqual(einvoice["ItemList"][3]["UnitPrice"], 10)
+
+		si = get_sales_invoice_for_e_invoice()
+		si.apply_discount_on = ""
+		si.items[1].price_list_rate = 15
+		si.items[1].discount_amount = -5
+		si.items[1].rate = 20
+		si.save()
+
+		einvoice = make_einvoice(si)
+		validate_totals(einvoice)
+
+		self.assertEqual(einvoice["ItemList"][1]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][1]["UnitPrice"], 20)
+
+	def test_einvoice_without_discounts(self):
+		from erpnext.regional.india.e_invoice.utils import make_einvoice, validate_totals
+
+		frappe.db.set_single_value("E Invoice Settings", "dont_show_discounts_in_e_invoice", True)
+
+		# Normal Itemized Discount
+		si = get_sales_invoice_for_e_invoice()
+		si.apply_discount_on = ""
+		si.items[0].price_list_rate = 12
+		si.items[0].discount_percentage = 16.6666666667
+		si.items[0].rate = 10
+
+		si.items[1].price_list_rate = 15
+		si.items[1].discount_amount = 5
+		si.items[1].rate = 10
+		si.save()
+
+		einvoice = make_einvoice(si)
+		validate_totals(einvoice)
+
+		self.assertEqual(einvoice["ItemList"][0]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][1]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][2]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][3]["Discount"], 0)
+		self.assertEqual(einvoice["ValDtls"]["Discount"], 0)
+
+		self.assertEqual(einvoice["ItemList"][0]["UnitPrice"], 10)
+		self.assertEqual(einvoice["ItemList"][1]["UnitPrice"], 10)
+		self.assertEqual(einvoice["ItemList"][2]["UnitPrice"], 18)
+		self.assertEqual(einvoice["ItemList"][3]["UnitPrice"], 5)
+
+		# Invoice Discount on net total
+		si = get_sales_invoice_for_e_invoice()
+		si.apply_discount_on = "Net Total"
+		si.discount_amount = 400
+		si.save()
+
+		einvoice = make_einvoice(si)
+		validate_totals(einvoice)
+
+		self.assertEqual(einvoice["ItemList"][0]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][1]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][2]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][3]["Discount"], 0)
+		self.assertEqual(einvoice["ValDtls"]["Discount"], 0)
+
+		self.assertEqual(einvoice["ItemList"][0]["UnitPrice"], 11.87)
+		self.assertEqual(einvoice["ItemList"][1]["UnitPrice"], 14.84)
+		self.assertEqual(einvoice["ItemList"][2]["UnitPrice"], 17.81)
+		self.assertEqual(einvoice["ItemList"][3]["UnitPrice"], 4.95)
+
+		# Invoice Discount on grand total (Itemized Discount)
+		si = get_sales_invoice_for_e_invoice()
+		si.apply_discount_on = "Grand Total"
+		si.discount_amount = 400
+		si.save()
+
+		einvoice = make_einvoice(si)
+		validate_totals(einvoice)
+
+		self.assertEqual(einvoice["ItemList"][0]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][1]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][2]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][3]["Discount"], 0)
+		self.assertEqual(einvoice["ValDtls"]["Discount"], 0)
+
+		self.assertEqual(einvoice["ItemList"][0]["UnitPrice"], 11.89)
+		self.assertEqual(einvoice["ItemList"][1]["UnitPrice"], 14.87)
+		self.assertEqual(einvoice["ItemList"][2]["UnitPrice"], 17.84)
+		self.assertEqual(einvoice["ItemList"][3]["UnitPrice"], 4.96)
+
+		# Invoice Discount on grand total (Cash/Non-Trade Discount)
+		si = get_sales_invoice_for_e_invoice()
+		si.apply_discount_on = "Grand Total"
+		si.is_cash_or_non_trade_discount = 1
+		si.discount_amount = 400
+		si.save()
+
+		einvoice = make_einvoice(si)
+		validate_totals(einvoice)
+
+		self.assertEqual(einvoice["ItemList"][0]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][1]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][2]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][3]["Discount"], 0)
+		self.assertEqual(einvoice["ValDtls"]["Discount"], 400)
+
+		self.assertEqual(einvoice["ItemList"][0]["UnitPrice"], 12)
+		self.assertEqual(einvoice["ItemList"][1]["UnitPrice"], 15)
+		self.assertEqual(einvoice["ItemList"][2]["UnitPrice"], 18)
+		self.assertEqual(einvoice["ItemList"][3]["UnitPrice"], 5)
+
+		si = get_sales_invoice_for_e_invoice()
+		si.apply_discount_on = ""
+		si.items[1].price_list_rate = 15
+		si.items[1].discount_amount = -5
+		si.items[1].rate = 20
+		si.save()
+
+		einvoice = make_einvoice(si)
+		validate_totals(einvoice)
+
+		self.assertEqual(einvoice["ItemList"][1]["Discount"], 0)
+		self.assertEqual(einvoice["ItemList"][1]["UnitPrice"], 20)
+
 	def test_item_tax_net_range(self):
 		item = create_item("T Shirt")
 
@@ -3042,7 +3295,7 @@ class TestSalesInvoice(unittest.TestCase):
 
 		acc_settings = frappe.get_single("Accounts Settings")
 		acc_settings.book_deferred_entries_via_journal_entry = 0
-		acc_settings.submit_journal_entriessubmit_journal_entries = 0
+		acc_settings.submit_journal_entries = 0
 		acc_settings.save()
 
 		frappe.db.set_value("Accounts Settings", None, "acc_frozen_upto", None)
@@ -3054,6 +3307,95 @@ class TestSalesInvoice(unittest.TestCase):
 		si.reload()
 		self.assertTrue(si.items[0].serial_no)
 
+	def test_sales_invoice_with_disabled_account(self):
+		try:
+			account = frappe.get_doc("Account", "VAT 5% - _TC")
+			account.disabled = 1
+			account.save()
+
+			si = create_sales_invoice(do_not_save=True)
+			si.posting_date = add_days(getdate(), 1)
+			si.taxes = []
+
+			si.append(
+				"taxes",
+				{
+					"charge_type": "On Net Total",
+					"account_head": "VAT 5% - _TC",
+					"cost_center": "Main - _TC",
+					"description": "VAT @ 5.0",
+					"rate": 9,
+				},
+			)
+			si.save()
+
+			with self.assertRaises(frappe.ValidationError) as err:
+				si.submit()
+
+			self.assertTrue(
+				"Cannot create accounting entries against disabled accounts" in str(err.exception)
+			)
+
+		finally:
+			account.disabled = 0
+			account.save()
+
+	def test_gain_loss_with_advance_entry(self):
+		from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
+
+		unlink_enabled = frappe.db.get_value(
+			"Accounts Settings", "Accounts Settings", "unlink_payment_on_cancel_of_invoice"
+		)
+
+		frappe.db.set_value(
+			"Accounts Settings", "Accounts Settings", "unlink_payment_on_cancel_of_invoice", 1
+		)
+
+		jv = make_journal_entry("_Test Receivable USD - _TC", "_Test Bank - _TC", -7000, save=False)
+
+		jv.accounts[0].exchange_rate = 70
+		jv.accounts[0].credit_in_account_currency = 100
+		jv.accounts[0].party_type = "Customer"
+		jv.accounts[0].party = "_Test Customer USD"
+
+		jv.save()
+		jv.submit()
+
+		si = create_sales_invoice(
+			customer="_Test Customer USD",
+			debit_to="_Test Receivable USD - _TC",
+			currency="USD",
+			conversion_rate=75,
+			do_not_save=1,
+			rate=100,
+		)
+
+		si.append(
+			"advances",
+			{
+				"reference_type": "Journal Entry",
+				"reference_name": jv.name,
+				"reference_row": jv.accounts[0].name,
+				"advance_amount": 100,
+				"allocated_amount": 100,
+				"ref_exchange_rate": 70,
+			},
+		)
+		si.save()
+		si.submit()
+
+		expected_gle = [
+			["_Test Receivable USD - _TC", 7500.0, 500],
+			["Exchange Gain/Loss - _TC", 500.0, 0.0],
+			["Sales - _TC", 0.0, 7500.0],
+		]
+
+		check_gl_entries(self, si.name, expected_gle, nowdate())
+
+		frappe.db.set_value(
+			"Accounts Settings", "Accounts Settings", "unlink_payment_on_cancel_of_invoice", unlink_enabled
+		)
+
 
 def get_sales_invoice_for_e_invoice():
 	si = make_sales_invoice_for_ewaybill()
@@ -3087,6 +3429,36 @@ def get_sales_invoice_for_e_invoice():
 		},
 	)
 
+	si.append(
+		"items",
+		{
+			"item_code": "_Test Item",
+			"uom": "Nos",
+			"warehouse": "_Test Warehouse - _TC",
+			"qty": 111,
+			"price_list_rate": 20,
+			"discount_percentage": 10,
+			"income_account": "Sales - _TC",
+			"expense_account": "Cost of Goods Sold - _TC",
+			"cost_center": "_Test Cost Center - _TC",
+		},
+	)
+
+	si.append(
+		"items",
+		{
+			"item_code": "_Test Item 2",
+			"uom": "Nos",
+			"warehouse": "_Test Warehouse - _TC",
+			"qty": 1111,
+			"price_list_rate": 10,
+			"rate": 5,
+			"income_account": "Sales - _TC",
+			"expense_account": "Cost of Goods Sold - _TC",
+			"cost_center": "_Test Cost Center - _TC",
+		},
+	)
+
 	return si
 
 

erpnext/accounts/general_ledger.py

@@ -29,6 +29,7 @@ def make_gl_entries(
 	if gl_map:
 		if not cancel:
 			validate_accounting_period(gl_map)
+			validate_disabled_accounts(gl_map)
 			gl_map = process_gl_map(gl_map, merge_entries)
 			if gl_map and len(gl_map) > 1:
 				save_entries(gl_map, adv_adj, update_outstanding, from_repost)
@@ -43,6 +44,26 @@ def make_gl_entries(
 			make_reverse_gl_entries(gl_map, adv_adj=adv_adj, update_outstanding=update_outstanding)
 
 
+def validate_disabled_accounts(gl_map):
+	accounts = [d.account for d in gl_map if d.account]
+
+	Account = frappe.qb.DocType("Account")
+
+	disabled_accounts = (
+		frappe.qb.from_(Account)
+		.where(Account.name.isin(accounts) & Account.disabled == 1)
+		.select(Account.name, Account.disabled)
+	).run(as_dict=True)
+
+	if disabled_accounts:
+		account_list = "<br>"
+		account_list += ", ".join([frappe.bold(d.name) for d in disabled_accounts])
+		frappe.throw(
+			_("Cannot create accounting entries against disabled accounts: {0}").format(account_list),
+			title=_("Disabled Account Selected"),
+		)
+
+
 def validate_accounting_period(gl_map):
 	accounting_periods = frappe.db.sql(
 		""" SELECT
@@ -127,6 +148,7 @@ def update_net_values(entry):
 def merge_similar_entries(gl_map, precision=None):
 	merged_gl_map = []
 	accounting_dimensions = get_accounting_dimensions()
+
 	for entry in gl_map:
 		# if there is already an entry in this account then just add it
 		# to that entry
@@ -208,9 +230,10 @@ def make_entry(args, adv_adj, update_outstanding, from_repost=False):
 	gle.flags.from_repost = from_repost
 	gle.flags.adv_adj = adv_adj
 	gle.flags.update_outstanding = update_outstanding or "Yes"
+	gle.flags.notify_update = False
 	gle.submit()
 
-	if not from_repost:
+	if not from_repost and gle.voucher_type != "Period Closing Voucher":
 		validate_expense_against_budget(args)
 
 
@@ -273,7 +296,7 @@ def round_off_debit_credit(gl_map):
 
 def make_round_off_gle(gl_map, debit_credit_diff, precision):
 	round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(
-		gl_map[0].company
+		gl_map[0].company, gl_map[0].voucher_type, gl_map[0].voucher_no
 	)
 	round_off_account_exists = False
 	round_off_gle = frappe._dict()
@@ -310,14 +333,43 @@ def make_round_off_gle(gl_map, debit_credit_diff, precision):
 		}
 	)
 
+	update_accounting_dimensions(round_off_gle)
+
 	if not round_off_account_exists:
 		gl_map.append(round_off_gle)
 
 
-def get_round_off_account_and_cost_center(company):
+def update_accounting_dimensions(round_off_gle):
+	dimensions = get_accounting_dimensions()
+	meta = frappe.get_meta(round_off_gle["voucher_type"])
+	has_all_dimensions = True
+
+	for dimension in dimensions:
+		if not meta.has_field(dimension):
+			has_all_dimensions = False
+
+	if dimensions and has_all_dimensions:
+		dimension_values = frappe.db.get_value(
+			round_off_gle["voucher_type"], round_off_gle["voucher_no"], dimensions, as_dict=1
+		)
+
+		for dimension in dimensions:
+			round_off_gle[dimension] = dimension_values.get(dimension)
+
+
+def get_round_off_account_and_cost_center(company, voucher_type, voucher_no):
 	round_off_account, round_off_cost_center = frappe.get_cached_value(
 		"Company", company, ["round_off_account", "round_off_cost_center"]
 	) or [None, None]
+
+	meta = frappe.get_meta(voucher_type)
+
+	# Give first preference to parent cost center for round off GLE
+	if meta.has_field("cost_center"):
+		parent_cost_center = frappe.db.get_value(voucher_type, voucher_no, "cost_center")
+		if parent_cost_center:
+			round_off_cost_center = parent_cost_center
+
 	if not round_off_account:
 		frappe.throw(_("Please mention Round Off Account in Company"))
 

erpnext/accounts/party.py

@@ -212,7 +212,7 @@ def set_address_details(
 	else:
 		party_details.update(get_company_address(company))
 
-	if doctype and doctype in ["Delivery Note", "Sales Invoice", "Sales Order"]:
+	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)
@@ -898,3 +898,18 @@ def get_default_contact(doctype, name):
 			return None
 	else:
 		return None
+
+
+def add_party_account(party_type, party, company, account):
+	doc = frappe.get_doc(party_type, party)
+	account_exists = False
+	for d in doc.get("accounts"):
+		if d.account == account:
+			account_exists = True
+
+	if not account_exists:
+		accounts = {"company": company, "account": account}
+
+		doc.append("accounts", accounts)
+
+		doc.save()

erpnext/accounts/report/accounts_payable/accounts_payable.js

@@ -53,6 +53,22 @@ frappe.query_reports["Accounts Payable"] = {
 				}
 			}
 		},
+		{
+			"fieldname": "party_account",
+			"label": __("Payable Account"),
+			"fieldtype": "Link",
+			"options": "Account",
+			get_query: () => {
+				var company = frappe.query_report.get_filter_value('company');
+				return {
+					filters: {
+						'company': company,
+						'account_type': 'Payable',
+						'is_group': 0
+					}
+				};
+			}
+		},
 		{
 			"fieldname": "ageing_based_on",
 			"label": __("Ageing Based On"),

erpnext/accounts/report/accounts_receivable/accounts_receivable.html

@@ -42,7 +42,7 @@
 
 	{% if(filters.show_future_payments) { %}
 		{% var balance_row = data.slice(-1).pop();
-			var start = filters.based_on_payment_terms ? 13 : 11;
+			var start = report.columns.findIndex((elem) => (elem.fieldname == 'age'));
 			var range1 = report.columns[start].label;
 			var range2 = report.columns[start+1].label;
 			var range3 = report.columns[start+2].label;

erpnext/accounts/report/accounts_receivable/accounts_receivable.js

@@ -66,6 +66,22 @@ frappe.query_reports["Accounts Receivable"] = {
 				}
 			}
 		},
+		{
+			"fieldname": "party_account",
+			"label": __("Receivable Account"),
+			"fieldtype": "Link",
+			"options": "Account",
+			get_query: () => {
+				var company = frappe.query_report.get_filter_value('company');
+				return {
+					filters: {
+						'company': company,
+						'account_type': 'Receivable',
+						'is_group': 0
+					}
+				};
+			}
+		},
 		{
 			"fieldname": "ageing_based_on",
 			"label": __("Ageing Based On"),

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -111,6 +111,7 @@ class ReceivablePayableReport(object):
 					voucher_type=gle.voucher_type,
 					voucher_no=gle.voucher_no,
 					party=gle.party,
+					party_account=gle.account,
 					posting_date=gle.posting_date,
 					account_currency=gle.account_currency,
 					remarks=gle.remarks if self.filters.get("show_remarks") else None,
@@ -777,18 +778,21 @@ class ReceivablePayableReport(object):
 			conditions.append("party=%s")
 			values.append(self.filters.get(party_type_field))
 
-		# get GL with "receivable" or "payable" account_type
-		account_type = "Receivable" if self.party_type == "Customer" else "Payable"
-		accounts = [
-			d.name
-			for d in frappe.get_all(
-				"Account", filters={"account_type": account_type, "company": self.filters.company}
-			)
-		]
-
-		if accounts:
-			conditions.append("account in (%s)" % ",".join(["%s"] * len(accounts)))
-			values += accounts
+		if self.filters.party_account:
+			conditions.append("account =%s")
+			values.append(self.filters.party_account)
+		else:
+			# get GL with "receivable" or "payable" account_type
+			account_type = "Receivable" if self.party_type == "Customer" else "Payable"
+			accounts = [
+				d.name
+				for d in frappe.get_all(
+					"Account", filters={"account_type": account_type, "company": self.filters.company}
+				)
+			]
+			if accounts:
+				conditions.append("account in (%s)" % ",".join(["%s"] * len(accounts)))
+				values += accounts
 
 	def add_customer_filters(self, conditions, values):
 		if self.filters.get("customer_group"):
@@ -889,6 +893,14 @@ class ReceivablePayableReport(object):
 			width=180,
 		)
 
+		self.add_column(
+			label="Receivable Account" if self.party_type == "Customer" else "Payable Account",
+			fieldname="party_account",
+			fieldtype="Link",
+			options="Account",
+			width=180,
+		)
+
 		if self.party_naming_by == "Naming Series":
 			self.add_column(
 				_("{0} Name").format(self.party_type),

erpnext/accounts/report/accounts_receivable/test_accounts_receivable.py

@@ -50,12 +50,19 @@ class TestAccountsReceivable(unittest.TestCase):
 		make_credit_note(name)
 		report = execute(filters)
 
-		expected_data_after_credit_note = [100, 0, 0, 40, -40]
+		expected_data_after_credit_note = [100, 0, 0, 40, -40, "Debtors - _TC2"]
 
 		row = report[1][0]
 		self.assertEqual(
 			expected_data_after_credit_note,
-			[row.invoice_grand_total, row.invoiced, row.paid, row.credit_note, row.outstanding],
+			[
+				row.invoice_grand_total,
+				row.invoiced,
+				row.paid,
+				row.credit_note,
+				row.outstanding,
+				row.party_account,
+			],
 		)
 
 

erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py

@@ -43,7 +43,7 @@ def get_columns():
 			"options": "Account",
 			"width": 170,
 		},
-		{"label": _("Amount"), "fieldname": "amount", "width": 120},
+		{"label": _("Amount"), "fieldname": "amount", "fieldtype": "Currency", "width": 120},
 	]
 
 	return columns

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py

@@ -198,12 +198,14 @@ def get_loan_entries(filters):
 			amount_field = (loan_doc.disbursed_amount).as_("credit")
 			posting_date = (loan_doc.disbursement_date).as_("posting_date")
 			account = loan_doc.disbursement_account
+			salary_condition = loan_doc.docstatus == 1
 		else:
 			amount_field = (loan_doc.amount_paid).as_("debit")
 			posting_date = (loan_doc.posting_date).as_("posting_date")
 			account = loan_doc.payment_account
+			salary_condition = loan_doc.repay_from_salary == 0
 
-		entries = (
+		query = (
 			frappe.qb.from_(loan_doc)
 			.select(
 				ConstantColumn(doctype).as_("payment_document"),
@@ -214,12 +216,13 @@ def get_loan_entries(filters):
 				posting_date,
 			)
 			.where(loan_doc.docstatus == 1)
+			.where(salary_condition)
 			.where(account == filters.get("account"))
 			.where(posting_date <= getdate(filters.get("report_date")))
 			.where(ifnull(loan_doc.clearance_date, "4000-01-01") > getdate(filters.get("report_date")))
-			.run(as_dict=1)
 		)
 
+		entries = query.run(as_dict=1)
 		loan_docs.extend(entries)
 
 	return loan_docs
@@ -264,15 +267,17 @@ def get_loan_amount(filters):
 			amount_field = Sum(loan_doc.disbursed_amount)
 			posting_date = (loan_doc.disbursement_date).as_("posting_date")
 			account = loan_doc.disbursement_account
+			salary_condition = loan_doc.docstatus == 1
 		else:
 			amount_field = Sum(loan_doc.amount_paid)
 			posting_date = (loan_doc.posting_date).as_("posting_date")
 			account = loan_doc.payment_account
-
+			salary_condition = loan_doc.repay_from_salary == 0
 		amount = (
 			frappe.qb.from_(loan_doc)
 			.select(amount_field)
 			.where(loan_doc.docstatus == 1)
+			.where(salary_condition)
 			.where(account == filters.get("account"))
 			.where(posting_date > getdate(filters.get("report_date")))
 			.where(ifnull(loan_doc.clearance_date, "4000-01-01") <= getdate(filters.get("report_date")))

erpnext/accounts/report/cash_flow/cash_flow.py

@@ -263,7 +263,10 @@ def get_report_summary(summary_data, currency):
 def get_chart_data(columns, data):
 	labels = [d.get("label") for d in columns[2:]]
 	datasets = [
-		{"name": account.get("account").replace("'", ""), "values": [account.get("total")]}
+		{
+			"name": account.get("account").replace("'", ""),
+			"values": [account.get(d.get("fieldname")) for d in columns[2:]],
+		}
 		for account in data
 		if account.get("parent_account") == None and account.get("currency")
 	]

erpnext/accounts/report/financial_statements.py

@@ -539,7 +539,7 @@ def get_additional_conditions(from_date, ignore_closing_entries, filters):
 					)
 					additional_conditions.append("{0} in %({0})s".format(dimension.fieldname))
 				else:
-					additional_conditions.append("{0} in (%({0})s)".format(dimension.fieldname))
+					additional_conditions.append("{0} in %({0})s".format(dimension.fieldname))
 
 	return " and {}".format(" and ".join(additional_conditions)) if additional_conditions else ""
 

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -318,7 +318,7 @@ def get_conditions(filters):
 							)
 							conditions.append("{0} in %({0})s".format(dimension.fieldname))
 						else:
-							conditions.append("{0} in (%({0})s)".format(dimension.fieldname))
+							conditions.append("{0} in %({0})s".format(dimension.fieldname))
 
 	return "and {}".format(" and ".join(conditions)) if conditions else ""
 
@@ -468,7 +468,7 @@ def get_accountwise_gle(filters, accounting_dimensions, gl_entries, gle_map):
 			update_value_in_dict(totals, "opening", gle)
 			update_value_in_dict(totals, "closing", gle)
 
-		elif gle.posting_date <= to_date:
+		elif gle.posting_date <= to_date or (cstr(gle.is_opening) == "Yes" and show_opening_entries):
 			if not group_by_voucher_consolidated:
 				update_value_in_dict(gle_map[group_by_value].totals, "total", gle)
 				update_value_in_dict(gle_map[group_by_value].totals, "closing", gle)
@@ -478,7 +478,13 @@ def get_accountwise_gle(filters, accounting_dimensions, gl_entries, gle_map):
 				gle_map[group_by_value].entries.append(gle)
 
 			elif group_by_voucher_consolidated:
-				keylist = [gle.get("voucher_type"), gle.get("voucher_no"), gle.get("account")]
+				keylist = [
+					gle.get("voucher_type"),
+					gle.get("voucher_no"),
+					gle.get("account"),
+					gle.get("party_type"),
+					gle.get("party"),
+				]
 				if filters.get("include_dimensions"):
 					for dim in accounting_dimensions:
 						keylist.append(gle.get(dim))

erpnext/accounts/report/gross_profit/gross_profit.js

@@ -44,14 +44,14 @@ frappe.query_reports["Gross Profit"] = {
 	"parent_field": "parent_invoice",
 	"initial_depth": 3,
 	"formatter": function(value, row, column, data, default_formatter) {
-		if (column.fieldname == "sales_invoice" && column.options == "Item" && data.indent == 0) {
+		if (column.fieldname == "sales_invoice" && column.options == "Item" && data && data.indent == 0) {
 			column._options = "Sales Invoice";
 		} else {
 			column._options = "Item";
 		}
 		value = default_formatter(value, row, column, data);
 
-		if (data && (data.indent == 0.0 || row[1].content == "Total")) {
+		if (data && (data.indent == 0.0 || (row[1] && row[1].content == "Total"))) {
 			value = $(`<span>${value}</span>`);
 			var $value = $(value).css("font-weight", "bold");
 			value = $value.wrap("<p></p>").parent().html();

erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py

@@ -443,12 +443,6 @@ def get_grand_total(filters, doctype):
 	]  # nosec
 
 
-def get_deducted_taxes():
-	return frappe.db.sql_list(
-		"select name from `tabPurchase Taxes and Charges` where add_deduct_tax = 'Deduct'"
-	)
-
-
 def get_tax_accounts(
 	item_list,
 	columns,
@@ -462,6 +456,7 @@ def get_tax_accounts(
 	tax_columns = []
 	invoice_item_row = {}
 	itemised_tax = {}
+	add_deduct_tax = "charge_type"
 
 	tax_amount_precision = (
 		get_field_precision(
@@ -477,13 +472,13 @@ def get_tax_accounts(
 	conditions = ""
 	if doctype == "Purchase Invoice":
 		conditions = " and category in ('Total', 'Valuation and Total') and base_tax_amount_after_discount_amount != 0"
+		add_deduct_tax = "add_deduct_tax"
 
-	deducted_tax = get_deducted_taxes()
 	tax_details = frappe.db.sql(
 		"""
 		select
 			name, parent, description, item_wise_tax_detail,
-			charge_type, base_tax_amount_after_discount_amount
+			charge_type, {add_deduct_tax}, base_tax_amount_after_discount_amount
 		from `tab%s`
 		where
 			parenttype = %s and docstatus = 1
@@ -491,12 +486,22 @@ def get_tax_accounts(
 			and parent in (%s)
 			%s
 		order by description
-	"""
+	""".format(
+			add_deduct_tax=add_deduct_tax
+		)
 		% (tax_doctype, "%s", ", ".join(["%s"] * len(invoice_item_row)), conditions),
 		tuple([doctype] + list(invoice_item_row)),
 	)
 
-	for name, parent, description, item_wise_tax_detail, charge_type, tax_amount in tax_details:
+	for (
+		name,
+		parent,
+		description,
+		item_wise_tax_detail,
+		charge_type,
+		add_deduct_tax,
+		tax_amount,
+	) in tax_details:
 		description = handle_html(description)
 		if description not in tax_columns and tax_amount:
 			# as description is text editor earlier and markup can break the column convention in reports
@@ -529,7 +534,9 @@ def get_tax_accounts(
 						if item_tax_amount:
 							tax_value = flt(item_tax_amount, tax_amount_precision)
 							tax_value = (
-								tax_value * -1 if (doctype == "Purchase Invoice" and name in deducted_tax) else tax_value
+								tax_value * -1
+								if (doctype == "Purchase Invoice" and add_deduct_tax == "Deduct")
+								else tax_value
 							)
 
 							itemised_tax.setdefault(d.name, {})[description] = frappe._dict(

erpnext/accounts/report/pos_register/pos_register.py

@@ -62,7 +62,7 @@ def get_pos_entries(filters, group_by_field):
 		"""
 		SELECT
 			p.posting_date, p.name as pos_invoice, p.pos_profile,
-			p.owner, p.base_grand_total as grand_total, p.base_paid_amount as paid_amount,
+			p.owner, p.base_grand_total as grand_total, p.base_paid_amount - p.change_amount  as paid_amount,
 			p.customer, p.is_return {select_mop_field}
 		FROM
 			`tabPOS Invoice` p {from_sales_invoice_payment}

erpnext/accounts/report/profitability_analysis/profitability_analysis.py

@@ -228,6 +228,7 @@ def set_gl_entries_by_account(
 		{additional_conditions}
 		and posting_date <= %(to_date)s
 		and {based_on} is not null
+		and is_cancelled = 0
 		order by {based_on}, posting_date""".format(
 			additional_conditions="\n".join(additional_conditions), based_on=based_on
 		),

erpnext/accounts/report/purchase_register/purchase_register.py

@@ -124,11 +124,10 @@ def get_columns(invoice_list, additional_table_columns):
 		_("Purchase Receipt") + ":Link/Purchase Receipt:100",
 		{"fieldname": "currency", "label": _("Currency"), "fieldtype": "Data", "width": 80},
 	]
-	expense_accounts = (
-		tax_accounts
-	) = (
-		expense_columns
-	) = tax_columns = unrealized_profit_loss_accounts = unrealized_profit_loss_account_columns = []
+
+	expense_accounts = []
+	tax_accounts = []
+	unrealized_profit_loss_accounts = []
 
 	if invoice_list:
 		expense_accounts = frappe.db.sql_list(
@@ -163,10 +162,11 @@ def get_columns(invoice_list, additional_table_columns):
 	unrealized_profit_loss_account_columns = [
 		(account + ":Currency/currency:120") for account in unrealized_profit_loss_accounts
 	]
-
-	for account in tax_accounts:
-		if account not in expense_accounts:
-			tax_columns.append(account + ":Currency/currency:120")
+	tax_columns = [
+		(account + ":Currency/currency:120")
+		for account in tax_accounts
+		if account not in expense_accounts
+	]
 
 	columns = (
 		columns
@@ -237,7 +237,7 @@ def get_conditions(filters):
 				else:
 					conditions += (
 						common_condition
-						+ "and ifnull(`tabPurchase Invoice Item`.{0}, '') in (%({0})s))".format(dimension.fieldname)
+						+ "and ifnull(`tabPurchase Invoice Item`.{0}, '') in %({0})s)".format(dimension.fieldname)
 					)
 
 	return conditions

erpnext/accounts/report/sales_register/sales_register.py

@@ -346,9 +346,13 @@ def get_columns(invoice_list, additional_table_columns):
 def get_conditions(filters):
 	conditions = ""
 
+	accounting_dimensions = get_accounting_dimensions(as_list=False) or []
+	accounting_dimensions_list = [d.fieldname for d in accounting_dimensions]
+
 	if filters.get("company"):
 		conditions += " and company=%(company)s"
-	if filters.get("customer"):
+
+	if filters.get("customer") and "customer" not in accounting_dimensions_list:
 		conditions += " and customer = %(customer)s"
 
 	if filters.get("from_date"):
@@ -359,32 +363,18 @@ def get_conditions(filters):
 	if filters.get("owner"):
 		conditions += " and owner = %(owner)s"
 
-	if filters.get("mode_of_payment"):
-		conditions += """ and exists(select name from `tabSales Invoice Payment`
-			 where parent=`tabSales Invoice`.name
-			 	and ifnull(`tabSales Invoice Payment`.mode_of_payment, '') = %(mode_of_payment)s)"""
+	def get_sales_invoice_item_field_condition(field, table="Sales Invoice Item") -> str:
+		if not filters.get(field) or field in accounting_dimensions_list:
+			return ""
+		return f""" and exists(select name from `tab{table}`
+				where parent=`tabSales Invoice`.name
+					and ifnull(`tab{table}`.{field}, '') = %({field})s)"""
 
-	if filters.get("cost_center"):
-		conditions += """ and exists(select name from `tabSales Invoice Item`
-			 where parent=`tabSales Invoice`.name
-			 	and ifnull(`tabSales Invoice Item`.cost_center, '') = %(cost_center)s)"""
-
-	if filters.get("warehouse"):
-		conditions += """ and exists(select name from `tabSales Invoice Item`
-			 where parent=`tabSales Invoice`.name
-			 	and ifnull(`tabSales Invoice Item`.warehouse, '') = %(warehouse)s)"""
-
-	if filters.get("brand"):
-		conditions += """ and exists(select name from `tabSales Invoice Item`
-			 where parent=`tabSales Invoice`.name
-			 	and ifnull(`tabSales Invoice Item`.brand, '') = %(brand)s)"""
-
-	if filters.get("item_group"):
-		conditions += """ and exists(select name from `tabSales Invoice Item`
-			 where parent=`tabSales Invoice`.name
-			 	and ifnull(`tabSales Invoice Item`.item_group, '') = %(item_group)s)"""
-
-	accounting_dimensions = get_accounting_dimensions(as_list=False)
+	conditions += get_sales_invoice_item_field_condition("mode_of_payments", "Sales Invoice Payment")
+	conditions += get_sales_invoice_item_field_condition("cost_center")
+	conditions += get_sales_invoice_item_field_condition("warehouse")
+	conditions += get_sales_invoice_item_field_condition("brand")
+	conditions += get_sales_invoice_item_field_condition("item_group")
 
 	if accounting_dimensions:
 		common_condition = """
@@ -405,7 +395,7 @@ def get_conditions(filters):
 				else:
 					conditions += (
 						common_condition
-						+ "and ifnull(`tabSales Invoice Item`.{0}, '') in (%({0})s))".format(dimension.fieldname)
+						+ "and ifnull(`tabSales Invoice Item`.{0}, '') in %({0})s)".format(dimension.fieldname)
 					)
 
 	return conditions

erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py

@@ -14,9 +14,9 @@ def execute(filters=None):
 	filters.naming_series = frappe.db.get_single_value("Buying Settings", "supp_master_name")
 
 	columns = get_columns(filters)
-	tds_docs, tds_accounts, tax_category_map = get_tds_docs(filters)
+	tds_docs, tds_accounts, tax_category_map, journal_entry_party_map = get_tds_docs(filters)
 
-	res = get_result(filters, tds_docs, tds_accounts, tax_category_map)
+	res = get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_party_map)
 	final_result = group_by_supplier_and_category(res)
 
 	return columns, final_result

erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py

@@ -8,11 +8,11 @@ from frappe import _
 
 def execute(filters=None):
 	validate_filters(filters)
-	tds_docs, tds_accounts, tax_category_map = get_tds_docs(filters)
+	tds_docs, tds_accounts, tax_category_map, journal_entry_party_map = get_tds_docs(filters)
 
 	columns = get_columns(filters)
 
-	res = get_result(filters, tds_docs, tds_accounts, tax_category_map)
+	res = get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_party_map)
 	return columns, res
 
 
@@ -22,7 +22,7 @@ def validate_filters(filters):
 		frappe.throw(_("From Date must be before To Date"))
 
 
-def get_result(filters, tds_docs, tds_accounts, tax_category_map):
+def get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_party_map):
 	supplier_map = get_supplier_pan_map()
 	tax_rate_map = get_tax_rate_map(filters)
 	gle_map = get_gle_map(tds_docs)
@@ -38,6 +38,11 @@ def get_result(filters, tds_docs, tds_accounts, tax_category_map):
 			posting_date = entry.posting_date
 			voucher_type = entry.voucher_type
 
+			if voucher_type == "Journal Entry":
+				suppliers = journal_entry_party_map.get(name)
+				if suppliers:
+					supplier = suppliers[0]
+
 			if not tax_withholding_category:
 				tax_withholding_category = supplier_map.get(supplier, {}).get("tax_withholding_category")
 				rate = tax_rate_map.get(tax_withholding_category)
@@ -176,6 +181,7 @@ def get_tds_docs(filters):
 	journal_entries = []
 	tax_category_map = {}
 	or_filters = {}
+	journal_entry_party_map = {}
 	bank_accounts = frappe.get_all("Account", {"is_group": 0, "account_type": "Bank"}, pluck="name")
 
 	tds_accounts = frappe.get_all(
@@ -218,9 +224,24 @@ def get_tds_docs(filters):
 		get_tax_category_map(payment_entries, "Payment Entry", tax_category_map)
 
 	if journal_entries:
+		journal_entry_party_map = get_journal_entry_party_map(journal_entries)
 		get_tax_category_map(journal_entries, "Journal Entry", tax_category_map)
 
-	return tds_documents, tds_accounts, tax_category_map
+	return tds_documents, tds_accounts, tax_category_map, journal_entry_party_map
+
+
+def get_journal_entry_party_map(journal_entries):
+	journal_entry_party_map = {}
+	for d in frappe.db.get_all(
+		"Journal Entry Account",
+		{"parent": ("in", journal_entries), "party_type": "Supplier", "party": ("is", "set")},
+		["parent", "party"],
+	):
+		if d.parent not in journal_entry_party_map:
+			journal_entry_party_map[d.parent] = []
+		journal_entry_party_map[d.parent].append(d.party)
+
+	return journal_entry_party_map
 
 
 def get_tax_category_map(vouchers, doctype, tax_category_map):

erpnext/accounts/report/trial_balance/trial_balance.py

@@ -160,14 +160,12 @@ def get_rootwise_opening_balances(filters, report_type):
 	if filters.project:
 		additional_conditions += " and project = %(project)s"
 
-	if filters.finance_book:
-		fb_conditions = " AND finance_book = %(finance_book)s"
-		if filters.include_default_book_entries:
-			fb_conditions = (
-				" AND (finance_book in (%(finance_book)s, %(company_fb)s, '') OR finance_book IS NULL)"
-			)
-
-		additional_conditions += fb_conditions
+	if filters.get("include_default_book_entries"):
+		additional_conditions += (
+			" AND (finance_book in (%(finance_book)s, %(company_fb)s, '') OR finance_book IS NULL)"
+		)
+	else:
+		additional_conditions += " AND (finance_book in (%(finance_book)s, '') OR finance_book IS NULL)"
 
 	accounting_dimensions = get_accounting_dimensions(as_list=False)
 
@@ -188,9 +186,9 @@ def get_rootwise_opening_balances(filters, report_type):
 					filters[dimension.fieldname] = get_dimension_with_children(
 						dimension.document_type, filters.get(dimension.fieldname)
 					)
-					additional_conditions += "and {0} in %({0})s".format(dimension.fieldname)
+					additional_conditions += " and {0} in %({0})s".format(dimension.fieldname)
 				else:
-					additional_conditions += "and {0} in (%({0})s)".format(dimension.fieldname)
+					additional_conditions += " and {0} in %({0})s".format(dimension.fieldname)
 
 				query_filters.update({dimension.fieldname: filters.get(dimension.fieldname)})
 

erpnext/accounts/test/test_reports.py

@@ -0,0 +1,49 @@
+import unittest
+from typing import List, Tuple
+
+from erpnext.tests.utils import ReportFilters, ReportName, execute_script_report
+
+DEFAULT_FILTERS = {
+	"company": "_Test Company",
+	"from_date": "2010-01-01",
+	"to_date": "2030-01-01",
+	"period_start_date": "2010-01-01",
+	"period_end_date": "2030-01-01",
+}
+
+
+REPORT_FILTER_TEST_CASES: List[Tuple[ReportName, ReportFilters]] = [
+	("General Ledger", {"group_by": "Group by Voucher (Consolidated)"}),
+	("General Ledger", {"group_by": "Group by Voucher (Consolidated)", "include_dimensions": 1}),
+	("Accounts Payable", {"range1": 30, "range2": 60, "range3": 90, "range4": 120}),
+	("Accounts Receivable", {"range1": 30, "range2": 60, "range3": 90, "range4": 120}),
+	("Consolidated Financial Statement", {"report": "Balance Sheet"}),
+	("Consolidated Financial Statement", {"report": "Profit and Loss Statement"}),
+	("Consolidated Financial Statement", {"report": "Cash Flow"}),
+	("Gross Profit", {"group_by": "Invoice"}),
+	("Gross Profit", {"group_by": "Item Code"}),
+	("Gross Profit", {"group_by": "Item Group"}),
+	("Gross Profit", {"group_by": "Customer"}),
+	("Gross Profit", {"group_by": "Customer Group"}),
+	("Item-wise Sales Register", {}),
+	("Item-wise Purchase Register", {}),
+	("Sales Register", {}),
+	("Sales Register", {"item_group": "All Item Groups"}),
+	("Purchase Register", {}),
+]
+
+OPTIONAL_FILTERS = {}
+
+
+class TestReports(unittest.TestCase):
+	def test_execute_all_accounts_reports(self):
+		"""Test that all script report in stock modules are executable with supported filters"""
+		for report, filter in REPORT_FILTER_TEST_CASES:
+			with self.subTest(report=report):
+				execute_script_report(
+					report_name=report,
+					module="Accounts",
+					filters=filter,
+					default_filters=DEFAULT_FILTERS,
+					optional_filters=OPTIONAL_FILTERS if filter.get("_optional") else None,
+				)

erpnext/accounts/test/test_utils.py

@@ -1,10 +1,17 @@
 import unittest
 
+import frappe
 from frappe.test_runner import make_test_objects
 
 from erpnext.accounts.party import get_party_shipping_address
-from erpnext.accounts.utils import get_future_stock_vouchers, get_voucherwise_gl_entries
+from erpnext.accounts.utils import (
+	get_future_stock_vouchers,
+	get_voucherwise_gl_entries,
+	sort_stock_vouchers_by_posting_date,
+)
+from erpnext.stock.doctype.item.test_item import make_item
 from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
+from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry
 
 
 class TestUtils(unittest.TestCase):
@@ -47,6 +54,25 @@ class TestUtils(unittest.TestCase):
 			msg="get_voucherwise_gl_entries not returning expected GLes",
 		)
 
+	def test_stock_voucher_sorting(self):
+		vouchers = []
+
+		item = make_item().name
+
+		stock_entry = {"item": item, "to_warehouse": "_Test Warehouse - _TC", "qty": 1, "rate": 10}
+
+		se1 = make_stock_entry(posting_date="2022-01-01", **stock_entry)
+		se3 = make_stock_entry(posting_date="2022-03-01", **stock_entry)
+		se2 = make_stock_entry(posting_date="2022-02-01", **stock_entry)
+
+		for doc in (se1, se2, se3):
+			vouchers.append((doc.doctype, doc.name))
+
+		vouchers.append(("Stock Entry", "Wat"))
+
+		sorted_vouchers = sort_stock_vouchers_by_posting_date(list(reversed(vouchers)))
+		self.assertEqual(sorted_vouchers, vouchers)
+
 
 ADDRESS_RECORDS = [
 	{

erpnext/accounts/utils.py

@@ -3,12 +3,23 @@
 
 
 from json import loads
+from typing import TYPE_CHECKING, List, Optional, Tuple
 
 import frappe
 import frappe.defaults
 from frappe import _, throw
 from frappe.model.meta import get_field_precision
-from frappe.utils import cint, cstr, flt, formatdate, get_number_format_info, getdate, now, nowdate
+from frappe.utils import (
+	cint,
+	create_batch,
+	cstr,
+	flt,
+	formatdate,
+	get_number_format_info,
+	getdate,
+	now,
+	nowdate,
+)
 from six import string_types
 
 import erpnext
@@ -18,9 +29,8 @@ from erpnext.accounts.doctype.account.account import get_account_currency  # noq
 from erpnext.stock import get_warehouse_account_map
 from erpnext.stock.utils import get_stock_value_on
 
-
-class StockValueAndAccountBalanceOutOfSync(frappe.ValidationError):
-	pass
+if TYPE_CHECKING:
+	from erpnext.stock.doctype.repost_item_valuation.repost_item_valuation import RepostItemValuation
 
 
 class FiscalYearError(frappe.ValidationError):
@@ -31,6 +41,9 @@ class PaymentEntryUnlinkError(frappe.ValidationError):
 	pass
 
 
+GL_REPOSTING_CHUNK = 100
+
+
 @frappe.whitelist()
 def get_fiscal_year(
 	date=None, fiscal_year=None, label="Date", verbose=1, company=None, as_dict=False
@@ -1125,33 +1138,79 @@ def update_gl_entries_after(
 
 
 def repost_gle_for_stock_vouchers(
-	stock_vouchers, posting_date, company=None, warehouse_account=None
+	stock_vouchers: List[Tuple[str, str]],
+	posting_date: str,
+	company: Optional[str] = None,
+	warehouse_account=None,
+	repost_doc: Optional["RepostItemValuation"] = None,
 ):
-	def _delete_gl_entries(voucher_type, voucher_no):
-		frappe.db.sql(
-			"""delete from `tabGL Entry`
-			where voucher_type=%s and voucher_no=%s""",
-			(voucher_type, voucher_no),
-		)
+	if not stock_vouchers:
+		return
 
 	if not warehouse_account:
 		warehouse_account = get_warehouse_account_map(company)
 
 	precision = get_field_precision(frappe.get_meta("GL Entry").get_field("debit")) or 2
 
-	gle = get_voucherwise_gl_entries(stock_vouchers, posting_date)
-	for voucher_type, voucher_no in stock_vouchers:
-		existing_gle = gle.get((voucher_type, voucher_no), [])
-		voucher_obj = frappe.get_cached_doc(voucher_type, voucher_no)
-		expected_gle = voucher_obj.get_gl_entries(warehouse_account)
-		if expected_gle:
-			if not existing_gle or not compare_existing_and_expected_gle(
-				existing_gle, expected_gle, precision
-			):
+	stock_vouchers = sort_stock_vouchers_by_posting_date(stock_vouchers)
+	if repost_doc and repost_doc.gl_reposting_index:
+		# Restore progress
+		stock_vouchers = stock_vouchers[cint(repost_doc.gl_reposting_index) :]
+
+	for stock_vouchers_chunk in create_batch(stock_vouchers, GL_REPOSTING_CHUNK):
+		gle = get_voucherwise_gl_entries(stock_vouchers_chunk, posting_date)
+		for voucher_type, voucher_no in stock_vouchers_chunk:
+			existing_gle = gle.get((voucher_type, voucher_no), [])
+			voucher_obj = frappe.get_doc(voucher_type, voucher_no)
+			expected_gle = voucher_obj.get_gl_entries(warehouse_account)
+			if expected_gle:
+				if not existing_gle or not compare_existing_and_expected_gle(
+					existing_gle, expected_gle, precision
+				):
+					_delete_gl_entries(voucher_type, voucher_no)
+					voucher_obj.make_gl_entries(gl_entries=expected_gle, from_repost=True)
+			else:
 				_delete_gl_entries(voucher_type, voucher_no)
-				voucher_obj.make_gl_entries(gl_entries=expected_gle, from_repost=True)
-		else:
-			_delete_gl_entries(voucher_type, voucher_no)
+
+		if not frappe.flags.in_test:
+			frappe.db.commit()
+
+		if repost_doc:
+			repost_doc.db_set(
+				"gl_reposting_index", cint(repost_doc.gl_reposting_index) + len(stock_vouchers_chunk)
+			)
+
+
+def _delete_gl_entries(voucher_type, voucher_no):
+	frappe.db.sql(
+		"""delete from `tabGL Entry`
+		where voucher_type=%s and voucher_no=%s""",
+		(voucher_type, voucher_no),
+	)
+
+
+def sort_stock_vouchers_by_posting_date(
+	stock_vouchers: List[Tuple[str, str]]
+) -> List[Tuple[str, str]]:
+	sle = frappe.qb.DocType("Stock Ledger Entry")
+	voucher_nos = [v[1] for v in stock_vouchers]
+
+	sles = (
+		frappe.qb.from_(sle)
+		.select(sle.voucher_type, sle.voucher_no, sle.posting_date, sle.posting_time, sle.creation)
+		.where((sle.is_cancelled == 0) & (sle.voucher_no.isin(voucher_nos)))
+		.groupby(sle.voucher_type, sle.voucher_no)
+		.orderby(sle.posting_date)
+		.orderby(sle.posting_time)
+		.orderby(sle.creation)
+	).run(as_dict=True)
+	sorted_vouchers = [(sle.voucher_type, sle.voucher_no) for sle in sles]
+
+	unknown_vouchers = set(stock_vouchers) - set(sorted_vouchers)
+	if unknown_vouchers:
+		sorted_vouchers.extend(unknown_vouchers)
+
+	return sorted_vouchers
 
 
 def get_future_stock_vouchers(
@@ -1247,47 +1306,6 @@ def compare_existing_and_expected_gle(existing_gle, expected_gle, precision):
 	return matched
 
 
-def check_if_stock_and_account_balance_synced(
-	posting_date, company, voucher_type=None, voucher_no=None
-):
-	if not cint(erpnext.is_perpetual_inventory_enabled(company)):
-		return
-
-	accounts = get_stock_accounts(company, voucher_type, voucher_no)
-	stock_adjustment_account = frappe.db.get_value("Company", company, "stock_adjustment_account")
-
-	for account in accounts:
-		account_bal, stock_bal, warehouse_list = get_stock_and_account_balance(
-			account, posting_date, company
-		)
-
-		if abs(account_bal - stock_bal) > 0.1:
-			precision = get_field_precision(
-				frappe.get_meta("GL Entry").get_field("debit"),
-				currency=frappe.get_cached_value("Company", company, "default_currency"),
-			)
-
-			diff = flt(stock_bal - account_bal, precision)
-
-			error_reason = _(
-				"Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses as on {3}."
-			).format(stock_bal, account_bal, frappe.bold(account), posting_date)
-			error_resolution = _("Please create an adjustment Journal Entry for amount {0} on {1}").format(
-				frappe.bold(diff), frappe.bold(posting_date)
-			)
-
-			frappe.msgprint(
-				msg="""{0}<br></br>{1}<br></br>""".format(error_reason, error_resolution),
-				raise_exception=StockValueAndAccountBalanceOutOfSync,
-				title=_("Values Out Of Sync"),
-				primary_action={
-					"label": _("Make Journal Entry"),
-					"client_action": "erpnext.route_to_adjustment_jv",
-					"args": get_journal_entry(account, stock_adjustment_account, diff),
-				},
-			)
-
-
 def get_stock_accounts(company, voucher_type=None, voucher_no=None):
 	stock_accounts = [
 		d.name

erpnext/assets/doctype/asset/asset.json

@@ -38,7 +38,6 @@
   "purchase_date",
   "section_break_23",
   "calculate_depreciation",
-  "allow_monthly_depreciation",
   "column_break_33",
   "opening_accumulated_depreciation",
   "number_of_depreciations_booked",
@@ -454,13 +453,6 @@
    "fieldname": "dimension_col_break",
    "fieldtype": "Column Break"
   },
-  {
-   "default": "0",
-   "depends_on": "calculate_depreciation",
-   "fieldname": "allow_monthly_depreciation",
-   "fieldtype": "Check",
-   "label": "Allow Monthly Depreciation"
-  },
   {
    "collapsible": 1,
    "collapsible_depends_on": "is_existing_asset",
@@ -503,7 +495,7 @@
    "link_fieldname": "asset"
   }
  ],
- "modified": "2022-01-30 20:19:24.680027",
+ "modified": "2022-07-20 16:22:44.437579",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset",
@@ -545,4 +537,4 @@
  "sort_order": "DESC",
  "title_field": "asset_name",
  "track_changes": 1
-}
+}

erpnext/assets/doctype/asset/asset.py

@@ -257,6 +257,7 @@ class Asset(AccountsController):
 				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)
@@ -270,6 +271,9 @@ class Asset(AccountsController):
 						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)
@@ -349,61 +353,16 @@ class Asset(AccountsController):
 					skip_row = True
 
 				if depreciation_amount > 0:
-					# With monthly depreciation, each depreciation is divided by months remaining until next date
-					if self.allow_monthly_depreciation:
-						# month range is 1 to 12
-						# In pro rata case, for first and last depreciation, month range would be different
-						month_range = (
-							months
-							if (has_pro_rata and n == 0)
-							or (has_pro_rata and n == cint(number_of_pending_depreciations) - 1)
-							else finance_book.frequency_of_depreciation
-						)
-
-						for r in range(month_range):
-							if has_pro_rata and n == 0:
-								# For first entry of monthly depr
-								if r == 0:
-									days_until_first_depr = date_diff(monthly_schedule_date, self.available_for_use_date)
-									per_day_amt = depreciation_amount / days
-									depreciation_amount_for_current_month = per_day_amt * days_until_first_depr
-									depreciation_amount -= depreciation_amount_for_current_month
-									date = monthly_schedule_date
-									amount = depreciation_amount_for_current_month
-								else:
-									date = add_months(monthly_schedule_date, r)
-									amount = depreciation_amount / (month_range - 1)
-							elif (has_pro_rata and n == cint(number_of_pending_depreciations) - 1) and r == cint(
-								month_range
-							) - 1:
-								# For last entry of monthly depr
-								date = last_schedule_date
-								amount = depreciation_amount / month_range
-							else:
-								date = add_months(monthly_schedule_date, r)
-								amount = depreciation_amount / month_range
-
-							self.append(
-								"schedules",
-								{
-									"schedule_date": date,
-									"depreciation_amount": amount,
-									"depreciation_method": finance_book.depreciation_method,
-									"finance_book": finance_book.finance_book,
-									"finance_book_id": finance_book.idx,
-								},
-							)
-					else:
-						self.append(
-							"schedules",
-							{
-								"schedule_date": schedule_date,
-								"depreciation_amount": depreciation_amount,
-								"depreciation_method": finance_book.depreciation_method,
-								"finance_book": finance_book.finance_book,
-								"finance_book_id": finance_book.idx,
-							},
-						)
+					self.append(
+						"schedules",
+						{
+							"schedule_date": schedule_date,
+							"depreciation_amount": depreciation_amount,
+							"depreciation_method": finance_book.depreciation_method,
+							"finance_book": finance_book.finance_book,
+							"finance_book_id": finance_book.idx,
+						},
+					)
 
 	# depreciation schedules need to be cleared before modification due to increase in asset life/asset sales
 	# JE: Journal Entry, FB: Finance Book
@@ -628,7 +587,7 @@ class Asset(AccountsController):
 
 				asset_value_after_full_schedule = flt(
 					flt(self.gross_purchase_amount) - flt(accumulated_depreciation_after_full_schedule),
-					self.precision("gross_purchase_amount"),
+					row.precision("expected_value_after_useful_life"),
 				)
 
 				if (
@@ -845,16 +804,11 @@ class Asset(AccountsController):
 			if args.get("rate_of_depreciation") and on_validate:
 				return args.get("rate_of_depreciation")
 
-			no_of_years = (
-				flt(args.get("total_number_of_depreciations") * flt(args.get("frequency_of_depreciation")))
-				/ 12
-			)
 			value = flt(args.get("expected_value_after_useful_life")) / flt(self.gross_purchase_amount)
 
-			# square root of flt(salvage_value) / flt(asset_cost)
-			depreciation_rate = math.pow(value, 1.0 / flt(no_of_years, 2))
+			depreciation_rate = math.pow(value, 1.0 / flt(args.get("total_number_of_depreciations"), 2))
 
-			return 100 * (1 - flt(depreciation_rate, float_precision))
+			return flt((100 * (1 - depreciation_rate)), float_precision)
 
 	def get_pro_rata_amt(self, row, depreciation_amount, from_date, to_date):
 		days = date_diff(to_date, from_date)
@@ -1103,9 +1057,18 @@ def is_cwip_accounting_enabled(asset_category):
 def get_total_days(date, frequency):
 	period_start_date = add_months(date, cint(frequency) * -1)
 
+	if is_last_day_of_the_month(date):
+		period_start_date = get_last_day(period_start_date)
+
 	return date_diff(date, period_start_date)
 
 
+def is_last_day_of_the_month(date):
+	last_day_of_the_month = get_last_day(date)
+
+	return getdate(last_day_of_the_month) == getdate(date)
+
+
 @erpnext.allow_regional
 def get_depreciation_amount(asset, depreciable_value, row):
 	if row.depreciation_method in ("Straight Line", "Manual"):

erpnext/assets/doctype/asset/test_asset.py

@@ -145,6 +145,7 @@ class TestAsset(AssetSetup):
 	def test_is_fixed_asset_set(self):
 		asset = create_asset(is_existing_asset=1)
 		doc = frappe.new_doc("Purchase Invoice")
+		doc.company = "_Test Company"
 		doc.supplier = "_Test Supplier"
 		doc.append("items", {"item_code": "Macbook Pro", "qty": 1, "asset": asset.name})
 
@@ -201,23 +202,23 @@ class TestAsset(AssetSetup):
 			depreciation_start_date="2020-12-31",
 			submit=1,
 		)
-
 		post_depreciation_entries(date="2021-01-01")
 
 		si = make_sales_invoice(asset=asset.name, item_code="Macbook Pro", company="_Test Company")
 		si.customer = "_Test Customer"
-		si.due_date = nowdate()
-		si.get("items")[0].rate = 25000
-		si.insert()
+		si.set_posting_time = 1
+		si.posting_date = "2021-10-31"
+		si.due_date = "2021-10-31"
+		si.get("items")[0].rate = 75000
 		si.submit()
 
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "status"), "Sold")
 
 		expected_gle = (
-			("_Test Accumulated Depreciations - _TC", 20490.2, 0.0),
+			("_Test Accumulated Depreciations - _TC", 50490.2, 0.0),
 			("_Test Fixed Asset - _TC", 0.0, 100000.0),
-			("_Test Gain/Loss on Asset Disposal - _TC", 54509.8, 0.0),
-			("Debtors - _TC", 25000.0, 0.0),
+			("_Test Gain/Loss on Asset Disposal - _TC", 0.0, 25490.2),
+			("Debtors - _TC", 75000.0, 0.0),
 		)
 
 		gle = frappe.db.sql(
@@ -227,9 +228,14 @@ class TestAsset(AssetSetup):
 			si.name,
 		)
 
-		self.assertEqual(gle, expected_gle)
+		for i, gle_entry in enumerate(gle):
+			self.assertEqual(gle_entry[0], expected_gle[i][0])
+			self.assertEqual(flt(gle_entry[1], 1), flt(expected_gle[i][1], 1))
+			self.assertEqual(flt(gle_entry[2], 1), flt(expected_gle[i][2], 1))
 
+		si.load_from_db()
 		si.cancel()
+
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "status"), "Partially Depreciated")
 
 	def test_expense_head(self):
@@ -696,6 +702,41 @@ class TestDepreciationMethods(AssetSetup):
 		asset.reload()
 		self.assertEquals(asset.finance_books[0].value_after_depreciation, 98000.0)
 
+	def test_monthly_depreciation_by_wdv_method(self):
+		existing_precision = frappe.db.get_default("float_precision")
+		frappe.db.set_default("float_precision", 3)
+		asset = create_asset(
+			calculate_depreciation=1,
+			available_for_use_date="2022-02-15",
+			purchase_date="2022-02-15",
+			depreciation_method="Written Down Value",
+			gross_purchase_amount=10000,
+			expected_value_after_useful_life=5000,
+			depreciation_start_date="2022-02-28",
+			total_number_of_depreciations=5,
+			frequency_of_depreciation=1,
+		)
+
+		expected_schedules = [
+			["2022-02-28", 647.25, 647.25],
+			["2022-03-31", 1210.71, 1857.96],
+			["2022-04-30", 1053.99, 2911.95],
+			["2022-05-31", 917.55, 3829.5],
+			["2022-06-30", 798.77, 4628.27],
+			["2022-07-15", 371.73, 5000.0],
+		]
+
+		schedules = [
+			[
+				cstr(d.schedule_date),
+				flt(d.depreciation_amount, 2),
+				flt(d.accumulated_depreciation_amount, 2),
+			]
+			for d in asset.get("schedules")
+		]
+		self.assertEqual(schedules, expected_schedules)
+		frappe.db.set_default("float_precision", existing_precision)
+
 
 class TestDepreciationBasics(AssetSetup):
 	def test_depreciation_without_pro_rata(self):
@@ -782,7 +823,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):
-			self.assertEqual(expected_values[i][0], schedule.schedule_date)
+			self.assertEqual(getdate(expected_values[i][0]), schedule.schedule_date)
 			self.assertEqual(expected_values[i][1], schedule.depreciation_amount)
 
 	def test_set_accumulated_depreciation(self):
@@ -1256,6 +1297,32 @@ class TestDepreciationBasics(AssetSetup):
 		asset.cost_center = "Main - _TC"
 		asset.submit()
 
+	def test_depreciation_on_final_day_of_the_month(self):
+		"""Tests if final day of the month is picked each time, if the depreciation start date is the last day of the month."""
+
+		asset = create_asset(
+			item_code="Macbook Pro",
+			calculate_depreciation=1,
+			purchase_date="2020-01-30",
+			available_for_use_date="2020-02-15",
+			depreciation_start_date="2020-02-29",
+			frequency_of_depreciation=1,
+			total_number_of_depreciations=5,
+			submit=1,
+		)
+
+		expected_dates = [
+			"2020-02-29",
+			"2020-03-31",
+			"2020-04-30",
+			"2020-05-31",
+			"2020-06-30",
+			"2020-07-15",
+		]
+
+		for i, schedule in enumerate(asset.schedules):
+			self.assertEqual(getdate(expected_dates[i]), getdate(schedule.schedule_date))
+
 
 def create_asset_data():
 	if not frappe.db.exists("Asset Category", "Computers"):

erpnext/assets/doctype/asset_repair/asset_repair.py

@@ -41,40 +41,46 @@ class AssetRepair(AccountsController):
 
 		if self.get("stock_consumption") or self.get("capitalize_repair_cost"):
 			self.increase_asset_value()
-		if self.get("stock_consumption"):
-			self.check_for_stock_items_and_warehouse()
-			self.decrease_stock_quantity()
-		if self.get("capitalize_repair_cost"):
-			self.make_gl_entries()
-			if (
-				frappe.db.get_value("Asset", self.asset, "calculate_depreciation")
-				and self.increase_in_asset_life
-			):
-				self.modify_depreciation_schedule()
 
-		self.asset_doc.flags.ignore_validate_update_after_submit = True
-		self.asset_doc.prepare_depreciation_data()
-		self.asset_doc.save()
+			if self.get("stock_consumption"):
+				self.check_for_stock_items_and_warehouse()
+				self.decrease_stock_quantity()
+
+			if self.get("capitalize_repair_cost"):
+				self.make_gl_entries()
+
+				if (
+					frappe.db.get_value("Asset", self.asset, "calculate_depreciation")
+					and self.increase_in_asset_life
+				):
+					self.modify_depreciation_schedule()
+
+			self.asset_doc.flags.ignore_validate_update_after_submit = True
+			self.asset_doc.prepare_depreciation_data()
+			self.asset_doc.save()
 
 	def before_cancel(self):
 		self.asset_doc = frappe.get_doc("Asset", self.asset)
 
 		if self.get("stock_consumption") or self.get("capitalize_repair_cost"):
 			self.decrease_asset_value()
-		if self.get("stock_consumption"):
-			self.increase_stock_quantity()
-		if self.get("capitalize_repair_cost"):
-			self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry")
-			self.make_gl_entries(cancel=True)
-			if (
-				frappe.db.get_value("Asset", self.asset, "calculate_depreciation")
-				and self.increase_in_asset_life
-			):
-				self.revert_depreciation_schedule_on_cancellation()
 
-		self.asset_doc.flags.ignore_validate_update_after_submit = True
-		self.asset_doc.prepare_depreciation_data()
-		self.asset_doc.save()
+			if self.get("stock_consumption"):
+				self.increase_stock_quantity()
+
+			if self.get("capitalize_repair_cost"):
+				self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry")
+				self.make_gl_entries(cancel=True)
+
+				if (
+					frappe.db.get_value("Asset", self.asset, "calculate_depreciation")
+					and self.increase_in_asset_life
+				):
+					self.revert_depreciation_schedule_on_cancellation()
+
+			self.asset_doc.flags.ignore_validate_update_after_submit = True
+			self.asset_doc.prepare_depreciation_data()
+			self.asset_doc.save()
 
 	def check_repair_status(self):
 		if self.repair_status == "Pending":

erpnext/buying/doctype/purchase_order/purchase_order.js

@@ -43,8 +43,6 @@ frappe.ui.form.on("Purchase Order", {
 		erpnext.queries.setup_queries(frm, "Warehouse", function() {
 			return erpnext.queries.warehouse(frm.doc);
 		});
-
-		erpnext.accounts.dimensions.setup_dimension_filters(frm, frm.doctype);
 	},
 
 	apply_tds: function(frm) {
@@ -427,7 +425,7 @@ erpnext.buying.PurchaseOrderController = erpnext.buying.BuyingController.extend(
 						company: me.frm.doc.company
 					},
 					allow_child_item_selection: true,
-					child_fielname: "items",
+					child_fieldname: "items",
 					child_columns: ["item_code", "qty"]
 				})
 			}, __("Get Items From"));

erpnext/buying/doctype/purchase_order/purchase_order.json

@@ -23,6 +23,10 @@
   "order_confirmation_no",
   "order_confirmation_date",
   "amended_from",
+  "accounting_dimensions_section",
+  "cost_center",
+  "dimension_col_break",
+  "project",
   "drop_ship",
   "customer",
   "customer_name",
@@ -1138,16 +1142,39 @@
    "fieldtype": "Link",
    "label": "Tax Withholding Category",
    "options": "Tax Withholding Category"
+  },
+  {
+   "collapsible": 1,
+   "fieldname": "accounting_dimensions_section",
+   "fieldtype": "Section Break",
+   "label": "Accounting Dimensions "
+  },
+  {
+   "fieldname": "cost_center",
+   "fieldtype": "Link",
+   "label": "Cost Center",
+   "options": "Cost Center"
+  },
+  {
+   "fieldname": "dimension_col_break",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "project",
+   "fieldtype": "Link",
+   "label": "Project",
+   "options": "Project"
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 105,
  "is_submittable": 1,
  "links": [],
- "modified": "2021-09-28 13:10:47.955401",
+ "modified": "2022-04-26 12:16:38.694276",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Purchase Order",
+ "naming_rule": "By \"Naming Series\" field",
  "owner": "Administrator",
  "permissions": [
   {
@@ -1194,6 +1221,7 @@
  "show_name_in_global_search": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
+ "states": [],
  "timeline_field": "supplier",
  "title_field": "supplier_name",
  "track_changes": 1

erpnext/buying/doctype/purchase_order/purchase_order.py

@@ -637,6 +637,8 @@ def make_rm_stock_entry(purchase_order, rm_items):
 						}
 					}
 					stock_entry.add_to_stock_entry_detail(items_dict)
+
+		stock_entry.set_missing_values()
 		return stock_entry.as_dict()
 	else:
 		frappe.throw(_("No Items selected for transfer"))
@@ -724,7 +726,7 @@ def make_return_stock_entry_for_subcontract(available_materials, po_doc, po_deta
 			add_items_in_ste(ste_doc, value, value.qty, po_details)
 
 	ste_doc.set_stock_entry_type()
-	ste_doc.calculate_rate_and_amount()
+	ste_doc.set_missing_values()
 
 	return ste_doc
 

erpnext/buying/doctype/purchase_order/test_purchase_order.py

@@ -140,6 +140,43 @@ class TestPurchaseOrder(FrappeTestCase):
 		# ordered qty decreases as ordered qty is 0 (deleted row)
 		self.assertEqual(get_ordered_qty(), existing_ordered_qty - 10)  # 0
 
+	def test_supplied_items_validations_on_po_update_after_submit(self):
+		po = create_purchase_order(item_code="_Test FG Item", is_subcontracted="Yes", qty=5, rate=100)
+		item = po.items[0]
+
+		original_supplied_items = {po.name: po.required_qty for po in po.supplied_items}
+
+		# Just update rate
+		trans_item = [
+			{
+				"item_code": "_Test FG Item",
+				"rate": 20,
+				"qty": 5,
+				"conversion_factor": 1.0,
+				"docname": item.name,
+			}
+		]
+		update_child_qty_rate("Purchase Order", json.dumps(trans_item), po.name)
+		po.reload()
+
+		new_supplied_items = {po.name: po.required_qty for po in po.supplied_items}
+		self.assertEqual(set(original_supplied_items.keys()), set(new_supplied_items.keys()))
+
+		# Update qty to 2x
+		trans_item[0]["qty"] *= 2
+		update_child_qty_rate("Purchase Order", json.dumps(trans_item), po.name)
+		po.reload()
+
+		new_supplied_items = {po.name: po.required_qty for po in po.supplied_items}
+		self.assertEqual(2 * sum(original_supplied_items.values()), sum(new_supplied_items.values()))
+
+		# Set transfer qty and attempt to update qty, shouldn't be allowed
+		po.supplied_items[0].supplied_qty = 2
+		po.supplied_items[0].db_update()
+		trans_item[0]["qty"] *= 2
+		with self.assertRaises(frappe.ValidationError):
+			update_child_qty_rate("Purchase Order", json.dumps(trans_item), po.name)
+
 	def test_update_child(self):
 		mr = make_material_request(qty=10)
 		po = make_purchase_order(mr.name)

erpnext/buying/doctype/request_for_quotation/request_for_quotation.js

@@ -31,7 +31,7 @@ frappe.ui.form.on("Request for Quotation",{
 		if (frm.doc.docstatus === 1) {
 
 			frm.add_custom_button(__('Supplier Quotation'),
-				function(){ frm.trigger("make_suppplier_quotation") }, __("Create"));
+				function(){ frm.trigger("make_supplier_quotation") }, __("Create"));
 
 
 			frm.add_custom_button(__("Send Emails to Suppliers"), function() {
@@ -87,16 +87,24 @@ frappe.ui.form.on("Request for Quotation",{
 
 	},
 
-	make_suppplier_quotation: function(frm) {
+	make_supplier_quotation: function(frm) {
 		var doc = frm.doc;
 		var dialog = new frappe.ui.Dialog({
 			title: __("Create Supplier Quotation"),
 			fields: [
-				{	"fieldtype": "Select", "label": __("Supplier"),
+				{	"fieldtype": "Link",
+					"label": __("Supplier"),
 					"fieldname": "supplier",
-					"options": doc.suppliers.map(d => d.supplier),
+					"options": 'Supplier',
 					"reqd": 1,
-					"default": doc.suppliers.length === 1 ? doc.suppliers[0].supplier_name : "" },
+					get_query: () => {
+						return {
+							filters: [
+								["Supplier", "name", "in", frm.doc.suppliers.map((row) => {return row.supplier;})]
+							]
+						}
+					}
+				}
 			],
 			primary_action_label: __("Create"),
 			primary_action: (args) => {

erpnext/buying/doctype/request_for_quotation/request_for_quotation.json

@@ -32,7 +32,9 @@
   "terms",
   "printing_settings",
   "select_print_heading",
-  "letter_head"
+  "letter_head",
+  "more_info",
+  "opportunity"
  ],
  "fields": [
   {
@@ -193,6 +195,23 @@
    "options": "Letter Head",
    "print_hide": 1
   },
+  {
+   "collapsible": 1,
+   "fieldname": "more_info",
+   "fieldtype": "Section Break",
+   "label": "More Information",
+   "oldfieldtype": "Section Break",
+   "options": "fa fa-file-text",
+   "print_hide": 1
+  },
+  {
+   "fieldname": "opportunity",
+   "fieldtype": "Link",
+   "label": "Opportunity",
+   "options": "Opportunity",
+   "print_hide": 1,
+   "read_only": 1
+  },
   {
    "fieldname": "status",
    "fieldtype": "Select",
@@ -258,7 +277,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2021-11-24 17:47:49.909000",
+ "modified": "2022-04-06 17:47:49.909000",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Request for Quotation",
@@ -327,4 +346,4 @@
  "show_name_in_global_search": 1,
  "sort_field": "modified",
  "sort_order": "DESC"
-}
+}

erpnext/buying/doctype/request_for_quotation/request_for_quotation.py

@@ -113,7 +113,7 @@ class RequestforQuotation(BuyingController):
 
 	def get_link(self):
 		# RFQ link for supplier portal
-		return get_url("/rfq/" + self.name)
+		return get_url("/app/request-for-quotation/" + self.name)
 
 	def update_supplier_part_no(self, supplier):
 		self.vendor = supplier
@@ -181,12 +181,20 @@ class RequestforQuotation(BuyingController):
 		doc_args = self.as_dict()
 		doc_args.update({"supplier": data.get("supplier"), "supplier_name": data.get("supplier_name")})
 
+		# Get Contact Full Name
+		supplier_name = None
+		if data.get("contact"):
+			contact_name = frappe.db.get_value(
+				"Contact", data.get("contact"), ["first_name", "middle_name", "last_name"]
+			)
+			supplier_name = (" ").join(x for x in contact_name if x)  # remove any blank values
+
 		args = {
 			"update_password_link": update_password_link,
 			"message": frappe.render_template(self.message_for_supplier, doc_args),
 			"rfq_link": rfq_link,
 			"user_fullname": full_name,
-			"supplier_name": data.get("supplier_name"),
+			"supplier_name": supplier_name or data.get("supplier_name"),
 			"supplier_salutation": self.salutation or "Dear Mx.",
 		}
 

erpnext/buying/doctype/supplier/supplier.py

@@ -84,6 +84,9 @@ class Supplier(TransactionBase):
 		self.save()
 
 	def validate_internal_supplier(self):
+		if not self.is_internal_supplier:
+			self.represents_company = ""
+
 		internal_supplier = frappe.db.get_value(
 			"Supplier",
 			{

erpnext/buying/report/purchase_order_analysis/purchase_order_analysis.js

@@ -59,6 +59,7 @@ frappe.query_reports["Purchase Order Analysis"] = {
 				for (let option of status){
 					options.push({
 						"value": option,
+						"label": __(option),
 						"description": ""
 					})
 				}

erpnext/change_log/v13/v13_26_0.md

@@ -0,0 +1,31 @@
+## Version 13.26.0 Release Notes
+
+### Features & Enhancements
+
+- feat: Receivable/Payable Account column and filter in AR/AP report ([#30620](https://github.com/frappe/erpnext/pull/30620))
+- feat(india): e-invoicing for intra-state union territory transactions ([#30626](https://github.com/frappe/erpnext/pull/30626))
+- feat: Ignore permlevel for specific fields ([#30686](https://github.com/frappe/erpnext/pull/30686))
+- feat: 'customer' column and more filter to Payment terms status report ([#30499](https://github.com/frappe/erpnext/pull/30499))
+
+### Fixes
+
+- fix: fallback to item_name if description is not found ([#30619](https://github.com/frappe/erpnext/pull/30619))
+- fix: Deferred Revenue/Expense Account validation ([#30602](https://github.com/frappe/erpnext/pull/30602))
+- fix(pos): reload doc before set value ([#30610](https://github.com/frappe/erpnext/pull/30610))
+- fix: Exchange gain and loss button in Payment Entry ([#30606](https://github.com/frappe/erpnext/pull/30606))
+- fix(pos): cannot change paid amount in pos payments ([#30657](https://github.com/frappe/erpnext/pull/30657))
+- fix: hide pending qty only if original item is assigned ([#30599](https://github.com/frappe/erpnext/pull/30599))
+- fix(pos): reload doc before set value ([#30611](https://github.com/frappe/erpnext/pull/30611))
+- fix: Handle multiple item transfer in separate SEs against WO ([#30674](https://github.com/frappe/erpnext/pull/30674))
+- fix(patch): check null values in is_cancelled patch ([#30594](https://github.com/frappe/erpnext/pull/30594))
+- fix: Download JSON for GSTR-1 report ([#30651](https://github.com/frappe/erpnext/pull/30651))
+- fix: remove bad defaults from BOM operation ([#30644](https://github.com/frappe/erpnext/pull/30644))
+- fix: update translation ([#30474](https://github.com/frappe/erpnext/pull/30474))
+- fix: dont reassign mutable (list) to a different field ([#30634](https://github.com/frappe/erpnext/pull/30634))
+- fix: update translation ([#30654](https://github.com/frappe/erpnext/pull/30654))
+- fix: ignore item-less maintenance visit for sr no ([#30684](https://github.com/frappe/erpnext/pull/30684))
+- fix: removed unused courses template ([#30596](https://github.com/frappe/erpnext/pull/30596))
+- fix: Implicit ignore pricing rule check on returns ([#30662](https://github.com/frappe/erpnext/pull/30662))
+- fix: warehouse naming when suffix is present ([#30621](https://github.com/frappe/erpnext/pull/30621))
+- fix: Ignore disabled tax categories ([#30542](https://github.com/frappe/erpnext/pull/30542))
+

erpnext/controllers/accounts_controller.py

@@ -35,6 +35,7 @@ from erpnext.accounts.doctype.pricing_rule.utils import (
 from erpnext.accounts.party import (
 	get_party_account,
 	get_party_account_currency,
+	get_party_gle_currency,
 	validate_party_frozen_disabled,
 )
 from erpnext.accounts.utils import get_account_currency, get_fiscal_years, validate_fiscal_year
@@ -46,6 +47,7 @@ from erpnext.controllers.print_settings import (
 from erpnext.controllers.sales_and_purchase_return import validate_return
 from erpnext.exceptions import InvalidCurrency
 from erpnext.setup.utils import get_exchange_rate
+from erpnext.stock.doctype.item.item import get_uom_conv_factor
 from erpnext.stock.doctype.packed_item.packed_item import make_packing_list
 from erpnext.stock.get_item_details import (
 	_get_item_tax_template,
@@ -149,6 +151,7 @@ class AccountsController(TransactionBase):
 
 		self.validate_inter_company_reference()
 
+		self.disable_pricing_rule_on_internal_transfer()
 		self.set_incoming_rate()
 
 		if self.meta.get_field("currency"):
@@ -168,6 +171,7 @@ class AccountsController(TransactionBase):
 
 		self.validate_party()
 		self.validate_currency()
+		self.validate_party_account_currency()
 
 		if self.doctype in ["Purchase Invoice", "Sales Invoice"]:
 			pos_check_field = "is_pos" if self.doctype == "Sales Invoice" else "is_paid"
@@ -181,6 +185,7 @@ class AccountsController(TransactionBase):
 			else:
 				self.validate_deferred_start_and_end_date()
 
+			self.validate_deferred_income_expense_account()
 			self.set_inter_company_account()
 
 		if self.doctype == "Purchase Invoice":
@@ -209,6 +214,27 @@ class AccountsController(TransactionBase):
 				(self.doctype, self.name),
 			)
 
+	def validate_deferred_income_expense_account(self):
+		field_map = {
+			"Sales Invoice": "deferred_revenue_account",
+			"Purchase Invoice": "deferred_expense_account",
+		}
+
+		for item in self.get("items"):
+			if item.get("enable_deferred_revenue") or item.get("enable_deferred_expense"):
+				if not item.get(field_map.get(self.doctype)):
+					default_deferred_account = frappe.db.get_value(
+						"Company", self.company, "default_" + field_map.get(self.doctype)
+					)
+					if not default_deferred_account:
+						frappe.throw(
+							_(
+								"Row #{0}: Please update deferred revenue/expense account in item row or default account in company master"
+							).format(item.idx)
+						)
+					else:
+						item.set(field_map.get(self.doctype), default_deferred_account)
+
 	def validate_deferred_start_and_end_date(self):
 		for d in self.items:
 			if d.get("enable_deferred_revenue") or d.get("enable_deferred_expense"):
@@ -361,6 +387,14 @@ class AccountsController(TransactionBase):
 				msg += _("Please create purchase from internal sale or delivery document itself")
 				frappe.throw(msg, title=_("Internal Sales Reference Missing"))
 
+	def disable_pricing_rule_on_internal_transfer(self):
+		if not self.get("ignore_pricing_rule") and self.is_internal_transfer():
+			self.ignore_pricing_rule = 1
+			frappe.msgprint(
+				_("Disabled pricing rules since this {} is an internal transfer").format(self.doctype),
+				alert=1,
+			)
+
 	def validate_due_date(self):
 		if self.get("is_pos"):
 			return
@@ -516,6 +550,15 @@ class AccountsController(TransactionBase):
 					if ret.get("pricing_rules"):
 						self.apply_pricing_rule_on_items(item, ret)
 						self.set_pricing_rule_details(item, ret)
+				else:
+					# Transactions line item without item code
+
+					uom = item.get("uom")
+					stock_uom = item.get("stock_uom")
+					if bool(uom) != bool(stock_uom):  # xor
+						item.stock_uom = item.uom = uom or stock_uom
+
+					item.conversion_factor = get_uom_conv_factor(item.get("uom"), item.get("stock_uom"))
 
 			if self.doctype == "Purchase Invoice":
 				self.set_expense_account(for_validate)
@@ -1095,11 +1138,10 @@ class AccountsController(TransactionBase):
 							{
 								"account": item.discount_account,
 								"against": supplier_or_customer,
-								dr_or_cr: flt(discount_amount, item.precision("discount_amount")),
-								dr_or_cr
-								+ "_in_account_currency": flt(
+								dr_or_cr: flt(
 									discount_amount * self.get("conversion_rate"), item.precision("discount_amount")
 								),
+								dr_or_cr + "_in_account_currency": flt(discount_amount, item.precision("discount_amount")),
 								"cost_center": item.cost_center,
 								"project": item.project,
 							},
@@ -1114,11 +1156,11 @@ class AccountsController(TransactionBase):
 							{
 								"account": income_or_expense_account,
 								"against": supplier_or_customer,
-								rev_dr_cr: flt(discount_amount, item.precision("discount_amount")),
-								rev_dr_cr
-								+ "_in_account_currency": flt(
+								rev_dr_cr: flt(
 									discount_amount * self.get("conversion_rate"), item.precision("discount_amount")
 								),
+								rev_dr_cr
+								+ "_in_account_currency": flt(discount_amount, item.precision("discount_amount")),
 								"cost_center": item.cost_center,
 								"project": item.project or self.project,
 							},
@@ -1415,6 +1457,34 @@ class AccountsController(TransactionBase):
 				# at quotation / sales order level and we shouldn't stop someone
 				# from creating a sales invoice if sales order is already created
 
+	def validate_party_account_currency(self):
+		if self.doctype not in ("Sales Invoice", "Purchase Invoice"):
+			return
+
+		if self.is_opening == "Yes":
+			return
+
+		party_type, party = self.get_party()
+		party_gle_currency = get_party_gle_currency(party_type, party, self.company)
+		party_account = (
+			self.get("debit_to") if self.doctype == "Sales Invoice" else self.get("credit_to")
+		)
+		party_account_currency = get_account_currency(party_account)
+		allow_multi_currency_invoices_against_single_party_account = frappe.db.get_singles_value(
+			"Accounts Settings", "allow_multi_currency_invoices_against_single_party_account"
+		)
+
+		if (
+			not party_gle_currency
+			and (party_account_currency != self.currency)
+			and not allow_multi_currency_invoices_against_single_party_account
+		):
+			frappe.throw(
+				_("Party Account {0} currency ({1}) and document currency ({2}) should be same").format(
+					frappe.bold(party_account), party_account_currency, self.currency
+				)
+			)
+
 	def delink_advance_entries(self, linked_doc_name):
 		total_allocated_amount = 0
 		for adv in self.advances:
@@ -1714,6 +1784,8 @@ class AccountsController(TransactionBase):
 			internal_party_field = "is_internal_customer"
 		elif self.doctype in ("Purchase Invoice", "Purchase Receipt", "Purchase Order"):
 			internal_party_field = "is_internal_supplier"
+		else:
+			return False
 
 		if self.get(internal_party_field) and (self.represents_company == self.company):
 			return True
@@ -1781,6 +1853,17 @@ class AccountsController(TransactionBase):
 		jv.save()
 		jv.submit()
 
+	def check_conversion_rate(self):
+		default_currency = erpnext.get_company_currency(self.company)
+		if not default_currency:
+			throw(_("Please enter default currency in Company Master"))
+		if (
+			(self.currency == default_currency and flt(self.conversion_rate) != 1.00)
+			or not self.conversion_rate
+			or (self.currency != default_currency and flt(self.conversion_rate) == 1.00)
+		):
+			throw(_("Conversion rate cannot be 0 or 1"))
+
 
 @frappe.whitelist()
 def get_tax_rate(account_head):
@@ -1978,12 +2061,13 @@ def get_advance_journal_entries(
 
 	reference_condition = " and (" + " or ".join(conditions) + ")" if conditions else ""
 
+	# nosemgrep
 	journal_entries = frappe.db.sql(
 		"""
 		select
 			"Journal Entry" as reference_type, t1.name as reference_name,
 			t1.remark as remarks, t2.{0} as amount, t2.name as reference_row,
-			t2.reference_name as against_order
+			t2.reference_name as against_order, t2.exchange_rate
 		from
 			`tabJournal Entry` t1, `tabJournal Entry Account` t2
 		where
@@ -2361,7 +2445,7 @@ def update_bin_on_delete(row, doctype):
 		update_bin_qty(row.item_code, row.warehouse, qty_dict)
 
 
-def validate_and_delete_children(parent, data):
+def validate_and_delete_children(parent, data) -> bool:
 	deleted_children = []
 	updated_item_names = [d.get("docname") for d in data]
 	for item in parent.items:
@@ -2380,6 +2464,8 @@ def validate_and_delete_children(parent, data):
 	for d in deleted_children:
 		update_bin_on_delete(d, parent.doctype)
 
+	return bool(deleted_children)
+
 
 @frappe.whitelist()
 def update_child_qty_rate(parent_doctype, trans_items, parent_doctype_name, child_docname="items"):
@@ -2426,20 +2512,55 @@ def update_child_qty_rate(parent_doctype, trans_items, parent_doctype_name, chil
 			parent_doctype, parent_doctype_name, child_doctype, child_docname, item_row
 		)
 
-	def validate_quantity(child_item, d):
-		if parent_doctype == "Sales Order" and flt(d.get("qty")) < flt(child_item.delivered_qty):
+	def validate_quantity(child_item, new_data):
+		if not flt(new_data.get("qty")):
+			frappe.throw(
+				_("Row # {0}: Quantity for Item {1} cannot be zero").format(
+					new_data.get("idx"), frappe.bold(new_data.get("item_code"))
+				),
+				title=_("Invalid Qty"),
+			)
+
+		if parent_doctype == "Sales Order" and flt(new_data.get("qty")) < flt(child_item.delivered_qty):
 			frappe.throw(_("Cannot set quantity less than delivered quantity"))
 
-		if parent_doctype == "Purchase Order" and flt(d.get("qty")) < flt(child_item.received_qty):
+		if parent_doctype == "Purchase Order" and flt(new_data.get("qty")) < flt(
+			child_item.received_qty
+		):
 			frappe.throw(_("Cannot set quantity less than received quantity"))
 
+	def should_update_supplied_items(doc) -> bool:
+		"""Subcontracted PO can allow following changes *after submit*:
+
+		1. Change rate of subcontracting - regardless of other changes.
+		2. Change qty and/or add new items and/or remove items
+		        Exception: Transfer/Consumption is already made, qty change not allowed.
+		"""
+
+		supplied_items_processed = any(
+			item.supplied_qty or item.consumed_qty or item.returned_qty for item in doc.supplied_items
+		)
+
+		update_supplied_items = (
+			any_qty_changed or items_added_or_removed or any_conversion_factor_changed
+		)
+		if update_supplied_items and supplied_items_processed:
+			frappe.throw(_("Item qty can not be updated as raw materials are already processed."))
+
+		return update_supplied_items
+
 	data = json.loads(trans_items)
 
+	any_qty_changed = False  # updated to true if any item's qty changes
+	items_added_or_removed = False  # updated to true if any new item is added or removed
+	any_conversion_factor_changed = False
+
 	sales_doctypes = ["Sales Order", "Sales Invoice", "Delivery Note", "Quotation"]
 	parent = frappe.get_doc(parent_doctype, parent_doctype_name)
 
 	check_doc_permissions(parent, "write")
-	validate_and_delete_children(parent, data)
+	_removed_items = validate_and_delete_children(parent, data)
+	items_added_or_removed |= _removed_items
 
 	for d in data:
 		new_child_flag = False
@@ -2450,6 +2571,7 @@ def update_child_qty_rate(parent_doctype, trans_items, parent_doctype_name, chil
 
 		if not d.get("docname"):
 			new_child_flag = True
+			items_added_or_removed = True
 			check_doc_permissions(parent, "create")
 			child_item = get_new_child_item(d)
 		else:
@@ -2472,6 +2594,7 @@ def update_child_qty_rate(parent_doctype, trans_items, parent_doctype_name, chil
 			qty_unchanged = prev_qty == new_qty
 			uom_unchanged = prev_uom == new_uom
 			conversion_factor_unchanged = prev_con_fac == new_con_fac
+			any_conversion_factor_changed |= not conversion_factor_unchanged
 			date_unchanged = (
 				prev_date == getdate(new_date) if prev_date and new_date else False
 			)  # in case of delivery note etc
@@ -2485,6 +2608,8 @@ def update_child_qty_rate(parent_doctype, trans_items, parent_doctype_name, chil
 				continue
 
 		validate_quantity(child_item, d)
+		if flt(child_item.get("qty")) != flt(d.get("qty")):
+			any_qty_changed = True
 
 		child_item.qty = flt(d.get("qty"))
 		rate_precision = child_item.precision("rate") or 2
@@ -2590,10 +2715,12 @@ def update_child_qty_rate(parent_doctype, trans_items, parent_doctype_name, chil
 		parent.update_ordered_and_reserved_qty()
 		parent.update_receiving_percentage()
 		if parent.is_subcontracted == "Yes":
-			parent.update_reserved_qty_for_subcontract()
-			parent.create_raw_materials_supplied("supplied_items")
+			if should_update_supplied_items(parent):
+				parent.update_reserved_qty_for_subcontract()
+				parent.create_raw_materials_supplied("supplied_items")
 			parent.save()
-	else:
+	else:  # Sales Order
+		parent.validate_warehouse()
 		parent.update_reserved_qty()
 		parent.update_project()
 		parent.update_prevdoc_status("submit")

erpnext/controllers/buying_controller.py

@@ -22,6 +22,9 @@ class QtyMismatchError(ValidationError):
 
 
 class BuyingController(StockController, Subcontracting):
+	def __setup__(self):
+		self.flags.ignore_permlevel_for_fields = ["buying_price_list", "price_list_currency"]
+
 	def get_feed(self):
 		if self.get("supplier_name"):
 			return _("From {0} | {1} {2}").format(self.supplier_name, self.currency, self.grand_total)
@@ -296,21 +299,23 @@ class BuyingController(StockController, Subcontracting):
 						raise_error_if_no_rate=False,
 					)
 
-					rate = flt(outgoing_rate * d.conversion_factor, d.precision("rate"))
+					rate = flt(outgoing_rate * (d.conversion_factor or 1), d.precision("rate"))
 				else:
-					rate = frappe.db.get_value(ref_doctype, d.get(frappe.scrub(ref_doctype)), "rate")
+					field = "incoming_rate" if self.get("is_internal_supplier") else "rate"
+					rate = frappe.db.get_value(ref_doctype, d.get(frappe.scrub(ref_doctype)), field)
 
 				if self.is_internal_transfer():
 					if rate != d.rate:
 						d.rate = rate
-						d.discount_percentage = 0
-						d.discount_amount = 0
 						frappe.msgprint(
 							_(
 								"Row {0}: Item rate has been updated as per valuation rate since its an internal stock transfer"
 							).format(d.idx),
 							alert=1,
 						)
+					d.discount_percentage = 0.0
+					d.discount_amount = 0.0
+					d.margin_rate_or_amount = 0.0
 
 	def get_supplied_items_cost(self, item_row_id, reset_outgoing_rate=True):
 		supplied_items_cost = 0.0

erpnext/controllers/queries.py

@@ -18,8 +18,9 @@ from erpnext.stock.get_item_details import _get_item_tax_template
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def employee_query(doctype, txt, searchfield, start, page_len, filters):
+	doctype = "Employee"
 	conditions = []
-	fields = get_fields("Employee", ["name", "employee_name"])
+	fields = get_fields(doctype, ["name", "employee_name"])
 
 	return frappe.db.sql(
 		"""select {fields} from `tabEmployee`
@@ -49,7 +50,8 @@ def employee_query(doctype, txt, searchfield, start, page_len, filters):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def lead_query(doctype, txt, searchfield, start, page_len, filters):
-	fields = get_fields("Lead", ["name", "lead_name", "company_name"])
+	doctype = "Lead"
+	fields = get_fields(doctype, ["name", "lead_name", "company_name"])
 
 	return frappe.db.sql(
 		"""select {fields} from `tabLead`
@@ -77,6 +79,7 @@ def lead_query(doctype, txt, searchfield, start, page_len, filters):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def customer_query(doctype, txt, searchfield, start, page_len, filters):
+	doctype = "Customer"
 	conditions = []
 	cust_master_name = frappe.defaults.get_user_default("cust_master_name")
 
@@ -85,9 +88,9 @@ def customer_query(doctype, txt, searchfield, start, page_len, filters):
 	else:
 		fields = ["name", "customer_name", "customer_group", "territory"]
 
-	fields = get_fields("Customer", fields)
+	fields = get_fields(doctype, fields)
 
-	searchfields = frappe.get_meta("Customer").get_search_fields()
+	searchfields = frappe.get_meta(doctype).get_search_fields()
 	searchfields = " or ".join(field + " like %(txt)s" for field in searchfields)
 
 	return frappe.db.sql(
@@ -116,6 +119,7 @@ def customer_query(doctype, txt, searchfield, start, page_len, filters):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def supplier_query(doctype, txt, searchfield, start, page_len, filters):
+	doctype = "Supplier"
 	supp_master_name = frappe.defaults.get_user_default("supp_master_name")
 
 	if supp_master_name == "Supplier Name":
@@ -123,7 +127,7 @@ def supplier_query(doctype, txt, searchfield, start, page_len, filters):
 	else:
 		fields = ["name", "supplier_name", "supplier_group"]
 
-	fields = get_fields("Supplier", fields)
+	fields = get_fields(doctype, fields)
 
 	return frappe.db.sql(
 		"""select {field} from `tabSupplier`
@@ -147,6 +151,7 @@ def supplier_query(doctype, txt, searchfield, start, page_len, filters):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def tax_account_query(doctype, txt, searchfield, start, page_len, filters):
+	doctype = "Account"
 	company_currency = erpnext.get_company_currency(filters.get("company"))
 
 	def get_accounts(with_account_type_filter):
@@ -162,6 +167,7 @@ def tax_account_query(doctype, txt, searchfield, start, page_len, filters):
 				{account_type_condition}
 				AND is_group = 0
 				AND company = %(company)s
+				AND disabled = %(disabled)s
 				AND (account_currency = %(currency)s or ifnull(account_currency, '') = '')
 				AND `{searchfield}` LIKE %(txt)s
 				{mcond}
@@ -175,6 +181,7 @@ def tax_account_query(doctype, txt, searchfield, start, page_len, filters):
 			dict(
 				account_types=filters.get("account_type"),
 				company=filters.get("company"),
+				disabled=filters.get("disabled", 0),
 				currency=company_currency,
 				txt="%{}%".format(txt),
 				offset=start,
@@ -195,13 +202,14 @@ def tax_account_query(doctype, txt, searchfield, start, page_len, filters):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def item_query(doctype, txt, searchfield, start, page_len, filters, as_dict=False):
+	doctype = "Item"
 	conditions = []
 
 	if isinstance(filters, str):
 		filters = json.loads(filters)
 
 	# Get searchfields from meta and use in Item Link field query
-	meta = frappe.get_meta("Item", cached=True)
+	meta = frappe.get_meta(doctype, cached=True)
 	searchfields = meta.get_search_fields()
 
 	# these are handled separately
@@ -255,7 +263,7 @@ def item_query(doctype, txt, searchfield, start, page_len, filters, as_dict=Fals
 			filters.pop("supplier", None)
 
 	description_cond = ""
-	if frappe.db.count("Item", cache=True) < 50000:
+	if frappe.db.count(doctype, cache=True) < 50000:
 		# scan description only if items are less than 50000
 		description_cond = "or tabItem.description LIKE %(txt)s"
 	return frappe.db.sql(
@@ -298,8 +306,9 @@ def item_query(doctype, txt, searchfield, start, page_len, filters, as_dict=Fals
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def bom(doctype, txt, searchfield, start, page_len, filters):
+	doctype = "BOM"
 	conditions = []
-	fields = get_fields("BOM", ["name", "item"])
+	fields = get_fields(doctype, ["name", "item"])
 
 	return frappe.db.sql(
 		"""select {fields}
@@ -329,6 +338,7 @@ def bom(doctype, txt, searchfield, start, page_len, filters):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def get_project_name(doctype, txt, searchfield, start, page_len, filters):
+	doctype = "Project"
 	cond = ""
 	if filters and filters.get("customer"):
 		cond = """(`tabProject`.customer = %s or
@@ -336,9 +346,9 @@ def get_project_name(doctype, txt, searchfield, start, page_len, filters):
 			frappe.db.escape(filters.get("customer"))
 		)
 
-	fields = get_fields("Project", ["name", "project_name"])
-	searchfields = frappe.get_meta("Project").get_search_fields()
-	searchfields = " or ".join([field + " like %(txt)s" for field in searchfields])
+	fields = get_fields(doctype, ["name", "project_name"])
+	searchfields = frappe.get_meta(doctype).get_search_fields()
+	searchfields = " or ".join(["`tabProject`." + field + " like %(txt)s" for field in searchfields])
 
 	return frappe.db.sql(
 		"""select {fields} from `tabProject`
@@ -364,7 +374,8 @@ def get_project_name(doctype, txt, searchfield, start, page_len, filters):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def get_delivery_notes_to_be_billed(doctype, txt, searchfield, start, page_len, filters, as_dict):
-	fields = get_fields("Delivery Note", ["name", "customer", "posting_date"])
+	doctype = "Delivery Note"
+	fields = get_fields(doctype, ["name", "customer", "posting_date"])
 
 	return frappe.db.sql(
 		"""
@@ -400,6 +411,7 @@ def get_delivery_notes_to_be_billed(doctype, txt, searchfield, start, page_len,
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def get_batch_no(doctype, txt, searchfield, start, page_len, filters):
+	doctype = "Batch"
 	cond = ""
 	if filters.get("posting_date"):
 		cond = "and (batch.expiry_date is null or batch.expiry_date >= %(posting_date)s)"
@@ -418,7 +430,7 @@ def get_batch_no(doctype, txt, searchfield, start, page_len, filters):
 	if filters.get("is_return"):
 		having_clause = ""
 
-	meta = frappe.get_meta("Batch", cached=True)
+	meta = frappe.get_meta(doctype, cached=True)
 	searchfields = meta.get_search_fields()
 
 	search_columns = ""
@@ -494,6 +506,7 @@ def get_batch_no(doctype, txt, searchfield, start, page_len, filters):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def get_account_list(doctype, txt, searchfield, start, page_len, filters):
+	doctype = "Account"
 	filter_list = []
 
 	if isinstance(filters, dict):
@@ -512,7 +525,7 @@ def get_account_list(doctype, txt, searchfield, start, page_len, filters):
 		filter_list.append([doctype, searchfield, "like", "%%%s%%" % txt])
 
 	return frappe.desk.reportview.execute(
-		"Account",
+		doctype,
 		filters=filter_list,
 		fields=["name", "parent_account"],
 		limit_start=start,
@@ -551,6 +564,7 @@ def get_income_account(doctype, txt, searchfield, start, page_len, filters):
 	if not filters:
 		filters = {}
 
+	doctype = "Account"
 	condition = ""
 	if filters.get("company"):
 		condition += "and tabAccount.company = %(company)s"
@@ -626,6 +640,7 @@ def get_expense_account(doctype, txt, searchfield, start, page_len, filters):
 	if not filters:
 		filters = {}
 
+	doctype = "Account"
 	condition = ""
 	if filters.get("company"):
 		condition += "and tabAccount.company = %(company)s"
@@ -648,6 +663,7 @@ def get_expense_account(doctype, txt, searchfield, start, page_len, filters):
 @frappe.validate_and_sanitize_search_inputs
 def warehouse_query(doctype, txt, searchfield, start, page_len, filters):
 	# Should be used when item code is passed in filters.
+	doctype = "Warehouse"
 	conditions, bin_conditions = [], []
 	filter_dict = get_doctype_wise_filters(filters)
 

erpnext/controllers/sales_and_purchase_return.py

@@ -316,7 +316,7 @@ def get_returned_qty_map_for_row(return_against, party, row_name, doctype):
 	return data[0]
 
 
-def make_return_doc(doctype, source_name, target_doc=None):
+def make_return_doc(doctype: str, source_name: str, target_doc=None):
 	from frappe.model.mapper import get_mapped_doc
 
 	from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
@@ -330,7 +330,6 @@ def make_return_doc(doctype, source_name, target_doc=None):
 		doc = frappe.get_doc(target)
 		doc.is_return = 1
 		doc.return_against = source.name
-		doc.ignore_pricing_rule = 1
 		doc.set_warehouse = ""
 		if doctype == "Sales Invoice" or doctype == "POS Invoice":
 			doc.is_pos = source.is_pos

erpnext/controllers/selling_controller.py

@@ -16,6 +16,9 @@ from erpnext.stock.utils import get_incoming_rate
 
 
 class SellingController(StockController):
+	def __setup__(self):
+		self.flags.ignore_permlevel_for_fields = ["selling_price_list", "price_list_currency"]
+
 	def get_feed(self):
 		return _("To {0} | {1} {2}").format(self.customer_name, self.currency, self.grand_total)
 
@@ -443,15 +446,16 @@ class SellingController(StockController):
 						rate = flt(d.incoming_rate * d.conversion_factor, d.precision("rate"))
 						if d.rate != rate:
 							d.rate = rate
+							frappe.msgprint(
+								_(
+									"Row {0}: Item rate has been updated as per valuation rate since its an internal stock transfer"
+								).format(d.idx),
+								alert=1,
+							)
 
-						d.discount_percentage = 0
-						d.discount_amount = 0
-						frappe.msgprint(
-							_(
-								"Row {0}: Item rate has been updated as per valuation rate since its an internal stock transfer"
-							).format(d.idx),
-							alert=1,
-						)
+						d.discount_percentage = 0.0
+						d.discount_amount = 0.0
+						d.margin_rate_or_amount = 0.0
 
 			elif self.get("return_against"):
 				# Get incoming rate of return entry from reference document
@@ -610,13 +614,13 @@ class SellingController(StockController):
 				stock_items = [d.item_code, d.description, d.warehouse, ""]
 				non_stock_items = [d.item_code, d.description]
 
+			duplicate_items_msg = _("Item {0} entered multiple times.").format(frappe.bold(d.item_code))
+			duplicate_items_msg += "<br><br>"
+			duplicate_items_msg += _("Please enable {} in {} to allow same item in multiple rows").format(
+				frappe.bold("Allow Item to Be Added Multiple Times in a Transaction"),
+				get_link_to_form("Selling Settings", "Selling Settings"),
+			)
 			if frappe.db.get_value("Item", d.item_code, "is_stock_item") == 1:
-				duplicate_items_msg = _("Item {0} entered multiple times.").format(frappe.bold(d.item_code))
-				duplicate_items_msg += "<br><br>"
-				duplicate_items_msg += _("Please enable {} in {} to allow same item in multiple rows").format(
-					frappe.bold("Allow Item to Be Added Multiple Times in a Transaction"),
-					get_link_to_form("Selling Settings", "Selling Settings"),
-				)
 				if stock_items in check_list:
 					frappe.throw(duplicate_items_msg)
 				else:

erpnext/controllers/status_updater.py

@@ -35,7 +35,8 @@ status_map = {
 		["Draft", None],
 		["Open", "eval:self.docstatus==1"],
 		["Lost", "eval:self.status=='Lost'"],
-		["Ordered", "has_sales_order"],
+		["Partially Ordered", "is_partially_ordered"],
+		["Ordered", "is_fully_ordered"],
 		["Cancelled", "eval:self.docstatus==2"],
 	],
 	"Sales Order": [

erpnext/controllers/stock_controller.py

@@ -166,7 +166,7 @@ class StockController(AccountsController):
 									"against": warehouse_account[sle.warehouse]["account"],
 									"cost_center": item_row.cost_center,
 									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
-									"credit": flt(sle.stock_value_difference, precision),
+									"debit": -1 * flt(sle.stock_value_difference, precision),
 									"project": item_row.get("project") or self.get("project"),
 									"is_opening": item_row.get("is_opening") or self.get("is_opening") or "No",
 								},

erpnext/controllers/subcontracting.py

@@ -355,6 +355,8 @@ class Subcontracting:
 			rm_obj.purchase_order = item_row.purchase_order
 			self.__set_batch_nos(bom_item, item_row, rm_obj, qty)
 
+		rm_obj.amount = flt(rm_obj.required_qty) * flt(rm_obj.rate)
+
 	def __set_batch_nos(self, bom_item, item_row, rm_obj, qty):
 		key = (rm_obj.rm_item_code, item_row.item_code, item_row.purchase_order)
 

erpnext/controllers/taxes_and_totals.py

@@ -500,6 +500,9 @@ class calculate_taxes_and_totals(object):
 		else:
 			self.doc.grand_total = flt(self.doc.net_total)
 
+		if self.doc.apply_discount_on == "Grand Total" and self.doc.get("is_cash_or_non_trade_discount"):
+			self.doc.grand_total -= self.doc.discount_amount
+
 		if self.doc.get("taxes"):
 			self.doc.total_taxes_and_charges = flt(
 				self.doc.grand_total - self.doc.net_total - flt(self.doc.rounding_adjustment),
@@ -594,6 +597,12 @@ class calculate_taxes_and_totals(object):
 			if not self.doc.apply_discount_on:
 				frappe.throw(_("Please select Apply Discount On"))
 
+			if self.doc.apply_discount_on == "Grand Total" and self.doc.get(
+				"is_cash_or_non_trade_discount"
+			):
+				self.discount_amount_applied = True
+				return
+
 			self.doc.base_discount_amount = flt(
 				self.doc.discount_amount * self.doc.conversion_rate, self.doc.precision("base_discount_amount")
 			)

erpnext/crm/doctype/opportunity/opportunity.py

@@ -8,7 +8,7 @@ import frappe
 from frappe import _
 from frappe.email.inbox import link_communication_to_document
 from frappe.model.mapper import get_mapped_doc
-from frappe.utils import cint, cstr, get_fullname
+from frappe.utils import cint, get_fullname
 
 from erpnext.accounts.party import get_party_account_currency
 from erpnext.setup.utils import get_exchange_rate
@@ -193,20 +193,20 @@ class Opportunity(TransactionBase):
 
 		if self.party_name and self.opportunity_from == "Customer":
 			if self.contact_person:
-				opts.description = "Contact " + cstr(self.contact_person)
+				opts.description = f"Contact {self.contact_person}"
 			else:
-				opts.description = "Contact customer " + cstr(self.party_name)
+				opts.description = f"Contact customer {self.party_name}"
 		elif self.party_name and self.opportunity_from == "Lead":
 			if self.contact_display:
-				opts.description = "Contact " + cstr(self.contact_display)
+				opts.description = f"Contact {self.contact_display}"
 			else:
-				opts.description = "Contact lead " + cstr(self.party_name)
+				opts.description = f"Contact lead {self.party_name}"
 
 		opts.subject = opts.description
-		opts.description += ". By : " + cstr(self.contact_by)
+		opts.description += f". By : {self.contact_by}"
 
 		if self.to_discuss:
-			opts.description += " To Discuss : " + cstr(self.to_discuss)
+			opts.description += f" To Discuss : {frappe.render_template(self.to_discuss, {'doc': self})}"
 
 		super(Opportunity, self).add_calendar_event(opts, force)
 

erpnext/crm/doctype/opportunity/opportunity_dashboard.py

@@ -2,6 +2,6 @@ def get_data():
 	return {
 		"fieldname": "opportunity",
 		"transactions": [
-			{"items": ["Quotation", "Supplier Quotation"]},
+			{"items": ["Quotation", "Request for Quotation", "Supplier Quotation"]},
 		],
 	}

erpnext/crm/doctype/opportunity/test_opportunity.py

@@ -4,7 +4,7 @@
 import unittest
 
 import frappe
-from frappe.utils import random_string, today
+from frappe.utils import add_days, now_datetime, random_string, today
 
 from erpnext.crm.doctype.lead.lead import make_customer
 from erpnext.crm.doctype.opportunity.opportunity import make_quotation
@@ -58,6 +58,22 @@ class TestOpportunity(unittest.TestCase):
 		self.assertEqual(opp_doc.opportunity_from, "Customer")
 		self.assertEqual(opp_doc.party_name, customer.name)
 
+	def test_render_template_for_to_discuss(self):
+		doc = make_opportunity(with_items=0, opportunity_from="Lead")
+		doc.contact_by = "test@example.com"
+		doc.contact_date = add_days(today(), days=2)
+		doc.to_discuss = "{{ doc.name }} test data"
+		doc.save()
+
+		event = frappe.get_all(
+			"Event Participants",
+			fields=["parent"],
+			filters={"reference_doctype": doc.doctype, "reference_docname": doc.name},
+		)
+
+		event_description = frappe.db.get_value("Event", event[0].parent, "description")
+		self.assertTrue(doc.name in event_description)
+
 
 def make_opportunity(**args):
 	args = frappe._dict(args)

erpnext/e_commerce/doctype/e_commerce_settings/e_commerce_settings.js

@@ -24,17 +24,17 @@ frappe.ui.form.on("E Commerce Settings", {
 			);
 		}
 
-		frappe.model.with_doctype("Item", () => {
+		frappe.model.with_doctype("Website Item", () => {
 			const web_item_meta = frappe.get_meta('Website Item');
 
 			const valid_fields = web_item_meta.fields.filter(
 				df => ["Link", "Table MultiSelect"].includes(df.fieldtype) && !df.hidden
 			).map(df => ({ label: df.label, value: df.fieldname }));
 
-			frm.fields_dict.filter_fields.grid.update_docfield_property(
+			frm.get_field("filter_fields").grid.update_docfield_property(
 				'fieldname', 'fieldtype', 'Select'
 			);
-			frm.fields_dict.filter_fields.grid.update_docfield_property(
+			frm.get_field("filter_fields").grid.update_docfield_property(
 				'fieldname', 'options', valid_fields
 			);
 		});

erpnext/e_commerce/doctype/e_commerce_settings/e_commerce_settings.py

@@ -26,7 +26,7 @@ class ECommerceSettings(Document):
 		self.is_redisearch_loaded = is_search_module_loaded()
 
 	def validate(self):
-		self.validate_field_filters()
+		self.validate_field_filters(self.filter_fields, self.enable_field_filters)
 		self.validate_attribute_filters()
 		self.validate_checkout()
 		self.validate_search_index_fields()
@@ -50,21 +50,22 @@ class ECommerceSettings(Document):
 			define_autocomplete_dictionary()
 			create_website_items_index()
 
-	def validate_field_filters(self):
-		if not (self.enable_field_filters and self.filter_fields):
+	@staticmethod
+	def validate_field_filters(filter_fields, enable_field_filters):
+		if not (enable_field_filters and filter_fields):
 			return
 
-		item_meta = frappe.get_meta("Item")
+		web_item_meta = frappe.get_meta("Website Item")
 		valid_fields = [
-			df.fieldname for df in item_meta.fields if df.fieldtype in ["Link", "Table MultiSelect"]
+			df.fieldname for df in web_item_meta.fields if df.fieldtype in ["Link", "Table MultiSelect"]
 		]
 
-		for f in self.filter_fields:
-			if f.fieldname not in valid_fields:
+		for row in filter_fields:
+			if row.fieldname not in valid_fields:
 				frappe.throw(
 					_(
-						"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type 'Link' or 'Table MultiSelect'"
-					).format(f.idx, f.fieldname)
+						"Filter Fields Row #{0}: Fieldname {1} must be of type 'Link' or 'Table MultiSelect'"
+					).format(row.idx, frappe.bold(row.fieldname))
 				)
 
 	def validate_attribute_filters(self):