chore(release): Bumped to Version 14.31.3

## [14.31.3](https://github.com/frappe/erpnext/compare/v14.31.2...v14.31.3) (2023-07-20)

### Bug Fixes

* Trial Balance report considering cancelled entries ([c5e30f5](c5e30f5336))

.github/stale.yml

@@ -13,7 +13,7 @@ exemptProjects: true
 exemptMilestones: true
 
 pulls:
-  daysUntilStale: 15
+  daysUntilStale: 14
   daysUntilClose: 3
   exemptLabels:
     - hotfix

.github/workflows/patch.yml

@@ -43,9 +43,11 @@ jobs:
           fi
 
       - name: Setup Python
-        uses: "gabrielfalcao/pyenv-action@v9"
+        uses: "actions/setup-python@v4"
         with:
-          versions: 3.10:latest, 3.7:latest
+          python-version: |
+              3.7
+              3.10
 
       - name: Setup Node
         uses: actions/setup-node@v2
@@ -92,7 +94,6 @@ jobs:
       - name: Install
         run: |
           pip install frappe-bench
-          pyenv global $(pyenv versions | grep '3.10')
           bash ${GITHUB_WORKSPACE}/.github/helper/install.sh
         env:
           DB: mariadb
@@ -107,7 +108,6 @@ jobs:
           git -C "apps/frappe" remote set-url upstream https://github.com/frappe/frappe.git
           git -C "apps/erpnext" remote set-url upstream https://github.com/frappe/erpnext.git
 
-          pyenv global $(pyenv versions | grep '3.7')
           for version in $(seq 12 13)
           do
               echo "Updating to v$version"
@@ -120,7 +120,7 @@ jobs:
               git -C "apps/erpnext" checkout -q -f $branch_name
 
               rm -rf ~/frappe-bench/env
-              bench setup env
+              bench setup env --python python3.7
               bench pip install -e ./apps/payments
               bench pip install -e ./apps/erpnext
 
@@ -132,9 +132,8 @@ jobs:
           git -C "apps/frappe" checkout -q -f "${GITHUB_BASE_REF:-${GITHUB_REF##*/}}"
           git -C "apps/erpnext" checkout -q -f "$GITHUB_SHA"
 
-          pyenv global $(pyenv versions | grep '3.10')
           rm -rf ~/frappe-bench/env
-          bench -v setup env
+          bench -v setup env --python python3.10
           bench pip install -e ./apps/payments
           bench pip install -e ./apps/erpnext
 

.github/workflows/release_notes.yml

@@ -0,0 +1,38 @@
+# This action:
+#
+# 1. Generates release notes using github API.
+# 2. Strips unnecessary info like chore/style etc from notes.
+# 3. Updates release info.
+
+# This action needs to be maintained on all branches that do releases.
+
+name: 'Release Notes'
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: 'Tag of release like v13.0.0'
+        required: true
+        type: string
+  release:
+    types: [released]
+
+permissions:
+  contents: read
+
+jobs:
+  regen-notes:
+    name: 'Regenerate release notes'
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Update notes
+      run: |
+        NEW_NOTES=$(gh api --method POST -H "Accept: application/vnd.github+json"  /repos/frappe/erpnext/releases/generate-notes  -f tag_name=$RELEASE_TAG | jq -r '.body' | sed  -E '/^\* (chore|ci|test|docs|style)/d' )
+        RELEASE_ID=$(gh api -H "Accept: application/vnd.github+json" /repos/frappe/erpnext/releases/tags/$RELEASE_TAG | jq -r '.id')
+        gh api --method PATCH -H "Accept: application/vnd.github+json" /repos/frappe/erpnext/releases/$RELEASE_ID -f body="$NEW_NOTES"
+
+      env:
+        GH_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+        RELEASE_TAG: ${{ github.event.inputs.tag_name || github.event.release.tag_name }}

erpnext/__init__.py

@@ -1,8 +1,9 @@
+import functools
 import inspect
 
 import frappe
 
-__version__ = "14.22.0"
+__version__ = "14.31.3"
 
 
 def get_default_company(user=None):
@@ -120,12 +121,14 @@ def get_region(company=None):
 
 	You can also set global company flag in `frappe.flags.company`
 	"""
-	if company or frappe.flags.company:
-		return frappe.get_cached_value("Company", company or frappe.flags.company, "country")
-	elif frappe.flags.country:
-		return frappe.flags.country
-	else:
-		return frappe.get_system_settings("country")
+
+	if not company:
+		company = frappe.local.flags.company
+
+	if company:
+		return frappe.get_cached_value("Company", company, "country")
+
+	return frappe.flags.country or frappe.get_system_settings("country")
 
 
 def allow_regional(fn):
@@ -136,6 +139,7 @@ def allow_regional(fn):
 	def myfunction():
 	  pass"""
 
+	@functools.wraps(fn)
 	def caller(*args, **kwargs):
 		overrides = frappe.get_hooks("regional_overrides", {}).get(get_region())
 		function_path = f"{inspect.getmodule(fn).__name__}.{fn.__name__}"

erpnext/accounts/dashboard_chart/budget_variance/budget_variance.json

@@ -4,18 +4,19 @@
  "creation": "2020-07-17 11:25:34.593061",
  "docstatus": 0,
  "doctype": "Dashboard Chart",
- "dynamic_filters_json": "{\"company\":\"frappe.defaults.get_user_default(\\\"Company\\\")\",\"from_fiscal_year\":\"frappe.sys_defaults.fiscal_year\",\"to_fiscal_year\":\"frappe.sys_defaults.fiscal_year\"}",
+ "dynamic_filters_json": "{\"company\":\"frappe.defaults.get_user_default(\\\"Company\\\")\",\"from_fiscal_year\":\"erpnext.utils.get_fiscal_year()\",\"to_fiscal_year\":\"erpnext.utils.get_fiscal_year()\"}",
  "filters_json": "{\"period\":\"Monthly\",\"budget_against\":\"Cost Center\",\"show_cumulative\":0}",
  "idx": 0,
  "is_public": 1,
  "is_standard": 1,
- "modified": "2020-07-22 12:24:49.144210",
+ "modified": "2023-07-19 13:13:13.307073",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Budget Variance",
  "number_of_groups": 0,
  "owner": "Administrator",
  "report_name": "Budget Variance Report",
+ "roles": [],
  "timeseries": 0,
  "type": "Bar",
  "use_report_chart": 1,

erpnext/accounts/dashboard_chart/profit_and_loss/profit_and_loss.json

@@ -4,18 +4,19 @@
  "creation": "2020-07-17 11:25:34.448572",
  "docstatus": 0,
  "doctype": "Dashboard Chart",
- "dynamic_filters_json": "{\"company\":\"frappe.defaults.get_user_default(\\\"Company\\\")\",\"from_fiscal_year\":\"frappe.sys_defaults.fiscal_year\",\"to_fiscal_year\":\"frappe.sys_defaults.fiscal_year\"}",
+ "dynamic_filters_json": "{\"company\":\"frappe.defaults.get_user_default(\\\"Company\\\")\",\"from_fiscal_year\":\"erpnext.utils.get_fiscal_year()\",\"to_fiscal_year\":\"erpnext.utils.get_fiscal_year()\"}",
  "filters_json": "{\"filter_based_on\":\"Fiscal Year\",\"period_start_date\":\"2020-04-01\",\"period_end_date\":\"2021-03-31\",\"periodicity\":\"Yearly\",\"include_default_book_entries\":1}",
  "idx": 0,
  "is_public": 1,
  "is_standard": 1,
- "modified": "2020-07-22 12:33:48.888943",
+ "modified": "2023-07-19 13:08:56.470390",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Profit and Loss",
  "number_of_groups": 0,
  "owner": "Administrator",
  "report_name": "Profit and Loss Statement",
+ "roles": [],
  "timeseries": 0,
  "type": "Bar",
  "use_report_chart": 1,

erpnext/accounts/deferred_revenue.py

@@ -136,7 +136,7 @@ def convert_deferred_revenue_to_income(
 		send_mail(deferred_process)
 
 
-def get_booking_dates(doc, item, posting_date=None):
+def get_booking_dates(doc, item, posting_date=None, prev_posting_date=None):
 	if not posting_date:
 		posting_date = add_days(today(), -1)
 
@@ -146,39 +146,42 @@ def get_booking_dates(doc, item, posting_date=None):
 		"deferred_revenue_account" if doc.doctype == "Sales Invoice" else "deferred_expense_account"
 	)
 
-	prev_gl_entry = frappe.db.sql(
-		"""
-		select name, posting_date from `tabGL Entry` where company=%s and account=%s and
-		voucher_type=%s and voucher_no=%s and voucher_detail_no=%s
-		and is_cancelled = 0
-		order by posting_date desc limit 1
-	""",
-		(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
-		as_dict=True,
-	)
+	if not prev_posting_date:
+		prev_gl_entry = frappe.db.sql(
+			"""
+			select name, posting_date from `tabGL Entry` where company=%s and account=%s and
+			voucher_type=%s and voucher_no=%s and voucher_detail_no=%s
+			and is_cancelled = 0
+			order by posting_date desc limit 1
+		""",
+			(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
+			as_dict=True,
+		)
 
-	prev_gl_via_je = frappe.db.sql(
-		"""
-		SELECT p.name, p.posting_date FROM `tabJournal Entry` p, `tabJournal Entry Account` c
-		WHERE p.name = c.parent and p.company=%s and c.account=%s
-		and c.reference_type=%s and c.reference_name=%s
-		and c.reference_detail_no=%s and c.docstatus < 2 order by posting_date desc limit 1
-	""",
-		(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
-		as_dict=True,
-	)
+		prev_gl_via_je = frappe.db.sql(
+			"""
+			SELECT p.name, p.posting_date FROM `tabJournal Entry` p, `tabJournal Entry Account` c
+			WHERE p.name = c.parent and p.company=%s and c.account=%s
+			and c.reference_type=%s and c.reference_name=%s
+			and c.reference_detail_no=%s and c.docstatus < 2 order by posting_date desc limit 1
+		""",
+			(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
+			as_dict=True,
+		)
 
-	if prev_gl_via_je:
-		if (not prev_gl_entry) or (
-			prev_gl_entry and prev_gl_entry[0].posting_date < prev_gl_via_je[0].posting_date
-		):
-			prev_gl_entry = prev_gl_via_je
+		if prev_gl_via_je:
+			if (not prev_gl_entry) or (
+				prev_gl_entry and prev_gl_entry[0].posting_date < prev_gl_via_je[0].posting_date
+			):
+				prev_gl_entry = prev_gl_via_je
+
+		if prev_gl_entry:
+			start_date = getdate(add_days(prev_gl_entry[0].posting_date, 1))
+		else:
+			start_date = item.service_start_date
 
-	if prev_gl_entry:
-		start_date = getdate(add_days(prev_gl_entry[0].posting_date, 1))
 	else:
-		start_date = item.service_start_date
-
+		start_date = getdate(add_days(prev_posting_date, 1))
 	end_date = get_last_day(start_date)
 	if end_date >= item.service_end_date:
 		end_date = item.service_end_date
@@ -341,9 +344,15 @@ def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 	accounts_frozen_upto = frappe.get_cached_value("Accounts Settings", "None", "acc_frozen_upto")
 
 	def _book_deferred_revenue_or_expense(
-		item, via_journal_entry, submit_journal_entry, book_deferred_entries_based_on
+		item,
+		via_journal_entry,
+		submit_journal_entry,
+		book_deferred_entries_based_on,
+		prev_posting_date=None,
 	):
-		start_date, end_date, last_gl_entry = get_booking_dates(doc, item, posting_date=posting_date)
+		start_date, end_date, last_gl_entry = get_booking_dates(
+			doc, item, posting_date=posting_date, prev_posting_date=prev_posting_date
+		)
 		if not (start_date and end_date):
 			return
 
@@ -377,9 +386,12 @@ def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 		if not amount:
 			return
 
+		gl_posting_date = end_date
+		prev_posting_date = None
 		# check if books nor frozen till endate:
 		if accounts_frozen_upto and getdate(end_date) <= getdate(accounts_frozen_upto):
-			end_date = get_last_day(add_days(accounts_frozen_upto, 1))
+			gl_posting_date = get_last_day(add_days(accounts_frozen_upto, 1))
+			prev_posting_date = end_date
 
 		if via_journal_entry:
 			book_revenue_via_journal_entry(
@@ -388,7 +400,7 @@ def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 				debit_account,
 				amount,
 				base_amount,
-				end_date,
+				gl_posting_date,
 				project,
 				account_currency,
 				item.cost_center,
@@ -404,7 +416,7 @@ def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 				against,
 				amount,
 				base_amount,
-				end_date,
+				gl_posting_date,
 				project,
 				account_currency,
 				item.cost_center,
@@ -418,7 +430,11 @@ def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 
 		if getdate(end_date) < getdate(posting_date) and not last_gl_entry:
 			_book_deferred_revenue_or_expense(
-				item, via_journal_entry, submit_journal_entry, book_deferred_entries_based_on
+				item,
+				via_journal_entry,
+				submit_journal_entry,
+				book_deferred_entries_based_on,
+				prev_posting_date,
 			)
 
 	via_journal_entry = cint(

erpnext/accounts/doctype/account/account.py

@@ -201,8 +201,11 @@ class Account(NestedSet):
 				)
 
 	def validate_account_currency(self):
+		self.currency_explicitly_specified = True
+
 		if not self.account_currency:
 			self.account_currency = frappe.get_cached_value("Company", self.company, "default_currency")
+			self.currency_explicitly_specified = False
 
 		gl_currency = frappe.db.get_value("GL Entry", {"account": self.name}, "account_currency")
 
@@ -248,8 +251,10 @@ class Account(NestedSet):
 					{
 						"company": company,
 						# parent account's currency should be passed down to child account's curreny
-						# if it is None, it picks it up from default company currency, which might be unintended
-						"account_currency": erpnext.get_company_currency(company),
+						# if currency explicitly specified by user, child will inherit. else, default currency will be used.
+						"account_currency": self.account_currency
+						if self.currency_explicitly_specified
+						else erpnext.get_company_currency(company),
 						"parent_account": parent_acc_name_map[company],
 					}
 				)

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

@@ -2,75 +2,13 @@
     "country_code": "nl", 
     "name": "Netherlands - Grootboekschema", 
     "tree": {
-        "FABRIKAGEREKENINGEN": {
-			"is_group": 1,
-            "root_type": "Expense"
-        }, 
         "FINANCIELE REKENINGEN, KORTLOPENDE VORDERINGEN EN SCHULDEN": {
             "Bank": {
                 "RABO Bank": {
                     "account_type": "Bank"
                 }, 
                 "account_type": "Bank"
-            }, 
-            "KORTLOPENDE SCHULDEN": {
-                "Af te dragen Btw-verlegd": {
-                    "account_type": "Tax"
-                }, 
-                "Afdracht loonheffing": {}, 
-                "Btw af te dragen hoog": {
-                    "account_type": "Tax"
-                }, 
-                "Btw af te dragen laag": {
-                    "account_type": "Tax"
-                }, 
-                "Btw af te dragen overig": {
-                    "account_type": "Tax"
-                }, 
-                "Btw oude jaren": {
-                    "account_type": "Tax"
-                }, 
-                "Btw te vorderen hoog": {
-                    "account_type": "Tax"
-                }, 
-                "Btw te vorderen laag": {
-                    "account_type": "Tax"
-                }, 
-                "Btw te vorderen overig": {
-                    "account_type": "Tax"
-                }, 
-                "Btw-afdracht": {
-                    "account_type": "Tax"
-                }, 
-                "Crediteuren": {
-                    "account_type": "Payable"
-                }, 
-                "Dividend": {}, 
-                "Dividendbelasting": {}, 
-                "Energiekosten 1": {}, 
-                "Investeringsaftrek": {}, 
-                "Loonheffing": {}, 
-                "Overige te betalen posten": {}, 
-                "Pensioenpremies 1": {}, 
-                "Premie WIR": {}, 
-                "Rekening-courant inkoopvereniging": {}, 
-                "Rente": {}, 
-                "Sociale lasten 1": {}, 
-                "Stock Recieved niet gefactureerd": {
-                    "account_type": "Stock Received But Not Billed"
-                }, 
-                "Tanti\u00e8mes 1": {}, 
-                "Te vorderen Btw-verlegd": {
-                    "account_type": "Tax"
-                }, 
-                "Telefoon/telefax 1": {}, 
-                "Termijnen onderh. werk": {}, 
-                "Vakantiedagen": {}, 
-                "Vakantiegeld 1": {}, 
-                "Vakantiezegels": {}, 
-                "Vennootschapsbelasting": {}, 
-                "Vooruit ontvangen bedr.": {}
-            }, 
+            },
             "LIQUIDE MIDDELEN": {
                 "ABN-AMRO bank": {}, 
                 "Bankbetaalkaarten": {}, 
@@ -91,6 +29,110 @@
                 }, 
                 "account_type": "Cash"
             }, 
+            "TUSSENREKENINGEN": {
+                "Betaalwijze cadeaubonnen": {
+                    "account_type": "Cash"
+                }, 
+                "Betaalwijze chipknip": {
+                    "account_type": "Cash"
+                }, 
+                "Betaalwijze contant": {
+                    "account_type": "Cash"
+                }, 
+                "Betaalwijze pin": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen Nederland hoog": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen Nederland laag": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen Nederland onbelast": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen Nederland overig": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen Nederland verlegd": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen binnen EU hoog": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen binnen EU laag": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen binnen EU overig": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen buiten EU hoog": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen buiten EU laag": {
+                    "account_type": "Cash"
+                }, 
+                "Inkopen buiten EU overig": {
+                    "account_type": "Cash"
+                }, 
+                "Kassa 1": {
+                    "account_type": "Cash"
+                }, 
+                "Kassa 2": {
+                    "account_type": "Cash"
+                }, 
+                "Netto lonen": {
+                    "account_type": "Cash"
+                }, 
+                "Tegenrekening Inkopen": {
+                    "account_type": "Cash"
+                }, 
+                "Tussenrek. autom. betalingen": {
+                    "account_type": "Cash"
+                }, 
+                "Tussenrek. autom. loonbetalingen": {
+                    "account_type": "Cash"
+                }, 
+                "Tussenrek. cadeaubonbetalingen": {
+                    "account_type": "Cash"
+                }, 
+                "Tussenrekening balans": {
+                    "account_type": "Cash"
+                }, 
+                "Tussenrekening chipknip": {
+                    "account_type": "Cash"
+                }, 
+                "Tussenrekening correcties": {
+                    "account_type": "Cash"
+                }, 
+                "Tussenrekening pin": {
+                    "account_type": "Cash"
+                }, 
+                "Vraagposten": {
+                    "account_type": "Cash"
+                },
+                "VOORRAAD GRONDSTOFFEN, HULPMATERIALEN EN HANDELSGOEDEREN": {
+                    "Emballage": {}, 
+                    "Gereed product 1": {}, 
+                    "Gereed product 2": {}, 
+                    "Goederen 1": {}, 
+                    "Goederen 2": {}, 
+                    "Goederen in consignatie": {}, 
+                    "Goederen onderweg": {}, 
+                    "Grondstoffen 1": {}, 
+                    "Grondstoffen 2": {}, 
+                    "Halffabrikaten 1": {}, 
+                    "Halffabrikaten 2": {}, 
+                    "Hulpstoffen 1": {}, 
+                    "Hulpstoffen 2": {}, 
+                    "Kantoorbenodigdheden": {}, 
+                    "Onderhanden werk": {}, 
+                    "Verpakkingsmateriaal": {}, 
+                    "Zegels": {}, 
+                    "root_type": "Asset"
+                },
+                "root_type": "Asset"
+            },
             "VORDERINGEN": {
                 "Debiteuren": {
                     "account_type": "Receivable"
@@ -104,278 +146,299 @@
                 "Voorziening dubieuze debiteuren": {}
             }, 
             "root_type": "Asset"
-        }, 
-        "INDIRECTE KOSTEN": {
+        },
+        "KORTLOPENDE SCHULDEN": {
+            "Af te dragen Btw-verlegd": {
+                "account_type": "Tax"
+            }, 
+            "Afdracht loonheffing": {}, 
+            "Btw af te dragen hoog": {
+                "account_type": "Tax"
+            }, 
+            "Btw af te dragen laag": {
+                "account_type": "Tax"
+            }, 
+            "Btw af te dragen overig": {
+                "account_type": "Tax"
+            }, 
+            "Btw oude jaren": {
+                "account_type": "Tax"
+            }, 
+            "Btw te vorderen hoog": {
+                "account_type": "Tax"
+            }, 
+            "Btw te vorderen laag": {
+                "account_type": "Tax"
+            }, 
+            "Btw te vorderen overig": {
+                "account_type": "Tax"
+            }, 
+            "Btw-afdracht": {
+                "account_type": "Tax"
+            }, 
+            "Crediteuren": {
+                "account_type": "Payable"
+            }, 
+            "Dividend": {}, 
+            "Dividendbelasting": {}, 
+            "Energiekosten 1": {}, 
+            "Investeringsaftrek": {}, 
+            "Loonheffing": {}, 
+            "Overige te betalen posten": {}, 
+            "Pensioenpremies 1": {}, 
+            "Premie WIR": {}, 
+            "Rekening-courant inkoopvereniging": {}, 
+            "Rente": {}, 
+            "Sociale lasten 1": {}, 
+            "Stock Recieved niet gefactureerd": {
+                "account_type": "Stock Received But Not Billed"
+            }, 
+            "Tanti\u00e8mes 1": {}, 
+            "Te vorderen Btw-verlegd": {
+                "account_type": "Tax"
+            }, 
+            "Telefoon/telefax 1": {}, 
+            "Termijnen onderh. werk": {}, 
+            "Vakantiedagen": {}, 
+            "Vakantiegeld 1": {}, 
+            "Vakantiezegels": {}, 
+            "Vennootschapsbelasting": {}, 
+            "Vooruit ontvangen bedr.": {},
+            "is_group": 1,
+            "root_type": "Liability"
+        },
+        "FABRIKAGEREKENINGEN": {
 			"is_group": 1,
-            "root_type": "Expense"
-        }, 
-        "KOSTENREKENINGEN": {
-            "AFSCHRIJVINGEN": {
-                "Aanhangwagens": {}, 
-                "Aankoopkosten": {}, 
-                "Aanloopkosten": {}, 
-                "Auteursrechten": {}, 
-                "Bedrijfsgebouwen": {}, 
-                "Bedrijfsinventaris": {
+            "root_type": "Expense",
+            "INDIRECTE KOSTEN": {
+                "is_group": 1,
+                "root_type": "Expense"
+            }, 
+            "KOSTENREKENINGEN": {
+                "AFSCHRIJVINGEN": {
+                    "Aanhangwagens": {}, 
+                    "Aankoopkosten": {}, 
+                    "Aanloopkosten": {}, 
+                    "Auteursrechten": {}, 
+                    "Bedrijfsgebouwen": {}, 
+                    "Bedrijfsinventaris": {
+                        "account_type": "Depreciation"
+                    }, 
+                    "Drankvergunningen": {}, 
+                    "Fabrieksinventaris": {
+                        "account_type": "Depreciation"
+                    }, 
+                    "Gebouwen": {}, 
+                    "Gereedschappen": {}, 
+                    "Goodwill": {}, 
+                    "Grondverbetering": {}, 
+                    "Heftrucks": {}, 
+                    "Kantine-inventaris": {}, 
+                    "Kantoorinventaris": {
+                        "account_type": "Depreciation"
+                    }, 
+                    "Kantoormachines": {}, 
+                    "Licenties": {}, 
+                    "Machines 1": {}, 
+                    "Magazijninventaris": {}, 
+                    "Octrooien": {}, 
+                    "Ontwikkelingskosten": {}, 
+                    "Pachtersinvestering": {}, 
+                    "Parkeerplaats": {}, 
+                    "Personenauto's": {
+                        "account_type": "Depreciation"
+                    }, 
+                    "Rijwielen en bromfietsen": {}, 
+                    "Tonnagevergunningen": {}, 
+                    "Verbouwingen": {}, 
+                    "Vergunningen": {}, 
+                    "Voorraadverschillen": {}, 
+                    "Vrachtauto's": {}, 
+                    "Winkels": {}, 
+                    "Woon-winkelhuis": {}, 
                     "account_type": "Depreciation"
                 }, 
-                "Drankvergunningen": {}, 
-                "Fabrieksinventaris": {
-                    "account_type": "Depreciation"
+                "ALGEMENE KOSTEN": {
+                    "Accountantskosten": {}, 
+                    "Advieskosten": {}, 
+                    "Assuranties 1": {}, 
+                    "Bankkosten": {}, 
+                    "Juridische kosten": {}, 
+                    "Overige algemene kosten": {}, 
+                    "Toev. Ass. eigen risico": {}
                 }, 
-                "Gebouwen": {}, 
-                "Gereedschappen": {}, 
-                "Goodwill": {}, 
-                "Grondverbetering": {}, 
-                "Heftrucks": {}, 
-                "Kantine-inventaris": {}, 
-                "Kantoorinventaris": {
-                    "account_type": "Depreciation"
+                "BEDRIJFSKOSTEN": {
+                    "Assuranties 2": {}, 
+                    "Energie (krachtstroom)": {}, 
+                    "Gereedschappen 1": {}, 
+                    "Hulpmaterialen 1": {}, 
+                    "Huur inventaris": {}, 
+                    "Huur machines": {}, 
+                    "Leasing invent.operational": {}, 
+                    "Leasing mach. operational": {}, 
+                    "Onderhoud inventaris": {}, 
+                    "Onderhoud machines": {}, 
+                    "Ophalen/vervoer afval": {}, 
+                    "Overige bedrijfskosten": {}
                 }, 
-                "Kantoormachines": {}, 
-                "Licenties": {}, 
-                "Machines 1": {}, 
-                "Magazijninventaris": {}, 
-                "Octrooien": {}, 
-                "Ontwikkelingskosten": {}, 
-                "Pachtersinvestering": {}, 
-                "Parkeerplaats": {}, 
-                "Personenauto's": {
-                    "account_type": "Depreciation"
+                "FINANCIERINGSKOSTEN 1": {
+                    "Overige rentebaten": {}, 
+                    "Overige rentelasten": {}, 
+                    "Rente bankkrediet": {}, 
+                    "Rente huurkoopcontracten": {}, 
+                    "Rente hypotheek": {}, 
+                    "Rente leasecontracten": {}, 
+                    "Rente lening o/g": {}, 
+                    "Rente lening u/g": {}
                 }, 
-                "Rijwielen en bromfietsen": {}, 
-                "Tonnagevergunningen": {}, 
-                "Verbouwingen": {}, 
-                "Vergunningen": {}, 
-                "Voorraadverschillen": {}, 
-                "Vrachtauto's": {}, 
-                "Winkels": {}, 
-                "Woon-winkelhuis": {}, 
-                "account_type": "Depreciation"
-            }, 
-            "ALGEMENE KOSTEN": {
-                "Accountantskosten": {}, 
-                "Advieskosten": {}, 
-                "Assuranties 1": {}, 
-                "Bankkosten": {}, 
-                "Juridische kosten": {}, 
-                "Overige algemene kosten": {}, 
-                "Toev. Ass. eigen risico": {}
-            }, 
-            "BEDRIJFSKOSTEN": {
-                "Assuranties 2": {}, 
-                "Energie (krachtstroom)": {}, 
-                "Gereedschappen 1": {}, 
-                "Hulpmaterialen 1": {}, 
-                "Huur inventaris": {}, 
-                "Huur machines": {}, 
-                "Leasing invent.operational": {}, 
-                "Leasing mach. operational": {}, 
-                "Onderhoud inventaris": {}, 
-                "Onderhoud machines": {}, 
-                "Ophalen/vervoer afval": {}, 
-                "Overige bedrijfskosten": {}
-            }, 
-            "FINANCIERINGSKOSTEN 1": {
-                "Overige rentebaten": {}, 
-                "Overige rentelasten": {}, 
-                "Rente bankkrediet": {}, 
-                "Rente huurkoopcontracten": {}, 
-                "Rente hypotheek": {}, 
-                "Rente leasecontracten": {}, 
-                "Rente lening o/g": {}, 
-                "Rente lening u/g": {}
-            }, 
-            "HUISVESTINGSKOSTEN": {
-                "Assurantie onroerend goed": {}, 
-                "Belastingen onr. Goed": {}, 
-                "Energiekosten": {}, 
-                "Groot onderhoud onr. Goed": {}, 
-                "Huur": {}, 
-                "Huurwaarde woongedeelte": {}, 
-                "Onderhoud onroerend goed": {}, 
-                "Ontvangen huren": {}, 
-                "Overige huisvestingskosten": {}, 
-                "Pacht": {}, 
-                "Schoonmaakkosten": {}, 
-                "Toevoeging egalisatieres. Groot onderhoud": {}
-            }, 
-            "KANTOORKOSTEN": {
-                "Administratiekosten": {}, 
-                "Contributies/abonnementen": {}, 
-                "Huur kantoorapparatuur": {}, 
-                "Internetaansluiting": {}, 
-                "Kantoorbenodigdh./drukw.": {}, 
-                "Onderhoud kantoorinvent.": {}, 
-                "Overige kantoorkosten": {}, 
-                "Porti": {}, 
-                "Telefoon/telefax": {}
-            }, 
-            "OVERIGE BATEN EN LASTEN": {
-                "Betaalde schadevergoed.": {}, 
-                "Boekverlies vaste activa": {}, 
-                "Boekwinst van vaste activa": {}, 
-                "K.O. regeling OB": {}, 
-                "Kasverschillen": {}, 
-                "Kosten loonbelasting": {}, 
-                "Kosten omzetbelasting": {}, 
-                "Nadelige koersverschillen": {}, 
-                "Naheffing bedrijfsver.": {}, 
-                "Ontvangen schadevergoed.": {}, 
-                "Overige baten": {}, 
-                "Overige lasten": {}, 
-                "Voordelige koersverschil.": {}
-            }, 
-            "PERSONEELSKOSTEN": {
-                "Autokostenvergoeding": {}, 
-                "Bedrijfskleding": {}, 
-                "Belastingvrije uitkeringen": {}, 
-                "Bijzondere beloningen": {}, 
-                "Congressen, seminars en symposia": {}, 
-                "Gereedschapsgeld": {}, 
-                "Geschenken personeel": {}, 
-                "Gratificaties": {}, 
-                "Inhouding pensioenpremies": {}, 
-                "Inhouding sociale lasten": {}, 
-                "Kantinekosten": {}, 
-                "Lonen en salarissen": {}, 
-                "Loonwerk": {}, 
-                "Managementvergoedingen": {}, 
-                "Opleidingskosten": {}, 
-                "Oprenting stamrechtverpl.": {}, 
-                "Overhevelingstoeslag": {}, 
-                "Overige kostenverg.": {}, 
-                "Overige personeelskosten": {}, 
-                "Overige uitkeringen": {}, 
-                "Pensioenpremies": {}, 
-                "Provisie 1": {}, 
-                "Reiskosten": {}, 
-                "Rijwielvergoeding": {}, 
-                "Sociale lasten": {}, 
-                "Tanti\u00e8mes": {}, 
-                "Thuiswerkers": {}, 
-                "Toev. Backservice pens.verpl.": {}, 
-                "Toevoeging pensioenverpl.": {}, 
-                "Uitkering ziekengeld": {}, 
-                "Uitzendkrachten": {}, 
-                "Vakantiebonnen": {}, 
-                "Vakantiegeld": {}, 
-                "Vergoeding studiekosten": {}, 
-                "Wervingskosten personeel": {}
-            }, 
-            "VERKOOPKOSTEN": {
-                "Advertenties": {}, 
-                "Afschrijving dubieuze deb.": {}, 
-                "Beurskosten": {}, 
-                "Etalagekosten": {}, 
-                "Exportkosten": {}, 
-                "Kascorrecties": {}, 
-                "Overige verkoopkosten": {}, 
-                "Provisie": {}, 
-                "Reclame": {}, 
-                "Reis en verblijfkosten": {}, 
-                "Relatiegeschenken": {}, 
-                "Representatiekosten": {}, 
-                "Uitgaande vrachten": {}, 
-                "Veilingkosten": {}, 
-                "Verpakkingsmateriaal 1": {}, 
-                "Websitekosten": {}
-            }, 
-            "VERVOERSKOSTEN": {
-                "Assuranties auto's": {}, 
-                "Brandstoffen": {}, 
-                "Leasing auto's": {}, 
-                "Onderhoud personenauto's": {}, 
-                "Onderhoud vrachtauto's": {}, 
-                "Overige vervoerskosten": {}, 
-                "Priv\u00e9-gebruik auto's": {}, 
-                "Wegenbelasting": {}
-            }, 
-            "root_type": "Expense"
-        }, 
-        "TUSSENREKENINGEN": {
-            "Betaalwijze cadeaubonnen": {
-                "account_type": "Cash"
-            }, 
-            "Betaalwijze chipknip": {
-                "account_type": "Cash"
-            }, 
-            "Betaalwijze contant": {
-                "account_type": "Cash"
-            }, 
-            "Betaalwijze pin": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen Nederland hoog": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen Nederland laag": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen Nederland onbelast": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen Nederland overig": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen Nederland verlegd": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen binnen EU hoog": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen binnen EU laag": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen binnen EU overig": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen buiten EU hoog": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen buiten EU laag": {
-                "account_type": "Cash"
-            }, 
-            "Inkopen buiten EU overig": {
-                "account_type": "Cash"
-            }, 
-            "Kassa 1": {
-                "account_type": "Cash"
-            }, 
-            "Kassa 2": {
-                "account_type": "Cash"
-            }, 
-            "Netto lonen": {
-                "account_type": "Cash"
-            }, 
-            "Tegenrekening Inkopen": {
-                "account_type": "Cash"
-            }, 
-            "Tussenrek. autom. betalingen": {
-                "account_type": "Cash"
-            }, 
-            "Tussenrek. autom. loonbetalingen": {
-                "account_type": "Cash"
-            }, 
-            "Tussenrek. cadeaubonbetalingen": {
-                "account_type": "Cash"
-            }, 
-            "Tussenrekening balans": {
-                "account_type": "Cash"
-            }, 
-            "Tussenrekening chipknip": {
-                "account_type": "Cash"
-            }, 
-            "Tussenrekening correcties": {
-                "account_type": "Cash"
-            }, 
-            "Tussenrekening pin": {
-                "account_type": "Cash"
-            }, 
-            "Vraagposten": {
-                "account_type": "Cash"
-            }, 
-            "root_type": "Asset"
+                "HUISVESTINGSKOSTEN": {
+                    "Assurantie onroerend goed": {}, 
+                    "Belastingen onr. Goed": {}, 
+                    "Energiekosten": {}, 
+                    "Groot onderhoud onr. Goed": {}, 
+                    "Huur": {}, 
+                    "Huurwaarde woongedeelte": {}, 
+                    "Onderhoud onroerend goed": {}, 
+                    "Ontvangen huren": {}, 
+                    "Overige huisvestingskosten": {}, 
+                    "Pacht": {}, 
+                    "Schoonmaakkosten": {}, 
+                    "Toevoeging egalisatieres. Groot onderhoud": {}
+                }, 
+                "KANTOORKOSTEN": {
+                    "Administratiekosten": {}, 
+                    "Contributies/abonnementen": {}, 
+                    "Huur kantoorapparatuur": {}, 
+                    "Internetaansluiting": {}, 
+                    "Kantoorbenodigdh./drukw.": {}, 
+                    "Onderhoud kantoorinvent.": {}, 
+                    "Overige kantoorkosten": {}, 
+                    "Porti": {}, 
+                    "Telefoon/telefax": {}
+                }, 
+                "OVERIGE BATEN EN LASTEN": {
+                    "Betaalde schadevergoed.": {}, 
+                    "Boekverlies vaste activa": {}, 
+                    "Boekwinst van vaste activa": {}, 
+                    "K.O. regeling OB": {}, 
+                    "Kasverschillen": {}, 
+                    "Kosten loonbelasting": {}, 
+                    "Kosten omzetbelasting": {}, 
+                    "Nadelige koersverschillen": {}, 
+                    "Naheffing bedrijfsver.": {}, 
+                    "Ontvangen schadevergoed.": {}, 
+                    "Overige baten": {}, 
+                    "Overige lasten": {}, 
+                    "Voordelige koersverschil.": {}
+                }, 
+                "PERSONEELSKOSTEN": {
+                    "Autokostenvergoeding": {}, 
+                    "Bedrijfskleding": {}, 
+                    "Belastingvrije uitkeringen": {}, 
+                    "Bijzondere beloningen": {}, 
+                    "Congressen, seminars en symposia": {}, 
+                    "Gereedschapsgeld": {}, 
+                    "Geschenken personeel": {}, 
+                    "Gratificaties": {}, 
+                    "Inhouding pensioenpremies": {}, 
+                    "Inhouding sociale lasten": {}, 
+                    "Kantinekosten": {}, 
+                    "Lonen en salarissen": {}, 
+                    "Loonwerk": {}, 
+                    "Managementvergoedingen": {}, 
+                    "Opleidingskosten": {}, 
+                    "Oprenting stamrechtverpl.": {}, 
+                    "Overhevelingstoeslag": {}, 
+                    "Overige kostenverg.": {}, 
+                    "Overige personeelskosten": {}, 
+                    "Overige uitkeringen": {}, 
+                    "Pensioenpremies": {}, 
+                    "Provisie 1": {}, 
+                    "Reiskosten": {}, 
+                    "Rijwielvergoeding": {}, 
+                    "Sociale lasten": {}, 
+                    "Tanti\u00e8mes": {}, 
+                    "Thuiswerkers": {}, 
+                    "Toev. Backservice pens.verpl.": {}, 
+                    "Toevoeging pensioenverpl.": {}, 
+                    "Uitkering ziekengeld": {}, 
+                    "Uitzendkrachten": {}, 
+                    "Vakantiebonnen": {}, 
+                    "Vakantiegeld": {}, 
+                    "Vergoeding studiekosten": {}, 
+                    "Wervingskosten personeel": {}
+                }, 
+                "VERKOOPKOSTEN": {
+                    "Advertenties": {}, 
+                    "Afschrijving dubieuze deb.": {}, 
+                    "Beurskosten": {}, 
+                    "Etalagekosten": {}, 
+                    "Exportkosten": {}, 
+                    "Kascorrecties": {}, 
+                    "Overige verkoopkosten": {}, 
+                    "Provisie": {}, 
+                    "Reclame": {}, 
+                    "Reis en verblijfkosten": {}, 
+                    "Relatiegeschenken": {}, 
+                    "Representatiekosten": {}, 
+                    "Uitgaande vrachten": {}, 
+                    "Veilingkosten": {}, 
+                    "Verpakkingsmateriaal 1": {}, 
+                    "Websitekosten": {}
+                }, 
+                "VERVOERSKOSTEN": {
+                    "Assuranties auto's": {}, 
+                    "Brandstoffen": {}, 
+                    "Leasing auto's": {}, 
+                    "Onderhoud personenauto's": {}, 
+                    "Onderhoud vrachtauto's": {}, 
+                    "Overige vervoerskosten": {}, 
+                    "Priv\u00e9-gebruik auto's": {}, 
+                    "Wegenbelasting": {}
+                },
+                "VOORRAAD GEREED PRODUCT EN ONDERHANDEN WERK": {
+                    "Betalingskort. crediteuren": {}, 
+                    "Garantiekosten": {}, 
+                    "Hulpmaterialen": {}, 
+                    "Inkomende vrachten": {
+                        "account_type": "Expenses Included In Valuation"
+                    }, 
+                    "Inkoop import buiten EU hoog": {}, 
+                    "Inkoop import buiten EU laag": {}, 
+                    "Inkoop import buiten EU overig": {}, 
+                    "Inkoopbonussen": {}, 
+                    "Inkoopkosten": {}, 
+                    "Inkoopprovisie": {}, 
+                    "Inkopen BTW verlegd": {}, 
+                    "Inkopen EU hoog tarief": {}, 
+                    "Inkopen EU laag tarief": {}, 
+                    "Inkopen EU overig": {}, 
+                    "Inkopen hoog": {}, 
+                    "Inkopen laag": {}, 
+                    "Inkopen nul": {}, 
+                    "Inkopen overig": {}, 
+                    "Invoerkosten": {}, 
+                    "Kosten inkoopvereniging": {}, 
+                    "Kostprijs omzet grondstoffen": {
+                        "account_type": "Cost of Goods Sold"
+                    }, 
+                    "Kostprijs omzet handelsgoederen": {}, 
+                    "Onttrekking uitgev.garantie": {}, 
+                    "Priv\u00e9-gebruik goederen": {}, 
+                    "Stock aanpassing": {
+                        "account_type": "Stock Adjustment"
+                    }, 
+                    "Tegenrekening inkoop": {}, 
+                    "Toev. Voorz. incour. grondst.": {}, 
+                    "Toevoeging garantieverpl.": {}, 
+                    "Toevoeging voorz. incour. handelsgoed.": {}, 
+                    "Uitbesteed werk": {}, 
+                    "Voorz. Incourourant grondst.": {}, 
+                    "Voorz.incour. handelsgoed.": {}, 
+                    "root_type": "Expense"
+                },
+                "root_type": "Expense"
+            }
         }, 
         "VASTE ACTIVA, EIGEN VERMOGEN, LANGLOPEND VREEMD VERMOGEN EN VOORZIENINGEN": {
             "EIGEN VERMOGEN": {
@@ -602,7 +665,7 @@
                     "account_type": "Equity"
                 }
             }, 
-            "root_type": "Asset"
+            "root_type": "Equity"
         }, 
         "VERKOOPRESULTATEN": {
             "Diensten fabric. 0% niet-EU": {}, 
@@ -627,67 +690,6 @@
             "Verleende Kredietbep. fabricage": {}, 
             "Verleende Kredietbep. handel": {}, 
             "root_type": "Income"
-        }, 
-        "VOORRAAD GEREED PRODUCT EN ONDERHANDEN WERK": {
-            "Betalingskort. crediteuren": {}, 
-            "Garantiekosten": {}, 
-            "Hulpmaterialen": {}, 
-            "Inkomende vrachten": {
-                "account_type": "Expenses Included In Valuation"
-            }, 
-            "Inkoop import buiten EU hoog": {}, 
-            "Inkoop import buiten EU laag": {}, 
-            "Inkoop import buiten EU overig": {}, 
-            "Inkoopbonussen": {}, 
-            "Inkoopkosten": {}, 
-            "Inkoopprovisie": {}, 
-            "Inkopen BTW verlegd": {}, 
-            "Inkopen EU hoog tarief": {}, 
-            "Inkopen EU laag tarief": {}, 
-            "Inkopen EU overig": {}, 
-            "Inkopen hoog": {}, 
-            "Inkopen laag": {}, 
-            "Inkopen nul": {}, 
-            "Inkopen overig": {}, 
-            "Invoerkosten": {}, 
-            "Kosten inkoopvereniging": {}, 
-            "Kostprijs omzet grondstoffen": {
-                "account_type": "Cost of Goods Sold"
-            }, 
-            "Kostprijs omzet handelsgoederen": {}, 
-            "Onttrekking uitgev.garantie": {}, 
-            "Priv\u00e9-gebruik goederen": {}, 
-            "Stock aanpassing": {
-                "account_type": "Stock Adjustment"
-            }, 
-            "Tegenrekening inkoop": {}, 
-            "Toev. Voorz. incour. grondst.": {}, 
-            "Toevoeging garantieverpl.": {}, 
-            "Toevoeging voorz. incour. handelsgoed.": {}, 
-            "Uitbesteed werk": {}, 
-            "Voorz. Incourourant grondst.": {}, 
-            "Voorz.incour. handelsgoed.": {}, 
-            "root_type": "Expense"
-        }, 
-        "VOORRAAD GRONDSTOFFEN, HULPMATERIALEN EN HANDELSGOEDEREN": {
-            "Emballage": {}, 
-            "Gereed product 1": {}, 
-            "Gereed product 2": {}, 
-            "Goederen 1": {}, 
-            "Goederen 2": {}, 
-            "Goederen in consignatie": {}, 
-            "Goederen onderweg": {}, 
-            "Grondstoffen 1": {}, 
-            "Grondstoffen 2": {}, 
-            "Halffabrikaten 1": {}, 
-            "Halffabrikaten 2": {}, 
-            "Hulpstoffen 1": {}, 
-            "Hulpstoffen 2": {}, 
-            "Kantoorbenodigdheden": {}, 
-            "Onderhanden werk": {}, 
-            "Verpakkingsmateriaal": {}, 
-            "Zegels": {}, 
-            "root_type": "Asset"
         }
     }
 }

erpnext/accounts/doctype/account/test_account.py

@@ -5,10 +5,13 @@
 import unittest
 
 import frappe
+from frappe.test_runner import make_test_records
 
 from erpnext.accounts.doctype.account.account import merge_account, update_account_number
 from erpnext.stock import get_company_default_inventory_account, get_warehouse_account
 
+test_dependencies = ["Company"]
+
 
 class TestAccount(unittest.TestCase):
 	def test_rename_account(self):
@@ -188,6 +191,58 @@ class TestAccount(unittest.TestCase):
 		frappe.delete_doc("Account", "1234 - Test Rename Sync Account - _TC4")
 		frappe.delete_doc("Account", "1234 - Test Rename Sync Account - _TC5")
 
+	def test_account_currency_sync(self):
+		"""
+		In a parent->child company setup, child should inherit parent account currency if explicitly specified.
+		"""
+
+		make_test_records("Company")
+
+		frappe.local.flags.pop("ignore_root_company_validation", None)
+
+		def create_bank_account():
+			acc = frappe.new_doc("Account")
+			acc.account_name = "_Test Bank JPY"
+
+			acc.parent_account = "Temporary Accounts - _TC6"
+			acc.company = "_Test Company 6"
+			return acc
+
+		acc = create_bank_account()
+		# Explicitly set currency
+		acc.account_currency = "JPY"
+		acc.insert()
+		self.assertTrue(
+			frappe.db.exists(
+				{
+					"doctype": "Account",
+					"account_name": "_Test Bank JPY",
+					"account_currency": "JPY",
+					"company": "_Test Company 7",
+				}
+			)
+		)
+
+		frappe.delete_doc("Account", "_Test Bank JPY - _TC6")
+		frappe.delete_doc("Account", "_Test Bank JPY - _TC7")
+
+		acc = create_bank_account()
+		# default currency is used
+		acc.insert()
+		self.assertTrue(
+			frappe.db.exists(
+				{
+					"doctype": "Account",
+					"account_name": "_Test Bank JPY",
+					"account_currency": "USD",
+					"company": "_Test Company 7",
+				}
+			)
+		)
+
+		frappe.delete_doc("Account", "_Test Bank JPY - _TC6")
+		frappe.delete_doc("Account", "_Test Bank JPY - _TC7")
+
 	def test_child_company_account_rename_sync(self):
 		frappe.local.flags.pop("ignore_root_company_validation", None)
 
@@ -297,7 +352,7 @@ def _make_test_records(verbose=None):
 		# fixed asset depreciation
 		["_Test Fixed Asset", "Current Assets", 0, "Fixed Asset", None],
 		["_Test Accumulated Depreciations", "Current Assets", 0, "Accumulated Depreciation", None],
-		["_Test Depreciations", "Expenses", 0, None, None],
+		["_Test Depreciations", "Expenses", 0, "Depreciation", None],
 		["_Test Gain/Loss on Asset Disposal", "Expenses", 0, None, None],
 		# Receivable / Payable Account
 		["_Test Receivable", "Current Assets", 0, "Receivable", None],

erpnext/accounts/doctype/account_closing_balance/account_closing_balance.js

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

erpnext/accounts/doctype/account_closing_balance/account_closing_balance.json

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

erpnext/accounts/doctype/account_closing_balance/account_closing_balance.py

@@ -0,0 +1,125 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+import frappe
+from frappe.model.document import Document
+from frappe.utils import cint, cstr
+
+from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
+	get_accounting_dimensions,
+)
+
+
+class AccountClosingBalance(Document):
+	pass
+
+
+def make_closing_entries(closing_entries, voucher_name, company, closing_date):
+	accounting_dimensions = get_accounting_dimensions()
+
+	previous_closing_entries = get_previous_closing_entries(
+		company, closing_date, accounting_dimensions
+	)
+	combined_entries = closing_entries + previous_closing_entries
+
+	merged_entries = aggregate_with_last_account_closing_balance(
+		combined_entries, accounting_dimensions
+	)
+
+	for key, value in merged_entries.items():
+		cle = frappe.new_doc("Account Closing Balance")
+		cle.update(value)
+		cle.update(value["dimensions"])
+		cle.update(
+			{
+				"period_closing_voucher": voucher_name,
+				"closing_date": closing_date,
+			}
+		)
+		cle.submit()
+
+
+def aggregate_with_last_account_closing_balance(entries, accounting_dimensions):
+	merged_entries = {}
+	for entry in entries:
+		key, key_values = generate_key(entry, accounting_dimensions)
+		merged_entries.setdefault(
+			key,
+			{
+				"debit": 0,
+				"credit": 0,
+				"debit_in_account_currency": 0,
+				"credit_in_account_currency": 0,
+			},
+		)
+
+		merged_entries[key]["dimensions"] = key_values
+		merged_entries[key]["debit"] += entry.get("debit")
+		merged_entries[key]["credit"] += entry.get("credit")
+		merged_entries[key]["debit_in_account_currency"] += entry.get("debit_in_account_currency")
+		merged_entries[key]["credit_in_account_currency"] += entry.get("credit_in_account_currency")
+
+	return merged_entries
+
+
+def generate_key(entry, accounting_dimensions):
+	key = [
+		cstr(entry.get("account")),
+		cstr(entry.get("account_currency")),
+		cstr(entry.get("cost_center")),
+		cstr(entry.get("project")),
+		cstr(entry.get("finance_book")),
+		cint(entry.get("is_period_closing_voucher_entry")),
+	]
+
+	key_values = {
+		"company": cstr(entry.get("company")),
+		"account": cstr(entry.get("account")),
+		"account_currency": cstr(entry.get("account_currency")),
+		"cost_center": cstr(entry.get("cost_center")),
+		"project": cstr(entry.get("project")),
+		"finance_book": cstr(entry.get("finance_book")),
+		"is_period_closing_voucher_entry": cint(entry.get("is_period_closing_voucher_entry")),
+	}
+	for dimension in accounting_dimensions:
+		key.append(cstr(entry.get(dimension)))
+		key_values[dimension] = cstr(entry.get(dimension))
+
+	return tuple(key), key_values
+
+
+def get_previous_closing_entries(company, closing_date, accounting_dimensions):
+	entries = []
+	last_period_closing_voucher = frappe.db.get_all(
+		"Period Closing Voucher",
+		filters={"docstatus": 1, "company": company, "posting_date": ("<", closing_date)},
+		fields=["name"],
+		order_by="posting_date desc",
+		limit=1,
+	)
+
+	if last_period_closing_voucher:
+		account_closing_balance = frappe.qb.DocType("Account Closing Balance")
+		query = frappe.qb.from_(account_closing_balance).select(
+			account_closing_balance.company,
+			account_closing_balance.account,
+			account_closing_balance.account_currency,
+			account_closing_balance.debit,
+			account_closing_balance.credit,
+			account_closing_balance.debit_in_account_currency,
+			account_closing_balance.credit_in_account_currency,
+			account_closing_balance.cost_center,
+			account_closing_balance.project,
+			account_closing_balance.finance_book,
+			account_closing_balance.is_period_closing_voucher_entry,
+		)
+
+		for dimension in accounting_dimensions:
+			query = query.select(account_closing_balance[dimension])
+
+		query = query.where(
+			account_closing_balance.period_closing_voucher == last_period_closing_voucher[0].name
+		)
+		entries = query.run(as_dict=1)
+
+	return entries

erpnext/accounts/doctype/account_closing_balance/test_account_closing_balance.py

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

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -50,13 +50,15 @@ class AccountingDimension(Document):
 		if frappe.flags.in_test:
 			make_dimension_in_accounting_doctypes(doc=self)
 		else:
-			frappe.enqueue(make_dimension_in_accounting_doctypes, doc=self, queue="long")
+			frappe.enqueue(
+				make_dimension_in_accounting_doctypes, doc=self, queue="long", enqueue_after_commit=True
+			)
 
 	def on_trash(self):
 		if frappe.flags.in_test:
 			delete_accounting_dimension(doc=self)
 		else:
-			frappe.enqueue(delete_accounting_dimension, doc=self, queue="long")
+			frappe.enqueue(delete_accounting_dimension, doc=self, queue="long", enqueue_after_commit=True)
 
 	def set_fieldname_and_label(self):
 		if not self.label:
@@ -269,6 +271,12 @@ def get_dimensions(with_cost_center_and_project=False):
 		as_dict=1,
 	)
 
+	if isinstance(with_cost_center_and_project, str):
+		if with_cost_center_and_project.lower().strip() == "true":
+			with_cost_center_and_project = True
+		else:
+			with_cost_center_and_project = False
+
 	if with_cost_center_and_project:
 		dimension_filters.extend(
 			[

erpnext/accounts/doctype/accounting_period/accounting_period.js

@@ -20,5 +20,11 @@ frappe.ui.form.on('Accounting Period', {
 				}
 			});
 		}
+
+		frm.set_query("document_type", "closed_documents", () => {
+			return {
+				query: "erpnext.controllers.queries.get_doctypes_for_closing",
+			}
+		});
 	}
 });

