chore(release): Bumped to Version 15.34.0

# [15.34.0](https://github.com/frappe/erpnext/compare/v15.33.5...v15.34.0) (2024-08-28)

### Bug Fixes

* calculation correction for annual depreciation ([fa85482](fa85482662))
* call 'process' directly instead of creating 'process_subscripti ([7582827](758282739e))
* Cannot read properties of null (reading 'doctype') (backport [#42941](https://github.com/frappe/erpnext/issues/42941)) ([#42943](https://github.com/frappe/erpnext/issues/42943)) ([2c99075](2c99075899))
* Column 'valuation_rate' cannot be null (backport [#42909](https://github.com/frappe/erpnext/issues/42909)) ([#42913](https://github.com/frappe/erpnext/issues/42913)) ([8c350d4](8c350d43b2))
* custom stock entry type issue (backport [#42835](https://github.com/frappe/erpnext/issues/42835)) ([#42846](https://github.com/frappe/erpnext/issues/42846)) ([831e2aa](831e2aaf18))
* do not copy date fields in opportunity doctype ([7401dc4](7401dc4015))
* get amount with taxes and charges from payment entry ([c54e97b](c54e97b89a))
* include erpnext in apps page ([7428df8](7428df8778))
* incorrect in and out qty in the Batch-Wise Balance History (backport [#42866](https://github.com/frappe/erpnext/issues/42866)) ([#42876](https://github.com/frappe/erpnext/issues/42876)) ([d9ca680](d9ca680a29))
* incorrect Received Qty Amount in Purchase Order Analysis (backport [#42852](https://github.com/frappe/erpnext/issues/42852)) ([#42854](https://github.com/frappe/erpnext/issues/42854)) ([72c1609](72c16097d6))
* last purchase rate not updated from purchase invoice (backport [#42847](https://github.com/frappe/erpnext/issues/42847)) ([#42853](https://github.com/frappe/erpnext/issues/42853)) ([2203ea9](2203ea9301))
* LCV based on purchase invoice amount with multi-currency (backport [#42890](https://github.com/frappe/erpnext/issues/42890)) ([#42894](https://github.com/frappe/erpnext/issues/42894)) ([ff868a9](ff868a9290))
* make party naming sequential when naming_by set as auto name ([0650c22](0650c22b53))
* not able to make stock entry against MR (backport [#42874](https://github.com/frappe/erpnext/issues/42874)) ([#42875](https://github.com/frappe/erpnext/issues/42875)) ([08bed61](08bed618f6))
* same posting date and time, creation causing incorrect balance qty (backport [#42904](https://github.com/frappe/erpnext/issues/42904)) ([#42920](https://github.com/frappe/erpnext/issues/42920)) ([2624892](26248924b6))
* spec mobile and email fields for notifications ([f56ee58](f56ee58e81))
* timeout while submitting stock entry (backport [#42929](https://github.com/frappe/erpnext/issues/42929)) ([#42931](https://github.com/frappe/erpnext/issues/42931)) ([ec26c92](ec26c92263))
* unsupported operand type(s) for *: 'float' and 'NoneType' (backport [#42916](https://github.com/frappe/erpnext/issues/42916)) ([#42918](https://github.com/frappe/erpnext/issues/42918)) ([8d29dc6](8d29dc6a81))
* update dimesions in exchange_gain_loss jv based on base document ([caa6ca1](caa6ca1d0b))
* Update get_amount to return currency precision grand total ([976abf7](976abf7b3c))
* use of incorrect attribute ([80244ba](80244bafa4))

### Features

* added finance book filter in depreciation and balances report ([5bdd298](5bdd2989c6))
* Disassembly Order (backport [#42655](https://github.com/frappe/erpnext/issues/42655)) ([#42957](https://github.com/frappe/erpnext/issues/42957)) ([8d8dd0c](8d8dd0cd2b))
* report to identify incorrectly cleared cheques ([25193c5](25193c5e92))

erpnext/__init__.py

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

erpnext/accounts/doctype/account/account.py

@@ -202,7 +202,7 @@ class Account(NestedSet):
 				msg = _(
 					"There are ledger entries against this account. Changing {0} to non-{1} in live system will cause incorrect output in 'Accounts {2}' report"
 				).format(
-					frappe.bold("Account Type"), doc_before_save.account_type, doc_before_save.account_type
+					frappe.bold(_("Account Type")), doc_before_save.account_type, doc_before_save.account_type
 				)
 				frappe.msgprint(msg)
 				self.add_comment("Comment", msg)

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -55,6 +55,8 @@
   "post_change_gl_entries",
   "assets_tab",
   "asset_settings_section",
+  "calculate_depr_using_total_days",
+  "column_break_gjcc",
   "book_asset_depreciation_entry_automatically",
   "closing_settings_tab",
   "period_closing_settings_section",
@@ -71,7 +73,9 @@
   "remarks_section",
   "general_ledger_remarks_length",
   "column_break_lvjk",
-  "receivable_payable_remarks_length"
+  "receivable_payable_remarks_length",
+  "payment_request_settings",
+  "create_pr_in_draft_status"
  ],
  "fields": [
   {
@@ -462,6 +466,29 @@
    "fieldname": "enable_immutable_ledger",
    "fieldtype": "Check",
    "label": "Enable Immutable Ledger"
+  },
+  {
+   "fieldname": "column_break_gjcc",
+   "fieldtype": "Column Break"
+  },
+  {
+   "default": "0",
+   "description": "Enable this option to calculate daily depreciation by considering the total number of days in the entire depreciation period, (including leap years) while using daily pro-rata based depreciation",
+   "fieldname": "calculate_depr_using_total_days",
+   "fieldtype": "Check",
+   "label": "Calculate daily depreciation using total days in depreciation period"
+  },
+  {
+   "description": "Payment Request created from Sales Order or Purchase Order will be in Draft status. When disabled document will be in unsaved state.",
+   "fieldname": "payment_request_settings",
+   "fieldtype": "Tab Break",
+   "label": "Payment Request"
+  },
+  {
+   "default": "1",
+   "fieldname": "create_pr_in_draft_status",
+   "fieldtype": "Check",
+   "label": "Create in Draft Status"
   }
  ],
  "icon": "icon-cog",
@@ -469,7 +496,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2024-05-11 23:19:44.673975",
+ "modified": "2024-07-26 06:48:52.714630",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",
@@ -498,4 +525,4 @@
  "sort_order": "ASC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -33,7 +33,9 @@ class AccountsSettings(Document):
 		book_deferred_entries_based_on: DF.Literal["Days", "Months"]
 		book_deferred_entries_via_journal_entry: DF.Check
 		book_tax_discount_loss: DF.Check
+		calculate_depr_using_total_days: DF.Check
 		check_supplier_invoice_uniqueness: DF.Check
+		create_pr_in_draft_status: DF.Check
 		credit_controller: DF.Link | None
 		delete_linked_ledger_entries: DF.Check
 		determine_address_tax_category_from: DF.Literal["Billing Address", "Shipping Address"]

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, getdate
+from frappe.utils import flt, fmt_money, get_link_to_form, getdate
 from pypika import Order
 
 import erpnext
@@ -96,8 +96,11 @@ class BankClearance(Document):
 
 				if d.cheque_date and getdate(d.clearance_date) < getdate(d.cheque_date):
 					frappe.throw(
-						_("Row #{0}: Clearance date {1} cannot be before Cheque Date {2}").format(
-							d.idx, d.clearance_date, d.cheque_date
+						_("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,
 						)
 					)
 

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -47,9 +47,11 @@ def validate_columns(data):
 
 	no_of_columns = max([len(d) for d in data])
 
-	if no_of_columns > 8:
+	if no_of_columns != 8:
 		frappe.throw(
-			_("More columns found than expected. Please compare the uploaded file with standard template"),
+			_(
+				"Columns are not according to template. Please compare the uploaded file with standard template"
+			),
 			title=(_("Wrong Template")),
 		)
 

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js

@@ -85,18 +85,16 @@ frappe.ui.form.on("Exchange Rate Revaluation", {
 	},
 
 	make_jv: function (frm) {
-		let revaluation_journal = null;
-		let zero_balance_journal = null;
 		frappe.call({
 			method: "make_jv_entries",
 			doc: frm.doc,
 			freeze: true,
-			freeze_message: "Making Journal Entries...",
+			freeze_message: __("Creating Journal Entries..."),
 			callback: function (r) {
 				if (r.message) {
 					let response = r.message;
 					if (response["revaluation_jv"] || response["zero_balance_jv"]) {
-						frappe.msgprint(__("Journals have been created"));
+						frappe.msgprint(__("Journal entries have been created"));
 					}
 				}
 			},

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -25,30 +25,6 @@ frappe.ui.form.on("Journal Entry", {
 	refresh: function (frm) {
 		erpnext.toggle_naming_series();
 
-		if (frm.doc.repost_required && frm.doc.docstatus === 1) {
-			frm.set_intro(
-				__(
-					"Accounting entries for this Journal Entry need to be reposted. Please click on 'Repost' button to update."
-				)
-			);
-			frm.add_custom_button(__("Repost Accounting Entries"), () => {
-				frm.call({
-					doc: frm.doc,
-					method: "repost_accounting_entries",
-					freeze: true,
-					freeze_message: __("Reposting..."),
-					callback: (r) => {
-						if (!r.exc) {
-							frappe.msgprint(__("Accounting Entries are reposted."));
-							frm.refresh();
-						}
-					},
-				});
-			})
-				.removeClass("btn-default")
-				.addClass("btn-warning");
-		}
-
 		if (frm.doc.docstatus > 0) {
 			frm.add_custom_button(
 				__("Ledger"),

erpnext/accounts/doctype/journal_entry/journal_entry.json

@@ -64,8 +64,7 @@
   "stock_entry",
   "subscription_section",
   "auto_repeat",
-  "amended_from",
-  "repost_required"
+  "amended_from"
  ],
  "fields": [
   {
@@ -544,15 +543,6 @@
    "label": "Is System Generated",
    "no_copy": 1,
    "read_only": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "repost_required",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Repost Required",
-   "print_hide": 1,
-   "read_only": 1
   }
  ],
  "icon": "fa fa-file-text",
@@ -567,7 +557,7 @@
    "table_fieldname": "payment_entries"
   }
  ],
- "modified": "2023-11-23 12:11:04.128015",
+ "modified": "2024-07-18 15:32:29.413598",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Journal Entry",
@@ -618,4 +608,4 @@
  "states": [],
  "title_field": "title",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -47,9 +47,7 @@ class JournalEntry(AccountsController):
 	if TYPE_CHECKING:
 		from frappe.types import DF
 
-		from erpnext.accounts.doctype.journal_entry_account.journal_entry_account import (
-			JournalEntryAccount,
-		)
+		from erpnext.accounts.doctype.journal_entry_account.journal_entry_account import JournalEntryAccount
 
 		accounts: DF.Table[JournalEntryAccount]
 		amended_from: DF.Link | None
@@ -197,13 +195,10 @@ class JournalEntry(AccountsController):
 		self.update_booked_depreciation()
 
 	def on_update_after_submit(self):
-		if hasattr(self, "repost_required"):
-			self.needs_repost = self.check_if_fields_updated(
-				fields_to_check=[], child_tables={"accounts": []}
-			)
-			if self.needs_repost:
-				self.validate_for_repost()
-				self.db_set("repost_required", self.needs_repost)
+		self.needs_repost = self.check_if_fields_updated(fields_to_check=[], child_tables={"accounts": []})
+		if self.needs_repost:
+			self.validate_for_repost()
+			self.repost_accounting_entries()
 
 	def on_cancel(self):
 		# References for this Journal are removed on the `on_cancel` event in accounts_controller

erpnext/accounts/doctype/journal_entry/test_journal_entry.py

@@ -454,12 +454,9 @@ class TestJournalEntry(unittest.TestCase):
 		# Change cost center for bank account - _Test Cost Center for BS Account
 		create_cost_center(cost_center_name="_Test Cost Center for BS Account", company="_Test Company")
 		jv.accounts[1].cost_center = "_Test Cost Center for BS Account - _TC"
+		# Ledger reposted implicitly upon 'Update After Submit'
 		jv.save()
 
-		# Check if repost flag gets set on update after submit
-		self.assertTrue(jv.repost_required)
-		jv.repost_accounting_entries()
-
 		# Check GL entries after reposting
 		jv.load_from_db()
 		self.expected_gle[0]["cost_center"] = "_Test Cost Center for BS Account - _TC"
@@ -481,6 +478,43 @@ class TestJournalEntry(unittest.TestCase):
 			for field in self.fields:
 				self.assertEqual(self.expected_gle[i][field], gl_entries[i][field])
 
+	def test_negative_debit_and_credit_with_same_account_head(self):
+		from erpnext.accounts.general_ledger import process_gl_map
+
+		# Create JV with defaut cost center - _Test Cost Center
+		frappe.db.set_single_value("Accounts Settings", "merge_similar_account_heads", 0)
+
+		jv = make_journal_entry("_Test Bank - _TC", "_Test Bank - _TC", 100 * -1, save=True)
+		jv.append(
+			"accounts",
+			{
+				"account": "_Test Cash - _TC",
+				"debit": 100 * -1,
+				"credit": 100 * -1,
+				"debit_in_account_currency": 100 * -1,
+				"credit_in_account_currency": 100 * -1,
+				"exchange_rate": 1,
+			},
+		)
+		jv.flags.ignore_validate = True
+		jv.save()
+
+		self.assertEqual(len(jv.accounts), 3)
+
+		gl_map = jv.build_gl_map()
+
+		for row in gl_map:
+			if row.account == "_Test Cash - _TC":
+				self.assertEqual(row.debit_in_account_currency, 100 * -1)
+				self.assertEqual(row.credit_in_account_currency, 100 * -1)
+
+		gl_map = process_gl_map(gl_map, False)
+
+		for row in gl_map:
+			if row.account == "_Test Cash - _TC":
+				self.assertEqual(row.debit_in_account_currency, 100)
+				self.assertEqual(row.credit_in_account_currency, 100)
+
 
 def make_journal_entry(
 	account1,

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -35,6 +35,11 @@ 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],
@@ -90,6 +95,9 @@ 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],
@@ -165,8 +173,25 @@ frappe.ui.form.on("Payment Entry", {
 				filters: filters,
 			};
 		});
-	},
 
+		frm.set_query("sales_taxes_and_charges_template", function () {
+			return {
+				filters: {
+					company: frm.doc.company,
+					disabled: false,
+				},
+			};
+		});
+
+		frm.set_query("purchase_taxes_and_charges_template", function () {
+			return {
+				filters: {
+					company: frm.doc.company,
+					disabled: false,
+				},
+			};
+		});
+	},
 	refresh: function (frm) {
 		erpnext.hide_company(frm);
 		frm.events.hide_unhide_fields(frm);
@@ -213,7 +238,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
+			? frappe.get_doc(":Company", frm.doc.company)?.default_currency
 			: "";
 
 		frm.toggle_display(
@@ -395,6 +420,12 @@ frappe.ui.form.on("Payment Entry", {
 				return {
 					query: "erpnext.controllers.queries.employee_query",
 				};
+			} else if (frm.doc.party_type == "Shareholder") {
+				return {
+					filters: {
+						company: frm.doc.company,
+					},
+				};
 			}
 		});
 

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -37,7 +37,6 @@ from erpnext.accounts.utils import (
 	get_account_currency,
 	get_balance_on,
 	get_outstanding_invoices,
-	get_party_types_from_account_type,
 )
 from erpnext.controllers.accounts_controller import (
 	AccountsController,
@@ -1119,90 +1118,82 @@ class PaymentEntry(AccountsController):
 		self.make_advance_gl_entries(cancel=cancel)
 
 	def add_party_gl_entries(self, gl_entries):
-		if self.party_account:
-			if self.payment_type == "Receive":
-				against_account = self.paid_to
-			else:
-				against_account = self.paid_from
+		if not self.party_account:
+			return
 
-			party_gl_dict = self.get_gl_dict(
+		if self.payment_type == "Receive":
+			against_account = self.paid_to
+		else:
+			against_account = self.paid_from
+
+		party_account_type = frappe.db.get_value("Party Type", self.party_type, "account_type")
+
+		party_gl_dict = self.get_gl_dict(
+			{
+				"account": self.party_account,
+				"party_type": self.party_type,
+				"party": self.party,
+				"against": against_account,
+				"account_currency": self.party_account_currency,
+				"cost_center": self.cost_center,
+			},
+			item=self,
+		)
+
+		for d in self.get("references"):
+			# re-defining dr_or_cr for every reference in order to avoid the last value affecting calculation of reverse
+			dr_or_cr = "credit" if self.payment_type == "Receive" else "debit"
+			cost_center = self.cost_center
+			if d.reference_doctype == "Sales Invoice" and not cost_center:
+				cost_center = frappe.db.get_value(d.reference_doctype, d.reference_name, "cost_center")
+
+			gle = party_gl_dict.copy()
+
+			allocated_amount_in_company_currency = self.calculate_base_allocated_amount_for_reference(d)
+
+			if (
+				d.reference_doctype in ["Sales Invoice", "Purchase Invoice"]
+				and d.allocated_amount < 0
+				and (
+					(party_account_type == "Receivable" and self.payment_type == "Pay")
+					or (party_account_type == "Payable" and self.payment_type == "Receive")
+				)
+			):
+				# reversing dr_cr because because it will get reversed in gl processing due to negative amount
+				dr_or_cr = "debit" if dr_or_cr == "credit" else "credit"
+
+			gle.update(
 				{
-					"account": self.party_account,
-					"party_type": self.party_type,
-					"party": self.party,
-					"against": against_account,
-					"account_currency": self.party_account_currency,
-					"cost_center": self.cost_center,
-				},
-				item=self,
+					dr_or_cr: allocated_amount_in_company_currency,
+					dr_or_cr + "_in_account_currency": d.allocated_amount,
+					"against_voucher_type": d.reference_doctype,
+					"against_voucher": d.reference_name,
+					"cost_center": cost_center,
+				}
+			)
+			gl_entries.append(gle)
+
+		if self.unallocated_amount:
+			dr_or_cr = "credit" if self.payment_type == "Receive" else "debit"
+			exchange_rate = self.get_exchange_rate()
+			base_unallocated_amount = self.unallocated_amount * exchange_rate
+
+			gle = party_gl_dict.copy()
+			gle.update(
+				{
+					dr_or_cr + "_in_account_currency": self.unallocated_amount,
+					dr_or_cr: base_unallocated_amount,
+				}
 			)
 
-			dr_or_cr = "credit" if self.payment_type == "Receive" else "debit"
-
-			for d in self.get("references"):
-				# re-defining dr_or_cr for every reference in order to avoid the last value affecting calculation of reverse
-				dr_or_cr = "credit" if self.payment_type == "Receive" else "debit"
-				cost_center = self.cost_center
-				if d.reference_doctype == "Sales Invoice" and not cost_center:
-					cost_center = frappe.db.get_value(d.reference_doctype, d.reference_name, "cost_center")
-
-				gle = party_gl_dict.copy()
-
-				allocated_amount_in_company_currency = self.calculate_base_allocated_amount_for_reference(d)
-				reverse_dr_or_cr = 0
-
-				if d.reference_doctype in ["Sales Invoice", "Purchase Invoice"]:
-					is_return = frappe.db.get_value(d.reference_doctype, d.reference_name, "is_return")
-					payable_party_types = get_party_types_from_account_type("Payable")
-					receivable_party_types = get_party_types_from_account_type("Receivable")
-					if (
-						is_return
-						and self.party_type in receivable_party_types
-						and (self.payment_type == "Pay")
-					):
-						reverse_dr_or_cr = 1
-					elif (
-						is_return
-						and self.party_type in payable_party_types
-						and (self.payment_type == "Receive")
-					):
-						reverse_dr_or_cr = 1
-
-					if is_return and not reverse_dr_or_cr:
-						dr_or_cr = "debit" if dr_or_cr == "credit" else "credit"
-
+			if self.book_advance_payments_in_separate_party_account:
 				gle.update(
 					{
-						dr_or_cr: abs(allocated_amount_in_company_currency),
-						dr_or_cr + "_in_account_currency": abs(d.allocated_amount),
-						"against_voucher_type": d.reference_doctype,
-						"against_voucher": d.reference_name,
-						"cost_center": cost_center,
+						"against_voucher_type": "Payment Entry",
+						"against_voucher": self.name,
 					}
 				)
-				gl_entries.append(gle)
-
-			if self.unallocated_amount:
-				dr_or_cr = "credit" if self.payment_type == "Receive" else "debit"
-				exchange_rate = self.get_exchange_rate()
-				base_unallocated_amount = self.unallocated_amount * exchange_rate
-
-				gle = party_gl_dict.copy()
-				gle.update(
-					{
-						dr_or_cr + "_in_account_currency": self.unallocated_amount,
-						dr_or_cr: base_unallocated_amount,
-					}
-				)
-
-				if self.book_advance_payments_in_separate_party_account:
-					gle.update(
-						{
-							"against_voucher_type": "Payment Entry",
-							"against_voucher": self.name,
-						}
-					)
-				gl_entries.append(gle)
+			gl_entries.append(gle)
 
 	def make_advance_gl_entries(
 		self, entry: object | dict = None, cancel: bool = 0, update_outstanding: str = "Yes"
@@ -1749,7 +1740,7 @@ def get_outstanding_reference_documents(args, validate=False):
 				d["bill_no"] = frappe.db.get_value(d.voucher_type, d.voucher_no, "bill_no")
 
 		# Get negative outstanding sales /purchase invoices
-		if args.get("party_type") != "Employee" and not args.get("voucher_no"):
+		if args.get("party_type") != "Employee":
 			negative_outstanding_invoices = get_negative_outstanding_invoices(
 				args.get("party_type"),
 				args.get("party"),

erpnext/accounts/doctype/payment_order/payment_order.js

@@ -36,7 +36,7 @@ frappe.ui.form.on("Payment Order", {
 
 		// payment Entry
 		if (frm.doc.docstatus === 1 && frm.doc.payment_order_type === "Payment Request") {
-			frm.add_custom_button(__("Create Payment Entries"), function () {
+			frm.add_custom_button(__("Create Journal Entries"), function () {
 				frm.trigger("make_payment_records");
 			});
 		}

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -267,6 +267,7 @@ class PaymentReconciliation(Document):
 		conditions.append(doc.docstatus == 1)
 		conditions.append(doc[frappe.scrub(self.party_type)] == self.party)
 		conditions.append(doc.is_return == 1)
+		conditions.append(doc.outstanding_amount != 0)
 
 		if self.payment_name:
 			conditions.append(doc.name.like(f"%{self.payment_name}%"))

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -1805,6 +1805,46 @@ class TestPaymentReconciliation(FrappeTestCase):
 		]
 		self.assertEqual(pl_entries, expected_ple)
 
+	def test_cr_note_payment_limit_filter(self):
+		transaction_date = nowdate()
+		amount = 100
+
+		for _ in range(6):
+			self.create_sales_invoice(qty=1, rate=amount, posting_date=transaction_date)
+			cr_note = self.create_sales_invoice(
+				qty=-1, rate=amount, posting_date=transaction_date, do_not_save=True, do_not_submit=True
+			)
+			cr_note.is_return = 1
+			cr_note = cr_note.save().submit()
+
+		pr = self.create_payment_reconciliation()
+
+		pr.get_unreconciled_entries()
+		self.assertEqual(len(pr.invoices), 6)
+		self.assertEqual(len(pr.payments), 6)
+		invoices = [x.as_dict() for x in pr.get("invoices")]
+		payments = [x.as_dict() for x in pr.get("payments")]
+		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+		pr.reconcile()
+
+		pr.get_unreconciled_entries()
+		self.assertEqual(pr.get("invoices"), [])
+		self.assertEqual(pr.get("payments"), [])
+
+		self.create_sales_invoice(qty=1, rate=amount, posting_date=transaction_date)
+		cr_note = self.create_sales_invoice(
+			qty=-1, rate=amount, posting_date=transaction_date, do_not_save=True, do_not_submit=True
+		)
+		cr_note.is_return = 1
+		cr_note = cr_note.save().submit()
+
+		# Limit should not affect in fetching the unallocated cr_note
+		pr.invoice_limit = 5
+		pr.payment_limit = 5
+		pr.get_unreconciled_entries()
+		self.assertEqual(len(pr.invoices), 1)
+		self.assertEqual(len(pr.payments), 1)
+
 
 def make_customer(customer_name, currency=None):
 	if not frappe.db.exists("Customer", customer_name):

erpnext/accounts/doctype/payment_request/payment_request.json

@@ -144,6 +144,7 @@
    "fieldname": "grand_total",
    "fieldtype": "Currency",
    "label": "Amount",
+   "non_negative": 1,
    "options": "currency"
   },
   {
@@ -395,7 +396,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2023-09-27 09:51:42.277638",
+ "modified": "2024-06-20 13:54:55.245774",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Request",
@@ -433,4 +434,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -15,7 +15,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
+from erpnext.accounts.utils import get_account_currency, get_currency_precision
 from erpnext.utilities import payment_app_import_guard
 
 
@@ -338,6 +338,17 @@ class PaymentRequest(Document):
 		payment_entry.received_amount = amount
 		payment_entry.get("references")[0].allocated_amount = amount
 
+		# 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
+				)
+
 		for dimension in get_accounting_dimensions():
 			payment_entry.update({dimension: self.get(dimension)})
 
@@ -500,7 +511,8 @@ def make_payment_request(**args):
 		if args.order_type == "Shopping Cart" or args.mute_email:
 			pr.flags.mute_email = True
 
-		pr.insert(ignore_permissions=True)
+		if frappe.db.get_single_value("Accounts Settings", "create_pr_in_draft_status", cache=True):
+			pr.insert(ignore_permissions=True)
 		if args.submit_doc:
 			pr.submit()
 
@@ -540,7 +552,7 @@ def get_amount(ref_doc, payment_account=None):
 		grand_total = ref_doc.outstanding_amount
 
 	if grand_total > 0:
-		return grand_total
+		return flt(grand_total, get_currency_precision())
 	else:
 		frappe.throw(_("Payment Entry is already created"))
 

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -4,10 +4,12 @@
 import unittest
 
 import frappe
+from frappe.tests.utils import FrappeTestCase
 
 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
 
@@ -32,7 +34,7 @@ payment_method = [
 ]
 
 
-class TestPaymentRequest(unittest.TestCase):
+class TestPaymentRequest(FrappeTestCase):
 	def setUp(self):
 		if not frappe.db.get_value("Payment Gateway", payment_gateway["gateway"], "name"):
 			frappe.get_doc(payment_gateway).insert(ignore_permissions=True)
@@ -260,3 +262,19 @@ class TestPaymentRequest(unittest.TestCase):
 		# 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)

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -136,18 +136,28 @@ class PeriodClosingVoucher(AccountsController):
 
 	def check_if_previous_year_closed(self):
 		last_year_closing = add_days(self.year_start_date, -1)
-
 		previous_fiscal_year = get_fiscal_year(last_year_closing, company=self.company, boolean=True)
+		if not previous_fiscal_year:
+			return
 
-		if previous_fiscal_year and not frappe.db.exists(
+		previous_fiscal_year_start_date = previous_fiscal_year[0][1]
+		if not frappe.db.exists(
 			"GL Entry",
-			{"posting_date": ("<=", last_year_closing), "company": self.company, "is_cancelled": 0},
+			{
+				"posting_date": ("between", [previous_fiscal_year_start_date, last_year_closing]),
+				"company": self.company,
+				"is_cancelled": 0,
+			},
 		):
 			return
 
-		if previous_fiscal_year and not frappe.db.exists(
+		if not frappe.db.exists(
 			"Period Closing Voucher",
-			{"posting_date": ("<=", last_year_closing), "docstatus": 1, "company": self.company},
+			{
+				"posting_date": ("between", [previous_fiscal_year_start_date, last_year_closing]),
+				"docstatus": 1,
+				"company": self.company,
+			},
 		):
 			frappe.throw(_("Previous Year is not closed, please close it first"))
 

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.py

@@ -87,19 +87,15 @@ class POSClosingEntry(StatusUpdater):
 				as_dict=1,
 			)[0]
 			if pos_invoice.consolidated_invoice:
-				invalid_row.setdefault("msg", []).append(
-					_("POS Invoice is {}").format(frappe.bold("already consolidated"))
-				)
+				invalid_row.setdefault("msg", []).append(_("POS Invoice is already consolidated"))
 				invalid_rows.append(invalid_row)
 				continue
 			if pos_invoice.pos_profile != self.pos_profile:
 				invalid_row.setdefault("msg", []).append(
-					_("POS Profile doesn't matches {}").format(frappe.bold(self.pos_profile))
+					_("POS Profile doesn't match {}").format(frappe.bold(self.pos_profile))
 				)
 			if pos_invoice.docstatus != 1:
-				invalid_row.setdefault("msg", []).append(
-					_("POS Invoice is not {}").format(frappe.bold("submitted"))
-				)
+				invalid_row.setdefault("msg", []).append(_("POS Invoice is not submitted"))
 			if pos_invoice.owner != self.user:
 				invalid_row.setdefault("msg", []).append(
 					_("POS Invoice isn't created by user {}").format(frappe.bold(self.owner))

erpnext/accounts/doctype/pos_closing_entry/test_pos_closing_entry.py

@@ -17,6 +17,10 @@ from erpnext.accounts.doctype.pos_invoice.test_pos_invoice import create_pos_inv
 from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
 from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
 from erpnext.selling.page.point_of_sale.point_of_sale import get_items
+from erpnext.stock.doctype.item.test_item import make_item
+from erpnext.stock.doctype.serial_and_batch_bundle.test_serial_and_batch_bundle import (
+	get_batch_from_bundle,
+)
 from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
 
 
@@ -179,6 +183,94 @@ class TestPOSClosingEntry(unittest.TestCase):
 		accounting_dimension_department.save()
 		disable_dimension()
 
+	def test_merging_into_sales_invoice_for_batched_item(self):
+		frappe.flags.print_message = False
+		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import (
+			init_user_and_profile,
+		)
+		from erpnext.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import (
+			consolidate_pos_invoices,
+		)
+		from erpnext.stock.doctype.batch.batch import get_batch_qty
+
+		frappe.db.sql("delete from `tabPOS Invoice`")
+		item_doc = make_item(
+			"_Test Item With Batch FOR POS Merge Test",
+			properties={
+				"is_stock_item": 1,
+				"has_batch_no": 1,
+				"batch_number_series": "BATCH-PM-POS-MERGE-.####",
+				"create_new_batch": 1,
+			},
+		)
+
+		item_code = item_doc.name
+		se = make_stock_entry(
+			target="_Test Warehouse - _TC",
+			item_code=item_code,
+			qty=10,
+			basic_rate=100,
+			use_serial_batch_fields=0,
+		)
+		batch_no = get_batch_from_bundle(se.items[0].serial_and_batch_bundle)
+
+		test_user, pos_profile = init_user_and_profile()
+		opening_entry = create_opening_entry(pos_profile, test_user.name)
+
+		pos_inv = create_pos_invoice(
+			item_code=item_code, qty=5, rate=300, use_serial_batch_fields=1, batch_no=batch_no
+		)
+		pos_inv2 = create_pos_invoice(
+			item_code=item_code, qty=5, rate=300, use_serial_batch_fields=1, batch_no=batch_no
+		)
+
+		batch_qty = frappe.db.get_value("Batch", batch_no, "batch_qty")
+		self.assertEqual(batch_qty, 10)
+
+		batch_qty_with_pos = get_batch_qty(batch_no, "_Test Warehouse - _TC", item_code)
+		self.assertEqual(batch_qty_with_pos, 0.0)
+
+		pcv_doc = make_closing_entry_from_opening(opening_entry)
+		pcv_doc.submit()
+
+		piv_merge = frappe.db.get_value("POS Invoice Merge Log", {"pos_closing_entry": pcv_doc.name}, "name")
+
+		self.assertTrue(piv_merge)
+		piv_merge_doc = frappe.get_doc("POS Invoice Merge Log", piv_merge)
+		self.assertTrue(piv_merge_doc.pos_invoices[0].pos_invoice)
+		self.assertTrue(piv_merge_doc.pos_invoices[1].pos_invoice)
+
+		pos_inv.load_from_db()
+		self.assertTrue(pos_inv.consolidated_invoice)
+		pos_inv2.load_from_db()
+		self.assertTrue(pos_inv2.consolidated_invoice)
+
+		batch_qty = frappe.db.get_value("Batch", batch_no, "batch_qty")
+		self.assertEqual(batch_qty, 0.0)
+
+		batch_qty_with_pos = get_batch_qty(batch_no, "_Test Warehouse - _TC", item_code)
+		self.assertEqual(batch_qty_with_pos, 0.0)
+
+		frappe.flags.print_message = True
+
+		pcv_doc.reload()
+		pcv_doc.cancel()
+
+		batch_qty = frappe.db.get_value("Batch", batch_no, "batch_qty")
+		self.assertEqual(batch_qty, 10)
+
+		batch_qty_with_pos = get_batch_qty(batch_no, "_Test Warehouse - _TC", item_code)
+		self.assertEqual(batch_qty_with_pos, 0.0)
+
+		pos_inv.reload()
+		pos_inv2.reload()
+
+		pos_inv.cancel()
+		pos_inv2.cancel()
+
+		batch_qty_with_pos = get_batch_qty(batch_no, "_Test Warehouse - _TC", item_code)
+		self.assertEqual(batch_qty_with_pos, 10.0)
+
 
 def init_user_and_profile(**args):
 	user = "test@example.com"

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -188,7 +188,7 @@ class POSInvoice(SalesInvoice):
 	def validate(self):
 		if not cint(self.is_pos):
 			frappe.throw(
-				_("POS Invoice should have {} field checked.").format(frappe.bold("Include Payment"))
+				_("POS Invoice should have the field {0} checked.").format(frappe.bold(_("Include Payment")))
 			)
 
 		# run on validate method of selling controller
@@ -229,7 +229,9 @@ class POSInvoice(SalesInvoice):
 		self.check_phone_payments()
 		self.set_status(update=True)
 		self.make_bundle_for_sales_purchase_return()
-		self.submit_serial_batch_bundle()
+		for table_name in ["items", "packed_items"]:
+			self.make_bundle_using_old_serial_batch_fields(table_name)
+			self.submit_serial_batch_bundle(table_name)
 
 		if self.coupon_code:
 			from erpnext.accounts.doctype.pricing_rule.utils import update_coupon_code_count
@@ -283,10 +285,11 @@ class POSInvoice(SalesInvoice):
 						{"is_cancelled": 1, "voucher_no": ""},
 					)
 
+				frappe.get_doc("Serial and Batch Bundle", row.serial_and_batch_bundle).cancel()
 				row.db_set("serial_and_batch_bundle", None)
 
-	def submit_serial_batch_bundle(self):
-		for item in self.items:
+	def submit_serial_batch_bundle(self, table_name):
+		for item in self.get(table_name):
 			if item.serial_and_batch_bundle:
 				doc = frappe.get_doc("Serial and Batch Bundle", item.serial_and_batch_bundle)
 
@@ -355,10 +358,16 @@ class POSInvoice(SalesInvoice):
 		error_msg = []
 		for d in self.get("items"):
 			error_msg = ""
-			if d.get("has_serial_no") and not d.serial_and_batch_bundle:
+			if d.get("has_serial_no") and (
+				(not d.use_serial_batch_fields and not d.serial_and_batch_bundle)
+				or (d.use_serial_batch_fields and not d.serial_no)
+			):
 				error_msg = f"Row #{d.idx}: Please select Serial No. for item {bold(d.item_code)}"
 
-			elif d.get("has_batch_no") and not d.serial_and_batch_bundle:
+			elif d.get("has_batch_no") and (
+				(not d.use_serial_batch_fields and not d.serial_and_batch_bundle)
+				or (d.use_serial_batch_fields and not d.batch_no)
+			):
 				error_msg = f"Row #{d.idx}: Please select Batch No. for item {bold(d.item_code)}"
 
 		if error_msg:

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -780,8 +780,6 @@ class TestPOSInvoice(unittest.TestCase):
 		pos_inv1.submit()
 		pos_inv1.reload()
 
-		self.assertFalse(pos_inv1.items[0].serial_and_batch_bundle)
-
 		batches = get_auto_batch_nos(
 			frappe._dict({"item_code": "_BATCH ITEM Test For Reserve", "warehouse": "_Test Warehouse - _TC"})
 		)
@@ -957,7 +955,7 @@ def create_pos_invoice(**args):
 	pos_inv.set_missing_values()
 
 	bundle_id = None
-	if args.get("batch_no") or args.get("serial_no"):
+	if not args.use_serial_batch_fields and (args.get("batch_no") or args.get("serial_no")):
 		type_of_transaction = args.type_of_transaction or "Outward"
 
 		if pos_inv.is_return:
@@ -998,6 +996,9 @@ def create_pos_invoice(**args):
 		"expense_account": args.expense_account or "Cost of Goods Sold - _TC",
 		"cost_center": args.cost_center or "_Test Cost Center - _TC",
 		"serial_and_batch_bundle": bundle_id,
+		"use_serial_batch_fields": args.use_serial_batch_fields,
+		"serial_no": args.serial_no if args.use_serial_batch_fields else None,
+		"batch_no": args.batch_no if args.use_serial_batch_fields else None,
 	}
 	# append in pos invoice items without item_code by checking flag without_item_code
 	if args.without_item_code:
@@ -1023,6 +1024,8 @@ def create_pos_invoice(**args):
 		pos_inv.insert()
 		if not args.do_not_submit:
 			pos_inv.submit()
+			if args.use_serial_batch_fields:
+				pos_inv.reload()
 		else:
 			pos_inv.payment_schedule = []
 	else:

erpnext/accounts/doctype/pos_invoice_item/pos_invoice_item.json

@@ -634,7 +634,6 @@
    "depends_on": "eval:doc.use_serial_batch_fields === 1",
    "fieldname": "batch_no",
    "fieldtype": "Link",
-   "hidden": 1,
    "label": "Batch No",
    "options": "Batch",
    "print_hide": 1
@@ -655,7 +654,6 @@
    "depends_on": "eval:doc.use_serial_batch_fields === 1",
    "fieldname": "serial_no",
    "fieldtype": "Text",
-   "hidden": 1,
    "in_list_view": 1,
    "label": "Serial No",
    "oldfieldname": "serial_no",
@@ -827,7 +825,7 @@
    "read_only": 1
   },
   {
-   "depends_on": "eval:doc.use_serial_batch_fields === 1",
+   "depends_on": "eval:doc.use_serial_batch_fields === 0 || doc.serial_and_batch_bundle",
    "fieldname": "serial_and_batch_bundle",
    "fieldtype": "Link",
    "label": "Serial and Batch Bundle",
@@ -853,7 +851,7 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2024-02-25 15:50:17.140269",
+ "modified": "2024-05-07 15:56:53.343317",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice Item",
@@ -863,4 +861,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -97,16 +97,15 @@ class POSInvoiceMergeLog(Document):
 				return_against_status = frappe.db.get_value("POS Invoice", return_against, "status")
 				if return_against_status != "Consolidated":
 					# if return entry is not getting merged in the current pos closing and if it is not consolidated
-					bold_unconsolidated = frappe.bold("not Consolidated")
-					msg = _("Row #{}: Original Invoice {} of return invoice {} is {}.").format(
-						d.idx, bold_return_against, bold_pos_invoice, bold_unconsolidated
-					)
+					msg = _(
+						"Row #{}: The original Invoice {} of return invoice {} is not consolidated."
+					).format(d.idx, bold_return_against, bold_pos_invoice)
 					msg += " "
 					msg += _(
-						"Original invoice should be consolidated before or along with the return invoice."
+						"The original invoice should be consolidated before or along with the return invoice."
 					)
 					msg += "<br><br>"
-					msg += _("You can add original invoice {} manually to proceed.").format(
+					msg += _("You can add the original invoice {} manually to proceed.").format(
 						bold_return_against
 					)
 					frappe.throw(msg)
@@ -131,6 +130,7 @@ class POSInvoiceMergeLog(Document):
 		pos_invoice_docs = [frappe.get_cached_doc("POS Invoice", d.pos_invoice) for d in self.pos_invoices]
 
 		self.update_pos_invoices(pos_invoice_docs)
+		self.serial_and_batch_bundle_reference_for_pos_invoice()
 		self.cancel_linked_invoices()
 
 	def process_merging_into_sales_invoice(self, data):
@@ -191,6 +191,7 @@ class POSInvoiceMergeLog(Document):
 				for i in items:
 					if (
 						i.item_code == item.item_code
+						and not i.serial_and_batch_bundle
 						and not i.serial_no
 						and not i.batch_no
 						and i.uom == item.uom
@@ -312,6 +313,12 @@ class POSInvoiceMergeLog(Document):
 			doc.set_status(update=True)
 			doc.save()
 
+	def serial_and_batch_bundle_reference_for_pos_invoice(self):
+		for d in self.pos_invoices:
+			pos_invoice = frappe.get_doc("POS Invoice", d.pos_invoice)
+			for table_name in ["items", "packed_items"]:
+				pos_invoice.set_serial_and_batch_bundle(table_name)
+
 	def cancel_linked_invoices(self):
 		for si_name in [self.consolidated_invoice, self.consolidated_credit_note]:
 			if not si_name:

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -186,7 +186,8 @@ class PricingRule(Document):
 			if not self.priority:
 				throw(
 					_("As the field {0} is enabled, the field {1} is mandatory.").format(
-						frappe.bold("Apply Discount on Discounted Rate"), frappe.bold("Priority")
+						frappe.bold(_("Apply Discount on Discounted Rate")),
+						frappe.bold(_("Priority")),
 					)
 				)
 
@@ -194,7 +195,7 @@ class PricingRule(Document):
 				throw(
 					_(
 						"As the field {0} is enabled, the value of the field {1} should be more than 1."
-					).format(frappe.bold("Apply Discount on Discounted Rate"), frappe.bold("Priority"))
+					).format(frappe.bold(_("Apply Discount on Discounted Rate")), frappe.bold(_("Priority")))
 				)
 
 	def validate_applicable_for_selling_or_buying(self):

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -6,7 +6,9 @@ import unittest
 
 import frappe
 
+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
@@ -1311,6 +1313,69 @@ class TestPricingRule(unittest.TestCase):
 		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

@@ -486,7 +486,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 * (row.get("price_list_rate") or row.get("rate"))
+			amount = stock_qty * (flt(row.get("price_list_rate")) or flt(row.get("rate")))
 			pricing_rules = filter_pricing_rules_for_qty_amount(stock_qty, amount, pricing_rules, row)
 
 			if pricing_rules and pricing_rules[0]:

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -16,6 +16,7 @@
   "cost_center",
   "territory",
   "ignore_exchange_rate_revaluation_journals",
+  "ignore_cr_dr_notes",
   "column_break_14",
   "to_date",
   "finance_book",
@@ -383,10 +384,16 @@
    "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"
   }
  ],
  "links": [],
- "modified": "2023-12-18 12:20:08.965120",
+ "modified": "2024-08-13 10:41:18.381165",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -54,6 +54,7 @@ class ProcessStatementOfAccounts(Document):
 		frequency: DF.Literal["Weekly", "Monthly", "Quarterly"]
 		from_date: DF.Date | None
 		group_by: DF.Literal["", "Group by Voucher", "Group by Voucher (Consolidated)"]
+		ignore_cr_dr_notes: DF.Check
 		ignore_exchange_rate_revaluation_journals: DF.Check
 		include_ageing: DF.Check
 		include_break: DF.Check
@@ -133,6 +134,9 @@ 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)

erpnext/accounts/doctype/promotional_scheme/promotional_scheme.js

@@ -2,6 +2,18 @@
 // For license information, please see license.txt
 
 frappe.ui.form.on("Promotional Scheme", {
+	setup: function (frm) {
+		frm.set_query("for_price_list", "price_discount_slabs", (doc) => {
+			return {
+				filters: {
+					selling: doc.selling,
+					buying: doc.buying,
+					currency: doc.currency,
+				},
+			};
+		});
+	},
+
 	refresh: function (frm) {
 		frm.trigger("set_options_for_applicable_for");
 		frm.trigger("toggle_reqd_apply_on");

erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py

@@ -51,6 +51,7 @@ price_discount_fields = [
 	"discount_percentage",
 	"validate_applied_rule",
 	"apply_multiple_pricing_rules",
+	"for_price_list",
 ]
 
 product_discount_fields = [
@@ -63,6 +64,7 @@ product_discount_fields = [
 	"recurse_for",
 	"apply_recursion_over",
 	"apply_multiple_pricing_rules",
+	"round_free_qty",
 ]
 
 

erpnext/accounts/doctype/promotional_scheme_price_discount/promotional_scheme_price_discount.json

@@ -21,6 +21,7 @@
   "rate",
   "discount_amount",
   "discount_percentage",
+  "for_price_list",
   "section_break_11",
   "warehouse",
   "threshold_percentage",
@@ -120,6 +121,13 @@
    "fieldtype": "Float",
    "label": "Discount Percentage"
   },
+  {
+   "depends_on": "eval:doc.rate_or_discount!=\"Rate\"",
+   "fieldname": "for_price_list",
+   "fieldtype": "Link",
+   "label": "For Price List",
+   "options": "Price List"
+  },
   {
    "fieldname": "section_break_11",
    "fieldtype": "Section Break"
@@ -169,7 +177,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2021-11-16 00:25:33.843996",
+ "modified": "2024-07-23 12:33:46.574950",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Promotional Scheme Price Discount",
@@ -177,4 +185,4 @@
  "permissions": [],
  "sort_field": "modified",
  "sort_order": "DESC"
-}
+}

erpnext/accounts/doctype/promotional_scheme_price_discount/promotional_scheme_price_discount.py

@@ -19,6 +19,7 @@ class PromotionalSchemePriceDiscount(Document):
 		disable: DF.Check
 		discount_amount: DF.Currency
 		discount_percentage: DF.Float
+		for_price_list: DF.Link | None
 		max_amount: DF.Currency
 		max_qty: DF.Float
 		min_amount: DF.Currency

erpnext/accounts/doctype/promotional_scheme_product_discount/promotional_scheme_product_discount.json

@@ -22,6 +22,7 @@
   "column_break_9",
   "free_item_uom",
   "free_item_rate",
+  "round_free_qty",
   "section_break_12",
   "warehouse",
   "threshold_percentage",
@@ -181,12 +182,18 @@
    "fieldtype": "Float",
    "label": "Apply Recursion Over (As Per Transaction UOM)",
    "mandatory_depends_on": "is_recursive"
+  },
+  {
+   "default": "0",
+   "fieldname": "round_free_qty",
+   "fieldtype": "Check",
+   "label": "Round Free Qty"
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-03-12 12:53:58.199108",
+ "modified": "2024-07-22 17:25:07.880984",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Promotional Scheme Product Discount",
@@ -195,4 +202,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/promotional_scheme_product_discount/promotional_scheme_product_discount.py

@@ -53,6 +53,7 @@ class PromotionalSchemeProductDiscount(Document):
 			"20",
 		]
 		recurse_for: DF.Float
+		round_free_qty: DF.Check
 		rule_description: DF.SmallText
 		same_item: DF.Check
 		threshold_percentage: DF.Percent

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -77,31 +77,6 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 			erpnext.accounts.ledger_preview.show_stock_ledger_preview(this.frm);
 		}
 
-		if (this.frm.doc.repost_required && this.frm.doc.docstatus === 1) {
-			this.frm.set_intro(
-				__(
-					"Accounting entries for this invoice need to be reposted. Please click on 'Repost' button to update."
-				)
-			);
-			this.frm
-				.add_custom_button(__("Repost Accounting Entries"), () => {
-					this.frm.call({
-						doc: this.frm.doc,
-						method: "repost_accounting_entries",
-						freeze: true,
-						freeze_message: __("Reposting..."),
-						callback: (r) => {
-							if (!r.exc) {
-								frappe.msgprint(__("Accounting Entries are reposted."));
-								me.frm.refresh();
-							}
-						},
-					});
-				})
-				.removeClass("btn-default")
-				.addClass("btn-warning");
-		}
-
 		if (!doc.is_return && doc.docstatus == 1 && doc.outstanding_amount != 0) {
 			if (doc.on_hold) {
 				this.frm.add_custom_button(

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -170,7 +170,6 @@
   "against_expense_account",
   "column_break_63",
   "unrealized_profit_loss_account",
-  "repost_required",
   "subscription_section",
   "subscription",
   "auto_repeat",
@@ -364,7 +363,8 @@
    "description": "Once set, this invoice will be on hold till the set date",
    "fieldname": "release_date",
    "fieldtype": "Date",
-   "label": "Release Date"
+   "label": "Release Date",
+   "search_index": 1
   },
   {
    "fieldname": "cb_17",
@@ -1603,15 +1603,6 @@
    "fieldtype": "Check",
    "label": "Use Company Default Round Off Cost Center"
   },
-  {
-   "default": "0",
-   "fieldname": "repost_required",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Repost Required",
-   "options": "Account",
-   "read_only": 1
-  },
   {
    "default": "0",
    "fieldname": "use_transaction_date_exchange_rate",
@@ -1639,7 +1630,7 @@
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-04-11 11:28:42.802211",
+ "modified": "2024-07-25 19:42:36.931278",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -159,7 +159,6 @@ class PurchaseInvoice(BuyingController):
 		rejected_warehouse: DF.Link | None
 		release_date: DF.Date | None
 		remarks: DF.SmallText | None
-		repost_required: DF.Check
 		represents_company: DF.Link | None
 		return_against: DF.Link | None
 		rounded_total: DF.Currency
@@ -378,16 +377,16 @@ class PurchaseInvoice(BuyingController):
 		if account.report_type != "Balance Sheet":
 			frappe.throw(
 				_(
-					"Please ensure {} account is a Balance Sheet account. You can change the parent account to a Balance Sheet account or select a different account."
-				).format(frappe.bold("Credit To")),
+					"Please ensure that the {0} account is a Balance Sheet account. You can change the parent account to a Balance Sheet account or select a different account."
+				).format(frappe.bold(_("Credit To"))),
 				title=_("Invalid Account"),
 			)
 
 		if self.supplier and account.account_type != "Payable":
 			frappe.throw(
 				_(
-					"Please ensure {} account {} is a Payable account. Change the account type to Payable or select a different account."
-				).format(frappe.bold("Credit To"), frappe.bold(self.credit_to)),
+					"Please ensure that the {0} account {1} is a Payable account. You can change the account type to Payable or select a different account."
+				).format(frappe.bold(_("Credit To")), frappe.bold(self.credit_to)),
 				title=_("Invalid Account"),
 			)
 
@@ -635,7 +634,7 @@ class PurchaseInvoice(BuyingController):
 						"To submit the invoice without purchase order please set {0} as {1} in {2}"
 					).format(
 						frappe.bold(_("Purchase Order Required")),
-						frappe.bold("No"),
+						frappe.bold(_("No")),
 						get_link_to_form("Buying Settings", "Buying Settings", "Buying Settings"),
 					)
 					throw(msg, title=_("Mandatory Purchase Order"))
@@ -656,7 +655,7 @@ class PurchaseInvoice(BuyingController):
 						"To submit the invoice without purchase receipt please set {0} as {1} in {2}"
 					).format(
 						frappe.bold(_("Purchase Receipt Required")),
-						frappe.bold("No"),
+						frappe.bold(_("No")),
 						get_link_to_form("Buying Settings", "Buying Settings", "Buying Settings"),
 					)
 					throw(msg, title=_("Mandatory Purchase Receipt"))
@@ -796,18 +795,17 @@ class PurchaseInvoice(BuyingController):
 		self.process_common_party_accounting()
 
 	def on_update_after_submit(self):
-		if hasattr(self, "repost_required"):
-			fields_to_check = [
-				"cash_bank_account",
-				"write_off_account",
-				"unrealized_profit_loss_account",
-				"is_opening",
-			]
-			child_tables = {"items": ("expense_account",), "taxes": ("account_head",)}
-			self.needs_repost = self.check_if_fields_updated(fields_to_check, child_tables)
-			if self.needs_repost:
-				self.validate_for_repost()
-				self.db_set("repost_required", self.needs_repost)
+		fields_to_check = [
+			"cash_bank_account",
+			"write_off_account",
+			"unrealized_profit_loss_account",
+			"is_opening",
+		]
+		child_tables = {"items": ("expense_account",), "taxes": ("account_head",)}
+		self.needs_repost = self.check_if_fields_updated(fields_to_check, child_tables)
+		if self.needs_repost:
+			self.validate_for_repost()
+			self.repost_accounting_entries()
 
 	def make_gl_entries(self, gl_entries=None, from_repost=False):
 		update_outstanding = "No" if (cint(self.is_paid) or self.write_off_account) else "Yes"
@@ -1704,6 +1702,9 @@ class PurchaseInvoice(BuyingController):
 		self.db_set("release_date", None)
 
 	def set_tax_withholding(self):
+		self.set("advance_tax", [])
+		self.set("tax_withheld_vouchers", [])
+
 		if not self.apply_tds:
 			return
 
@@ -1745,8 +1746,6 @@ class PurchaseInvoice(BuyingController):
 			self.remove(d)
 
 		## Add pending vouchers on which tax was withheld
-		self.set("tax_withheld_vouchers", [])
-
 		for voucher_no, voucher_details in voucher_wise_amount.items():
 			self.append(
 				"tax_withheld_vouchers",
@@ -1761,7 +1760,6 @@ class PurchaseInvoice(BuyingController):
 		self.calculate_taxes_and_totals()
 
 	def allocate_advance_tds(self, tax_withholding_details, advance_taxes):
-		self.set("advance_tax", [])
 		for tax in advance_taxes:
 			allocated_amount = 0
 			pending_amount = flt(tax.tax_amount - tax.allocated_amount)

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -2005,18 +2005,15 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		check_gl_entries(self, pi.name, expected_gle, nowdate())
 
 		pi.items[0].expense_account = "Service - _TC"
+		# Ledger reposted implicitly upon 'Update After Submit'
 		pi.save()
 		pi.load_from_db()
-		self.assertTrue(pi.repost_required)
-		pi.repost_accounting_entries()
 
 		expected_gle = [
 			["Creditors - _TC", 0.0, 1000, nowdate()],
 			["Service - _TC", 1000, 0.0, nowdate()],
 		]
 		check_gl_entries(self, pi.name, expected_gle, nowdate())
-		pi.load_from_db()
-		self.assertFalse(pi.repost_required)
 
 	@change_settings("Buying Settings", {"supplier_group": None})
 	def test_purchase_invoice_without_supplier_group(self):
@@ -2239,6 +2236,62 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 			self.assertEqual(pi_expected_values[i][1], gle.debit)
 			self.assertEqual(pi_expected_values[i][2], gle.credit)
 
+	def test_adjust_incoming_rate_from_pi_with_multi_currency(self):
+		from erpnext.stock.doctype.landed_cost_voucher.test_landed_cost_voucher import (
+			make_landed_cost_voucher,
+		)
+
+		frappe.db.set_single_value("Buying Settings", "maintain_same_rate", 0)
+
+		frappe.db.set_single_value("Buying Settings", "set_landed_cost_based_on_purchase_invoice_rate", 1)
+
+		# Increase the cost of the item
+
+		pr = make_purchase_receipt(
+			qty=10, rate=1, currency="USD", do_not_save=1, supplier="_Test Supplier USD"
+		)
+		pr.conversion_rate = 6300
+		pr.plc_conversion_rate = 1
+		pr.save()
+		pr.submit()
+
+		self.assertEqual(pr.conversion_rate, 6300)
+		self.assertEqual(pr.plc_conversion_rate, 1)
+		self.assertEqual(pr.base_grand_total, 6300 * 10)
+
+		stock_value_difference = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
+			"stock_value_difference",
+		)
+		self.assertEqual(stock_value_difference, 6300 * 10)
+
+		make_landed_cost_voucher(
+			company=pr.company,
+			receipt_document_type="Purchase Receipt",
+			receipt_document=pr.name,
+			charges=3000,
+			distribute_charges_based_on="Qty",
+		)
+
+		pi = create_purchase_invoice_from_receipt(pr.name)
+		for row in pi.items:
+			row.rate = 1.1
+
+		pi.save()
+		pi.submit()
+
+		stock_value_difference = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
+			"stock_value_difference",
+		)
+		self.assertEqual(stock_value_difference, 7230 * 10)
+
+		frappe.db.set_single_value("Buying Settings", "set_landed_cost_based_on_purchase_invoice_rate", 0)
+
+		frappe.db.set_single_value("Buying Settings", "maintain_same_rate", 1)
+
 
 def set_advance_flag(company, flag, default_account):
 	frappe.db.set_value(

erpnext/accounts/doctype/purchase_invoice_item/purchase_invoice_item.json

@@ -57,6 +57,7 @@
   "base_net_rate",
   "base_net_amount",
   "valuation_rate",
+  "sales_incoming_rate",
   "item_tax_amount",
   "landed_cost_voucher_amount",
   "rm_supp_cost",
@@ -958,12 +959,22 @@
    "print_hide": 1,
    "read_only": 1,
    "search_index": 1
+  },
+  {
+   "description": "Valuation rate for the item as per Sales Invoice (Only for Internal Transfers)",
+   "fieldname": "sales_incoming_rate",
+   "fieldtype": "Currency",
+   "hidden": 1,
+   "label": "Sales Incoming Rate",
+   "no_copy": 1,
+   "options": "Company:company:default_currency",
+   "print_hide": 1
   }
  ],
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-06-14 11:57:07.171700",
+ "modified": "2024-07-19 12:12:42.449298",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice Item",

erpnext/accounts/doctype/purchase_invoice_item/purchase_invoice_item.py

@@ -79,6 +79,7 @@ class PurchaseInvoiceItem(Document):
 		rejected_serial_no: DF.Text | None
 		rejected_warehouse: DF.Link | None
 		rm_supp_cost: DF.Currency
+		sales_incoming_rate: DF.Currency
 		sales_invoice_item: DF.Data | None
 		serial_and_batch_bundle: DF.Link | None
 		serial_no: DF.Text | None

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -68,31 +68,6 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 
 		this.frm.toggle_reqd("due_date", !this.frm.doc.is_return);
 
-		if (this.frm.doc.repost_required && this.frm.doc.docstatus === 1) {
-			this.frm.set_intro(
-				__(
-					"Accounting entries for this invoice needs to be reposted. Please click on 'Repost' button to update."
-				)
-			);
-			this.frm
-				.add_custom_button(__("Repost Accounting Entries"), () => {
-					this.frm.call({
-						doc: this.frm.doc,
-						method: "repost_accounting_entries",
-						freeze: true,
-						freeze_message: __("Reposting..."),
-						callback: (r) => {
-							if (!r.exc) {
-								frappe.msgprint(__("Accounting Entries are reposted"));
-								me.frm.refresh();
-							}
-						},
-					});
-				})
-				.removeClass("btn-default")
-				.addClass("btn-warning");
-		}
-
 		if (this.frm.doc.is_return) {
 			this.frm.return_print_format = "Sales Invoice Return";
 		}
@@ -157,7 +132,7 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 
 				const payment_is_overdue = doc.payment_schedule
 					.map((row) => Date.parse(row.due_date) < Date.now())
-					.reduce((prev, current) => prev || current);
+					.reduce((prev, current) => prev || current, false);
 
 				if (payment_is_overdue) {
 					this.frm.add_custom_button(
@@ -502,9 +477,13 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 				frappe.msgprint(__("Please specify Company to proceed"));
 			} else {
 				var me = this;
+				const for_validate = me.frm.doc.is_return ? true : false;
 				return this.frm.call({
 					doc: me.frm.doc,
 					method: "set_missing_values",
+					args: {
+						for_validate: for_validate,
+					},
 					callback: function (r) {
 						if (!r.exc) {
 							if (r.message && r.message.print_format) {

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -213,7 +213,6 @@
   "is_internal_customer",
   "is_discounted",
   "remarks",
-  "repost_required",
   "connections_tab"
  ],
  "fields": [
@@ -2125,15 +2124,6 @@
    "label": "Write Off",
    "width": "50%"
   },
-  {
-   "default": "0",
-   "fieldname": "repost_required",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Repost Required",
-   "no_copy": 1,
-   "read_only": 1
-  },
   {
    "fieldname": "incoterm",
    "fieldtype": "Link",
@@ -2188,7 +2178,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2024-06-07 16:49:32.458402",
+ "modified": "2024-07-18 15:30:39.428519",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -161,7 +161,6 @@ class SalesInvoice(SellingController):
 		project: DF.Link | None
 		redeem_loyalty_points: DF.Check
 		remarks: DF.SmallText | None
-		repost_required: DF.Check
 		represents_company: DF.Link | None
 		return_against: DF.Link | None
 		rounded_total: DF.Currency
@@ -515,7 +514,7 @@ class SalesInvoice(SellingController):
 			)
 			if pos_closing_entry and pos_closing_entry[0]:
 				msg = _("To cancel a {} you need to cancel the POS Closing Entry {}.").format(
-					frappe.bold("Consolidated Sales Invoice"),
+					frappe.bold(_("Consolidated Sales Invoice")),
 					get_link_to_form("POS Closing Entry", pos_closing_entry[0]),
 				)
 				frappe.throw(msg, title=_("Not Allowed"))
@@ -556,7 +555,6 @@ class SalesInvoice(SellingController):
 			self.repost_future_sle_and_gle()
 
 		self.db_set("status", "Cancelled")
-		self.db_set("repost_required", 0)
 
 		if frappe.db.get_single_value("Selling Settings", "sales_update_frequency") == "Each Transaction":
 			update_company_current_month_sales(self.company)
@@ -706,24 +704,23 @@ class SalesInvoice(SellingController):
 				data.sales_invoice = sales_invoice
 
 	def on_update_after_submit(self):
-		if hasattr(self, "repost_required"):
-			fields_to_check = [
-				"additional_discount_account",
-				"cash_bank_account",
-				"account_for_change_amount",
-				"write_off_account",
-				"loyalty_redemption_account",
-				"unrealized_profit_loss_account",
-				"is_opening",
-			]
-			child_tables = {
-				"items": ("income_account", "expense_account", "discount_account"),
-				"taxes": ("account_head",),
-			}
-			self.needs_repost = self.check_if_fields_updated(fields_to_check, child_tables)
-			if self.needs_repost:
-				self.validate_for_repost()
-				self.db_set("repost_required", self.needs_repost)
+		fields_to_check = [
+			"additional_discount_account",
+			"cash_bank_account",
+			"account_for_change_amount",
+			"write_off_account",
+			"loyalty_redemption_account",
+			"unrealized_profit_loss_account",
+			"is_opening",
+		]
+		child_tables = {
+			"items": ("income_account", "expense_account", "discount_account"),
+			"taxes": ("account_head",),
+		}
+		self.needs_repost = self.check_if_fields_updated(fields_to_check, child_tables)
+		if self.needs_repost:
+			self.validate_for_repost()
+			self.repost_accounting_entries()
 
 	def set_paid_amount(self):
 		paid_amount = 0.0
@@ -861,7 +858,7 @@ class SalesInvoice(SellingController):
 
 		if account.report_type != "Balance Sheet":
 			msg = (
-				_("Please ensure {} account is a Balance Sheet account.").format(frappe.bold("Debit To"))
+				_("Please ensure {} account is a Balance Sheet account.").format(frappe.bold(_("Debit To")))
 				+ " "
 			)
 			msg += _(
@@ -872,7 +869,7 @@ class SalesInvoice(SellingController):
 		if self.customer and account.account_type != "Receivable":
 			msg = (
 				_("Please ensure {} account {} is a Receivable account.").format(
-					frappe.bold("Debit To"), frappe.bold(self.debit_to)
+					frappe.bold(_("Debit To")), frappe.bold(self.debit_to)
 				)
 				+ " "
 			)
@@ -1212,6 +1209,8 @@ class SalesInvoice(SellingController):
 		self.make_precision_loss_gl_entry(gl_entries)
 		self.make_discount_gl_entries(gl_entries)
 
+		gl_entries = make_regional_gl_entries(gl_entries, self)
+
 		# merge gl entries before adding pos entries
 		gl_entries = merge_similar_entries(gl_entries)
 
@@ -1317,6 +1316,10 @@ class SalesInvoice(SellingController):
 
 		for item in self.get("items"):
 			if flt(item.base_net_amount, item.precision("base_net_amount")):
+				# Do not book income for transfer within same company
+				if self.is_internal_transfer():
+					continue
+
 				if item.is_fixed_asset:
 					asset = self.get_asset(item)
 
@@ -1375,37 +1378,33 @@ class SalesInvoice(SellingController):
 					self.set_asset_status(asset)
 
 				else:
-					# Do not book income for transfer within same company
-					if not self.is_internal_transfer():
-						income_account = (
-							item.income_account
-							if (not item.enable_deferred_revenue or self.is_return)
-							else item.deferred_revenue_account
-						)
+					income_account = (
+						item.income_account
+						if (not item.enable_deferred_revenue or self.is_return)
+						else item.deferred_revenue_account
+					)
 
-						amount, base_amount = self.get_amount_and_base_amount(
-							item, enable_discount_accounting
-						)
+					amount, base_amount = self.get_amount_and_base_amount(item, enable_discount_accounting)
 
-						account_currency = get_account_currency(income_account)
-						gl_entries.append(
-							self.get_gl_dict(
-								{
-									"account": income_account,
-									"against": self.customer,
-									"credit": flt(base_amount, item.precision("base_net_amount")),
-									"credit_in_account_currency": (
-										flt(base_amount, item.precision("base_net_amount"))
-										if account_currency == self.company_currency
-										else flt(amount, item.precision("net_amount"))
-									),
-									"cost_center": item.cost_center,
-									"project": item.project or self.project,
-								},
-								account_currency,
-								item=item,
-							)
+					account_currency = get_account_currency(income_account)
+					gl_entries.append(
+						self.get_gl_dict(
+							{
+								"account": income_account,
+								"against": self.customer,
+								"credit": flt(base_amount, item.precision("base_net_amount")),
+								"credit_in_account_currency": (
+									flt(base_amount, item.precision("base_net_amount"))
+									if account_currency == self.company_currency
+									else flt(amount, item.precision("net_amount"))
+								),
+								"cost_center": item.cost_center,
+								"project": item.project or self.project,
+							},
+							account_currency,
+							item=item,
 						)
+					)
 
 		# expense account gl entries
 		if cint(self.update_stock) and erpnext.is_perpetual_inventory_enabled(self.company):
@@ -1480,6 +1479,10 @@ 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(
@@ -1493,7 +1496,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": self.name,
+								"against_voucher": against_voucher,
 								"against_voucher_type": self.doctype,
 								"cost_center": self.cost_center,
 							},
@@ -2225,6 +2228,11 @@ def make_inter_company_purchase_invoice(source_name, target_doc=None):
 	return make_inter_company_transaction("Sales Invoice", source_name, target_doc)
 
 
+@erpnext.allow_regional
+def make_regional_gl_entries(gl_entries, doc):
+	return gl_entries
+
+
 def make_inter_company_transaction(doctype, source_name, target_doc=None):
 	if doctype in ["Sales Invoice", "Sales Order"]:
 		source_doc = frappe.get_doc(doctype, source_name)

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -5,6 +5,7 @@ import copy
 import json
 
 import frappe
+from frappe import qb
 from frappe.model.dynamic_links import get_dynamic_link_map
 from frappe.tests.utils import FrappeTestCase, change_settings
 from frappe.utils import add_days, flt, getdate, nowdate, today
@@ -2940,13 +2941,9 @@ class TestSalesInvoice(FrappeTestCase):
 		si.items[0].income_account = "Service - _TC"
 		si.additional_discount_account = "_Test Account Sales - _TC"
 		si.taxes[0].account_head = "TDS Payable - _TC"
+		# Ledger reposted implicitly upon 'Update After Submit'
 		si.save()
 
-		si.load_from_db()
-		self.assertTrue(si.repost_required)
-
-		si.repost_accounting_entries()
-
 		expected_gle = [
 			["_Test Account Sales - _TC", 22.0, 0.0, nowdate()],
 			["Debtors - _TC", 88, 0.0, nowdate()],
@@ -2956,9 +2953,6 @@ class TestSalesInvoice(FrappeTestCase):
 
 		check_gl_entries(self, si.name, expected_gle, add_days(nowdate(), -1))
 
-		si.load_from_db()
-		self.assertFalse(si.repost_required)
-
 	def test_asset_depreciation_on_sale_with_pro_rata(self):
 		"""
 		Tests if an Asset set to depreciate yearly on June 30, that gets sold on Sept 30, creates an additional depreciation entry on its date of sale.
@@ -3090,6 +3084,84 @@ class TestSalesInvoice(FrappeTestCase):
 		party_link.delete()
 		frappe.db.set_single_value("Accounts Settings", "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_payment_statuses(self):
 		from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
 
@@ -3765,6 +3837,40 @@ 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)
+
 
 def set_advance_flag(company, flag, default_account):
 	frappe.db.set_value(

erpnext/accounts/doctype/subscription/subscription.js

@@ -38,6 +38,12 @@ frappe.ui.form.on("Subscription", {
 				__("Actions")
 			);
 
+			frm.add_custom_button(
+				__("Force-Fetch Subscription Updates"),
+				() => frm.trigger("force_fetch_subscription_updates"),
+				__("Actions")
+			);
+
 			frm.add_custom_button(
 				__("Cancel Subscription"),
 				() => frm.trigger("cancel_this_subscription"),
@@ -82,4 +88,11 @@ 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

@@ -717,6 +717,28 @@ class Subscription(Document):
 		self.update_subscription_period(posting_date or nowdate())
 		self.save()
 
+	@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 is_prorate() -> int:
 	return cint(frappe.db.get_single_value("Subscription Settings", "prorate"))

erpnext/accounts/doctype/subscription/test_subscription.py

@@ -521,6 +521,18 @@ class TestSubscription(FrappeTestCase):
 		subscription.process(posting_date="2023-01-22")
 		self.assertEqual(len(subscription.invoices), 2)
 
+	def test_future_subscription(self):
+		"""Force-Fetch should not process future subscriptions"""
+		subscription = create_subscription(
+			start_date=add_months(nowdate(), 1),
+			submit_invoice=0,
+			generate_new_invoices_past_due_date=1,
+			party="_Test Subscription Customer John Doe",
+		)
+		subscription.force_fetch_subscription_updates()
+		subscription.reload()
+		self.assertEqual(len(subscription.invoices), 0)
+
 
 def make_plans():
 	create_plan(plan_name="_Test Plan Name", cost=900, currency="INR")

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py

@@ -268,6 +268,11 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 	vouchers, voucher_wise_amount = get_invoice_vouchers(
 		parties, tax_details, inv.company, party_type=party_type
 	)
+
+	payment_entry_vouchers = get_payment_entry_vouchers(
+		parties, tax_details, inv.company, party_type=party_type
+	)
+
 	advance_vouchers = get_advance_vouchers(
 		parties,
 		company=inv.company,
@@ -275,7 +280,8 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 		to_date=tax_details.to_date,
 		party_type=party_type,
 	)
-	taxable_vouchers = vouchers + advance_vouchers
+
+	taxable_vouchers = vouchers + advance_vouchers + payment_entry_vouchers
 	tax_deducted_on_advances = 0
 
 	if inv.doctype == "Purchase Invoice":
@@ -369,12 +375,14 @@ def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
 			AND ja.party in %s
 			AND j.apply_tds = 1
 			AND j.tax_withholding_category = %s
+			AND j.company = %s
 	""",
 		(
 			tax_details.from_date,
 			tax_details.to_date,
 			tuple(parties),
 			tax_details.get("tax_withholding_category"),
+			company,
 		),
 		as_dict=1,
 	)
@@ -387,6 +395,20 @@ def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
 	return vouchers, voucher_wise_amount
 
 
+def get_payment_entry_vouchers(parties, tax_details, company, party_type="Supplier"):
+	payment_entry_filters = {
+		"party_type": party_type,
+		"party": ("in", parties),
+		"docstatus": 1,
+		"apply_tax_withholding_amount": 1,
+		"posting_date": ["between", (tax_details.from_date, tax_details.to_date)],
+		"tax_withholding_category": tax_details.get("tax_withholding_category"),
+		"company": company,
+	}
+
+	return frappe.db.get_all("Payment Entry", filters=payment_entry_filters, pluck="name")
+
+
 def get_advance_vouchers(parties, company=None, from_date=None, to_date=None, party_type="Supplier"):
 	"""
 	Use Payment Ledger to fetch unallocated Advance Payments
@@ -477,6 +499,7 @@ def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
 		"unallocated_amount": (">", 0),
 		"posting_date": ["between", (tax_details.from_date, tax_details.to_date)],
 		"tax_withholding_category": tax_details.get("tax_withholding_category"),
+		"company": inv.company,
 	}
 
 	field = "sum(tax_withholding_net_total)"

erpnext/accounts/general_ledger.py

@@ -310,6 +310,18 @@ def check_if_in_list(gle, gl_map):
 def toggle_debit_credit_if_negative(gl_map):
 	for entry in gl_map:
 		# toggle debit, credit if negative entry
+		if flt(entry.debit) < 0 and flt(entry.credit) < 0 and flt(entry.debit) == flt(entry.credit):
+			entry.credit *= -1
+			entry.debit *= -1
+
+		if (
+			flt(entry.debit_in_account_currency) < 0
+			and flt(entry.credit_in_account_currency) < 0
+			and flt(entry.debit_in_account_currency) == flt(entry.credit_in_account_currency)
+		):
+			entry.credit_in_account_currency *= -1
+			entry.debit_in_account_currency *= -1
+
 		if flt(entry.debit) < 0:
 			entry.credit = flt(entry.credit) - flt(entry.debit)
 			entry.debit = 0.0

erpnext/accounts/report/accounts_payable/test_accounts_payable.py

@@ -7,7 +7,7 @@ from erpnext.accounts.report.accounts_payable.accounts_payable import execute
 from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
 
 
-class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
+class TestAccountsPayable(AccountsTestMixin, FrappeTestCase):
 	def setUp(self):
 		self.create_company()
 		self.create_customer()

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -139,6 +139,7 @@ class ReceivablePayableReport:
 					paid_in_account_currency=0.0,
 					credit_note_in_account_currency=0.0,
 					outstanding_in_account_currency=0.0,
+					cost_center=ple.cost_center,
 				)
 			self.get_invoices(ple)
 
@@ -253,7 +254,7 @@ class ReceivablePayableReport:
 				row.paid -= amount
 				row.paid_in_account_currency -= amount_in_account_currency
 
-		if ple.cost_center:
+		if not row.cost_center and ple.cost_center:
 			row.cost_center = str(ple.cost_center)
 
 	def update_sub_total_row(self, row, party):
@@ -288,13 +289,13 @@ class ReceivablePayableReport:
 
 			must_consider = False
 			if self.filters.get("for_revaluation_journals"):
-				if (abs(row.outstanding) > 0.0 / 10**self.currency_precision) or (
-					abs(row.outstanding_in_account_currency) > 0.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:
-				if (abs(row.outstanding) > 1.0 / 10**self.currency_precision) and (
-					(abs(row.outstanding_in_account_currency) > 1.0 / 10**self.currency_precision)
+				if (abs(row.outstanding) >= 1.0 / 10**self.currency_precision) and (
+					(abs(row.outstanding_in_account_currency) >= 1.0 / 10**self.currency_precision)
 					or (row.voucher_no in self.err_journals)
 				):
 					must_consider = True

erpnext/accounts/report/accounts_receivable/test_accounts_receivable.py

@@ -53,11 +53,13 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 			si = si.submit()
 		return si
 
-	def create_payment_entry(self, docname):
+	def create_payment_entry(self, docname, do_not_submit=False):
 		pe = get_payment_entry("Sales Invoice", docname, bank_account=self.cash, party_amount=40)
 		pe.paid_from = self.debit_to
 		pe.insert()
-		pe.submit()
+		if not do_not_submit:
+			pe.submit()
+		return pe
 
 	def create_credit_note(self, docname, do_not_submit=False):
 		credit_note = create_sales_invoice(
@@ -955,3 +957,69 @@ class TestAccountsReceivable(AccountsTestMixin, FrappeTestCase):
 		self.assertEqual(
 			expected_data, [row.invoiced, row.outstanding, row.remaining_balance, row.future_amount]
 		)
+
+	def test_accounts_receivable_output_for_minor_outstanding(self):
+		"""
+		AR/AP should report miniscule outstanding of 0.01. Or else there will be slight difference with General Ledger/Trial Balance
+		"""
+		filters = {
+			"company": self.company,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+		}
+
+		# check invoice grand total and invoiced column's value for 3 payment terms
+		si = self.create_sales_invoice(no_payment_schedule=True)
+
+		pe = get_payment_entry("Sales Invoice", si.name, bank_account=self.cash, party_amount=99.99)
+		pe.paid_from = self.debit_to
+		pe.save().submit()
+		report = execute(filters)
+
+		expected_data_after_payment = [100, 100, 99.99, 0.01]
+		self.assertEqual(len(report[1]), 1)
+		row = report[1][0]
+		self.assertEqual(
+			expected_data_after_payment,
+			[row.invoice_grand_total, row.invoiced, row.paid, row.outstanding],
+		)
+
+	def test_cost_center_on_report_output(self):
+		filters = {
+			"company": self.company,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+		}
+
+		# check invoice grand total and invoiced column's value for 3 payment terms
+		si = self.create_sales_invoice(no_payment_schedule=True, do_not_submit=True)
+		si.cost_center = self.cost_center
+		si.save().submit()
+
+		new_cc = frappe.get_doc(
+			{
+				"doctype": "Cost Center",
+				"cost_center_name": "East Wing",
+				"parent_cost_center": self.company + " - " + self.company_abbr,
+				"company": self.company,
+			}
+		)
+		new_cc.save()
+
+		# check invoice grand total, invoiced, paid and outstanding column's value after payment
+		pe = self.create_payment_entry(si.name, do_not_submit=True)
+		pe.cost_center = new_cc.name
+		pe.save().submit()
+		report = execute(filters)
+
+		expected_data_after_payment = [si.name, si.cost_center, 60]
+
+		self.assertEqual(len(report[1]), 1)
+		row = report[1][0]
+		self.assertEqual(expected_data_after_payment, [row.voucher_no, row.cost_center, row.outstanding])

erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.js

@@ -46,5 +46,11 @@ frappe.query_reports["Asset Depreciations and Balances"] = {
 			options: "Asset",
 			depends_on: "eval: doc.group_by == 'Asset'",
 		},
+		{
+			fieldname: "finance_book",
+			label: __("Finance Book"),
+			fieldtype: "Link",
+			options: "Finance Book",
+		},
 	],
 };

erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py

@@ -69,6 +69,9 @@ def get_asset_categories_for_grouped_by_category(filters):
 	condition = ""
 	if filters.get("asset_category"):
 		condition += " and asset_category = %(asset_category)s"
+	if filters.get("finance_book"):
+		condition += " and exists (select 1 from `tabAsset Depreciation Schedule` ads where ads.asset = a.name and ads.finance_book = %(finance_book)s)"
+
 	# nosemgrep
 	return frappe.db.sql(
 		f"""
@@ -119,6 +122,7 @@ def get_asset_categories_for_grouped_by_category(filters):
 			"from_date": filters.from_date,
 			"company": filters.company,
 			"asset_category": filters.get("asset_category"),
+			"finance_book": filters.get("finance_book"),
 		},
 		as_dict=1,
 	)
@@ -128,6 +132,10 @@ def get_asset_details_for_grouped_by_category(filters):
 	condition = ""
 	if filters.get("asset"):
 		condition += " and name = %(asset)s"
+	if filters.get("finance_book"):
+		condition += " and exists (select 1 from `tabAsset Depreciation Schedule` ads where ads.asset = `tabAsset`.name and ads.finance_book = %(finance_book)s)"
+
+	# nosemgrep
 	return frappe.db.sql(
 		f"""
 		SELECT name,
@@ -176,6 +184,7 @@ def get_asset_details_for_grouped_by_category(filters):
 			"from_date": filters.from_date,
 			"company": filters.company,
 			"asset": filters.get("asset"),
+			"finance_book": filters.get("finance_book"),
 		},
 		as_dict=1,
 	)

erpnext/accounts/report/balance_sheet/balance_sheet.py

@@ -123,19 +123,15 @@ def get_provisional_profit_loss(
 		for period in period_list:
 			key = period if consolidated else period.key
 			total_assets = flt(asset[0].get(key))
+			effective_liability = 0.00
 
-			if liability or equity:
-				effective_liability = 0.0
-				if liability:
-					effective_liability += flt(liability[0].get(key))
-				if equity:
-					effective_liability += flt(equity[0].get(key))
+			if liability:
+				effective_liability += flt(liability[0].get(key))
+			if equity:
+				effective_liability += flt(equity[0].get(key))
 
-				provisional_profit_loss[key] = total_assets - effective_liability
-			else:
-				provisional_profit_loss[key] = total_assets
-
-			total_row[key] = provisional_profit_loss[key]
+			provisional_profit_loss[key] = total_assets - effective_liability
+			total_row[key] = provisional_profit_loss[key] + effective_liability
 
 			if provisional_profit_loss[key]:
 				has_value = True

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py

@@ -154,8 +154,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, 0) as debit,
-			if(paid_from=%(account)s, paid_amount, 0) as credit,
+			if(paid_to=%(account)s, received_amount_after_tax, 0) as debit,
+			if(paid_from=%(account)s, paid_amount_after_tax, 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/cheques_and_deposits_incorrectly_cleared/cheques_and_deposits_incorrectly_cleared.js

@@ -0,0 +1,44 @@
+// 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

@@ -0,0 +1,29 @@
+{
+ "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

@@ -0,0 +1,153 @@
+# 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

@@ -104,7 +104,7 @@ def get_balance_sheet_data(fiscal_year, companies, columns, filters):
 	if total_credit:
 		data.append(total_credit)
 
-	report_summary = get_bs_summary(
+	report_summary, primitive_summary = get_bs_summary(
 		companies,
 		asset,
 		liability,
@@ -175,7 +175,7 @@ def get_profit_loss_data(fiscal_year, companies, columns, filters):
 
 	chart = get_pl_chart_data(filters, columns, income, expense, net_profit_loss)
 
-	report_summary = get_pl_summary(
+	report_summary, primitive_summary = get_pl_summary(
 		companies, "", income, expense, net_profit_loss, company_currency, filters, True
 	)
 

erpnext/accounts/report/general_ledger/general_ledger.js

@@ -209,6 +209,11 @@ frappe.query_reports["General Ledger"] = {
 			label: __("Ignore Exchange Rate Revaluation Journals"),
 			fieldtype: "Check",
 		},
+		{
+			fieldname: "ignore_cr_dr_notes",
+			label: __("Ignore System Generated Credit / Debit Notes"),
+			fieldtype: "Check",
+		},
 	],
 };
 

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -236,6 +236,23 @@ def get_conditions(filters):
 		if err_journals:
 			filters.update({"voucher_no_not_in": [x[0] for x in err_journals]})
 
+	if filters.get("ignore_cr_dr_notes"):
+		system_generated_cr_dr_journals = frappe.db.get_all(
+			"Journal Entry",
+			filters={
+				"company": filters.get("company"),
+				"docstatus": 1,
+				"voucher_type": ("in", ["Credit Note", "Debit Note"]),
+				"is_system_generated": 1,
+			},
+			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})
+
 	if filters.get("voucher_no_not_in"):
 		conditions.append("voucher_no not in %(voucher_no_not_in)s")
 

erpnext/accounts/report/general_ledger/test_general_ledger.py

@@ -2,13 +2,32 @@
 # MIT License. See license.txt
 
 import frappe
+from frappe import qb
 from frappe.tests.utils import FrappeTestCase
 from frappe.utils import flt, today
 
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.report.general_ledger.general_ledger import execute
+from erpnext.controllers.sales_and_purchase_return import make_return_doc
 
 
 class TestGeneralLedger(FrappeTestCase):
+	def setUp(self):
+		self.company = "_Test Company"
+		self.clear_old_entries()
+
+	def clear_old_entries(self):
+		doctype_list = [
+			"GL Entry",
+			"Payment Ledger Entry",
+			"Sales Invoice",
+			"Purchase Invoice",
+			"Payment Entry",
+			"Journal Entry",
+		]
+		for doctype in doctype_list:
+			qb.from_(qb.DocType(doctype)).delete().where(qb.DocType(doctype).company == self.company).run()
+
 	def test_foreign_account_balance_after_exchange_rate_revaluation(self):
 		"""
 		Checks the correctness of balance after exchange rate revaluation
@@ -248,3 +267,68 @@ class TestGeneralLedger(FrappeTestCase):
 			)
 		)
 		self.assertIn(revaluation_jv.name, set([x.voucher_no for x in data]))
+
+	def test_ignore_cr_dr_notes_filter(self):
+		si = create_sales_invoice()
+
+		cr_note = make_return_doc(si.doctype, si.name)
+		cr_note.submit()
+
+		pr = frappe.get_doc("Payment Reconciliation")
+		pr.company = si.company
+		pr.party_type = "Customer"
+		pr.party = si.customer
+		pr.receivable_payable_account = si.debit_to
+
+		pr.get_unreconciled_entries()
+
+		invoices = [invoice.as_dict() for invoice in pr.invoices if invoice.invoice_number == si.name]
+		payments = [payment.as_dict() for payment in pr.payments if payment.reference_name == cr_note.name]
+		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+		pr.reconcile()
+
+		system_generated_journal = frappe.db.get_all(
+			"Journal Entry",
+			filters={
+				"docstatus": 1,
+				"reference_type": si.doctype,
+				"reference_name": si.name,
+				"voucher_type": "Credit Note",
+				"is_system_generated": True,
+			},
+			fields=["name"],
+		)
+		self.assertEqual(len(system_generated_journal), 1)
+		expected = set([si.name, cr_note.name, system_generated_journal[0].name])
+		# Without ignore_cr_dr_notes
+		columns, data = execute(
+			frappe._dict(
+				{
+					"company": si.company,
+					"from_date": si.posting_date,
+					"to_date": si.posting_date,
+					"account": [si.debit_to],
+					"group_by": "Group by Voucher (Consolidated)",
+					"ignore_cr_dr_notes": False,
+				}
+			)
+		)
+		actual = set([x.voucher_no for x in data if x.voucher_no])
+		self.assertEqual(expected, actual)
+
+		# Without ignore_cr_dr_notes
+		expected = set([si.name, cr_note.name])
+		columns, data = execute(
+			frappe._dict(
+				{
+					"company": si.company,
+					"from_date": si.posting_date,
+					"to_date": si.posting_date,
+					"account": [si.debit_to],
+					"group_by": "Group by Voucher (Consolidated)",
+					"ignore_cr_dr_notes": True,
+				}
+			)
+		)
+		actual = set([x.voucher_no for x in data if x.voucher_no])
+		self.assertEqual(expected, actual)

erpnext/accounts/report/gross_profit/gross_profit.py

@@ -713,7 +713,8 @@ class GrossProfitGenerator:
 
 	def get_average_buying_rate(self, row, item_code):
 		args = row
-		if item_code not in self.average_buying_rate:
+		key = (item_code, row.warehouse)
+		if key not in self.average_buying_rate:
 			args.update(
 				{
 					"voucher_type": row.parenttype,
@@ -727,9 +728,9 @@ class GrossProfitGenerator:
 				args.update({"serial_and_batch_bundle": row.serial_and_batch_bundle})
 
 			average_buying_rate = get_incoming_rate(args)
-			self.average_buying_rate[item_code] = flt(average_buying_rate)
+			self.average_buying_rate[key] = flt(average_buying_rate)
 
-		return self.average_buying_rate[item_code]
+		return self.average_buying_rate[key]
 
 	def get_last_purchase_rate(self, item_code, row):
 		purchase_invoice = frappe.qb.DocType("Purchase Invoice")

erpnext/accounts/report/gross_profit/test_gross_profit.py

@@ -558,3 +558,50 @@ class TestGrossProfit(FrappeTestCase):
 		}
 		gp_entry = [x for x in data if x.parent_invoice == sinv.name]
 		self.assertDictContainsSubset(expected_entry, gp_entry[0])
+
+	def test_valuation_rate_without_previous_sle(self):
+		"""
+		Test Valuation rate calculation when stock ledger is empty and invoices are against different warehouses
+		"""
+		stock_settings = frappe.get_doc("Stock Settings")
+		stock_settings.valuation_method = "FIFO"
+		stock_settings.save()
+
+		item = create_item(
+			item_code="_Test Wirebound Notebook",
+			is_stock_item=1,
+		)
+		item.allow_negative_stock = True
+		item.save()
+		self.item = item.item_code
+
+		item.reload()
+		item.valuation_rate = 1900
+		item.save()
+		sinv1 = self.create_sales_invoice(qty=1, rate=2000, posting_date=nowdate(), do_not_submit=True)
+		sinv1.update_stock = 1
+		sinv1.set_warehouse = self.warehouse
+		sinv1.items[0].warehouse = self.warehouse
+		sinv1.save().submit()
+
+		item.reload()
+		item.valuation_rate = 1800
+		item.save()
+		sinv2 = self.create_sales_invoice(qty=1, rate=2000, posting_date=nowdate(), do_not_submit=True)
+		sinv2.update_stock = 1
+		sinv2.set_warehouse = self.finished_warehouse
+		sinv2.items[0].warehouse = self.finished_warehouse
+		sinv2.save().submit()
+
+		filters = frappe._dict(
+			company=self.company, from_date=nowdate(), to_date=nowdate(), group_by="Invoice"
+		)
+		columns, data = execute(filters=filters)
+
+		item_from_sinv1 = [x for x in data if x.parent_invoice == sinv1.name]
+		self.assertEqual(len(item_from_sinv1), 1)
+		self.assertEqual(1900, item_from_sinv1[0].valuation_rate)
+
+		item_from_sinv2 = [x for x in data if x.parent_invoice == sinv2.name]
+		self.assertEqual(len(item_from_sinv2), 1)
+		self.assertEqual(1800, item_from_sinv2[0].valuation_rate)

erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py

@@ -315,8 +315,9 @@ def apply_conditions(query, pi, pii, filters):
 
 
 def get_items(filters, additional_table_columns):
-	pi = frappe.qb.DocType("Purchase Invoice")
-	pii = frappe.qb.DocType("Purchase Invoice Item")
+	doctype = "Purchase Invoice"
+	pi = frappe.qb.DocType(doctype)
+	pii = frappe.qb.DocType(f"{doctype} Item")
 	Item = frappe.qb.DocType("Item")
 	query = (
 		frappe.qb.from_(pi)
@@ -353,6 +354,7 @@ def get_items(filters, additional_table_columns):
 			pi.mode_of_payment,
 		)
 		.where(pi.docstatus == 1)
+		.where(pii.parenttype == doctype)
 	)
 
 	if filters.get("supplier"):

erpnext/accounts/report/item_wise_purchase_register/test_item_wise_purchase_register.py

@@ -0,0 +1,63 @@
+import frappe
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import getdate, today
+
+from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
+from erpnext.accounts.report.item_wise_purchase_register.item_wise_purchase_register import execute
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+
+
+class TestItemWisePurchaseRegister(AccountsTestMixin, FrappeTestCase):
+	def setUp(self):
+		self.create_company()
+		self.create_supplier()
+		self.create_item()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def create_purchase_invoice(self, do_not_submit=False):
+		pi = make_purchase_invoice(
+			item=self.item,
+			company=self.company,
+			supplier=self.supplier,
+			is_return=False,
+			update_stock=False,
+			do_not_save=1,
+			rate=100,
+			price_list_rate=100,
+			qty=1,
+		)
+
+		pi = pi.save()
+		if not do_not_submit:
+			pi = pi.submit()
+		return pi
+
+	def test_basic_report_output(self):
+		pi = self.create_purchase_invoice()
+
+		filters = frappe._dict({"from_date": today(), "to_date": today(), "company": self.company})
+		report = execute(filters)
+
+		self.assertEqual(len(report[1]), 1)
+
+		expected_result = {
+			"item_code": pi.items[0].item_code,
+			"invoice": pi.name,
+			"posting_date": getdate(),
+			"supplier": pi.supplier,
+			"credit_to": pi.credit_to,
+			"company": self.company,
+			"expense_account": pi.items[0].expense_account,
+			"stock_qty": 1.0,
+			"stock_uom": pi.items[0].stock_uom,
+			"rate": 100.0,
+			"amount": 100.0,
+			"total_tax": 0,
+			"total": 100.0,
+			"currency": "INR",
+		}
+
+		report_output = {k: v for k, v in report[1][0].items() if k in expected_result}
+		self.assertDictEqual(report_output, expected_result)

erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py

@@ -410,8 +410,9 @@ def apply_group_by_conditions(query, si, ii, filters):
 
 
 def get_items(filters, additional_query_columns, additional_conditions=None):
-	si = frappe.qb.DocType("Sales Invoice")
-	sii = frappe.qb.DocType("Sales Invoice Item")
+	doctype = "Sales Invoice"
+	si = frappe.qb.DocType(doctype)
+	sii = frappe.qb.DocType(f"{doctype} Item")
 	item = frappe.qb.DocType("Item")
 
 	query = (
@@ -459,6 +460,7 @@ def get_items(filters, additional_query_columns, additional_conditions=None):
 			sii.qty,
 		)
 		.where(si.docstatus == 1)
+		.where(sii.parenttype == doctype)
 	)
 
 	if additional_query_columns:

erpnext/accounts/report/item_wise_sales_register/test_item_wise_sales_register.py

@@ -0,0 +1,65 @@
+import frappe
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import getdate, today
+
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+from erpnext.accounts.report.item_wise_sales_register.item_wise_sales_register import execute
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+
+
+class TestItemWiseSalesRegister(AccountsTestMixin, FrappeTestCase):
+	def setUp(self):
+		self.create_company()
+		self.create_customer()
+		self.create_item()
+		self.clear_old_entries()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def create_sales_invoice(self, do_not_submit=False):
+		si = create_sales_invoice(
+			item=self.item,
+			company=self.company,
+			customer=self.customer,
+			debit_to=self.debit_to,
+			posting_date=today(),
+			parent_cost_center=self.cost_center,
+			cost_center=self.cost_center,
+			rate=100,
+			price_list_rate=100,
+			do_not_save=1,
+		)
+		si = si.save()
+		if not do_not_submit:
+			si = si.submit()
+		return si
+
+	def test_basic_report_output(self):
+		si = self.create_sales_invoice()
+
+		filters = frappe._dict({"from_date": today(), "to_date": today(), "company": self.company})
+		report = execute(filters)
+
+		self.assertEqual(len(report[1]), 1)
+
+		expected_result = {
+			"item_code": si.items[0].item_code,
+			"invoice": si.name,
+			"posting_date": getdate(),
+			"customer": si.customer,
+			"debit_to": si.debit_to,
+			"company": self.company,
+			"income_account": si.items[0].income_account,
+			"stock_qty": 1.0,
+			"stock_uom": si.items[0].stock_uom,
+			"rate": 100.0,
+			"amount": 100.0,
+			"total_tax": 0,
+			"total_other_charges": 0,
+			"total": 100.0,
+			"currency": "INR",
+		}
+
+		report_output = {k: v for k, v in report[1][0].items() if k in expected_result}
+		self.assertDictEqual(report_output, expected_result)

erpnext/accounts/report/tax_withholding_details/tax_withholding_details.py

@@ -336,7 +336,7 @@ def get_tds_docs(filters):
 def get_tds_docs_query(filters, bank_accounts, tds_accounts):
 	if not tds_accounts:
 		frappe.throw(
-			_("No {0} Accounts found for this company.").format(frappe.bold("Tax Withholding")),
+			_("No {0} Accounts found for this company.").format(frappe.bold(_("Tax Withholding"))),
 			title=_("Accounts Missing Error"),
 		)
 	gle = frappe.qb.DocType("GL Entry")

erpnext/accounts/utils.py

@@ -1598,6 +1598,18 @@ def auto_create_exchange_rate_revaluation_weekly() -> None:
 	create_err_and_its_journals(companies)
 
 
+def auto_create_exchange_rate_revaluation_monthly() -> None:
+	"""
+	Executed by background job
+	"""
+	companies = frappe.db.get_all(
+		"Company",
+		filters={"auto_exchange_rate_revaluation": 1, "auto_err_frequency": "Montly"},
+		fields=["name", "submit_err_jv"],
+	)
+	create_err_and_its_journals(companies)
+
+
 def get_payment_ledger_entries(gl_entries, cancel=0):
 	ple_map = []
 	if gl_entries:

erpnext/assets/doctype/asset/asset.js

@@ -187,12 +187,22 @@ frappe.ui.form.on("Asset", {
 		if (frm.doc.docstatus == 0) {
 			frm.toggle_reqd("finance_books", frm.doc.calculate_depreciation);
 
-			if (frm.doc.is_composite_asset && !frm.doc.capitalized_in) {
-				$(".primary-action").prop("hidden", true);
-				$(".form-message").text("Capitalize this asset to confirm");
+			if (frm.doc.is_composite_asset) {
+				frappe.call({
+					method: "erpnext.assets.doctype.asset.asset.has_active_capitalization",
+					args: {
+						asset: frm.doc.name,
+					},
+					callback: function (r) {
+						if (!r.message) {
+							$(".primary-action").prop("hidden", true);
+							$(".form-message").text("Capitalize this asset to confirm");
 
-				frm.add_custom_button(__("Capitalize Asset"), function () {
-					frm.trigger("create_asset_capitalization");
+							frm.add_custom_button(__("Capitalize Asset"), function () {
+								frm.trigger("create_asset_capitalization");
+							});
+						}
+					},
 				});
 			}
 		}
@@ -511,6 +521,8 @@ frappe.ui.form.on("Asset", {
 		frappe.call({
 			args: {
 				asset: frm.doc.name,
+				asset_name: frm.doc.asset_name,
+				item_code: frm.doc.item_code,
 			},
 			method: "erpnext.assets.doctype.asset.asset.create_asset_capitalization",
 			callback: function (r) {
@@ -773,11 +785,8 @@ frappe.ui.form.on("Asset Finance Book", {
 
 	depreciation_start_date: function (frm, cdt, cdn) {
 		const book = locals[cdt][cdn];
-		if (
-			frm.doc.available_for_use_date &&
-			book.depreciation_start_date == frm.doc.available_for_use_date
-		) {
-			frappe.msgprint(__("Depreciation Posting Date should not be equal to Available for Use Date."));
+		if (frm.doc.available_for_use_date && book.depreciation_start_date < frm.doc.available_for_use_date) {
+			frappe.msgprint(__("Depreciation Posting Date cannot be before Available-for-use Date"));
 			book.depreciation_start_date = "";
 			frm.refresh_field("finance_books");
 		}

erpnext/assets/doctype/asset/asset.json

@@ -75,8 +75,7 @@
   "purchase_amount",
   "default_finance_book",
   "depr_entry_posting_status",
-  "amended_from",
-  "capitalized_in"
+  "amended_from"
  ],
  "fields": [
   {
@@ -222,7 +221,6 @@
    "read_only": 1
   },
   {
-   "depends_on": "eval:!(doc.is_composite_asset && !doc.capitalized_in)",
    "fieldname": "gross_purchase_amount",
    "fieldtype": "Currency",
    "label": "Gross Purchase Amount",
@@ -508,14 +506,6 @@
    "fieldtype": "Check",
    "label": "Is Composite Asset"
   },
-  {
-   "fieldname": "capitalized_in",
-   "fieldtype": "Link",
-   "hidden": 1,
-   "label": "Capitalized In",
-   "options": "Asset Capitalization",
-   "read_only": 1
-  },
   {
    "depends_on": "eval:doc.docstatus > 0",
    "fieldname": "total_asset_cost",
@@ -589,7 +579,7 @@
    "link_fieldname": "target_asset"
   }
  ],
- "modified": "2024-05-21 13:46:21.066483",
+ "modified": "2024-08-01 16:39:09.340973",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset",

erpnext/assets/doctype/asset/asset.py

@@ -60,7 +60,6 @@ class Asset(AccountsController):
 		available_for_use_date: DF.Date | None
 		booked_fixed_asset: DF.Check
 		calculate_depreciation: DF.Check
-		capitalized_in: DF.Link | None
 		company: DF.Link
 		comprehensive_insurance: DF.Data | None
 		cost_center: DF.Link | None
@@ -162,7 +161,7 @@ class Asset(AccountsController):
 	def on_cancel(self):
 		self.validate_cancellation()
 		self.cancel_movement_entries()
-		self.cancel_capitalization()
+		self.reload()
 		self.delete_depreciation_entries()
 		cancel_asset_depr_schedules(self)
 		self.set_status()
@@ -268,10 +267,10 @@ class Asset(AccountsController):
 			frappe.throw(_("Available for use date is required"))
 
 		for d in self.finance_books:
-			if d.depreciation_start_date == self.available_for_use_date:
+			if getdate(d.depreciation_start_date) < getdate(self.available_for_use_date):
 				frappe.throw(
 					_(
-						"Row #{}: Depreciation Posting Date should not be equal to Available for Use Date."
+						"Depreciation Row {0}: Depreciation Posting Date cannot be before Available-for-use Date"
 					).format(d.idx),
 					title=_("Incorrect Date"),
 				)
@@ -524,16 +523,6 @@ class Asset(AccountsController):
 			movement = frappe.get_doc("Asset Movement", movement.get("name"))
 			movement.cancel()
 
-	def cancel_capitalization(self):
-		asset_capitalization = frappe.db.get_value(
-			"Asset Capitalization",
-			{"target_asset": self.name, "docstatus": 1, "entry_type": "Capitalization"},
-		)
-
-		if asset_capitalization:
-			asset_capitalization = frappe.get_doc("Asset Capitalization", asset_capitalization)
-			asset_capitalization.cancel()
-
 	def delete_depreciation_entries(self):
 		if self.calculate_depreciation:
 			for row in self.get("finance_books"):
@@ -680,7 +669,7 @@ class Asset(AccountsController):
 		if not fixed_asset_account:
 			frappe.throw(
 				_("Set {0} in asset category {1} for company {2}").format(
-					frappe.bold("Fixed Asset Account"),
+					frappe.bold(_("Fixed Asset Account")),
 					frappe.bold(self.asset_category),
 					frappe.bold(self.company),
 				),
@@ -872,10 +861,15 @@ def create_asset_repair(asset, asset_name):
 
 
 @frappe.whitelist()
-def create_asset_capitalization(asset):
+def create_asset_capitalization(asset, asset_name, item_code):
 	asset_capitalization = frappe.new_doc("Asset Capitalization")
 	asset_capitalization.update(
-		{"target_asset": asset, "capitalization_method": "Choose a WIP composite asset"}
+		{
+			"target_asset": asset,
+			"capitalization_method": "Choose a WIP composite asset",
+			"target_asset_name": asset_name,
+			"target_item_code": item_code,
+		}
 	)
 	return asset_capitalization
 
@@ -910,7 +904,7 @@ def transfer_asset(args):
 
 @frappe.whitelist()
 def get_item_details(item_code, asset_category, gross_purchase_amount):
-	asset_category_doc = frappe.get_doc("Asset Category", asset_category)
+	asset_category_doc = frappe.get_cached_doc("Asset Category", asset_category)
 	books = []
 	for d in asset_category_doc.finance_books:
 		books.append(
@@ -1041,6 +1035,14 @@ def get_asset_value_after_depreciation(asset_name, finance_book=None):
 	return asset.get_value_after_depreciation(finance_book)
 
 
+@frappe.whitelist()
+def has_active_capitalization(asset):
+	active_capitalizations = frappe.db.count(
+		"Asset Capitalization", filters={"target_asset": asset, "docstatus": 1}
+	)
+	return active_capitalizations > 0
+
+
 @frappe.whitelist()
 def split_asset(asset_name, split_qty):
 	asset = frappe.get_doc("Asset", asset_name)

erpnext/assets/doctype/asset/test_asset.py

@@ -234,7 +234,7 @@ class TestAsset(AssetSetup):
 		pro_rata_amount, _, _ = _get_pro_rata_amt(
 			asset.finance_books[0],
 			9000,
-			get_last_day(add_months(purchase_date, 1)),
+			add_days(get_last_day(add_months(purchase_date, 1)), 1),
 			date,
 			original_schedule_date=get_last_day(nowdate()),
 		)
@@ -320,7 +320,7 @@ class TestAsset(AssetSetup):
 		pro_rata_amount, _, _ = _get_pro_rata_amt(
 			asset.finance_books[0],
 			9000,
-			get_last_day(add_months(purchase_date, 1)),
+			add_days(get_last_day(add_months(purchase_date, 1)), 1),
 			date,
 			original_schedule_date=get_last_day(nowdate()),
 		)
@@ -740,7 +740,7 @@ class TestDepreciationMethods(AssetSetup):
 			available_for_use_date="2030-06-06",
 			is_existing_asset=1,
 			opening_number_of_booked_depreciations=2,
-			opening_accumulated_depreciation=47095.89,
+			opening_accumulated_depreciation=47178.08,
 			expected_value_after_useful_life=10000,
 			depreciation_start_date="2032-12-31",
 			total_number_of_depreciations=3,
@@ -748,7 +748,7 @@ class TestDepreciationMethods(AssetSetup):
 		)
 
 		self.assertEqual(asset.status, "Draft")
-		expected_schedules = [["2032-12-31", 42904.11, 90000.0]]
+		expected_schedules = [["2032-12-31", 30000.0, 77178.08], ["2033-06-06", 12821.92, 90000.0]]
 		schedules = [
 			[cstr(d.schedule_date), flt(d.depreciation_amount, 2), d.accumulated_depreciation_amount]
 			for d in get_depr_schedule(asset.name, "Draft")

erpnext/assets/doctype/asset_capitalization/asset_capitalization.js

@@ -11,6 +11,7 @@ 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/assets/doctype/asset_capitalization/asset_capitalization.py

@@ -138,22 +138,10 @@ class AssetCapitalization(StockController):
 			"Asset",
 			"Asset Movement",
 		)
-		self.cancel_target_asset()
 		self.update_stock_ledger()
 		self.make_gl_entries()
 		self.restore_consumed_asset_items()
 
-	def on_trash(self):
-		frappe.db.set_value("Asset", self.target_asset, "capitalized_in", None)
-		super().on_trash()
-
-	def cancel_target_asset(self):
-		if self.entry_type == "Capitalization" and self.target_asset:
-			asset_doc = frappe.get_doc("Asset", self.target_asset)
-			asset_doc.db_set("capitalized_in", None)
-			if asset_doc.docstatus == 1:
-				asset_doc.cancel()
-
 	def set_title(self):
 		self.title = self.target_asset_name or self.target_item_name or self.target_item_code
 
@@ -329,8 +317,12 @@ class AssetCapitalization(StockController):
 		if not self.target_is_fixed_asset and not self.get("asset_items"):
 			frappe.throw(_("Consumed Asset Items is mandatory for Decapitalization"))
 
-		if not self.get("stock_items") and not self.get("asset_items"):
-			frappe.throw(_("Consumed Stock Items or Consumed Asset Items is mandatory for Capitalization"))
+		if not (self.get("stock_items") or self.get("asset_items") or self.get("service_items")):
+			frappe.throw(
+				_(
+					"Consumed Stock Items, Consumed Asset Items or Consumed Service Items is mandatory for Capitalization"
+				)
+			)
 
 	def validate_item(self, item):
 		from erpnext.stock.doctype.item.item import validate_end_of_life
@@ -617,7 +609,6 @@ class AssetCapitalization(StockController):
 		asset_doc.purchase_date = self.posting_date
 		asset_doc.gross_purchase_amount = total_target_asset_value
 		asset_doc.purchase_amount = total_target_asset_value
-		asset_doc.capitalized_in = self.name
 		asset_doc.flags.ignore_validate = True
 		asset_doc.flags.asset_created_via_asset_capitalization = True
 		asset_doc.insert()
@@ -653,7 +644,6 @@ class AssetCapitalization(StockController):
 		asset_doc = frappe.get_doc("Asset", self.target_asset)
 		asset_doc.gross_purchase_amount = total_target_asset_value
 		asset_doc.purchase_amount = total_target_asset_value
-		asset_doc.capitalized_in = self.name
 		asset_doc.flags.ignore_validate = True
 		asset_doc.save()
 

erpnext/assets/doctype/asset_capitalization/test_asset_capitalization.py

@@ -386,6 +386,56 @@ class TestAssetCapitalization(unittest.TestCase):
 		self.assertFalse(get_actual_gle_dict(asset_capitalization.name))
 		self.assertFalse(get_actual_sle_dict(asset_capitalization.name))
 
+	def test_capitalize_only_service_item(self):
+		company = "_Test Company"
+		# Variables
+
+		service_rate = 500
+		service_qty = 2
+		service_amount = 1000
+
+		total_amount = 1000
+
+		wip_composite_asset = create_asset(
+			asset_name="Asset Capitalization WIP Composite Asset",
+			is_composite_asset=1,
+			warehouse="Stores - TCP1",
+			company=company,
+		)
+
+		# Create and submit Asset Captitalization
+		asset_capitalization = create_asset_capitalization(
+			entry_type="Capitalization",
+			capitalization_method="Choose a WIP composite asset",
+			target_asset=wip_composite_asset.name,
+			target_asset_location="Test Location",
+			service_qty=service_qty,
+			service_rate=service_rate,
+			service_expense_account="Expenses Included In Asset Valuation - _TC",
+			company=company,
+			submit=1,
+		)
+
+		self.assertEqual(asset_capitalization.service_items[0].amount, service_amount)
+		self.assertEqual(asset_capitalization.service_items_total, service_amount)
+
+		target_asset = frappe.get_doc("Asset", asset_capitalization.target_asset)
+		self.assertEqual(target_asset.gross_purchase_amount, total_amount)
+		self.assertEqual(target_asset.purchase_amount, total_amount)
+
+		expected_gle = {
+			"_Test Fixed Asset - _TC": 1000.0,
+			"Expenses Included In Asset Valuation - _TC": -1000.0,
+		}
+
+		actual_gle = get_actual_gle_dict(asset_capitalization.name)
+		self.assertEqual(actual_gle, expected_gle)
+
+		# Cancel Asset Capitalization and make test entries and status are reversed
+		asset_capitalization.cancel()
+		self.assertFalse(get_actual_gle_dict(asset_capitalization.name))
+		self.assertFalse(get_actual_sle_dict(asset_capitalization.name))
+
 
 def create_asset_capitalization_data():
 	create_item("Capitalization Target Stock Item", is_stock_item=1, is_fixed_asset=0, is_purchase_item=0)

erpnext/assets/doctype/asset_depreciation_schedule/asset_depreciation_schedule.py

@@ -291,7 +291,9 @@ class AssetDepreciationSchedule(Document):
 			if skip_row:
 				continue
 
-			schedule_date = add_months(row.depreciation_start_date, n * cint(row.frequency_of_depreciation))
+			schedule_date = get_last_day(
+				add_months(row.depreciation_start_date, n * cint(row.frequency_of_depreciation))
+			)
 			if not current_fiscal_year_end_date:
 				current_fiscal_year_end_date = get_fiscal_year(row.depreciation_start_date)[2]
 			elif getdate(schedule_date) > getdate(current_fiscal_year_end_date):
@@ -330,8 +332,10 @@ class AssetDepreciationSchedule(Document):
 					getdate(asset_doc.available_for_use_date),
 					(asset_doc.opening_number_of_booked_depreciations * row.frequency_of_depreciation),
 				)
+				if is_last_day_of_the_month(getdate(asset_doc.available_for_use_date)):
+					from_date = get_last_day(from_date)
 				if self.depreciation_schedule:
-					from_date = self.depreciation_schedule[-1].schedule_date
+					from_date = add_days(self.depreciation_schedule[-1].schedule_date, 1)
 
 				depreciation_amount, days, months = _get_pro_rata_amt(
 					row,
@@ -353,9 +357,8 @@ class AssetDepreciationSchedule(Document):
 				and not self.opening_accumulated_depreciation
 				and not self.flags.wdv_it_act_applied
 			):
-				from_date = add_days(
-					asset_doc.available_for_use_date, -1
-				)  # needed to calc depr amount for available_for_use_date too
+				from_date = asset_doc.available_for_use_date
+				# needed to calc depr amount for available_for_use_date too
 				depreciation_amount, days, months = _get_pro_rata_amt(
 					row,
 					depreciation_amount,
@@ -406,6 +409,8 @@ class AssetDepreciationSchedule(Document):
 						(n + self.opening_number_of_booked_depreciations)
 						* cint(row.frequency_of_depreciation),
 					)
+					if is_last_day_of_the_month(getdate(asset_doc.available_for_use_date)):
+						asset_doc.to_date = get_last_day(asset_doc.to_date)
 
 				depreciation_amount_without_pro_rata = depreciation_amount
 
@@ -421,7 +426,7 @@ class AssetDepreciationSchedule(Document):
 					depreciation_amount_without_pro_rata, depreciation_amount
 				)
 
-				schedule_date = add_days(schedule_date, days)
+				schedule_date = add_days(schedule_date, days - 1)
 
 			if not depreciation_amount:
 				continue
@@ -504,7 +509,10 @@ class AssetDepreciationSchedule(Document):
 				continue
 
 			if not accumulated_depreciation:
-				if i > 0 and asset_doc.flags.decrease_in_asset_value_due_to_value_adjustment:
+				if i > 0 and (
+					asset_doc.flags.decrease_in_asset_value_due_to_value_adjustment
+					or asset_doc.flags.increase_in_asset_value_due_to_repair
+				):
 					accumulated_depreciation = self.get("depreciation_schedule")[
 						i - 1
 					].accumulated_depreciation_amount
@@ -552,9 +560,20 @@ def _check_is_pro_rata(asset_doc, row, wdv_or_dd_non_yearly=False):
 	# if not existing asset, from_date = available_for_use_date
 	# otherwise, if opening_number_of_booked_depreciations = 2, available_for_use_date = 01/01/2020 and frequency_of_depreciation = 12
 	# from_date = 01/01/2022
-	from_date = _get_modified_available_for_use_date(asset_doc, row, wdv_or_dd_non_yearly=False)
-	days = date_diff(row.depreciation_start_date, from_date) + 1
-	total_days = get_total_days(row.depreciation_start_date, row.frequency_of_depreciation)
+	if row.depreciation_method in ("Straight Line", "Manual"):
+		prev_depreciation_start_date = get_last_day(
+			add_months(
+				row.depreciation_start_date,
+				(row.frequency_of_depreciation * -1) * asset_doc.opening_number_of_booked_depreciations,
+			)
+		)
+		from_date = asset_doc.available_for_use_date
+		days = date_diff(prev_depreciation_start_date, from_date) + 1
+		total_days = get_total_days(prev_depreciation_start_date, row.frequency_of_depreciation)
+	else:
+		from_date = _get_modified_available_for_use_date(asset_doc, row, wdv_or_dd_non_yearly=False)
+		days = date_diff(row.depreciation_start_date, from_date) + 1
+		total_days = get_total_days(row.depreciation_start_date, row.frequency_of_depreciation)
 	if days <= 0:
 		frappe.throw(
 			_(
@@ -601,7 +620,7 @@ def _get_pro_rata_amt(
 	has_wdv_or_dd_non_yearly_pro_rata=False,
 	original_schedule_date=None,
 ):
-	days = date_diff(to_date, from_date)
+	days = date_diff(to_date, from_date) + 1
 	months = month_diff(to_date, from_date)
 	if has_wdv_or_dd_non_yearly_pro_rata:
 		total_days = get_total_days(original_schedule_date or to_date, 12)
@@ -661,7 +680,7 @@ def get_straight_line_or_manual_depr_amount(
 	# if the Depreciation Schedule is being modified after Asset Repair due to increase in asset value
 	elif asset.flags.increase_in_asset_value_due_to_repair:
 		return (flt(row.value_after_depreciation) - flt(row.expected_value_after_useful_life)) / flt(
-			row.total_number_of_depreciations
+			number_of_pending_depreciations
 		)
 	# if the Depreciation Schedule is being modified after Asset Value Adjustment due to decrease in asset value
 	elif asset.flags.decrease_in_asset_value_due_to_value_adjustment:
@@ -682,39 +701,84 @@ def get_straight_line_or_manual_depr_amount(
 	# if the Depreciation Schedule is being prepared for the first time
 	else:
 		if row.daily_prorata_based:
-			amount = (
-				flt(asset.gross_purchase_amount)
-				- flt(asset.opening_accumulated_depreciation)
-				- flt(row.expected_value_after_useful_life)
-			)
+			amount = flt(asset.gross_purchase_amount) - flt(row.expected_value_after_useful_life)
 			return get_daily_prorata_based_straight_line_depr(
 				asset, row, schedule_idx, number_of_pending_depreciations, amount
 			)
 		else:
-			return (
-				flt(asset.gross_purchase_amount)
-				- flt(asset.opening_accumulated_depreciation)
-				- flt(row.expected_value_after_useful_life)
-			) / flt(row.total_number_of_depreciations - asset.opening_number_of_booked_depreciations)
+			depreciation_amount = (
+				flt(asset.gross_purchase_amount) - flt(row.expected_value_after_useful_life)
+			) / flt(row.total_number_of_depreciations)
+			return depreciation_amount
 
 
 def get_daily_prorata_based_straight_line_depr(
 	asset, row, schedule_idx, number_of_pending_depreciations, amount
 ):
-	total_years = flt(number_of_pending_depreciations * row.frequency_of_depreciation) / 12
-	every_year_depr = amount / total_years
+	daily_depr_amount = get_daily_depr_amount(asset, row, schedule_idx, amount)
 
-	year_start_date = add_years(
-		row.depreciation_start_date, (row.frequency_of_depreciation * schedule_idx) // 12
-	)
-	year_end_date = add_days(add_years(year_start_date, 1), -1)
-	daily_depr_amount = every_year_depr / (date_diff(year_end_date, year_start_date) + 1)
 	from_date, total_depreciable_days = _get_total_days(
 		row.depreciation_start_date, schedule_idx, row.frequency_of_depreciation
 	)
 	return daily_depr_amount * total_depreciable_days
 
 
+def get_daily_depr_amount(asset, row, schedule_idx, amount):
+	if cint(frappe.db.get_single_value("Accounts Settings", "calculate_depr_using_total_days")):
+		total_days = (
+			date_diff(
+				get_last_day(
+					add_months(
+						row.depreciation_start_date,
+						flt(
+							row.total_number_of_depreciations
+							- asset.opening_number_of_booked_depreciations
+							- 1
+						)
+						* row.frequency_of_depreciation,
+					)
+				),
+				add_days(
+					get_last_day(
+						add_months(
+							row.depreciation_start_date,
+							(
+								row.frequency_of_depreciation
+								* (asset.opening_number_of_booked_depreciations + 1)
+							)
+							* -1,
+						),
+					),
+					1,
+				),
+			)
+			+ 1
+		)
+
+		return amount / total_days
+	else:
+		total_years = (
+			flt(
+				(row.total_number_of_depreciations - row.total_number_of_booked_depreciations)
+				* row.frequency_of_depreciation
+			)
+			/ 12
+		)
+
+		every_year_depr = amount / total_years
+
+		depr_period_start_date = add_days(
+			get_last_day(add_months(row.depreciation_start_date, row.frequency_of_depreciation * -1)), 1
+		)
+
+		year_start_date = add_years(
+			depr_period_start_date, ((row.frequency_of_depreciation * schedule_idx) // 12)
+		)
+		year_end_date = add_days(add_years(year_start_date, 1), -1)
+
+		return every_year_depr / (date_diff(year_end_date, year_start_date) + 1)
+
+
 def get_shift_depr_amount(asset_depr_schedule, asset, row, schedule_idx):
 	if asset_depr_schedule.get("__islocal") and not asset.flags.shift_allocation:
 		return (
@@ -867,7 +931,7 @@ def _get_daily_prorata_based_default_wdv_or_dd_depr_amount(
 
 
 def get_monthly_depr_amount(fb_row, schedule_idx, depreciable_value):
-	""" "
+	"""
 	Returns monthly depreciation amount when year changes
 	1. Calculate per day depr based on new year
 	2. Calculate monthly amount based on new per day amount
@@ -984,6 +1048,7 @@ def make_new_active_asset_depr_schedules_and_cancel_current_ones(
 	date_of_return=None,
 	value_after_depreciation=None,
 	ignore_booked_entry=False,
+	difference_amount=None,
 ):
 	for row in asset_doc.get("finance_books"):
 		current_asset_depr_schedule_doc = get_asset_depr_schedule_doc(
@@ -998,6 +1063,8 @@ def make_new_active_asset_depr_schedules_and_cancel_current_ones(
 			)
 
 		new_asset_depr_schedule_doc = frappe.copy_doc(current_asset_depr_schedule_doc)
+		if asset_doc.flags.decrease_in_asset_value_due_to_value_adjustment and not value_after_depreciation:
+			value_after_depreciation = row.value_after_depreciation + difference_amount
 
 		if asset_doc.flags.increase_in_asset_value_due_to_repair and row.depreciation_method in (
 			"Written Down Value",

erpnext/assets/doctype/asset_depreciation_schedule/test_asset_depreciation_schedule.py

@@ -75,6 +75,178 @@ class TestAssetDepreciationSchedule(FrappeTestCase):
 		]
 		self.assertEqual(schedules, expected_schedules)
 
+	def test_schedule_for_slm_for_existing_asset_daily_pro_rata_enabled(self):
+		frappe.db.set_single_value("Accounts Settings", "calculate_depr_using_total_days", 1)
+		asset = create_asset(
+			calculate_depreciation=1,
+			depreciation_method="Straight Line",
+			available_for_use_date="2023-10-10",
+			is_existing_asset=1,
+			opening_number_of_booked_depreciations=9,
+			opening_accumulated_depreciation=265,
+			depreciation_start_date="2024-07-31",
+			total_number_of_depreciations=24,
+			frequency_of_depreciation=1,
+			gross_purchase_amount=731,
+			daily_prorata_based=1,
+		)
+
+		expected_schedules = [
+			["2024-07-31", 31.0, 296.0],
+			["2024-08-31", 31.0, 327.0],
+			["2024-09-30", 30.0, 357.0],
+			["2024-10-31", 31.0, 388.0],
+			["2024-11-30", 30.0, 418.0],
+			["2024-12-31", 31.0, 449.0],
+			["2025-01-31", 31.0, 480.0],
+			["2025-02-28", 28.0, 508.0],
+			["2025-03-31", 31.0, 539.0],
+			["2025-04-30", 30.0, 569.0],
+			["2025-05-31", 31.0, 600.0],
+			["2025-06-30", 30.0, 630.0],
+			["2025-07-31", 31.0, 661.0],
+			["2025-08-31", 31.0, 692.0],
+			["2025-09-30", 30.0, 722.0],
+			["2025-10-10", 9.0, 731.0],
+		]
+		schedules = [
+			[cstr(d.schedule_date), flt(d.depreciation_amount, 2), d.accumulated_depreciation_amount]
+			for d in get_depr_schedule(asset.name, "Draft")
+		]
+		self.assertEqual(schedules, expected_schedules)
+		frappe.db.set_single_value("Accounts Settings", "calculate_depr_using_total_days", 0)
+
+	def test_schedule_for_slm_for_existing_asset(self):
+		asset = create_asset(
+			calculate_depreciation=1,
+			depreciation_method="Straight Line",
+			available_for_use_date="2023-10-10",
+			is_existing_asset=1,
+			opening_number_of_booked_depreciations=9,
+			opening_accumulated_depreciation=265.30,
+			depreciation_start_date="2024-07-31",
+			total_number_of_depreciations=24,
+			frequency_of_depreciation=1,
+			gross_purchase_amount=731,
+		)
+
+		expected_schedules = [
+			["2024-07-31", 30.46, 295.76],
+			["2024-08-31", 30.46, 326.22],
+			["2024-09-30", 30.46, 356.68],
+			["2024-10-31", 30.46, 387.14],
+			["2024-11-30", 30.46, 417.6],
+			["2024-12-31", 30.46, 448.06],
+			["2025-01-31", 30.46, 478.52],
+			["2025-02-28", 30.46, 508.98],
+			["2025-03-31", 30.46, 539.44],
+			["2025-04-30", 30.46, 569.9],
+			["2025-05-31", 30.46, 600.36],
+			["2025-06-30", 30.46, 630.82],
+			["2025-07-31", 30.46, 661.28],
+			["2025-08-31", 30.46, 691.74],
+			["2025-09-30", 30.46, 722.2],
+			["2025-10-10", 8.8, 731.0],
+		]
+		schedules = [
+			[cstr(d.schedule_date), flt(d.depreciation_amount, 2), d.accumulated_depreciation_amount]
+			for d in get_depr_schedule(asset.name, "Draft")
+		]
+		self.assertEqual(schedules, expected_schedules)
+
+	def test_schedule_sl_method_for_existing_asset_with_frequency_of_3_months(self):
+		asset = create_asset(
+			calculate_depreciation=1,
+			depreciation_method="Straight Line",
+			available_for_use_date="2023-11-01",
+			is_existing_asset=1,
+			opening_number_of_booked_depreciations=4,
+			opening_accumulated_depreciation=223.15,
+			depreciation_start_date="2024-12-31",
+			total_number_of_depreciations=12,
+			frequency_of_depreciation=3,
+			gross_purchase_amount=731,
+		)
+
+		expected_schedules = [
+			["2024-12-31", 60.92, 284.07],
+			["2025-03-31", 60.92, 344.99],
+			["2025-06-30", 60.92, 405.91],
+			["2025-09-30", 60.92, 466.83],
+			["2025-12-31", 60.92, 527.75],
+			["2026-03-31", 60.92, 588.67],
+			["2026-06-30", 60.92, 649.59],
+			["2026-09-30", 60.92, 710.51],
+			["2026-11-01", 20.49, 731.0],
+		]
+		schedules = [
+			[cstr(d.schedule_date), flt(d.depreciation_amount, 2), d.accumulated_depreciation_amount]
+			for d in get_depr_schedule(asset.name, "Draft")
+		]
+		self.assertEqual(schedules, expected_schedules)
+
+	# Enable Checkbox to Calculate depreciation using total days in depreciation period
+	def test_daily_prorata_based_depr_after_enabling_configuration(self):
+		frappe.db.set_single_value("Accounts Settings", "calculate_depr_using_total_days", 1)
+
+		asset = create_asset(
+			calculate_depreciation=1,
+			depreciation_method="Straight Line",
+			daily_prorata_based=1,
+			gross_purchase_amount=1096,
+			available_for_use_date="2020-01-15",
+			depreciation_start_date="2020-01-31",
+			frequency_of_depreciation=1,
+			total_number_of_depreciations=36,
+		)
+
+		expected_schedule = [
+			["2020-01-31", 17.0, 17.0],
+			["2020-02-29", 29.0, 46.0],
+			["2020-03-31", 31.0, 77.0],
+			["2020-04-30", 30.0, 107.0],
+			["2020-05-31", 31.0, 138.0],
+			["2020-06-30", 30.0, 168.0],
+			["2020-07-31", 31.0, 199.0],
+			["2020-08-31", 31.0, 230.0],
+			["2020-09-30", 30.0, 260.0],
+			["2020-10-31", 31.0, 291.0],
+			["2020-11-30", 30.0, 321.0],
+			["2020-12-31", 31.0, 352.0],
+			["2021-01-31", 31.0, 383.0],
+			["2021-02-28", 28.0, 411.0],
+			["2021-03-31", 31.0, 442.0],
+			["2021-04-30", 30.0, 472.0],
+			["2021-05-31", 31.0, 503.0],
+			["2021-06-30", 30.0, 533.0],
+			["2021-07-31", 31.0, 564.0],
+			["2021-08-31", 31.0, 595.0],
+			["2021-09-30", 30.0, 625.0],
+			["2021-10-31", 31.0, 656.0],
+			["2021-11-30", 30.0, 686.0],
+			["2021-12-31", 31.0, 717.0],
+			["2022-01-31", 31.0, 748.0],
+			["2022-02-28", 28.0, 776.0],
+			["2022-03-31", 31.0, 807.0],
+			["2022-04-30", 30.0, 837.0],
+			["2022-05-31", 31.0, 868.0],
+			["2022-06-30", 30.0, 898.0],
+			["2022-07-31", 31.0, 929.0],
+			["2022-08-31", 31.0, 960.0],
+			["2022-09-30", 30.0, 990.0],
+			["2022-10-31", 31.0, 1021.0],
+			["2022-11-30", 30.0, 1051.0],
+			["2022-12-31", 31.0, 1082.0],
+			["2023-01-15", 14.0, 1096.0],
+		]
+
+		schedules = [
+			[cstr(d.schedule_date), d.depreciation_amount, d.accumulated_depreciation_amount]
+			for d in get_depr_schedule(asset.name, "Draft")
+		]
+		self.assertEqual(schedules, expected_schedule)
+		frappe.db.set_single_value("Accounts Settings", "calculate_depr_using_total_days", 0)
+
 	# Test for Written Down Value Method
 	# Frequency of deprciation = 3
 	def test_for_daily_prorata_based_depreciation_wdv_method_frequency_3_months(self):

erpnext/assets/doctype/asset_maintenance/asset_maintenance.js

@@ -3,6 +3,15 @@
 
 frappe.ui.form.on("Asset Maintenance", {
 	setup: (frm) => {
+		frm.set_query("asset_name", function () {
+			return {
+				filters: {
+					company: frm.doc.company,
+					docstatus: 1,
+				},
+			};
+		});
+
 		frm.set_query("assign_to", "asset_maintenance_tasks", function (doc) {
 			return {
 				query: "erpnext.assets.doctype.asset_maintenance.asset_maintenance.get_team_members",

erpnext/assets/doctype/asset_repair/asset_repair.js

@@ -29,6 +29,15 @@ frappe.ui.form.on("Asset Repair", {
 			};
 		});
 
+		frm.set_query("purchase_invoice", function () {
+			return {
+				filters: {
+					company: frm.doc.company,
+					docstatus: 1,
+				},
+			};
+		});
+
 		frm.set_query("warehouse", "stock_items", function () {
 			return {
 				filters: {

erpnext/assets/doctype/asset_repair/asset_repair.py

@@ -117,7 +117,9 @@ class AssetRepair(AccountsController):
 					get_link_to_form(self.doctype, self.name),
 				)
 				self.asset_doc.flags.ignore_validate_update_after_submit = True
-				make_new_active_asset_depr_schedules_and_cancel_current_ones(self.asset_doc, notes)
+				make_new_active_asset_depr_schedules_and_cancel_current_ones(
+					self.asset_doc, notes, ignore_booked_entry=True
+				)
 				self.asset_doc.save()
 
 				add_asset_activity(
@@ -154,7 +156,9 @@ class AssetRepair(AccountsController):
 					get_link_to_form(self.doctype, self.name),
 				)
 				self.asset_doc.flags.ignore_validate_update_after_submit = True
-				make_new_active_asset_depr_schedules_and_cancel_current_ones(self.asset_doc, notes)
+				make_new_active_asset_depr_schedules_and_cancel_current_ones(
+					self.asset_doc, notes, ignore_booked_entry=True
+				)
 				self.asset_doc.save()
 
 				add_asset_activity(

erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py

@@ -56,7 +56,8 @@ class AssetValueAdjustment(Document):
 		)
 
 	def on_cancel(self):
-		self.update_asset(self.current_asset_value)
+		frappe.get_doc("Journal Entry", self.journal_entry).cancel()
+		self.update_asset()
 		add_asset_activity(
 			self.asset,
 			_("Asset's value adjusted after cancellation of Asset Value Adjustment {0}").format(
@@ -144,7 +145,7 @@ class AssetValueAdjustment(Document):
 
 		self.db_set("journal_entry", je.name)
 
-	def update_asset(self, asset_value):
+	def update_asset(self, asset_value=None):
 		asset = frappe.get_doc("Asset", self.asset)
 
 		if not asset.calculate_depreciation:
@@ -170,7 +171,11 @@ class AssetValueAdjustment(Document):
 			)
 
 		make_new_active_asset_depr_schedules_and_cancel_current_ones(
-			asset, notes, value_after_depreciation=asset_value, ignore_booked_entry=True
+			asset,
+			notes,
+			value_after_depreciation=asset_value,
+			ignore_booked_entry=True,
+			difference_amount=self.difference_amount,
 		)
 		asset.flags.ignore_validate_update_after_submit = True
 		asset.save()

erpnext/assets/doctype/asset_value_adjustment/test_asset_value_adjustment.py

@@ -12,6 +12,7 @@ from erpnext.assets.doctype.asset.test_asset import create_asset_data
 from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
 	get_asset_depr_schedule_doc,
 )
+from erpnext.assets.doctype.asset_repair.test_asset_repair import create_asset_repair
 from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
 
 
@@ -128,6 +129,136 @@ class TestAssetValueAdjustment(unittest.TestCase):
 
 		self.assertEqual(schedules, expected_schedules)
 
+	def test_depreciation_after_cancelling_asset_repair(self):
+		pr = make_purchase_receipt(item_code="Macbook Pro", qty=1, rate=120000.0, location="Test Location")
+
+		asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, "name")
+		asset_doc = frappe.get_doc("Asset", asset_name)
+		asset_doc.calculate_depreciation = 1
+		asset_doc.available_for_use_date = "2023-01-15"
+		asset_doc.purchase_date = "2023-01-15"
+
+		asset_doc.append(
+			"finance_books",
+			{
+				"expected_value_after_useful_life": 200,
+				"depreciation_method": "Straight Line",
+				"total_number_of_depreciations": 12,
+				"frequency_of_depreciation": 1,
+				"depreciation_start_date": "2023-01-31",
+			},
+		)
+		asset_doc.submit()
+
+		post_depreciation_entries(getdate("2023-08-21"))
+
+		# create asset repair
+		asset_repair = create_asset_repair(asset=asset_doc, capitalize_repair_cost=1, submit=1)
+
+		first_asset_depr_schedule = get_asset_depr_schedule_doc(asset_doc.name, "Active")
+		self.assertEqual(first_asset_depr_schedule.status, "Active")
+
+		# create asset value adjustment
+		current_value = get_asset_value_after_depreciation(asset_doc.name)
+
+		adj_doc = make_asset_value_adjustment(
+			asset=asset_doc.name,
+			current_asset_value=current_value,
+			new_asset_value=50000.0,
+			date="2023-08-21",
+		)
+		adj_doc.submit()
+
+		first_asset_depr_schedule.load_from_db()
+
+		second_asset_depr_schedule = get_asset_depr_schedule_doc(asset_doc.name, "Active")
+		self.assertEqual(second_asset_depr_schedule.status, "Active")
+		self.assertEqual(first_asset_depr_schedule.status, "Cancelled")
+
+		# Test gl entry creted from asset value adjustemnet
+		expected_gle = (
+			("_Test Accumulated Depreciations - _TC", 0.0, 5625.29),
+			("_Test Depreciations - _TC", 5625.29, 0.0),
+		)
+
+		gle = frappe.db.sql(
+			"""select account, debit, credit from `tabGL Entry`
+			where voucher_type='Journal Entry' and voucher_no = %s
+			order by account""",
+			adj_doc.journal_entry,
+		)
+
+		self.assertSequenceEqual(gle, expected_gle)
+
+		# test depreciation schedule after asset repair and asset value adjustemnet
+		expected_schedules = [
+			["2023-01-31", 5474.73, 5474.73],
+			["2023-02-28", 9983.33, 15458.06],
+			["2023-03-31", 9983.33, 25441.39],
+			["2023-04-30", 9983.33, 35424.72],
+			["2023-05-31", 9983.33, 45408.05],
+			["2023-06-30", 9983.33, 55391.38],
+			["2023-07-31", 9983.33, 65374.71],
+			["2023-08-31", 2766.67, 68141.38],
+			["2023-09-30", 2766.67, 70908.05],
+			["2023-10-31", 2766.67, 73674.72],
+			["2023-11-30", 2766.67, 76441.39],
+			["2023-12-31", 2766.67, 79208.06],
+			["2024-01-31", 2766.67, 81974.73],
+			["2024-02-29", 2766.67, 84741.4],
+			["2024-03-31", 2766.67, 87508.07],
+			["2024-04-30", 2766.67, 90274.74],
+			["2024-05-31", 2766.67, 93041.41],
+			["2024-06-30", 2766.67, 95808.08],
+			["2024-07-31", 2766.67, 98574.75],
+			["2024-08-31", 2766.67, 101341.42],
+			["2024-09-30", 2766.67, 104108.09],
+			["2024-10-31", 2766.67, 106874.76],
+			["2024-11-30", 2766.67, 109641.43],
+			["2024-12-31", 2766.67, 112408.1],
+			["2025-01-15", 2766.61, 115174.71],
+		]
+
+		schedules = [
+			[cstr(d.schedule_date), d.depreciation_amount, d.accumulated_depreciation_amount]
+			for d in second_asset_depr_schedule.get("depreciation_schedule")
+		]
+
+		self.assertEqual(schedules, expected_schedules)
+
+		# Cancel asset repair
+		asset_repair.cancel()
+		asset_repair.load_from_db()
+		second_asset_depr_schedule.load_from_db()
+
+		third_asset_depr_schedule = get_asset_depr_schedule_doc(asset_doc.name, "Active")
+		self.assertEqual(third_asset_depr_schedule.status, "Active")
+		self.assertEqual(second_asset_depr_schedule.status, "Cancelled")
+
+		# After cancelling asset repair asset life will be decreased and new depreciation schedule should be calculated
+		expected_schedules = [
+			["2023-01-31", 5474.73, 5474.73],
+			["2023-02-28", 9983.33, 15458.06],
+			["2023-03-31", 9983.33, 25441.39],
+			["2023-04-30", 9983.33, 35424.72],
+			["2023-05-31", 9983.33, 45408.05],
+			["2023-06-30", 9983.33, 55391.38],
+			["2023-07-31", 9983.33, 65374.71],
+			["2023-08-31", 8133.33, 73508.04],
+			["2023-09-30", 8133.33, 81641.37],
+			["2023-10-31", 8133.33, 89774.7],
+			["2023-11-30", 8133.33, 97908.03],
+			["2023-12-31", 8133.33, 106041.36],
+			["2024-01-15", 8133.35, 114174.71],
+		]
+
+		schedules = [
+			[cstr(d.schedule_date), d.depreciation_amount, d.accumulated_depreciation_amount]
+			for d in third_asset_depr_schedule.get("depreciation_schedule")
+		]
+
+		self.assertEqual(schedules, expected_schedules)
+
 
 def make_asset_value_adjustment(**args):
 	args = frappe._dict(args)

erpnext/buying/doctype/supplier/supplier.json

@@ -174,7 +174,7 @@
    "fieldname": "supplier_type",
    "fieldtype": "Select",
    "label": "Supplier Type",
-   "options": "Company\nIndividual\nProprietorship\nPartnership",
+   "options": "Company\nIndividual\nPartnership",
    "reqd": 1
   },
   {

erpnext/buying/doctype/supplier/supplier.py

@@ -65,7 +65,7 @@ class Supplier(TransactionBase):
 		supplier_name: DF.Data
 		supplier_primary_address: DF.Link | None
 		supplier_primary_contact: DF.Link | None
-		supplier_type: DF.Literal["Company", "Individual", "Proprietorship", "Partnership"]
+		supplier_type: DF.Literal["Company", "Individual", "Partnership"]
 		tax_category: DF.Link | None
 		tax_id: DF.Data | None
 		tax_withholding_category: DF.Link | None
@@ -97,7 +97,7 @@ class Supplier(TransactionBase):
 		elif supp_master_name == "Naming Series":
 			set_name_by_naming_series(self)
 		else:
-			self.name = set_name_from_naming_options(frappe.get_meta(self.doctype).autoname, self)
+			set_name_from_naming_options(frappe.get_meta(self.doctype).autoname, self)
 
 	def on_update(self):
 		self.create_primary_contact()

erpnext/buying/report/item_wise_purchase_history/item_wise_purchase_history.js

@@ -0,0 +1,62 @@
+// Copyright (c) 2024, Frappe Technologies Pvt. Ltd. and contributors
+// For license information, please see license.txt
+
+frappe.query_reports["Item-wise Purchase History"] = {
+	filters: [
+		{
+			fieldname: "company",
+			label: __("Company"),
+			fieldtype: "Link",
+			options: "Company",
+			default: frappe.defaults.get_user_default("Company"),
+			reqd: 1,
+		},
+		{
+			fieldname: "from_date",
+			reqd: 1,
+			label: __("From Date"),
+			fieldtype: "Date",
+			default: frappe.datetime.add_months(frappe.datetime.get_today(), -1),
+		},
+		{
+			fieldname: "to_date",
+			reqd: 1,
+			default: frappe.datetime.get_today(),
+			label: __("To Date"),
+			fieldtype: "Date",
+		},
+		{
+			fieldname: "item_group",
+			label: __("Item Group"),
+			fieldtype: "Link",
+			options: "Item Group",
+		},
+		{
+			fieldname: "item_code",
+			label: __("Item"),
+			fieldtype: "Link",
+			options: "Item",
+			get_query: () => {
+				return {
+					query: "erpnext.controllers.queries.item_query",
+				};
+			},
+		},
+		{
+			fieldname: "supplier",
+			label: __("Supplier"),
+			fieldtype: "Link",
+			options: "Supplier",
+		},
+	],
+
+	formatter: function (value, row, column, data, default_formatter) {
+		value = default_formatter(value, row, column, data);
+		let format_fields = ["received_qty", "billed_amt"];
+
+		if (format_fields.includes(column.fieldname) && data && data[column.fieldname] > 0) {
+			value = "<span style='color:green;'>" + value + "</span>";
+		}
+		return value;
+	},
+};

erpnext/buying/report/item_wise_purchase_history/item_wise_purchase_history.json

@@ -1,30 +1,30 @@
 {
- "add_total_row": 1, 
- "apply_user_permissions": 1, 
- "creation": "2013-05-03 14:55:53", 
- "disabled": 0, 
- "docstatus": 0, 
- "doctype": "Report", 
- "idx": 3, 
- "is_standard": "Yes", 
- "modified": "2017-02-24 20:08:57.446613", 
- "modified_by": "Administrator", 
- "module": "Buying", 
- "name": "Item-wise Purchase History", 
- "owner": "Administrator", 
- "query": "select\n    po_item.item_code as \"Item Code:Link/Item:120\",\n\tpo_item.item_name as \"Item Name::120\",\n        po_item.item_group as \"Item Group:Link/Item Group:120\",\n\tpo_item.description as \"Description::150\",\n\tpo_item.qty as \"Qty:Float:100\",\n\tpo_item.uom as \"UOM:Link/UOM:80\",\n\tpo_item.base_rate as \"Rate:Currency:120\",\n\tpo_item.base_amount as \"Amount:Currency:120\",\n\tpo.name as \"Purchase Order:Link/Purchase Order:120\",\n\tpo.transaction_date as \"Transaction Date:Date:140\",\n\tpo.supplier as \"Supplier:Link/Supplier:130\",\n        sup.supplier_name as \"Supplier Name::150\",\n\tpo_item.project as \"Project:Link/Project:130\",\n\tifnull(po_item.received_qty, 0) as \"Received Qty:Float:120\",\n\tpo.company as \"Company:Link/Company:\"\nfrom\n\t`tabPurchase Order` po, `tabPurchase Order Item` po_item, `tabSupplier` sup\nwhere\n\tpo.name = po_item.parent and po.supplier = sup.name and po.docstatus = 1\norder by po.name desc", 
- "ref_doctype": "Purchase Order", 
- "report_name": "Item-wise Purchase History", 
- "report_type": "Query Report", 
+ "add_total_row": 1,
+ "creation": "2013-05-03 14:55:53",
+ "disable_prepared_report": 0,
+ "disabled": 0,
+ "docstatus": 0,
+ "doctype": "Report",
+ "idx": 5,
+ "is_standard": "Yes",
+ "modified": "2024-06-19 12:12:15.418799",
+ "modified_by": "Administrator",
+ "module": "Buying",
+ "name": "Item-wise Purchase History",
+ "owner": "Administrator",
+ "prepared_report": 0,
+ "ref_doctype": "Purchase Order",
+ "report_name": "Item-wise Purchase History",
+ "report_type": "Script Report",
  "roles": [
   {
    "role": "Stock User"
-  }, 
+  },
   {
    "role": "Purchase Manager"
-  }, 
+  },
   {
    "role": "Purchase User"
   }
- ]
+  ]
 }

erpnext/buying/report/item_wise_purchase_history/item_wise_purchase_history.py

@@ -0,0 +1,276 @@
+# Copyright (c) 2024, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+import frappe
+from frappe import _
+from frappe.utils import flt
+from frappe.utils.nestedset import get_descendants_of
+
+
+def execute(filters=None):
+	filters = frappe._dict(filters or {})
+	if filters.from_date > filters.to_date:
+		frappe.throw(_("From Date cannot be greater than To Date"))
+
+	columns = get_columns(filters)
+	data = get_data(filters)
+
+	chart_data = get_chart_data(data)
+
+	return columns, data, None, chart_data
+
+
+def get_columns(filters):
+	return [
+		{
+			"label": _("Item Code"),
+			"fieldtype": "Link",
+			"fieldname": "item_code",
+			"options": "Item",
+			"width": 120,
+		},
+		{
+			"label": _("Item Name"),
+			"fieldtype": "Data",
+			"fieldname": "item_name",
+			"width": 140,
+		},
+		{
+			"label": _("Item Group"),
+			"fieldtype": "Link",
+			"fieldname": "item_group",
+			"options": "Item Group",
+			"width": 120,
+		},
+		{
+			"label": _("Description"),
+			"fieldtype": "Data",
+			"fieldname": "description",
+			"width": 140,
+		},
+		{
+			"label": _("Quantity"),
+			"fieldtype": "Float",
+			"fieldname": "quantity",
+			"width": 120,
+		},
+		{
+			"label": _("UOM"),
+			"fieldtype": "Link",
+			"fieldname": "uom",
+			"options": "UOM",
+			"width": 90,
+		},
+		{
+			"label": _("Rate"),
+			"fieldname": "rate",
+			"fieldtype": "Currency",
+			"options": "currency",
+			"width": 120,
+		},
+		{
+			"label": _("Amount"),
+			"fieldname": "amount",
+			"fieldtype": "Currency",
+			"options": "currency",
+			"width": 120,
+		},
+		{
+			"label": _("Purchase Order"),
+			"fieldtype": "Link",
+			"fieldname": "purchase_order",
+			"options": "Purchase Order",
+			"width": 160,
+		},
+		{
+			"label": _("Transaction Date"),
+			"fieldtype": "Date",
+			"fieldname": "transaction_date",
+			"width": 110,
+		},
+		{
+			"label": _("Supplier"),
+			"fieldtype": "Link",
+			"fieldname": "supplier",
+			"options": "Supplier",
+			"width": 100,
+		},
+		{
+			"label": _("Supplier Name"),
+			"fieldtype": "Data",
+			"fieldname": "supplier_name",
+			"width": 140,
+		},
+		{
+			"label": _("Supplier Group"),
+			"fieldtype": "Link",
+			"fieldname": "supplier_group",
+			"options": "Supplier Group",
+			"width": 120,
+		},
+		{
+			"label": _("Project"),
+			"fieldtype": "Link",
+			"fieldname": "project",
+			"options": "Project",
+			"width": 100,
+		},
+		{
+			"label": _("Received Quantity"),
+			"fieldtype": "Float",
+			"fieldname": "received_qty",
+			"width": 150,
+		},
+		{
+			"label": _("Billed Amount"),
+			"fieldtype": "Currency",
+			"fieldname": "billed_amt",
+			"options": "currency",
+			"width": 120,
+		},
+		{
+			"label": _("Company"),
+			"fieldtype": "Link",
+			"fieldname": "company",
+			"options": "Company",
+			"width": 100,
+		},
+		{
+			"label": _("Currency"),
+			"fieldtype": "Link",
+			"fieldname": "currency",
+			"options": "Currency",
+			"hidden": 1,
+		},
+	]
+
+
+def get_data(filters):
+	data = []
+
+	company_list = get_descendants_of("Company", filters.get("company"))
+	company_list.append(filters.get("company"))
+
+	supplier_details = get_supplier_details()
+	item_details = get_item_details()
+	purchase_order_records = get_purchase_order_details(company_list, filters)
+
+	for record in purchase_order_records:
+		supplier_record = supplier_details.get(record.supplier)
+		item_record = item_details.get(record.item_code)
+		row = {
+			"item_code": record.get("item_code"),
+			"item_name": item_record.get("item_name"),
+			"item_group": item_record.get("item_group"),
+			"description": record.get("description"),
+			"quantity": record.get("qty"),
+			"uom": record.get("uom"),
+			"rate": record.get("base_rate"),
+			"amount": record.get("base_amount"),
+			"purchase_order": record.get("name"),
+			"transaction_date": record.get("transaction_date"),
+			"supplier": record.get("supplier"),
+			"supplier_name": supplier_record.get("supplier_name"),
+			"supplier_group": supplier_record.get("supplier_group"),
+			"project": record.get("project"),
+			"received_qty": flt(record.get("received_qty")),
+			"billed_amt": flt(record.get("billed_amt")),
+			"company": record.get("company"),
+		}
+		row["currency"] = frappe.get_cached_value("Company", row["company"], "default_currency")
+		data.append(row)
+
+	return data
+
+
+def get_supplier_details():
+	details = frappe.get_all("Supplier", fields=["name", "supplier_name", "supplier_group"])
+	supplier_details = {}
+	for d in details:
+		supplier_details.setdefault(
+			d.name,
+			frappe._dict({"supplier_name": d.supplier_name, "supplier_group": d.supplier_group}),
+		)
+	return supplier_details
+
+
+def get_item_details():
+	details = frappe.db.get_all("Item", fields=["name", "item_name", "item_group"])
+	item_details = {}
+	for d in details:
+		item_details.setdefault(d.name, frappe._dict({"item_name": d.item_name, "item_group": d.item_group}))
+	return item_details
+
+
+def get_purchase_order_details(company_list, filters):
+	db_po = frappe.qb.DocType("Purchase Order")
+	db_po_item = frappe.qb.DocType("Purchase Order Item")
+
+	query = (
+		frappe.qb.from_(db_po)
+		.inner_join(db_po_item)
+		.on(db_po_item.parent == db_po.name)
+		.select(
+			db_po.name,
+			db_po.supplier,
+			db_po.transaction_date,
+			db_po.project,
+			db_po.company,
+			db_po_item.item_code,
+			db_po_item.description,
+			db_po_item.qty,
+			db_po_item.uom,
+			db_po_item.base_rate,
+			db_po_item.base_amount,
+			db_po_item.received_qty,
+			(db_po_item.billed_amt * db_po.conversion_rate).as_("billed_amt"),
+		)
+		.where(db_po.docstatus == 1)
+		.where(db_po.company.isin(tuple(company_list)))
+	)
+
+	for field in ("item_code", "item_group"):
+		if filters.get(field):
+			query = query.where(db_po_item[field] == filters[field])
+
+	if filters.get("from_date"):
+		query = query.where(db_po.transaction_date >= filters.from_date)
+
+	if filters.get("to_date"):
+		query = query.where(db_po.transaction_date <= filters.to_date)
+
+	if filters.get("supplier"):
+		query = query.where(db_po.supplier == filters.supplier)
+
+	return query.run(as_dict=1)
+
+
+def get_chart_data(data):
+	item_wise_purchase_map = {}
+	labels, datapoints = [], []
+
+	for row in data:
+		item_key = row.get("item_code")
+
+		if item_key not in item_wise_purchase_map:
+			item_wise_purchase_map[item_key] = 0
+
+		item_wise_purchase_map[item_key] = flt(item_wise_purchase_map[item_key]) + flt(row.get("amount"))
+
+	item_wise_purchase_map = {
+		item: value
+		for item, value in (sorted(item_wise_purchase_map.items(), key=lambda i: i[1], reverse=True))
+	}
+
+	for key in item_wise_purchase_map:
+		labels.append(key)
+		datapoints.append(item_wise_purchase_map[key])
+
+	return {
+		"data": {
+			"labels": labels[:30],  # show max of 30 items in chart
+			"datasets": [{"name": _("Total Purchase Amount"), "values": datapoints[:30]}],
+		},
+		"type": "bar",
+		"fieldtype": "Currency",
+	}

erpnext/buying/report/purchase_order_analysis/purchase_order_analysis.py

@@ -39,16 +39,17 @@ def validate_filters(filters):
 def get_data(filters):
 	po = frappe.qb.DocType("Purchase Order")
 	po_item = frappe.qb.DocType("Purchase Order Item")
-	pi = frappe.qb.DocType("Purchase Invoice")
 	pi_item = frappe.qb.DocType("Purchase Invoice Item")
+	pr_item = frappe.qb.DocType("Purchase Receipt Item")
 
 	query = (
 		frappe.qb.from_(po)
-		.from_(po_item)
+		.inner_join(po_item)
+		.on(po_item.parent == po.name)
 		.left_join(pi_item)
-		.on(pi_item.po_detail == po_item.name)
-		.left_join(pi)
-		.on(pi.name == pi_item.parent)
+		.on((pi_item.po_detail == po_item.name) & (pi_item.docstatus == 1))
+		.left_join(pr_item)
+		.on((pr_item.purchase_order_item == po_item.name) & (pr_item.docstatus == 1))
 		.select(
 			po.transaction_date.as_("date"),
 			po_item.schedule_date.as_("required_date"),
@@ -62,7 +63,7 @@ def get_data(filters):
 			(po_item.qty - po_item.received_qty).as_("pending_qty"),
 			Sum(IfNull(pi_item.qty, 0)).as_("billed_qty"),
 			po_item.base_amount.as_("amount"),
-			(po_item.received_qty * po_item.base_rate).as_("received_qty_amount"),
+			(pr_item.base_amount).as_("received_qty_amount"),
 			(po_item.billed_amt * IfNull(po.conversion_rate, 1)).as_("billed_amount"),
 			(po_item.base_amount - (po_item.billed_amt * IfNull(po.conversion_rate, 1))).as_(
 				"pending_amount"
@@ -72,7 +73,6 @@ def get_data(filters):
 			po_item.name,
 		)
 		.where((po_item.parent == po.name) & (po.status.notin(("Stopped", "Closed"))) & (po.docstatus == 1))
-		.where(pi.docstatus == 1)
 		.groupby(po_item.name)
 		.orderby(po.transaction_date)
 	)

erpnext/buying/utils.py

@@ -14,6 +14,9 @@ from erpnext.stock.doctype.item.item import get_last_purchase_details, validate_
 def update_last_purchase_rate(doc, is_submit) -> None:
 	"""updates last_purchase_rate in item table for each item"""
 
+	if doc.get("is_internal_supplier"):
+		return
+
 	this_purchase_date = getdate(doc.get("posting_date") or doc.get("transaction_date"))
 
 	for d in doc.get("items"):

erpnext/controllers/accounts_controller.py

@@ -85,7 +85,6 @@ force_item_fields = (
 	"brand",
 	"stock_uom",
 	"is_fixed_asset",
-	"item_tax_rate",
 	"pricing_rules",
 	"weight_per_unit",
 	"weight_uom",
@@ -234,7 +233,7 @@ class AccountsController(TransactionBase):
 						).format(
 							frappe.bold(document_type),
 							get_link_to_form(self.doctype, self.get("return_against")),
-							frappe.bold("Update Outstanding for Self"),
+							frappe.bold(_("Update Outstanding for Self")),
 							get_link_to_form("Payment Reconciliation", "Payment Reconciliation"),
 						)
 					)
@@ -743,7 +742,6 @@ 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:
@@ -753,7 +751,10 @@ 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
@@ -1333,6 +1334,12 @@ 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.
@@ -1961,7 +1968,9 @@ class AccountsController(TransactionBase):
 
 	def raise_missing_debit_credit_account_error(self, party_type, party):
 		"""Raise an error if debit to/credit to account does not exist."""
-		db_or_cr = frappe.bold("Debit To") if self.doctype == "Sales Invoice" else frappe.bold("Credit To")
+		db_or_cr = (
+			frappe.bold(_("Debit To")) if self.doctype == "Sales Invoice" else frappe.bold(_("Credit To"))
+		)
 		rec_or_pay = "Receivable" if self.doctype == "Sales Invoice" else "Payable"
 
 		link_to_party = frappe.utils.get_link_to_form(party_type, party)
@@ -2432,6 +2441,15 @@ 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
@@ -2489,16 +2507,12 @@ class AccountsController(TransactionBase):
 
 	@frappe.whitelist()
 	def repost_accounting_entries(self):
-		if self.repost_required:
-			repost_ledger = frappe.new_doc("Repost Accounting Ledger")
-			repost_ledger.company = self.company
-			repost_ledger.append("vouchers", {"voucher_type": self.doctype, "voucher_no": self.name})
-			repost_ledger.flags.ignore_permissions = True
-			repost_ledger.insert()
-			repost_ledger.submit()
-			self.db_set("repost_required", 0)
-		else:
-			frappe.throw(_("No updates pending for reposting"))
+		repost_ledger = frappe.new_doc("Repost Accounting Ledger")
+		repost_ledger.company = self.company
+		repost_ledger.append("vouchers", {"voucher_type": self.doctype, "voucher_no": self.name})
+		repost_ledger.flags.ignore_permissions = True
+		repost_ledger.insert()
+		repost_ledger.submit()
 
 
 @frappe.whitelist()
@@ -3079,9 +3093,9 @@ def set_order_defaults(parent_doctype, parent_doctype_name, child_doctype, child
 		child_item.warehouse = get_item_warehouse(item, p_doc, overwrite_warehouse=True)
 		if not child_item.warehouse:
 			frappe.throw(
-				_("Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.").format(
-					frappe.bold("default warehouse"), frappe.bold(item.item_code)
-				)
+				_(
+					"Cannot find a default warehouse for item {0}. Please set one in the Item Master or in Stock Settings."
+				).format(frappe.bold(item.item_code))
 			)
 
 	set_child_tax_template_and_map(item, child_item, p_doc)

erpnext/controllers/buying_controller.py

@@ -314,18 +314,22 @@ class BuyingController(SubcontractingController):
 						get_conversion_factor(item.item_code, item.uom).get("conversion_factor") or 1.0
 					)
 
+				net_rate = item.base_net_amount
+				if item.sales_incoming_rate:  # for internal transfer
+					net_rate = item.qty * item.sales_incoming_rate
+
 				qty_in_stock_uom = flt(item.qty * item.conversion_factor)
 				if self.get("is_old_subcontracting_flow"):
 					item.rm_supp_cost = self.get_supplied_items_cost(item.name, reset_outgoing_rate)
 					item.valuation_rate = (
-						item.base_net_amount
+						net_rate
 						+ item.item_tax_amount
 						+ item.rm_supp_cost
 						+ flt(item.landed_cost_voucher_amount)
 					) / qty_in_stock_uom
 				else:
 					item.valuation_rate = (
-						item.base_net_amount
+						net_rate
 						+ item.item_tax_amount
 						+ flt(item.landed_cost_voucher_amount)
 						+ flt(item.get("rate_difference_with_purchase_invoice"))
@@ -336,72 +340,88 @@ class BuyingController(SubcontractingController):
 		update_regional_item_valuation_rate(self)
 
 	def set_incoming_rate(self):
-		if self.doctype not in ("Purchase Receipt", "Purchase Invoice", "Purchase Order"):
+		"""
+		Override item rate with incoming rate for internal stock transfer
+		"""
+		if self.doctype not in ("Purchase Receipt", "Purchase Invoice"):
+			return
+
+		if not (self.doctype == "Purchase Receipt" or self.get("update_stock")):
+			return
+
+		if cint(self.get("is_return")):
+			# Get outgoing rate based on original item cost based on valuation method
 			return
 
 		if not self.is_internal_transfer():
 			return
 
+		allow_at_arms_length_price = frappe.get_cached_value(
+			"Stock Settings", None, "allow_internal_transfer_at_arms_length_price"
+		)
+		if allow_at_arms_length_price:
+			return
+
+		self.set_sales_incoming_rate_for_internal_transfer()
+
+		for d in self.get("items"):
+			d.discount_percentage = 0.0
+			d.discount_amount = 0.0
+			d.margin_rate_or_amount = 0.0
+
+			if d.rate == d.sales_incoming_rate:
+				continue
+
+			d.rate = d.sales_incoming_rate
+			frappe.msgprint(
+				_(
+					"Row {0}: Item rate has been updated as per valuation rate since its an internal stock transfer"
+				).format(d.idx),
+				alert=1,
+			)
+
+	def set_sales_incoming_rate_for_internal_transfer(self):
+		"""
+		Set incoming rate from the sales transaction against which the
+		purchase is made (internal transfer)
+		"""
 		ref_doctype_map = {
-			"Purchase Order": "Sales Order Item",
 			"Purchase Receipt": "Delivery Note Item",
 			"Purchase Invoice": "Sales Invoice Item",
 		}
 
 		ref_doctype = ref_doctype_map.get(self.doctype)
-		items = self.get("items")
-		for d in items:
-			if not cint(self.get("is_return")):
-				# Get outgoing rate based on original item cost based on valuation method
+		for d in self.get("items"):
+			if not d.get(frappe.scrub(ref_doctype)):
+				posting_time = self.get("posting_time")
+				if not posting_time:
+					posting_time = nowtime()
 
-				if not d.get(frappe.scrub(ref_doctype)):
-					posting_time = self.get("posting_time")
-					if not posting_time and self.doctype == "Purchase Order":
-						posting_time = nowtime()
+				outgoing_rate = get_incoming_rate(
+					{
+						"item_code": d.item_code,
+						"warehouse": d.get("from_warehouse"),
+						"posting_date": self.get("posting_date") or self.get("transaction_date"),
+						"posting_time": posting_time,
+						"qty": -1 * flt(d.get("stock_qty")),
+						"serial_and_batch_bundle": d.get("serial_and_batch_bundle"),
+						"company": self.company,
+						"voucher_type": self.doctype,
+						"voucher_no": self.name,
+						"allow_zero_valuation": d.get("allow_zero_valuation"),
+						"voucher_detail_no": d.name,
+					},
+					raise_error_if_no_rate=False,
+				)
 
-					outgoing_rate = get_incoming_rate(
-						{
-							"item_code": d.item_code,
-							"warehouse": d.get("from_warehouse"),
-							"posting_date": self.get("posting_date") or self.get("transaction_date"),
-							"posting_time": posting_time,
-							"qty": -1 * flt(d.get("stock_qty")),
-							"serial_and_batch_bundle": d.get("serial_and_batch_bundle"),
-							"company": self.company,
-							"voucher_type": self.doctype,
-							"voucher_no": self.name,
-							"allow_zero_valuation": d.get("allow_zero_valuation"),
-							"voucher_detail_no": d.name,
-						},
-						raise_error_if_no_rate=False,
-					)
-
-					rate = flt(outgoing_rate * (d.conversion_factor or 1), d.precision("rate"))
-				else:
-					field = (
-						"incoming_rate"
-						if self.get("is_internal_supplier") and not self.doctype == "Purchase Order"
-						else "rate"
-					)
-					rate = flt(
-						frappe.db.get_value(ref_doctype, d.get(frappe.scrub(ref_doctype)), field)
-						* (d.conversion_factor or 1),
-						d.precision("rate"),
-					)
-
-				if self.is_internal_transfer():
-					if self.doctype == "Purchase Receipt" or self.get("update_stock"):
-						if rate != d.rate:
-							d.rate = rate
-							frappe.msgprint(
-								_(
-									"Row {0}: Item rate has been updated as per valuation rate since its an internal stock transfer"
-								).format(d.idx),
-								alert=1,
-							)
-						d.discount_percentage = 0.0
-						d.discount_amount = 0.0
-						d.margin_rate_or_amount = 0.0
+				d.sales_incoming_rate = flt(outgoing_rate * (d.conversion_factor or 1), d.precision("rate"))
+			else:
+				field = "incoming_rate" if self.get("is_internal_supplier") else "rate"
+				d.sales_incoming_rate = flt(
+					frappe.db.get_value(ref_doctype, d.get(frappe.scrub(ref_doctype)), field)
+					* (d.conversion_factor or 1),
+					d.precision("rate"),
+				)
 
 	def validate_for_subcontracting(self):
 		if self.is_subcontracted and self.get("is_old_subcontracting_flow"):
@@ -541,7 +561,9 @@ class BuyingController(SubcontractingController):
 							"actual_qty": flt(pr_qty),
 							"serial_and_batch_bundle": (
 								d.serial_and_batch_bundle
-								if not self.is_internal_transfer() or self.is_return
+								if not self.is_internal_transfer()
+								or self.is_return
+								or (self.is_internal_transfer() and self.docstatus == 2)
 								else self.get_package_for_target_warehouse(
 									d, type_of_transaction=type_of_transaction
 								)
@@ -564,11 +586,9 @@ class BuyingController(SubcontractingController):
 						if d.from_warehouse:
 							sle.dependant_sle_voucher_detail_no = d.name
 					else:
-						val_rate_db_precision = 6 if cint(self.precision("valuation_rate", d)) <= 6 else 9
-						incoming_rate = flt(d.valuation_rate, val_rate_db_precision)
 						sle.update(
 							{
-								"incoming_rate": incoming_rate,
+								"incoming_rate": d.valuation_rate,
 								"recalculate_rate": 1
 								if (self.is_subcontracted and (d.bom or d.get("fg_item"))) or d.from_warehouse
 								else 0,
@@ -580,6 +600,14 @@ class BuyingController(SubcontractingController):
 						(not cint(self.is_return) and self.docstatus == 2)
 						or (cint(self.is_return) and self.docstatus == 1)
 					):
+						serial_and_batch_bundle = None
+						if self.is_internal_transfer() and self.docstatus == 2:
+							serial_and_batch_bundle = frappe.db.get_value(
+								"Stock Ledger Entry",
+								{"voucher_detail_no": d.name, "warehouse": d.warehouse},
+								"serial_and_batch_bundle",
+							)
+
 						from_warehouse_sle = self.get_sl_entries(
 							d,
 							{
@@ -589,7 +617,7 @@ class BuyingController(SubcontractingController):
 								"serial_and_batch_bundle": (
 									self.get_package_for_target_warehouse(d, d.from_warehouse, "Inward")
 									if self.is_internal_transfer() and self.is_return
-									else None
+									else serial_and_batch_bundle
 								),
 							},
 						)
@@ -661,9 +689,11 @@ class BuyingController(SubcontractingController):
 		if self.doctype in ["Purchase Receipt", "Purchase Invoice"]:
 			self.process_fixed_asset()
 
-		if self.doctype in ["Purchase Order", "Purchase Receipt"] and not frappe.db.get_single_value(
-			"Buying Settings", "disable_last_purchase_rate"
-		):
+		if self.doctype in [
+			"Purchase Order",
+			"Purchase Receipt",
+			"Purchase Invoice",
+		] and not frappe.db.get_single_value("Buying Settings", "disable_last_purchase_rate"):
 			update_last_purchase_rate(self, is_submit=1)
 
 	def on_cancel(self):

erpnext/controllers/item_variant.py

@@ -41,7 +41,8 @@ def get_variant(template, args=None, variant=None, manufacturer=None, manufactur
 	if isinstance(args, str):
 		args = json.loads(args)
 
-	if not args:
+	attribute_args = {k: v for k, v in args.items() if k != "use_template_image"}
+	if not attribute_args:
 		frappe.throw(_("Please specify at least one attribute in the Attributes table"))
 
 	return find_variant(template, args, variant)
@@ -149,7 +150,7 @@ def validate_item_attribute_value(attributes_list, attribute, attribute_value, i
 			)
 			msg += "<br>" + _(
 				"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings."
-			).format(frappe.bold("Allow Rename Attribute Value"))
+			).format(frappe.bold(_("Allow Rename Attribute Value")))
 
 			frappe.throw(msg, InvalidItemAttributeValueError, title=_("Edit Not Allowed"))
 
@@ -197,7 +198,8 @@ def find_variant(template, args, variant_item_code=None):
 
 
 @frappe.whitelist()
-def create_variant(item, args):
+def create_variant(item, args, use_template_image=False):
+	use_template_image = frappe.parse_json(use_template_image)
 	if isinstance(args, str):
 		args = json.loads(args)
 
@@ -211,13 +213,18 @@ def create_variant(item, args):
 
 	variant.set("attributes", variant_attributes)
 	copy_attributes_to_variant(template, variant)
+
+	if use_template_image and template.image:
+		variant.image = template.image
+
 	make_variant_item_code(template.item_code, template.item_name, variant)
 
 	return variant
 
 
 @frappe.whitelist()
-def enqueue_multiple_variant_creation(item, args):
+def enqueue_multiple_variant_creation(item, args, use_template_image=False):
+	use_template_image = frappe.parse_json(use_template_image)
 	# There can be innumerable attribute combinations, enqueue
 	if isinstance(args, str):
 		variants = json.loads(args)
@@ -228,27 +235,31 @@ def enqueue_multiple_variant_creation(item, args):
 		frappe.throw(_("Please do not create more than 500 items at a time"))
 		return
 	if total_variants < 10:
-		return create_multiple_variants(item, args)
+		return create_multiple_variants(item, args, use_template_image)
 	else:
 		frappe.enqueue(
 			"erpnext.controllers.item_variant.create_multiple_variants",
 			item=item,
 			args=args,
+			use_template_image=use_template_image,
 			now=frappe.flags.in_test,
 		)
 		return "queued"
 
 
-def create_multiple_variants(item, args):
+def create_multiple_variants(item, args, use_template_image=False):
 	count = 0
 	if isinstance(args, str):
 		args = json.loads(args)
 
+	template_item = frappe.get_doc("Item", item)
 	args_set = generate_keyed_value_combinations(args)
 
 	for attribute_values in args_set:
 		if not get_variant(item, args=attribute_values):
 			variant = create_variant(item, attribute_values)
+			if use_template_image and template_item.image:
+				variant.image = template_item.image
 			variant.save()
 			count += 1
 

erpnext/controllers/sales_and_purchase_return.py

@@ -319,6 +319,8 @@ def make_return_doc(doctype: str, source_name: str, target_doc=None, return_agai
 	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":
@@ -478,6 +480,7 @@ def make_return_doc(doctype: str, source_name: str, target_doc=None, return_agai
 
 	def update_item(source_doc, target_doc, source_parent):
 		target_doc.qty = -1 * source_doc.qty
+		target_doc.pricing_rules = None
 		if doctype in ["Purchase Receipt", "Subcontracting Receipt"]:
 			returned_qty_map = get_returned_qty_map_for_row(
 				source_parent.name, source_parent.supplier, source_doc.name, doctype
@@ -640,6 +643,12 @@ def make_return_doc(doctype: str, source_name: str, target_doc=None, return_agai
 	def update_terms(source_doc, target_doc, source_parent):
 		target_doc.payment_amount = -source_doc.payment_amount
 
+	def item_condition(doc):
+		if return_against_rejected_qty:
+			return doc.rejected_qty
+
+		return doc.qty
+
 	doclist = get_mapped_doc(
 		doctype,
 		source_name,
@@ -654,6 +663,7 @@ def make_return_doc(doctype: str, source_name: str, target_doc=None, return_agai
 				"doctype": doctype + " Item",
 				"field_map": {"serial_no": "serial_no", "batch_no": "batch_no", "bom": "bom"},
 				"postprocess": update_item,
+				"condition": item_condition,
 			},
 			"Payment Schedule": {"doctype": "Payment Schedule", "postprocess": update_terms},
 		},