fix: POS opening issue because of Product Bundle

.github/workflows/release.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v2
         with:
-          node-version: 20
+          node-version: 18
 
       - name: Setup dependencies
         run: |

.github/workflows/semantic-commits.yml

@@ -21,7 +21,7 @@ jobs:
 
       - uses: actions/setup-node@v3
         with:
-          node-version: 20
+          node-version: 14
           check-latest: true
 
       - name: Check commit titles

.pre-commit-config.yaml

@@ -5,7 +5,7 @@ fail_fast: false
 
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.3.0
+    rev: v4.0.1
     hooks:
       - id: trailing-whitespace
         files: "erpnext.*"
@@ -15,10 +15,6 @@ repos:
         args: ['--branch', 'develop']
       - id: check-merge-conflict
       - id: check-ast
-      - id: check-json
-      - id: check-toml
-      - id: check-yaml
-      - id: debug-statements
 
   - repo: https://github.com/PyCQA/flake8
     rev: 5.0.4

erpnext/__init__.py

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

erpnext/accounts/doctype/account/account.py

@@ -58,7 +58,6 @@ class Account(NestedSet):
 		self.validate_balance_must_be_debit_or_credit()
 		self.validate_account_currency()
 		self.validate_root_company_and_sync_account_to_children()
-		self.validate_receivable_payable_account_type()
 
 	def validate_parent(self):
 		"""Fetch Parent Details and validate parent account"""
@@ -115,24 +114,6 @@ class Account(NestedSet):
 				"Balance Sheet" if self.root_type in ("Asset", "Liability", "Equity") else "Profit and Loss"
 			)
 
-	def validate_receivable_payable_account_type(self):
-		doc_before_save = self.get_doc_before_save()
-		receivable_payable_types = ["Receivable", "Payable"]
-		if (
-			doc_before_save
-			and doc_before_save.account_type in receivable_payable_types
-			and doc_before_save.account_type != self.account_type
-		):
-			# check for ledger entries
-			if frappe.db.get_all("GL Entry", filters={"account": self.name, "is_cancelled": 0}, limit=1):
-				msg = _(
-					"There are ledger entries against this account. Changing {0} to non-{1} in live system will cause incorrect output in 'Accounts {2}' report"
-				).format(
-					frappe.bold("Account Type"), doc_before_save.account_type, doc_before_save.account_type
-				)
-				frappe.msgprint(msg)
-				self.add_comment("Comment", msg)
-
 	def validate_root_details(self):
 		# does not exists parent
 		if frappe.db.exists("Account", self.name):

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