erpnext/accounts/doctype/accounting_period/accounting_period.py

@@ -11,6 +11,10 @@ class OverlapError(frappe.ValidationError):
 	pass
 
 
+class ClosedAccountingPeriod(frappe.ValidationError):
+	pass
+
+
 class AccountingPeriod(Document):
 	def validate(self):
 		self.validate_overlap()
@@ -65,3 +69,42 @@ class AccountingPeriod(Document):
 					"closed_documents",
 					{"document_type": doctype_for_closing.document_type, "closed": doctype_for_closing.closed},
 				)
+
+
+def validate_accounting_period_on_doc_save(doc, method=None):
+	if doc.doctype == "Bank Clearance":
+		return
+	elif doc.doctype == "Asset":
+		if doc.is_existing_asset:
+			return
+		else:
+			date = doc.available_for_use_date
+	elif doc.doctype == "Asset Repair":
+		date = doc.completion_date
+	else:
+		date = doc.posting_date
+
+	ap = frappe.qb.DocType("Accounting Period")
+	cd = frappe.qb.DocType("Closed Document")
+
+	accounting_period = (
+		frappe.qb.from_(ap)
+		.from_(cd)
+		.select(ap.name)
+		.where(
+			(ap.name == cd.parent)
+			& (ap.company == doc.company)
+			& (cd.closed == 1)
+			& (cd.document_type == doc.doctype)
+			& (date >= ap.start_date)
+			& (date <= ap.end_date)
+		)
+	).run(as_dict=1)
+
+	if accounting_period:
+		frappe.throw(
+			_("You cannot create a {0} within the closed Accounting Period {1}").format(
+				doc.doctype, frappe.bold(accounting_period[0]["name"])
+			),
+			ClosedAccountingPeriod,
+		)

erpnext/accounts/doctype/accounting_period/test_accounting_period.py

@@ -6,9 +6,11 @@ import unittest
 import frappe
 from frappe.utils import add_months, nowdate
 
-from erpnext.accounts.doctype.accounting_period.accounting_period import OverlapError
+from erpnext.accounts.doctype.accounting_period.accounting_period import (
+	ClosedAccountingPeriod,
+	OverlapError,
+)
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-from erpnext.accounts.general_ledger import ClosedAccountingPeriod
 
 test_dependencies = ["Item"]
 
@@ -33,9 +35,9 @@ class TestAccountingPeriod(unittest.TestCase):
 		ap1.save()
 
 		doc = create_sales_invoice(
-			do_not_submit=1, cost_center="_Test Company - _TC", warehouse="Stores - _TC"
+			do_not_save=1, cost_center="_Test Company - _TC", warehouse="Stores - _TC"
 		)
-		self.assertRaises(ClosedAccountingPeriod, doc.submit)
+		self.assertRaises(ClosedAccountingPeriod, doc.save)
 
 	def tearDown(self):
 		for d in frappe.get_all("Accounting Period"):

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -19,6 +19,8 @@
   "column_break_17",
   "enable_common_party_accounting",
   "allow_multi_currency_invoices_against_single_party_account",
+  "journals_section",
+  "merge_similar_account_heads",
   "report_setting_section",
   "use_custom_cash_flow",
   "deferred_accounting_settings_section",
@@ -34,10 +36,13 @@
   "book_tax_discount_loss",
   "print_settings",
   "show_inclusive_tax_in_print",
+  "show_taxes_as_table_in_print",
   "column_break_12",
   "show_payment_schedule_in_print",
   "currency_exchange_section",
   "allow_stale",
+  "section_break_jpd0",
+  "auto_reconcile_payments",
   "stale_days",
   "invoicing_settings_tab",
   "accounts_transactions_settings_section",
@@ -57,7 +62,10 @@
   "acc_frozen_upto",
   "column_break_25",
   "frozen_accounts_modifier",
-  "report_settings_sb"
+  "report_settings_sb",
+  "banking_tab",
+  "enable_party_matching",
+  "enable_fuzzy_matching"
  ],
  "fields": [
   {
@@ -168,11 +176,6 @@
    "fieldtype": "Int",
    "label": "Stale Days"
   },
-  {
-   "fieldname": "report_settings_sb",
-   "fieldtype": "Section Break",
-   "label": "Report Settings"
-  },
   {
    "default": "0",
    "description": "Only select this if you have set up the Cash Flow Mapper documents",
@@ -356,6 +359,55 @@
    "fieldname": "book_tax_discount_loss",
    "fieldtype": "Check",
    "label": "Book Tax Loss on Early Payment Discount"
+  },
+  {
+   "fieldname": "journals_section",
+   "fieldtype": "Section Break",
+   "label": "Journals"
+  },
+  {
+   "default": "0",
+   "description": "Rows with Same Account heads will be merged on Ledger",
+   "fieldname": "merge_similar_account_heads",
+   "fieldtype": "Check",
+   "label": "Merge Similar Account Heads"
+  },
+  {
+   "fieldname": "section_break_jpd0",
+   "fieldtype": "Section Break",
+   "label": "Payment Reconciliations"
+  },
+  {
+   "default": "0",
+   "fieldname": "auto_reconcile_payments",
+   "fieldtype": "Check",
+   "label": "Auto Reconcile Payments"
+  },
+  {
+   "default": "0",
+   "fieldname": "show_taxes_as_table_in_print",
+   "fieldtype": "Check",
+   "label": "Show Taxes as Table in Print"
+  },
+  {
+   "fieldname": "banking_tab",
+   "fieldtype": "Tab Break",
+   "label": "Banking"
+  },
+  {
+   "default": "0",
+   "description": "Auto match and set the Party in Bank Transactions",
+   "fieldname": "enable_party_matching",
+   "fieldtype": "Check",
+   "label": "Enable Automatic Party Matching"
+  },
+  {
+   "default": "0",
+   "depends_on": "enable_party_matching",
+   "description": "Approximately match the description/party name against parties",
+   "fieldname": "enable_fuzzy_matching",
+   "fieldtype": "Check",
+   "label": "Enable Fuzzy Matching"
   }
  ],
  "icon": "icon-cog",
@@ -363,7 +415,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-04-14 17:22:03.680886",
+ "modified": "2023-06-15 18:47:46.430291",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",
@@ -392,4 +444,4 @@
  "sort_order": "ASC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -56,7 +56,7 @@ class BankClearance(Document):
 			select
 				"Payment Entry" as payment_document, name as payment_entry,
 				reference_no as cheque_number, reference_date as cheque_date,
-				if(paid_from=%(account)s, paid_amount, 0) as credit,
+				if(paid_from=%(account)s, paid_amount + total_taxes_and_charges, 0) as credit,
 				if(paid_from=%(account)s, 0, received_amount) as debit,
 				posting_date, ifnull(party,if(paid_from=%(account)s,paid_to,paid_from)) as against_account, clearance_date,
 				if(paid_to=%(account)s, paid_to_account_currency, paid_from_account_currency) as account_currency

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.js

@@ -19,7 +19,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 
 	onload: function (frm) {
 		// Set default filter dates
-		today = frappe.datetime.get_today()
+		let today = frappe.datetime.get_today()
 		frm.doc.bank_statement_from_date = frappe.datetime.add_months(today, -1);
 		frm.doc.bank_statement_to_date = today;
 		frm.trigger('bank_account');

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -10,6 +10,7 @@ from frappe.model.document import Document
 from frappe.query_builder.custom import ConstantColumn
 from frappe.utils import cint, flt
 
+from erpnext import get_default_cost_center
 from erpnext.accounts.doctype.bank_transaction.bank_transaction import get_total_allocated_amount
 from erpnext.accounts.report.bank_reconciliation_statement.bank_reconciliation_statement import (
 	get_amounts_not_reflected_in_system,
@@ -140,6 +141,9 @@ def create_journal_entry_bts(
 					second_account
 				)
 			)
+
+	company = frappe.get_value("Account", company_account, "company")
+
 	accounts = []
 	# Multi Currency?
 	accounts.append(
@@ -149,6 +153,7 @@ def create_journal_entry_bts(
 			"debit_in_account_currency": bank_transaction.withdrawal,
 			"party_type": party_type,
 			"party": party,
+			"cost_center": get_default_cost_center(company),
 		}
 	)
 
@@ -158,11 +163,10 @@ def create_journal_entry_bts(
 			"bank_account": bank_transaction.bank_account,
 			"credit_in_account_currency": bank_transaction.withdrawal,
 			"debit_in_account_currency": bank_transaction.deposit,
+			"cost_center": get_default_cost_center(company),
 		}
 	)
 
-	company = frappe.get_value("Account", company_account, "company")
-
 	journal_entry_dict = {
 		"voucher_type": entry_type,
 		"company": company,

erpnext/accounts/doctype/bank_transaction/auto_match_party.py

@@ -0,0 +1,178 @@
+from typing import Tuple, Union
+
+import frappe
+from frappe.utils import flt
+from rapidfuzz import fuzz, process
+
+
+class AutoMatchParty:
+	"""
+	Matches by Account/IBAN and then by Party Name/Description sequentially.
+	Returns when a result is obtained.
+
+	Result (if present) is of the form: (Party Type, Party,)
+	"""
+
+	def __init__(self, **kwargs) -> None:
+		self.__dict__.update(kwargs)
+
+	def get(self, key):
+		return self.__dict__.get(key, None)
+
+	def match(self) -> Union[Tuple, None]:
+		result = None
+		result = AutoMatchbyAccountIBAN(
+			bank_party_account_number=self.bank_party_account_number,
+			bank_party_iban=self.bank_party_iban,
+			deposit=self.deposit,
+		).match()
+
+		fuzzy_matching_enabled = frappe.db.get_single_value("Accounts Settings", "enable_fuzzy_matching")
+		if not result and fuzzy_matching_enabled:
+			result = AutoMatchbyPartyNameDescription(
+				bank_party_name=self.bank_party_name, description=self.description, deposit=self.deposit
+			).match()
+
+		return result
+
+
+class AutoMatchbyAccountIBAN:
+	def __init__(self, **kwargs) -> None:
+		self.__dict__.update(kwargs)
+
+	def get(self, key):
+		return self.__dict__.get(key, None)
+
+	def match(self):
+		if not (self.bank_party_account_number or self.bank_party_iban):
+			return None
+
+		result = self.match_account_in_party()
+		return result
+
+	def match_account_in_party(self) -> Union[Tuple, None]:
+		"""Check if there is a IBAN/Account No. match in Customer/Supplier/Employee"""
+		result = None
+		parties = get_parties_in_order(self.deposit)
+		or_filters = self.get_or_filters()
+
+		for party in parties:
+			party_result = frappe.db.get_all(
+				"Bank Account", or_filters=or_filters, pluck="party", limit_page_length=1
+			)
+
+			if party == "Employee" and not party_result:
+				# Search in Bank Accounts first for Employee, and then Employee record
+				if "bank_account_no" in or_filters:
+					or_filters["bank_ac_no"] = or_filters.pop("bank_account_no")
+
+				party_result = frappe.db.get_all(
+					party, or_filters=or_filters, pluck="name", limit_page_length=1
+				)
+
+			if party_result:
+				result = (
+					party,
+					party_result[0],
+				)
+				break
+
+		return result
+
+	def get_or_filters(self) -> dict:
+		or_filters = {}
+		if self.bank_party_account_number:
+			or_filters["bank_account_no"] = self.bank_party_account_number
+
+		if self.bank_party_iban:
+			or_filters["iban"] = self.bank_party_iban
+
+		return or_filters
+
+
+class AutoMatchbyPartyNameDescription:
+	def __init__(self, **kwargs) -> None:
+		self.__dict__.update(kwargs)
+
+	def get(self, key):
+		return self.__dict__.get(key, None)
+
+	def match(self) -> Union[Tuple, None]:
+		# fuzzy search by customer/supplier & employee
+		if not (self.bank_party_name or self.description):
+			return None
+
+		result = self.match_party_name_desc_in_party()
+		return result
+
+	def match_party_name_desc_in_party(self) -> Union[Tuple, None]:
+		"""Fuzzy search party name and/or description against parties in the system"""
+		result = None
+		parties = get_parties_in_order(self.deposit)
+
+		for party in parties:
+			filters = {"status": "Active"} if party == "Employee" else {"disabled": 0}
+			names = frappe.get_all(party, filters=filters, pluck=party.lower() + "_name")
+
+			for field in ["bank_party_name", "description"]:
+				if not self.get(field):
+					continue
+
+				result, skip = self.fuzzy_search_and_return_result(party, names, field)
+				if result or skip:
+					break
+
+			if result or skip:
+				# Skip If: It was hard to distinguish between close matches and so match is None
+				# OR if the right match was found
+				break
+
+		return result
+
+	def fuzzy_search_and_return_result(self, party, names, field) -> Union[Tuple, None]:
+		skip = False
+		result = process.extract(query=self.get(field), choices=names, scorer=fuzz.token_set_ratio)
+		party_name, skip = self.process_fuzzy_result(result)
+
+		if not party_name:
+			return None, skip
+
+		return (
+			party,
+			party_name,
+		), skip
+
+	def process_fuzzy_result(self, result: Union[list, None]):
+		"""
+		If there are multiple valid close matches return None as result may be faulty.
+		Return the result only if one accurate match stands out.
+
+		Returns: Result, Skip (whether or not to discontinue matching)
+		"""
+		PARTY, SCORE, CUTOFF = 0, 1, 80
+
+		if not result or not len(result):
+			return None, False
+
+		first_result = result[0]
+		if len(result) == 1:
+			return (first_result[PARTY] if first_result[SCORE] > CUTOFF else None), True
+
+		second_result = result[1]
+		if first_result[SCORE] > CUTOFF:
+			# If multiple matches with the same score, return None but discontinue matching
+			# Matches were found but were too close to distinguish between
+			if first_result[SCORE] == second_result[SCORE]:
+				return None, True
+
+			return first_result[PARTY], True
+		else:
+			return None, False
+
+
+def get_parties_in_order(deposit: float) -> list:
+	parties = ["Supplier", "Employee", "Customer"]  # most -> least likely to receive
+	if flt(deposit) > 0:
+		parties = ["Customer", "Supplier", "Employee"]  # most -> least likely to pay
+
+	return parties

erpnext/accounts/doctype/bank_transaction/bank_transaction.json

@@ -33,7 +33,11 @@
   "unallocated_amount",
   "party_section",
   "party_type",
-  "party"
+  "party",
+  "column_break_3czf",
+  "bank_party_name",
+  "bank_party_account_number",
+  "bank_party_iban"
  ],
  "fields": [
   {
@@ -63,7 +67,7 @@
    "fieldtype": "Select",
    "in_standard_filter": 1,
    "label": "Status",
-   "options": "\nPending\nSettled\nUnreconciled\nReconciled"
+   "options": "\nPending\nSettled\nUnreconciled\nReconciled\nCancelled"
   },
   {
    "fieldname": "bank_account",
@@ -202,11 +206,30 @@
    "fieldtype": "Data",
    "label": "Transaction Type",
    "length": 50
+  },
+  {
+   "fieldname": "column_break_3czf",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "bank_party_name",
+   "fieldtype": "Data",
+   "label": "Party Name/Account Holder (Bank Statement)"
+  },
+  {
+    "fieldname": "bank_party_iban",
+    "fieldtype": "Data",
+    "label": "Party IBAN (Bank Statement)"
+  },
+  {
+   "fieldname": "bank_party_account_number",
+   "fieldtype": "Data",
+   "label": "Party Account No. (Bank Statement)"
   }
  ],
  "is_submittable": 1,
  "links": [],
