chore(release): Bumped to Version 14.74.8

## [14.74.8](https://github.com/frappe/erpnext/compare/v14.74.7...v14.74.8) (2024-10-30)

### Bug Fixes

* add company filter for project ([d3e29fe](d3e29fe828))
* add parenttype clause to invoice tax query in sales_register report ([cbe704c](cbe704c73c))
* added validation for UOM must be whole number (backport [#43710](https://github.com/frappe/erpnext/issues/43710)) ([#43711](https://github.com/frappe/erpnext/issues/43711)) ([aaae81f](aaae81f7e8))
* basic rate not editable in Stock Entry Detail (backport [#43837](https://github.com/frappe/erpnext/issues/43837)) ([#43839](https://github.com/frappe/erpnext/issues/43839)) ([51c1d03](51c1d032ba))
* calculate tds with net amount when invoice exceeds single threshold amount (backport [#43869](https://github.com/frappe/erpnext/issues/43869)) ([#43919](https://github.com/frappe/erpnext/issues/43919)) ([55c5f30](55c5f30d54))
* do not check for payment terms details for return invoices. ([fd63ace](fd63ace6c7))
* do not set payment terms for return invoices ([bd34a67](bd34a67871))
* get stock accounts from the doc instead of db in validate_stock_accounts ([ad04610](ad04610c94))
* hide payment terms for return and paid purchase invoices ([78db8c0](78db8c0029))
* not able to submit stock entry ([#43890](https://github.com/frappe/erpnext/issues/43890)) ([0742e6e](0742e6e193))
* purchase return validation issue ([#43871](https://github.com/frappe/erpnext/issues/43871)) ([a7cc7b2](a7cc7b28c0))
* remarks field in payment reconciliation ([93243b1](93243b1d95))
* **RFQ:** make strings translatable (backport [#43843](https://github.com/frappe/erpnext/issues/43843)) ([#43847](https://github.com/frappe/erpnext/issues/43847)) ([895f1bf](895f1bff01))
* set bill_no before `against_voucher` gets concatenated ([2f3c3d5](2f3c3d5519))
* work order finish button not showing (backport [#43875](https://github.com/frappe/erpnext/issues/43875)) ([#43877](https://github.com/frappe/erpnext/issues/43877)) ([76530de](76530de786))

.github/helper/documentation.py

@@ -10,7 +10,6 @@ WEBSITE_REPOS = [
 
 DOCUMENTATION_DOMAINS = [
 	"docs.erpnext.com",
-	"docs.frappe.io",
 	"frappeframework.com",
 ]
 

.github/release.yml

@@ -1,4 +0,0 @@
-changelog:
-  exclude:
-    labels:
-      - skip-release-notes

.github/workflows/label-base-on-title.yml

@@ -1,30 +0,0 @@
-name: "Auto-label PRs based on title"
-
-on:
-  pull_request_target:
-    types: [opened, reopened]
-
-jobs:
-  add-label-if-prefix-matches:
-    permissions:
-      contents: read
-      pull-requests: write
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check PR title and add label if it matches prefixes
-        uses: actions/github-script@v7
-        continue-on-error: true
-        with:
-          script: |
-            const title = context.payload.pull_request.title.toLowerCase();
-            const prefixes = ['chore', 'ci', 'style', 'test', 'refactor'];
-            
-            // Check if the PR title starts with any of the prefixes
-            if (prefixes.some(prefix => title.startsWith(prefix))) {
-              await github.rest.issues.addLabels({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.payload.pull_request.number,
-                labels: ['skip-release-notes']
-              });
-            }

.github/workflows/linters.yml

@@ -9,16 +9,15 @@ jobs:
     name: linters
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
 
       - name: Set up Python 3.10
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v2
         with:
           python-version: '3.10'
-          cache: pip
 
       - name: Install and Run Pre-commit
-        uses: pre-commit/action@v3.0.0
+        uses: pre-commit/action@v2.0.3
 
       - name: Download Semgrep rules
         run: git clone --depth 1 https://github.com/frappe/semgrep-rules.git frappe-semgrep-rules

.github/workflows/patch.yml

@@ -16,7 +16,7 @@ concurrency:
 
 jobs:
   test:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     timeout-minutes: 60
 
     name: Patch Test
@@ -59,7 +59,7 @@ jobs:
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
       - name: Cache pip
-        uses: actions/cache@v4
+        uses: actions/cache@v2
         with:
           path: ~/.cache/pip
           key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
@@ -68,7 +68,7 @@ jobs:
             ${{ runner.os }}-
 
       - name: Cache node modules
-        uses: actions/cache@v4
+        uses: actions/cache@v2
         env:
           cache-name: cache-node-modules
         with:
@@ -83,7 +83,7 @@ jobs:
         id: yarn-cache-dir-path
         run: echo "::set-output name=dir::$(yarn cache dir)"
 
-      - uses: actions/cache@v4
+      - uses: actions/cache@v2
         id: yarn-cache
         with:
           path: ${{ steps.yarn-cache-dir-path.outputs.dir }}

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

@@ -79,7 +79,7 @@ jobs:
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
       - name: Cache pip
-        uses: actions/cache@v4
+        uses: actions/cache@v2
         with:
           path: ~/.cache/pip
           key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
@@ -88,7 +88,7 @@ jobs:
             ${{ runner.os }}-
 
       - name: Cache node modules
-        uses: actions/cache@v4
+        uses: actions/cache@v2
         env:
           cache-name: cache-node-modules
         with:
@@ -103,7 +103,7 @@ jobs:
         id: yarn-cache-dir-path
         run: echo "::set-output name=dir::$(yarn cache dir)"
 
-      - uses: actions/cache@v4
+      - uses: actions/cache@v2
         id: yarn-cache
         with:
           path: ${{ steps.yarn-cache-dir-path.outputs.dir }}

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

@@ -66,7 +66,7 @@ jobs:
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
       - name: Cache pip
-        uses: actions/cache@v4
+        uses: actions/cache@v2
         with:
           path: ~/.cache/pip
           key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
@@ -75,7 +75,7 @@ jobs:
             ${{ runner.os }}-
 
       - name: Cache node modules
-        uses: actions/cache@v4
+        uses: actions/cache@v2
         env:
           cache-name: cache-node-modules
         with:
@@ -90,7 +90,7 @@ jobs:
         id: yarn-cache-dir-path
         run: echo "::set-output name=dir::$(yarn cache dir)"
 
-      - uses: actions/cache@v4
+      - uses: actions/cache@v2
         id: yarn-cache
         with:
           path: ${{ steps.yarn-cache-dir-path.outputs.dir }}

.pre-commit-config.yaml

@@ -1,5 +1,5 @@
 exclude: 'node_modules|.git'
-default_stages: [pre-commit]
+default_stages: [commit]
 fail_fast: false
 
 

CODEOWNERS

@@ -4,22 +4,22 @@
 # the repo. Unless a later match takes precedence,
 
 erpnext/accounts/               @deepeshgarg007 @ruthra-kumar
-erpnext/assets/                 @khushi8112 @deepeshgarg007
+erpnext/assets/                 @anandbaburajan @deepeshgarg007
 erpnext/loan_management/        @deepeshgarg007
 erpnext/regional                @deepeshgarg007 @ruthra-kumar
 erpnext/selling                 @deepeshgarg007 @ruthra-kumar
 erpnext/support/                @deepeshgarg007
 pos*                            
 
-erpnext/buying/                 @rohitwaghchaure
-erpnext/maintenance/            @rohitwaghchaure
-erpnext/manufacturing/          @rohitwaghchaure
-erpnext/quality_management/     @rohitwaghchaure
-erpnext/stock/                  @rohitwaghchaure
-erpnext/subcontracting          @rohitwaghchaure
+erpnext/buying/                 @rohitwaghchaure @s-aga-r
+erpnext/maintenance/            @rohitwaghchaure @s-aga-r
+erpnext/manufacturing/          @rohitwaghchaure @s-aga-r
+erpnext/quality_management/     @rohitwaghchaure @s-aga-r
+erpnext/stock/                  @rohitwaghchaure @s-aga-r
+erpnext/subcontracting          @rohitwaghchaure @s-aga-r
 
 erpnext/controllers/            @deepeshgarg007 @rohitwaghchaure
 erpnext/patches/                @deepeshgarg007 
 
 .github/                        @deepeshgarg007
-pyproject.toml                  @akhilnarang
+pyproject.toml                  @ankush

erpnext/__init__.py

@@ -3,7 +3,7 @@ import inspect
 
 import frappe
 
-__version__ = "14.67.1"
+__version__ = "14.74.8"
 
 
 def get_default_company(user=None):

erpnext/accounts/deferred_revenue.py

@@ -58,7 +58,7 @@ def build_conditions(process_type, account, company):
 	)
 
 	if account:
-		conditions += f"AND {deferred_account}={frappe.db.escape(account)}"
+		conditions += f"AND {deferred_account}='{frappe.db.escape(account)}'"
 	elif company:
 		conditions += f"AND p.company = {frappe.db.escape(company)}"
 

erpnext/accounts/doctype/account/account.js

@@ -94,8 +94,8 @@ frappe.ui.form.on("Account", {
 				function () {
 					frappe.route_options = {
 						account: frm.doc.name,
-						from_date: erpnext.utils.get_fiscal_year(frappe.datetime.get_today(), true)[1],
-						to_date: erpnext.utils.get_fiscal_year(frappe.datetime.get_today(), true)[2],
+						from_date: frappe.sys_defaults.year_start_date,
+						to_date: frappe.sys_defaults.year_end_date,
 						company: frm.doc.company,
 					};
 					frappe.set_route("query-report", "General Ledger");

erpnext/accounts/doctype/account/account.py

@@ -4,7 +4,7 @@
 
 import frappe
 from frappe import _, throw
-from frappe.utils import add_to_date, cint, cstr, pretty_date
+from frappe.utils import cint, cstr
 from frappe.utils.nestedset import NestedSet, get_ancestors_of, get_descendants_of
 
 import erpnext
@@ -400,7 +400,6 @@ def validate_account_number(name, account_number, company):
 
 @frappe.whitelist()
 def update_account_number(name, account_name, account_number=None, from_descendant=False):
-	_ensure_idle_system()
 	account = frappe.db.get_value("Account", name, "company", as_dict=True)
 	if not account:
 		return
@@ -421,7 +420,7 @@ def update_account_number(name, account_name, account_number=None, from_descenda
 				"name",
 			)
 
-			if old_name and not from_descendant:
+			if old_name:
 				# same account in parent company exists
 				allow_child_account_creation = _("Allow Account Creation Against Child Company")
 
@@ -462,7 +461,6 @@ def update_account_number(name, account_name, account_number=None, from_descenda
 
 @frappe.whitelist()
 def merge_account(old, new):
-	_ensure_idle_system()
 	# Validate properties before merging
 	new_account = frappe.get_cached_doc("Account", new)
 	old_account = frappe.get_cached_doc("Account", old)
@@ -516,27 +514,3 @@ def sync_update_account_number_in_child(
 
 	for d in frappe.db.get_values("Account", filters=filters, fieldname=["company", "name"], as_dict=True):
 		update_account_number(d["name"], account_name, account_number, from_descendant=True)
-
-
-def _ensure_idle_system():
-	# Don't allow renaming if accounting entries are actively being updated, there are two main reasons:
-	# 1. Correctness: It's next to impossible to ensure that renamed account is not being used *right now*.
-	# 2. Performance: Renaming requires locking out many tables entirely and severely degrades performance.
-
-	if frappe.flags.in_test:
-		return
-
-	try:
-		# We also lock inserts to GL entry table with for_update here.
-		last_gl_update = frappe.db.get_value("GL Entry", {}, "modified", for_update=True, wait=False)
-	except frappe.QueryTimeoutError:
-		# wait=False fails immediately if there's an active transaction.
-		last_gl_update = add_to_date(None, seconds=-1)
-
-	if last_gl_update > add_to_date(None, minutes=-5):
-		frappe.throw(
-			_(
-				"Last GL Entry update was done {}. This operation is not allowed while system is actively being used. Please wait for 5 minutes before retrying."
-			).format(pretty_date(last_gl_update)),
-			title=_("System In Use"),
-		)

erpnext/accounts/doctype/account/account_tree.js

@@ -279,8 +279,8 @@ frappe.treeview_settings["Account"] = {
 			click: function (node, btn) {
 				frappe.route_options = {
 					account: node.label,
-					from_date: erpnext.utils.get_fiscal_year(frappe.datetime.get_today(), true)[1],
-					to_date: erpnext.utils.get_fiscal_year(frappe.datetime.get_today(), true)[2],
+					from_date: frappe.sys_defaults.year_start_date,
+					to_date: frappe.sys_defaults.year_end_date,
 					company:
 						frappe.treeview_settings["Account"].treeview.page.fields_dict.company.get_value(),
 				};

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

@@ -98,7 +98,7 @@
                 "Office Maintenance Expenses": {},
                 "Office Rent": {},
                 "Postal Expenses": {},
-                "Print and Stationery": {},
+                "Print and Stationary": {},
                 "Rounded Off": {
                     "account_type": "Round Off"
                 },

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.json

@@ -31,8 +31,7 @@
    "label": "Reference Document Type",
    "options": "DocType",
    "read_only_depends_on": "eval:!doc.__islocal",
-   "reqd": 1,
-   "search_index": 1
+   "reqd": 1
   },
   {
    "default": "0",

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -25,7 +25,6 @@ class AccountingDimension(Document):
 			"Accounting Dimension Detail",
 			"Company",
 			"Account",
-			"Finance Book",
 		):
 			msg = _("Not allowed to create accounting dimension for {0}").format(self.document_type)
 			frappe.throw(msg)

erpnext/accounts/doctype/accounts_settings/accounts_settings.js

@@ -3,14 +3,4 @@
 
 frappe.ui.form.on("Accounts Settings", {
 	refresh: function (frm) {},
-
-	drop_ar_procedures: function (frm) {
-		frm.call({
-			doc: frm.doc,
-			method: "drop_ar_sql_procedures",
-			callback: function (r) {
-				frappe.show_alert(__("Procedures dropped"), 5);
-			},
-		});
-	},
 });

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -44,7 +44,6 @@
   "section_break_jpd0",
   "auto_reconcile_payments",
   "stale_days",
-  "exchange_gain_loss_posting_date",
   "invoicing_settings_tab",
   "accounts_transactions_settings_section",
   "over_billing_allowance",
@@ -74,13 +73,7 @@
   "remarks_section",
   "general_ledger_remarks_length",
   "column_break_lvjk",
-  "receivable_payable_remarks_length",
-  "accounts_receivable_payable_tuning_section",
-  "receivable_payable_fetch_method",
-  "column_break_ntmi",
-  "drop_ar_procedures",
-  "legacy_section",
-  "ignore_is_opening_check_for_reporting"
+  "receivable_payable_remarks_length"
  ],
  "fields": [
   {
@@ -390,7 +383,7 @@
   {
    "fieldname": "section_break_jpd0",
    "fieldtype": "Section Break",
-   "label": "Payment Reconciliation Settings"
+   "label": "Payment Reconciliations"
   },
   {
    "default": "0",
@@ -469,49 +462,6 @@
    "fieldname": "remarks_section",
    "fieldtype": "Section Break",
    "label": "Remarks Column Length"
-  },
-  {
-   "default": "Payment",
-   "description": "Only applies for Normal Payments",
-   "fieldname": "exchange_gain_loss_posting_date",
-   "fieldtype": "Select",
-   "label": "Posting Date Inheritance for Exchange Gain / Loss",
-   "options": "Invoice\nPayment\nReconciliation Date"
-  },
-  {
-   "default": "0",
-   "description": "Ignores legacy Is Opening field in GL Entry that allows adding opening balance post the system is in use while generating reports",
-   "fieldname": "ignore_is_opening_check_for_reporting",
-   "fieldtype": "Check",
-   "label": "Ignore Is Opening check for reporting"
-  },
-  {
-   "default": "Buffered Cursor",
-   "fieldname": "receivable_payable_fetch_method",
-   "fieldtype": "Select",
-   "label": "Data Fetch Method",
-   "options": "Buffered Cursor\nUnBuffered Cursor\nRaw SQL"
-  },
-  {
-   "fieldname": "accounts_receivable_payable_tuning_section",
-   "fieldtype": "Section Break",
-   "label": "Accounts Receivable / Payable Tuning"
-  },
-  {
-   "fieldname": "legacy_section",
-   "fieldtype": "Section Break",
-   "label": "Legacy Fields"
-  },
-  {
-   "fieldname": "column_break_ntmi",
-   "fieldtype": "Column Break"
-  },
-  {
-   "depends_on": "eval:doc.receivable_payable_fetch_method == \"Raw SQL\"",
-   "description": "Drops existing SQL Procedures and Function setup by Accounts Receivable report",
-   "fieldname": "drop_ar_procedures",
-   "fieldtype": "Button",
-   "label": "Drop Procedures"
   }
  ],
  "icon": "icon-cog",
@@ -519,7 +469,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2025-05-05 12:29:38.302027",
+ "modified": "2024-01-22 12:10:10.151819",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -65,11 +65,3 @@ class AccountsSettings(Document):
 	def validate_pending_reposts(self):
 		if self.acc_frozen_upto:
 			check_pending_reposting(self.acc_frozen_upto)
-
-	@frappe.whitelist()
-	def drop_ar_sql_procedures(self):
-		from erpnext.accounts.report.accounts_receivable.accounts_receivable import InitSQLProceduresForAR
-
-		frappe.db.sql(f"drop function if exists {InitSQLProceduresForAR.genkey_function_name}")
-		frappe.db.sql(f"drop procedure if exists {InitSQLProceduresForAR.init_procedure_name}")
-		frappe.db.sql(f"drop procedure if exists {InitSQLProceduresForAR.allocate_procedure_name}")

erpnext/accounts/doctype/bank_account/bank_account.json

@@ -224,6 +224,11 @@
    "link_doctype": "Bank Guarantee",
    "link_fieldname": "bank_account"
   },
+  {
+   "group": "Transactions",
+   "link_doctype": "Payroll Entry",
+   "link_fieldname": "bank_account"
+  },
   {
    "group": "Transactions",
    "link_doctype": "Bank Transaction",
@@ -250,7 +255,7 @@
    "link_fieldname": "default_bank_account"
   }
  ],
- "modified": "2024-10-30 09:41:14.113414",
+ "modified": "2024-09-24 06:57:41.292970",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account",

erpnext/accounts/doctype/bank_account/bank_account.py

@@ -21,7 +21,7 @@ class BankAccount(Document):
 		self.name = self.account_name + " - " + self.bank
 
 	def on_trash(self):
-		delete_contact_and_address("Bank Account", self.name)
+		delete_contact_and_address("BankAccount", self.name)
 
 	def validate(self):
 		self.validate_company()

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -46,6 +46,9 @@ class BankClearance(Document):
 			as_dict=1,
 		)
 
+		if self.bank_account:
+			condition += "and bank_account = %(bank_account)s"
+
 		payment_entries = frappe.db.sql(
 			f"""
 			select
@@ -67,6 +70,7 @@ class BankClearance(Document):
 				"account": self.account,
 				"from": self.from_date,
 				"to": self.to_date,
+				"bank_account": self.bank_account,
 			},
 			as_dict=1,
 		)
@@ -89,7 +93,7 @@ class BankClearance(Document):
 			.where(loan_disbursement.docstatus == 1)
 			.where(loan_disbursement.disbursement_date >= self.from_date)
 			.where(loan_disbursement.disbursement_date <= self.to_date)
-			.where(loan_disbursement.disbursement_account == self.account)
+			.where(loan_disbursement.disbursement_account.isin([self.bank_account, self.account]))
 			.orderby(loan_disbursement.disbursement_date)
 			.orderby(loan_disbursement.name, order=frappe.qb.desc)
 		)
@@ -117,7 +121,7 @@ class BankClearance(Document):
 			.where(loan_repayment.docstatus == 1)
 			.where(loan_repayment.posting_date >= self.from_date)
 			.where(loan_repayment.posting_date <= self.to_date)
-			.where(loan_repayment.payment_account == self.account)
+			.where(loan_repayment.payment_account.isin([self.bank_account, self.account]))
 		)
 
 		if not self.include_reconciled_entries:

erpnext/accounts/doctype/bank_guarantee/bank_guarantee.js

@@ -9,6 +9,13 @@ cur_frm.add_fetch("bank", "swift_number", "swift_number");
 
 frappe.ui.form.on("Bank Guarantee", {
 	setup: function (frm) {
+		frm.set_query("bank", function () {
+			return {
+				filters: {
+					company: frm.doc.company,
+				},
+			};
+		});
 		frm.set_query("bank_account", function () {
 			return {
 				filters: {

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.js

@@ -19,15 +19,10 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 	},
 
 	onload: function (frm) {
-		if (!frm.doc.company) {
-			frm.set_value("company", frappe.defaults.get_default("company"));
-		}
-
 		// Set default filter dates
 		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");
 	},
 
@@ -99,7 +94,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 
 	make_reconciliation_tool(frm) {
 		frm.get_field("reconciliation_tool_cards").$wrapper.empty();
-		if (frm.doc.company && frm.doc.bank_account && frm.doc.bank_statement_to_date) {
+		if (frm.doc.bank_account && frm.doc.bank_statement_to_date) {
 			frm.trigger("get_cleared_balance").then(() => {
 				if (
 					frm.doc.bank_account &&
@@ -115,7 +110,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 	},
 
 	get_account_opening_balance(frm) {
-		if (frm.doc.company && frm.doc.bank_account && frm.doc.bank_statement_from_date) {
+		if (frm.doc.bank_account && frm.doc.bank_statement_from_date) {
 			frappe.call({
 				method: "erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.get_account_balance",
 				args: {
@@ -130,7 +125,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 	},
 
 	get_cleared_balance(frm) {
-		if (frm.doc.company && frm.doc.bank_account && frm.doc.bank_statement_to_date) {
+		if (frm.doc.bank_account && frm.doc.bank_statement_to_date) {
 			return frappe.call({
 				method: "erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.get_account_balance",
 				args: {

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -12,7 +12,6 @@ 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.party import get_party_account
 from erpnext.accounts.report.bank_reconciliation_statement.bank_reconciliation_statement import (
 	get_amounts_not_reflected_in_system,
 	get_entries,
@@ -285,56 +284,54 @@ def create_payment_entry_bts(
 	bank_transaction = frappe.db.get_values(
 		"Bank Transaction",
 		bank_transaction_name,
-		fieldname=["name", "unallocated_amount", "deposit", "bank_account", "currency"],
+		fieldname=["name", "unallocated_amount", "deposit", "bank_account"],
 		as_dict=True,
 	)[0]
-
+	paid_amount = bank_transaction.unallocated_amount
 	payment_type = "Receive" if bank_transaction.deposit > 0.0 else "Pay"
 
-	bank_account = frappe.get_cached_value("Bank Account", bank_transaction.bank_account, "account")
-	company = frappe.get_cached_value("Account", bank_account, "company")
-	party_account = get_party_account(party_type, party, company)
+	company_account = frappe.get_value("Bank Account", bank_transaction.bank_account, "account")
+	company = frappe.get_value("Account", company_account, "company")
+	payment_entry_dict = {
+		"company": company,
+		"payment_type": payment_type,
+		"reference_no": reference_number,
+		"reference_date": reference_date,
+		"party_type": party_type,
+		"party": party,
+		"posting_date": posting_date,
+		"paid_amount": paid_amount,
+		"received_amount": paid_amount,
+	}
+	payment_entry = frappe.new_doc("Payment Entry")
 
-	bank_currency = bank_transaction.currency
-	party_currency = frappe.get_cached_value("Account", party_account, "account_currency")
+	payment_entry.update(payment_entry_dict)
 
-	exc_rate = get_exchange_rate(bank_currency, party_currency, posting_date)
+	if mode_of_payment:
+		payment_entry.mode_of_payment = mode_of_payment
+	if project:
+		payment_entry.project = project
+	if cost_center:
+		payment_entry.cost_center = cost_center
+	if payment_type == "Receive":
+		payment_entry.paid_to = company_account
+	else:
+		payment_entry.paid_from = company_account
 
-	amt_in_bank_acc_currency = bank_transaction.unallocated_amount
-	amount_in_party_currency = bank_transaction.unallocated_amount * exc_rate
-
-	pe = frappe.new_doc("Payment Entry")
-	pe.payment_type = payment_type
-	pe.company = company
-	pe.reference_no = reference_number
-	pe.reference_date = reference_date
-	pe.party_type = party_type
-	pe.party = party
-	pe.posting_date = posting_date
-	pe.paid_from = party_account if payment_type == "Receive" else bank_account
-	pe.paid_to = party_account if payment_type == "Pay" else bank_account
-	pe.paid_from_account_currency = party_currency if payment_type == "Receive" else bank_currency
-	pe.paid_to_account_currency = party_currency if payment_type == "Pay" else bank_currency
-	pe.paid_amount = amount_in_party_currency if payment_type == "Receive" else amt_in_bank_acc_currency
-	pe.received_amount = amount_in_party_currency if payment_type == "Pay" else amt_in_bank_acc_currency
-	pe.mode_of_payment = mode_of_payment
-	pe.project = project
-	pe.cost_center = cost_center
-
-	pe.validate()
+	payment_entry.validate()
 
 	if allow_edit:
-		return pe
+		return payment_entry
 
-	pe.insert()
-	pe.submit()
+	payment_entry.insert()
 
+	payment_entry.submit()
 	vouchers = json.dumps(
 		[
 			{
 				"payment_doctype": "Payment Entry",
-				"payment_name": pe.name,
-				"amount": amt_in_bank_acc_currency,
+				"payment_name": payment_entry.name,
+				"amount": paid_amount,
 			}
 		]
 	)
@@ -458,12 +455,8 @@ def get_linked_payments(
 def subtract_allocations(gl_account, vouchers):
 	"Look up & subtract any existing Bank Transaction allocations"
 	copied = []
-
-	voucher_docs = [(voucher[1], voucher[2]) for voucher in vouchers]
-	voucher_allocated_amounts = get_total_allocated_amount(voucher_docs)
-
 	for voucher in vouchers:
-		rows = voucher_allocated_amounts.get((voucher[1], voucher[2])) or []
+		rows = get_total_allocated_amount(voucher[1], voucher[2])
 		amount = None
 		for row in rows:
 			if row["gl_account"] == gl_account:

erpnext/accounts/doctype/bank_transaction/auto_match_party.py

@@ -45,41 +45,42 @@ class AutoMatchbyAccountIBAN:
 		if not (self.bank_party_account_number or self.bank_party_iban):
 			return None
 
-		return self.match_account_in_party()
+		result = self.match_account_in_party()
+		return result
 
 	def match_account_in_party(self) -> tuple | None:
-		"""
-		Returns (Party Type, Party) if a matching account is found in Bank Account or Employee:
-		1. Get party from a matching (iban/account no) Bank Account
-		2. If not found, get party from Employee with matching bank account details (iban/account no)
-		"""
-		if not (self.bank_party_account_number or self.bank_party_iban):
-			# Nothing to match
-			return 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()
 
-		# Search for a matching Bank Account that has party set
-		party_result = frappe.db.get_all(
-			"Bank Account",
-			or_filters=self.get_or_filters(),
-			filters={"party_type": ("is", "set"), "party": ("is", "set")},
-			fields=["party", "party_type"],
-			limit_page_length=1,
-		)
-		if result := party_result[0] if party_result else None:
-			return (result["party_type"], result["party"])
+		for party in parties:
+			party_result = frappe.db.get_all(
+				"Bank Account", or_filters=or_filters, pluck="party", limit_page_length=1
+			)
 
-		# If no party is found, search in Employee (since it has bank account details)
-		if employee_result := frappe.db.get_all(
-			"Employee", or_filters=self.get_or_filters("Employee"), pluck="name", limit_page_length=1
-		):
-			return ("Employee", employee_result[0])
+			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")
 
-	def get_or_filters(self, party: str | None = None) -> dict:
-		"""Return OR filters for Bank Account and IBAN"""
+				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:
-			bank_ac_field = "bank_ac_no" if party == "Employee" else "bank_account_no"
-			or_filters[bank_ac_field] = 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
@@ -99,7 +100,8 @@ class AutoMatchbyPartyNameDescription:
 		if not (self.bank_party_name or self.description):
 			return None
 
-		return self.match_party_name_desc_in_party()
+		result = self.match_party_name_desc_in_party()
+		return result
 
 	def match_party_name_desc_in_party(self) -> tuple | None:
 		"""Fuzzy search party name and/or description against parties in the system"""
@@ -108,7 +110,7 @@ class AutoMatchbyPartyNameDescription:
 
 		for party in parties:
 			filters = {"status": "Active"} if party == "Employee" else {"disabled": 0}
-			field = f"{party.lower()}_name"
+			field = party.lower() + "_name"
 			names = frappe.get_all(party, filters=filters, fields=[f"{field} as party_name", "name"])
 
 			for field in ["bank_party_name", "description"]:
@@ -135,7 +137,13 @@ class AutoMatchbyPartyNameDescription:
 		)
 		party_name, skip = self.process_fuzzy_result(result)
 
-		return ((party, party_name), skip) if party_name else (None, skip)
+		if not party_name:
+			return None, skip
+
+		return (
+			party,
+			party_name,
+		), skip
 
 	def process_fuzzy_result(self, result: list | None):
 		"""
@@ -153,8 +161,8 @@ class AutoMatchbyPartyNameDescription:
 		if len(result) == 1:
 			return (first_result[PARTY_ID] if first_result[SCORE] > CUTOFF else None), True
 
+		second_result = result[1]
 		if first_result[SCORE] > CUTOFF:
-			second_result = result[1]
 			# 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]:
@@ -166,8 +174,8 @@ class AutoMatchbyPartyNameDescription:
 
 
 def get_parties_in_order(deposit: float) -> list:
-	return (
-		["Customer", "Supplier", "Employee"]  # most -> least likely to pay us
-		if flt(deposit) > 0
-		else ["Supplier", "Employee", "Customer"]  # most -> least likely to receive from us
-	)
+	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.py

@@ -2,7 +2,6 @@
 # For license information, please see license.txt
 
 import frappe
-from frappe import _
 from frappe.model.docstatus import DocStatus
 from frappe.utils import flt
 
@@ -93,16 +92,10 @@ class BankTransaction(StatusUpdater):
 		- clear means: set the latest transaction date as clearance date
 		"""
 		remaining_amount = self.unallocated_amount
-		payment_entry_docs = [(pe.payment_document, pe.payment_entry) for pe in self.payment_entries]
-		pe_bt_allocations = get_total_allocated_amount(payment_entry_docs)
-
 		for payment_entry in self.payment_entries:
 			if payment_entry.allocated_amount == 0.0:
 				unallocated_amount, should_clear, latest_transaction = get_clearance_details(
-					self,
-					payment_entry,
-					pe_bt_allocations.get((payment_entry.payment_document, payment_entry.payment_entry))
-					or [],
+					self, payment_entry
 				)
 
 				if 0.0 == unallocated_amount:
@@ -163,17 +156,13 @@ class BankTransaction(StatusUpdater):
 		if self.party_type and self.party:
 			return
 
-		result = None
-		try:
-			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()
-		except Exception:
-			frappe.log_error(title=_("Error in party matching for Bank Transaction {0}").format(self.name))
+		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
@@ -188,7 +177,7 @@ def get_doctypes_for_bank_reconciliation():
 	return frappe.get_hooks("bank_reconciliation_doctypes")
 
 
-def get_clearance_details(transaction, payment_entry, bt_allocations):
+def get_clearance_details(transaction, payment_entry):
 	"""
 	There should only be one bank gle for a voucher.
 	Could be none for a Bank Transaction.
@@ -197,6 +186,7 @@ def get_clearance_details(transaction, payment_entry, bt_allocations):
 	"""
 	gl_bank_account = frappe.db.get_value("Bank Account", transaction.bank_account, "account")
 	gles = get_related_bank_gl_entries(payment_entry.payment_document, payment_entry.payment_entry)
+	bt_allocations = get_total_allocated_amount(payment_entry.payment_document, payment_entry.payment_entry)
 
 	unallocated_amount = min(
 		transaction.unallocated_amount,
@@ -252,52 +242,44 @@ def get_related_bank_gl_entries(doctype, docname):
 	return result
 
 
-def get_total_allocated_amount(docs):
+def get_total_allocated_amount(doctype, docname):
 	"""
 	Gets the sum of allocations for a voucher on each bank GL account
 	along with the latest bank transaction name & date
 	NOTE: query may also include just saved vouchers/payments but with zero allocated_amount
 	"""
-	if not docs:
-		return {}
-
 	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
 	result = frappe.db.sql(
 		"""
-		SELECT total, latest_name, latest_date, gl_account, payment_document, payment_entry FROM (
+		SELECT total, latest_name, latest_date, gl_account FROM (
 			SELECT
 				ROW_NUMBER() OVER w AS rownum,
-				SUM(btp.allocated_amount) OVER(PARTITION BY ba.account, btp.payment_document, btp.payment_entry) AS total,
+				SUM(btp.allocated_amount) OVER(PARTITION BY ba.account) AS total,
 				FIRST_VALUE(bt.name) OVER w AS latest_name,
 				FIRST_VALUE(bt.date) OVER w AS latest_date,
-				ba.account AS gl_account,
-				btp.payment_document,
-				btp.payment_entry
+				ba.account AS gl_account
 			FROM
 				`tabBank Transaction Payments` btp
 			LEFT JOIN `tabBank Transaction` bt ON bt.name=btp.parent
 			LEFT JOIN `tabBank Account` ba ON ba.name=bt.bank_account
 			WHERE
-				(btp.payment_document, btp.payment_entry) IN %(docs)s
+				btp.payment_document = %(doctype)s
+				AND btp.payment_entry = %(docname)s
 				AND bt.docstatus = 1
-			WINDOW w AS (PARTITION BY ba.account, btp.payment_document, btp.payment_entry ORDER BY bt.date DESC)
+			WINDOW w AS (PARTITION BY ba.account ORDER BY bt.date desc)
 		) temp
 		WHERE
 			rownum = 1
 		""",
-		dict(docs=docs),
+		dict(doctype=doctype, docname=docname),
 		as_dict=True,
 	)
-
-	payment_allocation_details = {}
 	for row in result:
 		# Why is this *sometimes* a byte string?
 		if isinstance(row["latest_name"], bytes):
 			row["latest_name"] = row["latest_name"].decode()
 		row["latest_date"] = frappe.utils.getdate(row["latest_date"])
-		payment_allocation_details.setdefault((row["payment_document"], row["payment_entry"]), []).append(row)
-
-	return payment_allocation_details
+	return result
 
 
 def get_paid_amount(payment_entry, currency, gl_bank_account):

erpnext/accounts/doctype/budget/budget.py

@@ -460,20 +460,13 @@ def get_actual_expense(args):
 def get_accumulated_monthly_budget(monthly_distribution, posting_date, fiscal_year, annual_budget):
 	distribution = {}
 	if monthly_distribution:
-		mdp = frappe.qb.DocType("Monthly Distribution Percentage")
-		md = frappe.qb.DocType("Monthly Distribution")
-
-		res = (
-			frappe.qb.from_(mdp)
-			.join(md)
-			.on(mdp.parent == md.name)
-			.select(mdp.month, mdp.percentage_allocation)
-			.where(md.fiscal_year == fiscal_year)
-			.where(md.name == monthly_distribution)
-			.run(as_dict=True)
-		)
-
-		for d in res:
+		for d in frappe.db.sql(
+			"""select mdp.month, mdp.percentage_allocation
+			from `tabMonthly Distribution Percentage` mdp, `tabMonthly Distribution` md
+			where mdp.parent=md.name and md.fiscal_year=%s""",
+			fiscal_year,
+			as_dict=1,
+		):
 			distribution.setdefault(d.month, d.percentage_allocation)
 
 	dt = frappe.db.get_value("Fiscal Year", fiscal_year, "year_start_date")

erpnext/accounts/doctype/budget/test_budget.py

@@ -6,11 +6,7 @@ import unittest
 import frappe
 from frappe.utils import now_datetime, nowdate
 
-from erpnext.accounts.doctype.budget.budget import (
-	BudgetError,
-	get_accumulated_monthly_budget,
-	get_actual_expense,
-)
+from erpnext.accounts.doctype.budget.budget import BudgetError, get_actual_expense
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 from erpnext.accounts.utils import get_fiscal_year
 from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
@@ -100,10 +96,6 @@ class TestBudget(unittest.TestCase):
 		frappe.db.set_value("Budget", budget.name, "action_if_accumulated_monthly_budget_exceeded", "Stop")
 		frappe.db.set_value("Budget", budget.name, "fiscal_year", fiscal_year)
 
-		accumulated_limit = get_accumulated_monthly_budget(
-			budget.monthly_distribution, nowdate(), budget.fiscal_year, budget.accounts[0].budget_amount
-		)
-
 		mr = frappe.get_doc(
 			{
 				"doctype": "Material Request",
@@ -117,7 +109,7 @@ class TestBudget(unittest.TestCase):
 						"uom": "_Test UOM",
 						"warehouse": "_Test Warehouse - _TC",
 						"schedule_date": nowdate(),
-						"rate": accumulated_limit + 1,
+						"rate": 100000,
 						"expense_account": "_Test Account Cost for Goods Sold - _TC",
 						"cost_center": "_Test Cost Center - _TC",
 					}

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -448,8 +448,9 @@ def unset_existing_data(company):
 		"Sales Taxes and Charges Template",
 		"Purchase Taxes and Charges Template",
 	]:
-		dt = frappe.qb.DocType(doctype)
-		frappe.qb.from_(dt).where(dt.company == company).delete().run()
+		frappe.db.sql(
+			f'''delete from `tab{doctype}` where `company`="%s"''' % (company)  # nosec
+		)
 
 
 def set_default_accounts(company):

erpnext/accounts/doctype/cost_center_allocation/test_cost_center_allocation.py

@@ -4,8 +4,6 @@
 import unittest
 
 import frappe
-from frappe.query_builder.functions import Sum
-from frappe.tests.utils import change_settings
 from frappe.utils import add_days, today
 
 from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
@@ -192,31 +190,6 @@ class TestCostCenterAllocation(unittest.TestCase):
 		coa2.cancel()
 		jv.cancel()
 
-	@change_settings("System Settings", {"rounding_method": "Commercial Rounding"})
-	def test_debit_credit_on_cost_center_allocation_for_commercial_rounding(self):
-		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-
-		cca = create_cost_center_allocation(
-			"_Test Company",
-			"Main Cost Center 1 - _TC",
-			{"Sub Cost Center 2 - _TC": 50, "Sub Cost Center 3 - _TC": 50},
-		)
-
-		si = create_sales_invoice(rate=145.65, cost_center="Main Cost Center 1 - _TC")
-
-		gl_entry = frappe.qb.DocType("GL Entry")
-		gl_entries = (
-			frappe.qb.from_(gl_entry)
-			.select(Sum(gl_entry.credit).as_("cr"), Sum(gl_entry.debit).as_("dr"))
-			.where(gl_entry.voucher_type == "Sales Invoice")
-			.where(gl_entry.voucher_no == si.name)
-		).run(as_dict=1)
-
-		self.assertEqual(gl_entries[0].cr, gl_entries[0].dr)
-
-		si.cancel()
-		cca.cancel()
-
 
 def create_cost_center_allocation(
 	company,

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.js

@@ -19,7 +19,7 @@ frappe.ui.form.on("Currency Exchange Settings", {
 							to: "{to_currency}",
 						};
 						add_param(frm, r.message, params, result);
-					} else if (["frankfurter.app", "frankfurter.dev"].includes(frm.doc.service_provider)) {
+					} else if (frm.doc.service_provider == "frankfurter.app") {
 						let result = ["rates", "{to_currency}"];
 						let params = {
 							base: "{from_currency}",

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.json

@@ -78,7 +78,7 @@
    "fieldname": "service_provider",
    "fieldtype": "Select",
    "label": "Service Provider",
-   "options": "frankfurter.dev\nexchangerate.host\nCustom",
+   "options": "frankfurter.app\nexchangerate.host\nCustom",
    "reqd": 1
   },
   {
@@ -104,7 +104,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2026-03-23 21:16:41.896424",
+ "modified": "2024-03-18 08:32:26.895076",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Currency Exchange Settings",
@@ -141,8 +141,8 @@
    "write": 1
   }
  ],
- "sort_field": "creation",
+ "sort_field": "modified",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.py

@@ -35,7 +35,7 @@ class CurrencyExchangeSettings(Document):
 			self.append("req_params", {"key": "date", "value": "{transaction_date}"})
 			self.append("req_params", {"key": "from", "value": "{from_currency}"})
 			self.append("req_params", {"key": "to", "value": "{to_currency}"})
-		elif self.service_provider in ("frankfurter.dev", "frankfurter.app"):
+		elif self.service_provider == "frankfurter.app":
 			self.set("result_key", [])
 			self.set("req_params", [])
 
@@ -80,13 +80,11 @@ class CurrencyExchangeSettings(Document):
 
 @frappe.whitelist()
 def get_api_endpoint(service_provider: str | None = None, use_http: bool = False):
-	if service_provider and service_provider in ["exchangerate.host", "frankfurter.dev", "frankfurter.app"]:
+	if service_provider and service_provider in ["exchangerate.host", "frankfurter.app"]:
 		if service_provider == "exchangerate.host":
 			api = "api.exchangerate.host/convert"
 		elif service_provider == "frankfurter.app":
 			api = "api.frankfurter.app/{transaction_date}"
-		elif service_provider == "frankfurter.dev":
-			api = "api.frankfurter.dev/v1/{transaction_date}"
 
 		protocol = "https://"
 		if use_http:

erpnext/accounts/doctype/dunning/dunning.py

@@ -55,46 +55,46 @@ class Dunning(AccountsController):
 			"conversion_rate",
 			"cost_center",
 		]
+		inv = frappe.db.get_value("Sales Invoice", self.sales_invoice, invoice_fields, as_dict=1)
 
 		accounting_dimensions = get_accounting_dimensions()
 		invoice_fields.extend(accounting_dimensions)
 
-		inv = frappe.db.get_value("Sales Invoice", self.sales_invoice, invoice_fields, as_dict=1)
-
 		dunning_in_company_currency = flt(self.dunning_amount * inv.conversion_rate)
 		default_cost_center = frappe.get_cached_value("Company", self.company, "cost_center")
 
-		debit = {
-			"account": inv.debit_to,
-			"party_type": "Customer",
-			"party": self.customer,
-			"due_date": self.due_date,
-			"against": self.income_account,
-			"debit": dunning_in_company_currency,
-			"debit_in_account_currency": self.dunning_amount,
-			"against_voucher": self.name,
-			"against_voucher_type": "Dunning",
-			"cost_center": inv.cost_center or default_cost_center,
-			"project": inv.project,
-		}
-
-		credit = {
-			"account": self.income_account,
-			"against": self.customer,
-			"credit": dunning_in_company_currency,
-			"credit_in_account_currency": self.dunning_amount,
-			"cost_center": inv.cost_center or default_cost_center,
-			"project": inv.project,
-		}
-
-		for dimension in accounting_dimensions:
-			if val := inv.get(dimension):
-				debit[dimension] = credit[dimension] = val
-
-		gl_entries = [
-			self.get_gl_dict(debit, inv.party_account_currency, item=inv),
-			self.get_gl_dict(credit, item=inv),
-		]
+		gl_entries.append(
+			self.get_gl_dict(
+				{
+					"account": inv.debit_to,
+					"party_type": "Customer",
+					"party": self.customer,
+					"due_date": self.due_date,
+					"against": self.income_account,
+					"debit": dunning_in_company_currency,
+					"debit_in_account_currency": self.dunning_amount,
+					"against_voucher": self.name,
+					"against_voucher_type": "Dunning",
+					"cost_center": inv.cost_center or default_cost_center,
+					"project": inv.project,
+				},
+				inv.party_account_currency,
+				item=inv,
+			)
+		)
+		gl_entries.append(
+			self.get_gl_dict(
+				{
+					"account": self.income_account,
+					"against": self.customer,
+					"credit": dunning_in_company_currency,
+					"cost_center": inv.cost_center or default_cost_center,
+					"credit_in_account_currency": self.dunning_amount,
+					"project": inv.project,
+				},
+				item=inv,
+			)
+		)
 		make_gl_entries(
 			gl_entries, cancel=(self.docstatus == 2), update_outstanding="No", merge_entries=False
 		)

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -52,21 +52,6 @@ class ExchangeRateRevaluation(Document):
 		if not (self.company and self.posting_date):
 			frappe.throw(_("Please select Company and Posting Date to getting entries"))
 
-	def before_submit(self):
-		self.remove_accounts_without_gain_loss()
-
-	def remove_accounts_without_gain_loss(self):
-		self.accounts = [account for account in self.accounts if account.gain_loss]
-
-		if not self.accounts:
-			frappe.throw(_("At least one account with exchange gain or loss is required"))
-
-		frappe.msgprint(
-			_("Removing rows without exchange gain or loss"),
-			alert=True,
-			indicator="yellow",
-		)
-
 	def on_cancel(self):
 		self.ignore_linked_doctypes = "GL Entry"
 
@@ -241,23 +226,23 @@ class ExchangeRateRevaluation(Document):
 				new_exchange_rate = get_exchange_rate(d.account_currency, company_currency, posting_date)
 				new_balance_in_base_currency = flt(d.balance_in_account_currency * new_exchange_rate)
 				gain_loss = flt(new_balance_in_base_currency, precision) - flt(d.balance, precision)
-
-				accounts.append(
-					{
-						"account": d.account,
-						"party_type": d.party_type,
-						"party": d.party,
-						"account_currency": d.account_currency,
-						"balance_in_base_currency": d.balance,
-						"balance_in_account_currency": d.balance_in_account_currency,
-						"zero_balance": d.zero_balance,
-						"current_exchange_rate": current_exchange_rate,
-						"new_exchange_rate": new_exchange_rate,
-						"new_balance_in_base_currency": new_balance_in_base_currency,
-						"new_balance_in_account_currency": d.balance_in_account_currency,
-						"gain_loss": gain_loss,
-					}
-				)
+				if gain_loss:
+					accounts.append(
+						{
+							"account": d.account,
+							"party_type": d.party_type,
+							"party": d.party,
+							"account_currency": d.account_currency,
+							"balance_in_base_currency": d.balance,
+							"balance_in_account_currency": d.balance_in_account_currency,
+							"zero_balance": d.zero_balance,
+							"current_exchange_rate": current_exchange_rate,
+							"new_exchange_rate": new_exchange_rate,
+							"new_balance_in_base_currency": new_balance_in_base_currency,
+							"new_balance_in_account_currency": d.balance_in_account_currency,
+							"gain_loss": gain_loss,
+						}
+					)
 
 			# Handle Accounts with '0' balance in Account/Base Currency
 			for d in [x for x in account_details if x.zero_balance]:
@@ -281,22 +266,23 @@ class ExchangeRateRevaluation(Document):
 						current_exchange_rate * d.balance_in_account_currency
 					)
 
-				accounts.append(
-					{
-						"account": d.account,
-						"party_type": d.party_type,
-						"party": d.party,
-						"account_currency": d.account_currency,
-						"balance_in_base_currency": d.balance,
-						"balance_in_account_currency": d.balance_in_account_currency,
-						"zero_balance": d.zero_balance,
-						"current_exchange_rate": current_exchange_rate,
-						"new_exchange_rate": new_exchange_rate,
-						"new_balance_in_base_currency": new_balance_in_base_currency,
-						"new_balance_in_account_currency": new_balance_in_account_currency,
-						"gain_loss": gain_loss,
-					}
-				)
+				if gain_loss:
+					accounts.append(
+						{
+							"account": d.account,
+							"party_type": d.party_type,
+							"party": d.party,
+							"account_currency": d.account_currency,
+							"balance_in_base_currency": d.balance,
+							"balance_in_account_currency": d.balance_in_account_currency,
+							"zero_balance": d.zero_balance,
+							"current_exchange_rate": current_exchange_rate,
+							"new_exchange_rate": new_exchange_rate,
+							"new_balance_in_base_currency": new_balance_in_base_currency,
+							"new_balance_in_account_currency": new_balance_in_account_currency,
+							"gain_loss": gain_loss,
+						}
+					)
 
 		return accounts
 

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -7,7 +7,7 @@ from frappe import _
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
 from frappe.model.naming import set_name_from_naming_options
-from frappe.utils import flt, fmt_money, now
+from frappe.utils import flt, fmt_money
 
 import erpnext
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
@@ -83,7 +83,7 @@ class GLEntry(Document):
 			if not self.get(k):
 				frappe.throw(_("{0} is required").format(_(self.meta.get_label(k))))
 
-		if not self.is_cancelled and not (self.party_type and self.party):
+		if not (self.party_type and self.party):
 			account_type = frappe.get_cached_value("Account", self.account, "account_type")
 			if account_type == "Receivable":
 				frappe.throw(
@@ -261,7 +261,7 @@ def validate_balance_type(account, adv_adj=False):
 		if balance_must_be:
 			balance = frappe.db.sql(
 				"""select sum(debit) - sum(credit)
-				from `tabGL Entry` where is_cancelled = 0 and account = %s""",
+				from `tabGL Entry` where account = %s""",
 				account,
 			)[0][0]
 
@@ -405,7 +405,7 @@ def rename_temporarily_named_docs(doctype):
 		set_name_from_naming_options(frappe.get_meta(doctype).autoname, doc)
 		newname = doc.name
 		frappe.db.sql(
-			f"UPDATE `tab{doctype}` SET name = %s, to_rename = 0, modified = %s where name = %s",
-			(newname, now(), oldname),
+			f"UPDATE `tab{doctype}` SET name = %s, to_rename = 0 where name = %s",
+			(newname, oldname),
 			auto_commit=True,
 		)

erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js

@@ -197,7 +197,7 @@ frappe.ui.form.on("Invoice Discounting", {
 						from_date: frm.doc.posting_date,
 						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
 						company: frm.doc.company,
-						categorize_by: "Categorize by Voucher (Consolidated)",
+						group_by: "Group by Voucher (Consolidated)",
 						show_cancelled_entries: frm.doc.docstatus === 2,
 					};
 					frappe.set_route("query-report", "General Ledger");

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -34,7 +34,7 @@ frappe.ui.form.on("Journal Entry", {
 						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
 						company: frm.doc.company,
 						finance_book: frm.doc.finance_book,
-						categorize_by: "",
+						group_by: "",
 						show_cancelled_entries: frm.doc.docstatus === 2,
 					};
 					frappe.set_route("query-report", "General Ledger");

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -433,22 +433,8 @@ class JournalEntry(AccountsController):
 		if customers:
 			from erpnext.selling.doctype.customer.customer import check_credit_limit
 
-			customer_details = frappe._dict(
-				frappe.db.get_all(
-					"Customer Credit Limit",
-					filters={
-						"parent": ["in", customers],
-						"parenttype": ["=", "Customer"],
-						"company": ["=", self.company],
-					},
-					fields=["parent", "bypass_credit_limit_check"],
-					as_list=True,
-				)
-			)
-
 			for customer in customers:
-				ignore_outstanding_sales_order = bool(customer_details.get(customer))
-				check_credit_limit(customer, self.company, ignore_outstanding_sales_order)
+				check_credit_limit(customer, self.company)
 
 	def validate_cheque_info(self):
 		if self.voucher_type in ["Bank Entry"]:

erpnext/accounts/doctype/loyalty_program/loyalty_program.py

@@ -5,7 +5,6 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.query_builder.functions import Sum
 from frappe.utils import flt, today
 
 
@@ -19,29 +18,21 @@ def get_loyalty_details(
 	if not expiry_date:
 		expiry_date = today()
 
-	LoyaltyPointEntry = frappe.qb.DocType("Loyalty Point Entry")
-
-	query = (
-		frappe.qb.from_(LoyaltyPointEntry)
-		.select(
-			Sum(LoyaltyPointEntry.loyalty_points).as_("loyalty_points"),
-			Sum(LoyaltyPointEntry.purchase_amount).as_("total_spent"),
-		)
-		.where(
-			(LoyaltyPointEntry.customer == customer)
-			& (LoyaltyPointEntry.loyalty_program == loyalty_program)
-			& (LoyaltyPointEntry.posting_date <= expiry_date)
-		)
-		.groupby(LoyaltyPointEntry.customer)
-	)
-
+	condition = ""
 	if company:
-		query = query.where(LoyaltyPointEntry.company == company)
-
+		condition = " and company=%s " % frappe.db.escape(company)
 	if not include_expired_entry:
-		query = query.where(LoyaltyPointEntry.expiry_date >= expiry_date)
+		condition += " and expiry_date>='%s' " % expiry_date
 
-	loyalty_point_details = query.run(as_dict=True)
+	loyalty_point_details = frappe.db.sql(
+		f"""select sum(loyalty_points) as loyalty_points,
+		sum(purchase_amount) as total_spent from `tabLoyalty Point Entry`
+		where customer=%s and loyalty_program=%s and posting_date <= %s
+		{condition}
+		group by customer""",
+		(customer, loyalty_program, expiry_date),
+		as_dict=1,
+	)
 
 	if loyalty_point_details:
 		return loyalty_point_details[0]

erpnext/accounts/doctype/party_link/party_link.py

@@ -60,6 +60,6 @@ def create_party_link(primary_role, primary_party, secondary_party):
 	party_link.secondary_role = "Customer" if primary_role == "Supplier" else "Supplier"
 	party_link.secondary_party = secondary_party
 
-	party_link.save()
+	party_link.save(ignore_permissions=True)
 
 	return party_link

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -15,10 +15,6 @@ frappe.ui.form.on('Payment Entry', {
 		}
 
 		erpnext.accounts.dimensions.setup_dimension_filters(frm, frm.doctype);
-
-		if (frm.is_new()) {
-			set_default_party_type(frm);
-		}
 	},
 
 	setup: function(frm) {
@@ -165,10 +161,6 @@ frappe.ui.form.on('Payment Entry', {
 				filters: {
 					reference_doctype: row.reference_doctype,
 					reference_name: row.reference_name,
-					company: doc.company,
-					status: ["!=", "Paid"],
-					outstanding_amount: [">", 0], // for compatibility with old data
-					docstatus: 1,
 				},
 			};
 		});
@@ -319,7 +311,7 @@ frappe.ui.form.on('Payment Entry', {
 					"from_date": frm.doc.posting_date,
 					"to_date": moment(frm.doc.modified).format('YYYY-MM-DD'),
 					"company": frm.doc.company,
-					"categorize_by": "",
+					"group_by": "",
 					"show_cancelled_entries": frm.doc.docstatus === 2
 				};
 				frappe.set_route("query-report", "General Ledger");
@@ -328,9 +320,8 @@ frappe.ui.form.on('Payment Entry', {
 	},
 
 	payment_type: function(frm) {
-		set_default_party_type(frm);
 		if(frm.doc.payment_type == "Internal Transfer") {
-			$.each(["party", "party_type", "party_balance", "paid_from", "paid_to",
+			$.each(["party", "party_balance", "paid_from", "paid_to",
 				"references", "total_allocated_amount"], function(i, field) {
 				frm.set_value(field, null);
 			});
@@ -1088,24 +1079,6 @@ frappe.ui.form.on('Payment Entry', {
 					if (r.message) {
 						if (!frm.doc.mode_of_payment) {
 							frm.set_value(field, r.message.account);
-						} else {
-							frappe.call({
-								method: "frappe.client.get_value",
-								args: {
-									doctype: "Mode of Payment Account",
-									filters: {
-										parent: frm.doc.mode_of_payment,
-										company: frm.doc.company,
-									},
-									fieldname: "default_account",
-									parent: "Mode of Payment",
-								},
-								callback: function (res) {
-									if (!res.message.default_account) {
-										frm.set_value(field, r.message.account);
-									}
-								},
-							});
 						}
 						frm.set_value('bank', r.message.bank);
 						frm.set_value('bank_account_no', r.message.bank_account_no);
@@ -1538,16 +1511,3 @@ frappe.ui.form.on('Payment Entry Deduction', {
 		frm.events.set_unallocated_amount(frm);
 	},
 });
-
-function set_default_party_type(frm) {
-	if (frm.doc.party) return;
-
-	let party_type;
-	if (frm.doc.payment_type == "Receive") {
-		party_type = "Customer";
-	} else if (frm.doc.payment_type == "Pay") {
-		party_type = "Supplier";
-	}
-
-	if (party_type) frm.set_value("party_type", party_type);
-}

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -350,25 +350,15 @@ class PaymentEntry(AccountsController):
 				self.set(self.party_account_field, party_account)
 				self.party_account = party_account
 
-		if self.paid_from and (
-			not self.paid_from_account_currency
-			or not self.paid_from_account_balance
-			or not self.paid_from_account_type
-		):
+		if self.paid_from and not (self.paid_from_account_currency or self.paid_from_account_balance):
 			acc = get_account_details(self.paid_from, self.posting_date, self.cost_center)
 			self.paid_from_account_currency = acc.account_currency
 			self.paid_from_account_balance = acc.account_balance
-			self.paid_from_account_type = acc.account_type
 
-		if self.paid_to and (
-			not self.paid_to_account_currency
-			or not self.paid_to_account_balance
-			or not self.paid_to_account_type
-		):
+		if self.paid_to and not (self.paid_to_account_currency or self.paid_to_account_balance):
 			acc = get_account_details(self.paid_to, self.posting_date, self.cost_center)
 			self.paid_to_account_currency = acc.account_currency
 			self.paid_to_account_balance = acc.account_balance
-			self.paid_to_account_type = acc.account_type
 
 		self.party_account_currency = (
 			self.paid_from_account_currency
@@ -475,7 +465,7 @@ class PaymentEntry(AccountsController):
 			if d.reference_doctype not in valid_reference_doctypes:
 				frappe.throw(
 					_("Reference Doctype must be one of {0}").format(
-						comma_or([_(d) for d in valid_reference_doctypes])
+						comma_or(_(d) for d in valid_reference_doctypes)
 					)
 				)
 
@@ -1529,11 +1519,11 @@ class PaymentEntry(AccountsController):
 
 			allocated_positive_outstanding = paid_amount + allocated_negative_outstanding
 
-		elif self.party_type in ("Supplier", "Customer"):
+		elif self.party_type in ("Supplier", "Employee"):
 			if paid_amount > total_negative_outstanding:
 				if total_negative_outstanding == 0:
 					frappe.msgprint(
-						_("Cannot {0} from {1} without any negative outstanding invoice").format(
+						_("Cannot {0} from {2} without any negative outstanding invoice").format(
 							self.payment_type,
 							self.party_type,
 						)
@@ -1590,7 +1580,7 @@ class PaymentEntry(AccountsController):
 
 			# Re allocate amount to those references which have PR set (Higher priority)
 			for ref in self.references:
-				if not (ref.reference_doctype and ref.reference_name and ref.payment_request):
+				if not ref.payment_request:
 					continue
 
 				# fetch outstanding_amount of `Reference` (Payment Term) and `Payment Request` to allocate new amount
@@ -1641,7 +1631,7 @@ class PaymentEntry(AccountsController):
 					)
 			# Re allocate amount to those references which have no PR (Lower priority)
 			for ref in self.references:
-				if ref.payment_request or not (ref.reference_doctype and ref.reference_name):
+				if ref.payment_request:
 					continue
 
 				key = (ref.reference_doctype, ref.reference_name, ref.get("payment_term"))
@@ -2491,7 +2481,6 @@ def get_payment_entry(
 	pe.paid_amount = paid_amount
 	pe.received_amount = received_amount
 	pe.letter_head = doc.get("letter_head")
-	pe.bank_account = frappe.db.get_value("Bank Account", {"is_company_account": 1, "is_default": 1}, "name")
 
 	if dt in ["Purchase Order", "Sales Order", "Sales Invoice", "Purchase Invoice"]:
 		pe.project = doc.get("project") or reduce(
@@ -2616,7 +2605,6 @@ def get_open_payment_requests_for_references(references=None):
 		.where(Tuple(PR.reference_doctype, PR.reference_name).isin(list(refs)))
 		.where(PR.status != "Paid")
 		.where(PR.docstatus == 1)
-		.where(PR.outstanding_amount > 0)  # to avoid old PRs with 0 outstanding amount
 		.orderby(Coalesce(PR.transaction_date, PR.creation), order=frappe.qb.asc)
 	).run(as_dict=True)
 

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -144,14 +144,12 @@ class PaymentReconciliation(Document):
 		if self.get("cost_center"):
 			conditions.append(jea.cost_center == self.cost_center)
 
-		account_type = erpnext.get_party_account_type(self.party_type)
-
-		if account_type == "Receivable":
-			dr_or_cr = jea.credit_in_account_currency - jea.debit_in_account_currency
-		elif account_type == "Payable":
-			dr_or_cr = jea.debit_in_account_currency - jea.credit_in_account_currency
-
-		conditions.append(dr_or_cr.gt(0))
+		dr_or_cr = (
+			"credit_in_account_currency"
+			if erpnext.get_party_account_type(self.party_type) == "Receivable"
+			else "debit_in_account_currency"
+		)
+		conditions.append(jea[dr_or_cr].gt(0))
 
 		if self.bank_cash_account:
 			conditions.append(jea.against_account.like(f"%%{self.bank_cash_account}%%"))
@@ -166,7 +164,7 @@ class PaymentReconciliation(Document):
 				je.posting_date,
 				je.remark.as_("remarks"),
 				jea.name.as_("reference_row"),
-				dr_or_cr.as_("amount"),
+				jea[dr_or_cr].as_("amount"),
 				jea.is_advance,
 				jea.exchange_rate,
 				jea.account_currency.as_("currency"),
@@ -270,7 +268,6 @@ class PaymentReconciliation(Document):
 		for payment in non_reconciled_payments:
 			row = self.append("payments", {})
 			row.update(payment)
-			row.is_advance = payment.book_advance_payments_in_separate_party_account
 
 	def get_invoice_entries(self):
 		# Fetch JVs, Sales and Purchase Invoices for 'invoices' to reconcile against
@@ -302,10 +299,6 @@ class PaymentReconciliation(Document):
 		if self.invoice_limit:
 			non_reconciled_invoices = non_reconciled_invoices[: self.invoice_limit]
 
-		non_reconciled_invoices = sorted(
-			non_reconciled_invoices, key=lambda k: k["posting_date"] or getdate(nowdate())
-		)
-
 		self.add_invoice_entries(non_reconciled_invoices)
 
 	def add_invoice_entries(self, non_reconciled_invoices):
@@ -355,9 +348,6 @@ class PaymentReconciliation(Document):
 	def allocate_entries(self, args):
 		self.validate_entries()
 
-		exc_gain_loss_posting_date = frappe.db.get_single_value(
-			"Accounts Settings", "exchange_gain_loss_posting_date", cache=True
-		)
 		invoice_exchange_map = self.get_invoice_exchange_map(args.get("invoices"), args.get("payments"))
 		default_exchange_gain_loss_account = frappe.get_cached_value(
 			"Company", self.company, "exchange_gain_loss_account"
@@ -384,11 +374,6 @@ class PaymentReconciliation(Document):
 				res.difference_account = default_exchange_gain_loss_account
 				res.exchange_rate = inv.get("exchange_rate")
 				res.update({"gain_loss_posting_date": pay.get("posting_date")})
-				if not pay.get("is_advance"):
-					if exc_gain_loss_posting_date == "Invoice":
-						res.update({"gain_loss_posting_date": inv.get("invoice_date")})
-					elif exc_gain_loss_posting_date == "Reconciliation Date":
-						res.update({"gain_loss_posting_date": nowdate()})
 
 				if pay.get("amount") == 0:
 					entries.append(res)

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -615,42 +615,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		self.assertEqual(len(pr.get("invoices")), 0)
 		self.assertEqual(len(pr.get("payments")), 0)
 
-	def test_negative_debit_or_credit_journal_against_invoice(self):
-		transaction_date = nowdate()
-		amount = 100
-		si = self.create_sales_invoice(qty=1, rate=amount, posting_date=transaction_date)
-
-		# credit debtors account to record a payment
-		je = self.create_journal_entry(self.bank, self.debit_to, amount, transaction_date)
-		je.accounts[1].party_type = "Customer"
-		je.accounts[1].party = self.customer
-		je.accounts[1].credit_in_account_currency = 0
-		je.accounts[1].debit_in_account_currency = -1 * amount
-		je.save()
-		je.submit()
-
-		pr = self.create_payment_reconciliation()
-
-		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}))
-
-		# Difference amount should not be calculated for base currency accounts
-		for row in pr.allocation:
-			self.assertEqual(flt(row.get("difference_amount")), 0.0)
-
-		pr.reconcile()
-
-		# assert outstanding
-		si.reload()
-		self.assertEqual(si.status, "Paid")
-		self.assertEqual(si.outstanding_amount, 0)
-
-		# check PR tool output
-		self.assertEqual(len(pr.get("invoices")), 0)
-		self.assertEqual(len(pr.get("payments")), 0)
-
 	def test_journal_against_journal(self):
 		transaction_date = nowdate()
 		sales = "Sales - _PR"
@@ -973,100 +937,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 			frappe.db.get_value("Journal Entry", jea_parent.parent, "voucher_type"), "Exchange Gain Or Loss"
 		)
 
-	def test_difference_amount_via_negative_debit_or_credit_journal_entry(self):
-		# Make Sale Invoice
-		si = self.create_sales_invoice(
-			qty=1, rate=100, posting_date=nowdate(), do_not_save=True, do_not_submit=True
-		)
-		si.customer = self.customer4
-		si.currency = "EUR"
-		si.conversion_rate = 85
-		si.debit_to = self.debtors_eur
-		si.save().submit()
-
-		# Make payment using Journal Entry
-		je1 = self.create_journal_entry("HDFC - _PR", self.debtors_eur, 100, nowdate())
-		je1.multi_currency = 1
-		je1.accounts[0].exchange_rate = 1
-		je1.accounts[0].credit_in_account_currency = -8000
-		je1.accounts[0].credit = -8000
-		je1.accounts[0].debit_in_account_currency = 0
-		je1.accounts[0].debit = 0
-		je1.accounts[1].party_type = "Customer"
-		je1.accounts[1].party = self.customer4
-		je1.accounts[1].exchange_rate = 80
-		je1.accounts[1].credit_in_account_currency = 100
-		je1.accounts[1].credit = 8000
-		je1.accounts[1].debit_in_account_currency = 0
-		je1.accounts[1].debit = 0
-		je1.save()
-		je1.submit()
-
-		je2 = self.create_journal_entry("HDFC - _PR", self.debtors_eur, 200, nowdate())
-		je2.multi_currency = 1
-		je2.accounts[0].exchange_rate = 1
-		je2.accounts[0].credit_in_account_currency = -16000
-		je2.accounts[0].credit = -16000
-		je2.accounts[0].debit_in_account_currency = 0
-		je2.accounts[0].debit = 0
-		je2.accounts[1].party_type = "Customer"
-		je2.accounts[1].party = self.customer4
-		je2.accounts[1].exchange_rate = 80
-		je2.accounts[1].credit_in_account_currency = 200
-		je1.accounts[1].credit = 16000
-		je1.accounts[1].debit_in_account_currency = 0
-		je1.accounts[1].debit = 0
-		je2.save()
-		je2.submit()
-
-		pr = self.create_payment_reconciliation()
-		pr.party = self.customer4
-		pr.receivable_payable_account = self.debtors_eur
-		pr.get_unreconciled_entries()
-
-		self.assertEqual(len(pr.invoices), 1)
-		self.assertEqual(len(pr.payments), 2)
-
-		# Test exact payment allocation
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [pr.payments[0].as_dict()]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		self.assertEqual(pr.allocation[0].allocated_amount, 100)
-		self.assertEqual(pr.allocation[0].difference_amount, -500)
-
-		# Test partial payment allocation (with excess payment entry)
-		pr.set("allocation", [])
-		pr.get_unreconciled_entries()
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [pr.payments[1].as_dict()]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-		pr.allocation[0].difference_account = "Exchange Gain/Loss - _PR"
-
-		self.assertEqual(pr.allocation[0].allocated_amount, 100)
-		self.assertEqual(pr.allocation[0].difference_amount, -500)
-
-		# Check if difference journal entry gets generated for difference amount after reconciliation
-		pr.reconcile()
-		total_credit_amount = frappe.db.get_all(
-			"Journal Entry Account",
-			{"account": self.debtors_eur, "docstatus": 1, "reference_name": si.name},
-			"sum(credit) as amount",
-			group_by="reference_name",
-		)[0].amount
-
-		# total credit includes the exchange gain/loss amount
-		self.assertEqual(flt(total_credit_amount, 2), 8500)
-
-		jea_parent = frappe.db.get_all(
-			"Journal Entry Account",
-			filters={"account": self.debtors_eur, "docstatus": 1, "reference_name": si.name, "credit": 500},
-			fields=["parent"],
-		)[0]
-		self.assertEqual(
-			frappe.db.get_value("Journal Entry", jea_parent.parent, "voucher_type"), "Exchange Gain Or Loss"
-		)
-
 	def test_difference_amount_via_payment_entry(self):
 		# Make Sale Invoice
 		si = self.create_sales_invoice(

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -246,7 +246,6 @@ class PaymentRequest(Document):
 				"payer_name": data.customer_name,
 				"order_id": self.name,
 				"currency": self.currency,
-				"payment_gateway": self.payment_gateway,
 			}
 		)
 
@@ -839,17 +838,21 @@ def validate_payment(doc, method=None):
 @frappe.whitelist()
 def get_open_payment_requests_query(doctype, txt, searchfield, start, page_len, filters):
 	# permission checks in `get_list()`
-	filters = frappe._dict(filters)
+	reference_doctype = filters.get("reference_doctype")
+	reference_name = filters.get("reference_doctype")
 
-	if not filters.reference_doctype or not filters.reference_name:
+	if not reference_doctype or not reference_name:
 		return []
 
-	if txt:
-		filters.name = ["like", f"%{txt}%"]
-
 	open_payment_requests = frappe.get_list(
 		"Payment Request",
-		filters=filters,
+		filters={
+			"reference_doctype": filters["reference_doctype"],
+			"reference_name": filters["reference_name"],
+			"status": ["!=", "Paid"],
+			"outstanding_amount": ["!=", 0],  # for compatibility with old data
+			"docstatus": 1,
+		},
 		fields=["name", "grand_total", "outstanding_amount"],
 		order_by="transaction_date ASC,creation ASC",
 	)

erpnext/accounts/doctype/payment_request/payment_request_dashboard.py

@@ -1,14 +0,0 @@
-from frappe import _
-
-
-def get_data():
-	return {
-		"fieldname": "payment_request",
-		"internal_links": {
-			"Payment Entry": ["references", "payment_request"],
-			"Payment Order": ["references", "payment_order"],
-		},
-		"transactions": [
-			{"label": _("Payment"), "items": ["Payment Entry", "Payment Order"]},
-		],
-	}

erpnext/accounts/doctype/payment_request/payment_request_list.js

@@ -1,18 +1,19 @@
-const INDICATORS = {
-	"Partially Paid": "orange",
-	Cancelled: "red",
-	Draft: "gray",
-	Failed: "red",
-	Initiated: "green",
-	Paid: "blue",
-	Requested: "green",
-};
-
 frappe.listview_settings["Payment Request"] = {
 	add_fields: ["status"],
 	get_indicator: function (doc) {
-		if (!doc.status || !INDICATORS[doc.status]) return;
-
-		return [__(doc.status), INDICATORS[doc.status], `status,=,${doc.status}`];
+		if (doc.status == "Draft") {
+			return [__("Draft"), "gray", "status,=,Draft"];
+		}
+		if (doc.status == "Requested") {
+			return [__("Requested"), "green", "status,=,Requested"];
+		} else if (doc.status == "Initiated") {
+			return [__("Initiated"), "green", "status,=,Initiated"];
+		} else if (doc.status == "Partially Paid") {
+			return [__("Partially Paid"), "orange", "status,=,Partially Paid"];
+		} else if (doc.status == "Paid") {
+			return [__("Paid"), "blue", "status,=,Paid"];
+		} else if (doc.status == "Cancelled") {
+			return [__("Cancelled"), "red", "status,=,Cancelled"];
+		}
 	},
 };

erpnext/accounts/doctype/payment_schedule/payment_schedule.json

@@ -10,19 +10,14 @@
   "description",
   "section_break_4",
   "due_date",
-  "invoice_portion",
   "mode_of_payment",
   "column_break_5",
-  "due_date_based_on",
-  "credit_days",
-  "credit_months",
+  "invoice_portion",
   "section_break_6",
-  "discount_date",
-  "discount",
   "discount_type",
+  "discount_date",
   "column_break_9",
-  "discount_validity_based_on",
-  "discount_validity",
+  "discount",
   "section_break_9",
   "payment_amount",
   "outstanding",
@@ -160,50 +155,12 @@
    "fieldtype": "Currency",
    "label": "Payment Amount (Company Currency)",
    "options": "Company:company:default_currency"
-  },
-  {
-   "fieldname": "due_date_based_on",
-   "fieldtype": "Select",
-   "label": "Due Date Based On",
-   "options": "\nDay(s) after invoice date\nDay(s) after the end of the invoice month\nMonth(s) after the end of the invoice month",
-   "read_only": 1
-  },
-  {
-   "depends_on": "eval:in_list(['Day(s) after invoice date', 'Day(s) after the end of the invoice month'], doc.due_date_based_on)",
-   "fieldname": "credit_days",
-   "fieldtype": "Int",
-   "label": "Credit Days",
-   "non_negative": 1,
-   "read_only": 1
-  },
-  {
-   "depends_on": "eval:doc.due_date_based_on=='Month(s) after the end of the invoice month'",
-   "fieldname": "credit_months",
-   "fieldtype": "Int",
-   "label": "Credit Months",
-   "non_negative": 1,
-   "read_only": 1
-  },
-  {
-   "depends_on": "discount",
-   "fieldname": "discount_validity_based_on",
-   "fieldtype": "Select",
-   "label": "Discount Validity Based On",
-   "options": "\nDay(s) after invoice date\nDay(s) after the end of the invoice month\nMonth(s) after the end of the invoice month",
-   "read_only": 1
-  },
-  {
-   "depends_on": "discount_validity_based_on",
-   "fieldname": "discount_validity",
-   "fieldtype": "Int",
-   "label": "Discount Validity",
-   "read_only": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-07-31 08:38:25.820701",
+ "modified": "2022-09-16 13:57:06.382859",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Schedule",
@@ -214,4 +171,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/payment_terms_template_detail/payment_terms_template_detail.json

@@ -161,4 +161,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.js

@@ -11,9 +11,9 @@ frappe.ui.form.on("Period Closing Voucher", {
 			return {
 				filters: [
 					["Account", "company", "=", frm.doc.company],
-					["Account", "is_group", "=", 0],
+					["Account", "is_group", "=", "0"],
 					["Account", "freeze_account", "=", "No"],
-					["Account", "root_type", "in", ["Liability", "Equity"]],
+					["Account", "root_type", "in", "Liability, Equity"],
 				],
 			};
 		});
@@ -29,7 +29,7 @@ frappe.ui.form.on("Period Closing Voucher", {
 						from_date: frm.doc.posting_date,
 						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
 						company: frm.doc.company,
-						categorize_by: "",
+						group_by: "",
 						show_cancelled_entries: frm.doc.docstatus === 2,
 					};
 					frappe.set_route("query-report", "General Ledger");

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -32,13 +32,8 @@ class PeriodClosingVoucher(AccountsController):
 
 	def on_cancel(self):
 		self.validate_future_closing_vouchers()
-		self.ignore_linked_doctypes = (
-			"GL Entry",
-			"Stock Ledger Entry",
-			"Payment Ledger Entry",
-			"Account Closing Balance",
-		)
 		self.db_set("gle_processing_status", "In Progress")
+		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry", "Payment Ledger Entry")
 		gle_count = frappe.db.count(
 			"GL Entry",
 			{"voucher_type": "Period Closing Voucher", "voucher_no": self.name, "is_cancelled": 0},
@@ -206,9 +201,6 @@ class PeriodClosingVoucher(AccountsController):
 		return gl_entry
 
 	def get_gle_for_closing_account(self, acc):
-		debit = abs(flt(acc.bal_in_company_currency)) if flt(acc.bal_in_company_currency) > 0 else 0
-		credit = abs(flt(acc.bal_in_company_currency)) if flt(acc.bal_in_company_currency) < 0 else 0
-
 		gl_entry = self.get_gl_dict(
 			{
 				"company": self.company,
@@ -217,10 +209,16 @@ class PeriodClosingVoucher(AccountsController):
 				"cost_center": acc.cost_center,
 				"finance_book": acc.finance_book,
 				"account_currency": acc.account_currency,
-				"debit_in_account_currency": debit,
-				"debit": debit,
-				"credit_in_account_currency": credit,
-				"credit": credit,
+				"debit_in_account_currency": abs(flt(acc.bal_in_account_currency))
+				if flt(acc.bal_in_account_currency) > 0
+				else 0,
+				"debit": abs(flt(acc.bal_in_company_currency)) if flt(acc.bal_in_company_currency) > 0 else 0,
+				"credit_in_account_currency": abs(flt(acc.bal_in_account_currency))
+				if flt(acc.bal_in_account_currency) < 0
+				else 0,
+				"credit": abs(flt(acc.bal_in_company_currency))
+				if flt(acc.bal_in_company_currency) < 0
+				else 0,
 				"is_period_closing_voucher_entry": 1,
 			},
 			item=acc,

erpnext/accounts/doctype/pos_invoice/pos_invoice.json

@@ -48,7 +48,6 @@
   "shipping_address",
   "company_address",
   "company_address_display",
-  "company_contact_person",
   "currency_and_price_list",
   "currency",
   "conversion_rate",
@@ -1558,19 +1557,12 @@
    "fieldname": "update_billed_amount_in_delivery_note",
    "fieldtype": "Check",
    "label": "Update Billed Amount in Delivery Note"
-  },
-  {
-   "fieldname": "company_contact_person",
-   "fieldtype": "Link",
-   "label": "Company Contact Person",
-   "options": "Contact",
-   "print_hide": 1
   }
  ],
  "icon": "fa fa-file-text",
  "is_submittable": 1,
  "links": [],
- "modified": "2024-11-26 13:10:50.309570",
+ "modified": "2024-03-20 16:00:34.268756",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice",
@@ -1623,5 +1615,6 @@
  "states": [],
  "timeline_field": "customer",
  "title_field": "title",
- "track_changes": 1
-}
+ "track_changes": 1,
+ "track_seen": 1
+}

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -560,13 +560,7 @@ class POSInvoice(SalesInvoice):
 				"Account", self.debit_to, "account_currency", cache=True
 			)
 		if not self.due_date and self.customer:
-			self.due_date = get_due_date(
-				self.posting_date,
-				"Customer",
-				self.customer,
-				self.company,
-				template_name=self.payment_terms_template,
-			)
+			self.due_date = get_due_date(self.posting_date, "Customer", self.customer, self.company)
 
 		super(SalesInvoice, self).set_missing_values(for_validate)
 

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -389,9 +389,7 @@ def split_invoices(invoices):
 			if not item.serial_no:
 				continue
 
-			return_against_is_added = any(
-				d for d in _invoices if d and d[0].pos_invoice == pos_invoice.return_against
-			)
+			return_against_is_added = any(d for d in _invoices if d.pos_invoice == pos_invoice.return_against)
 			if return_against_is_added:
 				break
 

erpnext/accounts/doctype/pricing_rule/pricing_rule.json

@@ -53,7 +53,6 @@
   "column_break_42",
   "free_item_uom",
   "round_free_qty",
-  "dont_enforce_free_item_qty",
   "is_recursive",
   "recurse_for",
   "apply_recursion_over",
@@ -644,19 +643,12 @@
    "fieldname": "has_priority",
    "fieldtype": "Check",
    "label": "Has Priority"
-  },
-  {
-   "default": "0",
-   "depends_on": "eval:doc.price_or_product_discount == 'Product'",
-   "fieldname": "dont_enforce_free_item_qty",
-   "fieldtype": "Check",
-   "label": "Don't Enforce Free Item Qty"
   }
  ],
  "icon": "fa fa-gift",
  "idx": 1,
  "links": [],
- "modified": "2025-02-17 18:15:39.824639",
+ "modified": "2024-09-16 18:14:51.314765",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Pricing Rule",

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -359,20 +359,7 @@ def get_pricing_rule_for_item(args, doc=None, for_validate=False):
 			if isinstance(pricing_rule, str):
 				pricing_rule = frappe.get_cached_doc("Pricing Rule", pricing_rule)
 				update_pricing_rule_uom(pricing_rule, args)
-				fetch_other_item = True if pricing_rule.apply_rule_on_other else False
-				pricing_rule.apply_rule_on_other_items = (
-					get_pricing_rule_items(pricing_rule, other_items=fetch_other_item) or []
-				)
-
-			if pricing_rule.coupon_code_based == 1:
-				if not args.coupon_code:
-					return item_details
-
-				coupon_code = frappe.db.get_value(
-					doctype="Coupon Code", filters={"pricing_rule": pricing_rule.name}, fieldname="name"
-				)
-				if args.coupon_code != coupon_code:
-					continue
+				pricing_rule.apply_rule_on_other_items = get_pricing_rule_items(pricing_rule) or []
 
 			if pricing_rule.get("suggestion"):
 				continue
@@ -399,6 +386,9 @@ def get_pricing_rule_for_item(args, doc=None, for_validate=False):
 						pricing_rule.apply_rule_on_other_items
 					)
 
+			if pricing_rule.coupon_code_based == 1 and args.coupon_code is None:
+				return item_details
+
 			if not pricing_rule.validate_applied_rule:
 				if pricing_rule.price_or_product_discount == "Price":
 					apply_price_discount_rule(pricing_rule, item_details, args)
@@ -553,7 +543,7 @@ def remove_pricing_rule_for_item(pricing_rules, item_details, item_code=None, ra
 			if pricing_rule.margin_type in ["Percentage", "Amount"]:
 				item_details.margin_rate_or_amount = 0.0
 				item_details.margin_type = None
-		elif pricing_rule.get("free_item") and not pricing_rule.get("dont_enforce_free_item_qty"):
+		elif pricing_rule.get("free_item"):
 			item_details.remove_free_item = (
 				item_code if pricing_rule.get("same_item") else pricing_rule.get("free_item")
 			)

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -428,54 +428,6 @@ class TestPricingRule(FrappeTestCase):
 		self.assertEqual(so.items[1].is_free_item, 1)
 		self.assertEqual(so.items[1].item_code, "_Test Item 2")
 
-	def test_dont_enforce_free_item_qty(self):
-		# this test is only for testing non-enforcement as all other tests in this file already test with enforcement
-		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule")
-		test_record = {
-			"doctype": "Pricing Rule",
-			"title": "_Test Pricing Rule",
-			"apply_on": "Item Code",
-			"currency": "USD",
-			"items": [
-				{
-					"item_code": "_Test Item",
-				}
-			],
-			"selling": 1,
-			"rate_or_discount": "Discount Percentage",
-			"rate": 0,
-			"min_qty": 0,
-			"max_qty": 7,
-			"discount_percentage": 17.5,
-			"price_or_product_discount": "Product",
-			"same_item": 0,
-			"free_item": "_Test Item 2",
-			"free_qty": 1,
-			"company": "_Test Company",
-		}
-		pricing_rule = frappe.get_doc(test_record.copy()).insert()
-
-		# With enforcement
-		so = make_sales_order(item_code="_Test Item", qty=1, do_not_submit=True)
-		self.assertEqual(so.items[1].is_free_item, 1)
-		self.assertEqual(so.items[1].item_code, "_Test Item 2")
-
-		# Test 1 : Saving a document with an item with pricing list without it's corresponding free item will cause it the free item to be refetched on save
-		so.items.pop(1)
-		so.save()
-		so.reload()
-		self.assertEqual(len(so.items), 2)
-
-		# Without enforcement
-		pricing_rule.dont_enforce_free_item_qty = 1
-		pricing_rule.save()
-
-		# Test 2 : Deleted free item will not be fetched again on save without enforcement
-		so.items.pop(1)
-		so.save()
-		so.reload()
-		self.assertEqual(len(so.items), 1)
-
 	def test_cumulative_pricing_rule(self):
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Cumulative Pricing Rule")
 		test_record = {
@@ -1035,45 +987,6 @@ class TestPricingRule(FrappeTestCase):
 		so.save()
 		self.assertEqual(len(so.items), 1)
 
-	def test_pricing_rule_for_product_free_item_round_free_qty(self):
-		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule")
-		test_record = {
-			"doctype": "Pricing Rule",
-			"title": "_Test Pricing Rule",
-			"apply_on": "Item Code",
-			"currency": "USD",
-			"items": [
-				{
-					"item_code": "_Test Item",
-				}
-			],
-			"selling": 1,
-			"rate": 0,
-			"min_qty": 100,
-			"max_qty": 0,
-			"price_or_product_discount": "Product",
-			"same_item": 1,
-			"free_qty": 10,
-			"round_free_qty": 1,
-			"is_recursive": 1,
-			"recurse_for": 100,
-			"company": "_Test Company",
-		}
-		frappe.get_doc(test_record.copy()).insert()
-
-		# With pricing rule
-		so = make_sales_order(item_code="_Test Item", qty=100)
-		so.load_from_db()
-		self.assertEqual(so.items[1].is_free_item, 1)
-		self.assertEqual(so.items[1].item_code, "_Test Item")
-		self.assertEqual(so.items[1].qty, 10)
-
-		so = make_sales_order(item_code="_Test Item", qty=150)
-		so.load_from_db()
-		self.assertEqual(so.items[1].is_free_item, 1)
-		self.assertEqual(so.items[1].item_code, "_Test Item")
-		self.assertEqual(so.items[1].qty, 10)
-
 	def test_apply_multiple_pricing_rules_for_discount_percentage_and_amount(self):
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule 1")
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule 2")
@@ -1287,7 +1200,6 @@ def make_pricing_rule(**args):
 			"discount_amount": args.discount_amount or 0.0,
 			"apply_multiple_pricing_rules": args.apply_multiple_pricing_rules or 0,
 			"has_priority": args.has_priority or 0,
-			"enforce_free_item_qty": args.dont_enforce_free_item_qty or 0,
 		}
 	)
 

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -642,7 +642,7 @@ def get_product_discount_rule(pricing_rule, item_details, args=None, doc=None):
 		if transaction_qty:
 			qty = flt(transaction_qty) * qty / pricing_rule.recurse_for
 			if pricing_rule.round_free_qty:
-				qty = (flt(transaction_qty) // pricing_rule.recurse_for) * (pricing_rule.free_qty or 1)
+				qty = math.floor(qty)
 
 	if not qty:
 		return
@@ -691,10 +691,7 @@ def apply_pricing_rule_for_free_items(doc, pricing_rule_args):
 				args.pop((item.item_code, item.pricing_rules))
 
 		for free_item in args.values():
-			if doc.is_new() or not frappe.get_value(
-				"Pricing Rule", free_item["pricing_rules"], "dont_enforce_free_item_qty"
-			):
-				doc.append("items", free_item)
+			doc.append("items", free_item)
 
 
 def get_pricing_rule_items(pr_doc, other_items=False) -> list:

erpnext/accounts/doctype/process_payment_reconciliation_log_allocations/process_payment_reconciliation_log_allocations.json

@@ -20,7 +20,6 @@
   "is_advance",
   "section_break_5",
   "difference_amount",
-  "gain_loss_posting_date",
   "column_break_7",
   "difference_account",
   "exchange_rate",
@@ -154,16 +153,11 @@
    "fieldtype": "Check",
    "in_list_view": 1,
    "label": "Reconciled"
-  },
-  {
-   "fieldname": "gain_loss_posting_date",
-   "fieldtype": "Date",
-   "label": "Difference Posting Date"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2025-01-23 16:09:01.058574",
+ "modified": "2023-03-20 21:05:43.121945",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Payment Reconciliation Log Allocations",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -12,7 +12,7 @@
   "posting_date",
   "company",
   "account",
-  "categorize_by",
+  "group_by",
   "cost_center",
   "territory",
   "ignore_exchange_rate_revaluation_journals",
@@ -172,6 +172,14 @@
    "fieldtype": "Date",
    "label": "Start Date"
   },
+  {
+   "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",
@@ -387,18 +395,10 @@
    "fieldname": "show_remarks",
    "fieldtype": "Check",
    "label": "Show Remarks"
-  },
-  {
-   "default": "Categorize by Voucher (Consolidated)",
-   "depends_on": "eval:(doc.report == 'General Ledger');",
-   "fieldname": "categorize_by",
-   "fieldtype": "Select",
-   "label": "Categorize By",
-   "options": "\nCategorize by Voucher\nCategorize by Voucher (Consolidated)"
   }
  ],
  "links": [],
- "modified": "2025-04-30 14:43:23.643006",
+ "modified": "2024-10-18 17:51:39.108481",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",
@@ -433,4 +433,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -145,7 +145,7 @@ def get_gl_filters(doc, entry, tax_id, presentation_currency):
 		"party": [entry.customer],
 		"party_name": [entry.customer_name] if entry.customer_name else None,
 		"presentation_currency": presentation_currency,
-		"categorize_by": doc.categorize_by,
+		"group_by": doc.group_by,
 		"currency": doc.currency,
 		"project": [p.project_name for p in doc.project],
 		"show_opening_entries": 0,
@@ -177,21 +177,17 @@ def get_ar_filters(doc, entry):
 
 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_accounts_receivable.html"
-	if doc.report == "General Ledger":
-		template_path = (
-			"erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html"
-		)
-
-	process_soa_html = frappe.get_hooks("process_soa_html")
-	# fetching custom print format for Process Statement of Accounts
-	if process_soa_html and process_soa_html.get(doc.report):
-		template_path = process_soa_html[doc.report][-1]
+	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,
 		{
@@ -207,6 +203,7 @@ def get_html(doc, filters, entry, col, res, ageing):
 			else None,
 		},
 	)
+
 	html = frappe.render_template(
 		base_template_path,
 		{"body": html, "css": get_print_style(), "title": "Statement For " + entry.customer},
@@ -265,12 +262,9 @@ def get_recipients_and_cc(customer, doc):
 	recipients = []
 	for clist in doc.customers:
 		if clist.customer == customer:
-			if clist.billing_email:
-				for email in clist.billing_email.split(","):
-					recipients.append(email.strip())
+			recipients.append(clist.billing_email)
 			if doc.primary_mandatory and clist.primary_email:
-				for email in clist.primary_email.split(","):
-					recipients.append(email.strip())
+				recipients.append(clist.primary_email)
 	cc = []
 	if doc.cc_to != "":
 		try:
@@ -449,7 +443,7 @@ def send_auto_email():
 	selected = frappe.get_list(
 		"Process Statement Of Accounts",
 		filters={"enable_auto_email": 1},
-		or_filters={"to_date": today(), "posting_date": today()},
+		or_filters={"to_date": format_date(today()), "posting_date": format_date(today())},
 	)
 	for entry in selected:
 		send_emails(entry.name, from_scheduler=True)

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -29,10 +29,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		this.frm.set_query("expense_account", "items", function () {
 			return {
 				query: "erpnext.controllers.queries.get_expense_account",
-				filters: {
-					company: doc.company,
-					disabled: 0,
-				},
+				filters: { company: doc.company },
 			};
 		});
 	}
@@ -305,11 +302,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 
 		if (this.frm.doc.__onload && this.frm.doc.__onload.load_after_mapping) return;
 
-		let payment_terms_template = this.frm.doc.payment_terms_template;
-
-		erpnext.utils.get_party_details(
-			this.frm,
-			"erpnext.accounts.party.get_party_details",
+		erpnext.utils.get_party_details(this.frm, "erpnext.accounts.party.get_party_details",
 			{
 				posting_date: this.frm.doc.posting_date,
 				bill_date: this.frm.doc.bill_date,
@@ -327,14 +320,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 				me.frm.doc.tax_withholding_category = me.frm.supplier_tds;
 				me.frm.set_df_property("apply_tds", "read_only", me.frm.supplier_tds ? 0 : 1);
 				me.frm.set_df_property("tax_withholding_category", "hidden", me.frm.supplier_tds ? 0 : 1);
-
-				// while duplicating, don't change payment terms
-				if (me.frm.doc.__run_link_triggers === false) {
-					me.frm.set_value("payment_terms_template", payment_terms_template);
-					me.frm.refresh_field("payment_terms_template");
-				}
-			}
-		);
+			})
 	}
 
 	apply_tds(frm) {
@@ -380,8 +366,6 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		hide_fields(this.frm.doc);
 		if(cint(this.frm.doc.is_paid)) {
 			this.frm.set_value("allocate_advances_automatically", 0);
-			this.frm.set_value("payment_terms_template", "");
-			this.frm.set_value("payment_schedule", []);
 			if(!this.frm.doc.company) {
 				this.frm.set_value("is_paid", 0)
 				frappe.msgprint(__("Please specify Company to proceed"));

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -10,6 +10,7 @@ from frappe.utils import cint, cstr, flt, formatdate, get_link_to_form, getdate,
 
 import erpnext
 from erpnext.accounts.deferred_revenue import validate_service_stop_date
+from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
 from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger import (
 	validate_docs_for_deferred_accounting,
 	validate_docs_for_voucher_types,
@@ -32,7 +33,7 @@ from erpnext.accounts.general_ledger import (
 	merge_similar_entries,
 )
 from erpnext.accounts.party import get_due_date, get_party_account
-from erpnext.accounts.utils import get_account_currency, get_fiscal_year, update_voucher_outstanding
+from erpnext.accounts.utils import get_account_currency, get_fiscal_year
 from erpnext.assets.doctype.asset.asset import is_cwip_accounting_enabled
 from erpnext.assets.doctype.asset_category.asset_category import get_asset_category_account
 from erpnext.buying.utils import check_on_hold_or_closed_status
@@ -173,12 +174,7 @@ class PurchaseInvoice(BuyingController):
 			)
 		if not self.due_date:
 			self.due_date = get_due_date(
-				self.posting_date,
-				"Supplier",
-				self.supplier,
-				self.company,
-				self.bill_date,
-				template_name=self.payment_terms_template,
+				self.posting_date, "Supplier", self.supplier, self.company, self.bill_date
 			)
 
 		tds_category = frappe.db.get_value("Supplier", self.supplier, "tax_withholding_category")
@@ -665,12 +661,12 @@ class PurchaseInvoice(BuyingController):
 
 	def update_supplier_outstanding(self, update_outstanding):
 		if update_outstanding == "No":
-			update_voucher_outstanding(
-				voucher_type=self.doctype,
-				voucher_no=self.return_against if cint(self.is_return) and self.return_against else self.name,
-				account=self.credit_to,
-				party_type="Supplier",
-				party=self.supplier,
+			update_outstanding_amt(
+				self.credit_to,
+				"Supplier",
+				self.supplier,
+				self.doctype,
+				self.return_against if cint(self.is_return) and self.return_against else self.name,
 			)
 
 	def get_gl_entries(self, warehouse_account=None):
@@ -786,7 +782,7 @@ class PurchaseInvoice(BuyingController):
 			self.get_provisional_accounts()
 
 		for item in self.get("items"):
-			if flt(item.base_net_amount) or (self.get("update_stock") and item.valuation_rate):
+			if flt(item.base_net_amount):
 				account_currency = get_account_currency(item.expense_account)
 				if item.item_code:
 					frappe.get_cached_value("Item", item.item_code, "asset_category")
@@ -1021,9 +1017,6 @@ class PurchaseInvoice(BuyingController):
 	def get_provisional_accounts(self):
 		self.provisional_accounts = frappe._dict()
 		linked_purchase_receipts = set([d.purchase_receipt for d in self.items if d.purchase_receipt])
-		if not linked_purchase_receipts:
-			return
-
 		pr_items = frappe.get_all(
 			"Purchase Receipt Item",
 			filters={"parent": ("in", linked_purchase_receipts)},
@@ -1132,30 +1125,6 @@ class PurchaseInvoice(BuyingController):
 
 			warehouse_debit_amount = stock_amount
 
-		elif self.is_return and self.update_stock and (self.is_internal_supplier or not self.return_against):
-			net_rate = item.base_net_amount
-			stock_amount = net_rate + item.item_tax_amount + flt(item.landed_cost_voucher_amount)
-
-			if flt(stock_amount, net_amt_precision) != flt(warehouse_debit_amount, net_amt_precision):
-				cost_of_goods_sold_account = self.get_company_default("default_expense_account")
-				stock_adjustment_amt = stock_amount - warehouse_debit_amount
-
-				gl_entries.append(
-					self.get_gl_dict(
-						{
-							"account": cost_of_goods_sold_account,
-							"against": item.expense_account,
-							"debit": stock_adjustment_amt,
-							"debit_in_transaction_currency": stock_adjustment_amt / self.conversion_rate,
-							"remarks": self.get("remarks") or _("Stock Adjustment"),
-							"cost_center": item.cost_center,
-							"project": item.project or self.project,
-						},
-						account_currency,
-						item=item,
-					)
-				)
-
 		return warehouse_debit_amount
 
 	def make_tax_gl_entries(self, gl_entries):
@@ -1474,12 +1443,7 @@ class PurchaseInvoice(BuyingController):
 
 				if pi:
 					pi = pi[0][0]
-
-					frappe.throw(
-						_("Supplier Invoice No exists in Purchase Invoice {0}").format(
-							get_link_to_form("Purchase Invoice", pi)
-						)
-					)
+					frappe.throw(_("Supplier Invoice No exists in Purchase Invoice {0}").format(pi))
 
 	def update_billing_status_in_pr(self, update_modified=True):
 		if self.is_return and not self.update_billed_amount_in_purchase_receipt:

erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js

@@ -45,16 +45,12 @@ frappe.listview_settings["Purchase Invoice"] = {
 	},
 
 	onload: function (listview) {
-		if (frappe.model.can_create("Purchase Receipt")) {
-			listview.page.add_action_item(__("Purchase Receipt"), () => {
-				erpnext.bulk_transaction_processing.create(listview, "Purchase Invoice", "Purchase Receipt");
-			});
-		}
+		listview.page.add_action_item(__("Purchase Receipt"), () => {
+			erpnext.bulk_transaction_processing.create(listview, "Purchase Invoice", "Purchase Receipt");
+		});
 
-		if (frappe.model.can_create("Payment Entry")) {
-			listview.page.add_action_item(__("Payment"), () => {
-				erpnext.bulk_transaction_processing.create(listview, "Purchase Invoice", "Payment Entry");
-			});
-		}
+		listview.page.add_action_item(__("Payment"), () => {
+			erpnext.bulk_transaction_processing.create(listview, "Purchase Invoice", "Payment Entry");
+		});
 	},
 };

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -1643,30 +1643,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 
 		frappe.db.set_single_value("Buying Settings", "set_landed_cost_based_on_purchase_invoice_rate", 1)
 
-		# Cost of Item is zero in Purchase Receipt
-		pr = make_purchase_receipt(qty=1, rate=0)
-
-		stock_value_difference = frappe.db.get_value(
-			"Stock Ledger Entry",
-			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
-			"stock_value_difference",
-		)
-		self.assertEqual(stock_value_difference, 0)
-
-		pi = create_purchase_invoice_from_receipt(pr.name)
-		for row in pi.items:
-			row.rate = 150
-
-		pi.save()
-		pi.submit()
-
-		stock_value_difference = frappe.db.get_value(
-			"Stock Ledger Entry",
-			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
-			"stock_value_difference",
-		)
-		self.assertEqual(stock_value_difference, 150)
-
 		# Increase the cost of the item
 
 		pr = make_purchase_receipt(qty=1, rate=100)
@@ -1816,16 +1792,19 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		rate = flt(sle.stock_value_difference) / flt(sle.actual_qty)
 		self.assertAlmostEqual(rate, 500)
 
-	@change_settings("Accounts Settings", {"automatically_fetch_payment_terms": 1})
 	def test_payment_allocation_for_payment_terms(self):
 		from erpnext.buying.doctype.purchase_order.test_purchase_order import (
 			create_pr_against_po,
 			create_purchase_order,
 		)
+		from erpnext.selling.doctype.sales_order.test_sales_order import (
+			automatically_fetch_payment_terms,
+		)
 		from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
 			make_purchase_invoice as make_pi_from_pr,
 		)
 
+		automatically_fetch_payment_terms()
 		frappe.db.set_value(
 			"Payment Terms Template",
 			"_Test Payment Term Template",
@@ -1849,8 +1828,9 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 			1,
 		)
 		pi = make_pi_from_pr(pr.name)
-		self.assertEqual(pi.payment_schedule[0].payment_amount, 1000)
+		self.assertEqual(pi.payment_schedule[0].payment_amount, 2500)
 
+		automatically_fetch_payment_terms(enable=0)
 		frappe.db.set_value(
 			"Payment Terms Template",
 			"_Test Payment Term Template",
@@ -1980,78 +1960,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 
 		self.assertRaises(frappe.ValidationError, dr_note.save)
 
-	def test_apply_discount_on_grand_total(self):
-		"""
-		To test if after applying discount on grand total,
-		the grand total is calculated correctly without any rounding errors
-		"""
-		invoice = make_purchase_invoice(qty=2, rate=100, do_not_save=True, do_not_submit=True)
-		invoice.append(
-			"items",
-			{
-				"item_code": "_Test Item",
-				"qty": 1,
-				"rate": 21.39,
-			},
-		)
-		invoice.append(
-			"taxes",
-			{
-				"charge_type": "On Net Total",
-				"account_head": "_Test Account VAT - _TC",
-				"description": "VAT",
-				"rate": 15.5,
-			},
-		)
-
-		# the grand total here will be 255.71
-		invoice.disable_rounded_total = 1
-		# apply discount on grand total to adjust the grand total to 255
-		invoice.discount_amount = 0.71
-		invoice.save()
-
-		# check if grand total is 496 and not something like 254.99 due to rounding errors
-		self.assertEqual(invoice.grand_total, 255)
-
-	def test_apply_discount_on_grand_total_with_previous_row_total_tax(self):
-		"""
-		To test if after applying discount on grand total,
-		where the tax is calculated on previous row total, the grand total is calculated correctly
-		"""
-
-		invoice = make_purchase_invoice(qty=2, rate=100, do_not_save=True, do_not_submit=True)
-		invoice.extend(
-			"taxes",
-			[
-				{
-					"charge_type": "Actual",
-					"account_head": "_Test Account VAT - _TC",
-					"description": "VAT",
-					"tax_amount": 100,
-				},
-				{
-					"charge_type": "On Previous Row Amount",
-					"account_head": "_Test Account VAT - _TC",
-					"description": "VAT",
-					"row_id": 1,
-					"rate": 10,
-				},
-				{
-					"charge_type": "On Previous Row Total",
-					"account_head": "_Test Account VAT - _TC",
-					"description": "VAT",
-					"row_id": 1,
-					"rate": 10,
-				},
-			],
-		)
-
-		# the total here will be 340, so applying 40 discount
-		invoice.discount_amount = 40
-		invoice.save()
-
-		self.assertEqual(invoice.grand_total, 300)
-
 
 def check_gl_entries(
 	doc,

erpnext/accounts/doctype/purchase_invoice_advance/purchase_invoice_advance.json

@@ -14,8 +14,7 @@
   "advance_amount",
   "allocated_amount",
   "exchange_gain_loss",
-  "ref_exchange_rate",
-  "difference_posting_date"
+  "ref_exchange_rate"
  ],
  "fields": [
   {
@@ -31,7 +30,7 @@
    "width": "180px"
   },
   {
-   "columns": 2,
+   "columns": 3,
    "fieldname": "reference_name",
    "fieldtype": "Dynamic Link",
    "in_list_view": 1,
@@ -41,7 +40,7 @@
    "read_only": 1
   },
   {
-   "columns": 2,
+   "columns": 3,
    "fieldname": "remarks",
    "fieldtype": "Text",
    "in_list_view": 1,
@@ -112,20 +111,13 @@
    "label": "Reference Exchange Rate",
    "non_negative": 1,
    "read_only": 1
-  },
-  {
-   "columns": 2,
-   "fieldname": "difference_posting_date",
-   "fieldtype": "Date",
-   "in_list_view": 1,
-   "label": "Difference Posting Date"
   }
  ],
  "idx": 1,
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-12-20 12:04:46.729972",
+ "modified": "2021-09-26 15:47:28.167371",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice Advance",

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.py

@@ -6,8 +6,6 @@ from frappe import _, qb
 from frappe.model.document import Document
 from frappe.utils.data import comma_and
 
-from erpnext.stock import get_warehouse_account_map
-
 
 class RepostAccountingLedger(Document):
 	def __init__(self, *args, **kwargs):
@@ -29,7 +27,7 @@ class RepostAccountingLedger(Document):
 			latest_pcv = (
 				frappe.db.get_all(
 					"Period Closing Voucher",
-					filters={"company": self.company, "docstatus": 1},
+					filters={"company": self.company},
 					order_by="posting_date desc",
 					pluck="posting_date",
 					limit=1,
@@ -79,9 +77,6 @@ class RepostAccountingLedger(Document):
 			doc = frappe.get_doc(x.voucher_type, x.voucher_no)
 			if doc.doctype in ["Payment Entry", "Journal Entry"]:
 				gle_map = doc.build_gl_map()
-			elif doc.doctype == "Purchase Receipt":
-				warehouse_account_map = get_warehouse_account_map(doc.company)
-				gle_map = doc.get_gl_entries(warehouse_account_map)
 			else:
 				gle_map = doc.get_gl_entries()
 
@@ -151,7 +146,7 @@ def start_repost(account_repost_doc=str) -> None:
 				if doc.doctype in ["Sales Invoice", "Purchase Invoice"]:
 					if not repost_doc.delete_cancelled_entries:
 						doc.docstatus = 2
-						doc.make_gl_entries_on_cancel(from_repost=True)
+						doc.make_gl_entries_on_cancel()
 
 					doc.docstatus = 1
 					if doc.doctype == "Sales Invoice":
@@ -160,14 +155,6 @@ def start_repost(account_repost_doc=str) -> None:
 						doc.force_set_against_expense_account()
 					doc.make_gl_entries()
 
-				elif doc.doctype == "Purchase Receipt":
-					if not repost_doc.delete_cancelled_entries:
-						doc.docstatus = 2
-						doc.make_gl_entries_on_cancel(from_repost=True)
-
-					doc.docstatus = 1
-					doc.make_gl_entries(from_repost=True)
-
 				elif doc.doctype in ["Payment Entry", "Journal Entry", "Expense Claim"]:
 					if not repost_doc.delete_cancelled_entries:
 						doc.make_gl_entries(1)

erpnext/accounts/doctype/repost_accounting_ledger/test_repost_accounting_ledger.py

@@ -12,8 +12,6 @@ from erpnext.accounts.doctype.payment_request.payment_request import make_paymen
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
 from erpnext.accounts.utils import get_fiscal_year
-from erpnext.stock.doctype.item.test_item import make_item
-from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import get_gl_entries, make_purchase_receipt
 
 
 class TestRepostAccountingLedger(AccountsTestMixin, FrappeTestCase):
@@ -204,81 +202,9 @@ class TestRepostAccountingLedger(AccountsTestMixin, FrappeTestCase):
 		self.assertIsNotNone(frappe.db.exists("GL Entry", {"voucher_no": si.name, "is_cancelled": 1}))
 		self.assertIsNotNone(frappe.db.exists("GL Entry", {"voucher_no": pe.name, "is_cancelled": 1}))
 
-	def test_06_repost_purchase_receipt(self):
-		from erpnext.accounts.doctype.account.test_account import create_account
-
-		provisional_account = create_account(
-			account_name="Provision Account",
-			parent_account="Current Liabilities - _TC",
-			company=self.company,
-		)
-
-		another_provisional_account = create_account(
-			account_name="Another Provision Account",
-			parent_account="Current Liabilities - _TC",
-			company=self.company,
-		)
-
-		company = frappe.get_doc("Company", self.company)
-		company.enable_provisional_accounting_for_non_stock_items = 1
-		company.default_provisional_account = provisional_account
-		company.save()
-
-		test_cc = company.cost_center
-		default_expense_account = company.default_expense_account
-
-		item = make_item(properties={"is_stock_item": 0})
-
-		pr = make_purchase_receipt(company=self.company, item_code=item.name, rate=1000.0, qty=1.0)
-		pr_gl_entries = get_gl_entries(pr.doctype, pr.name, skip_cancelled=True)
-		expected_pr_gles = [
-			{"account": provisional_account, "debit": 0.0, "credit": 1000.0, "cost_center": test_cc},
-			{"account": default_expense_account, "debit": 1000.0, "credit": 0.0, "cost_center": test_cc},
-		]
-		self.assertEqual(expected_pr_gles, pr_gl_entries)
-
-		# change the provisional account
-		frappe.db.set_value(
-			"Purchase Receipt Item",
-			pr.items[0].name,
-			"provisional_expense_account",
-			another_provisional_account,
-		)
-
-		repost_doc = frappe.new_doc("Repost Accounting Ledger")
-		repost_doc.company = self.company
-		repost_doc.delete_cancelled_entries = True
-		repost_doc.append("vouchers", {"voucher_type": pr.doctype, "voucher_no": pr.name})
-		repost_doc.save().submit()
-
-		pr_gles_after_repost = get_gl_entries(pr.doctype, pr.name, skip_cancelled=True)
-		expected_pr_gles_after_repost = [
-			{"account": default_expense_account, "debit": 1000.0, "credit": 0.0, "cost_center": test_cc},
-			{"account": another_provisional_account, "debit": 0.0, "credit": 1000.0, "cost_center": test_cc},
-		]
-		self.assertEqual(len(pr_gles_after_repost), len(expected_pr_gles_after_repost))
-		self.assertEqual(expected_pr_gles_after_repost, pr_gles_after_repost)
-
-		# teardown
-		repost_doc.cancel()
-		repost_doc.delete()
-
-		pr.reload()
-		pr.cancel()
-
-		company.enable_provisional_accounting_for_non_stock_items = 0
-		company.default_provisional_account = None
-		company.save()
-
 
 def update_repost_settings():
-	allowed_types = [
-		"Sales Invoice",
-		"Purchase Invoice",
-		"Payment Entry",
-		"Journal Entry",
-		"Purchase Receipt",
-	]
+	allowed_types = ["Sales Invoice", "Purchase Invoice", "Payment Entry", "Journal Entry"]
 	repost_settings = frappe.get_doc("Repost Accounting Ledger Settings")
 	for x in allowed_types:
 		repost_settings.append("allowed_types", {"document_type": x, "allowed": True})

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -9,10 +9,6 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 	setup(doc) {
 		this.setup_posting_date_time_check();
 		super.setup(doc);
-		this.frm.make_methods = {
-			Dunning: this.make_dunning.bind(this),
-			"Invoice Discounting": this.make_invoice_discounting.bind(this),
-		};
 	}
 	company() {
 		super.company();
@@ -98,35 +94,26 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 				}
 			}
 
-			if (doc.outstanding_amount > 0) {
-				this.frm.add_custom_button(
-					__("Payment Request"),
-					function () {
-						me.make_payment_request();
-					},
-					__("Create")
-				);
-				this.frm.add_custom_button(
-					__("Invoice Discounting"),
-					this.make_invoice_discounting.bind(this),
-					__("Create")
-				);
+			if (doc.outstanding_amount>0) {
+				cur_frm.add_custom_button(__('Payment Request'), function() {
+					me.make_payment_request();
+				}, __('Create'));
 
-				const payment_is_overdue = doc.payment_schedule
-					.map((row) => Date.parse(row.due_date) < Date.now())
-					.reduce((prev, current) => prev || current, false);
+				cur_frm.add_custom_button(__('Invoice Discounting'), function() {
+					cur_frm.events.create_invoice_discounting(cur_frm);
+				}, __('Create'));
 
-				if (payment_is_overdue) {
-					this.frm.add_custom_button(__("Dunning"), this.make_dunning.bind(this), __("Create"));
+				if (doc.due_date < frappe.datetime.get_today()) {
+					cur_frm.add_custom_button(__('Dunning'), function() {
+						cur_frm.events.create_dunning(cur_frm);
+					}, __('Create'));
 				}
 			}
 
 			if (doc.docstatus === 1) {
-				this.frm.add_custom_button(
-					__("Maintenance Schedule"),
-					this.make_maintenance_schedule.bind(this),
-					__("Create")
-				);
+				cur_frm.add_custom_button(__('Maintenance Schedule'), function () {
+					cur_frm.cscript.make_maintenance_schedule();
+				}, __('Create'));
 			}
 
 			if(!doc.auto_repeat) {
@@ -159,20 +146,6 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 		erpnext.accounts.unreconcile_payment.add_unreconcile_btn(me.frm);
 	}
 
-	make_invoice_discounting() {
-		frappe.model.open_mapped_doc({
-			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_invoice_discounting",
-			frm: this.frm,
-		});
-	}
-
-	make_dunning() {
-		frappe.model.open_mapped_doc({
-			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_dunning",
-			frm: this.frm,
-		});
-	}
-
 	make_maintenance_schedule() {
 		frappe.model.open_mapped_doc({
 			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.make_maintenance_schedule",
@@ -694,6 +667,20 @@ frappe.ui.form.on('Sales Invoice', {
 			}
 		}
 
+		frm.set_query('company_address', function(doc) {
+			if(!doc.company) {
+				frappe.throw(__('Please set Company'));
+			}
+
+			return {
+				query: 'frappe.contacts.doctype.address.address.address_query',
+				filters: {
+					link_doctype: 'Company',
+					link_name: doc.company
+				}
+			};
+		});
+
 		frm.set_query('pos_profile', function(doc) {
 			if(!doc.company) {
 				frappe.throw(_('Please set Company'));
@@ -975,6 +962,20 @@ frappe.ui.form.on('Sales Invoice', {
 			frm.set_df_property('return_against', 'label', __('Adjustment Against'));
 		}
 	},
+
+	create_invoice_discounting: function(frm) {
+		frappe.model.open_mapped_doc({
+			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_invoice_discounting",
+			frm: frm
+		});
+	},
+
+	create_dunning: function(frm) {
+		frappe.model.open_mapped_doc({
+			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_dunning",
+			frm: frm
+		});
+	}
 });
 
 frappe.ui.form.on("Sales Invoice Timesheet", {

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -160,9 +160,8 @@
   "dispatch_address",
   "company_address_section",
   "company_address",
-  "company_address_display",
   "company_addr_col_break",
-  "company_contact_person",
+  "company_address_display",
   "terms_tab",
   "payment_schedule_section",
   "ignore_default_payment_terms_template",
@@ -2172,13 +2171,6 @@
    "label": "Update Outstanding for Self",
    "no_copy": 1,
    "print_hide": 1
-  },
-  {
-   "fieldname": "company_contact_person",
-   "fieldtype": "Link",
-   "label": "Company Contact Person",
-   "options": "Contact",
-   "print_hide": 1
   }
  ],
  "icon": "fa fa-file-text",
@@ -2191,7 +2183,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2024-11-26 12:34:09.110690",
+ "modified": "2024-07-18 15:30:39.428519",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -24,11 +24,7 @@ from erpnext.accounts.doctype.tax_withholding_category.tax_withholding_category
 )
 from erpnext.accounts.general_ledger import get_round_off_account_and_cost_center
 from erpnext.accounts.party import get_due_date, get_party_account, get_party_details
-from erpnext.accounts.utils import (
-	cancel_exchange_gain_loss_journal,
-	get_account_currency,
-	update_voucher_outstanding,
-)
+from erpnext.accounts.utils import cancel_exchange_gain_loss_journal, get_account_currency
 from erpnext.assets.doctype.asset.depreciation import (
 	depreciate_asset,
 	get_disposal_account_and_cost_center,
@@ -91,8 +87,8 @@ class SalesInvoice(SellingController):
 			self.indicator_title = _("Paid")
 
 	def validate(self):
-		self.validate_auto_set_posting_time()
 		super().validate()
+		self.validate_auto_set_posting_time()
 
 		if not (self.is_pos or self.is_debit_note):
 			self.so_dn_required()
@@ -498,13 +494,7 @@ class SalesInvoice(SellingController):
 				"Account", self.debit_to, "account_currency", cache=True
 			)
 		if not self.due_date and self.customer:
-			self.due_date = get_due_date(
-				self.posting_date,
-				"Customer",
-				self.customer,
-				self.company,
-				template_name=self.payment_terms_template,
-			)
+			self.due_date = get_due_date(self.posting_date, "Customer", self.customer, self.company)
 
 		super().set_missing_values(for_validate)
 
@@ -1025,17 +1015,18 @@ class SalesInvoice(SellingController):
 
 				self.make_exchange_gain_loss_journal()
 			elif self.docstatus == 2:
+				cancel_exchange_gain_loss_journal(frappe._dict(doctype=self.doctype, name=self.name))
 				make_reverse_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
 
 			if update_outstanding == "No":
-				update_voucher_outstanding(
-					voucher_type=self.doctype,
-					voucher_no=self.return_against
-					if cint(self.is_return) and self.return_against
-					else self.name,
-					account=self.debit_to,
-					party_type="Customer",
-					party=self.customer,
+				from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
+
+				update_outstanding_amt(
+					self.debit_to,
+					"Customer",
+					self.customer,
+					self.doctype,
+					self.return_against if cint(self.is_return) and self.return_against else self.name,
 				)
 
 		elif self.docstatus == 2 and cint(self.update_stock) and cint(auto_accounting_for_stock):
@@ -1565,12 +1556,8 @@ class SalesInvoice(SellingController):
 				)
 
 	def update_project(self):
-		unique_projects = list(set([d.project for d in self.get("items") if d.project]))
-		if self.project and self.project not in unique_projects:
-			unique_projects.append(self.project)
-
-		for p in unique_projects:
-			project = frappe.get_doc("Project", p)
+		if self.project:
+			project = frappe.get_doc("Project", self.project)
 			project.update_billed_amount()
 			project.db_update()
 

erpnext/accounts/doctype/sales_invoice/sales_invoice_list.js

@@ -32,16 +32,12 @@ frappe.listview_settings["Sales Invoice"] = {
 	right_column: "grand_total",
 
 	onload: function (listview) {
-		if (frappe.model.can_create("Delivery Note")) {
-			listview.page.add_action_item(__("Delivery Note"), () => {
-				erpnext.bulk_transaction_processing.create(listview, "Sales Invoice", "Delivery Note");
-			});
-		}
+		listview.page.add_action_item(__("Delivery Note"), () => {
+			erpnext.bulk_transaction_processing.create(listview, "Sales Invoice", "Delivery Note");
+		});
 
-		if (frappe.model.can_create("Payment Entry")) {
-			listview.page.add_action_item(__("Payment"), () => {
-				erpnext.bulk_transaction_processing.create(listview, "Sales Invoice", "Payment Entry");
-			});
-		}
+		listview.page.add_action_item(__("Payment"), () => {
+			erpnext.bulk_transaction_processing.create(listview, "Sales Invoice", "Payment Entry");
+		});
 	},
 };

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -36,7 +36,6 @@ from erpnext.stock.doctype.stock_entry.test_stock_entry import (
 from erpnext.stock.doctype.stock_reconciliation.test_stock_reconciliation import (
 	create_stock_reconciliation,
 )
-from erpnext.stock.get_item_details import get_item_tax_map
 from erpnext.stock.utils import get_incoming_rate, get_stock_balance
 
 
@@ -416,9 +415,9 @@ class TestSalesInvoice(FrappeTestCase):
 			for i, k in enumerate(expected_values["keys"]):
 				self.assertEqual(d.get(k), expected_values[d.account_head][i])
 
-		self.assertEqual(si.base_grand_total, 1500)
-		self.assertEqual(si.grand_total, 1500)
-		self.assertEqual(si.rounding_adjustment, 0)
+		self.assertEqual(si.base_grand_total, 1500.01)
+		self.assertEqual(si.grand_total, 1500.01)
+		self.assertEqual(si.rounding_adjustment, -0.01)
 
 	def test_discount_amount_gl_entry(self):
 		frappe.db.set_value("Company", "_Test Company", "round_off_account", "Round Off - _TC")
@@ -1773,6 +1772,17 @@ class TestSalesInvoice(FrappeTestCase):
 
 		self.assertTrue(gle)
 
+	def test_invoice_exchange_rate(self):
+		si = create_sales_invoice(
+			customer="_Test Customer USD",
+			debit_to="_Test Receivable USD - _TC",
+			currency="USD",
+			conversion_rate=1,
+			do_not_save=1,
+		)
+
+		self.assertRaises(frappe.ValidationError, si.save)
+
 	def test_invalid_currency(self):
 		# Customer currency = USD
 
@@ -2807,80 +2817,13 @@ class TestSalesInvoice(FrappeTestCase):
 		item.save()
 
 		sales_invoice = create_sales_invoice(item="T Shirt", rate=700, do_not_submit=True)
-		item_tax_map = get_item_tax_map(
-			company=sales_invoice.company,
-			item_tax_template=sales_invoice.items[0].item_tax_template,
-		)
-
 		self.assertEqual(sales_invoice.items[0].item_tax_template, "_Test Account Excise Duty @ 12 - _TC")
-		self.assertEqual(sales_invoice.items[0].item_tax_rate, item_tax_map)
 
 		# Apply discount
 		sales_invoice.apply_discount_on = "Net Total"
 		sales_invoice.discount_amount = 300
 		sales_invoice.save()
-
-		item_tax_map = get_item_tax_map(
-			company=sales_invoice.company,
-			item_tax_template=sales_invoice.items[0].item_tax_template,
-		)
-
 		self.assertEqual(sales_invoice.items[0].item_tax_template, "_Test Account Excise Duty @ 10 - _TC")
-		self.assertEqual(sales_invoice.items[0].item_tax_rate, item_tax_map)
-
-	def test_item_tax_template_change_with_grand_total_discount(self):
-		"""
-		Test that when item tax template changes due to discount on Grand Total,
-		the tax calculations are consistent.
-		"""
-		item = create_item("Test Item With Multiple Tax Templates")
-
-		item.set("taxes", [])
-		item.append(
-			"taxes",
-			{
-				"item_tax_template": "_Test Account Excise Duty @ 10 - _TC",
-				"minimum_net_rate": 0,
-				"maximum_net_rate": 500,
-			},
-		)
-
-		item.append(
-			"taxes",
-			{
-				"item_tax_template": "_Test Account Excise Duty @ 12 - _TC",
-				"minimum_net_rate": 501,
-				"maximum_net_rate": 1000,
-			},
-		)
-
-		item.save()
-
-		si = create_sales_invoice(item=item.name, rate=700, do_not_save=True)
-		si.append(
-			"taxes",
-			{
-				"charge_type": "On Net Total",
-				"account_head": "_Test Account Excise Duty - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"description": "Excise Duty",
-				"rate": 0,
-			},
-		)
-		si.insert()
-
-		self.assertEqual(si.items[0].item_tax_template, "_Test Account Excise Duty @ 12 - _TC")
-
-		si.apply_discount_on = "Grand Total"
-		si.discount_amount = 300
-		si.save()
-
-		# Verify template changed to 10%
-		self.assertEqual(si.items[0].item_tax_template, "_Test Account Excise Duty @ 10 - _TC")
-		self.assertEqual(si.taxes[0].tax_amount, 70)  # 10% of 700
-		self.assertEqual(si.grand_total, 470)  # 700 + 70 - 300
-
-		si.submit()
 
 	@change_settings("Selling Settings", {"enable_discount_accounting": 1})
 	def test_sales_invoice_with_discount_accounting_enabled(self):
@@ -3341,7 +3284,6 @@ class TestSalesInvoice(FrappeTestCase):
 		si.posting_date = getdate()
 		si.submit()
 
-	@change_settings("Accounts Settings", {"over_billing_allowance": 0})
 	def test_over_billing_case_against_delivery_note(self):
 		"""
 		Test a case where duplicating the item with qty = 1 in the invoice
@@ -3349,23 +3291,24 @@ class TestSalesInvoice(FrappeTestCase):
 		"""
 		from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
 
+		over_billing_allowance = frappe.db.get_single_value("Accounts Settings", "over_billing_allowance")
+		frappe.db.set_value("Accounts Settings", None, "over_billing_allowance", 0)
+
 		dn = create_delivery_note()
 		dn.submit()
 
 		si = make_sales_invoice(dn.name)
+		# make a copy of first item and add it to invoice
 		item_copy = frappe.copy_doc(si.items[0])
-		si.save()
-
-		si.items = []  # Clear existing items
 		si.append("items", item_copy)
 		si.save()
 
-		si.append("items", item_copy)
 		with self.assertRaises(frappe.ValidationError) as err:
-			si.save()
+			si.submit()
 
 		self.assertTrue("cannot overbill" in str(err.exception).lower())
-		dn.cancel()
+
+		frappe.db.set_value("Accounts Settings", None, "over_billing_allowance", over_billing_allowance)
 
 	@change_settings(
 		"Accounts Settings",
@@ -3817,186 +3760,6 @@ class TestSalesInvoice(FrappeTestCase):
 		self.assertTrue(jv)
 		self.assertEqual(jv[0], si.grand_total)
 
-	@change_settings("Accounts Settings", {"enable_common_party_accounting": True})
-	def test_common_party_with_different_currency_in_debtor_and_creditor(self):
-		from erpnext.accounts.doctype.account.test_account import create_account
-		from erpnext.accounts.doctype.opening_invoice_creation_tool.test_opening_invoice_creation_tool import (
-			make_customer,
-		)
-		from erpnext.accounts.doctype.party_link.party_link import create_party_link
-		from erpnext.buying.doctype.supplier.test_supplier import create_supplier
-		from erpnext.setup.utils import get_exchange_rate
-
-		creditors = create_account(
-			account_name="Creditors INR",
-			parent_account="Accounts Payable - _TC",
-			company="_Test Company",
-			account_currency="INR",
-			account_type="Payable",
-		)
-		debtors = create_account(
-			account_name="Debtors USD",
-			parent_account="Accounts Receivable - _TC",
-			company="_Test Company",
-			account_currency="USD",
-			account_type="Receivable",
-		)
-
-		# create a customer
-		customer = make_customer(customer="_Test Common Party USD")
-		cust_doc = frappe.get_doc("Customer", customer)
-		cust_doc.default_currency = "USD"
-		test_account_details = {
-			"company": "_Test Company",
-			"account": debtors,
-		}
-		cust_doc.append("accounts", test_account_details)
-		cust_doc.save()
-
-		# create a supplier
-		supplier = create_supplier(supplier_name="_Test Common Party INR").name
-		supp_doc = frappe.get_doc("Supplier", supplier)
-		supp_doc.default_currency = "INR"
-		test_account_details = {
-			"company": "_Test Company",
-			"account": creditors,
-		}
-		supp_doc.append("accounts", test_account_details)
-		supp_doc.save()
-
-		# create a party link between customer & supplier
-		create_party_link("Supplier", supplier, customer)
-
-		# create a sales invoice
-		si = create_sales_invoice(
-			customer=customer,
-			currency="USD",
-			conversion_rate=get_exchange_rate("USD", "INR"),
-			debit_to=debtors,
-			do_not_save=1,
-		)
-		si.party_account_currency = "USD"
-		si.save()
-		si.submit()
-
-		# check outstanding of sales invoice
-		si.reload()
-		self.assertEqual(si.status, "Paid")
-		self.assertEqual(flt(si.outstanding_amount), 0.0)
-
-		# check creation of journal entry
-		jv = frappe.get_all(
-			"Journal Entry Account",
-			{
-				"account": si.debit_to,
-				"party_type": "Customer",
-				"party": si.customer,
-				"reference_type": si.doctype,
-				"reference_name": si.name,
-			},
-			pluck="credit_in_account_currency",
-		)
-		self.assertTrue(jv)
-		self.assertEqual(jv[0], si.grand_total)
-
-	def test_total_billed_amount(self):
-		si = create_sales_invoice(do_not_submit=True)
-
-		project = frappe.new_doc("Project")
-		project.company = "_Test Company"
-		project.project_name = "Test Total Billed Amount"
-		project.save()
-
-		si.project = project.name
-		si.save()
-		si.submit()
-
-		doc = frappe.get_doc("Project", project.name)
-		self.assertEqual(doc.total_billed_amount, si.grand_total)
-
-	def test_create_return_invoice_for_self_update(self):
-		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
-		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-		from erpnext.controllers.sales_and_purchase_return import make_return_doc
-
-		invoice = create_sales_invoice()
-
-		payment_entry = get_payment_entry(dt=invoice.doctype, dn=invoice.name)
-		payment_entry.reference_no = "test001"
-		payment_entry.reference_date = getdate()
-
-		payment_entry.save()
-		payment_entry.submit()
-
-		r_invoice = make_return_doc(invoice.doctype, invoice.name)
-
-		r_invoice.update_outstanding_for_self = 0
-		r_invoice.save()
-
-		self.assertEqual(r_invoice.update_outstanding_for_self, 1)
-
-		r_invoice.submit()
-
-		self.assertNotEqual(r_invoice.outstanding_amount, 0)
-
-		invoice.reload()
-
-		self.assertEqual(invoice.outstanding_amount, 0)
-
-	def test_system_generated_exchange_gain_or_loss_je_after_repost(self):
-		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
-		from erpnext.accounts.doctype.repost_accounting_ledger.test_repost_accounting_ledger import (
-			update_repost_settings,
-		)
-
-		update_repost_settings()
-
-		si = create_sales_invoice(
-			customer="_Test Customer USD",
-			debit_to="_Test Receivable USD - _TC",
-			currency="USD",
-			conversion_rate=80,
-		)
-
-		pe = get_payment_entry("Sales Invoice", si.name)
-		pe.reference_no = "10"
-		pe.reference_date = nowdate()
-		pe.paid_from_account_currency = si.currency
-		pe.paid_to_account_currency = "INR"
-		pe.source_exchange_rate = 85
-		pe.target_exchange_rate = 1
-		pe.paid_amount = si.outstanding_amount
-		pe.received_amount = 8500
-		pe.insert()
-		pe.submit()
-
-		ral = frappe.new_doc("Repost Accounting Ledger")
-		ral.company = si.company
-		ral.append("vouchers", {"voucher_type": si.doctype, "voucher_no": si.name})
-		ral.save()
-		ral.submit()
-
-		je = frappe.qb.DocType("Journal Entry")
-		jea = frappe.qb.DocType("Journal Entry Account")
-		q = (
-			(
-				frappe.qb.from_(je)
-				.join(jea)
-				.on(je.name == jea.parent)
-				.select(je.docstatus)
-				.where(
-					(je.voucher_type == "Exchange Gain Or Loss")
-					& (jea.reference_name == si.name)
-					& (jea.reference_type == "Sales Invoice")
-					& (je.is_system_generated == 1)
-				)
-			)
-			.limit(1)
-			.run()
-		)
-
-		self.assertEqual(q[0][0], 1)
-
 
 def check_gl_entries(doc, voucher_no, expected_gle, posting_date):
 	gl_entries = frappe.db.sql(

erpnext/accounts/doctype/sales_invoice_advance/sales_invoice_advance.json

@@ -14,8 +14,7 @@
   "advance_amount",
   "allocated_amount",
   "exchange_gain_loss",
-  "ref_exchange_rate",
-  "difference_posting_date"
+  "ref_exchange_rate"
  ],
  "fields": [
   {
@@ -31,7 +30,7 @@
    "width": "250px"
   },
   {
-   "columns": 2,
+   "columns": 3,
    "fieldname": "reference_name",
    "fieldtype": "Dynamic Link",
    "in_list_view": 1,
@@ -42,7 +41,7 @@
    "read_only": 1
   },
   {
-   "columns": 2,
+   "columns": 3,
    "fieldname": "remarks",
    "fieldtype": "Text",
    "in_list_view": 1,
@@ -113,20 +112,13 @@
    "label": "Reference Exchange Rate",
    "non_negative": 1,
    "read_only": 1
-  },
-  {
-   "columns": 2,
-   "fieldname": "difference_posting_date",
-   "fieldtype": "Date",
-   "in_list_view": 1,
-   "label": "Difference Posting Date"
   }
  ],
  "idx": 1,
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-12-20 11:58:28.962370",
+ "modified": "2021-09-26 15:47:46.911595",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Advance",

erpnext/accounts/doctype/share_balance/share_balance.json

@@ -80,7 +80,7 @@
    "collapsible": 0, 
    "columns": 0, 
    "fieldname": "rate", 
-   "fieldtype": "Currency", 
+   "fieldtype": "Int", 
    "hidden": 0, 
    "ignore_user_permissions": 0, 
    "ignore_xss_filter": 0, 
@@ -102,7 +102,7 @@
    "search_index": 0, 
    "set_only_once": 0, 
    "unique": 0
-  },
+  }, 
   {
    "allow_bulk_edit": 0, 
    "allow_on_submit": 0, 
@@ -199,7 +199,7 @@
    "collapsible": 0, 
    "columns": 0, 
    "fieldname": "amount", 
-   "fieldtype": "Currency", 
+   "fieldtype": "Int", 
    "hidden": 0, 
    "ignore_user_permissions": 0, 
    "ignore_xss_filter": 0, 
@@ -221,7 +221,7 @@
    "search_index": 0, 
    "set_only_once": 0, 
    "unique": 0
-  },
+  }, 
   {
    "allow_bulk_edit": 0, 
    "allow_on_submit": 0, 
@@ -324,7 +324,7 @@
  "issingle": 0, 
  "istable": 1, 
  "max_attachments": 0, 
- "modified": "2025-12-10 08:06:40.611761", 
+ "modified": "2018-01-10 18:32:36.201124", 
  "modified_by": "Administrator", 
  "module": "Accounts", 
  "name": "Share Balance", 
@@ -339,4 +339,4 @@
  "sort_order": "DESC", 
  "track_changes": 1, 
  "track_seen": 0
-}
+}

erpnext/accounts/doctype/tax_withheld_vouchers/tax_withheld_vouchers.json

@@ -13,15 +13,17 @@
  "fields": [
   {
    "fieldname": "voucher_type",
-   "fieldtype": "Data",
+   "fieldtype": "Link",
    "in_list_view": 1,
-   "label": "Voucher Type"
+   "label": "Voucher Type",
+   "options": "DocType"
   },
   {
    "fieldname": "voucher_name",
-   "fieldtype": "Data",
+   "fieldtype": "Dynamic Link",
    "in_list_view": 1,
-   "label": "Voucher Name"
+   "label": "Voucher Name",
+   "options": "voucher_type"
   },
   {
    "fieldname": "taxable_amount",
@@ -34,7 +36,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-02-05 16:39:14.863698",
+ "modified": "2023-01-13 13:40:41.479208",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Tax Withheld Vouchers",

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.json

@@ -75,7 +75,7 @@
   },
   {
    "default": "0",
-   "description": "Only payment entries with apply tax withholding unchecked will be considered for checking cumulative threshold breach",
+   "description": "Even invoices with apply tax withholding unchecked will be considered for checking cumulative threshold breach",
    "fieldname": "consider_party_ledger_amount",
    "fieldtype": "Check",
    "label": "Consider Entire Party Ledger Amount",
@@ -102,11 +102,10 @@
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2025-07-30 07:13:51.785735",
+ "modified": "2021-07-27 21:47:34.396071",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Tax Withholding Category",
- "naming_rule": "Set by user",
  "owner": "Administrator",
  "permissions": [
   {
@@ -149,4 +148,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py

@@ -124,9 +124,6 @@ def get_party_tax_withholding_details(inv, tax_withholding_category=None):
 	cost_center = get_cost_center(inv)
 	tax_row.update({"cost_center": cost_center})
 
-	if cint(tax_details.round_off_tax_amount):
-		inv.round_off_applicable_accounts_for_tax_withholding = tax_details.account_head
-
 	if inv.doctype == "Purchase Invoice":
 		return tax_row, tax_deducted_on_advances, voucher_wise_amount
 	else:
@@ -218,14 +215,14 @@ def get_tax_row_for_tds(tax_details, tax_amount):
 	}
 
 
-def get_lower_deduction_certificate(company, posting_date, tax_details, pan_no):
+def get_lower_deduction_certificate(company, tax_details, pan_no):
 	ldc_name = frappe.db.get_value(
 		"Lower Deduction Certificate",
 		{
 			"pan_no": pan_no,
 			"tax_withholding_category": tax_details.tax_withholding_category,
-			"valid_from": ("<=", posting_date),
-			"valid_upto": (">=", posting_date),
+			"valid_from": (">=", tax_details.from_date),
+			"valid_upto": ("<=", tax_details.to_date),
 			"company": company,
 		},
 		"name",
@@ -236,7 +233,7 @@ def get_lower_deduction_certificate(company, posting_date, tax_details, pan_no):
 
 
 def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=None):
-	vouchers, voucher_wise_amount, zero_rate_ldc_invoices = get_invoice_vouchers(
+	vouchers, voucher_wise_amount = get_invoice_vouchers(
 		parties, tax_details, inv.company, party_type=party_type
 	)
 
@@ -273,7 +270,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(inv.company, posting_date, 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:
@@ -290,8 +287,7 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 			# once tds is deducted, not need to add vouchers in the invoice
 			voucher_wise_amount = {}
 		else:
-			taxable_vouchers = list(set(vouchers) - set(zero_rate_ldc_invoices))
-			tax_amount = get_tds_amount(ldc, parties, inv, tax_details, taxable_vouchers)
+			tax_amount = get_tds_amount(ldc, parties, inv, tax_details, vouchers)
 
 	elif party_type == "Customer":
 		if tax_deducted:
@@ -310,33 +306,12 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 
 def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
 	doctype = "Purchase Invoice" if party_type == "Supplier" else "Sales Invoice"
-	field = [
-		"name",
-		"base_tax_withholding_net_total as base_net_total" if party_type == "Supplier" else "base_net_total",
-		"posting_date",
-	]
+	field = (
+		"base_tax_withholding_net_total as base_net_total" if party_type == "Supplier" else "base_net_total"
+	)
 	voucher_wise_amount = {}
 	vouchers = []
 
-	ldcs = frappe.db.get_all(
-		"Lower Deduction Certificate",
-		filters={
-			"valid_from": [">=", tax_details.from_date],
-			"valid_upto": ["<=", tax_details.to_date],
-			"company": company,
-			"supplier": ["in", parties],
-		},
-		fields=["supplier", "valid_from", "valid_upto", "rate"],
-	)
-
-	doctype = "Purchase Invoice" if party_type == "Supplier" else "Sales Invoice"
-	field = [
-		"base_tax_withholding_net_total as base_net_total" if party_type == "Supplier" else "base_net_total",
-		"name",
-		"grand_total",
-		"posting_date",
-	]
-
 	filters = {
 		"company": company,
 		frappe.scrub(party_type): ["in", parties],
@@ -350,31 +325,11 @@ def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
 			{"apply_tds": 1, "tax_withholding_category": tax_details.get("tax_withholding_category")}
 		)
 
-	invoices_details = frappe.get_all(doctype, filters=filters, fields=field)
+	invoices_details = frappe.get_all(doctype, filters=filters, fields=["name", field])
 
-	ldcs = frappe.db.get_all(
-		"Lower Deduction Certificate",
-		filters={
-			"valid_from": [">=", tax_details.from_date],
-			"valid_upto": ["<=", tax_details.to_date],
-			"company": company,
-			"supplier": ["in", parties],
-			"rate": 0,
-		},
-		fields=["name", "supplier", "valid_from", "valid_upto"],
-	)
-
-	zero_rate_ldc_invoices = []
 	for d in invoices_details:
 		vouchers.append(d.name)
-		_voucher_detail = {"amount": d.base_net_total, "voucher_type": doctype}
-
-		if ldc := [x for x in ldcs if d.posting_date >= x.valid_from and d.posting_date <= x.valid_upto]:
-			if ldc[0].supplier in parties:
-				_voucher_detail.update({"amount": 0})
-				zero_rate_ldc_invoices.append(d.name)
-
-		voucher_wise_amount.update({d.name: _voucher_detail})
+		voucher_wise_amount.update({d.name: {"amount": d.base_net_total, "voucher_type": doctype}})
 
 	journal_entries_details = frappe.db.sql(
 		"""
@@ -405,7 +360,7 @@ def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
 			vouchers.append(d.name)
 			voucher_wise_amount.update({d.name: {"amount": d.amount, "voucher_type": "Journal Entry"}})
 
-	return vouchers, voucher_wise_amount, zero_rate_ldc_invoices
+	return vouchers, voucher_wise_amount
 
 
 def get_payment_entry_vouchers(parties, tax_details, company, party_type="Supplier"):
@@ -552,7 +507,7 @@ def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
 	)
 
 	supp_credit_amt = supp_jv_credit_amt
-	supp_credit_amt += inv.get("tax_withholding_net_total", 0)
+	supp_credit_amt += inv.tax_withholding_net_total
 
 	for type in payment_entry_amounts:
 		if type.payment_type == "Pay":
@@ -564,15 +519,13 @@ def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
 	cumulative_threshold = tax_details.get("cumulative_threshold", 0)
 
 	if inv.doctype != "Payment Entry":
-		tax_withholding_net_total = inv.get("base_tax_withholding_net_total", 0)
+		tax_withholding_net_total = inv.base_tax_withholding_net_total
 	else:
-		tax_withholding_net_total = inv.get("tax_withholding_net_total", 0)
+		tax_withholding_net_total = inv.tax_withholding_net_total
 
-	has_cumulative_threshold_breached = (
+	if (threshold and tax_withholding_net_total >= threshold) or (
 		cumulative_threshold and (supp_credit_amt + supp_inv_credit_amt) >= cumulative_threshold
-	)
-
-	if (threshold and tax_withholding_net_total >= threshold) or (has_cumulative_threshold_breached):
+	):
 		# Get net total again as TDS is calculated on net total
 		# Grand is used to just check for threshold breach
 		net_total = (
@@ -580,8 +533,10 @@ def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
 		)
 		supp_credit_amt += net_total
 
-		if has_cumulative_threshold_breached and cint(tax_details.tax_on_excess_amount):
-			supp_credit_amt = net_total + tax_withholding_net_total - cumulative_threshold
+		if (cumulative_threshold and supp_credit_amt >= cumulative_threshold) and cint(
+			tax_details.tax_on_excess_amount
+		):
+			supp_credit_amt = net_total - cumulative_threshold
 
 		if ldc and is_valid_certificate(ldc, inv.get("posting_date") or inv.get("transaction_date"), 0):
 			tds_amount = get_lower_deduction_amount(
@@ -622,7 +577,6 @@ def get_tcs_amount(parties, inv, tax_details, vouchers, adv_vouchers):
 	conditions.append(ple.party.isin(parties))
 	conditions.append(ple.voucher_no == ple.against_voucher_no)
 	conditions.append(ple.company == inv.company)
-	conditions.append(ple.posting_date[tax_details.from_date : tax_details.to_date])
 
 	advance_amt = (
 		qb.from_(ple).select(Abs(Sum(ple.amount))).where(Criterion.all(conditions)).run()[0][0] or 0.0

erpnext/accounts/doctype/tax_withholding_category/test_tax_withholding_category.py

@@ -7,7 +7,7 @@ import unittest
 import frappe
 from frappe.custom.doctype.custom_field.custom_field import create_custom_fields
 from frappe.tests.utils import FrappeTestCase, change_settings
-from frappe.utils import add_days, add_months, today
+from frappe.utils import add_days, today
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.accounts.utils import get_fiscal_year
@@ -161,45 +161,6 @@ class TestTaxWithholdingCategory(FrappeTestCase):
 		for d in reversed(invoices):
 			d.cancel()
 
-	def test_cumulative_threshold_with_tax_on_excess_amount(self):
-		invoices = []
-		frappe.db.set_value("Supplier", "Test TDS Supplier3", "tax_withholding_category", "New TDS Category")
-
-		# Invoice with tax and without exceeding single and cumulative thresholds
-		for _ in range(2):
-			pi = create_purchase_invoice(supplier="Test TDS Supplier3", rate=10000, do_not_save=True)
-			pi.apply_tds = 1
-			pi.append(
-				"taxes",
-				{
-					"category": "Total",
-					"charge_type": "Actual",
-					"account_head": "_Test Account VAT - _TC",
-					"cost_center": "Main - _TC",
-					"tax_amount": 500,
-					"description": "Test",
-					"add_deduct_tax": "Add",
-				},
-			)
-			pi.save()
-			pi.submit()
-			invoices.append(pi)
-
-		# Third Invoice exceeds single threshold and not exceeding cumulative threshold
-		pi1 = create_purchase_invoice(supplier="Test TDS Supplier3", rate=20000)
-		pi1.apply_tds = 1
-		pi1.save()
-		pi1.submit()
-		invoices.append(pi1)
-
-		# Cumulative threshold is 10,000
-		# Threshold calculation should be only on the third invoice
-		self.assertTrue(len(pi1.taxes) > 0)
-		self.assertEqual(pi1.taxes[0].tax_amount, 1000)
-
-		for d in reversed(invoices):
-			d.cancel()
-
 	def test_cumulative_threshold_tcs(self):
 		frappe.db.set_value(
 			"Customer", "Test TCS Customer", "tax_withholding_category", "Cumulative Threshold TCS"
@@ -243,18 +204,17 @@ class TestTaxWithholdingCategory(FrappeTestCase):
 		frappe.db.set_value(
 			"Customer", "Test TCS Customer", "tax_withholding_category", "Cumulative Threshold TCS"
 		)
-		fiscal_year = get_fiscal_year(today(), company="_Test Company")
 
 		vouchers = []
 
 		# create advance payment
-		pe1 = create_payment_entry(
+		pe = create_payment_entry(
 			payment_type="Receive", party_type="Customer", party="Test TCS Customer", paid_amount=20000
 		)
-		pe1.paid_from = "Debtors - _TC"
-		pe1.paid_to = "Cash - _TC"
-		pe1.submit()
-		vouchers.append(pe1)
+		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)
@@ -276,17 +236,6 @@ class TestTaxWithholdingCategory(FrappeTestCase):
 		# make another invoice
 		# sum of unallocated amount from payment entry and this sales invoice will breach cumulative threashold
 		# TDS should be calculated
-
-		# this payment should not be considered for TCS calculation as it is outside of fiscal year
-		pe2 = create_payment_entry(
-			payment_type="Receive", party_type="Customer", party="Test TCS Customer", paid_amount=10000
-		)
-		pe2.paid_from = "Debtors - _TC"
-		pe2.paid_to = "Cash - _TC"
-		pe2.posting_date = add_days(fiscal_year[1], -10)
-		pe2.submit()
-		vouchers.append(pe2)
-
 		si2 = create_sales_invoice(customer="Test TCS Customer", rate=15000)
 		si2.submit()
 		vouchers.append(si2)
@@ -626,49 +575,6 @@ class TestTaxWithholdingCategory(FrappeTestCase):
 		pi2.cancel()
 		pi3.cancel()
 
-	def test_ldc_at_0_rate(self):
-		frappe.db.set_value(
-			"Supplier",
-			"Test LDC Supplier",
-			{
-				"tax_withholding_category": "Test Service Category",
-				"pan": "ABCTY1234D",
-			},
-		)
-
-		fiscal_year = get_fiscal_year(today(), company="_Test Company")
-		valid_from = fiscal_year[1]
-		valid_upto = add_months(valid_from, 1)
-		create_lower_deduction_certificate(
-			supplier="Test LDC Supplier",
-			certificate_no="1AE0423AAJ",
-			tax_withholding_category="Test Service Category",
-			tax_rate=0,
-			limit=50000,
-			valid_from=valid_from,
-			valid_upto=valid_upto,
-		)
-
-		pi1 = create_purchase_invoice(
-			supplier="Test LDC Supplier", rate=35000, posting_date=valid_from, set_posting_time=True
-		)
-		pi1.submit()
-		self.assertEqual(pi1.taxes, [])
-
-		pi2 = create_purchase_invoice(
-			supplier="Test LDC Supplier",
-			rate=35000,
-			posting_date=add_days(valid_upto, 1),
-			set_posting_time=True,
-		)
-		pi2.submit()
-		self.assertEqual(len(pi2.taxes), 1)
-		# pi1 net total shouldn't be included as it lies within LDC at rate of '0'
-		self.assertEqual(pi2.taxes[0].tax_amount, 3500)
-
-		pi1.cancel()
-		pi2.cancel()
-
 	def set_previous_fy_and_tax_category(self):
 		test_company = "_Test Company"
 		category = "Cumulative Threshold TDS"
@@ -826,8 +732,7 @@ def create_purchase_invoice(**args):
 	pi = frappe.get_doc(
 		{
 			"doctype": "Purchase Invoice",
-			"set_posting_time": args.set_posting_time or False,
-			"posting_date": args.posting_date or today(),
+			"posting_date": today(),
 			"apply_tds": 0 if args.do_not_apply_tds else 1,
 			"supplier": args.supplier,
 			"company": "_Test Company",
@@ -1155,9 +1060,7 @@ def create_tax_withholding_category(
 		).insert()
 
 
-def create_lower_deduction_certificate(
-	supplier, tax_withholding_category, tax_rate, certificate_no, limit, valid_from=None, valid_upto=None
-):
+def create_lower_deduction_certificate(supplier, tax_withholding_category, tax_rate, certificate_no, limit):
 	fiscal_year = get_fiscal_year(today(), company="_Test Company")
 	if not frappe.db.exists("Lower Deduction Certificate", certificate_no):
 		frappe.get_doc(
@@ -1168,8 +1071,8 @@ def create_lower_deduction_certificate(
 				"certificate_no": certificate_no,
 				"tax_withholding_category": tax_withholding_category,
 				"fiscal_year": fiscal_year[0],
-				"valid_from": valid_from or fiscal_year[1],
-				"valid_upto": valid_upto or fiscal_year[2],
+				"valid_from": fiscal_year[1],
+				"valid_upto": fiscal_year[2],
 				"rate": tax_rate,
 				"certificate_limit": limit,
 			}

erpnext/accounts/general_ledger.py

@@ -179,15 +179,6 @@ def process_gl_map(gl_map, merge_entries=True, precision=None):
 
 
 def distribute_gl_based_on_cost_center_allocation(gl_map, precision=None):
-	round_off_account, default_currency = frappe.get_cached_value(
-		"Company", gl_map[0].company, ["round_off_account", "default_currency"]
-	)
-	if not precision:
-		precision = get_field_precision(
-			frappe.get_meta("GL Entry").get_field("debit"),
-			currency=default_currency,
-		)
-
 	new_gl_map = []
 	for d in gl_map:
 		cost_center = d.get("cost_center")
@@ -201,11 +192,6 @@ def distribute_gl_based_on_cost_center_allocation(gl_map, precision=None):
 			new_gl_map.append(d)
 			continue
 
-		if d.account == round_off_account:
-			d.cost_center = cost_center_allocation[0][0]
-			new_gl_map.append(d)
-			continue
-
 		for sub_cost_center, percentage in cost_center_allocation:
 			gle = copy.deepcopy(d)
 			gle.cost_center = sub_cost_center

erpnext/accounts/party.py

@@ -29,12 +29,6 @@ from erpnext.accounts.utils import get_fiscal_year
 from erpnext.exceptions import InvalidAccountCurrency, PartyDisabled, PartyFrozen
 from erpnext.utilities.regional import temporary_flag
 
-try:
-	from frappe.contacts.doctype.address.address import render_address as _render_address
-except ImportError:
-	# Older frappe versions where this function is not available
-	from frappe.contacts.doctype.address.address import get_address_display as _render_address
-
 PURCHASE_TRANSACTION_TYPES = {
 	"Supplier Quotation",
 	"Purchase Order",
@@ -552,13 +546,12 @@ def validate_party_accounts(doc):
 
 
 @frappe.whitelist()
-def get_due_date(posting_date, party_type, party, company=None, bill_date=None, template_name=None):
+def get_due_date(posting_date, party_type, party, company=None, bill_date=None):
 	"""Get due date from `Payment Terms Template`"""
 	due_date = None
 	if (bill_date or posting_date) and party:
 		due_date = bill_date or posting_date
-		if not template_name:
-			template_name = get_payment_terms_template(party, party_type, company)
+		template_name = get_payment_terms_template(party, party_type, company)
 
 		if template_name:
 			due_date = get_due_date_from_template(template_name, posting_date, bill_date).strftime("%Y-%m-%d")
@@ -598,34 +591,35 @@ def get_due_date_from_template(template_name, posting_date, bill_date):
 
 
 def validate_due_date(
-	posting_date, due_date, party_type, party, company=None, bill_date=None, template_name=None, doctype=None
+	posting_date, due_date, party_type, party, company=None, bill_date=None, template_name=None
 ):
 	if getdate(due_date) < getdate(posting_date):
 		frappe.throw(_("Due Date cannot be before Posting / Supplier Invoice Date"))
 	else:
-		validate_due_date_with_template(posting_date, due_date, bill_date, template_name, doctype)
+		if not template_name:
+			return
 
+		default_due_date = get_due_date_from_template(template_name, posting_date, bill_date).strftime(
+			"%Y-%m-%d"
+		)
 
-def validate_due_date_with_template(posting_date, due_date, bill_date, template_name, doctype=None):
-	if not template_name:
-		return
+		if not default_due_date:
+			return
 
-	default_due_date = format(get_due_date_from_template(template_name, posting_date, bill_date))
-
-	if not default_due_date:
-		return
-
-	if default_due_date != posting_date and getdate(due_date) > getdate(default_due_date):
-		if frappe.db.get_single_value("Accounts Settings", "credit_controller") in frappe.get_roles():
-			party_type = "supplier" if doctype == "Purchase Invoice" else "customer"
-
-			msgprint(
-				_("Note: Due Date exceeds allowed {0} credit days by {1} day(s)").format(
-					party_type, date_diff(due_date, default_due_date)
-				)
+		if default_due_date != posting_date and getdate(due_date) > getdate(default_due_date):
+			is_credit_controller = (
+				frappe.db.get_single_value("Accounts Settings", "credit_controller") in frappe.get_roles()
 			)
-		else:
-			frappe.throw(_("Due Date cannot be after {0}").format(formatdate(default_due_date)))
+			if is_credit_controller:
+				msgprint(
+					_("Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)").format(
+						date_diff(due_date, default_due_date)
+					)
+				)
+			else:
+				frappe.throw(
+					_("Due / Reference Date cannot be after {0}").format(formatdate(default_due_date))
+				)
 
 
 @frappe.whitelist()
@@ -903,16 +897,12 @@ def get_party_shipping_address(doctype: str, name: str) -> str | None:
 			["is_shipping_address", "=", 1],
 			["address_type", "=", "Shipping"],
 		],
-		fields=["name", "is_shipping_address"],
+		pluck="name",
+		limit=1,
 		order_by="is_shipping_address DESC",
 	)
 
-	if shipping_addresses and shipping_addresses[0].is_shipping_address == 1:
-		return shipping_addresses[0].name
-	if len(shipping_addresses) == 1:
-		return shipping_addresses[0].name
-	else:
-		return None
+	return shipping_addresses[0] if shipping_addresses else None
 
 
 def get_partywise_advanced_payment_amount(
@@ -995,4 +985,10 @@ def add_party_account(party_type, party, company, account):
 
 
 def render_address(address, check_permissions=True):
-	return frappe.call(_render_address, address, check_permissions=check_permissions)
+	try:
+		from frappe.contacts.doctype.address.address import render_address as _render
+	except ImportError:
+		# Older frappe versions where this function is not available
+		from frappe.contacts.doctype.address.address import get_address_display as _render
+
+	return frappe.call(_render, address, check_permissions=check_permissions)

erpnext/accounts/report/accounts_payable/accounts_payable.js

@@ -111,7 +111,6 @@ frappe.query_reports["Accounts Payable"] = {
 			fieldname: "party",
 			label: __("Party"),
 			fieldtype: "MultiSelectList",
-			options: "party_type",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.js

@@ -88,7 +88,6 @@ frappe.query_reports["Accounts Payable Summary"] = {
 			fieldname: "party",
 			label: __("Party"),
 			fieldtype: "MultiSelectList",
-			options: "party_type",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/accounts_receivable/accounts_receivable.html

@@ -282,4 +282,4 @@
 			{% } %}
 		</tbody>
 	</table>
-	<p class="text-right text-muted">{%= __("Printed on {0}", [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.js

@@ -56,7 +56,6 @@ frappe.query_reports["Accounts Receivable"] = {
 			fieldname: "party",
 			label: __("Party"),
 			fieldtype: "MultiSelectList",
-			options: "party_type",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -6,7 +6,6 @@ from collections import OrderedDict
 
 import frappe
 from frappe import _, qb, query_builder, scrub
-from frappe.database.schema import get_definition
 from frappe.query_builder import Criterion
 from frappe.query_builder.functions import Date, Substring, Sum
 from frappe.utils import cint, cstr, flt, getdate, nowdate
@@ -15,10 +14,7 @@ from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
 	get_dimension_with_children,
 )
-from erpnext.accounts.utils import (
-	build_qb_match_conditions,
-	get_currency_precision,
-)
+from erpnext.accounts.utils import get_currency_precision
 
 #  This report gives a summary of all Outstanding Invoices considering the following
 
@@ -53,10 +49,6 @@ class ReceivablePayableReport:
 		self.age_as_on = (
 			getdate(nowdate()) if self.filters.report_date > getdate(nowdate()) else self.filters.report_date
 		)
-		self.ple_fetch_method = (
-			frappe.db.get_single_value("Accounts Settings", "receivable_payable_fetch_method")
-			or "Buffered Cursor"
-		)  # Fail Safe
 
 	def run(self, args):
 		self.filters.update(args)
@@ -93,7 +85,13 @@ class ReceivablePayableReport:
 				self.skip_total_row = 1
 
 	def get_data(self):
+		self.get_ple_entries()
 		self.get_sales_invoices_or_customers_based_on_sales_person()
+		self.voucher_balance = OrderedDict()
+		self.init_voucher_balance()  # invoiced, paid, credit_note, outstanding
+
+		# Build delivery note map against all sales invoices
+		self.build_delivery_note_map()
 
 		# Get invoice details like bill_no, due_date etc for all invoices
 		self.get_invoice_details()
@@ -107,46 +105,13 @@ class ReceivablePayableReport:
 		# Get Exchange Rate Revaluations
 		self.get_exchange_rate_revaluations()
 
-		self.prepare_ple_query()
 		self.data = []
-		self.voucher_balance = OrderedDict()
 
-		if self.ple_fetch_method == "Buffered Cursor":
-			self.fetch_ple_in_buffered_cursor()
-		elif self.ple_fetch_method == "UnBuffered Cursor":
-			self.fetch_ple_in_unbuffered_cursor()
-		elif self.ple_fetch_method == "Raw SQL":
-			self.fetch_ple_in_sql_procedures()
-
-		# Build delivery note map against all sales invoices
-		self.build_delivery_note_map()
+		for ple in self.ple_entries:
+			self.update_voucher_balance(ple)
 
 		self.build_data()
 
-	def fetch_ple_in_buffered_cursor(self):
-		self.ple_entries = self.ple_query.run(as_dict=True)
-
-		for ple in self.ple_entries:
-			self.init_voucher_balance(ple)  # invoiced, paid, credit_note, outstanding
-
-		# This is unavoidable. Initialization and allocation cannot happen in same loop
-		for ple in self.ple_entries:
-			self.update_voucher_balance(ple)
-
-		delattr(self, "ple_entries")
-
-	def fetch_ple_in_unbuffered_cursor(self):
-		self.ple_entries = []
-		with frappe.db.unbuffered_cursor():
-			for ple in self.ple_query.run(as_dict=True, as_iterator=True):
-				self.init_voucher_balance(ple)  # invoiced, paid, credit_note, outstanding
-				self.ple_entries.append(ple)
-
-		# This is unavoidable. Initialization and allocation cannot happen in same loop
-		for ple in self.ple_entries:
-			self.update_voucher_balance(ple)
-		delattr(self, "ple_entries")
-
 	def build_voucher_dict(self, ple):
 		return frappe._dict(
 			voucher_type=ple.voucher_type,
@@ -164,24 +129,26 @@ class ReceivablePayableReport:
 			paid_in_account_currency=0.0,
 			credit_note_in_account_currency=0.0,
 			outstanding_in_account_currency=0.0,
+			cost_center=ple.cost_center,
 		)
 
-	def init_voucher_balance(self, ple):
-		if self.filters.get("ignore_accounts"):
-			key = (ple.voucher_type, ple.voucher_no, ple.party)
-		else:
-			key = (ple.account, ple.voucher_type, ple.voucher_no, ple.party)
+	def init_voucher_balance(self):
+		# build all keys, since we want to exclude vouchers beyond the report date
+		for ple in self.ple_entries:
+			# get the balance object for voucher_type
 
-		if key not in self.voucher_balance:
-			self.voucher_balance[key] = self.build_voucher_dict(ple)
+			if self.filters.get("ignore_accounts"):
+				key = (ple.voucher_type, ple.voucher_no, ple.party)
+			else:
+				key = (ple.account, ple.voucher_type, ple.voucher_no, ple.party)
 
-		if ple.voucher_type == ple.against_voucher_type and ple.voucher_no == ple.against_voucher_no:
-			self.voucher_balance[key].cost_center = ple.cost_center
+			if key not in self.voucher_balance:
+				self.voucher_balance[key] = self.build_voucher_dict(ple)
 
-		self.get_invoices(ple)
+			self.get_invoices(ple)
 
-		if self.filters.get("group_by_party"):
-			self.init_subtotal_row(ple.party)
+			if self.filters.get("group_by_party"):
+				self.init_subtotal_row(ple.party)
 
 		if self.filters.get("group_by_party") and not self.filters.get("in_party_currency"):
 			self.init_subtotal_row("Total")
@@ -303,78 +270,8 @@ class ReceivablePayableReport:
 				row.paid -= amount
 				row.paid_in_account_currency -= amount_in_account_currency
 
-	def fetch_ple_in_sql_procedures(self):
-		self.proc = InitSQLProceduresForAR()
-
-		build_balance = f"""
-		begin not atomic
-		declare done boolean default false;
-		declare rec1 row type of `{self.proc._row_def_table_name}`;
-		declare ple cursor for {self.ple_query.get_sql()};
-		declare continue handler for not found set done = true;
-
-		open ple;
-		fetch ple into rec1;
-		while not done do
-			call {self.proc.init_procedure_name}(rec1);
-			fetch ple into rec1;
-		end while;
-		close ple;
-
-		set done = false;
-		open ple;
-		fetch ple into rec1;
-		while not done do
-			call {self.proc.allocate_procedure_name}(rec1);
-			fetch ple into rec1;
-		end while;
-		close ple;
-		end;
-		"""
-		frappe.db.sql(build_balance)
-
-		balances = frappe.db.sql(
-			f"""select
-			name,
-			voucher_type,
-			voucher_no,
-			party,
-			party_account `account`,
-			posting_date,
-			account_currency,
-			cost_center,
-			sum(invoiced) `invoiced`,
-			sum(paid) `paid`,
-			sum(credit_note) `credit_note`,
-			sum(invoiced) - sum(paid) - sum(credit_note) `outstanding`,
-			sum(invoiced_in_account_currency) `invoiced_in_account_currency`,
-			sum(paid_in_account_currency) `paid_in_account_currency`,
-			sum(credit_note_in_account_currency) `credit_note_in_account_currency`,
-			sum(invoiced_in_account_currency) - sum(paid_in_account_currency) - sum(credit_note_in_account_currency) `outstanding_in_account_currency`
-			from `{self.proc._voucher_balance_name}` group by name order by posting_date;""",
-			as_dict=True,
-		)
-		for x in balances:
-			if self.filters.get("ignore_accounts"):
-				key = (x.voucher_type, x.voucher_no, x.party)
-			else:
-				key = (x.account, x.voucher_type, x.voucher_no, x.party)
-
-			_d = self.build_voucher_dict(x)
-			for field in [
-				"invoiced",
-				"paid",
-				"credit_note",
-				"outstanding",
-				"invoiced_in_account_currency",
-				"paid_in_account_currency",
-				"credit_note_in_account_currency",
-				"outstanding_in_account_currency",
-				"cost_center",
-			]:
-				_d[field] = x.get(field)
-
-			self.voucher_balance[key] = _d
+		if not row.cost_center and ple.cost_center:
+			row.cost_center = str(ple.cost_center)
 
 	def update_sub_total_row(self, row, party):
 		total_row = self.total_row_map.get(party)
@@ -602,7 +499,7 @@ class ReceivablePayableReport:
 				ps.description, ps.paid_amount, ps.discounted_amount
 			from `tab{row.voucher_type}` si, `tabPayment Schedule` ps
 			where
-				si.name = ps.parent and ps.parenttype = '{row.voucher_type}' and
+				si.name = ps.parent and
 				si.name = %s and
 				si.is_return = 0
 			order by ps.paid_amount desc, due_date
@@ -632,7 +529,9 @@ class ReceivablePayableReport:
 			self.append_payment_term(row, d, term)
 
 	def append_payment_term(self, row, d, term):
-		if d.currency == d.party_account_currency:
+		if (
+			self.filters.get("customer") or self.filters.get("supplier")
+		) and d.currency == d.party_account_currency:
 			invoiced = d.payment_amount
 		else:
 			invoiced = d.base_payment_amount
@@ -868,7 +767,7 @@ class ReceivablePayableReport:
 			index = 4
 		row["range" + str(index + 1)] = row.outstanding
 
-	def prepare_ple_query(self):
+	def get_ple_entries(self):
 		# get all the GL entries filtered by the given filters
 
 		self.prepare_conditions()
@@ -916,15 +815,12 @@ class ReceivablePayableReport:
 			else:
 				query = query.select(ple.remarks)
 
-		if match_conditions := build_qb_match_conditions("Payment Ledger Entry"):
-			query = query.where(Criterion.all(match_conditions))
-
 		if self.filters.get("group_by_party"):
 			query = query.orderby(self.ple.party, self.ple.posting_date)
 		else:
 			query = query.orderby(self.ple.posting_date, self.ple.party)
 
-		self.ple_query = query
+		self.ple_entries = query.run(as_dict=True)
 
 	def get_sales_invoices_or_customers_based_on_sales_person(self):
 		if self.filters.get("sales_person"):
@@ -1108,29 +1004,22 @@ class ReceivablePayableReport:
 
 	def get_columns(self):
 		self.columns = []
-		self.add_column(_("Posting Date"), fieldname="posting_date", fieldtype="Date")
+		self.add_column("Posting Date", fieldtype="Date")
 		self.add_column(
-			label=_("Party Type"),
+			label="Party Type",
 			fieldname="party_type",
 			fieldtype="Data",
 			width=100,
 		)
 		self.add_column(
-			label=_("Party"),
+			label="Party",
 			fieldname="party",
 			fieldtype="Dynamic Link",
 			options="party_type",
 			width=180,
 		)
-		if self.account_type == "Receivable":
-			label = _("Receivable Account")
-		elif self.account_type == "Payable":
-			label = _("Payable Account")
-		else:
-			label = _("Party Account")
-
 		self.add_column(
-			label=label,
+			label=self.account_type + " Account",
 			fieldname="party_account",
 			fieldtype="Link",
 			options="Account",
@@ -1139,10 +1028,10 @@ class ReceivablePayableReport:
 
 		if self.party_naming_by == "Naming Series":
 			if self.account_type == "Payable":
-				label = _("Supplier Name")
+				label = "Supplier Name"
 				fieldname = "supplier_name"
 			else:
-				label = _("Customer Name")
+				label = "Customer Name"
 				fieldname = "customer_name"
 			self.add_column(
 				label=label,
@@ -1168,7 +1057,7 @@ class ReceivablePayableReport:
 			width=180,
 		)
 
-		self.add_column(label=_("Due Date"), fieldname="due_date", fieldtype="Date")
+		self.add_column(label="Due Date", fieldtype="Date")
 
 		if self.account_type == "Payable":
 			self.add_column(label=_("Bill No"), fieldname="bill_no", fieldtype="Data")
@@ -1311,134 +1200,3 @@ def get_customer_group_with_children(customer_groups):
 			frappe.throw(_("Customer Group: {0} does not exist").format(d))
 
 	return list(set(all_customer_groups))
-
-
-class InitSQLProceduresForAR:
-	"""
-	Initialize SQL Procedures, Functions and Temporary tables to build Receivable / Payable report
-	"""
-
-	_varchar_type = get_definition("Data")
-	_currency_type = get_definition("Currency")
-	# Temporary Tables
-	_voucher_balance_name = "_ar_voucher_balance"
-	_voucher_balance_definition = f"""
-		create temporary table `{_voucher_balance_name}`(
-		name {_varchar_type},
-		voucher_type {_varchar_type},
-		voucher_no {_varchar_type},
-		party {_varchar_type},
-		party_account {_varchar_type},
-		posting_date date,
-		account_currency {_varchar_type},
-		cost_center {_varchar_type},
-		invoiced {_currency_type},
-		paid {_currency_type},
-		credit_note {_currency_type},
-		invoiced_in_account_currency {_currency_type},
-		paid_in_account_currency {_currency_type},
-		credit_note_in_account_currency {_currency_type}) engine=memory;
-	"""
-
-	_row_def_table_name = "_ar_ple_row"
-	_row_def_table_definition = f"""
-		create temporary table `{_row_def_table_name}`(
-		name {_varchar_type},
-		account {_varchar_type},
-		voucher_type {_varchar_type},
-		voucher_no {_varchar_type},
-		against_voucher_type {_varchar_type},
-		against_voucher_no {_varchar_type},
-		party_type {_varchar_type},
-		cost_center {_varchar_type},
-		party {_varchar_type},
-		posting_date date,
-		due_date date,
-		account_currency {_varchar_type},
-		amount {_currency_type},
-		amount_in_account_currency {_currency_type}) engine=memory;
-	"""
-
-	# Function
-	genkey_function_name = "ar_genkey"
-	genkey_function_sql = f"""
-	create function `{genkey_function_name}`(rec row type of `{_row_def_table_name}`, allocate bool) returns char(40)
-	begin
-		if allocate then
-			return sha1(concat_ws(',', rec.account, rec.against_voucher_type, rec.against_voucher_no, rec.party));
-		else
-			return sha1(concat_ws(',', rec.account, rec.voucher_type, rec.voucher_no, rec.party));
-		end if;
-	end
-	"""
-
-	# Procedures
-	init_procedure_name = "ar_init_tmp_table"
-	init_procedure_sql = f"""
-	create procedure ar_init_tmp_table(in ple row type of `{_row_def_table_name}`)
-	begin
-		if not exists (select name from `{_voucher_balance_name}` where name = `{genkey_function_name}`(ple, false))
-		then
-			insert into `{_voucher_balance_name}` values (`{genkey_function_name}`(ple, false), ple.voucher_type, ple.voucher_no, ple.party, ple.account, ple.posting_date, ple.account_currency, ple.cost_center, 0, 0, 0, 0, 0, 0);
-		end if;
-	end;
-	"""
-
-	allocate_procedure_name = "ar_allocate_to_tmp_table"
-	allocate_procedure_sql = f"""
-	create procedure ar_allocate_to_tmp_table(in ple row type of `{_row_def_table_name}`)
-	begin
-		declare invoiced {_currency_type} default 0;
-		declare invoiced_in_account_currency {_currency_type} default 0;
-		declare paid {_currency_type} default 0;
-		declare paid_in_account_currency {_currency_type} default 0;
-		declare credit_note {_currency_type} default 0;
-		declare credit_note_in_account_currency {_currency_type} default 0;
-
-
-		if ple.amount > 0 then
-			if (ple.voucher_type in ("Journal Entry", "Payment Entry") and (ple.voucher_no != ple.against_voucher_no)) then
-				set paid = -1 * ple.amount;
-				set paid_in_account_currency = -1 * ple.amount_in_account_currency;
-			else
-				set invoiced = ple.amount;
-				set invoiced_in_account_currency = ple.amount_in_account_currency;
-			end if;
-		else
-
-		if ple.voucher_type in ("Sales Invoice", "Purchase Invoice") then
-			if (ple.voucher_no = ple.against_voucher_no) then
-				set paid = -1 * ple.amount;
-				set paid_in_account_currency = -1 * ple.amount_in_account_currency;
-			else
-				set credit_note = -1 * ple.amount;
-				set credit_note_in_account_currency = -1 * ple.amount_in_account_currency;
-		end if;
-		else
-			set paid = -1 * ple.amount;
-			set paid_in_account_currency = -1 * ple.amount_in_account_currency;
-		end if;
-
-		end if;
-
-		insert into `{_voucher_balance_name}` values (`{genkey_function_name}`(ple, true), ple.against_voucher_type, ple.against_voucher_no, ple.party, ple.account, ple.posting_date, ple.account_currency,'', invoiced, paid, 0, invoiced_in_account_currency, paid_in_account_currency, 0);
-	end;
-	"""
-
-	def __init__(self):
-		existing_procedures = frappe.db.get_routines()
-
-		if self.genkey_function_name not in existing_procedures:
-			frappe.db.sql(self.genkey_function_sql)
-
-		if self.init_procedure_name not in existing_procedures:
-			frappe.db.sql(self.init_procedure_sql)
-
-		if self.allocate_procedure_name not in existing_procedures:
-			frappe.db.sql(self.allocate_procedure_sql)
-
-		frappe.db.sql(f"drop table if exists `{self._voucher_balance_name}`")
-		frappe.db.sql(self._voucher_balance_definition)
-
-		frappe.db.sql(f"drop table if exists `{self._row_def_table_name}`")
-		frappe.db.sql(self._row_def_table_definition)

erpnext/accounts/report/accounts_receivable/test_accounts_receivable.py

@@ -21,7 +21,7 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 	def tearDown(self):
 		frappe.db.rollback()
 
-	def create_sales_invoice(self, no_payment_schedule=False, do_not_submit=False, **args):
+	def create_sales_invoice(self, no_payment_schedule=False, do_not_submit=False):
 		frappe.set_user("Administrator")
 		si = create_sales_invoice(
 			item=self.item,
@@ -34,7 +34,6 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 			rate=100,
 			price_list_rate=100,
 			do_not_save=1,
-			**args,
 		)
 		if not no_payment_schedule:
 			si.append(
@@ -112,7 +111,7 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 		self.assertEqual(expected_data[0], [row.invoiced, row.paid, row.credit_note])
 		pos_inv.cancel()
 
-	def test_accounts_receivable_with_payment(self):
+	def test_accounts_receivable(self):
 		filters = {
 			"company": self.company,
 			"based_on_payment_terms": 1,
@@ -152,15 +151,11 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 		cr_note = self.create_credit_note(si.name, do_not_submit=True)
 		cr_note.update_outstanding_for_self = False
 		cr_note.save().submit()
-
-		# as the invoice partially paid and returning the full amount so the outstanding amount should be True
-		self.assertEqual(cr_note.update_outstanding_for_self, True)
-
 		report = execute(filters)
 
-		expected_data_after_credit_note = [0, 0, 100, 0, -100, self.debit_to]
+		expected_data_after_credit_note = [100, 0, 0, 40, -40, self.debit_to]
 
-		row = report[1][-1]
+		row = report[1][0]
 		self.assertEqual(
 			expected_data_after_credit_note,
 			[
@@ -173,105 +168,6 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 			],
 		)
 
-	def test_accounts_receivable_without_payment(self):
-		filters = {
-			"company": self.company,
-			"based_on_payment_terms": 1,
-			"report_date": today(),
-			"range1": 30,
-			"range2": 60,
-			"range3": 90,
-			"range4": 120,
-			"show_remarks": True,
-		}
-
-		# check invoice grand total and invoiced column's value for 3 payment terms
-		si = self.create_sales_invoice()
-
-		report = execute(filters)
-
-		expected_data = [[100, 30, "No Remarks"], [100, 50, "No Remarks"], [100, 20, "No Remarks"]]
-
-		for i in range(3):
-			row = report[1][i - 1]
-			self.assertEqual(expected_data[i - 1], [row.invoice_grand_total, row.invoiced, row.remarks])
-
-		# check invoice grand total, invoiced, paid and outstanding column's value after credit note
-		cr_note = self.create_credit_note(si.name, do_not_submit=True)
-		cr_note.update_outstanding_for_self = False
-		cr_note.save().submit()
-
-		self.assertEqual(cr_note.update_outstanding_for_self, False)
-
-		report = execute(filters)
-
-		row = report[1]
-		self.assertTrue(len(row) == 0)
-
-	def test_accounts_receivable_with_partial_payment(self):
-		filters = {
-			"company": self.company,
-			"based_on_payment_terms": 1,
-			"report_date": today(),
-			"range1": 30,
-			"range2": 60,
-			"range3": 90,
-			"range4": 120,
-			"show_remarks": True,
-		}
-
-		# check invoice grand total and invoiced column's value for 3 payment terms
-		si = self.create_sales_invoice(qty=2)
-
-		report = execute(filters)
-
-		expected_data = [[200, 60, "No Remarks"], [200, 100, "No Remarks"], [200, 40, "No Remarks"]]
-
-		for i in range(3):
-			row = report[1][i - 1]
-			self.assertEqual(expected_data[i - 1], [row.invoice_grand_total, row.invoiced, row.remarks])
-
-		# check invoice grand total, invoiced, paid and outstanding column's value after payment
-		self.create_payment_entry(si.name)
-		report = execute(filters)
-
-		expected_data_after_payment = [[200, 60, 40, 20], [200, 100, 0, 100], [200, 40, 0, 40]]
-
-		for i in range(3):
-			row = report[1][i - 1]
-			self.assertEqual(
-				expected_data_after_payment[i - 1],
-				[row.invoice_grand_total, row.invoiced, row.paid, row.outstanding],
-			)
-
-		# check invoice grand total, invoiced, paid and outstanding column's value after credit note
-		cr_note = self.create_credit_note(si.name, do_not_submit=True)
-		cr_note.update_outstanding_for_self = False
-		cr_note.save().submit()
-
-		self.assertFalse(cr_note.update_outstanding_for_self)
-
-		report = execute(filters)
-
-		expected_data_after_credit_note = [
-			[200, 100, 0, 80, 20, self.debit_to],
-			[200, 40, 0, 0, 40, self.debit_to],
-		]
-
-		for i in range(2):
-			row = report[1][i - 1]
-			self.assertEqual(
-				expected_data_after_credit_note[i - 1],
-				[
-					row.invoice_grand_total,
-					row.invoiced,
-					row.paid,
-					row.credit_note,
-					row.outstanding,
-					row.party_account,
-				],
-			)
-
 	def test_cr_note_flag_to_update_self(self):
 		filters = {
 			"company": self.company,

erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.js

@@ -88,7 +88,6 @@ frappe.query_reports["Accounts Receivable Summary"] = {
 			fieldname: "party",
 			label: __("Party"),
 			fieldtype: "MultiSelectList",
-			options: "party_type",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.js

@@ -25,26 +25,11 @@ frappe.query_reports["Asset Depreciations and Balances"] = {
 			default: erpnext.utils.get_fiscal_year(frappe.datetime.get_today(), true)[2],
 			reqd: 1,
 		},
-		{
-			fieldname: "group_by",
-			label: __("Group By"),
-			fieldtype: "Select",
-			options: ["Asset Category", "Asset"],
-			default: "Asset Category",
-		},
 		{
 			fieldname: "asset_category",
 			label: __("Asset Category"),
 			fieldtype: "Link",
 			options: "Asset Category",
-			depends_on: "eval: doc.group_by == 'Asset Category'",
-		},
-		{
-			fieldname: "asset",
-			label: __("Asset"),
-			fieldtype: "Link",
-			options: "Asset",
-			depends_on: "eval: doc.group_by == 'Asset'",
 		},
 	],
 };

erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py

@@ -14,28 +14,21 @@ def execute(filters=None):
 
 
 def get_data(filters):
-	if filters.get("group_by") == "Asset Category":
-		return get_group_by_asset_category_data(filters)
-	elif filters.get("group_by") == "Asset":
-		return get_group_by_asset_data(filters)
-
-
-def get_group_by_asset_category_data(filters):
 	data = []
 
-	asset_categories = get_asset_categories_for_grouped_by_category(filters)
-	assets = get_assets_for_grouped_by_category(filters)
+	asset_categories = get_asset_categories(filters)
+	assets = get_assets(filters)
 
 	for asset_category in asset_categories:
 		row = frappe._dict()
+		# row.asset_category = asset_category
 		row.update(asset_category)
 
-		row.value_as_on_to_date = (
-			flt(row.value_as_on_from_date)
-			+ flt(row.value_of_new_purchase)
-			- flt(row.value_of_sold_asset)
-			- flt(row.value_of_scrapped_asset)
-			- flt(row.value_of_capitalized_asset)
+		row.cost_as_on_to_date = (
+			flt(row.cost_as_on_from_date)
+			+ flt(row.cost_of_new_purchase)
+			- flt(row.cost_of_sold_asset)
+			- flt(row.cost_of_scrapped_asset)
 		)
 
 		row.update(
@@ -45,19 +38,17 @@ def get_group_by_asset_category_data(filters):
 				if asset["asset_category"] == asset_category.get("asset_category", "")
 			)
 		)
-
 		row.accumulated_depreciation_as_on_to_date = (
 			flt(row.accumulated_depreciation_as_on_from_date)
 			+ flt(row.depreciation_amount_during_the_period)
 			- flt(row.depreciation_eliminated_during_the_period)
-			- flt(row.depreciation_eliminated_via_reversal)
 		)
 
-		row.net_asset_value_as_on_from_date = flt(row.value_as_on_from_date) - flt(
+		row.net_asset_value_as_on_from_date = flt(row.cost_as_on_from_date) - flt(
 			row.accumulated_depreciation_as_on_from_date
 		)
 
-		row.net_asset_value_as_on_to_date = flt(row.value_as_on_to_date) - flt(
+		row.net_asset_value_as_on_to_date = flt(row.cost_as_on_to_date) - flt(
 			row.accumulated_depreciation_as_on_to_date
 		)
 
@@ -66,71 +57,52 @@ def get_group_by_asset_category_data(filters):
 	return data
 
 
-def get_asset_categories_for_grouped_by_category(filters):
+def get_asset_categories(filters):
 	condition = ""
 	if filters.get("asset_category"):
-		condition += " and a.asset_category = %(asset_category)s"
-
-	# nosemgrep
+		condition += " and asset_category = %(asset_category)s"
 	return frappe.db.sql(
 		f"""
-		SELECT a.asset_category,
-			   ifnull(sum(case when a.purchase_date < %(from_date)s then
-							   case when ifnull(a.disposal_date, 0) = 0 or a.disposal_date >= %(from_date)s then
-									a.gross_purchase_amount
+		SELECT asset_category,
+			   ifnull(sum(case when purchase_date < %(from_date)s then
+							   case when ifnull(disposal_date, 0) = 0 or disposal_date >= %(from_date)s then
+									gross_purchase_amount
 							   else
 									0
 							   end
 						   else
 								0
-						   end), 0) as value_as_on_from_date,
-			   ifnull(sum(case when a.purchase_date >= %(from_date)s then
-			   						a.gross_purchase_amount
+						   end), 0) as cost_as_on_from_date,
+			   ifnull(sum(case when purchase_date >= %(from_date)s then
+			   						gross_purchase_amount
 			   				   else
 			   				   		0
-			   				   end), 0) as value_of_new_purchase,
-			   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
-			   						and a.disposal_date >= %(from_date)s
-			   						and a.disposal_date <= %(to_date)s then
-							   case when a.status = "Sold" then
-							   		a.gross_purchase_amount
+			   				   end), 0) as cost_of_new_purchase,
+			   ifnull(sum(case when ifnull(disposal_date, 0) != 0
+			   						and disposal_date >= %(from_date)s
+			   						and disposal_date <= %(to_date)s then
+							   case when status = "Sold" then
+							   		gross_purchase_amount
 							   else
 							   		0
 							   end
 						   else
 								0
-						   end), 0) as value_of_sold_asset,
-			   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
-			   						and a.disposal_date >= %(from_date)s
-			   						and a.disposal_date <= %(to_date)s then
-							   case when a.status = "Scrapped" then
-							   		a.gross_purchase_amount
+						   end), 0) as cost_of_sold_asset,
+			   ifnull(sum(case when ifnull(disposal_date, 0) != 0
+			   						and disposal_date >= %(from_date)s
+			   						and disposal_date <= %(to_date)s then
+							   case when status = "Scrapped" then
+							   		gross_purchase_amount
 							   else
 							   		0
 							   end
 						   else
 								0
-						   end), 0) as value_of_scrapped_asset,
-				ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
-			   						and a.disposal_date >= %(from_date)s
-			   						and a.disposal_date <= %(to_date)s then
-							   case when a.status = "Capitalized" then
-							   		a.gross_purchase_amount
-							   else
-							   		0
-							   end
-						   else
-								0
-						   end), 0) as value_of_capitalized_asset
-		from `tabAsset` a
-		where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s {condition}
-			and not exists(
-				select 1 from `tabAsset Capitalization Asset Item` acai join `tabAsset Capitalization` ac on acai.parent=ac.name
-				where acai.asset = a.name
-				and ac.posting_date < %(from_date)s
-				and ac.docstatus=1
-			)
-		group by a.asset_category
+						   end), 0) as cost_of_scrapped_asset
+		from `tabAsset`
+		where docstatus=1 and company=%(company)s and purchase_date <= %(to_date)s {condition}
+		group by asset_category
 	""",
 		{
 			"to_date": filters.to_date,
@@ -142,17 +114,14 @@ def get_asset_categories_for_grouped_by_category(filters):
 	)
 
 
-def get_assets_for_grouped_by_category(filters):
+def get_assets(filters):
 	condition = ""
 	if filters.get("asset_category"):
-		condition = f" and a.asset_category = '{filters.get('asset_category')}'"
-
-	# nosemgrep
+		condition = " and a.asset_category = '{}'".format(filters.get("asset_category"))
 	return frappe.db.sql(
-		f"""
+		"""
 		SELECT results.asset_category,
 			   sum(results.accumulated_depreciation_as_on_from_date) as accumulated_depreciation_as_on_from_date,
-			   sum(results.depreciation_eliminated_via_reversal) as depreciation_eliminated_via_reversal,
 			   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,
@@ -161,11 +130,6 @@ def get_assets_for_grouped_by_category(filters):
 							  else
 								   0
 							  end), 0) as accumulated_depreciation_as_on_from_date,
-				   ifnull(sum(case when gle.posting_date <= %(to_date)s and ifnull(a.disposal_date, 0) = 0 then
-								   gle.credit
-							  else
-								   0
-							  end), 0) as depreciation_eliminated_via_reversal,
 				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date >= %(from_date)s
 										and a.disposal_date <= %(to_date)s and gle.posting_date <= a.disposal_date then
 								   gle.debit
@@ -185,22 +149,15 @@ def get_assets_for_grouped_by_category(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.purchase_date <= %(to_date)s
-				and gle.is_cancelled = 0
-				and gle.account = ifnull(aca.depreciation_expense_account, company.depreciation_expense_account)
-				{condition}
+			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) {0}
 			group by a.asset_category
 			union
 			SELECT a.asset_category,
-				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date < %(from_date)s then
+				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and (a.disposal_date < %(from_date)s or a.disposal_date > %(to_date)s) then
 									0
 							   else
 									a.opening_accumulated_depreciation
 							   end), 0) as accumulated_depreciation_as_on_from_date,
-				0 as depreciation_eliminated_via_reversal,
 				   ifnull(sum(case when a.disposal_date >= %(from_date)s and a.disposal_date <= %(to_date)s then
 								   a.opening_accumulated_depreciation
 							  else
@@ -208,272 +165,51 @@ def get_assets_for_grouped_by_category(filters):
 							  end), 0) as depreciation_eliminated_during_the_period,
 				   0 as depreciation_amount_during_the_period
 			from `tabAsset` a
-			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s {condition}
+			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s {0}
 			group by a.asset_category) as results
 		group by results.asset_category
-		""",
-		{
-			"to_date": filters.to_date,
-			"from_date": filters.from_date,
-			"company": filters.company,
-		},
-		as_dict=1,
-	)
-
-
-def get_group_by_asset_data(filters):
-	data = []
-
-	asset_details = get_asset_details_for_grouped_by_category(filters)
-	assets = get_assets_for_grouped_by_asset(filters)
-
-	for asset_detail in asset_details:
-		row = frappe._dict()
-		row.update(asset_detail)
-
-		row.value_as_on_to_date = (
-			flt(row.value_as_on_from_date)
-			+ flt(row.value_of_new_purchase)
-			- flt(row.value_of_sold_asset)
-			- flt(row.value_of_scrapped_asset)
-			- flt(row.value_of_capitalized_asset)
-		)
-
-		row.update(next(asset for asset in assets if asset["asset"] == asset_detail.get("name", "")))
-
-		row.accumulated_depreciation_as_on_to_date = (
-			flt(row.accumulated_depreciation_as_on_from_date)
-			+ flt(row.depreciation_amount_during_the_period)
-			- flt(row.depreciation_eliminated_during_the_period)
-			- flt(row.depreciation_eliminated_via_reversal)
-		)
-
-		row.net_asset_value_as_on_from_date = flt(row.value_as_on_from_date) - flt(
-			row.accumulated_depreciation_as_on_from_date
-		)
-
-		row.net_asset_value_as_on_to_date = flt(row.value_as_on_to_date) - flt(
-			row.accumulated_depreciation_as_on_to_date
-		)
-
-		data.append(row)
-
-	return data
-
-
-def get_asset_details_for_grouped_by_category(filters):
-	condition = ""
-	if filters.get("asset"):
-		condition += " and a.name = %(asset)s"
-
-	# nosemgrep
-	return frappe.db.sql(
-		f"""
-		SELECT a.name,
-			   ifnull(sum(case when a.purchase_date < %(from_date)s then
-							   case when ifnull(a.disposal_date, 0) = 0 or a.disposal_date >= %(from_date)s then
-									a.gross_purchase_amount
-							   else
-									0
-							   end
-						   else
-								0
-						   end), 0) as value_as_on_from_date,
-			   ifnull(sum(case when a.purchase_date >= %(from_date)s then
-			   						a.gross_purchase_amount
-			   				   else
-			   				   		0
-			   				   end), 0) as value_of_new_purchase,
-			   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
-			   						and a.disposal_date >= %(from_date)s
-			   						and a.disposal_date <= %(to_date)s then
-							   case when a.status = "Sold" then
-							   		a.gross_purchase_amount
-							   else
-							   		0
-							   end
-						   else
-								0
-						   end), 0) as value_of_sold_asset,
-			   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
-			   						and a.disposal_date >= %(from_date)s
-			   						and a.disposal_date <= %(to_date)s then
-							   case when a.status = "Scrapped" then
-							   		a.gross_purchase_amount
-							   else
-							   		0
-							   end
-						   else
-								0
-						   end), 0) as value_of_scrapped_asset,
-				ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
-			   						and a.disposal_date >= %(from_date)s
-			   						and a.disposal_date <= %(to_date)s then
-							   case when a.status = "Capitalized" then
-							   		a.gross_purchase_amount
-							   else
-							   		0
-							   end
-						   else
-								0
-						   end), 0) as value_of_capitalized_asset
-		from `tabAsset` a
-		where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s {condition}
-		and not exists(
-				select 1 from `tabAsset Capitalization Asset Item` acai join `tabAsset Capitalization` ac on acai.parent=ac.name
-				where acai.asset = a.name
-				and ac.posting_date < %(from_date)s
-				and ac.docstatus=1
-			)
-		group by a.name
-	""",
-		{
-			"to_date": filters.to_date,
-			"from_date": filters.from_date,
-			"company": filters.company,
-			"asset": filters.get("asset"),
-		},
-		as_dict=1,
-	)
-
-
-def get_assets_for_grouped_by_asset(filters):
-	condition = ""
-	if filters.get("asset"):
-		condition = f" and a.name = '{filters.get('asset')}'"
-
-	# nosemgrep
-	return frappe.db.sql(
-		f"""
-		SELECT results.name as asset,
-			   sum(results.accumulated_depreciation_as_on_from_date) as accumulated_depreciation_as_on_from_date,
-			   sum(results.depreciation_eliminated_via_reversal) as depreciation_eliminated_via_reversal,
-			   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.name as name,
-				   ifnull(sum(case when gle.posting_date < %(from_date)s and (ifnull(a.disposal_date, 0) = 0 or a.disposal_date >= %(from_date)s) then
-								   gle.debit
-							  else
-								   0
-							  end), 0) as accumulated_depreciation_as_on_from_date,
-				   ifnull(sum(case when gle.posting_date <= %(to_date)s and ifnull(a.disposal_date, 0) = 0 then
-								   gle.credit
-							  else
-								   0
-							  end), 0) as depreciation_eliminated_via_reversal,
-				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date >= %(from_date)s
-										and a.disposal_date <= %(to_date)s and gle.posting_date <= a.disposal_date then
-								   gle.debit
-							  else
-								   0
-							  end), 0) as depreciation_eliminated_during_the_period,
-				   ifnull(sum(case when gle.posting_date >= %(from_date)s and gle.posting_date <= %(to_date)s
-										and (ifnull(a.disposal_date, 0) = 0 or gle.posting_date <= a.disposal_date) then
-								   gle.debit
-							  else
-								   0
-							  end), 0) as depreciation_amount_during_the_period
-			from `tabGL Entry` gle
-			join `tabAsset` a on
-				gle.against_voucher = a.name
-			join `tabAsset Category Account` aca on
-				aca.parent = a.asset_category and aca.company_name = %(company)s
-			join `tabCompany` company on
-				company.name = %(company)s
-			where
-				a.docstatus=1
-				and a.company=%(company)s
-				and a.purchase_date <= %(to_date)s
-				and gle.is_cancelled = 0
-				and gle.account = ifnull(aca.depreciation_expense_account, company.depreciation_expense_account)
-				{condition}
-			group by a.name
-			union
-			SELECT a.name as name,
-				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date < %(from_date)s then
-									0
-							   else
-									a.opening_accumulated_depreciation
-							   end), 0) as accumulated_depreciation_as_on_from_date,
-				   0 as depreciation_as_on_from_date_credit,
-				   ifnull(sum(case when a.disposal_date >= %(from_date)s and a.disposal_date <= %(to_date)s then
-								   a.opening_accumulated_depreciation
-							  else
-								   0
-							  end), 0) as depreciation_eliminated_during_the_period,
-				   0 as depreciation_amount_during_the_period
-			from `tabAsset` a
-			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s {condition}
-			group by a.name) as results
-		group by results.name
-		""",
-		{
-			"to_date": filters.to_date,
-			"from_date": filters.from_date,
-			"company": filters.company,
-		},
+		""".format(condition),
+		{"to_date": filters.to_date, "from_date": filters.from_date, "company": filters.company},
 		as_dict=1,
 	)
 
 
 def get_columns(filters):
-	columns = []
-
-	if filters.get("group_by") == "Asset Category":
-		columns.append(
-			{
-				"label": _("Asset Category"),
-				"fieldname": "asset_category",
-				"fieldtype": "Link",
-				"options": "Asset Category",
-				"width": 120,
-			}
-		)
-	elif filters.get("group_by") == "Asset":
-		columns.append(
-			{
-				"label": _("Asset"),
-				"fieldname": "asset",
-				"fieldtype": "Link",
-				"options": "Asset",
-				"width": 120,
-			}
-		)
-
-	columns += [
+	return [
 		{
-			"label": _("Value as on") + " " + formatdate(filters.day_before_from_date),
-			"fieldname": "value_as_on_from_date",
+			"label": _("Asset Category"),
+			"fieldname": "asset_category",
+			"fieldtype": "Link",
+			"options": "Asset Category",
+			"width": 120,
+		},
+		{
+			"label": _("Cost as on") + " " + formatdate(filters.day_before_from_date),
+			"fieldname": "cost_as_on_from_date",
 			"fieldtype": "Currency",
 			"width": 140,
 		},
 		{
-			"label": _("Value of New Purchase"),
-			"fieldname": "value_of_new_purchase",
+			"label": _("Cost of New Purchase"),
+			"fieldname": "cost_of_new_purchase",
 			"fieldtype": "Currency",
 			"width": 140,
 		},
 		{
-			"label": _("Value of Sold Asset"),
-			"fieldname": "value_of_sold_asset",
+			"label": _("Cost of Sold Asset"),
+			"fieldname": "cost_of_sold_asset",
 			"fieldtype": "Currency",
 			"width": 140,
 		},
 		{
-			"label": _("Value of Scrapped Asset"),
-			"fieldname": "value_of_scrapped_asset",
+			"label": _("Cost of Scrapped Asset"),
+			"fieldname": "cost_of_scrapped_asset",
 			"fieldtype": "Currency",
 			"width": 140,
 		},
 		{
-			"label": _("Value of New Capitalized Asset"),
-			"fieldname": "value_of_capitalized_asset",
-			"fieldtype": "Currency",
-			"width": 140,
-		},
-		{
-			"label": _("Value as on") + " " + formatdate(filters.to_date),
-			"fieldname": "value_as_on_to_date",
+			"label": _("Cost as on") + " " + formatdate(filters.to_date),
+			"fieldname": "cost_as_on_to_date",
 			"fieldtype": "Currency",
 			"width": 140,
 		},
@@ -501,12 +237,6 @@ def get_columns(filters):
 			"fieldtype": "Currency",
 			"width": 270,
 		},
-		{
-			"label": _("Depreciation eliminated via reversal"),
-			"fieldname": "depreciation_eliminated_via_reversal",
-			"fieldtype": "Currency",
-			"width": 270,
-		},
 		{
 			"label": _("Net Asset value as on") + " " + formatdate(filters.day_before_from_date),
 			"fieldname": "net_asset_value_as_on_from_date",
@@ -520,5 +250,3 @@ def get_columns(filters):
 			"width": 200,
 		},
 	]
-
-	return columns

erpnext/accounts/report/balance_sheet/balance_sheet.py

@@ -7,7 +7,6 @@ from frappe import _
 from frappe.utils import cint, flt
 
 from erpnext.accounts.report.financial_statements import (
-	compute_growth_view_data,
 	get_columns,
 	get_data,
 	get_filtered_list_for_consolidated_report,
@@ -102,9 +101,6 @@ def execute(filters=None):
 		period_list, asset, liability, equity, provisional_profit_loss, currency, filters
 	)
 
-	if filters.get("selected_view") == "Growth":
-		compute_growth_view_data(data, period_list)
-
 	return columns, data, message, chart, report_summary, primitive_summary
 
 

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html

@@ -1,3 +1,6 @@
+<div style="margin-bottom: 7px;">
+	{%= frappe.boot.letter_heads[frappe.defaults.get_default("letter_head")] %}
+</div>
 <h2 class="text-center">{%= __("Bank Reconciliation Statement") %}</h2>
 <h4 class="text-center">{%= filters.account && (filters.account + ", "+filters.report_date)  || "" %} {%= filters.company %}</h4>
 <hr>
@@ -43,4 +46,4 @@
 		{% } %}
 	</tbody>
 </table>
-<p class="text-right text-muted">{%= __("Printed on {0}", [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/billed_items_to_be_received/billed_items_to_be_received.py

@@ -27,7 +27,6 @@ def get_report_filters(report_filters):
 		["Purchase Invoice", "docstatus", "=", 1],
 		["Purchase Invoice", "per_received", "<", 100],
 		["Purchase Invoice", "update_stock", "=", 0],
-		["Purchase Invoice", "is_opening", "!=", "Yes"],
 	]
 
 	if report_filters.get("purchase_invoice"):

erpnext/accounts/report/budget_variance_report/budget_variance_report.js

@@ -91,7 +91,6 @@ function get_filters() {
 			fieldname: "budget_against_filter",
 			label: __("Dimension Filter"),
 			fieldtype: "MultiSelectList",
-			options: "budget_against",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/budget_variance_report/budget_variance_report.py

@@ -263,7 +263,6 @@ def get_actual_details(name, filters):
 				and ba.account=gl.account
 				and b.{budget_against} = gl.{budget_against}
 				and gl.fiscal_year between %s and %s
-				and gl.is_cancelled = 0
 				and b.{budget_against} = %s
 				and exists(
 					select

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py

@@ -355,7 +355,7 @@ def get_data(companies, root_type, balance_must_be, fiscal_year, filters=None, i
 			gl_entries_by_account,
 			accounts_by_name,
 			accounts,
-			ignore_closing_entries=ignore_closing_entries,
+			ignore_closing_entries=False,
 			root_type=root_type,
 		)
 

erpnext/accounts/report/financial_statements.html

@@ -67,5 +67,5 @@
 	</tbody>
 </table>
 <p class="text-right text-muted">
-	{%= __("Printed on {0}", [frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string())]) %}
+	Printed On {%= frappe.datetime.str_to_user(frappe.datetime.get_datetime_as_string()) %}
 </p>