chore(release): Bumped to Version 13.43.2

## [13.43.2](https://github.com/frappe/erpnext/compare/v13.43.1...v13.43.2) (2023-01-17)

### Bug Fixes

* allow to create sales order from expired quotation ([#33582](https://github.com/frappe/erpnext/issues/33582)) ([2f81f15](2f81f15f02))
* asset value in fixed asset register ([#33608](https://github.com/frappe/erpnext/issues/33608)) ([42fe63d](42fe63da2c))
* better comparision of difference value between stock and account ([a450c8d](a450c8dce9))
* don't check other warehouse ledgers to calculate valuation rate ([66bf107](66bf1071bb))
* handle post depr entries fail and fix asset repair link ([5f7dc8a](5f7dc8a5b9))
* only group similar items in print format if group_same_items is checked in pick list (backport [#33627](https://github.com/frappe/erpnext/issues/33627)) ([#33631](https://github.com/frappe/erpnext/issues/33631)) ([7dcf0f0](7dcf0f0866))
* Return against internal purchase invoice ([#33635](https://github.com/frappe/erpnext/issues/33635)) ([eef0f45](eef0f453d2))
* Sales ORder Connections on Material Request ([97488ae](97488aee88))
* Updating SO throws ordered_qty not allowed to change after submission ([a46aa80](a46aa808be))

### Reverts

* Reverting changes done on 33495 ([#33662](https://github.com/frappe/erpnext/issues/33662)) ([0f0a2b1](0f0a2b100c))

.github/helper/.flake8_strict

@@ -66,7 +66,8 @@ ignore =
     F841,
     E713,
     E712,
-    B023
+    B023,
+    B028
 
 
 max-line-length = 200

.github/workflows/release.yml

@@ -13,10 +13,10 @@ jobs:
         with:
           fetch-depth: 0
           persist-credentials: false
-      - name: Setup Node.js v14
+      - name: Setup Node.js
         uses: actions/setup-node@v2
         with:
-          node-version: 14
+          node-version: 18
       - name: Setup dependencies
         run: |
           npm install @semantic-release/git @semantic-release/exec --no-save
@@ -28,4 +28,4 @@ jobs:
           GIT_AUTHOR_EMAIL: "developers@frappe.io"
           GIT_COMMITTER_NAME: "Frappe PR Bot"
           GIT_COMMITTER_EMAIL: "developers@frappe.io"
-        run: npx semantic-release
+        run: npx semantic-release

.pre-commit-config.yaml

@@ -16,8 +16,8 @@ repos:
       - id: check-merge-conflict
       - id: check-ast
 
-  - repo: https://gitlab.com/pycqa/flake8
-    rev: 3.9.2
+  - repo: https://github.com/PyCQA/flake8
+    rev: 5.0.4
     hooks:
       - id: flake8
         additional_dependencies: [

erpnext/__init__.py

@@ -4,7 +4,7 @@ import frappe
 
 from erpnext.hooks import regional_overrides
 
-__version__ = "13.41.1"
+__version__ = "13.43.2"
 
 
 def get_default_company(user=None):

erpnext/accounts/deferred_revenue.py

@@ -378,7 +378,7 @@ def book_deferred_income_or_expense(doc, deferred_process, posting_date=None):
 			return
 
 		# check if books nor frozen till endate:
-		if accounts_frozen_upto and (end_date) <= getdate(accounts_frozen_upto):
+		if accounts_frozen_upto and getdate(end_date) <= getdate(accounts_frozen_upto):
 			end_date = get_last_day(add_days(accounts_frozen_upto, 1))
 
 		if via_journal_entry:

erpnext/accounts/doctype/accounting_dimension_filter/accounting_dimension_filter.js

@@ -3,10 +3,6 @@
 
 frappe.ui.form.on('Accounting Dimension Filter', {
 	refresh: function(frm, cdt, cdn) {
-		if (frm.doc.accounting_dimension) {
-			frm.set_df_property('dimensions', 'label', frm.doc.accounting_dimension, cdn, 'dimension_value');
-		}
-
 		let help_content =
 			`<table class="table table-bordered" style="background-color: var(--scrollbar-track-color);">
 				<tr><td>
@@ -68,6 +64,7 @@ frappe.ui.form.on('Accounting Dimension Filter', {
 		frm.clear_table("dimensions");
 		let row = frm.add_child("dimensions");
 		row.accounting_dimension = frm.doc.accounting_dimension;
+		frm.fields_dict["dimensions"].grid.update_docfield_property("dimension_value", "label", frm.doc.accounting_dimension);
 		frm.refresh_field("dimensions");
 		frm.trigger('setup_filters');
 	},

erpnext/accounts/doctype/bank_guarantee/bank_guarantee.js

@@ -43,20 +43,13 @@ frappe.ui.form.on('Bank Guarantee', {
 
 	reference_docname: function(frm) {
 		if (frm.doc.reference_docname && frm.doc.reference_doctype) {
-			let fields_to_fetch = ["grand_total"];
 			let party_field = frm.doc.reference_doctype == "Sales Order" ? "customer" : "supplier";
 
-			if (frm.doc.reference_doctype == "Sales Order") {
-				fields_to_fetch.push("project");
-			}
-
-			fields_to_fetch.push(party_field);
 			frappe.call({
-				method: "erpnext.accounts.doctype.bank_guarantee.bank_guarantee.get_vouchar_detials",
+				method: "erpnext.accounts.doctype.bank_guarantee.bank_guarantee.get_voucher_details",
 				args: {
-					"column_list": fields_to_fetch,
-					"doctype": frm.doc.reference_doctype,
-					"docname": frm.doc.reference_docname
+					"bank_guarantee_type": frm.doc.bg_type,
+					"reference_name": frm.doc.reference_docname
 				},
 				callback: function(r) {
 					if (r.message) {

erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py

@@ -2,11 +2,8 @@
 # For license information, please see license.txt
 
 
-import json
-
 import frappe
 from frappe import _
-from frappe.desk.search import sanitize_searchfield
 from frappe.model.document import Document
 
 
@@ -25,14 +22,18 @@ class BankGuarantee(Document):
 
 
 @frappe.whitelist()
-def get_vouchar_detials(column_list, doctype, docname):
-	column_list = json.loads(column_list)
-	for col in column_list:
-		sanitize_searchfield(col)
-	return frappe.db.sql(
-		""" select {columns} from `tab{doctype}` where name=%s""".format(
-			columns=", ".join(column_list), doctype=doctype
-		),
-		docname,
-		as_dict=1,
-	)[0]
+def get_voucher_details(bank_guarantee_type: str, reference_name: str):
+	if not isinstance(reference_name, str):
+		raise TypeError("reference_name must be a string")
+
+	fields_to_fetch = ["grand_total"]
+
+	if bank_guarantee_type == "Receiving":
+		doctype = "Sales Order"
+		fields_to_fetch.append("customer")
+		fields_to_fetch.append("project")
+	else:
+		doctype = "Purchase Order"
+		fields_to_fetch.append("supplier")
+
+	return frappe.db.get_value(doctype, reference_name, fields_to_fetch, as_dict=True)

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -299,7 +299,7 @@ def reconcile_vouchers(bank_transaction_name, vouchers):
 			dict(
 				account=account, voucher_type=voucher["payment_doctype"], voucher_no=voucher["payment_name"]
 			),
-			["credit", "debit"],
+			["credit_in_account_currency as credit", "debit_in_account_currency as debit"],
 			as_dict=1,
 		)
 		gl_amount, transaction_amount = (

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -138,7 +138,7 @@ def get_paid_amount(payment_entry, currency, bank_account):
 				)
 			elif doc.payment_type == "Pay":
 				paid_amount_field = (
-					"paid_amount" if doc.paid_to_account_currency == currency else "base_paid_amount"
+					"paid_amount" if doc.paid_from_account_currency == currency else "base_paid_amount"
 				)
 
 		return frappe.db.get_value(

erpnext/accounts/doctype/fiscal_year/fiscal_year.py

@@ -169,5 +169,6 @@ def auto_create_fiscal_year():
 
 
 def get_from_and_to_date(fiscal_year):
-	fields = ["year_start_date as from_date", "year_end_date as to_date"]
-	return frappe.db.get_value("Fiscal Year", fiscal_year, fields, as_dict=1)
+	fields = ["year_start_date", "year_end_date"]
+	cached_results = frappe.get_cached_value("Fiscal Year", fiscal_year, fields, as_dict=1)
+	return dict(from_date=cached_results.year_start_date, to_date=cached_results.year_end_date)

erpnext/accounts/doctype/journal_entry_template/journal_entry_template.js

@@ -45,21 +45,6 @@ frappe.ui.form.on("Journal Entry Template", {
 
 		frm.trigger("clear_child");
 		switch(frm.doc.voucher_type){
-			case "Opening Entry":
-				frm.set_value("is_opening", "Yes");
-				frappe.call({
-					type:"GET",
-					method: "erpnext.accounts.doctype.journal_entry.journal_entry.get_opening_accounts",
-					args: {
-						"company": frm.doc.company
-					},
-					callback: function(r) {
-						if(r.message) {
-							add_accounts(frm.doc, r.message);
-						}
-					}
-				});
-				break;
 			case "Bank Entry":
 			case "Cash Entry":
 				frappe.call({

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js

@@ -20,7 +20,6 @@ frappe.ui.form.on('Opening Invoice Creation Tool', {
 				frm.dashboard.reset();
 				frm.doc.import_in_progress = true;
 			}
-			if (data.user != frappe.session.user) return;
 			if (data.count == data.total) {
 				setTimeout((title) => {
 					frm.doc.import_in_progress = false;

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py

@@ -271,10 +271,10 @@ def publish(index, total, doctype):
 		dict(
 			title=_("Opening Invoice Creation In Progress"),
 			message=_("Creating {} out of {} {}").format(index + 1, total, doctype),
-			user=frappe.session.user,
 			count=index + 1,
 			total=total,
 		),
+		user=frappe.session.user,
 	)
 
 

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -67,7 +67,6 @@ class PaymentEntry(AccountsController):
 		self.set_missing_values()
 		self.validate_payment_type()
 		self.validate_party_details()
-		self.validate_bank_accounts()
 		self.set_exchange_rate()
 		self.validate_mandatory()
 		self.validate_reference_documents()
@@ -250,23 +249,6 @@ class PaymentEntry(AccountsController):
 			if not frappe.db.exists(self.party_type, self.party):
 				frappe.throw(_("Invalid {0}: {1}").format(self.party_type, self.party))
 
-			if self.party_account and self.party_type in ("Customer", "Supplier"):
-				self.validate_account_type(
-					self.party_account, [erpnext.get_party_account_type(self.party_type)]
-				)
-
-	def validate_bank_accounts(self):
-		if self.payment_type in ("Pay", "Internal Transfer"):
-			self.validate_account_type(self.paid_from, ["Bank", "Cash"])
-
-		if self.payment_type in ("Receive", "Internal Transfer"):
-			self.validate_account_type(self.paid_to, ["Bank", "Cash"])
-
-	def validate_account_type(self, account, account_types):
-		account_type = frappe.db.get_value("Account", account, "account_type")
-		# if account_type not in account_types:
-		# 	frappe.throw(_("Account Type for {0} must be {1}").format(account, comma_or(account_types)))
-
 	def set_exchange_rate(self, ref_doc=None):
 		self.set_source_exchange_rate(ref_doc)
 		self.set_target_exchange_rate(ref_doc)

erpnext/accounts/doctype/payment_entry_reference/payment_entry_reference.json

@@ -25,7 +25,8 @@
    "in_list_view": 1,
    "label": "Type",
    "options": "DocType",
-   "reqd": 1
+   "reqd": 1,
+   "search_index": 1
   },
   {
    "columns": 2,
@@ -35,7 +36,8 @@
    "in_list_view": 1,
    "label": "Name",
    "options": "reference_doctype",
-   "reqd": 1
+   "reqd": 1,
+   "search_index": 1
   },
   {
    "fieldname": "due_date",
@@ -104,7 +106,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2021-09-26 17:06:55.597389",
+ "modified": "2022-12-12 12:31:44.919895",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry Reference",
@@ -113,5 +115,6 @@
  "quick_entry": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
+ "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -3,8 +3,10 @@
 
 
 import frappe
-from frappe import _, msgprint
+from frappe import _, msgprint, qb
 from frappe.model.document import Document
+from frappe.query_builder import Criterion
+from frappe.query_builder.functions import Sum
 from frappe.utils import flt, getdate, nowdate, today
 
 import erpnext
@@ -47,6 +49,10 @@ class PaymentReconciliation(Document):
 	def get_payment_entries(self):
 		order_doctype = "Sales Order" if self.party_type == "Customer" else "Purchase Order"
 		condition = self.get_conditions(get_payments=True)
+
+		if self.get("cost_center"):
+			condition += " and cost_center = '{0}' ".format(self.cost_center)
+
 		payment_entries = get_advance_payment_entries(
 			self.party_type,
 			self.party,
@@ -61,6 +67,10 @@ class PaymentReconciliation(Document):
 
 	def get_jv_entries(self):
 		condition = self.get_conditions()
+
+		if self.get("cost_center"):
+			condition += " and t2.cost_center = '{0}' ".format(self.cost_center)
+
 		dr_or_cr = (
 			"credit_in_account_currency"
 			if erpnext.get_party_account_type(self.party_type) == "Receivable"
@@ -112,54 +122,79 @@ class PaymentReconciliation(Document):
 		return list(journal_entries)
 
 	def get_dr_or_cr_notes(self):
-		condition = self.get_conditions(get_return_invoices=True)
+		gl = qb.DocType("GL Entry")
+
+		voucher_type = "Sales Invoice" if self.party_type == "Customer" else "Purchase Invoice"
+		doc = qb.DocType(voucher_type)
+
+		# build conditions
+		sub_query_conditions = []
+		conditions = []
+		sub_query_conditions.append(doc.company == self.company)
+
+		if self.get("from_payment_date"):
+			sub_query_conditions.append(doc.posting_date.gte(self.from_payment_date))
+
+		if self.get("to_payment_date"):
+			sub_query_conditions.append(doc.posting_date.lte(self.to_payment_date))
+
+		if self.get("cost_center"):
+			sub_query_conditions.append(doc.cost_center == self.cost_center)
+
 		dr_or_cr = (
-			"credit_in_account_currency"
+			gl["credit_in_account_currency"]
 			if erpnext.get_party_account_type(self.party_type) == "Receivable"
-			else "debit_in_account_currency"
+			else gl["debit_in_account_currency"]
 		)
 
 		reconciled_dr_or_cr = (
-			"debit_in_account_currency"
-			if dr_or_cr == "credit_in_account_currency"
-			else "credit_in_account_currency"
+			gl["debit_in_account_currency"]
+			if dr_or_cr.name == "credit_in_account_currency"
+			else gl["credit_in_account_currency"]
 		)
 
-		voucher_type = "Sales Invoice" if self.party_type == "Customer" else "Purchase Invoice"
+		having_clause = qb.Field("amount") > 0
 
-		return frappe.db.sql(
-			""" SELECT doc.name as reference_name, %(voucher_type)s as reference_type,
-				(sum(gl.{dr_or_cr}) - sum(gl.{reconciled_dr_or_cr})) as amount, doc.posting_date,
-				account_currency as currency
-			FROM `tab{doc}` doc, `tabGL Entry` gl
-			WHERE
-				(doc.name = gl.against_voucher or doc.name = gl.voucher_no)
-				and doc.{party_type_field} = %(party)s
-				and doc.is_return = 1 and ifnull(doc.return_against, "") = ""
-				and gl.against_voucher_type = %(voucher_type)s
-				and doc.docstatus = 1 and gl.party = %(party)s
-				and gl.party_type = %(party_type)s and gl.account = %(account)s
-				and gl.is_cancelled = 0 {condition}
-			GROUP BY doc.name
-			Having
-				amount > 0
-			ORDER BY doc.posting_date
-		""".format(
-				doc=voucher_type,
-				dr_or_cr=dr_or_cr,
-				reconciled_dr_or_cr=reconciled_dr_or_cr,
-				party_type_field=frappe.scrub(self.party_type),
-				condition=condition or "",
-			),
-			{
-				"party": self.party,
-				"party_type": self.party_type,
-				"voucher_type": voucher_type,
-				"account": self.receivable_payable_account,
-			},
-			as_dict=1,
+		if self.minimum_payment_amount:
+			having_clause = qb.Field("amount") >= self.minimum_payment_amount
+		if self.maximum_payment_amount:
+			having_clause = having_clause & qb.Field("amount") <= self.maximum_payment_amount
+
+		sub_query = (
+			qb.from_(doc)
+			.select(doc.name)
+			.where(Criterion.all(sub_query_conditions))
+			.where(
+				(doc.docstatus == 1)
+				& (doc.is_return == 1)
+				& ((doc.return_against == "") | (doc.return_against.isnull()))
+			)
 		)
 
+		query = (
+			qb.from_(gl)
+			.select(
+				gl.against_voucher_type.as_("reference_type"),
+				gl.against_voucher.as_("reference_name"),
+				(Sum(dr_or_cr) - Sum(reconciled_dr_or_cr)).as_("amount"),
+				gl.posting_date,
+				gl.account_currency.as_("currency"),
+			)
+			.where(
+				(gl.against_voucher.isin(sub_query))
+				& (gl.against_voucher_type == voucher_type)
+				& (gl.is_cancelled == 0)
+				& (gl.account == self.receivable_payable_account)
+				& (gl.party_type == self.party_type)
+				& (gl.party == self.party)
+			)
+			.where(Criterion.all(conditions))
+			.groupby(gl.against_voucher)
+			.having(having_clause)
+		)
+		dr_cr_notes = query.run(as_dict=True)
+		return dr_cr_notes
+
 	def add_payment_entries(self, non_reconciled_payments):
 		self.set("payments", [])
 
@@ -172,6 +207,9 @@ class PaymentReconciliation(Document):
 
 		condition = self.get_conditions(get_invoices=True)
 
+		if self.get("cost_center"):
+			condition += " and cost_center = '{0}' ".format(self.cost_center)
+
 		non_reconciled_invoices = get_outstanding_invoices(
 			self.party_type, self.party, self.receivable_payable_account, condition=condition
 		)
@@ -354,12 +392,9 @@ class PaymentReconciliation(Document):
 		if not invoices_to_reconcile:
 			frappe.throw(_("No records found in Allocation table"))
 
-	def get_conditions(self, get_invoices=False, get_payments=False, get_return_invoices=False):
+	def get_conditions(self, get_invoices=False, get_payments=False):
 		condition = " and company = '{0}' ".format(self.company)
 
-		if self.get("cost_center"):
-			condition = " and cost_center = '{0}' ".format(self.cost_center)
-
 		if get_invoices:
 			condition += (
 				" and posting_date >= {0}".format(frappe.db.escape(self.from_invoice_date))
@@ -385,35 +420,7 @@ class PaymentReconciliation(Document):
 				condition += " and {dr_or_cr} <= {amount}".format(
 					dr_or_cr=dr_or_cr, amount=flt(self.maximum_invoice_amount)
 				)
-
-		elif get_return_invoices:
-			condition = " and doc.company = '{0}' ".format(self.company)
-			condition += (
-				" and doc.posting_date >= {0}".format(frappe.db.escape(self.from_payment_date))
-				if self.from_payment_date
-				else ""
-			)
-			condition += (
-				" and doc.posting_date <= {0}".format(frappe.db.escape(self.to_payment_date))
-				if self.to_payment_date
-				else ""
-			)
-			dr_or_cr = (
-				"debit_in_account_currency"
-				if erpnext.get_party_account_type(self.party_type) == "Receivable"
-				else "credit_in_account_currency"
-			)
-
-			if self.minimum_invoice_amount:
-				condition += " and gl.{dr_or_cr} >= {amount}".format(
-					dr_or_cr=dr_or_cr, amount=flt(self.minimum_payment_amount)
-				)
-			if self.maximum_invoice_amount:
-				condition += " and gl.{dr_or_cr} <= {amount}".format(
-					dr_or_cr=dr_or_cr, amount=flt(self.maximum_payment_amount)
-				)
-
-		else:
+		elif get_payments:
 			condition += (
 				" and posting_date >= {0}".format(frappe.db.escape(self.from_payment_date))
 				if self.from_payment_date

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.js

@@ -25,7 +25,7 @@ frappe.ui.form.on('POS Closing Entry', {
 
 		frappe.realtime.on('closing_process_complete', async function(data) {
 			await frm.reload_doc();
-			if (frm.doc.status == 'Failed' && frm.doc.error_message && data.user == frappe.session.user) {
+			if (frm.doc.status == 'Failed' && frm.doc.error_message) {
 				frappe.msgprint({
 					title: __('POS Closing Failed'),
 					message: frm.doc.error_message,

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -432,7 +432,7 @@ def create_merge_logs(invoice_by_customer, closing_entry=None):
 
 	finally:
 		frappe.db.commit()
-		frappe.publish_realtime("closing_process_complete", {"user": frappe.session.user})
+		frappe.publish_realtime("closing_process_complete", user=frappe.session.user)
 
 
 def cancel_merge_logs(merge_logs, closing_entry=None):
@@ -459,7 +459,7 @@ def cancel_merge_logs(merge_logs, closing_entry=None):
 
 	finally:
 		frappe.db.commit()
-		frappe.publish_realtime("closing_process_complete", {"user": frappe.session.user})
+		frappe.publish_realtime("closing_process_complete", user=frappe.session.user)
 
 
 def enqueue_job(job, **kwargs):

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -712,6 +712,140 @@ class TestPricingRule(unittest.TestCase):
 
 		item.delete()
 
+	def test_item_group_price_with_blank_uom_pricing_rule(self):
+		group = frappe.get_doc(
+			doctype="Item Group",
+			item_group_name="_Test Pricing Rule Item Group",
+			parent_item_group="All Item Groups",
+		)
+		group.save()
+		properties = {
+			"item_code": "Item with Group Blank UOM",
+			"item_group": "_Test Pricing Rule Item Group",
+			"stock_uom": "Nos",
+			"sales_uom": "Box",
+			"uoms": [dict(uom="Box", conversion_factor=10)],
+		}
+		item = make_item(properties=properties)
+
+		make_item_price("Item with Group Blank UOM", "_Test Price List", 100)
+
+		pricing_rule_record = {
+			"doctype": "Pricing Rule",
+			"title": "_Test Item with Group Blank UOM Rule",
+			"apply_on": "Item Group",
+			"item_groups": [
+				{
+					"item_group": "_Test Pricing Rule Item Group",
+				}
+			],
+			"selling": 1,
+			"currency": "INR",
+			"rate_or_discount": "Rate",
+			"rate": 101,
+			"company": "_Test Company",
+		}
+		rule = frappe.get_doc(pricing_rule_record)
+		rule.insert()
+
+		si = create_sales_invoice(
+			do_not_save=True, item_code="Item with Group Blank UOM", uom="Box", conversion_factor=10
+		)
+		si.selling_price_list = "_Test Price List"
+		si.save()
+
+		# If UOM is blank consider it as stock UOM and apply pricing_rule on all UOM.
+		# rate is 101, Selling UOM is Box that have conversion_factor of 10 so 101 * 10 = 1010
+		self.assertEqual(si.items[0].price_list_rate, 1010)
+		self.assertEqual(si.items[0].rate, 1010)
+
+		si.delete()
+
+		si = create_sales_invoice(do_not_save=True, item_code="Item with Group Blank UOM", uom="Nos")
+		si.selling_price_list = "_Test Price List"
+		si.save()
+
+		# UOM is blank so consider it as stock UOM and apply pricing_rule on all UOM.
+		# rate is 101, Selling UOM is Nos that have conversion_factor of 1 so 101 * 1 = 101
+		self.assertEqual(si.items[0].price_list_rate, 101)
+		self.assertEqual(si.items[0].rate, 101)
+
+		si.delete()
+		rule.delete()
+		frappe.get_doc("Item Price", {"item_code": "Item with Group Blank UOM"}).delete()
+		item.delete()
+		group.delete()
+
+	def test_item_group_price_with_selling_uom_pricing_rule(self):
+		group = frappe.get_doc(
+			doctype="Item Group",
+			item_group_name="_Test Pricing Rule Item Group UOM",
+			parent_item_group="All Item Groups",
+		)
+		group.save()
+		properties = {
+			"item_code": "Item with Group UOM other than Stock",
+			"item_group": "_Test Pricing Rule Item Group UOM",
+			"stock_uom": "Nos",
+			"sales_uom": "Box",
+			"uoms": [dict(uom="Box", conversion_factor=10)],
+		}
+		item = make_item(properties=properties)
+
+		make_item_price("Item with Group UOM other than Stock", "_Test Price List", 100)
+
+		pricing_rule_record = {
+			"doctype": "Pricing Rule",
+			"title": "_Test Item with Group UOM other than Stock Rule",
+			"apply_on": "Item Group",
+			"item_groups": [
+				{
+					"item_group": "_Test Pricing Rule Item Group UOM",
+					"uom": "Box",
+				}
+			],
+			"selling": 1,
+			"currency": "INR",
+			"rate_or_discount": "Rate",
+			"rate": 101,
+			"company": "_Test Company",
+		}
+		rule = frappe.get_doc(pricing_rule_record)
+		rule.insert()
+
+		si = create_sales_invoice(
+			do_not_save=True,
+			item_code="Item with Group UOM other than Stock",
+			uom="Box",
+			conversion_factor=10,
+		)
+		si.selling_price_list = "_Test Price List"
+		si.save()
+
+		# UOM is Box so apply pricing_rule only on Box UOM.
+		# Selling UOM is Box and as both UOM are same no need to multiply by conversion_factor.
+		self.assertEqual(si.items[0].price_list_rate, 101)
+		self.assertEqual(si.items[0].rate, 101)
+
+		si.delete()
+
+		si = create_sales_invoice(
+			do_not_save=True, item_code="Item with Group UOM other than Stock", uom="Nos"
+		)
+		si.selling_price_list = "_Test Price List"
+		si.save()
+
+		# UOM is Box so pricing_rule won't apply as selling_uom is Nos.
+		# As Pricing Rule is not applied price of 100 will be fetched from Item Price List.
+		self.assertEqual(si.items[0].price_list_rate, 100)
+		self.assertEqual(si.items[0].rate, 100)
+
+		si.delete()
+		rule.delete()
+		frappe.get_doc("Item Price", {"item_code": "Item with Group UOM other than Stock"}).delete()
+		item.delete()
+		group.delete()
+
 	def test_pricing_rule_for_different_currency(self):
 		make_item("Test Sanitizer Item")
 

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -127,7 +127,12 @@ def _get_pricing_rules(apply_on, args, values):
 				values["variant_of"] = args.variant_of
 	elif apply_on_field == "item_group":
 		item_conditions = _get_tree_conditions(args, "Item Group", child_doc, False)
-
+		if args.get("uom", None):
+			item_conditions += (
+				" and ({child_doc}.uom='{item_uom}' or IFNULL({child_doc}.uom, '')='')".format(
+					child_doc=child_doc, item_uom=args.get("uom")
+				)
+			)
 	conditions += get_other_conditions(conditions, values, args)
 	warehouse_conditions = _get_tree_conditions(args, "Warehouse", "`tabPricing Rule`")
 	if warehouse_conditions:

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.js

@@ -8,7 +8,8 @@ frappe.ui.form.on('Process Statement Of Accounts', {
 	},
 	refresh: function(frm){
 		if(!frm.doc.__islocal) {
-			frm.add_custom_button('Send Emails',function(){
+			frm.add_custom_button(__('Send Emails'), function(){
+				if (frm.is_dirty()) frappe.throw(__("Please save before proceeding."))
 				frappe.call({
 					method: "erpnext.accounts.doctype.process_statement_of_accounts.process_statement_of_accounts.send_emails",
 					args: {
@@ -24,8 +25,9 @@ frappe.ui.form.on('Process Statement Of Accounts', {
 					}
 				});
 			});
-			frm.add_custom_button('Download',function(){
-				var url = frappe.urllib.get_full_url(
+			frm.add_custom_button(__('Download'), function(){
+				if (frm.is_dirty()) frappe.throw(__("Please save before proceeding."))
+				let url = frappe.urllib.get_full_url(
 					'/api/method/erpnext.accounts.doctype.process_statement_of_accounts.process_statement_of_accounts.download_statements?'
 					+ 'document_name='+encodeURIComponent(frm.doc.name))
 				$.ajax({

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.json

@@ -27,6 +27,7 @@
   "customers",
   "preferences",
   "orientation",
+  "include_break",
   "include_ageing",
   "ageing_based_on",
   "section_break_14",
@@ -284,10 +285,16 @@
    "fieldtype": "Link",
    "label": "Terms and Conditions",
    "options": "Terms and Conditions"
+  },
+  {
+   "default": "1",
+   "fieldname": "include_break",
+   "fieldtype": "Check",
+   "label": "Page Break After Each SoA"
   }
  ],
  "links": [],
- "modified": "2021-09-06 21:00:45.732505",
+ "modified": "2022-10-17 17:47:08.662475",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Statement Of Accounts",
@@ -320,5 +327,6 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
+ "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -6,6 +6,7 @@ import copy
 
 import frappe
 from frappe import _
+from frappe.desk.reportview import get_match_cond
 from frappe.model.document import Document
 from frappe.utils import add_days, add_months, format_date, getdate, today
 from frappe.utils.jinja import validate_template
@@ -128,7 +129,8 @@ def get_report_pdf(doc, consolidated=True):
 	if not bool(statement_dict):
 		return False
 	elif consolidated:
-		result = "".join(list(statement_dict.values()))
+		delimiter = '<div style="page-break-before: always;"></div>' if doc.include_break else ""
+		result = delimiter.join(list(statement_dict.values()))
 		return get_pdf(result, {"orientation": doc.orientation})
 	else:
 		for customer, statement_html in statement_dict.items():
@@ -240,8 +242,6 @@ def fetch_customers(customer_collection, collection_name, primary_mandatory):
 		if int(primary_mandatory):
 			if primary_email == "":
 				continue
-		elif (billing_email == "") and (primary_email == ""):
-			continue
 
 		customer_list.append(
 			{"name": customer.name, "primary_email": primary_email, "billing_email": billing_email}
@@ -273,8 +273,12 @@ def get_customer_emails(customer_name, primary_mandatory, billing_and_primary=Tr
 			link.link_doctype='Customer'
 			and link.link_name=%s
 			and contact.is_billing_contact=1
+			{mcond}
 		ORDER BY
-			contact.creation desc""",
+			contact.creation desc
+		""".format(
+			mcond=get_match_cond("Contact")
+		),
 		customer_name,
 	)
 
@@ -313,6 +317,8 @@ def send_emails(document_name, from_scheduler=False):
 			attachments = [{"fname": customer + ".pdf", "fcontent": report_pdf}]
 
 			recipients, cc = get_recipients_and_cc(customer, doc)
+			if not recipients:
+				continue
 			context = get_context(customer, doc)
 			subject = frappe.render_template(doc.subject, context)
 			message = frappe.render_template(doc.body, context)

erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.json

@@ -843,7 +843,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2022-10-10 20:57:38.340026",
+ "modified": "2022-12-28 16:17:33.484531",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Item",

erpnext/accounts/doctype/tax_withheld_vouchers/tax_withheld_vouchers.json

@@ -36,11 +36,11 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2022-09-13 23:40:41.479208",
+ "modified": "2022-12-28 23:40:41.479208",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Tax Withheld Vouchers",
- "naming_rule": "Autoincrement",
+ "naming_rule": "Random",
  "owner": "Administrator",
  "permissions": [],
  "sort_field": "modified",

erpnext/accounts/general_ledger.py

@@ -298,20 +298,22 @@ def make_round_off_gle(gl_map, debit_credit_diff, precision):
 	round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(
 		gl_map[0].company, gl_map[0].voucher_type, gl_map[0].voucher_no
 	)
-	round_off_account_exists = False
 	round_off_gle = frappe._dict()
-	for d in gl_map:
-		if d.account == round_off_account:
-			round_off_gle = d
-			if d.debit:
-				debit_credit_diff -= flt(d.debit)
-			else:
-				debit_credit_diff += flt(d.credit)
-			round_off_account_exists = True
+	round_off_account_exists = False
 
-	if round_off_account_exists and abs(debit_credit_diff) < (1.0 / (10**precision)):
-		gl_map.remove(round_off_gle)
-		return
+	if gl_map[0].voucher_type != "Period Closing Voucher":
+		for d in gl_map:
+			if d.account == round_off_account:
+				round_off_gle = d
+				if d.debit:
+					debit_credit_diff -= flt(d.debit) - flt(d.credit)
+				else:
+					debit_credit_diff += flt(d.credit)
+				round_off_account_exists = True
+
+		if round_off_account_exists and abs(debit_credit_diff) < (1.0 / (10**precision)):
+			gl_map.remove(round_off_gle)
+			return
 
 	if not round_off_gle:
 		for k in ["voucher_type", "voucher_no", "company", "posting_date", "remarks"]:
@@ -334,7 +336,6 @@ def make_round_off_gle(gl_map, debit_credit_diff, precision):
 	)
 
 	update_accounting_dimensions(round_off_gle)
-
 	if not round_off_account_exists:
 		gl_map.append(round_off_gle)
 

erpnext/accounts/print_format/gst_e_invoice/gst_e_invoice.html

@@ -50,6 +50,10 @@
 				<div class="col-xs-4"><label>Document No</label></div>
 				<div class="col-xs-8 value">{{ einvoice.DocDtls.No }}</div>
 			</div>
+			<div class="row data-field">
+				<div class="col-xs-4"><label>Document Date</label></div>
+				<div class="col-xs-8 value">{{ einvoice.DocDtls.Dt }}</div>
+			</div>
 		</div>
 		<div class="col-xs-4 column-break">
 			<img src="{{ doc.qrcode_image }}" width="175px" style="float: right;">

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -5,7 +5,7 @@
 from collections import OrderedDict
 
 import frappe
-from frappe import _, scrub
+from frappe import _, qb, scrub
 from frappe.utils import cint, cstr, flt, getdate, nowdate
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
@@ -95,6 +95,9 @@ class ReceivablePayableReport(object):
 		# Get return entries
 		self.get_return_entries()
 
+		# Get Exchange Rate Revaluations
+		self.get_exchange_rate_revaluations()
+
 		self.data = []
 		for gle in self.gl_entries:
 			self.update_voucher_balance(gle)
@@ -258,7 +261,8 @@ class ReceivablePayableReport(object):
 			row.invoice_grand_total = row.invoiced
 
 			if (abs(row.outstanding) > 1.0 / 10**self.currency_precision) and (
-				abs(row.outstanding_in_account_currency) > 1.0 / 10**self.currency_precision
+				(abs(row.outstanding_in_account_currency) > 1.0 / 10**self.currency_precision)
+				or (row.voucher_no in self.err_journals)
 			):
 				# non-zero oustanding, we must consider this row
 
@@ -685,10 +689,10 @@ class ReceivablePayableReport(object):
 
 		if self.filters.get(scrub(self.party_type)):
 			select_fields = "debit_in_account_currency as debit, credit_in_account_currency as credit"
+			doc_currency_fields = "debit as debit_in_account_currency, credit as credit_in_account_currency"
 		else:
 			select_fields = "debit, credit"
-
-		doc_currency_fields = "debit_in_account_currency, credit_in_account_currency"
+			doc_currency_fields = "debit_in_account_currency, credit_in_account_currency"
 
 		remarks = ", remarks" if self.filters.get("show_remarks") else ""
 
@@ -1033,3 +1037,17 @@ class ReceivablePayableReport(object):
 			"data": {"labels": self.ageing_column_labels, "datasets": rows},
 			"type": "percentage",
 		}
+
+	def get_exchange_rate_revaluations(self):
+		je = qb.DocType("Journal Entry")
+		results = (
+			qb.from_(je)
+			.select(je.name)
+			.where(
+				(je.company == self.filters.company)
+				& (je.posting_date.lte(self.filters.report_date))
+				& (je.voucher_type == "Exchange Rate Revaluation")
+			)
+			.run()
+		)
+		self.err_journals = [x[0] for x in results] if results else []

erpnext/accounts/report/accounts_receivable/test_accounts_receivable.py

@@ -1,18 +1,51 @@
 import unittest
 
 import frappe
-from frappe.utils import add_days, getdate, today
+from frappe.tests.utils import FrappeTestCase, change_settings
+from frappe.utils import add_days, flt, getdate, today
 
+from erpnext import get_default_cost_center
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.report.accounts_receivable.accounts_receivable import execute
 
 
 class TestAccountsReceivable(unittest.TestCase):
-	def test_accounts_receivable(self):
+	def setUp(self):
 		frappe.db.sql("delete from `tabSales Invoice` where company='_Test Company 2'")
 		frappe.db.sql("delete from `tabGL Entry` where company='_Test Company 2'")
+		frappe.db.sql("delete from `tabJournal Entry` where company='_Test Company 2'")
+		frappe.db.sql("delete from `tabExchange Rate Revaluation` where company='_Test Company 2'")
 
+		self.create_usd_account()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def create_usd_account(self):
+		name = "Debtors USD"
+		exists = frappe.db.get_list(
+			"Account", filters={"company": "_Test Company 2", "account_name": "Debtors USD"}
+		)
+		if exists:
+			self.debtors_usd = exists[0].name
+		else:
+			debtors = frappe.get_doc(
+				"Account",
+				frappe.db.get_list(
+					"Account", filters={"company": "_Test Company 2", "account_name": "Debtors"}
+				)[0].name,
+			)
+
+			debtors_usd = frappe.new_doc("Account")
+			debtors_usd.company = debtors.company
+			debtors_usd.account_name = "Debtors USD"
+			debtors_usd.account_currency = "USD"
+			debtors_usd.parent_account = debtors.parent_account
+			debtors_usd.account_type = debtors.account_type
+			self.debtors_usd = debtors_usd.save().name
+
+	def test_accounts_receivable(self):
 		filters = {
 			"company": "_Test Company 2",
 			"based_on_payment_terms": 1,
@@ -24,7 +57,7 @@ class TestAccountsReceivable(unittest.TestCase):
 		}
 
 		# check invoice grand total and invoiced column's value for 3 payment terms
-		name = make_sales_invoice()
+		name = make_sales_invoice().name
 		report = execute(filters)
 
 		expected_data = [[100, 30], [100, 50], [100, 20]]
@@ -65,8 +98,74 @@ class TestAccountsReceivable(unittest.TestCase):
 			],
 		)
 
+	@change_settings(
+		"Accounts Settings", {"allow_multi_currency_invoices_against_single_party_account": 1}
+	)
+	def test_exchange_revaluation_for_party(self):
+		"""
+		Exchange Revaluation for party on Receivable/Payable shoule be included
+		"""
 
-def make_sales_invoice():
+		company = "_Test Company 2"
+		customer = "_Test Customer 2"
+
+		# Using Exchange Gain/Loss account for unrealized as well.
+		company_doc = frappe.get_doc("Company", company)
+		company_doc.unrealized_exchange_gain_loss_account = company_doc.exchange_gain_loss_account
+		company_doc.save()
+
+		si = make_sales_invoice(no_payment_schedule=True, do_not_submit=True)
+		si.currency = "USD"
+		si.conversion_rate = 0.90
+		si.debit_to = self.debtors_usd
+		si = si.save().submit()
+
+		# Exchange Revaluation
+		err = frappe.new_doc("Exchange Rate Revaluation")
+		err.company = company
+		err.posting_date = today()
+		accounts = err.get_accounts_data()
+		err.extend("accounts", accounts)
+		err.accounts[0].new_exchange_rate = 0.95
+		row = err.accounts[0]
+		row.new_balance_in_base_currency = flt(
+			row.new_exchange_rate * flt(row.balance_in_account_currency)
+		)
+		row.gain_loss = row.new_balance_in_base_currency - flt(row.balance_in_base_currency)
+		err.set_total_gain_loss()
+		err = err.save().submit()
+
+		# Submit JV for ERR
+		jv = frappe.get_doc(err.make_jv_entry())
+		jv = jv.save()
+		for x in jv.accounts:
+			x.cost_center = get_default_cost_center(jv.company)
+		jv.submit()
+
+		filters = {
+			"company": company,
+			"report_date": today(),
+			"range1": 30,
+			"range2": 60,
+			"range3": 90,
+			"range4": 120,
+		}
+		report = execute(filters)
+
+		expected_data_for_err = [0, -5, 0, 5]
+		row = [x for x in report[1] if x.voucher_type == jv.doctype and x.voucher_no == jv.name][0]
+		self.assertEqual(
+			expected_data_for_err,
+			[
+				row.invoiced,
+				row.paid,
+				row.credit_note,
+				row.outstanding,
+			],
+		)
+
+
+def make_sales_invoice(no_payment_schedule=False, do_not_submit=False):
 	frappe.set_user("Administrator")
 
 	si = create_sales_invoice(
@@ -81,22 +180,26 @@ def make_sales_invoice():
 		do_not_save=1,
 	)
 
-	si.append(
-		"payment_schedule",
-		dict(due_date=getdate(add_days(today(), 30)), invoice_portion=30.00, payment_amount=30),
-	)
-	si.append(
-		"payment_schedule",
-		dict(due_date=getdate(add_days(today(), 60)), invoice_portion=50.00, payment_amount=50),
-	)
-	si.append(
-		"payment_schedule",
-		dict(due_date=getdate(add_days(today(), 90)), invoice_portion=20.00, payment_amount=20),
-	)
+	if not no_payment_schedule:
+		si.append(
+			"payment_schedule",
+			dict(due_date=getdate(add_days(today(), 30)), invoice_portion=30.00, payment_amount=30),
+		)
+		si.append(
+			"payment_schedule",
+			dict(due_date=getdate(add_days(today(), 60)), invoice_portion=50.00, payment_amount=50),
+		)
+		si.append(
+			"payment_schedule",
+			dict(due_date=getdate(add_days(today(), 90)), invoice_portion=20.00, payment_amount=20),
+		)
 
-	si.submit()
+	si = si.save()
 
-	return si.name
+	if not do_not_submit:
+		si = si.submit()
+
+	return si
 
 
 def make_payment(docname):

erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py

@@ -22,8 +22,7 @@ def get_columns():
 		{
 			"label": _("Payment Document Type"),
 			"fieldname": "payment_document_type",
-			"fieldtype": "Link",
-			"options": "Doctype",
+			"fieldtype": "Data",
 			"width": 130,
 		},
 		{
@@ -33,15 +32,15 @@ def get_columns():
 			"options": "payment_document_type",
 			"width": 140,
 		},
-		{"label": _("Posting Date"), "fieldname": "posting_date", "fieldtype": "Date", "width": 100},
+		{"label": _("Posting Date"), "fieldname": "posting_date", "fieldtype": "Date", "width": 120},
 		{"label": _("Cheque/Reference No"), "fieldname": "cheque_no", "width": 120},
-		{"label": _("Clearance Date"), "fieldname": "clearance_date", "fieldtype": "Date", "width": 100},
+		{"label": _("Clearance Date"), "fieldname": "clearance_date", "fieldtype": "Date", "width": 120},
 		{
 			"label": _("Against Account"),
 			"fieldname": "against",
 			"fieldtype": "Link",
 			"options": "Account",
-			"width": 170,
+			"width": 200,
 		},
 		{"label": _("Amount"), "fieldname": "amount", "fieldtype": "Currency", "width": 120},
 	]

erpnext/accounts/report/cash_flow/cash_flow.py

@@ -9,6 +9,7 @@ from six import iteritems
 
 from erpnext.accounts.report.financial_statements import (
 	get_columns,
+	get_cost_centers_with_children,
 	get_data,
 	get_filtered_list_for_consolidated_report,
 	get_period_list,
@@ -161,10 +162,11 @@ def get_account_type_based_data(company, account_type, period_list, accumulated_
 	total = 0
 	for period in period_list:
 		start_date = get_start_date(period, accumulated_values, company)
+		filters.start_date = start_date
+		filters.end_date = period["to_date"]
+		filters.account_type = account_type
 
-		amount = get_account_type_based_gl_data(
-			company, start_date, period["to_date"], account_type, filters
-		)
+		amount = get_account_type_based_gl_data(company, filters)
 
 		if amount and account_type == "Depreciation":
 			amount *= -1
@@ -176,7 +178,7 @@ def get_account_type_based_data(company, account_type, period_list, accumulated_
 	return data
 
 
-def get_account_type_based_gl_data(company, start_date, end_date, account_type, filters=None):
+def get_account_type_based_gl_data(company, filters=None):
 	cond = ""
 	filters = frappe._dict(filters or {})
 
@@ -192,17 +194,21 @@ def get_account_type_based_gl_data(company, start_date, end_date, account_type,
 			frappe.db.escape(cstr(filters.finance_book))
 		)
 
+	if filters.get("cost_center"):
+		filters.cost_center = get_cost_centers_with_children(filters.cost_center)
+		cond += " and cost_center in %(cost_center)s"
+
 	gl_sum = frappe.db.sql_list(
 		"""
 		select sum(credit) - sum(debit)
 		from `tabGL Entry`
-		where company=%s and posting_date >= %s and posting_date <= %s
+		where company=%(company)s and posting_date >= %(start_date)s and posting_date <= %(end_date)s
 			and voucher_type != 'Period Closing Voucher'
-			and account in ( SELECT name FROM tabAccount WHERE account_type = %s) {cond}
+			and account in ( SELECT name FROM tabAccount WHERE account_type = %(account_type)s) {cond}
 	""".format(
 			cond=cond
 		),
-		(company, start_date, end_date, account_type),
+		filters,
 	)
 
 	return gl_sum[0] if gl_sum and gl_sum[0] else 0

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py

@@ -268,10 +268,12 @@ def get_cash_flow_data(fiscal_year, companies, filters):
 def get_account_type_based_data(account_type, companies, fiscal_year, filters):
 	data = {}
 	total = 0
+	filters.account_type = account_type
+	filters.start_date = fiscal_year.year_start_date
+	filters.end_date = fiscal_year.year_end_date
+
 	for company in companies:
-		amount = get_account_type_based_gl_data(
-			company, fiscal_year.year_start_date, fiscal_year.year_end_date, account_type, filters
-		)
+		amount = get_account_type_based_gl_data(company, filters)
 
 		if amount and account_type == "Depreciation":
 			amount *= -1
@@ -533,12 +535,13 @@ def get_accounts(root_type, companies):
 			],
 			filters={"company": company, "root_type": root_type},
 		):
-			if account.account_name not in added_accounts:
+			if account.account_number:
+				account_key = account.account_number + "-" + account.account_name
+			else:
+				account_key = account.account_name
+
+			if account_key not in added_accounts:
 				accounts.append(account)
-				if account.account_number:
-					account_key = account.account_number + "-" + account.account_name
-				else:
-					account_key = account.account_name
 				added_accounts.append(account_key)
 
 	return accounts

erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py

@@ -27,6 +27,7 @@ class PartyLedgerSummaryReport(object):
 		)
 
 		self.get_gl_entries()
+		self.get_additional_columns()
 		self.get_return_invoices()
 		self.get_party_adjustment_amounts()
 
@@ -34,6 +35,42 @@ class PartyLedgerSummaryReport(object):
 		data = self.get_data()
 		return columns, data
 
+	def get_additional_columns(self):
+		"""
+		Additional Columns for 'User Permission' based access control
+		"""
+		from frappe import qb
+
+		if self.filters.party_type == "Customer":
+			self.territories = frappe._dict({})
+			self.customer_group = frappe._dict({})
+
+			customer = qb.DocType("Customer")
+			result = (
+				frappe.qb.from_(customer)
+				.select(
+					customer.name, customer.territory, customer.customer_group, customer.default_sales_partner
+				)
+				.where((customer.disabled == 0))
+				.run(as_dict=True)
+			)
+
+			for x in result:
+				self.territories[x.name] = x.territory
+				self.customer_group[x.name] = x.customer_group
+		else:
+			self.supplier_group = frappe._dict({})
+			supplier = qb.DocType("Supplier")
+			result = (
+				frappe.qb.from_(supplier)
+				.select(supplier.name, supplier.supplier_group)
+				.where((supplier.disabled == 0))
+				.run(as_dict=True)
+			)
+
+			for x in result:
+				self.supplier_group[x.name] = x.supplier_group
+
 	def get_columns(self):
 		columns = [
 			{
@@ -117,6 +154,35 @@ class PartyLedgerSummaryReport(object):
 			},
 		]
 
+		# Hidden columns for handling 'User Permissions'
+		if self.filters.party_type == "Customer":
+			columns += [
+				{
+					"label": _("Territory"),
+					"fieldname": "territory",
+					"fieldtype": "Link",
+					"options": "Territory",
+					"hidden": 1,
+				},
+				{
+					"label": _("Customer Group"),
+					"fieldname": "customer_group",
+					"fieldtype": "Link",
+					"options": "Customer Group",
+					"hidden": 1,
+				},
+			]
+		else:
+			columns += [
+				{
+					"label": _("Supplier Group"),
+					"fieldname": "supplier_group",
+					"fieldtype": "Link",
+					"options": "Supplier Group",
+					"hidden": 1,
+				}
+			]
+
 		return columns
 
 	def get_data(self):
@@ -144,6 +210,12 @@ class PartyLedgerSummaryReport(object):
 				),
 			)
 
+			if self.filters.party_type == "Customer":
+				self.party_data[gle.party].update({"territory": self.territories.get(gle.party)})
+				self.party_data[gle.party].update({"customer_group": self.customer_group.get(gle.party)})
+			else:
+				self.party_data[gle.party].update({"supplier_group": self.supplier_group.get(gle.party)})
+
 			amount = gle.get(invoice_dr_or_cr) - gle.get(reverse_dr_or_cr)
 			self.party_data[gle.party].closing_balance += amount
 

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -282,7 +282,7 @@ def get_conditions(filters):
 	):
 		conditions.append("(posting_date >=%(from_date)s or is_opening = 'Yes')")
 
-	conditions.append("(posting_date <=%(to_date)s)")
+	conditions.append("(posting_date <=%(to_date)s or is_opening = 'Yes')")
 
 	if filters.get("project"):
 		conditions.append("project in %(project)s")

erpnext/accounts/report/gross_profit/gross_profit.py

@@ -3,7 +3,8 @@
 
 
 import frappe
-from frappe import _, scrub
+from frappe import _, qb, scrub
+from frappe.query_builder import Order
 from frappe.utils import cint, flt
 
 from erpnext.controllers.queries import get_match_cond
@@ -367,6 +368,7 @@ class GrossProfitGenerator(object):
 		self.average_buying_rate = {}
 		self.filters = frappe._dict(filters)
 		self.load_invoice_items()
+		self.get_delivery_notes()
 
 		if filters.group_by == "Invoice":
 			self.group_items_by_invoice()
@@ -535,6 +537,22 @@ class GrossProfitGenerator(object):
 
 		return flt(buying_amount, self.currency_precision)
 
+	def calculate_buying_amount_from_sle(self, row, my_sle, parenttype, parent, item_row, item_code):
+		for i, sle in enumerate(my_sle):
+			# find the stock valution rate from stock ledger entry
+			if (
+				sle.voucher_type == parenttype
+				and parent == sle.voucher_no
+				and sle.voucher_detail_no == item_row
+			):
+				previous_stock_value = len(my_sle) > i + 1 and flt(my_sle[i + 1].stock_value) or 0.0
+
+				if previous_stock_value:
+					return abs(previous_stock_value - flt(sle.stock_value)) * flt(row.qty) / abs(flt(sle.qty))
+				else:
+					return flt(row.qty) * self.get_average_buying_rate(row, item_code)
+		return 0.0
+
 	def get_buying_amount(self, row, item_code):
 		# IMP NOTE
 		# stock_ledger_entries should already be filtered by item_code and warehouse and
@@ -551,19 +569,22 @@ class GrossProfitGenerator(object):
 				if row.dn_detail:
 					parenttype, parent = "Delivery Note", row.delivery_note
 
-				for i, sle in enumerate(my_sle):
-					# find the stock valution rate from stock ledger entry
-					if (
-						sle.voucher_type == parenttype
-						and parent == sle.voucher_no
-						and sle.voucher_detail_no == row.item_row
-					):
-						previous_stock_value = len(my_sle) > i + 1 and flt(my_sle[i + 1].stock_value) or 0.0
-
-						if previous_stock_value:
-							return abs(previous_stock_value - flt(sle.stock_value)) * flt(row.qty) / abs(flt(sle.qty))
-						else:
-							return flt(row.qty) * self.get_average_buying_rate(row, item_code)
+				return self.calculate_buying_amount_from_sle(
+					row, my_sle, parenttype, parent, row.item_row, item_code
+				)
+			elif self.delivery_notes.get((row.parent, row.item_code), None):
+				#  check if Invoice has delivery notes
+				dn = self.delivery_notes.get((row.parent, row.item_code))
+				parenttype, parent, item_row, warehouse = (
+					"Delivery Note",
+					dn["delivery_note"],
+					dn["item_row"],
+					dn["warehouse"],
+				)
+				my_sle = self.sle.get((item_code, warehouse))
+				return self.calculate_buying_amount_from_sle(
+					row, my_sle, parenttype, parent, item_row, item_code
+				)
 			else:
 				return flt(row.qty) * self.get_average_buying_rate(row, item_code)
 
@@ -667,6 +688,29 @@ class GrossProfitGenerator(object):
 			as_dict=1,
 		)
 
+	def get_delivery_notes(self):
+		self.delivery_notes = frappe._dict({})
+		if self.si_list:
+			invoices = [x.parent for x in self.si_list]
+			dni = qb.DocType("Delivery Note Item")
+			delivery_notes = (
+				qb.from_(dni)
+				.select(
+					dni.against_sales_invoice.as_("sales_invoice"),
+					dni.item_code,
+					dni.warehouse,
+					dni.parent.as_("delivery_note"),
+					dni.name.as_("item_row"),
+				)
+				.where((dni.docstatus == 1) & (dni.against_sales_invoice.isin(invoices)))
+				.groupby(dni.against_sales_invoice, dni.item_code)
+				.orderby(dni.creation, order=Order.desc)
+				.run(as_dict=True)
+			)
+
+			for entry in delivery_notes:
+				self.delivery_notes[(entry.sales_invoice, entry.item_code)] = entry
+
 	def group_items_by_invoice(self):
 		"""
 		Turns list of Sales Invoice Items to a tree of Sales Invoices with their Items as children.

erpnext/accounts/report/gross_profit/test_gross_profit.py

@@ -0,0 +1,303 @@
+import frappe
+from frappe import qb
+from frappe.tests.utils import FrappeTestCase
+from frappe.utils import add_days, flt, nowdate
+
+from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_delivery_note
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+from erpnext.accounts.report.gross_profit.gross_profit import execute
+from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_invoice
+from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
+from erpnext.stock.doctype.item.test_item import create_item
+from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry
+
+
+class TestGrossProfit(FrappeTestCase):
+	def setUp(self):
+		self.create_company()
+		self.create_item()
+		self.create_bundle()
+		self.create_customer()
+		self.create_sales_invoice()
+		self.clear_old_entries()
+
+	def tearDown(self):
+		frappe.db.rollback()
+
+	def create_company(self):
+		company_name = "_Test Gross Profit"
+		abbr = "_GP"
+		if frappe.db.exists("Company", company_name):
+			company = frappe.get_doc("Company", company_name)
+		else:
+			company = frappe.get_doc(
+				{
+					"doctype": "Company",
+					"company_name": company_name,
+					"country": "India",
+					"default_currency": "INR",
+					"create_chart_of_accounts_based_on": "Standard Template",
+					"chart_of_accounts": "Standard",
+				}
+			)
+			company = company.save()
+
+		self.company = company.name
+		self.cost_center = company.cost_center
+		self.warehouse = "Stores - " + abbr
+		self.finished_warehouse = "Finished Goods - " + abbr
+		self.income_account = "Sales - " + abbr
+		self.expense_account = "Cost of Goods Sold - " + abbr
+		self.debit_to = "Debtors - " + abbr
+		self.creditors = "Creditors - " + abbr
+
+	def create_item(self):
+		item = create_item(
+			item_code="_Test GP Item", is_stock_item=1, company=self.company, warehouse=self.warehouse
+		)
+		self.item = item if isinstance(item, str) else item.item_code
+
+	def create_bundle(self):
+		from erpnext.selling.doctype.product_bundle.test_product_bundle import make_product_bundle
+
+		item2 = create_item(
+			item_code="_Test GP Item 2", is_stock_item=1, company=self.company, warehouse=self.warehouse
+		)
+		self.item2 = item2 if isinstance(item2, str) else item2.item_code
+
+		# This will be parent item
+		bundle = create_item(
+			item_code="_Test GP bundle", is_stock_item=0, company=self.company, warehouse=self.warehouse
+		)
+		self.bundle = bundle if isinstance(bundle, str) else bundle.item_code
+
+		# Create Product Bundle
+		self.product_bundle = make_product_bundle(parent=self.bundle, items=[self.item, self.item2])
+
+	def create_customer(self):
+		name = "_Test GP Customer"
+		if frappe.db.exists("Customer", name):
+			self.customer = name
+		else:
+			customer = frappe.new_doc("Customer")
+			customer.customer_name = name
+			customer.type = "Individual"
+			customer.save()
+			self.customer = customer.name
+
+	def create_sales_invoice(
+		self, qty=1, rate=100, posting_date=nowdate(), do_not_save=False, do_not_submit=False
+	):
+		"""
+		Helper function to populate default values in sales invoice
+		"""
+		sinv = create_sales_invoice(
+			qty=qty,
+			rate=rate,
+			company=self.company,
+			customer=self.customer,
+			item_code=self.item,
+			item_name=self.item,
+			cost_center=self.cost_center,
+			warehouse=self.warehouse,
+			debit_to=self.debit_to,
+			parent_cost_center=self.cost_center,
+			update_stock=0,
+			currency="INR",
+			is_pos=0,
+			is_return=0,
+			return_against=None,
+			income_account=self.income_account,
+			expense_account=self.expense_account,
+			do_not_save=do_not_save,
+			do_not_submit=do_not_submit,
+		)
+		return sinv
+
+	def create_delivery_note(
+		self, item=None, qty=1, rate=100, posting_date=nowdate(), do_not_save=False, do_not_submit=False
+	):
+		"""
+		Helper function to populate default values in Delivery Note
+		"""
+		dnote = create_delivery_note(
+			company=self.company,
+			customer=self.customer,
+			currency="INR",
+			item=item or self.item,
+			qty=qty,
+			rate=rate,
+			cost_center=self.cost_center,
+			warehouse=self.warehouse,
+			return_against=None,
+			expense_account=self.expense_account,
+			do_not_save=do_not_save,
+			do_not_submit=do_not_submit,
+		)
+		return dnote
+
+	def clear_old_entries(self):
+		doctype_list = [
+			"Sales Invoice",
+			"GL Entry",
+			"Stock Entry",
+			"Stock Ledger Entry",
+			"Delivery Note",
+		]
+		for doctype in doctype_list:
+			qb.from_(qb.DocType(doctype)).delete().where(qb.DocType(doctype).company == self.company).run()
+
+	def test_invoice_without_only_delivery_note(self):
+		"""
+		Test buying amount for Invoice without `update_stock` flag set but has Delivery Note
+		"""
+		se = make_stock_entry(
+			company=self.company,
+			item_code=self.item,
+			target=self.warehouse,
+			qty=1,
+			basic_rate=100,
+			do_not_submit=True,
+		)
+		item = se.items[0]
+		se.append(
+			"items",
+			{
+				"item_code": item.item_code,
+				"s_warehouse": item.s_warehouse,
+				"t_warehouse": item.t_warehouse,
+				"qty": 1,
+				"basic_rate": 200,
+				"conversion_factor": item.conversion_factor or 1.0,
+				"transfer_qty": flt(item.qty) * (flt(item.conversion_factor) or 1.0),
+				"serial_no": item.serial_no,
+				"batch_no": item.batch_no,
+				"cost_center": item.cost_center,
+				"expense_account": item.expense_account,
+			},
+		)
+		se = se.save().submit()
+
+		sinv = create_sales_invoice(
+			qty=1,
+			rate=100,
+			company=self.company,
+			customer=self.customer,
+			item_code=self.item,
+			item_name=self.item,
+			cost_center=self.cost_center,
+			warehouse=self.warehouse,
+			debit_to=self.debit_to,
+			parent_cost_center=self.cost_center,
+			update_stock=0,
+			currency="INR",
+			income_account=self.income_account,
+			expense_account=self.expense_account,
+		)
+
+		filters = frappe._dict(
+			company=self.company, from_date=nowdate(), to_date=nowdate(), group_by="Invoice"
+		)
+
+		columns, data = execute(filters=filters)
+
+		# Without Delivery Note, buying rate should be 150
+		expected_entry_without_dn = {
+			"parent_invoice": sinv.name,
+			"currency": "INR",
+			"sales_invoice": self.item,
+			"customer": self.customer,
+			"posting_date": frappe.utils.datetime.date.fromisoformat(nowdate()),
+			"item_code": self.item,
+			"item_name": self.item,
+			"warehouse": "Stores - _GP",
+			"qty": 1.0,
+			"avg._selling_rate": 100.0,
+			"valuation_rate": 150.0,
+			"selling_amount": 100.0,
+			"buying_amount": 150.0,
+			"gross_profit": -50.0,
+			"gross_profit_%": -50.0,
+		}
+		gp_entry = [x for x in data if x.parent_invoice == sinv.name]
+		self.assertDictContainsSubset(expected_entry_without_dn, gp_entry[0])
+
+		# make delivery note
+		dn = make_delivery_note(sinv.name)
+		dn.items[0].qty = 1
+		dn = dn.save().submit()
+
+		columns, data = execute(filters=filters)
+
+		# Without Delivery Note, buying rate should be 100
+		expected_entry_with_dn = {
+			"parent_invoice": sinv.name,
+			"currency": "INR",
+			"sales_invoice": self.item,
+			"customer": self.customer,
+			"posting_date": frappe.utils.datetime.date.fromisoformat(nowdate()),
+			"item_code": self.item,
+			"item_name": self.item,
+			"warehouse": "Stores - _GP",
+			"qty": 1.0,
+			"avg._selling_rate": 100.0,
+			"valuation_rate": 100.0,
+			"selling_amount": 100.0,
+			"buying_amount": 100.0,
+			"gross_profit": 0.0,
+			"gross_profit_%": 0.0,
+		}
+		gp_entry = [x for x in data if x.parent_invoice == sinv.name]
+		self.assertDictContainsSubset(expected_entry_with_dn, gp_entry[0])
+
+	def test_bundled_delivery_note_with_different_warehouses(self):
+		"""
+		Test Delivery Note with bundled item. Packed Item from the bundle having different warehouses
+		"""
+		se = make_stock_entry(
+			company=self.company,
+			item_code=self.item,
+			target=self.warehouse,
+			qty=1,
+			basic_rate=100,
+			do_not_submit=True,
+		)
+		item = se.items[0]
+		se.append(
+			"items",
+			{
+				"item_code": self.item2,
+				"s_warehouse": "",
+				"t_warehouse": self.finished_warehouse,
+				"qty": 1,
+				"basic_rate": 100,
+				"conversion_factor": item.conversion_factor or 1.0,
+				"transfer_qty": flt(item.qty) * (flt(item.conversion_factor) or 1.0),
+				"serial_no": item.serial_no,
+				"batch_no": item.batch_no,
+				"cost_center": item.cost_center,
+				"expense_account": item.expense_account,
+			},
+		)
+		se = se.save().submit()
+
+		# Make a Delivery note with Product bundle
+		# Packed Items will have different warehouses
+		dnote = self.create_delivery_note(item=self.bundle, qty=1, rate=200, do_not_submit=True)
+		dnote.packed_items[1].warehouse = self.finished_warehouse
+		dnote = dnote.submit()
+
+		# make Sales Invoice for above delivery note
+		sinv = make_sales_invoice(dnote.name)
+		sinv = sinv.save().submit()
+
+		filters = frappe._dict(
+			company=self.company,
+			from_date=nowdate(),
+			to_date=nowdate(),
+			group_by="Invoice",
+			sales_invoice=sinv.name,
+		)
+
+		columns, data = execute(filters=filters)
+		self.assertGreater(len(data), 0)

erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py

@@ -53,9 +53,6 @@ def _execute(filters=None, additional_table_columns=None, additional_query_colum
 	item_details = get_item_details()
 
 	for d in item_list:
-		if not d.stock_qty:
-			continue
-
 		item_record = item_details.get(d.item_code)
 
 		purchase_receipt = None
@@ -94,7 +91,7 @@ def _execute(filters=None, additional_table_columns=None, additional_query_colum
 				"expense_account": expense_account,
 				"stock_qty": d.stock_qty,
 				"stock_uom": d.stock_uom,
-				"rate": d.base_net_amount / d.stock_qty,
+				"rate": d.base_net_amount / d.stock_qty if d.stock_qty else d.base_net_amount,
 				"amount": d.base_net_amount,
 			}
 		)

erpnext/accounts/report/purchase_register/purchase_register.py

@@ -232,12 +232,12 @@ def get_conditions(filters):
 
 					conditions += (
 						common_condition
-						+ "and ifnull(`tabPurchase Invoice Item`.{0}, '') in %({0})s)".format(dimension.fieldname)
+						+ "and ifnull(`tabPurchase Invoice`.{0}, '') in %({0})s)".format(dimension.fieldname)
 					)
 				else:
 					conditions += (
 						common_condition
-						+ "and ifnull(`tabPurchase Invoice Item`.{0}, '') in %({0})s)".format(dimension.fieldname)
+						+ "and ifnull(`tabPurchase Invoice`.{0}, '') in %({0})s)".format(dimension.fieldname)
 					)
 
 	return conditions

erpnext/accounts/report/sales_register/sales_register.py

@@ -390,12 +390,12 @@ def get_conditions(filters):
 
 					conditions += (
 						common_condition
-						+ "and ifnull(`tabSales Invoice Item`.{0}, '') in %({0})s)".format(dimension.fieldname)
+						+ "and ifnull(`tabSales Invoice`.{0}, '') in %({0})s)".format(dimension.fieldname)
 					)
 				else:
 					conditions += (
 						common_condition
-						+ "and ifnull(`tabSales Invoice Item`.{0}, '') in %({0})s)".format(dimension.fieldname)
+						+ "and ifnull(`tabSales Invoice`.{0}, '') in %({0})s)".format(dimension.fieldname)
 					)
 
 	return conditions

erpnext/accounts/report/supplier_ledger_summary/supplier_ledger_summary.js

@@ -63,24 +63,6 @@ frappe.query_reports["Supplier Ledger Summary"] = {
 			"fieldtype": "Link",
 			"options": "Payment Terms Template"
 		},
-		{
-			"fieldname":"territory",
-			"label": __("Territory"),
-			"fieldtype": "Link",
-			"options": "Territory"
-		},
-		{
-			"fieldname":"sales_partner",
-			"label": __("Sales Partner"),
-			"fieldtype": "Link",
-			"options": "Sales Partner"
-		},
-		{
-			"fieldname":"sales_person",
-			"label": __("Sales Person"),
-			"fieldtype": "Link",
-			"options": "Sales Person"
-		},
 		{
 			"fieldname":"tax_id",
 			"label": __("Tax Id"),

erpnext/accounts/report/utils.py

@@ -28,7 +28,7 @@ def get_currency(filters):
 		filters["presentation_currency"] if filters.get("presentation_currency") else company_currency
 	)
 
-	report_date = filters.get("to_date")
+	report_date = filters.get("to_date") or filters.get("period_end_date")
 
 	if not report_date:
 		fiscal_year_to_date = get_from_and_to_date(filters.get("to_fiscal_year"))["to_date"]

erpnext/assets/doctype/asset/asset.js

@@ -132,6 +132,10 @@ frappe.ui.form.on('Asset', {
 				}, __("Manage"));
 			}
 
+			if (frm.doc.depr_entry_posting_status === "Failed") {
+				frm.trigger("set_depr_posting_failure_alert");
+			}
+
 			frm.trigger("setup_chart");
 		}
 
@@ -142,6 +146,19 @@ frappe.ui.form.on('Asset', {
 		}
 	},
 
+	set_depr_posting_failure_alert: function (frm) {
+		const alert = `
+			<div class="row">
+				<div class="col-xs-12 col-sm-6">
+					<span class="indicator whitespace-nowrap red">
+						<span>Failed to post depreciation entries</span>
+					</span>
+				</div>
+			</div>`;
+
+		frm.dashboard.set_headline_alert(alert);
+	},
+
 	toggle_reference_doc: function(frm) {
 		if (frm.doc.purchase_receipt && frm.doc.purchase_invoice && frm.doc.docstatus === 1) {
 			frm.set_df_property('purchase_invoice', 'read_only', 1);

erpnext/assets/doctype/asset/asset.json

@@ -68,6 +68,7 @@
   "column_break_51",
   "purchase_receipt_amount",
   "default_finance_book",
+  "depr_entry_posting_status",
   "amended_from"
  ],
  "fields": [
@@ -473,6 +474,16 @@
    "fieldname": "section_break_36",
    "fieldtype": "Section Break",
    "label": "Finance Books"
+  },
+  {
+   "fieldname": "depr_entry_posting_status",
+   "fieldtype": "Select",
+   "hidden": 1,
+   "label": "Depreciation Entry Posting Status",
+   "no_copy": 1,
+   "options": "\nSuccessful\nFailed",
+   "print_hide": 1,
+   "read_only": 1
   }
  ],
  "idx": 72,
@@ -487,7 +498,7 @@
   {
    "group": "Repair",
    "link_doctype": "Asset Repair",
-   "link_fieldname": "asset_name"
+   "link_fieldname": "asset"
   },
   {
    "group": "Value",
@@ -495,7 +506,7 @@
    "link_fieldname": "asset"
   }
  ],
- "modified": "2022-07-20 16:22:44.437579",
+ "modified": "2023-01-17 00:28:37.789345",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset",

erpnext/assets/doctype/asset/asset.py

@@ -825,7 +825,9 @@ def update_maintenance_status():
 
 	for asset in assets:
 		asset = frappe.get_doc("Asset", asset.name)
-		if frappe.db.exists("Asset Repair", {"asset_name": asset.name, "repair_status": "Pending"}):
+		if frappe.db.exists(
+			"Asset Repair", {"asset_name": asset.name, "repair_status": "Pending", "docstatus": 0}
+		):
 			asset.set_status("Out of Order")
 		elif frappe.db.exists(
 			"Asset Maintenance Task", {"parent": asset.name, "next_due_date": today()}

erpnext/assets/doctype/asset/depreciation.py

@@ -4,7 +4,8 @@
 
 import frappe
 from frappe import _
-from frappe.utils import cint, flt, getdate, today
+from frappe.utils import cint, flt, get_link_to_form, getdate, today
+from frappe.utils.user import get_users_with_role
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_checks_for_pl_and_bs_accounts,
@@ -20,9 +21,22 @@ def post_depreciation_entries(date=None):
 
 	if not date:
 		date = today()
-	for asset in get_depreciable_assets(date):
-		make_depreciation_entry(asset, date)
-		frappe.db.commit()
+
+	failed_asset_names = []
+
+	for asset_name in get_depreciable_assets(date):
+		try:
+			make_depreciation_entry(asset_name, date)
+			frappe.db.commit()
+		except Exception as e:
+			frappe.db.rollback()
+			failed_asset_names.append(asset_name)
+
+	if failed_asset_names:
+		set_depr_entry_posting_status_for_failed_assets(failed_asset_names)
+		notify_depr_entry_posting_error(failed_asset_names)
+
+	frappe.db.commit()
 
 
 def get_depreciable_assets(date):
@@ -121,6 +135,8 @@ def make_depreciation_entry(asset_name, date=None):
 			finance_books.value_after_depreciation -= d.depreciation_amount
 			finance_books.db_update()
 
+	frappe.db.set_value("Asset", asset_name, "depr_entry_posting_status", "Successful")
+
 	asset.set_status()
 
 	return asset
@@ -184,6 +200,42 @@ def get_credit_and_debit_accounts(accumulated_depreciation_account, depreciation
 	return credit_account, debit_account
 
 
+def set_depr_entry_posting_status_for_failed_assets(failed_asset_names):
+	for asset_name in failed_asset_names:
+		frappe.db.set_value("Asset", asset_name, "depr_entry_posting_status", "Failed")
+
+
+def notify_depr_entry_posting_error(failed_asset_names):
+	recipients = get_users_with_role("Accounts Manager")
+
+	if not recipients:
+		recipients = get_users_with_role("System Manager")
+
+	subject = _("Error while posting depreciation entries")
+
+	asset_links = get_comma_separated_asset_links(failed_asset_names)
+
+	message = (
+		_("Hi,")
+		+ "<br>"
+		+ _("The following assets have failed to post depreciation entries: {0}").format(asset_links)
+		+ "."
+	)
+
+	frappe.sendmail(recipients=recipients, subject=subject, message=message)
+
+
+def get_comma_separated_asset_links(asset_names):
+	asset_links = []
+
+	for asset_name in asset_names:
+		asset_links.append(get_link_to_form("Asset", asset_name))
+
+	asset_links = ", ".join(asset_links)
+
+	return asset_links
+
+
 @frappe.whitelist()
 def scrap_asset(asset_name):
 	asset = frappe.get_doc("Asset", asset_name)

erpnext/assets/doctype/asset/test_asset.py

@@ -1387,6 +1387,7 @@ def create_asset(**args):
 			"location": args.location or "Test Location",
 			"asset_owner": args.asset_owner or "Company",
 			"is_existing_asset": args.is_existing_asset or 1,
+			"depr_entry_posting_status": args.depr_entry_posting_status or "",
 		}
 	)
 

erpnext/assets/doctype/location/location.py

@@ -200,11 +200,11 @@ def get_children(doctype, parent=None, location=None, is_root=False):
 			name as value,
 			is_group as expandable
 		from
-			`tab{doctype}` comp
+			`tabLocation` comp
 		where
 			ifnull(parent_location, "")={parent}
 		""".format(
-			doctype=doctype, parent=frappe.db.escape(parent)
+			parent=frappe.db.escape(parent)
 		),
 		as_dict=1,
 	)

erpnext/assets/report/fixed_asset_register/fixed_asset_register.py

@@ -86,6 +86,7 @@ def get_data(filters):
 			"status",
 			"department",
 			"cost_center",
+			"calculate_depreciation",
 			"purchase_receipt",
 			"asset_category",
 			"purchase_date",
@@ -98,11 +99,7 @@ def get_data(filters):
 		assets_record = frappe.db.get_all("Asset", filters=conditions, fields=fields)
 
 	for asset in assets_record:
-		asset_value = (
-			asset.gross_purchase_amount
-			- flt(asset.opening_accumulated_depreciation)
-			- flt(depreciation_amount_map.get(asset.name))
-		)
+		asset_value = get_asset_value(asset, filters.finance_book)
 		row = {
 			"asset_id": asset.asset_id,
 			"asset_name": asset.asset_name,
@@ -125,6 +122,21 @@ def get_data(filters):
 	return data
 
 
+def get_asset_value(asset, finance_book=None):
+	if not asset.calculate_depreciation:
+		return flt(asset.gross_purchase_amount) - flt(asset.opening_accumulated_depreciation)
+
+	finance_book_filter = ["finance_book", "is", "not set"]
+	if finance_book:
+		finance_book_filter = ["finance_book", "=", finance_book]
+
+	return frappe.db.get_value(
+		doctype="Asset Finance Book",
+		filters=[["parent", "=", asset.asset_id], finance_book_filter],
+		fieldname="value_after_depreciation",
+	)
+
+
 def prepare_chart_data(data, filters):
 	labels_values_map = {}
 	date_field = frappe.scrub(filters.date_based_on)

erpnext/buying/doctype/purchase_order/purchase_order.json

@@ -370,7 +370,7 @@
   {
    "fieldname": "shipping_address",
    "fieldtype": "Link",
-   "label": "Company Shipping Address",
+   "label": "Shipping Address",
    "options": "Address",
    "print_hide": 1
   },
@@ -1118,7 +1118,8 @@
    "fetch_from": "supplier.is_internal_supplier",
    "fieldname": "is_internal_supplier",
    "fieldtype": "Check",
-   "label": "Is Internal Supplier"
+   "label": "Is Internal Supplier",
+   "read_only": 1
   },
   {
    "fetch_from": "supplier.represents_company",
@@ -1169,7 +1170,7 @@
  "idx": 105,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-09-16 17:45:04.954055",
+ "modified": "2022-12-25 18:08:59.074182",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Purchase Order",

erpnext/buying/doctype/request_for_quotation/request_for_quotation.js

@@ -22,6 +22,13 @@ frappe.ui.form.on("Request for Quotation",{
 				}
 			};
 		}
+
+		frm.set_query('warehouse', 'items', () => ({
+			filters: {
+				company: frm.doc.company,
+				is_group: 0
+			}
+		}));
 	},
 
 	onload: function(frm) {

erpnext/buying/doctype/request_for_quotation/request_for_quotation.py

@@ -479,7 +479,7 @@ def get_rfq_containing_supplier(doctype, txt, searchfield, start, page_len, filt
 		conditions += "and rfq.transaction_date = '{0}'".format(filters.get("transaction_date"))
 
 	rfq_data = frappe.db.sql(
-		"""
+		f"""
 		select
 			distinct rfq.name, rfq.transaction_date,
 			rfq.company
@@ -487,15 +487,18 @@ def get_rfq_containing_supplier(doctype, txt, searchfield, start, page_len, filt
 			`tabRequest for Quotation` rfq, `tabRequest for Quotation Supplier` rfq_supplier
 		where
 			rfq.name = rfq_supplier.parent
-			and rfq_supplier.supplier = '{0}'
+			and rfq_supplier.supplier = %(supplier)s
 			and rfq.docstatus = 1
-			and rfq.company = '{1}'
-			{2}
+			and rfq.company = %(company)s
+			{conditions}
 		order by rfq.transaction_date ASC
-		limit %(page_len)s offset %(start)s """.format(
-			filters.get("supplier"), filters.get("company"), conditions
-		),
-		{"page_len": page_len, "start": start},
+		limit %(page_len)s offset %(start)s """,
+		{
+			"page_len": page_len,
+			"start": start,
+			"company": filters.get("company"),
+			"supplier": filters.get("supplier"),
+		},
 		as_dict=1,
 	)
 

erpnext/controllers/accounts_controller.py

@@ -383,7 +383,7 @@ class AccountsController(TransactionBase):
 				self.get("inter_company_reference")
 				or self.get("inter_company_invoice_reference")
 				or self.get("inter_company_order_reference")
-			):
+			) and not self.get("is_return"):
 				msg = _("Internal Sale or Delivery Reference missing.")
 				msg += _("Please create purchase from internal sale or delivery document itself")
 				frappe.throw(msg, title=_("Internal Sales Reference Missing"))
@@ -573,7 +573,12 @@ class AccountsController(TransactionBase):
 					if bool(uom) != bool(stock_uom):  # xor
 						item.stock_uom = item.uom = uom or stock_uom
 
-					item.conversion_factor = get_uom_conv_factor(item.get("uom"), item.get("stock_uom"))
+					# UOM cannot be zero so substitute as 1
+					item.conversion_factor = (
+						get_uom_conv_factor(item.get("uom"), item.get("stock_uom"))
+						or item.get("conversion_factor")
+						or 1
+					)
 
 			if self.doctype == "Purchase Invoice":
 				self.set_expense_account(for_validate)

erpnext/controllers/selling_controller.py

@@ -26,7 +26,7 @@ class SellingController(StockController):
 		super(SellingController, self).onload()
 		if self.doctype in ("Sales Order", "Delivery Note", "Sales Invoice"):
 			for item in self.get("items"):
-				item.update(get_bin_details(item.item_code, item.warehouse))
+				item.update(get_bin_details(item.item_code, item.warehouse, include_child_warehouses=True))
 
 	def validate(self):
 		super(SellingController, self).validate()
@@ -578,6 +578,7 @@ class SellingController(StockController):
 			"customer_address": "address_display",
 			"shipping_address_name": "shipping_address",
 			"company_address": "company_address_display",
+			"dispatch_address_name": "dispatch_address",
 		}
 
 		for address_field, address_display_field in address_dict.items():

erpnext/controllers/status_updater.py

@@ -333,16 +333,21 @@ class StatusUpdater(Document):
 		)
 
 	def warn_about_bypassing_with_role(self, item, qty_or_amount, role):
-		action = _("Over Receipt/Delivery") if qty_or_amount == "qty" else _("Overbilling")
+		if qty_or_amount == "qty":
+			msg = _("Over Receipt/Delivery of {0} {1} ignored for item {2} because you have {3} role.")
+		else:
+			msg = _("Overbilling of {0} {1} ignored for item {2} because you have {3} role.")
 
-		msg = _("{} of {} {} ignored for item {} because you have {} role.").format(
-			action,
-			_(item["target_ref_field"].title()),
-			frappe.bold(item["reduce_by"]),
-			frappe.bold(item.get("item_code")),
-			role,
+		frappe.msgprint(
+			msg.format(
+				_(item["target_ref_field"].title()),
+				frappe.bold(item["reduce_by"]),
+				frappe.bold(item.get("item_code")),
+				role,
+			),
+			indicator="orange",
+			alert=True,
 		)
-		frappe.msgprint(msg, indicator="orange", alert=True)
 
 	def update_qty(self, update_modified=True):
 		"""Updates qty or amount at row level

erpnext/crm/doctype/appointment/appointment.json

@@ -102,7 +102,7 @@
   }
  ],
  "links": [],
- "modified": "2021-06-29 18:27:02.832979",
+ "modified": "2022-12-28 16:35:34.377575",
  "modified_by": "Administrator",
  "module": "CRM",
  "name": "Appointment",
@@ -121,16 +121,6 @@
    "share": 1,
    "write": 1
   },
-  {
-   "create": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "Guest",
-   "share": 1
-  },
   {
    "create": 1,
    "delete": 1,

erpnext/crm/doctype/appointment/appointment.py

@@ -5,7 +5,9 @@
 from collections import Counter
 
 import frappe
+import frappe.share
 from frappe import _
+from frappe.desk.form.assign_to import add as add_assignment
 from frappe.model.document import Document
 from frappe.utils import get_url, getdate
 from frappe.utils.verified_command import get_signed_params
@@ -118,21 +120,18 @@ class Appointment(Document):
 		self.party = lead.name
 
 	def auto_assign(self):
-		from frappe.desk.form.assign_to import add as add_assignemnt
-
 		existing_assignee = self.get_assignee_from_latest_opportunity()
 		if existing_assignee:
 			# If the latest opportunity is assigned to someone
 			# Assign the appointment to the same
-			add_assignemnt({"doctype": self.doctype, "name": self.name, "assign_to": [existing_assignee]})
+			self.assign_agent(existing_assignee)
 			return
 		if self._assign:
 			return
 		available_agents = _get_agents_sorted_by_asc_workload(getdate(self.scheduled_time))
 		for agent in available_agents:
 			if _check_agent_availability(agent, self.scheduled_time):
-				agent = agent[0]
-				add_assignemnt({"doctype": self.doctype, "name": self.name, "assign_to": [agent]})
+				self.assign_agent(agent[0])
 			break
 
 	def get_assignee_from_latest_opportunity(self):
@@ -187,9 +186,15 @@ class Appointment(Document):
 		params = {"email": self.customer_email, "appointment": self.name}
 		return get_url(verify_route + "?" + get_signed_params(params))
 
+	def assign_agent(self, agent):
+		if not frappe.has_permission(doc=self, user=agent):
+			frappe.share.add(self.doctype, self.name, agent, flags={"ignore_share_permission": True})
+
+		add_assignment({"doctype": self.doctype, "name": self.name, "assign_to": [agent]})
+
 
 def _get_agents_sorted_by_asc_workload(date):
-	appointments = frappe.db.get_list("Appointment", fields="*")
+	appointments = frappe.get_all("Appointment", fields="*")
 	agent_list = _get_agent_list_as_strings()
 	if not appointments:
 		return agent_list
@@ -214,7 +219,7 @@ def _get_agent_list_as_strings():
 
 
 def _check_agent_availability(agent_email, scheduled_time):
-	appointemnts_at_scheduled_time = frappe.get_list(
+	appointemnts_at_scheduled_time = frappe.get_all(
 		"Appointment", filters={"scheduled_time": scheduled_time}
 	)
 	for appointment in appointemnts_at_scheduled_time:

erpnext/crm/doctype/appointment_booking_settings/appointment_booking_settings.json

@@ -1,4 +1,5 @@
 {
+ "actions": [],
  "creation": "2019-08-27 10:56:48.309824",
  "doctype": "DocType",
  "editable_grid": 1,
@@ -101,7 +102,8 @@
   }
  ],
  "issingle": 1,
- "modified": "2019-11-26 12:14:17.669366",
+ "links": [],
+ "modified": "2022-12-28 16:41:28.773090",
  "modified_by": "Administrator",
  "module": "CRM",
  "name": "Appointment Booking Settings",
@@ -117,13 +119,6 @@
    "share": 1,
    "write": 1
   },
-  {
-   "email": 1,
-   "print": 1,
-   "read": 1,
-   "role": "Guest",
-   "share": 1
-  },
   {
    "create": 1,
    "email": 1,

erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py

@@ -1345,7 +1345,7 @@ class QuickBooksMigrator(Document):
 		)[0]["name"]
 
 	def _publish(self, *args, **kwargs):
-		frappe.publish_realtime("quickbooks_progress_update", *args, **kwargs)
+		frappe.publish_realtime("quickbooks_progress_update", *args, **kwargs, user=self.modified_by)
 
 	def _get_unique_account_name(self, quickbooks_name, number=0):
 		if number:

erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py

@@ -302,6 +302,7 @@ class TallyMigration(Document):
 		frappe.publish_realtime(
 			"tally_migration_progress_update",
 			{"title": title, "message": message, "count": count, "total": total},
+			user=self.modified_by,
 		)
 
 	def _import_master_data(self):

erpnext/erpnext_integrations/taxjar_integration.py

@@ -302,7 +302,7 @@ def check_for_nexus(doc, tax_dict):
 			item.tax_collectable = flt(0)
 			item.taxable_amount = flt(0)
 
-		for tax in doc.taxes:
+		for tax in list(doc.taxes):
 			if tax.account_head == TAX_ACCOUNT_HEAD:
 				doc.taxes.remove(tax)
 		return

erpnext/hr/doctype/attendance/attendance.py

@@ -5,7 +5,16 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.utils import cint, cstr, formatdate, get_datetime, getdate, nowdate
+from frappe.utils import (
+	add_days,
+	cint,
+	cstr,
+	formatdate,
+	get_datetime,
+	get_link_to_form,
+	getdate,
+	nowdate,
+)
 
 from erpnext.hr.utils import get_holiday_dates_for_employee, validate_active_employee
 
@@ -106,8 +115,6 @@ class Attendance(Document):
 			frappe.throw(_("Employee {0} is not active or does not exist").format(self.employee))
 
 	def unlink_attendance_from_checkins(self):
-		from frappe.utils import get_link_to_form
-
 		EmployeeCheckin = frappe.qb.DocType("Employee Checkin")
 		linked_logs = (
 			frappe.qb.from_(EmployeeCheckin)
@@ -221,75 +228,39 @@ def mark_bulk_attendance(data):
 		attendance.submit()
 
 
-def get_month_map():
-	return frappe._dict(
-		{
-			"January": 1,
-			"February": 2,
-			"March": 3,
-			"April": 4,
-			"May": 5,
-			"June": 6,
-			"July": 7,
-			"August": 8,
-			"September": 9,
-			"October": 10,
-			"November": 11,
-			"December": 12,
-		}
-	)
-
-
 @frappe.whitelist()
-def get_unmarked_days(employee, month, exclude_holidays=0):
-	import calendar
-
-	month_map = get_month_map()
-	today = get_datetime()
-
+def get_unmarked_days(employee, from_date, to_date, exclude_holidays=0):
 	joining_date, relieving_date = frappe.get_cached_value(
 		"Employee", employee, ["date_of_joining", "relieving_date"]
 	)
-	start_day = 1
-	end_day = calendar.monthrange(today.year, month_map[month])[1] + 1
 
-	if joining_date and joining_date.year == today.year and joining_date.month == month_map[month]:
-		start_day = joining_date.day
-
-	if (
-		relieving_date and relieving_date.year == today.year and relieving_date.month == month_map[month]
-	):
-		end_day = relieving_date.day + 1
-
-	dates_of_month = [
-		"{}-{}-{}".format(today.year, month_map[month], r) for r in range(start_day, end_day)
-	]
-	month_start, month_end = dates_of_month[0], dates_of_month[-1]
+	from_date = max(getdate(from_date), joining_date or getdate(from_date))
+	to_date = min(getdate(to_date), relieving_date or getdate(to_date))
 
 	records = frappe.get_all(
 		"Attendance",
 		fields=["attendance_date", "employee"],
 		filters=[
-			["attendance_date", ">=", month_start],
-			["attendance_date", "<=", month_end],
+			["attendance_date", ">=", from_date],
+			["attendance_date", "<=", to_date],
 			["employee", "=", employee],
 			["docstatus", "!=", 2],
 		],
 	)
 
-	marked_days = [get_datetime(record.attendance_date) for record in records]
+	marked_days = [getdate(record.attendance_date) for record in records]
+
 	if cint(exclude_holidays):
-		holiday_dates = get_holiday_dates_for_employee(employee, month_start, month_end)
-		holidays = [get_datetime(record) for record in holiday_dates]
+		holiday_dates = get_holiday_dates_for_employee(employee, from_date, to_date)
+		holidays = [getdate(record) for record in holiday_dates]
 		marked_days.extend(holidays)
 
 	unmarked_days = []
 
-	for date in dates_of_month:
-		date_time = get_datetime(date)
-		if today.day <= date_time.day and today.month <= date_time.month:
-			break
-		if date_time not in marked_days:
-			unmarked_days.append(date)
+	while from_date <= to_date:
+		if from_date not in marked_days:
+			unmarked_days.append(from_date)
+
+		from_date = add_days(from_date, 1)
 
 	return unmarked_days

erpnext/hr/doctype/attendance/attendance_list.js

@@ -1,5 +1,6 @@
-frappe.listview_settings['Attendance'] = {
+frappe.listview_settings["Attendance"] = {
 	add_fields: ["status", "attendance_date"],
+
 	get_indicator: function (doc) {
 		if (["Present", "Work From Home"].includes(doc.status)) {
 			return [__(doc.status), "green", "status,=," + doc.status];
@@ -10,157 +11,185 @@ frappe.listview_settings['Attendance'] = {
 		}
 	},
 
-	onload: function(list_view) {
+	onload: function (list_view) {
 		let me = this;
-		const months = moment.months();
-		const curMonth = moment().format("MMMM");
-		months.splice(months.indexOf(curMonth) + 1);
-		list_view.page.add_inner_button(__("Mark Attendance"), function() {
+
+		list_view.page.add_inner_button(__("Mark Attendance"), function () {
+			let first_day_of_month = moment().startOf('month');
+
+			if (moment().toDate().getDate() === 1) {
+				first_day_of_month = first_day_of_month.subtract(1, "month");
+			}
+
 			let dialog = new frappe.ui.Dialog({
 				title: __("Mark Attendance"),
-				fields: [{
-					fieldname: 'employee',
-					label: __('For Employee'),
-					fieldtype: 'Link',
-					options: 'Employee',
-					get_query: () => {
-						return {query: "erpnext.controllers.queries.employee_query"};
+				fields: [
+					{
+						fieldname: "employee",
+						label: __("For Employee"),
+						fieldtype: "Link",
+						options: "Employee",
+						get_query: () => {
+							return {
+								query: "erpnext.controllers.queries.employee_query",
+							};
+						},
+						reqd: 1,
+						onchange: () => me.reset_dialog(dialog),
 					},
-					reqd: 1,
-					onchange: function() {
-						dialog.set_df_property("unmarked_days", "hidden", 1);
-						dialog.set_df_property("status", "hidden", 1);
-						dialog.set_df_property("exclude_holidays", "hidden", 1);
-						dialog.set_df_property("month", "value", '');
-						dialog.set_df_property("unmarked_days", "options", []);
-						dialog.no_unmarked_days_left = false;
-					}
-				},
-				{
-					label: __("For Month"),
-					fieldtype: "Select",
-					fieldname: "month",
-					options: months,
-					reqd: 1,
-					onchange: function() {
-						if (dialog.fields_dict.employee.value && dialog.fields_dict.month.value) {
-							dialog.set_df_property("status", "hidden", 0);
-							dialog.set_df_property("exclude_holidays", "hidden", 0);
-							dialog.set_df_property("unmarked_days", "options", []);
-							dialog.no_unmarked_days_left = false;
-							me.get_multi_select_options(
-								dialog.fields_dict.employee.value,
-								dialog.fields_dict.month.value,
-								dialog.fields_dict.exclude_holidays.get_value()
-							).then(options => {
-								if (options.length > 0) {
-									dialog.set_df_property("unmarked_days", "hidden", 0);
-									dialog.set_df_property("unmarked_days", "options", options);
-								} else {
-									dialog.no_unmarked_days_left = true;
-								}
-							});
-						}
-					}
-				},
-				{
-					label: __("Status"),
-					fieldtype: "Select",
-					fieldname: "status",
-					options: ["Present", "Absent", "Half Day", "Work From Home"],
-					hidden: 1,
-					reqd: 1,
-
-				},
-				{
-					label: __("Exclude Holidays"),
-					fieldtype: "Check",
-					fieldname: "exclude_holidays",
-					hidden: 1,
-					onchange: function() {
-						if (dialog.fields_dict.employee.value && dialog.fields_dict.month.value) {
-							dialog.set_df_property("status", "hidden", 0);
-							dialog.set_df_property("unmarked_days", "options", []);
-							dialog.no_unmarked_days_left = false;
-							me.get_multi_select_options(
-								dialog.fields_dict.employee.value,
-								dialog.fields_dict.month.value,
-								dialog.fields_dict.exclude_holidays.get_value()
-							).then(options => {
-								if (options.length > 0) {
-									dialog.set_df_property("unmarked_days", "hidden", 0);
-									dialog.set_df_property("unmarked_days", "options", options);
-								} else {
-									dialog.no_unmarked_days_left = true;
-								}
-							});
-						}
-					}
-				},
-				{
-					label: __("Unmarked Attendance for days"),
-					fieldname: "unmarked_days",
-					fieldtype: "MultiCheck",
-					options: [],
-					columns: 2,
-					hidden: 1
-				}],
+					{
+						fieldtype: "Section Break",
+						fieldname: "time_period_section",
+						hidden: 1,
+					},
+					{
+						label: __("Start"),
+						fieldtype: "Date",
+						fieldname: "from_date",
+						reqd: 1,
+						default: first_day_of_month.toDate(),
+						onchange: () => me.get_unmarked_days(dialog),
+					},
+					{
+						fieldtype: "Column Break",
+						fieldname: "time_period_column",
+					},
+					{
+						label: __("End"),
+						fieldtype: "Date",
+						fieldname: "to_date",
+						reqd: 1,
+						default: moment().subtract(1, 'days').toDate(),
+						onchange: () => me.get_unmarked_days(dialog),
+					},
+					{
+						fieldtype: "Section Break",
+						fieldname: "days_section",
+						hidden: 1,
+					},
+					{
+						label: __("Status"),
+						fieldtype: "Select",
+						fieldname: "status",
+						options: ["Present", "Absent", "Half Day", "Work From Home"],
+						reqd: 1,
+					},
+					{
+						label: __("Exclude Holidays"),
+						fieldtype: "Check",
+						fieldname: "exclude_holidays",
+						onchange: () => me.get_unmarked_days(dialog),
+					},
+					{
+						label: __("Unmarked Attendance for days"),
+						fieldname: "unmarked_days",
+						fieldtype: "MultiCheck",
+						options: [],
+						columns: 2,
+					},
+				],
 				primary_action(data) {
 					if (cur_dialog.no_unmarked_days_left) {
-						frappe.msgprint(__("Attendance for the month of {0} , has already been marked for the Employee {1}",
-							[dialog.fields_dict.month.value, dialog.fields_dict.employee.value]));
+						frappe.msgprint(
+							__(
+								"Attendance from {0} to {1} has already been marked for the Employee {2}",
+								[data.from_date, data.to_date, data.employee]
+							)
+						);
 					} else {
-						frappe.confirm(__('Mark attendance as {0} for {1} on selected dates?', [data.status, data.month]), () => {
-							frappe.call({
-								method: "erpnext.hr.doctype.attendance.attendance.mark_bulk_attendance",
-								args: {
-									data: data
-								},
-								callback: function (r) {
-									if (r.message === 1) {
-										frappe.show_alert({
-											message: __("Attendance Marked"),
-											indicator: 'blue'
-										});
-										cur_dialog.hide();
-									}
-								}
-							});
-						});
+						frappe.confirm(
+							__("Mark attendance as {0} for {1} on selected dates?", [
+								data.status,
+								data.employee,
+							]),
+							() => {
+								frappe.call({
+									method: "erpnext.hr.doctype.attendance.attendance.mark_bulk_attendance",
+									args: {
+										data: data,
+									},
+									callback: function (r) {
+										if (r.message === 1) {
+											frappe.show_alert({
+												message: __("Attendance Marked"),
+												indicator: "blue",
+											});
+											cur_dialog.hide();
+										}
+									},
+								});
+							}
+						);
 					}
 					dialog.hide();
 					list_view.refresh();
 				},
-				primary_action_label: __('Mark Attendance')
-
+				primary_action_label: __("Mark Attendance"),
 			});
 			dialog.show();
 		});
 	},
 
-	get_multi_select_options: function(employee, month, exclude_holidays) {
-		return new Promise(resolve => {
-			frappe.call({
-				method: 'erpnext.hr.doctype.attendance.attendance.get_unmarked_days',
-				async: false,
-				args: {
-					employee: employee,
-					month: month,
-					exclude_holidays: exclude_holidays
-				}
-			}).then(r => {
-				var options = [];
-				for (var d in r.message) {
-					var momentObj = moment(r.message[d], 'YYYY-MM-DD');
-					var date = momentObj.format('DD-MM-YYYY');
-					options.push({
-						"label": date,
-						"value": r.message[d],
-						"checked": 1
-					});
-				}
-				resolve(options);
-			});
+	reset_dialog: function (dialog) {
+		let fields = dialog.fields_dict;
+
+		dialog.set_df_property(
+			"time_period_section",
+			"hidden",
+			fields.employee.value ? 0 : 1
+		);
+
+		dialog.set_df_property("days_section", "hidden", 1);
+		dialog.set_df_property("unmarked_days", "options", []);
+		dialog.no_unmarked_days_left = false;
+		fields.exclude_holidays.value = false;
+
+		fields.to_date.datepicker.update({
+			maxDate: moment().subtract(1, 'days').toDate()
 		});
-	}
+
+		this.get_unmarked_days(dialog)
+	},
+
+	get_unmarked_days: function (dialog) {
+		let fields = dialog.fields_dict;
+		if (fields.employee.value && fields.from_date.value && fields.to_date.value) {
+			dialog.set_df_property("days_section", "hidden", 0);
+			dialog.set_df_property("status", "hidden", 0);
+			dialog.set_df_property("exclude_holidays", "hidden", 0);
+			dialog.no_unmarked_days_left = false;
+
+			frappe
+				.call({
+					method: "erpnext.hr.doctype.attendance.attendance.get_unmarked_days",
+					async: false,
+					args: {
+						employee: fields.employee.value,
+						from_date: fields.from_date.value,
+						to_date: fields.to_date.value,
+						exclude_holidays: fields.exclude_holidays.value,
+					},
+				})
+				.then((r) => {
+					var options = [];
+
+					for (var d in r.message) {
+						var momentObj = moment(r.message[d], "YYYY-MM-DD");
+						var date = momentObj.format("DD-MM-YYYY");
+						options.push({
+							label: date,
+							value: r.message[d],
+							checked: 1,
+						});
+					}
+
+					dialog.set_df_property(
+						"unmarked_days",
+						"options",
+						options.length > 0 ? options : []
+					);
+					dialog.no_unmarked_days_left = options.length === 0;
+				});
+		}
+	},
 };

erpnext/hr/doctype/attendance/test_attendance.py

@@ -6,6 +6,7 @@ from frappe.tests.utils import FrappeTestCase
 from frappe.utils import (
 	add_days,
 	add_months,
+	get_first_day,
 	get_last_day,
 	get_year_ending,
 	get_year_start,
@@ -13,11 +14,7 @@ from frappe.utils import (
 	nowdate,
 )
 
-from erpnext.hr.doctype.attendance.attendance import (
-	get_month_map,
-	get_unmarked_days,
-	mark_attendance,
-)
+from erpnext.hr.doctype.attendance.attendance import get_unmarked_days, mark_attendance
 from erpnext.hr.doctype.employee.test_employee import make_employee
 from erpnext.hr.tests.test_utils import get_first_sunday
 
@@ -28,7 +25,7 @@ class TestAttendance(FrappeTestCase):
 	def setUp(self):
 		from erpnext.payroll.doctype.salary_slip.test_salary_slip import make_holiday_list
 
-		from_date = get_year_start(getdate())
+		from_date = get_year_start(add_months(getdate(), -1))
 		to_date = get_year_ending(getdate())
 		self.holiday_list = make_holiday_list(from_date=from_date, to_date=to_date)
 
@@ -55,9 +52,10 @@ class TestAttendance(FrappeTestCase):
 		frappe.db.set_value("Employee", employee, "holiday_list", self.holiday_list)
 
 		mark_attendance(employee, attendance_date, "Present")
-		month_name = get_month_name(attendance_date)
 
-		unmarked_days = get_unmarked_days(employee, month_name)
+		unmarked_days = get_unmarked_days(
+			employee, get_first_day(attendance_date), get_last_day(attendance_date)
+		)
 		unmarked_days = [getdate(date) for date in unmarked_days]
 
 		# attendance already marked for the day
@@ -81,9 +79,10 @@ class TestAttendance(FrappeTestCase):
 		frappe.db.set_value("Employee", employee, "holiday_list", self.holiday_list)
 
 		mark_attendance(employee, attendance_date, "Present")
-		month_name = get_month_name(attendance_date)
 
-		unmarked_days = get_unmarked_days(employee, month_name, exclude_holidays=True)
+		unmarked_days = unmarked_days = get_unmarked_days(
+			employee, get_first_day(attendance_date), get_last_day(attendance_date), exclude_holidays=True
+		)
 		unmarked_days = [getdate(date) for date in unmarked_days]
 
 		# attendance already marked for the day
@@ -110,9 +109,10 @@ class TestAttendance(FrappeTestCase):
 
 		attendance_date = add_days(date, 2)
 		mark_attendance(employee, attendance_date, "Present")
-		month_name = get_month_name(attendance_date)
 
-		unmarked_days = get_unmarked_days(employee, month_name)
+		unmarked_days = get_unmarked_days(
+			employee, get_first_day(attendance_date), get_last_day(attendance_date)
+		)
 		unmarked_days = [getdate(date) for date in unmarked_days]
 
 		# attendance already marked for the day
@@ -124,10 +124,3 @@ class TestAttendance(FrappeTestCase):
 
 	def tearDown(self):
 		frappe.db.rollback()
-
-
-def get_month_name(date):
-	month_number = date.month
-	for month, number in get_month_map().items():
-		if number == month_number:
-			return month

erpnext/hr/doctype/department/department.py

@@ -70,11 +70,11 @@ def get_children(doctype, parent=None, company=None, is_root=False):
 		select
 			name as value,
 			is_group as expandable
-		from `tab{doctype}`
+		from `tabDepartment`
 		where
 			{condition}
 		order by name""".format(
-			doctype=doctype, condition=condition
+			condition=condition
 		),
 		var_dict,
 		as_dict=1,

erpnext/hr/report/employee_leave_balance/employee_leave_balance.py

@@ -111,34 +111,30 @@ def get_data(filters: Filters) -> List:
 				employee.leave_approver
 			)
 
-			if (
-				(leave_approvers and len(leave_approvers) and user in leave_approvers)
-				or (user in ["Administrator", employee.user_id])
-				or ("HR Manager" in frappe.get_roles(user))
-			):
-				if len(active_employees) > 1:
-					row = frappe._dict()
-				row.employee = employee.name
-				row.employee_name = employee.employee_name
+			if len(active_employees) > 1:
+				row = frappe._dict()
 
-				leaves_taken = (
-					get_leaves_for_period(employee.name, leave_type, filters.from_date, filters.to_date) * -1
-				)
+			row.employee = employee.name
+			row.employee_name = employee.employee_name
 
-				new_allocation, expired_leaves, carry_forwarded_leaves = get_allocated_and_expired_leaves(
-					filters.from_date, filters.to_date, employee.name, leave_type
-				)
-				opening = get_opening_balance(employee.name, leave_type, filters, carry_forwarded_leaves)
+			leaves_taken = (
+				get_leaves_for_period(employee.name, leave_type, filters.from_date, filters.to_date) * -1
+			)
 
-				row.leaves_allocated = new_allocation
-				row.leaves_expired = expired_leaves
-				row.opening_balance = opening
-				row.leaves_taken = leaves_taken
+			new_allocation, expired_leaves, carry_forwarded_leaves = get_allocated_and_expired_leaves(
+				filters.from_date, filters.to_date, employee.name, leave_type
+			)
+			opening = get_opening_balance(employee.name, leave_type, filters, carry_forwarded_leaves)
 
-				# not be shown on the basis of days left it create in user mind for carry_forward leave
-				row.closing_balance = new_allocation + opening - (row.leaves_expired + leaves_taken)
-				row.indent = 1
-				data.append(row)
+			row.leaves_allocated = new_allocation
+			row.leaves_expired = expired_leaves
+			row.opening_balance = opening
+			row.leaves_taken = leaves_taken
+
+			# not be shown on the basis of days left it create in user mind for carry_forward leave
+			row.closing_balance = new_allocation + opening - (row.leaves_expired + leaves_taken)
+			row.indent = 1
+			data.append(row)
 
 	return data
 

erpnext/hr/report/employee_leave_balance_summary/employee_leave_balance_summary.py

@@ -65,21 +65,16 @@ def get_data(filters, leave_types):
 		if employee.leave_approver:
 			leave_approvers.append(employee.leave_approver)
 
-		if (
-			(len(leave_approvers) and user in leave_approvers)
-			or (user in ["Administrator", employee.user_id])
-			or ("HR Manager" in frappe.get_roles(user))
-		):
-			row = [employee.name, employee.employee_name, employee.department]
-			available_leave = get_leave_details(employee.name, filters.date)
-			for leave_type in leave_types:
-				remaining = 0
-				if leave_type in available_leave["leave_allocation"]:
-					# opening balance
-					remaining = available_leave["leave_allocation"][leave_type]["remaining_leaves"]
+		row = [employee.name, employee.employee_name, employee.department]
+		available_leave = get_leave_details(employee.name, filters.date)
+		for leave_type in leave_types:
+			remaining = 0
+			if leave_type in available_leave["leave_allocation"]:
+				# opening balance
+				remaining = available_leave["leave_allocation"][leave_type]["remaining_leaves"]
 
-				row += [remaining]
+			row += [remaining]
 
-			data.append(row)
+		data.append(row)
 
 	return data

erpnext/hr/report/monthly_attendance_sheet/test_monthly_attendance_sheet.py

@@ -1,7 +1,7 @@
 import frappe
 from dateutil.relativedelta import relativedelta
 from frappe.tests.utils import FrappeTestCase
-from frappe.utils import now_datetime
+from frappe.utils import add_months, getdate
 
 from erpnext.hr.doctype.attendance.attendance import mark_attendance
 from erpnext.hr.doctype.employee.test_employee import make_employee
@@ -14,9 +14,7 @@ class TestMonthlyAttendanceSheet(FrappeTestCase):
 		frappe.db.delete("Attendance", {"employee": self.employee})
 
 	def test_monthly_attendance_sheet_report(self):
-		now = now_datetime()
-		previous_month = now.month - 1
-		previous_month_first = now.replace(day=1).replace(month=previous_month).date()
+		previous_month_first = add_months(getdate(), -1).replace(day=1)
 
 		company = frappe.db.get_value("Employee", self.employee, "company")
 
@@ -27,8 +25,8 @@ class TestMonthlyAttendanceSheet(FrappeTestCase):
 
 		filters = frappe._dict(
 			{
-				"month": previous_month,
-				"year": now.year,
+				"month": previous_month_first.month,
+				"year": previous_month_first.year,
 				"company": company,
 			}
 		)

erpnext/loan_management/doctype/loan_disbursement/loan_disbursement.py

@@ -191,7 +191,9 @@ def get_total_pledged_security_value(loan):
 
 	for security, qty in pledged_securities.items():
 		after_haircut_percentage = 100 - hair_cut_map.get(security)
-		security_value += (loan_security_price_map.get(security) * qty * after_haircut_percentage) / 100
+		security_value += (
+			loan_security_price_map.get(security, 0) * qty * after_haircut_percentage
+		) / 100
 
 	return security_value
 

erpnext/loan_management/doctype/loan_repayment/loan_repayment.py

@@ -577,8 +577,8 @@ def regenerate_repayment_schedule(loan, cancel=0):
 	loan_doc = frappe.get_doc("Loan", loan)
 	next_accrual_date = None
 	accrued_entries = 0
-	last_repayment_amount = 0
-	last_balance_amount = 0
+	last_repayment_amount = None
+	last_balance_amount = None
 
 	for term in reversed(loan_doc.get("repayment_schedule")):
 		if not term.is_accrued:
@@ -586,9 +586,9 @@ def regenerate_repayment_schedule(loan, cancel=0):
 			loan_doc.remove(term)
 		else:
 			accrued_entries += 1
-			if not last_repayment_amount:
+			if last_repayment_amount is None:
 				last_repayment_amount = term.total_payment
-			if not last_balance_amount:
+			if last_balance_amount is None:
 				last_balance_amount = term.balance_loan_amount
 
 	loan_doc.save()

erpnext/manufacturing/doctype/job_card/job_card.py

@@ -7,6 +7,8 @@ import frappe
 from frappe import _, bold
 from frappe.model.document import Document
 from frappe.model.mapper import get_mapped_doc
+from frappe.query_builder import Criterion
+from frappe.query_builder.functions import IfNull, Max, Min
 from frappe.utils import (
 	add_days,
 	add_to_date,
@@ -54,6 +56,9 @@ class JobCard(Document):
 		self.set_onload("job_card_excess_transfer", excess_transfer)
 		self.set_onload("work_order_stopped", self.is_work_order_stopped())
 
+	def before_validate(self):
+		self.set_wip_warehouse()
+
 	def validate(self):
 		self.validate_time_logs()
 		self.set_status()
@@ -109,43 +114,44 @@ class JobCard(Document):
 	def get_overlap_for(self, args, check_next_available_slot=False):
 		production_capacity = 1
 
+		jc = frappe.qb.DocType("Job Card")
+		jctl = frappe.qb.DocType("Job Card Time Log")
+
+		time_conditions = [
+			((jctl.from_time < args.from_time) & (jctl.to_time > args.from_time)),
+			((jctl.from_time < args.to_time) & (jctl.to_time > args.to_time)),
+			((jctl.from_time >= args.from_time) & (jctl.to_time <= args.to_time)),
+		]
+
+		if check_next_available_slot:
+			time_conditions.append(((jctl.from_time >= args.from_time) & (jctl.to_time >= args.to_time)))
+
+		query = (
+			frappe.qb.from_(jctl)
+			.from_(jc)
+			.select(jc.name.as_("name"), jctl.to_time)
+			.where(
+				(jctl.parent == jc.name)
+				& (Criterion.any(time_conditions))
+				& (jctl.name != f"{args.name or 'No Name'}")
+				& (jc.name != f"{args.parent or 'No Name'}")
+				& (jc.docstatus < 2)
+			)
+			.orderby(jctl.to_time, order=frappe.qb.desc)
+		)
+
 		if self.workstation:
 			production_capacity = (
 				frappe.get_cached_value("Workstation", self.workstation, "production_capacity") or 1
 			)
-			validate_overlap_for = " and jc.workstation = %(workstation)s "
+			query = query.where(jc.workstation == self.workstation)
 
 		if args.get("employee"):
 			# override capacity for employee
 			production_capacity = 1
-			validate_overlap_for = " and jctl.employee = %(employee)s "
+			query = query.where(jctl.employee == args.get("employee"))
 
-		extra_cond = ""
-		if check_next_available_slot:
-			extra_cond = " or (%(from_time)s <= jctl.from_time and %(to_time)s <= jctl.to_time)"
-
-		existing = frappe.db.sql(
-			"""select jc.name as name, jctl.to_time from
-			`tabJob Card Time Log` jctl, `tabJob Card` jc where jctl.parent = jc.name and
-			(
-				(%(from_time)s > jctl.from_time and %(from_time)s < jctl.to_time) or
-				(%(to_time)s > jctl.from_time and %(to_time)s < jctl.to_time) or
-				(%(from_time)s <= jctl.from_time and %(to_time)s >= jctl.to_time) {0}
-			)
-			and jctl.name != %(name)s and jc.name != %(parent)s and jc.docstatus < 2 {1}
-			order by jctl.to_time desc""".format(
-				extra_cond, validate_overlap_for
-			),
-			{
-				"from_time": args.from_time,
-				"to_time": args.to_time,
-				"name": args.name or "No Name",
-				"parent": args.parent or "No Name",
-				"employee": args.get("employee"),
-				"workstation": self.workstation,
-			},
-			as_dict=True,
-		)
+		existing = query.run(as_dict=True)
 
 		if existing and production_capacity > len(existing):
 			return
@@ -485,18 +491,21 @@ class JobCard(Document):
 			)
 
 	def update_work_order_data(self, for_quantity, time_in_mins, wo):
-		time_data = frappe.db.sql(
-			"""
-				SELECT
-					min(from_time) as start_time, max(to_time) as end_time
-				FROM `tabJob Card` jc, `tabJob Card Time Log` jctl
-				WHERE
-					jctl.parent = jc.name and jc.work_order = %s and jc.operation_id = %s
-					and jc.docstatus = 1 and IFNULL(jc.is_corrective_job_card, 0) = 0
-			""",
-			(self.work_order, self.operation_id),
-			as_dict=1,
-		)
+		jc = frappe.qb.DocType("Job Card")
+		jctl = frappe.qb.DocType("Job Card Time Log")
+
+		time_data = (
+			frappe.qb.from_(jc)
+			.from_(jctl)
+			.select(Min(jctl.from_time).as_("start_time"), Max(jctl.to_time).as_("end_time"))
+			.where(
+				(jctl.parent == jc.name)
+				& (jc.work_order == self.work_order)
+				& (jc.operation_id == self.operation_id)
+				& (jc.docstatus == 1)
+				& (IfNull(jc.is_corrective_job_card, 0) == 0)
+			)
+		).run(as_dict=True)
 
 		for data in wo.operations:
 			if data.get("name") == self.operation_id:
@@ -639,6 +648,12 @@ class JobCard(Document):
 		if update_status:
 			self.db_set("status", self.status)
 
+	def set_wip_warehouse(self):
+		if not self.wip_warehouse:
+			self.wip_warehouse = frappe.db.get_single_value(
+				"Manufacturing Settings", "default_wip_warehouse"
+			)
+
 	def validate_operation_id(self):
 		if (
 			self.get("operation_id")

erpnext/manufacturing/doctype/production_plan/production_plan.py

@@ -652,23 +652,13 @@ class ProductionPlan(Document):
 			else:
 				material_request = material_request_map[key]
 
-			conversion_factor = 1.0
-			if (
-				material_request_type == "Purchase"
-				and item_doc.purchase_uom
-				and item_doc.purchase_uom != item_doc.stock_uom
-			):
-				conversion_factor = (
-					get_conversion_factor(item_doc.name, item_doc.purchase_uom).get("conversion_factor") or 1.0
-				)
-
 			# add item
 			material_request.append(
 				"items",
 				{
 					"item_code": item.item_code,
 					"from_warehouse": item.from_warehouse,
-					"qty": item.quantity / conversion_factor,
+					"qty": item.quantity,
 					"schedule_date": schedule_date,
 					"warehouse": item.warehouse,
 					"sales_order": item.sales_order,
@@ -988,11 +978,25 @@ def get_material_request_items(
 	if include_safety_stock:
 		required_qty += flt(row["safety_stock"])
 
+	item_details = frappe.get_cached_value(
+		"Item", row.item_code, ["purchase_uom", "stock_uom"], as_dict=1
+	)
+
+	conversion_factor = 1.0
+	if (
+		row.get("default_material_request_type") == "Purchase"
+		and item_details.purchase_uom
+		and item_details.purchase_uom != item_details.stock_uom
+	):
+		conversion_factor = (
+			get_conversion_factor(row.item_code, item_details.purchase_uom).get("conversion_factor") or 1.0
+		)
+
 	if required_qty > 0:
 		return {
 			"item_code": row.item_code,
 			"item_name": row.item_name,
-			"quantity": required_qty,
+			"quantity": required_qty / conversion_factor,
 			"required_bom_qty": total_qty,
 			"stock_uom": row.get("stock_uom"),
 			"warehouse": warehouse

erpnext/manufacturing/doctype/production_plan/test_production_plan.py

@@ -752,6 +752,11 @@ class TestProductionPlan(FrappeTestCase):
 		)
 
 		pln.make_material_request()
+
+		for row in pln.mr_items:
+			self.assertEqual(row.uom, "Nos")
+			self.assertEqual(row.quantity, 1)
+
 		for row in frappe.get_all(
 			"Material Request Item",
 			filters={"production_plan": pln.name},

erpnext/manufacturing/doctype/work_order/test_work_order.py

@@ -625,6 +625,10 @@ class TestWorkOrder(FrappeTestCase):
 			bom.submit()
 			bom_name = bom.name
 
+		ste1 = test_stock_entry.make_stock_entry(
+			item_code=rm1, target="_Test Warehouse - _TC", qty=32, basic_rate=5000.0
+		)
+
 		work_order = make_wo_order_test_record(
 			item=fg_item, skip_transfer=True, planned_start_date=now(), qty=1
 		)
@@ -649,11 +653,29 @@ class TestWorkOrder(FrappeTestCase):
 		work_order.insert()
 		work_order.submit()
 		self.assertEqual(work_order.has_batch_no, 1)
-		ste1 = frappe.get_doc(make_stock_entry(work_order.name, "Manufacture", 30))
+		batches = frappe.get_all("Batch", filters={"reference_name": work_order.name})
+		self.assertEqual(len(batches), 3)
+		batches = [batch.name for batch in batches]
+
+		ste1 = frappe.get_doc(make_stock_entry(work_order.name, "Manufacture", 10))
 		for row in ste1.get("items"):
 			if row.is_finished_item:
 				self.assertEqual(row.item_code, fg_item)
 				self.assertEqual(row.qty, 10)
+				self.assertTrue(row.batch_no in batches)
+				batches.remove(row.batch_no)
+
+		ste1.submit()
+
+		remaining_batches = []
+		ste1 = frappe.get_doc(make_stock_entry(work_order.name, "Manufacture", 20))
+		for row in ste1.get("items"):
+			if row.is_finished_item:
+				self.assertEqual(row.item_code, fg_item)
+				self.assertEqual(row.qty, 10)
+				remaining_batches.append(row.batch_no)
+
+		self.assertEqual(sorted(remaining_batches), sorted(batches))
 
 		frappe.db.set_value("Manufacturing Settings", None, "make_serial_no_batch_from_work_order", 0)
 
@@ -1123,6 +1145,37 @@ class TestWorkOrder(FrappeTestCase):
 		except frappe.MandatoryError:
 			self.fail("Batch generation causing failing in Work Order")
 
+	@change_settings("Manufacturing Settings", {"make_serial_no_batch_from_work_order": 1})
+	def test_auto_serial_no_creation(self):
+		from erpnext.manufacturing.doctype.bom.test_bom import create_nested_bom
+		from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
+
+		fg_item = frappe.generate_hash(length=20)
+		child_item = frappe.generate_hash(length=20)
+
+		bom_tree = {fg_item: {child_item: {}}}
+
+		create_nested_bom(bom_tree, prefix="")
+
+		item = frappe.get_doc("Item", fg_item)
+		item.has_serial_no = 1
+		item.serial_no_series = f"{item.name}.#####"
+		item.save()
+
+		try:
+			wo_order = make_wo_order_test_record(item=fg_item, qty=2, skip_transfer=True)
+			serial_nos = wo_order.serial_no
+			stock_entry = frappe.get_doc(make_stock_entry(wo_order.name, "Manufacture", 10))
+			stock_entry.set_work_order_details()
+			stock_entry.set_serial_no_batch_for_finished_good()
+			for row in stock_entry.items:
+				if row.item_code == fg_item:
+					self.assertTrue(row.serial_no)
+					self.assertEqual(sorted(get_serial_nos(row.serial_no)), sorted(get_serial_nos(serial_nos)))
+
+		except frappe.MandatoryError:
+			self.fail("Batch generation causing failing in Work Order")
+
 	@change_settings(
 		"Manufacturing Settings",
 		{"backflush_raw_materials_based_on": "Material Transferred for Manufacture"},

erpnext/manufacturing/doctype/work_order/work_order.py

@@ -145,7 +145,7 @@ class WorkOrder(Document):
 			frappe.throw(_("Sales Order {0} is {1}").format(self.sales_order, status))
 
 	def set_default_warehouse(self):
-		if not self.wip_warehouse:
+		if not self.wip_warehouse and not self.skip_transfer:
 			self.wip_warehouse = frappe.db.get_single_value(
 				"Manufacturing Settings", "default_wip_warehouse"
 			)

erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py

@@ -4,7 +4,7 @@
 
 import frappe
 from frappe import _
-from frappe.query_builder.functions import Floor, Sum
+from frappe.query_builder.functions import Sum
 from pypika.terms import ExistsCriterion
 
 
@@ -58,9 +58,9 @@ def get_bom_stock(filters):
 			bom_item.description,
 			bom_item.stock_qty,
 			bom_item.stock_uom,
-			bom_item.stock_qty * qty_to_produce / bom.quantity,
-			Sum(bin.actual_qty).as_("actual_qty"),
-			Sum(Floor(bin.actual_qty / (bom_item.stock_qty * qty_to_produce / bom.quantity))),
+			(bom_item.stock_qty / bom.quantity) * qty_to_produce,
+			Sum(bin.actual_qty),
+			Sum(bin.actual_qty) / (bom_item.stock_qty / bom.quantity),
 		)
 		.where((bom_item.parent == filters.get("bom")) & (bom_item.parenttype == "BOM"))
 		.groupby(bom_item.item_code)

erpnext/manufacturing/report/job_card_summary/job_card_summary.js

@@ -54,11 +54,11 @@ frappe.query_reports["Job Card Summary"] = {
 			options: ["", "Open", "Work In Progress", "Completed", "On Hold"]
 		},
 		{
-			label: __("Sales Orders"),
-			fieldname: "sales_order",
+			label: __("Work Orders"),
+			fieldname: "work_order",
 			fieldtype: "MultiSelectList",
 			get_data: function(txt) {
-				return frappe.db.get_link_options('Sales Order', txt);
+				return frappe.db.get_link_options('Work Order', txt);
 			}
 		},
 		{

erpnext/manufacturing/report/job_card_summary/job_card_summary.py

@@ -36,10 +36,14 @@ def get_data(filters):
 		"total_time_in_mins",
 	]
 
-	for field in ["work_order", "workstation", "operation", "company"]:
+	for field in ["work_order", "production_item"]:
 		if filters.get(field):
 			query_filters[field] = ("in", filters.get(field))
 
+	for field in ["workstation", "operation", "status", "company"]:
+		if filters.get(field):
+			query_filters[field] = filters.get(field)
+
 	data = frappe.get_all("Job Card", fields=fields, filters=query_filters)
 
 	if not data:

erpnext/manufacturing/report/production_planning_report/production_planning_report.py

@@ -49,7 +49,7 @@ class ProductionPlanReport(object):
 					parent.bom_no,
 					parent.fg_warehouse.as_("warehouse"),
 				)
-				.where(parent.status.notin(["Completed", "Stopped"]))
+				.where(parent.status.notin(["Completed", "Stopped", "Closed"]))
 			)
 
 			if order_by == "Planned Start Date":
@@ -79,10 +79,11 @@ class ProductionPlanReport(object):
 				query = query.where(child.parent.isin(self.filters.docnames))
 
 			if doctype == "Sales Order":
-				query = query.select(
-					child.delivery_date,
-					parent.base_grand_total,
-				).where((child.stock_qty > child.produced_qty) & (parent.per_delivered < 100.0))
+				query = query.select(child.delivery_date, parent.base_grand_total,).where(
+					(child.stock_qty > child.produced_qty)
+					& (parent.per_delivered < 100.0)
+					& (parent.status.notin(["Completed", "Closed"]))
+				)
 
 				if order_by == "Delivery Date":
 					query = query.orderby(child.delivery_date, order=Order.asc)
@@ -91,7 +92,9 @@ class ProductionPlanReport(object):
 
 			elif doctype == "Material Request":
 				query = query.select(child.schedule_date,).where(
-					(parent.per_ordered < 100) & (parent.material_request_type == "Manufacture")
+					(parent.per_ordered < 100)
+					& (parent.material_request_type == "Manufacture")
+					& (parent.status != "Stopped")
 				)
 
 				if order_by == "Required Date":

erpnext/manufacturing/report/work_order_summary/work_order_summary.py

@@ -39,10 +39,14 @@ def get_data(filters):
 		"lead_time",
 	]
 
-	for field in ["sales_order", "production_item", "status", "company"]:
+	for field in ["sales_order", "production_item"]:
 		if filters.get(field):
 			query_filters[field] = ("in", filters.get(field))
 
+	for field in ["status", "company"]:
+		if filters.get(field):
+			query_filters[field] = filters.get(field)
+
 	query_filters["planned_start_date"] = (">=", filters.get("from_date"))
 	query_filters["planned_end_date"] = ("<=", filters.get("to_date"))
 

erpnext/patches/v11_0/create_salary_structure_assignments.py

@@ -13,8 +13,10 @@ from erpnext.payroll.doctype.salary_structure_assignment.salary_structure_assign
 
 
 def execute():
+	frappe.reload_doc("Payroll", "doctype", "Payroll Settings")
 	frappe.reload_doc("Payroll", "doctype", "Salary Structure")
 	frappe.reload_doc("Payroll", "doctype", "Salary Structure Assignment")
+
 	frappe.db.sql(
 		"""
 		delete from `tabSalary Structure Assignment`

erpnext/payroll/doctype/payroll_entry/payroll_entry.py

@@ -346,6 +346,8 @@ class PayrollEntry(Document):
 						"credit_in_account_currency": flt(payable_amt, precision),
 						"exchange_rate": flt(exchange_rate),
 						"cost_center": self.cost_center,
+						"reference_type": self.doctype,
+						"reference_name": self.name,
 					},
 					accounting_dimensions,
 				)
@@ -720,12 +722,21 @@ def get_month_details(year, month):
 
 def get_payroll_entry_bank_entries(payroll_entry_name):
 	journal_entries = frappe.db.sql(
-		"select name from `tabJournal Entry Account` "
-		'where reference_type="Payroll Entry" '
-		"and reference_name=%s and docstatus=1",
+		"""
+		select
+			je.name
+		from
+			`tabJournal Entry` je,
+			`tabJournal Entry Account` jea
+		where
+			je.name = jea.parent
+			and je.voucher_type = 'Bank Entry'
+			and jea.reference_type = 'Payroll Entry'
+			and jea.reference_name = %s
+	""",
 		payroll_entry_name,
-		as_dict=1,
-	)
+		as_dict=True,
+	)  # nosemgrep
 
 	return journal_entries
 

erpnext/payroll/doctype/payroll_entry/test_payroll_entry.py

@@ -133,9 +133,17 @@ class TestPayrollEntry(FrappeTestCase):
 
 		payment_entry = frappe.db.sql(
 			"""
-			Select ifnull(sum(je.total_debit),0) as total_debit, ifnull(sum(je.total_credit),0) as total_credit from `tabJournal Entry` je, `tabJournal Entry Account` jea
-			Where je.name = jea.parent
-			And jea.reference_name = %s
+			select
+				ifnull(sum(je.total_debit),0) as total_debit,
+				ifnull(sum(je.total_credit),0) as total_credit
+			from
+				`tabJournal Entry` je,
+				`tabJournal Entry Account` jea
+			Where
+				je.name = jea.parent
+				and je.voucher_type = 'Bank Entry'
+				and jea.reference_type = 'Payroll Entry'
+				and jea.reference_name = %s
 			""",
 			(payroll_entry.name),
 			as_dict=1,

erpnext/payroll/doctype/payroll_settings/payroll_settings.json

@@ -11,6 +11,7 @@
   "max_working_hours_against_timesheet",
   "include_holidays_in_total_working_days",
   "disable_rounded_total",
+  "define_opening_balance_for_earning_and_deductions",
   "column_break_11",
   "daily_wages_fraction_for_half_day",
   "email_salary_slip_to_employee",
@@ -91,13 +92,20 @@
    "fieldname": "show_leave_balances_in_salary_slip",
    "fieldtype": "Check",
    "label": "Show Leave Balances in Salary Slip"
+  },
+  {
+   "default": "0",
+   "description": "If checked, then the system will enable the provision to set the opening balance for earnings and deductions till date while creating a Salary Structure Assignment (if any)",
+   "fieldname": "define_opening_balance_for_earning_and_deductions",
+   "fieldtype": "Check",
+   "label": "Define Opening Balance for Earning and Deductions"
   }
  ],
  "icon": "fa fa-cog",
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2021-03-03 17:49:59.579723",
+ "modified": "2022-12-21 17:30:08.704247",
  "modified_by": "Administrator",
  "module": "Payroll",
  "name": "Payroll Settings",

erpnext/payroll/doctype/salary_slip/salary_slip.py

@@ -1063,7 +1063,25 @@ class SalarySlip(TransactionBase):
 			)
 			exempted_amount = flt(exempted_amount[0][0]) if exempted_amount else 0
 
-		return taxable_earnings - exempted_amount
+		opening_taxable_earning = self.get_opening_balance_for(
+			"taxable_earnings_till_date", start_date, end_date
+		)
+
+		return (taxable_earnings + opening_taxable_earning) - exempted_amount
+
+	def get_opening_balance_for(self, field_to_select, start_date, end_date):
+		opening_balance = frappe.db.get_all(
+			"Salary Structure Assignment",
+			{
+				"employee": self.employee,
+				"salary_structure": self.salary_structure,
+				"from_date": ["between", (start_date, end_date)],
+				"docstatus": 1,
+			},
+			field_to_select,
+		)
+
+		return opening_balance[0].get(field_to_select) if opening_balance else 0.0
 
 	def get_tax_paid_in_period(self, start_date, end_date, tax_component):
 		# find total_tax_paid, tax paid for benefit, additional_salary
@@ -1092,7 +1110,11 @@ class SalarySlip(TransactionBase):
 			)[0][0]
 		)
 
-		return total_tax_paid
+		tax_deducted_till_date = self.get_opening_balance_for(
+			"tax_deducted_till_date", start_date, end_date
+		)
+
+		return total_tax_paid + tax_deducted_till_date
 
 	def get_taxable_earnings(
 		self, allow_tax_exemption=False, based_on_payment_days=0, payroll_period=None

erpnext/payroll/doctype/salary_slip/test_salary_slip.py

@@ -1030,6 +1030,104 @@ class TestSalarySlip(FrappeTestCase):
 		activity_type.wage_rate = 25
 		activity_type.save()
 
+	def test_salary_slip_generation_against_opening_entries_in_ssa(self):
+		import math
+
+		from erpnext.payroll.doctype.payroll_period.payroll_period import get_period_factor
+		from erpnext.payroll.doctype.salary_structure.test_salary_structure import make_salary_structure
+
+		payroll_period = frappe.db.get_value(
+			"Payroll Period",
+			{
+				"company": "_Test Company",
+				"start_date": ["<=", "2023-03-31"],
+				"end_date": [">=", "2022-04-01"],
+			},
+			"name",
+		)
+
+		if not payroll_period:
+			payroll_period = create_payroll_period(
+				name="_Test Payroll Period for Tax",
+				company="_Test Company",
+				start_date="2022-04-01",
+				end_date="2023-03-31",
+			)
+		else:
+			payroll_period = frappe.get_cached_doc("Payroll Period", payroll_period)
+
+		emp = make_employee(
+			"test_employee_ss_with_opening_balance@salary.com",
+			company="_Test Company",
+			**{"date_of_joining": "2021-12-01"},
+		)
+		employee_doc = frappe.get_doc("Employee", emp)
+
+		create_tax_slab(payroll_period, allow_tax_exemption=True)
+
+		salary_structure_name = "Test Salary Structure for Opening Balance"
+		if not frappe.db.exists("Salary Structure", salary_structure_name):
+			salary_structure_doc = make_salary_structure(
+				salary_structure_name,
+				"Monthly",
+				company="_Test Company",
+				employee=emp,
+				from_date="2022-04-01",
+				payroll_period=payroll_period,
+				test_tax=True,
+			)
+
+		# validate no salary slip exists for the employee
+		self.assertTrue(
+			frappe.db.count(
+				"Salary Slip",
+				{
+					"employee": emp,
+					"salary_structure": salary_structure_doc.name,
+					"docstatus": 1,
+					"start_date": [">=", "2022-04-01"],
+				},
+			)
+			== 0
+		)
+
+		remaining_sub_periods = get_period_factor(
+			emp,
+			get_first_day("2022-10-01"),
+			get_last_day("2022-10-01"),
+			"Monthly",
+			payroll_period,
+			depends_on_payment_days=0,
+		)[1]
+
+		prev_period = math.ceil(remaining_sub_periods)
+
+		annual_tax = 93036  # 89220 #data[0].get('applicable_tax')
+		monthly_tax_amount = 7732.40  # 7435 #annual_tax/12
+		annual_earnings = 933600  # data[0].get('ctc')
+		monthly_earnings = 77800  # annual_earnings/12
+
+		# Get Salary Structure Assignment
+		ssa = frappe.get_value(
+			"Salary Structure Assignment",
+			{"employee": emp, "salary_structure": salary_structure_doc.name},
+			"name",
+		)
+		ssa_doc = frappe.get_doc("Salary Structure Assignment", ssa)
+
+		# Set opening balance for earning and tax deduction in Salary Structure Assignment
+		ssa_doc.taxable_earnings_till_date = monthly_earnings * prev_period
+		ssa_doc.tax_deducted_till_date = monthly_tax_amount * prev_period
+		ssa_doc.save()
+
+		# Create Salary Slip
+		salary_slip = make_salary_slip(
+			salary_structure_doc.name, employee=employee_doc.name, posting_date=getdate("2022-10-01")
+		)
+		for deduction in salary_slip.deductions:
+			if deduction.salary_component == "TDS":
+				self.assertEqual(deduction.amount, rounded(monthly_tax_amount))
+
 
 def get_no_of_days():
 	no_of_days_in_month = calendar.monthrange(getdate(nowdate()).year, getdate(nowdate()).month)

erpnext/payroll/doctype/salary_structure_assignment/salary_structure_assignment.js

@@ -42,6 +42,13 @@ frappe.ui.form.on('Salary Structure Assignment', {
 		});
 	},
 
+	refresh: function(frm) {
+		if(frm.doc.__onload){
+			frm.unhide_earnings_and_taxation_section = frm.doc.__onload.earning_and_deduction_entries_does_not_exists;
+			frm.trigger("set_earnings_and_taxation_section_visibility");
+		}
+	},
+
 	employee: function(frm) {
 		if(frm.doc.employee){
 			frappe.call({
@@ -59,6 +66,8 @@ frappe.ui.form.on('Salary Structure Assignment', {
 					}
 				}
 			});
+
+			frm.trigger("valiadte_joining_date_and_salary_slips");
 		}
 		else{
 			frm.set_value("company", null);
@@ -71,5 +80,33 @@ frappe.ui.form.on('Salary Structure Assignment', {
 				frm.set_value("payroll_payable_account", r.default_payroll_payable_account);
 			});
 		}
-	}
+	},
+
+	valiadte_joining_date_and_salary_slips: function(frm) {
+		frappe.call({
+			method: "earning_and_deduction_entries_does_not_exists",
+			doc: frm.doc,
+			callback: function(data) {
+				let earning_and_deduction_entries_does_not_exists = data.message;
+				frm.unhide_earnings_and_taxation_section = earning_and_deduction_entries_does_not_exists;
+				frm.trigger("set_earnings_and_taxation_section_visibility");
+			}
+		});
+	},
+
+	set_earnings_and_taxation_section_visibility: function(frm) {
+		if(frm.unhide_earnings_and_taxation_section){
+			frm.set_df_property('earnings_and_taxation_section', 'hidden', 0);
+		}
+		else{
+			frm.set_df_property('earnings_and_taxation_section', 'hidden', 1);
+		}
+	},
+
+	from_date: function(frm) {
+		if (frm.doc.from_date) {
+			frm.trigger("valiadte_joining_date_and_salary_slips" );
+		}
+	},
+
 });

erpnext/payroll/doctype/salary_structure_assignment/salary_structure_assignment.json

@@ -22,6 +22,10 @@
   "base",
   "column_break_9",
   "variable",
+  "earnings_and_taxation_section",
+  "taxable_earnings_till_date",
+  "column_break_18",
+  "tax_deducted_till_date",
   "amended_from"
  ],
  "fields": [
@@ -141,11 +145,31 @@
    "fieldtype": "Link",
    "label": "Payroll Payable Account",
    "options": "Account"
+  },
+  {
+   "fieldname": "earnings_and_taxation_section",
+   "fieldtype": "Section Break"
+  },
+  {
+   "allow_on_submit": 1,
+   "fieldname": "tax_deducted_till_date",
+   "fieldtype": "Currency",
+   "label": "Tax Deducted Till Date"
+  },
+  {
+   "fieldname": "column_break_18",
+   "fieldtype": "Column Break"
+  },
+  {
+   "allow_on_submit": 1,
+   "fieldname": "taxable_earnings_till_date",
+   "fieldtype": "Currency",
+   "label": "Taxable Earnings Till Date"
   }
  ],
  "is_submittable": 1,
  "links": [],
- "modified": "2021-03-31 22:44:46.267974",
+ "modified": "2022-12-26 12:47:42.521891",
  "modified_by": "Administrator",
  "module": "Payroll",
  "name": "Salary Structure Assignment",

erpnext/payroll/doctype/salary_structure_assignment/salary_structure_assignment.py

@@ -13,10 +13,32 @@ class DuplicateAssignment(frappe.ValidationError):
 
 
 class SalaryStructureAssignment(Document):
+	def onload(self):
+		if self.employee:
+			self.set_onload(
+				"earning_and_deduction_entries_exists", self.earning_and_deduction_entries_does_not_exists()
+			)
+
 	def validate(self):
 		self.validate_dates()
 		self.validate_income_tax_slab()
 		self.set_payroll_payable_account()
+		self.valiadte_missing_taxable_earnings_and_deductions_till_date()
+
+	def valiadte_missing_taxable_earnings_and_deductions_till_date(self):
+		if self.earning_and_deduction_entries_does_not_exists():
+			if not self.taxable_earnings_till_date and not self.tax_deducted_till_date:
+				frappe.msgprint(
+					_(
+						"""Not found any salary slip record(s) for the employee {0}.<br><br>Please specify {1} and {2} (if any), for the correct tax calculation in future salary slips."""
+					).format(
+						self.employee,
+						"<b>" + _("Taxable Earnings Till Date") + "</b>",
+						"<b>" + _("Tax Deducted Till Date") + "</b>",
+					),
+					indicator="orange",
+					title=_("Warning"),
+				)
 
 	def validate_dates(self):
 		joining_date, relieving_date = frappe.db.get_value(
@@ -76,6 +98,56 @@ class SalaryStructureAssignment(Document):
 				)
 			self.payroll_payable_account = payroll_payable_account
 
+	@frappe.whitelist()
+	def earning_and_deduction_entries_does_not_exists(self):
+		if self.enabled_settings_to_specify_earnings_and_deductions_till_date():
+			if not self.joined_in_the_same_month() and not self.have_salary_slips():
+				return True
+			else:
+				if self.docstatus in [1, 2] and (
+					self.taxable_earnings_till_date or self.tax_deducted_till_date
+				):
+					return True
+				return False
+		else:
+			return False
+
+	def enabled_settings_to_specify_earnings_and_deductions_till_date(self):
+		"""returns True if settings are enabled to specify earnings and deductions till date else False"""
+
+		if frappe.db.get_single_value(
+			"Payroll Settings", "define_opening_balance_for_earning_and_deductions"
+		):
+			return True
+		return False
+
+	def have_salary_slips(self):
+		"""returns True if salary structure assignment has salary slips else False"""
+
+		salary_slip = frappe.db.get_value(
+			"Salary Slip", filters={"employee": self.employee, "docstatus": 1}
+		)
+
+		if salary_slip:
+			return True
+
+		return False
+
+	def joined_in_the_same_month(self):
+		"""returns True if employee joined in same month as salary structure assignment from date else False"""
+
+		date_of_joining = frappe.db.get_value("Employee", self.employee, "date_of_joining")
+		from_date = getdate(self.from_date)
+
+		if not self.from_date or not date_of_joining:
+			return False
+
+		elif date_of_joining.month == from_date.month:
+			return True
+
+		else:
+			return False
+
 
 def get_assigned_salary_structure(employee, on_date):
 	if not employee or not on_date:

erpnext/public/js/bank_reconciliation_tool/dialog_manager.js

@@ -371,12 +371,14 @@ erpnext.accounts.bank_reconciliation.DialogManager = class DialogManager {
 				fieldname: "deposit",
 				fieldtype: "Currency",
 				label: "Deposit",
+				options: "currency",
 				read_only: 1,
 			},
 			{
 				fieldname: "withdrawal",
 				fieldtype: "Currency",
 				label: "Withdrawal",
+				options: "currency",
 				read_only: 1,
 			},
 			{
@@ -394,6 +396,7 @@ erpnext.accounts.bank_reconciliation.DialogManager = class DialogManager {
 				fieldname: "allocated_amount",
 				fieldtype: "Currency",
 				label: "Allocated Amount",
+				options: "Currency",
 				read_only: 1,
 			},
 
@@ -401,8 +404,17 @@ erpnext.accounts.bank_reconciliation.DialogManager = class DialogManager {
 				fieldname: "unallocated_amount",
 				fieldtype: "Currency",
 				label: "Unallocated Amount",
+				options: "Currency",
 				read_only: 1,
 			},
+			{
+				fieldname: "currency",
+				fieldtype: "Link",
+				label: "Currency",
+				options: "Currency",
+				read_only: 1,
+				hidden: 1,
+			}
 		];
 
 		me.dialog = new frappe.ui.Dialog({

erpnext/public/js/controllers/buying.js

@@ -217,7 +217,8 @@ erpnext.buying.BuyingController = erpnext.TransactionController.extend({
 				args: {
 					item_code: item.item_code,
 					warehouse: item.warehouse,
-					company: doc.company
+					company: doc.company,
+					include_child_warehouses: true
 				}
 			});
 		}

erpnext/public/scss/point-of-sale.scss

@@ -159,6 +159,12 @@
 					}
 				}
 
+				.item-img {
+					@extend .image;
+					border-radius: 8px 8px 0 0;
+					object-fit: cover;
+				}
+
 				> .item-detail {
 					display: flex;
 					flex-direction: column;

erpnext/quality_management/doctype/quality_procedure/quality_procedure.py

@@ -79,7 +79,7 @@ def get_children(doctype, parent=None, parent_quality_procedure=None, is_root=Fa
 		]
 	else:
 		return frappe.get_all(
-			doctype,
+			"Quality Procedure",
 			fields=["name as value", "is_group as expandable"],
 			filters=dict(parent_quality_procedure=parent),
 			order_by="name asc",

erpnext/regional/doctype/e_invoice_settings/e_invoice_settings.py

@@ -10,3 +10,8 @@ class EInvoiceSettings(Document):
 	def validate(self):
 		if self.enable and not self.credentials:
 			frappe.throw(_("You must add atleast one credentials to be able to use E Invoicing."))
+
+		prev_doc = self.get_doc_before_save()
+		if prev_doc.client_secret != self.client_secret or prev_doc.client_id != self.client_id:
+			self.auth_token = None
+			self.token_expiry = None

erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py

@@ -146,7 +146,9 @@ class ImportSupplierInvoice(Document):
 
 	def publish(self, title, message, count, total):
 		frappe.publish_realtime(
-			"import_invoice_update", {"title": title, "message": message, "count": count, "total": total}
+			"import_invoice_update",
+			{"title": title, "message": message, "count": count, "total": total},
+			user=self.modified_by,
 		)
 
 

erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py

@@ -35,7 +35,7 @@ def _execute(filters=None):
 	data = []
 	added_item = []
 	for d in item_list:
-		if (d.parent, d.item_code) not in added_item:
+		if (d.parent, d.gst_hsn_code, d.item_code) not in added_item:
 			row = [d.gst_hsn_code, d.description, d.stock_uom, d.stock_qty]
 			total_tax = 0
 			tax_rate = 0
@@ -52,7 +52,7 @@ def _execute(filters=None):
 				item_tax = itemised_tax.get((d.parent, d.item_code), {}).get(tax, {})
 				row += [item_tax.get("tax_amount", 0)]
 			data.append(row)
-			added_item.append((d.parent, d.item_code))
+			added_item.append((d.parent, d.gst_hsn_code, d.item_code))
 	if data:
 		data = get_merged_data(columns, data)  # merge same hsn code data
 	return columns, data
@@ -161,11 +161,9 @@ def get_items(filters):
 		GROUP BY
 			`tabSales Invoice Item`.parent,
 			`tabSales Invoice Item`.item_code,
-			`tabSales Invoice Item`.gst_hsn_code,
-			`tabSales Invoice Item`.uom
+			`tabSales Invoice Item`.gst_hsn_code
 		ORDER BY
-			`tabSales Invoice Item`.gst_hsn_code,
-			`tabSales Invoice Item`.uom
+			`tabSales Invoice Item`.gst_hsn_code
 		""".format(
 			conditions=conditions
 		),

erpnext/selling/doctype/quotation/quotation.py

@@ -191,14 +191,7 @@ def get_list_context(context=None):
 
 
 @frappe.whitelist()
-def make_sales_order(source_name, target_doc=None):
-	quotation = frappe.db.get_value(
-		"Quotation", source_name, ["transaction_date", "valid_till"], as_dict=1
-	)
-	if quotation.valid_till and (
-		quotation.valid_till < quotation.transaction_date or quotation.valid_till < getdate(nowdate())
-	):
-		frappe.throw(_("Validity period of this quotation has ended."))
+def make_sales_order(source_name: str, target_doc=None):
 	return _make_sales_order(source_name, target_doc)
 
 

erpnext/selling/doctype/quotation/test_quotation.py

@@ -118,17 +118,20 @@ class TestQuotation(FrappeTestCase):
 			sales_order.payment_schedule[1].due_date, getdate(add_days(quotation.transaction_date, 30))
 		)
 
-	def test_valid_till(self):
-		from erpnext.selling.doctype.quotation.quotation import make_sales_order
-
+	def test_valid_till_before_transaction_date(self):
 		quotation = frappe.copy_doc(test_records[0])
 		quotation.valid_till = add_days(quotation.transaction_date, -1)
 		self.assertRaises(frappe.ValidationError, quotation.validate)
 
+	def test_so_from_expired_quotation(self):
+		from erpnext.selling.doctype.quotation.quotation import make_sales_order
+
+		quotation = frappe.copy_doc(test_records[0])
 		quotation.valid_till = add_days(nowdate(), -1)
 		quotation.insert()
 		quotation.submit()
-		self.assertRaises(frappe.ValidationError, make_sales_order, quotation.name)
+
+		make_sales_order(quotation.name)
 
 	def test_shopping_cart_without_website_item(self):
 		if frappe.db.exists("Website Item", {"item_code": "_Test Item Home Desktop 100"}):

erpnext/selling/doctype/sales_order/sales_order.py

@@ -1090,6 +1090,15 @@ def make_purchase_order(source_name, selected_items=None, target_doc=None):
 	]
 	items_to_map = list(set(items_to_map))
 
+	def is_drop_ship_order(target):
+		drop_ship = True
+		for item in target.items:
+			if not item.delivered_by_supplier:
+				drop_ship = False
+				break
+
+		return drop_ship
+
 	def set_missing_values(source, target):
 		target.supplier = ""
 		target.apply_discount_on = ""
@@ -1097,8 +1106,14 @@ def make_purchase_order(source_name, selected_items=None, target_doc=None):
 		target.discount_amount = 0.0
 		target.inter_company_order_reference = ""
 		target.shipping_rule = ""
-		target.customer = ""
-		target.customer_name = ""
+
+		if is_drop_ship_order(target):
+			target.customer = source.customer
+			target.customer_name = source.customer_name
+			target.shipping_address = source.shipping_address_name
+		else:
+			target.customer = target.customer_name = target.shipping_address = None
+
 		target.run_method("set_missing_values")
 		target.run_method("calculate_taxes_and_totals")
 

erpnext/selling/doctype/sales_order/sales_order_dashboard.py

@@ -12,7 +12,9 @@ def get_data():
 			"Auto Repeat": "reference_document",
 			"Maintenance Visit": "prevdoc_docname",
 		},
-		"internal_links": {"Quotation": ["items", "prevdoc_docname"]},
+		"internal_links": {
+			"Quotation": ["items", "prevdoc_docname"],
+		},
 		"transactions": [
 			{
 				"label": _("Fulfillment"),