- "modified": "2022-05-29 18:36:50.475964",
+ "modified": "2023-06-06 13:58:12.821411",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Transaction",
@@ -260,4 +283,4 @@
  "states": [],
  "title_field": "bank_account",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -15,6 +15,9 @@ class BankTransaction(StatusUpdater):
 		self.clear_linked_payment_entries()
 		self.set_status()
 
+		if frappe.db.get_single_value("Accounts Settings", "enable_party_matching"):
+			self.auto_set_party()
+
 	_saving_flag = False
 
 	# nosemgrep: frappe-semgrep-rules.rules.frappe-modifying-but-not-comitting
@@ -46,7 +49,7 @@ class BankTransaction(StatusUpdater):
 	def add_payment_entries(self, vouchers):
 		"Add the vouchers with zero allocation. Save() will perform the allocations and clearance"
 		if 0.0 >= self.unallocated_amount:
-			frappe.throw(frappe._(f"Bank Transaction {self.name} is already fully reconciled"))
+			frappe.throw(frappe._("Bank Transaction {0} is already fully reconciled").format(self.name))
 
 		added = False
 		for voucher in vouchers:
@@ -114,9 +117,7 @@ class BankTransaction(StatusUpdater):
 
 				elif 0.0 > unallocated_amount:
 					self.db_delete_payment_entry(payment_entry)
-					frappe.throw(
-						frappe._(f"Voucher {payment_entry.payment_entry} is over-allocated by {unallocated_amount}")
-					)
+					frappe.throw(frappe._("Voucher {0} is over-allocated by {1}").format(unallocated_amount))
 
 		self.reload()
 
@@ -148,6 +149,26 @@ class BankTransaction(StatusUpdater):
 			payment_entry.payment_document, payment_entry.payment_entry, clearance_date, self
 		)
 
+	def auto_set_party(self):
+		from erpnext.accounts.doctype.bank_transaction.auto_match_party import AutoMatchParty
+
+		if self.party_type and self.party:
+			return
+
+		result = AutoMatchParty(
+			bank_party_account_number=self.bank_party_account_number,
+			bank_party_iban=self.bank_party_iban,
+			bank_party_name=self.bank_party_name,
+			description=self.description,
+			deposit=self.deposit,
+		).match()
+
+		if result:
+			party_type, party = result
+			frappe.db.set_value(
+				"Bank Transaction", self.name, field={"party_type": party_type, "party": party}
+			)
+
 
 @frappe.whitelist()
 def get_doctypes_for_bank_reconciliation():
@@ -178,7 +199,9 @@ def get_clearance_details(transaction, payment_entry):
 		if gle["gl_account"] == gl_bank_account:
 			if gle["amount"] <= 0.0:
 				frappe.throw(
-					frappe._(f"Voucher {payment_entry.payment_entry} value is broken: {gle['amount']}")
+					frappe._("Voucher {0} value is broken: {1}").format(
+						payment_entry.payment_entry, gle["amount"]
+					)
 				)
 
 			unmatched_gles -= 1
@@ -281,10 +304,13 @@ def get_paid_amount(payment_entry, currency, gl_bank_account):
 		)
 
 	elif payment_entry.payment_document == "Journal Entry":
