chore(release): Bumped to Version 15.48.3

## [15.48.3](https://github.com/frappe/erpnext/compare/v15.48.2...v15.48.3) (2025-01-13)

### Bug Fixes

* delivery_document_no column issue ([47a622d](47a622d0cb))
* incorrect valuation rate for PI based revaluation ([23b846e](23b846ef39))
* test case ([b75c736](b75c7364d6))

.github/helper/documentation.py

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

.github/helper/install.sh

@@ -6,7 +6,7 @@ cd ~ || exit
 
 sudo apt update
 sudo apt remove mysql-server mysql-client
-sudo apt install libcups2-dev redis-server mariadb-client-10.6
+sudo apt install libcups2-dev redis-server mariadb-client
 
 pip install frappe-bench
 
@@ -44,13 +44,9 @@ fi
 
 
 install_whktml() {
-    if [ "$(lsb_release -rs)" = "22.04" ]; then
-        wget -O /tmp/wkhtmltox.deb https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
-        sudo apt install /tmp/wkhtmltox.deb
-    else
-        echo "Please update this script to support wkhtmltopdf for $(lsb_release -ds)"
-        exit 1
-    fi
+    wget -O /tmp/wkhtmltox.deb https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
+    sudo apt install /tmp/wkhtmltox.deb
+
 }
 install_whktml &
 wkpid=$!

erpnext/__init__.py

@@ -4,7 +4,7 @@ import inspect
 import frappe
 from frappe.utils.user import is_website_user
 
-__version__ = "15.43.2"
+__version__ = "15.48.3"
 
 
 def get_default_company(user=None):

erpnext/accounts/doctype/account/account.json

@@ -128,7 +128,7 @@
    "description": "Rate at which this tax is applied",
    "fieldname": "tax_rate",
    "fieldtype": "Float",
-   "label": "Rate",
+   "label": "Tax Rate",
    "oldfieldname": "tax_rate",
    "oldfieldtype": "Currency"
   },

erpnext/accounts/doctype/account/account_tree.js

@@ -237,19 +237,22 @@ frappe.treeview_settings["Account"] = {
 	},
 	post_render: function (treeview) {
 		frappe.treeview_settings["Account"].treeview["tree"] = treeview.tree;
-		treeview.page.set_primary_action(
-			__("New"),
-			function () {
-				let root_company = treeview.page.fields_dict.root_company.get_value();
-
-				if (root_company) {
-					frappe.throw(__("Please add the account to root level Company - {0}"), [root_company]);
-				} else {
-					treeview.new_node();
-				}
-			},
-			"add"
-		);
+		if (treeview.can_create) {
+			treeview.page.set_primary_action(
+				__("New"),
+				function () {
+					let root_company = treeview.page.fields_dict.root_company.get_value();
+					if (root_company) {
+						frappe.throw(__("Please add the account to root level Company - {0}"), [
+							root_company,
+						]);
+					} else {
+						treeview.new_node();
+					}
+				},
+				"add"
+			);
+		}
 	},
 	toolbar: [
 		{

erpnext/accounts/doctype/advance_taxes_and_charges/advance_taxes_and_charges.json

@@ -101,7 +101,7 @@
    "fieldname": "rate",
    "fieldtype": "Float",
    "in_list_view": 1,
-   "label": "Rate",
+   "label": "Tax Rate",
    "oldfieldname": "rate",
    "oldfieldtype": "Currency"
   },

erpnext/accounts/doctype/bank_account/bank_account.py

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

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -117,9 +117,9 @@ class BankClearance(Document):
 					)
 
 				else:
-					frappe.db.set_value(
-						d.payment_document, d.payment_entry, "clearance_date", d.clearance_date
-					)
+					# using db_set to trigger notification
+					payment_entry = frappe.get_doc(d.payment_document, d.payment_entry)
+					payment_entry.db_set("clearance_date", d.clearance_date)
 
 				clearance_date_updated = True
 

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.js

