chore(release): Bumped to Version 14.71.0

# [14.71.0](https://github.com/frappe/erpnext/compare/v14.70.14...v14.71.0) (2024-08-07)

### Bug Fixes

* 'undefined' in PL and BS report summary on Consolidated report ([a5e1432](a5e14324da))
* company filter for filtring tax withheld vouchers ([b7731c8](b7731c8fd7))
* do not update item price and last purchase rate for inter transf… (backport [#42616](https://github.com/frappe/erpnext/issues/42616)) ([#42632](https://github.com/frappe/erpnext/issues/42632)) ([5c5349e](5c5349ed16))
* filter condition in item-wise purchase register ([bc9b461](bc9b46126b))
* fixed depreciation calculation as per income tax act ([8df1079](8df1079618))
* item_code filter in item-wise sales register ([f0f8a2f](f0f8a2f01b))
* min height for rows in sales funnel ([7086a96](7086a96462))
* set query filters for sales / purchase tax template on PE ([c8d8536](c8d85364b9))
* slowness in reposting dependent vouchers. (backport [#42282](https://github.com/frappe/erpnext/issues/42282)) ([#42569](https://github.com/frappe/erpnext/issues/42569)) ([3fb6f97](3fb6f97f66))

### Features

* expiry date column in Available Batch Report (backport [#42628](https://github.com/frappe/erpnext/issues/42628)) ([#42641](https://github.com/frappe/erpnext/issues/42641)) ([83928bb](83928bbf78))

erpnext/__init__.py

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

erpnext/accounts/deferred_revenue.py

@@ -58,7 +58,7 @@ def build_conditions(process_type, account, company):
 	)
 
 	if account:
-		conditions += f"AND {deferred_account}={frappe.db.escape(account)}"
+		conditions += f"AND {deferred_account}='{account}'"
 	elif company:
 		conditions += f"AND p.company = {frappe.db.escape(company)}"
 
@@ -360,45 +360,45 @@ def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 			)
 
 		if not amount:
-			prev_posting_date = end_date
-		else:
-			gl_posting_date = end_date
-			prev_posting_date = None
-			# check if books nor frozen till endate:
-			if accounts_frozen_upto and getdate(end_date) <= getdate(accounts_frozen_upto):
-				gl_posting_date = get_last_day(add_days(accounts_frozen_upto, 1))
-				prev_posting_date = end_date
+			return
 
-			if via_journal_entry:
-				book_revenue_via_journal_entry(
-					doc,
-					credit_account,
-					debit_account,
-					amount,
-					base_amount,
-					gl_posting_date,
-					project,
-					account_currency,
-					item.cost_center,
-					item,
-					deferred_process,
-					submit_journal_entry,
-				)
-			else:
-				make_gl_entries(
-					doc,
-					credit_account,
-					debit_account,
-					against,
-					amount,
-					base_amount,
-					gl_posting_date,
-					project,
-					account_currency,
-					item.cost_center,
-					item,
-					deferred_process,
-				)
+		gl_posting_date = end_date
+		prev_posting_date = None
+		# check if books nor frozen till endate:
+		if accounts_frozen_upto and getdate(end_date) <= getdate(accounts_frozen_upto):
+			gl_posting_date = get_last_day(add_days(accounts_frozen_upto, 1))
+			prev_posting_date = end_date
+
+		if via_journal_entry:
+			book_revenue_via_journal_entry(
+				doc,
+				credit_account,
+				debit_account,
+				amount,
+				base_amount,
+				gl_posting_date,
+				project,
+				account_currency,
+				item.cost_center,
+				item,
+				deferred_process,
+				submit_journal_entry,
+			)
+		else:
+			make_gl_entries(
+				doc,
+				credit_account,
+				debit_account,
+				against,
+				amount,
+				base_amount,
+				gl_posting_date,
+				project,
+				account_currency,
+				item.cost_center,
+				item,
+				deferred_process,
+			)
 
 		# Returned in case of any errors because it tries to submit the same record again and again in case of errors
 		if frappe.flags.deferred_accounting_error:

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -469,7 +469,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2024-01-22 12:10:10.151819",
+ "modified": "2023-11-20 09:37:47.650347",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/bank_account/bank_account.json

@@ -208,49 +208,8 @@
    "label": "Disabled"
   }
  ],
- "links": [
-  {
-   "group": "Transactions",
-   "link_doctype": "Payment Request",
-   "link_fieldname": "bank_account"
-  },
-  {
-   "group": "Transactions",
-   "link_doctype": "Payment Order",
-   "link_fieldname": "bank_account"
-  },
-  {
-   "group": "Transactions",
-   "link_doctype": "Bank Guarantee",
-   "link_fieldname": "bank_account"
-  },
-  {
-   "group": "Transactions",
-   "link_doctype": "Bank Transaction",
-   "link_fieldname": "bank_account"
-  },
-  {
-   "group": "Accounting",
-   "link_doctype": "Payment Entry",
-   "link_fieldname": "bank_account"
-  },
-  {
-   "group": "Accounting",
-   "link_doctype": "Journal Entry",
-   "link_fieldname": "bank_account"
-  },
-  {
-   "group": "Party",
-   "link_doctype": "Customer",
-   "link_fieldname": "default_bank_account"
-  },
-  {
-   "group": "Party",
-   "link_doctype": "Supplier",
-   "link_fieldname": "default_bank_account"
-  }
- ],
- "modified": "2024-10-30 09:41:14.113414",
+ "links": [],
+ "modified": "2024-02-02 17:50:09.768835",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account",
@@ -287,4 +246,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/bank_account/bank_account_dashboard.py

@@ -0,0 +1,20 @@
+from frappe import _
+
+
+def get_data():
+	return {
+		"fieldname": "bank_account",
+		"non_standard_fieldnames": {
+			"Customer": "default_bank_account",
+			"Supplier": "default_bank_account",
+		},
+		"transactions": [
+			{
+				"label": _("Payments"),
+				"items": ["Payment Entry", "Payment Request", "Payment Order", "Payroll Entry"],
+			},
+			{"label": _("Party"), "items": ["Customer", "Supplier"]},
+			{"items": ["Bank Guarantee"]},
+			{"items": ["Journal Entry"]},
+		],
+	}

erpnext/accounts/doctype/bank_clearance/bank_clearance.js

@@ -36,12 +36,8 @@ frappe.ui.form.on("Bank Clearance", {
 	refresh: function (frm) {
 		frm.disable_save();
 		frm.add_custom_button(__("Get Payment Entries"), () => frm.trigger("get_payment_entries"));
-		frm.change_custom_button_type(__("Get Payment Entries"), null, "primary");
-		if (frm.doc.payment_entries.length) {
-			frm.add_custom_button(__("Update Clearance Date"), () => frm.trigger("update_clearance_date"));
-			frm.change_custom_button_type(__("Get Payment Entries"), null, "default");
-			frm.change_custom_button_type(__("Update Clearance Date"), null, "primary");
-		}
+
+		frm.change_custom_button_type("Get Payment Entries", null, "primary");
 	},
 
 	update_clearance_date: function (frm) {
@@ -49,7 +45,13 @@ frappe.ui.form.on("Bank Clearance", {
 			method: "update_clearance_date",
 			doc: frm.doc,
 			callback: function (r, rt) {
-				frm.refresh();
+				frm.refresh_field("payment_entries");
+				frm.refresh_fields();
+
+				if (!frm.doc.payment_entries.length) {
+					frm.change_custom_button_type("Get Payment Entries", null, "primary");
+					frm.change_custom_button_type("Update Clearance Date", null, "default");
+				}
 			},
 		});
 	},
@@ -58,8 +60,17 @@ frappe.ui.form.on("Bank Clearance", {
 		return frappe.call({
 			method: "get_payment_entries",
 			doc: frm.doc,
-			callback: function () {
-				frm.refresh();
+			callback: function (r, rt) {
+				frm.refresh_field("payment_entries");
+
+				if (frm.doc.payment_entries.length) {
+					frm.add_custom_button(__("Update Clearance Date"), () =>
+						frm.trigger("update_clearance_date")
+					);
+
+					frm.change_custom_button_type("Get Payment Entries", null, "default");
+					frm.change_custom_button_type("Update Clearance Date", null, "primary");
+				}
 			},
 		});
 	},

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -6,7 +6,7 @@ import frappe
 from frappe import _, msgprint
 from frappe.model.document import Document
 from frappe.query_builder.custom import ConstantColumn
-from frappe.utils import flt, fmt_money, get_link_to_form, getdate
+from frappe.utils import flt, fmt_money, getdate
 
 import erpnext
 
@@ -55,7 +55,7 @@ class BankClearance(Document):
 				"Payment Entry" as payment_document, name as payment_entry,
 				reference_no as cheque_number, reference_date as cheque_date,
 				if(paid_from=%(account)s, paid_amount + total_taxes_and_charges, 0) as credit,
-				if(paid_from=%(account)s, 0, received_amount + total_taxes_and_charges) as debit,
+				if(paid_from=%(account)s, 0, received_amount) as debit,
 				posting_date, ifnull(party,if(paid_from=%(account)s,paid_to,paid_from)) as against_account, clearance_date,
 				if(paid_to=%(account)s, paid_to_account_currency, paid_from_account_currency) as account_currency
 			from `tabPayment Entry`
@@ -210,11 +210,8 @@ class BankClearance(Document):
 
 				if d.cheque_date and getdate(d.clearance_date) < getdate(d.cheque_date):
 					frappe.throw(
-						_("Row #{0}: For {1} Clearance date {2} cannot be before Cheque Date {3}").format(
-							d.idx,
-							get_link_to_form(d.payment_document, d.payment_entry),
-							d.clearance_date,
-							d.cheque_date,
+						_("Row #{0}: Clearance date {1} cannot be before Cheque Date {2}").format(
+							d.idx, d.clearance_date, d.cheque_date
 						)
 					)
 

erpnext/accounts/doctype/cost_center_allocation/test_cost_center_allocation.py

@@ -22,10 +22,8 @@ class TestCostCenterAllocation(unittest.TestCase):
 		cost_centers = [
 			"Main Cost Center 1",
 			"Main Cost Center 2",
-			"Main Cost Center 3",
 			"Sub Cost Center 1",
 			"Sub Cost Center 2",
-			"Sub Cost Center 3",
 		]
 		for cc in cost_centers:
 			create_cost_center(cost_center_name=cc, company="_Test Company")
@@ -38,7 +36,7 @@ class TestCostCenterAllocation(unittest.TestCase):
 		)
 
 		jv = make_journal_entry(
-			"Cash - _TC", "Sales - _TC", 100, cost_center="Main Cost Center 1 - _TC", submit=True
+			"_Test Cash - _TC", "Sales - _TC", 100, cost_center="Main Cost Center 1 - _TC", submit=True
 		)
 
 		expected_values = [["Sub Cost Center 1 - _TC", 0.0, 60], ["Sub Cost Center 2 - _TC", 0.0, 40]]
@@ -122,7 +120,7 @@ class TestCostCenterAllocation(unittest.TestCase):
 	def test_valid_from_based_on_existing_gle(self):
 		# GLE posted against Sub Cost Center 1 on today
 		jv = make_journal_entry(
-			"Cash - _TC",
+			"_Test Cash - _TC",
 			"Sales - _TC",
 			100,
 			cost_center="Main Cost Center 1 - _TC",
@@ -143,53 +141,6 @@ class TestCostCenterAllocation(unittest.TestCase):
 
 		jv.cancel()
 
-	def test_multiple_cost_center_allocation_on_same_main_cost_center(self):
-		coa1 = create_cost_center_allocation(
-			"_Test Company",
-			"Main Cost Center 3 - _TC",
-			{"Sub Cost Center 1 - _TC": 30, "Sub Cost Center 2 - _TC": 30, "Sub Cost Center 3 - _TC": 40},
-			valid_from=add_days(today(), -5),
-		)
-
-		coa2 = create_cost_center_allocation(
-			"_Test Company",
-			"Main Cost Center 3 - _TC",
-			{"Sub Cost Center 1 - _TC": 50, "Sub Cost Center 2 - _TC": 50},
-			valid_from=add_days(today(), -1),
-		)
-
-		jv = make_journal_entry(
-			"Cash - _TC",
-			"Sales - _TC",
-			100,
-			cost_center="Main Cost Center 3 - _TC",
-			posting_date=today(),
-			submit=True,
-		)
-
-		expected_values = {"Sub Cost Center 1 - _TC": 50, "Sub Cost Center 2 - _TC": 50}
-
-		gle = frappe.qb.DocType("GL Entry")
-		gl_entries = (
-			frappe.qb.from_(gle)
-			.select(gle.cost_center, gle.debit, gle.credit)
-			.where(gle.voucher_type == "Journal Entry")
-			.where(gle.voucher_no == jv.name)
-			.where(gle.account == "Sales - _TC")
-			.orderby(gle.cost_center)
-		).run(as_dict=1)
-
-		self.assertTrue(gl_entries)
-
-		for gle in gl_entries:
-			self.assertTrue(gle.cost_center in expected_values)
-			self.assertEqual(gle.debit, 0)
-			self.assertEqual(gle.credit, expected_values[gle.cost_center])
-
-		coa1.cancel()
-		coa2.cancel()
-		jv.cancel()
-
 
 def create_cost_center_allocation(
 	company,

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.py

@@ -84,7 +84,7 @@ def get_api_endpoint(service_provider: str | None = None, use_http: bool = False
 		if service_provider == "exchangerate.host":
 			api = "api.exchangerate.host/convert"
 		elif service_provider == "frankfurter.app":
-			api = "api.frankfurter.app/{transaction_date}"
+			api = "frankfurter.app/{transaction_date}"
 
 		protocol = "https://"
 		if use_http:

erpnext/accounts/doctype/dunning/dunning.py

@@ -129,31 +129,19 @@ def calculate_interest_and_amount(outstanding_amount, rate_of_interest, dunning_
 
 
 @frappe.whitelist()
-def get_dunning_letter_text(dunning_type: str, doc: str | dict, language: str | None = None) -> dict:
-	DOCTYPE = "Dunning Letter Text"
-	FIELDS = ["body_text", "closing_text", "language"]
-
+def get_dunning_letter_text(dunning_type, doc, language=None):
 	if isinstance(doc, str):
 		doc = json.loads(doc)
-
-	if not language:
-		language = doc.get("language")
-
 	if language:
-		letter_text = frappe.db.get_value(
-			DOCTYPE, {"parent": dunning_type, "language": language}, FIELDS, as_dict=1
-		)
-
-	if not letter_text:
-		letter_text = frappe.db.get_value(
-			DOCTYPE, {"parent": dunning_type, "is_default_language": 1}, FIELDS, as_dict=1
-		)
-
-	if not letter_text:
-		return {}
-
-	return {
-		"body_text": frappe.render_template(letter_text.body_text, doc),
-		"closing_text": frappe.render_template(letter_text.closing_text, doc),
-		"language": letter_text.language,
-	}
+		filters = {"parent": dunning_type, "language": language}
+	else:
+		filters = {"parent": dunning_type, "is_default_language": 1}
+	letter_text = frappe.db.get_value(
+		"Dunning Letter Text", filters, ["body_text", "closing_text", "language"], as_dict=1
+	)
+	if letter_text:
+		return {
+			"body_text": frappe.render_template(letter_text.body_text, doc),
+			"closing_text": frappe.render_template(letter_text.closing_text, doc),
+			"language": letter_text.language,
+		}

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -153,7 +153,7 @@ class JournalEntry(AccountsController):
 			frappe.throw(_("Journal Entry type should be set as Depreciation Entry for asset depreciation"))
 
 	def validate_stock_accounts(self):
-		stock_accounts = get_stock_accounts(self.company, accounts=self.accounts)
+		stock_accounts = get_stock_accounts(self.company, self.doctype, self.name)
 		for account in stock_accounts:
 			account_bal, stock_bal, warehouse_list = get_stock_and_account_balance(
 				account, self.posting_date, self.company

erpnext/accounts/doctype/journal_entry/test_journal_entry.py

@@ -146,12 +146,12 @@ class TestJournalEntry(unittest.TestCase):
 				"credit_in_account_currency": 0 if diff > 0 else abs(diff),
 			},
 		)
+		jv.insert()
 
 		if account_bal == stock_bal:
-			self.assertRaises(StockAccountInvalidTransaction, jv.insert)
+			self.assertRaises(StockAccountInvalidTransaction, jv.submit)
 			frappe.db.rollback()
 		else:
-			jv.insert()
 			jv.submit()
 			jv.cancel()
 

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -23,11 +23,6 @@ frappe.ui.form.on('Payment Entry', {
 
 			var account_types = ["Pay", "Internal Transfer"].includes(frm.doc.payment_type) ?
 				["Bank", "Cash"] : [frappe.boot.party_account_types[frm.doc.party_type]];
-
-			if (frm.doc.party_type == "Shareholder") {
-				account_types.push("Equity");
-			}
-
 			return {
 				filters: {
 					"account_type": ["in", account_types],
@@ -82,9 +77,6 @@ frappe.ui.form.on('Payment Entry', {
 
 			var account_types = ["Receive", "Internal Transfer"].includes(frm.doc.payment_type) ?
 				["Bank", "Cash"] : [frappe.boot.party_account_types[frm.doc.party_type]];
-			if (frm.doc.party_type == "Shareholder") {
-				account_types.push("Equity");
-			}
 			return {
 				filters: {
 					"account_type": ["in", account_types],
@@ -154,17 +146,6 @@ frappe.ui.form.on('Payment Entry', {
 			};
 		});
 
-		frm.set_query("payment_request", "references", function (doc, cdt, cdn) {
-			const row = frappe.get_doc(cdt, cdn);
-			return {
-				query: "erpnext.accounts.doctype.payment_request.payment_request.get_open_payment_requests_query",
-				filters: {
-					reference_doctype: row.reference_doctype,
-					reference_name: row.reference_name,
-				},
-			};
-		});
-
 		frm.set_query("sales_taxes_and_charges_template", function () {
 			return {
 				filters: {
@@ -182,15 +163,7 @@ frappe.ui.form.on('Payment Entry', {
 				},
 			};
 		});
-
-		frm.add_fetch(
-			"payment_request",
-			"outstanding_amount",
-			"payment_request_outstanding",
-			"Payment Entry Reference"
-		);
 	},
-
 	refresh: function (frm) {
 		erpnext.hide_company(frm);
 		frm.events.hide_unhide_fields(frm);
@@ -203,7 +176,6 @@ frappe.ui.form.on('Payment Entry', {
 
 		}
 		erpnext.accounts.unreconcile_payment.add_unreconcile_btn(frm);
-		frappe.flags.allocate_payment_amount = true;
 	},
 
 	validate_company: (frm) => {
@@ -224,7 +196,7 @@ frappe.ui.form.on('Payment Entry', {
 	},
 
 	hide_unhide_fields: function(frm) {
-		var company_currency = frm.doc.company? frappe.get_doc(":Company", frm.doc.company)?.default_currency: "";
+		var company_currency = frm.doc.company? frappe.get_doc(":Company", frm.doc.company).default_currency: "";
 
 		frm.toggle_display("source_exchange_rate",
 			(frm.doc.paid_amount && frm.doc.paid_from_account_currency != company_currency));
@@ -270,7 +242,7 @@ frappe.ui.form.on('Payment Entry', {
 	},
 
 	set_dynamic_labels: function(frm) {
-		var company_currency = frm.doc.company? frappe.get_doc(":Company", frm.doc.company)?.default_currency: "";
+		var company_currency = frm.doc.company? frappe.get_doc(":Company", frm.doc.company).default_currency: "";
 
 		frm.set_currency_labels(["base_paid_amount", "base_received_amount", "base_total_allocated_amount",
 			"difference_amount", "base_paid_amount_after_tax", "base_received_amount_after_tax",
@@ -354,12 +326,6 @@ frappe.ui.form.on('Payment Entry', {
 				return {
 					query: "erpnext.controllers.queries.customer_query"
 				}
-			} else if (frm.doc.party_type == "Shareholder") {
-				return {
-					filters: {
-						company: frm.doc.company,
-					},
-				};
 			}
 		});
 
@@ -537,7 +503,7 @@ frappe.ui.form.on('Payment Entry', {
 			frm.set_value("source_exchange_rate", 1);
 		} else if (frm.doc.paid_from){
 			if (["Internal Transfer", "Pay"].includes(frm.doc.payment_type)) {
-				let company_currency = frappe.get_doc(":Company", frm.doc.company)?.default_currency;
+				let company_currency = frappe.get_doc(":Company", frm.doc.company).default_currency;
 				frappe.call({
 					method: "erpnext.setup.utils.get_exchange_rate",
 					args: {
@@ -653,9 +619,10 @@ frappe.ui.form.on('Payment Entry', {
 		frm.set_value("base_received_amount",
 			flt(frm.doc.received_amount) * flt(frm.doc.target_exchange_rate));
 
-		if (frm.doc.payment_type == "Pay")
-			frm.events.allocate_party_amount_against_ref_docs(frm, frm.doc.received_amount, true);
-		else frm.events.set_unallocated_amount(frm);
+		if(frm.doc.payment_type == "Pay")
+			frm.events.allocate_party_amount_against_ref_docs(frm, frm.doc.received_amount, 1);
+		else
+			frm.events.set_unallocated_amount(frm);
 
 		frm.set_paid_amount_based_on_received_amount = false;
 		frm.events.hide_unhide_fields(frm);
@@ -673,9 +640,10 @@ frappe.ui.form.on('Payment Entry', {
 			frm.set_value("base_received_amount", frm.doc.base_paid_amount);
 		}
 
-		if (frm.doc.payment_type == "Receive")
-			frm.events.allocate_party_amount_against_ref_docs(frm, frm.doc.paid_amount, true);
-		else frm.events.set_unallocated_amount(frm);
+		if(frm.doc.payment_type == "Receive")
+			frm.events.allocate_party_amount_against_ref_docs(frm, frm.doc.paid_amount, 1);
+		else
+			frm.events.set_unallocated_amount(frm);
 	},
 
 	get_outstanding_invoices_or_orders: function(frm, get_outstanding_invoices, get_orders_to_be_billed) {
@@ -819,7 +787,6 @@ frappe.ui.form.on('Payment Entry', {
 						c.outstanding_amount = d.outstanding_amount;
 						c.bill_no = d.bill_no;
 						c.payment_term = d.payment_term;
-						c.payment_term_outstanding = d.payment_term_outstanding;
 						c.allocated_amount = d.allocated_amount;
 
 						if(!in_list(frm.events.get_order_doctypes(frm), d.voucher_type)) {
@@ -861,12 +828,10 @@ frappe.ui.form.on('Payment Entry', {
 					}
 				}
 
-				frm.events.allocate_party_amount_against_ref_docs(
-					frm,
-					frm.doc.payment_type == "Receive" ? frm.doc.paid_amount : frm.doc.received_amount,
-					false
-				);
-			},
+				frm.events.allocate_party_amount_against_ref_docs(frm,
+					(frm.doc.payment_type=="Receive" ? frm.doc.paid_amount : frm.doc.received_amount));
+
+			}
 		});
 	},
 
@@ -878,13 +843,76 @@ frappe.ui.form.on('Payment Entry', {
 		return ["Sales Invoice", "Purchase Invoice"];
 	},
 
-	allocate_party_amount_against_ref_docs: async function (frm, paid_amount, paid_amount_change) {
-		await frm.call("allocate_amount_to_references", {
-			paid_amount: paid_amount,
-			paid_amount_change: paid_amount_change,
-			allocate_payment_amount: frappe.flags.allocate_payment_amount ?? false,
-		});
+	allocate_party_amount_against_ref_docs: function(frm, paid_amount, paid_amount_change) {
+		var total_positive_outstanding_including_order = 0;
+		var total_negative_outstanding = 0;
+		var total_deductions = frappe.utils.sum($.map(frm.doc.deductions || [],
+			function(d) { return flt(d.amount) }));
 
+		paid_amount -= total_deductions;
+
+		$.each(frm.doc.references || [], function(i, row) {
+			if(flt(row.outstanding_amount) > 0)
+				total_positive_outstanding_including_order += flt(row.outstanding_amount);
+			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") ||
+				(frm.doc.payment_type=="Pay" && frm.doc.party_type=="Supplier") ||
+				(frm.doc.payment_type=="Pay" && frm.doc.party_type=="Employee")
+			) {
+				if(total_positive_outstanding_including_order > paid_amount) {
+					var remaining_outstanding = total_positive_outstanding_including_order - paid_amount;
+					allocated_negative_outstanding = total_negative_outstanding < remaining_outstanding ?
+						total_negative_outstanding : remaining_outstanding;
+			}
+
+			var allocated_positive_outstanding =  paid_amount + allocated_negative_outstanding;
+		} else if (["Customer", "Supplier"].includes(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(
+						__("Cannot {0} {1} {2} without any negative outstanding invoice", [frm.doc.payment_type,
+							(frm.doc.party_type=="Customer" ? "to" : "from"), frm.doc.party_type])
+					);
+					return false
+				} else {
+					frappe.msgprint(
+						__("Paid Amount cannot be greater than total negative outstanding amount {0}", [total_negative_outstanding])
+					);
+					return false;
+				}
+			} else {
+				allocated_positive_outstanding = total_negative_outstanding - paid_amount;
+				allocated_negative_outstanding = paid_amount +
+					(total_positive_outstanding_including_order < allocated_positive_outstanding ?
+						total_positive_outstanding_including_order : allocated_positive_outstanding)
+			}
+		}
+
+		$.each(frm.doc.references || [], function(i, row) {
+			if (frappe.flags.allocate_payment_amount == 0) {
+				//If allocate payment amount checkbox is unchecked, set zero to allocate amount
+				row.allocated_amount = 0;
+
+			} else if (frappe.flags.allocate_payment_amount != 0 && (!row.allocated_amount || paid_amount_change)) {
+				if (row.outstanding_amount > 0 && allocated_positive_outstanding >= 0) {
+					row.allocated_amount = (row.outstanding_amount >= allocated_positive_outstanding) ?
+						allocated_positive_outstanding : row.outstanding_amount;
+					allocated_positive_outstanding -= flt(row.allocated_amount);
+
+				} else if (row.outstanding_amount < 0 && allocated_negative_outstanding) {
+					row.allocated_amount = (Math.abs(row.outstanding_amount) >= allocated_negative_outstanding) ?
+						-1*allocated_negative_outstanding : row.outstanding_amount;
+					allocated_negative_outstanding -= Math.abs(flt(row.allocated_amount));
+				}
+			}
+		})
+
+		frm.refresh_fields()
 		frm.events.set_total_allocated_amount(frm);
 	},
 
@@ -1367,62 +1395,6 @@ frappe.ui.form.on('Payment Entry', {
 
 		return current_tax_amount;
 	},
-
-	cost_center: function (frm) {
-		if (frm.doc.posting_date && (frm.doc.paid_from || frm.doc.paid_to)) {
-			return frappe.call({
-				method: "erpnext.accounts.doctype.payment_entry.payment_entry.get_party_and_account_balance",
-				args: {
-					company: frm.doc.company,
-					date: frm.doc.posting_date,
-					paid_from: frm.doc.paid_from,
-					paid_to: frm.doc.paid_to,
-					ptype: frm.doc.party_type,
-					pty: frm.doc.party,
-					cost_center: frm.doc.cost_center,
-				},
-				callback: function (r, rt) {
-					if (r.message) {
-						frappe.run_serially([
-							() => {
-								frm.set_value(
-									"paid_from_account_balance",
-									r.message.paid_from_account_balance
-								);
-								frm.set_value("paid_to_account_balance", r.message.paid_to_account_balance);
-								frm.set_value("party_balance", r.message.party_balance);
-							},
-						]);
-					}
-				},
-			});
-		}
-	},
-
-	after_save: function (frm) {
-		const { matched_payment_requests } = frappe.last_response;
-		if (!matched_payment_requests) return;
-
-		const COLUMN_LABEL = [
-			[__("Reference DocType"), __("Reference Name"), __("Allocated Amount"), __("Payment Request")],
-		];
-
-		frappe.msgprint({
-			title: __("Unset Matched Payment Request"),
-			message: COLUMN_LABEL.concat(matched_payment_requests),
-			as_table: true,
-			wide: true,
-			primary_action: {
-				label: __("Allocate Payment Request"),
-				action() {
-					frappe.hide_msgprint();
-					frm.call("set_matched_payment_requests", { matched_payment_requests }, () => {
-						frm.dirty();
-					});
-				},
-			},
-		});
-	},
 });
 
 
@@ -1509,5 +1481,35 @@ frappe.ui.form.on('Payment Entry Deduction', {
 
 	deductions_remove: function(frm) {
 		frm.events.set_unallocated_amount(frm);
+	}
+})
+frappe.ui.form.on('Payment Entry', {
+	cost_center: function(frm){
+		if (frm.doc.posting_date && (frm.doc.paid_from||frm.doc.paid_to)) {
+			return frappe.call({
+				method: "erpnext.accounts.doctype.payment_entry.payment_entry.get_party_and_account_balance",
+				args: {
+					company: frm.doc.company,
+					date: frm.doc.posting_date,
+					paid_from: frm.doc.paid_from,
+					paid_to: frm.doc.paid_to,
+					ptype: frm.doc.party_type,
+					pty: frm.doc.party,
+					cost_center: frm.doc.cost_center
+				},
+				callback: function(r, rt) {
+					if(r.message) {
+						frappe.run_serially([
+							() => {
+								frm.set_value("paid_from_account_balance", r.message.paid_from_account_balance);
+								frm.set_value("paid_to_account_balance", r.message.paid_to_account_balance);
+								frm.set_value("party_balance", r.message.party_balance);
+							}
+						]);
+
+					}
+				}
+			});
+		}
 	},
-});
+})

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -7,11 +7,9 @@ from functools import reduce
 
 import frappe
 from frappe import ValidationError, _, qb, scrub, throw
-from frappe.query_builder import Tuple
-from frappe.query_builder.functions import Count
 from frappe.utils import cint, comma_or, flt, getdate, nowdate
-from frappe.utils.data import comma_and, fmt_money, get_link_to_form
-from pypika.functions import Coalesce, Sum
+from frappe.utils.data import comma_and, fmt_money
+from pypika.functions import Sum
 
 import erpnext
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import get_dimensions
@@ -93,17 +91,13 @@ class PaymentEntry(AccountsController):
 		self.set_tax_withholding()
 		self.set_status()
 
-	def before_save(self):
-		self.set_matched_unset_payment_requests_to_response()
-
 	def on_submit(self):
 		if self.difference_amount:
 			frappe.throw(_("Difference Amount must be zero"))
 		self.make_gl_entries()
 		self.update_outstanding_amounts()
+		self.update_advance_paid()
 		self.update_payment_schedule()
-		self.update_payment_requests()
-		self.update_advance_paid()  # advance_paid_status depends on the payment request amount
 		self.set_status()
 
 	def on_cancel(self):
@@ -121,34 +115,30 @@ class PaymentEntry(AccountsController):
 		super().on_cancel()
 		self.make_gl_entries(cancel=1)
 		self.update_outstanding_amounts()
+		self.update_advance_paid()
 		self.delink_advance_entry_references()
 		self.update_payment_schedule(cancel=1)
-		self.update_payment_requests(cancel=True)
-		self.update_advance_paid()  # advance_paid_status depends on the payment request amount
+		self.set_payment_req_status()
 		self.set_status()
 
-	def update_payment_requests(self, cancel=False):
-		from erpnext.accounts.doctype.payment_request.payment_request import (
-			update_payment_requests_as_per_pe_references,
-		)
+	def set_payment_req_status(self):
+		from erpnext.accounts.doctype.payment_request.payment_request import update_payment_req_status
 
-		update_payment_requests_as_per_pe_references(self.references, cancel=cancel)
+		update_payment_req_status(self, None)
 
 	def update_outstanding_amounts(self):
 		self.set_missing_ref_details(force=True)
 
 	def validate_duplicate_entry(self):
-		reference_names = set()
+		reference_names = []
 		for d in self.get("references"):
-			key = (d.reference_doctype, d.reference_name, d.payment_term, d.payment_request)
-			if key in reference_names:
+			if (d.reference_doctype, d.reference_name, d.payment_term) in reference_names:
 				frappe.throw(
 					_("Row #{0}: Duplicate entry in References {1} {2}").format(
 						d.idx, d.reference_doctype, d.reference_name
 					)
 				)
-
-			reference_names.add(key)
+			reference_names.append((d.reference_doctype, d.reference_name, d.payment_term))
 
 	def set_bank_account_data(self):
 		if self.bank_account:
@@ -174,8 +164,6 @@ class PaymentEntry(AccountsController):
 		if self.payment_type == "Internal Transfer":
 			return
 
-		self.validate_allocated_amount_as_per_payment_request()
-
 		if self.party_type in ("Customer", "Supplier"):
 			self.validate_allocated_amount_with_latest_data()
 		else:
@@ -188,27 +176,6 @@ class PaymentEntry(AccountsController):
 				if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(d.outstanding_amount):
 					frappe.throw(fail_message.format(d.idx))
 
-	def validate_allocated_amount_as_per_payment_request(self):
-		"""
-		Allocated amount should not be greater than the outstanding amount of the Payment Request.
-		"""
-		if not self.references:
-			return
-
-		pr_outstanding_amounts = get_payment_request_outstanding_set_in_references(self.references)
-
-		if not pr_outstanding_amounts:
-			return
-
-		for ref in self.references:
-			if ref.payment_request and ref.allocated_amount > pr_outstanding_amounts[ref.payment_request]:
-				frappe.throw(
-					msg=_(
-						"Row #{0}: Allocated Amount cannot be greater than Outstanding Amount of Payment Request {1}"
-					).format(ref.idx, get_link_to_form("Payment Request", ref.payment_request)),
-					title=_("Invalid Allocated Amount"),
-				)
-
 	def term_based_allocation_enabled_for_reference(
 		self, reference_doctype: str, reference_name: str
 	) -> bool:
@@ -1455,380 +1422,6 @@ class PaymentEntry(AccountsController):
 
 		return current_tax_fraction
 
-	def set_matched_unset_payment_requests_to_response(self):
-		"""
-		Find matched Payment Requests for those references which have no Payment Request set.\n
-		And set to `frappe.response` to show in the frontend for allocation.
-		"""
-		if not self.references:
-			return
-
-		matched_payment_requests = get_matched_payment_request_of_references(
-			[row for row in self.references if not row.payment_request]
-		)
-
-		if not matched_payment_requests:
-			return
-
-		frappe.response["matched_payment_requests"] = matched_payment_requests
-
-	@frappe.whitelist()
-	def allocate_amount_to_references(self, paid_amount, paid_amount_change, allocate_payment_amount):
-		"""
-		Allocate `Allocated Amount` and `Payment Request` against `Reference` based on `Paid Amount` and `Outstanding Amount`.\n
-		:param paid_amount: Paid Amount / Received Amount.
-		:param paid_amount_change: Flag to check if `Paid Amount` is changed or not.
-		:param allocate_payment_amount: Flag to allocate amount or not. (Payment Request is also dependent on this flag)
-		"""
-		if not self.references:
-			return
-
-		if not allocate_payment_amount:
-			for ref in self.references:
-				ref.allocated_amount = 0
-			return
-
-		# calculating outstanding amounts
-		precision = self.precision("paid_amount")
-		total_positive_outstanding_including_order = 0
-		total_negative_outstanding = 0
-		paid_amount -= sum(flt(d.amount, precision) for d in self.deductions)
-
-		for ref in self.references:
-			reference_outstanding_amount = ref.outstanding_amount
-			abs_outstanding_amount = abs(reference_outstanding_amount)
-
-			if reference_outstanding_amount > 0:
-				total_positive_outstanding_including_order += abs_outstanding_amount
-			else:
-				total_negative_outstanding += abs_outstanding_amount
-
-		# calculating allocated outstanding amounts
-		allocated_negative_outstanding = 0
-		allocated_positive_outstanding = 0
-
-		# checking party type and payment type
-		if (self.payment_type == "Receive" and self.party_type == "Customer") or (
-			self.payment_type == "Pay" and self.party_type in ("Supplier", "Employee")
-		):
-			if total_positive_outstanding_including_order > paid_amount:
-				remaining_outstanding = flt(
-					total_positive_outstanding_including_order - paid_amount, precision
-				)
-				allocated_negative_outstanding = min(remaining_outstanding, total_negative_outstanding)
-
-			allocated_positive_outstanding = paid_amount + allocated_negative_outstanding
-
-		elif self.party_type in ("Supplier", "Employee"):
-			if paid_amount > total_negative_outstanding:
-				if total_negative_outstanding == 0:
-					frappe.msgprint(
-						_("Cannot {0} from {2} without any negative outstanding invoice").format(
-							self.payment_type,
-							self.party_type,
-						)
-					)
-				else:
-					frappe.msgprint(
-						_("Paid Amount cannot be greater than total negative outstanding amount {0}").format(
-							total_negative_outstanding
-						)
-					)
-
-				return
-
-			else:
-				allocated_positive_outstanding = flt(total_negative_outstanding - paid_amount, precision)
-				allocated_negative_outstanding = paid_amount + min(
-					total_positive_outstanding_including_order, allocated_positive_outstanding
-				)
-
-		# inner function to set `allocated_amount` to those row which have no PR
-		def _allocation_to_unset_pr_row(
-			row, outstanding_amount, allocated_positive_outstanding, allocated_negative_outstanding
-		):
-			if outstanding_amount > 0 and allocated_positive_outstanding >= 0:
-				row.allocated_amount = min(allocated_positive_outstanding, outstanding_amount)
-				allocated_positive_outstanding = flt(
-					allocated_positive_outstanding - row.allocated_amount, precision
-				)
-			elif outstanding_amount < 0 and allocated_negative_outstanding:
-				row.allocated_amount = min(allocated_negative_outstanding, abs(outstanding_amount)) * -1
-				allocated_negative_outstanding = flt(
-					allocated_negative_outstanding - abs(row.allocated_amount), precision
-				)
-			return allocated_positive_outstanding, allocated_negative_outstanding
-
-		# allocate amount based on `paid_amount` is changed or not
-		if not paid_amount_change:
-			for ref in self.references:
-				allocated_positive_outstanding, allocated_negative_outstanding = _allocation_to_unset_pr_row(
-					ref,
-					ref.outstanding_amount,
-					allocated_positive_outstanding,
-					allocated_negative_outstanding,
-				)
-
-			allocate_open_payment_requests_to_references(self.references, self.precision("paid_amount"))
-
-		else:
-			payment_request_outstanding_amounts = (
-				get_payment_request_outstanding_set_in_references(self.references) or {}
-			)
-			references_outstanding_amounts = get_references_outstanding_amount(self.references) or {}
-			remaining_references_allocated_amounts = references_outstanding_amounts.copy()
-
-			# Re allocate amount to those references which have PR set (Higher priority)
-			for ref in self.references:
-				if not ref.payment_request:
-					continue
-
-				# fetch outstanding_amount of `Reference` (Payment Term) and `Payment Request` to allocate new amount
-				key = (ref.reference_doctype, ref.reference_name, ref.get("payment_term"))
-				reference_outstanding_amount = references_outstanding_amounts[key]
-				pr_outstanding_amount = payment_request_outstanding_amounts[ref.payment_request]
-
-				if reference_outstanding_amount > 0 and allocated_positive_outstanding >= 0:
-					# allocate amount according to outstanding amounts
-					outstanding_amounts = (
-						allocated_positive_outstanding,
-						reference_outstanding_amount,
-						pr_outstanding_amount,
-					)
-
-					ref.allocated_amount = min(outstanding_amounts)
-
-					# update amounts to track allocation
-					allocated_amount = ref.allocated_amount
-					allocated_positive_outstanding = flt(
-						allocated_positive_outstanding - allocated_amount, precision
-					)
-					remaining_references_allocated_amounts[key] = flt(
-						remaining_references_allocated_amounts[key] - allocated_amount, precision
-					)
-					payment_request_outstanding_amounts[ref.payment_request] = flt(
-						payment_request_outstanding_amounts[ref.payment_request] - allocated_amount, precision
-					)
-
-				elif reference_outstanding_amount < 0 and allocated_negative_outstanding:
-					# allocate amount according to outstanding amounts
-					outstanding_amounts = (
-						allocated_negative_outstanding,
-						abs(reference_outstanding_amount),
-						pr_outstanding_amount,
-					)
-
-					ref.allocated_amount = min(outstanding_amounts) * -1
-
-					# update amounts to track allocation
-					allocated_amount = abs(ref.allocated_amount)
-					allocated_negative_outstanding = flt(
-						allocated_negative_outstanding - allocated_amount, precision
-					)
-					remaining_references_allocated_amounts[key] += allocated_amount  # negative amount
-					payment_request_outstanding_amounts[ref.payment_request] = flt(
-						payment_request_outstanding_amounts[ref.payment_request] - allocated_amount, precision
-					)
-			# Re allocate amount to those references which have no PR (Lower priority)
-			for ref in self.references:
-				if ref.payment_request:
-					continue
-
-				key = (ref.reference_doctype, ref.reference_name, ref.get("payment_term"))
-				reference_outstanding_amount = remaining_references_allocated_amounts[key]
-
-				allocated_positive_outstanding, allocated_negative_outstanding = _allocation_to_unset_pr_row(
-					ref,
-					reference_outstanding_amount,
-					allocated_positive_outstanding,
-					allocated_negative_outstanding,
-				)
-
-	@frappe.whitelist()
-	def set_matched_payment_requests(self, matched_payment_requests):
-		"""
-		Set `Payment Request` against `Reference` based on `matched_payment_requests`.\n
-		:param matched_payment_requests: List of tuple of matched Payment Requests.
-
-		---
-		Example: [(reference_doctype, reference_name, allocated_amount, payment_request), ...]
-		"""
-		if not self.references or not matched_payment_requests:
-			return
-
-		if isinstance(matched_payment_requests, str):
-			matched_payment_requests = json.loads(matched_payment_requests)
-
-		# modify matched_payment_requests
-		# like (reference_doctype, reference_name, allocated_amount): payment_request
-		payment_requests = {}
-
-		for row in matched_payment_requests:
-			key = tuple(row[:3])
-			payment_requests[key] = row[3]
-
-		for ref in self.references:
-			if ref.payment_request:
-				continue
-
-			key = (ref.reference_doctype, ref.reference_name, ref.allocated_amount)
-
-			if key in payment_requests:
-				ref.payment_request = payment_requests[key]
-				del payment_requests[key]  # to avoid duplicate allocation
-
-
-def get_matched_payment_request_of_references(references=None):
-	"""
-	Get those `Payment Requests` which are matched with `References`.\n
-	    - Amount must be same.
-	    - Only single `Payment Request` available for this amount.
-
-	Example: [(reference_doctype, reference_name, allocated_amount, payment_request), ...]
-	"""
-	if not references:
-		return
-
-	# to fetch matched rows
-	refs = {
-		(row.reference_doctype, row.reference_name, row.allocated_amount)
-		for row in references
-		if row.reference_doctype and row.reference_name and row.allocated_amount
-	}
-
-	if not refs:
-		return
-
-	PR = frappe.qb.DocType("Payment Request")
-
-	# query to group by reference_doctype, reference_name, outstanding_amount
-	subquery = (
-		frappe.qb.from_(PR)
-		.select(
-			PR.reference_doctype,
-			PR.reference_name,
-			PR.outstanding_amount.as_("allocated_amount"),
-			PR.name.as_("payment_request"),
-			Count("*").as_("count"),
-		)
-		.where(Tuple(PR.reference_doctype, PR.reference_name, PR.outstanding_amount).isin(refs))
-		.where(PR.status != "Paid")
-		.where(PR.docstatus == 1)
-		.groupby(PR.reference_doctype, PR.reference_name, PR.outstanding_amount)
-	)
-
-	# query to fetch matched rows which are single
-	matched_prs = (
-		frappe.qb.from_(subquery)
-		.select(
-			subquery.reference_doctype,
-			subquery.reference_name,
-			subquery.allocated_amount,
-			subquery.payment_request,
-		)
-		.where(subquery.count == 1)
-		.run()
-	)
-
-	return matched_prs if matched_prs else None
-
-
-def get_references_outstanding_amount(references=None):
-	"""
-	Fetch accurate outstanding amount of `References`.\n
-	    - If `Payment Term` is set, then fetch outstanding amount from `Payment Schedule`.
-	    - If `Payment Term` is not set, then fetch outstanding amount from `References` it self.
-
-	Example: {(reference_doctype, reference_name, payment_term): outstanding_amount, ...}
-	"""
-	if not references:
-		return
-
-	refs_with_payment_term = get_outstanding_of_references_with_payment_term(references) or {}
-	refs_without_payment_term = get_outstanding_of_references_with_no_payment_term(references) or {}
-
-	return {**refs_with_payment_term, **refs_without_payment_term}
-
-
-def get_outstanding_of_references_with_payment_term(references=None):
-	"""
-	Fetch outstanding amount of `References` which have `Payment Term` set.\n
-	Example: {(reference_doctype, reference_name, payment_term): outstanding_amount, ...}
-	"""
-	if not references:
-		return
-
-	refs = {
-		(row.reference_doctype, row.reference_name, row.payment_term)
-		for row in references
-		if row.reference_doctype and row.reference_name and row.payment_term
-	}
-
-	if not refs:
-		return
-
-	PS = frappe.qb.DocType("Payment Schedule")
-
-	response = (
-		frappe.qb.from_(PS)
-		.select(PS.parenttype, PS.parent, PS.payment_term, PS.outstanding)
-		.where(Tuple(PS.parenttype, PS.parent, PS.payment_term).isin(refs))
-	).run(as_dict=True)
-
-	if not response:
-		return
-
-	return {(row.parenttype, row.parent, row.payment_term): row.outstanding for row in response}
-
-
-def get_outstanding_of_references_with_no_payment_term(references):
-	"""
-	Fetch outstanding amount of `References` which have no `Payment Term` set.\n
-	    - Fetch outstanding amount from `References` it self.
-
-	Note: `None` is used for allocation of `Payment Request`
-	Example: {(reference_doctype, reference_name, None): outstanding_amount, ...}
-	"""
-	if not references:
-		return
-
-	outstanding_amounts = {}
-
-	for ref in references:
-		if ref.payment_term:
-			continue
-
-		key = (ref.reference_doctype, ref.reference_name, None)
-
-		if key not in outstanding_amounts:
-			outstanding_amounts[key] = ref.outstanding_amount
-
-	return outstanding_amounts
-
-
-def get_payment_request_outstanding_set_in_references(references=None):
-	"""
-	Fetch outstanding amount of `Payment Request` which are set in `References`.\n
-	Example: {payment_request: outstanding_amount, ...}
-	"""
-	if not references:
-		return
-
-	referenced_payment_requests = {row.payment_request for row in references if row.payment_request}
-
-	if not referenced_payment_requests:
-		return
-
-	PR = frappe.qb.DocType("Payment Request")
-
-	response = (
-		frappe.qb.from_(PR)
-		.select(PR.name, PR.outstanding_amount)
-		.where(PR.name.isin(referenced_payment_requests))
-	).run()
-
-	return dict(response) if response else None
-
 
 def validate_inclusive_tax(tax, doc):
 	def _on_previous_row_error(row_range):
@@ -1970,7 +1563,7 @@ def get_outstanding_reference_documents(args):
 				d["bill_no"] = frappe.db.get_value(d.voucher_type, d.voucher_no, "bill_no")
 
 		# Get negative outstanding sales /purchase invoices
-		if args.get("party_type") != "Employee":
+		if args.get("party_type") != "Employee" and not args.get("voucher_no"):
 			negative_outstanding_invoices = get_negative_outstanding_invoices(
 				args.get("party_type"),
 				args.get("party"),
@@ -2270,9 +1863,7 @@ def get_party_details(company, party_type, party, date, cost_center=None):
 	account_balance = get_balance_on(party_account, date, cost_center=cost_center)
 	_party_name = "title" if party_type == "Shareholder" else party_type.lower() + "_name"
 	party_name = frappe.db.get_value(party_type, party, _party_name)
-	party_balance = get_balance_on(
-		party_type=party_type, party=party, company=company, cost_center=cost_center
-	)
+	party_balance = get_balance_on(party_type=party_type, party=party, cost_center=cost_center)
 	if party_type in ["Customer", "Supplier"]:
 		bank_account = get_party_bank_account(party_type, party)
 
@@ -2419,8 +2010,6 @@ def get_payment_entry(
 	party_type=None,
 	payment_type=None,
 	reference_date=None,
-	ignore_permissions=False,
-	created_from_payment_request=False,
 ):
 	doc = frappe.get_doc(dt, dn)
 	over_billing_allowance = frappe.db.get_single_value("Accounts Settings", "over_billing_allowance")
@@ -2571,179 +2160,9 @@ def get_payment_entry(
 
 		pe.set_difference_amount()
 
-	# If PE is created from PR directly, then no need to find open PRs for the references
-	if not created_from_payment_request:
-		allocate_open_payment_requests_to_references(pe.references, pe.precision("paid_amount"))
-
 	return pe
 
 
-def get_open_payment_requests_for_references(references=None):
-	"""
-	Fetch all unpaid Payment Requests for the references. \n
-	    - Each reference can have multiple Payment Requests. \n
-
-	Example: {("Sales Invoice", "SINV-00001"): {"PREQ-00001": 1000, "PREQ-00002": 2000}}
-	"""
-	if not references:
-		return
-
-	refs = {
-		(row.reference_doctype, row.reference_name)
-		for row in references
-		if row.reference_doctype and row.reference_name and row.allocated_amount
-	}
-
-	if not refs:
-		return
-
-	PR = frappe.qb.DocType("Payment Request")
-
-	response = (
-		frappe.qb.from_(PR)
-		.select(PR.name, PR.reference_doctype, PR.reference_name, PR.outstanding_amount)
-		.where(Tuple(PR.reference_doctype, PR.reference_name).isin(list(refs)))
-		.where(PR.status != "Paid")
-		.where(PR.docstatus == 1)
-		.orderby(Coalesce(PR.transaction_date, PR.creation), order=frappe.qb.asc)
-	).run(as_dict=True)
-
-	if not response:
-		return
-
-	reference_payment_requests = {}
-
-	for row in response:
-		key = (row.reference_doctype, row.reference_name)
-
-		if key not in reference_payment_requests:
-			reference_payment_requests[key] = {row.name: row.outstanding_amount}
-		else:
-			reference_payment_requests[key][row.name] = row.outstanding_amount
-
-	return reference_payment_requests
-
-
-def allocate_open_payment_requests_to_references(references=None, precision=None):
-	"""
-	Allocate unpaid Payment Requests to the references. \n
-	---
-	- Allocation based on below factors
-	    - Reference Allocated Amount
-	    - Reference Outstanding Amount (With Payment Terms or without Payment Terms)
-	    - Reference Payment Request's outstanding amount
-	---
-	- Allocation based on below scenarios
-	    - Reference's Allocated Amount == Payment Request's Outstanding Amount
-	        - Allocate the Payment Request to the reference
-	        - This PR will not be allocated further
-	    - Reference's Allocated Amount < Payment Request's Outstanding Amount
-	        - Allocate the Payment Request to the reference
-	        - Reduce the PR's outstanding amount by the allocated amount
-	        - This PR can be allocated further
-	    - Reference's Allocated Amount > Payment Request's Outstanding Amount
-	        - Allocate the Payment Request to the reference
-	        - Reduce Allocated Amount of the reference by the PR's outstanding amount
-	        - Create a new row for the remaining amount until the Allocated Amount is 0
-	            - Allocate PR if available
-	---
-	- Note:
-	    - Priority is given to the first Payment Request of respective references.
-	    - Single Reference can have multiple rows.
-	        - With Payment Terms or without Payment Terms
-	        - With Payment Request or without Payment Request
-	"""
-	if not references:
-		return
-
-	# get all unpaid payment requests for the references
-	references_open_payment_requests = get_open_payment_requests_for_references(references)
-
-	if not references_open_payment_requests:
-		return
-
-	if not precision:
-		precision = references[0].precision("allocated_amount")
-
-	# to manage new rows
-	row_number = 1
-	MOVE_TO_NEXT_ROW = 1
-	TO_SKIP_NEW_ROW = 2
-
-	while row_number <= len(references):
-		row = references[row_number - 1]
-		reference_key = (row.reference_doctype, row.reference_name)
-
-		# update the idx to maintain the order
-		row.idx = row_number
-
-		# unpaid payment requests for the reference
-		reference_payment_requests = references_open_payment_requests.get(reference_key)
-
-		if not reference_payment_requests:
-			row_number += MOVE_TO_NEXT_ROW  # to move to next reference row
-			continue
-
-		# get the first payment request and its outstanding amount
-		payment_request, pr_outstanding_amount = next(iter(reference_payment_requests.items()))
-		allocated_amount = row.allocated_amount
-
-		# allocate the payment request to the reference and PR's outstanding amount
-		row.payment_request = payment_request
-
-		if pr_outstanding_amount == allocated_amount:
-			del reference_payment_requests[payment_request]
-			row_number += MOVE_TO_NEXT_ROW
-
-		elif pr_outstanding_amount > allocated_amount:
-			# reduce the outstanding amount of the payment request
-			reference_payment_requests[payment_request] -= allocated_amount
-			row_number += MOVE_TO_NEXT_ROW
-
-		else:
-			# split the reference row to allocate the remaining amount
-			del reference_payment_requests[payment_request]
-			row.allocated_amount = pr_outstanding_amount
-			allocated_amount = flt(allocated_amount - pr_outstanding_amount, precision)
-
-			# set the remaining amount to the next row
-			while allocated_amount:
-				# create a new row for the remaining amount
-				new_row = frappe.copy_doc(row)
-				references.insert(row_number, new_row)
-
-				# get the first payment request and its outstanding amount
-				payment_request, pr_outstanding_amount = next(
-					iter(reference_payment_requests.items()), (None, None)
-				)
-
-				# update new row
-				new_row.idx = row_number + 1
-				new_row.payment_request = payment_request
-				new_row.allocated_amount = min(
-					pr_outstanding_amount if pr_outstanding_amount else allocated_amount, allocated_amount
-				)
-
-				if not payment_request or not pr_outstanding_amount:
-					row_number += TO_SKIP_NEW_ROW
-					break
-
-				elif pr_outstanding_amount == allocated_amount:
-					del reference_payment_requests[payment_request]
-					row_number += TO_SKIP_NEW_ROW
-					break
-
-				elif pr_outstanding_amount > allocated_amount:
-					reference_payment_requests[payment_request] -= allocated_amount
-					row_number += TO_SKIP_NEW_ROW
-					break
-
-				else:
-					allocated_amount = flt(allocated_amount - pr_outstanding_amount, precision)
-					del reference_payment_requests[payment_request]
-					row_number += MOVE_TO_NEXT_ROW
-
-
 def update_accounting_dimensions(pe, doc):
 	"""
 	Updates accounting dimensions in Payment Entry based on the accounting dimensions in the reference document

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -1365,79 +1365,6 @@ class TestPaymentEntry(FrappeTestCase):
 		expected_out_str = json.dumps(sorted(expected_pl_entries, key=json.dumps))
 		self.assertEqual(out_str, expected_out_str)
 
-	@change_settings("Accounts Settings", {"delete_linked_ledger_entries": 1})
-	def test_delete_linked_exchange_gain_loss_journal(self):
-		from erpnext.accounts.doctype.account.test_account import create_account
-		from erpnext.accounts.doctype.opening_invoice_creation_tool.test_opening_invoice_creation_tool import (
-			make_customer,
-		)
-
-		debtors = create_account(
-			account_name="Debtors USD",
-			parent_account="Accounts Receivable - _TC",
-			company="_Test Company",
-			account_currency="USD",
-			account_type="Receivable",
-		)
-
-		# create a customer
-		customer = make_customer(customer="_Test Party USD")
-		cust_doc = frappe.get_doc("Customer", customer)
-		cust_doc.default_currency = "USD"
-		test_account_details = {
-			"company": "_Test Company",
-			"account": debtors,
-		}
-		cust_doc.append("accounts", test_account_details)
-		cust_doc.save()
-
-		# create a sales invoice
-		si = create_sales_invoice(
-			customer=customer,
-			currency="USD",
-			conversion_rate=83.970000000,
-			debit_to=debtors,
-			do_not_save=1,
-		)
-		si.party_account_currency = "USD"
-		si.save()
-		si.submit()
-
-		# create a payment entry for the invoice
-		pe = get_payment_entry("Sales Invoice", si.name)
-		pe.reference_no = "1"
-		pe.reference_date = frappe.utils.nowdate()
-		pe.paid_amount = 100
-		pe.source_exchange_rate = 90
-		pe.append(
-			"deductions",
-			{
-				"account": "_Test Exchange Gain/Loss - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"amount": 2710,
-			},
-		)
-		pe.save()
-		pe.submit()
-
-		# check creation of journal entry
-		jv = frappe.get_all(
-			"Journal Entry Account",
-			{"reference_type": pe.doctype, "reference_name": pe.name, "docstatus": 1},
-			pluck="parent",
-		)
-		self.assertTrue(jv)
-
-		# check cancellation of payment entry and journal entry
-		pe.cancel()
-		self.assertTrue(pe.docstatus == 2)
-		self.assertTrue(frappe.db.get_value("Journal Entry", {"name": jv[0]}, "docstatus") == 2)
-
-		# check deletion of payment entry and journal entry
-		pe.delete()
-		self.assertRaises(frappe.DoesNotExistError, frappe.get_doc, pe.doctype, pe.name)
-		self.assertRaises(frappe.DoesNotExistError, frappe.get_doc, "Journal Entry", jv[0])
-
 
 def create_payment_entry(**args):
 	payment_entry = frappe.new_doc("Payment Entry")

erpnext/accounts/doctype/payment_entry_reference/payment_entry_reference.json

@@ -10,15 +10,12 @@
   "due_date",
   "bill_no",
   "payment_term",
-  "payment_term_outstanding",
   "column_break_4",
   "total_amount",
   "outstanding_amount",
   "allocated_amount",
   "exchange_rate",
-  "exchange_gain_loss",
-  "payment_request",
-  "payment_request_outstanding"
+  "exchange_gain_loss"
  ],
  "fields": [
   {
@@ -104,33 +101,12 @@
    "label": "Exchange Gain/Loss",
    "options": "Company:company:default_currency",
    "read_only": 1
-  },
-  {
-   "fieldname": "payment_request",
-   "fieldtype": "Link",
-   "label": "Payment Request",
-   "options": "Payment Request"
-  },
-  {
-   "depends_on": "eval: doc.payment_term",
-   "fieldname": "payment_term_outstanding",
-   "fieldtype": "Float",
-   "label": "Payment Term Outstanding",
-   "read_only": 1
-  },
-  {
-   "depends_on": "eval: doc.payment_request && doc.payment_request_outstanding",
-   "fieldname": "payment_request_outstanding",
-   "fieldtype": "Float",
-   "is_virtual": 1,
-   "label": "Payment Request Outstanding",
-   "read_only": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-09-16 18:11:50.019343",
+ "modified": "2022-12-12 12:31:44.919895",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry Reference",

erpnext/accounts/doctype/payment_entry_reference/payment_entry_reference.py

@@ -1,14 +1,9 @@
 # Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and contributors
 # For license information, please see license.txt
 
-import frappe
+
 from frappe.model.document import Document
 
 
 class PaymentEntryReference(Document):
-	@property
-	def payment_request_outstanding(self):
-		if not self.payment_request:
-			return
-
-		return frappe.db.get_value("Payment Request", self.payment_request, "outstanding_amount")
+	pass

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -256,7 +256,6 @@ class PaymentReconciliation(Document):
 								"posting_date": inv.posting_date,
 								"currency": inv.currency,
 								"cost_center": inv.cost_center,
-								"remarks": inv.remarks,
 							}
 						)
 					)

erpnext/accounts/doctype/payment_reconciliation_payment/payment_reconciliation_payment.json

@@ -14,7 +14,7 @@
   "amount",
   "difference_amount",
   "sec_break1",
-  "remarks",
+  "remark",
   "currency",
   "exchange_rate",
   "cost_center"
@@ -74,6 +74,12 @@
    "fieldname": "sec_break1",
    "fieldtype": "Section Break"
   },
+  {
+   "fieldname": "remark",
+   "fieldtype": "Small Text",
+   "label": "Remark",
+   "read_only": 1
+  },
   {
    "fieldname": "currency",
    "fieldtype": "Link",
@@ -99,18 +105,12 @@
    "fieldtype": "Link",
    "label": "Cost Center",
    "options": "Cost Center"
-  },
-  {
-   "fieldname": "remarks",
-   "fieldtype": "Small Text",
-   "label": "Remarks",
-   "read_only": 1
   }
  ],
  "is_virtual": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-10-29 16:24:43.021230",
+ "modified": "2023-11-17 17:33:34.818530",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Payment",

erpnext/accounts/doctype/payment_request/payment_request.js

@@ -48,8 +48,8 @@ frappe.ui.form.on("Payment Request", "refresh", function (frm) {
 	}
 
 	if (
-		frm.doc.payment_request_type == "Outward" &&
-		["Initiated", "Partially Paid"].includes(frm.doc.status)
+		(!frm.doc.payment_gateway_account || frm.doc.payment_request_type == "Outward") &&
+		frm.doc.status == "Initiated"
 	) {
 		frm.add_custom_button(__("Create Payment Entry"), function () {
 			frappe.call({

erpnext/accounts/doctype/payment_request/payment_request.json

@@ -18,11 +18,9 @@
   "reference_name",
   "transaction_details",
   "grand_total",
-  "currency",
   "is_a_subscription",
   "column_break_18",
-  "outstanding_amount",
-  "party_account_currency",
+  "currency",
   "subscription_section",
   "subscription_plans",
   "bank_account_details",
@@ -70,7 +68,6 @@
   {
    "fieldname": "transaction_date",
    "fieldtype": "Date",
-   "in_preview": 1,
    "label": "Transaction Date"
   },
   {
@@ -135,8 +132,7 @@
    "no_copy": 1,
    "options": "reference_doctype",
    "print_hide": 1,
-   "read_only": 1,
-   "search_index": 1
+   "read_only": 1
   },
   {
    "fieldname": "transaction_details",
@@ -144,14 +140,11 @@
    "label": "Transaction Details"
   },
   {
-   "description": "Amount in transaction currency",
+   "description": "Amount in customer's currency",
    "fieldname": "grand_total",
    "fieldtype": "Currency",
-   "in_preview": 1,
    "label": "Amount",
-   "non_negative": 1,
-   "options": "currency",
-   "reqd": 1
+   "options": "currency"
   },
   {
    "default": "0",
@@ -395,31 +388,13 @@
    "fieldtype": "Link",
    "label": "Project",
    "options": "Project"
-  },
-  {
-   "depends_on": "eval: doc.docstatus === 1",
-   "description": "Amount in party's bank account currency",
-   "fieldname": "outstanding_amount",
-   "fieldtype": "Currency",
-   "in_preview": 1,
-   "label": "Outstanding Amount",
-   "non_negative": 1,
-   "options": "party_account_currency",
-   "read_only": 1
-  },
-  {
-   "fieldname": "party_account_currency",
-   "fieldtype": "Link",
-   "label": "Party Account Currency",
-   "options": "Currency",
-   "read_only": 1
   }
  ],
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-09-16 17:50:54.440090",
+ "modified": "2022-12-21 16:56:40.115737",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Request",
@@ -454,8 +429,7 @@
    "write": 1
   }
  ],
- "show_preview_popup": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -7,11 +7,9 @@ import json
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.query_builder.functions import Sum
 from frappe.utils import flt, get_url, nowdate
 from frappe.utils.background_jobs import enqueue
 
-from erpnext import get_company_currency
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
 )
@@ -21,7 +19,7 @@ from erpnext.accounts.doctype.payment_entry.payment_entry import (
 )
 from erpnext.accounts.doctype.subscription_plan.subscription_plan import get_plan_rate
 from erpnext.accounts.party import get_party_account, get_party_bank_account
-from erpnext.accounts.utils import get_account_currency, get_currency_precision
+from erpnext.accounts.utils import get_account_currency
 from erpnext.erpnext_integrations.stripe_integration import create_stripe_subscription
 from erpnext.utilities import payment_app_import_guard
 
@@ -47,12 +45,6 @@ class PaymentRequest(Document):
 			frappe.throw(_("To create a Payment Request reference document is required"))
 
 	def validate_payment_request_amount(self):
-		if self.grand_total == 0:
-			frappe.throw(
-				_("{0} cannot be zero").format(self.get_label_from_fieldname("grand_total")),
-				title=_("Invalid Amount"),
-			)
-
 		existing_payment_request_amount = flt(
 			get_existing_payment_request_amount(self.reference_doctype, self.reference_name)
 		)
@@ -100,29 +92,6 @@ class PaymentRequest(Document):
 					).format(self.grand_total, amount)
 				)
 
-	def before_submit(self):
-		company = frappe.get_value(self.reference_doctype, self.reference_name, "company")
-		if (
-			self.currency != self.party_account_currency
-			and self.party_account_currency == get_company_currency(company)
-		):
-			# set outstanding amount in party account currency
-			invoice = frappe.get_value(
-				self.reference_doctype,
-				self.reference_name,
-				["rounded_total", "grand_total", "base_rounded_total", "base_grand_total"],
-				as_dict=1,
-			)
-			grand_total = invoice.get("rounded_total") or invoice.get("grand_total")
-			base_grand_total = invoice.get("base_rounded_total") or invoice.get("base_grand_total")
-			self.outstanding_amount = flt(
-				self.grand_total / grand_total * base_grand_total,
-				self.precision("outstanding_amount"),
-			)
-
-		else:
-			self.outstanding_amount = self.grand_total
-
 	def on_submit(self):
 		if self.payment_request_type == "Outward":
 			self.db_set("status", "Initiated")
@@ -238,12 +207,12 @@ class PaymentRequest(Document):
 		return controller.get_payment_url(
 			**{
 				"amount": flt(self.grand_total, self.precision("grand_total")),
-				"title": data.company,
-				"description": self.subject,
+				"title": data.company.encode("utf-8"),
+				"description": self.subject.encode("utf-8"),
 				"reference_doctype": "Payment Request",
 				"reference_docname": self.name,
 				"payer_email": self.email_to or frappe.session.user,
-				"payer_name": data.customer_name,
+				"payer_name": frappe.safe_encode(data.customer_name),
 				"order_id": self.name,
 				"currency": self.currency,
 			}
@@ -251,7 +220,7 @@ class PaymentRequest(Document):
 
 	def set_as_paid(self):
 		if self.payment_channel == "Phone":
-			self.db_set({"status": "Paid", "outstanding_amount": 0})
+			self.db_set("status", "Paid")
 
 		else:
 			payment_entry = self.create_payment_entry()
@@ -272,32 +241,26 @@ class PaymentRequest(Document):
 		else:
 			party_account = get_party_account("Customer", ref_doc.get("customer"), ref_doc.company)
 
-		party_account_currency = (
-			self.get("party_account_currency")
-			or ref_doc.get("party_account_currency")
-			or get_account_currency(party_account)
-		)
-
-		party_amount = bank_amount = self.outstanding_amount
+		party_account_currency = ref_doc.get("party_account_currency") or get_account_currency(party_account)
 
+		bank_amount = self.grand_total
 		if party_account_currency == ref_doc.company_currency and party_account_currency != self.currency:
-			exchange_rate = ref_doc.get("conversion_rate")
-			bank_amount = flt(self.outstanding_amount / exchange_rate, self.precision("grand_total"))
+			party_amount = ref_doc.get("base_rounded_total") or ref_doc.get("base_grand_total")
+		else:
+			party_amount = self.grand_total
 
-		# outstanding amount is already in Part's account currency
 		payment_entry = get_payment_entry(
 			self.reference_doctype,
 			self.reference_name,
 			party_amount=party_amount,
 			bank_account=self.payment_account,
 			bank_amount=bank_amount,
-			created_from_payment_request=True,
 		)
 
 		payment_entry.update(
 			{
 				"mode_of_payment": self.mode_of_payment,
-				"reference_no": self.name,  # to prevent validation error
+				"reference_no": self.name,
 				"reference_date": nowdate(),
 				"remarks": "Payment Entry against {} {} via Payment Request {}".format(
 					self.reference_doctype, self.reference_name, self.name
@@ -305,9 +268,6 @@ class PaymentRequest(Document):
 			}
 		)
 
-		# Allocate payment_request for each reference in payment_entry (Payment Term can splits the row)
-		self._allocate_payment_request_to_pe_references(references=payment_entry.references)
-
 		# Update dimensions
 		payment_entry.update(
 			{
@@ -316,16 +276,13 @@ class PaymentRequest(Document):
 			}
 		)
 
-		# Update 'Paid Amount' on Forex transactions
-		if self.currency != ref_doc.company_currency:
-			if (
-				self.payment_request_type == "Outward"
-				and payment_entry.paid_from_account_currency == ref_doc.company_currency
-				and payment_entry.paid_from_account_currency != payment_entry.paid_to_account_currency
-			):
-				payment_entry.paid_amount = payment_entry.base_paid_amount = (
-					payment_entry.target_exchange_rate * payment_entry.received_amount
-				)
+		if party_account_currency == ref_doc.company_currency and party_account_currency != self.currency:
+			amount = payment_entry.base_paid_amount
+		else:
+			amount = self.grand_total
+
+		payment_entry.received_amount = amount
+		payment_entry.get("references")[0].allocated_amount = amount
 
 		for dimension in get_accounting_dimensions():
 			payment_entry.update({dimension: self.get(dimension)})
@@ -429,62 +386,6 @@ class PaymentRequest(Document):
 		if payment_provider == "stripe":
 			return create_stripe_subscription(gateway_controller, data)
 
-	def _allocate_payment_request_to_pe_references(self, references):
-		"""
-		Allocate the Payment Request to the Payment Entry references based on\n
-		    - Allocated Amount.
-		    - Outstanding Amount of Payment Request.\n
-		Payment Request is doc itself and references are the rows of Payment Entry.
-		"""
-		if len(references) == 1:
-			references[0].payment_request = self.name
-			return
-
-		precision = references[0].precision("allocated_amount")
-		outstanding_amount = self.outstanding_amount
-
-		# to manage rows
-		row_number = 1
-		MOVE_TO_NEXT_ROW = 1
-		TO_SKIP_NEW_ROW = 2
-		NEW_ROW_ADDED = False
-
-		while row_number <= len(references):
-			row = references[row_number - 1]
-
-			# update the idx to maintain the order
-			row.idx = row_number
-
-			if outstanding_amount == 0:
-				if not NEW_ROW_ADDED:
-					break
-
-				row_number += MOVE_TO_NEXT_ROW
-				continue
-
-			# allocate the payment request to the row
-			row.payment_request = self.name
-
-			if row.allocated_amount <= outstanding_amount:
-				outstanding_amount = flt(outstanding_amount - row.allocated_amount, precision)
-				row_number += MOVE_TO_NEXT_ROW
-			else:
-				remaining_allocated_amount = flt(row.allocated_amount - outstanding_amount, precision)
-				row.allocated_amount = outstanding_amount
-				outstanding_amount = 0
-
-				# create a new row without PR for remaining unallocated amount
-				new_row = frappe.copy_doc(row)
-				references.insert(row_number, new_row)
-
-				# update new row
-				new_row.idx = row_number + 1
-				new_row.payment_request = None
-				new_row.allocated_amount = remaining_allocated_amount
-
-				NEW_ROW_ADDED = True
-				row_number += TO_SKIP_NEW_ROW
-
 
 @frappe.whitelist(allow_guest=True)
 def make_payment_request(**args):
@@ -515,15 +416,11 @@ def make_payment_request(**args):
 		{"reference_doctype": args.dt, "reference_name": args.dn, "docstatus": 0},
 	)
 
-	# fetches existing payment request `grand_total` amount
-	existing_payment_request_amount = get_existing_payment_request_amount(ref_doc.doctype, ref_doc.name)
+	existing_payment_request_amount = get_existing_payment_request_amount(args.dt, args.dn)
 
 	if existing_payment_request_amount:
 		grand_total -= existing_payment_request_amount
 
-		if not grand_total:
-			frappe.throw(_("Payment Request is already created"))
-
 	if draft_payment_request:
 		frappe.db.set_value(
 			"Payment Request", draft_payment_request, "grand_total", grand_total, update_modified=False
@@ -537,13 +434,6 @@ def make_payment_request(**args):
 				"Outward" if args.get("dt") in ["Purchase Order", "Purchase Invoice"] else "Inward"
 			)
 
-		party_type = args.get("party_type") or "Customer"
-		party_account_currency = ref_doc.get("party_account_currency")
-
-		if not party_account_currency:
-			party_account = get_party_account(party_type, ref_doc.get(party_type.lower()), ref_doc.company)
-			party_account_currency = get_account_currency(party_account)
-
 		pr.update(
 			{
 				"payment_gateway_account": gateway_account.get("name"),
@@ -552,7 +442,6 @@ def make_payment_request(**args):
 				"payment_channel": gateway_account.get("payment_channel"),
 				"payment_request_type": args.get("payment_request_type"),
 				"currency": ref_doc.currency,
-				"party_account_currency": party_account_currency,
 				"grand_total": grand_total,
 				"mode_of_payment": args.mode_of_payment,
 				"email_to": args.recipient_id or ref_doc.owner,
@@ -560,7 +449,7 @@ def make_payment_request(**args):
 				"message": gateway_account.get("message") or get_dummy_message(ref_doc),
 				"reference_doctype": args.dt,
 				"reference_name": args.dn,
-				"party_type": party_type,
+				"party_type": args.get("party_type") or "Customer",
 				"party": args.get("party") or ref_doc.get("customer"),
 				"bank_account": bank_account,
 			}
@@ -603,11 +492,9 @@ def get_amount(ref_doc, payment_account=None):
 	elif dt in ["Sales Invoice", "Purchase Invoice"]:
 		if not ref_doc.get("is_pos"):
 			if ref_doc.party_account_currency == ref_doc.currency:
-				grand_total = flt(ref_doc.rounded_total or ref_doc.grand_total)
+				grand_total = flt(ref_doc.grand_total)
 			else:
-				grand_total = flt(
-					flt(ref_doc.base_rounded_total or ref_doc.base_grand_total) / ref_doc.conversion_rate
-				)
+				grand_total = flt(ref_doc.base_grand_total) / ref_doc.conversion_rate
 		elif dt == "Sales Invoice":
 			for pay in ref_doc.payments:
 				if pay.type == "Phone" and pay.account == payment_account:
@@ -622,27 +509,31 @@ def get_amount(ref_doc, payment_account=None):
 		grand_total = ref_doc.outstanding_amount
 
 	if grand_total > 0:
-		return flt(grand_total, get_currency_precision())
+		return grand_total
 	else:
 		frappe.throw(_("Payment Entry is already created"))
 
 
 def get_existing_payment_request_amount(ref_dt, ref_dn):
 	"""
-	Return the total amount of Payment Requests against a reference document.
+	Get the existing payment request which are unpaid or partially paid for payment channel other than Phone
+	and get the summation of existing paid payment request for Phone payment channel.
 	"""
-	PR = frappe.qb.DocType("Payment Request")
-
-	response = (
-		frappe.qb.from_(PR)
-		.select(Sum(PR.grand_total))
-		.where(PR.reference_doctype == ref_dt)
-		.where(PR.reference_name == ref_dn)
-		.where(PR.docstatus == 1)
-		.run()
+	existing_payment_request_amount = frappe.db.sql(
+		"""
+		select sum(grand_total)
+		from `tabPayment Request`
+		where
+			reference_doctype = %s
+			and reference_name = %s
+			and docstatus = 1
+			and (status != 'Paid'
+			or (payment_channel = 'Phone'
+				and status = 'Paid'))
+	""",
+		(ref_dt, ref_dn),
 	)
-
-	return response[0][0] if response[0] else 0
+	return flt(existing_payment_request_amount[0][0]) if existing_payment_request_amount else 0
 
 
 def get_gateway_details(args):  # nosemgrep
@@ -690,67 +581,42 @@ def make_payment_entry(docname):
 	return doc.create_payment_entry(submit=False).as_dict()
 
 
-def update_payment_requests_as_per_pe_references(references=None, cancel=False):
-	"""
-	Update Payment Request's `Status` and `Outstanding Amount` based on Payment Entry Reference's `Allocated Amount`.
-	"""
-	if not references:
-		return
+def update_payment_req_status(doc, method):
+	from erpnext.accounts.doctype.payment_entry.payment_entry import get_reference_details
 
-	precision = references[0].precision("allocated_amount")
-
-	referenced_payment_requests = frappe.get_all(
-		"Payment Request",
-		filters={"name": ["in", {row.payment_request for row in references if row.payment_request}]},
-		fields=[
-			"name",
-			"grand_total",
-			"outstanding_amount",
-			"payment_request_type",
-		],
-	)
-
-	referenced_payment_requests = {pr.name: pr for pr in referenced_payment_requests}
-
-	for ref in references:
-		if not ref.payment_request:
-			continue
-
-		payment_request = referenced_payment_requests[ref.payment_request]
-		pr_outstanding = payment_request["outstanding_amount"]
-
-		# update outstanding amount
-		new_outstanding_amount = flt(
-			pr_outstanding + ref.allocated_amount if cancel else pr_outstanding - ref.allocated_amount,
-			precision,
-		)
-
-		# to handle same payment request for the multiple allocations
-		payment_request["outstanding_amount"] = new_outstanding_amount
-
-		if not cancel and new_outstanding_amount < 0:
-			frappe.throw(
-				msg=_(
-					"The allocated amount is greater than the outstanding amount of Payment Request {0}"
-				).format(ref.payment_request),
-				title=_("Invalid Allocated Amount"),
-			)
-
-		# update status
-		if new_outstanding_amount == payment_request["grand_total"]:
-			status = "Initiated" if payment_request["payment_request_type"] == "Outward" else "Requested"
-		elif new_outstanding_amount == 0:
-			status = "Paid"
-		elif new_outstanding_amount > 0:
-			status = "Partially Paid"
-
-		# update database
-		frappe.db.set_value(
+	for ref in doc.references:
+		payment_request_name = frappe.db.get_value(
 			"Payment Request",
-			ref.payment_request,
-			{"outstanding_amount": new_outstanding_amount, "status": status},
+			{
+				"reference_doctype": ref.reference_doctype,
+				"reference_name": ref.reference_name,
+				"docstatus": 1,
+			},
 		)
 
+		if payment_request_name:
+			ref_details = get_reference_details(
+				ref.reference_doctype,
+				ref.reference_name,
+				doc.party_account_currency,
+				doc.party_type,
+				doc.party,
+			)
+			pay_req_doc = frappe.get_doc("Payment Request", payment_request_name)
+			status = pay_req_doc.status
+
+			if status != "Paid" and not ref_details.outstanding_amount:
+				status = "Paid"
+			elif status != "Partially Paid" and ref_details.outstanding_amount != ref_details.total_amount:
+				status = "Partially Paid"
+			elif ref_details.outstanding_amount == ref_details.total_amount:
+				if pay_req_doc.payment_request_type == "Outward":
+					status = "Initiated"
+				elif pay_req_doc.payment_request_type == "Inward":
+					status = "Requested"
+
+			pay_req_doc.db_set("status", status)
+
 
 def get_dummy_message(doc):
 	return frappe.render_template(
@@ -833,35 +699,3 @@ def validate_payment(doc, method=None):
 			doc.reference_docname
 		)
 	)
-
-
-@frappe.whitelist()
-def get_open_payment_requests_query(doctype, txt, searchfield, start, page_len, filters):
-	# permission checks in `get_list()`
-	reference_doctype = filters.get("reference_doctype")
-	reference_name = filters.get("reference_doctype")
-
-	if not reference_doctype or not reference_name:
-		return []
-
-	open_payment_requests = frappe.get_list(
-		"Payment Request",
-		filters={
-			"reference_doctype": filters["reference_doctype"],
-			"reference_name": filters["reference_name"],
-			"status": ["!=", "Paid"],
-			"outstanding_amount": ["!=", 0],  # for compatibility with old data
-			"docstatus": 1,
-		},
-		fields=["name", "grand_total", "outstanding_amount"],
-		order_by="transaction_date ASC,creation ASC",
-	)
-
-	return [
-		(
-			pr.name,
-			_("<strong>Grand Total:</strong> {0}").format(pr.grand_total),
-			_("<strong>Outstanding Amount:</strong> {0}").format(pr.outstanding_amount),
-		)
-		for pr in open_payment_requests
-	]

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -1,23 +1,18 @@
 # Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-import re
 import unittest
 
 import frappe
-from frappe.tests.utils import FrappeTestCase, change_settings
 
-from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_terms_template
 from erpnext.accounts.doctype.payment_request.payment_request import make_payment_request
 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.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.setup.utils import get_exchange_rate
 
 test_dependencies = ["Currency Exchange", "Journal Entry", "Contact", "Address"]
 
-
 payment_gateway = {"doctype": "Payment Gateway", "gateway": "_Test Gateway"}
 
 payment_method = [
@@ -37,7 +32,7 @@ payment_method = [
 ]
 
 
-class TestPaymentRequest(FrappeTestCase):
+class TestPaymentRequest(unittest.TestCase):
 	def setUp(self):
 		if not frappe.db.get_value("Payment Gateway", payment_gateway["gateway"], "name"):
 			frappe.get_doc(payment_gateway).insert(ignore_permissions=True)
@@ -265,262 +260,3 @@ class TestPaymentRequest(FrappeTestCase):
 		# Try to make Payment Request more than SO amount, should give validation
 		pr2.grand_total = 900
 		self.assertRaises(frappe.ValidationError, pr2.save)
-
-	def test_conversion_on_foreign_currency_accounts(self):
-		po_doc = create_purchase_order(supplier="_Test Supplier USD", currency="USD", do_not_submit=1)
-		po_doc.conversion_rate = 80
-		po_doc.items[0].qty = 1
-		po_doc.items[0].rate = 10
-		po_doc.save().submit()
-
-		pr = make_payment_request(dt=po_doc.doctype, dn=po_doc.name, recipient_id="nabin@erpnext.com")
-		pr = frappe.get_doc(pr).save().submit()
-
-		pe = pr.create_payment_entry()
-		self.assertEqual(pe.base_paid_amount, 800)
-		self.assertEqual(pe.paid_amount, 800)
-		self.assertEqual(pe.base_received_amount, 800)
-		self.assertEqual(pe.received_amount, 10)
-
-	def test_multiple_payment_if_partially_paid_for_same_currency(self):
-		so = make_sales_order(currency="INR", qty=1, rate=1000)
-
-		pr = make_payment_request(
-			dt="Sales Order",
-			dn=so.name,
-			mute_email=1,
-			submit_doc=1,
-			return_doc=1,
-		)
-
-		self.assertEqual(pr.grand_total, 1000)
-		self.assertEqual(pr.outstanding_amount, pr.grand_total)
-		self.assertEqual(pr.party_account_currency, pr.currency)  # INR
-
-		so.load_from_db()
-
-		# to make partial payment
-		pe = pr.create_payment_entry(submit=False)
-		pe.paid_amount = 200
-		pe.references[0].allocated_amount = 200
-		pe.submit()
-
-		self.assertEqual(pe.references[0].payment_request, pr.name)
-
-		so.load_from_db()
-
-		pr.load_from_db()
-		self.assertEqual(pr.status, "Partially Paid")
-		self.assertEqual(pr.outstanding_amount, 800)
-		self.assertEqual(pr.grand_total, 1000)
-
-		# complete payment
-		pe = pr.create_payment_entry()
-
-		self.assertEqual(pe.paid_amount, 800)  # paid amount set from pr's outstanding amount
-		self.assertEqual(pe.references[0].allocated_amount, 800)
-		self.assertEqual(pe.references[0].outstanding_amount, 800)  # for Orders it is not zero
-		self.assertEqual(pe.references[0].payment_request, pr.name)
-
-		so.load_from_db()
-
-		pr.load_from_db()
-		self.assertEqual(pr.status, "Paid")
-		self.assertEqual(pr.outstanding_amount, 0)
-		self.assertEqual(pr.grand_total, 1000)
-
-		# creating a more payment Request must not allowed
-		self.assertRaisesRegex(
-			frappe.exceptions.ValidationError,
-			re.compile(r"Payment Request is already created"),
-			make_payment_request,
-			dt="Sales Order",
-			dn=so.name,
-			mute_email=1,
-			submit_doc=1,
-			return_doc=1,
-		)
-
-	@change_settings("Accounts Settings", {"allow_multi_currency_invoices_against_single_party_account": 1})
-	def test_multiple_payment_if_partially_paid_for_multi_currency(self):
-		pi = make_purchase_invoice(currency="USD", conversion_rate=50, qty=1, rate=100, do_not_save=1)
-		pi.credit_to = "Creditors - _TC"
-		pi.submit()
-
-		pr = make_payment_request(
-			dt="Purchase Invoice",
-			dn=pi.name,
-			mute_email=1,
-			submit_doc=1,
-			return_doc=1,
-		)
-
-		# 100 USD -> 5000 INR
-		self.assertEqual(pr.grand_total, 100)
-		self.assertEqual(pr.outstanding_amount, 5000)
-		self.assertEqual(pr.currency, "USD")
-		self.assertEqual(pr.party_account_currency, "INR")
-		self.assertEqual(pr.status, "Initiated")
-
-		# to make partial payment
-		pe = pr.create_payment_entry(submit=False)
-		pe.paid_amount = 2000
-		pe.references[0].allocated_amount = 2000
-		pe.submit()
-
-		self.assertEqual(pe.references[0].payment_request, pr.name)
-
-		pr.load_from_db()
-		self.assertEqual(pr.status, "Partially Paid")
-		self.assertEqual(pr.outstanding_amount, 3000)
-		self.assertEqual(pr.grand_total, 100)
-
-		# complete payment
-		pe = pr.create_payment_entry()
-		self.assertEqual(pe.paid_amount, 3000)  # paid amount set from pr's outstanding amount
-		self.assertEqual(pe.references[0].allocated_amount, 3000)
-		self.assertEqual(pe.references[0].outstanding_amount, 0)  # for Invoices it will zero
-		self.assertEqual(pe.references[0].payment_request, pr.name)
-
-		pr.load_from_db()
-		self.assertEqual(pr.status, "Paid")
-		self.assertEqual(pr.outstanding_amount, 0)
-		self.assertEqual(pr.grand_total, 100)
-
-		# creating a more payment Request must not allowed
-		self.assertRaisesRegex(
-			frappe.exceptions.ValidationError,
-			re.compile(r"Payment Request is already created"),
-			make_payment_request,
-			dt="Purchase Invoice",
-			dn=pi.name,
-			mute_email=1,
-			submit_doc=1,
-			return_doc=1,
-		)
-
-	def test_single_payment_with_payment_term_for_same_currency(self):
-		create_payment_terms_template()
-
-		po = create_purchase_order(do_not_save=1, currency="INR", qty=1, rate=20000)
-		po.payment_terms_template = "Test Receivable Template"  # 84.746 and 15.254
-		po.save()
-		po.submit()
-
-		pr = make_payment_request(
-			dt="Purchase Order",
-			dn=po.name,
-			mute_email=1,
-			submit_doc=1,
-			return_doc=1,
-		)
-
-		self.assertEqual(pr.grand_total, 20000)
-		self.assertEqual(pr.outstanding_amount, pr.grand_total)
-		self.assertEqual(pr.party_account_currency, pr.currency)  # INR
-		self.assertEqual(pr.status, "Initiated")
-
-		po.load_from_db()
-
-		pe = pr.create_payment_entry()
-
-		self.assertEqual(len(pe.references), 2)
-		self.assertEqual(pe.paid_amount, 20000)
-
-		# check 1st payment term
-		self.assertEqual(pe.references[0].allocated_amount, 16949.2)
-		self.assertEqual(pe.references[0].payment_request, pr.name)
-
-		# check 2nd payment term
-		self.assertEqual(pe.references[1].allocated_amount, 3050.8)
-		self.assertEqual(pe.references[1].payment_request, pr.name)
-
-		po.load_from_db()
-
-		pr.load_from_db()
-		self.assertEqual(pr.status, "Paid")
-		self.assertEqual(pr.outstanding_amount, 0)
-		self.assertEqual(pr.grand_total, 20000)
-
-	@change_settings("Accounts Settings", {"allow_multi_currency_invoices_against_single_party_account": 1})
-	def test_single_payment_with_payment_term_for_multi_currency(self):
-		create_payment_terms_template()
-
-		si = create_sales_invoice(
-			do_not_save=1, currency="USD", debit_to="Debtors - _TC", qty=1, rate=200, conversion_rate=50
-		)
-		si.payment_terms_template = "Test Receivable Template"  # 84.746 and 15.254
-		si.save()
-		si.submit()
-
-		pr = make_payment_request(
-			dt="Sales Invoice",
-			dn=si.name,
-			mute_email=1,
-			submit_doc=1,
-			return_doc=1,
-		)
-
-		# 200 USD -> 10000 INR
-		self.assertEqual(pr.grand_total, 200)
-		self.assertEqual(pr.outstanding_amount, 10000)
-		self.assertEqual(pr.currency, "USD")
-		self.assertEqual(pr.party_account_currency, "INR")
-
-		pe = pr.create_payment_entry()
-		self.assertEqual(len(pe.references), 2)
-		self.assertEqual(pe.paid_amount, 10000)
-
-		# check 1st payment term
-		# convert it via dollar and conversion_rate
-		self.assertEqual(pe.references[0].allocated_amount, 8474.5)  # multi currency conversion
-		self.assertEqual(pe.references[0].payment_request, pr.name)
-
-		# check 2nd payment term
-		self.assertEqual(pe.references[1].allocated_amount, 1525.5)  # multi currency conversion
-		self.assertEqual(pe.references[1].payment_request, pr.name)
-
-		pr.load_from_db()
-		self.assertEqual(pr.status, "Paid")
-		self.assertEqual(pr.outstanding_amount, 0)
-		self.assertEqual(pr.grand_total, 200)
-
-	def test_payment_cancel_process(self):
-		so = make_sales_order(currency="INR", qty=1, rate=1000)
-
-		pr = make_payment_request(
-			dt="Sales Order",
-			dn=so.name,
-			mute_email=1,
-			submit_doc=1,
-			return_doc=1,
-		)
-
-		self.assertEqual(pr.grand_total, 1000)
-		self.assertEqual(pr.outstanding_amount, pr.grand_total)
-
-		so.load_from_db()
-
-		pe = pr.create_payment_entry(submit=False)
-		pe.paid_amount = 800
-		pe.references[0].allocated_amount = 800
-		pe.submit()
-
-		self.assertEqual(pe.references[0].payment_request, pr.name)
-
-		so.load_from_db()
-
-		pr.load_from_db()
-		self.assertEqual(pr.status, "Partially Paid")
-		self.assertEqual(pr.outstanding_amount, 200)
-		self.assertEqual(pr.grand_total, 1000)
-
-		# cancelling PE
-		pe.cancel()
-
-		pr.load_from_db()
-		self.assertEqual(pr.status, "Requested")
-		self.assertEqual(pr.outstanding_amount, 1000)
-		self.assertEqual(pr.grand_total, 1000)
-
-		so.load_from_db()

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -40,7 +40,7 @@ class PeriodClosingVoucher(AccountsController):
 		)
 		if gle_count > 5000:
 			frappe.enqueue(
-				process_cancellation,
+				make_reverse_gl_entries,
 				voucher_type="Period Closing Voucher",
 				voucher_no=self.name,
 				queue="long",
@@ -51,7 +51,9 @@ class PeriodClosingVoucher(AccountsController):
 				alert=True,
 			)
 		else:
-			process_cancellation(voucher_type="Period Closing Voucher", voucher_no=self.name)
+			make_reverse_gl_entries(voucher_type="Period Closing Voucher", voucher_no=self.name)
+
+		self.delete_closing_entries()
 
 	def validate_future_closing_vouchers(self):
 		if frappe.db.exists(
@@ -64,6 +66,12 @@ class PeriodClosingVoucher(AccountsController):
 				)
 			)
 
+	def delete_closing_entries(self):
+		closing_balance = frappe.qb.DocType("Account Closing Balance")
+		frappe.qb.from_(closing_balance).delete().where(
+			closing_balance.period_closing_voucher == self.name
+		).run()
+
 	def validate_account_head(self):
 		closing_account_type = frappe.get_cached_value("Account", self.closing_account_head, "root_type")
 
@@ -128,7 +136,14 @@ class PeriodClosingVoucher(AccountsController):
 		closing_entries = self.get_grouped_gl_entries(get_opening_entries=get_opening_entries)
 		if len(gl_entries + closing_entries) > 3000:
 			frappe.enqueue(
-				process_gl_and_closing_entries,
+				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,
@@ -142,9 +157,8 @@ class PeriodClosingVoucher(AccountsController):
 				alert=True,
 			)
 		else:
-			process_gl_and_closing_entries(
-				gl_entries, closing_entries, self.name, self.company, self.posting_date
-			)
+			process_gl_entries(gl_entries, self.name)
+			process_closing_entries(gl_entries, closing_entries, self.name, self.company, self.posting_date)
 
 	def get_grouped_gl_entries(self, get_opening_entries=False):
 		closing_entries = []
@@ -309,10 +323,9 @@ class PeriodClosingVoucher(AccountsController):
 
 		if get_opening_entries:
 			query = query.where(
-				(  # noqa: UP034
-					(gl_entry.posting_date.between(self.get("year_start_date"), self.posting_date))
-					| (gl_entry.is_opening == "Yes")
-				)
+				gl_entry.posting_date.between(self.get("year_start_date"), self.posting_date)
+				| gl_entry.is_opening
+				== "Yes"
 			)
 		else:
 			query = query.where(
@@ -330,16 +343,12 @@ class PeriodClosingVoucher(AccountsController):
 		return query.run(as_dict=1)
 
 
-def process_gl_and_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,
-	)
+def process_gl_entries(gl_entries, voucher_name):
 	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()
@@ -347,21 +356,26 @@ def process_gl_and_closing_entries(gl_entries, closing_entries, voucher_name, co
 		frappe.db.set_value("Period Closing Voucher", voucher_name, "gle_processing_status", "Failed")
 
 
-def process_cancellation(voucher_type, voucher_no):
+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
 
 	try:
 		make_reverse_gl_entries(voucher_type=voucher_type, voucher_no=voucher_no)
-		delete_closing_entries(voucher_no)
 		frappe.db.set_value("Period Closing Voucher", voucher_no, "gle_processing_status", "Completed")
 	except Exception as e:
 		frappe.db.rollback()
 		frappe.log_error(e)
 		frappe.db.set_value("Period Closing Voucher", voucher_no, "gle_processing_status", "Failed")
-
-
-def delete_closing_entries(voucher_no):
-	closing_balance = frappe.qb.DocType("Account Closing Balance")
-	frappe.qb.from_(closing_balance).delete().where(
-		closing_balance.period_closing_voucher == voucher_no
-	).run()

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.js

@@ -80,10 +80,8 @@ frappe.ui.form.on("POS Closing Entry", {
 		) {
 			reset_values(frm);
 			frappe.run_serially([
-				() => frappe.dom.freeze(__("Loading Invoices! Please Wait...")),
 				() => frm.trigger("set_opening_amounts"),
 				() => frm.trigger("get_pos_invoices"),
-				() => frappe.dom.unfreeze(),
 			]);
 		}
 	},

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -379,7 +379,7 @@ class POSInvoice(SalesInvoice):
 			if self.is_return and entry.amount > 0:
 				frappe.throw(_("Row #{0} (Payment Table): Amount must be negative").format(entry.idx))
 
-		if self.is_return and self.docstatus != 0:
+		if self.is_return:
 			invoice_total = self.rounded_total or self.grand_total
 			if total_amount_in_payments and total_amount_in_payments < invoice_total:
 				frappe.throw(_("Total payments amount can't be greater than {}").format(-invoice_total))

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -87,7 +87,7 @@ class TestPOSInvoice(unittest.TestCase):
 
 		inv.save()
 
-		self.assertEqual(inv.net_total, 4298.24)
+		self.assertEqual(inv.net_total, 4298.25)
 		self.assertEqual(inv.grand_total, 4900.00)
 
 	def test_tax_calculation_with_multiple_items(self):

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

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

erpnext/accounts/doctype/pos_invoice_merge_log/test_pos_invoice_merge_log.py

@@ -340,7 +340,7 @@ class TestPOSInvoiceMergeLog(unittest.TestCase):
 			inv.load_from_db()
 			consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
 			self.assertEqual(consolidated_invoice.status, "Return")
-			self.assertEqual(consolidated_invoice.rounding_adjustment, -0.002)
+			self.assertEqual(consolidated_invoice.rounding_adjustment, -0.001)
 
 		finally:
 			frappe.set_user("Administrator")

erpnext/accounts/doctype/pricing_rule/pricing_rule.json

@@ -419,8 +419,7 @@
    "depends_on": "eval:doc.rate_or_discount==\"Rate\"",
    "fieldname": "rate",
    "fieldtype": "Currency",
-   "label": "Rate",
-   "options": "currency"
+   "label": "Rate"
   },
   {
    "default": "0",
@@ -648,7 +647,7 @@
  "icon": "fa fa-gift",
  "idx": 1,
  "links": [],
- "modified": "2024-09-16 18:14:51.314765",
+ "modified": "2024-05-17 13:16:34.496704",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Pricing Rule",
@@ -710,4 +709,4 @@
  "sort_order": "DESC",
  "states": [],
  "title_field": "title"
-}
+}

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -5,17 +5,14 @@
 import unittest
 
 import frappe
-from frappe.tests.utils import FrappeTestCase, change_settings
 
-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.controllers.sales_and_purchase_return import make_return_doc
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.stock.doctype.item.test_item import make_item
 from erpnext.stock.get_item_details import get_item_details
 
 
-class TestPricingRule(FrappeTestCase):
+class TestPricingRule(unittest.TestCase):
 	def setUp(self):
 		delete_existing_pricing_rules()
 		setup_pricing_rule_data()
@@ -981,12 +978,6 @@ class TestPricingRule(FrappeTestCase):
 		self.assertEqual(so.items[1].item_code, "_Test Item")
 		self.assertEqual(so.items[1].qty, 3)
 
-		so = make_sales_order(item_code="_Test Item", qty=5, do_not_submit=1)
-		so.items[0].qty = 1
-		del so.items[-1]
-		so.save()
-		self.assertEqual(len(so.items), 1)
-
 	def test_apply_multiple_pricing_rules_for_discount_percentage_and_amount(self):
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule 1")
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule 2")
@@ -1108,69 +1099,6 @@ class TestPricingRule(FrappeTestCase):
 		pricing_rule.is_recursive = True
 		self.assertRaises(frappe.ValidationError, pricing_rule.save)
 
-	def test_ignore_pricing_rule_for_credit_note(self):
-		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule")
-		pricing_rule = make_pricing_rule(
-			discount_percentage=20,
-			selling=1,
-			buying=1,
-			priority=1,
-			title="_Test Pricing Rule",
-		)
-
-		si = create_sales_invoice(do_not_submit=True, customer="_Test Customer 1", qty=1)
-		item = si.items[0]
-		si.submit()
-		self.assertEqual(item.discount_percentage, 20)
-		self.assertEqual(item.rate, 80)
-
-		# change discount on pricing rule
-		pricing_rule.discount_percentage = 30
-		pricing_rule.save()
-
-		credit_note = make_return_doc(si.doctype, si.name)
-		credit_note.save()
-		self.assertEqual(credit_note.ignore_pricing_rule, 1)
-		self.assertEqual(credit_note.pricing_rules, [])
-		self.assertEqual(credit_note.items[0].discount_percentage, 20)
-		self.assertEqual(credit_note.items[0].rate, 80)
-		self.assertEqual(credit_note.items[0].pricing_rules, None)
-
-		credit_note.delete()
-		si.cancel()
-
-	def test_ignore_pricing_rule_for_debit_note(self):
-		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule")
-		pricing_rule = make_pricing_rule(
-			discount_percentage=20,
-			buying=1,
-			priority=1,
-			title="_Test Pricing Rule",
-		)
-
-		pi = make_purchase_invoice(do_not_submit=True, supplier="_Test Supplier 1", qty=1)
-		item = pi.items[0]
-		pi.submit()
-		self.assertEqual(item.discount_percentage, 20)
-		self.assertEqual(item.rate, 40)
-
-		# change discount on pricing rule
-		pricing_rule.discount_percentage = 30
-		pricing_rule.save()
-
-		# create debit note from purchase invoice
-		debit_note = make_return_doc(pi.doctype, pi.name)
-		debit_note.save()
-
-		self.assertEqual(debit_note.ignore_pricing_rule, 1)
-		self.assertEqual(debit_note.pricing_rules, [])
-		self.assertEqual(debit_note.items[0].discount_percentage, 20)
-		self.assertEqual(debit_note.items[0].rate, 40)
-		self.assertEqual(debit_note.items[0].pricing_rules, None)
-
-		debit_note.delete()
-		pi.cancel()
-
 
 test_dependencies = ["Campaign"]
 

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -485,7 +485,7 @@ def get_qty_and_rate_for_other_item(doc, pr_doc, pricing_rules, row_item):
 				continue
 
 			stock_qty = row.get("qty") * (row.get("conversion_factor") or 1.0)
-			amount = stock_qty * (flt(row.get("price_list_rate")) or flt(row.get("rate")))
+			amount = stock_qty * (row.get("price_list_rate") or row.get("rate"))
 			pricing_rules = filter_pricing_rules_for_qty_amount(stock_qty, amount, pricing_rules, row)
 
 			if pricing_rules and pricing_rules[0]:
@@ -644,9 +644,6 @@ def get_product_discount_rule(pricing_rule, item_details, args=None, doc=None):
 			if pricing_rule.round_free_qty:
 				qty = math.floor(qty)
 
-	if not qty:
-		return
-
 	free_item_data_args = {
 		"item_code": free_item,
 		"qty": qty,
@@ -715,11 +712,14 @@ def get_pricing_rule_items(pr_doc, other_items=False) -> list:
 
 def validate_coupon_code(coupon_name):
 	coupon = frappe.get_doc("Coupon Code", coupon_name)
-	if coupon.valid_from and coupon.valid_from > getdate(today()):
-		frappe.throw(_("Sorry, this coupon code's validity has not started"))
-	elif coupon.valid_upto and coupon.valid_upto < getdate(today()):
-		frappe.throw(_("Sorry, this coupon code's validity has expired"))
-	elif coupon.maximum_use and coupon.used >= coupon.maximum_use:
+
+	if coupon.valid_from:
+		if coupon.valid_from > getdate(today()):
+			frappe.throw(_("Sorry, this coupon code's validity has not started"))
+	elif coupon.valid_upto:
+		if coupon.valid_upto < getdate(today()):
+			frappe.throw(_("Sorry, this coupon code's validity has expired"))
+	elif coupon.used >= coupon.maximum_use:
 		frappe.throw(_("Sorry, this coupon code is no longer valid"))
 
 

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.js

@@ -20,17 +20,6 @@ frappe.ui.form.on("Process Payment Reconciliation", {
 				},
 			};
 		});
-
-		frm.set_query("default_advance_account", function (doc) {
-			return {
-				filters: {
-					company: doc.company,
-					is_group: 0,
-					account_type: doc.party_type == "Customer" ? "Receivable" : "Payable",
-					root_type: doc.party_type == "Customer" ? "Liability" : "Asset",
-				},
-			};
-		});
 		frm.set_query("cost_center", function (doc) {
 			return {
 				filters: {
@@ -113,7 +102,6 @@ frappe.ui.form.on("Process Payment Reconciliation", {
 	company(frm) {
 		frm.set_value("party", "");
 		frm.set_value("receivable_payable_account", "");
-		frm.set_value("default_advance_account", "");
 	},
 	party_type(frm) {
 		frm.set_value("party", "");
@@ -121,7 +109,6 @@ frappe.ui.form.on("Process Payment Reconciliation", {
 
 	party(frm) {
 		frm.set_value("receivable_payable_account", "");
-		frm.set_value("default_advance_account", "");
 		if (!frm.doc.receivable_payable_account && frm.doc.party_type && frm.doc.party) {
 			return frappe.call({
 				method: "erpnext.accounts.party.get_party_account",
@@ -129,16 +116,10 @@ frappe.ui.form.on("Process Payment Reconciliation", {
 					company: frm.doc.company,
 					party_type: frm.doc.party_type,
 					party: frm.doc.party,
-					include_advance: 1,
 				},
 				callback: (r) => {
 					if (!r.exc && r.message) {
-						if (typeof r.message === "string") {
-							frm.set_value("receivable_payable_account", r.message);
-						} else if (Array.isArray(r.message)) {
-							frm.set_value("receivable_payable_account", r.message[0]);
-							frm.set_value("default_advance_account", r.message[1]);
-						}
+						frm.set_value("receivable_payable_account", r.message);
 					}
 					frm.refresh();
 				},

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.json

@@ -13,7 +13,6 @@
   "column_break_io6c",
   "party",
   "receivable_payable_account",
-  "default_advance_account",
   "filter_section",
   "from_invoice_date",
   "to_invoice_date",
@@ -142,23 +141,12 @@
   {
    "fieldname": "section_break_a8yx",
    "fieldtype": "Section Break"
-  },
-  {
-   "depends_on": "eval:doc.party",
-   "description": "Only 'Payment Entries' made against this advance account are supported.",
-   "documentation_url": "https://docs.erpnext.com/docs/user/manual/en/advance-in-separate-party-account",
-   "fieldname": "default_advance_account",
-   "fieldtype": "Link",
-   "label": "Default Advance Account",
-   "mandatory_depends_on": "doc.party_type",
-   "options": "Account",
-   "reqd": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-08-27 14:48:56.715320",
+ "modified": "2023-08-11 10:56:51.699137",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Payment Reconciliation",
@@ -192,4 +180,4 @@
  "sort_order": "DESC",
  "states": [],
  "title_field": "company"
-}
+}

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.py

@@ -76,7 +76,6 @@ def get_pr_instance(doc: str):
 		"party_type",
 		"party",
 		"receivable_payable_account",
-		"default_advance_account",
 		"from_invoice_date",
 		"to_invoice_date",
 		"from_payment_date",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -16,7 +16,6 @@
   "cost_center",
   "territory",
   "ignore_exchange_rate_revaluation_journals",
-  "ignore_cr_dr_notes",
   "column_break_14",
   "to_date",
   "finance_book",
@@ -25,7 +24,6 @@
   "payment_terms_template",
   "sales_partner",
   "sales_person",
-  "show_remarks",
   "based_on_payment_terms",
   "section_break_3",
   "customer_collection",
@@ -383,22 +381,10 @@
    "fieldname": "ignore_exchange_rate_revaluation_journals",
    "fieldtype": "Check",
    "label": "Ignore Exchange Rate Revaluation Journals"
-  },
-  {
-   "default": "0",
-   "fieldname": "ignore_cr_dr_notes",
-   "fieldtype": "Check",
-   "label": "Ignore System Generated Credit / Debit Notes"
-  },
-  {
-   "default": "0",
-   "fieldname": "show_remarks",
-   "fieldtype": "Check",
-   "label": "Show Remarks"
   }
  ],
  "links": [],
- "modified": "2024-10-18 17:51:39.108481",
+ "modified": "2023-12-18 12:20:08.965120",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -79,9 +79,6 @@ def get_statement_dict(doc, get_statement_dict=False):
 		if doc.ignore_exchange_rate_revaluation_journals:
 			filters.update({"ignore_err": True})
 
-		if doc.ignore_cr_dr_notes:
-			filters.update({"ignore_cr_dr_notes": True})
-
 		if doc.report == "General Ledger":
 			filters.update(get_gl_filters(doc, entry, tax_id, presentation_currency))
 			col, res = get_soa(filters)
@@ -132,7 +129,6 @@ def get_common_filters(doc):
 			"finance_book": doc.finance_book if doc.finance_book else None,
 			"account": [doc.account] if doc.account else None,
 			"cost_center": [cc.cost_center_name for cc in doc.cost_center],
-			"show_remarks": doc.show_remarks,
 		}
 	)
 

erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py

@@ -5,8 +5,6 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.query_builder import Criterion
-from frappe.query_builder.functions import IfNull
 
 pricing_rule_fields = [
 	"apply_on",
@@ -93,50 +91,22 @@ class PromotionalScheme(Document):
 		if self.is_new():
 			return
 
-		invalid_pricing_rule = self.get_invalid_pricing_rules()
+		transaction_exists = False
+		docnames = []
 
-		if not invalid_pricing_rule:
+		# If user has changed applicable for
+		if self.get_doc_before_save() and self.get_doc_before_save().applicable_for == self.applicable_for:
 			return
 
-		if frappe.db.exists(
-			"Pricing Rule Detail",
-			{
-				"pricing_rule": ["in", invalid_pricing_rule],
-				"docstatus": ["<", 2],
-			},
-		):
-			raise_for_transaction_exists(self.name)
+		docnames = frappe.get_all("Pricing Rule", filters={"promotional_scheme": self.name})
 
-		for doc in invalid_pricing_rule:
-			frappe.delete_doc("Pricing Rule", doc)
+		for docname in docnames:
+			if frappe.db.exists("Pricing Rule Detail", {"pricing_rule": docname.name, "docstatus": ("<", 2)}):
+				raise_for_transaction_exists(self.name)
 
-		frappe.msgprint(
-			_("The following invalid Pricing Rules are deleted:")
-			+ "<br><br><ul><li>"
-			+ "</li><li>".join(invalid_pricing_rule)
-			+ "</li></ul>"
-		)
-
-	def get_invalid_pricing_rules(self):
-		pr = frappe.qb.DocType("Pricing Rule")
-		conditions = []
-		conditions.append(pr.promotional_scheme == self.name)
-
-		if self.applicable_for:
-			applicable_for = frappe.scrub(self.applicable_for)
-			applicable_for_list = [d.get(applicable_for) for d in self.get(applicable_for)]
-
-			conditions.append(
-				(IfNull(pr.applicable_for, "") != self.applicable_for)
-				| (
-					(IfNull(pr.applicable_for, "") == self.applicable_for)
-					& IfNull(pr[applicable_for], "").notin(applicable_for_list)
-				)
-			)
-		else:
-			conditions.append(IfNull(pr.applicable_for, "") != "")
-
-		return frappe.qb.from_(pr).select(pr.name).where(Criterion.all(conditions)).run(pluck=True)
+		if docnames and not transaction_exists:
+			for docname in docnames:
+				frappe.delete_doc("Pricing Rule", docname.name)
 
 	def on_update(self):
 		self.validate()

erpnext/accounts/doctype/promotional_scheme/test_promotional_scheme.py

@@ -90,31 +90,6 @@ class TestPromotionalScheme(unittest.TestCase):
 		price_rules = frappe.get_all("Pricing Rule", filters={"promotional_scheme": ps.name})
 		self.assertEqual(price_rules, [])
 
-	def test_change_applicable_for_values_in_promotional_scheme(self):
-		ps = make_promotional_scheme(applicable_for="Customer", customer="_Test Customer")
-		ps.append("customer", {"customer": "_Test Customer 2"})
-		ps.save()
-
-		price_rules = frappe.get_all(
-			"Pricing Rule", filters={"promotional_scheme": ps.name, "applicable_for": "Customer"}
-		)
-		self.assertTrue(len(price_rules), 2)
-
-		ps.set("customer", [])
-		ps.append("customer", {"customer": "_Test Customer 2"})
-		ps.save()
-
-		price_rules = frappe.get_all(
-			"Pricing Rule",
-			filters={
-				"promotional_scheme": ps.name,
-				"applicable_for": "Customer",
-				"customer": "_Test Customer",
-			},
-		)
-		self.assertEqual(price_rules, [])
-		frappe.delete_doc("Promotional Scheme", ps.name)
-
 	def test_min_max_amount_configuration(self):
 		ps = make_promotional_scheme()
 		ps.price_discount_slabs[0].min_amount = 10

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -25,13 +25,6 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 				}
 			};
 		});
-
-		this.frm.set_query("expense_account", "items", function () {
-			return {
-				query: "erpnext.controllers.queries.get_expense_account",
-				filters: { company: doc.company },
-			};
-		});
 	}
 
 	onload() {
@@ -310,11 +303,8 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 				party_type: "Supplier",
 				account: this.frm.doc.credit_to,
 				price_list: this.frm.doc.buying_price_list,
-				fetch_payment_terms_template: cint(
-					(this.frm.doc.is_return == 0) & !this.frm.doc.ignore_default_payment_terms_template
-				),
-			},
-			function () {
+				fetch_payment_terms_template: cint(!this.frm.doc.ignore_default_payment_terms_template)
+			}, function() {
 				me.apply_pricing_rule();
 				me.frm.doc.apply_tds = me.frm.supplier_tds ? 1 : 0;
 				me.frm.doc.tax_withholding_category = me.frm.supplier_tds;
@@ -479,6 +469,13 @@ cur_frm.fields_dict['select_print_heading'].get_query = function(doc, cdt, cdn)
 	}
 }
 
+cur_frm.set_query("expense_account", "items", function(doc) {
+	return {
+		query: "erpnext.controllers.queries.get_expense_account",
+		filters: {'company': doc.company }
+	}
+});
+
 cur_frm.set_query("wip_composite_asset", "items", function() {
 	return {
 		filters: {'is_composite_asset': 1, 'docstatus': 0 }

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -1128,14 +1128,12 @@
    "label": "Payment Terms"
   },
   {
-   "depends_on": "eval:(!doc.is_paid && !doc.is_return)",
    "fieldname": "payment_terms_template",
    "fieldtype": "Link",
    "label": "Payment Terms Template",
    "options": "Payment Terms Template"
   },
   {
-   "depends_on": "eval:(!doc.is_paid && !doc.is_return)",
    "fieldname": "payment_schedule",
    "fieldtype": "Table",
    "label": "Payment Schedule",
@@ -1267,7 +1265,6 @@
    "fieldtype": "Select",
    "in_standard_filter": 1,
    "label": "Status",
-   "no_copy": 1,
    "options": "\nDraft\nReturn\nDebit Note Issued\nSubmitted\nPaid\nPartly Paid\nUnpaid\nOverdue\nCancelled\nInternal Transfer",
    "print_hide": 1
   },
@@ -1613,7 +1610,7 @@
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-10-25 18:13:01.944477",
+ "modified": "2024-07-25 19:42:36.931278",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -369,21 +369,6 @@ class PurchaseInvoice(BuyingController):
 						item.expense_account = stock_not_billed_account
 			elif item.is_fixed_asset:
 				account = None
-				if not item.pr_detail and item.po_detail:
-					receipt_item = frappe.get_cached_value(
-						"Purchase Receipt Item",
-						{
-							"purchase_order": item.purchase_order,
-							"purchase_order_item": item.po_detail,
-							"docstatus": 1,
-						},
-						["name", "parent"],
-						as_dict=1,
-					)
-					if receipt_item:
-						item.pr_detail = receipt_item.name
-						item.purchase_receipt = receipt_item.parent
-
 				if item.pr_detail:
 					if not self.asset_received_but_not_billed:
 						self.asset_received_but_not_billed = self.get_company_default(

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -10,10 +10,7 @@ import erpnext
 from erpnext.accounts.doctype.account.test_account import create_account, get_inventory_account
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.buying.doctype.purchase_order.purchase_order import get_mapped_purchase_invoice
-from erpnext.buying.doctype.purchase_order.purchase_order import make_purchase_invoice as make_pi_from_po
-from erpnext.buying.doctype.purchase_order.test_purchase_order import (
-	create_purchase_order,
-)
+from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
 from erpnext.buying.doctype.supplier.test_supplier import create_supplier
 from erpnext.controllers.accounts_controller import get_payment_terms
 from erpnext.controllers.buying_controller import QtyMismatchError

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -280,12 +280,8 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends e
 				party_type: "Customer",
 				account: this.frm.doc.debit_to,
 				price_list: this.frm.doc.selling_price_list,
-				pos_profile: pos_profile,
-				fetch_payment_terms_template: cint(
-					(this.frm.doc.is_return == 0) & !this.frm.doc.ignore_default_payment_terms_template
-				),
-			},
-			function () {
+				pos_profile: pos_profile
+			}, function() {
 				me.apply_pricing_rule();
 			});
 

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -170,7 +170,6 @@ class SalesInvoice(SellingController):
 		):
 			validate_loyalty_points(self, self.loyalty_points)
 
-		self.allow_write_off_only_on_pos()
 		self.reset_default_field_value("set_warehouse", "items", "warehouse")
 
 	def validate_accounts(self):
@@ -851,10 +850,6 @@ class SalesInvoice(SellingController):
 					raise_exception=1,
 				)
 
-	def allow_write_off_only_on_pos(self):
-		if not self.is_pos and self.write_off_account:
-			self.write_off_account = None
-
 	def validate_write_off_account(self):
 		if flt(self.write_off_amount) and not self.write_off_account:
 			self.write_off_account = frappe.get_cached_value("Company", self.company, "write_off_account")
@@ -1299,10 +1294,6 @@ 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)
 
-				against_voucher = self.name
-				if self.is_return and self.return_against and not self.update_outstanding_for_self:
-					against_voucher = self.return_against
-
 				if payment_mode.base_amount:
 					# POS, make payment entries
 					gl_entries.append(
@@ -1316,7 +1307,7 @@ 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": against_voucher,
+								"against_voucher": self.name,
 								"against_voucher_type": self.doctype,
 								"cost_center": self.cost_center,
 							},

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -5,7 +5,6 @@ import copy
 import json
 
 import frappe
-from frappe import qb
 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
@@ -307,8 +306,7 @@ class TestSalesInvoice(FrappeTestCase):
 		si.insert()
 
 		# with inclusive tax
-		self.assertEqual(si.items[0].net_amount, 3947.37)
-		self.assertEqual(si.net_total, si.base_net_total)
+		self.assertEqual(si.items[0].net_amount, 3947.368421052631)
 		self.assertEqual(si.net_total, 3947.37)
 		self.assertEqual(si.grand_total, 5000)
 
@@ -415,8 +413,8 @@ class TestSalesInvoice(FrappeTestCase):
 			for i, k in enumerate(expected_values["keys"]):
 				self.assertEqual(d.get(k), expected_values[d.account_head][i])
 
-		self.assertEqual(si.base_grand_total, 1500.01)
-		self.assertEqual(si.grand_total, 1500.01)
+		self.assertEqual(si.base_grand_total, 1500)
+		self.assertEqual(si.grand_total, 1500)
 		self.assertEqual(si.rounding_adjustment, -0.01)
 
 	def test_discount_amount_gl_entry(self):
@@ -652,7 +650,7 @@ class TestSalesInvoice(FrappeTestCase):
 				62.5,
 				625.0,
 				50,
-				499.98,
+				499.97600115194473,
 			],
 			"_Test Item Home Desktop 200": [
 				190.66,
@@ -663,7 +661,7 @@ class TestSalesInvoice(FrappeTestCase):
 				190.66,
 				953.3,
 				150,
-				750,
+				749.9968530500239,
 			],
 		}
 
@@ -676,21 +674,20 @@ class TestSalesInvoice(FrappeTestCase):
 				self.assertEqual(d.get(k), expected_values[d.item_code][i])
 
 		# check net total
-		self.assertEqual(si.base_net_total, si.net_total)
-		self.assertEqual(si.net_total, 1249.98)
+		self.assertEqual(si.net_total, 1249.97)
 		self.assertEqual(si.total, 1578.3)
 
 		# check tax calculation
 		expected_values = {
 			"keys": ["tax_amount", "total"],
-			"_Test Account Excise Duty - _TC": [140, 1389.98],
-			"_Test Account Education Cess - _TC": [2.8, 1392.78],
-			"_Test Account S&H Education Cess - _TC": [1.4, 1394.18],
-			"_Test Account CST - _TC": [27.88, 1422.06],
-			"_Test Account VAT - _TC": [156.25, 1578.31],
-			"_Test Account Customs Duty - _TC": [125, 1703.31],
-			"_Test Account Shipping Charges - _TC": [100, 1803.31],
-			"_Test Account Discount - _TC": [-180.33, 1622.98],
+			"_Test Account Excise Duty - _TC": [140, 1389.97],
+			"_Test Account Education Cess - _TC": [2.8, 1392.77],
+			"_Test Account S&H Education Cess - _TC": [1.4, 1394.17],
+			"_Test Account CST - _TC": [27.88, 1422.05],
+			"_Test Account VAT - _TC": [156.25, 1578.30],
+			"_Test Account Customs Duty - _TC": [125, 1703.30],
+			"_Test Account Shipping Charges - _TC": [100, 1803.30],
+			"_Test Account Discount - _TC": [-180.33, 1622.97],
 		}
 
 		for d in si.get("taxes"):
@@ -726,7 +723,7 @@ class TestSalesInvoice(FrappeTestCase):
 				"base_rate": 2500,
 				"base_amount": 25000,
 				"net_rate": 40,
-				"net_amount": 399.98,
+				"net_amount": 399.9808009215558,
 				"base_net_rate": 2000,
 				"base_net_amount": 19999,
 			},
@@ -740,7 +737,7 @@ class TestSalesInvoice(FrappeTestCase):
 				"base_rate": 7500,
 				"base_amount": 37500,
 				"net_rate": 118.01,
-				"net_amount": 590.05,
+				"net_amount": 590.0531205155963,
 				"base_net_rate": 5900.5,
 				"base_net_amount": 29502.5,
 			},
@@ -778,13 +775,8 @@ class TestSalesInvoice(FrappeTestCase):
 
 		self.assertEqual(si.base_grand_total, 60795)
 		self.assertEqual(si.grand_total, 1215.90)
-		# no rounding adjustment as the Smallest Currency Fraction Value of USD is 0.01
-		if frappe.db.get_value("Currency", "USD", "smallest_currency_fraction_value") < 0.01:
-			self.assertEqual(si.rounding_adjustment, 0.10)
-			self.assertEqual(si.base_rounding_adjustment, 5.0)
-		else:
-			self.assertEqual(si.rounding_adjustment, 0.0)
-			self.assertEqual(si.base_rounding_adjustment, 0.0)
+		self.assertEqual(si.rounding_adjustment, 0.01)
+		self.assertEqual(si.base_rounding_adjustment, 0.50)
 
 	def test_outstanding(self):
 		w = self.make()
@@ -2106,7 +2098,7 @@ class TestSalesInvoice(FrappeTestCase):
 		self.assertEqual(si.net_total, 19453.13)
 		self.assertEqual(si.grand_total, 24900)
 		self.assertEqual(si.total_taxes_and_charges, 5446.88)
-		self.assertEqual(si.rounding_adjustment, 0.00)
+		self.assertEqual(si.rounding_adjustment, -0.01)
 
 		expected_values = dict(
 			(d[0], d)
@@ -2133,7 +2125,7 @@ class TestSalesInvoice(FrappeTestCase):
 
 	def test_rounding_adjustment_2(self):
 		si = create_sales_invoice(rate=400, do_not_save=True)
-		for rate in [400.25, 600.30, 100.65]:
+		for rate in [400, 600, 100]:
 			si.append(
 				"items",
 				{
@@ -2159,18 +2151,17 @@ class TestSalesInvoice(FrappeTestCase):
 			)
 		si.save()
 		si.submit()
-		self.assertEqual(si.net_total, si.base_net_total)
-		self.assertEqual(si.net_total, 1272.20)
-		self.assertEqual(si.grand_total, 1501.20)
-		self.assertEqual(si.total_taxes_and_charges, 229)
-		self.assertEqual(si.rounding_adjustment, -0.20)
+		self.assertEqual(si.net_total, 1271.19)
+		self.assertEqual(si.grand_total, 1500)
+		self.assertEqual(si.total_taxes_and_charges, 228.82)
+		self.assertEqual(si.rounding_adjustment, -0.01)
 
 		expected_values = [
-			["_Test Account Service Tax - _TC", 0.0, 114.50],
-			["_Test Account VAT - _TC", 0.0, 114.50],
-			[si.debit_to, 1501, 0.0],
-			["Round Off - _TC", 0.20, 0.0],
-			["Sales - _TC", 0.0, 1272.20],
+			["_Test Account Service Tax - _TC", 0.0, 114.41],
+			["_Test Account VAT - _TC", 0.0, 114.41],
+			[si.debit_to, 1500, 0.0],
+			["Round Off - _TC", 0.01, 0.01],
+			["Sales - _TC", 0.0, 1271.18],
 		]
 
 		gl_entries = frappe.db.sql(
@@ -2228,8 +2219,7 @@ class TestSalesInvoice(FrappeTestCase):
 
 		si.save()
 		si.submit()
-		self.assertEqual(si.net_total, si.base_net_total)
-		self.assertEqual(si.net_total, 4007.15)
+		self.assertEqual(si.net_total, 4007.16)
 		self.assertEqual(si.grand_total, 4488.02)
 		self.assertEqual(si.total_taxes_and_charges, 480.86)
 		self.assertEqual(si.rounding_adjustment, -0.02)
@@ -2241,7 +2231,7 @@ class TestSalesInvoice(FrappeTestCase):
 				["_Test Account Service Tax - _TC", 0.0, 240.43],
 				["_Test Account VAT - _TC", 0.0, 240.43],
 				["Sales - _TC", 0.0, 4007.15],
-				["Round Off - _TC", 0.01, 0.0],
+				["Round Off - _TC", 0.02, 0.01],
 			]
 		)
 
@@ -3035,128 +3025,6 @@ class TestSalesInvoice(FrappeTestCase):
 		party_link.delete()
 		frappe.db.set_value("Accounts Settings", None, "enable_common_party_accounting", 0)
 
-	def test_sales_invoice_against_supplier_usd_with_dimensions(self):
-		from erpnext.accounts.doctype.opening_invoice_creation_tool.test_opening_invoice_creation_tool import (
-			make_customer,
-		)
-		from erpnext.accounts.doctype.party_link.party_link import create_party_link
-		from erpnext.buying.doctype.supplier.test_supplier import create_supplier
-
-		# create a customer
-		customer = make_customer(customer="_Test Common Supplier USD")
-		cust_doc = frappe.get_doc("Customer", customer)
-		cust_doc.default_currency = "USD"
-		cust_doc.save()
-		# create a supplier
-		supplier = create_supplier(supplier_name="_Test Common Supplier USD").name
-		supp_doc = frappe.get_doc("Supplier", supplier)
-		supp_doc.default_currency = "USD"
-		supp_doc.save()
-
-		# create a party link between customer & supplier
-		party_link = create_party_link("Supplier", supplier, customer)
-
-		# enable common party accounting
-		frappe.db.set_single_value("Accounts Settings", "enable_common_party_accounting", 1)
-
-		# create a dimension and make it mandatory
-		if not frappe.get_all("Accounting Dimension", filters={"document_type": "Department"}):
-			dim = frappe.get_doc(
-				{
-					"doctype": "Accounting Dimension",
-					"document_type": "Department",
-					"dimension_defaults": [{"company": "_Test Company", "mandatory_for_bs": True}],
-				}
-			)
-			dim.save()
-		else:
-			dim = frappe.get_doc(
-				"Accounting Dimension",
-				frappe.get_all("Accounting Dimension", filters={"document_type": "Department"})[0],
-			)
-			dim.disabled = False
-			dim.dimension_defaults = []
-			dim.append("dimension_defaults", {"company": "_Test Company", "mandatory_for_bs": True})
-			dim.save()
-
-		# create a sales invoice
-		si = create_sales_invoice(
-			customer=customer, parent_cost_center="_Test Cost Center - _TC", do_not_submit=True
-		)
-		si.department = "All Departments"
-		si.save().submit()
-
-		# check outstanding of sales invoice
-		si.reload()
-		self.assertEqual(si.status, "Paid")
-		self.assertEqual(flt(si.outstanding_amount), 0.0)
-
-		# check creation of journal entry
-		jv = frappe.get_all(
-			"Journal Entry Account",
-			{
-				"account": si.debit_to,
-				"party_type": "Customer",
-				"party": si.customer,
-				"reference_type": si.doctype,
-				"reference_name": si.name,
-				"department": "All Departments",
-			},
-			pluck="credit_in_account_currency",
-		)
-
-		self.assertTrue(jv)
-		self.assertEqual(jv[0], si.grand_total)
-
-		dim.disabled = True
-		dim.save()
-		party_link.delete()
-		frappe.db.set_single_value("Accounts Settings", "enable_common_party_accounting", 0)
-
-	def test_sales_invoice_cancel_with_common_party_advance_jv(self):
-		from erpnext.accounts.doctype.opening_invoice_creation_tool.test_opening_invoice_creation_tool import (
-			make_customer,
-		)
-		from erpnext.accounts.doctype.party_link.party_link import create_party_link
-		from erpnext.buying.doctype.supplier.test_supplier import create_supplier
-
-		# create a customer
-		customer = make_customer(customer="_Test Common Supplier")
-		# create a supplier
-		supplier = create_supplier(supplier_name="_Test Common Supplier").name
-
-		# create a party link between customer & supplier
-		party_link = create_party_link("Supplier", supplier, customer)
-
-		# enable common party accounting
-		frappe.db.set_single_value("Accounts Settings", "enable_common_party_accounting", 1)
-
-		# create a sales invoice
-		si = create_sales_invoice(customer=customer)
-
-		# check creation of journal entry
-		jv = frappe.db.get_value(
-			"Journal Entry Account",
-			filters={
-				"reference_type": si.doctype,
-				"reference_name": si.name,
-				"docstatus": 1,
-			},
-			fieldname="parent",
-		)
-
-		self.assertTrue(jv)
-
-		# cancel sales invoice
-		si.cancel()
-
-		# check cancellation of journal entry
-		jv_status = frappe.db.get_value("Journal Entry", jv, "docstatus")
-		self.assertEqual(jv_status, 2)
-
-		party_link.delete()
-		frappe.db.set_single_value("Accounts Settings", "enable_common_party_accounting", 0)
-
 	def test_payment_statuses(self):
 		from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
 
@@ -3644,124 +3512,7 @@ class TestSalesInvoice(FrappeTestCase):
 		]
 		self.assertEqual(expected, actual)
 
-	def test_pos_returns_without_update_outstanding_for_self(self):
-		from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_sales_return
 
-		pos_profile = make_pos_profile()
-		pos_profile.payments = []
-		pos_profile.append("payments", {"default": 1, "mode_of_payment": "Cash"})
-		pos_profile.save()
-
-		pos = create_sales_invoice(qty=10, do_not_save=True)
-		pos.is_pos = 1
-		pos.pos_profile = pos_profile.name
-		pos.append(
-			"payments", {"mode_of_payment": "Bank Draft", "account": "_Test Bank - _TC", "amount": 500}
-		)
-		pos.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 500})
-		pos.save().submit()
-
-		pos_return = make_sales_return(pos.name)
-		pos_return.update_outstanding_for_self = False
-		pos_return.save().submit()
-
-		gle = qb.DocType("GL Entry")
-		res = (
-			qb.from_(gle)
-			.select(gle.against_voucher)
-			.distinct()
-			.where(
-				gle.is_cancelled.eq(0) & gle.voucher_no.eq(pos_return.name) & gle.against_voucher.notnull()
-			)
-			.run(as_list=1)
-		)
-		self.assertEqual(len(res), 1)
-		self.assertEqual(res[0][0], pos_return.return_against)
-
-	@change_settings("Accounts Settings", {"enable_common_party_accounting": True})
-	def test_common_party_with_foreign_currency_jv(self):
-		from erpnext.accounts.doctype.account.test_account import create_account
-		from erpnext.accounts.doctype.opening_invoice_creation_tool.test_opening_invoice_creation_tool import (
-			make_customer,
-		)
-		from erpnext.accounts.doctype.party_link.party_link import create_party_link
-		from erpnext.buying.doctype.supplier.test_supplier import create_supplier
-		from erpnext.setup.utils import get_exchange_rate
-
-		creditors = create_account(
-			account_name="Creditors USD",
-			parent_account="Accounts Payable - _TC",
-			company="_Test Company",
-			account_currency="USD",
-			account_type="Payable",
-		)
-		debtors = create_account(
-			account_name="Debtors USD",
-			parent_account="Accounts Receivable - _TC",
-			company="_Test Company",
-			account_currency="USD",
-			account_type="Receivable",
-		)
-
-		# create a customer
-		customer = make_customer(customer="_Test Common Party USD")
-		cust_doc = frappe.get_doc("Customer", customer)
-		cust_doc.default_currency = "USD"
-		test_account_details = {
-			"company": "_Test Company",
-			"account": debtors,
-		}
-		cust_doc.append("accounts", test_account_details)
-		cust_doc.save()
-
-		# create a supplier
-		supplier = create_supplier(supplier_name="_Test Common Party USD").name
-		supp_doc = frappe.get_doc("Supplier", supplier)
-		supp_doc.default_currency = "USD"
-		test_account_details = {
-			"company": "_Test Company",
-			"account": creditors,
-		}
-		supp_doc.append("accounts", test_account_details)
-		supp_doc.save()
-
-		# create a party link between customer & supplier
-		create_party_link("Supplier", supplier, customer)
-
-		# create a sales invoice
-		si = create_sales_invoice(
-			customer=customer,
-			currency="USD",
-			conversion_rate=get_exchange_rate("USD", "INR"),
-			debit_to=debtors,
-			do_not_save=1,
-		)
-		si.party_account_currency = "USD"
-		si.save()
-		si.submit()
-
-		# check outstanding of sales invoice
-		si.reload()
-		self.assertEqual(si.status, "Paid")
-		self.assertEqual(flt(si.outstanding_amount), 0.0)
-
-		# check creation of journal entry
-		jv = frappe.get_all(
-			"Journal Entry Account",
-			{
-				"account": si.debit_to,
-				"party_type": "Customer",
-				"party": si.customer,
-				"reference_type": si.doctype,
-				"reference_name": si.name,
-			},
-			pluck="credit_in_account_currency",
-		)
-		self.assertTrue(jv)
-		self.assertEqual(jv[0], si.grand_total)
-
-
-<<<<<<< HEAD
 def check_gl_entries(doc, voucher_no, expected_gle, posting_date):
 	gl_entries = frappe.db.sql(
 		"""select account, debit, credit, posting_date
@@ -3771,36 +3522,6 @@ def check_gl_entries(doc, voucher_no, expected_gle, posting_date):
 		order by posting_date asc, account asc""",
 		(voucher_no, posting_date),
 		as_dict=1,
-=======
-	def test_gl_voucher_subtype(self):
-		si = create_sales_invoice()
-		gl_entries = frappe.get_all(
-			"GL Entry",
-			filters={"voucher_type": "Sales Invoice", "voucher_no": si.name},
-			pluck="voucher_subtype",
-		)
-
-		self.assertTrue(all([x == "Sales Invoice" for x in gl_entries]))
-
-		si = create_sales_invoice(is_return=1, qty=-1)
-		gl_entries = frappe.get_all(
-			"GL Entry",
-			filters={"voucher_type": "Sales Invoice", "voucher_no": si.name},
-			pluck="voucher_subtype",
-		)
-
-		self.assertTrue(all([x == "Credit Note" for x in gl_entries]))
-
-
-def set_advance_flag(company, flag, default_account):
-	frappe.db.set_value(
-		"Company",
-		company,
-		{
-			"book_advance_payments_in_separate_party_account": flag,
-			"default_advance_received_account": default_account,
-		},
->>>>>>> ad6cc352f1 (test: test voucher subtype for sales invoice)
 	)
 
 	for i, gle in enumerate(gl_entries):

erpnext/accounts/doctype/share_transfer/share_transfer.json

@@ -147,7 +147,6 @@
    "fieldname": "amount",
    "fieldtype": "Currency",
    "label": "Amount",
-   "options": "Company:company:default_currency",
    "read_only": 1
   },
   {

erpnext/accounts/doctype/subscription/subscription.js

@@ -37,12 +37,6 @@ frappe.ui.form.on("Subscription", {
 				frm.add_custom_button(__("Fetch Subscription Updates"), () =>
 					frm.events.get_subscription_updates(frm)
 				);
-
-				frm.add_custom_button(
-					__("Force-Fetch Subscription Updates"),
-					() => frm.trigger("force_fetch_subscription_updates"),
-					__("Actions")
-				);
 			} else if (frm.doc.status === "Cancelled") {
 				frm.add_custom_button(__("Restart Subscription"), () =>
 					frm.events.renew_this_subscription(frm)
@@ -102,11 +96,4 @@ frappe.ui.form.on("Subscription", {
 			},
 		});
 	},
-	force_fetch_subscription_updates: function (frm) {
-		frm.call("force_fetch_subscription_updates").then((r) => {
-			if (!r.exec) {
-				frm.reload_doc();
-			}
-		});
-	},
 });

erpnext/accounts/doctype/subscription/subscription.py

@@ -674,28 +674,6 @@ class Subscription(Document):
 		if invoice:
 			return invoice.precision("grand_total")
 
-	@frappe.whitelist()
-	def force_fetch_subscription_updates(self):
-		"""
-		Process Subscription and create Invoices even if current date doesn't lie between current_invoice_start and currenct_invoice_end
-		It makes use of 'Proces Subscription' to force processing in a specific 'posting_date'
-		"""
-
-		# Don't process future subscriptions
-		if nowdate() < self.current_invoice_start:
-			frappe.msgprint(_("Subscription for Future dates cannot be processed."))
-			return
-
-		processing_date = None
-		if self.generate_invoice_at == "Beginning of the current subscription period":
-			processing_date = self.current_invoice_start
-		elif self.generate_invoice_at == "End of the current subscription period":
-			processing_date = self.current_invoice_end
-		elif self.generate_invoice_at == "Days before the current subscription period":
-			processing_date = add_days(self.current_invoice_start, -self.number_of_days)
-
-		self.process(posting_date=processing_date)
-
 
 def get_calendar_months(billing_interval):
 	calendar_months = []

erpnext/accounts/doctype/subscription/test_subscription.py

@@ -712,18 +712,3 @@ class TestSubscription(FrappeTestCase):
 		self.assertEqual(pi.total, 55333.33)
 
 		subscription.delete()
-
-	def test_future_subscription(self):
-		"""Force-Fetch should not process future subscriptions"""
-		subscription = frappe.new_doc("Subscription")
-		subscription.party_type = "Customer"
-		subscription.party = "_Test Customer"
-		subscription.generate_invoice_at_period_start = 1
-		subscription.generate_new_invoices_past_due_date = 1
-		subscription.start_date = add_months(nowdate(), 1)
-		subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
-		subscription.save()
-
-		subscription.force_fetch_subscription_updates()
-		subscription.reload()
-		self.assertEqual(len(subscription.invoices), 0)

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py

@@ -295,7 +295,7 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 			tax_amount = 0
 		else:
 			#  if no TCS has been charged in FY,
-			# then chargeable value is "prev invoices + advances - advance_adjusted" value which cross the threshold
+			# then chargeable value is "prev invoices + advances" value which cross the threshold
 			tax_amount = get_tcs_amount(parties, inv, tax_details, vouchers, advance_vouchers)
 
 	if cint(tax_details.round_off_tax_amount):
@@ -382,9 +382,6 @@ def get_advance_vouchers(parties, company=None, from_date=None, to_date=None, pa
 	Use Payment Ledger to fetch unallocated Advance Payments
 	"""
 
-	if party_type == "Supplier":
-		return []
-
 	ple = qb.DocType("Payment Ledger Entry")
 
 	conditions = []
@@ -482,7 +479,7 @@ def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
 		payment_entry_filters.pop("apply_tax_withholding_amount", None)
 		payment_entry_filters.pop("tax_withholding_category", None)
 
-	supp_inv_credit_amt = frappe.db.get_value("Purchase Invoice", invoice_filters, field) or 0.0
+	supp_credit_amt = frappe.db.get_value("Purchase Invoice", invoice_filters, field) or 0.0
 
 	supp_jv_credit_amt = (
 		frappe.db.get_value(
@@ -506,7 +503,7 @@ def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
 		group_by="payment_type",
 	)
 
-	supp_credit_amt = supp_jv_credit_amt
+	supp_credit_amt += supp_jv_credit_amt
 	supp_credit_amt += inv.tax_withholding_net_total
 
 	for type in payment_entry_amounts:
@@ -524,18 +521,18 @@ def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
 		tax_withholding_net_total = inv.tax_withholding_net_total
 
 	if (threshold and tax_withholding_net_total >= threshold) or (
-		cumulative_threshold and (supp_credit_amt + supp_inv_credit_amt) >= cumulative_threshold
+		cumulative_threshold and supp_credit_amt >= cumulative_threshold
 	):
-		# Get net total again as TDS is calculated on net total
-		# Grand is used to just check for threshold breach
-		net_total = (
-			frappe.db.get_value("Purchase Invoice", invoice_filters, "sum(tax_withholding_net_total)") or 0.0
-		)
-		supp_credit_amt += net_total
-
 		if (cumulative_threshold and supp_credit_amt >= cumulative_threshold) and cint(
 			tax_details.tax_on_excess_amount
 		):
+			# Get net total again as TDS is calculated on net total
+			# Grand is used to just check for threshold breach
+			net_total = (
+				frappe.db.get_value("Purchase Invoice", invoice_filters, "sum(tax_withholding_net_total)")
+				or 0.0
+			)
+			net_total += inv.tax_withholding_net_total
 			supp_credit_amt = net_total - cumulative_threshold
 
 		if ldc and is_valid_certificate(ldc, inv.get("posting_date") or inv.get("transaction_date"), 0):
@@ -578,6 +575,8 @@ def get_tcs_amount(parties, inv, tax_details, vouchers, adv_vouchers):
 	conditions.append(ple.voucher_no == ple.against_voucher_no)
 	conditions.append(ple.company == inv.company)
 
+	(qb.from_(ple).select(Abs(Sum(ple.amount))).where(Criterion.all(conditions)).run(as_list=1))
+
 	advance_amt = (
 		qb.from_(ple).select(Abs(Sum(ple.amount))).where(Criterion.all(conditions)).run()[0][0] or 0.0
 	)
@@ -600,12 +599,9 @@ def get_tcs_amount(parties, inv, tax_details, vouchers, adv_vouchers):
 	)
 
 	cumulative_threshold = tax_details.get("cumulative_threshold", 0)
-	advance_adjusted = get_advance_adjusted_in_invoice(inv)
 
 	current_invoice_total = get_invoice_total_without_tcs(inv, tax_details)
-	total_invoiced_amt = (
-		current_invoice_total + invoiced_amt + advance_amt - credit_note_amt - advance_adjusted
-	)
+	total_invoiced_amt = current_invoice_total + invoiced_amt + advance_amt - credit_note_amt
 
 	if cumulative_threshold and total_invoiced_amt >= cumulative_threshold:
 		chargeable_amt = total_invoiced_amt - cumulative_threshold
@@ -614,14 +610,6 @@ def get_tcs_amount(parties, inv, tax_details, vouchers, adv_vouchers):
 	return tcs_amount
 
 
-def get_advance_adjusted_in_invoice(inv):
-	advances_adjusted = 0
-	for row in inv.get("advances", []):
-		advances_adjusted += row.allocated_amount
-
-	return advances_adjusted
-
-
 def get_invoice_total_without_tcs(inv, tax_details):
 	tcs_tax_row = [d for d in inv.taxes if d.account_head == tax_details.account_head]
 	tcs_tax_row_amount = tcs_tax_row[0].base_tax_amount if tcs_tax_row else 0

erpnext/accounts/doctype/tax_withholding_category/test_tax_withholding_category.py

@@ -121,46 +121,6 @@ class TestTaxWithholdingCategory(FrappeTestCase):
 		for d in reversed(invoices):
 			d.cancel()
 
-	def test_cumulative_threshold_with_party_ledger_amount_on_net_total(self):
-		invoices = []
-		frappe.db.set_value(
-			"Supplier", "Test TDS Supplier3", "tax_withholding_category", "Advance TDS Category"
-		)
-
-		# Invoice with tax and without exceeding single and cumulative thresholds
-		for _ in range(2):
-			pi = create_purchase_invoice(supplier="Test TDS Supplier3", rate=1000, do_not_save=True)
-			pi.apply_tds = 1
-			pi.append(
-				"taxes",
-				{
-					"category": "Total",
-					"charge_type": "Actual",
-					"account_head": "_Test Account VAT - _TC",
-					"cost_center": "Main - _TC",
-					"tax_amount": 500,
-					"description": "Test",
-					"add_deduct_tax": "Add",
-				},
-			)
-			pi.save()
-			pi.submit()
-			invoices.append(pi)
-
-		# Third Invoice exceeds single threshold and not exceeding cumulative threshold
-		pi1 = create_purchase_invoice(supplier="Test TDS Supplier3", rate=6000)
-		pi1.apply_tds = 1
-		pi1.save()
-		pi1.submit()
-		invoices.append(pi1)
-
-		# Cumulative threshold is 10,000
-		# Threshold calculation should be only on the third invoice
-		self.assertEqual(pi1.taxes[0].tax_amount, 800)
-
-		for d in reversed(invoices):
-			d.cancel()
-
 	def test_cumulative_threshold_tcs(self):
 		frappe.db.set_value(
 			"Customer", "Test TCS Customer", "tax_withholding_category", "Cumulative Threshold TCS"
@@ -254,50 +214,6 @@ class TestTaxWithholdingCategory(FrappeTestCase):
 			d.reload()
 			d.cancel()
 
-	@change_settings(
-		"Accounts Settings",
-		{"unlink_payment_on_cancellation_of_invoice": 1},
-	)
-	def test_tcs_on_allocated_advance_payments(self):
-		frappe.db.set_value(
-			"Customer", "Test TCS Customer", "tax_withholding_category", "Cumulative Threshold TCS"
-		)
-
-		vouchers = []
-
-		# create advance payment
-		pe = create_payment_entry(
-			payment_type="Receive", party_type="Customer", party="Test TCS Customer", paid_amount=30000
-		)
-		pe.paid_from = "Debtors - _TC"
-		pe.paid_to = "Cash - _TC"
-		pe.submit()
-		vouchers.append(pe)
-
-		si = create_sales_invoice(customer="Test TCS Customer", rate=50000)
-		advances = si.get_advance_entries()
-		si.append(
-			"advances",
-			{
-				"reference_type": advances[0].reference_type,
-				"reference_name": advances[0].reference_name,
-				"advance_amount": advances[0].amount,
-				"allocated_amount": 30000,
-			},
-		)
-		si.submit()
-		vouchers.append(si)
-
-		# assert tax collection on total invoice ,advance payment adjusted should be excluded.
-		tcs_charged = sum([d.base_tax_amount for d in si.taxes if d.account_head == "TCS - _TC"])
-		# tcs = (inv amt)50000+(adv amt)30000-(adv adj) 30000 - threshold(30000) * rate 10%
-		self.assertEqual(tcs_charged, 2000)
-
-		# cancel invoice and payments to avoid clashing
-		for d in reversed(vouchers):
-			d.reload()
-			d.cancel()
-
 	def test_tds_calculation_on_net_total(self):
 		frappe.db.set_value(
 			"Supplier", "Test TDS Supplier4", "tax_withholding_category", "Cumulative Threshold TDS"

erpnext/accounts/doctype/unreconcile_payment/unreconcile_payment.json

@@ -1,5 +1,7 @@
 {
  "actions": [],
+ "allow_rename": 1,
+ "autoname": "format:UNREC-{#####}",
  "creation": "2023-08-22 10:26:34.421423",
  "default_view": "List",
  "doctype": "DocType",
@@ -56,10 +58,11 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-10-10 12:03:50.022444",
+ "modified": "2023-08-28 17:42:50.261377",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Unreconcile Payment",
+ "naming_rule": "Expression",
  "owner": "Administrator",
  "permissions": [
   {

erpnext/accounts/general_ledger.py

@@ -179,53 +179,50 @@ def process_gl_map(gl_map, merge_entries=True, precision=None):
 
 
 def distribute_gl_based_on_cost_center_allocation(gl_map, precision=None):
+	cost_center_allocation = get_cost_center_allocation_data(gl_map[0]["company"], gl_map[0]["posting_date"])
+	if not cost_center_allocation:
+		return gl_map
+
 	new_gl_map = []
 	for d in gl_map:
 		cost_center = d.get("cost_center")
 
 		# Validate budget against main cost center
 		validate_expense_against_budget(d, expense_amount=flt(d.debit, precision) - flt(d.credit, precision))
-		cost_center_allocation = get_cost_center_allocation_data(
-			gl_map[0]["company"], gl_map[0]["posting_date"], cost_center
-		)
-		if not cost_center_allocation:
-			new_gl_map.append(d)
-			continue
 
-		for sub_cost_center, percentage in cost_center_allocation:
-			gle = copy.deepcopy(d)
-			gle.cost_center = sub_cost_center
-			for field in ("debit", "credit", "debit_in_account_currency", "credit_in_account_currency"):
-				gle[field] = flt(flt(d.get(field)) * percentage / 100, precision)
-			new_gl_map.append(gle)
+		if cost_center and cost_center_allocation.get(cost_center):
+			for sub_cost_center, percentage in cost_center_allocation.get(cost_center, {}).items():
+				gle = copy.deepcopy(d)
+				gle.cost_center = sub_cost_center
+				for field in ("debit", "credit", "debit_in_account_currency", "credit_in_account_currency"):
+					gle[field] = flt(flt(d.get(field)) * percentage / 100, precision)
+				new_gl_map.append(gle)
+		else:
+			new_gl_map.append(d)
 
 	return new_gl_map
 
 
-def get_cost_center_allocation_data(company, posting_date, cost_center):
-	cost_center_allocation = frappe.db.get_value(
-		"Cost Center Allocation",
-		{
-			"docstatus": 1,
-			"company": company,
-			"valid_from": ("<=", posting_date),
-			"main_cost_center": cost_center,
-		},
-		pluck="name",
-		order_by="valid_from desc",
-	)
+def get_cost_center_allocation_data(company, posting_date):
+	par = frappe.qb.DocType("Cost Center Allocation")
+	child = frappe.qb.DocType("Cost Center Allocation Percentage")
 
-	if not cost_center_allocation:
-		return []
+	records = (
+		frappe.qb.from_(par)
+		.inner_join(child)
+		.on(par.name == child.parent)
+		.select(par.main_cost_center, child.cost_center, child.percentage)
+		.where(par.docstatus == 1)
+		.where(par.company == company)
+		.where(par.valid_from <= posting_date)
+		.orderby(par.valid_from, order=frappe.qb.desc)
+	).run(as_dict=True)
 
-	records = frappe.db.get_all(
-		"Cost Center Allocation Percentage",
-		{"parent": cost_center_allocation},
-		["cost_center", "percentage"],
-		as_list=True,
-	)
+	cc_allocation = frappe._dict()
+	for d in records:
+		cc_allocation.setdefault(d.main_cost_center, frappe._dict()).setdefault(d.cost_center, d.percentage)
 
-	return records
+	return cc_allocation
 
 
 def merge_similar_entries(gl_map, precision=None):

erpnext/accounts/party.py

@@ -68,7 +68,7 @@ def get_party_details(
 	pos_profile=None,
 ):
 	if not party:
-		return frappe._dict()
+		return {}
 	if not frappe.db.exists(party_type, party):
 		frappe.throw(_("{0}: {1} does not exists").format(party_type, party))
 	return _get_party_details(

erpnext/accounts/report/accounts_payable/accounts_payable.js

@@ -162,11 +162,6 @@ frappe.query_reports["Accounts Payable"] = {
 			label: __("Group by Voucher"),
 			fieldtype: "Check",
 		},
-		{
-			fieldname: "handle_employee_advances",
-			label: __("Handle Employee Advances"),
-			fieldtype: "Check",
-		},
 	],
 
 	formatter: function (value, row, column, data, default_formatter) {

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -112,26 +112,6 @@ class ReceivablePayableReport:
 
 		self.build_data()
 
-	def build_voucher_dict(self, ple):
-		return frappe._dict(
-			voucher_type=ple.voucher_type,
-			voucher_no=ple.voucher_no,
-			party=ple.party,
-			party_account=ple.account,
-			posting_date=ple.posting_date,
-			account_currency=ple.account_currency,
-			remarks=ple.remarks,
-			invoiced=0.0,
-			paid=0.0,
-			credit_note=0.0,
-			outstanding=0.0,
-			invoiced_in_account_currency=0.0,
-			paid_in_account_currency=0.0,
-			credit_note_in_account_currency=0.0,
-			outstanding_in_account_currency=0.0,
-			cost_center=ple.cost_center,
-		)
-
 	def init_voucher_balance(self):
 		# build all keys, since we want to exclude vouchers beyond the report date
 		for ple in self.ple_entries:
@@ -143,8 +123,24 @@ class ReceivablePayableReport:
 				key = (ple.account, ple.voucher_type, ple.voucher_no, ple.party)
 
 			if key not in self.voucher_balance:
-				self.voucher_balance[key] = self.build_voucher_dict(ple)
-
+				self.voucher_balance[key] = frappe._dict(
+					voucher_type=ple.voucher_type,
+					voucher_no=ple.voucher_no,
+					party=ple.party,
+					party_account=ple.account,
+					posting_date=ple.posting_date,
+					account_currency=ple.account_currency,
+					remarks=ple.remarks,
+					invoiced=0.0,
+					paid=0.0,
+					credit_note=0.0,
+					outstanding=0.0,
+					invoiced_in_account_currency=0.0,
+					paid_in_account_currency=0.0,
+					credit_note_in_account_currency=0.0,
+					outstanding_in_account_currency=0.0,
+					cost_center=ple.cost_center,
+				)
 			self.get_invoices(ple)
 
 			if self.filters.get("group_by_party"):
@@ -212,18 +208,6 @@ class ReceivablePayableReport:
 
 		row = self.voucher_balance.get(key)
 
-		# Build and use a separate row for Employee Advances.
-		# This allows Payments or Journals made against Emp Advance to be processed.
-		if (
-			not row
-			and ple.against_voucher_type == "Employee Advance"
-			and self.filters.handle_employee_advances
-		):
-			_d = self.build_voucher_dict(ple)
-			_d.voucher_type = ple.against_voucher_type
-			_d.voucher_no = ple.against_voucher_no
-			row = self.voucher_balance[key] = _d
-
 		if not row:
 			# no invoice, this is an invoice / stand-alone payment / credit note
 			if self.filters.get("ignore_accounts"):
@@ -305,8 +289,8 @@ class ReceivablePayableReport:
 
 			must_consider = False
 			if self.filters.get("for_revaluation_journals"):
-				if (abs(row.outstanding) >= 1.0 / 10**self.currency_precision) or (
-					abs(row.outstanding_in_account_currency) >= 1.0 / 10**self.currency_precision
+				if (abs(row.outstanding) >= 0.0 / 10**self.currency_precision) or (
+					abs(row.outstanding_in_account_currency) >= 0.0 / 10**self.currency_precision
 				):
 					must_consider = True
 			else:
@@ -500,8 +484,7 @@ class ReceivablePayableReport:
 			from `tab{row.voucher_type}` si, `tabPayment Schedule` ps
 			where
 				si.name = ps.parent and
-				si.name = %s and
-				si.is_return = 0
+				si.name = %s
 			order by ps.paid_amount desc, due_date
 		""",
 			row.voucher_no,

erpnext/accounts/report/balance_sheet/balance_sheet.py

@@ -95,7 +95,7 @@ def execute(filters=None):
 		filters.periodicity, period_list, filters.accumulated_values, company=filters.company
 	)
 
-	chart = get_chart_data(filters, columns, asset, liability, equity, currency)
+	chart = get_chart_data(filters, columns, asset, liability, equity)
 
 	report_summary, primitive_summary = get_report_summary(
 		period_list, asset, liability, equity, provisional_profit_loss, currency, filters
@@ -219,7 +219,7 @@ def get_report_summary(
 	], (net_asset - net_liability + net_equity)
 
 
-def get_chart_data(filters, columns, asset, liability, equity, currency):
+def get_chart_data(filters, columns, asset, liability, equity):
 	labels = [d.get("label") for d in columns[2:]]
 
 	asset_data, liability_data, equity_data = [], [], []
@@ -247,8 +247,4 @@ def get_chart_data(filters, columns, asset, liability, equity, currency):
 	else:
 		chart["type"] = "line"
 
-	chart["fieldtype"] = "Currency"
-	chart["options"] = "currency"
-	chart["currency"] = currency
-
 	return chart

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.js

@@ -46,20 +46,4 @@ frappe.query_reports["Bank Reconciliation Statement"] = {
 			fieldtype: "Check",
 		},
 	],
-	formatter: function (value, row, column, data, default_formatter, filter) {
-		if (column.fieldname == "payment_entry" && value == __("Cheques and Deposits incorrectly cleared")) {
-			column.link_onclick =
-				"frappe.query_reports['Bank Reconciliation Statement'].open_utility_report()";
-		}
-		return default_formatter(value, row, column, data);
-	},
-	open_utility_report: function () {
-		frappe.route_options = {
-			company: frappe.query_report.get_filter_value("company"),
-			account: frappe.query_report.get_filter_value("account"),
-			report_date: frappe.query_report.get_filter_value("report_date"),
-		};
-		frappe.open_in_new_tab = true;
-		frappe.set_route("query-report", "Cheques and Deposits Incorrectly cleared");
-	},
 };

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py

@@ -150,8 +150,8 @@ def get_payment_entries(filters):
 		select
 			"Payment Entry" as payment_document, name as payment_entry,
 			reference_no, reference_date as ref_date,
-			if(paid_to=%(account)s, received_amount_after_tax, 0) as debit,
-			if(paid_from=%(account)s, paid_amount_after_tax, 0) as credit,
+			if(paid_to=%(account)s, received_amount, 0) as debit,
+			if(paid_from=%(account)s, paid_amount, 0) as credit,
 			posting_date, ifnull(party,if(paid_from=%(account)s,paid_to,paid_from)) as against_account, clearance_date,
 			if(paid_to=%(account)s, paid_to_account_currency, paid_from_account_currency) as account_currency
 		from `tabPayment Entry`

erpnext/accounts/report/budget_variance_report/budget_variance_report.js

@@ -43,7 +43,7 @@ function get_filters() {
 			label: __("From Fiscal Year"),
 			fieldtype: "Link",
 			options: "Fiscal Year",
-			default: erpnext.utils.get_fiscal_year(frappe.datetime.get_today()),
+			default: frappe.sys_defaults.fiscal_year,
 			reqd: 1,
 		},
 		{
@@ -51,7 +51,7 @@ function get_filters() {
 			label: __("To Fiscal Year"),
 			fieldtype: "Link",
 			options: "Fiscal Year",
-			default: erpnext.utils.get_fiscal_year(frappe.datetime.get_today()),
+			default: frappe.sys_defaults.fiscal_year,
 			reqd: 1,
 		},
 		{

erpnext/accounts/report/cash_flow/cash_flow.py

@@ -116,7 +116,7 @@ def execute(filters=None):
 	)
 	columns = get_columns(filters.periodicity, period_list, filters.accumulated_values, filters.company)
 
-	chart = get_chart_data(columns, data, company_currency)
+	chart = get_chart_data(columns, data)
 
 	report_summary = get_report_summary(summary_data, company_currency)
 
@@ -257,7 +257,7 @@ def get_report_summary(summary_data, currency):
 	return report_summary
 
 
-def get_chart_data(columns, data, currency):
+def get_chart_data(columns, data):
 	labels = [d.get("label") for d in columns[2:]]
 	datasets = [
 		{
@@ -272,7 +272,5 @@ def get_chart_data(columns, data, currency):
 	chart = {"data": {"labels": labels, "datasets": datasets}, "type": "bar"}
 
 	chart["fieldtype"] = "Currency"
-	chart["options"] = "currency"
-	chart["currency"] = currency
 
 	return chart

erpnext/accounts/report/cheques_and_deposits_incorrectly_cleared/cheques_and_deposits_incorrectly_cleared.js

@@ -1,44 +0,0 @@
-// Copyright (c) 2024, Frappe Technologies Pvt. Ltd. and contributors
-// For license information, please see license.txt
-
-frappe.query_reports["Cheques and Deposits Incorrectly cleared"] = {
-	filters: [
-		{
-			fieldname: "company",
-			label: __("Company"),
-			fieldtype: "Link",
-			options: "Company",
-			reqd: 1,
-			default: frappe.defaults.get_user_default("Company"),
-		},
-		{
-			fieldname: "account",
-			label: __("Bank Account"),
-			fieldtype: "Link",
-			options: "Account",
-			default: frappe.defaults.get_user_default("Company")
-				? locals[":Company"][frappe.defaults.get_user_default("Company")]["default_bank_account"]
-				: "",
-			reqd: 1,
-			get_query: function () {
-				var company = frappe.query_report.get_filter_value("company");
-				return {
-					query: "erpnext.controllers.queries.get_account_list",
-					filters: [
-						["Account", "account_type", "in", "Bank, Cash"],
-						["Account", "is_group", "=", 0],
-						["Account", "disabled", "=", 0],
-						["Account", "company", "=", company],
-					],
-				};
-			},
-		},
-		{
-			fieldname: "report_date",
-			label: __("Date"),
-			fieldtype: "Date",
-			default: frappe.datetime.get_today(),
-			reqd: 1,
-		},
-	],
-};

erpnext/accounts/report/cheques_and_deposits_incorrectly_cleared/cheques_and_deposits_incorrectly_cleared.json

@@ -1,29 +0,0 @@
-{
- "add_total_row": 0,
- "columns": [],
- "creation": "2024-07-30 17:20:07.570971",
- "disabled": 0,
- "docstatus": 0,
- "doctype": "Report",
- "filters": [],
- "idx": 0,
- "is_standard": "Yes",
- "letterhead": null,
- "modified": "2024-07-30 17:20:07.570971",
- "modified_by": "Administrator",
- "module": "Accounts",
- "name": "Cheques and Deposits Incorrectly cleared",
- "owner": "Administrator",
- "prepared_report": 0,
- "ref_doctype": "Payment Entry",
- "report_name": "Cheques and Deposits Incorrectly cleared",
- "report_type": "Script Report",
- "roles": [
-  {
-   "role": "Accounts User"
-  },
-  {
-   "role": "Accounts Manager"
-  }
- ]
-}

erpnext/accounts/report/cheques_and_deposits_incorrectly_cleared/cheques_and_deposits_incorrectly_cleared.py

@@ -1,153 +0,0 @@
-# Copyright (c) 2024, Frappe Technologies Pvt. Ltd. and contributors
-# For license information, please see license.txt
-
-import frappe
-from frappe import _, qb
-from frappe.query_builder import CustomFunction
-from frappe.query_builder.custom import ConstantColumn
-
-
-def execute(filters=None):
-	columns = get_columns()
-	data = build_data(filters)
-	return columns, data
-
-
-def build_payment_entry_dict(row: dict) -> dict:
-	row_dict = frappe._dict()
-	row_dict.update(
-		{
-			"payment_document": row.get("doctype"),
-			"payment_entry": row.get("name"),
-			"posting_date": row.get("posting_date"),
-			"clearance_date": row.get("clearance_date"),
-		}
-	)
-	if row.get("payment_type") == "Receive" and row.get("party_type") in ["Customer", "Supplier"]:
-		row_dict.update(
-			{
-				"debit": row.get("amount"),
-				"credit": 0,
-			}
-		)
-	else:
-		row_dict.update(
-			{
-				"debit": 0,
-				"credit": row.get("amount"),
-			}
-		)
-	return row_dict
-
-
-def build_journal_entry_dict(row: dict) -> dict:
-	row_dict = frappe._dict()
-	row_dict.update(
-		{
-			"payment_document": row.get("doctype"),
-			"payment_entry": row.get("name"),
-			"posting_date": row.get("posting_date"),
-			"clearance_date": row.get("clearance_date"),
-			"debit": row.get("debit_in_account_currency"),
-			"credit": row.get("credit_in_account_currency"),
-		}
-	)
-	return row_dict
-
-
-def build_data(filters):
-	vouchers = get_amounts_not_reflected_in_system_for_bank_reconciliation_statement(filters)
-	data = []
-	for x in vouchers:
-		if x.doctype == "Payment Entry":
-			data.append(build_payment_entry_dict(x))
-		elif x.doctype == "Journal Entry":
-			data.append(build_journal_entry_dict(x))
-	return data
-
-
-def get_amounts_not_reflected_in_system_for_bank_reconciliation_statement(filters):
-	je = qb.DocType("Journal Entry")
-	jea = qb.DocType("Journal Entry Account")
-	doctype_name = ConstantColumn("Journal Entry")
-
-	journals = (
-		qb.from_(je)
-		.inner_join(jea)
-		.on(je.name == jea.parent)
-		.select(
-			doctype_name.as_("doctype"),
-			je.name,
-			jea.debit_in_account_currency,
-			jea.credit_in_account_currency,
-			je.posting_date,
-			je.clearance_date,
-		)
-		.where(
-			je.docstatus.eq(1)
-			& jea.account.eq(filters.account)
-			& je.posting_date.gt(filters.report_date)
-			& je.clearance_date.lte(filters.report_date)
-			& (je.is_opening.isnull() | je.is_opening.eq("No"))
-		)
-		.run(as_dict=1)
-	)
-
-	ifelse = CustomFunction("IF", ["condition", "then", "else"])
-	pe = qb.DocType("Payment Entry")
-	doctype_name = ConstantColumn("Payment Entry")
-	payments = (
-		qb.from_(pe)
-		.select(
-			doctype_name.as_("doctype"),
-			pe.name,
-			ifelse(pe.paid_from.eq(filters.account), pe.paid_amount, pe.received_amount).as_("amount"),
-			pe.payment_type,
-			pe.party_type,
-			pe.posting_date,
-			pe.clearance_date,
-		)
-		.where(
-			pe.docstatus.eq(1)
-			& (pe.paid_from.eq(filters.account) | pe.paid_to.eq(filters.account))
-			& pe.posting_date.gt(filters.report_date)
-			& pe.clearance_date.lte(filters.report_date)
-		)
-		.run(as_dict=1)
-	)
-
-	return journals + payments
-
-
-def get_columns():
-	return [
-		{
-			"fieldname": "payment_document",
-			"label": _("Payment Document Type"),
-			"fieldtype": "Data",
-			"width": 220,
-		},
-		{
-			"fieldname": "payment_entry",
-			"label": _("Payment Document"),
-			"fieldtype": "Dynamic Link",
-			"options": "payment_document",
-			"width": 220,
-		},
-		{
-			"fieldname": "debit",
-			"label": _("Debit"),
-			"fieldtype": "Currency",
-			"options": "account_currency",
-			"width": 120,
-		},
-		{
-			"fieldname": "credit",
-			"label": _("Credit"),
-			"fieldtype": "Currency",
-			"options": "account_currency",
-			"width": 120,
-		},
-		{"fieldname": "posting_date", "label": _("Posting Date"), "fieldtype": "Date", "width": 110},
-		{"fieldname": "clearance_date", "label": _("Clearance Date"), "fieldtype": "Date", "width": 110},
-	]

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py

@@ -120,7 +120,7 @@ def get_balance_sheet_data(fiscal_year, companies, columns, filters):
 		True,
 	)
 
-	chart = get_chart_data(filters, columns, asset, liability, equity, company_currency)
+	chart = get_chart_data(filters, columns, asset, liability, equity)
 
 	return data, message, chart, report_summary
 
@@ -178,7 +178,7 @@ def get_profit_loss_data(fiscal_year, companies, columns, filters):
 	if net_profit_loss:
 		data.append(net_profit_loss)
 
-	chart = get_pl_chart_data(filters, columns, income, expense, net_profit_loss, company_currency)
+	chart = get_pl_chart_data(filters, columns, income, expense, net_profit_loss)
 
 	report_summary, primitive_summary = get_pl_summary(
 		companies, "", income, expense, net_profit_loss, company_currency, filters, True
@@ -474,13 +474,10 @@ def update_parent_account_names(accounts):
 
 	for d in accounts:
 		if d.account_number:
-			account_key = d.account_number + " - " + d.account_name
+			account_name = d.account_number + " - " + d.account_name
 		else:
-			account_key = d.account_name
-
-		d.account_key = account_key
-
-		name_to_account_map[d.name] = account_key
+			account_name = d.account_name
+		name_to_account_map[d.name] = account_name
 
 	for account in accounts:
 		if account.parent_account:
@@ -513,26 +510,33 @@ def get_subsidiary_companies(company):
 
 def get_accounts(root_type, companies):
 	accounts = []
+	added_accounts = []
 
 	for company in companies:
-		accounts.extend(
-			frappe.get_all(
-				"Account",
-				fields=[
-					"name",
-					"is_group",
-					"company",
-					"parent_account",
-					"lft",
-					"rgt",
-					"root_type",
-					"report_type",
-					"account_name",
-					"account_number",
-				],
-				filters={"company": company, "root_type": root_type},
-			)
-		)
+		for account in frappe.get_all(
+			"Account",
+			fields=[
+				"name",
+				"is_group",
+				"company",
+				"parent_account",
+				"lft",
+				"rgt",
+				"root_type",
+				"report_type",
+				"account_name",
+				"account_number",
+			],
+			filters={"company": company, "root_type": root_type},
+		):
+			if account.account_number:
+				account_key = account.account_number + "-" + account.account_name
+			else:
+				account_key = account.account_name
+
+			if account_key not in added_accounts:
+				accounts.append(account)
+				added_accounts.append(account_key)
 
 	return accounts
 
@@ -771,17 +775,15 @@ def add_total_row(out, root_type, balance_must_be, companies, company_currency):
 def filter_accounts(accounts, depth=10):
 	parent_children_map = {}
 	accounts_by_name = {}
-	added_accounts = []
-
 	for d in accounts:
-		if d.account_key in added_accounts:
-			continue
-
-		added_accounts.append(d.account_key)
+		if d.account_number:
+			account_name = d.account_number + " - " + d.account_name
+		else:
+			account_name = d.account_name
 		d["company_wise_opening_bal"] = defaultdict(float)
-		accounts_by_name[d.account_key] = d
+		accounts_by_name[account_name] = d
 
-		parent_children_map.setdefault(d.parent_account_name or None, []).append(d)
+		parent_children_map.setdefault(d.parent_account or None, []).append(d)
 
 	filtered_accounts = []
 
@@ -793,7 +795,7 @@ def filter_accounts(accounts, depth=10):
 			for child in children:
 				child.indent = level
 				filtered_accounts.append(child)
-				add_to_list(child.account_key, level + 1)
+				add_to_list(child.name, level + 1)
 
 	add_to_list(None, 0)
 

erpnext/accounts/report/deferred_revenue_and_expense/deferred_revenue_and_expense.py

@@ -122,24 +122,21 @@ class Deferred_Item:
 		"""
 		simulate future posting by creating dummy gl entries. starts from the last posting date.
 		"""
-		if (
-			self.service_start_date != self.service_end_date
-			and add_days(self.last_entry_date, 1) < self.service_end_date
-		):
-			self.estimate_for_period_list = get_period_list(
-				self.filters.from_fiscal_year,
-				self.filters.to_fiscal_year,
-				add_days(self.last_entry_date, 1),
-				self.service_end_date,
-				"Date Range",
-				"Monthly",
-				company=self.filters.company,
-			)
-
-			for period in self.estimate_for_period_list:
-				amount = self.calculate_amount(period.from_date, period.to_date)
-				gle = self.make_dummy_gle(period.key, period.to_date, amount)
-				self.gle_entries.append(gle)
+		if self.service_start_date != self.service_end_date:
+			if add_days(self.last_entry_date, 1) < self.period_list[-1].to_date:
+				self.estimate_for_period_list = get_period_list(
+					self.filters.from_fiscal_year,
+					self.filters.to_fiscal_year,
+					add_days(self.last_entry_date, 1),
+					self.period_list[-1].to_date,
+					"Date Range",
+					"Monthly",
+					company=self.filters.company,
+				)
+				for period in self.estimate_for_period_list:
+					amount = self.calculate_amount(period.from_date, period.to_date)
+					gle = self.make_dummy_gle(period.key, period.to_date, amount)
+					self.gle_entries.append(gle)
 
 	def calculate_item_revenue_expense_for_period(self):
 		"""

erpnext/accounts/report/deferred_revenue_and_expense/test_deferred_revenue_and_expense.py

@@ -279,79 +279,3 @@ class TestDeferredRevenueAndExpense(FrappeTestCase, AccountsTestMixin):
 			{"key": "aug_2021", "total": 0, "actual": 0},
 		]
 		self.assertEqual(report.period_total, expected)
-
-	@change_settings(
-		"Accounts Settings",
-		{"book_deferred_entries_based_on": "Months", "book_deferred_entries_via_journal_entry": 0},
-	)
-	def test_zero_amount(self):
-		self.create_item("_Test Office Desk", 0, self.warehouse, self.company)
-		item = frappe.get_doc("Item", self.item)
-		item.enable_deferred_expense = 1
-		item.item_defaults[0].deferred_expense_account = self.deferred_expense_account
-		item.no_of_months_exp = 12
-		item.save()
-
-		pi = make_purchase_invoice(
-			item=self.item,
-			company=self.company,
-			supplier=self.supplier,
-			is_return=False,
-			update_stock=False,
-			posting_date=frappe.utils.datetime.date(2021, 12, 30),
-			parent_cost_center=self.cost_center,
-			cost_center=self.cost_center,
-			do_not_save=True,
-			rate=3910,
-			price_list_rate=3910,
-			warehouse=self.warehouse,
-			qty=1,
-		)
-		pi.set_posting_time = True
-		pi.items[0].enable_deferred_expense = 1
-		pi.items[0].service_start_date = "2021-12-30"
-		pi.items[0].service_end_date = "2022-12-30"
-		pi.items[0].deferred_expense_account = self.deferred_expense_account
-		pi.items[0].expense_account = self.expense_account
-		pi.save()
-		pi.submit()
-
-		pda = frappe.get_doc(
-			doctype="Process Deferred Accounting",
-			posting_date=nowdate(),
-			start_date="2022-01-01",
-			end_date="2022-01-31",
-			type="Expense",
-			company=self.company,
-		)
-		pda.insert()
-		pda.submit()
-
-		# execute report
-		fiscal_year = frappe.get_doc("Fiscal Year", get_fiscal_year(date="2022-01-31"))
-		self.filters = frappe._dict(
-			{
-				"company": self.company,
-				"filter_based_on": "Date Range",
-				"period_start_date": "2022-01-01",
-				"period_end_date": "2022-01-31",
-				"from_fiscal_year": fiscal_year.year,
-				"to_fiscal_year": fiscal_year.year,
-				"periodicity": "Monthly",
-				"type": "Expense",
-				"with_upcoming_postings": False,
-			}
-		)
-
-		report = Deferred_Revenue_and_Expense_Report(filters=self.filters)
-		report.run()
-
-		# fetch the invoice from deferred invoices list
-		inv = [d for d in report.deferred_invoices if d.name == pi.name]
-		# make sure the list isn't empty
-		self.assertTrue(inv)
-		# calculate the total deferred expense for the period
-		inv = inv[0].calculate_invoice_revenue_expense_for_period()
-		deferred_exp = sum([inv[idx].actual for idx in range(len(report.period_list))])
-		# make sure the total deferred expense is greater than 0
-		self.assertLess(deferred_exp, 0)

erpnext/accounts/report/general_and_payment_ledger_comparison/general_and_payment_ledger_comparison.py

@@ -199,7 +199,8 @@ class General_Payment_Ledger_Comparison:
 			dict(
 				label=_("Voucher Type"),
 				fieldname="voucher_type",
-				fieldtype="Data",
+				fieldtype="Link",
+				options="DocType",
 				width="100",
 			)
 		)
@@ -218,7 +219,8 @@ class General_Payment_Ledger_Comparison:
 			dict(
 				label=_("Party Type"),
 				fieldname="party_type",
-				fieldtype="Data",
+				fieldtype="Link",
+				options="DocType",
 				width="100",
 			)
 		)

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -246,10 +246,7 @@ def get_conditions(filters):
 			as_list=True,
 		)
 		if system_generated_cr_dr_journals:
-			vouchers_to_ignore = (filters.get("voucher_no_not_in") or []) + [
-				x[0] for x in system_generated_cr_dr_journals
-			]
-			filters.update({"voucher_no_not_in": vouchers_to_ignore})
+			filters.update({"voucher_no_not_in": [x[0] for x in system_generated_cr_dr_journals]})
 
 	if filters.get("voucher_no_not_in"):
 		conditions.append("voucher_no not in %(voucher_no_not_in)s")
@@ -337,17 +334,9 @@ def get_accounts_with_children(accounts):
 	return list(set(all_accounts)) if all_accounts else None
 
 
-def set_bill_no(gl_entries):
-	inv_details = get_supplier_invoice_details()
-	for gl in gl_entries:
-		gl["bill_no"] = inv_details.get(gl.get("against_voucher"), "")
-
-
 def get_data_with_opening_closing(filters, account_details, accounting_dimensions, gl_entries):
 	data = []
 
-	set_bill_no(gl_entries)
-
 	gle_map = initialize_gle_map(gl_entries, filters)
 
 	totals, entries = get_accountwise_gle(filters, accounting_dimensions, gl_entries, gle_map)
@@ -521,6 +510,7 @@ def get_account_type_map(company):
 
 def get_result_as_list(data, filters):
 	balance, _balance_in_account_currency = 0, 0
+	inv_details = get_supplier_invoice_details()
 
 	for d in data:
 		if not d.get("posting_date"):
@@ -530,6 +520,7 @@ def get_result_as_list(data, filters):
 		d["balance"] = balance
 
 		d["account_currency"] = filters.account_currency
+		d["bill_no"] = inv_details.get(d.get("against_voucher"), "")
 
 	return data
 

erpnext/accounts/report/invalid_ledger_entries/invalid_ledger_entries.js

@@ -1,51 +0,0 @@
-// Copyright (c) 2024, Frappe Technologies Pvt. Ltd. and contributors
-// For license information, please see license.txt
-
-function get_filters() {
-	let filters = [
-		{
-			fieldname: "company",
-			label: __("Company"),
-			fieldtype: "Link",
-			options: "Company",
-			default: frappe.defaults.get_user_default("Company"),
-			reqd: 1,
-		},
-		{
-			fieldname: "from_date",
-			label: __("Start Date"),
-			fieldtype: "Date",
-			reqd: 1,
-			default: frappe.datetime.add_months(frappe.datetime.get_today(), -1),
-		},
-		{
-			fieldname: "to_date",
-			label: __("End Date"),
-			fieldtype: "Date",
-			reqd: 1,
-			default: frappe.datetime.get_today(),
-		},
-		{
-			fieldname: "account",
-			label: __("Account"),
-			fieldtype: "MultiSelectList",
-			options: "Account",
-			get_data: function (txt) {
-				return frappe.db.get_link_options("Account", txt, {
-					company: frappe.query_report.get_filter_value("company"),
-				});
-			},
-		},
-		{
-			fieldname: "voucher_no",
-			label: __("Voucher No"),
-			fieldtype: "Data",
-			width: 100,
-		},
-	];
-	return filters;
-}
-
-frappe.query_reports["Invalid Ledger Entries"] = {
-	filters: get_filters(),
-};

erpnext/accounts/report/invalid_ledger_entries/invalid_ledger_entries.json

@@ -1,23 +0,0 @@
-{
- "add_total_row": 0,
- "columns": [],
- "creation": "2024-09-09 12:31:25.295976",
- "disabled": 0,
- "docstatus": 0,
- "doctype": "Report",
- "filters": [],
- "idx": 0,
- "is_standard": "Yes",
- "letterhead": null,
- "modified": "2024-09-09 12:31:25.295976",
- "modified_by": "Administrator",
- "module": "Accounts",
- "name": "Invalid Ledger Entries",
- "owner": "Administrator",
- "prepared_report": 0,
- "ref_doctype": "GL Entry",
- "report_name": "Invalid Ledger Entries",
- "report_type": "Script Report",
- "roles": [],
- "timeout": 0
-}

erpnext/accounts/report/invalid_ledger_entries/invalid_ledger_entries.py

@@ -1,137 +0,0 @@
-# Copyright (c) 2024, Frappe Technologies Pvt. Ltd. and contributors
-# For license information, please see license.txt
-
-import frappe
-from frappe import _, qb
-from frappe.query_builder import Criterion
-from frappe.query_builder.custom import ConstantColumn
-
-
-def execute(filters: dict | None = None):
-	"""Return columns and data for the report.
-
-	This is the main entry point for the report. It accepts the filters as a
-	dictionary and should return columns and data. It is called by the framework
-	every time the report is refreshed or a filter is updated.
-	"""
-	validate_filters(filters)
-
-	columns = get_columns()
-	data = get_data(filters)
-
-	return columns, data
-
-
-def get_columns() -> list[dict]:
-	"""Return columns for the report.
-
-	One field definition per column, just like a DocType field definition.
-	"""
-	return [
-		{"label": _("Voucher Type"), "fieldname": "voucher_type", "fieldtype": "Link", "options": "DocType"},
-		{
-			"label": _("Voucher No"),
-			"fieldname": "voucher_no",
-			"fieldtype": "Dynamic Link",
-			"options": "voucher_type",
-		},
-	]
-
-
-def get_data(filters) -> list[list]:
-	"""Return data for the report.
-
-	The report data is a list of rows, with each row being a list of cell values.
-	"""
-	active_vouchers = get_active_vouchers_for_period(filters)
-	invalid_vouchers = identify_cancelled_vouchers(active_vouchers)
-
-	return invalid_vouchers
-
-
-def identify_cancelled_vouchers(active_vouchers: list[dict] | list | None = None) -> list[dict]:
-	cancelled_vouchers = []
-	if active_vouchers:
-		# Group by voucher types and use single query to identify cancelled vouchers
-		vtypes = set([x.voucher_type for x in active_vouchers])
-
-		for _t in vtypes:
-			_names = [x.voucher_no for x in active_vouchers if x.voucher_type == _t]
-			dt = qb.DocType(_t)
-			non_active_vouchers = (
-				qb.from_(dt)
-				.select(ConstantColumn(_t).as_("voucher_type"), dt.name.as_("voucher_no"))
-				.where(dt.docstatus.ne(1) & dt.name.isin(_names))
-				.run(as_dict=True)
-			)
-			if non_active_vouchers:
-				cancelled_vouchers.extend(non_active_vouchers)
-	return cancelled_vouchers
-
-
-def validate_filters(filters: dict | None = None):
-	if not filters:
-		frappe.throw(_("Filters missing"))
-
-	if not filters.company:
-		frappe.throw(_("Company is mandatory"))
-
-	if filters.from_date > filters.to_date:
-		frappe.throw(_("Start Date should be lower than End Date"))
-
-
-def build_query_filters(filters: dict | None = None) -> list:
-	qb_filters = []
-	if filters:
-		if filters.account:
-			qb_filters.append(qb.Field("account").isin(filters.account))
-
-		if filters.voucher_no:
-			qb_filters.append(qb.Field("voucher_no").eq(filters.voucher_no))
-
-	return qb_filters
-
-
-def get_active_vouchers_for_period(filters: dict | None = None) -> list[dict]:
-	uniq_vouchers = []
-
-	if filters:
-		gle = qb.DocType("GL Entry")
-		ple = qb.DocType("Payment Ledger Entry")
-
-		qb_filters = build_query_filters(filters)
-
-		gl_vouchers = (
-			qb.from_(gle)
-			.select(gle.voucher_type)
-			.distinct()
-			.select(gle.voucher_no)
-			.distinct()
-			.where(
-				gle.is_cancelled.eq(0)
-				& gle.company.eq(filters.company)
-				& gle.posting_date[filters.from_date : filters.to_date]
-			)
-			.where(Criterion.all(qb_filters))
-			.run(as_dict=True)
-		)
-
-		pl_vouchers = (
-			qb.from_(ple)
-			.select(ple.voucher_type)
-			.distinct()
-			.select(ple.voucher_no)
-			.distinct()
-			.where(
-				ple.delinked.eq(0)
-				& ple.company.eq(filters.company)
-				& ple.posting_date[filters.from_date : filters.to_date]
-			)
-			.where(Criterion.all(qb_filters))
-			.run(as_dict=True)
-		)
-
-		uniq_vouchers.extend(gl_vouchers)
-		uniq_vouchers.extend(pl_vouchers)
-
-	return uniq_vouchers

erpnext/accounts/report/payment_ledger/payment_ledger.py

@@ -210,7 +210,7 @@ class PaymentLedger:
 				)
 			)
 		self.columns.append(
-			dict(label=_("Currency"), fieldname="currency", fieldtype="Link", options="Currency", hidden=True)
+			dict(label=_("Currency"), fieldname="currency", fieldtype="Currency", hidden=True)
 		)
 
 	def run(self):

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py

@@ -59,11 +59,11 @@ def execute(filters=None):
 
 	columns = get_columns(filters.periodicity, period_list, filters.accumulated_values, filters.company)
 
+	chart = get_chart_data(filters, columns, income, expense, net_profit_loss)
+
 	currency = filters.presentation_currency or frappe.get_cached_value(
 		"Company", filters.company, "default_currency"
 	)
-	chart = get_chart_data(filters, columns, income, expense, net_profit_loss, currency)
-
 	report_summary, primitive_summary = get_report_summary(
 		period_list, filters.periodicity, income, expense, net_profit_loss, currency, filters
 	)
@@ -141,7 +141,7 @@ def get_net_profit_loss(income, expense, period_list, company, currency=None, co
 		return net_profit_loss
 
 
-def get_chart_data(filters, columns, income, expense, net_profit_loss, currency):
+def get_chart_data(filters, columns, income, expense, net_profit_loss):
 	labels = [d.get("label") for d in columns[2:]]
 
 	income_data, expense_data, net_profit = [], [], []
@@ -170,7 +170,5 @@ def get_chart_data(filters, columns, income, expense, net_profit_loss, currency)
 		chart["type"] = "line"
 
 	chart["fieldtype"] = "Currency"
-	chart["options"] = "currency"
-	chart["currency"] = currency
 
 	return chart

erpnext/accounts/report/purchase_register/purchase_register.py

@@ -311,7 +311,6 @@ def get_account_columns(invoice_list, include_payments):
 			"""select distinct expense_account
 			from `tabPurchase Invoice Item` where docstatus = 1
 			and (expense_account is not null and expense_account != '')
-			and parenttype='Purchase Invoice'
 			and parent in (%s) order by expense_account"""
 			% ", ".join(["%s"] * len(invoice_list)),
 			tuple([inv.name for inv in invoice_list]),
@@ -444,7 +443,7 @@ def get_invoice_expense_map(invoice_list):
 		"""
 		select parent, expense_account, sum(base_net_amount) as amount
 		from `tabPurchase Invoice Item`
-		where parent in (%s) and parenttype='Purchase Invoice'
+		where parent in (%s)
 		group by parent, expense_account
 	"""
 		% ", ".join(["%s"] * len(invoice_list)),
@@ -515,7 +514,7 @@ def get_invoice_po_pr_map(invoice_list):
 		"""
 		select parent, purchase_order, purchase_receipt, po_detail, project
 		from `tabPurchase Invoice Item`
-		where parent in (%s) and parenttype='Purchase Invoice'
+		where parent in (%s)
 	"""
 		% ", ".join(["%s"] * len(invoice_list)),
 		tuple(inv.name for inv in invoice_list),

erpnext/accounts/report/sales_register/sales_register.py

@@ -522,8 +522,7 @@ def get_invoice_tax_map(invoice_list, invoice_income_map, income_accounts, inclu
 	tax_details = frappe.db.sql(
 		"""select parent, account_head,
 		sum(base_tax_amount_after_discount_amount) as tax_amount
-		from `tabSales Taxes and Charges` where parent in (%s) and parenttype = 'Sales Invoice'
-		group by parent, account_head"""
+		from `tabSales Taxes and Charges` where parent in (%s) group by parent, account_head"""
 		% ", ".join(["%s"] * len(invoice_list)),
 		tuple(inv.name for inv in invoice_list),
 		as_dict=1,

erpnext/accounts/report/utils.py

@@ -326,7 +326,6 @@ def apply_common_conditions(filters, query, doctype, child_doctype=None, payment
 
 	if join_required:
 		query = query.inner_join(child_doc).on(parent_doc.name == child_doc.parent)
-		query = query.where(child_doc.parenttype == doctype)
 		query = query.distinct()
 
 	if parent_doc.get_table_name() != "tabJournal Entry":

erpnext/accounts/utils.py

@@ -703,114 +703,40 @@ def cancel_exchange_gain_loss_journal(
 	Cancel Exchange Gain/Loss for Sales/Purchase Invoice, if they have any.
 	"""
 	if parent_doc.doctype in ["Sales Invoice", "Purchase Invoice", "Payment Entry", "Journal Entry"]:
-		gain_loss_journals = get_linked_exchange_gain_loss_journal(
-			referenced_dt=parent_doc.doctype, referenced_dn=parent_doc.name, je_docstatus=1
-		)
-		for doc in gain_loss_journals:
-			gain_loss_je = frappe.get_doc("Journal Entry", doc)
-			if referenced_dt and referenced_dn:
-				references = [(x.reference_type, x.reference_name) for x in gain_loss_je.accounts]
-				if (
-					len(references) == 2
-					and (referenced_dt, referenced_dn) in references
-					and (parent_doc.doctype, parent_doc.name) in references
-				):
-					# only cancel JE generated against parent_doc and referenced_dn
-					gain_loss_je.cancel()
-			else:
-				gain_loss_je.cancel()
-
-
-def delete_exchange_gain_loss_journal(
-	parent_doc: dict | object, referenced_dt: str | None = None, referenced_dn: str | None = None
-) -> None:
-	"""
-	Delete Exchange Gain/Loss for Sales/Purchase Invoice, if they have any.
-	"""
-	if parent_doc.doctype in ["Sales Invoice", "Purchase Invoice", "Payment Entry", "Journal Entry"]:
-		gain_loss_journals = get_linked_exchange_gain_loss_journal(
-			referenced_dt=parent_doc.doctype, referenced_dn=parent_doc.name, je_docstatus=2
-		)
-		for doc in gain_loss_journals:
-			gain_loss_je = frappe.get_doc("Journal Entry", doc)
-			if referenced_dt and referenced_dn:
-				references = [(x.reference_type, x.reference_name) for x in gain_loss_je.accounts]
-				if (
-					len(references) == 2
-					and (referenced_dt, referenced_dn) in references
-					and (parent_doc.doctype, parent_doc.name) in references
-				):
-					# only delete JE generated against parent_doc and referenced_dn
-					gain_loss_je.delete()
-			else:
-				gain_loss_je.delete()
-
-
-def get_linked_exchange_gain_loss_journal(referenced_dt: str, referenced_dn: str, je_docstatus: int) -> list:
-	"""
-	Get all the linked exchange gain/loss journal entries for a given document.
-	"""
-	gain_loss_journals = []
-	if journals := frappe.db.get_all(
-		"Journal Entry Account",
-		{
-			"reference_type": referenced_dt,
-			"reference_name": referenced_dn,
-			"docstatus": je_docstatus,
-		},
-		pluck="parent",
-	):
-		gain_loss_journals = frappe.db.get_all(
-			"Journal Entry",
-			{
-				"name": ["in", journals],
-				"voucher_type": "Exchange Gain Or Loss",
-				"is_system_generated": 1,
-				"docstatus": je_docstatus,
+		journals = frappe.db.get_all(
+			"Journal Entry Account",
+			filters={
+				"reference_type": parent_doc.doctype,
+				"reference_name": parent_doc.name,
+				"docstatus": 1,
 			},
-			pluck="name",
+			fields=["parent"],
+			as_list=1,
 		)
-	return gain_loss_journals
 
-
-def cancel_common_party_journal(self):
-	if self.doctype not in ["Sales Invoice", "Purchase Invoice"]:
-		return
-
-	if not frappe.db.get_single_value("Accounts Settings", "enable_common_party_accounting"):
-		return
-
-	party_link = self.get_common_party_link()
-	if not party_link:
-		return
-
-	journal_entry = frappe.db.get_value(
-		"Journal Entry Account",
-		filters={
-			"reference_type": self.doctype,
-			"reference_name": self.name,
-			"docstatus": 1,
-		},
-		fieldname="parent",
-	)
-
-	if not journal_entry:
-		return
-
-	common_party_journal = frappe.db.get_value(
-		"Journal Entry",
-		filters={
-			"name": journal_entry,
-			"is_system_generated": True,
-			"docstatus": 1,
-		},
-	)
-
-	if not common_party_journal:
-		return
-
-	common_party_je = frappe.get_doc("Journal Entry", common_party_journal)
-	common_party_je.cancel()
+		if journals:
+			gain_loss_journals = frappe.db.get_all(
+				"Journal Entry",
+				filters={
+					"name": ["in", [x[0] for x in journals]],
+					"voucher_type": "Exchange Gain Or Loss",
+					"docstatus": 1,
+				},
+				as_list=1,
+			)
+			for doc in gain_loss_journals:
+				gain_loss_je = frappe.get_doc("Journal Entry", doc[0])
+				if referenced_dt and referenced_dn:
+					references = [(x.reference_type, x.reference_name) for x in gain_loss_je.accounts]
+					if (
+						len(references) == 2
+						and (referenced_dt, referenced_dn) in references
+						and (parent_doc.doctype, parent_doc.name) in references
+					):
+						# only cancel JE generated against parent_doc and referenced_dn
+						gain_loss_je.cancel()
+				else:
+					gain_loss_je.cancel()
 
 
 def update_accounting_ledgers_after_reference_removal(
@@ -1524,16 +1450,12 @@ def compare_existing_and_expected_gle(existing_gle, expected_gle, precision):
 	return matched
 
 
-def get_stock_accounts(company, voucher_type=None, voucher_no=None, accounts=None):
+def get_stock_accounts(company, voucher_type=None, voucher_no=None):
 	stock_accounts = [
 		d.name
 		for d in frappe.db.get_all("Account", {"account_type": "Stock", "company": company, "is_group": 0})
 	]
-
-	if accounts:
-		stock_accounts = [row.account for row in accounts if row.account in stock_accounts]
-
-	elif voucher_type and voucher_no:
+	if voucher_type and voucher_no:
 		if voucher_type == "Journal Entry":
 			stock_accounts = [
 				d.account
@@ -1930,7 +1852,6 @@ class QueryPaymentLedger:
 				ple.cost_center.as_("cost_center"),
 				Sum(ple.amount).as_("amount"),
 				Sum(ple.amount_in_account_currency).as_("amount_in_account_currency"),
-				ple.remarks,
 			)
 			.where(ple.delinked == 0)
 			.where(Criterion.all(filter_on_voucher_no))
@@ -1993,7 +1914,6 @@ class QueryPaymentLedger:
 				Table("vouchers").due_date,
 				Table("vouchers").currency,
 				Table("vouchers").cost_center.as_("cost_center"),
-				Table("vouchers").remarks,
 			)
 			.where(Criterion.all(filter_on_outstanding_amount))
 		)

erpnext/assets/doctype/asset/asset.js

@@ -202,7 +202,7 @@ frappe.ui.form.on("Asset", {
 			<div class="row">
 				<div class="col-xs-12 col-sm-6">
 					<span class="indicator whitespace-nowrap red">
-						<span>${__("Failed to post depreciation entries")}</span>
+						<span>Failed to post depreciation entries</span>
 					</span>
 				</div>
 			</div>`;

erpnext/assets/doctype/asset_capitalization/asset_capitalization.js

@@ -11,7 +11,6 @@ erpnext.assets.AssetCapitalization = class AssetCapitalization extends erpnext.s
 
 	onload() {
 		this.setup_queries();
-		erpnext.accounts.dimensions.setup_dimension_filters(this.frm, this.frm.doctype);
 	}
 
 	refresh() {

erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py

@@ -14,26 +14,15 @@ def get_data():
 			"Material Request": ["items", "material_request"],
 			"Supplier Quotation": ["items", "supplier_quotation"],
 			"Project": ["items", "project"],
-			"Sales Order": ["items", "sales_order"],
-			"BOM": ["items", "bom"],
-			"Production Plan": ["items", "production_plan"],
-			"Blanket Order": ["items", "blanket_order"],
 		},
 		"transactions": [
-			{"label": _("Related"), "items": ["Purchase Receipt", "Purchase Invoice", "Sales Order"]},
+			{"label": _("Related"), "items": ["Purchase Receipt", "Purchase Invoice"]},
 			{"label": _("Payment"), "items": ["Payment Entry", "Journal Entry", "Payment Request"]},
 			{
 				"label": _("Reference"),
-				"items": ["Supplier Quotation", "Project", "Auto Repeat"],
-			},
-			{
-				"label": _("Manufacturing"),
-				"items": ["Material Request", "BOM", "Production Plan", "Blanket Order"],
-			},
-			{
-				"label": _("Sub-contracting"),
-				"items": ["Subcontracting Order", "Stock Entry"],
+				"items": ["Material Request", "Supplier Quotation", "Project", "Auto Repeat"],
 			},
+			{"label": _("Sub-contracting"), "items": ["Subcontracting Order", "Stock Entry"]},
 			{"label": _("Internal"), "items": ["Sales Order"]},
 		],
 	}

erpnext/buying/doctype/request_for_quotation/request_for_quotation.js

@@ -137,8 +137,8 @@ frappe.ui.form.on("Request for Quotation",{
 								return;
 							}
 						},
-						__("Download PDF for Supplier"),
-						__("Download")
+						"Download PDF for Supplier",
+						"Download"
 					);
 				},
 				__("Tools")
@@ -257,10 +257,8 @@ frappe.ui.form.on("Request for Quotation",{
 			});
 		};
 
-		const msg = __(
-			"This is a preview of the email to be sent. A PDF of the document will automatically be attached with the email."
-		);
-		dialog.fields_dict.note.$wrapper.append(`<p class="small text-muted">${msg}</p>`);
+		dialog.fields_dict.note.$wrapper.append(`<p class="small text-muted">This is a preview of the email to be sent. A PDF of the document will
+			automatically be attached with the email.</p>`);
 
 		dialog.show();
 	}

erpnext/buying/doctype/request_for_quotation/request_for_quotation.py

@@ -392,7 +392,6 @@ def create_rfq_items(sq_doc, supplier, data):
 		"material_request",
 		"material_request_item",
 		"stock_qty",
-		"uom",
 	]:
 		args[field] = data.get(field)
 

erpnext/buying/report/procurement_tracker/procurement_tracker.py

@@ -175,7 +175,7 @@ def get_data(filters):
 				"purchase_order": po.parent,
 				"supplier": po.supplier,
 				"estimated_cost": flt(mr_record.get("amount")),
-				"actual_cost": flt(pi_records.get(po.name)) or flt(po.amount),
+				"actual_cost": flt(pi_records.get(po.name)),
 				"purchase_order_amt": flt(po.amount),
 				"purchase_order_amt_in_company_currency": flt(po.base_amount),
 				"expected_delivery_date": po.schedule_date,

erpnext/controllers/accounts_controller.py

@@ -84,6 +84,7 @@ force_item_fields = (
 	"brand",
 	"stock_uom",
 	"is_fixed_asset",
+	"item_tax_rate",
 	"pricing_rules",
 	"weight_per_unit",
 	"weight_uom",
@@ -326,16 +327,11 @@ class AccountsController(TransactionBase):
 					repost_doc.save(ignore_permissions=True)
 
 	def on_trash(self):
-		from erpnext.accounts.utils import delete_exchange_gain_loss_journal
-
 		self._remove_references_in_repost_doctypes()
 		self._remove_references_in_unreconcile()
 
 		# delete sl and gl entries on deletion of transaction
 		if frappe.db.get_single_value("Accounts Settings", "delete_linked_ledger_entries"):
-			# delete linked exchange gain/loss journal
-			delete_exchange_gain_loss_journal(self)
-
 			ple = frappe.qb.DocType("Payment Ledger Entry")
 			frappe.qb.from_(ple).delete().where(
 				(ple.voucher_type == self.doctype) & (ple.voucher_no == self.name)
@@ -357,15 +353,12 @@ class AccountsController(TransactionBase):
 	def validate_return_against_account(self):
 		if self.doctype in ["Sales Invoice", "Purchase Invoice"] and self.is_return and self.return_against:
 			cr_dr_account_field = "debit_to" if self.doctype == "Sales Invoice" else "credit_to"
-			original_account = frappe.get_value(self.doctype, self.return_against, cr_dr_account_field)
-			if original_account != self.get(cr_dr_account_field):
+			cr_dr_account_label = "Debit To" if self.doctype == "Sales Invoice" else "Credit To"
+			cr_dr_account = self.get(cr_dr_account_field)
+			if frappe.get_value(self.doctype, self.return_against, cr_dr_account_field) != cr_dr_account:
 				frappe.throw(
-					_(
-						"Please set {0} to {1}, the same account that was used in the original invoice {2}."
-					).format(
-						frappe.bold(_(self.meta.get_label(cr_dr_account_field), context=self.doctype)),
-						frappe.bold(original_account),
-						frappe.bold(self.return_against),
+					_("'{0}' account: '{1}' should match the Return Against Invoice").format(
+						frappe.bold(cr_dr_account_label), frappe.bold(cr_dr_account)
 					)
 				)
 
@@ -415,11 +408,6 @@ class AccountsController(TransactionBase):
 					)
 
 	def validate_invoice_documents_schedule(self):
-		if self.is_return:
-			self.payment_terms_template = ""
-			self.payment_schedule = []
-			return
-
 		self.validate_payment_schedule_dates()
 		self.set_due_date()
 		self.set_payment_schedule()
@@ -434,7 +422,7 @@ class AccountsController(TransactionBase):
 		self.validate_payment_schedule_amount()
 
 	def validate_all_documents_schedule(self):
-		if self.doctype in ("Sales Invoice", "Purchase Invoice"):
+		if self.doctype in ("Sales Invoice", "Purchase Invoice") and not self.is_return:
 			self.validate_invoice_documents_schedule()
 		elif self.doctype in ("Quotation", "Purchase Order", "Sales Order"):
 			self.validate_non_invoice_documents_schedule()
@@ -719,6 +707,7 @@ class AccountsController(TransactionBase):
 						args["is_subcontracted"] = self.is_subcontracted
 
 					ret = get_item_details(args, self, for_validate=for_validate, overwrite_warehouse=False)
+
 					for fieldname, value in ret.items():
 						if item.meta.get_field(fieldname) and value is not None:
 							if item.get(fieldname) is None or fieldname in force_item_fields:
@@ -728,10 +717,7 @@ class AccountsController(TransactionBase):
 								fieldname
 							):
 								item.set(fieldname, value)
-							elif fieldname == "item_tax_rate" and not (
-								self.get("is_return") and self.get("return_against")
-							):
-								item.set(fieldname, value)
+
 							elif fieldname == "serial_no":
 								# Ensure that serial numbers are matched against Stock UOM
 								item_conversion_factor = item.get("conversion_factor") or 1.0
@@ -981,36 +967,6 @@ class AccountsController(TransactionBase):
 
 		return gl_dict
 
-<<<<<<< HEAD
-=======
-	def get_voucher_subtype(self):
-		voucher_subtypes = {
-			"Journal Entry": "voucher_type",
-			"Payment Entry": "payment_type",
-			"Stock Entry": "stock_entry_type",
-			"Asset Capitalization": "entry_type",
-		}
-		if self.doctype in voucher_subtypes:
-			return self.get(voucher_subtypes[self.doctype])
-		elif self.doctype == "Purchase Receipt" and self.is_return:
-			return "Purchase Return"
-		elif self.doctype == "Delivery Note" and self.is_return:
-			return "Sales Return"
-		elif self.doctype == "Sales Invoice" and self.is_return:
-			return "Credit Note"
-		elif self.doctype == "Sales Invoice" and self.is_debit_note:
-			return "Debit Note"
-		elif self.doctype == "Purchase Invoice" and self.is_return:
-			return "Debit Note"
-		return self.doctype
-
-	def get_value_in_transaction_currency(self, account_currency, gl_dict, field):
-		if account_currency == self.get("currency"):
-			return gl_dict.get(field + "_in_account_currency")
-		else:
-			return flt(gl_dict.get(field, 0) / self.get("conversion_rate", 1))
-
->>>>>>> 00eee16190 (fix: improved the conditions for determining voucher subtypes)
 	def validate_zero_qty_for_return_invoices_with_stock(self):
 		rows = []
 		for item in self.items:
@@ -1236,12 +1192,6 @@ class AccountsController(TransactionBase):
 		# Cancelling existing exchange gain/loss journals is handled during the `on_cancel` event.
 		# see accounts/utils.py:cancel_exchange_gain_loss_journal()
 		if self.docstatus == 1:
-			if dimensions_dict is None:
-				dimensions_dict = frappe._dict()
-				active_dimensions = get_dimensions()[0]
-				for dim in active_dimensions:
-					dimensions_dict[dim.fieldname] = self.get(dim.fieldname)
-
 			if self.get("doctype") == "Journal Entry":
 				# 'args' is populated with exchange gain/loss account and the amount to be booked.
 				# These are generated by Sales/Purchase Invoice during reconciliation and advance allocation.
@@ -1506,7 +1456,6 @@ class AccountsController(TransactionBase):
 			remove_from_bank_transaction,
 		)
 		from erpnext.accounts.utils import (
-			cancel_common_party_journal,
 			cancel_exchange_gain_loss_journal,
 			unlink_ref_doc_from_payment_entries,
 		)
@@ -1518,7 +1467,6 @@ class AccountsController(TransactionBase):
 
 			# Cancel Exchange Gain/Loss Journal before unlinking
 			cancel_exchange_gain_loss_journal(self)
-			cancel_common_party_journal(self)
 
 			if frappe.db.get_single_value("Accounts Settings", "unlink_payment_on_cancellation_of_invoice"):
 				unlink_ref_doc_from_payment_entries(self)
@@ -1882,7 +1830,7 @@ class AccountsController(TransactionBase):
 					).format(formatted_advance_paid, self.name, formatted_order_total)
 				)
 
-			self.db_set("advance_paid", advance_paid)
+			frappe.db.set_value(self.doctype, self.name, "advance_paid", advance_paid)
 
 	@property
 	def company_abbr(self):
@@ -2341,15 +2289,12 @@ class AccountsController(TransactionBase):
 
 		primary_account = get_party_account(primary_party_type, primary_party, self.company)
 		secondary_account = get_party_account(secondary_party_type, secondary_party, self.company)
-		primary_account_currency = get_account_currency(primary_account)
-		secondary_account_currency = get_account_currency(secondary_account)
 
 		jv = frappe.new_doc("Journal Entry")
 		jv.voucher_type = "Journal Entry"
 		jv.posting_date = self.posting_date
 		jv.company = self.company
 		jv.remark = f"Adjustment for {self.doctype} {self.name}"
-		jv.is_system_generated = True
 
 		reconcilation_entry = frappe._dict()
 		advance_entry = frappe._dict()
@@ -2367,15 +2312,6 @@ class AccountsController(TransactionBase):
 		advance_entry.cost_center = self.cost_center or erpnext.get_default_cost_center(self.company)
 		advance_entry.is_advance = "Yes"
 
-		# update dimesions
-		dimensions_dict = frappe._dict()
-		active_dimensions = get_dimensions()[0]
-		for dim in active_dimensions:
-			dimensions_dict[dim.fieldname] = self.get(dim.fieldname)
-
-		reconcilation_entry.update(dimensions_dict)
-		advance_entry.update(dimensions_dict)
-
 		if self.doctype == "Sales Invoice":
 			reconcilation_entry.credit_in_account_currency = self.outstanding_amount
 			advance_entry.debit_in_account_currency = self.outstanding_amount
@@ -2383,10 +2319,6 @@ class AccountsController(TransactionBase):
 			advance_entry.credit_in_account_currency = self.outstanding_amount
 			reconcilation_entry.debit_in_account_currency = self.outstanding_amount
 
-		default_currency = erpnext.get_company_currency(self.company)
-		if primary_account_currency != default_currency or secondary_account_currency != default_currency:
-			jv.multi_currency = 1
-
 		jv.append("accounts", reconcilation_entry)
 		jv.append("accounts", advance_entry)
 
@@ -3162,6 +3094,7 @@ def update_child_qty_rate(parent_doctype, trans_items, parent_doctype_name, chil
 	items_added_or_removed = False  # updated to true if any new item is added or removed
 	any_conversion_factor_changed = False
 
+	sales_doctypes = ["Sales Order", "Sales Invoice", "Delivery Note", "Quotation"]
 	parent = frappe.get_doc(parent_doctype, parent_doctype_name)
 
 	check_doc_permissions(parent, "write")
@@ -3263,21 +3196,25 @@ def update_child_qty_rate(parent_doctype, trans_items, parent_doctype_name, chil
 				#  if rate is greater than price_list_rate, set margin
 				#  or set discount
 				child_item.discount_percentage = 0
-				child_item.margin_type = "Amount"
-				child_item.margin_rate_or_amount = flt(
-					child_item.rate - child_item.price_list_rate,
-					child_item.precision("margin_rate_or_amount"),
-				)
-				child_item.rate_with_margin = child_item.rate
+
+				if parent_doctype in sales_doctypes:
+					child_item.margin_type = "Amount"
+					child_item.margin_rate_or_amount = flt(
+						child_item.rate - child_item.price_list_rate,
+						child_item.precision("margin_rate_or_amount"),
+					)
+					child_item.rate_with_margin = child_item.rate
 			else:
 				child_item.discount_percentage = flt(
 					(1 - flt(child_item.rate) / flt(child_item.price_list_rate)) * 100.0,
 					child_item.precision("discount_percentage"),
 				)
 				child_item.discount_amount = flt(child_item.price_list_rate) - flt(child_item.rate)
-				child_item.margin_type = ""
-				child_item.margin_rate_or_amount = 0
-				child_item.rate_with_margin = 0
+
+				if parent_doctype in sales_doctypes:
+					child_item.margin_type = ""
+					child_item.margin_rate_or_amount = 0
+					child_item.rate_with_margin = 0
 
 		child_item.flags.ignore_validate_update_after_submit = True
 		if new_child_flag:
@@ -3343,9 +3280,6 @@ def update_child_qty_rate(parent_doctype, trans_items, parent_doctype_name, chil
 	parent.update_billing_percentage()
 	parent.set_status()
 
-	parent.validate_uom_is_integer("uom", "qty")
-	parent.validate_uom_is_integer("stock_uom", "stock_qty")
-
 
 def check_if_child_table_updated(child_table_before_update, child_table_after_update, fields_to_check):
 	accounting_dimensions = [*get_accounting_dimensions(), "cost_center", "project"]

erpnext/controllers/sales_and_purchase_return.py

@@ -78,9 +78,6 @@ def validate_returned_items(doc):
 	if doc.doctype in ["Purchase Invoice", "Purchase Receipt", "Subcontracting Receipt"]:
 		select_fields += ",rejected_qty, received_qty"
 
-	if doc.doctype in ["Purchase Receipt", "Purchase Invoice"]:
-		select_fields += ",name"
-
 	for d in frappe.db.sql(
 		f"""select {select_fields} from `tab{doc.doctype} Item` where parent = %s""",
 		doc.return_against,
@@ -106,24 +103,15 @@ def validate_returned_items(doc):
 
 	items_returned = False
 	for d in doc.get("items"):
-		key = d.item_code
-		raise_exception = False
-		if doc.doctype in ["Purchase Receipt", "Purchase Invoice"]:
-			field = frappe.scrub(doc.doctype) + "_item"
-			if d.get(field):
-				key = (d.item_code, d.get(field))
-				raise_exception = True
-
 		if d.item_code and (flt(d.qty) < 0 or flt(d.get("received_qty")) < 0):
-			if key not in valid_items:
-				frappe.msgprint(
+			if d.item_code not in valid_items:
+				frappe.throw(
 					_("Row # {0}: Returned Item {1} does not exist in {2} {3}").format(
 						d.idx, d.item_code, doc.doctype, doc.return_against
-					),
-					raise_exception=raise_exception,
+					)
 				)
 			else:
-				ref = valid_items.get(key, frappe._dict())
+				ref = valid_items.get(d.item_code, frappe._dict())
 				validate_quantity(doc, d, ref, valid_items, already_returned_items)
 
 				if (
@@ -218,12 +206,8 @@ def validate_quantity(doc, args, ref, valid_items, already_returned_items):
 def get_ref_item_dict(valid_items, ref_item_row):
 	from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
 
-	key = ref_item_row.item_code
-	if ref_item_row.get("name"):
-		key = (ref_item_row.item_code, ref_item_row.name)
-
 	valid_items.setdefault(
-		key,
+		ref_item_row.item_code,
 		frappe._dict(
 			{
 				"qty": 0,
@@ -237,7 +221,7 @@ def get_ref_item_dict(valid_items, ref_item_row):
 			}
 		),
 	)
-	item_dict = valid_items[key]
+	item_dict = valid_items[ref_item_row.item_code]
 	item_dict["qty"] += ref_item_row.qty
 	item_dict["stock_qty"] += ref_item_row.get("stock_qty", 0)
 	if ref_item_row.get("rate", 0) > item_dict["rate"]:
@@ -350,8 +334,6 @@ def make_return_doc(doctype: str, source_name: str, target_doc=None):
 	def set_missing_values(source, target):
 		doc = frappe.get_doc(target)
 		doc.is_return = 1
-		doc.ignore_pricing_rule = 1
-		doc.pricing_rules = []
 		doc.return_against = source.name
 		doc.set_warehouse = ""
 		if doctype == "Sales Invoice" or doctype == "POS Invoice":
@@ -415,7 +397,6 @@ def make_return_doc(doctype: str, source_name: str, target_doc=None):
 
 	def update_item(source_doc, target_doc, source_parent):
 		target_doc.qty = -1 * source_doc.qty
-		target_doc.pricing_rules = None
 
 		if source_doc.serial_no:
 			returned_serial_nos = get_returned_serial_nos(source_doc, source_parent)

erpnext/controllers/selling_controller.py

@@ -456,16 +456,6 @@ class SellingController(StockController):
 						raise_error_if_no_rate=False,
 					)
 
-				if (
-					not d.incoming_rate
-					and self.get("return_against")
-					and self.get("is_return")
-					and get_valuation_method(d.item_code) == "Moving Average"
-				):
-					d.incoming_rate = get_rate_for_return(
-						self.doctype, self.name, d.item_code, self.return_against, item_row=d
-					)
-
 				# For internal transfers use incoming rate as the valuation rate
 				if self.is_internal_transfer():
 					if self.doctype == "Delivery Note" or self.get("update_stock"):
@@ -601,7 +591,7 @@ class SellingController(StockController):
 		if self.doctype in ["Sales Order", "Quotation"]:
 			for item in self.items:
 				item.gross_profit = flt(
-					((flt(item.stock_uom_rate) - flt(item.valuation_rate)) * item.stock_qty),
+					((item.base_rate - flt(item.valuation_rate)) * item.stock_qty),
 					self.precision("amount", item),
 				)
 

erpnext/controllers/stock_controller.py

@@ -50,21 +50,6 @@ class StockController(AccountsController):
 		self.set_rate_of_stock_uom()
 		self.validate_internal_transfer()
 		self.validate_putaway_capacity()
-		self.reset_conversion_factor()
-
-	def reset_conversion_factor(self):
-		for row in self.get("items"):
-			if row.uom != row.stock_uom:
-				continue
-
-			if row.conversion_factor != 1.0:
-				row.conversion_factor = 1.0
-				frappe.msgprint(
-					_(
-						"Conversion factor for item {0} has been reset to 1.0 as the uom {1} is same as stock uom {2}."
-					).format(bold(row.item_code), bold(row.uom), bold(row.stock_uom)),
-					alert=True,
-				)
 
 	def make_gl_entries(self, gl_entries=None, from_repost=False, via_landed_cost_voucher=False):
 		if self.docstatus == 2:

erpnext/controllers/taxes_and_totals.py

@@ -8,7 +8,6 @@ import frappe
 from frappe import _, scrub
 from frappe.model.document import Document
 from frappe.utils import cint, flt, round_based_on_smallest_currency_fraction
-from frappe.utils.deprecations import deprecated
 
 import erpnext
 from erpnext.accounts.doctype.journal_entry.journal_entry import get_exchange_rate
@@ -72,7 +71,7 @@ class calculate_taxes_and_totals:
 		self.calculate_net_total()
 		self.calculate_tax_withholding_net_total()
 		self.calculate_taxes()
-		self.adjust_grand_total_for_inclusive_tax()
+		self.manipulate_grand_total_for_inclusive_tax()
 		self.calculate_totals()
 		self._cleanup()
 		self.calculate_total_net_weight()
@@ -90,9 +89,6 @@ class calculate_taxes_and_totals:
 			self.doc.base_tax_withholding_net_total = sum_base_net_amount
 
 	def validate_item_tax_template(self):
-		if self.doc.get("is_return") and self.doc.get("return_against"):
-			return
-
 		for item in self._items:
 			if item.item_code and item.get("item_tax_template"):
 				item_doc = frappe.get_cached_doc("Item", item.item_code)
@@ -241,6 +237,7 @@ class calculate_taxes_and_totals:
 				"tax_fraction_for_current_item",
 				"grand_total_fraction_for_current_item",
 			]
+
 			if tax.charge_type != "Actual" and not (
 				self.discount_amount_applied and self.doc.apply_discount_on == "Grand Total"
 			):
@@ -283,7 +280,7 @@ class calculate_taxes_and_totals:
 			):
 				amount = flt(item.amount) - total_inclusive_tax_amount_per_qty
 
-				item.net_amount = flt(amount / (1 + cumulated_tax_fraction), item.precision("net_amount"))
+				item.net_amount = flt(amount / (1 + cumulated_tax_fraction))
 				item.net_rate = flt(item.net_amount / item.qty, item.precision("net_rate"))
 				item.discount_percentage = flt(
 					item.discount_percentage, item.precision("discount_percentage")
@@ -508,12 +505,7 @@ class calculate_taxes_and_totals:
 			tax.base_tax_amount = round(tax.base_tax_amount, 0)
 			tax.base_tax_amount_after_discount_amount = round(tax.base_tax_amount_after_discount_amount, 0)
 
-	@deprecated
 	def manipulate_grand_total_for_inclusive_tax(self):
-		# for backward compatablility - if in case used by an external application
-		return self.adjust_grand_total_for_inclusive_tax()
-
-	def adjust_grand_total_for_inclusive_tax(self):
 		# if fully inclusive taxes and diff
 		if self.doc.get("taxes") and any(cint(t.included_in_print_rate) for t in self.doc.get("taxes")):
 			last_tax = self.doc.get("taxes")[-1]
@@ -535,21 +527,17 @@ class calculate_taxes_and_totals:
 			diff = flt(diff, self.doc.precision("rounding_adjustment"))
 
 			if diff and abs(diff) <= (5.0 / 10 ** last_tax.precision("tax_amount")):
-				self.doc.grand_total_diff = diff
-			else:
-				self.doc.grand_total_diff = 0
+				self.doc.rounding_adjustment = diff
 
 	def calculate_totals(self):
 		if self.doc.get("taxes"):
-			self.doc.grand_total = flt(self.doc.get("taxes")[-1].total) + flt(
-				self.doc.get("grand_total_diff")
-			)
+			self.doc.grand_total = flt(self.doc.get("taxes")[-1].total) + flt(self.doc.rounding_adjustment)
 		else:
 			self.doc.grand_total = flt(self.doc.net_total)
 
 		if self.doc.get("taxes"):
 			self.doc.total_taxes_and_charges = flt(
-				self.doc.grand_total - self.doc.net_total - flt(self.doc.get("grand_total_diff")),
+				self.doc.grand_total - self.doc.net_total - flt(self.doc.rounding_adjustment),
 				self.doc.precision("total_taxes_and_charges"),
 			)
 		else:
@@ -612,8 +600,8 @@ class calculate_taxes_and_totals:
 				self.doc.grand_total, self.doc.currency, self.doc.precision("rounded_total")
 			)
 
-			# rounding adjustment should always be the difference vetween grand and rounded total
-			self.doc.rounding_adjustment = flt(
+			# if print_in_rate is set, we would have already calculated rounding adjustment
+			self.doc.rounding_adjustment += flt(
 				self.doc.rounded_total - self.doc.grand_total, self.doc.precision("rounding_adjustment")
 			)
 

erpnext/crm/doctype/opportunity/opportunity.json

@@ -185,8 +185,7 @@
   {
    "fieldname": "expected_closing",
    "fieldtype": "Date",
-   "label": "Expected Closing Date",
-   "no_copy": 1
+   "label": "Expected Closing Date"
   },
   {
    "fieldname": "section_break_14",
@@ -358,7 +357,6 @@
    "fieldname": "transaction_date",
    "fieldtype": "Date",
    "label": "Opportunity Date",
-   "no_copy": 1,
    "oldfieldname": "transaction_date",
    "oldfieldtype": "Date",
    "reqd": 1,
@@ -390,7 +388,6 @@
    "fieldname": "first_response_time",
    "fieldtype": "Duration",
    "label": "First Response Time",
-   "no_copy": 1,
    "read_only": 1
   },
   {
@@ -625,7 +622,7 @@
  "icon": "fa fa-info-sign",
  "idx": 195,
  "links": [],
- "modified": "2024-08-20 04:12:29.095761",
+ "modified": "2022-10-13 12:42:21.545636",
  "modified_by": "Administrator",
  "module": "CRM",
  "name": "Opportunity",

erpnext/crm/doctype/opportunity/opportunity.py

@@ -27,26 +27,7 @@ from erpnext.utilities.transaction_base import TransactionBase
 class Opportunity(TransactionBase, CRMNote):
 	def onload(self):
 		ref_doc = frappe.get_doc(self.opportunity_from, self.party_name)
-
 		load_address_and_contact(ref_doc)
-		load_address_and_contact(self)
-
-		ref_doc_contact_list = ref_doc.get("__onload").get("contact_list")
-		opportunity_doc_contact_list = [
-			contact
-			for contact in self.get("__onload").get("contact_list")
-			if contact not in ref_doc_contact_list
-		]
-		ref_doc_contact_list.extend(opportunity_doc_contact_list)
-		ref_doc.set_onload("contact_list", ref_doc_contact_list)
-
-		ref_doc_addr_list = ref_doc.get("__onload").get("addr_list")
-		opportunity_doc_addr_list = [
-			addr for addr in self.get("__onload").get("addr_list") if addr not in ref_doc_addr_list
-		]
-		ref_doc_addr_list.extend(opportunity_doc_addr_list)
-		ref_doc.set_onload("addr_list", ref_doc_addr_list)
-
 		self.set("__onload", ref_doc.get("__onload"))
 
 	def after_insert(self):

erpnext/crm/report/opportunity_summary_by_sales_stage/opportunity_summary_by_sales_stage.py

@@ -108,9 +108,7 @@ class OpportunitySummaryBySalesStage:
 			self.grouped_data = []
 
 			grouping_key = lambda o: (o["sales_stage"], o[based_on])  # noqa
-			for (sales_stage, _based_on), rows in groupby(
-				sorted(self.query_result, key=grouping_key), key=grouping_key
-			):
+			for (sales_stage, _based_on), rows in groupby(self.query_result, grouping_key):
 				self.grouped_data.append(
 					{
 						"sales_stage": sales_stage,

erpnext/crm/report/sales_pipeline_analytics/sales_pipeline_analytics.py

@@ -122,9 +122,7 @@ class SalesPipelineAnalytics:
 			self.grouped_data = []
 
 			grouping_key = lambda o: (o.get(self.pipeline_by) or "Not Assigned", o[self.period_by])  # noqa
-			for (pipeline_by, period_by), rows in groupby(
-				sorted(self.query_result, key=grouping_key), grouping_key
-			):
+			for (pipeline_by, period_by), rows in groupby(self.query_result, grouping_key):
 				self.grouped_data.append(
 					{
 						self.pipeline_by: pipeline_by,

erpnext/hooks.py

@@ -354,6 +354,7 @@ doc_events = {
 	"Payment Entry": {
 		"on_submit": [
 			"erpnext.regional.create_transaction_log",
+			"erpnext.accounts.doctype.payment_request.payment_request.update_payment_req_status",
 			"erpnext.accounts.doctype.dunning.dunning.resolve_dunning",
 		],
 		"on_trash": "erpnext.regional.check_deletion_permission",

erpnext/manufacturing/doctype/bom_update_log/bom_update_log.py

@@ -8,7 +8,7 @@ from frappe import _
 from frappe.model.document import Document
 from frappe.query_builder import DocType, Interval
 from frappe.query_builder.functions import Now
-from frappe.utils import cint, cstr, date_diff, today
+from frappe.utils import cint, cstr
 
 from erpnext.manufacturing.doctype.bom_update_log.bom_updation_utils import (
 	get_leaf_boms,
@@ -67,12 +67,10 @@ class BOMUpdateLog(Document):
 
 		wip_log = frappe.get_all(
 			"BOM Update Log",
-			fields=["name", "modified"],
-			filters={"update_type": "Update Cost", "status": ["in", ["Queued", "In Progress"]]},
+			{"update_type": "Update Cost", "status": ["in", ["Queued", "In Progress"]]},
 			limit_page_length=1,
 		)
-
-		if wip_log and date_diff(today(), wip_log[0].modified) < 1:
+		if wip_log:
 			log_link = frappe.utils.get_link_to_form("BOM Update Log", wip_log[0].name)
 			frappe.throw(
 				_("BOM Updation already in progress. Please wait until {0} is complete.").format(log_link),

erpnext/manufacturing/doctype/job_card/job_card.py

@@ -521,7 +521,7 @@ class JobCard(Document):
 		self.set_transferred_qty()
 
 	def validate_transfer_qty(self):
-		if not self.is_corrective_job_card and self.items and self.transferred_qty < self.for_quantity:
+		if self.items and self.transferred_qty < self.for_quantity:
 			frappe.throw(
 				_(
 					"Materials needs to be transferred to the work in progress warehouse for the job card {0}"
@@ -767,19 +767,26 @@ class JobCard(Document):
 
 		qty = 0
 		if self.work_order:
+			doc = frappe.get_doc("Work Order", self.work_order)
 			if doc.transfer_material_against == "Job Card" and not doc.skip_transfer:
-				min_qty = []
+				completed = True
 				for d in doc.operations:
-					if d.completed_qty:
-						min_qty.append(d.completed_qty)
-					else:
-						min_qty = []
+					if d.status != "Completed":
+						completed = False
 						break
 
-				if min_qty:
-					qty = min(min_qty)
+				if completed:
+					job_cards = frappe.get_all(
+						"Job Card",
+						filters={"work_order": self.work_order, "docstatus": ("!=", 2)},
+						fields="sum(transferred_qty) as qty",
+						group_by="operation_id",
+					)
 
-				doc.db_set("material_transferred_for_manufacturing", qty)
+					if job_cards:
+						qty = min(d.qty for d in job_cards)
+
+			doc.db_set("material_transferred_for_manufacturing", qty)
 
 		self.set_status(update_status)
 

erpnext/patches.txt

@@ -357,7 +357,6 @@ erpnext.patches.v14_0.clear_reconciliation_values_from_singles
 erpnext.patches.v14_0.update_total_asset_cost_field
 erpnext.patches.v14_0.create_accounting_dimensions_in_reconciliation_tool
 erpnext.patches.v14_0.update_flag_for_return_invoices #2024-03-22
-erpnext.patches.v14_0.update_pos_return_ledger_entries #2024-08-16
 # below migration patch should always run last
 erpnext.patches.v14_0.migrate_gl_to_payment_ledger
 erpnext.stock.doctype.delivery_note.patches.drop_unused_return_against_index # 2023-12-20
@@ -366,23 +365,3 @@ execute:frappe.db.set_single_value('E Commerce Settings', 'show_actual_qty', 1)
 erpnext.patches.v14_0.delete_orphaned_asset_movement_item_records
 erpnext.patches.v14_0.remove_cancelled_asset_capitalization_from_asset
 erpnext.patches.v14_0.enable_set_priority_for_pricing_rules #1
-<<<<<<< HEAD
-erpnext.patches.v14_0.update_currency_exchange_settings_for_frankfurter
-=======
-erpnext.patches.v15_0.rename_number_of_depreciations_booked_to_opening_booked_depreciations
-erpnext.patches.v15_0.add_default_operations
-erpnext.patches.v15_0.enable_old_serial_batch_fields
-erpnext.patches.v15_0.update_warehouse_field_in_asset_repair_consumed_item_doctype
-erpnext.patches.v15_0.update_asset_repair_field_in_stock_entry
-erpnext.patches.v15_0.update_total_number_of_booked_depreciations
-erpnext.patches.v15_0.do_not_use_batchwise_valuation
-erpnext.patches.v15_0.update_invoice_remarks
-erpnext.patches.v14_0.update_reports_with_range
-erpnext.patches.v15_0.drop_index_posting_datetime_from_sle
-erpnext.patches.v15_0.add_disassembly_order_stock_entry_type #1
-erpnext.patches.v15_0.set_standard_stock_entry_type
-erpnext.patches.v15_0.set_difference_amount_in_asset_value_adjustment
-erpnext.patches.v15_0.link_purchase_item_to_asset_doc
-erpnext.patches.v15_0.migrate_to_utm_analytics
-erpnext.patches.v15_0.update_sub_voucher_type_in_gl_entries
->>>>>>> d76cc21086 (fix: patch)