-		return frappe.db.get_value(
-			"Journal Entry Account",
-			{"parent": payment_entry.payment_entry, "account": gl_bank_account},
-			"sum(credit_in_account_currency)",
+		return abs(
+			frappe.db.get_value(
+				"Journal Entry Account",
+				{"parent": payment_entry.payment_entry, "account": gl_bank_account},
+				"sum(debit_in_account_currency-credit_in_account_currency)",
+			)
+			or 0
 		)
 
 	elif payment_entry.payment_document == "Expense Claim":

erpnext/accounts/doctype/bank_transaction/test_auto_match_party.py

@@ -0,0 +1,151 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+import frappe
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import nowdate
+
+from erpnext.accounts.doctype.bank_transaction.test_bank_transaction import create_bank_account
+
+
+class TestAutoMatchParty(FrappeTestCase):
+	@classmethod
+	def setUpClass(cls):
+		create_bank_account()
+		frappe.db.set_single_value("Accounts Settings", "enable_party_matching", 1)
+		frappe.db.set_single_value("Accounts Settings", "enable_fuzzy_matching", 1)
+		return super().setUpClass()
+
+	@classmethod
+	def tearDownClass(cls):
+		frappe.db.set_single_value("Accounts Settings", "enable_party_matching", 0)
+		frappe.db.set_single_value("Accounts Settings", "enable_fuzzy_matching", 0)
+
+	def test_match_by_account_number(self):
+		create_supplier_for_match(account_no="000000003716541159")
+		doc = create_bank_transaction(
+			withdrawal=1200,
+			transaction_id="562213b0ca1bf838dab8f2c6a39bbc3b",
+			account_no="000000003716541159",
+			iban="DE02000000003716541159",
+		)
+
+		self.assertEqual(doc.party_type, "Supplier")
+		self.assertEqual(doc.party, "John Doe & Co.")
+
+	def test_match_by_iban(self):
+		create_supplier_for_match(iban="DE02000000003716541159")
+		doc = create_bank_transaction(
+			withdrawal=1200,
+			transaction_id="c5455a224602afaa51592a9d9250600d",
+			account_no="000000003716541159",
+			iban="DE02000000003716541159",
+		)
+
+		self.assertEqual(doc.party_type, "Supplier")
+		self.assertEqual(doc.party, "John Doe & Co.")
+
+	def test_match_by_party_name(self):
+		create_supplier_for_match(supplier_name="Jackson Ella W.")
+		doc = create_bank_transaction(
+			withdrawal=1200,
+			transaction_id="1f6f661f347ff7b1ea588665f473adb1",
+			party_name="Ella Jackson",
+			iban="DE04000000003716545346",
+		)
+		self.assertEqual(doc.party_type, "Supplier")
+		self.assertEqual(doc.party, "Jackson Ella W.")
+
+	def test_match_by_description(self):
+		create_supplier_for_match(supplier_name="Microsoft")
+		doc = create_bank_transaction(
+			description="Auftraggeber: microsoft payments Buchungstext: msft ..e3006b5hdy. ref. j375979555927627/5536",
+			withdrawal=1200,
+			transaction_id="8df880a2d09c3bed3fea358ca5168c5a",
+			party_name="",
+		)
+		self.assertEqual(doc.party_type, "Supplier")
+		self.assertEqual(doc.party, "Microsoft")
+
+	def test_skip_match_if_multiple_close_results(self):
+		create_supplier_for_match(supplier_name="Adithya Medical & General Stores")
+		create_supplier_for_match(supplier_name="Adithya Medical And General Stores")
+
+		doc = create_bank_transaction(
+			description="Paracetamol Consignment, SINV-0009",
+			withdrawal=24.85,
+			transaction_id="3a1da4ee2dc5a980138d56ef3460cbd9",
+			party_name="Adithya Medical & General",
+		)
+
+		# Mapping is skipped as both Supplier names have the same match score
+		self.assertEqual(doc.party_type, None)
+		self.assertEqual(doc.party, None)
+
+
+def create_supplier_for_match(supplier_name="John Doe & Co.", iban=None, account_no=None):
+	if frappe.db.exists("Supplier", {"supplier_name": supplier_name}):
+		# Update related Bank Account details
+		if not (iban or account_no):
+			return
+
+		frappe.db.set_value(
+			dt="Bank Account",
+			dn={"party": supplier_name},
+			field={"iban": iban, "bank_account_no": account_no},
+		)
+		return
+
+	# Create Supplier and Bank Account for the same
+	supplier = frappe.new_doc("Supplier")
+	supplier.supplier_name = supplier_name
+	supplier.supplier_group = "Services"
+	supplier.supplier_type = "Company"
+	supplier.insert()
+
+	if not frappe.db.exists("Bank", "TestBank"):
+		bank = frappe.new_doc("Bank")
+		bank.bank_name = "TestBank"
+		bank.insert(ignore_if_duplicate=True)
+
+	if not frappe.db.exists("Bank Account", supplier.name + " - " + "TestBank"):
+		bank_account = frappe.new_doc("Bank Account")
+		bank_account.account_name = supplier.name
+		bank_account.bank = "TestBank"
+		bank_account.iban = iban
+		bank_account.bank_account_no = account_no
+		bank_account.party_type = "Supplier"
+		bank_account.party = supplier.name
+		bank_account.insert()
+
+
+def create_bank_transaction(
+	description=None,
+	withdrawal=0,
+	deposit=0,
+	transaction_id=None,
+	party_name=None,
+	account_no=None,
+	iban=None,
+):
+	doc = frappe.new_doc("Bank Transaction")
+	doc.update(
+		{
+			"doctype": "Bank Transaction",
+			"description": description or "1512567 BG/000002918 OPSKATTUZWXXX AT776000000098709837 Herr G",
+			"date": nowdate(),
+			"withdrawal": withdrawal,
+			"deposit": deposit,
+			"currency": "INR",
+			"bank_account": "Checking Account - Citi Bank",
+			"transaction_id": transaction_id,
+			"bank_party_name": party_name,
+			"bank_party_account_number": account_no,
+			"bank_party_iban": iban,
+		}
+	)
+	doc.insert()
+	doc.submit()
+	doc.reload()
+
+	return doc

erpnext/accounts/doctype/budget/budget.py

@@ -125,14 +125,27 @@ def validate_expense_against_budget(args, expense_amount=0):
 	if not args.account:
 		return
 
-	for budget_against in ["project", "cost_center"] + get_accounting_dimensions():
+	default_dimensions = [
+		{
+			"fieldname": "project",
+			"document_type": "Project",
+		},
+		{
+			"fieldname": "cost_center",
+			"document_type": "Cost Center",
+		},
+	]
+
+	for dimension in default_dimensions + get_accounting_dimensions(as_list=False):
+		budget_against = dimension.get("fieldname")
+
 		if (
 			args.get(budget_against)
 			and args.account
 			and frappe.db.get_value("Account", {"name": args.account, "root_type": "Expense"})
 		):
 
-			doctype = frappe.unscrub(budget_against)
+			doctype = dimension.get("document_type")
 
 			if frappe.get_cached_value("DocType", doctype, "is_tree"):
 				lft, rgt = frappe.db.get_value(doctype, args.get(budget_against), ["lft", "rgt"])

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js

@@ -35,6 +35,21 @@ frappe.ui.form.on('Exchange Rate Revaluation', {
 		}
 	},
 
+	validate_rounding_loss: function(frm) {
+		let allowance = frm.doc.rounding_loss_allowance;
+		if (!(allowance >= 0 && allowance < 1)) {
+			frappe.throw(__("Rounding Loss Allowance should be between 0 and 1"));
+		}
+	},
+
+	rounding_loss_allowance: function(frm) {
+		frm.events.validate_rounding_loss(frm);
+	},
+
+	validate: function(frm) {
+		frm.events.validate_rounding_loss(frm);
+	},
+
 	get_entries: function(frm, account) {
 		frappe.call({
 			method: "get_accounts_data",
@@ -126,7 +141,8 @@ var get_account_details = function(frm, cdt, cdn) {
 			company: frm.doc.company,
 			posting_date: frm.doc.posting_date,
 			party_type: row.party_type,
-			party: row.party
+			party: row.party,
+			rounding_loss_allowance: frm.doc.rounding_loss_allowance
 		},
 		callback: function(r){
 			$.extend(row, r.message);

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.json

@@ -8,6 +8,7 @@
  "engine": "InnoDB",
  "field_order": [
   "posting_date",
+  "rounding_loss_allowance",
   "column_break_2",
   "company",
   "section_break_4",
@@ -96,11 +97,19 @@
   {
    "fieldname": "column_break_10",
    "fieldtype": "Column Break"
+  },
+  {
+   "default": "0.05",
+   "description": "Only values between [0,1) are allowed. Like {0.00, 0.04, 0.09, ...}\nEx: If allowance is set at 0.07, accounts that have balance of 0.07 in either of the currencies will be considered as zero balance account",
+   "fieldname": "rounding_loss_allowance",
+   "fieldtype": "Float",
+   "label": "Rounding Loss Allowance",
+   "precision": "9"
   }
  ],
  "is_submittable": 1,
  "links": [],
- "modified": "2022-12-29 19:38:24.416529",
+ "modified": "2023-06-20 07:29:06.972434",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Exchange Rate Revaluation",

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -12,13 +12,19 @@ from frappe.utils import flt, get_link_to_form
 
 import erpnext
 from erpnext.accounts.doctype.journal_entry.journal_entry import get_balance_on
+from erpnext.accounts.utils import get_currency_precision
 from erpnext.setup.utils import get_exchange_rate
 
 
 class ExchangeRateRevaluation(Document):
 	def validate(self):
+		self.validate_rounding_loss_allowance()
 		self.set_total_gain_loss()
 
+	def validate_rounding_loss_allowance(self):
+		if not (self.rounding_loss_allowance >= 0 and self.rounding_loss_allowance < 1):
+			frappe.throw(_("Rounding Loss Allowance should be between 0 and 1"))
+
 	def set_total_gain_loss(self):
 		total_gain_loss = 0
 
@@ -87,11 +93,22 @@ class ExchangeRateRevaluation(Document):
 
 		return True
 
+	def fetch_and_calculate_accounts_data(self):
+		accounts = self.get_accounts_data()
+		if accounts:
+			for acc in accounts:
+				self.append("accounts", acc)
+
 	@frappe.whitelist()
 	def get_accounts_data(self):
 		self.validate_mandatory()
 		account_details = self.get_account_balance_from_gle(
-			company=self.company, posting_date=self.posting_date, account=None, party_type=None, party=None
+			company=self.company,
+			posting_date=self.posting_date,
+			account=None,
+			party_type=None,
+			party=None,
+			rounding_loss_allowance=self.rounding_loss_allowance,
 		)
 		accounts_with_new_balance = self.calculate_new_account_balance(
 			self.company, self.posting_date, account_details
@@ -103,7 +120,9 @@ class ExchangeRateRevaluation(Document):
 		return accounts_with_new_balance
 
 	@staticmethod
-	def get_account_balance_from_gle(company, posting_date, account, party_type, party):
+	def get_account_balance_from_gle(
+		company, posting_date, account, party_type, party, rounding_loss_allowance
+	):
 		account_details = []
 
 		if company and posting_date:
@@ -170,6 +189,23 @@ class ExchangeRateRevaluation(Document):
 					.run(as_dict=True)
 				)
 
+				# round off balance based on currency precision
+				# and consider debit-credit difference allowance
+				currency_precision = get_currency_precision()
+				rounding_loss_allowance = float(rounding_loss_allowance) or 0.05
+				for acc in account_details:
+					acc.balance_in_account_currency = flt(acc.balance_in_account_currency, currency_precision)
+					if abs(acc.balance_in_account_currency) <= rounding_loss_allowance:
+						acc.balance_in_account_currency = 0
+
+					acc.balance = flt(acc.balance, currency_precision)
+					if abs(acc.balance) <= rounding_loss_allowance:
+						acc.balance = 0
+
+					acc.zero_balance = (
+						True if (acc.balance == 0 or acc.balance_in_account_currency == 0) else False
+					)
+
 		return account_details
 
 	@staticmethod
@@ -222,8 +258,8 @@ class ExchangeRateRevaluation(Document):
 					new_balance_in_base_currency = 0
 					new_balance_in_account_currency = 0
 
-					current_exchange_rate = calculate_exchange_rate_using_last_gle(
-						company, d.account, d.party_type, d.party
+					current_exchange_rate = (
+						calculate_exchange_rate_using_last_gle(company, d.account, d.party_type, d.party) or 0.0
 					)
 
 					gain_loss = new_balance_in_account_currency - (
@@ -343,6 +379,24 @@ class ExchangeRateRevaluation(Document):
 						"credit": 0,
 					}
 				)
+
+				journal_entry_accounts.append(journal_account)
+
+				journal_entry_accounts.append(
+					{
+						"account": unrealized_exchange_gain_loss_account,
+						"balance": get_balance_on(unrealized_exchange_gain_loss_account),
+						"debit": 0,
+						"credit": 0,
+						"debit_in_account_currency": abs(d.gain_loss) if d.gain_loss < 0 else 0,
+						"credit_in_account_currency": abs(d.gain_loss) if d.gain_loss > 0 else 0,
+						"cost_center": erpnext.get_default_cost_center(self.company),
+						"exchange_rate": 1,
+						"reference_type": "Exchange Rate Revaluation",
+						"reference_name": self.name,
+					}
+				)
+
 			elif d.get("balance_in_base_currency") and not d.get("new_balance_in_base_currency"):
 				# Base currency has balance
 				dr_or_cr = "credit" if d.get("balance_in_base_currency") > 0 else "debit"
@@ -358,22 +412,22 @@ class ExchangeRateRevaluation(Document):
 					}
 				)
 
-			journal_entry_accounts.append(journal_account)
+				journal_entry_accounts.append(journal_account)
 
-		journal_entry_accounts.append(
-			{
-				"account": unrealized_exchange_gain_loss_account,
-				"balance": get_balance_on(unrealized_exchange_gain_loss_account),
-				"debit": abs(self.gain_loss_booked) if self.gain_loss_booked < 0 else 0,
-				"credit": abs(self.gain_loss_booked) if self.gain_loss_booked > 0 else 0,
-				"debit_in_account_currency": abs(self.gain_loss_booked) if self.gain_loss_booked < 0 else 0,
-				"credit_in_account_currency": self.gain_loss_booked if self.gain_loss_booked > 0 else 0,
-				"cost_center": erpnext.get_default_cost_center(self.company),
-				"exchange_rate": 1,
-				"reference_type": "Exchange Rate Revaluation",
-				"reference_name": self.name,
-			}
-		)
+				journal_entry_accounts.append(
+					{
+						"account": unrealized_exchange_gain_loss_account,
+						"balance": get_balance_on(unrealized_exchange_gain_loss_account),
+						"debit": abs(d.gain_loss) if d.gain_loss < 0 else 0,
+						"credit": abs(d.gain_loss) if d.gain_loss > 0 else 0,
+						"debit_in_account_currency": 0,
+						"credit_in_account_currency": 0,
+						"cost_center": erpnext.get_default_cost_center(self.company),
+						"exchange_rate": 1,
+						"reference_type": "Exchange Rate Revaluation",
+						"reference_name": self.name,
+					}
+				)
 
 		journal_entry.set("accounts", journal_entry_accounts)
 		journal_entry.set_total_debit_credit()
@@ -521,7 +575,9 @@ def calculate_exchange_rate_using_last_gle(company, account, party_type, party):
 
 
 @frappe.whitelist()
-def get_account_details(company, posting_date, account, party_type=None, party=None):
+def get_account_details(
+	company, posting_date, account, party_type=None, party=None, rounding_loss_allowance: float = None
+):
 	if not (company and posting_date):
 		frappe.throw(_("Company and Posting Date is mandatory"))
 
@@ -539,7 +595,12 @@ def get_account_details(company, posting_date, account, party_type=None, party=N
 		"account_currency": account_currency,
 	}
 	account_balance = ExchangeRateRevaluation.get_account_balance_from_gle(
-		company=company, posting_date=posting_date, account=account, party_type=party_type, party=party
+		company=company,
+		posting_date=posting_date,
+		account=account,
+		party_type=party_type,
+		party=party,
+		rounding_loss_allowance=rounding_loss_allowance,
 	)
 
 	if account_balance and (

erpnext/accounts/doctype/exchange_rate_revaluation_account/exchange_rate_revaluation_account.json

@@ -73,6 +73,7 @@
    "fieldname": "current_exchange_rate",
    "fieldtype": "Float",
    "label": "Current Exchange Rate",
+   "precision": "9",
    "read_only": 1
   },
   {
@@ -92,6 +93,7 @@
    "fieldtype": "Float",
    "in_list_view": 1,
    "label": "New Exchange Rate",
+   "precision": "9",
    "reqd": 1
   },
   {
@@ -147,7 +149,7 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2022-12-29 19:38:52.915295",
+ "modified": "2023-06-22 12:39:56.446722",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Exchange Rate Revaluation Account",

erpnext/accounts/doctype/fiscal_year/fiscal_year.js

@@ -8,17 +8,6 @@ frappe.ui.form.on('Fiscal Year', {
 				frappe.datetime.add_days(frappe.defaults.get_default("year_end_date"), 1));
 		}
 	},
-	refresh: function (frm) {
-		if (!frm.doc.__islocal && (frm.doc.name != frappe.sys_defaults.fiscal_year)) {
-			frm.add_custom_button(__("Set as Default"), () => frm.events.set_as_default(frm));
-			frm.set_intro(__("To set this Fiscal Year as Default, click on 'Set as Default'"));
-		} else {
-			frm.set_intro("");
-		}
-	},
-	set_as_default: function(frm) {
-		return frm.call('set_as_default');
-	},
 	year_start_date: function(frm) {
 		if (!frm.doc.is_short_year) {
 			let year_end_date =

erpnext/accounts/doctype/fiscal_year/fiscal_year.py

@@ -4,7 +4,7 @@
 
 import frappe
 from dateutil.relativedelta import relativedelta
-from frappe import _, msgprint
+from frappe import _
 from frappe.model.document import Document
 from frappe.utils import add_days, add_years, cstr, getdate
 
@@ -14,22 +14,6 @@ class FiscalYearIncorrectDate(frappe.ValidationError):
 
 
 class FiscalYear(Document):
-	@frappe.whitelist()
-	def set_as_default(self):
-		frappe.db.set_value("Global Defaults", None, "current_fiscal_year", self.name)
-		global_defaults = frappe.get_doc("Global Defaults")
-		global_defaults.check_permission("write")
-		global_defaults.on_update()
-
-		# clear cache
-		frappe.clear_cache()
-
-		msgprint(
-			_(
-				"{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect."
-			).format(self.name)
-		)
-
 	def validate(self):
 		self.validate_dates()
 		self.validate_overlap()
@@ -77,13 +61,6 @@ class FiscalYear(Document):
 		frappe.cache().delete_value("fiscal_years")
 
 	def on_trash(self):
-		global_defaults = frappe.get_doc("Global Defaults")
-		if global_defaults.current_fiscal_year == self.name:
-			frappe.throw(
-				_(
-					"You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings"
-				).format(self.name)
-			)
 		frappe.cache().delete_value("fiscal_years")
 
 	def validate_overlap(self):

erpnext/accounts/doctype/journal_entry/journal_entry.js

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

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -69,6 +69,7 @@ class JournalEntry(AccountsController):
 		self.validate_empty_accounts_table()
 		self.set_account_and_party_balance()
 		self.validate_inter_company_accounts()
+		self.validate_depr_entry_voucher_type()
 
 		if self.docstatus == 0:
 			self.apply_tax_withholding()
@@ -130,6 +131,13 @@ class JournalEntry(AccountsController):
 				if self.total_credit != doc.total_debit or self.total_debit != doc.total_credit:
 					frappe.throw(_("Total Credit/ Debit Amount should be same as linked Journal Entry"))
 
+	def validate_depr_entry_voucher_type(self):
+		if (
+			any(d.account_type == "Depreciation" for d in self.get("accounts"))
+			and self.voucher_type != "Depreciation Entry"
+		):
+			frappe.throw(_("Journal Entry type should be set as Depreciation Entry for asset depreciation"))
+
 	def validate_stock_accounts(self):
 		stock_accounts = get_stock_accounts(self.company, self.doctype, self.name)
 		for account in stock_accounts:
@@ -233,25 +241,30 @@ class JournalEntry(AccountsController):
 			self.remove(d)
 
 	def update_asset_value(self):
-		if self.voucher_type != "Depreciation Entry":
+		if self.flags.planned_depr_entry or self.voucher_type != "Depreciation Entry":
 			return
 
-		processed_assets = []
-
 		for d in self.get("accounts"):
 			if (
-				d.reference_type == "Asset" and d.reference_name and d.reference_name not in processed_assets
+				d.reference_type == "Asset"
+				and d.reference_name
+				and d.account_type == "Depreciation"
+				and d.debit
 			):
-				processed_assets.append(d.reference_name)
-
 				asset = frappe.get_doc("Asset", d.reference_name)
 
 				if asset.calculate_depreciation:
-					continue
-
-				depr_value = d.debit or d.credit
-
-				asset.db_set("value_after_depreciation", asset.value_after_depreciation - depr_value)
+					fb_idx = 1
+					if self.finance_book:
+						for fb_row in asset.get("finance_books"):
+							if fb_row.finance_book == self.finance_book:
+								fb_idx = fb_row.idx
+								break
+					fb_row = asset.get("finance_books")[fb_idx - 1]
+					fb_row.value_after_depreciation -= d.debit
+					fb_row.db_update()
+				else:
+					asset.db_set("value_after_depreciation", asset.value_after_depreciation - d.debit)
 
 				asset.set_status()
 
@@ -313,38 +326,45 @@ class JournalEntry(AccountsController):
 				d.db_update()
 
 	def unlink_asset_reference(self):
-		if self.voucher_type != "Depreciation Entry":
-			return
-
-		processed_assets = []
-
 		for d in self.get("accounts"):
 			if (
-				d.reference_type == "Asset" and d.reference_name and d.reference_name not in processed_assets
+				self.voucher_type == "Depreciation Entry"
+				and d.reference_type == "Asset"
+				and d.reference_name
+				and d.account_type == "Depreciation"
+				and d.debit
 			):
-				processed_assets.append(d.reference_name)
-
 				asset = frappe.get_doc("Asset", d.reference_name)
 
 				if asset.calculate_depreciation:
+					fb_idx = None
 					for s in asset.get("schedules"):
 						if s.journal_entry == self.name:
 							s.db_set("journal_entry", None)
-
-							idx = cint(s.finance_book_id) or 1
-							finance_books = asset.get("finance_books")[idx - 1]
-							finance_books.value_after_depreciation += s.depreciation_amount
-							finance_books.db_update()
-
-							asset.set_status()
-
+							fb_idx = cint(s.finance_book_id) or 1
 							break
+					if not fb_idx:
+						fb_idx = 1
+						if self.finance_book:
+							for fb_row in asset.get("finance_books"):
+								if fb_row.finance_book == self.finance_book:
+									fb_idx = fb_row.idx
+									break
+					fb_row = asset.get("finance_books")[fb_idx - 1]
+					fb_row.value_after_depreciation += d.debit
+					fb_row.db_update()
 				else:
-					depr_value = d.debit or d.credit
+					asset.db_set("value_after_depreciation", asset.value_after_depreciation + d.debit)
+				asset.set_status()
+			elif self.voucher_type == "Journal Entry" and d.reference_type == "Asset" and d.reference_name:
+				journal_entry_for_scrap = frappe.db.get_value(
+					"Asset", d.reference_name, "journal_entry_for_scrap"
+				)
 
-					asset.db_set("value_after_depreciation", asset.value_after_depreciation + depr_value)
-
-					asset.set_status()
+				if journal_entry_for_scrap == self.name:
+					frappe.throw(
+						_("Journal Entry for Asset scrapping cannot be cancelled. Please restore the Asset.")
+					)
 
 	def unlink_inter_company_jv(self):
 		if (
@@ -376,6 +396,15 @@ class JournalEntry(AccountsController):
 							d.idx, d.account
 						)
 					)
+				elif (
+					d.party_type
+					and frappe.db.get_value("Party Type", d.party_type, "account_type") != account_type
+				):
+					frappe.throw(
+						_("Row {0}: Account {1} and Party Type {2} have different account types").format(
+							d.idx, d.account, d.party_type
+						)
+					)
 
 	def check_credit_limit(self):
 		customers = list(
@@ -878,6 +907,8 @@ class JournalEntry(AccountsController):
 	def make_gl_entries(self, cancel=0, adv_adj=0):
 		from erpnext.accounts.general_ledger import make_gl_entries
 
+		merge_entries = frappe.db.get_single_value("Accounts Settings", "merge_similar_account_heads")
+
 		gl_map = self.build_gl_map()
 		if self.voucher_type in ("Deferred Revenue", "Deferred Expense"):
 			update_outstanding = "No"
@@ -885,7 +916,13 @@ class JournalEntry(AccountsController):
 			update_outstanding = "Yes"
 
 		if gl_map:
-			make_gl_entries(gl_map, cancel=cancel, adv_adj=adv_adj, update_outstanding=update_outstanding)
+			make_gl_entries(
+				gl_map,
+				cancel=cancel,
+				adv_adj=adv_adj,
+				merge_entries=merge_entries,
+				update_outstanding=update_outstanding,
+			)
 
 	@frappe.whitelist()
 	def get_balance(self, difference_account=None):
@@ -919,6 +956,7 @@ class JournalEntry(AccountsController):
 					blank_row.debit_in_account_currency = abs(diff)
 					blank_row.debit = abs(diff)
 
+			self.set_total_debit_credit()
 			self.validate_total_debit_and_credit()
 
 	@frappe.whitelist()

erpnext/accounts/doctype/journal_entry_template/journal_entry_template.js

@@ -2,6 +2,21 @@
 // For license information, please see license.txt
 
 frappe.ui.form.on("Journal Entry Template", {
+	onload: function(frm) {
+		if(frm.is_new()) {
+			frappe.call({
+				type: "GET",
+				method: "erpnext.accounts.doctype.journal_entry_template.journal_entry_template.get_naming_series",
+				callback: function(r){
+					if(r.message) {
+						frm.set_df_property("naming_series", "options", r.message.split("\n"));
+						frm.set_value("naming_series", r.message.split("\n")[0]);
+						frm.refresh_field("naming_series");
+					}
+				}
+			});
+		}
+	},
 	refresh: function(frm) {
 		frappe.model.set_default_values(frm.doc);
 
@@ -19,18 +34,6 @@ frappe.ui.form.on("Journal Entry Template", {
 
 			return { filters: filters };
 		});
-
-		frappe.call({
-			type: "GET",
-			method: "erpnext.accounts.doctype.journal_entry_template.journal_entry_template.get_naming_series",
-			callback: function(r){
-				if(r.message){
-					frm.set_df_property("naming_series", "options", r.message.split("\n"));
-					frm.set_value("naming_series", r.message.split("\n")[0]);
-					frm.refresh_field("naming_series");
-				}
-			}
-		});
 	},
 	voucher_type: function(frm) {
 		var add_accounts = function(doc, r) {

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -613,7 +613,7 @@ frappe.ui.form.on('Payment Entry', {
 			frm.events.set_unallocated_amount(frm);
 	},
 
-	get_outstanding_invoice: function(frm) {
+	get_outstanding_invoices_or_orders: function(frm, get_outstanding_invoices, get_orders_to_be_billed) {
 		const today = frappe.datetime.get_today();
 		const fields = [
 			{fieldtype:"Section Break", label: __("Posting Date")},
@@ -643,12 +643,29 @@ frappe.ui.form.on('Payment Entry', {
 			{fieldtype:"Check", label: __("Allocate Payment Amount"), fieldname:"allocate_payment_amount", default:1},
 		];
 
+		let btn_text = "";
+
+		if (get_outstanding_invoices) {
+			btn_text = "Get Outstanding Invoices";
+		}
+		else if (get_orders_to_be_billed) {
+			btn_text = "Get Outstanding Orders";
+		}
+
 		frappe.prompt(fields, function(filters){
 			frappe.flags.allocate_payment_amount = true;
 			frm.events.validate_filters_data(frm, filters);
 			frm.doc.cost_center = filters.cost_center;
-			frm.events.get_outstanding_documents(frm, filters);
-		}, __("Filters"), __("Get Outstanding Documents"));
+			frm.events.get_outstanding_documents(frm, filters, get_outstanding_invoices, get_orders_to_be_billed);
+		}, __("Filters"), __(btn_text));
+	},
+
+	get_outstanding_invoices: function(frm) {
+		frm.events.get_outstanding_invoices_or_orders(frm, true, false);
+	},
+
+	get_outstanding_orders: function(frm) {
+		frm.events.get_outstanding_invoices_or_orders(frm, false, true);
 	},
 
 	validate_filters_data: function(frm, filters) {
@@ -674,7 +691,7 @@ frappe.ui.form.on('Payment Entry', {
 		}
 	},
 
-	get_outstanding_documents: function(frm, filters) {
+	get_outstanding_documents: function(frm, filters, get_outstanding_invoices, get_orders_to_be_billed) {
 		frm.clear_table("references");
 
 		if(!frm.doc.party) {
@@ -698,6 +715,13 @@ frappe.ui.form.on('Payment Entry', {
 			args[key] = filters[key];
 		}
 
+		if (get_outstanding_invoices) {
+			args["get_outstanding_invoices"] = true;
+		}
+		else if (get_orders_to_be_billed) {
+			args["get_orders_to_be_billed"] = true;
+		}
+
 		frappe.flags.allocate_payment_amount = filters['allocate_payment_amount'];
 
 		return  frappe.call({
@@ -905,7 +929,7 @@ frappe.ui.form.on('Payment Entry', {
 			function(d) { return flt(d.amount) }));
 
 		frm.set_value("difference_amount", difference_amount - total_deductions +
-			frm.doc.base_total_taxes_and_charges);
+			flt(frm.doc.base_total_taxes_and_charges));
 
 		frm.events.hide_unhide_fields(frm);
 	},
@@ -978,6 +1002,7 @@ frappe.ui.form.on('Payment Entry', {
 							precision("difference_amount"));
 
 						const add_deductions = (details) => {
+							let row = null;
 							if (!write_off_row.length && difference_amount) {
 								row = frm.add_child("deductions");
 								row.account = details[account];

erpnext/accounts/doctype/payment_entry/payment_entry.json

@@ -48,7 +48,8 @@
   "base_received_amount",
   "base_received_amount_after_tax",
   "section_break_14",
-  "get_outstanding_invoice",
+  "get_outstanding_invoices",
+  "get_outstanding_orders",
   "references",
   "section_break_34",
   "total_allocated_amount",
@@ -355,12 +356,6 @@
    "fieldtype": "Section Break",
    "label": "Reference"
   },
-  {
-   "depends_on": "eval:doc.docstatus==0",
-   "fieldname": "get_outstanding_invoice",
-   "fieldtype": "Button",
-   "label": "Get Outstanding Invoice"
-  },
   {
    "fieldname": "references",
    "fieldtype": "Table",
@@ -728,12 +723,24 @@
    "fieldname": "section_break_60",
    "fieldtype": "Section Break",
    "hide_border": 1
+  },
+  {
+   "depends_on": "eval:doc.docstatus==0",
+   "fieldname": "get_outstanding_invoices",
+   "fieldtype": "Button",
+   "label": "Get Outstanding Invoices"
+  },
+  {
+   "depends_on": "eval:doc.docstatus==0",
+   "fieldname": "get_outstanding_orders",
+   "fieldtype": "Button",
+   "label": "Get Outstanding Orders"
   }
  ],
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-02-14 04:52:30.478523",
+ "modified": "2023-06-19 11:38:04.387219",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry",

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -8,6 +8,7 @@ from functools import reduce
 import frappe
 from frappe import ValidationError, _, qb, scrub, throw
 from frappe.utils import cint, comma_or, flt, getdate, nowdate
+from frappe.utils.data import comma_and, fmt_money
 
 import erpnext
 from erpnext.accounts.doctype.bank_account.bank_account import (
@@ -60,6 +61,7 @@ class PaymentEntry(AccountsController):
 	def validate(self):
 		self.setup_party_account_field()
 		self.set_missing_values()
+		self.set_missing_ref_details()
 		self.validate_payment_type()
 		self.validate_party_details()
 		self.set_exchange_rate()
@@ -147,19 +149,82 @@ class PaymentEntry(AccountsController):
 			)
 
 	def validate_allocated_amount(self):
+		if self.payment_type == "Internal Transfer":
+			return
+
+		if self.party_type in ("Customer", "Supplier"):
+			self.validate_allocated_amount_with_latest_data()
+		else:
+			fail_message = _("Row #{0}: Allocated Amount cannot be greater than outstanding amount.")
+			for d in self.get("references"):
+				if (flt(d.allocated_amount)) > 0 and flt(d.allocated_amount) > flt(d.outstanding_amount):
+					frappe.throw(fail_message.format(d.idx))
+
+				# Check for negative outstanding invoices as well
+				if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(d.outstanding_amount):
+					frappe.throw(fail_message.format(d.idx))
+
+	def validate_allocated_amount_with_latest_data(self):
+		latest_references = get_outstanding_reference_documents(
+			{
+				"posting_date": self.posting_date,
+				"company": self.company,
+				"party_type": self.party_type,
+				"payment_type": self.payment_type,
+				"party": self.party,
+				"party_account": self.paid_from if self.payment_type == "Receive" else self.paid_to,
+				"get_outstanding_invoices": True,
+				"get_orders_to_be_billed": True,
+			}
+		)
+
+		# Group latest_references by (voucher_type, voucher_no)
+		latest_lookup = {}
+		for d in latest_references:
+			d = frappe._dict(d)
+			latest_lookup.setdefault((d.voucher_type, d.voucher_no), frappe._dict())[d.payment_term] = d
+
 		for d in self.get("references"):
-			if (flt(d.allocated_amount)) > 0:
-				if flt(d.allocated_amount) > flt(d.outstanding_amount):
-					frappe.throw(
-						_("Row #{0}: Allocated Amount cannot be greater than outstanding amount.").format(d.idx)
+			latest = (latest_lookup.get((d.reference_doctype, d.reference_name)) or frappe._dict()).get(
+				d.payment_term
+			)
+
+			# The reference has already been fully paid
+			if not latest:
+				frappe.throw(
+					_("{0} {1} has already been fully paid.").format(_(d.reference_doctype), d.reference_name)
+				)
+			# The reference has already been partly paid
+			elif latest.outstanding_amount < latest.invoice_amount and flt(
+				d.outstanding_amount, d.precision("outstanding_amount")
+			) != flt(latest.outstanding_amount, d.precision("outstanding_amount")):
+
+				frappe.throw(
+					_(
+						"{0} {1} has already been partly paid. Please use the 'Get Outstanding Invoice' or the 'Get Outstanding Orders' button to get the latest outstanding amounts."
+					).format(_(d.reference_doctype), d.reference_name)
+				)
+
+			fail_message = _("Row #{0}: Allocated Amount cannot be greater than outstanding amount.")
+
+			if (flt(d.allocated_amount)) > 0 and flt(d.allocated_amount) > flt(latest.outstanding_amount):
+				frappe.throw(fail_message.format(d.idx))
+
+			if d.payment_term and (
+				(flt(d.allocated_amount)) > 0
+				and flt(d.allocated_amount) > flt(latest.payment_term_outstanding)
+			):
+				frappe.throw(
+					_(
+						"Row #{0}: Allocated amount:{1} is greater than outstanding amount:{2} for Payment Term {3}"
+					).format(
+						d.idx, d.allocated_amount, latest.payment_term_outstanding, d.payment_term
 					)
+				)
 
 			# Check for negative outstanding invoices as well
-			if flt(d.allocated_amount) < 0:
-				if flt(d.allocated_amount) < flt(d.outstanding_amount):
-					frappe.throw(
-						_("Row #{0}: Allocated Amount cannot be greater than outstanding amount.").format(d.idx)
-					)
+			if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(latest.outstanding_amount):
+				frappe.throw(fail_message.format(d.idx))
 
 	def delink_advance_entry_references(self):
 		for reference in self.references:
@@ -219,11 +284,16 @@ class PaymentEntry(AccountsController):
 			else self.paid_to_account_currency
 		)
 
-		self.set_missing_ref_details()
-
-	def set_missing_ref_details(self, force=False):
+	def set_missing_ref_details(
+		self, force: bool = False, update_ref_details_only_for: list | None = None
+	) -> None:
 		for d in self.get("references"):
 			if d.allocated_amount:
+				if update_ref_details_only_for and (
+					not (d.reference_doctype, d.reference_name) in update_ref_details_only_for
+				):
+					continue
+
 				ref_details = get_reference_details(
 					d.reference_doctype, d.reference_name, self.party_account_currency
 				)
@@ -246,7 +316,7 @@ class PaymentEntry(AccountsController):
 	def validate_party_details(self):
 		if self.party:
 			if not frappe.db.exists(self.party_type, self.party):
-				frappe.throw(_("Invalid {0}: {1}").format(self.party_type, self.party))
+				frappe.throw(_("{0} {1} does not exist").format(_(self.party_type), self.party))
 
 	def set_exchange_rate(self, ref_doc=None):
 		self.set_source_exchange_rate(ref_doc)
@@ -295,7 +365,9 @@ class PaymentEntry(AccountsController):
 				continue
 			if d.reference_doctype not in valid_reference_doctypes:
 				frappe.throw(
-					_("Reference Doctype must be one of {0}").format(comma_or(valid_reference_doctypes))
+					_("Reference Doctype must be one of {0}").format(
+						comma_or((_(d) for d in valid_reference_doctypes))
+					)
 				)
 
 			elif d.reference_name:
@@ -308,7 +380,7 @@ class PaymentEntry(AccountsController):
 						if self.party != ref_doc.get(scrub(self.party_type)):
 							frappe.throw(
 								_("{0} {1} is not associated with {2} {3}").format(
-									d.reference_doctype, d.reference_name, self.party_type, self.party
+									_(d.reference_doctype), d.reference_name, _(self.party_type), self.party
 								)
 							)
 					else:
@@ -327,18 +399,18 @@ class PaymentEntry(AccountsController):
 						if ref_party_account != self.party_account:
 							frappe.throw(
 								_("{0} {1} is associated with {2}, but Party Account is {3}").format(
-									d.reference_doctype, d.reference_name, ref_party_account, self.party_account
+									_(d.reference_doctype), d.reference_name, ref_party_account, self.party_account
 								)
 							)
 
 						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"),
+								_("{0} {1} is on hold").format(_(d.reference_doctype), d.reference_name),
+								title=_("Invalid Purchase Invoice"),
 							)
 
 					if ref_doc.docstatus != 1:
-						frappe.throw(_("{0} {1} must be submitted").format(d.reference_doctype, d.reference_name))
+						frappe.throw(_("{0} {1} must be submitted").format(_(d.reference_doctype), d.reference_name))
 
 	def get_valid_reference_doctypes(self):
 		if self.party_type == "Customer":
@@ -364,14 +436,13 @@ class PaymentEntry(AccountsController):
 				if outstanding_amount <= 0 and not is_return:
 					no_oustanding_refs.setdefault(d.reference_doctype, []).append(d)
 
-		for k, v in no_oustanding_refs.items():
+		for reference_doctype, references in no_oustanding_refs.items():
 			frappe.msgprint(
 				_(
-					"{} - {} now have {} as they had no outstanding amount left before submitting the Payment Entry."
+					"References {0} of type {1} had no outstanding amount left before submitting the Payment Entry. Now they have a negative outstanding amount."
 				).format(
-					_(k),
-					frappe.bold(", ".join(d.reference_name for d in v)),
-					frappe.bold(_("negative outstanding amount")),
+					frappe.bold(comma_and((d.reference_name for d in references))),
+					_(reference_doctype),
 				)
 				+ "<br><br>"
 				+ _("If this is undesirable please cancel the corresponding Payment Entry."),
@@ -406,7 +477,7 @@ class PaymentEntry(AccountsController):
 					if not valid:
 						frappe.throw(
 							_("Against Journal Entry {0} does not have any unmatched {1} entry").format(
-								d.reference_name, dr_or_cr
+								d.reference_name, _(dr_or_cr)
 							)
 						)
 
@@ -473,7 +544,7 @@ class PaymentEntry(AccountsController):
 				if allocated_amount > outstanding:
 					frappe.throw(
 						_("Row #{0}: Cannot allocate more than {1} against payment term {2}").format(
-							idx, outstanding, key[0]
+							idx, fmt_money(outstanding), key[0]
 						)
 					)
 
@@ -648,6 +719,28 @@ class PaymentEntry(AccountsController):
 				self.precision("base_received_amount"),
 			)
 
+	def calculate_base_allocated_amount_for_reference(self, d) -> float:
+		base_allocated_amount = 0
+		if d.reference_doctype in frappe.get_hooks("advance_payment_doctypes"):
+			# When referencing Sales/Purchase Order, use the source/target exchange rate depending on payment type.
+			# This is so there are no Exchange Gain/Loss generated for such doctypes
+
+			exchange_rate = 1
+			if self.payment_type == "Receive":
+				exchange_rate = self.source_exchange_rate
+			elif self.payment_type == "Pay":
+				exchange_rate = self.target_exchange_rate
+
+			base_allocated_amount += flt(
+				flt(d.allocated_amount) * flt(exchange_rate), self.precision("base_paid_amount")
+			)
+		else:
+			base_allocated_amount += flt(
+				flt(d.allocated_amount) * flt(d.exchange_rate), self.precision("base_paid_amount")
+			)
+
+		return base_allocated_amount
+
 	def set_total_allocated_amount(self):
 		if self.payment_type == "Internal Transfer":
 			return
@@ -656,9 +749,7 @@ class PaymentEntry(AccountsController):
 		for d in self.get("references"):
 			if d.allocated_amount:
 				total_allocated_amount += flt(d.allocated_amount)
-				base_total_allocated_amount += flt(
-					flt(d.allocated_amount) * flt(d.exchange_rate), self.precision("base_paid_amount")
-				)
+				base_total_allocated_amount += self.calculate_base_allocated_amount_for_reference(d)
 
 		self.total_allocated_amount = abs(total_allocated_amount)
 		self.base_total_allocated_amount = abs(base_total_allocated_amount)
@@ -757,7 +848,7 @@ class PaymentEntry(AccountsController):
 		elif paid_amount - additional_charges > total_negative_outstanding:
 			frappe.throw(
 				_("Paid Amount cannot be greater than total negative outstanding amount {0}").format(
-					total_negative_outstanding
+					fmt_money(total_negative_outstanding)
 				),
 				InvalidPaymentEntry,
 			)
@@ -875,9 +966,7 @@ class PaymentEntry(AccountsController):
 					}
 				)
 
-				allocated_amount_in_company_currency = flt(
-					flt(d.allocated_amount) * flt(d.exchange_rate), self.precision("paid_amount")
-				)
+				allocated_amount_in_company_currency = self.calculate_base_allocated_amount_for_reference(d)
 
 				gle.update(
 					{
@@ -1235,6 +1324,9 @@ def get_outstanding_reference_documents(args):
 	if args.get("party_type") == "Member":
 		return
 
+	if not args.get("get_outstanding_invoices") and not args.get("get_orders_to_be_billed"):
+		args["get_outstanding_invoices"] = True
+
 	ple = qb.DocType("Payment Ledger Entry")
 	common_filter = []
 	accounting_dimensions_filter = []
@@ -1285,69 +1377,103 @@ def get_outstanding_reference_documents(args):
 		condition += " and company = {0}".format(frappe.db.escape(args.get("company")))
 		common_filter.append(ple.company == args.get("company"))
 
-	outstanding_invoices = get_outstanding_invoices(
-		args.get("party_type"),
-		args.get("party"),
-		args.get("party_account"),
-		common_filter=common_filter,
-		posting_date=posting_and_due_date,
-		min_outstanding=args.get("outstanding_amt_greater_than"),
-		max_outstanding=args.get("outstanding_amt_less_than"),
-		accounting_dimensions=accounting_dimensions_filter,
-	)
-
-	outstanding_invoices = split_invoices_based_on_payment_terms(outstanding_invoices)
-
-	for d in outstanding_invoices:
-		d["exchange_rate"] = 1
-		if party_account_currency != company_currency:
-			if d.voucher_type in frappe.get_hooks("invoice_doctypes"):
-				d["exchange_rate"] = frappe.db.get_value(d.voucher_type, d.voucher_no, "conversion_rate")
-			elif d.voucher_type == "Journal Entry":
-				d["exchange_rate"] = get_exchange_rate(
-					party_account_currency, company_currency, d.posting_date
-				)
-		if d.voucher_type in ("Purchase Invoice"):
-			d["bill_no"] = frappe.db.get_value(d.voucher_type, d.voucher_no, "bill_no")
-
-	# Get all SO / PO which are not fully billed or against which full advance not paid
-	orders_to_be_billed = []
-	orders_to_be_billed = get_orders_to_be_billed(
-		args.get("posting_date"),
-		args.get("party_type"),
-		args.get("party"),
-		args.get("company"),
-		party_account_currency,
-		company_currency,
-		filters=args,
-	)
-
-	# Get negative outstanding sales /purchase invoices
+	outstanding_invoices = []
 	negative_outstanding_invoices = []
-	if args.get("party_type") != "Employee" and not args.get("voucher_no"):
-		negative_outstanding_invoices = get_negative_outstanding_invoices(
+
+	if args.get("get_outstanding_invoices"):
+		outstanding_invoices = get_outstanding_invoices(
 			args.get("party_type"),
 			args.get("party"),
 			args.get("party_account"),
+			common_filter=common_filter,
+			posting_date=posting_and_due_date,
+			min_outstanding=args.get("outstanding_amt_greater_than"),
+			max_outstanding=args.get("outstanding_amt_less_than"),
+			accounting_dimensions=accounting_dimensions_filter,
+		)
+
+		outstanding_invoices = split_invoices_based_on_payment_terms(
+			outstanding_invoices, args.get("company")
+		)
+
+		for d in outstanding_invoices:
+			d["exchange_rate"] = 1
+			if party_account_currency != company_currency:
+				if d.voucher_type in frappe.get_hooks("invoice_doctypes"):
+					d["exchange_rate"] = frappe.db.get_value(d.voucher_type, d.voucher_no, "conversion_rate")
+				elif d.voucher_type == "Journal Entry":
+					d["exchange_rate"] = get_exchange_rate(
+						party_account_currency, company_currency, d.posting_date
+					)
+			if d.voucher_type in ("Purchase Invoice"):
+				d["bill_no"] = frappe.db.get_value(d.voucher_type, d.voucher_no, "bill_no")
+
+		# Get negative outstanding sales /purchase invoices
+		if args.get("party_type") != "Employee" and not args.get("voucher_no"):
+			negative_outstanding_invoices = get_negative_outstanding_invoices(
+				args.get("party_type"),
+				args.get("party"),
+				args.get("party_account"),
+				party_account_currency,
+				company_currency,
+				condition=condition,
+			)
+
+	# Get all SO / PO which are not fully billed or against which full advance not paid
+	orders_to_be_billed = []
+	if args.get("get_orders_to_be_billed"):
+		orders_to_be_billed = get_orders_to_be_billed(
+			args.get("posting_date"),
+			args.get("party_type"),
+			args.get("party"),
+			args.get("company"),
 			party_account_currency,
 			company_currency,
-			condition=condition,
+			filters=args,
 		)
 
 	data = negative_outstanding_invoices + outstanding_invoices + orders_to_be_billed
 
 	if not data:
+		if args.get("get_outstanding_invoices") and args.get("get_orders_to_be_billed"):
+			ref_document_type = "invoices or orders"
+		elif args.get("get_outstanding_invoices"):
+			ref_document_type = "invoices"
+		elif args.get("get_orders_to_be_billed"):
+			ref_document_type = "orders"
+
 		frappe.msgprint(
 			_(
-				"No outstanding invoices found for the {0} {1} which qualify the filters you have specified."
-			).format(_(args.get("party_type")).lower(), frappe.bold(args.get("party")))
+				"No outstanding {0} found for the {1} {2} which qualify the filters you have specified."
+			).format(
+				_(ref_document_type), _(args.get("party_type")).lower(), frappe.bold(args.get("party"))
+			)
 		)
 
 	return data
 
 
-def split_invoices_based_on_payment_terms(outstanding_invoices):
+def split_invoices_based_on_payment_terms(outstanding_invoices, company):
 	invoice_ref_based_on_payment_terms = {}
+
+	company_currency = (
+		frappe.db.get_value("Company", company, "default_currency") if company else None
+	)
+	exc_rates = frappe._dict()
+	for doctype in ["Sales Invoice", "Purchase Invoice"]:
+		invoices = [x.voucher_no for x in outstanding_invoices if x.voucher_type == doctype]
+		for x in frappe.db.get_all(
+			doctype,
+			filters={"name": ["in", invoices]},
+			fields=["name", "currency", "conversion_rate", "party_account_currency"],
+		):
+			exc_rates[x.name] = frappe._dict(
+				conversion_rate=x.conversion_rate,
+				currency=x.currency,
+				party_account_currency=x.party_account_currency,
+				company_currency=company_currency,
+			)
+
 	for idx, d in enumerate(outstanding_invoices):
 		if d.voucher_type in ["Sales Invoice", "Purchase Invoice"]:
 			payment_term_template = frappe.db.get_value(
@@ -1364,6 +1490,14 @@ def split_invoices_based_on_payment_terms(outstanding_invoices):
 
 					for payment_term in payment_schedule:
 						if payment_term.outstanding > 0.1:
+							doc_details = exc_rates.get(payment_term.parent, None)
+							is_multi_currency_acc = (doc_details.currency != doc_details.company_currency) and (
+								doc_details.party_account_currency != doc_details.company_currency
+							)
+							payment_term_outstanding = flt(payment_term.outstanding)
+							if not is_multi_currency_acc:
+								payment_term_outstanding = doc_details.conversion_rate * flt(payment_term.outstanding)
+
 							invoice_ref_based_on_payment_terms.setdefault(idx, [])
 							invoice_ref_based_on_payment_terms[idx].append(
 								frappe._dict(
@@ -1375,6 +1509,7 @@ def split_invoices_based_on_payment_terms(outstanding_invoices):
 										"posting_date": d.posting_date,
 										"invoice_amount": flt(d.invoice_amount),
 										"outstanding_amount": flt(d.outstanding_amount),
+										"payment_term_outstanding": payment_term_outstanding,
 										"payment_amount": payment_term.payment_amount,
 										"payment_term": payment_term.payment_term,
 									}
@@ -1414,66 +1549,71 @@ def get_orders_to_be_billed(
 	cost_center=None,
 	filters=None,
 ):
+	voucher_type = None
 	if party_type == "Customer":
 		voucher_type = "Sales Order"
 	elif party_type == "Supplier":
 		voucher_type = "Purchase Order"
-	elif party_type == "Employee":
-		voucher_type = None
+
+	if not voucher_type:
+		return []
 
 	# Add cost center condition
-	if voucher_type:
-		doc = frappe.get_doc({"doctype": voucher_type})
-		condition = ""
-		if doc and hasattr(doc, "cost_center"):
-			condition = " and cost_center='%s'" % cost_center
+	doc = frappe.get_doc({"doctype": voucher_type})
+	condition = ""
+	if doc and hasattr(doc, "cost_center") and doc.cost_center:
+		condition = " and cost_center='%s'" % cost_center
 
-	orders = []
-	if voucher_type:
-		if party_account_currency == company_currency:
-			grand_total_field = "base_grand_total"
-			rounded_total_field = "base_rounded_total"
-		else:
-			grand_total_field = "grand_total"
-			rounded_total_field = "rounded_total"
+	if party_account_currency == company_currency:
+		grand_total_field = "base_grand_total"
+		rounded_total_field = "base_rounded_total"
+	else:
+		grand_total_field = "grand_total"
+		rounded_total_field = "rounded_total"
 
-		orders = frappe.db.sql(
-			"""
-			select
-				name as voucher_no,
-				if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) as invoice_amount,
-				(if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) - advance_paid) as outstanding_amount,
-				transaction_date as posting_date
-			from
-				`tab{voucher_type}`
-			where
-				{party_type} = %s
-				and docstatus = 1
-				and company = %s
-				and ifnull(status, "") != "Closed"
-				and if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) > advance_paid
-				and abs(100 - per_billed) > 0.01
-				{condition}
-			order by
-				transaction_date, name
-		""".format(
-				**{
-					"rounded_total_field": rounded_total_field,
-					"grand_total_field": grand_total_field,
-					"voucher_type": voucher_type,
-					"party_type": scrub(party_type),
-					"condition": condition,
-				}
-			),
-			(party, company),
-			as_dict=True,
-		)
+	orders = frappe.db.sql(
+		"""
+		select
+			name as voucher_no,
+			if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) as invoice_amount,
+			(if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) - advance_paid) as outstanding_amount,
+			transaction_date as posting_date
+		from
+			`tab{voucher_type}`
+		where
+			{party_type} = %s
+			and docstatus = 1
+			and company = %s
+			and ifnull(status, "") != "Closed"
+			and if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) > advance_paid
+			and abs(100 - per_billed) > 0.01
+			{condition}
+		order by
+			transaction_date, name
+	""".format(
+			**{
+				"rounded_total_field": rounded_total_field,
+				"grand_total_field": grand_total_field,
+				"voucher_type": voucher_type,
+				"party_type": scrub(party_type),
+				"condition": condition,
+			}
+		),
+		(party, company),
+		as_dict=True,
+	)
 
 	order_list = []
 	for d in orders:
-		if not (
-			flt(d.outstanding_amount) >= flt(filters.get("outstanding_amt_greater_than"))
-			and flt(d.outstanding_amount) <= flt(filters.get("outstanding_amt_less_than"))
+		if (
+			filters
+			and filters.get("outstanding_amt_greater_than")
+			and filters.get("outstanding_amt_less_than")
+			and not (
+				flt(filters.get("outstanding_amt_greater_than"))
+				<= flt(d.outstanding_amount)
+				<= flt(filters.get("outstanding_amt_less_than"))
+			)
 		):
 			continue
 
@@ -1494,6 +1634,8 @@ def get_negative_outstanding_invoices(
 	cost_center=None,
 	condition=None,
 ):
+	if party_type not in ["Customer", "Supplier"]:
+		return []
 	voucher_type = "Sales Invoice" if party_type == "Customer" else "Purchase Invoice"
 	supplier_condition = ""
 	if voucher_type == "Purchase Invoice":
@@ -1542,7 +1684,7 @@ def get_negative_outstanding_invoices(
 def get_party_details(company, party_type, party, date, cost_center=None):
 	bank_account = ""
 	if not frappe.db.exists(party_type, party):
-		frappe.throw(_("Invalid {0}: {1}").format(party_type, party))
+		frappe.throw(_("{0} {1} does not exist").format(_(party_type), party))
 
 	party_account = get_party_account(party_type, party, company)
 
@@ -1643,7 +1785,7 @@ def get_reference_details(reference_doctype, reference_name, party_account_curre
 		if not total_amount:
 			if party_account_currency == company_currency:
 				# for handling cases that don't have multi-currency (base field)
-				total_amount = ref_doc.get("grand_total") or ref_doc.get("base_grand_total")
+				total_amount = ref_doc.get("base_grand_total") or ref_doc.get("grand_total")
 				exchange_rate = 1
 			else:
 				total_amount = ref_doc.get("grand_total")
@@ -1687,8 +1829,11 @@ def get_payment_entry(
 ):
 	reference_doc = None
 	doc = frappe.get_doc(dt, dn)
-	if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) >= 99.99:
-		frappe.throw(_("Can only make payment against unbilled {0}").format(dt))
+	over_billing_allowance = frappe.db.get_single_value("Accounts Settings", "over_billing_allowance")
+	if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) >= (
+		100.0 + over_billing_allowance
+	):
+		frappe.throw(_("Can only make payment against unbilled {0}").format(_(dt)))
 
 	if not party_type:
 		party_type = set_party_type(dt)
@@ -1706,6 +1851,13 @@ def get_payment_entry(
 	# bank or cash
 	bank = get_bank_cash_account(doc, bank_account)
 
+	# if default bank or cash account is not set in company master and party has default company bank account, fetch it
+	if party_type in ["Customer", "Supplier"] and not bank:
+		party_bank_account = get_party_bank_account(party_type, doc.get(scrub(party_type)))
+		if party_bank_account:
+			account = frappe.db.get_value("Bank Account", party_bank_account, "account")
+			bank = get_bank_cash_account(doc, account)
+
 	paid_amount, received_amount = set_paid_amount_and_received_amount(
 		dt, party_account_currency, bank, outstanding_amount, payment_type, bank_amount, doc
 	)
@@ -1811,6 +1963,7 @@ def get_payment_entry(
 
 	pe.setup_party_account_field()
 	pe.set_missing_values()
+	pe.set_missing_ref_details()
 
 	update_accounting_dimensions(pe, doc)
 
@@ -1921,19 +2074,27 @@ def set_paid_amount_and_received_amount(
 	paid_amount = received_amount = 0
 	if party_account_currency == bank.account_currency:
 		paid_amount = received_amount = abs(outstanding_amount)
-	elif payment_type == "Receive":
-		paid_amount = abs(outstanding_amount)
-		if bank_amount:
-			received_amount = bank_amount
-		else:
-			received_amount = paid_amount * doc.get("conversion_rate", 1)
 	else:
-		received_amount = abs(outstanding_amount)
-		if bank_amount:
-			paid_amount = bank_amount
+		company_currency = frappe.get_cached_value("Company", doc.get("company"), "default_currency")
+		if payment_type == "Receive":
+			paid_amount = abs(outstanding_amount)
+			if bank_amount:
+				received_amount = bank_amount
+			else:
+				if company_currency != bank.account_currency:
+					received_amount = paid_amount / doc.get("conversion_rate", 1)
+				else:
+					received_amount = paid_amount * doc.get("conversion_rate", 1)
 		else:
-			# if party account currency and bank currency is different then populate paid amount as well
-			paid_amount = received_amount * doc.get("conversion_rate", 1)
+			received_amount = abs(outstanding_amount)
+			if bank_amount:
+				paid_amount = bank_amount
+			else:
+				if company_currency != bank.account_currency:
+					paid_amount = received_amount / doc.get("conversion_rate", 1)
+				else:
+					# if party account currency and bank currency is different then populate paid amount as well
+					paid_amount = received_amount * doc.get("conversion_rate", 1)
 
 	return paid_amount, received_amount
 
@@ -2123,6 +2284,7 @@ def get_reference_as_per_payment_terms(
 					"due_date": doc.get("due_date"),
 					"total_amount": grand_total,
 					"outstanding_amount": outstanding_amount,
+					"payment_term_outstanding": payment_term_outstanding,
 					"payment_term": payment_term.payment_term,
 					"allocated_amount": payment_term_outstanding,
 				}

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -11,6 +11,7 @@ from frappe.utils import flt, nowdate
 from erpnext.accounts.doctype.payment_entry.payment_entry import (
 	InvalidPaymentEntry,
 	get_payment_entry,
+	get_reference_details,
 )
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import (
 	make_purchase_invoice,
@@ -51,6 +52,38 @@ class TestPaymentEntry(FrappeTestCase):
 		so_advance_paid = frappe.db.get_value("Sales Order", so.name, "advance_paid")
 		self.assertEqual(so_advance_paid, 0)
 
+	def test_payment_against_sales_order_usd_to_inr(self):
+		so = make_sales_order(
+			customer="_Test Customer USD", currency="USD", qty=1, rate=100, do_not_submit=True
+		)
+		so.conversion_rate = 50
+		so.submit()
+		pe = get_payment_entry("Sales Order", so.name)
+		pe.source_exchange_rate = 55
+		pe.received_amount = 5500
+		pe.insert()
+		pe.submit()
+
+		# there should be no difference amount
+		pe.reload()
+		self.assertEqual(pe.difference_amount, 0)
+		self.assertEqual(pe.deductions, [])
+
+		expected_gle = dict(
+			(d[0], d)
+			for d in [["_Test Receivable USD - _TC", 0, 5500, so.name], ["Cash - _TC", 5500.0, 0, None]]
+		)
+
+		self.validate_gl_entries(pe.name, expected_gle)
+
+		so_advance_paid = frappe.db.get_value("Sales Order", so.name, "advance_paid")
+		self.assertEqual(so_advance_paid, 100)
+
+		pe.cancel()
+
+		so_advance_paid = frappe.db.get_value("Sales Order", so.name, "advance_paid")
+		self.assertEqual(so_advance_paid, 0)
+
 	def test_payment_entry_for_blocked_supplier_invoice(self):
 		supplier = frappe.get_doc("Supplier", "_Test Supplier")
 		supplier.on_hold = 1
@@ -981,6 +1014,53 @@ class TestPaymentEntry(FrappeTestCase):
 		employee = make_employee("test_payment_entry@salary.com", company="_Test Company")
 		create_payment_entry(party_type="Employee", party=employee, save=True)
 
+	def test_duplicate_payment_entry_allocate_amount(self):
+		si = create_sales_invoice()
+
+		pe_draft = get_payment_entry("Sales Invoice", si.name)
+		pe_draft.insert()
+
+		pe = get_payment_entry("Sales Invoice", si.name)
+		pe.submit()
+
+		self.assertRaises(frappe.ValidationError, pe_draft.submit)
+
+	def test_duplicate_payment_entry_partial_allocate_amount(self):
+		si = create_sales_invoice()
+
+		pe_draft = get_payment_entry("Sales Invoice", si.name)
+		pe_draft.insert()
+
+		pe = get_payment_entry("Sales Invoice", si.name)
+		pe.received_amount = si.total / 2
+		pe.references[0].allocated_amount = si.total / 2
+		pe.submit()
+
+		self.assertRaises(frappe.ValidationError, pe_draft.submit)
+
+	def test_details_update_on_reference_table(self):
+		so = make_sales_order(
+			customer="_Test Customer USD", currency="USD", qty=1, rate=100, do_not_submit=True
+		)
+		so.conversion_rate = 50
+		so.submit()
+		pe = get_payment_entry("Sales Order", so.name)
+		pe.references.clear()
+		pe.paid_from = "Debtors - _TC"
+		pe.paid_from_account_currency = "INR"
+		pe.source_exchange_rate = 50
+		pe.save()
+
+		ref_details = get_reference_details(so.doctype, so.name, pe.paid_from_account_currency)
+		expected_response = {
+			"total_amount": 5000.0,
+			"outstanding_amount": 5000.0,
+			"exchange_rate": 1.0,
+			"due_date": None,
+			"bill_no": None,
+		}
+		self.assertDictEqual(ref_details, expected_response)
+
 
 def create_payment_entry(**args):
 	payment_entry = frappe.new_doc("Payment Entry")

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js

@@ -82,6 +82,36 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 			this.frm.change_custom_button_type('Get Unreconciled Entries', null, 'default');
 			this.frm.change_custom_button_type('Allocate', null, 'default');
 		}
+
+		// check for any running reconciliation jobs
+		if (this.frm.doc.receivable_payable_account) {
+			this.frm.call({
+				doc: this.frm.doc,
+				method: 'is_auto_process_enabled',
+				callback: (r) => {
+					if (r.message) {
+						this.frm.call({
+							'method': "erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.is_any_doc_running",
+							"args": {
+								for_filter: {
+									company: this.frm.doc.company,
+									party_type: this.frm.doc.party_type,
+									party: this.frm.doc.party,
+									receivable_payable_account: this.frm.doc.receivable_payable_account
+								}
+							}
+						}).then(r => {
+							if (r.message) {
+								let doc_link = frappe.utils.get_form_link("Process Payment Reconciliation", r.message, true);
+								let msg = __("Payment Reconciliation Job: {0} is running for this party. Can't reconcile now.", [doc_link]);
+								this.frm.dashboard.add_comment(msg, "yellow");
+							}
+						});
+					}
+				}
+			});
+		}
+
 	}
 
 	company() {

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -6,10 +6,12 @@ import frappe
 from frappe import _, msgprint, qb
 from frappe.model.document import Document
 from frappe.query_builder.custom import ConstantColumn
-from frappe.query_builder.functions import IfNull
-from frappe.utils import flt, getdate, nowdate, today
+from frappe.utils import flt, get_link_to_form, getdate, nowdate, today
 
 import erpnext
+from erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation import (
+	is_any_doc_running,
+)
 from erpnext.accounts.utils import (
 	QueryPaymentLedger,
 	get_outstanding_invoices,
@@ -124,12 +126,29 @@ class PaymentReconciliation(Document):
 
 		return list(journal_entries)
 
+	def get_return_invoices(self):
+		voucher_type = "Sales Invoice" if self.party_type == "Customer" else "Purchase Invoice"
+		doc = qb.DocType(voucher_type)
+		self.return_invoices = (
+			qb.from_(doc)
+			.select(
+				ConstantColumn(voucher_type).as_("voucher_type"),
+				doc.name.as_("voucher_no"),
+				doc.return_against,
+			)
+			.where(
+				(doc.docstatus == 1)
+				& (doc[frappe.scrub(self.party_type)] == self.party)
+				& (doc.is_return == 1)
+			)
+			.run(as_dict=True)
+		)
+
 	def get_dr_or_cr_notes(self):
 
 		self.build_qb_filter_conditions(get_return_invoices=True)
 
 		ple = qb.DocType("Payment Ledger Entry")
-		voucher_type = "Sales Invoice" if self.party_type == "Customer" else "Purchase Invoice"
 
 		if erpnext.get_party_account_type(self.party_type) == "Receivable":
 			self.common_filter_conditions.append(ple.account_type == "Receivable")
@@ -137,19 +156,10 @@ class PaymentReconciliation(Document):
 			self.common_filter_conditions.append(ple.account_type == "Payable")
 		self.common_filter_conditions.append(ple.account == self.receivable_payable_account)
 
-		# get return invoices
-		doc = qb.DocType(voucher_type)
-		return_invoices = (
-			qb.from_(doc)
-			.select(ConstantColumn(voucher_type).as_("voucher_type"), doc.name.as_("voucher_no"))
-			.where(
-				(doc.docstatus == 1)
-				& (doc[frappe.scrub(self.party_type)] == self.party)
-				& (doc.is_return == 1)
-				& (IfNull(doc.return_against, "") == "")
-			)
-			.run(as_dict=True)
-		)
+		self.get_return_invoices()
+		return_invoices = [
+			x for x in self.return_invoices if x.return_against == None or x.return_against == ""
+		]
 
 		outstanding_dr_or_cr = []
 		if return_invoices:
@@ -201,6 +211,15 @@ class PaymentReconciliation(Document):
 			accounting_dimensions=self.accounting_dimension_filter_conditions,
 		)
 
+		cr_dr_notes = (
+			[x.voucher_no for x in self.return_invoices]
+			if self.party_type in ["Customer", "Supplier"]
+			else []
+		)
+		# Filter out cr/dr notes from outstanding invoices list
+		# Happens when non-standalone cr/dr notes are linked with another invoice through journal entry
+		non_reconciled_invoices = [x for x in non_reconciled_invoices if x.voucher_no not in cr_dr_notes]
+
 		if self.invoice_limit:
 			non_reconciled_invoices = non_reconciled_invoices[: self.invoice_limit]
 
@@ -233,6 +252,10 @@ class PaymentReconciliation(Document):
 
 		return difference_amount
 
+	@frappe.whitelist()
+	def is_auto_process_enabled(self):
+		return frappe.db.get_single_value("Accounts Settings", "auto_reconcile_payments")
+
 	@frappe.whitelist()
 	def calculate_difference_on_allocation_change(self, payment_entry, invoice, allocated_amount):
 		invoice_exchange_map = self.get_invoice_exchange_map(invoice, payment_entry)
@@ -304,9 +327,7 @@ class PaymentReconciliation(Document):
 			}
 		)
 
-	@frappe.whitelist()
-	def reconcile(self):
-		self.validate_allocation()
+	def reconcile_allocations(self, skip_ref_details_update_for_pe=False):
 		dr_or_cr = (
 			"credit_in_account_currency"
 			if erpnext.get_party_account_type(self.party_type) == "Receivable"
@@ -326,16 +347,42 @@ class PaymentReconciliation(Document):
 				payment_details = self.get_payment_details(row, dr_or_cr)
 				reconciled_entry.append(payment_details)
 
-				if payment_details.difference_amount:
+				if payment_details.difference_amount and row.reference_type not in [
+					"Sales Invoice",
+					"Purchase Invoice",
+				]:
 					self.make_difference_entry(payment_details)
 
 		if entry_list:
-			reconcile_against_document(entry_list)
+			reconcile_against_document(entry_list, skip_ref_details_update_for_pe)
 
 		if dr_or_cr_notes:
 			reconcile_dr_cr_note(dr_or_cr_notes, self.company)
 
+	@frappe.whitelist()
+	def reconcile(self):
+		if frappe.db.get_single_value("Accounts Settings", "auto_reconcile_payments"):
+			running_doc = is_any_doc_running(
+				dict(
+					company=self.company,
+					party_type=self.party_type,
+					party=self.party,
+					receivable_payable_account=self.receivable_payable_account,
+				)
+			)
+
+			if running_doc:
+				frappe.throw(
+					_("A Reconciliation Job {0} is running for the same filters. Cannot reconcile now").format(
+						get_link_to_form("Auto Reconcile", running_doc)
+					)
+				)
+				return
+
+		self.validate_allocation()
+		self.reconcile_allocations()
 		msgprint(_("Successfully Reconciled"))
+
 		self.get_unreconciled_entries()
 
 	def make_difference_entry(self, row):
@@ -389,6 +436,8 @@ class PaymentReconciliation(Document):
 		journal_entry.save()
 		journal_entry.submit()
 
+		return journal_entry
+
 	def get_payment_details(self, row, dr_or_cr):
 		return frappe._dict(
 			{
@@ -554,6 +603,16 @@ class PaymentReconciliation(Document):
 
 
 def reconcile_dr_cr_note(dr_cr_notes, company):
+	def get_difference_row(inv):
+		if inv.difference_amount != 0 and inv.difference_account:
+			difference_row = {
+				"account": inv.difference_account,
+				inv.dr_or_cr: abs(inv.difference_amount) if inv.difference_amount > 0 else 0,
+				reconcile_dr_or_cr: abs(inv.difference_amount) if inv.difference_amount < 0 else 0,
+				"cost_center": erpnext.get_default_cost_center(company),
+			}
+			return difference_row
+
 	for inv in dr_cr_notes:
 		voucher_type = "Credit Note" if inv.voucher_type == "Sales Invoice" else "Debit Note"
 
@@ -598,5 +657,9 @@ def reconcile_dr_cr_note(dr_cr_notes, company):
 				],
 			}
 		)
+
+		if difference_entry := get_difference_row(inv):
+			jv.append("accounts", difference_entry)
+
 		jv.flags.ignore_mandatory = True
 		jv.submit()

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -11,10 +11,13 @@ from frappe.utils import add_days, flt, nowdate
 from erpnext import get_default_cost_center
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
+from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.party import get_party_account
 from erpnext.stock.doctype.item.test_item import create_item
 
+test_dependencies = ["Item"]
+
 
 class TestPaymentReconciliation(FrappeTestCase):
 	def setUp(self):
@@ -163,7 +166,9 @@ class TestPaymentReconciliation(FrappeTestCase):
 	def create_payment_reconciliation(self):
 		pr = frappe.new_doc("Payment Reconciliation")
 		pr.company = self.company
-		pr.party_type = "Customer"
+		pr.party_type = (
+			self.party_type if hasattr(self, "party_type") and self.party_type else "Customer"
+		)
 		pr.party = self.customer
 		pr.receivable_payable_account = get_party_account(pr.party_type, pr.party, pr.company)
 		pr.from_invoice_date = pr.to_invoice_date = pr.from_payment_date = pr.to_payment_date = nowdate()
@@ -890,6 +895,42 @@ class TestPaymentReconciliation(FrappeTestCase):
 		self.assertEqual(pr.allocation[0].allocated_amount, 85)
 		self.assertEqual(pr.allocation[0].difference_amount, 0)
 
+	def test_reconciliation_purchase_invoice_against_return(self):
+		pi = make_purchase_invoice(
+			supplier="_Test Supplier USD", currency="USD", conversion_rate=50
+		).submit()
+
+		pi_return = frappe.get_doc(pi.as_dict())
+		pi_return.name = None
+		pi_return.docstatus = 0
+		pi_return.is_return = 1
+		pi_return.conversion_rate = 80
+		pi_return.items[0].qty = -pi_return.items[0].qty
+		pi_return.submit()
+
+		self.company = "_Test Company"
+		self.party_type = "Supplier"
+		self.customer = "_Test Supplier USD"
+
+		pr = self.create_payment_reconciliation()
+		pr.get_unreconciled_entries()
+
+		invoices = []
+		payments = []
+		for invoice in pr.invoices:
+			if invoice.invoice_number == pi.name:
+				invoices.append(invoice.as_dict())
+				break
+		for payment in pr.payments:
+			if payment.reference_name == pi_return.name:
+				payments.append(payment.as_dict())
+				break
+
+		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+
+		# Should not raise frappe.exceptions.ValidationError: Total Debit must be equal to Total Credit.
+		pr.reconcile()
+
 
 def make_customer(customer_name, currency=None):
 	if not frappe.db.exists("Customer", customer_name):

erpnext/accounts/doctype/payment_terms_template/payment_terms_template.js

@@ -2,7 +2,11 @@
 // For license information, please see license.txt
 
 frappe.ui.form.on('Payment Terms Template', {
-	setup: function(frm) {
+	refresh: function(frm) {
+		frm.fields_dict.terms.grid.toggle_reqd("payment_term", frm.doc.allocate_payment_based_on_payment_terms);
+	},
 
+	allocate_payment_based_on_payment_terms: function(frm) {
+		frm.fields_dict.terms.grid.toggle_reqd("payment_term", frm.doc.allocate_payment_based_on_payment_terms);
 	}
 });

erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py

@@ -11,7 +11,7 @@ from frappe.utils import flt
 class PaymentTermsTemplate(Document):
 	def validate(self):
 		self.validate_invoice_portion()
-		self.check_duplicate_terms()
+		self.validate_terms()
 
 	def validate_invoice_portion(self):
 		total_portion = 0
@@ -23,9 +23,12 @@ class PaymentTermsTemplate(Document):
 				_("Combined invoice portion must equal 100%"), raise_exception=1, indicator="red"
 			)
 
-	def check_duplicate_terms(self):
+	def validate_terms(self):
 		terms = []
 		for term in self.terms:
+			if self.allocate_payment_based_on_payment_terms and not term.payment_term:
+				frappe.throw(_("Row {0}: Payment Term is mandatory").format(term.idx))
+
 			term_info = (term.payment_term, term.credit_days, term.credit_months, term.due_date_based_on)
 			if term_info in terms:
 				frappe.msgprint(

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

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

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

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

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.js

@@ -123,22 +123,29 @@ frappe.ui.form.on('POS Closing Entry', {
 			row.expected_amount = row.opening_amount;
 		}
 
-		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);
-		}
-
+		await Promise.all([
+			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),
+					end: frappe.datetime.get_datetime_as_string(frm.doc.period_end_date),
+					pos_profile: frm.doc.pos_profile,
+					user: frm.doc.user
+				},
+				callback: (r) => {
+					let pos_invoices = r.message;
+					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

@@ -4,6 +4,7 @@
 
 import frappe
 from frappe import _
+from frappe.query_builder.functions import IfNull, Sum
 from frappe.utils import cint, flt, get_link_to_form, getdate, nowdate
 
 from erpnext.accounts.doctype.loyalty_program.loyalty_program import validate_loyalty_points
@@ -673,18 +674,22 @@ def get_bin_qty(item_code, warehouse):
 
 
 def get_pos_reserved_qty(item_code, warehouse):
-	reserved_qty = frappe.db.sql(
-		"""select sum(p_item.stock_qty) as qty
-		from `tabPOS Invoice` p, `tabPOS Invoice Item` p_item
-		where p.name = p_item.parent
-		and ifnull(p.consolidated_invoice, '') = ''
-		and p_item.docstatus = 1
-		and p_item.item_code = %s
-		and p_item.warehouse = %s
-		""",
-		(item_code, warehouse),
-		as_dict=1,
-	)
+	p_inv = frappe.qb.DocType("POS Invoice")
+	p_item = frappe.qb.DocType("POS Invoice Item")
+
+	reserved_qty = (
+		frappe.qb.from_(p_inv)
+		.from_(p_item)
+		.select(Sum(p_item.qty).as_("qty"))
+		.where(
+			(p_inv.name == p_item.parent)
+			& (IfNull(p_inv.consolidated_invoice, "") == "")
+			& (p_inv.is_return == 0)
+			& (p_item.docstatus == 1)
+			& (p_item.item_code == item_code)
+			& (p_item.warehouse == warehouse)
+		)
+	).run(as_dict=True)
 
 	return reserved_qty[0].qty or 0 if reserved_qty else 0
 

erpnext/accounts/doctype/pricing_rule/pricing_rule.json

@@ -469,7 +469,7 @@
    "options": "UOM"
   },
   {
-   "description": "If rate is zero them item will be treated as \"Free Item\"",
+   "description": "If rate is zero then item will be treated as \"Free Item\"",
    "fieldname": "free_item_rate",
    "fieldtype": "Currency",
    "label": "Free Item Rate"
@@ -670,4 +670,4 @@
  "sort_order": "DESC",
  "states": [],
  "title_field": "title"
-}
+}

erpnext/accounts/doctype/process_deferred_accounting/test_process_deferred_accounting.py

@@ -16,8 +16,10 @@ from erpnext.stock.doctype.item.test_item import create_item
 class TestProcessDeferredAccounting(unittest.TestCase):
 	def test_creation_of_ledger_entry_on_submit(self):
 		"""test creation of gl entries on submission of document"""
+		change_acc_settings(acc_frozen_upto="2023-05-31", book_deferred_entries_based_on="Months")
+
 		deferred_account = create_account(
-			account_name="Deferred Revenue",
+			account_name="Deferred Revenue for Accounts Frozen",
 			parent_account="Current Liabilities - _TC",
 			company="_Test Company",
 		)
@@ -29,11 +31,11 @@ class TestProcessDeferredAccounting(unittest.TestCase):
 		item.save()
 
 		si = create_sales_invoice(
-			item=item.name, update_stock=0, posting_date="2019-01-10", do_not_submit=True
+			item=item.name, rate=3000, update_stock=0, posting_date="2023-07-01", 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"
+		si.items[0].service_start_date = "2023-05-01"
+		si.items[0].service_end_date = "2023-07-31"
 		si.items[0].deferred_revenue_account = deferred_account
 		si.save()
 		si.submit()
@@ -41,9 +43,9 @@ class TestProcessDeferredAccounting(unittest.TestCase):
 		process_deferred_accounting = doc = frappe.get_doc(
 			dict(
 				doctype="Process Deferred Accounting",
-				posting_date="2019-01-01",
-				start_date="2019-01-01",
-				end_date="2019-01-31",
+				posting_date="2023-07-01",
+				start_date="2023-05-01",
+				end_date="2023-06-30",
 				type="Income",
 			)
 		)
@@ -52,11 +54,16 @@ class TestProcessDeferredAccounting(unittest.TestCase):
 		process_deferred_accounting.submit()
 
 		expected_gle = [
-			[deferred_account, 33.85, 0.0, "2019-01-31"],
-			["Sales - _TC", 0.0, 33.85, "2019-01-31"],
+			["Debtors - _TC", 3000, 0.0, "2023-07-01"],
+			[deferred_account, 0.0, 3000, "2023-07-01"],
+			["Sales - _TC", 0.0, 1000, "2023-06-30"],
+			[deferred_account, 1000, 0.0, "2023-06-30"],
+			["Sales - _TC", 0.0, 1000, "2023-06-30"],
+			[deferred_account, 1000, 0.0, "2023-06-30"],
 		]
 
-		check_gl_entries(self, si.name, expected_gle, "2019-01-10")
+		check_gl_entries(self, si.name, expected_gle, "2023-07-01")
+		change_acc_settings()
 
 	def test_pda_submission_and_cancellation(self):
 		pda = frappe.get_doc(
@@ -70,3 +77,10 @@ class TestProcessDeferredAccounting(unittest.TestCase):
 		)
 		pda.submit()
 		pda.cancel()
+
+
+def change_acc_settings(acc_frozen_upto="", book_deferred_entries_based_on="Days"):
+	acc_settings = frappe.get_doc("Accounts Settings", "Accounts Settings")
+	acc_settings.acc_frozen_upto = acc_frozen_upto
+	acc_settings.book_deferred_entries_based_on = book_deferred_entries_based_on
+	acc_settings.save()

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.js

@@ -0,0 +1,130 @@
+// Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
+// For license information, please see license.txt
+
+frappe.ui.form.on("Process Payment Reconciliation", {
+	onload: function(frm) {
+		// set queries
+		frm.set_query("party_type", function() {
+			return {
+				"filters": {
+					"name": ["in", Object.keys(frappe.boot.party_account_types)],
+				}
+			}
+		});
+		frm.set_query('receivable_payable_account',  function(doc) {
+			return {
+				filters: {
+					"company": doc.company,
+					"is_group": 0,
+					"account_type": frappe.boot.party_account_types[doc.party_type]
+				}
+			};
+		});
+		frm.set_query('cost_center', function(doc) {
+			return {
+				filters: {
+					"company": doc.company,
+					"is_group": 0,
+				}
+			};
+		});
+		frm.set_query('bank_cash_account', function(doc) {
+			return {
+				filters:[
+					['Account', 'company', '=', doc.company],
+					['Account', 'is_group', '=', 0],
+					['Account', 'account_type', 'in', ['Bank', 'Cash']]
+				]
+			};
+		});
+
+	},
+	refresh: function(frm) {
+		if (frm.doc.docstatus==1 && ['Queued', 'Paused'].find(x => x == frm.doc.status)) {
+			let execute_btn = __("Start / Resume")
+
+			frm.add_custom_button(execute_btn, () => {
+				frm.call({
+					method: 'erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.trigger_job_for_doc',
+					args: {
+						docname: frm.doc.name
+					}
+				}).then(r => {
+					if(!r.exc) {
+						frappe.show_alert(__("Job Started"));
+						frm.reload_doc();
+					}
+				});
+			});
+		}
+		if (frm.doc.docstatus==1 && ['Completed', 'Running', 'Paused', 'Partially Reconciled'].find(x => x == frm.doc.status)) {
+			frm.call({
+				'method': "erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.get_reconciled_count",
+				args: {
+					"docname": frm.docname,
+				}
+			}).then(r => {
+				if (r.message) {
+					let progress = 0;
+					let description = "";
+
+					if (r.message.processed) {
+						progress = (r.message.processed/r.message.total) * 100;
+						description = r.message.processed + "/" + r.message.total +  " processed";
+					} else if (r.message.total == 0 && frm.doc.status == "Completed") {
+						progress = 100;
+					}
+
+
+					frm.dashboard.add_progress('Reconciliation Progress', progress, description);
+				}
+			})
+		}
+		if (frm.doc.docstatus==1 && frm.doc.status == 'Running') {
+			let execute_btn = __("Pause")
+
+			frm.add_custom_button(execute_btn, () => {
+				frm.call({
+					'method': "erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.pause_job_for_doc",
+					args: {
+						"docname": frm.docname,
+					}
+				}).then(r => {
+					if (!r.exc) {
+						frappe.show_alert(__("Job Paused"));
+						frm.reload_doc()
+					}
+				});
+
+			});
+		}
+	},
+	company(frm) {
+		frm.set_value('party', '');
+		frm.set_value('receivable_payable_account', '');
+	},
+	party_type(frm) {
+		frm.set_value('party', '');
+	},
+
+	party(frm) {
+		frm.set_value('receivable_payable_account', '');
+		if (!frm.doc.receivable_payable_account && frm.doc.party_type && frm.doc.party) {
+			return frappe.call({
+				method: "erpnext.accounts.party.get_party_account",
+				args: {
+					company: frm.doc.company,
+					party_type: frm.doc.party_type,
+					party: frm.doc.party
+				},
+				callback: (r) => {
+					if (!r.exc && r.message) {
+						frm.set_value("receivable_payable_account", r.message);
+					}
+					frm.refresh();
+
+				}
+			});
+		}
+	}
+});

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.json

@@ -0,0 +1,173 @@
+{
+ "actions": [],
+ "autoname": "format:ACC-PPR-{#####}",
+ "beta": 1,
+ "creation": "2023-03-30 21:28:39.793927",
+ "default_view": "List",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "company",
+  "party_type",
+  "column_break_io6c",
+  "party",
+  "receivable_payable_account",
+  "filter_section",
+  "from_invoice_date",
+  "to_invoice_date",
+  "column_break_kegk",
+  "from_payment_date",
+  "to_payment_date",
+  "column_break_uj04",
+  "cost_center",
+  "bank_cash_account",
+  "section_break_2n02",
+  "status",
+  "error_log",
+  "section_break_a8yx",
+  "amended_from"
+ ],
+ "fields": [
+  {
+   "allow_on_submit": 1,
+   "fieldname": "status",
+   "fieldtype": "Select",
+   "label": "Status",
+   "options": "\nQueued\nRunning\nPaused\nCompleted\nPartially Reconciled\nFailed\nCancelled",
+   "read_only": 1
+  },
+  {
+   "fieldname": "company",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "Company",
+   "options": "Company",
+   "reqd": 1
+  },
+  {
+   "fieldname": "party_type",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "Party Type",
+   "options": "DocType",
+   "reqd": 1
+  },
+  {
+   "fieldname": "column_break_io6c",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "party",
+   "fieldtype": "Dynamic Link",
+   "in_list_view": 1,
+   "label": "Party",
+   "options": "party_type",
+   "reqd": 1
+  },
+  {
+   "fieldname": "receivable_payable_account",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "Receivable/Payable Account",
+   "options": "Account",
+   "reqd": 1
+  },
+  {
+   "fieldname": "filter_section",
+   "fieldtype": "Section Break",
+   "label": "Filters"
+  },
+  {
+   "fieldname": "from_invoice_date",
+   "fieldtype": "Date",
+   "label": "From Invoice Date"
+  },
+  {
+   "fieldname": "to_invoice_date",
+   "fieldtype": "Date",
+   "label": "To Invoice Date"
+  },
+  {
+   "fieldname": "column_break_kegk",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "from_payment_date",
+   "fieldtype": "Date",
+   "label": "From Payment Date"
+  },
+  {
+   "fieldname": "to_payment_date",
+   "fieldtype": "Date",
+   "label": "To Payment Date"
+  },
+  {
+   "fieldname": "column_break_uj04",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "cost_center",
+   "fieldtype": "Link",
+   "label": "Cost Center",
+   "options": "Cost Center"
+  },
+  {
+   "fieldname": "bank_cash_account",
+   "fieldtype": "Link",
+   "label": "Bank/Cash Account",
+   "options": "Account"
+  },
+  {
+   "fieldname": "section_break_2n02",
+   "fieldtype": "Section Break",
+   "label": "Status"
+  },
+  {
+   "depends_on": "eval:doc.error_log",
+   "fieldname": "error_log",
+   "fieldtype": "Long Text",
+   "label": "Error Log"
+  },
+  {
+   "fieldname": "amended_from",
+   "fieldtype": "Link",
+   "label": "Amended From",
+   "no_copy": 1,
+   "options": "Process Payment Reconciliation",
+   "print_hide": 1,
+   "read_only": 1
+  },
+  {
+   "fieldname": "section_break_a8yx",
+   "fieldtype": "Section Break"
+  }
+ ],
+ "index_web_pages_for_search": 1,
+ "is_submittable": 1,
+ "links": [],
+ "modified": "2023-04-21 17:19:30.912953",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Process Payment Reconciliation",
+ "naming_rule": "Expression",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "System Manager",
+   "share": 1,
+   "write": 1
+  }
+ ],
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "states": [],
+ "title_field": "company"
+}

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.py

@@ -0,0 +1,503 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+import frappe
+from frappe import _, qb
+from frappe.model.document import Document
+from frappe.utils import get_link_to_form
+from frappe.utils.scheduler import is_scheduler_inactive
+
+
+class ProcessPaymentReconciliation(Document):
+	def validate(self):
+		self.validate_receivable_payable_account()
+		self.validate_bank_cash_account()
+
+	def validate_receivable_payable_account(self):
+		if self.receivable_payable_account:
+			if self.company != frappe.db.get_value("Account", self.receivable_payable_account, "company"):
+				frappe.throw(
+					_("Receivable/Payable Account: {0} doesn't belong to company {1}").format(
+						frappe.bold(self.receivable_payable_account), frappe.bold(self.company)
+					)
+				)
+
+	def validate_bank_cash_account(self):
+		if self.bank_cash_account:
+			if self.company != frappe.db.get_value("Account", self.bank_cash_account, "company"):
+				frappe.throw(
+					_("Bank/Cash Account {0} doesn't belong to company {1}").format(
+						frappe.bold(self.bank_cash_account), frappe.bold(self.company)
+					)
+				)
+
+	def before_save(self):
+		self.status = ""
+		self.error_log = ""
+
+	def on_submit(self):
+		self.db_set("status", "Queued")
+		self.db_set("error_log", None)
+
+	def on_cancel(self):
+		self.db_set("status", "Cancelled")
+		log = frappe.db.get_value(
+			"Process Payment Reconciliation Log", filters={"process_pr": self.name}
+		)
+		if log:
+			frappe.db.set_value("Process Payment Reconciliation Log", log, "status", "Cancelled")
+
+
+@frappe.whitelist()
+def get_reconciled_count(docname: str | None = None) -> float:
+	current_status = {}
+	if docname:
+		reconcile_log = frappe.db.get_value(
+			"Process Payment Reconciliation Log", filters={"process_pr": docname}, fieldname="name"
+		)
+		if reconcile_log:
+			res = frappe.get_all(
+				"Process Payment Reconciliation Log",
+				filters={"name": reconcile_log},
+				fields=["reconciled_entries", "total_allocations"],
+				as_list=1,
+			)
+			current_status["processed"], current_status["total"] = res[0]
+
+	return current_status
+
+
+def get_pr_instance(doc: str):
+	process_payment_reconciliation = frappe.get_doc("Process Payment Reconciliation", doc)
+
+	pr = frappe.get_doc("Payment Reconciliation")
+	fields = [
+		"company",
+		"party_type",
+		"party",
+		"receivable_payable_account",
+		"from_invoice_date",
+		"to_invoice_date",
+		"from_payment_date",
+		"to_payment_date",
+	]
+	d = {}
+	for field in fields:
+		d[field] = process_payment_reconciliation.get(field)
+	pr.update(d)
+	pr.invoice_limit = 1000
+	pr.payment_limit = 1000
+	return pr
+
+
+def is_job_running(job_name: str) -> bool:
+	jobs = frappe.db.get_all("RQ Job", filters={"status": ["in", ["started", "queued"]]})
+	for x in jobs:
+		if x.job_name == job_name:
+			return True
+	return False
+
+
+@frappe.whitelist()
+def pause_job_for_doc(docname: str | None = None):
+	if docname:
+		frappe.db.set_value("Process Payment Reconciliation", docname, "status", "Paused")
+		log = frappe.db.get_value("Process Payment Reconciliation Log", filters={"process_pr": docname})
+		if log:
+			frappe.db.set_value("Process Payment Reconciliation Log", log, "status", "Paused")
+
+
+@frappe.whitelist()
+def trigger_job_for_doc(docname: str | None = None):
+	"""
+	Trigger background job
+	"""
+	if not docname:
+		return
+
+	if not frappe.db.get_single_value("Accounts Settings", "auto_reconcile_payments"):
+		frappe.throw(
+			_("Auto Reconciliation of Payments has been disabled. Enable it through {0}").format(
+				get_link_to_form("Accounts Settings", "Accounts Settings")
+			)
+		)
+
+		return
+
+	if not is_scheduler_inactive():
+		if frappe.db.get_value("Process Payment Reconciliation", docname, "status") == "Queued":
+			frappe.db.set_value("Process Payment Reconciliation", docname, "status", "Running")
+			job_name = f"start_processing_{docname}"
+			if not is_job_running(job_name):
+				job = frappe.enqueue(
+					method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.reconcile_based_on_filters",
+					queue="long",
+					is_async=True,
+					job_name=job_name,
+					enqueue_after_commit=True,
+					doc=docname,
+				)
+
+		elif frappe.db.get_value("Process Payment Reconciliation", docname, "status") == "Paused":
+			frappe.db.set_value("Process Payment Reconciliation", docname, "status", "Running")
+			log = frappe.db.get_value("Process Payment Reconciliation Log", filters={"process_pr": docname})
+			if log:
+				frappe.db.set_value("Process Payment Reconciliation Log", log, "status", "Running")
+
+			# Resume tasks for running doc
+			job_name = f"start_processing_{docname}"
+			if not is_job_running(job_name):
+				job = frappe.enqueue(
+					method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.reconcile_based_on_filters",
+					queue="long",
+					is_async=True,
+					job_name=job_name,
+					doc=docname,
+				)
+	else:
+		frappe.msgprint(_("Scheduler is Inactive. Can't trigger job now."))
+
+
+def trigger_reconciliation_for_queued_docs():
+	"""
+	Will be called from Cron Job
+	Fetch queued docs and start reconciliation process for each one
+	"""
+	if not frappe.db.get_single_value("Accounts Settings", "auto_reconcile_payments"):
+		frappe.msgprint(
+			_("Auto Reconciliation of Payments has been disabled. Enable it through {0}").format(
+				get_link_to_form("Accounts Settings", "Accounts Settings")
+			)
+		)
+
+		return
+
+	if not is_scheduler_inactive():
+		# Get all queued documents
+		all_queued = frappe.db.get_all(
+			"Process Payment Reconciliation",
+			filters={"docstatus": 1, "status": "Queued"},
+			order_by="creation desc",
+			as_list=1,
+		)
+
+		docs_to_trigger = []
+		unique_filters = set()
+		queue_size = 5
+
+		fields = ["company", "party_type", "party", "receivable_payable_account"]
+
+		def get_filters_as_tuple(fields, doc):
+			filters = ()
+			for x in fields:
+				filters += tuple(doc.get(x))
+			return filters
+
+		for x in all_queued:
+			doc = frappe.get_doc("Process Payment Reconciliation", x)
+			filters = get_filters_as_tuple(fields, doc)
+			if filters not in unique_filters:
+				unique_filters.add(filters)
+				docs_to_trigger.append(doc.name)
+			if len(docs_to_trigger) == queue_size:
+				break
+
+		# trigger reconcilation process for queue_size unique filters
+		for doc in docs_to_trigger:
+			trigger_job_for_doc(doc)
+
+	else:
+		frappe.msgprint(_("Scheduler is Inactive. Can't trigger jobs now."))
+
+
+def reconcile_based_on_filters(doc: None | str = None) -> None:
+	"""
+	Identify current state of document and execute next tasks in background
+	"""
+	if doc:
+		log = frappe.db.get_value("Process Payment Reconciliation Log", filters={"process_pr": doc})
+		if not log:
+			log = frappe.new_doc("Process Payment Reconciliation Log")
+			log.process_pr = doc
+			log.status = "Running"
+			log = log.save()
+
+			job_name = f"process_{doc}_fetch_and_allocate"
+			if not is_job_running(job_name):
+				job = frappe.enqueue(
+					method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.fetch_and_allocate",
+					queue="long",
+					timeout="3600",
+					is_async=True,
+					job_name=job_name,
+					enqueue_after_commit=True,
+					doc=doc,
+				)
+		else:
+			res = frappe.get_all(
+				"Process Payment Reconciliation Log",
+				filters={"name": log},
+				fields=["allocated", "reconciled"],
+				as_list=1,
+			)
+			allocated, reconciled = res[0]
+
+			if not allocated:
+				job_name = f"process__{doc}_fetch_and_allocate"
+				if not is_job_running(job_name):
+					job = frappe.enqueue(
+						method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.fetch_and_allocate",
+						queue="long",
+						timeout="3600",
+						is_async=True,
+						job_name=job_name,
+						enqueue_after_commit=True,
+						doc=doc,
+					)
+			elif not reconciled:
+				allocation = get_next_allocation(log)
+				if allocation:
+					reconcile_job_name = (
+						f"process_{doc}_reconcile_allocation_{allocation[0].idx}_{allocation[-1].idx}"
+					)
+				else:
+					reconcile_job_name = f"process_{doc}_reconcile"
+				if not is_job_running(reconcile_job_name):
+					job = frappe.enqueue(
+						method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.reconcile",
+						queue="long",
+						timeout="3600",
+						is_async=True,
+						job_name=reconcile_job_name,
+						enqueue_after_commit=True,
+						doc=doc,
+					)
+			elif reconciled:
+				frappe.db.set_value("Process Payment Reconciliation", doc, "status", "Completed")
+
+
+def get_next_allocation(log: str) -> list:
+	if log:
+		allocations = []
+		next = frappe.db.get_all(
+			"Process Payment Reconciliation Log Allocations",
+			filters={"parent": log, "reconciled": 0},
+			fields=["reference_type", "reference_name"],
+			order_by="idx",
+			limit=1,
+		)
+
+		if next:
+			allocations = frappe.db.get_all(
+				"Process Payment Reconciliation Log Allocations",
+				filters={
+					"parent": log,
+					"reconciled": 0,
+					"reference_type": next[0].reference_type,
+					"reference_name": next[0].reference_name,
+				},
+				fields=["*"],
+				order_by="idx",
+			)
+
+		return allocations
+	return []
+
+
+def fetch_and_allocate(doc: str) -> None:
+	"""
+	Fetch Invoices and Payments based on filters applied. FIFO ordering is used for allocation.
+	"""
+
+	if doc:
+		log = frappe.db.get_value("Process Payment Reconciliation Log", filters={"process_pr": doc})
+		if log:
+			if not frappe.db.get_value("Process Payment Reconciliation Log", log, "allocated"):
+				reconcile_log = frappe.get_doc("Process Payment Reconciliation Log", log)
+
+				pr = get_pr_instance(doc)
+				pr.get_unreconciled_entries()
+
+				if len(pr.invoices) > 0 and len(pr.payments) > 0:
+					invoices = [x.as_dict() for x in pr.invoices]
+					payments = [x.as_dict() for x in pr.payments]
+					pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+
+					for x in pr.get("allocation"):
+						reconcile_log.append(
+							"allocations",
+							x.as_dict().update(
+								{
+									"parenttype": "Process Payment Reconciliation Log",
+									"parent": reconcile_log.name,
+									"name": None,
+									"reconciled": False,
+								}
+							),
+						)
+				reconcile_log.allocated = True
+				reconcile_log.total_allocations = len(reconcile_log.get("allocations"))
+				reconcile_log.reconciled_entries = 0
+				reconcile_log.save()
+
+				# generate reconcile job name
+				allocation = get_next_allocation(log)
+				if allocation:
+					reconcile_job_name = (
+						f"process_{doc}_reconcile_allocation_{allocation[0].idx}_{allocation[-1].idx}"
+					)
+				else:
+					reconcile_job_name = f"process_{doc}_reconcile"
+
+				if not is_job_running(reconcile_job_name):
+					job = frappe.enqueue(
+						method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.reconcile",
+						queue="long",
+						timeout="3600",
+						is_async=True,
+						job_name=reconcile_job_name,
+						enqueue_after_commit=True,
+						doc=doc,
+					)
+
+
+def reconcile(doc: None | str = None) -> None:
+	if doc:
+		log = frappe.db.get_value("Process Payment Reconciliation Log", filters={"process_pr": doc})
+		if log:
+			res = frappe.get_all(
+				"Process Payment Reconciliation Log",
+				filters={"name": log},
+				fields=["reconciled_entries", "total_allocations"],
+				as_list=1,
+				limit=1,
+			)
+
+			reconciled_entries, total_allocations = res[0]
+			if reconciled_entries != total_allocations:
+				try:
+					# Fetch next allocation
+					allocations = get_next_allocation(log)
+
+					pr = get_pr_instance(doc)
+
+					# pass allocation to PR instance
+					for x in allocations:
+						pr.append("allocation", x)
+
+					# reconcile
+					pr.reconcile_allocations(skip_ref_details_update_for_pe=True)
+
+					# If Payment Entry, update details only for newly linked references
+					# This is for performance
+					if allocations[0].reference_type == "Payment Entry":
+
+						references = [(x.invoice_type, x.invoice_number) for x in allocations]
+						pe = frappe.get_doc(allocations[0].reference_type, allocations[0].reference_name)
+						pe.flags.ignore_validate_update_after_submit = True
+						pe.set_missing_ref_details(update_ref_details_only_for=references)
+						pe.save()
+
+					# Update reconciled flag
+					allocation_names = [x.name for x in allocations]
+					ppa = qb.DocType("Process Payment Reconciliation Log Allocations")
+					qb.update(ppa).set(ppa.reconciled, True).where(ppa.name.isin(allocation_names)).run()
+
+					# Update reconciled count
+					reconciled_count = frappe.db.count(
+						"Process Payment Reconciliation Log Allocations", filters={"parent": log, "reconciled": True}
+					)
+					frappe.db.set_value(
+						"Process Payment Reconciliation Log", log, "reconciled_entries", reconciled_count
+					)
+
+				except Exception as err:
+					# Update the parent doc about the exception
+					frappe.db.rollback()
+
+					traceback = frappe.get_traceback()
+					if traceback:
+						message = "Traceback: <br>" + traceback
+						frappe.db.set_value("Process Payment Reconciliation Log", log, "error_log", message)
+						frappe.db.set_value(
+							"Process Payment Reconciliation",
+							doc,
+							"error_log",
+							message,
+						)
+					if reconciled_entries and total_allocations and reconciled_entries < total_allocations:
+						frappe.db.set_value(
+							"Process Payment Reconciliation Log", log, "status", "Partially Reconciled"
+						)
+						frappe.db.set_value(
+							"Process Payment Reconciliation",
+							doc,
+							"status",
+							"Partially Reconciled",
+						)
+					else:
+						frappe.db.set_value("Process Payment Reconciliation Log", log, "status", "Failed")
+						frappe.db.set_value(
+							"Process Payment Reconciliation",
+							doc,
+							"status",
+							"Failed",
+						)
+				finally:
+					if reconciled_entries == total_allocations:
+						frappe.db.set_value("Process Payment Reconciliation Log", log, "status", "Reconciled")
+						frappe.db.set_value("Process Payment Reconciliation Log", log, "reconciled", True)
+						frappe.db.set_value("Process Payment Reconciliation", doc, "status", "Completed")
+					else:
+
+						if not (frappe.db.get_value("Process Payment Reconciliation", doc, "status") == "Paused"):
+							# trigger next batch in job
+							# generate reconcile job name
+							allocation = get_next_allocation(log)
+							if allocation:
+								reconcile_job_name = (
+									f"process_{doc}_reconcile_allocation_{allocation[0].idx}_{allocation[-1].idx}"
+								)
+							else:
+								reconcile_job_name = f"process_{doc}_reconcile"
+
+							if not is_job_running(reconcile_job_name):
+								job = frappe.enqueue(
+									method="erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation.reconcile",
+									queue="long",
+									timeout="3600",
+									is_async=True,
+									job_name=reconcile_job_name,
+									enqueue_after_commit=True,
+									doc=doc,
+								)
+			else:
+				frappe.db.set_value("Process Payment Reconciliation Log", log, "status", "Reconciled")
+				frappe.db.set_value("Process Payment Reconciliation Log", log, "reconciled", True)
+				frappe.db.set_value("Process Payment Reconciliation", doc, "status", "Completed")
+
+
+@frappe.whitelist()
+def is_any_doc_running(for_filter: str | dict | None = None) -> str | None:
+	running_doc = None
+	if for_filter:
+		if type(for_filter) == str:
+			for_filter = frappe.json.loads(for_filter)
+
+		running_doc = frappe.db.get_value(
+			"Process Payment Reconciliation",
+			filters={
+				"docstatus": 1,
+				"status": ["in", ["Running", "Paused"]],
+				"company": for_filter.get("company"),
+				"party_type": for_filter.get("party_type"),
+				"party": for_filter.get("party"),
+				"receivable_payable_account": for_filter.get("receivable_payable_account"),
+			},
+			fieldname="name",
+		)
+	else:
+		running_doc = frappe.db.get_value(
+			"Process Payment Reconciliation", filters={"docstatus": 1, "status": "Running"}
+		)
+	return running_doc

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation_dashboard.py

@@ -0,0 +1,15 @@
+from frappe import _
+
+
+def get_data():
+	return {
+		"fieldname": "process_pr",
+		"transactions": [
+			{
+				"label": _("Reconciliation Logs"),
+				"items": [
+					"Process Payment Reconciliation Log",
+				],
+			},
+		],
+	}

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation_list.js

@@ -0,0 +1,15 @@
+frappe.listview_settings['Process Payment Reconciliation'] = {
+	add_fields: ["status"],
+	get_indicator: function(doc) {
+		let colors = {
+			'Queued': 'orange',
+			'Paused': 'orange',
+			'Completed': 'green',
+			'Partially Reconciled': 'orange',
+			'Running': 'blue',
+			'Failed': 'red',
+		};
+		let status = doc.status;
+		return [__(status), colors[status], 'status,=,'+status];
+	},
+};

erpnext/accounts/doctype/process_payment_reconciliation/test_process_payment_reconciliation.py

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

erpnext/accounts/doctype/process_payment_reconciliation_log/process_payment_reconciliation_log.js

@@ -0,0 +1,17 @@
+// Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
+// For license information, please see license.txt
+
+frappe.ui.form.on("Process Payment Reconciliation Log", {
+	refresh(frm) {
+		if (['Completed', 'Running', 'Paused', 'Partially Reconciled'].find(x => x == frm.doc.status)) {
+			let progress = 0;
+			if (frm.doc.reconciled_entries != 0) {
+				progress = frm.doc.reconciled_entries / frm.doc.total_allocations * 100;
+			} else if(frm.doc.total_allocations == 0 && frm.doc.status == "Completed"){
+				progress = 100;
+			}
+			frm.dashboard.add_progress(__('Reconciliation Progress'), progress);
+		}
+
+	},
+});

erpnext/accounts/doctype/process_payment_reconciliation_log/process_payment_reconciliation_log.json

@@ -0,0 +1,137 @@
+{
+ "actions": [],
+ "autoname": "format:PPR-LOG-{##}",
+ "beta": 1,
+ "creation": "2023-03-13 15:00:09.149681",
+ "default_view": "List",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "process_pr",
+  "section_break_fvdw",
+  "status",
+  "tasks_section",
+  "allocated",
+  "reconciled",
+  "column_break_yhin",
+  "total_allocations",
+  "reconciled_entries",
+  "section_break_4ywv",
+  "error_log",
+  "allocations_section",
+  "allocations"
+ ],
+ "fields": [
+  {
+   "fieldname": "allocations",
+   "fieldtype": "Table",
+   "label": "Allocations",
+   "options": "Process Payment Reconciliation Log Allocations",
+   "read_only": 1
+  },
+  {
+   "default": "0",
+   "description": "All allocations have been successfully reconciled",
+   "fieldname": "reconciled",
+   "fieldtype": "Check",
+   "label": "Reconciled",
+   "read_only": 1
+  },
+  {
+   "fieldname": "total_allocations",
+   "fieldtype": "Int",
+   "in_list_view": 1,
+   "label": "Total Allocations",
+   "read_only": 1
+  },
+  {
+   "default": "0",
+   "description": "Invoices and Payments have been Fetched and Allocated",
+   "fieldname": "allocated",
+   "fieldtype": "Check",
+   "label": "Allocated",
+   "read_only": 1
+  },
+  {
+   "fieldname": "reconciled_entries",
+   "fieldtype": "Int",
+   "in_list_view": 1,
+   "label": "Reconciled Entries",
+   "read_only": 1
+  },
+  {
+   "fieldname": "tasks_section",
+   "fieldtype": "Section Break",
+   "label": "Tasks"
+  },
+  {
+   "fieldname": "allocations_section",
+   "fieldtype": "Section Break",
+   "label": "Allocations"
+  },
+  {
+   "fieldname": "column_break_yhin",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "section_break_4ywv",
+   "fieldtype": "Section Break"
+  },
+  {
+   "depends_on": "eval:doc.error_log",
+   "fieldname": "error_log",
+   "fieldtype": "Long Text",
+   "label": "Reconciliation Error Log",
+   "read_only": 1
+  },
+  {
+   "fieldname": "process_pr",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "Parent Document",
+   "options": "Process Payment Reconciliation",
+   "read_only": 1,
+   "reqd": 1
+  },
+  {
+   "fieldname": "section_break_fvdw",
+   "fieldtype": "Section Break",
+   "label": "Status"
+  },
+  {
+   "fieldname": "status",
+   "fieldtype": "Select",
+   "label": "Status",
+   "options": "Running\nPaused\nReconciled\nPartially Reconciled\nFailed\nCancelled",
+   "read_only": 1
+  }
+ ],
+ "in_create": 1,
+ "index_web_pages_for_search": 1,
+ "links": [],
+ "modified": "2023-04-21 17:36:26.642617",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Process Payment Reconciliation Log",
+ "naming_rule": "Expression",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "System Manager",
+   "share": 1,
+   "write": 1
+  }
+ ],
+ "search_fields": "allocated, reconciled, total_allocations, reconciled_entries",
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "states": []
+}

erpnext/accounts/doctype/process_payment_reconciliation_log/process_payment_reconciliation_log.py

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

erpnext/accounts/doctype/process_payment_reconciliation_log/process_payment_reconciliation_log_list.js

@@ -0,0 +1,15 @@
+frappe.listview_settings['Process Payment Reconciliation Log'] = {
+	add_fields: ["status"],
+	get_indicator: function(doc) {
+		var colors = {
+			'Partially Reconciled': 'orange',
+			'Paused': 'orange',
+			'Reconciled': 'green',
+			'Failed': 'red',
+			'Cancelled': 'red',
+			'Running': 'blue',
+		};
+		let status = doc.status;
+		return [__(status), colors[status], "status,=,"+status];
+	},
+};

erpnext/accounts/doctype/process_payment_reconciliation_log/test_process_payment_reconciliation_log.py

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

erpnext/accounts/doctype/process_payment_reconciliation_log_allocations/process_payment_reconciliation_log_allocations.json

@@ -0,0 +1,170 @@
+{
+ "actions": [],
+ "creation": "2023-03-13 13:51:27.351463",
+ "default_view": "List",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "reference_type",
+  "reference_name",
+  "reference_row",
+  "column_break_3",
+  "invoice_type",
+  "invoice_number",
+  "section_break_6",
+  "allocated_amount",
+  "unreconciled_amount",
+  "column_break_8",
+  "amount",
+  "is_advance",
+  "section_break_5",
+  "difference_amount",
+  "column_break_7",
+  "difference_account",
+  "exchange_rate",
+  "currency",
+  "reconciled"
+ ],
+ "fields": [
+  {
+   "fieldname": "reference_type",
+   "fieldtype": "Link",
+   "label": "Reference Type",
+   "options": "DocType",
+   "read_only": 1,
+   "reqd": 1
+  },
+  {
+   "fieldname": "reference_name",
+   "fieldtype": "Dynamic Link",
+   "in_list_view": 1,
+   "label": "Reference Name",
+   "options": "reference_type",
+   "read_only": 1,
+   "reqd": 1
+  },
+  {
+   "fieldname": "reference_row",
+   "fieldtype": "Data",
+   "hidden": 1,
+   "label": "Reference Row",
+   "read_only": 1
+  },
+  {
+   "fieldname": "column_break_3",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "invoice_type",
+   "fieldtype": "Link",
+   "label": "Invoice Type",
+   "options": "DocType",
+   "read_only": 1,
+   "reqd": 1
+  },
+  {
+   "fieldname": "invoice_number",
+   "fieldtype": "Dynamic Link",
+   "in_list_view": 1,
+   "label": "Invoice Number",
+   "options": "invoice_type",
+   "read_only": 1,
+   "reqd": 1
+  },
+  {
+   "fieldname": "section_break_6",
+   "fieldtype": "Section Break"
+  },
+  {
+   "fieldname": "allocated_amount",
+   "fieldtype": "Currency",
+   "in_list_view": 1,
+   "label": "Allocated Amount",
+   "options": "currency",
+   "reqd": 1
+  },
+  {
+   "fieldname": "unreconciled_amount",
+   "fieldtype": "Currency",
+   "hidden": 1,
+   "label": "Unreconciled Amount",
+   "options": "currency",
+   "read_only": 1
+  },
+  {
+   "fieldname": "column_break_8",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "amount",
+   "fieldtype": "Currency",
+   "hidden": 1,
+   "label": "Amount",
+   "options": "currency",
+   "read_only": 1
+  },
+  {
+   "fieldname": "is_advance",
+   "fieldtype": "Data",
+   "hidden": 1,
+   "label": "Is Advance",
+   "read_only": 1
+  },
+  {
+   "fieldname": "section_break_5",
+   "fieldtype": "Section Break"
+  },
+  {
+   "fieldname": "difference_amount",
+   "fieldtype": "Currency",
+   "in_list_view": 1,
+   "label": "Difference Amount",
+   "options": "Currency",
+   "read_only": 1
+  },
+  {
+   "fieldname": "column_break_7",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "difference_account",
+   "fieldtype": "Link",
+   "label": "Difference Account",
+   "options": "Account",
+   "read_only": 1
+  },
+  {
+   "fieldname": "exchange_rate",
+   "fieldtype": "Float",
+   "label": "Exchange Rate",
+   "read_only": 1
+  },
+  {
+   "fieldname": "currency",
+   "fieldtype": "Link",
+   "hidden": 1,
+   "label": "Currency",
+   "options": "Currency"
+  },
+  {
+   "default": "0",
+   "fieldname": "reconciled",
+   "fieldtype": "Check",
+   "in_list_view": 1,
+   "label": "Reconciled"
+  }
+ ],
+ "istable": 1,
+ "links": [],
+ "modified": "2023-03-20 21:05:43.121945",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Process Payment Reconciliation Log Allocations",
+ "owner": "Administrator",
+ "permissions": [],
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "states": [],
+ "track_changes": 1
+}

erpnext/accounts/doctype/process_payment_reconciliation_log_allocations/process_payment_reconciliation_log_allocations.py

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

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html

@@ -1,6 +1,6 @@
 <div class="page-break">
 	<div id="header-html" class="hidden-pdf">
-		{% if letter_head %}
+		{% if letter_head.content %}
 		<div class="letter-head text-center">{{ letter_head.content }}</div>
 		<hr style="height:2px;border-width:0;color:black;background-color:black;">
 		{% endif %}
@@ -15,7 +15,12 @@
 	</div>
 	<h2 class="text-center">{{ _("STATEMENTS OF ACCOUNTS") }}</h2>
 	<div>
-		<h5 style="float: left;">{{ _("Customer: ") }} <b>{{filters.party_name[0] }}</b></h5>
+		{% if filters.party[0] == filters.party_name[0] %}
+			<h5 style="float: left;">{{ _("Customer: ") }} <b>{{ filters.party_name[0] }}</b></h5>
+		{% else %}
+			<h5 style="float: left;">{{ _("Customer: ") }} <b>{{ filters.party[0] }}</b></h5>
+			<h5 style="float: left; margin-left:15px">{{ _("Customer Name: ") }} <b>{{filters.party_name[0] }}</b></h5>
+		{% endif %}
 		<h5 style="float: right;">
 			{{ _("Date: ") }}
 			<b>{{ frappe.format(filters.from_date, 'Date')}}

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.js

@@ -63,6 +63,20 @@ frappe.ui.form.on('Process Statement Of Accounts', {
 			frm.set_value('to_date', frappe.datetime.get_today());
 		}
 	},
+	report: function(frm){
+		let filters = {
+			'company': frm.doc.company,
+		}
+		if(frm.doc.report == 'Accounts Receivable'){
+			filters['account_type'] = 'Receivable';
+		}
+		frm.set_query("account", function() {
+			return {
+				filters: filters
+			};
+		});
+
+	},
 	customer_collection: function(frm){
 		frm.set_value('collection_name', '');
 		if(frm.doc.customer_collection){

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -6,17 +6,24 @@
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
+  "report",
   "section_break_11",
   "from_date",
+  "posting_date",
   "company",
   "account",
   "group_by",
   "cost_center",
+  "territory",
   "column_break_14",
   "to_date",
   "finance_book",
   "currency",
   "project",
+  "payment_terms_template",
+  "sales_partner",
+  "sales_person",
+  "based_on_payment_terms",
   "section_break_3",
   "customer_collection",
   "collection_name",
@@ -34,6 +41,8 @@
   "terms_and_conditions",
   "section_break_1",
   "enable_auto_email",
+  "column_break_ocfq",
+  "sender",
   "section_break_18",
   "frequency",
   "filter_duration",
@@ -63,14 +72,14 @@
    "reqd": 1
   },
   {
-   "depends_on": "eval:doc.enable_auto_email == 0;",
+   "depends_on": "eval:(doc.enable_auto_email == 0 && doc.report == 'General Ledger');",
    "fieldname": "from_date",
    "fieldtype": "Date",
    "label": "From Date",
    "mandatory_depends_on": "eval:doc.frequency == '';"
   },
   {
-   "depends_on": "eval:doc.enable_auto_email == 0;",
+   "depends_on": "eval:(doc.enable_auto_email == 0 && doc.report == 'General Ledger');",
    "fieldname": "to_date",
    "fieldtype": "Date",
    "label": "To Date",
@@ -83,6 +92,7 @@
    "options": "PSOA Cost Center"
   },
   {
+   "depends_on": "eval: (doc.report == 'General Ledger');",
    "fieldname": "project",
    "fieldtype": "Table MultiSelect",
    "label": "Project",
@@ -100,7 +110,7 @@
   {
    "fieldname": "section_break_11",
    "fieldtype": "Section Break",
-   "label": "General Ledger Filters"
+   "label": "Report Filters"
   },
   {
    "fieldname": "column_break_14",
@@ -160,12 +170,14 @@
   },
   {
    "default": "Group by Voucher (Consolidated)",
+   "depends_on": "eval:(doc.report == 'General Ledger');",
    "fieldname": "group_by",
    "fieldtype": "Select",
    "label": "Group By",
    "options": "\nGroup by Voucher\nGroup by Voucher (Consolidated)"
   },
   {
+   "depends_on": "eval: (doc.report == 'General Ledger');",
    "fieldname": "currency",
    "fieldtype": "Link",
    "label": "Currency",
@@ -284,10 +296,82 @@
    "fieldtype": "Link",
    "label": "Terms and Conditions",
    "options": "Terms and Conditions"
+  },
+  {
+   "default": "1",
+   "fieldname": "include_break",
+   "fieldtype": "Check",
+   "label": "Page Break After Each SoA"
+  },
+  {
+   "default": "0",
+   "depends_on": "eval: (doc.report == 'General Ledger');",
+   "fieldname": "show_net_values_in_party_account",
+   "fieldtype": "Check",
+   "label": "Show Net Values in Party Account"
+  },
+  {
+   "fieldname": "sender",
+   "fieldtype": "Link",
+   "label": "Sender",
+   "options": "Email Account"
+  },
+  {
+   "fieldname": "column_break_ocfq",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "report",
+   "fieldtype": "Select",
+   "label": "Report",
+   "options": "General Ledger\nAccounts Receivable",
+   "reqd": 1
+  },
+  {
+   "default": "Today",
+   "depends_on": "eval:(doc.report == 'Accounts Receivable');",
+   "fieldname": "posting_date",
+   "fieldtype": "Date",
+   "label": "Posting Date"
+  },
+  {
+   "depends_on": "eval: (doc.report == 'Accounts Receivable');",
+   "fieldname": "payment_terms_template",
+   "fieldtype": "Link",
+   "label": "Payment Terms Template",
+   "options": "Payment Terms Template"
+  },
+  {
+   "depends_on": "eval: (doc.report == 'Accounts Receivable');",
+   "fieldname": "sales_partner",
+   "fieldtype": "Link",
+   "label": "Sales Partner",
+   "options": "Sales Partner"
+  },
+  {
+   "depends_on": "eval: (doc.report == 'Accounts Receivable');",
+   "fieldname": "sales_person",
+   "fieldtype": "Link",
+   "label": "Sales Person",
+   "options": "Sales Person"
+  },
+  {
+   "depends_on": "eval: (doc.report == 'Accounts Receivable');",
+   "fieldname": "territory",
+   "fieldtype": "Link",
+   "label": "Territory",
+   "options": "Territory"
+  },
+  {
+   "default": "0",
+   "depends_on": "eval:(doc.report == 'Accounts Receivable');",
+   "fieldname": "based_on_payment_terms",
+   "fieldtype": "Check",
+   "label": "Based On Payment Terms"
   }
  ],
  "links": [],
- "modified": "2021-09-06 21:00:45.732505",
+ "modified": "2023-06-23 10:13:15.051950",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -14,6 +14,7 @@ from frappe.www.printview import get_print_style
 
 from erpnext import get_company_currency
 from erpnext.accounts.party import get_party_account_currency
+from erpnext.accounts.report.accounts_receivable.accounts_receivable import execute as get_ar_soa
 from erpnext.accounts.report.accounts_receivable_summary.accounts_receivable_summary import (
 	execute as get_ageing,
 )
@@ -42,29 +43,10 @@ class ProcessStatementOfAccounts(Document):
 def get_report_pdf(doc, consolidated=True):
 	statement_dict = {}
 	ageing = ""
-	base_template_path = "frappe/www/printview.html"
-	template_path = (
-		"erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html"
-	)
 
 	for entry in doc.customers:
 		if doc.include_ageing:
-			ageing_filters = frappe._dict(
-				{
-					"company": doc.company,
-					"report_date": doc.to_date,
-					"ageing_based_on": doc.ageing_based_on,
-					"range1": 30,
-					"range2": 60,
-					"range3": 90,
-					"range4": 120,
-					"customer": entry.customer,
-				}
-			)
-			col1, ageing = get_ageing(ageing_filters)
-
-			if ageing:
-				ageing[0]["ageing_based_on"] = doc.ageing_based_on
+			ageing = set_ageing(doc, entry)
 
 		tax_id = frappe.get_doc("Customer", entry.customer).tax_id
 		presentation_currency = (
@@ -72,59 +54,25 @@ def get_report_pdf(doc, consolidated=True):
 			or doc.currency
 			or get_company_currency(doc.company)
 		)
-		if doc.letter_head:
-			from frappe.www.printview import get_letter_head
 
-			letter_head = get_letter_head(doc, 0)
+		filters = get_common_filters(doc)
 
-		filters = frappe._dict(
-			{
-				"from_date": doc.from_date,
-				"to_date": doc.to_date,
-				"company": doc.company,
-				"finance_book": doc.finance_book if doc.finance_book else None,
-				"account": [doc.account] if doc.account else None,
-				"party_type": "Customer",
-				"party": [entry.customer],
-				"party_name": [entry.customer_name] if entry.customer_name else None,
-				"presentation_currency": presentation_currency,
-				"group_by": doc.group_by,
-				"currency": doc.currency,
-				"cost_center": [cc.cost_center_name for cc in doc.cost_center],
-				"project": [p.project_name for p in doc.project],
-				"show_opening_entries": 0,
-				"include_default_book_entries": 0,
-				"tax_id": tax_id if tax_id else None,
-			}
-		)
-		col, res = get_soa(filters)
+		if doc.report == "General Ledger":
+			filters.update(get_gl_filters(doc, entry, tax_id, presentation_currency))
+		else:
+			filters.update(get_ar_filters(doc, entry))
 
-		for x in [0, -2, -1]:
-			res[x]["account"] = res[x]["account"].replace("'", "")
+		if doc.report == "General Ledger":
+			col, res = get_soa(filters)
+			for x in [0, -2, -1]:
+				res[x]["account"] = res[x]["account"].replace("'", "")
+			if len(res) == 3:
+				continue
+		else:
+			ar_res = get_ar_soa(filters)
+			col, res = ar_res[0], ar_res[1]
 
-		if len(res) == 3:
-			continue
-
-		html = frappe.render_template(
-			template_path,
-			{
-				"filters": filters,
-				"data": res,
-				"ageing": ageing[0] if (doc.include_ageing and ageing) else None,
-				"letter_head": letter_head if doc.letter_head else None,
-				"terms_and_conditions": frappe.db.get_value(
-					"Terms and Conditions", doc.terms_and_conditions, "terms"
-				)
-				if doc.terms_and_conditions
-				else None,
-			},
-		)
-
-		html = frappe.render_template(
-			base_template_path,
-			{"body": html, "css": get_print_style(), "title": "Statement For " + entry.customer},
-		)
-		statement_dict[entry.customer] = html
+		statement_dict[entry.customer] = get_html(doc, filters, entry, col, res, ageing)
 
 	if not bool(statement_dict):
 		return False
@@ -137,6 +85,110 @@ def get_report_pdf(doc, consolidated=True):
 		return statement_dict
 
 
+def set_ageing(doc, entry):
+	ageing_filters = frappe._dict(
+		{
+			"company": doc.company,
+			"report_date": doc.to_date,
+			"ageing_based_on": doc.ageing_based_on,
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+			"customer": entry.customer,
+		}
+	)
+	col1, ageing = get_ageing(ageing_filters)
+
+	if ageing:
+		ageing[0]["ageing_based_on"] = doc.ageing_based_on
+
+	return ageing
+
+
+def get_common_filters(doc):
+	return frappe._dict(
+		{
+			"company": doc.company,
+			"finance_book": doc.finance_book if doc.finance_book else None,
+			"account": [doc.account] if doc.account else None,
+			"cost_center": [cc.cost_center_name for cc in doc.cost_center],
+		}
+	)
+
+
+def get_gl_filters(doc, entry, tax_id, presentation_currency):
+	return {
+		"from_date": doc.from_date,
+		"to_date": doc.to_date,
+		"party_type": "Customer",
+		"party": [entry.customer],
+		"party_name": [entry.customer_name] if entry.customer_name else None,
+		"presentation_currency": presentation_currency,
+		"group_by": doc.group_by,
+		"currency": doc.currency,
+		"project": [p.project_name for p in doc.project],
+		"show_opening_entries": 0,
+		"include_default_book_entries": 0,
+		"tax_id": tax_id if tax_id else None,
+		"show_net_values_in_party_account": doc.show_net_values_in_party_account,
+	}
+
+
+def get_ar_filters(doc, entry):
+	return {
+		"report_date": doc.posting_date if doc.posting_date else None,
+		"customer_name": entry.customer,
+		"payment_terms_template": doc.payment_terms_template if doc.payment_terms_template else None,
+		"sales_partner": doc.sales_partner if doc.sales_partner else None,
+		"sales_person": doc.sales_person if doc.sales_person else None,
+		"territory": doc.territory if doc.territory else None,
+		"based_on_payment_terms": doc.based_on_payment_terms,
+		"report_name": "Accounts Receivable",
+		"ageing_based_on": doc.ageing_based_on,
+		"range1": 30,
+		"range2": 60,
+		"range3": 90,
+		"range4": 120,
+	}
+
+
+def get_html(doc, filters, entry, col, res, ageing):
+	base_template_path = "frappe/www/printview.html"
+	template_path = (
+		"erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html"
+		if doc.report == "General Ledger"
+		else "erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts_accounts_receivable.html"
+	)
+
+	if doc.letter_head:
+		from frappe.www.printview import get_letter_head
+
+		letter_head = get_letter_head(doc, 0)
+
+	html = frappe.render_template(
+		template_path,
+		{
+			"filters": filters,
+			"data": res,
+			"report": {"report_name": doc.report, "columns": col},
+			"ageing": ageing[0] if (doc.include_ageing and ageing) else None,
+			"letter_head": letter_head if doc.letter_head else None,
+			"terms_and_conditions": frappe.db.get_value(
+				"Terms and Conditions", doc.terms_and_conditions, "terms"
+			)
+			if doc.terms_and_conditions
+			else None,
+		},
+	)
+
+	html = frappe.render_template(
+		base_template_path,
+		{"body": html, "css": get_print_style(), "title": "Statement For " + entry.customer},
+	)
+	return html
+
+
 def get_customers_based_on_territory_or_customer_group(customer_collection, collection_name):
 	fields_dict = {
 		"Customer Group": "customer_group",
@@ -327,7 +379,7 @@ def send_emails(document_name, from_scheduler=False):
 				queue="short",
 				method=frappe.sendmail,
 				recipients=recipients,
-				sender=frappe.session.user,
+				sender=doc.sender or frappe.session.user,
 				cc=cc,
 				subject=subject,
 				message=message,

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts_accounts_receivable.html

@@ -0,0 +1,348 @@
+<style>
+	.print-format {
+		padding: 4mm;
+		font-size: 8.0pt !important;
+	}
+	.print-format td {
+		vertical-align:middle !important;
+	}
+	</style>
+
+	<h2 class="text-center" style="margin-top:0">{{ _(report.report_name) }}</h2>
+	<h4 class="text-center">
+		{% if (filters.customer_name) %}
+			{{ filters.customer_name }}
+		{% else %}
+			{{ filters.customer ~ filters.supplier }}
+		{% endif %}
+	</h4>
+	<h6 class="text-center">
+			{% if (filters.tax_id) %}
+			{{ _("Tax Id: ") }}{{ filters.tax_id }}
+			{% endif %}
+	</h6>
+	<h5 class="text-center">
+		{{ _(filters.ageing_based_on) }}
+		{{ _("Until") }}
+		{{ frappe.format(filters.report_date, 'Date') }}
+	</h5>
+
+	<div class="clearfix">
+		<div class="pull-left">
+		{% if(filters.payment_terms) %}
+			<strong>{{ _("Payment Terms") }}:</strong> {{ filters.payment_terms }}
+		{% endif %}
+		</div>
+		<div class="pull-right">
+		{% if(filters.credit_limit) %}
+			<strong>{{ _("Credit Limit") }}:</strong> {{ frappe.utils.fmt_money(filters.credit_limit) }}
+		{% endif %}
+		</div>
+	</div>
+
+	{% if(filters.show_future_payments) %}
+		{% set balance_row = data.slice(-1).pop() %}
+		{% for i in report.columns %}
+			{% if i.fieldname == 'age' %}
+				{% set elem = i %}
+			{% endif %}
+		{% endfor %}
+		{% set start = report.columns.findIndex(elem) %}
+		{% set range1 = report.columns[start].label %}
+		{% set range2 = report.columns[start+1].label %}
+		{% set range3 = report.columns[start+2].label %}
+		{% set range4 = report.columns[start+3].label %}
+		{% set range5 = report.columns[start+4].label %}
+		{% set range6 = report.columns[start+5].label %}
+
+		{% if(balance_row) %}
+		<table class="table table-bordered table-condensed">
+			<caption class="text-right">(Amount in {{ data[0]["currency"] ~ "" }})</caption>
+				<colgroup>
+					<col style="width: 30mm;">
+					<col style="width: 18mm;">
+					<col style="width: 18mm;">
+					<col style="width: 18mm;">
+					<col style="width: 18mm;">
+					<col style="width: 18mm;">
+					<col style="width: 18mm;">
+					<col style="width: 18mm;">
+				</colgroup>
+
+			<thead>
+				<tr>
+					<th>{{ _(" ") }}</th>
+					<th>{{ _(range1) }}</th>
+					<th>{{ _(range2) }}</th>
+					<th>{{ _(range3) }}</th>
+					<th>{{ _(range4) }}</th>
+					<th>{{ _(range5) }}</th>
+					<th>{{ _(range6) }}</th>
+					<th>{{ _("Total") }}</th>
+				</tr>
+			</thead>
+			<tbody>
+				<tr>
+					<td>{{ _("Total Outstanding") }}</td>
+					<td class="text-right">
+						{{ format_number(balance_row["age"], null, 2) }}
+					</td>
+					<td class="text-right">
+						{{ frappe.utils.fmt_money(balance_row["range1"], data[data.length-1]["currency"]) }}
+					</td>
+					<td class="text-right">
+						{{ frappe.utils.fmt_money(balance_row["range2"], data[data.length-1]["currency"]) }}
+					</td>
+					<td class="text-right">
+						{{ frappe.utils.fmt_money(balance_row["range3"], data[data.length-1]["currency"]) }}
+					</td>
+					<td class="text-right">
+						{{ frappe.utils.fmt_money(balance_row["range4"], data[data.length-1]["currency"]) }}
+					</td>
+					<td class="text-right">
+						{{ frappe.utils.fmt_money(balance_row["range5"], data[data.length-1]["currency"]) }}
+					</td>
+					<td class="text-right">
+						{{ frappe.utils.fmt_money(flt(balance_row["outstanding"]), data[data.length-1]["currency"]) }}
+					</td>
+				</tr>
+					<td>{{ _("Future Payments") }}</td>
+					<td></td>
+					<td></td>
+					<td></td>
+					<td></td>
+					<td></td>
+					<td></td>
+					<td class="text-right">
+						{{ frappe.utils.fmt_money(flt(balance_row[("future_amount")]), data[data.length-1]["currency"]) }}
+					</td>
+				<tr class="cvs-footer">
+					<th class="text-left">{{ _("Cheques Required") }}</th>
+					<th></th>
+					<th></th>
+					<th></th>
+					<th></th>
+					<th></th>
+					<th></th>
+					<th class="text-right">
+						{{ frappe.utils.fmt_money(flt(balance_row["outstanding"] - balance_row[("future_amount")]), data[data.length-1]["currency"]) }}</th>
+				</tr>
+			</tbody>
+
+		</table>
+		{% endif %}
+	{% endif %}
+	<table class="table table-bordered">
+		<thead>
+			<tr>
+				{% if(report.report_name == "Accounts Receivable" or report.report_name == "Accounts Payable") %}
+					<th style="width: 10%">{{ _("Date") }}</th>
+					<th style="width: 4%">{{ _("Age (Days)") }}</th>
+
+					{% if(report.report_name == "Accounts Receivable" and filters.show_sales_person) %}
+						<th style="width: 14%">{{ _("Reference") }}</th>
+						<th style="width: 10%">{{ _("Sales Person") }}</th>
+					{% else %}
+						<th style="width: 24%">{{ _("Reference") }}</th>
+					{% endif %}
+					{% if not(filters.show_future_payments) %}
+						<th style="width: 20%">
+						{% if (filters.customer or filters.supplier or filters.customer_name) %}
+							{{ _("Remarks") }}
+						{% else %}
+							{{ _("Party") }}
+						{% endif %}
+						</th>
+					{% endif %}
+					<th style="width: 10%; text-align: right">{{ _("Invoiced Amount") }}</th>
+					{% if not(filters.show_future_payments) %}
+						<th style="width: 10%; text-align: right">{{ _("Paid Amount") }}</th>
+						<th style="width: 10%; text-align: right">
+							{% if report.report_name == "Accounts Receivable" %}
+								{{ _('Credit Note') }}
+							{% else %}
+								{{ _('Debit Note') }}
+							{% endif %}
+						</th>
+					{% endif %}
+					<th style="width: 10%; text-align: right">{{ _("Outstanding Amount") }}</th>
+					{% if(filters.show_future_payments) %}
+						{% if(report.report_name == "Accounts Receivable") %}
+							<th style="width: 12%">{{ _("Customer LPO No.") }}</th>
+						{% endif %}
+						<th style="width: 10%">{{ _("Future Payment Ref") }}</th>
+						<th style="width: 10%">{{ _("Future Payment Amount") }}</th>
+						<th style="width: 10%">{{ _("Remaining Balance") }}</th>
+					{% endif %}
+				{% else %}
+					<th style="width: 40%">
+						{% if (filters.customer or filters.supplier or filters.customer_name) %}
+							{{ _("Remarks")}}
+						{% else %}
+							{{ _("Party") }}
+						{% endif %}
+					</th>
+					<th style="width: 15%">{{ _("Total Invoiced Amount") }}</th>
+					<th style="width: 15%">{{ _("Total Paid Amount") }}</th>
+					<th style="width: 15%">
+						{% if report.report_name == "Accounts Receivable Summary" %}
+							{{ _('Credit Note Amount') }}
+						{% else %}
+							{{ _('Debit Note Amount') }}
+						{% endif %}
+					</th>
+					<th style="width: 15%">{{ _("Total Outstanding Amount") }}</th>
+				{% endif %}
+			</tr>
+		</thead>
+		<tbody>
+			{% for i in range(data|length) %}
+				<tr>
+				{% if(report.report_name == "Accounts Receivable" or report.report_name == "Accounts Payable") %}
+					{% if(data[i]["party"]) %}
+						<td>{{ (data[i]["posting_date"]) }}</td>
+						<td style="text-align: right">{{ data[i]["age"] }}</td>
+						<td>
+							{% if not(filters.show_future_payments) %}
+								{{ data[i]["voucher_type"] }}
+								<br>
+							{% endif %}
+							{{ data[i]["voucher_no"] }}
+						</td>
+
+						{% if(report.report_name == "Accounts Receivable" and filters.show_sales_person) %}
+						<td>{{ data[i]["sales_person"] }}</td>
+						{% endif %}
+
+						{% if not (filters.show_future_payments) %}
+						<td>
+							{% if(not(filters.customer or filters.supplier or filters.customer_name)) %}
+								{{ data[i]["party"] }}
+								{% if(data[i]["customer_name"] and data[i]["customer_name"] != data[i]["party"]) %}
+									<br> {{ data[i]["customer_name"] }}
+								{% elif(data[i]["supplier_name"] != data[i]["party"]) %}
+									<br> {{ data[i]["supplier_name"] }}
+								{% endif %}
+							{% endif %}
+							<div>
+							{% if data[i]["remarks"] %}
+								{{ _("Remarks") }}:
+								{{ data[i]["remarks"] }}
+							{% endif %}
+							</div>
+						</td>
+						{% endif %}
+
+						<td style="text-align: right">
+							{{ frappe.utils.fmt_money(data[i]["invoiced"], currency=data[i]["currency"]) }}</td>
+
+						{% if not(filters.show_future_payments) %}
+							<td style="text-align: right">
+								{{ frappe.utils.fmt_money(data[i]["paid"], currency=data[i]["currency"]) }}</td>
+							<td style="text-align: right">
+								{{ frappe.utils.fmt_money(data[i]["credit_note"], currency=data[i]["currency"]) }}</td>
+						{% endif %}
+						<td style="text-align: right">
+							{{ frappe.utils.fmt_money(data[i]["outstanding"], currency=data[i]["currency"]) }}</td>
+
+						{% if(filters.show_future_payments) %}
+							{% if(report.report_name == "Accounts Receivable") %}
+								<td style="text-align: right">
+									{{ data[i]["po_no"] }}</td>
+							{% endif %}
+							<td style="text-align: right">{{ data[i]["future_ref"] }}</td>
+							<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["future_amount"], currency=data[i]["currency"]) }}</td>
+							<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["remaining_balance"], currency=data[i]["currency"]) }}</td>
+						{% endif %}
+					{% else %}
+						<td></td>
+						{% if not(filters.show_future_payments) %}
+						<td></td>
+						{% endif %}
+						{% if(report.report_name == "Accounts Receivable" and filters.show_sales_person) %}
+						<td></td>
+						{% endif %}
+						<td></td>
+						<td style="text-align: right"><b>{{ _("Total") }}</b></td>
+						<td style="text-align: right">
+							{{ frappe.utils.fmt_money(data[i]["invoiced"], data[i]["currency"]) }}</td>
+
+						{% if not(filters.show_future_payments) %}
+							<td style="text-align: right">
+								{{ frappe.utils.fmt_money(data[i]["paid"], currency=data[i]["currency"]) }}</td>
+							<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["credit_note"], currency=data[i]["currency"]) }} </td>
+						{% endif %}
+						<td style="text-align: right">
+							{{ frappe.utils.fmt_money(data[i]["outstanding"], currency=data[i]["currency"]) }}</td>
+
+						{% if(filters.show_future_payments) %}
+							{% if(report.report_name == "Accounts Receivable") %}
+								<td style="text-align: right">
+									{{ data[i]["po_no"] }}</td>
+							{% endif %}
+							<td style="text-align: right">{{ data[i]["future_ref"] }}</td>
+							<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["future_amount"], currency=data[i]["currency"]) }}</td>
+							<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["remaining_balance"], currency=data[i]["currency"]) }}</td>
+						{% endif %}
+					{% endif %}
+				{% else %}
+					{% if(data[i]["party"] or "&nbsp;") %}
+						{% if not(data[i]["is_total_row"]) %}
+							<td>
+								{% if(not(filters.customer | filters.supplier)) %}
+									{{ data[i]["party"] }}
+									{% if(data[i]["customer_name"] and data[i]["customer_name"] != data[i]["party"]) %}
+										<br> {{ data[i]["customer_name"] }}
+									{% elif(data[i]["supplier_name"] != data[i]["party"]) %}
+										<br> {{ data[i]["supplier_name"] }}
+									{% endif %}
+								{% endif %}
+								<br>{{ _("Remarks") }}:
+								{{ data[i]["remarks"] }}
+							</td>
+						{% else %}
+							<td><b>{{ _("Total") }}</b></td>
+						{% endif %}
+						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["invoiced"], currency=data[i]["currency"]) }}</td>
+						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["paid"], currency=data[i]["currency"]) }}</td>
+						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["credit_note"], currency=data[i]["currency"]) }}</td>
+						<td style="text-align: right">{{ frappe.utils.fmt_money(data[i]["outstanding"], currency=data[i]["currency"]) }}</td>
+					{% endif %}
+				{% endif %}
+				</tr>
+			{% endfor %}
+			<td></td>
+			<td></td>
+			<td></td>
+			<td></td>
+			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="invoiced"), currency=data[0]["currency"]) }}</b></td>
+			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="paid"), currency=data[0]["currency"]) }}</b></td>
+			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="credit_note"), currency=data[0]["currency"]) }}</b></td>
+			<td style="text-align: right"><b>{{ frappe.utils.fmt_money(data|sum(attribute="outstanding"), currency=data[0]["currency"]) }}</b></td>
+		</tbody>
+	</table>
+	<br>
+	{% if ageing %}
+	<h4 class="text-center">{{ _("Ageing Report based on ") }} {{ ageing.ageing_based_on }}
+		{{ _("up to " ) }}  {{ frappe.format(filters.report_date, 'Date')}}
+	</h4>
+	<table class="table table-bordered">
+		<thead>
+			<tr>
+				<th style="width: 25%">30 Days</th>
+				<th style="width: 25%">60 Days</th>
+				<th style="width: 25%">90 Days</th>
+				<th style="width: 25%">120 Days</th>
+			</tr>
+		</thead>
+		<tbody>
+			<tr>
+				<td>{{ frappe.utils.fmt_money(ageing.range1, currency=data[0]["currency"]) }}</td>
+				<td>{{ frappe.utils.fmt_money(ageing.range2, currency=data[0]["currency"]) }}</td>
+				<td>{{ frappe.utils.fmt_money(ageing.range3, currency=data[0]["currency"]) }}</td>
+				<td>{{ frappe.utils.fmt_money(ageing.range4, currency=data[0]["currency"]) }}</td>
+			</tr>
+		</tbody>
+	</table>
+	{% endif %}
+	<p class="text-right text-muted">{{ _("Printed On ") }}{{ frappe.utils.now() }}</p>