@@ -53,13 +53,8 @@
 				},
 				"II. Forderungen und sonstige Vermögensgegenstände": {
 					"is_group": 1,
-					"Forderungen aus Lieferungen und Leistungen mit Kontokorrent": {
+					"Ford. a. Lieferungen und Leistungen": {
 						"account_number": "1400",
-						"account_type": "Receivable",
-						"is_group": 1
-					},
-					"Forderungen aus Lieferungen und Leistungen ohne Kontokorrent": {
-						"account_number": "1410",
 						"account_type": "Receivable"
 					},
 					"Durchlaufende Posten": {
@@ -185,13 +180,8 @@
 				},
 				"IV. Verbindlichkeiten aus Lieferungen und Leistungen": {
 					"is_group": 1,
-					"Verbindlichkeiten aus Lieferungen und Leistungen mit Kontokorrent": {
+					"Verbindlichkeiten aus Lieferungen u. Leistungen": {
 						"account_number": "1600",
-						"account_type": "Payable",
-						"is_group": 1
-					},
-					"Verbindlichkeiten aus Lieferungen und Leistungen ohne Kontokorrent": {
-						"account_number": "1610",
 						"account_type": "Payable"
 					}
 				},

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

@@ -407,10 +407,13 @@
                         "Bewertungskorrektur zu Forderungen aus Lieferungen und Leistungen": {
                             "account_number": "9960"
                         },
-                        "Forderungen aus Lieferungen und Leistungen mit Kontokorrent": {
+                        "Debitoren": {
+                            "is_group": 1,
+                            "account_number": "10000"
+                        },
+                        "Forderungen aus Lieferungen und Leistungen": {
                             "account_number": "1200",
-                            "account_type": "Receivable",
-                            "is_group": 1
+                            "account_type": "Receivable"
                         },
                         "Forderungen aus Lieferungen und Leistungen ohne Kontokorrent": {
                             "account_number": "1210"
@@ -1135,15 +1138,18 @@
                     "Bewertungskorrektur zu Verb. aus Lieferungen und Leistungen": {
                         "account_number": "9964"
                     },
-                    "Verb. aus Lieferungen und Leistungen mit Kontokorrent": {
-                        "account_number": "3300",
-                        "account_type": "Payable",
+                    "Kreditoren": {
+                        "account_number": "70000",
                         "is_group": 1,
-                        "Wareneingangs-Verrechnungskonto" : {
+                        "Wareneingangs-­Verrechnungskonto" : {
                             "account_number": "70001",
                             "account_type": "Stock Received But Not Billed"
                         }
                     },
+                    "Verb. aus Lieferungen und Leistungen": {
+                        "account_number": "3300",
+                        "account_type": "Payable"
+                    },
                     "Verb. aus Lieferungen und Leistungen ohne Kontokorrent": {
                         "account_number": "3310"
                     },

erpnext/accounts/doctype/account_closing_balance/account_closing_balance.py

@@ -37,7 +37,6 @@ def make_closing_entries(closing_entries, voucher_name, company, closing_date):
 			}
 		)
 		cle.flags.ignore_permissions = True
-		cle.flags.ignore_links = True
 		cle.submit()
 
 

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -301,30 +301,3 @@ def get_dimensions(with_cost_center_and_project=False):
 		default_dimensions_map[dimension.company][dimension.fieldname] = dimension.default_dimension
 
 	return dimension_filters, default_dimensions_map
-
-
-def create_accounting_dimensions_for_doctype(doctype):
-	accounting_dimensions = frappe.db.get_all(
-		"Accounting Dimension", fields=["fieldname", "label", "document_type", "disabled"]
-	)
-
-	if not accounting_dimensions:
-		return
-
-	for d in accounting_dimensions:
-		field = frappe.db.get_value("Custom Field", {"dt": doctype, "fieldname": d.fieldname})
-
-		if field:
-			continue
-
-		df = {
-			"fieldname": d.fieldname,
-			"label": d.label,
-			"fieldtype": "Link",
-			"options": d.document_type,
-			"insert_after": "accounting_dimensions_section",
-		}
-
-		create_custom_field(doctype, df, ignore_validate=True)
-
-	frappe.clear_cache(doctype=doctype)

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -68,12 +68,7 @@
   "enable_party_matching",
   "enable_fuzzy_matching",
   "tab_break_dpet",
-  "show_balance_in_coa",
-  "reports_tab",
-  "remarks_section",
-  "general_ledger_remarks_length",
-  "column_break_lvjk",
-  "receivable_payable_remarks_length"
+  "show_balance_in_coa"
  ],
  "fields": [
   {
@@ -434,34 +429,6 @@
    "fieldname": "show_balance_in_coa",
    "fieldtype": "Check",
    "label": "Show Balances in Chart Of Accounts"
-  },
-  {
-   "fieldname": "reports_tab",
-   "fieldtype": "Tab Break",
-   "label": "Reports"
-  },
-  {
-   "default": "0",
-   "description": "Truncates 'Remarks' column to set character length",
-   "fieldname": "general_ledger_remarks_length",
-   "fieldtype": "Int",
-   "label": "General Ledger"
-  },
-  {
-   "default": "0",
-   "description": "Truncates 'Remarks' column to set character length",
-   "fieldname": "receivable_payable_remarks_length",
-   "fieldtype": "Int",
-   "label": "Accounts Receivable/Payable"
-  },
-  {
-   "fieldname": "column_break_lvjk",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "remarks_section",
-   "fieldtype": "Section Break",
-   "label": "Remarks Column Length"
   }
  ],
  "icon": "icon-cog",
@@ -469,7 +436,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-11-20 09:37:47.650347",
+ "modified": "2023-07-27 15:05:34.000264",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/allowed_to_transact_with/allowed_to_transact_with.json

@@ -11,7 +11,6 @@
   {
    "fieldname": "company",
    "fieldtype": "Link",
-   "ignore_user_permissions": 1,
    "in_list_view": 1,
    "label": "Company",
    "options": "Company",
@@ -20,7 +19,7 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2024-01-03 11:13:02.669632",
+ "modified": "2020-05-01 12:32:34.044911",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Allowed To Transact With",
@@ -29,6 +28,5 @@
  "quick_entry": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/bank_account/bank_account.json

@@ -13,7 +13,6 @@
   "account_type",
   "account_subtype",
   "column_break_7",
-  "disabled",
   "is_default",
   "is_company_account",
   "company",
@@ -200,16 +199,10 @@
    "fieldtype": "Data",
    "in_global_search": 1,
    "label": "Branch Code"
-  },
-  {
-   "default": "0",
-   "fieldname": "disabled",
-   "fieldtype": "Check",
-   "label": "Disabled"
   }
  ],
  "links": [],
- "modified": "2024-02-02 17:50:09.768835",
+ "modified": "2022-05-04 15:49:42.620630",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account",

erpnext/accounts/doctype/bank_account/bank_account.py

@@ -9,7 +9,6 @@ from frappe.contacts.address_and_contact import (
 	load_address_and_contact,
 )
 from frappe.model.document import Document
-from frappe.utils import comma_and, get_link_to_form
 
 
 class BankAccount(Document):
@@ -26,17 +25,6 @@ class BankAccount(Document):
 	def validate(self):
 		self.validate_company()
 		self.validate_iban()
-		self.validate_account()
-
-	def validate_account(self):
-		if self.account:
-			if accounts := frappe.db.get_all("Bank Account", filters={"account": self.account}, as_list=1):
-				frappe.throw(
-					_("'{0}' account is already used by {1}. Use another account.").format(
-						frappe.bold(self.account),
-						frappe.bold(comma_and([get_link_to_form(self.doctype, x[0]) for x in accounts])),
-					)
-				)
 
 	def validate_company(self):
 		if self.is_company_account and not self.company:

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.js

@@ -137,7 +137,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 					"erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.get_account_balance",
 				args: {
 					bank_account: frm.doc.bank_account,
-					till_date: frappe.datetime.add_days(frm.doc.bank_statement_from_date, -1)
+					till_date: frm.doc.bank_statement_from_date,
 				},
 				callback: (response) => {
 					frm.set_value("account_opening_balance", response.message);

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -17,7 +17,6 @@ from erpnext.accounts.report.bank_reconciliation_statement.bank_reconciliation_s
 	get_entries,
 )
 from erpnext.accounts.utils import get_balance_on
-from erpnext.setup.utils import get_exchange_rate
 
 
 class BankReconciliationTool(Document):
@@ -130,7 +129,7 @@ def create_journal_entry_bts(
 	bank_transaction = frappe.db.get_values(
 		"Bank Transaction",
 		bank_transaction_name,
-		fieldname=["name", "deposit", "withdrawal", "bank_account", "currency"],
+		fieldname=["name", "deposit", "withdrawal", "bank_account"],
 		as_dict=True,
 	)[0]
 	company_account = frappe.get_value("Bank Account", bank_transaction.bank_account, "account")
@@ -144,94 +143,29 @@ def create_journal_entry_bts(
 			)
 
 	company = frappe.get_value("Account", company_account, "company")
-	company_default_currency = frappe.get_cached_value("Company", company, "default_currency")
-	company_account_currency = frappe.get_cached_value("Account", company_account, "account_currency")
-	second_account_currency = frappe.get_cached_value("Account", second_account, "account_currency")
-
-	# determine if multi-currency Journal or not
-	is_multi_currency = (
-		True
-		if company_default_currency != company_account_currency
-		or company_default_currency != second_account_currency
-		or company_default_currency != bank_transaction.currency
-		else False
-	)
 
 	accounts = []
-	second_account_dict = {
-		"account": second_account,
-		"account_currency": second_account_currency,
-		"credit_in_account_currency": bank_transaction.deposit,
-		"debit_in_account_currency": bank_transaction.withdrawal,
-		"party_type": party_type,
-		"party": party,
-		"cost_center": get_default_cost_center(company),
-	}
+	# Multi Currency?
+	accounts.append(
+		{
+			"account": second_account,
+			"credit_in_account_currency": bank_transaction.deposit,
+			"debit_in_account_currency": bank_transaction.withdrawal,
+			"party_type": party_type,
+			"party": party,
+			"cost_center": get_default_cost_center(company),
+		}
+	)
 
-	company_account_dict = {
-		"account": company_account,
-		"account_currency": company_account_currency,
-		"bank_account": bank_transaction.bank_account,
-		"credit_in_account_currency": bank_transaction.withdrawal,
-		"debit_in_account_currency": bank_transaction.deposit,
-		"cost_center": get_default_cost_center(company),
-	}
-
-	# convert transaction amount to company currency
-	if is_multi_currency:
-		exc_rate = get_exchange_rate(bank_transaction.currency, company_default_currency, posting_date)
-		withdrawal_in_company_currency = flt(exc_rate * abs(bank_transaction.withdrawal))
-		deposit_in_company_currency = flt(exc_rate * abs(bank_transaction.deposit))
-	else:
-		withdrawal_in_company_currency = bank_transaction.withdrawal
-		deposit_in_company_currency = bank_transaction.deposit
-
-	# if second account is of foreign currency, convert and set debit and credit fields.
-	if second_account_currency != company_default_currency:
-		exc_rate = get_exchange_rate(second_account_currency, company_default_currency, posting_date)
-		second_account_dict.update(
-			{
-				"exchange_rate": exc_rate,
-				"credit": deposit_in_company_currency,
-				"debit": withdrawal_in_company_currency,
-				"credit_in_account_currency": flt(deposit_in_company_currency / exc_rate) or 0,
-				"debit_in_account_currency": flt(withdrawal_in_company_currency / exc_rate) or 0,
-			}
-		)
-	else:
-		second_account_dict.update(
-			{
-				"exchange_rate": 1,
-				"credit": deposit_in_company_currency,
-				"debit": withdrawal_in_company_currency,
-				"credit_in_account_currency": deposit_in_company_currency,
-				"debit_in_account_currency": withdrawal_in_company_currency,
-			}
-		)
-
-	# if company account is of foreign currency, convert and set debit and credit fields.
-	if company_account_currency != company_default_currency:
-		exc_rate = get_exchange_rate(company_account_currency, company_default_currency, posting_date)
-		company_account_dict.update(
-			{
-				"exchange_rate": exc_rate,
-				"credit": withdrawal_in_company_currency,
-				"debit": deposit_in_company_currency,
-			}
-		)
-	else:
-		company_account_dict.update(
-			{
-				"exchange_rate": 1,
-				"credit": withdrawal_in_company_currency,
-				"debit": deposit_in_company_currency,
-				"credit_in_account_currency": withdrawal_in_company_currency,
-				"debit_in_account_currency": deposit_in_company_currency,
-			}
-		)
-
-	accounts.append(second_account_dict)
-	accounts.append(company_account_dict)
+	accounts.append(
+		{
+			"account": company_account,
+			"bank_account": bank_transaction.bank_account,
+			"credit_in_account_currency": bank_transaction.withdrawal,
+			"debit_in_account_currency": bank_transaction.deposit,
+			"cost_center": get_default_cost_center(company),
+		}
+	)
 
 	journal_entry_dict = {
 		"voucher_type": entry_type,
@@ -241,9 +175,6 @@ def create_journal_entry_bts(
 		"cheque_no": reference_number,
 		"mode_of_payment": mode_of_payment,
 	}
-	if is_multi_currency:
-		journal_entry_dict.update({"multi_currency": True})
-
 	journal_entry = frappe.new_doc("Journal Entry")
 	journal_entry.update(journal_entry_dict)
 	journal_entry.set("accounts", accounts)

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.js

@@ -2,16 +2,6 @@
 // For license information, please see license.txt
 
 frappe.ui.form.on("Bank Statement Import", {
-	onload(frm) {
-		frm.set_query("bank_account", function (doc) {
-			return {
-				filters: {
-					company: doc.company,
-				},
-			};
-		});
-	},
-
 	setup(frm) {
 		frappe.realtime.on("data_import_refresh", ({ data_import }) => {
 			frm.import_in_progress = false;
@@ -362,11 +352,10 @@ frappe.ui.form.on("Bank Statement Import", {
 
 	export_errored_rows(frm) {
 		open_url_post(
-			"/api/method/erpnext.accounts.doctype.bank_statement_import.bank_statement_import.download_errored_template",
+			"/api/method/frappe.core.doctype.data_import.data_import.download_errored_template",
 			{
 				data_import_name: frm.doc.name,
-			},
-			true
+			}
 		);
 	},
 

erpnext/accounts/doctype/bank_transaction/auto_match_party.py

@@ -112,8 +112,7 @@ class AutoMatchbyPartyNameDescription:
 
 		for party in parties:
 			filters = {"status": "Active"} if party == "Employee" else {"disabled": 0}
-			field = party.lower() + "_name"
-			names = frappe.get_all(party, filters=filters, fields=[f"{field} as party_name", "name"])
+			names = frappe.get_all(party, filters=filters, pluck=party.lower() + "_name")
 
 			for field in ["bank_party_name", "description"]:
 				if not self.get(field):
@@ -132,11 +131,7 @@ class AutoMatchbyPartyNameDescription:
 
 	def fuzzy_search_and_return_result(self, party, names, field) -> Union[Tuple, None]:
 		skip = False
-		result = process.extract(
-			query=self.get(field),
-			choices={row.get("name"): row.get("party_name") for row in names},
-			scorer=fuzz.token_set_ratio,
-		)
+		result = process.extract(query=self.get(field), choices=names, scorer=fuzz.token_set_ratio)
 		party_name, skip = self.process_fuzzy_result(result)
 
 		if not party_name:
@@ -154,14 +149,14 @@ class AutoMatchbyPartyNameDescription:
 
 		Returns: Result, Skip (whether or not to discontinue matching)
 		"""
-		SCORE, PARTY_ID, CUTOFF = 1, 2, 80
+		PARTY, SCORE, CUTOFF = 0, 1, 80
 
 		if not result or not len(result):
 			return None, False
 
 		first_result = result[0]
 		if len(result) == 1:
-			return (first_result[PARTY_ID] if first_result[SCORE] > CUTOFF else None), True
+			return (first_result[PARTY] if first_result[SCORE] > CUTOFF else None), True
 
 		second_result = result[1]
 		if first_result[SCORE] > CUTOFF:
@@ -170,7 +165,7 @@ class AutoMatchbyPartyNameDescription:
 			if first_result[SCORE] == second_result[SCORE]:
 				return None, True
 
-			return first_result[PARTY_ID], True
+			return first_result[PARTY], True
 		else:
 			return None, False
 

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -2,7 +2,6 @@
 # For license information, please see license.txt
 
 import frappe
-from frappe.model.docstatus import DocStatus
 from frappe.utils import flt
 
 from erpnext.controllers.status_updater import StatusUpdater
@@ -41,10 +40,9 @@ class BankTransaction(StatusUpdater):
 		else:
 			allocated_amount = 0.0
 
-		unallocated_amount = abs(flt(self.withdrawal) - flt(self.deposit)) - allocated_amount
-
-		self.db_set("allocated_amount", flt(allocated_amount, self.precision("allocated_amount")))
-		self.db_set("unallocated_amount", flt(unallocated_amount, self.precision("unallocated_amount")))
+		amount = abs(flt(self.withdrawal) - flt(self.deposit))
+		self.db_set("allocated_amount", flt(allocated_amount))
+		self.db_set("unallocated_amount", amount - flt(allocated_amount))
 		self.reload()
 		self.set_status(update=True)
 
@@ -70,7 +68,7 @@ class BankTransaction(StatusUpdater):
 					"payment_entry": voucher["payment_name"],
 					"allocated_amount": 0.0,  # Temporary
 				}
-				self.append("payment_entries", pe)
+				child = self.append("payment_entries", pe)
 				added = True
 
 		# runs on_update_after_submit
@@ -91,6 +89,7 @@ class BankTransaction(StatusUpdater):
 		    - 0 > a: Error: already over-allocated
 		- clear means: set the latest transaction date as clearance date
 		"""
+		gl_bank_account = frappe.db.get_value("Bank Account", self.bank_account, "account")
 		remaining_amount = self.unallocated_amount
 		for payment_entry in self.payment_entries:
 			if payment_entry.allocated_amount == 0.0:
@@ -395,21 +394,3 @@ def unclear_reference_payment(doctype, docname, bt_name):
 	bt = frappe.get_doc("Bank Transaction", bt_name)
 	set_voucher_clearance(doctype, docname, None, bt)
 	return docname
-
-
-def remove_from_bank_transaction(doctype, docname):
-	"""Remove a (cancelled) voucher from all Bank Transactions."""
-	for bt_name in get_reconciled_bank_transactions(doctype, docname):
-		bt = frappe.get_doc("Bank Transaction", bt_name)
-		if bt.docstatus == DocStatus.cancelled():
-			continue
-
-		modified = False
-
-		for pe in bt.payment_entries:
-			if pe.payment_document == doctype and pe.payment_entry == docname:
-				bt.remove(pe)
-				modified = True
-
-		if modified:
-			bt.save()

erpnext/accounts/doctype/bank_transaction/test_bank_transaction.py

@@ -2,10 +2,10 @@
 # See license.txt
 
 import json
+import unittest
 
 import frappe
 from frappe import utils
-from frappe.model.docstatus import DocStatus
 from frappe.tests.utils import FrappeTestCase
 
 from erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool import (
@@ -32,16 +32,8 @@ class TestBankTransaction(FrappeTestCase):
 			frappe.db.delete(dt)
 
 		make_pos_profile()
-
-		# generate and use a uniq hash identifier for 'Bank Account' and it's linked GL 'Account' to avoid validation error
-		uniq_identifier = frappe.generate_hash(length=10)
-		gl_account = create_gl_account("_Test Bank " + uniq_identifier)
-		bank_account = create_bank_account(
-			gl_account=gl_account, bank_account_name="Checking Account " + uniq_identifier
-		)
-
-		add_transactions(bank_account=bank_account)
-		add_vouchers(gl_account=gl_account)
+		add_transactions()
+		add_vouchers()
 
 	# This test checks if ERPNext is able to provide a linked payment for a bank transaction based on the amount of the bank transaction.
 	def test_linked_payments(self):
@@ -89,29 +81,6 @@ class TestBankTransaction(FrappeTestCase):
 		clearance_date = frappe.db.get_value("Payment Entry", payment.name, "clearance_date")
 		self.assertFalse(clearance_date)
 
-	def test_cancel_voucher(self):
-		bank_transaction = frappe.get_doc(
-			"Bank Transaction",
-			dict(description="1512567 BG/000003025 OPSKATTUZWXXX AT776000000098709849 Herr G"),
-		)
-		payment = frappe.get_doc("Payment Entry", dict(party="Mr G", paid_amount=1700))
-		vouchers = json.dumps(
-			[
-				{
-					"payment_doctype": "Payment Entry",
-					"payment_name": payment.name,
-					"amount": bank_transaction.unallocated_amount,
-				}
-			]
-		)
-		reconcile_vouchers(bank_transaction.name, vouchers)
-		payment.reload()
-		payment.cancel()
-		bank_transaction.reload()
-		self.assertEqual(bank_transaction.docstatus, DocStatus.submitted())
-		self.assertEqual(bank_transaction.unallocated_amount, 1700)
-		self.assertEqual(bank_transaction.payment_entries, [])
-
 	# Check if ERPNext can correctly filter a linked payments based on the debit/credit amount
 	def test_debit_credit_output(self):
 		bank_transaction = frappe.get_doc(
@@ -221,9 +190,7 @@ class TestBankTransaction(FrappeTestCase):
 		self.assertEqual(linked_payments[0][2], repayment_entry.name)
 
 
-def create_bank_account(
-	bank_name="Citi Bank", gl_account="_Test Bank - _TC", bank_account_name="Checking Account"
-):
+def create_bank_account(bank_name="Citi Bank", account_name="_Test Bank - _TC"):
 	try:
 		frappe.get_doc(
 			{
@@ -235,35 +202,21 @@ def create_bank_account(
 		pass
 
 	try:
-		bank_account = frappe.get_doc(
+		frappe.get_doc(
 			{
 				"doctype": "Bank Account",
-				"account_name": bank_account_name,
+				"account_name": "Checking Account",
 				"bank": bank_name,
-				"account": gl_account,
+				"account": account_name,
 			}
 		).insert(ignore_if_duplicate=True)
 	except frappe.DuplicateEntryError:
 		pass
 
-	return bank_account.name
 
+def add_transactions():
+	create_bank_account()
 
-def create_gl_account(gl_account_name="_Test Bank - _TC"):
-	gl_account = frappe.get_doc(
-		{
-			"doctype": "Account",
-			"company": "_Test Company",
-			"parent_account": "Current Assets - _TC",
-			"account_type": "Bank",
-			"is_group": 0,
-			"account_name": gl_account_name,
-		}
-	).insert()
-	return gl_account.name
-
-
-def add_transactions(bank_account="_Test Bank - _TC"):
 	doc = frappe.get_doc(
 		{
 			"doctype": "Bank Transaction",
@@ -271,7 +224,7 @@ def add_transactions(bank_account="_Test Bank - _TC"):
 			"date": "2018-10-23",
 			"deposit": 1200,
 			"currency": "INR",
-			"bank_account": bank_account,
+			"bank_account": "Checking Account - Citi Bank",
 		}
 	).insert()
 	doc.submit()
@@ -283,7 +236,7 @@ def add_transactions(bank_account="_Test Bank - _TC"):
 			"date": "2018-10-23",
 			"deposit": 1700,
 			"currency": "INR",
-			"bank_account": bank_account,
+			"bank_account": "Checking Account - Citi Bank",
 		}
 	).insert()
 	doc.submit()
@@ -295,7 +248,7 @@ def add_transactions(bank_account="_Test Bank - _TC"):
 			"date": "2018-10-26",
 			"withdrawal": 690,
 			"currency": "INR",
-			"bank_account": bank_account,
+			"bank_account": "Checking Account - Citi Bank",
 		}
 	).insert()
 	doc.submit()
@@ -307,7 +260,7 @@ def add_transactions(bank_account="_Test Bank - _TC"):
 			"date": "2018-10-27",
 			"deposit": 3900,
 			"currency": "INR",
-			"bank_account": bank_account,
+			"bank_account": "Checking Account - Citi Bank",
 		}
 	).insert()
 	doc.submit()
@@ -319,13 +272,13 @@ def add_transactions(bank_account="_Test Bank - _TC"):
 			"date": "2018-10-27",
 			"withdrawal": 109080,
 			"currency": "INR",
-			"bank_account": bank_account,
+			"bank_account": "Checking Account - Citi Bank",
 		}
 	).insert()
 	doc.submit()
 
 
-def add_vouchers(gl_account="_Test Bank - _TC"):
+def add_vouchers():
 	try:
 		frappe.get_doc(
 			{
@@ -341,7 +294,7 @@ def add_vouchers(gl_account="_Test Bank - _TC"):
 
 	pi = make_purchase_invoice(supplier="Conrad Electronic", qty=1, rate=690)
 
-	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account=gl_account)
+	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
 	pe.reference_no = "Conrad Oct 18"
 	pe.reference_date = "2018-10-24"
 	pe.insert()
@@ -360,14 +313,14 @@ def add_vouchers(gl_account="_Test Bank - _TC"):
 		pass
 
 	pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1200)
-	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account=gl_account)
+	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
 	pe.reference_no = "Herr G Oct 18"
 	pe.reference_date = "2018-10-24"
 	pe.insert()
 	pe.submit()
 
 	pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1700)
-	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account=gl_account)
+	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
 	pe.reference_no = "Herr G Nov 18"
 	pe.reference_date = "2018-11-01"
 	pe.insert()
@@ -398,10 +351,10 @@ def add_vouchers(gl_account="_Test Bank - _TC"):
 		pass
 
 	pi = make_purchase_invoice(supplier="Poore Simon's", qty=1, rate=3900, is_paid=1, do_not_save=1)
-	pi.cash_bank_account = gl_account
+	pi.cash_bank_account = "_Test Bank - _TC"
 	pi.insert()
 	pi.submit()
-	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account=gl_account)
+	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
 	pe.reference_no = "Poore Simon's Oct 18"
 	pe.reference_date = "2018-10-28"
 	pe.paid_amount = 690
@@ -410,7 +363,7 @@ def add_vouchers(gl_account="_Test Bank - _TC"):
 	pe.submit()
 
 	si = create_sales_invoice(customer="Poore Simon's", qty=1, rate=3900)
-	pe = get_payment_entry("Sales Invoice", si.name, bank_account=gl_account)
+	pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC")
 	pe.reference_no = "Poore Simon's Oct 18"
 	pe.reference_date = "2018-10-28"
 	pe.insert()
@@ -433,12 +386,16 @@ def add_vouchers(gl_account="_Test Bank - _TC"):
 	if not frappe.db.get_value(
 		"Mode of Payment Account", {"company": "_Test Company", "parent": "Cash"}
 	):
-		mode_of_payment.append("accounts", {"company": "_Test Company", "default_account": gl_account})
+		mode_of_payment.append(
+			"accounts", {"company": "_Test Company", "default_account": "_Test Bank - _TC"}
+		)
 		mode_of_payment.save()
 
 	si = create_sales_invoice(customer="Fayva", qty=1, rate=109080, do_not_save=1)
 	si.is_pos = 1
-	si.append("payments", {"mode_of_payment": "Cash", "account": gl_account, "amount": 109080})
+	si.append(
+		"payments", {"mode_of_payment": "Cash", "account": "_Test Bank - _TC", "amount": 109080}
+	)
 	si.insert()
 	si.submit()
 

erpnext/accounts/doctype/cashier_closing/cashier_closing.json

@@ -1,152 +1,457 @@
 {
- "actions": [],
+ "allow_copy": 0,
+ "allow_events_in_timeline": 0,
+ "allow_guest_to_view": 0,
+ "allow_import": 0,
+ "allow_rename": 0,
  "autoname": "naming_series:",
+ "beta": 0,
  "creation": "2018-06-18 16:51:49.994750",
+ "custom": 0,
+ "docstatus": 0,
  "doctype": "DocType",
+ "document_type": "",
  "editable_grid": 1,
  "engine": "InnoDB",
- "field_order": [
-  "naming_series",
-  "user",
-  "date",
-  "from_time",
-  "time",
-  "expense",
-  "custody",
-  "returns",
-  "outstanding_amount",
-  "payments",
-  "net_amount",
-  "amended_from"
- ],
  "fields": [
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "POS-CLO-",
    "fieldname": "naming_series",
    "fieldtype": "Select",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
    "in_global_search": 1,
+   "in_list_view": 0,
    "in_standard_filter": 1,
    "label": "Series",
+   "length": 0,
+   "no_copy": 0,
    "options": "POS-CLO-",
-   "read_only": 1
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 1,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "fieldname": "user",
    "fieldtype": "Link",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "User",
+   "length": 0,
+   "no_copy": 0,
    "options": "User",
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
    "read_only": 1,
-   "reqd": 1
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 1,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "Today",
    "fieldname": "date",
    "fieldtype": "Date",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
+   "in_list_view": 0,
    "in_standard_filter": 1,
    "label": "Date",
-   "read_only": 1
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 1,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "fieldname": "from_time",
    "fieldtype": "Time",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
+   "in_list_view": 0,
    "in_standard_filter": 1,
    "label": "From Time",
-   "reqd": 1
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 1,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
+   "default": "",
    "fieldname": "time",
    "fieldtype": "Time",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
+   "in_list_view": 0,
    "in_standard_filter": 1,
    "label": "To Time",
-   "reqd": 1
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 1,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "0.00",
    "fieldname": "expense",
    "fieldtype": "Float",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
-   "label": "Expense"
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
+   "label": "Expense",
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "0.00",
    "fieldname": "custody",
    "fieldtype": "Float",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
-   "label": "Custody"
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
+   "label": "Custody",
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "0.00",
    "fieldname": "returns",
    "fieldtype": "Float",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
    "label": "Returns",
-   "precision": "2"
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "2",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "default": "0.00",
    "fieldname": "outstanding_amount",
    "fieldtype": "Float",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
+   "in_filter": 0,
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
    "label": "Outstanding Amount",
-   "read_only": 1
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 1,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
+   "default": "0.0",
    "fieldname": "payments",
    "fieldtype": "Table",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
    "label": "Payments",
-   "options": "Cashier Closing Payments"
+   "length": 0,
+   "no_copy": 0,
+   "options": "Cashier Closing Payments",
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 0,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "fieldname": "net_amount",
    "fieldtype": "Float",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
    "in_filter": 1,
+   "in_global_search": 0,
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Net Amount",
-   "read_only": 1
+   "length": 0,
+   "no_copy": 0,
+   "permlevel": 0,
+   "precision": "",
+   "print_hide": 0,
+   "print_hide_if_no_value": 0,
+   "read_only": 1,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   },
   {
+   "allow_bulk_edit": 0,
+   "allow_in_quick_entry": 0,
+   "allow_on_submit": 0,
+   "bold": 0,
+   "collapsible": 0,
+   "columns": 0,
    "fieldname": "amended_from",
    "fieldtype": "Link",
+   "hidden": 0,
+   "ignore_user_permissions": 0,
+   "ignore_xss_filter": 0,
+   "in_filter": 0,
+   "in_global_search": 0,
+   "in_list_view": 0,
+   "in_standard_filter": 0,
    "label": "Amended From",
+   "length": 0,
    "no_copy": 1,
    "options": "Cashier Closing",
+   "permlevel": 0,
    "print_hide": 1,
-   "read_only": 1
+   "print_hide_if_no_value": 0,
+   "read_only": 1,
+   "remember_last_selected_value": 0,
+   "report_hide": 0,
+   "reqd": 0,
+   "search_index": 0,
+   "set_only_once": 0,
+   "translatable": 0,
+   "unique": 0
   }
  ],
+ "has_web_view": 0,
+ "hide_heading": 0,
+ "hide_toolbar": 0,
+ "idx": 0,
+ "image_view": 0,
+ "in_create": 0,
  "is_submittable": 1,
- "links": [],
- "modified": "2023-12-28 13:15:46.858427",
+ "issingle": 0,
+ "istable": 0,
+ "max_attachments": 0,
+ "modified": "2019-02-19 08:35:24.157327",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Cashier Closing",
- "naming_rule": "By \"Naming Series\" field",
+ "name_case": "",
  "owner": "Administrator",
  "permissions": [
   {
+   "amend": 0,
+   "cancel": 0,
    "create": 1,
    "delete": 1,
    "email": 1,
    "export": 1,
+   "if_owner": 0,
+   "import": 0,
+   "permlevel": 0,
    "print": 1,
    "read": 1,
    "report": 1,
    "role": "System Manager",
+   "set_user_permissions": 0,
    "share": 1,
    "submit": 1,
    "write": 1
   }
  ],
+ "quick_entry": 0,
+ "read_only": 0,
+ "read_only_onload": 0,
+ "show_name_in_global_search": 0,
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
- "track_changes": 1
-}
+ "track_changes": 1,
+ "track_seen": 0,
+ "track_views": 0
+}

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js

@@ -53,18 +53,10 @@ frappe.ui.form.on('Chart of Accounts Importer', {
 								of Accounts. Please enter the account names and add more rows as per your requirement.`);
 						}
 					}
-				},
-				{
-					label : "Company",
-					fieldname: "company",
-					fieldtype: "Link",
-					reqd: 1,
-					hidden: 1,
-					default: frm.doc.company,
-				},
+				}
 			],
 			primary_action: function() {
-				let data = d.get_values();
+				var data = d.get_values();
 
 				if (!data.template_type) {
 					frappe.throw(__('Please select <b>Template Type</b> to download template'));
@@ -74,8 +66,7 @@ frappe.ui.form.on('Chart of Accounts Importer', {
 					'/api/method/erpnext.accounts.doctype.chart_of_accounts_importer.chart_of_accounts_importer.download_template',
 					{
 						file_type: data.file_type,
-						template_type: data.template_type,
-						company: data.company
+						template_type: data.template_type
 					}
 				);
 

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -8,7 +8,6 @@ from functools import reduce
 
 import frappe
 from frappe import _
-from frappe.desk.form.linked_with import get_linked_fields
 from frappe.model.document import Document
 from frappe.utils import cint, cstr
 from frappe.utils.csvutils import UnicodeWriter
@@ -113,7 +112,7 @@ def generate_data_from_csv(file_doc, as_dict=False):
 			if as_dict:
 				data.append({frappe.scrub(header): row[index] for index, header in enumerate(headers)})
 			else:
-				if not row[1] and len(row) > 1:
+				if not row[1]:
 					row[1] = row[0]
 					row[3] = row[2]
 				data.append(row)
@@ -295,8 +294,10 @@ def build_response_as_excel(writer):
 
 
 @frappe.whitelist()
-def download_template(file_type, template_type, company):
-	writer = get_template(template_type, company)
+def download_template(file_type, template_type):
+	data = frappe._dict(frappe.local.form_dict)
+
+	writer = get_template(template_type)
 
 	if file_type == "CSV":
 		# download csv file
@@ -307,7 +308,8 @@ def download_template(file_type, template_type, company):
 		build_response_as_excel(writer)
 
 
-def get_template(template_type, company):
+def get_template(template_type):
+
 	fields = [
 		"Account Name",
 		"Parent Account",
@@ -333,17 +335,34 @@ def get_template(template_type, company):
 				["", "", "", "", 0, account_type.get("account_type"), account_type.get("root_type")]
 			)
 	else:
-		writer = get_sample_template(writer, company)
+		writer = get_sample_template(writer)
 
 	return writer
 
 
-def get_sample_template(writer, company):
-	currency = frappe.db.get_value("Company", company, "default_currency")
-	with open(os.path.join(os.path.dirname(__file__), "coa_sample_template.csv"), "r") as f:
-		for row in f:
-			row = row.strip().split(",") + [currency]
-			writer.writerow(row)
+def get_sample_template(writer):
+	template = [
+		["Application Of Funds(Assets)", "", "", "", 1, "", "Asset"],
+		["Sources Of Funds(Liabilities)", "", "", "", 1, "", "Liability"],
+		["Equity", "", "", "", 1, "", "Equity"],
+		["Expenses", "", "", "", 1, "", "Expense"],
+		["Income", "", "", "", 1, "", "Income"],
+		["Bank Accounts", "Application Of Funds(Assets)", "", "", 1, "Bank", "Asset"],
+		["Cash In Hand", "Application Of Funds(Assets)", "", "", 1, "Cash", "Asset"],
+		["Stock Assets", "Application Of Funds(Assets)", "", "", 1, "Stock", "Asset"],
+		["Cost Of Goods Sold", "Expenses", "", "", 0, "Cost of Goods Sold", "Expense"],
+		["Asset Depreciation", "Expenses", "", "", 0, "Depreciation", "Expense"],
+		["Fixed Assets", "Application Of Funds(Assets)", "", "", 0, "Fixed Asset", "Asset"],
+		["Accounts Payable", "Sources Of Funds(Liabilities)", "", "", 0, "Payable", "Liability"],
+		["Accounts Receivable", "Application Of Funds(Assets)", "", "", 1, "Receivable", "Asset"],
+		["Stock Expenses", "Expenses", "", "", 0, "Stock Adjustment", "Expense"],
+		["Sample Bank", "Bank Accounts", "", "", 0, "Bank", "Asset"],
+		["Cash", "Cash In Hand", "", "", 0, "Cash", "Asset"],
+		["Stores", "Stock Assets", "", "", 0, "Stock", "Asset"],
+	]
+
+	for row in template:
+		writer.writerow(row)
 
 	return writer
 
@@ -434,11 +453,14 @@ def get_mandatory_account_types():
 
 
 def unset_existing_data(company):
-	# remove accounts data from company
+	linked = frappe.db.sql(
+		'''select fieldname from tabDocField
+		where fieldtype="Link" and options="Account" and parent="Company"''',
+		as_dict=True,
+	)
 
-	fieldnames = get_linked_fields("Account").get("Company", {}).get("fieldname", [])
-	linked = [{"fieldname": name} for name in fieldnames]
-	update_values = {d.get("fieldname"): "" for d in linked}
+	# remove accounts data from company
+	update_values = {d.fieldname: "" for d in linked}
 	frappe.db.set_value("Company", company, update_values, update_values)
 
 	# remove accounts data from various doctypes

erpnext/accounts/doctype/chart_of_accounts_importer/coa_sample_template.csv

@@ -1,17 +0,0 @@
-Application Of Funds(Assets),,,,1,,Asset
-Sources Of Funds(Liabilities),,,,1,,Liability
-Equity,,,,1,,Equity
-Expenses,,,,1,Expense Account,Expense
-Income,,,,1,Income Account,Income
-Bank Accounts,Application Of Funds(Assets),,,1,Bank,Asset
-Cash In Hand,Application Of Funds(Assets),,,1,Cash,Asset
-Stock Assets,Application Of Funds(Assets),,,1,Stock,Asset
-Cost Of Goods Sold,Expenses,,,0,Cost of Goods Sold,Expense
-Asset Depreciation,Expenses,,,0,Depreciation,Expense
-Fixed Assets,Application Of Funds(Assets),,,0,Fixed Asset,Asset
-Accounts Payable,Sources Of Funds(Liabilities),,,0,Payable,Liability
-Accounts Receivable,Application Of Funds(Assets),,,1,Receivable,Asset
-Stock Expenses,Expenses,,,0,Stock Adjustment,Expense
-Sample Bank,Bank Accounts,,,0,Bank,Asset
-Cash,Cash In Hand,,,0,Cash,Asset
-Stores,Stock Assets,,,0,Stock,Asset

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.json

@@ -6,10 +6,8 @@
  "engine": "InnoDB",
  "field_order": [
   "api_details_section",
-  "disabled",
   "service_provider",
   "api_endpoint",
-  "access_key",
   "url",
   "column_break_3",
   "help",
@@ -79,24 +77,12 @@
    "label": "Service Provider",
    "options": "frankfurter.app\nexchangerate.host\nCustom",
    "reqd": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "disabled",
-   "fieldtype": "Check",
-   "label": "Disabled"
-  },
-  {
-   "depends_on": "eval:doc.service_provider == 'exchangerate.host';",
-   "fieldname": "access_key",
-   "fieldtype": "Data",
-   "label": "Access Key"
   }
  ],
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-10-04 15:30:25.333860",
+ "modified": "2022-01-10 15:51:14.521174",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Currency Exchange Settings",

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.py

@@ -18,21 +18,11 @@ class CurrencyExchangeSettings(Document):
 
 	def set_parameters_and_result(self):
 		if self.service_provider == "exchangerate.host":
-
-			if not self.access_key:
-				frappe.throw(
-					_("Access Key is required for Service Provider: {0}").format(
-						frappe.bold(self.service_provider)
-					)
-				)
-
 			self.set("result_key", [])
 			self.set("req_params", [])
 
 			self.api_endpoint = "https://api.exchangerate.host/convert"
 			self.append("result_key", {"key": "result"})
-			self.append("req_params", {"key": "access_key", "value": self.access_key})
-			self.append("req_params", {"key": "amount", "value": "1"})
 			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}"})

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -192,7 +192,7 @@ class ExchangeRateRevaluation(Document):
 				# round off balance based on currency precision
 				# and consider debit-credit difference allowance
 				currency_precision = get_currency_precision()
-				rounding_loss_allowance = float(rounding_loss_allowance)
+				rounding_loss_allowance = float(rounding_loss_allowance) or 0.05
 				for acc in account_details:
 					acc.balance_in_account_currency = flt(acc.balance_in_account_currency, currency_precision)
 					if abs(acc.balance_in_account_currency) <= rounding_loss_allowance:

erpnext/accounts/doctype/fiscal_year/test_fiscal_year.py

@@ -41,7 +41,7 @@ def test_record_generator():
 	]
 
 	start = 2012
-	end = now_datetime().year + 25
+	end = now_datetime().year + 5
 	for year in range(start, end):
 		test_records.append(
 			{

erpnext/accounts/doctype/gl_entry/gl_entry.json

@@ -138,7 +138,8 @@
    "label": "Against Voucher Type",
    "oldfieldname": "against_voucher_type",
    "oldfieldtype": "Data",
-   "options": "DocType"
+   "options": "DocType",
+   "search_index": 1
   },
   {
    "fieldname": "against_voucher",
@@ -157,7 +158,8 @@
    "label": "Voucher Type",
    "oldfieldname": "voucher_type",
    "oldfieldtype": "Select",
-   "options": "DocType"
+   "options": "DocType",
+   "search_index": 1
   },
   {
    "fieldname": "voucher_no",
@@ -289,4 +291,4 @@
  "search_fields": "voucher_no,account,posting_date,against_voucher",
  "sort_field": "modified",
  "sort_order": "DESC"
-}
+}

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -13,9 +13,16 @@ import erpnext
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_checks_for_pl_and_bs_accounts,
 )
+from erpnext.accounts.doctype.accounting_dimension_filter.accounting_dimension_filter import (
+	get_dimension_filter_map,
+)
 from erpnext.accounts.party import validate_party_frozen_disabled, validate_party_gle_currency
 from erpnext.accounts.utils import get_account_currency, get_fiscal_year
-from erpnext.exceptions import InvalidAccountCurrency
+from erpnext.exceptions import (
+	InvalidAccountCurrency,
+	InvalidAccountDimensionError,
+	MandatoryAccountDimensionError,
+)
 
 exclude_from_linked_with = True
 
@@ -47,6 +54,7 @@ class GLEntry(Document):
 		if not self.flags.from_repost and self.voucher_type != "Period Closing Voucher":
 			self.validate_account_details(adv_adj)
 			self.validate_dimensions_for_pl_and_bs()
+			self.validate_allowed_dimensions()
 			validate_balance_type(self.account, adv_adj)
 			validate_frozen_account(self.account, adv_adj)
 
@@ -156,6 +164,42 @@ class GLEntry(Document):
 						)
 					)
 
+	def validate_allowed_dimensions(self):
+		dimension_filter_map = get_dimension_filter_map()
+		for key, value in dimension_filter_map.items():
+			dimension = key[0]
+			account = key[1]
+
+			if self.account == account:
+				if value["is_mandatory"] and not self.get(dimension):
+					frappe.throw(
+						_("{0} is mandatory for account {1}").format(
+							frappe.bold(frappe.unscrub(dimension)), frappe.bold(self.account)
+						),
+						MandatoryAccountDimensionError,
+					)
+
+				if value["allow_or_restrict"] == "Allow":
+					if self.get(dimension) and self.get(dimension) not in value["allowed_dimensions"]:
+						frappe.throw(
+							_("Invalid value {0} for {1} against account {2}").format(
+								frappe.bold(self.get(dimension)),
+								frappe.bold(frappe.unscrub(dimension)),
+								frappe.bold(self.account),
+							),
+							InvalidAccountDimensionError,
+						)
+				else:
+					if self.get(dimension) and self.get(dimension) in value["allowed_dimensions"]:
+						frappe.throw(
+							_("Invalid value {0} for {1} against account {2}").format(
+								frappe.bold(self.get(dimension)),
+								frappe.bold(frappe.unscrub(dimension)),
+								frappe.bold(self.account),
+							),
+							InvalidAccountDimensionError,
+						)
+
 	def check_pl_account(self):
 		if (
 			self.is_opening == "Yes"

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -8,7 +8,7 @@ frappe.provide("erpnext.journal_entry");
 frappe.ui.form.on("Journal Entry", {
 	setup: function(frm) {
 		frm.add_fetch("bank_account", "account", "account");
-		frm.ignore_doctypes_on_cancel_all = ["Sales Invoice", "Purchase Invoice", "Journal Entry", "Repost Payment Ledger", "Asset", "Asset Movement", "Repost Accounting Ledger", "Unreconcile Payment", "Unreconcile Payment Entries", "Bank Transaction"];
+		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', 'Journal Entry', 'Repost Payment Ledger', 'Asset', 'Asset Movement', 'Repost Accounting Ledger'];
 	},
 
 	refresh: function(frm) {
@@ -50,18 +50,8 @@ frappe.ui.form.on("Journal Entry", {
 					frm.trigger("make_inter_company_journal_entry");
 				}, __('Make'));
 		}
+	},
 
-		erpnext.accounts.unreconcile_payment.add_unreconcile_btn(frm);
-	},
-	before_save: function(frm) {
-		if ((frm.doc.docstatus == 0) && (!frm.doc.is_system_generated)) {
-			let payment_entry_references = frm.doc.accounts.filter(elem => (elem.reference_type == "Payment Entry"));
-			if (payment_entry_references.length > 0) {
-				let rows = payment_entry_references.map(x => "#"+x.idx);
-				frappe.throw(__("Rows: {0} have 'Payment Entry' as reference_type. This should not be set manually.", [frappe.utils.comma_and(rows)]));
-			}
-		}
-	},
 	make_inter_company_journal_entry: function(frm) {
 		var d = new frappe.ui.Dialog({
 			title: __("Select Company"),

erpnext/accounts/doctype/journal_entry/journal_entry.json

@@ -548,16 +548,8 @@
  "icon": "fa fa-file-text",
  "idx": 176,
  "is_submittable": 1,
- "links": [
-  {
-   "is_child_table": 1,
-   "link_doctype": "Bank Transaction Payments",
-   "link_fieldname": "payment_entry",
-   "parent_doctype": "Bank Transaction",
-   "table_fieldname": "payment_entries"
-  }
- ],
- "modified": "2023-11-23 12:11:04.128015",
+ "links": [],
+ "modified": "2023-08-10 14:32:22.366895",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry",

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -78,20 +78,6 @@ class JournalEntry(AccountsController):
 		if not self.title:
 			self.title = self.get_title()
 
-	def submit(self):
-		if len(self.accounts) > 100:
-			msgprint(_("The task has been enqueued as a background job."), alert=True)
-			self.queue_action("submit", timeout=4600)
-		else:
-			return self._submit()
-
-	def cancel(self):
-		if len(self.accounts) > 100:
-			msgprint(_("The task has been enqueued as a background job."), alert=True)
-			self.queue_action("cancel", timeout=4600)
-		else:
-			return self._cancel()
-
 	def on_submit(self):
 		self.validate_cheque_info()
 		self.check_credit_limit()
@@ -112,8 +98,6 @@ class JournalEntry(AccountsController):
 			"Repost Payment Ledger Items",
 			"Repost Accounting Ledger",
 			"Repost Accounting Ledger Items",
-			"Unreconcile Payment",
-			"Unreconcile Payment Entries",
 		)
 		self.make_gl_entries(1)
 		self.update_advance_paid()
@@ -512,7 +496,7 @@ class JournalEntry(AccountsController):
 							).format(d.reference_name, d.account)
 						)
 				else:
-					dr_or_cr = "debit" if flt(d.credit) > 0 else "credit"
+					dr_or_cr = "debit" if d.credit > 0 else "credit"
 					valid = False
 					for jvd in against_entries:
 						if flt(jvd[dr_or_cr]) > 0:

erpnext/accounts/doctype/journal_entry/test_records.json

@@ -81,6 +81,7 @@
    },
    {
     "account": "Sales - _TC",
+    "cost_center": "_Test Cost Center - _TC",
     "credit_in_account_currency": 400.0,
     "debit_in_account_currency": 0.0,
     "doctype": "Journal Entry Account",

erpnext/accounts/doctype/journal_entry_account/journal_entry_account.json

@@ -203,8 +203,7 @@
    "fieldtype": "Select",
    "label": "Reference Type",
    "no_copy": 1,
-   "options": "\nSales Invoice\nPurchase Invoice\nJournal Entry\nSales Order\nPurchase Order\nExpense Claim\nAsset\nLoan\nPayroll Entry\nEmployee Advance\nExchange Rate Revaluation\nInvoice Discounting\nFees\nFull and Final Statement\nPayment Entry",
-   "search_index": 1
+   "options": "\nSales Invoice\nPurchase Invoice\nJournal Entry\nSales Order\nPurchase Order\nExpense Claim\nAsset\nLoan\nPayroll Entry\nEmployee Advance\nExchange Rate Revaluation\nInvoice Discounting\nFees\nFull and Final Statement\nPayment Entry"
   },
   {
    "fieldname": "reference_name",
@@ -212,8 +211,7 @@
    "in_list_view": 1,
    "label": "Reference Name",
    "no_copy": 1,
-   "options": "reference_type",
-   "search_index": 1
+   "options": "reference_type"
   },
   {
    "depends_on": "eval:doc.reference_type&&!in_list(doc.reference_type, ['Expense Claim', 'Asset', 'Employee Loan', 'Employee Advance'])",
@@ -280,14 +278,13 @@
    "fieldtype": "Data",
    "hidden": 1,
    "label": "Reference Detail No",
-   "no_copy": 1,
-   "search_index": 1
+   "no_copy": 1
   }
  ],
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-11-23 11:44:25.841187",
+ "modified": "2023-06-16 14:11:13.507807",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry Account",

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -7,7 +7,7 @@ cur_frm.cscript.tax_table = "Advance Taxes and Charges";
 
 frappe.ui.form.on('Payment Entry', {
 	onload: function(frm) {
-		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', 'Journal Entry', 'Repost Payment Ledger', 'Repost Accounting Ledger', 'Unreconcile Payment', 'Unreconcile Payment Entries', 'Bank Transaction'];
+		frm.ignore_doctypes_on_cancel_all = ['Sales Invoice', 'Purchase Invoice', 'Journal Entry', 'Repost Payment Ledger','Repost Accounting Ledger'];
 
 		if(frm.doc.__islocal) {
 			if (!frm.doc.paid_from) frm.set_value("paid_from_account_currency", null);
@@ -152,13 +152,6 @@ frappe.ui.form.on('Payment Entry', {
 		frm.events.hide_unhide_fields(frm);
 		frm.events.set_dynamic_labels(frm);
 		frm.events.show_general_ledger(frm);
-		if((frm.doc.references) && (frm.doc.references.find((elem) => {return elem.exchange_gain_loss != 0}))) {
-			frm.add_custom_button(__("View Exchange Gain/Loss Journals"), function() {
-				frappe.set_route("List", "Journal Entry", {"voucher_type": "Exchange Gain Or Loss", "reference_name": frm.doc.name});
-			}, __('Actions'));
-
-		}
-		erpnext.accounts.unreconcile_payment.add_unreconcile_btn(frm);
 	},
 
 	validate_company: (frm) => {
@@ -631,7 +624,7 @@ frappe.ui.form.on('Payment Entry', {
 
 	get_outstanding_invoices_or_orders: function(frm, get_outstanding_invoices, get_orders_to_be_billed) {
 		const today = frappe.datetime.get_today();
-		let fields = [
+		const fields = [
 			{fieldtype:"Section Break", label: __("Posting Date")},
 			{fieldtype:"Date", label: __("From Date"),
 				fieldname:"from_posting_date", default:frappe.datetime.add_days(today, -30)},
@@ -646,29 +639,18 @@ frappe.ui.form.on('Payment Entry', {
 				fieldname:"outstanding_amt_greater_than", default: 0},
 			{fieldtype:"Column Break"},
 			{fieldtype:"Float", label: __("Less Than Amount"), fieldname:"outstanding_amt_less_than"},
-		];
-
-		if (frm.dimension_filters) {
-			let column_break_insertion_point = Math.ceil((frm.dimension_filters.length)/2);
-
-			fields.push({fieldtype:"Section Break"});
-			frm.dimension_filters.map((elem, idx)=>{
-				fields.push({
-					fieldtype: "Link",
-					label: elem.document_type == "Cost Center" ? "Cost Center" : elem.label,
-					options: elem.document_type,
-					fieldname: elem.fieldname || elem.document_type
-				});
-				if(idx+1 == column_break_insertion_point) {
-					fields.push({fieldtype:"Column Break"});
+			{fieldtype:"Section Break"},
+			{fieldtype:"Link", label:__("Cost Center"), fieldname:"cost_center", options:"Cost Center",
+				"get_query": function() {
+					return {
+						"filters": {"company": frm.doc.company}
+					}
 				}
-			});
-		}
-
-		fields = fields.concat([
+			},
+			{fieldtype:"Column Break"},
 			{fieldtype:"Section Break"},
 			{fieldtype:"Check", label: __("Allocate Payment Amount"), fieldname:"allocate_payment_amount", default:1},
-		]);
+		];
 
 		let btn_text = "";
 
@@ -840,6 +822,7 @@ frappe.ui.form.on('Payment Entry', {
 			else
 				total_negative_outstanding += Math.abs(flt(row.outstanding_amount));
 		})
+
 		var allocated_negative_outstanding = 0;
 		if (
 				(frm.doc.payment_type=="Receive" && frm.doc.party_type=="Customer") ||
@@ -854,7 +837,6 @@ frappe.ui.form.on('Payment Entry', {
 
 			var allocated_positive_outstanding =  paid_amount + allocated_negative_outstanding;
 		} else if (in_list(["Customer", "Supplier"], frm.doc.party_type)) {
-			total_negative_outstanding = flt(total_negative_outstanding, precision("outstanding_amount"))
 			if(paid_amount > total_negative_outstanding) {
 				if(total_negative_outstanding == 0) {
 					frappe.msgprint(
@@ -930,7 +912,7 @@ frappe.ui.form.on('Payment Entry', {
 			if(frm.doc.payment_type == "Receive"
 				&& frm.doc.base_total_allocated_amount < frm.doc.base_received_amount + total_deductions
 				&& frm.doc.total_allocated_amount < frm.doc.paid_amount + (total_deductions / frm.doc.source_exchange_rate)) {
-					unallocated_amount = (frm.doc.base_received_amount + total_deductions - flt(frm.doc.base_total_taxes_and_charges)
+					unallocated_amount = (frm.doc.base_received_amount + total_deductions + flt(frm.doc.base_total_taxes_and_charges)
 						- frm.doc.base_total_allocated_amount) / frm.doc.source_exchange_rate;
 			} else if (frm.doc.payment_type == "Pay"
 				&& frm.doc.base_total_allocated_amount < frm.doc.base_paid_amount - total_deductions

erpnext/accounts/doctype/payment_entry/payment_entry.json

@@ -739,16 +739,8 @@
  ],
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
- "links": [
-  {
-   "is_child_table": 1,
-   "link_doctype": "Bank Transaction Payments",
-   "link_fieldname": "payment_entry",
-   "parent_doctype": "Bank Transaction",
-   "table_fieldname": "payment_entries"
-  }
- ],
- "modified": "2023-11-23 12:07:20.887885",
+ "links": [],
+ "modified": "2023-06-19 11:38:04.387219",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry",
@@ -794,4 +786,4 @@
  "states": [],
  "title_field": "title",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -9,11 +9,8 @@ import frappe
 from frappe import ValidationError, _, qb, scrub, throw
 from frappe.utils import cint, comma_or, flt, getdate, nowdate
 from frappe.utils.data import comma_and, fmt_money
-from pypika import Case
-from pypika.functions import Coalesce, Sum
 
 import erpnext
-from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import get_dimensions
 from erpnext.accounts.doctype.bank_account.bank_account import (
 	get_bank_account_details,
 	get_party_bank_account,
@@ -110,8 +107,6 @@ class PaymentEntry(AccountsController):
 			"Repost Payment Ledger Items",
 			"Repost Accounting Ledger",
 			"Repost Accounting Ledger Items",
-			"Unreconcile Payment",
-			"Unreconcile Payment Entries",
 		)
 		super(PaymentEntry, self).on_cancel()
 		self.make_gl_entries(cancel=1)
@@ -232,18 +227,16 @@ class PaymentEntry(AccountsController):
 
 				# if no payment template is used by invoice and has a custom term(no `payment_term`), then invoice outstanding will be in 'None' key
 				latest = latest.get(d.payment_term) or latest.get(None)
+
 				# The reference has already been fully paid
 				if not latest:
 					frappe.throw(
 						_("{0} {1} has already been fully paid.").format(_(d.reference_doctype), d.reference_name)
 					)
 				# The reference has already been partly paid
-				elif (
-					latest.outstanding_amount < latest.invoice_amount
-					and flt(d.outstanding_amount, d.precision("outstanding_amount"))
-					!= flt(latest.outstanding_amount, d.precision("outstanding_amount"))
-					and d.payment_term == ""
-				):
+				elif latest.outstanding_amount < latest.invoice_amount and flt(
+					d.outstanding_amount, d.precision("outstanding_amount")
+				) != flt(latest.outstanding_amount, d.precision("outstanding_amount")):
 					frappe.throw(
 						_(
 							"{0} {1} has already been partly paid. Please use the 'Get Outstanding Invoice' or the 'Get Outstanding Orders' button to get the latest outstanding amounts."
@@ -874,19 +867,19 @@ class PaymentEntry(AccountsController):
 		)
 
 		base_party_amount = flt(self.base_total_allocated_amount) + flt(base_unallocated_amount)
-		included_taxes = self.get_included_taxes()
 
 		if self.payment_type == "Receive":
-			self.difference_amount = base_party_amount - self.base_received_amount + included_taxes
+			self.difference_amount = base_party_amount - self.base_received_amount
 		elif self.payment_type == "Pay":
-			self.difference_amount = self.base_paid_amount - base_party_amount - included_taxes
+			self.difference_amount = self.base_paid_amount - base_party_amount
 		else:
-			self.difference_amount = self.base_paid_amount - flt(self.base_received_amount) - included_taxes
+			self.difference_amount = self.base_paid_amount - flt(self.base_received_amount)
 
 		total_deductions = sum(flt(d.amount) for d in self.get("deductions"))
+		included_taxes = self.get_included_taxes()
 
 		self.difference_amount = flt(
-			self.difference_amount - total_deductions, self.precision("difference_amount")
+			self.difference_amount - total_deductions - included_taxes, self.precision("difference_amount")
 		)
 
 	def get_included_taxes(self):
@@ -916,11 +909,8 @@ class PaymentEntry(AccountsController):
 		):
 			return
 
-		total_negative_outstanding = flt(
-			sum(
-				abs(flt(d.outstanding_amount)) for d in self.get("references") if flt(d.outstanding_amount) < 0
-			),
-			self.references[0].precision("outstanding_amount") if self.references else None,
+		total_negative_outstanding = sum(
+			abs(flt(d.outstanding_amount)) for d in self.get("references") if flt(d.outstanding_amount) < 0
 		)
 
 		paid_amount = self.paid_amount if self.payment_type == "Receive" else self.received_amount
@@ -1454,13 +1444,6 @@ def get_outstanding_reference_documents(args):
 		condition += " and cost_center='%s'" % args.get("cost_center")
 		accounting_dimensions_filter.append(ple.cost_center == args.get("cost_center"))
 
-	# dynamic dimension filters
-	active_dimensions = get_dimensions()[0]
-	for dim in active_dimensions:
-		if args.get(dim.fieldname):
-			condition += " and {0}='{1}'".format(dim.fieldname, args.get(dim.fieldname))
-			accounting_dimensions_filter.append(ple[dim.fieldname] == args.get(dim.fieldname))
-
 	date_fields_dict = {
 		"posting_date": ["from_posting_date", "to_posting_date"],
 		"due_date": ["from_due_date", "to_due_date"],
@@ -1562,43 +1545,13 @@ def get_outstanding_reference_documents(args):
 	return data
 
 
-def split_invoices_based_on_payment_terms(outstanding_invoices, company) -> list:
-	"""Split a list of invoices based on their payment terms."""
-	exc_rates = get_currency_data(outstanding_invoices, company)
+def split_invoices_based_on_payment_terms(outstanding_invoices, company):
+	invoice_ref_based_on_payment_terms = {}
 
-	outstanding_invoices_after_split = []
-	for entry in outstanding_invoices:
-		if entry.voucher_type in ["Sales Invoice", "Purchase Invoice"]:
-			if payment_term_template := frappe.db.get_value(
-				entry.voucher_type, entry.voucher_no, "payment_terms_template"
-			):
-				split_rows = get_split_invoice_rows(entry, payment_term_template, exc_rates)
-				if not split_rows:
-					continue
-
-				if len(split_rows) > 1:
-					frappe.msgprint(
-						_("Splitting {0} {1} into {2} rows as per Payment Terms").format(
-							_(entry.voucher_type), frappe.bold(entry.voucher_no), len(split_rows)
-						),
-						alert=True,
-					)
-				outstanding_invoices_after_split += split_rows
-				continue
-
-		# If not an invoice or no payment terms template, add as it is
-		outstanding_invoices_after_split.append(entry)
-
-	return outstanding_invoices_after_split
-
-
-def get_currency_data(outstanding_invoices: list, company: str = None) -> dict:
-	"""Get currency and conversion data for a list of invoices."""
-	exc_rates = frappe._dict()
 	company_currency = (
 		frappe.db.get_value("Company", company, "default_currency") if company else None
 	)
-
+	exc_rates = frappe._dict()
 	for doctype in ["Sales Invoice", "Purchase Invoice"]:
 		invoices = [x.voucher_no for x in outstanding_invoices if x.voucher_type == doctype]
 		for x in frappe.db.get_all(
@@ -1613,54 +1566,72 @@ def get_currency_data(outstanding_invoices: list, company: str = None) -> dict:
 				company_currency=company_currency,
 			)
 
-	return exc_rates
-
-
-def get_split_invoice_rows(invoice: dict, payment_term_template: str, exc_rates: dict) -> list:
-	"""Split invoice based on its payment schedule table."""
-	split_rows = []
-	allocate_payment_based_on_payment_terms = frappe.db.get_value(
-		"Payment Terms Template", payment_term_template, "allocate_payment_based_on_payment_terms"
-	)
-
-	if not allocate_payment_based_on_payment_terms:
-		return [invoice]
-
-	payment_schedule = frappe.get_all(
-		"Payment Schedule", filters={"parent": invoice.voucher_no}, fields=["*"], order_by="due_date"
-	)
-	for payment_term in payment_schedule:
-		if not payment_term.outstanding > 0.1:
-			continue
-
-		doc_details = exc_rates.get(payment_term.parent, None)
-		is_multi_currency_acc = (doc_details.currency != doc_details.company_currency) and (
-			doc_details.party_account_currency != doc_details.company_currency
-		)
-		payment_term_outstanding = flt(payment_term.outstanding)
-		if not is_multi_currency_acc:
-			payment_term_outstanding = doc_details.conversion_rate * flt(payment_term.outstanding)
-
-		split_rows.append(
-			frappe._dict(
-				{
-					"due_date": invoice.due_date,
-					"currency": invoice.currency,
-					"voucher_no": invoice.voucher_no,
-					"voucher_type": invoice.voucher_type,
-					"posting_date": invoice.posting_date,
-					"invoice_amount": flt(invoice.invoice_amount),
-					"outstanding_amount": payment_term_outstanding
-					if payment_term_outstanding
-					else invoice.outstanding_amount,
-					"payment_term_outstanding": payment_term_outstanding,
-					"payment_amount": payment_term.payment_amount,
-					"payment_term": payment_term.payment_term,
-				}
+	for idx, d in enumerate(outstanding_invoices):
+		if d.voucher_type in ["Sales Invoice", "Purchase Invoice"]:
+			payment_term_template = frappe.db.get_value(
+				d.voucher_type, d.voucher_no, "payment_terms_template"
 			)
-		)
+			if payment_term_template:
+				allocate_payment_based_on_payment_terms = frappe.db.get_value(
+					"Payment Terms Template", payment_term_template, "allocate_payment_based_on_payment_terms"
+				)
+				if allocate_payment_based_on_payment_terms:
+					payment_schedule = frappe.get_all(
+						"Payment Schedule", filters={"parent": d.voucher_no}, fields=["*"]
+					)
 
-	return split_rows
+					for payment_term in payment_schedule:
+						if payment_term.outstanding > 0.1:
+							doc_details = exc_rates.get(payment_term.parent, None)
+							is_multi_currency_acc = (doc_details.currency != doc_details.company_currency) and (
+								doc_details.party_account_currency != doc_details.company_currency
+							)
+							payment_term_outstanding = flt(payment_term.outstanding)
+							if not is_multi_currency_acc:
+								payment_term_outstanding = doc_details.conversion_rate * flt(payment_term.outstanding)
+
+							invoice_ref_based_on_payment_terms.setdefault(idx, [])
+							invoice_ref_based_on_payment_terms[idx].append(
+								frappe._dict(
+									{
+										"due_date": d.due_date,
+										"currency": d.currency,
+										"voucher_no": d.voucher_no,
+										"voucher_type": d.voucher_type,
+										"posting_date": d.posting_date,
+										"invoice_amount": flt(d.invoice_amount),
+										"outstanding_amount": flt(d.outstanding_amount),
+										"payment_term_outstanding": payment_term_outstanding,
+										"allocated_amount": payment_term_outstanding
+										if payment_term_outstanding
+										else d.outstanding_amount,
+										"payment_amount": payment_term.payment_amount,
+										"payment_term": payment_term.payment_term,
+									}
+								)
+							)
+
+	outstanding_invoices_after_split = []
+	if invoice_ref_based_on_payment_terms:
+		for idx, ref in invoice_ref_based_on_payment_terms.items():
+			voucher_no = ref[0]["voucher_no"]
+			voucher_type = ref[0]["voucher_type"]
+
+			frappe.msgprint(
+				_("Spliting {} {} into {} row(s) as per Payment Terms").format(
+					voucher_type, voucher_no, len(ref)
+				),
+				alert=True,
+			)
+
+			outstanding_invoices_after_split += invoice_ref_based_on_payment_terms[idx]
+
+			existing_row = list(filter(lambda x: x.get("voucher_no") == voucher_no, outstanding_invoices))
+			index = outstanding_invoices.index(existing_row[0])
+			outstanding_invoices.pop(index)
+
+	outstanding_invoices_after_split += outstanding_invoices
+	return outstanding_invoices_after_split
 
 
 def get_orders_to_be_billed(
@@ -1688,12 +1659,6 @@ def get_orders_to_be_billed(
 	if doc and hasattr(doc, "cost_center") and doc.cost_center:
 		condition = " and cost_center='%s'" % cost_center
 
-	# dynamic dimension filters
-	active_dimensions = get_dimensions()[0]
-	for dim in active_dimensions:
-		if filters.get(dim.fieldname):
-			condition += " and {0}='{1}'".format(dim.fieldname, filters.get(dim.fieldname))
-
 	if party_account_currency == company_currency:
 		grand_total_field = "base_grand_total"
 		rounded_total_field = "base_rounded_total"
@@ -1870,24 +1835,18 @@ def get_company_defaults(company):
 
 
 def get_outstanding_on_journal_entry(name):
-	gl = frappe.qb.DocType("GL Entry")
-	res = (
-		frappe.qb.from_(gl)
-		.select(
-			Case()
-			.when(
-				gl.party_type == "Customer",
-				Coalesce(Sum(gl.debit_in_account_currency - gl.credit_in_account_currency), 0),
-			)
-			.else_(Coalesce(Sum(gl.credit_in_account_currency - gl.debit_in_account_currency), 0))
-			.as_("outstanding_amount")
-		)
-		.where(
-			(Coalesce(gl.party_type, "") != "")
-			& (gl.is_cancelled == 0)
-			& ((gl.voucher_no == name) | (gl.against_voucher == name))
-		)
-	).run(as_dict=True)
+	res = frappe.db.sql(
+		"SELECT "
+		'CASE WHEN party_type IN ("Customer") '
+		"THEN ifnull(sum(debit_in_account_currency - credit_in_account_currency), 0) "
+		"ELSE ifnull(sum(credit_in_account_currency - debit_in_account_currency), 0) "
+		"END as outstanding_amount "
+		"FROM `tabGL Entry` WHERE (voucher_no=%s OR against_voucher=%s) "
+		"AND party_type IS NOT NULL "
+		'AND party_type != ""',
+		(name, name),
+		as_dict=1,
+	)
 
 	outstanding_amount = res[0].get("outstanding_amount", 0) if res else 0
 

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -1,17 +1,15 @@
 # Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-import json
 import unittest
 
 import frappe
 from frappe import qb
 from frappe.tests.utils import FrappeTestCase, change_settings
-from frappe.utils import add_days, flt, nowdate
+from frappe.utils import flt, nowdate
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import (
 	InvalidPaymentEntry,
-	get_outstanding_reference_documents,
 	get_payment_entry,
 	get_reference_details,
 )
@@ -23,7 +21,6 @@ from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import (
 	create_sales_invoice,
 	create_sales_invoice_against_cost_center,
 )
-from erpnext.accounts.general_ledger import make_gl_entries, make_reverse_gl_entries
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.setup.doctype.employee.test_employee import make_employee
 
@@ -705,50 +702,7 @@ class TestPaymentEntry(FrappeTestCase):
 		pe2.submit()
 
 		# create return entry against si1
-		cr_note = create_sales_invoice(is_return=1, return_against=si1.name, qty=-1)
-		si1_outstanding = frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount")
-
-		# create JE(credit note) manually against si1 and cr_note
-		je = frappe.get_doc(
-			{
-				"doctype": "Journal Entry",
-				"company": si1.company,
-				"voucher_type": "Credit Note",
-				"posting_date": nowdate(),
-			}
-		)
-		je.append(
-			"accounts",
-			{
-				"account": si1.debit_to,
-				"party_type": "Customer",
-				"party": si1.customer,
-				"debit": 0,
-				"credit": 100,
-				"debit_in_account_currency": 0,
-				"credit_in_account_currency": 100,
-				"reference_type": si1.doctype,
-				"reference_name": si1.name,
-				"cost_center": si1.items[0].cost_center,
-			},
-		)
-		je.append(
-			"accounts",
-			{
-				"account": cr_note.debit_to,
-				"party_type": "Customer",
-				"party": cr_note.customer,
-				"debit": 100,
-				"credit": 0,
-				"debit_in_account_currency": 100,
-				"credit_in_account_currency": 0,
-				"reference_type": cr_note.doctype,
-				"reference_name": cr_note.name,
-				"cost_center": cr_note.items[0].cost_center,
-			},
-		)
-		je.save().submit()
-
+		create_sales_invoice(is_return=1, return_against=si1.name, qty=-1)
 		si1_outstanding = frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount")
 		self.assertEqual(si1_outstanding, -100)
 
@@ -1265,115 +1219,6 @@ class TestPaymentEntry(FrappeTestCase):
 		so.reload()
 		self.assertEqual(so.advance_paid, so.rounded_total)
 
-	def test_outstanding_invoices_api(self):
-		"""
-		Test if `get_outstanding_reference_documents` fetches invoices in the right order.
-		"""
-		customer = create_customer("Max Mustermann", "INR")
-		create_payment_terms_template()
-
-		# SI has an earlier due date and SI2 has a later due date
-		si = create_sales_invoice(
-			qty=1, rate=100, customer=customer, posting_date=add_days(nowdate(), -4)
-		)
-		si2 = create_sales_invoice(do_not_save=1, qty=1, rate=100, customer=customer)
-		si2.payment_terms_template = "Test Receivable Template"
-		si2.submit()
-
-		args = {
-			"posting_date": nowdate(),
-			"company": "_Test Company",
-			"party_type": "Customer",
-			"payment_type": "Pay",
-			"party": customer,
-			"party_account": "Debtors - _TC",
-		}
-		args.update(
-			{
-				"get_outstanding_invoices": True,
-				"from_posting_date": add_days(nowdate(), -4),
-				"to_posting_date": add_days(nowdate(), 2),
-			}
-		)
-		references = get_outstanding_reference_documents(args)
-
-		self.assertEqual(len(references), 3)
-		self.assertEqual(references[0].voucher_no, si.name)
-		self.assertEqual(references[1].voucher_no, si2.name)
-		self.assertEqual(references[2].voucher_no, si2.name)
-		self.assertEqual(references[1].payment_term, "Basic Amount Receivable")
-		self.assertEqual(references[2].payment_term, "Tax Receivable")
-
-	def test_partial_cancel_for_payment_entry(self):
-		si = create_sales_invoice()
-
-		pe = get_payment_entry(si.doctype, si.name)
-		pe.save()
-		pe.submit()
-
-		# Additional GL Entry
-		tax_amount = 10
-		reference_row = pe.references[0]
-		gl_args = {
-			"party_type": pe.party_type,
-			"party": pe.party,
-			"against_voucher_type": reference_row.reference_doctype,
-			"against_voucher": reference_row.reference_name,
-			"voucher_detail_no": reference_row.name,
-		}
-
-		gl_dicts = []
-
-		gl_dicts.extend(
-			[
-				pe.get_gl_dict(
-					{
-						"account": pe.paid_to,
-						"credit": tax_amount,
-						"credit_in_account_currency": tax_amount,
-						**gl_args,
-					}
-				),
-				pe.get_gl_dict(
-					{
-						"account": pe.paid_from,
-						"debit": tax_amount,
-						"debit_in_account_currency": tax_amount,
-						**gl_args,
-					}
-				),
-			]
-		)
-
-		make_gl_entries(gl_dicts)
-
-		# Assert PLEs Before
-		self.assertPLEntries(
-			pe,
-			[
-				{"amount": -100.0, "against_voucher_no": si.name},
-				{"amount": 10.0, "against_voucher_no": si.name},
-			],
-		)
-
-		# Partially cancel Payment Entry
-		make_reverse_gl_entries(gl_dicts, partial_cancel=True)
-		self.assertPLEntries(pe, [{"amount": -100.0, "against_voucher_no": si.name}])
-
-	def assertPLEntries(self, payment_doc, expected_pl_entries):
-		pl_entries = frappe.get_all(
-			"Payment Ledger Entry",
-			filters={
-				"voucher_type": payment_doc.doctype,
-				"voucher_no": payment_doc.name,
-				"delinked": 0,
-			},
-			fields=["amount", "against_voucher_no"],
-		)
-		out_str = json.dumps(sorted(pl_entries, key=json.dumps))
-		expected_out_str = json.dumps(sorted(expected_pl_entries, key=json.dumps))
-		self.assertEqual(out_str, expected_out_str)
-
 
 def create_payment_entry(**args):
 	payment_entry = frappe.new_doc("Payment Entry")
@@ -1434,9 +1279,6 @@ def create_payment_terms_template():
 def create_payment_terms_template_with_discount(
 	name=None, discount_type=None, discount=None, template_name=None
 ):
-	"""
-	Create a Payment Terms Template with %  or amount discount.
-	"""
 	create_payment_term(name or "30 Credit Days with 10% Discount")
 	template_name = template_name or "Test Discount Template"
 

erpnext/accounts/doctype/payment_ledger_entry/payment_ledger_entry.json

@@ -13,7 +13,6 @@
   "party_type",
   "party",
   "due_date",
-  "voucher_detail_no",
   "cost_center",
   "finance_book",
   "voucher_type",
@@ -30,8 +29,7 @@
   {
    "fieldname": "posting_date",
    "fieldtype": "Date",
-   "label": "Posting Date",
-   "search_index": 1
+   "label": "Posting Date"
   },
   {
    "fieldname": "account_type",
@@ -65,8 +63,7 @@
    "fieldtype": "Link",
    "in_standard_filter": 1,
    "label": "Voucher Type",
-   "options": "DocType",
-   "search_index": 1
+   "options": "DocType"
   },
   {
    "fieldname": "voucher_no",
@@ -74,16 +71,14 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Voucher No",
-   "options": "voucher_type",
-   "search_index": 1
+   "options": "voucher_type"
   },
   {
    "fieldname": "against_voucher_type",
    "fieldtype": "Link",
    "in_standard_filter": 1,
    "label": "Against Voucher Type",
-   "options": "DocType",
-   "search_index": 1
+   "options": "DocType"
   },
   {
    "fieldname": "against_voucher_no",
@@ -91,8 +86,7 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Against Voucher No",
-   "options": "against_voucher_type",
-   "search_index": 1
+   "options": "against_voucher_type"
   },
   {
    "fieldname": "amount",
@@ -148,18 +142,12 @@
    "fieldname": "remarks",
    "fieldtype": "Text",
    "label": "Remarks"
-  },
-  {
-   "fieldname": "voucher_detail_no",
-   "fieldtype": "Data",
-   "label": "Voucher Detail No",
-   "search_index": 1
   }
  ],
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2023-11-08 10:53:10.664896",
+ "modified": "2022-08-22 15:32:56.629430",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Ledger Entry",

erpnext/accounts/doctype/payment_ledger_entry/test_payment_ledger_entry.py

@@ -294,7 +294,7 @@ class TestPaymentLedgerEntry(FrappeTestCase):
 		cr_note1.return_against = si3.name
 		cr_note1 = cr_note1.save().submit()
 
-		pl_entries_si3 = (
+		pl_entries = (
 			qb.from_(ple)
 			.select(
 				ple.voucher_type,
@@ -309,24 +309,7 @@ class TestPaymentLedgerEntry(FrappeTestCase):
 			.run(as_dict=True)
 		)
 
-		pl_entries_cr_note1 = (
-			qb.from_(ple)
-			.select(
-				ple.voucher_type,
-				ple.voucher_no,
-				ple.against_voucher_type,
-				ple.against_voucher_no,
-				ple.amount,
-				ple.delinked,
-			)
-			.where(
-				(ple.against_voucher_type == cr_note1.doctype) & (ple.against_voucher_no == cr_note1.name)
-			)
-			.orderby(ple.creation)
-			.run(as_dict=True)
-		)
-
-		expected_values_for_si3 = [
+		expected_values = [
 			{
 				"voucher_type": si3.doctype,
 				"voucher_no": si3.name,
@@ -334,21 +317,18 @@ class TestPaymentLedgerEntry(FrappeTestCase):
 				"against_voucher_no": si3.name,
 				"amount": amount,
 				"delinked": 0,
-			}
-		]
-		# credit/debit notes post ledger entries against itself
-		expected_values_for_cr_note1 = [
+			},
 			{
 				"voucher_type": cr_note1.doctype,
 				"voucher_no": cr_note1.name,
-				"against_voucher_type": cr_note1.doctype,
-				"against_voucher_no": cr_note1.name,
+				"against_voucher_type": si3.doctype,
+				"against_voucher_no": si3.name,
 				"amount": -amount,
 				"delinked": 0,
 			},
 		]
-		self.assertEqual(pl_entries_si3, expected_values_for_si3)
-		self.assertEqual(pl_entries_cr_note1, expected_values_for_cr_note1)
+		self.assertEqual(pl_entries[0], expected_values[0])
+		self.assertEqual(pl_entries[1], expected_values[1])
 
 	def test_je_against_inv_and_note(self):
 		ple = self.ple

erpnext/accounts/doctype/payment_order/test_payment_order.py

@@ -4,13 +4,9 @@
 import unittest
 
 import frappe
-from frappe.tests.utils import FrappeTestCase
 from frappe.utils import getdate
 
-from erpnext.accounts.doctype.bank_transaction.test_bank_transaction import (
-	create_bank_account,
-	create_gl_account,
-)
+from erpnext.accounts.doctype.bank_transaction.test_bank_transaction import create_bank_account
 from erpnext.accounts.doctype.payment_entry.payment_entry import (
 	get_payment_entry,
 	make_payment_order,
@@ -18,32 +14,28 @@ from erpnext.accounts.doctype.payment_entry.payment_entry import (
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 
 
-class TestPaymentOrder(FrappeTestCase):
+class TestPaymentOrder(unittest.TestCase):
 	def setUp(self):
-		# generate and use a uniq hash identifier for 'Bank Account' and it's linked GL 'Account' to avoid validation error
-		uniq_identifier = frappe.generate_hash(length=10)
-		self.gl_account = create_gl_account("_Test Bank " + uniq_identifier)
-		self.bank_account = create_bank_account(
-			gl_account=self.gl_account, bank_account_name="Checking Account " + uniq_identifier
-		)
+		create_bank_account()
 
 	def tearDown(self):
-		frappe.db.rollback()
+		for bt in frappe.get_all("Payment Order"):
+			doc = frappe.get_doc("Payment Order", bt.name)
+			doc.cancel()
+			doc.delete()
 
 	def test_payment_order_creation_against_payment_entry(self):
 		purchase_invoice = make_purchase_invoice()
 		payment_entry = get_payment_entry(
-			"Purchase Invoice", purchase_invoice.name, bank_account=self.gl_account
+			"Purchase Invoice", purchase_invoice.name, bank_account="_Test Bank - _TC"
 		)
 		payment_entry.reference_no = "_Test_Payment_Order"
 		payment_entry.reference_date = getdate()
-		payment_entry.party_bank_account = self.bank_account
+		payment_entry.party_bank_account = "Checking Account - Citi Bank"
 		payment_entry.insert()
 		payment_entry.submit()
 
-		doc = create_payment_order_against_payment_entry(
-			payment_entry, "Payment Entry", self.bank_account
-		)
+		doc = create_payment_order_against_payment_entry(payment_entry, "Payment Entry")
 		reference_doc = doc.get("references")[0]
 		self.assertEqual(reference_doc.reference_name, payment_entry.name)
 		self.assertEqual(reference_doc.reference_doctype, "Payment Entry")
@@ -51,13 +43,13 @@ class TestPaymentOrder(FrappeTestCase):
 		self.assertEqual(reference_doc.amount, 250)
 
 
-def create_payment_order_against_payment_entry(ref_doc, order_type, bank_account):
+def create_payment_order_against_payment_entry(ref_doc, order_type):
 	payment_order = frappe.get_doc(
 		dict(
 			doctype="Payment Order",
 			company="_Test Company",
 			payment_order_type=order_type,
-			company_bank_account=bank_account,
+			company_bank_account="Checking Account - Citi Bank",
 		)
 	)
 	doc = make_payment_order(ref_doc.name, payment_order)

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js

@@ -83,8 +83,6 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 			this.frm.change_custom_button_type('Allocate', null, 'default');
 		}
 
-		this.frm.trigger("set_query_for_dimension_filters");
-
 		// check for any running reconciliation jobs
 		if (this.frm.doc.receivable_payable_account) {
 			this.frm.call({
@@ -115,25 +113,6 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 		}
 
 	}
-	set_query_for_dimension_filters() {
-		frappe.call({
-			method: "erpnext.accounts.doctype.payment_reconciliation.payment_reconciliation.get_queries_for_dimension_filters",
-			args: {
-				company: this.frm.doc.company,
-			},
-			callback: (r) => {
-				if (!r.exc && r.message) {
-					r.message.forEach(x => {
-						this.frm.set_query(x.fieldname, () => {
-							return {
-								'filters': x.filters
-							};
-						});
-					});
-				}
-			}
-		});
-	}
 
 	company() {
 		this.frm.set_value('party', '');
@@ -237,7 +216,6 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 			this.data = [];
 			const dialog = new frappe.ui.Dialog({
 				title: __("Select Difference Account"),
-				size: 'extra-large',
 				fields: [
 					{
 						fieldname: "allocation",
@@ -261,13 +239,6 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 							in_list_view: 1,
 							read_only: 1
 						}, {
-							fieldtype:'Date',
-							fieldname:"gain_loss_posting_date",
-							label: __("Posting Date"),
-							in_list_view: 1,
-							reqd: 1,
-						}, {
-
 							fieldtype:'Link',
 							options: 'Account',
 							in_list_view: 1,
@@ -301,9 +272,6 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 					args.forEach(d => {
 						frappe.model.set_value("Payment Reconciliation Allocation", d.docname,
 							"difference_account", d.difference_account);
-						frappe.model.set_value("Payment Reconciliation Allocation", d.docname,
-							"gain_loss_posting_date", d.gain_loss_posting_date);
-
 					});
 
 					this.reconcile_payment_entries();
@@ -319,7 +287,6 @@ erpnext.accounts.PaymentReconciliationController = class PaymentReconciliationCo
 						'reference_name': d.reference_name,
 						'difference_amount': d.difference_amount,
 						'difference_account': d.difference_account,
-						'gain_loss_posting_date': d.gain_loss_posting_date
 					});
 				}
 			});

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.json

@@ -24,9 +24,7 @@
   "invoice_limit",
   "payment_limit",
   "bank_cash_account",
-  "accounting_dimensions_section",
   "cost_center",
-  "dimension_col_break",
   "sec_break1",
   "invoice_name",
   "invoices",
@@ -201,26 +199,13 @@
    "fieldname": "payment_name",
    "fieldtype": "Data",
    "label": "Filter on Payment"
-  },
-  {
-   "collapsible": 1,
-   "collapsible_depends_on": "eval: doc.invoices.length == 0",
-   "depends_on": "eval:doc.receivable_payable_account",
-   "fieldname": "accounting_dimensions_section",
-   "fieldtype": "Section Break",
-   "label": "Accounting Dimensions Filter"
-  },
-  {
-   "fieldname": "dimension_col_break",
-   "fieldtype": "Column Break"
   }
  ],
  "hide_toolbar": 1,
  "icon": "icon-resize-horizontal",
- "is_virtual": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-12-14 13:38:16.264013",
+ "modified": "2023-08-15 05:35:50.109290",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation",
@@ -245,5 +230,6 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": []
+ "states": [],
+ "track_changes": 1
 }

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -10,7 +10,6 @@ from frappe.query_builder.custom import ConstantColumn
 from frappe.utils import flt, fmt_money, get_link_to_form, getdate, nowdate, today
 
 import erpnext
-from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import get_dimensions
 from erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation import (
 	is_any_doc_running,
 )
@@ -20,7 +19,7 @@ from erpnext.accounts.utils import (
 	get_outstanding_invoices,
 	reconcile_against_document,
 )
-from erpnext.controllers.accounts_controller import get_advance_payment_entries_for_regional
+from erpnext.controllers.accounts_controller import get_advance_payment_entries
 
 
 class PaymentReconciliation(Document):
@@ -29,59 +28,6 @@ class PaymentReconciliation(Document):
 		self.common_filter_conditions = []
 		self.accounting_dimension_filter_conditions = []
 		self.ple_posting_date_filter = []
-		self.dimensions = get_dimensions()[0]
-
-	def load_from_db(self):
-		# 'modified' attribute is required for `run_doc_method` to work properly.
-		doc_dict = frappe._dict(
-			{
-				"modified": None,
-				"company": None,
-				"party": None,
-				"party_type": None,
-				"receivable_payable_account": None,
-				"default_advance_account": None,
-				"from_invoice_date": None,
-				"to_invoice_date": None,
-				"invoice_limit": 50,
-				"from_payment_date": None,
-				"to_payment_date": None,
-				"payment_limit": 50,
-				"minimum_invoice_amount": None,
-				"minimum_payment_amount": None,
-				"maximum_invoice_amount": None,
-				"maximum_payment_amount": None,
-				"bank_cash_account": None,
-				"cost_center": None,
-				"payment_name": None,
-				"invoice_name": None,
-			}
-		)
-		super(Document, self).__init__(doc_dict)
-
-	def save(self):
-		return
-
-	@staticmethod
-	def get_list(args):
-		pass
-
-	@staticmethod
-	def get_count(args):
-		pass
-
-	@staticmethod
-	def get_stats(args):
-		pass
-
-	def db_insert(self, *args, **kwargs):
-		pass
-
-	def db_update(self, *args, **kwargs):
-		pass
-
-	def delete(self):
-		pass
 
 	@frappe.whitelist()
 	def get_unreconciled_entries(self):
@@ -112,9 +58,11 @@ class PaymentReconciliation(Document):
 
 	def get_payment_entries(self):
 		order_doctype = "Sales Order" if self.party_type == "Customer" else "Purchase Order"
-		condition = self.get_payment_entry_conditions()
+		condition = self.get_conditions(get_payments=True)
+		if self.payment_name:
+			condition += "name like '%%{0}%%'".format(self.payment_name)
 
-		payment_entries = get_advance_payment_entries_for_regional(
+		payment_entries = get_advance_payment_entries(
 			self.party_type,
 			self.party,
 			self.receivable_payable_account,
@@ -122,73 +70,67 @@ class PaymentReconciliation(Document):
 			against_all_orders=True,
 			limit=self.payment_limit,
 			condition=condition,
-			payment_name=self.payment_name,
 		)
 
 		return payment_entries
 
 	def get_jv_entries(self):
-		je = qb.DocType("Journal Entry")
-		jea = qb.DocType("Journal Entry Account")
-		conditions = self.get_journal_filter_conditions()
-
-		# Dimension filters
-		for x in self.dimensions:
-			dimension = x.fieldname
-			if self.get(dimension):
-				conditions.append(jea[dimension] == self.get(dimension))
+		condition = self.get_conditions()
 
 		if self.payment_name:
-			conditions.append(je.name.like(f"%%{self.payment_name}%%"))
+			condition += f" and t1.name like '%%{self.payment_name}%%'"
 
 		if self.get("cost_center"):
-			conditions.append(jea.cost_center == self.cost_center)
+			condition += f" and t2.cost_center = '{self.cost_center}' "
 
 		dr_or_cr = (
 			"credit_in_account_currency"
 			if erpnext.get_party_account_type(self.party_type) == "Receivable"
 			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}%%"))
-
-		journal_query = (
-			qb.from_(je)
-			.inner_join(jea)
-			.on(jea.parent == je.name)
-			.select(
-				ConstantColumn("Journal Entry").as_("reference_type"),
-				je.name.as_("reference_name"),
-				je.posting_date,
-				je.remark.as_("remarks"),
-				jea.name.as_("reference_row"),
-				jea[dr_or_cr].as_("amount"),
-				jea.is_advance,
-				jea.exchange_rate,
-				jea.account_currency.as_("currency"),
-				jea.cost_center.as_("cost_center"),
-			)
-			.where(
-				(je.docstatus == 1)
-				& (jea.party_type == self.party_type)
-				& (jea.party == self.party)
-				& (jea.account == self.receivable_payable_account)
-				& (
-					(jea.reference_type == "")
-					| (jea.reference_type.isnull())
-					| (jea.reference_type.isin(("Sales Order", "Purchase Order")))
-				)
-			)
-			.where(Criterion.all(conditions))
-			.orderby(je.posting_date)
+		bank_account_condition = (
+			"t2.against_account like %(bank_cash_account)s" if self.bank_cash_account else "1=1"
 		)
 
-		if self.payment_limit:
-			journal_query = journal_query.limit(self.payment_limit)
-
-		journal_entries = journal_query.run(as_dict=True)
+		# nosemgrep
+		journal_entries = frappe.db.sql(
+			"""
+			select
+				"Journal Entry" as reference_type, t1.name as reference_name,
+				t1.posting_date, t1.remark as remarks, t2.name as reference_row,
+				{dr_or_cr} as amount, t2.is_advance, t2.exchange_rate,
+				t2.account_currency as currency, t2.cost_center as cost_center
+			from
+				`tabJournal Entry` t1, `tabJournal Entry Account` t2
+			where
+				t1.name = t2.parent and t1.docstatus = 1 and t2.docstatus = 1
+				and t2.party_type = %(party_type)s and t2.party = %(party)s
+				and t2.account = %(account)s and {dr_or_cr} > 0 {condition}
+				and (t2.reference_type is null or t2.reference_type = '' or
+					(t2.reference_type in ('Sales Order', 'Purchase Order')
+						and t2.reference_name is not null and t2.reference_name != ''))
+				and (CASE
+					WHEN t1.voucher_type in ('Debit Note', 'Credit Note')
+					THEN 1=1
+					ELSE {bank_account_condition}
+				END)
+			order by t1.posting_date
+			""".format(
+				**{
+					"dr_or_cr": dr_or_cr,
+					"bank_account_condition": bank_account_condition,
+					"condition": condition,
+				}
+			),
+			{
+				"party_type": self.party_type,
+				"party": self.party,
+				"account": self.receivable_payable_account,
+				"bank_cash_account": "%%%s%%" % self.bank_cash_account,
+			},
+			as_dict=1,
+		)
 
 		return list(journal_entries)
 
@@ -204,7 +146,7 @@ class PaymentReconciliation(Document):
 		if self.payment_name:
 			conditions.append(doc.name.like(f"%{self.payment_name}%"))
 
-		self.return_invoices_query = (
+		self.return_invoices = (
 			qb.from_(doc)
 			.select(
 				ConstantColumn(voucher_type).as_("voucher_type"),
@@ -212,11 +154,8 @@ class PaymentReconciliation(Document):
 				doc.return_against,
 			)
 			.where(Criterion.all(conditions))
+			.run(as_dict=True)
 		)
-		if self.payment_limit:
-			self.return_invoices_query = self.return_invoices_query.limit(self.payment_limit)
-
-		self.return_invoices = self.return_invoices_query.run(as_dict=True)
 
 	def get_dr_or_cr_notes(self):
 
@@ -231,18 +170,20 @@ class PaymentReconciliation(Document):
 		self.common_filter_conditions.append(ple.account == self.receivable_payable_account)
 
 		self.get_return_invoices()
+		return_invoices = [
+			x for x in self.return_invoices if x.return_against == None or x.return_against == ""
+		]
 
 		outstanding_dr_or_cr = []
-		if self.return_invoices:
+		if return_invoices:
 			ple_query = QueryPaymentLedger()
 			return_outstanding = ple_query.get_voucher_outstandings(
-				vouchers=self.return_invoices,
+				vouchers=return_invoices,
 				common_filter=self.common_filter_conditions,
 				posting_date=self.ple_posting_date_filter,
 				min_outstanding=-(self.minimum_payment_amount) if self.minimum_payment_amount else None,
 				max_outstanding=-(self.maximum_payment_amount) if self.maximum_payment_amount else None,
 				get_payments=True,
-				accounting_dimensions=self.accounting_dimension_filter_conditions,
 			)
 
 			for inv in return_outstanding:
@@ -374,7 +315,6 @@ class PaymentReconciliation(Document):
 				res.difference_amount = self.get_difference_amount(pay, inv, res["allocated_amount"])
 				res.difference_account = default_exchange_gain_loss_account
 				res.exchange_rate = inv.get("exchange_rate")
-				res.update({"gain_loss_posting_date": pay.get("posting_date")})
 
 				if pay.get("amount") == 0:
 					entries.append(res)
@@ -392,15 +332,8 @@ class PaymentReconciliation(Document):
 				row = self.append("allocation", {})
 				row.update(entry)
 
-	def update_dimension_values_in_allocated_entries(self, res):
-		for x in self.dimensions:
-			dimension = x.fieldname
-			if self.get(dimension):
-				res[dimension] = self.get(dimension)
-		return res
-
 	def get_allocated_entry(self, pay, inv, allocated_amount):
-		res = frappe._dict(
+		return frappe._dict(
 			{
 				"reference_type": pay.get("reference_type"),
 				"reference_name": pay.get("reference_name"),
@@ -416,11 +349,7 @@ class PaymentReconciliation(Document):
 			}
 		)
 
-		res = self.update_dimension_values_in_allocated_entries(res)
-		return res
-
 	def reconcile_allocations(self, skip_ref_details_update_for_pe=False):
-		adjust_allocations_for_taxes(self)
 		dr_or_cr = (
 			"credit_in_account_currency"
 			if erpnext.get_party_account_type(self.party_type) == "Receivable"
@@ -441,10 +370,10 @@ class PaymentReconciliation(Document):
 				reconciled_entry.append(payment_details)
 
 		if entry_list:
-			reconcile_against_document(entry_list, skip_ref_details_update_for_pe, self.dimensions)
+			reconcile_against_document(entry_list, skip_ref_details_update_for_pe)
 
 		if dr_or_cr_notes:
-			reconcile_dr_cr_note(dr_or_cr_notes, self.company, self.dimensions)
+			reconcile_dr_cr_note(dr_or_cr_notes, self.company)
 
 	@frappe.whitelist()
 	def reconcile(self):
@@ -473,7 +402,7 @@ class PaymentReconciliation(Document):
 		self.get_unreconciled_entries()
 
 	def get_payment_details(self, row, dr_or_cr):
-		payment_details = frappe._dict(
+		return frappe._dict(
 			{
 				"voucher_type": row.get("reference_type"),
 				"voucher_no": row.get("reference_name"),
@@ -491,17 +420,10 @@ class PaymentReconciliation(Document):
 				"allocated_amount": flt(row.get("allocated_amount")),
 				"difference_amount": flt(row.get("difference_amount")),
 				"difference_account": row.get("difference_account"),
-				"difference_posting_date": row.get("gain_loss_posting_date"),
 				"cost_center": row.get("cost_center"),
 			}
 		)
 
-		for x in self.dimensions:
-			if row.get(x.fieldname):
-				payment_details[x.fieldname] = row.get(x.fieldname)
-
-		return payment_details
-
 	def check_mandatory_to_fetch(self):
 		for fieldname in ["company", "party_type", "party", "receivable_payable_account"]:
 			if not self.get(fieldname):
@@ -555,27 +477,6 @@ class PaymentReconciliation(Document):
 
 			invoice_exchange_map.update(purchase_invoice_map)
 
-		journals = [
-			d.get("invoice_number") for d in invoices if d.get("invoice_type") == "Journal Entry"
-		]
-		journals.extend(
-			[d.get("reference_name") for d in payments if d.get("reference_type") == "Journal Entry"]
-		)
-		if journals:
-			journals = list(set(journals))
-			journals_map = frappe._dict(
-				frappe.db.get_all(
-					"Journal Entry Account",
-					filters={"parent": ("in", journals), "account": ("in", [self.receivable_payable_account])},
-					fields=[
-						"parent as `name`",
-						"exchange_rate",
-					],
-					as_list=1,
-				)
-			)
-			invoice_exchange_map.update(journals_map)
-
 		return invoice_exchange_map
 
 	def validate_allocation(self):
@@ -609,13 +510,6 @@ class PaymentReconciliation(Document):
 		if not invoices_to_reconcile:
 			frappe.throw(_("No records found in Allocation table"))
 
-	def build_dimensions_filter_conditions(self):
-		ple = qb.DocType("Payment Ledger Entry")
-		for x in self.dimensions:
-			dimension = x.fieldname
-			if self.get(dimension):
-				self.accounting_dimension_filter_conditions.append(ple[dimension] == self.get(dimension))
-
 	def build_qb_filter_conditions(self, get_invoices=False, get_return_invoices=False):
 		self.common_filter_conditions.clear()
 		self.accounting_dimension_filter_conditions.clear()
@@ -639,58 +533,40 @@ class PaymentReconciliation(Document):
 			if self.to_payment_date:
 				self.ple_posting_date_filter.append(ple.posting_date.lte(self.to_payment_date))
 
-		self.build_dimensions_filter_conditions()
+	def get_conditions(self, get_payments=False):
+		condition = " and company = '{0}' ".format(self.company)
 
-	def get_payment_entry_conditions(self):
-		conditions = []
-		pe = qb.DocType("Payment Entry")
-		conditions.append(pe.company == self.company)
+		if self.get("cost_center") and get_payments:
+			condition = " and cost_center = '{0}' ".format(self.cost_center)
 
-		if self.get("cost_center"):
-			conditions.append(pe.cost_center == self.cost_center)
-
-		if self.from_payment_date:
-			conditions.append(pe.posting_date.gte(self.from_payment_date))
-
-		if self.to_payment_date:
-			conditions.append(pe.posting_date.lte(self.to_payment_date))
+		condition += (
+			" and posting_date >= {0}".format(frappe.db.escape(self.from_payment_date))
+			if self.from_payment_date
+			else ""
+		)
+		condition += (
+			" and posting_date <= {0}".format(frappe.db.escape(self.to_payment_date))
+			if self.to_payment_date
+			else ""
+		)
 
 		if self.minimum_payment_amount:
-			conditions.append(pe.unallocated_amount.gte(flt(self.minimum_payment_amount)))
-
+			condition += (
+				" and unallocated_amount >= {0}".format(flt(self.minimum_payment_amount))
+				if get_payments
+				else " and total_debit >= {0}".format(flt(self.minimum_payment_amount))
+			)
 		if self.maximum_payment_amount:
-			conditions.append(pe.unallocated_amount.lte(flt(self.maximum_payment_amount)))
+			condition += (
+				" and unallocated_amount <= {0}".format(flt(self.maximum_payment_amount))
+				if get_payments
+				else " and total_debit <= {0}".format(flt(self.maximum_payment_amount))
+			)
 
-		# pass dynamic dimension filter values to payment query
-		for x in self.dimensions:
-			dimension = x.fieldname
-			if self.get(dimension):
-				conditions.append(pe[dimension] == self.get(dimension))
-
-		return conditions
-
-	def get_journal_filter_conditions(self):
-		conditions = []
-		je = qb.DocType("Journal Entry")
-		jea = qb.DocType("Journal Entry Account")
-		conditions.append(je.company == self.company)
-
-		if self.from_payment_date:
-			conditions.append(je.posting_date.gte(self.from_payment_date))
-
-		if self.to_payment_date:
-			conditions.append(je.posting_date.lte(self.to_payment_date))
-
-		if self.minimum_payment_amount:
-			conditions.append(je.total_debit.gte(self.minimum_payment_amount))
-
-		if self.maximum_payment_amount:
-			conditions.append(je.total_debit.lte(self.maximum_payment_amount))
-
-		return conditions
+		return condition
 
 
-def reconcile_dr_cr_note(dr_cr_notes, company, active_dimensions=None):
+def reconcile_dr_cr_note(dr_cr_notes, company):
 	for inv in dr_cr_notes:
 		voucher_type = "Credit Note" if inv.voucher_type == "Sales Invoice" else "Debit Note"
 
@@ -740,15 +616,6 @@ def reconcile_dr_cr_note(dr_cr_notes, company, active_dimensions=None):
 			}
 		)
 
-		# Credit Note(JE) will inherit the same dimension values as payment
-		dimensions_dict = frappe._dict()
-		if active_dimensions:
-			for dim in active_dimensions:
-				dimensions_dict[dim.fieldname] = inv.get(dim.fieldname)
-
-		jv.accounts[0].update(dimensions_dict)
-		jv.accounts[1].update(dimensions_dict)
-
 		jv.flags.ignore_mandatory = True
 		jv.flags.skip_remarks_creation = True
 		jv.flags.ignore_exchange_rate = True
@@ -782,27 +649,4 @@ def reconcile_dr_cr_note(dr_cr_notes, company, active_dimensions=None):
 				inv.against_voucher,
 				None,
 				inv.cost_center,
-				dimensions_dict,
 			)
-
-
-@erpnext.allow_regional
-def adjust_allocations_for_taxes(doc):
-	pass
-
-
-@frappe.whitelist()
-def get_queries_for_dimension_filters(company: str = None):
-	dimensions_with_filters = []
-	for d in get_dimensions()[0]:
-		filters = {}
-		meta = frappe.get_meta(d.document_type)
-		if meta.has_field("company") and company:
-			filters.update({"company": company})
-
-		if meta.is_tree:
-			filters.update({"is_group": 0})
-
-		dimensions_with_filters.append({"fieldname": d.fieldname, "filters": filters})
-
-	return dimensions_with_filters

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -14,7 +14,6 @@ from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_pay
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.party import get_party_account
-from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
 from erpnext.stock.doctype.item.test_item import create_item
 
 test_dependencies = ["Item"]
@@ -86,44 +85,26 @@ class TestPaymentReconciliation(FrappeTestCase):
 		self.customer5 = make_customer("_Test PR Customer 5", "EUR")
 
 	def create_account(self):
-		accounts = [
-			{
-				"attribute": "debtors_eur",
-				"account_name": "Debtors EUR",
-				"parent_account": "Accounts Receivable - _PR",
-				"account_currency": "EUR",
-				"account_type": "Receivable",
-			},
-			{
-				"attribute": "creditors_usd",
-				"account_name": "Payable USD",
-				"parent_account": "Accounts Payable - _PR",
-				"account_currency": "USD",
-				"account_type": "Payable",
-			},
-		]
-
-		for x in accounts:
-			x = frappe._dict(x)
-			if not frappe.db.get_value(
-				"Account", filters={"account_name": x.account_name, "company": self.company}
-			):
-				acc = frappe.new_doc("Account")
-				acc.account_name = x.account_name
-				acc.parent_account = x.parent_account
-				acc.company = self.company
-				acc.account_currency = x.account_currency
-				acc.account_type = x.account_type
-				acc.insert()
-			else:
-				name = frappe.db.get_value(
-					"Account",
-					filters={"account_name": x.account_name, "company": self.company},
-					fieldname="name",
-					pluck=True,
-				)
-				acc = frappe.get_doc("Account", name)
-			setattr(self, x.attribute, acc.name)
+		account_name = "Debtors EUR"
+		if not frappe.db.get_value(
+			"Account", filters={"account_name": account_name, "company": self.company}
+		):
+			acc = frappe.new_doc("Account")
+			acc.account_name = account_name
+			acc.parent_account = "Accounts Receivable - _PR"
+			acc.company = self.company
+			acc.account_currency = "EUR"
+			acc.account_type = "Receivable"
+			acc.insert()
+		else:
+			name = frappe.db.get_value(
+				"Account",
+				filters={"account_name": account_name, "company": self.company},
+				fieldname="name",
+				pluck=True,
+			)
+			acc = frappe.get_doc("Account", name)
+		self.debtors_eur = acc.name
 
 	def create_sales_invoice(
 		self, qty=1, rate=100, posting_date=nowdate(), do_not_save=False, do_not_submit=False
@@ -170,64 +151,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		payment.posting_date = posting_date
 		return payment
 
-	def create_purchase_invoice(
-		self, qty=1, rate=100, posting_date=nowdate(), do_not_save=False, do_not_submit=False
-	):
-		"""
-		Helper function to populate default values in sales invoice
-		"""
-		pinv = make_purchase_invoice(
-			qty=qty,
-			rate=rate,
-			company=self.company,
-			customer=self.supplier,
-			item_code=self.item,
-			item_name=self.item,
-			cost_center=self.cost_center,
-			warehouse=self.warehouse,
-			debit_to=self.debit_to,
-			parent_cost_center=self.cost_center,
-			update_stock=0,
-			currency="INR",
-			is_pos=0,
-			is_return=0,
-			return_against=None,
-			income_account=self.income_account,
-			expense_account=self.expense_account,
-			do_not_save=do_not_save,
-			do_not_submit=do_not_submit,
-		)
-		return pinv
-
-	def create_purchase_order(
-		self, qty=1, rate=100, posting_date=nowdate(), do_not_save=False, do_not_submit=False
-	):
-		"""
-		Helper function to populate default values in sales invoice
-		"""
-		pord = create_purchase_order(
-			qty=qty,
-			rate=rate,
-			company=self.company,
-			customer=self.supplier,
-			item_code=self.item,
-			item_name=self.item,
-			cost_center=self.cost_center,
-			warehouse=self.warehouse,
-			debit_to=self.debit_to,
-			parent_cost_center=self.cost_center,
-			update_stock=0,
-			currency="INR",
-			is_pos=0,
-			is_return=0,
-			return_against=None,
-			income_account=self.income_account,
-			expense_account=self.expense_account,
-			do_not_save=do_not_save,
-			do_not_submit=do_not_submit,
-		)
-		return pord
-
 	def clear_old_entries(self):
 		doctype_list = [
 			"GL Entry",
@@ -240,11 +163,13 @@ class TestPaymentReconciliation(FrappeTestCase):
 		for doctype in doctype_list:
 			qb.from_(qb.DocType(doctype)).delete().where(qb.DocType(doctype).company == self.company).run()
 
-	def create_payment_reconciliation(self, party_is_customer=True):
+	def create_payment_reconciliation(self):
 		pr = frappe.new_doc("Payment Reconciliation")
 		pr.company = self.company
-		pr.party_type = "Customer" if party_is_customer else "Supplier"
-		pr.party = self.customer if party_is_customer else self.supplier
+		pr.party_type = (
+			self.party_type if hasattr(self, "party_type") and self.party_type else "Customer"
+		)
+		pr.party = self.customer
 		pr.receivable_payable_account = get_party_account(pr.party_type, pr.party, pr.company)
 		pr.from_invoice_date = pr.to_invoice_date = pr.from_payment_date = pr.to_payment_date = nowdate()
 		return pr
@@ -591,70 +516,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		self.assertEqual(si.status, "Paid")
 		self.assertEqual(si.outstanding_amount, 0)
 
-	def test_invoice_status_after_cr_note_cancellation(self):
-		# This test case is made after the 'always standalone Credit/Debit notes' feature is introduced
-		transaction_date = nowdate()
-		amount = 100
-
-		si = self.create_sales_invoice(qty=1, rate=amount, posting_date=transaction_date)
-
-		cr_note = self.create_sales_invoice(
-			qty=-1, rate=amount, posting_date=transaction_date, do_not_save=True, do_not_submit=True
-		)
-		cr_note.is_return = 1
-		cr_note.return_against = si.name
-		cr_note = cr_note.save().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}))
-		pr.reconcile()
-
-		pr.get_unreconciled_entries()
-		self.assertEqual(pr.get("invoices"), [])
-		self.assertEqual(pr.get("payments"), [])
-
-		journals = frappe.db.get_all(
-			"Journal Entry",
-			filters={
-				"is_system_generated": 1,
-				"docstatus": 1,
-				"voucher_type": "Credit Note",
-				"reference_type": si.doctype,
-				"reference_name": si.name,
-			},
-			pluck="name",
-		)
-		self.assertEqual(len(journals), 1)
-
-		# assert status and outstanding
-		si.reload()
-		self.assertEqual(si.status, "Credit Note Issued")
-		self.assertEqual(si.outstanding_amount, 0)
-
-		cr_note.reload()
-		cr_note.cancel()
-		# 'Credit Note' Journal should be auto cancelled
-		journals = frappe.db.get_all(
-			"Journal Entry",
-			filters={
-				"is_system_generated": 1,
-				"docstatus": 1,
-				"voucher_type": "Credit Note",
-				"reference_type": si.doctype,
-				"reference_name": si.name,
-			},
-			pluck="name",
-		)
-		self.assertEqual(len(journals), 0)
-		# assert status and outstanding
-		si.reload()
-		self.assertEqual(si.status, "Unpaid")
-		self.assertEqual(si.outstanding_amount, 100)
-
 	def test_cr_note_partial_against_invoice(self):
 		transaction_date = nowdate()
 		amount = 100
@@ -1045,13 +906,9 @@ class TestPaymentReconciliation(FrappeTestCase):
 		self.assertEqual(pr.allocation[0].difference_amount, 0)
 
 	def test_reconciliation_purchase_invoice_against_return(self):
-		self.supplier = "_Test Supplier USD"
-		pi = self.create_purchase_invoice(qty=5, rate=50, do_not_submit=True)
-		pi.supplier = self.supplier
-		pi.currency = "USD"
-		pi.conversion_rate = 50
-		pi.credit_to = self.creditors_usd
-		pi.save().submit()
+		pi = make_purchase_invoice(
+			supplier="_Test Supplier USD", currency="USD", conversion_rate=50
+		).submit()
 
 		pi_return = frappe.get_doc(pi.as_dict())
 		pi_return.name = None
@@ -1061,12 +918,11 @@ class TestPaymentReconciliation(FrappeTestCase):
 		pi_return.items[0].qty = -pi_return.items[0].qty
 		pi_return.submit()
 
-		pr = frappe.get_doc("Payment Reconciliation")
-		pr.company = self.company
-		pr.party_type = "Supplier"
-		pr.party = self.supplier
-		pr.receivable_payable_account = self.creditors_usd
-		pr.from_invoice_date = pr.to_invoice_date = pr.from_payment_date = pr.to_payment_date = nowdate()
+		self.company = "_Test Company"
+		self.party_type = "Supplier"
+		self.customer = "_Test Supplier USD"
+
+		pr = self.create_payment_reconciliation()
 		pr.get_unreconciled_entries()
 
 		invoices = []
@@ -1075,7 +931,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 			if invoice.invoice_number == pi.name:
 				invoices.append(invoice.as_dict())
 				break
-
 		for payment in pr.payments:
 			if payment.reference_name == pi_return.name:
 				payments.append(payment.as_dict())
@@ -1086,155 +941,6 @@ class TestPaymentReconciliation(FrappeTestCase):
 		# Should not raise frappe.exceptions.ValidationError: Total Debit must be equal to Total Credit.
 		pr.reconcile()
 
-	def test_reconciliation_from_purchase_order_to_multiple_invoices(self):
-		"""
-		Reconciling advance payment from PO/SO to multiple invoices should not cause overallocation
-		"""
-
-		self.supplier = "_Test Supplier"
-
-		pi1 = self.create_purchase_invoice(qty=10, rate=100)
-		pi2 = self.create_purchase_invoice(qty=10, rate=100)
-		po = self.create_purchase_order(qty=20, rate=100)
-		pay = get_payment_entry(po.doctype, po.name)
-		# Overpay Puchase Order
-		pay.paid_amount = 3000
-		pay.save().submit()
-		# assert total allocated and unallocated before reconciliation
-		self.assertEqual(
-			(
-				pay.references[0].reference_doctype,
-				pay.references[0].reference_name,
-				pay.references[0].allocated_amount,
-			),
-			(po.doctype, po.name, 2000),
-		)
-		self.assertEqual(pay.total_allocated_amount, 2000)
-		self.assertEqual(pay.unallocated_amount, 1000)
-		self.assertEqual(pay.difference_amount, 0)
-
-		pr = self.create_payment_reconciliation(party_is_customer=False)
-		pr.get_unreconciled_entries()
-
-		self.assertEqual(len(pr.invoices), 2)
-		self.assertEqual(len(pr.payments), 2)
-
-		for x in pr.payments:
-			self.assertEqual((x.reference_type, x.reference_name), (pay.doctype, pay.name))
-
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [x.as_dict() for x in pr.payments]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-		# partial allocation on pi1 and full allocate on pi2
-		pr.allocation[0].allocated_amount = 100
-		pr.reconcile()
-
-		# assert references and total allocated and unallocated amount
-		pay.reload()
-		self.assertEqual(len(pay.references), 3)
-		self.assertEqual(
-			(
-				pay.references[0].reference_doctype,
-				pay.references[0].reference_name,
-				pay.references[0].allocated_amount,
-			),
-			(po.doctype, po.name, 900),
-		)
-		self.assertEqual(
-			(
-				pay.references[1].reference_doctype,
-				pay.references[1].reference_name,
-				pay.references[1].allocated_amount,
-			),
-			(pi1.doctype, pi1.name, 100),
-		)
-		self.assertEqual(
-			(
-				pay.references[2].reference_doctype,
-				pay.references[2].reference_name,
-				pay.references[2].allocated_amount,
-			),
-			(pi2.doctype, pi2.name, 1000),
-		)
-		self.assertEqual(pay.total_allocated_amount, 2000)
-		self.assertEqual(pay.unallocated_amount, 1000)
-		self.assertEqual(pay.difference_amount, 0)
-
-		pr.get_unreconciled_entries()
-		self.assertEqual(len(pr.invoices), 1)
-		self.assertEqual(len(pr.payments), 2)
-
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [x.as_dict() for x in pr.payments]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-		pr.reconcile()
-
-		# assert references and total allocated and unallocated amount
-		pay.reload()
-		self.assertEqual(len(pay.references), 3)
-		# PO references should be removed now
-		self.assertEqual(
-			(
-				pay.references[0].reference_doctype,
-				pay.references[0].reference_name,
-				pay.references[0].allocated_amount,
-			),
-			(pi1.doctype, pi1.name, 100),
-		)
-		self.assertEqual(
-			(
-				pay.references[1].reference_doctype,
-				pay.references[1].reference_name,
-				pay.references[1].allocated_amount,
-			),
-			(pi2.doctype, pi2.name, 1000),
-		)
-		self.assertEqual(
-			(
-				pay.references[2].reference_doctype,
-				pay.references[2].reference_name,
-				pay.references[2].allocated_amount,
-			),
-			(pi1.doctype, pi1.name, 900),
-		)
-		self.assertEqual(pay.total_allocated_amount, 2000)
-		self.assertEqual(pay.unallocated_amount, 1000)
-		self.assertEqual(pay.difference_amount, 0)
-
-	def test_rounding_of_unallocated_amount(self):
-		self.supplier = "_Test Supplier USD"
-		pi = self.create_purchase_invoice(qty=1, rate=10, do_not_submit=True)
-		pi.supplier = self.supplier
-		pi.currency = "USD"
-		pi.conversion_rate = 80
-		pi.credit_to = self.creditors_usd
-		pi.save().submit()
-
-		pe = get_payment_entry(pi.doctype, pi.name)
-		pe.target_exchange_rate = 78.726500000
-		pe.received_amount = 26.75
-		pe.paid_amount = 2105.93
-		pe.references = []
-		pe.save().submit()
-
-		# unallocated_amount will have some rounding loss - 26.749950
-		self.assertNotEqual(pe.unallocated_amount, 26.75)
-
-		pr = frappe.get_doc("Payment Reconciliation")
-		pr.company = self.company
-		pr.party_type = "Supplier"
-		pr.party = self.supplier
-		pr.receivable_payable_account = self.creditors_usd
-		pr.from_invoice_date = pr.to_invoice_date = pr.from_payment_date = pr.to_payment_date = nowdate()
-		pr.get_unreconciled_entries()
-
-		invoices = [invoice.as_dict() for invoice in pr.invoices]
-		payments = [payment.as_dict() for payment in pr.payments]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Should not raise frappe.exceptions.ValidationError: Payment Entry has been modified after you pulled it. Please pull it again.
-		pr.reconcile()
-
 
 def make_customer(customer_name, currency=None):
 	if not frappe.db.exists("Customer", customer_name):

erpnext/accounts/doctype/payment_reconciliation_allocation/payment_reconciliation_allocation.json

@@ -19,14 +19,11 @@
   "is_advance",
   "section_break_5",
   "difference_amount",
-  "gain_loss_posting_date",
   "column_break_7",
   "difference_account",
   "exchange_rate",
   "currency",
-  "accounting_dimensions_section",
-  "cost_center",
-  "dimension_col_break"
+  "cost_center"
  ],
  "fields": [
   {
@@ -154,26 +151,11 @@
    "fieldtype": "Link",
    "label": "Cost Center",
    "options": "Cost Center"
-  },
-  {
-   "fieldname": "gain_loss_posting_date",
-   "fieldtype": "Date",
-   "label": "Difference Posting Date"
-  },
-  {
-   "fieldname": "accounting_dimensions_section",
-   "fieldtype": "Section Break",
-   "label": "Accounting Dimensions"
-  },
-  {
-   "fieldname": "dimension_col_break",
-   "fieldtype": "Column Break"
   }
  ],
- "is_virtual": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-12-14 13:38:26.104150",
+ "modified": "2023-09-03 07:52:33.684217",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Allocation",

erpnext/accounts/doctype/payment_reconciliation_allocation/payment_reconciliation_allocation.py

@@ -6,6 +6,4 @@ from frappe.model.document import Document
 
 
 class PaymentReconciliationAllocation(Document):
-	@staticmethod
-	def get_list(args):
-		pass
+	pass

erpnext/accounts/doctype/payment_reconciliation_invoice/payment_reconciliation_invoice.json

@@ -71,10 +71,9 @@
    "label": "Exchange Rate"
   }
  ],
- "is_virtual": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-11-17 17:33:45.455166",
+ "modified": "2022-11-08 18:18:02.502149",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Invoice",

erpnext/accounts/doctype/payment_reconciliation_invoice/payment_reconciliation_invoice.py

@@ -6,6 +6,4 @@ from frappe.model.document import Document
 
 
 class PaymentReconciliationInvoice(Document):
-	@staticmethod
-	def get_list(args):
-		pass
+	pass

erpnext/accounts/doctype/payment_reconciliation_payment/payment_reconciliation_payment.json

@@ -107,10 +107,9 @@
    "options": "Cost Center"
   }
  ],
- "is_virtual": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-11-17 17:33:34.818530",
+ "modified": "2023-09-03 07:43:29.965353",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Payment",

erpnext/accounts/doctype/payment_reconciliation_payment/payment_reconciliation_payment.py

@@ -6,6 +6,4 @@ from frappe.model.document import Document
 
 
 class PaymentReconciliationPayment(Document):
-	@staticmethod
-	def get_list(args):
-		pass
+	pass

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -249,7 +249,7 @@ class PaymentRequest(Document):
 		if (
 			party_account_currency == ref_doc.company_currency and party_account_currency != self.currency
 		):
-			party_amount = ref_doc.get("base_rounded_total") or ref_doc.get("base_grand_total")
+			party_amount = ref_doc.base_grand_total
 		else:
 			party_amount = self.grand_total
 

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.json

@@ -8,7 +8,6 @@
   "transaction_date",
   "posting_date",
   "fiscal_year",
-  "year_start_date",
   "amended_from",
   "company",
   "column_break1",
@@ -101,22 +100,16 @@
    "fieldtype": "Text",
    "label": "Error Message",
    "read_only": 1
-  },
-  {
-   "fieldname": "year_start_date",
-   "fieldtype": "Date",
-   "label": "Year Start Date"
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-09-11 20:19:11.810533",
+ "modified": "2022-07-20 14:51:04.714154",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Period Closing Voucher",
- "naming_rule": "Expression (old style)",
  "owner": "Administrator",
  "permissions": [
   {
@@ -151,6 +144,5 @@
  "search_fields": "posting_date, fiscal_year",
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "title_field": "closing_account_head"
 }

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -33,7 +33,7 @@ class PeriodClosingVoucher(AccountsController):
 	def on_cancel(self):
 		self.validate_future_closing_vouchers()
 		self.db_set("gle_processing_status", "In Progress")
-		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry", "Payment Ledger Entry")
+		self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry")
 		gle_count = frappe.db.count(
 			"GL Entry",
 			{"voucher_type": "Period Closing Voucher", "voucher_no": self.name, "is_cancelled": 0},
@@ -95,23 +95,15 @@ class PeriodClosingVoucher(AccountsController):
 
 		self.check_if_previous_year_closed()
 
-		pcv = frappe.qb.DocType("Period Closing Voucher")
-		existing_entry = (
-			frappe.qb.from_(pcv)
-			.select(pcv.name)
-			.where(
-				(pcv.posting_date >= self.posting_date)
-				& (pcv.fiscal_year == self.fiscal_year)
-				& (pcv.docstatus == 1)
-				& (pcv.company == self.company)
-			)
-			.run()
+		pce = frappe.db.sql(
+			"""select name from `tabPeriod Closing Voucher`
+			where posting_date > %s and fiscal_year = %s and docstatus = 1 and company = %s""",
+			(self.posting_date, self.fiscal_year, self.company),
 		)
-
-		if existing_entry and existing_entry[0][0]:
+		if pce and pce[0][0]:
 			frappe.throw(
 				_("Another Period Closing Entry {0} has been made after {1}").format(
-					existing_entry[0][0], self.posting_date
+					pce[0][0], self.posting_date
 				)
 			)
 
@@ -138,27 +130,18 @@ class PeriodClosingVoucher(AccountsController):
 			frappe.enqueue(
 				process_gl_entries,
 				gl_entries=gl_entries,
-				voucher_name=self.name,
-				timeout=3000,
-			)
-
-			frappe.enqueue(
-				process_closing_entries,
-				gl_entries=gl_entries,
 				closing_entries=closing_entries,
 				voucher_name=self.name,
 				company=self.company,
 				closing_date=self.posting_date,
-				timeout=3000,
+				queue="long",
 			)
-
 			frappe.msgprint(
 				_("The GL Entries will be processed in the background, it can take a few minutes."),
 				alert=True,
 			)
 		else:
-			process_gl_entries(gl_entries, self.name)
-			process_closing_entries(gl_entries, closing_entries, self.name, self.company, self.posting_date)
+			process_gl_entries(gl_entries, closing_entries, self.name, self.company, self.posting_date)
 
 	def get_grouped_gl_entries(self, get_opening_entries=False):
 		closing_entries = []
@@ -339,12 +322,17 @@ class PeriodClosingVoucher(AccountsController):
 		return query.run(as_dict=1)
 
 
-def process_gl_entries(gl_entries, voucher_name):
+def process_gl_entries(gl_entries, closing_entries, voucher_name, company, closing_date):
+	from erpnext.accounts.doctype.account_closing_balance.account_closing_balance import (
+		make_closing_entries,
+	)
 	from erpnext.accounts.general_ledger import make_gl_entries
 
 	try:
 		if gl_entries:
 			make_gl_entries(gl_entries, merge_entries=False)
+
+		make_closing_entries(gl_entries + closing_entries, voucher_name, company, closing_date)
 		frappe.db.set_value("Period Closing Voucher", voucher_name, "gle_processing_status", "Completed")
 	except Exception as e:
 		frappe.db.rollback()
@@ -352,19 +340,6 @@ def process_gl_entries(gl_entries, voucher_name):
 		frappe.db.set_value("Period Closing Voucher", voucher_name, "gle_processing_status", "Failed")
 
 
-def process_closing_entries(gl_entries, closing_entries, voucher_name, company, closing_date):
-	from erpnext.accounts.doctype.account_closing_balance.account_closing_balance import (
-		make_closing_entries,
-	)
-
-	try:
-		if gl_entries + closing_entries:
-			make_closing_entries(gl_entries + closing_entries, voucher_name, company, closing_date)
-	except Exception as e:
-		frappe.db.rollback()
-		frappe.log_error(e)
-
-
 def make_reverse_gl_entries(voucher_type, voucher_no):
 	from erpnext.accounts.general_ledger import make_reverse_gl_entries
 

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -10,7 +10,7 @@ from frappe.utils import add_months, today
 from erpnext.accounts.doctype.finance_book.test_finance_book import create_finance_book
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-from erpnext.accounts.utils import get_fiscal_year
+from erpnext.accounts.utils import get_fiscal_year, now
 
 
 class TestPeriodClosingVoucher(unittest.TestCase):

erpnext/accounts/doctype/pos_invoice/pos_invoice.json

@@ -18,7 +18,6 @@
   "is_pos",
   "is_return",
   "update_billed_amount_in_sales_order",
-  "update_billed_amount_in_delivery_note",
   "column_break1",
   "company",
   "posting_date",
@@ -1550,19 +1549,12 @@
    "fieldtype": "Currency",
    "label": "Amount Eligible for Commission",
    "read_only": 1
-  },
-  {
-   "default": "1",
-   "depends_on": "eval: doc.is_return && doc.return_against",
-   "fieldname": "update_billed_amount_in_delivery_note",
-   "fieldtype": "Check",
-   "label": "Update Billed Amount in Delivery Note"
   }
  ],
  "icon": "fa fa-file-text",
  "is_submittable": 1,
  "links": [],
- "modified": "2023-11-20 12:27:12.848149",
+ "modified": "2022-09-30 03:49:50.455199",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice",

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -1,7 +1,5 @@
 # Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors and contributors
 # For license information, please see license.txt
-
-
 import collections
 
 import frappe
@@ -13,6 +11,7 @@ from erpnext.accounts.doctype.loyalty_program.loyalty_program import validate_lo
 from erpnext.accounts.doctype.payment_request.payment_request import make_payment_request
 from erpnext.accounts.doctype.sales_invoice.sales_invoice import (
 	SalesInvoice,
+	get_bank_cash_account,
 	get_mode_of_payment_info,
 	update_multi_mode_option,
 )
@@ -44,6 +43,7 @@ class POSInvoice(SalesInvoice):
 		self.validate_debit_to_acc()
 		self.validate_write_off_account()
 		self.validate_change_amount()
+		self.validate_duplicate_serial_and_batch_no()
 		self.validate_change_account()
 		self.validate_item_cost_centers()
 		self.validate_warehouse()
@@ -51,11 +51,11 @@ class POSInvoice(SalesInvoice):
 		self.validate_stock_availablility()
 		self.validate_return_items_qty()
 		self.set_status()
+		self.set_account_for_mode_of_payment()
 		self.validate_pos()
 		self.validate_payment_amount()
 		self.validate_loyalty_transaction()
 		self.validate_company_with_pos_company()
-		self.validate_duplicate_serial_no()
 		if self.coupon_code:
 			from erpnext.accounts.doctype.pricing_rule.utils import validate_coupon_code
 
@@ -156,18 +156,27 @@ class POSInvoice(SalesInvoice):
 				title=_("Item Unavailable"),
 			)
 
-	def validate_duplicate_serial_no(self):
+	def validate_duplicate_serial_and_batch_no(self):
 		serial_nos = []
+		batch_nos = []
 
 		for row in self.get("items"):
 			if row.serial_no:
 				serial_nos = row.serial_no.split("\n")
 
+			if row.batch_no and not row.serial_no:
+				batch_nos.append(row.batch_no)
+
 		if serial_nos:
 			for key, value in collections.Counter(serial_nos).items():
 				if value > 1:
 					frappe.throw(_("Duplicate Serial No {0} found").format("key"))
 
+		if batch_nos:
+			for key, value in collections.Counter(batch_nos).items():
+				if value > 1:
+					frappe.throw(_("Duplicate Batch No {0} found").format("key"))
+
 	def validate_pos_reserved_batch_qty(self, item):
 		filters = {"item_code": item.item_code, "warehouse": item.warehouse, "batch_no": item.batch_no}
 
@@ -516,7 +525,7 @@ class POSInvoice(SalesInvoice):
 				selling_price_list = (
 					customer_price_list or customer_group_price_list or profile.get("selling_price_list")
 				)
-				if customer_currency and customer_currency != profile.get("currency"):
+				if customer_currency != profile.get("currency"):
 					self.set("currency", customer_currency)
 
 			else:
@@ -582,6 +591,11 @@ class POSInvoice(SalesInvoice):
 			update_multi_mode_option(self, pos_profile)
 			self.paid_amount = 0
 
+	def set_account_for_mode_of_payment(self):
+		for pay in self.payments:
+			if not pay.account:
+				pay.account = get_bank_cash_account(pay.mode_of_payment, self.company).get("account")
+
 	@frappe.whitelist()
 	def create_payment_request(self):
 		for pay in self.payments:
@@ -652,7 +666,7 @@ def get_stock_availability(item_code, warehouse):
 		return bin_qty - pos_sales_qty, is_stock_item
 	else:
 		is_stock_item = True
-		if frappe.db.exists("Product Bundle", {"name": item_code, "disabled": 0}):
+		if frappe.db.exists("Product Bundle", item_code):
 			return get_bundle_availability(item_code, warehouse), is_stock_item
 		else:
 			is_stock_item = False
@@ -698,7 +712,7 @@ def get_pos_reserved_qty(item_code, warehouse):
 	reserved_qty = (
 		frappe.qb.from_(p_inv)
 		.from_(p_item)
-		.select(Sum(p_item.stock_qty).as_("stock_qty"))
+		.select(Sum(p_item.qty).as_("qty"))
 		.where(
 			(p_inv.name == p_item.parent)
 			& (IfNull(p_inv.consolidated_invoice, "") == "")
@@ -709,7 +723,7 @@ def get_pos_reserved_qty(item_code, warehouse):
 		)
 	).run(as_dict=True)
 
-	return flt(reserved_qty[0].stock_qty) if reserved_qty else 0
+	return reserved_qty[0].qty or 0 if reserved_qty else 0
 
 
 @frappe.whitelist()

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -464,37 +464,6 @@ class TestPOSInvoice(unittest.TestCase):
 		pos2.insert()
 		self.assertRaises(frappe.ValidationError, pos2.submit)
 
-	def test_pos_invoice_with_duplicate_serial_no(self):
-		from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
-		from erpnext.stock.doctype.stock_entry.test_stock_entry import make_serialized_item
-
-		se = make_serialized_item(
-			company="_Test Company",
-			target_warehouse="Stores - _TC",
-			cost_center="Main - _TC",
-			expense_account="Cost of Goods Sold - _TC",
-		)
-
-		serial_nos = get_serial_nos(se.get("items")[0].serial_no)
-
-		pos = create_pos_invoice(
-			company="_Test Company",
-			debit_to="Debtors - _TC",
-			account_for_change_amount="Cash - _TC",
-			warehouse="Stores - _TC",
-			income_account="Sales - _TC",
-			expense_account="Cost of Goods Sold - _TC",
-			cost_center="Main - _TC",
-			item=se.get("items")[0].item_code,
-			rate=1000,
-			qty=2,
-			do_not_save=1,
-		)
-
-		pos.get("items")[0].has_serial_no = 1
-		pos.get("items")[0].serial_no = serial_nos[0] + "\n" + serial_nos[0]
-		self.assertRaises(frappe.ValidationError, pos.submit)
-
 	def test_invalid_serial_no_validation(self):
 		from erpnext.stock.doctype.stock_entry.test_stock_entry import make_serialized_item
 

erpnext/accounts/doctype/pos_invoice_item/pos_invoice_item.json

@@ -185,7 +185,6 @@
    "label": "Image"
   },
   {
-   "fetch_from": "item_code.image",
    "fieldname": "image",
    "fieldtype": "Attach",
    "hidden": 1,
@@ -822,7 +821,7 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2023-11-14 18:33:22.585715",
+ "modified": "2022-11-02 12:52:39.125295",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice Item",
@@ -832,4 +831,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -521,7 +521,7 @@ def get_qty_amount_data_for_cumulative(pr_doc, doc, items=None):
 		values.extend(warehouses)
 
 	if items:
-		condition += " and `tab{child_doc}`.{apply_on} in ({items})".format(
+		condition = " and `tab{child_doc}`.{apply_on} in ({items})".format(
 			child_doc=child_doctype, apply_on=apply_on, items=",".join(["%s"] * len(items))
 		)
 

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.py

@@ -415,7 +415,7 @@ def reconcile(doc: None | str = None) -> None:
 					# Update the parent doc about the exception
 					frappe.db.rollback()
 
-					traceback = frappe.get_traceback(with_context=True)
+					traceback = frappe.get_traceback()
 					if traceback:
 						message = "Traceback: <br>" + traceback
 						frappe.db.set_value("Process Payment Reconciliation Log", log, "error_log", message)

erpnext/accounts/doctype/process_payment_reconciliation_log/process_payment_reconciliation_log.json

@@ -110,7 +110,7 @@
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2023-11-02 11:32:12.254018",
+ "modified": "2023-04-21 17:36:26.642617",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Payment Reconciliation Log",
@@ -125,19 +125,7 @@
    "print": 1,
    "read": 1,
    "report": 1,
-   "role": "Accounts Manager",
-   "share": 1,
-   "write": 1
-  },
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "Accounts User",
+   "role": "System Manager",
    "share": 1,
    "write": 1
   }

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -15,7 +15,6 @@
   "group_by",
   "cost_center",
   "territory",
-  "ignore_exchange_rate_revaluation_journals",
   "column_break_14",
   "to_date",
   "finance_book",
@@ -375,16 +374,10 @@
    "fieldname": "pdf_name",
    "fieldtype": "Data",
    "label": "PDF Name"
-  },
-  {
-   "default": "0",
-   "fieldname": "ignore_exchange_rate_revaluation_journals",
-   "fieldtype": "Check",
-   "label": "Ignore Exchange Rate Revaluation Journals"
   }
  ],
  "links": [],
- "modified": "2023-12-18 12:20:08.965120",
+ "modified": "2023-08-28 12:59:53.071334",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -47,20 +47,6 @@ class ProcessStatementOfAccounts(Document):
 
 
 def get_report_pdf(doc, consolidated=True):
-	statement_dict = get_statement_dict(doc)
-	if not bool(statement_dict):
-		return False
-	elif consolidated:
-		delimiter = '<div style="page-break-before: always;"></div>' if doc.include_break else ""
-		result = delimiter.join(list(statement_dict.values()))
-		return get_pdf(result, {"orientation": doc.orientation})
-	else:
-		for customer, statement_html in statement_dict.items():
-			statement_dict[customer] = get_pdf(statement_html, {"orientation": doc.orientation})
-		return statement_dict
-
-
-def get_statement_dict(doc, get_statement_dict=False):
 	statement_dict = {}
 	ageing = ""
 
@@ -76,11 +62,8 @@ def get_statement_dict(doc, get_statement_dict=False):
 		)
 
 		filters = get_common_filters(doc)
-		if doc.ignore_exchange_rate_revaluation_journals:
-			filters.update({"ignore_err": True})
 
 		if doc.report == "General Ledger":
-			filters.update(get_gl_filters(doc, entry, tax_id, presentation_currency))
 			col, res = get_soa(filters)
 			for x in [0, -2, -1]:
 				res[x]["account"] = res[x]["account"].replace("'", "")
@@ -93,11 +76,17 @@ def get_statement_dict(doc, get_statement_dict=False):
 			if not res:
 				continue
 
-		statement_dict[entry.customer] = (
-			[res, ageing] if get_statement_dict else get_html(doc, filters, entry, col, res, ageing)
-		)
+		statement_dict[entry.customer] = get_html(doc, filters, entry, col, res, ageing)
 
-	return statement_dict
+	if not bool(statement_dict):
+		return False
+	elif consolidated:
+		result = "".join(list(statement_dict.values()))
+		return get_pdf(result, {"orientation": doc.orientation})
+	else:
+		for customer, statement_html in statement_dict.items():
+			statement_dict[customer] = get_pdf(statement_html, {"orientation": doc.orientation})
+		return statement_dict
 
 
 def set_ageing(doc, entry):
@@ -110,8 +99,7 @@ def set_ageing(doc, entry):
 			"range2": 60,
 			"range3": 90,
 			"range4": 120,
-			"party_type": "Customer",
-			"party": [entry.customer],
+			"customer": entry.customer,
 		}
 	)
 	col1, ageing = get_ageing(ageing_filters)
@@ -154,8 +142,7 @@ def get_gl_filters(doc, entry, tax_id, presentation_currency):
 def get_ar_filters(doc, entry):
 	return {
 		"report_date": doc.posting_date if doc.posting_date else None,
-		"party_type": "Customer",
-		"party": [entry.customer],
+		"customer": entry.customer,
 		"customer_name": entry.customer_name if entry.customer_name else None,
 		"payment_terms_template": doc.payment_terms_template if doc.payment_terms_template else None,
 		"sales_partner": doc.sales_partner if doc.sales_partner else None,

erpnext/accounts/doctype/process_statement_of_accounts/test_process_statement_of_accounts.py

@@ -4,107 +4,39 @@
 import unittest
 
 import frappe
-from frappe.tests.utils import FrappeTestCase
 from frappe.utils import add_days, getdate, today
 
 from erpnext.accounts.doctype.process_statement_of_accounts.process_statement_of_accounts import (
-	get_statement_dict,
 	send_emails,
 )
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
 
 
-class TestProcessStatementOfAccounts(AccountsTestMixin, FrappeTestCase):
+class TestProcessStatementOfAccounts(unittest.TestCase):
 	def setUp(self):
-		self.create_company()
-		self.create_customer()
-		self.create_customer(customer_name="Other Customer")
-		self.clear_old_entries()
 		self.si = create_sales_invoice()
-		create_sales_invoice(customer="Other Customer")
-
-	def test_process_soa_for_gl(self):
-		"""Tests the utils for Statement of Accounts(General Ledger)"""
-		process_soa = create_process_soa(
-			name="_Test Process SOA for GL",
-			customers=[{"customer": "_Test Customer"}, {"customer": "Other Customer"}],
-		)
-		statement_dict = get_statement_dict(process_soa, get_statement_dict=True)
-
-		# Checks if the statements are filtered based on the Customer
-		self.assertIn("Other Customer", statement_dict)
-		self.assertIn("_Test Customer", statement_dict)
-
-		# Checks if the correct number of receivable entries exist
-		# 3 rows for opening and closing and 1 row for SI
-		receivable_entries = statement_dict["_Test Customer"][0]
-		self.assertEqual(len(receivable_entries), 4)
-
-		# Checks the amount for the receivable entry
-		self.assertEqual(receivable_entries[1].voucher_no, self.si.name)
-		self.assertEqual(receivable_entries[1].balance, 100)
-
-	def test_process_soa_for_ar(self):
-		"""Tests the utils for Statement of Accounts(Accounts Receivable)"""
-		process_soa = create_process_soa(name="_Test Process SOA for AR", report="Accounts Receivable")
-		statement_dict = get_statement_dict(process_soa, get_statement_dict=True)
-
-		# Checks if the statements are filtered based on the Customer
-		self.assertNotIn("Other Customer", statement_dict)
-		self.assertIn("_Test Customer", statement_dict)
-
-		# Checks if the correct number of receivable entries exist
-		receivable_entries = statement_dict["_Test Customer"][0]
-		self.assertEqual(len(receivable_entries), 1)
-
-		# Checks the amount for the receivable entry
-		self.assertEqual(receivable_entries[0].voucher_no, self.si.name)
-		self.assertEqual(receivable_entries[0].total_due, 100)
-
-		# Checks the ageing summary for AR
-		ageing_summary = statement_dict["_Test Customer"][1][0]
-		expected_summary = frappe._dict(
-			range1=100,
-			range2=0,
-			range3=0,
-			range4=0,
-			range5=0,
-		)
-		self.check_ageing_summary(ageing_summary, expected_summary)
+		self.process_soa = create_process_soa()
 
 	def test_auto_email_for_process_soa_ar(self):
-		process_soa = create_process_soa(
-			name="_Test Process SOA", enable_auto_email=1, report="Accounts Receivable"
-		)
-		send_emails(process_soa.name, from_scheduler=True)
-		process_soa.load_from_db()
-		self.assertEqual(process_soa.posting_date, getdate(add_days(today(), 7)))
-
-	def check_ageing_summary(self, ageing, expected_ageing):
-		for age_range in expected_ageing:
-			self.assertEqual(expected_ageing[age_range], ageing.get(age_range))
+		send_emails(self.process_soa.name, from_scheduler=True)
+		self.process_soa.load_from_db()
+		self.assertEqual(self.process_soa.posting_date, getdate(add_days(today(), 7)))
 
 	def tearDown(self):
-		frappe.db.rollback()
+		frappe.delete_doc_if_exists("Process Statement Of Accounts", "Test Process SOA")
 
 
-def create_process_soa(**args):
-	args = frappe._dict(args)
-	frappe.delete_doc_if_exists("Process Statement Of Accounts", args.name)
+def create_process_soa():
+	frappe.delete_doc_if_exists("Process Statement Of Accounts", "Test Process SOA")
 	process_soa = frappe.new_doc("Process Statement Of Accounts")
-	soa_dict = frappe._dict(
-		name=args.name,
-		company=args.company or "_Test Company",
-		customers=args.customers or [{"customer": "_Test Customer"}],
-		enable_auto_email=1 if args.enable_auto_email else 0,
-		frequency=args.frequency or "Weekly",
-		report=args.report or "General Ledger",
-		from_date=args.from_date or getdate(today()),
-		to_date=args.to_date or getdate(today()),
-		posting_date=args.posting_date or getdate(today()),
-		include_ageing=1,
-	)
+	soa_dict = {
+		"name": "Test Process SOA",
+		"company": "_Test Company",
+	}
 	process_soa.update(soa_dict)
+	process_soa.set("customers", [{"customer": "_Test Customer"}])
+	process_soa.enable_auto_email = 1
+	process_soa.frequency = "Weekly"
+	process_soa.report = "Accounts Receivable"
 	process_soa.save()
 	return process_soa

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -31,7 +31,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		super.onload();
 
 		// Ignore linked advances
-		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry', 'Purchase Invoice', "Repost Payment Ledger", "Repost Accounting Ledger", "Unreconcile Payment", "Unreconcile Payment Entries", "Bank Transaction"];
+		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry', 'Purchase Invoice', "Repost Payment Ledger", "Repost Accounting Ledger"];
 
 		if(!this.frm.doc.__islocal) {
 			// show credit_to in print format
@@ -59,25 +59,6 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 			this.show_stock_ledger();
 		}
 
-		if (this.frm.doc.repost_required && this.frm.doc.docstatus===1) {
-			this.frm.set_intro(__("Accounting entries for this invoice need to be reposted. Please click on 'Repost' button to update."));
-			this.frm.add_custom_button(__('Repost Accounting Entries'),
-				() => {
-					this.frm.call({
-						doc: this.frm.doc,
-						method: 'repost_accounting_entries',
-						freeze: true,
-						freeze_message: __('Reposting...'),
-						callback: (r) => {
-							if (!r.exc) {
-								frappe.msgprint(__('Accounting Entries are reposted.'));
-								me.frm.refresh();
-							}
-						}
-					});
-				}).removeClass('btn-default').addClass('btn-warning');
-		}
-
 		if(!doc.is_return && doc.docstatus == 1 && doc.outstanding_amount != 0){
 			if(doc.on_hold) {
 				this.frm.add_custom_button(
@@ -99,7 +80,8 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 			}
 		}
 
-		if(doc.docstatus == 1 && doc.outstanding_amount != 0 && !doc.on_hold) {
+		if(doc.docstatus == 1 && doc.outstanding_amount != 0
+			&& !(doc.is_return && doc.return_against) && !doc.on_hold) {
 			this.frm.add_custom_button(
 				__('Payment'),
 				() => this.make_payment_entry(),
@@ -163,18 +145,6 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 					}
 				})
 			}, __("Get Items From"));
-
-			if (!this.frm.doc.is_return) {
-				frappe.db.get_single_value("Buying Settings", "maintain_same_rate").then((value) => {
-					if (value) {
-						this.frm.doc.items.forEach((item) => {
-							this.frm.fields_dict.items.grid.update_docfield_property(
-								"rate", "read_only", (item.purchase_receipt && item.pr_detail)
-							);
-						});
-					}
-				});
-			}
 		}
 		this.frm.toggle_reqd("supplier_warehouse", this.frm.doc.is_subcontracted);
 
@@ -192,7 +162,6 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		}
 
 		this.frm.set_df_property("tax_withholding_category", "hidden", doc.apply_tds ? 0 : 1);
-		erpnext.accounts.unreconcile_payment.add_unreconcile_btn(me.frm);
 	}
 
 	unblock_invoice() {
@@ -491,12 +460,6 @@ cur_frm.set_query("expense_account", "items", function(doc) {
 	}
 });
 
-cur_frm.set_query("wip_composite_asset", "items", function() {
-	return {
-		filters: {'is_composite_asset': 1, 'docstatus': 0 }
-	}
-});
-
 cur_frm.cscript.expense_account = function(doc, cdt, cdn){
 	var d = locals[cdt][cdn];
 	if(d.idx == 1 && d.expense_account){

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -22,8 +22,6 @@
   "is_paid",
   "is_return",
   "return_against",
-  "update_billed_amount_in_purchase_order",
-  "update_billed_amount_in_purchase_receipt",
   "apply_tds",
   "tax_withholding_category",
   "amended_from",
@@ -38,7 +36,6 @@
   "currency_and_price_list",
   "currency",
   "conversion_rate",
-  "use_transaction_date_exchange_rate",
   "column_break2",
   "buying_price_list",
   "price_list_currency",
@@ -169,7 +166,6 @@
   "against_expense_account",
   "column_break_63",
   "unrealized_profit_loss_account",
-  "repost_required",
   "subscription_section",
   "auto_repeat",
   "update_auto_repeat_reference",
@@ -194,7 +190,8 @@
   "inter_company_invoice_reference",
   "is_old_subcontracting_flow",
   "remarks",
-  "connections_tab"
+  "connections_tab",
+  "column_break_38"
  ],
  "fields": [
   {
@@ -385,8 +382,7 @@
    "label": "Supplier Invoice No",
    "oldfieldname": "bill_no",
    "oldfieldtype": "Data",
-   "print_hide": 1,
-   "search_index": 1
+   "print_hide": 1
   },
   {
    "fieldname": "column_break_15",
@@ -409,22 +405,7 @@
    "no_copy": 1,
    "options": "Purchase Invoice",
    "print_hide": 1,
-   "read_only": 1,
-   "search_index": 1
-  },
-  {
-   "default": "0",
-   "depends_on": "eval: doc.is_return",
-   "fieldname": "update_billed_amount_in_purchase_order",
-   "fieldtype": "Check",
-   "label": "Update Billed Amount in Purchase Order"
-  },
-  {
-   "default": "1",
-   "depends_on": "eval: doc.is_return",
-   "fieldname": "update_billed_amount_in_purchase_receipt",
-   "fieldtype": "Check",
-   "label": "Update Billed Amount in Purchase Receipt"
+   "read_only": 1
   },
   {
    "fieldname": "section_addresses",
@@ -1006,7 +987,6 @@
    "print_hide": 1
   },
   {
-   "allow_on_submit": 1,
    "fieldname": "cash_bank_account",
    "fieldtype": "Link",
    "label": "Cash/Bank Account",
@@ -1070,7 +1050,6 @@
    "fieldtype": "Column Break"
   },
   {
-   "allow_on_submit": 1,
    "depends_on": "eval:flt(doc.write_off_amount)!=0",
    "fieldname": "write_off_account",
    "fieldtype": "Link",
@@ -1234,7 +1213,6 @@
    "read_only": 1
   },
   {
-   "allow_on_submit": 1,
    "default": "No",
    "fieldname": "is_opening",
    "fieldtype": "Select",
@@ -1367,7 +1345,6 @@
    "options": "Project"
   },
   {
-   "allow_on_submit": 1,
    "depends_on": "eval:doc.is_internal_supplier",
    "description": "Unrealized Profit/Loss account for intra-company transfers",
    "fieldname": "unrealized_profit_loss_account",
@@ -1400,7 +1377,6 @@
    "depends_on": "eval:doc.is_subcontracted",
    "fieldname": "supplier_warehouse",
    "fieldtype": "Link",
-   "ignore_user_permissions": 1,
    "label": "Supplier Warehouse",
    "no_copy": 1,
    "options": "Warehouse",
@@ -1518,6 +1494,10 @@
    "fieldname": "column_break_6",
    "fieldtype": "Column Break"
   },
+  {
+   "fieldname": "column_break_38",
+   "fieldtype": "Column Break"
+  },
   {
    "fieldname": "column_break_50",
    "fieldtype": "Column Break"
@@ -1588,29 +1568,13 @@
    "fieldname": "use_company_roundoff_cost_center",
    "fieldtype": "Check",
    "label": "Use Company Default Round Off Cost Center"
-  },
-  {
-   "default": "0",
-   "fieldname": "repost_required",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Repost Required",
-   "options": "Account",
-   "read_only": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "use_transaction_date_exchange_rate",
-   "fieldtype": "Check",
-   "label": "Use Transaction Date Exchange Rate",
-   "read_only": 1
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-02-25 11:20:28.366808",
+ "modified": "2023-07-04 17:23:59.145031",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -11,10 +11,6 @@ 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,
-)
 from erpnext.accounts.doctype.sales_invoice.sales_invoice import (
 	check_if_return_invoice_linked_with_payment_entry,
 	get_total_in_party_account_currency,
@@ -34,7 +30,7 @@ from erpnext.accounts.general_ledger import (
 )
 from erpnext.accounts.party import get_due_date, get_party_account
 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.asset import get_asset_account, 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
 from erpnext.controllers.accounts_controller import validate_account_head
@@ -131,18 +127,6 @@ class PurchaseInvoice(BuyingController):
 		self.reset_default_field_value("set_warehouse", "items", "warehouse")
 		self.reset_default_field_value("rejected_warehouse", "items", "rejected_warehouse")
 		self.reset_default_field_value("set_from_warehouse", "items", "from_warehouse")
-		self.set_percentage_received()
-
-	def set_percentage_received(self):
-		total_billed_qty = 0.0
-		total_received_qty = 0.0
-		for row in self.items:
-			if row.purchase_receipt and row.pr_detail and row.received_qty:
-				total_billed_qty += row.qty
-				total_received_qty += row.received_qty
-
-		if total_billed_qty and total_received_qty:
-			self.per_received = total_received_qty / total_billed_qty * 100
 
 	def validate_release_date(self):
 		if self.release_date and getdate(nowdate()) >= getdate(self.release_date):
@@ -297,6 +281,9 @@ class PurchaseInvoice(BuyingController):
 			# in case of auto inventory accounting,
 			# expense account is always "Stock Received But Not Billed" for a stock item
 			# except opening entry, drop-ship entry and fixed asset items
+			if item.item_code:
+				asset_category = frappe.get_cached_value("Item", item.item_code, "asset_category")
+
 			if (
 				auto_accounting_for_stock
 				and item.item_code in stock_items
@@ -363,26 +350,22 @@ class PurchaseInvoice(BuyingController):
 							frappe.msgprint(msg, title=_("Expense Head Changed"))
 
 						item.expense_account = stock_not_billed_account
-			elif item.is_fixed_asset and item.pr_detail:
-				if not asset_received_but_not_billed:
-					asset_received_but_not_billed = self.get_company_default("asset_received_but_not_billed")
-				item.expense_account = asset_received_but_not_billed
-			elif item.is_fixed_asset:
-				account_type = (
-					"capital_work_in_progress_account"
-					if is_cwip_accounting_enabled(item.asset_category)
-					else "fixed_asset_account"
-				)
+
+			elif item.is_fixed_asset and not is_cwip_accounting_enabled(asset_category):
 				asset_category_account = get_asset_category_account(
-					account_type, item=item.item_code, company=self.company
+					"fixed_asset_account", item=item.item_code, company=self.company
 				)
 				if not asset_category_account:
-					form_link = get_link_to_form("Asset Category", item.asset_category)
+					form_link = get_link_to_form("Asset Category", asset_category)
 					throw(
 						_("Please set Fixed Asset Account in {} against {}.").format(form_link, self.company),
 						title=_("Missing Account"),
 					)
 				item.expense_account = asset_category_account
+			elif item.is_fixed_asset and item.pr_detail:
+				if not asset_received_but_not_billed:
+					asset_received_but_not_billed = self.get_company_default("asset_received_but_not_billed")
+				item.expense_account = asset_received_but_not_billed
 			elif not item.expense_account and for_validate:
 				throw(_("Expense account is mandatory for item {0}").format(item.item_code or item.item_name))
 
@@ -504,21 +487,10 @@ class PurchaseInvoice(BuyingController):
 						_("Stock cannot be updated against Purchase Receipt {0}").format(item.purchase_receipt)
 					)
 
-	def validate_for_repost(self):
-		self.validate_write_off_account()
-		self.validate_expense_account()
-		validate_docs_for_voucher_types(["Purchase Invoice"])
-		validate_docs_for_deferred_accounting([], [self.name])
-
 	def on_submit(self):
 		super(PurchaseInvoice, self).on_submit()
 
 		self.check_prev_docstatus()
-
-		if self.is_return and not self.update_billed_amount_in_purchase_order:
-			# NOTE status updating bypassed for is_return
-			self.status_updater = []
-
 		self.update_status_updater_args()
 		self.update_prevdoc_status()
 
@@ -551,29 +523,12 @@ class PurchaseInvoice(BuyingController):
 		if self.update_stock == 1:
 			self.repost_future_sle_and_gle()
 
-		if (
-			frappe.db.get_single_value("Buying Settings", "project_update_frequency") == "Each Transaction"
-		):
-			self.update_project()
-
+		self.update_project()
 		update_linked_doc(self.doctype, self.name, self.inter_company_invoice_reference)
 		self.update_advance_tax_references()
 
 		self.process_common_party_accounting()
 
-	def on_update_after_submit(self):
-		if hasattr(self, "repost_required"):
-			fields_to_check = [
-				"cash_bank_account",
-				"write_off_account",
-				"unrealized_profit_loss_account",
-			]
-			child_tables = {"items": ("expense_account",), "taxes": ("account_head",)}
-			self.needs_repost = self.check_if_fields_updated(fields_to_check, child_tables)
-			if self.needs_repost:
-				self.validate_for_repost()
-				self.db_set("repost_required", self.needs_repost)
-
 	def make_gl_entries(self, gl_entries=None, from_repost=False):
 		if not gl_entries:
 			gl_entries = self.get_gl_entries()
@@ -615,11 +570,12 @@ class PurchaseInvoice(BuyingController):
 
 	def get_gl_entries(self, warehouse_account=None):
 		self.auto_accounting_for_stock = erpnext.is_perpetual_inventory_enabled(self.company)
-
 		if self.auto_accounting_for_stock:
 			self.stock_received_but_not_billed = self.get_company_default("stock_received_but_not_billed")
+			self.expenses_included_in_valuation = self.get_company_default("expenses_included_in_valuation")
 		else:
 			self.stock_received_but_not_billed = None
+			self.expenses_included_in_valuation = None
 
 		self.negative_expense_to_be_booked = 0.0
 		gl_entries = []
@@ -628,6 +584,9 @@ class PurchaseInvoice(BuyingController):
 		self.make_item_gl_entries(gl_entries)
 		self.make_precision_loss_gl_entry(gl_entries)
 
+		if self.check_asset_cwip_enabled():
+			self.get_asset_gl_entry(gl_entries)
+
 		self.make_tax_gl_entries(gl_entries)
 		self.make_internal_transfer_gl_entries(gl_entries)
 
@@ -676,7 +635,9 @@ class PurchaseInvoice(BuyingController):
 						"credit_in_account_currency": base_grand_total
 						if self.party_account_currency == self.company_currency
 						else grand_total,
-						"against_voucher": self.name,
+						"against_voucher": self.return_against
+						if cint(self.is_return) and self.return_against
+						else self.name,
 						"against_voucher_type": self.doctype,
 						"project": self.project,
 						"cost_center": self.cost_center,
@@ -729,11 +690,7 @@ class PurchaseInvoice(BuyingController):
 				if item.item_code:
 					asset_category = frappe.get_cached_value("Item", item.item_code, "asset_category")
 
-				if (
-					self.update_stock
-					and self.auto_accounting_for_stock
-					and (item.item_code in stock_items or item.is_fixed_asset)
-				):
+				if self.update_stock and self.auto_accounting_for_stock and item.item_code in stock_items:
 					# warehouse account
 					warehouse_debit_amount = self.make_stock_adjustment_entry(
 						gl_entries, item, voucher_wise_stock_value, account_currency
@@ -848,7 +805,9 @@ class PurchaseInvoice(BuyingController):
 							)
 						)
 
-				else:
+				elif not item.is_fixed_asset or (
+					item.is_fixed_asset and not is_cwip_accounting_enabled(asset_category)
+				):
 					expense_account = (
 						item.expense_account
 						if (not item.enable_deferred_expense or self.is_return)
@@ -940,6 +899,51 @@ class PurchaseInvoice(BuyingController):
 										item=item,
 									)
 								)
+
+					# If asset is bought through this document and not linked to PR
+					if self.update_stock and item.landed_cost_voucher_amount:
+						expenses_included_in_asset_valuation = self.get_company_default(
+							"expenses_included_in_asset_valuation"
+						)
+						# Amount added through landed-cost-voucher
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": expenses_included_in_asset_valuation,
+									"against": expense_account,
+									"cost_center": item.cost_center,
+									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+									"credit": flt(item.landed_cost_voucher_amount),
+									"project": item.project or self.project,
+								},
+								item=item,
+							)
+						)
+
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": expense_account,
+									"against": expenses_included_in_asset_valuation,
+									"cost_center": item.cost_center,
+									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+									"debit": flt(item.landed_cost_voucher_amount),
+									"project": item.project or self.project,
+								},
+								item=item,
+							)
+						)
+
+						# update gross amount of asset bought through this document
+						assets = frappe.db.get_all(
+							"Asset", filters={"purchase_invoice": self.name, "item_code": item.item_code}
+						)
+						for asset in assets:
+							frappe.db.set_value("Asset", asset.name, "gross_purchase_amount", flt(item.valuation_rate))
+							frappe.db.set_value(
+								"Asset", asset.name, "purchase_receipt_amount", flt(item.valuation_rate)
+							)
+
 			if (
 				self.auto_accounting_for_stock
 				and self.is_opening == "No"
@@ -954,17 +958,11 @@ class PurchaseInvoice(BuyingController):
 						(item.purchase_receipt, valuation_tax_accounts),
 					)
 
-					stock_rbnb = (
-						self.get_company_default("asset_received_but_not_billed")
-						if item.is_fixed_asset
-						else self.stock_received_but_not_billed
-					)
-
 					if not negative_expense_booked_in_pr:
 						gl_entries.append(
 							self.get_gl_dict(
 								{
-									"account": stock_rbnb,
+									"account": self.stock_received_but_not_billed,
 									"against": self.supplier,
 									"debit": flt(item.item_tax_amount, item.precision("item_tax_amount")),
 									"remarks": self.remarks or _("Accounting Entry for Stock"),
@@ -979,25 +977,156 @@ class PurchaseInvoice(BuyingController):
 							item.item_tax_amount, item.precision("item_tax_amount")
 						)
 
-			if item.is_fixed_asset and item.landed_cost_voucher_amount:
-				self.update_gross_purchase_amount_for_linked_assets(item)
+	def get_asset_gl_entry(self, gl_entries):
+		arbnb_account = None
+		eiiav_account = None
+		asset_eiiav_currency = None
 
-	def update_gross_purchase_amount_for_linked_assets(self, item):
-		assets = frappe.db.get_all(
-			"Asset",
-			filters={"purchase_invoice": self.name, "item_code": item.item_code},
-			fields=["name", "asset_quantity"],
-		)
-		for asset in assets:
-			purchase_amount = flt(item.valuation_rate) * asset.asset_quantity
-			frappe.db.set_value(
-				"Asset",
-				asset.name,
-				{
-					"gross_purchase_amount": purchase_amount,
-					"purchase_receipt_amount": purchase_amount,
-				},
-			)
+		for item in self.get("items"):
+			if item.is_fixed_asset:
+				asset_amount = flt(item.net_amount) + flt(item.item_tax_amount / self.conversion_rate)
+				base_asset_amount = flt(item.base_net_amount + item.item_tax_amount)
+
+				item_exp_acc_type = frappe.db.get_value("Account", item.expense_account, "account_type")
+				if not item.expense_account or item_exp_acc_type not in [
+					"Asset Received But Not Billed",
+					"Fixed Asset",
+				]:
+					if not arbnb_account:
+						arbnb_account = self.get_company_default("asset_received_but_not_billed")
+					item.expense_account = arbnb_account
+
+				if not self.update_stock:
+					arbnb_currency = get_account_currency(item.expense_account)
+					gl_entries.append(
+						self.get_gl_dict(
+							{
+								"account": item.expense_account,
+								"against": self.supplier,
+								"remarks": self.get("remarks") or _("Accounting Entry for Asset"),
+								"debit": base_asset_amount,
+								"debit_in_account_currency": (
+									base_asset_amount if arbnb_currency == self.company_currency else asset_amount
+								),
+								"cost_center": item.cost_center,
+								"project": item.project or self.project,
+							},
+							item=item,
+						)
+					)
+
+					if item.item_tax_amount:
+						if not eiiav_account or not asset_eiiav_currency:
+							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
+							asset_eiiav_currency = get_account_currency(eiiav_account)
+
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": eiiav_account,
+									"against": self.supplier,
+									"remarks": self.get("remarks") or _("Accounting Entry for Asset"),
+									"cost_center": item.cost_center,
+									"project": item.project or self.project,
+									"credit": item.item_tax_amount,
+									"credit_in_account_currency": (
+										item.item_tax_amount
+										if asset_eiiav_currency == self.company_currency
+										else item.item_tax_amount / self.conversion_rate
+									),
+								},
+								item=item,
+							)
+						)
+				else:
+					cwip_account = get_asset_account(
+						"capital_work_in_progress_account", asset_category=item.asset_category, company=self.company
+					)
+
+					cwip_account_currency = get_account_currency(cwip_account)
+					gl_entries.append(
+						self.get_gl_dict(
+							{
+								"account": cwip_account,
+								"against": self.supplier,
+								"remarks": self.get("remarks") or _("Accounting Entry for Asset"),
+								"debit": base_asset_amount,
+								"debit_in_account_currency": (
+									base_asset_amount if cwip_account_currency == self.company_currency else asset_amount
+								),
+								"cost_center": self.cost_center,
+								"project": item.project or self.project,
+							},
+							item=item,
+						)
+					)
+
+					if item.item_tax_amount and not cint(erpnext.is_perpetual_inventory_enabled(self.company)):
+						if not eiiav_account or not asset_eiiav_currency:
+							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
+							asset_eiiav_currency = get_account_currency(eiiav_account)
+
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": eiiav_account,
+									"against": self.supplier,
+									"remarks": self.get("remarks") or _("Accounting Entry for Asset"),
+									"cost_center": item.cost_center,
+									"credit": item.item_tax_amount,
+									"project": item.project or self.project,
+									"credit_in_account_currency": (
+										item.item_tax_amount
+										if asset_eiiav_currency == self.company_currency
+										else item.item_tax_amount / self.conversion_rate
+									),
+								},
+								item=item,
+							)
+						)
+
+					# Assets are bought through this document then it will be linked to this document
+					if flt(item.landed_cost_voucher_amount):
+						if not eiiav_account:
+							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
+
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": eiiav_account,
+									"against": cwip_account,
+									"cost_center": item.cost_center,
+									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+									"credit": flt(item.landed_cost_voucher_amount),
+									"project": item.project or self.project,
+								},
+								item=item,
+							)
+						)
+
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": cwip_account,
+									"against": eiiav_account,
+									"cost_center": item.cost_center,
+									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+									"debit": flt(item.landed_cost_voucher_amount),
+									"project": item.project or self.project,
+								},
+								item=item,
+							)
+						)
+
+					# update gross amount of assets bought through this document
+					assets = frappe.db.get_all(
+						"Asset", filters={"purchase_invoice": self.name, "item_code": item.item_code}
+					)
+					for asset in assets:
+						frappe.db.set_value("Asset", asset.name, "gross_purchase_amount", flt(item.valuation_rate))
+						frappe.db.set_value("Asset", asset.name, "purchase_receipt_amount", flt(item.valuation_rate))
+
+		return gl_entries
 
 	def make_stock_adjustment_entry(
 		self, gl_entries, item, voucher_wise_stock_value, account_currency
@@ -1269,10 +1398,6 @@ class PurchaseInvoice(BuyingController):
 
 		self.check_on_hold_or_closed_status()
 
-		if self.is_return and not self.update_billed_amount_in_purchase_order:
-			# NOTE status updating bypassed for is_return
-			self.status_updater = []
-
 		self.update_status_updater_args()
 		self.update_prevdoc_status()
 
@@ -1296,10 +1421,7 @@ class PurchaseInvoice(BuyingController):
 		if self.update_stock == 1:
 			self.repost_future_sle_and_gle()
 
-		if (
-			frappe.db.get_single_value("Buying Settings", "project_update_frequency") == "Each Transaction"
-		):
-			self.update_project()
+		self.update_project()
 		self.db_set("status", "Cancelled")
 
 		unlink_inter_company_doc(self.doctype, self.name, self.inter_company_invoice_reference)
@@ -1311,29 +1433,19 @@ class PurchaseInvoice(BuyingController):
 			"Repost Payment Ledger Items",
 			"Repost Accounting Ledger",
 			"Repost Accounting Ledger Items",
-			"Unreconcile Payment",
-			"Unreconcile Payment Entries",
 			"Payment Ledger Entry",
 			"Tax Withheld Vouchers",
 		)
 		self.update_advance_tax_references(cancel=1)
 
 	def update_project(self):
-		projects = frappe._dict()
+		project_list = []
 		for d in self.items:
-			if d.project:
-				if self.docstatus == 1:
-					projects[d.project] = projects.get(d.project, 0) + d.base_net_amount
-				elif self.docstatus == 2:
-					projects[d.project] = projects.get(d.project, 0) - d.base_net_amount
-
-		pj = frappe.qb.DocType("Project")
-		for proj, value in projects.items():
-			res = (
-				frappe.qb.from_(pj).select(pj.total_purchase_cost).where(pj.name == proj).for_update().run()
-			)
-			current_purchase_cost = res and res[0][0] or 0
-			frappe.db.set_value("Project", proj, "total_purchase_cost", current_purchase_cost + value)
+			if d.project and d.project not in project_list:
+				project = frappe.get_doc("Project", d.project)
+				project.update_purchase_costing()
+				project.db_update()
+				project_list.append(d.project)
 
 	def validate_supplier_invoice(self):
 		if self.bill_date:
@@ -1366,9 +1478,6 @@ class PurchaseInvoice(BuyingController):
 					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:
-			return
-
 		updated_pr = []
 		po_details = []
 
@@ -1550,8 +1659,12 @@ class PurchaseInvoice(BuyingController):
 				elif outstanding_amount > 0 and getdate(self.due_date) >= getdate():
 					self.status = "Unpaid"
 				# Check if outstanding amount is 0 due to debit note issued against invoice
-				elif self.is_return == 0 and frappe.db.get_value(
-					"Purchase Invoice", {"is_return": 1, "return_against": self.name, "docstatus": 1}
+				elif (
+					outstanding_amount <= 0
+					and self.is_return == 0
+					and frappe.db.get_value(
+						"Purchase Invoice", {"is_return": 1, "return_against": self.name, "docstatus": 1}
+					)
 				):
 					self.status = "Debit Note Issued"
 				elif self.is_return == 1:
@@ -1680,6 +1793,10 @@ def make_inter_company_sales_invoice(source_name, target_doc=None):
 	return make_inter_company_transaction("Purchase Invoice", source_name, target_doc)
 
 
+def on_doctype_update():
+	frappe.db.add_index("Purchase Invoice", ["supplier", "is_return", "return_against"])
+
+
 @frappe.whitelist()
 def make_purchase_receipt(source_name, target_doc=None):
 	def update_item(obj, target, source_parent):
@@ -1711,7 +1828,6 @@ def make_purchase_receipt(source_name, target_doc=None):
 					"po_detail": "purchase_order_item",
 					"material_request": "material_request",
 					"material_request_item": "material_request_item",
-					"wip_composite_asset": "wip_composite_asset",
 				},
 				"postprocess": update_item,
 				"condition": lambda doc: abs(doc.received_qty) < abs(doc.qty),
@@ -1721,4 +1837,6 @@ def make_purchase_receipt(source_name, target_doc=None):
 		target_doc,
 	)
 
+	doc.set_onload("ignore_price_list", True)
+
 	return doc

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -5,7 +5,7 @@
 import unittest
 
 import frappe
-from frappe.tests.utils import FrappeTestCase, change_settings
+from frappe.tests.utils import change_settings
 from frappe.utils import add_days, cint, flt, getdate, nowdate, today
 
 import erpnext
@@ -33,7 +33,7 @@ test_dependencies = ["Item", "Cost Center", "Payment Term", "Payment Terms Templ
 test_ignore = ["Serial No"]
 
 
-class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
+class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 	@classmethod
 	def setUpClass(self):
 		unlink_payment_on_cancel_of_invoice()
@@ -43,9 +43,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 	def tearDownClass(self):
 		unlink_payment_on_cancel_of_invoice(0)
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def test_purchase_invoice_received_qty(self):
 		"""
 		1. Test if received qty is validated against accepted + rejected
@@ -420,7 +417,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 			self.assertEqual(tax.tax_amount, expected_values[i][1])
 			self.assertEqual(tax.total, expected_values[i][2])
 
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_purchase_invoice_with_advance(self):
 		from erpnext.accounts.doctype.journal_entry.test_journal_entry import (
 			test_records as jv_test_records,
@@ -475,7 +471,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 			)
 		)
 
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_invoice_with_advance_and_multi_payment_terms(self):
 		from erpnext.accounts.doctype.journal_entry.test_journal_entry import (
 			test_records as jv_test_records,
@@ -1214,7 +1209,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		acc_settings.submit_journal_entriessubmit_journal_entries = 0
 		acc_settings.save()
 
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_gain_loss_with_advance_entry(self):
 		unlink_enabled = frappe.db.get_value(
 			"Accounts Settings", "Accounts Settings", "unlink_payment_on_cancel_of_invoice"
@@ -1417,7 +1411,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		)
 		frappe.db.set_value("Company", "_Test Company", "exchange_gain_loss_account", original_account)
 
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_purchase_invoice_advance_taxes(self):
 		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 
@@ -1718,14 +1711,9 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		self.assertTrue(return_pi.docstatus == 1)
 
 	def test_gl_entries_for_standalone_debit_note(self):
-		from erpnext.stock.doctype.item.test_item import make_item
+		make_purchase_invoice(qty=5, rate=500, update_stock=True)
 
-		item_code = make_item(properties={"is_stock_item": 1})
-		make_purchase_invoice(item_code=item_code, qty=5, rate=500, update_stock=True)
-
-		returned_inv = make_purchase_invoice(
-			item_code=item_code, qty=-5, rate=5, update_stock=True, is_return=True
-		)
+		returned_inv = make_purchase_invoice(qty=-5, rate=5, update_stock=True, is_return=True)
 
 		# override the rate with valuation rate
 		sle = frappe.get_all(
@@ -1735,7 +1723,7 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		)[0]
 
 		rate = flt(sle.stock_value_difference) / flt(sle.actual_qty)
-		self.assertAlmostEqual(rate, 500)
+		self.assertAlmostEqual(returned_inv.items[0].rate, rate)
 
 	def test_payment_allocation_for_payment_terms(self):
 		from erpnext.buying.doctype.purchase_order.test_purchase_order import (
@@ -1808,6 +1796,7 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 
 		pi = make_purchase_invoice(
 			company="_Test Company",
+			customer="_Test Supplier",
 			do_not_save=True,
 			do_not_submit=True,
 			rate=1000,
@@ -1837,77 +1826,6 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		clear_dimension_defaults("Branch")
 		disable_dimension()
 
-	def test_repost_accounting_entries(self):
-		# update repost settings
-		settings = frappe.get_doc("Repost Accounting Ledger Settings")
-		if not [x for x in settings.allowed_types if x.document_type == "Purchase Invoice"]:
-			settings.append("allowed_types", {"document_type": "Purchase Invoice", "allowed": True})
-		settings.save()
-
-		pi = make_purchase_invoice(
-			rate=1000,
-			price_list_rate=1000,
-			qty=1,
-		)
-		expected_gle = [
-			["_Test Account Cost for Goods Sold - _TC", 1000, 0.0, nowdate()],
-			["Creditors - _TC", 0.0, 1000, nowdate()],
-		]
-		check_gl_entries(self, pi.name, expected_gle, nowdate())
-
-		pi.items[0].expense_account = "Service - _TC"
-		pi.save()
-		pi.load_from_db()
-		self.assertTrue(pi.repost_required)
-		pi.repost_accounting_entries()
-
-		expected_gle = [
-			["Creditors - _TC", 0.0, 1000, nowdate()],
-			["Service - _TC", 1000, 0.0, nowdate()],
-		]
-		check_gl_entries(self, pi.name, expected_gle, nowdate())
-		pi.load_from_db()
-		self.assertFalse(pi.repost_required)
-
-	def test_default_cost_center_for_purchase(self):
-		from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
-
-		for c_center in ["_Test Cost Center Selling", "_Test Cost Center Buying"]:
-			create_cost_center(cost_center_name=c_center)
-
-		item = create_item(
-			"_Test Cost Center Item For Purchase",
-			is_stock_item=1,
-			buying_cost_center="_Test Cost Center Buying - _TC",
-			selling_cost_center="_Test Cost Center Selling - _TC",
-		)
-
-		pi = make_purchase_invoice(
-			item=item.name, qty=1, rate=1000, update_stock=True, do_not_submit=True, cost_center=""
-		)
-
-		pi.items[0].cost_center = ""
-		pi.set_missing_values()
-		pi.calculate_taxes_and_totals()
-		pi.save()
-
-		self.assertEqual(pi.items[0].cost_center, "_Test Cost Center Buying - _TC")
-
-	def test_debit_note_with_account_mismatch(self):
-		new_creditors = create_account(
-			parent_account="Accounts Payable - _TC",
-			account_name="Creditors 2",
-			company="_Test Company",
-			account_type="Payable",
-		)
-		pi = make_purchase_invoice(qty=1, rate=1000)
-		dr_note = make_purchase_invoice(
-			qty=-1, rate=1000, is_return=1, return_against=pi.name, do_not_save=True
-		)
-		dr_note.credit_to = new_creditors
-
-		self.assertRaises(frappe.ValidationError, dr_note.save)
-
 
 def check_gl_entries(
 	doc,

erpnext/accounts/doctype/purchase_invoice_item/purchase_invoice_item.json

@@ -75,7 +75,6 @@
   "manufacturer_part_no",
   "accounting",
   "expense_account",
-  "wip_composite_asset",
   "col_break5",
   "is_fixed_asset",
   "asset_location",
@@ -156,7 +155,6 @@
    "width": "300px"
   },
   {
-   "fetch_from": "item_code.image",
    "fieldname": "image",
    "fieldtype": "Attach",
    "hidden": 1,
@@ -469,7 +467,6 @@
    "label": "Accounting"
   },
   {
-   "allow_on_submit": 1,
    "fieldname": "expense_account",
    "fieldtype": "Link",
    "label": "Expense Head",
@@ -492,7 +489,6 @@
    "fieldtype": "Column Break"
   },
   {
-   "allow_on_submit": 1,
    "fieldname": "project",
    "fieldtype": "Link",
    "label": "Project",
@@ -500,7 +496,6 @@
    "print_hide": 1
   },
   {
-   "allow_on_submit": 1,
    "default": ":Company",
    "depends_on": "eval:!doc.is_fixed_asset",
    "fieldname": "cost_center",
@@ -882,18 +877,12 @@
    "fieldname": "apply_tds",
    "fieldtype": "Check",
    "label": "Apply TDS"
-  },
-  {
-   "fieldname": "wip_composite_asset",
-   "fieldtype": "Link",
-   "label": "WIP Composite Asset",
-   "options": "Asset"
   }
  ],
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-12-25 22:00:28.043555",
+ "modified": "2023-07-04 17:22:21.501152",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice Item",
@@ -903,4 +892,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/purchase_taxes_and_charges/purchase_taxes_and_charges.json

@@ -86,7 +86,6 @@
    "fieldtype": "Column Break"
   },
   {
-   "allow_on_submit": 1,
    "columns": 2,
    "fieldname": "account_head",
    "fieldtype": "Link",
@@ -98,7 +97,6 @@
    "reqd": 1
   },
   {
-   "allow_on_submit": 1,
    "default": ":Company",
    "fieldname": "cost_center",
    "fieldtype": "Link",
@@ -126,7 +124,7 @@
    "fieldname": "rate",
    "fieldtype": "Float",
    "in_list_view": 1,
-   "label": "Tax Rate",
+   "label": "Rate",
    "oldfieldname": "rate",
    "oldfieldtype": "Currency"
   },
@@ -230,7 +228,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-01-14 10:04:36.618240",
+ "modified": "2021-08-05 20:04:36.618240",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Taxes and Charges",
@@ -239,4 +237,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.js

@@ -5,7 +5,9 @@ frappe.ui.form.on("Repost Accounting Ledger", {
 	setup: function(frm) {
 		frm.fields_dict['vouchers'].grid.get_field('voucher_type').get_query = function(doc) {
 			return {
-				query: "erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger.get_repost_allowed_types"
+				filters: {
+					name: ['in', ['Purchase Invoice', 'Sales Invoice', 'Payment Entry', 'Journal Entry']],
+				}
 			}
 		}
 

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.json

@@ -55,7 +55,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-09-26 14:21:27.362567",
+ "modified": "2023-07-27 15:47:58.975034",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Repost Accounting Ledger",
@@ -77,6 +77,5 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
- "track_changes": 1
+ "states": []
 }

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.py

@@ -10,7 +10,9 @@ from frappe.utils.data import comma_and
 class RepostAccountingLedger(Document):
 	def __init__(self, *args, **kwargs):
 		super(RepostAccountingLedger, self).__init__(*args, **kwargs)
-		self._allowed_types = get_allowed_types_from_settings()
+		self._allowed_types = set(
+			["Purchase Invoice", "Sales Invoice", "Payment Entry", "Journal Entry"]
+		)
 
 	def validate(self):
 		self.validate_vouchers()
@@ -19,8 +21,29 @@ class RepostAccountingLedger(Document):
 
 	def validate_for_deferred_accounting(self):
 		sales_docs = [x.voucher_no for x in self.vouchers if x.voucher_type == "Sales Invoice"]
+		docs_with_deferred_revenue = frappe.db.get_all(
+			"Sales Invoice Item",
+			filters={"parent": ["in", sales_docs], "docstatus": 1, "enable_deferred_revenue": True},
+			fields=["parent"],
+			as_list=1,
+		)
+
 		purchase_docs = [x.voucher_no for x in self.vouchers if x.voucher_type == "Purchase Invoice"]
-		validate_docs_for_deferred_accounting(sales_docs, purchase_docs)
+		docs_with_deferred_expense = frappe.db.get_all(
+			"Purchase Invoice Item",
+			filters={"parent": ["in", purchase_docs], "docstatus": 1, "enable_deferred_expense": 1},
+			fields=["parent"],
+			as_list=1,
+		)
+
+		if docs_with_deferred_revenue or docs_with_deferred_expense:
+			frappe.throw(
+				_("Documents: {0} have deferred revenue/expense enabled for them. Cannot repost.").format(
+					frappe.bold(
+						comma_and([x[0] for x in docs_with_deferred_expense + docs_with_deferred_revenue])
+					)
+				)
+			)
 
 	def validate_for_closed_fiscal_year(self):
 		if self.vouchers:
@@ -51,7 +74,15 @@ class RepostAccountingLedger(Document):
 
 	def validate_vouchers(self):
 		if self.vouchers:
-			validate_docs_for_voucher_types([x.voucher_type for x in self.vouchers])
+			# Validate voucher types
+			voucher_types = set([x.voucher_type for x in self.vouchers])
+			if disallowed_types := voucher_types.difference(self._allowed_types):
+				frappe.throw(
+					_("{0} types are not allowed. Only {1} are.").format(
+						frappe.bold(comma_and(list(disallowed_types))),
+						frappe.bold(comma_and(list(self._allowed_types))),
+					)
+				)
 
 	def get_existing_ledger_entries(self):
 		vouchers = [x.voucher_no for x in self.vouchers]
@@ -70,7 +101,6 @@ class RepostAccountingLedger(Document):
 			).append(gle.update({"old": True}))
 
 	def generate_preview_data(self):
-		frappe.flags.through_repost_accounting_ledger = True
 		self.gl_entries = []
 		self.get_existing_ledger_entries()
 		for x in self.vouchers:
@@ -109,22 +139,18 @@ class RepostAccountingLedger(Document):
 		return rendered_page
 
 	def on_submit(self):
-		if len(self.vouchers) > 5:
-			job_name = "repost_accounting_ledger_" + self.name
-			frappe.enqueue(
-				method="erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger.start_repost",
-				account_repost_doc=self.name,
-				is_async=True,
-				job_name=job_name,
-			)
-			frappe.msgprint(_("Repost has started in the background"))
-		else:
-			start_repost(self.name)
+		job_name = "repost_accounting_ledger_" + self.name
+		frappe.enqueue(
+			method="erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger.start_repost",
+			account_repost_doc=self.name,
+			is_async=True,
+			job_name=job_name,
+		)
+		frappe.msgprint(_("Repost has started in the background"))
 
 
 @frappe.whitelist()
 def start_repost(account_repost_doc=str) -> None:
-	frappe.flags.through_repost_accounting_ledger = True
 	if account_repost_doc:
 		repost_doc = frappe.get_doc("Repost Accounting Ledger", account_repost_doc)
 
@@ -149,73 +175,9 @@ def start_repost(account_repost_doc=str) -> None:
 					doc.docstatus = 1
 					doc.make_gl_entries()
 
-				elif doc.doctype in ["Payment Entry", "Journal Entry", "Expense Claim"]:
+				elif doc.doctype in ["Payment Entry", "Journal Entry"]:
 					if not repost_doc.delete_cancelled_entries:
 						doc.make_gl_entries(1)
 					doc.make_gl_entries()
 
-
-def get_allowed_types_from_settings():
-	return [
-		x.document_type
-		for x in frappe.db.get_all(
-			"Repost Allowed Types", filters={"allowed": True}, fields=["distinct(document_type)"]
-		)
-	]
-
-
-def validate_docs_for_deferred_accounting(sales_docs, purchase_docs):
-	docs_with_deferred_revenue = frappe.db.get_all(
-		"Sales Invoice Item",
-		filters={"parent": ["in", sales_docs], "docstatus": 1, "enable_deferred_revenue": True},
-		fields=["parent"],
-		as_list=1,
-	)
-
-	docs_with_deferred_expense = frappe.db.get_all(
-		"Purchase Invoice Item",
-		filters={"parent": ["in", purchase_docs], "docstatus": 1, "enable_deferred_expense": 1},
-		fields=["parent"],
-		as_list=1,
-	)
-
-	if docs_with_deferred_revenue or docs_with_deferred_expense:
-		frappe.throw(
-			_("Documents: {0} have deferred revenue/expense enabled for them. Cannot repost.").format(
-				frappe.bold(comma_and([x[0] for x in docs_with_deferred_expense + docs_with_deferred_revenue]))
-			)
-		)
-
-
-def validate_docs_for_voucher_types(doc_voucher_types):
-	allowed_types = get_allowed_types_from_settings()
-	# Validate voucher types
-	voucher_types = set(doc_voucher_types)
-	if disallowed_types := voucher_types.difference(allowed_types):
-		message = "are" if len(disallowed_types) > 1 else "is"
-		frappe.throw(
-			_("{0} {1} not allowed to be reposted. Modify {2} to enable reposting.").format(
-				frappe.bold(comma_and(list(disallowed_types))),
-				message,
-				frappe.bold(
-					frappe.utils.get_link_to_form(
-						"Repost Accounting Ledger Settings", "Repost Accounting Ledger Settings"
-					)
-				),
-			)
-		)
-
-
-@frappe.whitelist()
-@frappe.validate_and_sanitize_search_inputs
-def get_repost_allowed_types(doctype, txt, searchfield, start, page_len, filters):
-	filters = {"allowed": True}
-
-	if txt:
-		filters.update({"document_type": ("like", f"%{txt}%")})
-
-	if allowed_types := frappe.db.get_all(
-		"Repost Allowed Types", filters=filters, fields=["distinct(document_type)"], as_list=1
-	):
-		return allowed_types
-	return []
+				frappe.db.commit()

erpnext/accounts/doctype/repost_accounting_ledger/test_repost_accounting_ledger.py

@@ -20,9 +20,8 @@ class TestRepostAccountingLedger(AccountsTestMixin, FrappeTestCase):
 		self.create_company()
 		self.create_customer()
 		self.create_item()
-		update_repost_settings()
 
-	def tearDown(self):
+	def teadDown(self):
 		frappe.db.rollback()
 
 	def test_01_basic_functions(self):
@@ -83,6 +82,9 @@ class TestRepostAccountingLedger(AccountsTestMixin, FrappeTestCase):
 		# Submit repost document
 		ral.save().submit()
 
+		# background jobs don't run on test cases. Manually triggering repost function.
+		start_repost(ral.name)
+
 		res = (
 			qb.from_(gl)
 			.select(gl.voucher_no, Sum(gl.debit).as_("debit"), Sum(gl.credit).as_("credit"))
@@ -167,6 +169,26 @@ class TestRepostAccountingLedger(AccountsTestMixin, FrappeTestCase):
 		pe = get_payment_entry(si.doctype, si.name)
 		pe.save().submit()
 
+		# without deletion flag set
+		ral = frappe.new_doc("Repost Accounting Ledger")
+		ral.company = self.company
+		ral.delete_cancelled_entries = False
+		ral.append("vouchers", {"voucher_type": si.doctype, "voucher_no": si.name})
+		ral.append("vouchers", {"voucher_type": pe.doctype, "voucher_no": pe.name})
+		ral.save()
+
+		# assert preview data is generated
+		preview = ral.generate_preview()
+		self.assertIsNotNone(preview)
+
+		ral.save().submit()
+
+		# background jobs don't run on test cases. Manually triggering repost function.
+		start_repost(ral.name)
+
+		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}))
+
 		# with deletion flag set
 		ral = frappe.new_doc("Repost Accounting Ledger")
 		ral.company = self.company
@@ -175,38 +197,6 @@ class TestRepostAccountingLedger(AccountsTestMixin, FrappeTestCase):
 		ral.append("vouchers", {"voucher_type": pe.doctype, "voucher_no": pe.name})
 		ral.save().submit()
 
+		start_repost(ral.name)
 		self.assertIsNone(frappe.db.exists("GL Entry", {"voucher_no": si.name, "is_cancelled": 1}))
 		self.assertIsNone(frappe.db.exists("GL Entry", {"voucher_no": pe.name, "is_cancelled": 1}))
-
-	def test_05_without_deletion_flag(self):
-		si = create_sales_invoice(
-			item=self.item,
-			company=self.company,
-			customer=self.customer,
-			debit_to=self.debit_to,
-			parent_cost_center=self.cost_center,
-			cost_center=self.cost_center,
-			rate=100,
-		)
-
-		pe = get_payment_entry(si.doctype, si.name)
-		pe.save().submit()
-
-		# without deletion flag set
-		ral = frappe.new_doc("Repost Accounting Ledger")
-		ral.company = self.company
-		ral.delete_cancelled_entries = False
-		ral.append("vouchers", {"voucher_type": si.doctype, "voucher_no": si.name})
-		ral.append("vouchers", {"voucher_type": pe.doctype, "voucher_no": pe.name})
-		ral.save().submit()
-
-		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 update_repost_settings():
-	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})
-		repost_settings.save()

erpnext/accounts/doctype/repost_accounting_ledger_settings/repost_accounting_ledger_settings.js

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

erpnext/accounts/doctype/repost_accounting_ledger_settings/repost_accounting_ledger_settings.json

@@ -1,46 +0,0 @@
-{
- "actions": [],
- "creation": "2023-11-07 09:57:20.619939",
- "doctype": "DocType",
- "engine": "InnoDB",
- "field_order": [
-  "allowed_types"
- ],
- "fields": [
-  {
-   "fieldname": "allowed_types",
-   "fieldtype": "Table",
-   "label": "Allowed Doctypes",
-   "options": "Repost Allowed Types"
-  }
- ],
- "in_create": 1,
- "issingle": 1,
- "links": [],
- "modified": "2023-11-07 14:24:13.321522",
- "modified_by": "Administrator",
- "module": "Accounts",
- "name": "Repost Accounting Ledger Settings",
- "owner": "Administrator",
- "permissions": [
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "print": 1,
-   "read": 1,
-   "role": "Administrator",
-   "share": 1,
-   "write": 1
-  },
-  {
-   "read": 1,
-   "role": "System Manager",
-   "select": 1
-  }
- ],
- "sort_field": "modified",
- "sort_order": "DESC",
- "states": [],
- "track_changes": 1
-}

erpnext/accounts/doctype/repost_accounting_ledger_settings/repost_accounting_ledger_settings.py

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

erpnext/accounts/doctype/repost_accounting_ledger_settings/test_repost_accounting_ledger_settings.py

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

erpnext/accounts/doctype/repost_allowed_types/repost_allowed_types.json

@@ -1,45 +0,0 @@
-{
- "actions": [],
- "allow_rename": 1,
- "creation": "2023-11-07 09:58:03.595382",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "document_type",
-  "column_break_sfzb",
-  "allowed"
- ],
- "fields": [
-  {
-   "fieldname": "document_type",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Doctype",
-   "options": "DocType"
-  },
-  {
-   "default": "0",
-   "fieldname": "allowed",
-   "fieldtype": "Check",
-   "in_list_view": 1,
-   "label": "Allowed"
-  },
-  {
-   "fieldname": "column_break_sfzb",
-   "fieldtype": "Column Break"
-  }
- ],
- "index_web_pages_for_search": 1,
- "istable": 1,
- "links": [],
- "modified": "2023-11-07 10:01:39.217861",
- "modified_by": "Administrator",
- "module": "Accounts",
- "name": "Repost Allowed Types",
- "owner": "Administrator",
- "permissions": [],
- "sort_field": "modified",
- "sort_order": "DESC",
- "states": []
-}

erpnext/accounts/doctype/repost_allowed_types/repost_allowed_types.py

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

erpnext/accounts/doctype/repost_payment_ledger/repost_payment_ledger.json

@@ -99,7 +99,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-09-26 14:21:35.719727",
+ "modified": "2022-11-08 07:38:40.079038",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Repost Payment Ledger",
@@ -155,6 +155,5 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
- "track_changes": 1
+ "states": []
 }

erpnext/accounts/doctype/repost_payment_ledger/repost_payment_ledger.py

@@ -43,7 +43,7 @@ def start_payment_ledger_repost(docname=None):
 			except Exception as e:
 				frappe.db.rollback()
 
-				traceback = frappe.get_traceback(with_context=True)
+				traceback = frappe.get_traceback()
 				if traceback:
 					message = "Traceback: <br>" + traceback
 					frappe.db.set_value(repost_doc.doctype, repost_doc.name, "repost_error_log", message)

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -11,15 +11,30 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 		super.setup(doc);
 	}
 	company() {
-		super.company();
 		erpnext.accounts.dimensions.update_dimension(this.frm, this.frm.doctype);
+
+		let me = this;
+		if (this.frm.doc.company) {
+			frappe.call({
+				method:
+					"erpnext.accounts.party.get_party_account",
+				args: {
+					party_type: 'Customer',
+					party: this.frm.doc.customer,
+					company: this.frm.doc.company
+				},
+				callback: (response) => {
+					if (response) me.frm.set_value("debit_to", response.message);
+				},
+			});
+		}
 	}
 	onload() {
 		var me = this;
 		super.onload();
 
 		this.frm.ignore_doctypes_on_cancel_all = ['POS Invoice', 'Timesheet', 'POS Invoice Merge Log',
-							  'POS Closing Entry', 'Journal Entry', 'Payment Entry', "Repost Payment Ledger", "Repost Accounting Ledger", "Unreconcile Payment", "Unreconcile Payment Entries", "Bank Transaction"];
+							  'POS Closing Entry', 'Journal Entry', 'Payment Entry', "Repost Payment Ledger", "Repost Accounting Ledger"];
 
 		if(!this.frm.doc.__islocal && !this.frm.doc.customer && this.frm.doc.debit_to) {
 			// show debit_to in print format
@@ -76,7 +91,8 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 
 		if(doc.update_stock) this.show_stock_ledger();
 
-		if (doc.docstatus == 1 && doc.outstanding_amount!=0) {
+		if (doc.docstatus == 1 && doc.outstanding_amount!=0
+			&& !(cint(doc.is_return) && doc.return_against)) {
 			this.frm.add_custom_button(
 				__('Payment'),
 				() => this.make_payment_entry(),
@@ -161,8 +177,6 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 				}, __('Create'));
 			}
 		}
-
-		erpnext.accounts.unreconcile_payment.add_unreconcile_btn(me.frm);
 	}
 
 	make_maintenance_schedule() {
@@ -540,6 +554,15 @@ cur_frm.fields_dict.write_off_cost_center.get_query = function(doc) {
 	}
 }
 
+// Income Account in Details Table
+// --------------------------------
+cur_frm.set_query("income_account", "items", function(doc) {
+	return{
+		query: "erpnext.controllers.queries.get_income_account",
+		filters: {'company': doc.company}
+	}
+});
+
 // Cost Center in Details Table
 // -----------------------------
 cur_frm.fields_dict["items"].grid.get_field("cost_center").get_query = function(doc) {
@@ -634,16 +657,6 @@ frappe.ui.form.on('Sales Invoice', {
 			};
 		});
 
-		frm.set_query("income_account", "items", function() {
-			return{
-				query: "erpnext.controllers.queries.get_income_account",
-				filters: {
-					'company': frm.doc.company,
-					"disabled": 0
-				}
-			}
-		});
-
 		frm.custom_make_buttons = {
 			'Delivery Note': 'Delivery',
 			'Sales Invoice': 'Return / Credit Note',
@@ -874,8 +887,8 @@ frappe.ui.form.on('Sales Invoice', {
 				frm.events.append_time_log(frm, timesheet, 1.0);
 			}
 		});
+		frm.refresh_field("timesheets");
 		frm.trigger("calculate_timesheet_totals");
-		frm.refresh();
 	},
 
 	async get_exchange_rate(frm, from_currency, to_currency) {

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -26,7 +26,6 @@
   "is_return",
   "return_against",
   "update_billed_amount_in_sales_order",
-  "update_billed_amount_in_delivery_note",
   "is_debit_note",
   "amended_from",
   "accounting_dimensions_section",
@@ -138,7 +137,6 @@
   "loyalty_amount",
   "column_break_77",
   "loyalty_program",
-  "dont_create_loyalty_points",
   "loyalty_redemption_account",
   "loyalty_redemption_cost_center",
   "contact_and_address_tab",
@@ -1040,7 +1038,8 @@
    "label": "Loyalty Program",
    "no_copy": 1,
    "options": "Loyalty Program",
-   "print_hide": 1
+   "print_hide": 1,
+   "read_only": 1
   },
   {
    "allow_on_submit": 1,
@@ -1613,8 +1612,7 @@
    "hide_seconds": 1,
    "label": "Inter Company Invoice Reference",
    "options": "Purchase Invoice",
-   "read_only": 1,
-   "search_index": 1
+   "read_only": 1
   },
   {
    "fieldname": "customer_group",
@@ -2146,21 +2144,6 @@
    "fieldname": "use_company_roundoff_cost_center",
    "fieldtype": "Check",
    "label": "Use Company default Cost Center for Round off"
-  },
-  {
-   "default": "1",
-   "depends_on": "eval: doc.is_return",
-   "fieldname": "update_billed_amount_in_delivery_note",
-   "fieldtype": "Check",
-   "label": "Update Billed Amount in Delivery Note"
-  },
-  {
-   "default": "0",
-   "depends_on": "loyalty_program",
-   "fieldname": "dont_create_loyalty_points",
-   "fieldtype": "Check",
-   "label": "Don't Create Loyalty Points",
-   "no_copy": 1
   }
  ],
  "icon": "fa fa-file-text",
@@ -2173,7 +2156,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2024-01-02 17:25:46.027523",
+ "modified": "2023-06-19 16:02:05.309332",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -11,14 +11,13 @@ from frappe.utils import add_days, cint, cstr, flt, formatdate, get_link_to_form
 
 import erpnext
 from erpnext.accounts.deferred_revenue import validate_service_stop_date
+from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
+	get_accounting_dimensions,
+)
 from erpnext.accounts.doctype.loyalty_program.loyalty_program import (
 	get_loyalty_program_details_with_points,
 	validate_loyalty_points,
 )
-from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger import (
-	validate_docs_for_deferred_accounting,
-	validate_docs_for_voucher_types,
-)
 from erpnext.accounts.doctype.tax_withholding_category.tax_withholding_category import (
 	get_party_tax_withholding_details,
 )
@@ -90,7 +89,7 @@ class SalesInvoice(SellingController):
 		super(SalesInvoice, self).validate()
 		self.validate_auto_set_posting_time()
 
-		if not (self.is_pos or self.is_debit_note):
+		if not self.is_pos:
 			self.so_dn_required()
 
 		self.set_tax_withholding()
@@ -177,13 +176,6 @@ class SalesInvoice(SellingController):
 		self.validate_account_for_change_amount()
 		self.validate_income_account()
 
-	def validate_for_repost(self):
-		self.validate_write_off_account()
-		self.validate_account_for_change_amount()
-		self.validate_income_account()
-		validate_docs_for_voucher_types(["Sales Invoice"])
-		validate_docs_for_deferred_accounting([self.name], [])
-
 	def validate_fixed_asset(self):
 		for d in self.get("items"):
 			if d.is_fixed_asset and d.meta.get_field("asset") and d.asset:
@@ -245,8 +237,7 @@ class SalesInvoice(SellingController):
 		self.calculate_taxes_and_totals()
 
 	def before_save(self):
-		self.set_account_for_mode_of_payment()
-		self.set_paid_amount()
+		set_account_for_mode_of_payment(self)
 
 	def on_submit(self):
 		self.validate_pos_paid_amount()
@@ -264,7 +255,6 @@ class SalesInvoice(SellingController):
 
 		self.update_status_updater_args()
 		self.update_prevdoc_status()
-
 		self.update_billing_status_in_dn()
 		self.clear_unallocated_mode_of_payments()
 
@@ -301,12 +291,7 @@ class SalesInvoice(SellingController):
 		update_linked_doc(self.doctype, self.name, self.inter_company_invoice_reference)
 
 		# create the loyalty point ledger entry if the customer is enrolled in any loyalty program
-		if (
-			not self.is_return
-			and not self.is_consolidated
-			and self.loyalty_program
-			and not self.dont_create_loyalty_points
-		):
+		if not self.is_return and not self.is_consolidated and self.loyalty_program:
 			self.make_loyalty_point_entry()
 		elif (
 			self.is_return and self.return_against and not self.is_consolidated and self.loyalty_program
@@ -416,8 +401,6 @@ class SalesInvoice(SellingController):
 			"Repost Payment Ledger Items",
 			"Repost Accounting Ledger",
 			"Repost Accounting Ledger Items",
-			"Unreconcile Payment",
-			"Unreconcile Payment Entries",
 			"Payment Ledger Entry",
 		)
 
@@ -539,24 +522,94 @@ class SalesInvoice(SellingController):
 			):
 				data.sales_invoice = sales_invoice
 
+	def on_update(self):
+		self.set_paid_amount()
+
 	def on_update_after_submit(self):
 		if hasattr(self, "repost_required"):
-			fields_to_check = [
-				"additional_discount_account",
-				"cash_bank_account",
-				"account_for_change_amount",
-				"write_off_account",
-				"loyalty_redemption_account",
-				"unrealized_profit_loss_account",
-			]
-			child_tables = {
-				"items": ("income_account", "expense_account", "discount_account"),
-				"taxes": ("account_head",),
-			}
-			self.needs_repost = self.check_if_fields_updated(fields_to_check, child_tables)
-			if self.needs_repost:
-				self.validate_for_repost()
-				self.db_set("repost_required", self.needs_repost)
+			needs_repost = 0
+
+			# Check if any field affecting accounting entry is altered
+			doc_before_update = self.get_doc_before_save()
+			accounting_dimensions = get_accounting_dimensions() + ["cost_center", "project"]
+
+			# Check if opening entry check updated
+			if doc_before_update.get("is_opening") != self.is_opening:
+				needs_repost = 1
+
+			if not needs_repost:
+				# Parent Level Accounts excluding party account
+				for field in (
+					"additional_discount_account",
+					"cash_bank_account",
+					"account_for_change_amount",
+					"write_off_account",
+					"loyalty_redemption_account",
+					"unrealized_profit_loss_account",
+				):
+					if doc_before_update.get(field) != self.get(field):
+						needs_repost = 1
+						break
+
+				# Check for parent accounting dimensions
+				for dimension in accounting_dimensions:
+					if doc_before_update.get(dimension) != self.get(dimension):
+						needs_repost = 1
+						break
+
+				# Check for child tables
+				if self.check_if_child_table_updated(
+					"items",
+					doc_before_update,
+					("income_account", "expense_account", "discount_account"),
+					accounting_dimensions,
+				):
+					needs_repost = 1
+
+				if self.check_if_child_table_updated(
+					"taxes", doc_before_update, ("account_head",), accounting_dimensions
+				):
+					needs_repost = 1
+
+			self.validate_accounts()
+
+			# validate if deferred revenue is enabled for any item
+			# Don't allow to update the invoice if deferred revenue is enabled
+			for item in self.get("items"):
+				if item.enable_deferred_revenue:
+					frappe.throw(
+						_(
+							"Deferred Revenue is enabled for item {0}. You cannot update the invoice after submission."
+						).format(item.item_code)
+					)
+
+			self.db_set("repost_required", needs_repost)
+
+	def check_if_child_table_updated(
+		self, child_table, doc_before_update, fields_to_check, accounting_dimensions
+	):
+		# Check if any field affecting accounting entry is altered
+		for index, item in enumerate(self.get(child_table)):
+			for field in fields_to_check:
+				if doc_before_update.get(child_table)[index].get(field) != item.get(field):
+					return True
+
+			for dimension in accounting_dimensions:
+				if doc_before_update.get(child_table)[index].get(dimension) != item.get(dimension):
+					return True
+
+		return False
+
+	@frappe.whitelist()
+	def repost_accounting_entries(self):
+		if self.repost_required:
+			self.docstatus = 2
+			self.make_gl_entries_on_cancel()
+			self.docstatus = 1
+			self.make_gl_entries()
+			self.db_set("repost_required", 0)
+		else:
+			frappe.throw(_("No updates pending for reposting"))
 
 	def set_paid_amount(self):
 		paid_amount = 0.0
@@ -569,11 +622,6 @@ class SalesInvoice(SellingController):
 		self.paid_amount = paid_amount
 		self.base_paid_amount = base_paid_amount
 
-	def set_account_for_mode_of_payment(self):
-		for payment in self.payments:
-			if not payment.account:
-				payment.account = get_bank_cash_account(payment.mode_of_payment, self.company).get("account")
-
 	def validate_time_sheets_are_submitted(self):
 		for data in self.timesheets:
 			if data.time_sheet:
@@ -1047,7 +1095,7 @@ class SalesInvoice(SellingController):
 
 	def make_customer_gl_entry(self, gl_entries):
 		# Checked both rounding_adjustment and rounded_total
-		# because rounded_total had value even before introduction of posting GLE based on rounded total
+		# because rounded_total had value even before introcution of posting GLE based on rounded total
 		grand_total = (
 			self.rounded_total if (self.rounding_adjustment and self.rounded_total) else self.grand_total
 		)
@@ -1072,7 +1120,9 @@ class SalesInvoice(SellingController):
 						"debit_in_account_currency": base_grand_total
 						if self.party_account_currency == self.company_currency
 						else grand_total,
-						"against_voucher": self.name,
+						"against_voucher": self.return_against
+						if cint(self.is_return) and self.return_against
+						else self.name,
 						"against_voucher_type": self.doctype,
 						"cost_center": self.cost_center,
 						"project": self.project,
@@ -1280,7 +1330,7 @@ class SalesInvoice(SellingController):
 				if skip_change_gl_entries and payment_mode.account == self.account_for_change_amount:
 					payment_mode.base_amount -= flt(self.change_amount)
 
-				if payment_mode.base_amount:
+				if payment_mode.amount:
 					# POS, make payment entries
 					gl_entries.append(
 						self.get_gl_dict(
@@ -1293,7 +1343,9 @@ class SalesInvoice(SellingController):
 								"credit_in_account_currency": payment_mode.base_amount
 								if self.party_account_currency == self.company_currency
 								else payment_mode.amount,
-								"against_voucher": self.name,
+								"against_voucher": self.return_against
+								if cint(self.is_return) and self.return_against
+								else self.name,
 								"against_voucher_type": self.doctype,
 								"cost_center": self.cost_center,
 							},
@@ -1440,8 +1492,6 @@ class SalesInvoice(SellingController):
 			)
 
 	def update_billing_status_in_dn(self, update_modified=True):
-		if self.is_return and not self.update_billed_amount_in_delivery_note:
-			return
 		updated_delivery_notes = []
 		for d in self.get("items"):
 			if d.dn_detail:
@@ -1697,8 +1747,12 @@ class SalesInvoice(SellingController):
 				elif outstanding_amount > 0 and getdate(self.due_date) >= getdate():
 					self.status = "Unpaid"
 				# Check if outstanding amount is 0 due to credit note issued against invoice
-				elif self.is_return == 0 and frappe.db.get_value(
-					"Sales Invoice", {"is_return": 1, "return_against": self.name, "docstatus": 1}
+				elif (
+					outstanding_amount <= 0
+					and self.is_return == 0
+					and frappe.db.get_value(
+						"Sales Invoice", {"is_return": 1, "return_against": self.name, "docstatus": 1}
+					)
 				):
 					self.status = "Credit Note Issued"
 				elif self.is_return == 1:
@@ -1934,6 +1988,7 @@ def make_delivery_note(source_name, target_doc=None):
 		set_missing_values,
 	)
 
+	doclist.set_onload("ignore_price_list", True)
 	return doclist
 
 
@@ -1944,6 +1999,12 @@ def make_sales_return(source_name, target_doc=None):
 	return make_return_doc("Sales Invoice", source_name, target_doc)
 
 
+def set_account_for_mode_of_payment(self):
+	for data in self.payments:
+		if not data.account:
+			data.account = get_bank_cash_account(data.mode_of_payment, self.company).get("account")
+
+
 def get_inter_company_details(doc, doctype):
 	if doctype in ["Sales Invoice", "Sales Order", "Delivery Note"]:
 		parties = frappe.db.get_all(
@@ -2189,18 +2250,9 @@ def make_inter_company_transaction(doctype, source_name, target_doc=None):
 
 
 def get_received_items(reference_name, doctype, reference_fieldname):
-	reference_field = "inter_company_invoice_reference"
-	if doctype == "Purchase Order":
-		reference_field = "inter_company_order_reference"
-
-	filters = {
-		reference_field: reference_name,
-		"docstatus": 1,
-	}
-
 	target_doctypes = frappe.get_all(
 		doctype,
-		filters=filters,
+		filters={"inter_company_invoice_reference": reference_name, "docstatus": 1},
 		as_list=True,
 	)
 
@@ -2382,6 +2434,10 @@ def get_loyalty_programs(customer):
 		return lp_details
 
 
+def on_doctype_update():
+	frappe.db.add_index("Sales Invoice", ["customer", "is_return", "return_against"])
+
+
 @frappe.whitelist()
 def create_invoice_discounting(source_name, target_doc=None):
 	invoice = frappe.get_doc("Sales Invoice", source_name)

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -7,7 +7,7 @@ import unittest
 import frappe
 from frappe.model.dynamic_links import get_dynamic_link_map
 from frappe.model.naming import make_autoname
-from frappe.tests.utils import FrappeTestCase, change_settings
+from frappe.tests.utils import change_settings
 from frappe.utils import add_days, flt, getdate, nowdate, today
 
 import erpnext
@@ -38,17 +38,13 @@ from erpnext.stock.doctype.stock_reconciliation.test_stock_reconciliation import
 from erpnext.stock.utils import get_incoming_rate, get_stock_balance
 
 
-class TestSalesInvoice(FrappeTestCase):
+class TestSalesInvoice(unittest.TestCase):
 	def setUp(self):
 		from erpnext.stock.doctype.stock_ledger_entry.test_stock_ledger_entry import create_items
 
 		create_items(["_Test Internal Transfer Item"], uoms=[{"uom": "Box", "conversion_factor": 10}])
 		create_internal_parties()
 		setup_accounts()
-		frappe.db.set_single_value("Accounts Settings", "acc_frozen_upto", None)
-
-	def tearDown(self):
-		frappe.db.rollback()
 
 	def make(self):
 		w = frappe.copy_doc(test_records[0])
@@ -176,7 +172,6 @@ class TestSalesInvoice(FrappeTestCase):
 		self.assertRaises(frappe.LinkExistsError, si.cancel)
 		unlink_payment_on_cancel_of_invoice()
 
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_payment_entry_unlink_against_standalone_credit_note(self):
 		from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
 
@@ -782,28 +777,6 @@ class TestSalesInvoice(FrappeTestCase):
 		w = self.make()
 		self.assertEqual(w.outstanding_amount, w.base_rounded_total)
 
-	def test_rounded_total_with_cash_discount(self):
-		si = frappe.copy_doc(test_records[2])
-
-		item = copy.deepcopy(si.get("items")[0])
-		item.update(
-			{
-				"qty": 1,
-				"rate": 14960.66,
-			}
-		)
-
-		si.set("items", [item])
-		si.set("taxes", [])
-		si.apply_discount_on = "Grand Total"
-		si.is_cash_or_non_trade_discount = 1
-		si.discount_amount = 1
-		si.insert()
-
-		self.assertEqual(si.grand_total, 14959.66)
-		self.assertEqual(si.rounded_total, 14960)
-		self.assertEqual(si.rounding_adjustment, 0.34)
-
 	def test_payment(self):
 		w = self.make()
 
@@ -1081,44 +1054,6 @@ class TestSalesInvoice(FrappeTestCase):
 		self.assertEqual(pos.grand_total, 100.0)
 		self.assertEqual(pos.write_off_amount, 10)
 
-	def test_ledger_entries_of_return_pos_invoice(self):
-		make_pos_profile()
-
-		pos = create_sales_invoice(do_not_save=True)
-		pos.is_pos = 1
-		pos.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
-		pos.save().submit()
-		self.assertEqual(pos.outstanding_amount, 0.0)
-		self.assertEqual(pos.status, "Paid")
-
-		from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_sales_return
-
-		pos_return = make_sales_return(pos.name)
-		pos_return.save().submit()
-		pos_return.reload()
-		pos.reload()
-		self.assertEqual(pos_return.is_return, 1)
-		self.assertEqual(pos_return.return_against, pos.name)
-		self.assertEqual(pos_return.outstanding_amount, 0.0)
-		self.assertEqual(pos_return.status, "Return")
-		self.assertEqual(pos.outstanding_amount, 0.0)
-		self.assertEqual(pos.status, "Credit Note Issued")
-
-		expected = (
-			("Cash - _TC", 0.0, 100.0, pos_return.name, None),
-			("Debtors - _TC", 0.0, 100.0, pos_return.name, pos_return.name),
-			("Debtors - _TC", 100.0, 0.0, pos_return.name, pos_return.name),
-			("Sales - _TC", 100.0, 0.0, pos_return.name, None),
-		)
-		res = frappe.db.get_all(
-			"GL Entry",
-			filters={"voucher_no": pos_return.name, "is_cancelled": 0},
-			fields=["account", "debit", "credit", "voucher_no", "against_voucher"],
-			order_by="account, debit, credit",
-			as_list=1,
-		)
-		self.assertEqual(expected, res)
-
 	def test_pos_with_no_gl_entry_for_change_amount(self):
 		frappe.db.set_value("Accounts Settings", None, "post_change_gl_entries", 0)
 
@@ -1358,7 +1293,6 @@ class TestSalesInvoice(FrappeTestCase):
 		dn.submit()
 		return dn
 
-	@change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_sales_invoice_with_advance(self):
 		from erpnext.accounts.doctype.journal_entry.test_journal_entry import (
 			test_records as jv_test_records,
@@ -1566,21 +1500,8 @@ class TestSalesInvoice(FrappeTestCase):
 		self.assertEqual(party_credited, 1000)
 
 		# Check outstanding amount
-		self.assertEqual(frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount"), -1000)
-		self.assertEqual(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"), 2500)
-
-	def test_return_invoice_with_account_mismatch(self):
-		debtors2 = create_account(
-			parent_account="Accounts Receivable - _TC",
-			account_name="Debtors 2",
-			company="_Test Company",
-			account_type="Receivable",
-		)
-		si = create_sales_invoice(qty=1, rate=1000)
-		cr_note = create_sales_invoice(
-			qty=-1, rate=1000, is_return=1, return_against=si.name, debit_to=debtors2, do_not_save=True
-		)
-		self.assertRaises(frappe.ValidationError, cr_note.save)
+		self.assertFalse(si1.outstanding_amount)
+		self.assertEqual(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"), 1500)
 
 	def test_gle_made_when_asset_is_returned(self):
 		create_asset_data()
@@ -1880,10 +1801,6 @@ class TestSalesInvoice(FrappeTestCase):
 		)
 
 	def test_outstanding_amount_after_advance_payment_entry_cancellation(self):
-		"""Test impact of advance PE submission/cancellation on SI and SO."""
-		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
-
-		sales_order = make_sales_order(item_code="138-CMS Shoe", qty=1, price_list_rate=500)
 		pe = frappe.get_doc(
 			{
 				"doctype": "Payment Entry",
@@ -1903,25 +1820,10 @@ class TestSalesInvoice(FrappeTestCase):
 				"paid_to": "_Test Cash - _TC",
 			}
 		)
-		pe.append(
-			"references",
-			{
-				"reference_doctype": "Sales Order",
-				"reference_name": sales_order.name,
-				"total_amount": sales_order.grand_total,
-				"outstanding_amount": sales_order.grand_total,
-				"allocated_amount": 300,
-			},
-		)
 		pe.insert()
 		pe.submit()
 
-		sales_order.reload()
-		self.assertEqual(sales_order.advance_paid, 300)
-
 		si = frappe.copy_doc(test_records[0])
-		si.items[0].sales_order = sales_order.name
-		si.items[0].so_detail = sales_order.get("items")[0].name
 		si.is_pos = 0
 		si.append(
 			"advances",
@@ -1929,7 +1831,6 @@ class TestSalesInvoice(FrappeTestCase):
 				"doctype": "Sales Invoice Advance",
 				"reference_type": "Payment Entry",
 				"reference_name": pe.name,
-				"reference_row": pe.references[0].name,
 				"advance_amount": 300,
 				"allocated_amount": 300,
 				"remarks": pe.remarks,
@@ -1938,13 +1839,7 @@ class TestSalesInvoice(FrappeTestCase):
 		si.insert()
 		si.submit()
 
-		si.reload()
-		pe.reload()
-		sales_order.reload()
-
-		# Check if SO is unlinked/replaced by SI in PE & if SO advance paid is 0
-		self.assertEqual(pe.references[0].reference_name, si.name)
-		self.assertEqual(sales_order.advance_paid, 0.0)
+		si.load_from_db()
 
 		# check outstanding after advance allocation
 		self.assertEqual(
@@ -1952,9 +1847,11 @@ class TestSalesInvoice(FrappeTestCase):
 			flt(si.rounded_total - si.total_advance, si.precision("outstanding_amount")),
 		)
 
+		# added to avoid Document has been modified exception
+		pe = frappe.get_doc("Payment Entry", pe.name)
 		pe.cancel()
-		si.reload()
 
+		si.load_from_db()
 		# check outstanding after advance cancellation
 		self.assertEqual(
 			flt(si.outstanding_amount),
@@ -2570,6 +2467,12 @@ class TestSalesInvoice(FrappeTestCase):
 			"stock_received_but_not_billed",
 			"Stock Received But Not Billed - _TC1",
 		)
+		frappe.db.set_value(
+			"Company",
+			"_Test Company 1",
+			"expenses_included_in_valuation",
+			"Expenses Included In Valuation - _TC1",
+		)
 
 		# begin test
 		si = create_sales_invoice(
@@ -2607,7 +2510,7 @@ class TestSalesInvoice(FrappeTestCase):
 
 		# tear down
 		frappe.local.enable_perpetual_inventory["_Test Company 1"] = old_perpetual_inventory
-		frappe.db.set_single_value("Stock Settings", "allow_negative_stock", old_negative_stock)
+		frappe.db.set_value("Stock Settings", None, "allow_negative_stock", old_negative_stock)
 
 	def test_sle_for_target_warehouse(self):
 		se = make_stock_entry(
@@ -2619,7 +2522,6 @@ class TestSalesInvoice(FrappeTestCase):
 		)
 
 		si = frappe.copy_doc(test_records[0])
-		si.customer = "_Test Internal Customer 3"
 		si.update_stock = 1
 		si.set_warehouse = "Finished Goods - _TC"
 		si.set_target_warehouse = "Stores - _TC"
@@ -2842,25 +2744,12 @@ class TestSalesInvoice(FrappeTestCase):
 	@change_settings("Selling Settings", {"enable_discount_accounting": 1})
 	def test_additional_discount_for_sales_invoice_with_discount_accounting_enabled(self):
 
-		from erpnext.accounts.doctype.repost_accounting_ledger.test_repost_accounting_ledger import (
-			update_repost_settings,
-		)
-
-		update_repost_settings()
-
 		additional_discount_account = create_account(
 			account_name="Discount Account",
 			parent_account="Indirect Expenses - _TC",
 			company="_Test Company",
 		)
 
-		tds_payable_account = create_account(
-			account_name="TDS Payable",
-			account_type="Tax",
-			parent_account="Duties and Taxes - _TC",
-			company="_Test Company",
-		)
-
 		si = create_sales_invoice(parent_cost_center="Main - _TC", do_not_save=1)
 		si.apply_discount_on = "Grand Total"
 		si.additional_discount_account = additional_discount_account
@@ -3159,8 +3048,8 @@ class TestSalesInvoice(FrappeTestCase):
 			si.commission_rate = commission_rate
 			self.assertRaises(frappe.ValidationError, si.save)
 
-	@change_settings("Accounts Settings", {"acc_frozen_upto": add_days(getdate(), 1)})
 	def test_sales_invoice_submission_post_account_freezing_date(self):
+		frappe.db.set_value("Accounts Settings", None, "acc_frozen_upto", add_days(getdate(), 1))
 		si = create_sales_invoice(do_not_save=True)
 		si.posting_date = add_days(getdate(), 1)
 		si.save()
@@ -3169,6 +3058,8 @@ class TestSalesInvoice(FrappeTestCase):
 		si.posting_date = getdate()
 		si.submit()
 
+		frappe.db.set_value("Accounts Settings", None, "acc_frozen_upto", None)
+
 	def test_over_billing_case_against_delivery_note(self):
 		"""
 		Test a case where duplicating the item with qty = 1 in the invoice
@@ -3197,13 +3088,6 @@ class TestSalesInvoice(FrappeTestCase):
 
 		frappe.db.set_value("Accounts Settings", None, "over_billing_allowance", over_billing_allowance)
 
-	@change_settings(
-		"Accounts Settings",
-		{
-			"book_deferred_entries_via_journal_entry": 1,
-			"submit_journal_entries": 1,
-		},
-	)
 	def test_multi_currency_deferred_revenue_via_journal_entry(self):
 		deferred_account = create_account(
 			account_name="Deferred Revenue",
@@ -3211,6 +3095,11 @@ class TestSalesInvoice(FrappeTestCase):
 			company="_Test Company",
 		)
 
+		acc_settings = frappe.get_single("Accounts Settings")
+		acc_settings.book_deferred_entries_via_journal_entry = 1
+		acc_settings.submit_journal_entries = 1
+		acc_settings.save()
+
 		item = create_item("_Test Item for Deferred Accounting")
 		item.enable_deferred_expense = 1
 		item.item_defaults[0].deferred_revenue_account = deferred_account
@@ -3276,6 +3165,13 @@ class TestSalesInvoice(FrappeTestCase):
 			self.assertEqual(expected_gle[i][2], gle.debit)
 			self.assertEqual(getdate(expected_gle[i][3]), gle.posting_date)
 
+		acc_settings = frappe.get_single("Accounts Settings")
+		acc_settings.book_deferred_entries_via_journal_entry = 0
+		acc_settings.submit_journal_entries = 0
+		acc_settings.save()
+
+		frappe.db.set_value("Accounts Settings", None, "acc_frozen_upto", None)
+
 	def test_standalone_serial_no_return(self):
 		si = create_sales_invoice(
 			item_code="_Test Serialized Item With Series", update_stock=True, is_return=True, qty=-1
@@ -3653,20 +3549,6 @@ def create_internal_parties():
 		allowed_to_interact_with="_Test Company with perpetual inventory",
 	)
 
-	create_internal_customer(
-		customer_name="_Test Internal Customer 3",
-		represents_company="_Test Company",
-		allowed_to_interact_with="_Test Company",
-	)
-
-	account = create_account(
-		account_name="Unrealized Profit",
-		parent_account="Current Liabilities - _TC",
-		company="_Test Company",
-	)
-
-	frappe.db.set_value("Company", "_Test Company", "unrealized_profit_loss_account", account)
-
 	create_internal_supplier(
 		supplier_name="_Test Internal Supplier",
 		represents_company="Wind Power LLC",

erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.json

@@ -167,7 +167,6 @@
    "print_hide": 1
   },
   {
-   "fetch_from": "item_code.image",
    "fieldname": "image",
    "fieldtype": "Attach",
    "hidden": 1,
@@ -892,7 +891,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-11-14 18:34:10.479329",
+ "modified": "2023-07-25 11:58:10.723833",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Item",
@@ -902,4 +901,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/sales_taxes_and_charges/sales_taxes_and_charges.json

@@ -108,7 +108,7 @@
    "fieldname": "rate",
    "fieldtype": "Float",
    "in_list_view": 1,
-   "label": "Tax Rate",
+   "label": "Rate",
    "oldfieldname": "rate",
    "oldfieldtype": "Currency"
   },
@@ -218,7 +218,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-01-14 10:08:17.776528",
+ "modified": "2022-10-17 13:08:17.776528",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Taxes and Charges",
@@ -227,4 +227,4 @@
  "sort_field": "modified",
  "sort_order": "ASC",
  "states": []
-}
+}

erpnext/accounts/doctype/subscription/subscription.js

@@ -18,14 +18,6 @@ frappe.ui.form.on('Subscription', {
 				}
 			};
 		});
-
-		frm.set_query('sales_tax_template', function () {
-			return {
-				filters: {
-					company: frm.doc.company
-				}
-			};
-		});
 	},
 
 	refresh: function(frm) {

erpnext/accounts/doctype/subscription/test_subscription.py

@@ -4,7 +4,6 @@
 import unittest
 
 import frappe
-from frappe.tests.utils import FrappeTestCase
 from frappe.utils.data import (
 	add_days,
 	add_months,
@@ -91,14 +90,10 @@ def create_parties():
 		customer.insert()
 
 
-class TestSubscription(FrappeTestCase):
+class TestSubscription(unittest.TestCase):
 	def setUp(self):
 		create_plan()
 		create_parties()
-		frappe.db.set_single_value("Accounts Settings", "acc_frozen_upto", None)
-
-	def tearDown(self):
-		frappe.db.rollback()
 
 	def test_create_subscription_with_trial_with_correct_period(self):
 		subscription = frappe.new_doc("Subscription")

erpnext/accounts/doctype/unreconcile_payment/test_unreconcile_payment.py

@@ -1,365 +0,0 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
-# See license.txt
-
-import frappe
-from frappe.tests.utils import FrappeTestCase
-from frappe.utils import today
-
-from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
-from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
-from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
-
-
-class TestUnreconcilePayment(AccountsTestMixin, FrappeTestCase):
-	def setUp(self):
-		self.create_company()
-		self.create_customer()
-		self.create_usd_receivable_account()
-		self.create_item()
-		self.clear_old_entries()
-
-	def tearDown(self):
-		frappe.db.rollback()
-
-	def create_sales_invoice(self, do_not_submit=False):
-		si = create_sales_invoice(
-			item=self.item,
-			company=self.company,
-			customer=self.customer,
-			debit_to=self.debit_to,
-			posting_date=today(),
-			parent_cost_center=self.cost_center,
-			cost_center=self.cost_center,
-			rate=100,
-			price_list_rate=100,
-			do_not_submit=do_not_submit,
-		)
-		return si
-
-	def create_payment_entry(self):
-		pe = create_payment_entry(
-			company=self.company,
-			payment_type="Receive",
-			party_type="Customer",
-			party=self.customer,
-			paid_from=self.debit_to,
-			paid_to=self.cash,
-			paid_amount=200,
-			save=True,
-		)
-		return pe
-
-	def create_sales_order(self):
-		so = make_sales_order(
-			company=self.company,
-			customer=self.customer,
-			item=self.item,
-			rate=100,
-			transaction_date=today(),
-		)
-		return so
-
-	def test_01_unreconcile_invoice(self):
-		si1 = self.create_sales_invoice()
-		si2 = self.create_sales_invoice()
-
-		pe = self.create_payment_entry()
-		pe.append(
-			"references",
-			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 100},
-		)
-		pe.append(
-			"references",
-			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 100},
-		)
-		# Allocation payment against both invoices
-		pe.save().submit()
-
-		# Assert outstanding
-		[doc.reload() for doc in [si1, si2, pe]]
-		self.assertEqual(si1.outstanding_amount, 0)
-		self.assertEqual(si2.outstanding_amount, 0)
-		self.assertEqual(pe.unallocated_amount, 0)
-
-		unreconcile = frappe.get_doc(
-			{
-				"doctype": "Unreconcile Payment",
-				"company": self.company,
-				"voucher_type": pe.doctype,
-				"voucher_no": pe.name,
-			}
-		)
-		unreconcile.add_references()
-		self.assertEqual(len(unreconcile.allocations), 2)
-		allocations = [x.reference_name for x in unreconcile.allocations]
-		self.assertEquals([si1.name, si2.name], allocations)
-		# unreconcile si1
-		for x in unreconcile.allocations:
-			if x.reference_name != si1.name:
-				unreconcile.remove(x)
-		unreconcile.save().submit()
-
-		# Assert outstanding
-		[doc.reload() for doc in [si1, si2, pe]]
-		self.assertEqual(si1.outstanding_amount, 100)
-		self.assertEqual(si2.outstanding_amount, 0)
-		self.assertEqual(len(pe.references), 1)
-		self.assertEqual(pe.unallocated_amount, 100)
-
-	def test_02_unreconcile_one_payment_from_multi_payments(self):
-		"""
-		Scenario: 2 payments, both split against 2 different invoices
-		Unreconcile only one payment from one invoice
-		"""
-		si1 = self.create_sales_invoice()
-		si2 = self.create_sales_invoice()
-		pe1 = self.create_payment_entry()
-		pe1.paid_amount = 100
-		# Allocate payment against both invoices
-		pe1.append(
-			"references",
-			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 50},
-		)
-		pe1.append(
-			"references",
-			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 50},
-		)
-		pe1.save().submit()
-
-		pe2 = self.create_payment_entry()
-		pe2.paid_amount = 100
-		# Allocate payment against both invoices
-		pe2.append(
-			"references",
-			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 50},
-		)
-		pe2.append(
-			"references",
-			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 50},
-		)
-		pe2.save().submit()
-
-		# Assert outstanding and unallocated
-		[doc.reload() for doc in [si1, si2, pe1, pe2]]
-		self.assertEqual(si1.outstanding_amount, 0.0)
-		self.assertEqual(si2.outstanding_amount, 0.0)
-		self.assertEqual(pe1.unallocated_amount, 0.0)
-		self.assertEqual(pe2.unallocated_amount, 0.0)
-
-		unreconcile = frappe.get_doc(
-			{
-				"doctype": "Unreconcile Payment",
-				"company": self.company,
-				"voucher_type": pe2.doctype,
-				"voucher_no": pe2.name,
-			}
-		)
-		unreconcile.add_references()
-		self.assertEqual(len(unreconcile.allocations), 2)
-		allocations = [x.reference_name for x in unreconcile.allocations]
-		self.assertEquals([si1.name, si2.name], allocations)
-		# unreconcile si1 from pe2
-		for x in unreconcile.allocations:
-			if x.reference_name != si1.name:
-				unreconcile.remove(x)
-		unreconcile.save().submit()
-
-		# Assert outstanding and unallocated
-		[doc.reload() for doc in [si1, si2, pe1, pe2]]
-		self.assertEqual(si1.outstanding_amount, 50)
-		self.assertEqual(si2.outstanding_amount, 0)
-		self.assertEqual(len(pe1.references), 2)
-		self.assertEqual(len(pe2.references), 1)
-		self.assertEqual(pe1.unallocated_amount, 0)
-		self.assertEqual(pe2.unallocated_amount, 50)
-
-	def test_03_unreconciliation_on_multi_currency_invoice(self):
-		self.create_customer("_Test MC Customer USD", "USD")
-		si1 = self.create_sales_invoice(do_not_submit=True)
-		si1.currency = "USD"
-		si1.debit_to = self.debtors_usd
-		si1.conversion_rate = 80
-		si1.save().submit()
-
-		si2 = self.create_sales_invoice(do_not_submit=True)
-		si2.currency = "USD"
-		si2.debit_to = self.debtors_usd
-		si2.conversion_rate = 80
-		si2.save().submit()
-
-		pe = self.create_payment_entry()
-		pe.paid_from = self.debtors_usd
-		pe.paid_from_account_currency = "USD"
-		pe.source_exchange_rate = 75
-		pe.received_amount = 75 * 200
-		pe.save()
-		# Allocate payment against both invoices
-		pe.append(
-			"references",
-			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 100},
-		)
-		pe.append(
-			"references",
-			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 100},
-		)
-		pe.save().submit()
-
-		unreconcile = frappe.get_doc(
-			{
-				"doctype": "Unreconcile Payment",
-				"company": self.company,
-				"voucher_type": pe.doctype,
-				"voucher_no": pe.name,
-			}
-		)
-		unreconcile.add_references()
-		self.assertEqual(len(unreconcile.allocations), 2)
-		allocations = [x.reference_name for x in unreconcile.allocations]
-		self.assertEquals([si1.name, si2.name], allocations)
-		# unreconcile si1 from pe
-		for x in unreconcile.allocations:
-			if x.reference_name != si1.name:
-				unreconcile.remove(x)
-		unreconcile.save().submit()
-
-		# Assert outstanding and unallocated
-		[doc.reload() for doc in [si1, si2, pe]]
-		self.assertEqual(si1.outstanding_amount, 100)
-		self.assertEqual(si2.outstanding_amount, 0)
-		self.assertEqual(len(pe.references), 1)
-		self.assertEqual(pe.unallocated_amount, 100)
-
-		# Exc gain/loss JE should've been cancelled as well
-		self.assertEqual(
-			frappe.db.count(
-				"Journal Entry Account",
-				filters={"reference_type": si1.doctype, "reference_name": si1.name, "docstatus": 1},
-			),
-			0,
-		)
-
-	def test_04_unreconciliation_on_multi_currency_invoice(self):
-		"""
-		2 payments split against 2 foreign currency invoices
-		"""
-		self.create_customer("_Test MC Customer USD", "USD")
-		si1 = self.create_sales_invoice(do_not_submit=True)
-		si1.currency = "USD"
-		si1.debit_to = self.debtors_usd
-		si1.conversion_rate = 80
-		si1.save().submit()
-
-		si2 = self.create_sales_invoice(do_not_submit=True)
-		si2.currency = "USD"
-		si2.debit_to = self.debtors_usd
-		si2.conversion_rate = 80
-		si2.save().submit()
-
-		pe1 = self.create_payment_entry()
-		pe1.paid_from = self.debtors_usd
-		pe1.paid_from_account_currency = "USD"
-		pe1.source_exchange_rate = 75
-		pe1.received_amount = 75 * 100
-		pe1.save()
-		# Allocate payment against both invoices
-		pe1.append(
-			"references",
-			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 50},
-		)
-		pe1.append(
-			"references",
-			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 50},
-		)
-		pe1.save().submit()
-
-		pe2 = self.create_payment_entry()
-		pe2.paid_from = self.debtors_usd
-		pe2.paid_from_account_currency = "USD"
-		pe2.source_exchange_rate = 75
-		pe2.received_amount = 75 * 100
-		pe2.save()
-		# Allocate payment against both invoices
-		pe2.append(
-			"references",
-			{"reference_doctype": si1.doctype, "reference_name": si1.name, "allocated_amount": 50},
-		)
-		pe2.append(
-			"references",
-			{"reference_doctype": si2.doctype, "reference_name": si2.name, "allocated_amount": 50},
-		)
-		pe2.save().submit()
-
-		unreconcile = frappe.get_doc(
-			{
-				"doctype": "Unreconcile Payment",
-				"company": self.company,
-				"voucher_type": pe2.doctype,
-				"voucher_no": pe2.name,
-			}
-		)
-		unreconcile.add_references()
-		self.assertEqual(len(unreconcile.allocations), 2)
-		allocations = [x.reference_name for x in unreconcile.allocations]
-		self.assertEquals([si1.name, si2.name], allocations)
-		# unreconcile si1 from pe2
-		for x in unreconcile.allocations:
-			if x.reference_name != si1.name:
-				unreconcile.remove(x)
-		unreconcile.save().submit()
-
-		# Assert outstanding and unallocated
-		[doc.reload() for doc in [si1, si2, pe1, pe2]]
-		self.assertEqual(si1.outstanding_amount, 50)
-		self.assertEqual(si2.outstanding_amount, 0)
-		self.assertEqual(len(pe1.references), 2)
-		self.assertEqual(len(pe2.references), 1)
-		self.assertEqual(pe1.unallocated_amount, 0)
-		self.assertEqual(pe2.unallocated_amount, 50)
-
-		# Exc gain/loss JE from PE1 should be available
-		self.assertEqual(
-			frappe.db.count(
-				"Journal Entry Account",
-				filters={"reference_type": si1.doctype, "reference_name": si1.name, "docstatus": 1},
-			),
-			1,
-		)
-
-	def test_05_unreconcile_order(self):
-		so = self.create_sales_order()
-
-		pe = self.create_payment_entry()
-		# Allocation payment against Sales Order
-		pe.paid_amount = 100
-		pe.append(
-			"references",
-			{"reference_doctype": so.doctype, "reference_name": so.name, "allocated_amount": 100},
-		)
-		pe.save().submit()
-
-		# Assert 'Advance Paid'
-		so.reload()
-		self.assertEqual(so.advance_paid, 100)
-
-		unreconcile = frappe.get_doc(
-			{
-				"doctype": "Unreconcile Payment",
-				"company": self.company,
-				"voucher_type": pe.doctype,
-				"voucher_no": pe.name,
-			}
-		)
-		unreconcile.add_references()
-		self.assertEqual(len(unreconcile.allocations), 1)
-		allocations = [x.reference_name for x in unreconcile.allocations]
-		self.assertEquals([so.name], allocations)
-		# unreconcile so
-		unreconcile.save().submit()
-
-		# Assert 'Advance Paid'
-		so.reload()
-		pe.reload()
-		self.assertEqual(so.advance_paid, 0)
-		self.assertEqual(len(pe.references), 0)
-		self.assertEqual(pe.unallocated_amount, 100)

erpnext/accounts/doctype/unreconcile_payment/unreconcile_payment.js

@@ -1,41 +0,0 @@
-// Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
-// For license information, please see license.txt
-
-frappe.ui.form.on("Unreconcile Payment", {
-	refresh(frm) {
-		frm.set_query("voucher_type", function() {
-			return {
-				filters: {
-					name: ["in", ["Payment Entry", "Journal Entry"]]
-				}
-			}
-		});
-
-
-		frm.set_query("voucher_no", function(doc) {
-			return {
-				filters: {
-					company: doc.company,
-					docstatus: 1
-				}
-			}
-		});
-
-	},
-	get_allocations: function(frm) {
-		frm.clear_table("allocations");
-		frappe.call({
-			method: "get_allocations_from_payment",
-			doc: frm.doc,
-			callback: function(r) {
-				if (r.message) {
-					r.message.forEach(x => {
-						frm.add_child("allocations", x)
-					})
-					frm.refresh_fields();
-				}
-			}
-		})
-
-	}
-});

erpnext/accounts/doctype/unreconcile_payment/unreconcile_payment.json

@@ -1,93 +0,0 @@
-{
- "actions": [],
- "allow_rename": 1,
- "autoname": "format:UNREC-{#####}",
- "creation": "2023-08-22 10:26:34.421423",
- "default_view": "List",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "company",
-  "voucher_type",
-  "voucher_no",
-  "get_allocations",
-  "allocations",
-  "amended_from"
- ],
- "fields": [
-  {
-   "fieldname": "amended_from",
-   "fieldtype": "Link",
-   "label": "Amended From",
-   "no_copy": 1,
-   "options": "Unreconcile Payment",
-   "print_hide": 1,
-   "read_only": 1
-  },
-  {
-   "fieldname": "company",
-   "fieldtype": "Link",
-   "label": "Company",
-   "options": "Company"
-  },
-  {
-   "fieldname": "voucher_type",
-   "fieldtype": "Link",
-   "label": "Voucher Type",
-   "options": "DocType"
-  },
-  {
-   "fieldname": "voucher_no",
-   "fieldtype": "Dynamic Link",
-   "label": "Voucher No",
-   "options": "voucher_type"
-  },
-  {
-   "fieldname": "get_allocations",
-   "fieldtype": "Button",
-   "label": "Get Allocations"
-  },
-  {
-   "fieldname": "allocations",
-   "fieldtype": "Table",
-   "label": "Allocations",
-   "options": "Unreconcile Payment Entries"
-  }
- ],
- "index_web_pages_for_search": 1,
- "is_submittable": 1,
- "links": [],
- "modified": "2023-08-28 17:42:50.261377",
- "modified_by": "Administrator",
- "module": "Accounts",
- "name": "Unreconcile Payment",
- "naming_rule": "Expression",
- "owner": "Administrator",
- "permissions": [
-  {
-   "create": 1,
-   "delete": 1,
-   "read": 1,
-   "role": "Accounts Manager",
-   "select": 1,
-   "share": 1,
-   "submit": 1,
-   "write": 1
-  },
-  {
-   "create": 1,
-   "delete": 1,
-   "read": 1,
-   "role": "Accounts User",
-   "select": 1,
-   "share": 1,
-   "submit": 1,
-   "write": 1
-  }
- ],
- "sort_field": "modified",
- "sort_order": "DESC",
- "states": [],
- "track_changes": 1
-}

erpnext/accounts/doctype/unreconcile_payment/unreconcile_payment.py

@@ -1,161 +0,0 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
-# For license information, please see license.txt
-
-import frappe
-from frappe import _, qb
-from frappe.model.document import Document
-from frappe.query_builder import Criterion
-from frappe.query_builder.functions import Abs, Sum
-from frappe.utils.data import comma_and
-
-from erpnext.accounts.utils import (
-	cancel_exchange_gain_loss_journal,
-	unlink_ref_doc_from_payment_entries,
-	update_voucher_outstanding,
-)
-
-
-class UnreconcilePayment(Document):
-	def validate(self):
-		self.supported_types = ["Payment Entry", "Journal Entry"]
-		if not self.voucher_type in self.supported_types:
-			frappe.throw(_("Only {0} are supported").format(comma_and(self.supported_types)))
-
-	@frappe.whitelist()
-	def get_allocations_from_payment(self):
-		allocated_references = []
-		ple = qb.DocType("Payment Ledger Entry")
-		allocated_references = (
-			qb.from_(ple)
-			.select(
-				ple.account,
-				ple.party_type,
-				ple.party,
-				ple.against_voucher_type.as_("reference_doctype"),
-				ple.against_voucher_no.as_("reference_name"),
-				Abs(Sum(ple.amount_in_account_currency)).as_("allocated_amount"),
-				ple.account_currency,
-			)
-			.where(
-				(ple.docstatus == 1)
-				& (ple.voucher_type == self.voucher_type)
-				& (ple.voucher_no == self.voucher_no)
-				& (ple.voucher_no != ple.against_voucher_no)
-			)
-			.groupby(ple.against_voucher_type, ple.against_voucher_no)
-			.run(as_dict=True)
-		)
-
-		return allocated_references
-
-	def add_references(self):
-		allocations = self.get_allocations_from_payment()
-
-		for alloc in allocations:
-			self.append("allocations", alloc)
-
-	def on_submit(self):
-		# todo: more granular unreconciliation
-		for alloc in self.allocations:
-			doc = frappe.get_doc(alloc.reference_doctype, alloc.reference_name)
-			unlink_ref_doc_from_payment_entries(doc, self.voucher_no)
-			cancel_exchange_gain_loss_journal(doc, self.voucher_type, self.voucher_no)
-			update_voucher_outstanding(
-				alloc.reference_doctype, alloc.reference_name, alloc.account, alloc.party_type, alloc.party
-			)
-			if doc.doctype in frappe.get_hooks("advance_payment_doctypes"):
-				doc.set_total_advance_paid()
-
-			frappe.db.set_value("Unreconcile Payment Entries", alloc.name, "unlinked", True)
-
-
-@frappe.whitelist()
-def doc_has_references(doctype: str = None, docname: str = None):
-	if doctype in ["Sales Invoice", "Purchase Invoice"]:
-		return frappe.db.count(
-			"Payment Ledger Entry",
-			filters={"delinked": 0, "against_voucher_no": docname, "amount": ["<", 0]},
-		)
-	else:
-		return frappe.db.count(
-			"Payment Ledger Entry",
-			filters={"delinked": 0, "voucher_no": docname, "against_voucher_no": ["!=", docname]},
-		)
-
-
-@frappe.whitelist()
-def get_linked_payments_for_doc(
-	company: str = None, doctype: str = None, docname: str = None
-) -> list:
-	if company and doctype and docname:
-		_dt = doctype
-		_dn = docname
-		ple = qb.DocType("Payment Ledger Entry")
-		if _dt in ["Sales Invoice", "Purchase Invoice"]:
-			criteria = [
-				(ple.company == company),
-				(ple.delinked == 0),
-				(ple.against_voucher_no == _dn),
-				(ple.amount < 0),
-			]
-
-			res = (
-				qb.from_(ple)
-				.select(
-					ple.company,
-					ple.voucher_type,
-					ple.voucher_no,
-					Abs(Sum(ple.amount_in_account_currency)).as_("allocated_amount"),
-					ple.account_currency,
-				)
-				.where(Criterion.all(criteria))
-				.groupby(ple.voucher_no, ple.against_voucher_no)
-				.having(qb.Field("allocated_amount") > 0)
-				.run(as_dict=True)
-			)
-			return res
-		else:
-			criteria = [
-				(ple.company == company),
-				(ple.delinked == 0),
-				(ple.voucher_no == _dn),
-				(ple.against_voucher_no != _dn),
-			]
-
-			query = (
-				qb.from_(ple)
-				.select(
-					ple.company,
-					ple.against_voucher_type.as_("voucher_type"),
-					ple.against_voucher_no.as_("voucher_no"),
-					Abs(Sum(ple.amount_in_account_currency)).as_("allocated_amount"),
-					ple.account_currency,
-				)
-				.where(Criterion.all(criteria))
-				.groupby(ple.against_voucher_no)
-			)
-			res = query.run(as_dict=True)
-			return res
-	return []
-
-
-@frappe.whitelist()
-def create_unreconcile_doc_for_selection(selections=None):
-	if selections:
-		selections = frappe.json.loads(selections)
-		# assuming each row is a unique voucher
-		for row in selections:
-			unrecon = frappe.new_doc("Unreconcile Payment")
-			unrecon.company = row.get("company")
-			unrecon.voucher_type = row.get("voucher_type")
-			unrecon.voucher_no = row.get("voucher_no")
-			unrecon.add_references()
-
-			# remove unselected references
-			unrecon.allocations = [
-				x
-				for x in unrecon.allocations
-				if x.reference_doctype == row.get("against_voucher_type")
-				and x.reference_name == row.get("against_voucher_no")
-			]
-			unrecon.save().submit()

erpnext/accounts/doctype/unreconcile_payment_entries/unreconcile_payment_entries.json

@@ -1,83 +0,0 @@
-{
- "actions": [],
- "allow_rename": 1,
- "creation": "2023-08-22 10:28:10.196712",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "account",
-  "party_type",
-  "party",
-  "reference_doctype",
-  "reference_name",
-  "allocated_amount",
-  "account_currency",
-  "unlinked"
- ],
- "fields": [
-  {
-   "fieldname": "reference_name",
-   "fieldtype": "Dynamic Link",
-   "in_list_view": 1,
-   "label": "Reference Name",
-   "options": "reference_doctype"
-  },
-  {
-   "fieldname": "allocated_amount",
-   "fieldtype": "Currency",
-   "in_list_view": 1,
-   "label": "Allocated Amount",
-   "options": "account_currency"
-  },
-  {
-   "default": "0",
-   "fieldname": "unlinked",
-   "fieldtype": "Check",
-   "in_list_view": 1,
-   "label": "Unlinked",
-   "read_only": 1
-  },
-  {
-   "fieldname": "reference_doctype",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Reference Type",
-   "options": "DocType"
-  },
-  {
-   "fieldname": "account",
-   "fieldtype": "Data",
-   "label": "Account"
-  },
-  {
-   "fieldname": "party_type",
-   "fieldtype": "Data",
-   "label": "Party Type"
-  },
-  {
-   "fieldname": "party",
-   "fieldtype": "Data",
-   "label": "Party"
-  },
-  {
-   "fieldname": "account_currency",
-   "fieldtype": "Link",
-   "label": "Account Currency",
-   "options": "Currency",
-   "read_only": 1
-  }
- ],
- "index_web_pages_for_search": 1,
- "istable": 1,
- "links": [],
- "modified": "2023-09-05 09:33:28.620149",
- "modified_by": "Administrator",
- "module": "Accounts",
- "name": "Unreconcile Payment Entries",
- "owner": "Administrator",
- "permissions": [],
- "sort_field": "modified",
- "sort_order": "DESC",
- "states": []
-}