@@ -120,6 +120,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 				args: {
 					bank_account: frm.doc.bank_account,
 					till_date: frappe.datetime.add_days(frm.doc.bank_statement_from_date, -1),
+					company: frm.doc.company,
 				},
 				callback: (response) => {
 					frm.set_value("account_opening_balance", response.message);
@@ -135,6 +136,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 				args: {
 					bank_account: frm.doc.bank_account,
 					till_date: frm.doc.bank_statement_to_date,
+					company: frm.doc.company,
 				},
 				callback: (response) => {
 					frm.cleared_balance = response.message;

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -12,6 +12,7 @@ from frappe.utils import cint, flt
 
 from erpnext import get_default_cost_center
 from erpnext.accounts.doctype.bank_transaction.bank_transaction import get_total_allocated_amount
+from erpnext.accounts.party import get_party_account
 from erpnext.accounts.report.bank_reconciliation_statement.bank_reconciliation_statement import (
 	get_amounts_not_reflected_in_system,
 	get_entries,
@@ -78,10 +79,17 @@ def get_bank_transactions(bank_account, from_date=None, to_date=None):
 
 
 @frappe.whitelist()
-def get_account_balance(bank_account, till_date):
+def get_account_balance(bank_account, till_date, company):
 	# returns account balance till the specified date
 	account = frappe.db.get_value("Bank Account", bank_account, "account")
-	filters = frappe._dict({"account": account, "report_date": till_date, "include_pos_transactions": 1})
+	filters = frappe._dict(
+		{
+			"account": account,
+			"report_date": till_date,
+			"include_pos_transactions": 1,
+			"company": company,
+		}
+	)
 	data = get_entries(filters)
 
 	balance_as_per_system = get_balance_on(filters["account"], filters["report_date"])
@@ -93,11 +101,7 @@ def get_account_balance(bank_account, till_date):
 
 	amounts_not_reflected_in_system = get_amounts_not_reflected_in_system(filters)
 
-	bank_bal = (
-		flt(balance_as_per_system) - flt(total_debit) + flt(total_credit) + amounts_not_reflected_in_system
-	)
-
-	return bank_bal
+	return flt(balance_as_per_system) - flt(total_debit) + flt(total_credit) + amounts_not_reflected_in_system
 
 
 @frappe.whitelist()
@@ -304,54 +308,56 @@ def create_payment_entry_bts(
 	bank_transaction = frappe.db.get_values(
 		"Bank Transaction",
 		bank_transaction_name,
-		fieldname=["name", "unallocated_amount", "deposit", "bank_account"],
+		fieldname=["name", "unallocated_amount", "deposit", "bank_account", "currency"],
 		as_dict=True,
 	)[0]
-	paid_amount = bank_transaction.unallocated_amount
+
 	payment_type = "Receive" if bank_transaction.deposit > 0.0 else "Pay"
 
-	company_account = frappe.get_value("Bank Account", bank_transaction.bank_account, "account")
-	company = frappe.get_value("Account", company_account, "company")
-	payment_entry_dict = {
-		"company": company,
-		"payment_type": payment_type,
-		"reference_no": reference_number,
-		"reference_date": reference_date,
-		"party_type": party_type,
-		"party": party,
-		"posting_date": posting_date,
-		"paid_amount": paid_amount,
-		"received_amount": paid_amount,
-	}
-	payment_entry = frappe.new_doc("Payment Entry")
+	bank_account = frappe.get_cached_value("Bank Account", bank_transaction.bank_account, "account")
+	company = frappe.get_cached_value("Account", bank_account, "company")
+	party_account = get_party_account(party_type, party, company)
 
-	payment_entry.update(payment_entry_dict)
+	bank_currency = bank_transaction.currency
+	party_currency = frappe.get_cached_value("Account", party_account, "account_currency")
 
-	if mode_of_payment:
-		payment_entry.mode_of_payment = mode_of_payment
-	if project:
-		payment_entry.project = project
-	if cost_center:
-		payment_entry.cost_center = cost_center
-	if payment_type == "Receive":
-		payment_entry.paid_to = company_account
-	else:
-		payment_entry.paid_from = company_account
+	exc_rate = get_exchange_rate(bank_currency, party_currency, posting_date)
 
-	payment_entry.validate()
+	amt_in_bank_acc_currency = bank_transaction.unallocated_amount
+	amount_in_party_currency = bank_transaction.unallocated_amount * exc_rate
+
+	pe = frappe.new_doc("Payment Entry")
+	pe.payment_type = payment_type
+	pe.company = company
+	pe.reference_no = reference_number
+	pe.reference_date = reference_date
+	pe.party_type = party_type
+	pe.party = party
+	pe.posting_date = posting_date
+	pe.paid_from = party_account if payment_type == "Receive" else bank_account
+	pe.paid_to = party_account if payment_type == "Pay" else bank_account
+	pe.paid_from_account_currency = party_currency if payment_type == "Receive" else bank_currency
+	pe.paid_to_account_currency = party_currency if payment_type == "Pay" else bank_currency
+	pe.paid_amount = amount_in_party_currency if payment_type == "Receive" else amt_in_bank_acc_currency
+	pe.received_amount = amount_in_party_currency if payment_type == "Pay" else amt_in_bank_acc_currency
+	pe.mode_of_payment = mode_of_payment
+	pe.project = project
+	pe.cost_center = cost_center
+
+	pe.validate()
 
 	if allow_edit:
-		return payment_entry
+		return pe
 
-	payment_entry.insert()
+	pe.insert()
+	pe.submit()
 
-	payment_entry.submit()
 	vouchers = json.dumps(
 		[
 			{
 				"payment_doctype": "Payment Entry",
-				"payment_name": payment_entry.name,
-				"amount": paid_amount,
+				"payment_name": pe.name,
+				"amount": amt_in_bank_acc_currency,
 			}
 		]
 	)
@@ -480,8 +486,12 @@ def get_linked_payments(
 def subtract_allocations(gl_account, vouchers):
 	"Look up & subtract any existing Bank Transaction allocations"
 	copied = []
+
+	voucher_docs = [(voucher.get("doctype"), voucher.get("name")) for voucher in vouchers]
+	voucher_allocated_amounts = get_total_allocated_amount(voucher_docs)
+
 	for voucher in vouchers:
-		rows = get_total_allocated_amount(voucher.get("doctype"), voucher.get("name"))
+		rows = voucher_allocated_amounts.get((voucher.get("doctype"), voucher.get("name"))) or []
 		filtered_row = list(filter(lambda row: row.get("gl_account") == gl_account, rows))
 
 		if amount := None if not filtered_row else filtered_row[0]["total"]:
@@ -719,7 +729,7 @@ def get_pe_matching_query(
 			(ref_rank + amount_rank + party_rank + 1).as_("rank"),
 			ConstantColumn("Payment Entry").as_("doctype"),
 			pe.name,
-			pe.paid_amount_after_tax.as_("paid_amount"),
+			pe.base_paid_amount_after_tax.as_("paid_amount"),
 			pe.reference_no,
 			pe.reference_date,
 			pe.party,

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -154,10 +154,16 @@ class BankTransaction(Document):
 		"""
 		remaining_amount = self.unallocated_amount
 		to_remove = []
+		payment_entry_docs = [(pe.payment_document, pe.payment_entry) for pe in self.payment_entries]
+		pe_bt_allocations = get_total_allocated_amount(payment_entry_docs)
+
 		for payment_entry in self.payment_entries:
 			if payment_entry.allocated_amount == 0.0:
 				unallocated_amount, should_clear, latest_transaction = get_clearance_details(
-					self, payment_entry
+					self,
+					payment_entry,
+					pe_bt_allocations.get((payment_entry.payment_document, payment_entry.payment_entry))
+					or [],
 				)
 
 				if 0.0 == unallocated_amount:
@@ -208,13 +214,17 @@ class BankTransaction(Document):
 		if self.party_type and self.party:
 			return
 
-		result = AutoMatchParty(
-			bank_party_account_number=self.bank_party_account_number,
-			bank_party_iban=self.bank_party_iban,
-			bank_party_name=self.bank_party_name,
-			description=self.description,
-			deposit=self.deposit,
-		).match()
+		result = None
+		try:
+			result = AutoMatchParty(
+				bank_party_account_number=self.bank_party_account_number,
+				bank_party_iban=self.bank_party_iban,
+				bank_party_name=self.bank_party_name,
+				description=self.description,
+				deposit=self.deposit,
+			).match()
+		except Exception:
+			frappe.log_error(title=_("Error in party matching for Bank Transaction {0}").format(self.name))
 
 		if not result:
 			return
@@ -228,7 +238,7 @@ def get_doctypes_for_bank_reconciliation():
 	return frappe.get_hooks("bank_reconciliation_doctypes")
 
 
-def get_clearance_details(transaction, payment_entry):
+def get_clearance_details(transaction, payment_entry, bt_allocations):
 	"""
 	There should only be one bank gle for a voucher.
 	Could be none for a Bank Transaction.
@@ -237,7 +247,6 @@ def get_clearance_details(transaction, payment_entry):
 	"""
 	gl_bank_account = frappe.db.get_value("Bank Account", transaction.bank_account, "account")
 	gles = get_related_bank_gl_entries(payment_entry.payment_document, payment_entry.payment_entry)
-	bt_allocations = get_total_allocated_amount(payment_entry.payment_document, payment_entry.payment_entry)
 
 	unallocated_amount = min(
 		transaction.unallocated_amount,
@@ -290,44 +299,52 @@ def get_related_bank_gl_entries(doctype, docname):
 	)
 
 
-def get_total_allocated_amount(doctype, docname):
+def get_total_allocated_amount(docs):
 	"""
 	Gets the sum of allocations for a voucher on each bank GL account
 	along with the latest bank transaction name & date
 	NOTE: query may also include just saved vouchers/payments but with zero allocated_amount
 	"""
+	if not docs:
+		return {}
+
 	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
 	result = frappe.db.sql(
 		"""
-		SELECT total, latest_name, latest_date, gl_account FROM (
+		SELECT total, latest_name, latest_date, gl_account, payment_document, payment_entry FROM (
 			SELECT
 				ROW_NUMBER() OVER w AS rownum,
-				SUM(btp.allocated_amount) OVER(PARTITION BY ba.account) AS total,
+				SUM(btp.allocated_amount) OVER(PARTITION BY ba.account, btp.payment_document, btp.payment_entry) AS total,
 				FIRST_VALUE(bt.name) OVER w AS latest_name,
 				FIRST_VALUE(bt.date) OVER w AS latest_date,
-				ba.account AS gl_account
+				ba.account AS gl_account,
+				btp.payment_document,
+				btp.payment_entry
 			FROM
 				`tabBank Transaction Payments` btp
 			LEFT JOIN `tabBank Transaction` bt ON bt.name=btp.parent
 			LEFT JOIN `tabBank Account` ba ON ba.name=bt.bank_account
 			WHERE
-				btp.payment_document = %(doctype)s
-				AND btp.payment_entry = %(docname)s
+				(btp.payment_document, btp.payment_entry) IN %(docs)s
 				AND bt.docstatus = 1
-			WINDOW w AS (PARTITION BY ba.account ORDER BY bt.date desc)
+			WINDOW w AS (PARTITION BY ba.account, btp.payment_document, btp.payment_entry ORDER BY bt.date DESC)
 		) temp
 		WHERE
 			rownum = 1
 		""",
-		dict(doctype=doctype, docname=docname),
+		dict(docs=docs),
 		as_dict=True,
 	)
+
+	payment_allocation_details = {}
 	for row in result:
 		# Why is this *sometimes* a byte string?
 		if isinstance(row["latest_name"], bytes):
 			row["latest_name"] = row["latest_name"].decode()
 		row["latest_date"] = frappe.utils.getdate(row["latest_date"])
-	return result
+		payment_allocation_details.setdefault((row["payment_document"], row["payment_entry"]), []).append(row)
+
+	return payment_allocation_details
 
 
 def get_paid_amount(payment_entry, currency, gl_bank_account):

erpnext/accounts/doctype/budget/budget.py

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

erpnext/accounts/doctype/dunning/dunning.json

@@ -19,16 +19,6 @@
   "currency",
   "column_break_11",
   "conversion_rate",
-  "address_and_contact_section",
-  "customer_address",
-  "address_display",
-  "contact_person",
-  "contact_display",
-  "column_break_16",
-  "company_address",
-  "company_address_display",
-  "contact_mobile",
-  "contact_email",
   "section_break_6",
   "dunning_type",
   "column_break_8",
@@ -56,7 +46,21 @@
   "income_account",
   "column_break_48",
   "cost_center",
-  "amended_from"
+  "amended_from",
+  "address_and_contact_tab",
+  "address_and_contact_section",
+  "customer_address",
+  "address_display",
+  "column_break_vodj",
+  "contact_person",
+  "contact_display",
+  "contact_mobile",
+  "contact_email",
+  "section_break_xban",
+  "column_break_16",
+  "company_address",
+  "company_address_display",
+  "column_break_lqmf"
  ],
  "fields": [
   {
@@ -178,10 +182,8 @@
    "label": "Rate of Interest (%) Yearly"
   },
   {
-   "collapsible": 1,
    "fieldname": "address_and_contact_section",
-   "fieldtype": "Section Break",
-   "label": "Address and Contact"
+   "fieldtype": "Section Break"
   },
   {
    "fieldname": "address_display",
@@ -377,11 +379,28 @@
   {
    "fieldname": "column_break_48",
    "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "address_and_contact_tab",
+   "fieldtype": "Tab Break",
+   "label": "Address & Contact"
+  },
+  {
+   "fieldname": "column_break_vodj",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "section_break_xban",
+   "fieldtype": "Section Break"
+  },
+  {
+   "fieldname": "column_break_lqmf",
+   "fieldtype": "Column Break"
   }
  ],
  "is_submittable": 1,
  "links": [],
- "modified": "2023-06-15 15:46:53.865712",
+ "modified": "2024-11-26 13:46:07.760867",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Dunning",
@@ -435,4 +454,4 @@
  "states": [],
  "title_field": "customer_name",
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/exchange_rate_revaluation/test_exchange_rate_revaluation.py

@@ -188,7 +188,7 @@ class TestExchangeRateRevaluation(AccountsTestMixin, FrappeTestCase):
 
 		pe = get_payment_entry(si.doctype, si.name)
 		pe.paid_amount = 95
-		pe.source_exchange_rate = 84.211
+		pe.source_exchange_rate = 84.2105
 		pe.received_amount = 8000
 		pe.references = []
 		pe.save().submit()
@@ -229,7 +229,7 @@ class TestExchangeRateRevaluation(AccountsTestMixin, FrappeTestCase):
 		row = next(x for x in je.accounts if x.account == self.debtors_usd)
 		self.assertEqual(flt(row.credit_in_account_currency, precision), 5.0)  # in USD
 		row = next(x for x in je.accounts if x.account != self.debtors_usd)
-		self.assertEqual(flt(row.debit_in_account_currency, precision), 421.06)  # in INR
+		self.assertEqual(flt(row.debit_in_account_currency, precision), 421.05)  # in INR
 
 		# total_debit and total_credit will be 0.0, as JV is posting only to account currency fields
 		self.assertEqual(flt(je.total_debit, precision), 0.0)

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -13,7 +13,11 @@ import erpnext
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_checks_for_pl_and_bs_accounts,
 )
-from erpnext.accounts.party import validate_party_frozen_disabled, validate_party_gle_currency
+from erpnext.accounts.party import (
+	validate_account_party_type,
+	validate_party_frozen_disabled,
+	validate_party_gle_currency,
+)
 from erpnext.accounts.utils import get_account_currency, get_fiscal_year
 from erpnext.exceptions import InvalidAccountCurrency
 
@@ -268,8 +272,12 @@ class GLEntry(Document):
 
 	def validate_party(self):
 		validate_party_frozen_disabled(self.party_type, self.party)
+		validate_account_party_type(self)
 
 	def validate_currency(self):
+		if self.is_cancelled:
+			return
+
 		company_currency = erpnext.get_company_currency(self.company)
 		account_currency = get_account_currency(self.account)
 

erpnext/accounts/doctype/gl_entry/test_gl_entry.py

@@ -79,3 +79,48 @@ class TestGLEntry(unittest.TestCase):
 			"SELECT current from tabSeries where name = %s", naming_series
 		)[0][0]
 		self.assertEqual(old_naming_series_current_value + 2, new_naming_series_current_value)
+
+	def test_validate_account_party_type(self):
+		jv = make_journal_entry(
+			"_Test Account Cost for Goods Sold - _TC",
+			"_Test Bank - _TC",
+			100,
+			"_Test Cost Center - _TC",
+			save=False,
+			submit=False,
+		)
+
+		for row in jv.accounts:
+			row.party_type = "Supplier"
+			break
+
+		jv.save()
+		try:
+			jv.submit()
+		except Exception as e:
+			self.assertEqual(
+				str(e),
+				"Party Type and Party can only be set for Receivable / Payable account_Test Account Cost for Goods Sold - _TC",
+			)
+
+		jv1 = make_journal_entry(
+			"_Test Account Cost for Goods Sold - _TC",
+			"_Test Bank - _TC",
+			100,
+			"_Test Cost Center - _TC",
+			save=False,
+			submit=False,
+		)
+
+		for row in jv.accounts:
+			row.party_type = "Customer"
+			break
+
+		jv1.save()
+		try:
+			jv1.submit()
+		except Exception as e:
+			self.assertEqual(
+				str(e),
+				"Party Type and Party can only be set for Receivable / Payable account_Test Account Cost for Goods Sold - _TC",
+			)

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -127,9 +127,6 @@ class JournalEntry(AccountsController):
 		self.set_amounts_in_company_currency()
 		self.validate_debit_credit_amount()
 		self.set_total_debit_credit()
-		# Do not validate while importing via data import
-		if not frappe.flags.in_import:
-			self.validate_total_debit_and_credit()
 
 		if not frappe.flags.is_reverse_depr_entry:
 			self.validate_against_jv()
@@ -184,6 +181,11 @@ class JournalEntry(AccountsController):
 		else:
 			return self._cancel()
 
+	def before_submit(self):
+		# Do not validate while importing via data import
+		if not frappe.flags.in_import:
+			self.validate_total_debit_and_credit()
+
 	def on_submit(self):
 		self.validate_cheque_info()
 		self.check_credit_limit()

erpnext/accounts/doctype/journal_entry/test_journal_entry.py

@@ -515,6 +515,55 @@ class TestJournalEntry(unittest.TestCase):
 				self.assertEqual(row.debit_in_account_currency, 100)
 				self.assertEqual(row.credit_in_account_currency, 100)
 
+	def test_toggle_debit_credit_if_negative(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 = frappe.new_doc("Journal Entry")
+		jv.posting_date = nowdate()
+		jv.company = "_Test Company"
+		jv.user_remark = "test"
+		jv.extend(
+			"accounts",
+			[
+				{
+					"account": "_Test Cash - _TC",
+					"debit": 100 * -1,
+					"debit_in_account_currency": 100 * -1,
+					"exchange_rate": 1,
+				},
+				{
+					"account": "_Test Bank - _TC",
+					"credit": 100 * -1,
+					"credit_in_account_currency": 100 * -1,
+					"exchange_rate": 1,
+				},
+			],
+		)
+
+		jv.flags.ignore_validate = True
+		jv.save()
+
+		self.assertEqual(len(jv.accounts), 2)
+
+		gl_map = jv.build_gl_map()
+
+		for row in gl_map:
+			if row.account == "_Test Cash - _TC":
+				self.assertEqual(row.debit, 100 * -1)
+				self.assertEqual(row.debit_in_account_currency, 100 * -1)
+				self.assertEqual(row.debit_in_transaction_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.credit, 100)
+				self.assertEqual(row.credit_in_account_currency, 100)
+				self.assertEqual(row.credit_in_transaction_currency, 100)
+
 	def test_transaction_exchange_rate_on_journals(self):
 		jv = make_journal_entry("_Test Bank - _TC", "_Test Receivable USD - _TC", 100, save=False)
 		jv.accounts[0].update({"debit_in_account_currency": 8500, "exchange_rate": 1})

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -27,6 +27,18 @@ frappe.ui.form.on("Payment Entry", {
 
 		erpnext.accounts.dimensions.setup_dimension_filters(frm, frm.doctype);
 
+		// project excluded in setup_dimension_filters
+		frm.set_query("project", function (doc) {
+			let filters = {
+				company: doc.company,
+			};
+			if (doc.party_type == "Customer") filters.customer = doc.party;
+			return {
+				query: "erpnext.controllers.queries.get_project_name",
+				filters,
+			};
+		});
+
 		if (frm.is_new()) {
 			set_default_party_type(frm);
 		}
@@ -185,6 +197,10 @@ frappe.ui.form.on("Payment Entry", {
 				filters: {
 					reference_doctype: row.reference_doctype,
 					reference_name: row.reference_name,
+					company: doc.company,
+					status: ["!=", "Paid"],
+					outstanding_amount: [">", 0], // for compatibility with old data
+					docstatus: 1,
 				},
 			};
 		});
@@ -320,11 +336,6 @@ frappe.ui.form.on("Payment Entry", {
 			"write_off_difference_amount",
 			frm.doc.difference_amount && frm.doc.party && frm.doc.total_allocated_amount > party_amount
 		);
-
-		frm.toggle_display(
-			"set_exchange_gain_loss",
-			frm.doc.paid_amount && frm.doc.received_amount && frm.doc.difference_amount
-		);
 	},
 
 	set_dynamic_labels: function (frm) {
@@ -1115,36 +1126,34 @@ frappe.ui.form.on("Payment Entry", {
 	},
 
 	set_unallocated_amount: function (frm) {
-		var unallocated_amount = 0;
-		var total_deductions = frappe.utils.sum(
-			$.map(frm.doc.deductions || [], function (d) {
-				return flt(d.amount);
-			})
-		);
+		let unallocated_amount = 0;
+		let deductions_to_consider = 0;
+
+		for (const row of frm.doc.deductions || []) {
+			if (!row.is_exchange_gain_loss) deductions_to_consider += flt(row.amount);
+		}
+		const included_taxes = get_included_taxes(frm);
 
 		if (frm.doc.party) {
 			if (
 				frm.doc.payment_type == "Receive" &&
-				frm.doc.base_total_allocated_amount < frm.doc.base_received_amount + total_deductions &&
-				frm.doc.total_allocated_amount <
-					frm.doc.paid_amount + total_deductions / frm.doc.source_exchange_rate
-			) {
-				unallocated_amount =
-					(frm.doc.base_received_amount +
-						total_deductions -
-						flt(frm.doc.base_total_taxes_and_charges) -
-						frm.doc.base_total_allocated_amount) /
-					frm.doc.source_exchange_rate;
-			} else if (
-				frm.doc.payment_type == "Pay" &&
-				frm.doc.base_total_allocated_amount < frm.doc.base_paid_amount - total_deductions &&
-				frm.doc.total_allocated_amount <
-					frm.doc.received_amount + total_deductions / frm.doc.target_exchange_rate
+				frm.doc.base_total_allocated_amount < frm.doc.base_paid_amount + deductions_to_consider
 			) {
 				unallocated_amount =
 					(frm.doc.base_paid_amount +
-						flt(frm.doc.base_total_taxes_and_charges) -
-						(total_deductions + frm.doc.base_total_allocated_amount)) /
+						deductions_to_consider -
+						frm.doc.base_total_allocated_amount -
+						included_taxes) /
+					frm.doc.source_exchange_rate;
+			} else if (
+				frm.doc.payment_type == "Pay" &&
+				frm.doc.base_total_allocated_amount < frm.doc.base_received_amount - deductions_to_consider
+			) {
+				unallocated_amount =
+					(frm.doc.base_received_amount -
+						deductions_to_consider -
+						frm.doc.base_total_allocated_amount -
+						included_taxes) /
 					frm.doc.target_exchange_rate;
 			}
 		}
@@ -1238,77 +1247,85 @@ frappe.ui.form.on("Payment Entry", {
 	},
 
 	write_off_difference_amount: function (frm) {
-		frm.events.set_deductions_entry(frm, "write_off_account");
+		frm.events.set_write_off_deduction(frm);
 	},
 
-	set_exchange_gain_loss: function (frm) {
-		frm.events.set_deductions_entry(frm, "exchange_gain_loss_account");
+	base_paid_amount: function (frm) {
+		frm.events.set_exchange_gain_loss_deduction(frm);
 	},
 
-	set_deductions_entry: function (frm, account) {
-		if (frm.doc.difference_amount) {
-			frappe.call({
-				method: "erpnext.accounts.doctype.payment_entry.payment_entry.get_company_defaults",
-				args: {
-					company: frm.doc.company,
-				},
-				callback: function (r, rt) {
-					if (r.message) {
-						const write_off_row = $.map(frm.doc["deductions"] || [], function (t) {
-							return t.account == r.message[account] ? t : null;
-						});
+	base_received_amount: function (frm) {
+		frm.events.set_exchange_gain_loss_deduction(frm);
+	},
 
-						const difference_amount = flt(
-							frm.doc.difference_amount,
-							precision("difference_amount")
-						);
+	set_exchange_gain_loss_deduction: async function (frm) {
+		// wait for allocate_party_amount_against_ref_docs to finish
+		await frappe.after_ajax();
+		const base_paid_amount = frm.doc.base_paid_amount || 0;
+		const base_received_amount = frm.doc.base_received_amount || 0;
+		const exchange_gain_loss = flt(
+			base_paid_amount - base_received_amount,
+			get_deduction_amount_precision()
+		);
 
-						const add_deductions = (details) => {
-							let row = null;
-							if (!write_off_row.length && difference_amount) {
-								row = frm.add_child("deductions");
-								row.account = details[account];
-								row.cost_center = details["cost_center"];
-							} else {
-								row = write_off_row[0];
-							}
-
-							if (row) {
-								row.amount = flt(row.amount) + difference_amount;
-							} else {
-								frappe.msgprint(__("No gain or loss in the exchange rate"));
-							}
-							refresh_field("deductions");
-						};
-
-						if (!r.message[account]) {
-							frappe.prompt(
-								{
-									label: __("Please Specify Account"),
-									fieldname: account,
-									fieldtype: "Link",
-									options: "Account",
-									get_query: () => ({
-										filters: {
-											company: frm.doc.company,
-										},
-									}),
-								},
-								(values) => {
-									const details = Object.assign({}, r.message, values);
-									add_deductions(details);
-								},
-								__(frappe.unscrub(account))
-							);
-						} else {
-							add_deductions(r.message);
-						}
-
-						frm.events.set_unallocated_amount(frm);
-					}
-				},
-			});
+		if (!exchange_gain_loss) {
+			frm.events.delete_exchange_gain_loss(frm);
+			return;
 		}
+
+		const account_fieldname = "exchange_gain_loss_account";
+		let row = (frm.doc.deductions || []).find((t) => t.is_exchange_gain_loss);
+
+		if (!row) {
+			const response = await get_company_defaults(frm.doc.company);
+
+			const account =
+				response.message?.[account_fieldname] ||
+				(await prompt_for_missing_account(frm, account_fieldname));
+
+			row = frm.add_child("deductions");
+			row.account = account;
+			row.cost_center = response.message?.cost_center;
+			row.is_exchange_gain_loss = 1;
+		}
+
+		row.amount = exchange_gain_loss;
+		frm.refresh_field("deductions");
+		frm.events.set_unallocated_amount(frm);
+	},
+
+	delete_exchange_gain_loss: function (frm) {
+		const exchange_gain_loss_row = (frm.doc.deductions || []).find((row) => row.is_exchange_gain_loss);
+
+		if (!exchange_gain_loss_row) return;
+
+		exchange_gain_loss_row.amount = 0;
+		frm.get_field("deductions").grid.grid_rows[exchange_gain_loss_row.idx - 1].remove();
+		frm.refresh_field("deductions");
+	},
+
+	set_write_off_deduction: async function (frm) {
+		const difference_amount = flt(frm.doc.difference_amount, get_deduction_amount_precision());
+		if (!difference_amount) return;
+
+		const account_fieldname = "write_off_account";
+		const response = await get_company_defaults(frm.doc.company);
+		const write_off_account =
+			response.message?.[account_fieldname] ||
+			(await prompt_for_missing_account(frm, account_fieldname));
+
+		if (!write_off_account) return;
+
+		let row = (frm.doc["deductions"] || []).find((t) => t.account == write_off_account);
+		if (!row) {
+			row = frm.add_child("deductions");
+			row.account = write_off_account;
+			row.cost_center = response.message?.cost_center;
+		}
+
+		row.amount = flt(row.amount) + difference_amount;
+		frm.refresh_field("deductions");
+		frm.events.set_unallocated_amount(frm);
 	},
 
 	bank_account: function (frm) {
@@ -1323,6 +1340,24 @@ frappe.ui.form.on("Payment Entry", {
 					if (r.message) {
 						if (!frm.doc.mode_of_payment) {
 							frm.set_value(field, r.message.account);
+						} else {
+							frappe.call({
+								method: "frappe.client.get_value",
+								args: {
+									doctype: "Mode of Payment Account",
+									filters: {
+										parent: frm.doc.mode_of_payment,
+										company: frm.doc.company,
+									},
+									fieldname: "default_account",
+									parent: "Mode of Payment",
+								},
+								callback: function (res) {
+									if (!res.message.default_account) {
+										frm.set_value(field, r.message.account);
+									}
+								},
+							});
 						}
 						frm.set_value("bank", r.message.bank);
 						frm.set_value("bank_account_no", r.message.bank_account_no);
@@ -1774,6 +1809,13 @@ frappe.ui.form.on("Advance Taxes and Charges", {
 });
 
 frappe.ui.form.on("Payment Entry Deduction", {
+	before_deductions_remove: function (doc, cdt, cdn) {
+		const row = frappe.get_doc(cdt, cdn);
+		if (row.is_exchange_gain_loss && row.amount) {
+			frappe.throw(__("Cannot delete Exchange Gain/Loss row"));
+		}
+	},
+
 	amount: function (frm) {
 		frm.events.set_unallocated_amount(frm);
 	},
@@ -1795,3 +1837,53 @@ function set_default_party_type(frm) {
 
 	if (party_type) frm.set_value("party_type", party_type);
 }
+
+function get_included_taxes(frm) {
+	let included_taxes = 0;
+	for (const tax of frm.doc.taxes) {
+		if (!tax.included_in_paid_amount) continue;
+
+		if (tax.add_deduct_tax == "Add") {
+			included_taxes += tax.base_tax_amount;
+		} else {
+			included_taxes -= tax.base_tax_amount;
+		}
+	}
+
+	return included_taxes;
+}
+
+function get_company_defaults(company) {
+	return frappe.call({
+		method: "erpnext.accounts.doctype.payment_entry.payment_entry.get_company_defaults",
+		args: {
+			company: company,
+		},
+	});
+}
+
+function prompt_for_missing_account(frm, account) {
+	return new Promise((resolve) => {
+		const dialog = frappe.prompt(
+			{
+				label: __(frappe.unscrub(account)),
+				fieldname: account,
+				fieldtype: "Link",
+				options: "Account",
+				get_query: () => ({
+					filters: {
+						company: frm.doc.company,
+					},
+				}),
+			},
+			(values) => resolve(values?.[account]),
+			__("Please Specify Account")
+		);
+
+		dialog.on_hide = () => resolve("");
+	});
+}
+
+function get_deduction_amount_precision() {
+	return frappe.meta.get_field_precision(frappe.meta.get_field("Payment Entry Deduction", "amount"));
+}

erpnext/accounts/doctype/payment_entry/payment_entry.json

@@ -56,7 +56,6 @@
   "section_break_34",
   "total_allocated_amount",
   "base_total_allocated_amount",
-  "set_exchange_gain_loss",
   "column_break_36",
   "unallocated_amount",
   "difference_amount",
@@ -390,11 +389,6 @@
    "print_hide": 1,
    "read_only": 1
   },
-  {
-   "fieldname": "set_exchange_gain_loss",
-   "fieldtype": "Button",
-   "label": "Set Exchange Gain / Loss"
-  },
   {
    "fieldname": "column_break_36",
    "fieldtype": "Column Break"
@@ -801,7 +795,7 @@
    "table_fieldname": "payment_entries"
   }
  ],
- "modified": "2024-05-31 17:07:06.197249",
+ "modified": "2024-11-07 11:19:19.320883",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry",

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -893,6 +893,7 @@ class PaymentEntry(AccountsController):
 		self.set_amounts_in_company_currency()
 		self.set_total_allocated_amount()
 		self.set_unallocated_amount()
+		self.set_exchange_gain_loss()
 		self.set_difference_amount()
 
 	def validate_amounts(self):
@@ -988,10 +989,10 @@ class PaymentEntry(AccountsController):
 			if d.exchange_rate is None:
 				d.exchange_rate = 1
 
-			allocated_amount_in_pe_exchange_rate = flt(
+			allocated_amount_in_ref_exchange_rate = flt(
 				flt(d.allocated_amount) * flt(d.exchange_rate), self.precision("base_paid_amount")
 			)
-			d.exchange_gain_loss = base_allocated_amount - allocated_amount_in_pe_exchange_rate
+			d.exchange_gain_loss = base_allocated_amount - allocated_amount_in_ref_exchange_rate
 		return base_allocated_amount
 
 	def set_total_allocated_amount(self):
@@ -1009,29 +1010,80 @@ class PaymentEntry(AccountsController):
 
 	def set_unallocated_amount(self):
 		self.unallocated_amount = 0
-		if self.party:
-			total_deductions = sum(flt(d.amount) for d in self.get("deductions"))
-			included_taxes = self.get_included_taxes()
-			if (
-				self.payment_type == "Receive"
-				and self.base_total_allocated_amount < self.base_received_amount + total_deductions
-				and self.total_allocated_amount
-				< flt(self.paid_amount) + (total_deductions / self.source_exchange_rate)
-			):
-				self.unallocated_amount = (
-					self.base_received_amount + total_deductions - self.base_total_allocated_amount
-				) / self.source_exchange_rate
-				self.unallocated_amount -= included_taxes
-			elif (
-				self.payment_type == "Pay"
-				and self.base_total_allocated_amount < (self.base_paid_amount - total_deductions)
-				and self.total_allocated_amount
-				< flt(self.received_amount) + (total_deductions / self.target_exchange_rate)
-			):
-				self.unallocated_amount = (
-					self.base_paid_amount - (total_deductions + self.base_total_allocated_amount)
-				) / self.target_exchange_rate
-				self.unallocated_amount -= included_taxes
+		if not self.party:
+			return
+
+		deductions_to_consider = sum(
+			flt(d.amount) for d in self.get("deductions") if not d.is_exchange_gain_loss
+		)
+		included_taxes = self.get_included_taxes()
+
+		if self.payment_type == "Receive" and self.base_total_allocated_amount < (
+			self.base_paid_amount + deductions_to_consider
+		):
+			self.unallocated_amount = (
+				self.base_paid_amount
+				+ deductions_to_consider
+				- self.base_total_allocated_amount
+				- included_taxes
+			) / self.source_exchange_rate
+		elif self.payment_type == "Pay" and self.base_total_allocated_amount < (
+			self.base_received_amount - deductions_to_consider
+		):
+			self.unallocated_amount = (
+				self.base_received_amount
+				- deductions_to_consider
+				- self.base_total_allocated_amount
+				- included_taxes
+			) / self.target_exchange_rate
+
+	def set_exchange_gain_loss(self):
+		exchange_gain_loss = flt(
+			self.base_paid_amount - self.base_received_amount,
+			self.precision("amount", "deductions"),
+		)
+
+		exchange_gain_loss_rows = [row for row in self.get("deductions") if row.is_exchange_gain_loss]
+		exchange_gain_loss_row = exchange_gain_loss_rows.pop(0) if exchange_gain_loss_rows else None
+
+		for row in exchange_gain_loss_rows:
+			self.remove(row)
+
+		if not exchange_gain_loss:
+			if exchange_gain_loss_row:
+				self.remove(exchange_gain_loss_row)
+
+			return
+
+		if not exchange_gain_loss_row:
+			values = frappe.get_cached_value(
+				"Company", self.company, ("exchange_gain_loss_account", "cost_center"), as_dict=True
+			)
+
+			for fieldname, value in values.items():
+				if value:
+					continue
+
+				label = _(frappe.get_meta("Company").get_label(fieldname))
+				return frappe.msgprint(
+					_("Please set {0} in Company {1} to account for Exchange Gain / Loss").format(
+						label, get_link_to_form("Company", self.company)
+					),
+					title=_("Missing Default in Company"),
+					indicator="red" if self.docstatus.is_submitted() else "yellow",
+					raise_exception=self.docstatus.is_submitted(),
+				)
+
+			exchange_gain_loss_row = self.append(
+				"deductions",
+				{
+					"account": values.exchange_gain_loss_account,
+					"cost_center": values.cost_center,
+					"is_exchange_gain_loss": 1,
+				},
+			)
+
+		exchange_gain_loss_row.amount = exchange_gain_loss
 
 	def set_difference_amount(self):
 		base_unallocated_amount = flt(self.unallocated_amount) * (
@@ -1059,11 +1111,13 @@ class PaymentEntry(AccountsController):
 	def get_included_taxes(self):
 		included_taxes = 0
 		for tax in self.get("taxes"):
-			if tax.included_in_paid_amount:
-				if tax.add_deduct_tax == "Add":
-					included_taxes += tax.base_tax_amount
-				else:
-					included_taxes -= tax.base_tax_amount
+			if not tax.included_in_paid_amount:
+				continue
+
+			if tax.add_deduct_tax == "Add":
+				included_taxes += tax.base_tax_amount
+			else:
+				included_taxes -= tax.base_tax_amount
 
 		return included_taxes
 
@@ -1219,11 +1273,19 @@ class PaymentEntry(AccountsController):
 				dr_or_cr = "debit" if dr_or_cr == "credit" else "credit"
 
 			gle.update(
-				{
-					dr_or_cr: allocated_amount_in_company_currency,
-					dr_or_cr + "_in_account_currency": d.allocated_amount,
-					"cost_center": cost_center,
-				}
+				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": cost_center,
+						dr_or_cr + "_in_account_currency": d.allocated_amount,
+						dr_or_cr: allocated_amount_in_company_currency,
+					},
+					item=self,
+				)
 			)
 
 			if self.book_advance_payments_in_separate_party_account:
@@ -1746,7 +1808,7 @@ class PaymentEntry(AccountsController):
 			if paid_amount > total_negative_outstanding:
 				if total_negative_outstanding == 0:
 					frappe.msgprint(
-						_("Cannot {0} from {2} without any negative outstanding invoice").format(
+						_("Cannot {0} from {1} without any negative outstanding invoice").format(
 							self.payment_type,
 							self.party_type,
 						)
@@ -1904,8 +1966,8 @@ class PaymentEntry(AccountsController):
 def get_matched_payment_request_of_references(references=None):
 	"""
 	Get those `Payment Requests` which are matched with `References`.\n
-	    - Amount must be same.
-	    - Only single `Payment Request` available for this amount.
+	        - Amount must be same.
+	        - Only single `Payment Request` available for this amount.
 
 	Example: [(reference_doctype, reference_name, allocated_amount, payment_request), ...]
 	"""
@@ -2007,7 +2069,7 @@ def get_outstanding_of_references_with_payment_term(references=None):
 def get_outstanding_of_references_with_no_payment_term(references):
 	"""
 	Fetch outstanding amount of `References` which have no `Payment Term` set.\n
-	    - Fetch outstanding amount from `References` it self.
+	        - Fetch outstanding amount from `References` it self.
 
 	Note: `None` is used for allocation of `Payment Request`
 	Example: {(reference_doctype, reference_name, None): outstanding_amount, ...}
@@ -2821,9 +2883,6 @@ def get_payment_entry(
 	update_accounting_dimensions(pe, doc)
 
 	if party_account and bank:
-		pe.set_exchange_rate(ref_doc=doc)
-		pe.set_amounts()
-
 		if discount_amount:
 			base_total_discount_loss = 0
 			if frappe.db.get_single_value("Accounts Settings", "book_tax_discount_loss"):
@@ -2833,7 +2892,8 @@ def get_payment_entry(
 				pe, doc, discount_amount, base_total_discount_loss, party_account_currency
 			)
 
-		pe.set_difference_amount()
+		pe.set_exchange_rate(ref_doc=doc)
+		pe.set_amounts()
 
 	# If PE is created from PR directly, then no need to find open PRs for the references
 	if not created_from_payment_request:
@@ -2845,7 +2905,7 @@ def get_payment_entry(
 def get_open_payment_requests_for_references(references=None):
 	"""
 	Fetch all unpaid Payment Requests for the references. \n
-	    - Each reference can have multiple Payment Requests. \n
+	        - Each reference can have multiple Payment Requests. \n
 
 	Example: {("Sales Invoice", "SINV-00001"): {"PREQ-00001": 1000, "PREQ-00002": 2000}}
 	"""
@@ -2869,6 +2929,7 @@ def get_open_payment_requests_for_references(references=None):
 		.where(Tuple(PR.reference_doctype, PR.reference_name).isin(list(refs)))
 		.where(PR.status != "Paid")
 		.where(PR.docstatus == 1)
+		.where(PR.outstanding_amount > 0)  # to avoid old PRs with 0 outstanding amount
 		.orderby(Coalesce(PR.transaction_date, PR.creation), order=frappe.qb.asc)
 	).run(as_dict=True)
 
@@ -3179,13 +3240,14 @@ def set_pending_discount_loss(pe, doc, discount_amount, base_total_discount_loss
 		book_tax_loss = frappe.db.get_single_value("Accounts Settings", "book_tax_discount_loss")
 		account_type = "round_off_account" if book_tax_loss else "default_discount_account"
 
-		pe.set_gain_or_loss(
-			account_details={
+		pe.append(
+			"deductions",
+			{
 				"account": frappe.get_cached_value("Company", pe.company, account_type),
 				"cost_center": pe.cost_center
 				or frappe.get_cached_value("Company", pe.company, "cost_center"),
 				"amount": discount_amount * positive_negative,
-			}
+			},
 		)
 
 

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -479,16 +479,9 @@ class TestPaymentEntry(FrappeTestCase):
 		self.assertEqual(pe.deductions[0].account, "Write Off - _TC")
 
 		# Exchange loss
-		self.assertEqual(pe.difference_amount, 300.0)
-
-		pe.append(
-			"deductions",
-			{
-				"account": "_Test Exchange Gain/Loss - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"amount": 300.0,
-			},
-		)
+		self.assertEqual(pe.deductions[-1].amount, 300.0)
+		pe.deductions[-1].account = "_Test Exchange Gain/Loss - _TC"
+		pe.deductions[-1].cost_center = "_Test Cost Center - _TC"
 
 		pe.insert()
 		pe.submit()
@@ -552,16 +545,10 @@ class TestPaymentEntry(FrappeTestCase):
 		pe.reference_no = "1"
 		pe.reference_date = "2016-01-01"
 
-		self.assertEqual(pe.difference_amount, 100)
+		self.assertEqual(pe.deductions[0].amount, 100)
+		pe.deductions[0].account = "_Test Exchange Gain/Loss - _TC"
+		pe.deductions[0].cost_center = "_Test Cost Center - _TC"
 
-		pe.append(
-			"deductions",
-			{
-				"account": "_Test Exchange Gain/Loss - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"amount": 100,
-			},
-		)
 		pe.insert()
 		pe.submit()
 
@@ -654,16 +641,9 @@ class TestPaymentEntry(FrappeTestCase):
 		pe.set_exchange_rate()
 		pe.set_amounts()
 
-		self.assertEqual(pe.difference_amount, 500)
-
-		pe.append(
-			"deductions",
-			{
-				"account": "_Test Exchange Gain/Loss - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"amount": 500,
-			},
-		)
+		self.assertEqual(pe.deductions[0].amount, 500)
+		pe.deductions[0].account = "_Test Exchange Gain/Loss - _TC"
+		pe.deductions[0].cost_center = "_Test Cost Center - _TC"
 
 		pe.insert()
 		pe.submit()
@@ -1499,7 +1479,7 @@ class TestPaymentEntry(FrappeTestCase):
 			parent_account="Current Liabilities - _TC",
 			account_name="Advances Paid",
 			company=company,
-			account_type="Liability",
+			account_type="Payable",
 		)
 
 		frappe.db.set_value(

erpnext/accounts/doctype/payment_entry_deduction/payment_entry_deduction.json

@@ -9,6 +9,7 @@
   "cost_center",
   "amount",
   "column_break_2",
+  "is_exchange_gain_loss",
   "description"
  ],
  "fields": [
@@ -45,12 +46,20 @@
    "fieldname": "description",
    "fieldtype": "Small Text",
    "label": "Description"
+  },
+  {
+   "default": "0",
+   "depends_on": "eval:doc.is_exchange_gain_loss",
+   "fieldname": "is_exchange_gain_loss",
+   "fieldtype": "Check",
+   "label": "Is Exchange Gain / Loss?",
+   "read_only": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-03-06 07:11:57.739619",
+ "modified": "2024-11-05 16:07:47.307971",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry Deduction",

erpnext/accounts/doctype/payment_entry_deduction/payment_entry_deduction.py

@@ -18,6 +18,7 @@ class PaymentEntryDeduction(Document):
 		amount: DF.Currency
 		cost_center: DF.Link
 		description: DF.SmallText | None
+		is_exchange_gain_loss: DF.Check
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -153,10 +153,7 @@ class PaymentReconciliation(Document):
 		self.add_payment_entries(non_reconciled_payments)
 
 	def get_payment_entries(self):
-		if self.default_advance_account:
-			party_account = [self.receivable_payable_account, self.default_advance_account]
-		else:
-			party_account = [self.receivable_payable_account]
+		party_account = [self.receivable_payable_account]
 
 		order_doctype = "Sales Order" if self.party_type == "Customer" else "Purchase Order"
 		condition = frappe._dict(
@@ -187,6 +184,7 @@ class PaymentReconciliation(Document):
 			self.party,
 			party_account,
 			order_doctype,
+			default_advance_account=self.default_advance_account,
 			against_all_orders=True,
 			limit=self.payment_limit,
 			condition=condition,

erpnext/accounts/doctype/payment_request/payment_request.json

@@ -58,7 +58,9 @@
   "payment_account",
   "payment_channel",
   "payment_order",
-  "amended_from"
+  "amended_from",
+  "column_break_iiuv",
+  "phone_number"
  ],
  "fields": [
   {
@@ -376,6 +378,7 @@
    "read_only": 1
   },
   {
+   "depends_on": "eval: doc.payment_channel==\"Phone\"",
    "fetch_from": "payment_gateway_account.payment_channel",
    "fieldname": "payment_channel",
    "fieldtype": "Select",
@@ -429,13 +432,22 @@
    "fieldtype": "Data",
    "label": "Party Name",
    "read_only": 1
+  },
+  {
+   "fieldname": "column_break_iiuv",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "phone_number",
+   "fieldtype": "Data",
+   "label": "Phone Number"
   }
  ],
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-10-23 12:23:40.117336",
+ "modified": "2024-12-27 21:29:10.361894",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Request",

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -3,7 +3,7 @@ import json
 import frappe
 from frappe import _, qb
 from frappe.model.document import Document
-from frappe.query_builder.functions import Sum
+from frappe.query_builder.functions import Abs, Sum
 from frappe.utils import flt, nowdate
 from frappe.utils.background_jobs import enqueue
 
@@ -224,6 +224,7 @@ class PaymentRequest(Document):
 			sender=self.email_to,
 			currency=self.currency,
 			payment_gateway=self.payment_gateway,
+			phone_number=self.phone_number,
 		)
 
 		controller.validate_transaction_currency(self.currency)
@@ -564,6 +565,8 @@ def make_payment_request(**args):
 	# fetches existing payment request `grand_total` amount
 	existing_payment_request_amount = get_existing_payment_request_amount(ref_doc.doctype, ref_doc.name)
 
+	existing_paid_amount = get_existing_paid_amount(ref_doc.doctype, ref_doc.name)
+
 	def validate_and_calculate_grand_total(grand_total, existing_payment_request_amount):
 		grand_total -= existing_payment_request_amount
 		if not grand_total:
@@ -583,6 +586,15 @@ def make_payment_request(**args):
 		else:
 			grand_total = validate_and_calculate_grand_total(grand_total, existing_payment_request_amount)
 
+	if existing_paid_amount:
+		if ref_doc.party_account_currency == ref_doc.currency:
+			if ref_doc.conversion_rate:
+				grand_total -= flt(existing_paid_amount / ref_doc.conversion_rate)
+			else:
+				grand_total -= flt(existing_paid_amount)
+		else:
+			grand_total -= flt(existing_paid_amount / ref_doc.conversion_rate)
+
 	if draft_payment_request:
 		frappe.db.set_value(
 			"Payment Request", draft_payment_request, "grand_total", grand_total, update_modified=False
@@ -624,6 +636,7 @@ def make_payment_request(**args):
 				"party": args.get("party") or ref_doc.get("customer"),
 				"bank_account": bank_account,
 				"party_name": args.get("party_name") or ref_doc.get("customer_name"),
+				"phone_number": args.get("phone_number") if args.get("phone_number") else None,
 			}
 		)
 
@@ -753,6 +766,29 @@ def get_existing_payment_request_amount(ref_dt, ref_dn, statuses: list | None =
 	return response[0][0] if response[0] else 0
 
 
+def get_existing_paid_amount(doctype, name):
+	PL = frappe.qb.DocType("Payment Ledger Entry")
+	PER = frappe.qb.DocType("Payment Entry Reference")
+
+	query = (
+		frappe.qb.from_(PL)
+		.left_join(PER)
+		.on(
+			(PER.reference_doctype == PL.against_voucher_type) & (PER.reference_name == PL.against_voucher_no)
+		)
+		.select(Abs(Sum(PL.amount)).as_("total_paid_amount"))
+		.where(PL.against_voucher_type.eq(doctype))
+		.where(PL.against_voucher_no.eq(name))
+		.where(PL.amount < 0)
+		.where(PL.delinked == 0)
+		.where(PER.docstatus == 1)
+		.where(PER.payment_request.isnull())
+	)
+	response = query.run()
+
+	return response[0][0] if response[0] else 0
+
+
 def get_gateway_details(args):  # nosemgrep
 	"""
 	Return gateway and payment account of default payment gateway
@@ -955,12 +991,7 @@ def get_open_payment_requests_query(doctype, txt, searchfield, start, page_len,
 
 	open_payment_requests = frappe.get_list(
 		"Payment Request",
-		filters={
-			**filters,
-			"status": ["!=", "Paid"],
-			"outstanding_amount": ["!=", 0],  # for compatibility with old data
-			"docstatus": 1,
-		},
+		filters=filters,
 		fields=["name", "grand_total", "outstanding_amount"],
 		order_by="transaction_date ASC,creation ASC",
 	)

erpnext/accounts/doctype/payment_request/payment_request_dashboard.py

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

erpnext/accounts/doctype/payment_request/payment_request_list.js

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

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -7,6 +7,7 @@ import unittest
 import frappe
 from frappe.tests.utils import FrappeTestCase, change_settings
 
+from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_terms_template
 from erpnext.accounts.doctype.payment_request.payment_request import make_payment_request
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
@@ -524,3 +525,48 @@ class TestPaymentRequest(FrappeTestCase):
 		self.assertEqual(pr.grand_total, 1000)
 
 		so.load_from_db()
+
+	def test_partial_paid_invoice_with_payment_request(self):
+		si = create_sales_invoice(currency="INR", qty=1, rate=5000)
+		si.save()
+		si.submit()
+
+		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC")
+		pe.reference_no = "PAYEE0002"
+		pe.reference_date = frappe.utils.nowdate()
+		pe.paid_amount = 2500
+		pe.references[0].allocated_amount = 2500
+		pe.save()
+		pe.submit()
+
+		si.load_from_db()
+		pr = make_payment_request(dt="Sales Invoice", dn=si.name, mute_email=1)
+
+		self.assertEqual(pr.grand_total, si.outstanding_amount)
+
+
+def test_partial_paid_invoice_with_submitted_payment_entry(self):
+	pi = make_purchase_invoice(currency="INR", qty=1, rate=5000)
+	pi.save()
+	pi.submit()
+
+	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
+	pe.reference_no = "PURINV0001"
+	pe.reference_date = frappe.utils.nowdate()
+	pe.paid_amount = 2500
+	pe.references[0].allocated_amount = 2500
+	pe.save()
+	pe.submit()
+	pe.cancel()
+
+	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
+	pe.reference_no = "PURINV0002"
+	pe.reference_date = frappe.utils.nowdate()
+	pe.paid_amount = 2500
+	pe.references[0].allocated_amount = 2500
+	pe.save()
+	pe.submit()
+
+	pi.load_from_db()
+	pr = make_payment_request(dt="Purchase Invoice", dn=pi.name, mute_email=1)
+	self.assertEqual(pr.grand_total, pi.outstanding_amount)

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -171,9 +171,7 @@ class PeriodClosingVoucher(AccountsController):
 		pl_account_balances = self.get_account_balances_based_on_dimensions(report_type="Profit and Loss")
 		for dimensions, account_balances in pl_account_balances.items():
 			for acc, balances in account_balances.items():
-				balance_in_company_currency = flt(balances.debit_in_account_currency) - flt(
-					balances.credit_in_account_currency
-				)
+				balance_in_company_currency = flt(balances.debit) - flt(balances.credit)
 				if balance_in_company_currency and acc != "balances":
 					self.pl_accounts_reverse_gle.append(
 						self.get_gle_for_pl_account(acc, balances, dimensions)

erpnext/accounts/doctype/pos_closing_entry/closing_voucher_details.html

@@ -12,15 +12,15 @@
 								</thead>
 								<tbody>
 									<tr>
-										<td class="text-left font-bold">{{ _('Grand Total') }}</td>
+										<td class="text-left font-bold">{{ _("Grand Total") }}</td>
 										<td class='text-right'> {{ frappe.utils.fmt_money(data.grand_total or '', currency=currency) }}</td>
 									</tr>
 									<tr>
-										<td class="text-left font-bold">{{ _('Net Total') }}</td>
+										<td class="text-left font-bold">{{ _("Net Total") }}</td>
 										<td class='text-right'> {{ frappe.utils.fmt_money(data.net_total or '', currency=currency) }}</td>
 									</tr>
 									<tr>
-										<td class="text-left font-bold">{{ _('Total Quantity') }}</td>
+										<td class="text-left font-bold">{{ _("Total Quantity") }}</td>
 										<td class='text-right'>{{ data.total_quantity or '' }}</td>
 									</tr>
 
@@ -44,7 +44,7 @@
 								<tbody>
 								{% for d in data.payment_reconciliation %}
 									<tr>
-										<td class="text-left">{{ d.mode_of_payment }}</td>
+										<td class="text-left">{{ _(d.mode_of_payment) }}</td>
 										<td class='text-right'> {{ frappe.utils.fmt_money(d.expected_amount - d.opening_amount, currency=currency) }}</td>
 									</tr>
 								{% endfor %}
@@ -63,7 +63,7 @@
 								<thead>
 									<tr>
 										<th class="text-left">{{ _("Account") }}</th>
-										<th class="text-left">{{ _("Rate") }}</th>
+										<th class="text-left">{{ _("Tax Rate") }}</th>
 										<th class="text-right">{{ _("Amount") }}</th>
 									</tr>
 								</thead>

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.js

@@ -147,7 +147,7 @@ frappe.ui.form.on("POS Closing Entry", {
 						frm.doc.grand_total += flt(doc.grand_total);
 						frm.doc.net_total += flt(doc.net_total);
 						frm.doc.total_quantity += flt(doc.total_qty);
-						refresh_payments(doc, frm);
+						refresh_payments(doc, frm, false);
 						refresh_taxes(doc, frm);
 						refresh_fields(frm);
 						set_html_data(frm);
@@ -172,7 +172,7 @@ function set_form_data(data, frm) {
 		frm.doc.grand_total += flt(d.grand_total);
 		frm.doc.net_total += flt(d.net_total);
 		frm.doc.total_quantity += flt(d.total_qty);
-		refresh_payments(d, frm);
+		refresh_payments(d, frm, true);
 		refresh_taxes(d, frm);
 	});
 }
@@ -186,7 +186,7 @@ function add_to_pos_transaction(d, frm) {
 	});
 }
 
-function refresh_payments(d, frm) {
+function refresh_payments(d, frm, is_new) {
 	d.payments.forEach((p) => {
 		const payment = frm.doc.payment_reconciliation.find(
 			(pay) => pay.mode_of_payment === p.mode_of_payment
@@ -196,9 +196,7 @@ function refresh_payments(d, frm) {
 		}
 		if (payment) {
 			payment.expected_amount += flt(p.amount);
-			if (payment.closing_amount === 0) {
-				payment.closing_amount = payment.expected_amount;
-			}
+			if (is_new) payment.closing_amount = payment.expected_amount;
 			payment.difference = payment.closing_amount - payment.expected_amount;
 		} else {
 			frm.add_child("payment_reconciliation", {

erpnext/accounts/doctype/pos_closing_entry_taxes/pos_closing_entry_taxes.json

@@ -14,7 +14,7 @@
    "fieldname": "rate",
    "fieldtype": "Percent",
    "in_list_view": 1,
-   "label": "Rate",
+   "label": "Tax Rate",
    "read_only": 1
   },
   {

erpnext/accounts/doctype/pos_invoice/pos_invoice.json

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

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -32,12 +32,8 @@ class POSInvoice(SalesInvoice):
 		from erpnext.accounts.doctype.payment_schedule.payment_schedule import PaymentSchedule
 		from erpnext.accounts.doctype.pos_invoice_item.pos_invoice_item import POSInvoiceItem
 		from erpnext.accounts.doctype.pricing_rule_detail.pricing_rule_detail import PricingRuleDetail
-		from erpnext.accounts.doctype.sales_invoice_advance.sales_invoice_advance import (
-			SalesInvoiceAdvance,
-		)
-		from erpnext.accounts.doctype.sales_invoice_payment.sales_invoice_payment import (
-			SalesInvoicePayment,
-		)
+		from erpnext.accounts.doctype.sales_invoice_advance.sales_invoice_advance import SalesInvoiceAdvance
+		from erpnext.accounts.doctype.sales_invoice_payment.sales_invoice_payment import SalesInvoicePayment
 		from erpnext.accounts.doctype.sales_invoice_timesheet.sales_invoice_timesheet import (
 			SalesInvoiceTimesheet,
 		)
@@ -75,6 +71,7 @@ class POSInvoice(SalesInvoice):
 		company: DF.Link
 		company_address: DF.Link | None
 		company_address_display: DF.SmallText | None
+		company_contact_person: DF.Link | None
 		consolidated_invoice: DF.Link | None
 		contact_display: DF.SmallText | None
 		contact_email: DF.Data | None

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -117,11 +117,13 @@ class POSInvoiceMergeLog(Document):
 		sales = [d for d in pos_invoice_docs if d.get("is_return") == 0]
 
 		sales_invoice, credit_note = "", ""
-		if returns:
-			credit_note = self.process_merging_into_credit_note(returns)
-
+		sales_invoice_doc = None
 		if sales:
-			sales_invoice = self.process_merging_into_sales_invoice(sales)
+			sales_invoice_doc = self.process_merging_into_sales_invoice(sales)
+			sales_invoice = sales_invoice_doc.name
+
+		if returns:
+			credit_note = self.process_merging_into_credit_note(returns, sales_invoice_doc)
 
 		self.save()  # save consolidated_sales_invoice & consolidated_credit_note ref in merge log
 		self.update_pos_invoices(pos_invoice_docs, sales_invoice, credit_note)
@@ -132,6 +134,7 @@ class POSInvoiceMergeLog(Document):
 		self.update_pos_invoices(pos_invoice_docs)
 		self.serial_and_batch_bundle_reference_for_pos_invoice()
 		self.cancel_linked_invoices()
+		self.delink_serial_and_batch_bundle()
 
 	def process_merging_into_sales_invoice(self, data):
 		sales_invoice = self.get_new_sales_invoice()
@@ -139,20 +142,35 @@ class POSInvoiceMergeLog(Document):
 
 		sales_invoice.is_consolidated = 1
 		sales_invoice.set_posting_time = 1
-		sales_invoice.posting_date = getdate(self.posting_date)
-		sales_invoice.posting_time = get_time(self.posting_time)
+
+		if not sales_invoice.posting_date:
+			sales_invoice.posting_date = getdate(self.posting_date)
+
+		if not sales_invoice.posting_time:
+			sales_invoice.posting_time = get_time(self.posting_time)
+
 		sales_invoice.save()
 		sales_invoice.submit()
 
 		self.consolidated_invoice = sales_invoice.name
 
-		return sales_invoice.name
+		return sales_invoice
 
-	def process_merging_into_credit_note(self, data):
+	def process_merging_into_credit_note(self, data, sales_invoice_doc=None):
 		credit_note = self.get_new_sales_invoice()
 		credit_note.is_return = 1
 
 		credit_note = self.merge_pos_invoice_into(credit_note, data)
+		referenes = {}
+
+		if sales_invoice_doc:
+			credit_note.return_against = sales_invoice_doc.name
+
+			for d in sales_invoice_doc.items:
+				referenes[d.item_code] = d.name
+
+			for d in credit_note.items:
+				d.sales_invoice_item = referenes.get(d.item_code)
 
 		credit_note.is_consolidated = 1
 		credit_note.set_posting_time = 1
@@ -180,6 +198,10 @@ class POSInvoiceMergeLog(Document):
 		for doc in data:
 			map_doc(doc, invoice, table_map={"doctype": invoice.doctype})
 
+			if doc.get("posting_date"):
+				invoice.posting_date = getdate(doc.posting_date)
+				invoice.posting_time = get_time(doc.posting_time)
+
 			if doc.redeem_loyalty_points:
 				invoice.loyalty_redemption_account = doc.loyalty_redemption_account
 				invoice.loyalty_redemption_cost_center = doc.loyalty_redemption_cost_center
@@ -297,6 +319,8 @@ class POSInvoiceMergeLog(Document):
 		sales_invoice = frappe.new_doc("Sales Invoice")
 		sales_invoice.customer = self.customer
 		sales_invoice.is_pos = 1
+		sales_invoice.posting_date = None
+		sales_invoice.posting_time = None
 
 		return sales_invoice
 
@@ -319,8 +343,45 @@ class POSInvoiceMergeLog(Document):
 			for table_name in ["items", "packed_items"]:
 				pos_invoice.set_serial_and_batch_bundle(table_name)
 
+	def delink_serial_and_batch_bundle(self):
+		bundles = self.get_serial_and_batch_bundles()
+		if not bundles:
+			return
+
+		sle_table = frappe.qb.DocType("Stock Ledger Entry")
+		query = (
+			frappe.qb.update(sle_table)
+			.set(sle_table.serial_and_batch_bundle, None)
+			.where(sle_table.serial_and_batch_bundle.isin(bundles) & sle_table.is_cancelled == 1)
+		)
+
+		query.run()
+
+	def get_serial_and_batch_bundles(self):
+		pos_invoices = []
+		for d in self.pos_invoices:
+			pos_invoices.append(d.pos_invoice)
+
+		if pos_invoices:
+			return frappe.get_all(
+				"POS Invoice Item",
+				filters={
+					"docstatus": 1,
+					"parent": ["in", pos_invoices],
+					"serial_and_batch_bundle": ["is", "set"],
+				},
+				pluck="serial_and_batch_bundle",
+			)
+
+		return []
+
 	def cancel_linked_invoices(self):
-		for si_name in [self.consolidated_invoice, self.consolidated_credit_note]:
+		invoices = [self.consolidated_invoice, self.consolidated_credit_note]
+		if not invoices:
+			return
+
+		invoices.reverse()
+		for si_name in invoices:
 			if not si_name:
 				continue
 			si = frappe.get_doc("Sales Invoice", si_name)
@@ -503,6 +564,9 @@ def cancel_merge_logs(merge_logs, closing_entry=None):
 	try:
 		for log in merge_logs:
 			merge_log = frappe.get_doc("POS Invoice Merge Log", log)
+			if merge_log.docstatus == 2:
+				continue
+
 			merge_log.flags.ignore_permissions = True
 			merge_log.cancel()
 

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -415,6 +415,8 @@ def get_pricing_rule_for_item(args, doc=None, for_validate=False):
 			"parent": args.parent,
 			"parenttype": args.parenttype,
 			"child_docname": args.get("child_docname"),
+			"discount_percentage": 0.0,
+			"discount_amount": 0,
 		}
 	)
 

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -1137,6 +1137,45 @@ class TestPricingRule(FrappeTestCase):
 		so.save()
 		self.assertEqual(len(so.items), 1)
 
+	def test_pricing_rule_for_product_free_item_round_free_qty(self):
+		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule")
+		test_record = {
+			"doctype": "Pricing Rule",
+			"title": "_Test Pricing Rule",
+			"apply_on": "Item Code",
+			"currency": "USD",
+			"items": [
+				{
+					"item_code": "_Test Item",
+				}
+			],
+			"selling": 1,
+			"rate": 0,
+			"min_qty": 100,
+			"max_qty": 0,
+			"price_or_product_discount": "Product",
+			"same_item": 1,
+			"free_qty": 10,
+			"round_free_qty": 1,
+			"is_recursive": 1,
+			"recurse_for": 100,
+			"company": "_Test Company",
+		}
+		frappe.get_doc(test_record.copy()).insert()
+
+		# With pricing rule
+		so = make_sales_order(item_code="_Test Item", qty=100)
+		so.load_from_db()
+		self.assertEqual(so.items[1].is_free_item, 1)
+		self.assertEqual(so.items[1].item_code, "_Test Item")
+		self.assertEqual(so.items[1].qty, 10)
+
+		so = make_sales_order(item_code="_Test Item", qty=150)
+		so.load_from_db()
+		self.assertEqual(so.items[1].is_free_item, 1)
+		self.assertEqual(so.items[1].item_code, "_Test Item")
+		self.assertEqual(so.items[1].qty, 10)
+
 	def test_apply_multiple_pricing_rules_for_discount_percentage_and_amount(self):
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule 1")
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule 2")

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -651,11 +651,20 @@ def get_product_discount_rule(pricing_rule, item_details, args=None, doc=None):
 
 	qty = pricing_rule.free_qty or 1
 	if pricing_rule.is_recursive:
-		transaction_qty = (args.get("qty") if args else doc.total_qty) - pricing_rule.apply_recursion_over
-		if transaction_qty:
+		transaction_qty = sum(
+			[
+				row.qty
+				for row in doc.items
+				if not row.is_free_item
+				and row.item_code == args.item_code
+				and row.pricing_rules == args.pricing_rules
+			]
+		)
+		transaction_qty = transaction_qty - pricing_rule.apply_recursion_over
+		if transaction_qty and transaction_qty > 0:
 			qty = flt(transaction_qty) * qty / pricing_rule.recurse_for
 			if pricing_rule.round_free_qty:
-				qty = math.floor(qty)
+				qty = (flt(transaction_qty) // pricing_rule.recurse_for) * (pricing_rule.free_qty or 1)
 
 	if not qty:
 		return

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.json

@@ -1,7 +1,6 @@
 {
  "actions": [],
  "autoname": "format:ACC-PPR-{#####}",
- "beta": 1,
  "creation": "2023-03-30 21:28:39.793927",
  "default_view": "List",
  "doctype": "DocType",
@@ -158,7 +157,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2024-08-27 14:48:56.715320",
+ "modified": "2025-01-08 08:22:14.798085",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Payment Reconciliation",
@@ -192,4 +191,4 @@
  "sort_order": "DESC",
  "states": [],
  "title_field": "company"
-}
+}

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.py

@@ -212,7 +212,7 @@ def trigger_reconciliation_for_queued_docs():
 		unique_filters = set()
 		queue_size = 5
 
-		fields = ["company", "party_type", "party", "receivable_payable_account"]
+		fields = ["company", "party_type", "party", "receivable_payable_account", "default_advance_account"]
 
 		def get_filters_as_tuple(fields, doc):
 			filters = ()

erpnext/accounts/doctype/process_payment_reconciliation_log/process_payment_reconciliation_log.json

@@ -1,7 +1,6 @@
 {
  "actions": [],
  "autoname": "format:PPR-LOG-{##}",
- "beta": 1,
  "creation": "2023-03-13 15:00:09.149681",
  "default_view": "List",
  "doctype": "DocType",
@@ -110,7 +109,7 @@
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2023-11-02 11:32:12.254018",
+ "modified": "2025-01-08 08:22:19.104975",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Payment Reconciliation Log",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -244,9 +244,9 @@
   },
   {
    "fieldname": "cc_to",
-   "fieldtype": "Link",
+   "fieldtype": "Table MultiSelect",
    "label": "CC To",
-   "options": "User"
+   "options": "Process Statement Of Accounts CC"
   },
   {
    "default": "1",
@@ -400,7 +400,7 @@
   }
  ],
  "links": [],
- "modified": "2024-10-18 17:51:39.108481",
+ "modified": "2024-12-11 12:11:13.543134",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -31,6 +31,9 @@ class ProcessStatementOfAccounts(Document):
 	if TYPE_CHECKING:
 		from frappe.types import DF
 
+		from erpnext.accounts.doctype.process_statement_of_accounts_cc.process_statement_of_accounts_cc import (
+			ProcessStatementOfAccountsCC,
+		)
 		from erpnext.accounts.doctype.process_statement_of_accounts_customer.process_statement_of_accounts_customer import (
 			ProcessStatementOfAccountsCustomer,
 		)
@@ -41,7 +44,7 @@ class ProcessStatementOfAccounts(Document):
 		ageing_based_on: DF.Literal["Due Date", "Posting Date"]
 		based_on_payment_terms: DF.Check
 		body: DF.TextEditor | None
-		cc_to: DF.Link | None
+		cc_to: DF.TableMultiSelect[ProcessStatementOfAccountsCC]
 		collection_name: DF.DynamicLink | None
 		company: DF.Link
 		cost_center: DF.TableMultiSelect[PSOACostCenter]
@@ -324,7 +327,7 @@ def get_recipients_and_cc(customer, doc):
 	cc = []
 	if doc.cc_to != "":
 		try:
-			cc = [frappe.get_value("User", doc.cc_to, "email")]
+			cc = [frappe.get_value("User", user.cc, "email") for user in doc.cc_to]
 		except Exception:
 			pass
 
@@ -474,6 +477,7 @@ def send_emails(document_name, from_scheduler=False, posting_date=None):
 				reference_doctype="Process Statement Of Accounts",
 				reference_name=document_name,
 				attachments=attachments,
+				expose_recipients="header",
 			)
 
 		if doc.enable_auto_email and from_scheduler:

erpnext/accounts/doctype/process_statement_of_accounts_cc/process_statement_of_accounts_cc.json

@@ -0,0 +1,32 @@
+{
+ "actions": [],
+ "allow_rename": 1,
+ "creation": "2024-12-11 12:10:04.654593",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "cc"
+ ],
+ "fields": [
+  {
+   "fieldname": "cc",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "CC",
+   "options": "User"
+  }
+ ],
+ "index_web_pages_for_search": 1,
+ "istable": 1,
+ "links": [],
+ "modified": "2024-12-11 12:10:39.772598",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Process Statement Of Accounts CC",
+ "owner": "Administrator",
+ "permissions": [],
+ "sort_field": "creation",
+ "sort_order": "DESC",
+ "states": []
+}

erpnext/accounts/doctype/process_statement_of_accounts_cc/process_statement_of_accounts_cc.py

@@ -0,0 +1,23 @@
+# Copyright (c) 2024, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+# import frappe
+from frappe.model.document import Document
+
+
+class ProcessStatementOfAccountsCC(Document):
+	# begin: auto-generated types
+	# This code is auto-generated. Do not modify anything in this block.
+
+	from typing import TYPE_CHECKING
+
+	if TYPE_CHECKING:
+		from frappe.types import DF
+
+		cc: DF.Link | None
+		parent: DF.Data
+		parentfield: DF.Data
+		parenttype: DF.Data
+	# end: auto-generated types
+
+	pass

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -399,6 +399,8 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		hide_fields(this.frm.doc);
 		if (cint(this.frm.doc.is_paid)) {
 			this.frm.set_value("allocate_advances_automatically", 0);
+			this.frm.set_value("payment_terms_template", "");
+			this.frm.set_value("payment_schedule", []);
 			if (!this.frm.doc.company) {
 				this.frm.set_value("is_paid", 0);
 				frappe.msgprint(__("Please specify Company to proceed"));

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -1677,7 +1677,12 @@ class PurchaseInvoice(BuyingController):
 
 				if pi:
 					pi = pi[0][0]
-					frappe.throw(_("Supplier Invoice No exists in Purchase Invoice {0}").format(pi))
+
+					frappe.throw(
+						_("Supplier Invoice No exists in Purchase Invoice {0}").format(
+							get_link_to_form("Purchase Invoice", pi)
+						)
+					)
 
 	def update_billing_status_in_pr(self, update_modified=True):
 		if self.is_return and not self.update_billed_amount_in_purchase_receipt:

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -1735,6 +1735,30 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 
 		frappe.db.set_single_value("Buying Settings", "set_landed_cost_based_on_purchase_invoice_rate", 1)
 
+		# Cost of Item is zero in Purchase Receipt
+		pr = make_purchase_receipt(qty=1, rate=0)
+
+		stock_value_difference = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
+			"stock_value_difference",
+		)
+		self.assertEqual(stock_value_difference, 0)
+
+		pi = create_purchase_invoice_from_receipt(pr.name)
+		for row in pi.items:
+			row.rate = 150
+
+		pi.save()
+		pi.submit()
+
+		stock_value_difference = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
+			"stock_value_difference",
+		)
+		self.assertEqual(stock_value_difference, 150)
+
 		# Increase the cost of the item
 
 		pr = make_purchase_receipt(qty=1, rate=100)
@@ -1814,6 +1838,52 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 
 		frappe.db.set_single_value("Buying Settings", "maintain_same_rate", 1)
 
+	def test_adjust_incoming_rate_for_rejected_item(self):
+		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)
+
+		# Cost of Item is zero in Purchase Receipt
+		pr = make_purchase_receipt(qty=1, rejected_qty=1, rate=0)
+
+		stock_value_difference = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
+			"stock_value_difference",
+		)
+		self.assertEqual(stock_value_difference, 0)
+
+		pi = create_purchase_invoice_from_receipt(pr.name)
+		for row in pi.items:
+			row.qty = 1
+			row.rate = 150
+
+		pi.save()
+		pi.submit()
+
+		stock_value_difference = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name, "warehouse": pi.items[0].warehouse},
+			"stock_value_difference",
+		)
+		self.assertEqual(stock_value_difference, 150)
+
+		stock_value_difference = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{
+				"voucher_type": "Purchase Receipt",
+				"voucher_no": pr.name,
+				"warehouse": pi.items[0].rejected_warehouse,
+			},
+			"stock_value_difference",
+		)
+
+		self.assertFalse(stock_value_difference)
+
+		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 test_item_less_defaults(self):
 		pi = frappe.new_doc("Purchase Invoice")
 		pi.supplier = "_Test Supplier"
@@ -2424,6 +2494,34 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		self.assertEqual(len(actual), 3)
 		self.assertEqual(expected, actual)
 
+	def test_invoice_against_returned_pr(self):
+		from erpnext.stock.doctype.item.test_item import make_item
+		from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
+			make_purchase_invoice as make_purchase_invoice_from_pr,
+		)
+		from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
+			make_purchase_return_against_rejected_warehouse,
+		)
+
+		item = make_item("_Test Item For Invoice Against Returned PR", properties={"is_stock_item": 1}).name
+
+		original_value = frappe.db.get_single_value(
+			"Buying Settings", "bill_for_rejected_quantity_in_purchase_invoice"
+		)
+		frappe.db.set_single_value("Buying Settings", "bill_for_rejected_quantity_in_purchase_invoice", 0)
+
+		pr = make_purchase_receipt(item_code=item, qty=5, rejected_qty=5, rate=100)
+		pr_return = make_purchase_return_against_rejected_warehouse(pr.name)
+		pr_return.submit()
+
+		pi = make_purchase_invoice_from_pr(pr.name)
+		pi.save()
+		self.assertEqual(pi.items[0].qty, 5.0)
+
+		frappe.db.set_single_value(
+			"Buying Settings", "bill_for_rejected_quantity_in_purchase_invoice", original_value
+		)
+
 
 def set_advance_flag(company, flag, default_account):
 	frappe.db.set_value(

erpnext/accounts/doctype/purchase_invoice_advance/purchase_invoice_advance.json

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

erpnext/accounts/doctype/purchase_invoice_advance/purchase_invoice_advance.py

@@ -16,6 +16,7 @@ class PurchaseInvoiceAdvance(Document):
 
 		advance_amount: DF.Currency
 		allocated_amount: DF.Currency
+		difference_posting_date: DF.Date | None
 		exchange_gain_loss: DF.Currency
 		parent: DF.Data
 		parentfield: DF.Data

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.py

@@ -1,6 +1,8 @@
 # Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
 # For license information, please see license.txt
 
+import inspect
+
 import frappe
 from frappe import _, qb
 from frappe.model.document import Document
@@ -45,7 +47,7 @@ class RepostAccountingLedger(Document):
 			latest_pcv = (
 				frappe.db.get_all(
 					"Period Closing Voucher",
-					filters={"company": self.company},
+					filters={"company": self.company, "docstatus": 1},
 					order_by="period_end_date desc",
 					pluck="period_end_date",
 					limit=1,
@@ -142,6 +144,8 @@ class RepostAccountingLedger(Document):
 
 @frappe.whitelist()
 def start_repost(account_repost_doc=str) -> None:
+	from erpnext.accounts.general_ledger import make_reverse_gl_entries
+
 	frappe.flags.through_repost_accounting_ledger = True
 	if account_repost_doc:
 		repost_doc = frappe.get_doc("Repost Accounting Ledger", account_repost_doc)
@@ -177,6 +181,14 @@ def start_repost(account_repost_doc=str) -> None:
 					if not repost_doc.delete_cancelled_entries:
 						doc.make_gl_entries(1)
 					doc.make_gl_entries()
+				elif doc.doctype in frappe.get_hooks("repost_allowed_doctypes"):
+					if hasattr(doc, "make_gl_entries") and callable(doc.make_gl_entries):
+						if not repost_doc.delete_cancelled_entries:
+							if "cancel" in inspect.getfullargspec(doc.make_gl_entries):
+								doc.make_gl_entries(cancel=1)
+							else:
+								make_reverse_gl_entries(voucher_type=doc.doctype, voucher_no=doc.name)
+						doc.make_gl_entries()
 
 
 def get_allowed_types_from_settings():

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -741,20 +741,6 @@ frappe.ui.form.on("Sales Invoice", {
 			};
 		};
 
-		frm.set_query("company_address", function (doc) {
-			if (!doc.company) {
-				frappe.throw(__("Please set Company"));
-			}
-
-			return {
-				query: "frappe.contacts.doctype.address.address.address_query",
-				filters: {
-					link_doctype: "Company",
-					link_name: doc.company,
-				},
-			};
-		});
-
 		frm.set_query("pos_profile", function (doc) {
 			if (!doc.company) {
 				frappe.throw(__("Please set Company"));
@@ -1008,47 +994,51 @@ frappe.ui.form.on("Sales Invoice", {
 
 	refresh: function (frm) {
 		if (frm.doc.docstatus === 0 && !frm.doc.is_return) {
-			frm.add_custom_button(__("Fetch Timesheet"), function () {
-				let d = new frappe.ui.Dialog({
-					title: __("Fetch Timesheet"),
-					fields: [
-						{
-							label: __("From"),
-							fieldname: "from_time",
-							fieldtype: "Date",
-							reqd: 1,
+			frm.add_custom_button(
+				__("Timesheet"),
+				function () {
+					let d = new frappe.ui.Dialog({
+						title: __("Fetch Timesheet"),
+						fields: [
+							{
+								label: __("From"),
+								fieldname: "from_time",
+								fieldtype: "Date",
+								reqd: 1,
+							},
+							{
+								fieldtype: "Column Break",
+								fieldname: "col_break_1",
+							},
+							{
+								label: __("To"),
+								fieldname: "to_time",
+								fieldtype: "Date",
+								reqd: 1,
+							},
+							{
+								label: __("Project"),
+								fieldname: "project",
+								fieldtype: "Link",
+								options: "Project",
+								default: frm.doc.project,
+							},
+						],
+						primary_action: function () {
+							const data = d.get_values();
+							frm.events.add_timesheet_data(frm, {
+								from_time: data.from_time,
+								to_time: data.to_time,
+								project: data.project,
+							});
+							d.hide();
 						},
-						{
-							fieldtype: "Column Break",
-							fieldname: "col_break_1",
-						},
-						{
-							label: __("To"),
-							fieldname: "to_time",
-							fieldtype: "Date",
-							reqd: 1,
-						},
-						{
-							label: __("Project"),
-							fieldname: "project",
-							fieldtype: "Link",
-							options: "Project",
-							default: frm.doc.project,
-						},
-					],
-					primary_action: function () {
-						const data = d.get_values();
-						frm.events.add_timesheet_data(frm, {
-							from_time: data.from_time,
-							to_time: data.to_time,
-							project: data.project,
-						});
-						d.hide();
-					},
-					primary_action_label: __("Get Timesheets"),
-				});
-				d.show();
-			});
+						primary_action_label: __("Get Timesheets"),
+					});
+					d.show();
+				},
+				__("Get Items From")
+			);
 		}
 
 		if (frm.doc.is_debit_note) {

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -159,8 +159,9 @@
   "dispatch_address",
   "company_address_section",
   "company_address",
-  "company_addr_col_break",
   "company_address_display",
+  "company_addr_col_break",
+  "company_contact_person",
   "terms_tab",
   "payment_schedule_section",
   "ignore_default_payment_terms_template",
@@ -2166,6 +2167,13 @@
    "label": "Update Outstanding for Self",
    "no_copy": 1,
    "print_hide": 1
+  },
+  {
+   "fieldname": "company_contact_person",
+   "fieldtype": "Link",
+   "label": "Company Contact Person",
+   "options": "Contact",
+   "print_hide": 1
   }
  ],
  "icon": "fa fa-file-text",
@@ -2178,7 +2186,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2024-07-18 15:30:39.428519",
+ "modified": "2024-11-26 12:34:09.110690",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",
@@ -2233,4 +2241,4 @@
  "title_field": "title",
  "track_changes": 1,
  "track_seen": 1
-}
+}

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -39,7 +39,7 @@ from erpnext.controllers.selling_controller import SellingController
 from erpnext.projects.doctype.timesheet.timesheet import get_projectwise_timesheet_data
 from erpnext.setup.doctype.company.company import update_company_current_month_sales
 from erpnext.stock.doctype.delivery_note.delivery_note import update_billed_amount_based_on_so
-from erpnext.stock.doctype.serial_no.serial_no import get_delivery_note_serial_no, get_serial_nos
+from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
 
 form_grid_templates = {"items": "templates/form_grid/item_grid.html"}
 
@@ -96,6 +96,7 @@ class SalesInvoice(SellingController):
 		company: DF.Link
 		company_address: DF.Link | None
 		company_address_display: DF.SmallText | None
+		company_contact_person: DF.Link | None
 		company_tax_id: DF.Data | None
 		contact_display: DF.SmallText | None
 		contact_email: DF.Data | None
@@ -320,9 +321,7 @@ class SalesInvoice(SellingController):
 		self.set_against_income_account()
 		self.validate_time_sheets_are_submitted()
 		self.validate_multiple_billing("Delivery Note", "dn_detail", "amount")
-		if not self.is_return:
-			self.validate_serial_numbers()
-		else:
+		if self.is_return:
 			self.timesheets = []
 		self.update_packing_list()
 		self.set_billing_hours_and_amount()
@@ -506,7 +505,7 @@ class SalesInvoice(SellingController):
 				frappe.throw(_("Total payments amount can't be greater than {}").format(-invoice_total))
 
 	def validate_pos_paid_amount(self):
-		if len(self.payments) == 0 and self.is_pos:
+		if len(self.payments) == 0 and self.is_pos and flt(self.grand_total) > 0:
 			frappe.throw(_("At least one mode of payment is required for POS invoice."))
 
 	def check_if_consolidated_invoice(self):
@@ -1001,9 +1000,9 @@ class SalesInvoice(SellingController):
 	def validate_pos(self):
 		if self.is_return:
 			invoice_total = self.rounded_total or self.grand_total
-			if flt(self.paid_amount) + flt(self.write_off_amount) - flt(invoice_total) > 1.0 / (
-				10.0 ** (self.precision("grand_total") + 1.0)
-			):
+			if abs(flt(self.paid_amount)) + abs(flt(self.write_off_amount)) - abs(
+				flt(invoice_total)
+			) > 1.0 / (10.0 ** (self.precision("grand_total") + 1.0)):
 				frappe.throw(_("Paid amount + Write Off Amount can not be greater than Grand Total"))
 
 	def validate_warehouse(self):
@@ -1705,55 +1704,11 @@ class SalesInvoice(SellingController):
 		self.set("write_off_amount", reference_doc.get("write_off_amount"))
 		self.due_date = None
 
-	def validate_serial_numbers(self):
-		"""
-		validate serial number agains Delivery Note and Sales Invoice
-		"""
-		self.set_serial_no_against_delivery_note()
-		self.validate_serial_against_delivery_note()
-
-	def set_serial_no_against_delivery_note(self):
-		for item in self.items:
-			if item.serial_no and item.delivery_note and item.qty != len(get_serial_nos(item.serial_no)):
-				item.serial_no = get_delivery_note_serial_no(item.item_code, item.qty, item.delivery_note)
-
-	def validate_serial_against_delivery_note(self):
-		"""
-		validate if the serial numbers in Sales Invoice Items are same as in
-		Delivery Note Item
-		"""
-
-		for item in self.items:
-			if not item.delivery_note or not item.dn_detail:
-				continue
-
-			serial_nos = frappe.db.get_value("Delivery Note Item", item.dn_detail, "serial_no") or ""
-			dn_serial_nos = set(get_serial_nos(serial_nos))
-
-			serial_nos = item.serial_no or ""
-			si_serial_nos = set(get_serial_nos(serial_nos))
-			serial_no_diff = si_serial_nos - dn_serial_nos
-
-			if serial_no_diff:
-				dn_link = frappe.utils.get_link_to_form("Delivery Note", item.delivery_note)
-				serial_no_msg = ", ".join(frappe.bold(d) for d in serial_no_diff)
-
-				msg = _("Row #{0}: The following Serial Nos are not present in Delivery Note {1}:").format(
-					item.idx, dn_link
-				)
-				msg += " " + serial_no_msg
-
-				frappe.throw(msg=msg, title=_("Serial Nos Mismatch"))
-
-			if item.serial_no and cint(item.qty) != len(si_serial_nos):
-				frappe.throw(
-					_("Row #{0}: {1} Serial numbers required for Item {2}. You have provided {3}.").format(
-						item.idx, item.qty, item.item_code, len(si_serial_nos)
-					)
-				)
-
 	def update_project(self):
 		unique_projects = list(set([d.project for d in self.get("items") if d.project]))
+		if self.project and self.project not in unique_projects:
+			unique_projects.append(self.project)
+
 		for p in unique_projects:
 			project = frappe.get_doc("Project", p)
 			project.update_billed_amount()

erpnext/accounts/doctype/sales_invoice/sales_invoice_list.js

@@ -15,7 +15,7 @@ frappe.listview_settings["Sales Invoice"] = {
 	],
 	get_indicator: function (doc) {
 		const status_colors = {
-			Draft: "grey",
+			Draft: "red",
 			Unpaid: "orange",
 			Paid: "green",
 			Return: "gray",

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -43,6 +43,7 @@ from erpnext.stock.doctype.stock_entry.test_stock_entry import (
 from erpnext.stock.doctype.stock_reconciliation.test_stock_reconciliation import (
 	create_stock_reconciliation,
 )
+from erpnext.stock.get_item_details import get_item_tax_map
 from erpnext.stock.utils import get_incoming_rate, get_stock_balance
 
 
@@ -2873,13 +2874,26 @@ class TestSalesInvoice(FrappeTestCase):
 		item.save()
 
 		sales_invoice = create_sales_invoice(item="T Shirt", rate=700, do_not_submit=True)
+		item_tax_map = get_item_tax_map(
+			company=sales_invoice.company,
+			item_tax_template=sales_invoice.items[0].item_tax_template,
+		)
+
 		self.assertEqual(sales_invoice.items[0].item_tax_template, "_Test Account Excise Duty @ 12 - _TC")
+		self.assertEqual(sales_invoice.items[0].item_tax_rate, item_tax_map)
 
 		# Apply discount
 		sales_invoice.apply_discount_on = "Net Total"
 		sales_invoice.discount_amount = 300
 		sales_invoice.save()
+
+		item_tax_map = get_item_tax_map(
+			company=sales_invoice.company,
+			item_tax_template=sales_invoice.items[0].item_tax_template,
+		)
+
 		self.assertEqual(sales_invoice.items[0].item_tax_template, "_Test Account Excise Duty @ 10 - _TC")
+		self.assertEqual(sales_invoice.items[0].item_tax_rate, item_tax_map)
 
 	@change_settings("Selling Settings", {"enable_discount_accounting": 1})
 	def test_sales_invoice_with_discount_accounting_enabled(self):
@@ -4135,6 +4149,102 @@ class TestSalesInvoice(FrappeTestCase):
 		self.assertEqual(len(actual), 4)
 		self.assertEqual(expected, actual)
 
+	@change_settings("Accounts Settings", {"enable_common_party_accounting": True})
+	def test_common_party_with_different_currency_in_debtor_and_creditor(self):
+		from erpnext.accounts.doctype.account.test_account import create_account
+		from erpnext.accounts.doctype.opening_invoice_creation_tool.test_opening_invoice_creation_tool import (
+			make_customer,
+		)
+		from erpnext.accounts.doctype.party_link.party_link import create_party_link
+		from erpnext.buying.doctype.supplier.test_supplier import create_supplier
+		from erpnext.setup.utils import get_exchange_rate
+
+		creditors = create_account(
+			account_name="Creditors INR",
+			parent_account="Accounts Payable - _TC",
+			company="_Test Company",
+			account_currency="INR",
+			account_type="Payable",
+		)
+		debtors = create_account(
+			account_name="Debtors USD",
+			parent_account="Accounts Receivable - _TC",
+			company="_Test Company",
+			account_currency="USD",
+			account_type="Receivable",
+		)
+
+		# create a customer
+		customer = make_customer(customer="_Test Common Party USD")
+		cust_doc = frappe.get_doc("Customer", customer)
+		cust_doc.default_currency = "USD"
+		test_account_details = {
+			"company": "_Test Company",
+			"account": debtors,
+		}
+		cust_doc.append("accounts", test_account_details)
+		cust_doc.save()
+
+		# create a supplier
+		supplier = create_supplier(supplier_name="_Test Common Party INR").name
+		supp_doc = frappe.get_doc("Supplier", supplier)
+		supp_doc.default_currency = "INR"
+		test_account_details = {
+			"company": "_Test Company",
+			"account": creditors,
+		}
+		supp_doc.append("accounts", test_account_details)
+		supp_doc.save()
+
+		# create a party link between customer & supplier
+		create_party_link("Supplier", supplier, customer)
+
+		# create a sales invoice
+		si = create_sales_invoice(
+			customer=customer,
+			currency="USD",
+			conversion_rate=get_exchange_rate("USD", "INR"),
+			debit_to=debtors,
+			do_not_save=1,
+		)
+		si.party_account_currency = "USD"
+		si.save()
+		si.submit()
+
+		# check outstanding of sales invoice
+		si.reload()
+		self.assertEqual(si.status, "Paid")
+		self.assertEqual(flt(si.outstanding_amount), 0.0)
+
+		# check creation of journal entry
+		jv = frappe.get_all(
+			"Journal Entry Account",
+			{
+				"account": si.debit_to,
+				"party_type": "Customer",
+				"party": si.customer,
+				"reference_type": si.doctype,
+				"reference_name": si.name,
+			},
+			pluck="credit_in_account_currency",
+		)
+		self.assertTrue(jv)
+		self.assertEqual(jv[0], si.grand_total)
+
+	def test_total_billed_amount(self):
+		si = create_sales_invoice(do_not_submit=True)
+
+		project = frappe.new_doc("Project")
+		project.project_name = "Test Total Billed Amount"
+		project.save()
+
+		si.project = project.name
+		si.save()
+		si.submit()
+
+		doc = frappe.get_doc("Project", project.name)
+		self.assertEqual(doc.total_billed_amount, si.grand_total)
+
 
 def set_advance_flag(company, flag, default_account):
 	frappe.db.set_value(

erpnext/accounts/doctype/sales_invoice_advance/sales_invoice_advance.json

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

erpnext/accounts/doctype/sales_invoice_advance/sales_invoice_advance.py

@@ -16,6 +16,7 @@ class SalesInvoiceAdvance(Document):
 
 		advance_amount: DF.Currency
 		allocated_amount: DF.Currency
+		difference_posting_date: DF.Date | None
 		exchange_gain_loss: DF.Currency
 		parent: DF.Data
 		parentfield: DF.Data

erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.json

@@ -89,11 +89,14 @@
   "incoming_rate",
   "item_tax_rate",
   "actual_batch_qty",
-  "actual_qty",
   "section_break_eoec",
   "serial_no",
   "column_break_ytgd",
   "batch_no",
+  "available_quantity_section",
+  "actual_qty",
+  "column_break_ogff",
+  "company_total_stock",
   "edit_references",
   "sales_order",
   "so_detail",
@@ -675,7 +678,8 @@
    "allow_on_submit": 1,
    "fieldname": "actual_qty",
    "fieldtype": "Float",
-   "label": "Available Qty at Warehouse",
+   "label": "Qty (Warehouse)",
+   "no_copy": 1,
    "oldfieldname": "actual_qty",
    "oldfieldtype": "Currency",
    "print_hide": 1,
@@ -923,12 +927,30 @@
   {
    "fieldname": "column_break_ytgd",
    "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "available_quantity_section",
+   "fieldtype": "Section Break",
+   "label": "Available Quantity"
+  },
+  {
+   "fieldname": "column_break_ogff",
+   "fieldtype": "Column Break"
+  },
+  {
+   "allow_on_submit": 1,
+   "fieldname": "company_total_stock",
+   "fieldtype": "Float",
+   "label": "Qty (Company)",
+   "no_copy": 1,
+   "print_hide": 1,
+   "read_only": 1
   }
  ],
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-10-28 15:06:40.980995",
+ "modified": "2024-11-25 16:27:33.287341",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Item",

erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.py

@@ -28,6 +28,7 @@ class SalesInvoiceItem(Document):
 		base_rate_with_margin: DF.Currency
 		batch_no: DF.Link | None
 		brand: DF.Data | None
+		company_total_stock: DF.Float
 		conversion_factor: DF.Float
 		cost_center: DF.Link
 		customer_item_code: DF.Data | None

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py

@@ -247,14 +247,14 @@ def get_tax_row_for_tds(tax_details, tax_amount):
 	}
 
 
-def get_lower_deduction_certificate(company, tax_details, pan_no):
+def get_lower_deduction_certificate(company, posting_date, tax_details, pan_no):
 	ldc_name = frappe.db.get_value(
 		"Lower Deduction Certificate",
 		{
 			"pan_no": pan_no,
 			"tax_withholding_category": tax_details.tax_withholding_category,
-			"valid_from": (">=", tax_details.from_date),
-			"valid_upto": ("<=", tax_details.to_date),
+			"valid_from": ("<=", posting_date),
+			"valid_upto": (">=", posting_date),
 			"company": company,
 		},
 		"name",
@@ -302,7 +302,7 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 	tax_amount = 0
 
 	if party_type == "Supplier":
-		ldc = get_lower_deduction_certificate(inv.company, tax_details, pan_no)
+		ldc = get_lower_deduction_certificate(inv.company, posting_date, tax_details, pan_no)
 		if tax_deducted:
 			net_total = inv.tax_withholding_net_total
 			if ldc:
@@ -539,7 +539,7 @@ def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
 	)
 
 	supp_credit_amt = supp_jv_credit_amt
-	supp_credit_amt += inv.tax_withholding_net_total
+	supp_credit_amt += inv.get("tax_withholding_net_total", 0)
 
 	for type in payment_entry_amounts:
 		if type.payment_type == "Pay":
@@ -551,9 +551,9 @@ def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
 	cumulative_threshold = tax_details.get("cumulative_threshold", 0)
 
 	if inv.doctype != "Payment Entry":
-		tax_withholding_net_total = inv.base_tax_withholding_net_total
+		tax_withholding_net_total = inv.get("base_tax_withholding_net_total", 0)
 	else:
-		tax_withholding_net_total = inv.tax_withholding_net_total
+		tax_withholding_net_total = inv.get("tax_withholding_net_total", 0)
 
 	if (threshold and tax_withholding_net_total >= threshold) or (
 		cumulative_threshold and (supp_credit_amt + supp_inv_credit_amt) >= cumulative_threshold

erpnext/accounts/doctype/unreconcile_payment/test_unreconcile_payment.py

@@ -262,6 +262,7 @@ class TestUnreconcilePayment(AccountsTestMixin, FrappeTestCase):
 		pe1.paid_from = self.debtors_usd
 		pe1.paid_from_account_currency = "USD"
 		pe1.source_exchange_rate = 75
+		pe1.paid_amount = 100
 		pe1.received_amount = 75 * 100
 		pe1.save()
 		# Allocate payment against both invoices
@@ -279,6 +280,7 @@ class TestUnreconcilePayment(AccountsTestMixin, FrappeTestCase):
 		pe2.paid_from = self.debtors_usd
 		pe2.paid_from_account_currency = "USD"
 		pe2.source_exchange_rate = 75
+		pe2.paid_amount = 100
 		pe2.received_amount = 75 * 100
 		pe2.save()
 		# Allocate payment against both invoices

erpnext/accounts/general_ledger.py

@@ -315,66 +315,48 @@ def check_if_in_list(gle, gl_map):
 
 
 def toggle_debit_credit_if_negative(gl_map):
+	debit_credit_field_map = {
+		"debit": "credit",
+		"debit_in_account_currency": "credit_in_account_currency",
+		"debit_in_transaction_currency": "credit_in_transaction_currency",
+	}
+
 	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
+		for debit_field, credit_field in debit_credit_field_map.items():
+			debit = flt(entry.get(debit_field))
+			credit = flt(entry.get(credit_field))
 
-		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 debit < 0 and credit < 0 and debit == credit:
+				debit *= -1
+				credit *= -1
 
-		if flt(entry.debit) < 0:
-			entry.credit = flt(entry.credit) - flt(entry.debit)
-			entry.debit = 0.0
+			if debit < 0:
+				credit = credit - debit
+				debit = 0.0
 
-		if flt(entry.debit_in_account_currency) < 0:
-			entry.credit_in_account_currency = flt(entry.credit_in_account_currency) - flt(
-				entry.debit_in_account_currency
-			)
-			entry.debit_in_account_currency = 0.0
+			if credit < 0:
+				debit = debit - credit
+				credit = 0.0
 
-		if flt(entry.credit) < 0:
-			entry.debit = flt(entry.debit) - flt(entry.credit)
-			entry.credit = 0.0
+			# update net values
+			# In some scenarios net value needs to be shown in the ledger
+			# This method updates net values as debit or credit
+			if entry.post_net_value and debit and credit:
+				if debit > credit:
+					debit = debit - credit
+					credit = 0.0
 
-		if flt(entry.credit_in_account_currency) < 0:
-			entry.debit_in_account_currency = flt(entry.debit_in_account_currency) - flt(
-				entry.credit_in_account_currency
-			)
-			entry.credit_in_account_currency = 0.0
+				else:
+					credit = credit - debit
+					debit = 0.0
 
-		update_net_values(entry)
+			entry[debit_field] = debit
+			entry[credit_field] = credit
 
 	return gl_map
 
 
-def update_net_values(entry):
-	# In some scenarios net value needs to be shown in the ledger
-	# This method updates net values as debit or credit
-	if entry.post_net_value and entry.debit and entry.credit:
-		if entry.debit > entry.credit:
-			entry.debit = entry.debit - entry.credit
-			entry.debit_in_account_currency = (
-				entry.debit_in_account_currency - entry.credit_in_account_currency
-			)
-			entry.credit = 0
-			entry.credit_in_account_currency = 0
-		else:
-			entry.credit = entry.credit - entry.debit
-			entry.credit_in_account_currency = (
-				entry.credit_in_account_currency - entry.debit_in_account_currency
-			)
-
-			entry.debit = 0
-			entry.debit_in_account_currency = 0
-
-
 def save_entries(gl_map, adv_adj, update_outstanding, from_repost=False):
 	if not from_repost:
 		validate_cwip_accounts(gl_map)

erpnext/accounts/number_card/total_incoming_bills/total_incoming_bills.json

@@ -4,13 +4,14 @@
  "docstatus": 0,
  "doctype": "Number Card",
  "document_type": "Purchase Invoice",
+ "dynamic_filters_json": "[[\"Purchase Invoice\",\"company\",\"=\",\" frappe.defaults.get_user_default(\\\"Company\\\")\"]]",
  "filters_json": "[[\"Purchase Invoice\",\"docstatus\",\"=\",\"1\",false],[\"Purchase Invoice\",\"posting_date\",\"Timespan\",\"this year\",false]]",
  "function": "Sum",
  "idx": 0,
  "is_public": 1,
  "is_standard": 1,
  "label": "Total Incoming Bills",
- "modified": "2020-07-22 13:06:46.045344",
+ "modified": "2024-11-20 19:08:37.043777",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Total Incoming Bills",

erpnext/accounts/number_card/total_incoming_payment/total_incoming_payment.json

@@ -4,6 +4,7 @@
  "docstatus": 0,
  "doctype": "Number Card",
  "document_type": "Payment Entry",
+ "dynamic_filters_json": "[[\"Payment Entry\",\"company\",\"=\",\"frappe.defaults.get_user_default(\\\"Company\\\")\"]]",
  "filters_json": "[[\"Payment Entry\",\"docstatus\",\"=\",\"1\",false],[\"Payment Entry\",\"posting_date\",\"Timespan\",\"this year\",false],[\"Payment Entry\",\"payment_type\",\"=\",\"Receive\",false]]",
  "function": "Sum",
  "idx": 0,

erpnext/accounts/number_card/total_outgoing_bills/total_outgoing_bills.json

@@ -4,6 +4,7 @@
  "docstatus": 0,
  "doctype": "Number Card",
  "document_type": "Sales Invoice",
+ "dynamic_filters_json": "[[\"Sales Invoice\",\"company\",\"=\",\"frappe.defaults.get_user_default(\\\"Company\\\")\"]]",
  "filters_json": "[[\"Sales Invoice\",\"docstatus\",\"=\",\"1\",false],[\"Sales Invoice\",\"posting_date\",\"Timespan\",\"this year\",false]]",
  "function": "Sum",
  "idx": 0,

erpnext/accounts/number_card/total_outgoing_payment/total_outgoing_payment.json

@@ -4,6 +4,7 @@
  "docstatus": 0,
  "doctype": "Number Card",
  "document_type": "Payment Entry",
+ "dynamic_filters_json": "[[\"Payment Entry\",\"company\",\"=\",\"frappe.defaults.get_user_default(\\\"Company\\\")\"]]",
  "filters_json": "[[\"Payment Entry\",\"docstatus\",\"=\",\"1\",false],[\"Payment Entry\",\"posting_date\",\"Timespan\",\"this year\",false],[\"Payment Entry\",\"payment_type\",\"=\",\"Pay\",false]]",
  "function": "Sum",
  "idx": 0,

erpnext/accounts/party.py

@@ -29,6 +29,12 @@ from erpnext.accounts.utils import get_fiscal_year
 from erpnext.exceptions import InvalidAccountCurrency, PartyDisabled, PartyFrozen
 from erpnext.utilities.regional import temporary_flag
 
+try:
+	from frappe.contacts.doctype.address.address import render_address as _render_address
+except ImportError:
+	# Older frappe versions where this function is not available
+	from frappe.contacts.doctype.address.address import get_address_display as _render_address
+
 PURCHASE_TRANSACTION_TYPES = {
 	"Supplier Quotation",
 	"Purchase Order",
@@ -753,6 +759,20 @@ def validate_party_frozen_disabled(party_type, party_name):
 				frappe.msgprint(_("{0} {1} is not active").format(party_type, party_name), alert=True)
 
 
+def validate_account_party_type(self):
+	if self.is_cancelled:
+		return
+
+	if self.party_type and self.party:
+		account_type = frappe.get_cached_value("Account", self.account, "account_type")
+		if account_type and (account_type not in ["Receivable", "Payable"]):
+			frappe.throw(
+				_(
+					"Party Type and Party can only be set for Receivable / Payable account<br><br>" "{0}"
+				).format(self.account)
+			)
+
+
 def get_dashboard_info(party_type, party, loyalty_program=None):
 	current_fiscal_year = get_fiscal_year(nowdate(), as_dict=True)
 
@@ -982,10 +1002,4 @@ def add_party_account(party_type, party, company, account):
 
 
 def render_address(address, check_permissions=True):
-	try:
-		from frappe.contacts.doctype.address.address import render_address as _render
-	except ImportError:
-		# Older frappe versions where this function is not available
-		from frappe.contacts.doctype.address.address import get_address_display as _render
-
-	return frappe.call(_render, address, check_permissions=check_permissions)
+	return frappe.call(_render_address, address, check_permissions=check_permissions)

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -134,7 +134,6 @@ class ReceivablePayableReport:
 			paid_in_account_currency=0.0,
 			credit_note_in_account_currency=0.0,
 			outstanding_in_account_currency=0.0,
-			cost_center=ple.cost_center,
 		)
 
 	def init_voucher_balance(self):
@@ -150,6 +149,9 @@ class ReceivablePayableReport:
 			if key not in self.voucher_balance:
 				self.voucher_balance[key] = self.build_voucher_dict(ple)
 
+			if ple.voucher_type == ple.against_voucher_type and ple.voucher_no == ple.against_voucher_no:
+				self.voucher_balance[key].cost_center = ple.cost_center
+
 			self.get_invoices(ple)
 
 			if self.filters.get("group_by_party"):
@@ -275,9 +277,6 @@ class ReceivablePayableReport:
 				row.paid -= amount
 				row.paid_in_account_currency -= amount_in_account_currency
 
-		if not row.cost_center and ple.cost_center:
-			row.cost_center = str(ple.cost_center)
-
 	def update_sub_total_row(self, row, party):
 		total_row = self.total_row_map.get(party)
 
@@ -551,9 +550,7 @@ class ReceivablePayableReport:
 			self.append_payment_term(row, d, term)
 
 	def append_payment_term(self, row, d, term):
-		if (
-			self.filters.get("customer") or self.filters.get("supplier")
-		) and d.currency == d.party_account_currency:
+		if d.currency == d.party_account_currency:
 			invoiced = d.payment_amount
 		else:
 			invoiced = d.base_payment_amount
@@ -1013,22 +1010,29 @@ class ReceivablePayableReport:
 
 	def get_columns(self):
 		self.columns = []
-		self.add_column("Posting Date", fieldtype="Date")
+		self.add_column(_("Posting Date"), fieldname="posting_date", fieldtype="Date")
 		self.add_column(
-			label="Party Type",
+			label=_("Party Type"),
 			fieldname="party_type",
 			fieldtype="Data",
 			width=100,
 		)
 		self.add_column(
-			label="Party",
+			label=_("Party"),
 			fieldname="party",
 			fieldtype="Dynamic Link",
 			options="party_type",
 			width=180,
 		)
+		if self.account_type == "Receivable":
+			label = _("Receivable Account")
+		elif self.account_type == "Payable":
+			label = _("Payable Account")
+		else:
+			label = _("Party Account")
+
 		self.add_column(
-			label=self.account_type + " Account",
+			label=label,
 			fieldname="party_account",
 			fieldtype="Link",
 			options="Account",
@@ -1037,10 +1041,10 @@ class ReceivablePayableReport:
 
 		if self.party_naming_by == "Naming Series":
 			if self.account_type == "Payable":
-				label = "Supplier Name"
+				label = _("Supplier Name")
 				fieldname = "supplier_name"
 			else:
-				label = "Customer Name"
+				label = _("Customer Name")
 				fieldname = "customer_name"
 			self.add_column(
 				label=label,
@@ -1066,7 +1070,7 @@ class ReceivablePayableReport:
 			width=180,
 		)
 
-		self.add_column(label="Due Date", fieldtype="Date")
+		self.add_column(label=_("Due Date"), fieldname="due_date", fieldtype="Date")
 
 		if self.account_type == "Payable":
 			self.add_column(label=_("Bill No"), fieldname="bill_no", fieldtype="Data")

erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py

@@ -89,7 +89,9 @@ def get_data(filters):
 						& (DepreciationSchedule.schedule_date == d.posting_date)
 					)
 				).run(as_dict=True)
-				asset_data.accumulated_depreciation_amount = query[0]["accumulated_depreciation_amount"]
+				asset_data.accumulated_depreciation_amount = (
+					query[0]["accumulated_depreciation_amount"] if query else 0
+				)
 
 			else:
 				asset_data.accumulated_depreciation_amount += d.debit

erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py

@@ -28,15 +28,14 @@ def get_group_by_asset_category_data(filters):
 
 	for asset_category in asset_categories:
 		row = frappe._dict()
-		# row.asset_category = asset_category
 		row.update(asset_category)
 
-		row.cost_as_on_to_date = (
-			flt(row.cost_as_on_from_date)
-			+ flt(row.cost_of_new_purchase)
-			- flt(row.cost_of_sold_asset)
-			- flt(row.cost_of_scrapped_asset)
-			- flt(row.cost_of_capitalized_asset)
+		row.value_as_on_to_date = (
+			flt(row.value_as_on_from_date)
+			+ flt(row.value_of_new_purchase)
+			- flt(row.value_of_sold_asset)
+			- flt(row.value_of_scrapped_asset)
+			- flt(row.value_of_capitalized_asset)
 		)
 
 		row.update(
@@ -53,11 +52,11 @@ def get_group_by_asset_category_data(filters):
 			- flt(row.depreciation_eliminated_during_the_period)
 		)
 
-		row.net_asset_value_as_on_from_date = flt(row.cost_as_on_from_date) - flt(
+		row.net_asset_value_as_on_from_date = flt(row.value_as_on_from_date) - flt(
 			row.accumulated_depreciation_as_on_from_date
 		)
 
-		row.net_asset_value_as_on_to_date = flt(row.cost_as_on_to_date) - flt(
+		row.net_asset_value_as_on_to_date = flt(row.value_as_on_to_date) - flt(
 			row.accumulated_depreciation_as_on_to_date
 		)
 
@@ -85,12 +84,12 @@ def get_asset_categories_for_grouped_by_category(filters):
 							   end
 						   else
 								0
-						   end), 0) as cost_as_on_from_date,
+						   end), 0) as value_as_on_from_date,
 			   ifnull(sum(case when a.purchase_date >= %(from_date)s then
 			   						a.gross_purchase_amount
 			   				   else
 			   				   		0
-			   				   end), 0) as cost_of_new_purchase,
+			   				   end), 0) as value_of_new_purchase,
 			   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
 			   						and a.disposal_date >= %(from_date)s
 			   						and a.disposal_date <= %(to_date)s then
@@ -101,7 +100,7 @@ def get_asset_categories_for_grouped_by_category(filters):
 							   end
 						   else
 								0
-						   end), 0) as cost_of_sold_asset,
+						   end), 0) as value_of_sold_asset,
 			   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
 			   						and a.disposal_date >= %(from_date)s
 			   						and a.disposal_date <= %(to_date)s then
@@ -112,7 +111,7 @@ def get_asset_categories_for_grouped_by_category(filters):
 							   end
 						   else
 								0
-						   end), 0) as cost_of_scrapped_asset,
+						   end), 0) as value_of_scrapped_asset,
 				ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
 			   						and a.disposal_date >= %(from_date)s
 			   						and a.disposal_date <= %(to_date)s then
@@ -123,7 +122,7 @@ def get_asset_categories_for_grouped_by_category(filters):
 							   end
 						   else
 								0
-						   end), 0) as cost_of_capitalized_asset
+						   end), 0) as value_of_capitalized_asset
 		from `tabAsset` a
 		where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s {condition}
 			and not exists(
@@ -164,12 +163,12 @@ def get_asset_details_for_grouped_by_category(filters):
 							   end
 						   else
 								0
-						   end), 0) as cost_as_on_from_date,
+						   end), 0) as value_as_on_from_date,
 			   ifnull(sum(case when a.purchase_date >= %(from_date)s then
 			   						a.gross_purchase_amount
 			   				   else
 			   				   		0
-			   				   end), 0) as cost_of_new_purchase,
+			   				   end), 0) as value_of_new_purchase,
 			   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
 			   						and a.disposal_date >= %(from_date)s
 			   						and a.disposal_date <= %(to_date)s then
@@ -180,7 +179,7 @@ def get_asset_details_for_grouped_by_category(filters):
 							   end
 						   else
 								0
-						   end), 0) as cost_of_sold_asset,
+						   end), 0) as value_of_sold_asset,
 			   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
 			   						and a.disposal_date >= %(from_date)s
 			   						and a.disposal_date <= %(to_date)s then
@@ -191,7 +190,7 @@ def get_asset_details_for_grouped_by_category(filters):
 							   end
 						   else
 								0
-						   end), 0) as cost_of_scrapped_asset,
+						   end), 0) as value_of_scrapped_asset,
 				ifnull(sum(case when ifnull(a.disposal_date, 0) != 0
 			   						and a.disposal_date >= %(from_date)s
 			   						and a.disposal_date <= %(to_date)s then
@@ -202,7 +201,7 @@ def get_asset_details_for_grouped_by_category(filters):
 							   end
 						   else
 								0
-						   end), 0) as cost_of_capitalized_asset
+						   end), 0) as value_of_capitalized_asset
 		from `tabAsset` a
 		where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s {condition}
 		and not exists(
@@ -232,15 +231,14 @@ def get_group_by_asset_data(filters):
 
 	for asset_detail in asset_details:
 		row = frappe._dict()
-		# row.asset_category = asset_category
 		row.update(asset_detail)
 
-		row.cost_as_on_to_date = (
-			flt(row.cost_as_on_from_date)
-			+ flt(row.cost_of_new_purchase)
-			- flt(row.cost_of_sold_asset)
-			- flt(row.cost_of_scrapped_asset)
-			- flt(row.cost_of_capitalized_asset)
+		row.value_as_on_to_date = (
+			flt(row.value_as_on_from_date)
+			+ flt(row.value_of_new_purchase)
+			- flt(row.value_of_sold_asset)
+			- flt(row.value_of_scrapped_asset)
+			- flt(row.value_of_capitalized_asset)
 		)
 
 		row.update(next(asset for asset in assets if asset["asset"] == asset_detail.get("name", "")))
@@ -251,11 +249,11 @@ def get_group_by_asset_data(filters):
 			- flt(row.depreciation_eliminated_during_the_period)
 		)
 
-		row.net_asset_value_as_on_from_date = flt(row.cost_as_on_from_date) - flt(
+		row.net_asset_value_as_on_from_date = flt(row.value_as_on_from_date) - flt(
 			row.accumulated_depreciation_as_on_from_date
 		)
 
-		row.net_asset_value_as_on_to_date = flt(row.cost_as_on_to_date) - flt(
+		row.net_asset_value_as_on_to_date = flt(row.value_as_on_to_date) - flt(
 			row.accumulated_depreciation_as_on_to_date
 		)
 
@@ -446,38 +444,38 @@ def get_columns(filters):
 
 	columns += [
 		{
-			"label": _("Cost as on") + " " + formatdate(filters.day_before_from_date),
-			"fieldname": "cost_as_on_from_date",
+			"label": _("Value as on") + " " + formatdate(filters.day_before_from_date),
+			"fieldname": "value_as_on_from_date",
 			"fieldtype": "Currency",
 			"width": 140,
 		},
 		{
-			"label": _("Cost of New Purchase"),
-			"fieldname": "cost_of_new_purchase",
+			"label": _("Value of New Purchase"),
+			"fieldname": "value_of_new_purchase",
 			"fieldtype": "Currency",
 			"width": 140,
 		},
 		{
-			"label": _("Cost of Sold Asset"),
-			"fieldname": "cost_of_sold_asset",
+			"label": _("Value of Sold Asset"),
+			"fieldname": "value_of_sold_asset",
 			"fieldtype": "Currency",
 			"width": 140,
 		},
 		{
-			"label": _("Cost of Scrapped Asset"),
-			"fieldname": "cost_of_scrapped_asset",
+			"label": _("Value of Scrapped Asset"),
+			"fieldname": "value_of_scrapped_asset",
 			"fieldtype": "Currency",
 			"width": 140,
 		},
 		{
-			"label": _("Cost of New Capitalized Asset"),
-			"fieldname": "cost_of_capitalized_asset",
+			"label": _("Value of New Capitalized Asset"),
+			"fieldname": "value_of_capitalized_asset",
 			"fieldtype": "Currency",
 			"width": 140,
 		},
 		{
-			"label": _("Cost as on") + " " + formatdate(filters.to_date),
-			"fieldname": "cost_as_on_to_date",
+			"label": _("Value as on") + " " + formatdate(filters.to_date),
+			"fieldname": "value_as_on_to_date",
 			"fieldtype": "Currency",
 			"width": 140,
 		},

erpnext/accounts/report/balance_sheet/balance_sheet.py

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

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py

@@ -142,7 +142,8 @@ def get_journal_entries(filters):
 		where jvd.parent = jv.name and jv.docstatus=1
 			and jvd.account = %(account)s and jv.posting_date <= %(report_date)s
 			and ifnull(jv.clearance_date, '4000-01-01') > %(report_date)s
-			and ifnull(jv.is_opening, 'No') = 'No'""",
+			and ifnull(jv.is_opening, 'No') = 'No'
+			and jv.company = %(company)s """,
 		filters,
 		as_dict=1,
 	)
@@ -163,6 +164,7 @@ def get_payment_entries(filters):
 			(paid_from=%(account)s or paid_to=%(account)s) and docstatus=1
 			and posting_date <= %(report_date)s
 			and ifnull(clearance_date, '4000-01-01') > %(report_date)s
+			and company = %(company)s
 	""",
 		filters,
 		as_dict=1,
@@ -181,6 +183,7 @@ def get_pos_entries(filters):
 				sip.account=%(account)s and si.docstatus=1 and sip.parent = si.name
 				and account.name = sip.account and si.posting_date <= %(report_date)s and
 				ifnull(sip.clearance_date, '4000-01-01') > %(report_date)s
+				and si.company = %(company)s
 			order by
 				si.posting_date ASC, si.name DESC
 		""",

erpnext/accounts/report/cash_flow/cash_flow.js

@@ -1,7 +1,10 @@
 // Copyright (c) 2013, Frappe Technologies Pvt. Ltd. and contributors
 // For license information, please see license.txt
 
-frappe.query_reports["Cash Flow"] = $.extend({}, erpnext.financial_statements);
+frappe.query_reports["Cash Flow"] = $.extend(erpnext.financial_statements, {
+	name_field: "section",
+	parent_field: "parent_section",
+});
 
 erpnext.utils.add_dimensions("Cash Flow", 10);
 

erpnext/accounts/report/cash_flow/cash_flow.py

@@ -30,7 +30,7 @@ def execute(filters=None):
 		company=filters.company,
 	)
 
-	cash_flow_accounts = get_cash_flow_accounts()
+	cash_flow_sections = get_cash_flow_accounts()
 
 	# compute net profit / loss
 	income = get_data(
@@ -60,14 +60,14 @@ def execute(filters=None):
 	summary_data = {}
 	company_currency = frappe.get_cached_value("Company", filters.company, "default_currency")
 
-	for cash_flow_account in cash_flow_accounts:
+	for cash_flow_section in cash_flow_sections:
 		section_data = []
 		data.append(
 			{
-				"account_name": cash_flow_account["section_header"],
-				"parent_account": None,
+				"section_name": "'" + cash_flow_section["section_header"] + "'",
+				"parent_section": None,
 				"indent": 0.0,
-				"account": cash_flow_account["section_header"],
+				"section": cash_flow_section["section_header"],
 			}
 		)
 
@@ -75,31 +75,40 @@ def execute(filters=None):
 			# add first net income in operations section
 			if net_profit_loss:
 				net_profit_loss.update(
-					{"indent": 1, "parent_account": cash_flow_accounts[0]["section_header"]}
+					{"indent": 1, "parent_section": cash_flow_sections[0]["section_header"]}
 				)
 				data.append(net_profit_loss)
 				section_data.append(net_profit_loss)
 
-		for account in cash_flow_account["account_types"]:
-			account_data = get_account_type_based_data(
-				filters.company, account["account_type"], period_list, filters.accumulated_values, filters
+		for row in cash_flow_section["account_types"]:
+			row_data = get_account_type_based_data(
+				filters.company, row["account_type"], period_list, filters.accumulated_values, filters
 			)
-			account_data.update(
+			accounts = frappe.get_all(
+				"Account",
+				filters={
+					"account_type": row["account_type"],
+					"is_group": 0,
+				},
+				pluck="name",
+			)
+			row_data.update(
 				{
-					"account_name": account["label"],
-					"account": account["label"],
+					"section_name": row["label"],
+					"section": row["label"],
 					"indent": 1,
-					"parent_account": cash_flow_account["section_header"],
+					"accounts": accounts,
+					"parent_section": cash_flow_section["section_header"],
 					"currency": company_currency,
 				}
 			)
-			data.append(account_data)
-			section_data.append(account_data)
+			data.append(row_data)
+			section_data.append(row_data)
 
 		add_total_row_account(
 			data,
 			section_data,
-			cash_flow_account["section_footer"],
+			cash_flow_section["section_footer"],
 			period_list,
 			company_currency,
 			summary_data,
@@ -109,7 +118,7 @@ def execute(filters=None):
 	add_total_row_account(
 		data, data, _("Net Change in Cash"), period_list, company_currency, summary_data, filters
 	)
-	columns = get_columns(filters.periodicity, period_list, filters.accumulated_values, filters.company)
+	columns = get_columns(filters.periodicity, period_list, filters.accumulated_values, filters.company, True)
 
 	chart = get_chart_data(columns, data, company_currency)
 
@@ -217,8 +226,8 @@ def get_start_date(period, accumulated_values, company):
 
 def add_total_row_account(out, data, label, period_list, currency, summary_data, filters, consolidated=False):
 	total_row = {
-		"account_name": "'" + _("{0}").format(label) + "'",
-		"account": "'" + _("{0}").format(label) + "'",
+		"section_name": "'" + _("{0}").format(label) + "'",
+		"section": "'" + _("{0}").format(label) + "'",
 		"currency": currency,
 	}
 
@@ -229,7 +238,7 @@ def add_total_row_account(out, data, label, period_list, currency, summary_data,
 		period_list = get_filtered_list_for_consolidated_report(filters, period_list)
 
 	for row in data:
-		if row.get("parent_account"):
+		if row.get("parent_section"):
 			for period in period_list:
 				key = period if consolidated else period["key"]
 				total_row.setdefault(key, 0.0)
@@ -254,13 +263,14 @@ def get_report_summary(summary_data, currency):
 
 def get_chart_data(columns, data, currency):
 	labels = [d.get("label") for d in columns[2:]]
+	print(data)
 	datasets = [
 		{
-			"name": account.get("account").replace("'", ""),
-			"values": [account.get(d.get("fieldname")) for d in columns[2:]],
+			"name": section.get("section").replace("'", ""),
+			"values": [section.get(d.get("fieldname")) for d in columns[2:]],
 		}
-		for account in data
-		if account.get("parent_account") is None and account.get("currency")
+		for section in data
+		if section.get("parent_section") is None and section.get("currency")
 	]
 	datasets = datasets[:-1]
 

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py

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

erpnext/accounts/report/financial_statements.py

@@ -2,6 +2,7 @@
 # License: GNU General Public License v3. See license.txt
 
 
+import copy
 import functools
 import math
 import re
@@ -334,8 +335,8 @@ def filter_out_zero_value_rows(data, parent_children_map, show_zero_values=False
 
 def add_total_row(out, root_type, balance_must_be, period_list, company_currency):
 	total_row = {
-		"account_name": _("Total {0} ({1})").format(_(root_type), _(balance_must_be)),
-		"account": _("Total {0} ({1})").format(_(root_type), _(balance_must_be)),
+		"account_name": "'" + _("Total {0} ({1})").format(_(root_type), _(balance_must_be)) + "'",
+		"account": "'" + _("Total {0} ({1})").format(_(root_type), _(balance_must_be)) + "'",
 		"currency": company_currency,
 		"opening_balance": 0.0,
 	}
@@ -526,9 +527,15 @@ def get_accounting_entries(
 		account_filter_query = get_account_filter_query(root_lft, root_rgt, root_type, gl_entry)
 		query = query.where(ExistsCriterion(account_filter_query))
 
-	entries = query.run(as_dict=True)
+	from frappe.desk.reportview import build_match_conditions
 
-	return entries
+	query, params = query.walk()
+	match_conditions = build_match_conditions(doctype)
+
+	if match_conditions:
+		query += "and" + match_conditions
+
+	return frappe.db.sql(query, params, as_dict=True)
 
 
 def get_account_filter_query(root_lft, root_rgt, root_type, gl_entry):
@@ -616,11 +623,11 @@ def get_cost_centers_with_children(cost_centers):
 	return list(set(all_cost_centers))
 
 
-def get_columns(periodicity, period_list, accumulated_values=1, company=None):
+def get_columns(periodicity, period_list, accumulated_values=1, company=None, cash_flow=False):
 	columns = [
 		{
 			"fieldname": "account",
-			"label": _("Account"),
+			"label": _("Account") if not cash_flow else _("Section"),
 			"fieldtype": "Link",
 			"options": "Account",
 			"width": 300,
@@ -668,3 +675,67 @@ def get_filtered_list_for_consolidated_report(filters, period_list):
 			filtered_summary_list.append(period)
 
 	return filtered_summary_list
+
+
+def compute_growth_view_data(data, columns):
+	data_copy = copy.deepcopy(data)
+
+	for row_idx in range(len(data_copy)):
+		for column_idx in range(1, len(columns)):
+			previous_period_key = columns[column_idx - 1].get("key")
+			current_period_key = columns[column_idx].get("key")
+			current_period_value = data_copy[row_idx].get(current_period_key)
+			previous_period_value = data_copy[row_idx].get(previous_period_key)
+			annual_growth = 0
+
+			if current_period_value is None:
+				data[row_idx][current_period_key] = None
+				continue
+
+			if previous_period_value == 0 and current_period_value > 0:
+				annual_growth = 1
+
+			elif previous_period_value > 0:
+				annual_growth = (current_period_value - previous_period_value) / previous_period_value
+
+			growth_percent = round(annual_growth * 100, 2)
+
+			data[row_idx][current_period_key] = growth_percent
+
+
+def compute_margin_view_data(data, columns, accumulated_values):
+	if not columns:
+		return
+
+	if not accumulated_values:
+		columns.append({"key": "total"})
+
+	data_copy = copy.deepcopy(data)
+
+	base_row = None
+	for row in data_copy:
+		if row.get("account_name") == _("Income"):
+			base_row = row
+			break
+
+	if not base_row:
+		return
+
+	for row_idx in range(len(data_copy)):
+		# Taking the total income from each column (for all the financial years) as the base (100%)
+		row = data_copy[row_idx]
+		if not row:
+			continue
+
+		for column in columns:
+			curr_period = column.get("key")
+			base_value = base_row[curr_period]
+			curr_value = row[curr_period]
+
+			if curr_value is None or base_value <= 0:
+				data[row_idx][curr_period] = None
+				continue
+
+			margin_percent = round((curr_value / base_value) * 100, 2)
+
+			data[row_idx][curr_period] = margin_percent

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -35,9 +35,6 @@ def execute(filters=None):
 	if filters.get("party"):
 		filters.party = frappe.parse_json(filters.get("party"))
 
-	if filters.get("voucher_no") and not filters.get("group_by"):
-		filters.group_by = "Group by Voucher (Consolidated)"
-
 	validate_filters(filters, account_details)
 
 	validate_party(filters)
@@ -373,16 +370,21 @@ def get_data_with_opening_closing(filters, account_details, accounting_dimension
 			if acc_dict.entries:
 				# opening
 				data.append({"debit_in_transaction_currency": None, "credit_in_transaction_currency": None})
-				if filters.get("group_by") != "Group by Voucher":
+				if (not filters.get("group_by") and not filters.get("voucher_no")) or (
+					filters.get("group_by") and filters.get("group_by") != "Group by Voucher"
+				):
 					data.append(acc_dict.totals.opening)
 
 				data += acc_dict.entries
 
 				# totals
-				data.append(acc_dict.totals.total)
+				if filters.get("group_by") or not filters.voucher_no:
+					data.append(acc_dict.totals.total)
 
 				# closing
-				if filters.get("group_by") != "Group by Voucher":
+				if (not filters.get("group_by") and not filters.get("voucher_no")) or (
+					filters.get("group_by") and filters.get("group_by") != "Group by Voucher"
+				):
 					data.append(acc_dict.totals.closing)
 
 		data.append({"debit_in_transaction_currency": None, "credit_in_transaction_currency": None})

erpnext/accounts/report/gross_profit/gross_profit.py

@@ -421,10 +421,10 @@ class GrossProfitGenerator:
 		self.load_invoice_items()
 		self.get_delivery_notes()
 
+		self.load_product_bundle()
 		if filters.group_by == "Invoice":
 			self.group_items_by_invoice()
 
-		self.load_product_bundle()
 		self.load_non_stock_items()
 		self.get_returned_invoice_items()
 		self.process()
@@ -440,6 +440,7 @@ class GrossProfitGenerator:
 
 		if grouped_by_invoice:
 			buying_amount = 0
+			base_amount = 0
 
 		for row in reversed(self.si_list):
 			if self.filters.get("group_by") == "Monthly":
@@ -480,12 +481,11 @@ class GrossProfitGenerator:
 			else:
 				row.buying_amount = flt(self.get_buying_amount(row, row.item_code), self.currency_precision)
 
-			if grouped_by_invoice:
-				if row.indent == 1.0:
-					buying_amount += row.buying_amount
-				elif row.indent == 0.0:
-					row.buying_amount = buying_amount
-					buying_amount = 0
+			if grouped_by_invoice and row.indent == 0.0:
+				row.buying_amount = buying_amount
+				row.base_amount = base_amount
+				buying_amount = 0
+				base_amount = 0
 
 			# get buying rate
 			if flt(row.qty):
@@ -495,11 +495,19 @@ class GrossProfitGenerator:
 				if self.is_not_invoice_row(row):
 					row.buying_rate, row.base_rate = 0.0, 0.0
 
+			if self.is_not_invoice_row(row):
+				self.update_return_invoices(row)
+
+			if grouped_by_invoice and row.indent == 1.0:
+				buying_amount += row.buying_amount
+				base_amount += row.base_amount
+
 			# calculate gross profit
 			row.gross_profit = flt(row.base_amount - row.buying_amount, self.currency_precision)
 			if row.base_amount:
 				row.gross_profit_percent = flt(
-					(row.gross_profit / row.base_amount) * 100.0, self.currency_precision
+					(row.gross_profit / row.base_amount) * 100.0,
+					self.currency_precision,
 				)
 			else:
 				row.gross_profit_percent = 0.0
@@ -510,33 +518,29 @@ class GrossProfitGenerator:
 		if self.grouped:
 			self.get_average_rate_based_on_group_by()
 
+	def update_return_invoices(self, row):
+		if row.parent in self.returned_invoices and row.item_code in self.returned_invoices[row.parent]:
+			returned_item_rows = self.returned_invoices[row.parent][row.item_code]
+			for returned_item_row in returned_item_rows:
+				# returned_items 'qty' should be stateful
+				if returned_item_row.qty != 0:
+					if row.qty >= abs(returned_item_row.qty):
+						row.qty += returned_item_row.qty
+						row.base_amount += flt(returned_item_row.base_amount, self.currency_precision)
+						returned_item_row.qty = 0
+						returned_item_row.base_amount = 0
+
+					else:
+						row.qty = 0
+						row.base_amount = 0
+						returned_item_row.qty += row.qty
+						returned_item_row.base_amount += row.base_amount
+
+			row.buying_amount = flt(flt(row.qty) * flt(row.buying_rate), self.currency_precision)
+
 	def get_average_rate_based_on_group_by(self):
 		for key in list(self.grouped):
-			if self.filters.get("group_by") == "Invoice":
-				for row in self.grouped[key]:
-					if row.indent == 1.0:
-						if (
-							row.parent in self.returned_invoices
-							and row.item_code in self.returned_invoices[row.parent]
-						):
-							returned_item_rows = self.returned_invoices[row.parent][row.item_code]
-							for returned_item_row in returned_item_rows:
-								# returned_items 'qty' should be stateful
-								if returned_item_row.qty != 0:
-									if row.qty >= abs(returned_item_row.qty):
-										row.qty += returned_item_row.qty
-										returned_item_row.qty = 0
-									else:
-										row.qty = 0
-										returned_item_row.qty += row.qty
-								row.base_amount += flt(returned_item_row.base_amount, self.currency_precision)
-							row.buying_amount = flt(
-								flt(row.qty) * flt(row.buying_rate), self.currency_precision
-							)
-						if flt(row.qty) or row.base_amount:
-							row = self.set_average_rate(row)
-							self.grouped_data.append(row)
-			elif self.filters.get("group_by") == "Payment Term":
+			if self.filters.get("group_by") == "Payment Term":
 				for i, row in enumerate(self.grouped[key]):
 					invoice_portion = 0
 
@@ -556,7 +560,7 @@ class GrossProfitGenerator:
 
 				new_row = self.set_average_rate(new_row)
 				self.grouped_data.append(new_row)
-			else:
+			elif self.filters.get("group_by") != "Invoice":
 				for i, row in enumerate(self.grouped[key]):
 					if i == 0:
 						new_row = row
@@ -632,6 +636,8 @@ class GrossProfitGenerator:
 			if packed_item.get("parent_detail_docname") == row.item_row:
 				packed_item_row = row.copy()
 				packed_item_row.warehouse = packed_item.warehouse
+				packed_item_row.qty = packed_item.total_qty * -1
+				packed_item_row.serial_and_batch_bundle = packed_item.serial_and_batch_bundle
 				buying_amount += self.get_buying_amount(packed_item_row, packed_item.item_code)
 
 		return flt(buying_amount, self.currency_precision)
@@ -664,7 +670,9 @@ class GrossProfitGenerator:
 		else:
 			my_sle = self.get_stock_ledger_entries(item_code, row.warehouse)
 			if (row.update_stock or row.dn_detail) and my_sle:
-				parenttype, parent = row.parenttype, row.parent
+				parenttype = row.parenttype
+				parent = row.invoice or row.parent
+
 				if row.dn_detail:
 					parenttype, parent = "Delivery Note", row.delivery_note
 
@@ -721,6 +729,7 @@ class GrossProfitGenerator:
 					"voucher_no": row.parent,
 					"allow_zero_valuation": True,
 					"company": self.filters.company,
+					"item_code": item_code,
 				}
 			)
 
@@ -741,12 +750,13 @@ class GrossProfitGenerator:
 			.inner_join(purchase_invoice)
 			.on(purchase_invoice.name == purchase_invoice_item.parent)
 			.select(
-				purchase_invoice.name,
 				purchase_invoice_item.base_rate / purchase_invoice_item.conversion_factor,
 			)
 			.where(purchase_invoice.docstatus == 1)
 			.where(purchase_invoice.posting_date <= self.filters.to_date)
 			.where(purchase_invoice_item.item_code == item_code)
+			.where(purchase_invoice.is_return == 0)
+			.where(purchase_invoice_item.parenttype == "Purchase Invoice")
 		)
 
 		if row.project:
@@ -783,7 +793,10 @@ class GrossProfitGenerator:
 			"""
 
 		if self.filters.group_by == "Sales Person":
-			sales_person_cols = ", sales.sales_person, sales.allocated_amount, sales.incentives"
+			sales_person_cols = """, sales.sales_person,
+				sales.allocated_percentage * `tabSales Invoice Item`.base_net_amount / 100 as allocated_amount,
+				sales.incentives
+			"""
 			sales_team_table = "left join `tabSales Team` sales on sales.parent = `tabSales Invoice`.name"
 		else:
 			sales_person_cols = ""
@@ -847,6 +860,7 @@ class GrossProfitGenerator:
 				`tabSales Invoice`.project, `tabSales Invoice`.update_stock,
 				`tabSales Invoice`.customer, `tabSales Invoice`.customer_group,
 				`tabSales Invoice`.territory, `tabSales Invoice Item`.item_code,
+				`tabSales Invoice`.base_net_total as "invoice_base_net_total",
 				`tabSales Invoice Item`.item_name, `tabSales Invoice Item`.description,
 				`tabSales Invoice Item`.warehouse, `tabSales Invoice Item`.item_group,
 				`tabSales Invoice Item`.brand, `tabSales Invoice Item`.so_detail,
@@ -907,6 +921,7 @@ class GrossProfitGenerator:
 		"""
 
 		grouped = OrderedDict()
+		product_bundles = self.product_bundles.get("Sales Invoice", {})
 
 		for row in self.si_list:
 			# initialize list with a header row for each new parent
@@ -917,8 +932,7 @@ class GrossProfitGenerator:
 			)
 
 			# if item is a bundle, add it's components as seperate rows
-			if frappe.db.exists("Product Bundle", row.item_code):
-				bundled_items = self.get_bundle_items(row)
+			if bundled_items := product_bundles.get(row.parent, {}).get(row.item_code):
 				for x in bundled_items:
 					bundle_item = self.get_bundle_item_row(row, x)
 					grouped.get(row.parent).append(bundle_item)
@@ -954,47 +968,41 @@ class GrossProfitGenerator:
 				"item_row": None,
 				"is_return": row.is_return,
 				"cost_center": row.cost_center,
-				"base_net_amount": frappe.db.get_value("Sales Invoice", row.parent, "base_net_total"),
+				"base_net_amount": row.invoice_base_net_total,
 			}
 		)
 
-	def get_bundle_items(self, product_bundle):
-		return frappe.get_all(
-			"Product Bundle Item", filters={"parent": product_bundle.item_code}, fields=["item_code", "qty"]
-		)
-
-	def get_bundle_item_row(self, product_bundle, item):
-		item_name, description, item_group, brand = self.get_bundle_item_details(item.item_code)
-
+	def get_bundle_item_row(self, row, item):
 		return frappe._dict(
 			{
-				"parent_invoice": product_bundle.item_code,
-				"indent": product_bundle.indent + 1,
+				"parent_invoice": row.item_code,
+				"parenttype": row.parenttype,
+				"indent": row.indent + 1,
 				"parent": None,
 				"invoice_or_item": item.item_code,
-				"posting_date": product_bundle.posting_date,
-				"posting_time": product_bundle.posting_time,
-				"project": product_bundle.project,
-				"customer": product_bundle.customer,
-				"customer_group": product_bundle.customer_group,
+				"posting_date": row.posting_date,
+				"posting_time": row.posting_time,
+				"project": row.project,
+				"customer": row.customer,
+				"customer_group": row.customer_group,
 				"item_code": item.item_code,
-				"item_name": item_name,
-				"description": description,
-				"warehouse": product_bundle.warehouse,
-				"item_group": item_group,
-				"brand": brand,
-				"dn_detail": product_bundle.dn_detail,
-				"delivery_note": product_bundle.delivery_note,
-				"qty": (flt(product_bundle.qty) * flt(item.qty)),
-				"item_row": None,
-				"is_return": product_bundle.is_return,
-				"cost_center": product_bundle.cost_center,
+				"item_name": item.item_name,
+				"description": item.description,
+				"warehouse": item.warehouse or row.warehouse,
+				"update_stock": row.update_stock,
+				"item_group": "",
+				"brand": "",
+				"dn_detail": row.dn_detail,
+				"delivery_note": row.delivery_note,
+				"qty": item.total_qty * -1,
+				"item_row": row.item_row,
+				"is_return": row.is_return,
+				"cost_center": row.cost_center,
+				"invoice": row.parent,
+				"serial_and_batch_bundle": row.serial_and_batch_bundle,
 			}
 		)
 
-	def get_bundle_item_details(self, item_code):
-		return frappe.db.get_value("Item", item_code, ["item_name", "description", "item_group", "brand"])
-
 	def get_stock_ledger_entries(self, item_code, warehouse):
 		if item_code and warehouse:
 			if (item_code, warehouse) not in self.sle:
@@ -1043,6 +1051,7 @@ class GrossProfitGenerator:
 				pki.rate,
 				(pki.rate * pki.qty).as_("base_amount"),
 				pki.parent_detail_docname,
+				pki.serial_and_batch_bundle,
 			)
 			.where(pki.docstatus == 1)
 		)

erpnext/accounts/report/gross_profit/test_gross_profit.py

@@ -418,12 +418,12 @@ class TestGrossProfit(FrappeTestCase):
 			"item_name": self.item,
 			"warehouse": "Stores - _GP",
 			"qty": 0.0,
-			"avg._selling_rate": 0.0,
+			"avg._selling_rate": 100,
 			"valuation_rate": 0.0,
-			"selling_amount": -100.0,
+			"selling_amount": 0.0,
 			"buying_amount": 0.0,
-			"gross_profit": -100.0,
-			"gross_profit_%": 100.0,
+			"gross_profit": 0.0,
+			"gross_profit_%": 0.0,
 		}
 		gp_entry = [x for x in data if x.parent_invoice == sinv.name]
 		# Both items of Invoice should have '0' qty

erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py

@@ -318,7 +318,7 @@ def get_columns(additional_table_columns, filters):
 			"width": 100,
 		},
 		{
-			"label": _("Rate"),
+			"label": _("Tax Rate"),
 			"fieldname": "rate",
 			"fieldtype": "Float",
 			"options": "currency",

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py

@@ -7,6 +7,8 @@ from frappe import _
 from frappe.utils import flt
 
 from erpnext.accounts.report.financial_statements import (
+	compute_growth_view_data,
+	compute_margin_view_data,
 	get_columns,
 	get_data,
 	get_filtered_list_for_consolidated_report,
@@ -68,6 +70,12 @@ def execute(filters=None):
 		period_list, filters.periodicity, income, expense, net_profit_loss, currency, filters
 	)
 
+	if filters.get("selected_view") == "Growth":
+		compute_growth_view_data(data, period_list)
+
+	if filters.get("selected_view") == "Margin":
+		compute_margin_view_data(data, period_list, filters.accumulated_values)
+
 	return columns, data, None, chart, report_summary, primitive_summary
 
 

erpnext/accounts/report/tax_withholding_details/tax_withholding_details.py

@@ -70,10 +70,10 @@ def get_result(filters, tds_docs, tds_accounts, tax_category_map, journal_entry_
 
 				rate = tax_rate_map.get(tax_withholding_category)
 			if net_total_map.get((voucher_type, name)):
-				if voucher_type == "Journal Entry":
+				if voucher_type == "Journal Entry" and tax_amount and rate:
 					# back calcalute total amount from rate and tax_amount
-					if rate:
-						total_amount = grand_total = base_total = tax_amount / (rate / 100)
+					base_total = min(tax_amount / (rate / 100), net_total_map.get((voucher_type, name))[0])
+					total_amount = grand_total = base_total
 				elif voucher_type == "Purchase Invoice":
 					total_amount, grand_total, base_total, bill_no, bill_date = net_total_map.get(
 						(voucher_type, name)
@@ -405,7 +405,7 @@ def get_doc_info(vouchers, doctype, tax_category_map, net_total_map=None):
 			"paid_amount_after_tax",
 			"base_paid_amount",
 		],
-		"Journal Entry": ["total_amount"],
+		"Journal Entry": ["tax_withholding_category", "total_debit"],
 	}
 
 	entries = frappe.get_all(
@@ -427,7 +427,7 @@ def get_doc_info(vouchers, doctype, tax_category_map, net_total_map=None):
 		elif doctype == "Payment Entry":
 			value = [entry.paid_amount, entry.paid_amount_after_tax, entry.base_paid_amount]
 		else:
-			value = [entry.total_amount] * 3
+			value = [entry.total_debit] * 3
 
 		net_total_map[(doctype, entry.name)] = value
 

erpnext/accounts/test/test_utils.py

@@ -92,14 +92,14 @@ class TestUtils(unittest.TestCase):
 		payment_entry.deductions = []
 		payment_entry.save()
 
-		# below is the difference between base_received_amount and base_paid_amount
-		self.assertEqual(payment_entry.difference_amount, -4855.0)
+		# below is the difference between base_paid_amount and base_received_amount (exchange gain)
+		self.assertEqual(payment_entry.deductions[0].amount, -4855.0)
 
 		payment_entry.target_exchange_rate = 62.9
 		payment_entry.save()
 
-		# below is due to change in exchange rate
-		self.assertEqual(payment_entry.references[0].exchange_gain_loss, -4855.0)
+		# after changing the exchange rate, there is no exchange gain / loss
+		self.assertEqual(payment_entry.deductions, [])
 
 		payment_entry.references = []
 		self.assertEqual(payment_entry.difference_amount, 0.0)

erpnext/accounts/utils.py

@@ -130,7 +130,9 @@ def get_fiscal_years(
 			else:
 				return ((fy.name, fy.year_start_date, fy.year_end_date),)
 
-	error_msg = _("""{0} {1} is not in any active Fiscal Year""").format(label, formatdate(transaction_date))
+	error_msg = _("""{0} {1} is not in any active Fiscal Year""").format(
+		_(label), formatdate(transaction_date)
+	)
 	if company:
 		error_msg = _("""{0} for {1}""").format(error_msg, frappe.bold(company))
 

erpnext/assets/doctype/asset/asset.js

@@ -416,7 +416,7 @@ frappe.ui.form.on("Asset", {
 		}
 
 		frm.dashboard.render_graph({
-			title: "Asset Value",
+			title: __("Asset Value"),
 			data: {
 				labels: x_intervals,
 				datasets: [

erpnext/assets/doctype/asset/asset.json

@@ -378,7 +378,7 @@
    "in_standard_filter": 1,
    "label": "Status",
    "no_copy": 1,
-   "options": "Draft\nSubmitted\nPartially Depreciated\nFully Depreciated\nSold\nScrapped\nIn Maintenance\nOut of Order\nIssue\nReceipt\nCapitalized\nDecapitalized",
+   "options": "Draft\nSubmitted\nPartially Depreciated\nFully Depreciated\nSold\nScrapped\nIn Maintenance\nOut of Order\nIssue\nReceipt\nCapitalized\nDecapitalized\nWork In Progress",
    "read_only": 1
   },
   {
@@ -595,7 +595,7 @@
    "link_fieldname": "target_asset"
   }
  ],
- "modified": "2024-08-26 23:28:29.095139",
+ "modified": "2024-12-26 14:23:20.968882",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset",

erpnext/assets/doctype/asset/asset.py

@@ -19,6 +19,7 @@ from frappe.utils import (
 )
 
 import erpnext
+from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import get_dimensions
 from erpnext.accounts.general_ledger import make_reverse_gl_entries
 from erpnext.assets.doctype.asset.depreciation import (
 	get_comma_separated_links,
@@ -111,6 +112,7 @@ class Asset(AccountsController):
 			"Receipt",
 			"Capitalized",
 			"Decapitalized",
+			"Work In Progress",
 		]
 		supplier: DF.Link | None
 		total_asset_cost: DF.Currency
@@ -308,12 +310,14 @@ class Asset(AccountsController):
 				)
 
 	def validate_precision(self):
-		float_precision = cint(frappe.db.get_default("float_precision")) or 2
 		if self.gross_purchase_amount:
-			self.gross_purchase_amount = flt(self.gross_purchase_amount, float_precision)
+			self.gross_purchase_amount = flt(
+				self.gross_purchase_amount, self.precision("gross_purchase_amount")
+			)
+
 		if self.opening_accumulated_depreciation:
 			self.opening_accumulated_depreciation = flt(
-				self.opening_accumulated_depreciation, float_precision
+				self.opening_accumulated_depreciation, self.precision("opening_accumulated_depreciation")
 			)
 
 	def validate_asset_values(self):
@@ -410,6 +414,9 @@ class Asset(AccountsController):
 			)
 
 	def validate_asset_finance_books(self, row):
+		row.expected_value_after_useful_life = flt(
+			row.expected_value_after_useful_life, self.precision("gross_purchase_amount")
+		)
 		if flt(row.expected_value_after_useful_life) >= flt(self.gross_purchase_amount):
 			frappe.throw(
 				_("Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount").format(
@@ -430,7 +437,10 @@ class Asset(AccountsController):
 			self.opening_accumulated_depreciation = 0
 			self.opening_number_of_booked_depreciations = 0
 		else:
-			depreciable_amount = flt(self.gross_purchase_amount) - flt(row.expected_value_after_useful_life)
+			depreciable_amount = flt(
+				flt(self.gross_purchase_amount) - flt(row.expected_value_after_useful_life),
+				self.precision("gross_purchase_amount"),
+			)
 			if flt(self.opening_accumulated_depreciation) > depreciable_amount:
 				frappe.throw(
 					_("Opening Accumulated Depreciation must be less than or equal to {0}").format(
@@ -481,11 +491,7 @@ class Asset(AccountsController):
 
 	def validate_expected_value_after_useful_life(self):
 		for row in self.get("finance_books"):
-			row.expected_value_after_useful_life = flt(
-				row.expected_value_after_useful_life, self.precision("gross_purchase_amount")
-			)
 			depr_schedule = get_depr_schedule(self.name, "Draft", row.finance_book)
-
 			if not depr_schedule:
 				continue
 
@@ -798,6 +804,9 @@ class Asset(AccountsController):
 			):
 				return args.get("rate_of_depreciation")
 
+			if args.get("rate_of_depreciation") and not flt(args.get("expected_value_after_useful_life")):
+				return args.get("rate_of_depreciation")
+
 			if self.flags.increase_in_asset_value_due_to_repair:
 				value = flt(args.get("expected_value_after_useful_life")) / flt(
 					args.get("value_after_depreciation")
@@ -880,6 +889,7 @@ def get_asset_naming_series():
 
 @frappe.whitelist()
 def make_sales_invoice(asset, item_code, company, serial_no=None):
+	asset_doc = frappe.get_doc("Asset", asset)
 	si = frappe.new_doc("Sales Invoice")
 	si.company = company
 	si.currency = frappe.get_cached_value("Company", company, "default_currency")
@@ -896,6 +906,16 @@ def make_sales_invoice(asset, item_code, company, serial_no=None):
 			"qty": 1,
 		},
 	)
+
+	accounting_dimensions = get_dimensions(with_cost_center_and_project=True)
+	for dimension in accounting_dimensions[0]:
+		si.update(
+			{
+				dimension["fieldname"]: asset_doc.get(dimension["fieldname"])
+				or dimension.get("default_dimension")
+			}
+		)
+
 	si.set_missing_values()
 	return si
 

erpnext/assets/doctype/asset/asset_list.js

@@ -1,5 +1,6 @@
 frappe.listview_settings["Asset"] = {
-	add_fields: ["status"],
+	add_fields: ["status", "docstatus"],
+	has_indicator_for_draft: 1,
 	get_indicator: function (doc) {
 		if (doc.status === "Fully Depreciated") {
 			return [__("Fully Depreciated"), "green", "status,=,Fully Depreciated"];
@@ -7,6 +8,8 @@ frappe.listview_settings["Asset"] = {
 			return [__("Partially Depreciated"), "grey", "status,=,Partially Depreciated"];
 		} else if (doc.status === "Sold") {
 			return [__("Sold"), "green", "status,=,Sold"];
+		} else if (doc.status === "Work In Progress") {
+			return [__("Work In Progress"), "orange", "status,=,Work In Progress"];
 		} else if (["Capitalized", "Decapitalized"].includes(doc.status)) {
 			return [__(doc.status), "grey", "status,=," + doc.status];
 		} else if (doc.status === "Scrapped") {
@@ -21,7 +24,7 @@ frappe.listview_settings["Asset"] = {
 			return [__("Receipt"), "green", "status,=,Receipt"];
 		} else if (doc.status === "Submitted") {
 			return [__("Submitted"), "blue", "status,=,Submitted"];
-		} else if (doc.status === "Draft") {
+		} else if (doc.status === "Draft" || doc.docstatus === 0) {
 			return [__("Draft"), "red", "status,=,Draft"];
 		}
 	},

erpnext/assets/doctype/asset/test_asset.py

@@ -889,7 +889,7 @@ class TestDepreciationMethods(AssetSetup):
 			["2030-12-31", 28630.14, 28630.14],
 			["2031-12-31", 35684.93, 64315.07],
 			["2032-12-31", 17842.46, 82157.53],
-			["2033-06-06", 5342.46, 87499.99],
+			["2033-06-06", 5342.47, 87500.00],
 		]
 
 		schedules = [
@@ -1725,6 +1725,10 @@ def create_asset(**args):
 			},
 		)
 
+	if asset.is_composite_asset:
+		asset.gross_purchase_amount = 0
+		asset.purchase_amount = 0
+
 	if not args.do_not_save:
 		try:
 			asset.insert(ignore_if_duplicate=True)

erpnext/assets/doctype/asset_capitalization/asset_capitalization.py

@@ -638,6 +638,7 @@ class AssetCapitalization(StockController):
 		self.target_fixed_asset_account = get_asset_category_account(
 			"fixed_asset_account", item=self.target_item_code, company=asset_doc.company
 		)
+		asset_doc.set_status("Work In Progress")
 
 		add_asset_activity(
 			asset_doc.name,
@@ -662,8 +663,9 @@ class AssetCapitalization(StockController):
 		total_target_asset_value = flt(self.total_value, self.precision("total_value"))
 
 		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.gross_purchase_amount += total_target_asset_value
+		asset_doc.purchase_amount += total_target_asset_value
+		asset_doc.set_status("Work In Progress")
 		asset_doc.flags.ignore_validate = True
 		asset_doc.save()
 

erpnext/assets/doctype/asset_capitalization/test_asset_capitalization.py

@@ -96,6 +96,7 @@ class TestAssetCapitalization(unittest.TestCase):
 		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)
+		self.assertEqual(target_asset.status, "Work In Progress")
 
 		# Test Consumed Asset values
 		self.assertEqual(consumed_asset.db_get("status"), "Capitalized")
@@ -270,6 +271,7 @@ class TestAssetCapitalization(unittest.TestCase):
 		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)
+		self.assertEqual(target_asset.status, "Work In Progress")
 
 		# Test General Ledger Entries
 		expected_gle = {

erpnext/assets/doctype/asset_depreciation_schedule/asset_depreciation_schedule.py

@@ -13,6 +13,7 @@ from frappe.utils import (
 	flt,
 	get_first_day,
 	get_last_day,
+	get_link_to_form,
 	getdate,
 	is_last_day_of_the_month,
 	month_diff,
@@ -344,7 +345,7 @@ class AssetDepreciationSchedule(Document):
 					date_of_disposal,
 					original_schedule_date=schedule_date,
 				)
-
+				depreciation_amount = flt(depreciation_amount, asset_doc.precision("gross_purchase_amount"))
 				if depreciation_amount > 0:
 					self.add_depr_schedule_row(date_of_disposal, depreciation_amount, n)
 
@@ -430,6 +431,7 @@ class AssetDepreciationSchedule(Document):
 
 			if not depreciation_amount:
 				continue
+			depreciation_amount = flt(depreciation_amount, asset_doc.precision("gross_purchase_amount"))
 			value_after_depreciation = flt(
 				value_after_depreciation - flt(depreciation_amount),
 				asset_doc.precision("gross_purchase_amount"),
@@ -443,6 +445,7 @@ class AssetDepreciationSchedule(Document):
 				depreciation_amount += flt(value_after_depreciation) - flt(
 					row.expected_value_after_useful_life
 				)
+				depreciation_amount = flt(depreciation_amount, asset_doc.precision("gross_purchase_amount"))
 				skip_row = True
 
 			if flt(depreciation_amount, asset_doc.precision("gross_purchase_amount")) > 0:
@@ -517,10 +520,13 @@ class AssetDepreciationSchedule(Document):
 						i - 1
 					].accumulated_depreciation_amount
 				else:
-					accumulated_depreciation = flt(self.opening_accumulated_depreciation)
+					accumulated_depreciation = flt(
+						self.opening_accumulated_depreciation,
+						asset_doc.precision("opening_accumulated_depreciation"),
+					)
 
-			depreciation_amount = flt(d.depreciation_amount, d.precision("depreciation_amount"))
-			value_after_depreciation -= flt(depreciation_amount)
+			value_after_depreciation -= flt(d.depreciation_amount)
+			value_after_depreciation = flt(value_after_depreciation, d.precision("depreciation_amount"))
 
 			# for the last row, if depreciation method = Straight Line
 			if (
@@ -530,12 +536,11 @@ class AssetDepreciationSchedule(Document):
 				and not date_of_return
 				and not row.shift_based
 			):
-				depreciation_amount += flt(
+				d.depreciation_amount += flt(
 					value_after_depreciation - flt(row.expected_value_after_useful_life),
 					d.precision("depreciation_amount"),
 				)
 
-			d.depreciation_amount = depreciation_amount
 			accumulated_depreciation += d.depreciation_amount
 			d.accumulated_depreciation_amount = flt(
 				accumulated_depreciation, d.precision("accumulated_depreciation_amount")
@@ -1058,7 +1063,7 @@ def make_new_active_asset_depr_schedules_and_cancel_current_ones(
 		if not current_asset_depr_schedule_doc:
 			frappe.throw(
 				_("Asset Depreciation Schedule not found for Asset {0} and Finance Book {1}").format(
-					asset_doc.name, row.finance_book
+					get_link_to_form("Asset", asset_doc.name), row.finance_book
 				)
 			)
 
@@ -1104,7 +1109,7 @@ def get_temp_asset_depr_schedule_doc(
 	if not current_asset_depr_schedule_doc:
 		frappe.throw(
 			_("Asset Depreciation Schedule not found for Asset {0} and Finance Book {1}").format(
-				asset_doc.name, row.finance_book
+				get_link_to_form("Asset", asset_doc.name), row.finance_book
 			)
 		)
 

erpnext/assets/doctype/asset_finance_book/asset_finance_book.json

@@ -86,7 +86,8 @@
    "description": "In Percentage",
    "fieldname": "rate_of_depreciation",
    "fieldtype": "Percent",
-   "label": "Rate of Depreciation"
+   "label": "Rate of Depreciation (%)",
+   "mandatory_depends_on": "eval:doc.depreciation_method == 'Written Down Value'"
   },
   {
    "fieldname": "salvage_value_percentage",
@@ -117,7 +118,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-05-21 15:48:20.907250",
+ "modified": "2024-12-13 12:11:03.743209",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset Finance Book",

erpnext/assets/number_card/asset_value/asset_value.json

@@ -4,6 +4,7 @@
  "docstatus": 0,
  "doctype": "Number Card",
  "document_type": "Asset",
+ "dynamic_filters_json": "[[\"Asset\",\"company\",\"=\",\"frappe.defaults.get_user_default(\\\"Company\\\")\"]]",
  "filters_json": "[]",
  "function": "Sum",
  "idx": 0,

erpnext/assets/number_card/new_assets_(this_year)/new_assets_(this_year).json

@@ -3,6 +3,7 @@
  "docstatus": 0,
  "doctype": "Number Card",
  "document_type": "Asset",
+ "dynamic_filters_json": "[[\"Asset\",\"company\",\"=\",\"frappe.defaults.get_user_default(\\\"Company\\\")\"]]",
  "filters_json": "[[\"Asset\",\"creation\",\"Timespan\",\"this year\",false]]",
  "function": "Count",
  "idx": 0,