erpnext/accounts/doctype/process_statement_of_accounts_customer/process_statement_of_accounts_customer.json

@@ -27,7 +27,7 @@
   },
   {
    "fieldname": "billing_email",
-   "fieldtype": "Read Only",
+   "fieldtype": "Data",
    "in_list_view": 1,
    "label": "Billing Email"
   },
@@ -41,7 +41,7 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2023-03-13 00:12:34.508086",
+ "modified": "2023-04-26 13:02:41.964499",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts Customer",

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -303,7 +303,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 
 	apply_tds(frm) {
 		var me = this;
-
+		me.frm.set_value("tax_withheld_vouchers", []);
 		if (!me.frm.doc.apply_tds) {
 			me.frm.set_value("tax_withholding_category", '');
 			me.frm.set_df_property("tax_withholding_category", "hidden", 1);

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -89,6 +89,7 @@
   "column_break8",
   "grand_total",
   "rounding_adjustment",
+  "use_company_roundoff_cost_center",
   "rounded_total",
   "in_words",
   "total_advance",
@@ -546,6 +547,7 @@
    "depends_on": "update_stock",
    "fieldname": "rejected_warehouse",
    "fieldtype": "Link",
+   "ignore_user_permissions": 1,
    "label": "Rejected Warehouse",
    "no_copy": 1,
    "options": "Warehouse",
@@ -1368,6 +1370,7 @@
    "options": "Warehouse",
    "print_hide": 1,
    "print_width": "50px",
+   "ignore_user_permissions": 1,
    "width": "50px"
   },
   {
@@ -1559,13 +1562,19 @@
    "fieldname": "only_include_allocated_payments",
    "fieldtype": "Check",
    "label": "Only Include Allocated Payments"
+  },
+  {
+   "default": "0",
+   "fieldname": "use_company_roundoff_cost_center",
+   "fieldtype": "Check",
+   "label": "Use Company Default Round Off Cost Center"
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-04-03 22:57:14.074982",
+ "modified": "2023-07-04 17:23:59.145031",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -978,7 +978,7 @@ class PurchaseInvoice(BuyingController):
 
 	def make_precision_loss_gl_entry(self, gl_entries):
 		round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(
-			self.company, "Purchase Invoice", self.name
+			self.company, "Purchase Invoice", self.name, self.use_company_roundoff_cost_center
 		)
 
 		precision_loss = self.get("base_net_total") - flt(
@@ -992,7 +992,9 @@ class PurchaseInvoice(BuyingController):
 						"account": round_off_account,
 						"against": self.supplier,
 						"credit": precision_loss,
-						"cost_center": self.cost_center or round_off_cost_center,
+						"cost_center": round_off_cost_center
+						if self.use_company_roundoff_cost_center
+						else self.cost_center or round_off_cost_center,
 						"remarks": _("Net total calculation precision loss"),
 					}
 				)
@@ -1386,7 +1388,7 @@ class PurchaseInvoice(BuyingController):
 			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, "Purchase Invoice", self.name
+				self.company, "Purchase Invoice", self.name, self.use_company_roundoff_cost_center
 			)
 
 			gl_entries.append(
@@ -1396,7 +1398,9 @@ class PurchaseInvoice(BuyingController):
 						"against": self.supplier,
 						"debit_in_account_currency": self.rounding_adjustment,
 						"debit": self.base_rounding_adjustment,
-						"cost_center": self.cost_center or round_off_cost_center,
+						"cost_center": round_off_cost_center
+						if self.use_company_roundoff_cost_center
+						else (self.cost_center or round_off_cost_center),
 					},
 					item=self,
 				)

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -637,13 +637,6 @@ class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 			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 (
@@ -1662,6 +1655,21 @@ class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 
 		self.assertTrue(return_pi.docstatus == 1)
 
+	def test_gl_entries_for_standalone_debit_note(self):
+		make_purchase_invoice(qty=5, rate=500, update_stock=True)
+
+		returned_inv = make_purchase_invoice(qty=-5, rate=5, update_stock=True, is_return=True)
+
+		# override the rate with valuation rate
+		sle = frappe.get_all(
+			"Stock Ledger Entry",
+			fields=["stock_value_difference", "actual_qty"],
+			filters={"voucher_no": returned_inv.name},
+		)[0]
+
+		rate = flt(sle.stock_value_difference) / flt(sle.actual_qty)
+		self.assertAlmostEqual(returned_inv.items[0].rate, rate)
+
 
 def check_gl_entries(doc, voucher_no, expected_gle, posting_date):
 	gl_entries = frappe.db.sql(

erpnext/accounts/doctype/purchase_invoice_item/purchase_invoice_item.json

@@ -176,6 +176,7 @@
    "fieldname": "received_qty",
    "fieldtype": "Float",
    "label": "Received Qty",
+   "no_copy": 1,
    "read_only": 1
   },
   {
@@ -420,6 +421,7 @@
   {
    "fieldname": "rejected_warehouse",
    "fieldtype": "Link",
+   "ignore_user_permissions": 1,
    "label": "Rejected Warehouse",
    "options": "Warehouse"
   },
@@ -880,7 +882,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2022-11-29 13:01:20.438217",
+ "modified": "2023-07-04 17:22:21.501152",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice Item",
@@ -890,4 +892,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -334,6 +334,7 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 	}
 
 	make_inter_company_invoice() {
+		let me = this;
 		frappe.model.open_mapped_doc({
 			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.make_inter_company_purchase_invoice",
 			frm: me.frm
@@ -669,19 +670,6 @@ frappe.ui.form.on('Sales Invoice', {
 			}
 		}
 
-		// expense account
-		frm.fields_dict['items'].grid.get_field('expense_account').get_query = function(doc) {
-			if (erpnext.is_perpetual_inventory_enabled(doc.company)) {
-				return {
-					filters: {
-						'report_type': 'Profit and Loss',
-						'company': doc.company,
-						"is_group": 0
-					}
-				}
-			}
-		}
-
 		// discount account
 		frm.fields_dict['items'].grid.get_field('discount_account').get_query = function(doc) {
 			return {

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -79,6 +79,7 @@
   "column_break5",
   "grand_total",
   "rounding_adjustment",
+  "use_company_roundoff_cost_center",
   "rounded_total",
   "in_words",
   "total_advance",
@@ -319,6 +320,7 @@
   },
   {
    "default": "0",
+   "depends_on": "eval: !doc.is_debit_note",
    "fieldname": "is_return",
    "fieldtype": "Check",
    "hide_days": 1,
@@ -1958,6 +1960,7 @@
   },
   {
    "default": "0",
+   "depends_on": "eval: !doc.is_return",
    "description": "Issue a debit note with 0 qty against an existing Sales Invoice",
    "fieldname": "is_debit_note",
    "fieldtype": "Check",
@@ -2134,6 +2137,12 @@
    "fieldname": "only_include_allocated_payments",
    "fieldtype": "Check",
    "label": "Only Include Allocated Payments"
+  },
+  {
+   "default": "0",
+   "fieldname": "use_company_roundoff_cost_center",
+   "fieldtype": "Check",
+   "label": "Use Company default Cost Center for Round off"
   }
  ],
  "icon": "fa fa-file-text",
@@ -2146,7 +2155,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2023-04-03 22:55:14.206473",
+ "modified": "2023-06-19 16:02:05.309332",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -1012,10 +1012,16 @@ class SalesInvoice(SellingController):
 
 	def check_prev_docstatus(self):
 		for d in self.get("items"):
-			if d.sales_order and frappe.db.get_value("Sales Order", d.sales_order, "docstatus") != 1:
+			if (
+				d.sales_order
+				and frappe.db.get_value("Sales Order", d.sales_order, "docstatus", cache=True) != 1
+			):
 				frappe.throw(_("Sales Order {0} is not submitted").format(d.sales_order))
 
-			if d.delivery_note and frappe.db.get_value("Delivery Note", d.delivery_note, "docstatus") != 1:
+			if (
+				d.delivery_note
+				and frappe.db.get_value("Delivery Note", d.delivery_note, "docstatus", cache=True) != 1
+			):
 				throw(_("Delivery Note {0} is not submitted").format(d.delivery_note))
 
 	def make_gl_entries(self, gl_entries=None, from_repost=False):
@@ -1179,7 +1185,12 @@ class SalesInvoice(SellingController):
 
 					if self.is_return:
 						fixed_asset_gl_entries = get_gl_entries_on_asset_regain(
-							asset, item.base_net_amount, item.finance_book, self.get("doctype"), self.get("name")
+							asset,
+							item.base_net_amount,
+							item.finance_book,
+							self.get("doctype"),
+							self.get("name"),
+							self.get("posting_date"),
 						)
 						asset.db_set("disposal_date", None)
 
@@ -1194,7 +1205,12 @@ class SalesInvoice(SellingController):
 							asset.reload()
 
 						fixed_asset_gl_entries = get_gl_entries_on_asset_disposal(
-							asset, item.base_net_amount, item.finance_book, self.get("doctype"), self.get("name")
+							asset,
+							item.base_net_amount,
+							item.finance_book,
+							self.get("doctype"),
+							self.get("name"),
+							self.get("posting_date"),
 						)
 						asset.db_set("disposal_date", self.posting_date)
 
@@ -1450,7 +1466,7 @@ class SalesInvoice(SellingController):
 			and not self.is_internal_transfer()
 		):
 			round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(
-				self.company, "Sales Invoice", self.name
+				self.company, "Sales Invoice", self.name, self.use_company_roundoff_cost_center
 			)
 
 			gl_entries.append(
@@ -1462,7 +1478,9 @@ class SalesInvoice(SellingController):
 							self.rounding_adjustment, self.precision("rounding_adjustment")
 						),
 						"credit": flt(self.base_rounding_adjustment, self.precision("base_rounding_adjustment")),
-						"cost_center": self.cost_center or round_off_cost_center,
+						"cost_center": round_off_cost_center
+						if self.use_company_roundoff_cost_center
+						else (self.cost_center or round_off_cost_center),
 					},
 					item=self,
 				)

erpnext/accounts/doctype/shareholder/shareholder.json

@@ -1,4 +1,5 @@
 {
+ "actions": [],
  "autoname": "naming_series:",
  "creation": "2017-12-25 16:50:53.878430",
  "doctype": "DocType",
@@ -111,11 +112,12 @@
    "read_only": 1
   }
  ],
- "modified": "2019-11-17 23:24:11.395882",
+ "links": [],
+ "modified": "2023-04-10 22:02:20.406087",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Shareholder",
- "name_case": "Title Case",
+ "naming_rule": "By \"Naming Series\" field",
  "owner": "Administrator",
  "permissions": [
   {
@@ -158,6 +160,7 @@
  "search_fields": "folio_no",
  "sort_field": "modified",
  "sort_order": "DESC",
+ "states": [],
  "title_field": "title",
  "track_changes": 1
 }

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py

@@ -3,9 +3,11 @@
 
 
 import frappe
-from frappe import _
+from frappe import _, qb
 from frappe.model.document import Document
-from frappe.utils import cint, getdate
+from frappe.query_builder import Criterion
+from frappe.query_builder.functions import Abs, Sum
+from frappe.utils import cint, flt, getdate
 
 
 class TaxWithholdingCategory(Document):
@@ -215,7 +217,7 @@ def get_tax_row_for_tds(tax_details, tax_amount):
 	}
 
 
-def get_lower_deduction_certificate(tax_details, pan_no):
+def get_lower_deduction_certificate(company, tax_details, pan_no):
 	ldc_name = frappe.db.get_value(
 		"Lower Deduction Certificate",
 		{
@@ -223,6 +225,7 @@ def get_lower_deduction_certificate(tax_details, pan_no):
 			"tax_withholding_category": tax_details.tax_withholding_category,
 			"valid_from": (">=", tax_details.from_date),
 			"valid_upto": ("<=", tax_details.to_date),
+			"company": company,
 		},
 		"name",
 	)
@@ -255,7 +258,7 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 	tax_amount = 0
 
 	if party_type == "Supplier":
-		ldc = get_lower_deduction_certificate(tax_details, pan_no)
+		ldc = get_lower_deduction_certificate(inv.company, tax_details, pan_no)
 		if tax_deducted:
 			net_total = inv.tax_withholding_net_total
 			if ldc:
@@ -301,7 +304,7 @@ def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
 		"docstatus": 1,
 	}
 
-	if not tax_details.get("consider_party_ledger_amount") and doctype != "Sales Invoice":
+	if doctype != "Sales Invoice":
 		filters.update(
 			{"apply_tds": 1, "tax_withholding_category": tax_details.get("tax_withholding_category")}
 		)
@@ -345,26 +348,33 @@ def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
 def get_advance_vouchers(
 	parties, company=None, from_date=None, to_date=None, party_type="Supplier"
 ):
-	# for advance vouchers, debit and credit is reversed
-	dr_or_cr = "debit" if party_type == "Supplier" else "credit"
+	"""
+	Use Payment Ledger to fetch unallocated Advance Payments
+	"""
 
-	filters = {
-		dr_or_cr: [">", 0],
-		"is_opening": "No",
-		"is_cancelled": 0,
-		"party_type": party_type,
-		"party": ["in", parties],
-	}
+	ple = qb.DocType("Payment Ledger Entry")
 
-	if party_type == "Customer":
-		filters.update({"against_voucher": ["is", "not set"]})
+	conditions = []
+
+	conditions.append(ple.amount.lt(0))
+	conditions.append(ple.delinked == 0)
+	conditions.append(ple.party_type == party_type)
+	conditions.append(ple.party.isin(parties))
+	conditions.append(ple.voucher_no == ple.against_voucher_no)
 
 	if company:
-		filters["company"] = company
-	if from_date and to_date:
-		filters["posting_date"] = ["between", (from_date, to_date)]
+		conditions.append(ple.company == company)
 
-	return frappe.get_all("GL Entry", filters=filters, distinct=1, pluck="voucher_no") or [""]
+	if from_date and to_date:
+		conditions.append(ple.posting_date[from_date:to_date])
+
+	advances = (
+		qb.from_(ple).select(ple.voucher_no).distinct().where(Criterion.all(conditions)).run(as_list=1)
+	)
+	if advances:
+		advances = [x[0] for x in advances]
+
+	return advances
 
 
 def get_taxes_deducted_on_advances_allocated(inv, tax_details):
@@ -498,6 +508,7 @@ def get_tds_amount(ldc, parties, inv, tax_details, tax_deducted, vouchers):
 
 def get_tcs_amount(parties, inv, tax_details, vouchers, adv_vouchers):
 	tcs_amount = 0
+	ple = qb.DocType("Payment Ledger Entry")
 
 	# sum of debit entries made from sales invoices
 	invoiced_amt = (
@@ -515,18 +526,20 @@ def get_tcs_amount(parties, inv, tax_details, vouchers, adv_vouchers):
 	)
 
 	# sum of credit entries made from PE / JV with unset 'against voucher'
+
+	conditions = []
+	conditions.append(ple.amount.lt(0))
+	conditions.append(ple.delinked == 0)
+	conditions.append(ple.party.isin(parties))
+	conditions.append(ple.voucher_no == ple.against_voucher_no)
+	conditions.append(ple.company == inv.company)
+
+	advances = (
+		qb.from_(ple).select(Abs(Sum(ple.amount))).where(Criterion.all(conditions)).run(as_list=1)
+	)
+
 	advance_amt = (
-		frappe.db.get_value(
-			"GL Entry",
-			{
-				"is_cancelled": 0,
-				"party": ["in", parties],
-				"company": inv.company,
-				"voucher_no": ["in", adv_vouchers],
-			},
-			"sum(credit)",
-		)
-		or 0.0
+		qb.from_(ple).select(Abs(Sum(ple.amount))).where(Criterion.all(conditions)).run()[0][0] or 0.0
 	)
 
 	# sum of credit entries made from sales invoice
@@ -568,7 +581,14 @@ def get_tds_amount_from_ldc(ldc, parties, tax_details, posting_date, net_total):
 	tds_amount = 0
 	limit_consumed = frappe.db.get_value(
 		"Purchase Invoice",
-		{"supplier": ("in", parties), "apply_tds": 1, "docstatus": 1},
+		{
+			"supplier": ("in", parties),
+			"apply_tds": 1,
+			"docstatus": 1,
+			"tax_withholding_category": ldc.tax_withholding_category,
+			"posting_date": ("between", (ldc.valid_from, ldc.valid_upto)),
+			"company": ldc.company,
+		},
 		"sum(tax_withholding_net_total)",
 	)
 
@@ -583,10 +603,10 @@ def get_tds_amount_from_ldc(ldc, parties, tax_details, posting_date, net_total):
 
 
 def get_ltds_amount(current_amount, deducted_amount, certificate_limit, rate, tax_details):
-	if current_amount < (certificate_limit - deducted_amount):
+	if certificate_limit - flt(deducted_amount) - flt(current_amount) >= 0:
 		return current_amount * rate / 100
 	else:
-		ltds_amount = certificate_limit - deducted_amount
+		ltds_amount = certificate_limit - flt(deducted_amount)
 		tds_amount = current_amount - ltds_amount
 
 		return ltds_amount * rate / 100 + tds_amount * tax_details.rate / 100
@@ -597,9 +617,9 @@ def is_valid_certificate(
 ):
 	valid = False
 
-	if (
-		getdate(valid_from) <= getdate(posting_date) <= getdate(valid_upto)
-	) and certificate_limit > deducted_amount:
+	available_amount = flt(certificate_limit) - flt(deducted_amount)
+
+	if (getdate(valid_from) <= getdate(posting_date) <= getdate(valid_upto)) and available_amount > 0:
 		valid = True
 
 	return valid

erpnext/accounts/doctype/tax_withholding_category/test_tax_withholding_category.py

@@ -4,6 +4,7 @@
 import unittest
 
 import frappe
+from frappe.tests.utils import change_settings
 from frappe.utils import today
 
 from erpnext.accounts.utils import get_fiscal_year
@@ -110,9 +111,9 @@ class TestTaxWithholdingCategory(unittest.TestCase):
 		invoices.append(pi1)
 
 		# Cumulative threshold is 30000
-		# Threshold calculation should be on both the invoices
-		# TDS should be applied only on 1000
-		self.assertEqual(pi1.taxes[0].tax_amount, 1000)
+		# Threshold calculation should be only on the Second invoice
+		# Second didn't breach, no TDS should be applied
+		self.assertEqual(pi1.taxes, [])
 
 		for d in reversed(invoices):
 			d.cancel()
@@ -152,6 +153,64 @@ class TestTaxWithholdingCategory(unittest.TestCase):
 		for d in reversed(invoices):
 			d.cancel()
 
+	@change_settings(
+		"Accounts Settings",
+		{"unlink_payment_on_cancellation_of_invoice": 1},
+	)
+	def test_tcs_on_unallocated_advance_payments(self):
+		frappe.db.set_value(
+			"Customer", "Test TCS Customer", "tax_withholding_category", "Cumulative Threshold TCS"
+		)
+
+		vouchers = []
+
+		# create advance payment
+		pe = create_payment_entry(
+			payment_type="Receive", party_type="Customer", party="Test TCS Customer", paid_amount=20000
+		)
+		pe.paid_from = "Debtors - _TC"
+		pe.paid_to = "Cash - _TC"
+		pe.submit()
+		vouchers.append(pe)
+
+		# create invoice
+		si1 = create_sales_invoice(customer="Test TCS Customer", rate=5000)
+		si1.submit()
+		vouchers.append(si1)
+
+		# reconcile
+		pr = frappe.get_doc("Payment Reconciliation")
+		pr.company = "_Test Company"
+		pr.party_type = "Customer"
+		pr.party = "Test TCS Customer"
+		pr.receivable_payable_account = "Debtors - _TC"
+		pr.get_unreconciled_entries()
+		invoices = [x.as_dict() for x in pr.get("invoices")]
+		payments = [x.as_dict() for x in pr.get("payments")]
+		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+		pr.reconcile()
+
+		# make another invoice
+		# sum of unallocated amount from payment entry and this sales invoice will breach cumulative threashold
+		# TDS should be calculated
+		si2 = create_sales_invoice(customer="Test TCS Customer", rate=15000)
+		si2.submit()
+		vouchers.append(si2)
+
+		si3 = create_sales_invoice(customer="Test TCS Customer", rate=10000)
+		si3.submit()
+		vouchers.append(si3)
+
+		# assert tax collection on total invoice amount created until now
+		tcs_charged = sum([d.base_tax_amount for d in si2.taxes if d.account_head == "TCS - _TC"])
+		tcs_charged += sum([d.base_tax_amount for d in si3.taxes if d.account_head == "TCS - _TC"])
+		self.assertEqual(tcs_charged, 1500)
+
+		# cancel invoice and payments to avoid clashing
+		for d in reversed(vouchers):
+			d.reload()
+			d.cancel()
+
 	def test_tds_calculation_on_net_total(self):
 		frappe.db.set_value(
 			"Supplier", "Test TDS Supplier4", "tax_withholding_category", "Cumulative Threshold TDS"

erpnext/accounts/form_tour/sales_invoice/sales_invoice.json

@@ -0,0 +1,41 @@
+{
+ "creation": "2023-05-23 09:58:17.235916",
+ "docstatus": 0,
+ "doctype": "Form Tour",
+ "first_document": 0,
+ "idx": 0,
+ "include_name_field": 0,
+ "is_standard": 1,
+ "modified": "2023-05-23 13:10:56.227127",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Sales Invoice",
+ "owner": "Administrator",
+ "reference_doctype": "Sales Invoice",
+ "save_on_complete": 1,
+ "steps": [
+  {
+   "description": "Select a customer for whom this invoice is being prepared.",
+   "fieldname": "customer",
+   "fieldtype": "Link",
+   "has_next_condition": 1,
+   "is_table_field": 0,
+   "label": "Customer",
+   "next_step_condition": "eval: doc.customer",
+   "position": "Right",
+   "title": "Select Customer"
+  },
+  {
+   "child_doctype": "Sales Invoice Item",
+   "description": "Select item that you have sold along with quantity and rate.",
+   "fieldname": "items",
+   "fieldtype": "Table",
+   "has_next_condition": 0,
+   "is_table_field": 0,
+   "parent_fieldname": "items",
+   "position": "Top",
+   "title": "Select Item"
+  }
+ ],
+ "title": "Sales Invoice"
+}

erpnext/accounts/general_ledger.py

@@ -13,14 +13,11 @@ import erpnext
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
 )
+from erpnext.accounts.doctype.accounting_period.accounting_period import ClosedAccountingPeriod
 from erpnext.accounts.doctype.budget.budget import validate_expense_against_budget
 from erpnext.accounts.utils import create_payment_ledger_entry
 
 
-class ClosedAccountingPeriod(frappe.ValidationError):
-	pass
-
-
 def make_gl_entries(
 	gl_map,
 	cancel=False,
@@ -300,6 +297,9 @@ def save_entries(gl_map, adv_adj, update_outstanding, from_repost=False):
 
 	if gl_map:
 		check_freezing_date(gl_map[0]["posting_date"], adv_adj)
+		is_opening = any(d.get("is_opening") == "Yes" for d in gl_map)
+		if gl_map[0]["voucher_type"] != "Period Closing Voucher":
+			validate_against_pcv(is_opening, gl_map[0]["posting_date"], gl_map[0]["company"])
 
 	for entry in gl_map:
 		make_entry(entry, adv_adj, update_outstanding, from_repost)
@@ -472,7 +472,9 @@ def update_accounting_dimensions(round_off_gle):
 			round_off_gle[dimension] = dimension_values.get(dimension)
 
 
-def get_round_off_account_and_cost_center(company, voucher_type, voucher_no):
+def get_round_off_account_and_cost_center(
+	company, voucher_type, voucher_no, use_company_default=False
+):
 	round_off_account, round_off_cost_center = frappe.get_cached_value(
 		"Company", company, ["round_off_account", "round_off_cost_center"]
 	) or [None, None]
@@ -480,7 +482,7 @@ def get_round_off_account_and_cost_center(company, voucher_type, voucher_no):
 	meta = frappe.get_meta(voucher_type)
 
 	# Give first preference to parent cost center for round off GLE
-	if meta.has_field("cost_center"):
+	if not use_company_default and 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
@@ -519,6 +521,9 @@ def make_reverse_gl_entries(
 		)
 		validate_accounting_period(gl_entries)
 		check_freezing_date(gl_entries[0]["posting_date"], adv_adj)
+
+		is_opening = any(d.get("is_opening") == "Yes" for d in gl_entries)
+		validate_against_pcv(is_opening, gl_entries[0]["posting_date"], gl_entries[0]["company"])
 		set_as_cancel(gl_entries[0]["voucher_type"], gl_entries[0]["voucher_no"])
 
 		for entry in gl_entries:
@@ -566,6 +571,28 @@ def check_freezing_date(posting_date, adv_adj=False):
 				)
 
 
+def validate_against_pcv(is_opening, posting_date, company):
+	if is_opening and frappe.db.exists(
+		"Period Closing Voucher", {"docstatus": 1, "company": company}
+	):
+		frappe.throw(
+			_("Opening Entry can not be created after Period Closing Voucher is created."),
+			title=_("Invalid Opening Entry"),
+		)
+
+	last_pcv_date = frappe.db.get_value(
+		"Period Closing Voucher", {"docstatus": 1, "company": company}, "max(posting_date)"
+	)
+
+	if last_pcv_date and getdate(posting_date) <= getdate(last_pcv_date):
+		message = _("Books have been closed till the period ending on {0}").format(
+			formatdate(last_pcv_date)
+		)
+		message += "</br >"
+		message += _("You cannot create/amend any accounting entries till this date.")
+		frappe.throw(message, title=_("Period Closed"))
+
+
 def set_as_cancel(voucher_type, voucher_no):
 	"""
 	Set is_cancelled=1 in all original gl entries for the voucher

erpnext/accounts/party.py

@@ -2,6 +2,8 @@
 # License: GNU General Public License v3. See license.txt
 
 
+from typing import Optional
+
 import frappe
 from frappe import _, msgprint, scrub
 from frappe.contacts.doctype.address.address import (
@@ -259,6 +261,8 @@ def set_address_details(
 	)
 
 	if doctype in TRANSACTION_TYPES:
+		# required to set correct region
+		frappe.flags.company = company
 		get_regional_address_details(party_details, doctype, company)
 
 	return party_address, shipping_address
@@ -645,12 +649,12 @@ def set_taxes(
 	else:
 		args.update(get_party_details(party, party_type))
 
-	if party_type in ("Customer", "Lead"):
+	if party_type in ("Customer", "Lead", "Prospect"):
 		args.update({"tax_type": "Sales"})
 
-		if party_type == "Lead":
+		if party_type in ["Lead", "Prospect"]:
 			args["customer"] = None
-			del args["lead"]
+			del args[frappe.scrub(party_type)]
 	else:
 		args.update({"tax_type": "Purchase"})
 
@@ -848,7 +852,7 @@ def get_dashboard_info(party_type, party, loyalty_program=None):
 	return company_wise_info
 
 
-def get_party_shipping_address(doctype, name):
+def get_party_shipping_address(doctype: str, name: str) -> Optional[str]:
 	"""
 	Returns an Address name (best guess) for the given doctype and name for which `address_type == 'Shipping'` is true.
 	and/or `is_shipping_address = 1`.
@@ -859,37 +863,41 @@ def get_party_shipping_address(doctype, name):
 	:param name: Party name
 	:return: String
 	"""
-	out = frappe.db.sql(
-		"SELECT dl.parent "
-		"from `tabDynamic Link` dl join `tabAddress` ta on dl.parent=ta.name "
-		"where "
-		"dl.link_doctype=%s "
-		"and dl.link_name=%s "
-		"and dl.parenttype='Address' "
-		"and ifnull(ta.disabled, 0) = 0 and"
-		"(ta.address_type='Shipping' or ta.is_shipping_address=1) "
-		"order by ta.is_shipping_address desc, ta.address_type desc limit 1",
-		(doctype, name),
+	shipping_addresses = frappe.get_all(
+		"Address",
+		filters=[
+			["Dynamic Link", "link_doctype", "=", doctype],
+			["Dynamic Link", "link_name", "=", name],
+			["disabled", "=", 0],
+		],
+		or_filters=[
+			["is_shipping_address", "=", 1],
+			["address_type", "=", "Shipping"],
+		],
+		pluck="name",
+		limit=1,
+		order_by="is_shipping_address DESC",
 	)
-	if out:
-		return out[0][0]
-	else:
-		return ""
+
+	return shipping_addresses[0] if shipping_addresses else None
 
 
 def get_partywise_advanced_payment_amount(
-	party_type, posting_date=None, future_payment=0, company=None
+	party_type, posting_date=None, future_payment=0, company=None, party=None
 ):
 	cond = "1=1"
 	if posting_date:
 		if future_payment:
-			cond = "posting_date <= '{0}' OR DATE(creation) <= '{0}' " "".format(posting_date)
+			cond = "(posting_date <= '{0}' OR DATE(creation) <= '{0}')" "".format(posting_date)
 		else:
 			cond = "posting_date <= '{0}'".format(posting_date)
 
 	if company:
 		cond += "and company = {0}".format(frappe.db.escape(company))
 
+	if party:
+		cond += "and party = {0}".format(frappe.db.escape(party))
+
 	data = frappe.db.sql(
 		""" SELECT party, sum({0}) as amount
 		FROM `tabGL Entry`
@@ -901,36 +909,36 @@ def get_partywise_advanced_payment_amount(
 		),
 		party_type,
 	)
-
 	if data:
 		return frappe._dict(data)
 
 
-def get_default_contact(doctype, name):
+def get_default_contact(doctype: str, name: str) -> Optional[str]:
 	"""
-	Returns default contact for the given doctype and name.
-	Can be ordered by `contact_type` to either is_primary_contact or is_billing_contact.
+	Returns contact name only if there is a primary contact for given doctype and name.
+
+	Else returns None
+
+	:param doctype: Party Doctype
+	:param name: Party name
+	:return: String
 	"""
-	out = frappe.db.sql(
-		"""
-			SELECT dl.parent, c.is_primary_contact, c.is_billing_contact
-			FROM `tabDynamic Link` dl
-			INNER JOIN `tabContact` c ON c.name = dl.parent
-			WHERE
-				dl.link_doctype=%s AND
-				dl.link_name=%s AND
-				dl.parenttype = 'Contact'
-			ORDER BY is_primary_contact DESC, is_billing_contact DESC
-		""",
-		(doctype, name),
+	contacts = frappe.get_all(
+		"Contact",
+		filters=[
+			["Dynamic Link", "link_doctype", "=", doctype],
+			["Dynamic Link", "link_name", "=", name],
+		],
+		or_filters=[
+			["is_primary_contact", "=", 1],
+			["is_billing_contact", "=", 1],
+		],
+		pluck="name",
+		limit=1,
+		order_by="is_primary_contact DESC, is_billing_contact DESC",
 	)
-	if out:
-		try:
-			return out[0][0]
-		except Exception:
-			return None
-	else:
-		return None
+
+	return contacts[0] if contacts else None
 
 
 def add_party_account(party_type, party, company, account):

erpnext/accounts/report/accounts_receivable/accounts_receivable.html

@@ -284,4 +284,4 @@
 			{% } %}
 		</tbody>
 	</table>
-	<p class="text-right text-muted">{{ __("Printed On ") }}{%= frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string()) %}</p>
+	<p class="text-right text-muted">{{ __("Printed On ") }}{%= frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string()) %}</p>

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -181,6 +181,16 @@ class ReceivablePayableReport(object):
 				return
 
 		key = (ple.against_voucher_type, ple.against_voucher_no, ple.party)
+
+		# If payment is made against credit note
+		# and credit note is made against a Sales Invoice
+		# then consider the payment against original sales invoice.
+		if ple.against_voucher_type in ("Sales Invoice", "Purchase Invoice"):
+			if ple.against_voucher_no in self.return_entries:
+				return_against = self.return_entries.get(ple.against_voucher_no)
+				if return_against:
+					key = (ple.against_voucher_type, return_against, ple.party)
+
 		row = self.voucher_balance.get(key)
 
 		if not row:
@@ -610,7 +620,7 @@ class ReceivablePayableReport(object):
 
 	def get_return_entries(self):
 		doctype = "Sales Invoice" if self.party_type == "Customer" else "Purchase Invoice"
-		filters = {"is_return": 1, "docstatus": 1}
+		filters = {"is_return": 1, "docstatus": 1, "company": self.filters.company}
 		party_field = scrub(self.filters.party_type)
 		if self.filters.get(party_field):
 			filters.update({party_field: self.filters.get(party_field)})

erpnext/accounts/report/accounts_receivable/test_accounts_receivable.py

@@ -210,6 +210,67 @@ class TestAccountsReceivable(FrappeTestCase):
 			],
 		)
 
+	def test_payment_against_credit_note(self):
+		"""
+		Payment against credit/debit note should be considered against the parent invoice
+		"""
+		company = "_Test Company 2"
+		customer = "_Test Customer 2"
+
+		si1 = make_sales_invoice()
+
+		pe = get_payment_entry("Sales Invoice", si1.name, bank_account="Cash - _TC2")
+		pe.paid_from = "Debtors - _TC2"
+		pe.insert()
+		pe.submit()
+
+		cr_note = make_credit_note(si1.name)
+
+		si2 = make_sales_invoice()
+
+		# manually link cr_note with si2 using journal entry
+		je = frappe.new_doc("Journal Entry")
+		je.company = company
+		je.voucher_type = "Credit Note"
+		je.posting_date = today()
+
+		debit_account = "Debtors - _TC2"
+		debit_entry = {
+			"account": debit_account,
+			"party_type": "Customer",
+			"party": customer,
+			"debit": 100,
+			"debit_in_account_currency": 100,
+			"reference_type": cr_note.doctype,
+			"reference_name": cr_note.name,
+			"cost_center": "Main - _TC2",
+		}
+		credit_entry = {
+			"account": debit_account,
+			"party_type": "Customer",
+			"party": customer,
+			"credit": 100,
+			"credit_in_account_currency": 100,
+			"reference_type": si2.doctype,
+			"reference_name": si2.name,
+			"cost_center": "Main - _TC2",
+		}
+
+		je.append("accounts", debit_entry)
+		je.append("accounts", credit_entry)
+		je = je.save().submit()
+
+		filters = {
+			"company": company,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+		}
+		report = execute(filters)
+		self.assertEqual(report[1], [])
+
 
 def make_sales_invoice(no_payment_schedule=False, do_not_submit=False):
 	frappe.set_user("Administrator")
@@ -256,7 +317,7 @@ def make_payment(docname):
 
 
 def make_credit_note(docname):
-	create_sales_invoice(
+	credit_note = create_sales_invoice(
 		company="_Test Company 2",
 		customer="_Test Customer 2",
 		currency="EUR",
@@ -269,3 +330,5 @@ def make_credit_note(docname):
 		is_return=1,
 		return_against=docname,
 	)
+
+	return credit_note

erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py

@@ -31,7 +31,6 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 
 	def get_data(self, args):
 		self.data = []
-
 		self.receivables = ReceivablePayableReport(self.filters).run(args)[1]
 
 		self.get_party_total(args)
@@ -42,6 +41,7 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 				self.filters.report_date,
 				self.filters.show_future_payments,
 				self.filters.company,
+				party=self.filters.get(scrub(self.party_type)),
 			)
 			or {}
 		)
@@ -74,6 +74,9 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 				row.gl_balance = gl_balance_map.get(party)
 				row.diff = flt(row.outstanding) - flt(row.gl_balance)
 
+			if self.filters.show_future_payments:
+				row.remaining_balance = flt(row.outstanding) - flt(row.future_amount)
+
 			self.data.append(row)
 
 	def get_party_total(self, args):
@@ -106,6 +109,7 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 					"range4": 0.0,
 					"range5": 0.0,
 					"total_due": 0.0,
+					"future_amount": 0.0,
 					"sales_person": [],
 				}
 			),
@@ -151,6 +155,10 @@ class AccountsReceivableSummary(ReceivablePayableReport):
 
 		self.setup_ageing_columns()
 
+		if self.filters.show_future_payments:
+			self.add_column(label=_("Future Payment Amount"), fieldname="future_amount")
+			self.add_column(label=_("Remaining Balance"), fieldname="remaining_balance")
+
 		if self.party_type == "Customer":
 			self.add_column(
 				label=_("Territory"), fieldname="territory", fieldtype="Link", options="Territory"

erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py

@@ -114,28 +114,6 @@ def get_assets(filters):
 			   sum(results.depreciation_eliminated_during_the_period) as depreciation_eliminated_during_the_period,
 			   sum(results.depreciation_amount_during_the_period) as depreciation_amount_during_the_period
 		from (SELECT a.asset_category,
-				   ifnull(sum(case when ds.schedule_date < %(from_date)s and (ifnull(a.disposal_date, 0) = 0 or a.disposal_date >= %(from_date)s) then
-								   ds.depreciation_amount
-							  else
-								   0
-							  end), 0) as accumulated_depreciation_as_on_from_date,
-				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date >= %(from_date)s
-										and a.disposal_date <= %(to_date)s and ds.schedule_date <= a.disposal_date then
-								   ds.depreciation_amount
-							  else
-								   0
-							  end), 0) as depreciation_eliminated_during_the_period,
-				   ifnull(sum(case when ds.schedule_date >= %(from_date)s and ds.schedule_date <= %(to_date)s
-										and (ifnull(a.disposal_date, 0) = 0 or ds.schedule_date <= a.disposal_date) then
-								   ds.depreciation_amount
-							  else
-								   0
-							  end), 0) as depreciation_amount_during_the_period
-			from `tabAsset` a, `tabDepreciation Schedule` ds
-			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s and a.name = ds.parent and ifnull(ds.journal_entry, '') != ''
-			group by a.asset_category
-			union
-			SELECT a.asset_category,
 				   ifnull(sum(case when gle.posting_date < %(from_date)s and (ifnull(a.disposal_date, 0) = 0 or a.disposal_date >= %(from_date)s) then
 								   gle.debit
 							  else
@@ -160,7 +138,7 @@ def get_assets(filters):
 				aca.parent = a.asset_category and aca.company_name = %(company)s
 			join `tabCompany` company on
 				company.name = %(company)s
-			where a.docstatus=1 and a.company=%(company)s and a.calculate_depreciation=0 and a.purchase_date <= %(to_date)s and gle.debit != 0 and gle.is_cancelled = 0 and gle.account = ifnull(aca.depreciation_expense_account, company.depreciation_expense_account)
+			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s and gle.debit != 0 and gle.is_cancelled = 0 and gle.account = ifnull(aca.depreciation_expense_account, company.depreciation_expense_account)
 			group by a.asset_category
 			union
 			SELECT a.asset_category,

erpnext/accounts/report/balance_sheet/balance_sheet.py

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

erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py

@@ -80,7 +80,7 @@ def get_entries(filters):
 	payment_entries = frappe.db.sql(
 		"""SELECT
 			"Payment Entry", name, posting_date, reference_no, clearance_date, party,
-			if(paid_from=%(account)s, paid_amount * -1, received_amount)
+			if(paid_from=%(account)s, ((paid_amount * -1) - total_taxes_and_charges) , received_amount)
 		FROM
 			`tabPayment Entry`
 		WHERE
@@ -152,5 +152,5 @@ def get_entries(filters):
 
 	return sorted(
 		journal_entries + payment_entries + loan_disbursements + loan_repayments,
-		key=lambda k: k[2] or getdate(nowdate()),
+		key=lambda k: k[2].strftime("%H%M%S") or getdate(nowdate()),
 	)

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js

@@ -49,7 +49,7 @@ frappe.require("assets/erpnext/js/financial_statements.js", function() {
 				"label": __("Start Year"),
 				"fieldtype": "Link",
 				"options": "Fiscal Year",
-				"default": frappe.defaults.get_user_default("fiscal_year"),
+				"default": erpnext.utils.get_fiscal_year(frappe.datetime.get_today()),
 				"reqd": 1,
 				on_change: () => {
 					frappe.model.with_doc("Fiscal Year", frappe.query_report.get_filter_value('from_fiscal_year'), function(r) {
@@ -65,7 +65,7 @@ frappe.require("assets/erpnext/js/financial_statements.js", function() {
 				"label": __("End Year"),
 				"fieldtype": "Link",
 				"options": "Fiscal Year",
-				"default": frappe.defaults.get_user_default("fiscal_year"),
+				"default": erpnext.utils.get_fiscal_year(frappe.datetime.get_today()),
 				"reqd": 1,
 				on_change: () => {
 					frappe.model.with_doc("Fiscal Year", frappe.query_report.get_filter_value('to_fiscal_year'), function(r) {
@@ -139,7 +139,7 @@ frappe.require("assets/erpnext/js/financial_statements.js", function() {
 			return value;
 		},
 		onload: function() {
-			let fiscal_year = frappe.defaults.get_user_default("fiscal_year")
+			let fiscal_year = erpnext.utils.get_fiscal_year(frappe.datetime.get_today());
 
 			frappe.model.with_doc("Fiscal Year", fiscal_year, function(r) {
 				var fy = frappe.model.get_doc("Fiscal Year", fiscal_year);

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py

@@ -118,7 +118,6 @@ def get_balance_sheet_data(fiscal_year, companies, columns, filters):
 		liability,
 		equity,
 		provisional_profit_loss,
-		total_credit,
 		company_currency,
 		filters,
 		True,
@@ -656,7 +655,7 @@ def set_gl_entries_by_account(
 		if filters and filters.get("presentation_currency") != d.default_currency:
 			currency_info["company"] = d.name
 			currency_info["company_currency"] = d.default_currency
-			convert_to_presentation_currency(gl_entries, currency_info, filters.get("company"))
+			convert_to_presentation_currency(gl_entries, currency_info)
 
 		for entry in gl_entries:
 			if entry.account_number:

erpnext/accounts/report/deferred_revenue_and_expense/deferred_revenue_and_expense.js

@@ -48,7 +48,7 @@ function get_filters() {
 			"label": __("Start Year"),
 			"fieldtype": "Link",
 			"options": "Fiscal Year",
-			"default": frappe.defaults.get_user_default("fiscal_year"),
+			"default": erpnext.utils.get_fiscal_year(frappe.datetime.get_today()),
 			"reqd": 1
 		},
 		{
@@ -56,7 +56,7 @@ function get_filters() {
 			"label": __("End Year"),
 			"fieldtype": "Link",
 			"options": "Fiscal Year",
-			"default": frappe.defaults.get_user_default("fiscal_year"),
+			"default": erpnext.utils.get_fiscal_year(frappe.datetime.get_today()),
 			"reqd": 1
 		},
 		{
@@ -100,7 +100,7 @@ frappe.query_reports["Deferred Revenue and Expense"] = {
 		return default_formatter(value, row, column, data);
 	},
 	onload: function(report){
-		let fiscal_year = frappe.defaults.get_user_default("fiscal_year");
+		let fiscal_year = erpnext.utils.get_fiscal_year(frappe.datetime.get_today());
 
 		frappe.model.with_doc("Fiscal Year", fiscal_year, function(r) {
 			var fy = frappe.model.get_doc("Fiscal Year", fiscal_year);

erpnext/accounts/report/deferred_revenue_and_expense/deferred_revenue_and_expense.py

@@ -4,9 +4,10 @@
 import frappe
 from frappe import _, qb
 from frappe.query_builder import Column, functions
-from frappe.utils import add_days, date_diff, flt, get_first_day, get_last_day, rounded
+from frappe.utils import add_days, date_diff, flt, get_first_day, get_last_day, getdate, rounded
 
 from erpnext.accounts.report.financial_statements import get_period_list
+from erpnext.accounts.utils import get_fiscal_year
 
 
 class Deferred_Item(object):
@@ -226,7 +227,7 @@ class Deferred_Revenue_and_Expense_Report(object):
 
 		# If no filters are provided, get user defaults
 		if not filters:
-			fiscal_year = frappe.get_doc("Fiscal Year", frappe.defaults.get_user_default("fiscal_year"))
+			fiscal_year = frappe.get_doc("Fiscal Year", get_fiscal_year(date=getdate()))
 			self.filters = frappe._dict(
 				{
 					"company": frappe.defaults.get_user_default("Company"),

erpnext/accounts/report/deferred_revenue_and_expense/test_deferred_revenue_and_expense.py

@@ -10,6 +10,7 @@ from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sal
 from erpnext.accounts.report.deferred_revenue_and_expense.deferred_revenue_and_expense import (
 	Deferred_Revenue_and_Expense_Report,
 )
+from erpnext.accounts.utils import get_fiscal_year
 from erpnext.buying.doctype.supplier.test_supplier import create_supplier
 from erpnext.stock.doctype.item.test_item import create_item
 
@@ -116,7 +117,7 @@ class TestDeferredRevenueAndExpense(unittest.TestCase):
 		pda.submit()
 
 		# execute report
-		fiscal_year = frappe.get_doc("Fiscal Year", frappe.defaults.get_user_default("fiscal_year"))
+		fiscal_year = frappe.get_doc("Fiscal Year", get_fiscal_year(date="2021-05-01"))
 		self.filters = frappe._dict(
 			{
 				"company": frappe.defaults.get_user_default("Company"),
@@ -209,7 +210,7 @@ class TestDeferredRevenueAndExpense(unittest.TestCase):
 		pda.submit()
 
 		# execute report
-		fiscal_year = frappe.get_doc("Fiscal Year", frappe.defaults.get_user_default("fiscal_year"))
+		fiscal_year = frappe.get_doc("Fiscal Year", get_fiscal_year(date="2021-05-01"))
 		self.filters = frappe._dict(
 			{
 				"company": frappe.defaults.get_user_default("Company"),
@@ -297,7 +298,7 @@ class TestDeferredRevenueAndExpense(unittest.TestCase):
 		pda.submit()
 
 		# execute report
-		fiscal_year = frappe.get_doc("Fiscal Year", frappe.defaults.get_user_default("fiscal_year"))
+		fiscal_year = frappe.get_doc("Fiscal Year", get_fiscal_year(date="2021-05-01"))
 		self.filters = frappe._dict(
 			{
 				"company": frappe.defaults.get_user_default("Company"),