feat: Taxjar Integration update (#27143)

* feat: Taxjar Integration update

* added taxable_amount,taxable_amount fields in setup.py

* Update taxjar_integration.py

Sider issues fix

* Sider issues fix

* Sider issues fix

* sider issue fix: unused import

* sider issue fix

* Update erpnext/erpnext_integrations/taxjar_integration.py

Co-authored-by: Deepesh Garg <42651287+deepeshgarg007@users.noreply.github.com>

* Removed permission for 'All'

Co-authored-by: Deepesh Garg <42651287+deepeshgarg007@users.noreply.github.com>
(cherry picked from commit 7004944cc0)

# Conflicts:
#	erpnext/erpnext_integrations/taxjar_integration.py
#	erpnext/patches.txt
#	erpnext/patches/v13_0/custom_fields_for_taxjar_integration.py
#	erpnext/regional/doctype/product_tax_category/product_tax_category.py
#	erpnext/regional/doctype/product_tax_category/test_product_tax_category.py
#	erpnext/regional/united_states/setup.py

.github/workflows/linters.yml

@@ -11,10 +11,10 @@ jobs:
     steps:
       - uses: actions/checkout@v2
 
-      - name: Set up Python 3.8
+      - name: Set up Python 3.10
         uses: actions/setup-python@v2
         with:
-          python-version: 3.8
+          python-version: '3.10'
 
       - name: Install and Run Pre-commit
         uses: pre-commit/action@v2.0.3
@@ -22,10 +22,8 @@ jobs:
       - name: Download Semgrep rules
         run: git clone --depth 1 https://github.com/frappe/semgrep-rules.git frappe-semgrep-rules
 
-      - uses: returntocorp/semgrep-action@v1
-        env:
-            SEMGREP_TIMEOUT: 120
-        with:
-            config: >-
-              r/python.lang.correctness
-              ./frappe-semgrep-rules/rules
+      - name: Download semgrep
+        run: pip install semgrep
+
+      - name: Run Semgrep rules
+        run: semgrep ci --config ./frappe-semgrep-rules/rules --config r/python.lang.correctness

.github/workflows/release_notes.yml

@@ -0,0 +1,38 @@
+# This action:
+#
+# 1. Generates release notes using github API.
+# 2. Strips unnecessary info like chore/style etc from notes.
+# 3. Updates release info.
+
+# This action needs to be maintained on all branches that do releases.
+
+name: 'Release Notes'
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: 'Tag of release like v13.0.0'
+        required: true
+        type: string
+  release:
+    types: [released]
+
+permissions:
+  contents: read
+
+jobs:
+  regen-notes:
+    name: 'Regenerate release notes'
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Update notes
+      run: |
+        NEW_NOTES=$(gh api --method POST -H "Accept: application/vnd.github+json"  /repos/frappe/erpnext/releases/generate-notes  -f tag_name=$RELEASE_TAG | jq -r '.body' | sed  -E '/^\* (chore|ci|test|docs|style)/d' )
+        RELEASE_ID=$(gh api -H "Accept: application/vnd.github+json" /repos/frappe/erpnext/releases/tags/$RELEASE_TAG | jq -r '.id')
+        gh api --method PATCH -H "Accept: application/vnd.github+json" /repos/frappe/erpnext/releases/$RELEASE_ID -f body="$NEW_NOTES"
+
+      env:
+        GH_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+        RELEASE_TAG: ${{ github.event.inputs.tag_name || github.event.release.tag_name }}

erpnext/__init__.py

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

erpnext/accounts/doctype/accounts_settings/accounts_settings.js

@@ -4,6 +4,12 @@
 frappe.ui.form.on('Accounts Settings', {
 	refresh: function(frm) {
 
+	},
+	validate_access_key(frm) {
+		frappe.call({
+			doc: frm.doc,
+			method: "validate_access_key"
+		});
 	}
 });
 

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -40,11 +40,16 @@
   "submit_journal_entries",
   "print_settings",
   "show_inclusive_tax_in_print",
+  "show_taxes_as_table_in_print",
   "column_break_12",
   "show_payment_schedule_in_print",
   "currency_exchange_section",
   "allow_stale",
   "stale_days",
+  "service_provider",
+  "column_break_eiyok",
+  "access_key",
+  "validate_access_key",
   "report_settings_sb",
   "use_custom_cash_flow"
  ],
@@ -281,26 +286,56 @@
    "label": "Enable Common Party Accounting"
   },
   {
-    "default": "0",
-    "description": "Enabling this will allow creation of multi-currency invoices against single party account in company currency",
-    "fieldname": "allow_multi_currency_invoices_against_single_party_account",
-    "fieldtype": "Check",
-    "label": "Allow multi-currency invoices against single party account"
-   },
-   {
-    "default": "0",
-    "description": "Split Early Payment Discount Loss into Income and Tax Loss",
-    "fieldname": "book_tax_discount_loss",
-    "fieldtype": "Check",
-    "label": "Book Tax Loss on Early Payment Discount"
-   }
+   "default": "0",
+   "description": "Enabling this will allow creation of multi-currency invoices against single party account in company currency",
+   "fieldname": "allow_multi_currency_invoices_against_single_party_account",
+   "fieldtype": "Check",
+   "label": "Allow multi-currency invoices against single party account"
+  },
+  {
+   "default": "0",
+   "description": "Split Early Payment Discount Loss into Income and Tax Loss",
+   "fieldname": "book_tax_discount_loss",
+   "fieldtype": "Check",
+   "label": "Book Tax Loss on Early Payment Discount"
+  },
+  {
+   "default": "0",
+   "fieldname": "show_taxes_as_table_in_print",
+   "fieldtype": "Check",
+   "label": "Show Taxes as Table in Print"
+  },
+  {
+   "default": "frankfurter.app",
+   "fieldname": "service_provider",
+   "fieldtype": "Select",
+   "label": "Service Provider",
+   "options": "frankfurter.app\nexchangerate.host"
+  },
+  {
+   "depends_on": "eval:doc.service_provider == \"exchangerate.host\"",
+   "description": "Access Key is mandatory for exchangerate.host",
+   "fieldname": "access_key",
+   "fieldtype": "Data",
+   "label": "Access Key"
+  },
+  {
+   "depends_on": "eval:doc.service_provider == \"exchangerate.host\"",
+   "fieldname": "validate_access_key",
+   "fieldtype": "Button",
+   "label": "Validate Access Key"
+  },
+  {
+   "fieldname": "column_break_eiyok",
+   "fieldtype": "Column Break"
+  }
  ],
  "icon": "icon-cog",
  "idx": 1,
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2023-04-14 17:22:03.680886",
+ "modified": "2023-10-07 14:20:01.779208",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -8,12 +8,43 @@ import frappe
 from frappe import _
 from frappe.custom.doctype.property_setter.property_setter import make_property_setter
 from frappe.model.document import Document
-from frappe.utils import cint
+from frappe.utils import cint, nowdate
 
 from erpnext.stock.utils import check_pending_reposting
 
 
 class AccountsSettings(Document):
+	@frappe.whitelist()
+	def validate_access_key(self):
+		if self.service_provider == "exchangerate.host":
+			if not self.access_key:
+				frappe.throw(_("Access Key is required for exchangerate.host"))
+			else:
+				import requests
+
+				# Validate access key
+				api_url = "https://api.exchangerate.host/convert"
+				response = requests.get(
+					api_url,
+					params={
+						"access_key": self.access_key,
+						"transaction_date": nowdate(),
+						"amount": 1,
+						"from": "USD",
+						"to": "INR",
+					},
+				)
+				# exchangerate.host return 200 for all requests. Can't rely on it to raise exception
+				if not response.json()["success"]:
+					frappe.throw(
+						title=_("Service Provider Error"),
+						msg=_("Currency exchange rate serivce provider: {0} returned Error. {1}").format(
+							frappe.bold(self.service_provider), response.json()
+						),
+						exc=frappe.ValidationError,
+					)
+				frappe.msgprint(msg=_("Success"), title=_("Access Key Validation"))
+
 	def on_update(self):
 		frappe.clear_cache()
 

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -358,6 +358,7 @@ def update_outstanding_amt(
 	if against_voucher_type in ["Sales Invoice", "Purchase Invoice", "Fees"]:
 		ref_doc = frappe.get_doc(against_voucher_type, against_voucher)
 
+		bal = flt(bal, frappe.get_precision(against_voucher_type, "outstanding_amount"))
 		# Didn't use db_set for optimization purpose
 		ref_doc.outstanding_amount = bal
 		frappe.db.set_value(against_voucher_type, against_voucher, "outstanding_amount", bal)

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -330,12 +330,10 @@ class JournalEntry(AccountsController):
 				d.db_update()
 
 	def unlink_asset_reference(self):
-		if self.voucher_type != "Depreciation Entry":
-			return
-
 		for d in self.get("accounts"):
 			if (
-				d.reference_type == "Asset"
+				self.voucher_type == "Depreciation Entry"
+				and d.reference_type == "Asset"
 				and d.reference_name
 				and d.account_type == "Depreciation"
 				and d.debit
@@ -362,6 +360,15 @@ class JournalEntry(AccountsController):
 				else:
 					asset.db_set("value_after_depreciation", asset.value_after_depreciation + d.debit)
 				asset.set_status()
+			elif self.voucher_type == "Journal Entry" and d.reference_type == "Asset" and d.reference_name:
+				journal_entry_for_scrap = frappe.db.get_value(
+					"Asset", d.reference_name, "journal_entry_for_scrap"
+				)
+
+				if journal_entry_for_scrap == self.name:
+					frappe.throw(
+						_("Journal Entry for Asset scrapping cannot be cancelled. Please restore the Asset.")
+					)
 
 	def unlink_inter_company_jv(self):
 		if (
@@ -393,6 +400,15 @@ class JournalEntry(AccountsController):
 							d.idx, d.account
 						)
 					)
+				elif (
+					d.party_type
+					and frappe.db.get_value("Party Type", d.party_type, "account_type") != account_type
+				):
+					frappe.throw(
+						_("Row {0}: Account {1} and Party Type {2} have different account types").format(
+							d.idx, d.account, d.party_type
+						)
+					)
 
 	def check_credit_limit(self):
 		customers = list(

erpnext/accounts/doctype/journal_entry_template/journal_entry_template.js

@@ -2,6 +2,21 @@
 // For license information, please see license.txt
 
 frappe.ui.form.on("Journal Entry Template", {
+	onload: function(frm) {
+		if(frm.is_new()) {
+			frappe.call({
+				type: "GET",
+				method: "erpnext.accounts.doctype.journal_entry_template.journal_entry_template.get_naming_series",
+				callback: function(r){
+					if(r.message) {
+						frm.set_df_property("naming_series", "options", r.message.split("\n"));
+						frm.set_value("naming_series", r.message.split("\n")[0]);
+						frm.refresh_field("naming_series");
+					}
+				}
+			});
+		}
+	},
 	refresh: function(frm) {
 		frappe.model.set_default_values(frm.doc);
 
@@ -19,18 +34,6 @@ frappe.ui.form.on("Journal Entry Template", {
 
 			return { filters: filters };
 		});
-
-		frappe.call({
-			type: "GET",
-			method: "erpnext.accounts.doctype.journal_entry_template.journal_entry_template.get_naming_series",
-			callback: function(r){
-				if(r.message){
-					frm.set_df_property("naming_series", "options", r.message.split("\n"));
-					frm.set_value("naming_series", r.message.split("\n")[0]);
-					frm.refresh_field("naming_series");
-				}
-			}
-		});
 	},
 	voucher_type: function(frm) {
 		var add_accounts = function(doc, r) {

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -623,7 +623,7 @@ frappe.ui.form.on('Payment Entry', {
 			frm.events.set_unallocated_amount(frm);
 	},
 
-	get_outstanding_invoice: function(frm) {
+	get_outstanding_invoices_or_orders: function(frm, get_outstanding_invoices, get_orders_to_be_billed) {
 		const today = frappe.datetime.get_today();
 		const fields = [
 			{fieldtype:"Section Break", label: __("Posting Date")},
@@ -653,12 +653,29 @@ frappe.ui.form.on('Payment Entry', {
 			{fieldtype:"Check", label: __("Allocate Payment Amount"), fieldname:"allocate_payment_amount", default:1},
 		];
 
+		let btn_text = "";
+
+		if (get_outstanding_invoices) {
+			btn_text = "Get Outstanding Invoices";
+		}
+		else if (get_orders_to_be_billed) {
+			btn_text = "Get Outstanding Orders";
+		}
+
 		frappe.prompt(fields, function(filters){
 			frappe.flags.allocate_payment_amount = true;
 			frm.events.validate_filters_data(frm, filters);
 			frm.doc.cost_center = filters.cost_center;
-			frm.events.get_outstanding_documents(frm, filters);
-		}, __("Filters"), __("Get Outstanding Documents"));
+			frm.events.get_outstanding_documents(frm, filters, get_outstanding_invoices, get_orders_to_be_billed);
+		}, __("Filters"), __(btn_text));
+	},
+
+	get_outstanding_invoices: function(frm) {
+		frm.events.get_outstanding_invoices_or_orders(frm, true, false);
+	},
+
+	get_outstanding_orders: function(frm) {
+		frm.events.get_outstanding_invoices_or_orders(frm, false, true);
 	},
 
 	validate_filters_data: function(frm, filters) {
@@ -684,7 +701,7 @@ frappe.ui.form.on('Payment Entry', {
 		}
 	},
 
-	get_outstanding_documents: function(frm, filters) {
+	get_outstanding_documents: function(frm, filters, get_outstanding_invoices, get_orders_to_be_billed) {
 		frm.clear_table("references");
 
 		if(!frm.doc.party) {
@@ -708,6 +725,13 @@ frappe.ui.form.on('Payment Entry', {
 			args[key] = filters[key];
 		}
 
+		if (get_outstanding_invoices) {
+			args["get_outstanding_invoices"] = true;
+		}
+		else if (get_orders_to_be_billed) {
+			args["get_orders_to_be_billed"] = true;
+		}
+
 		frappe.flags.allocate_payment_amount = filters['allocate_payment_amount'];
 
 		return  frappe.call({

erpnext/accounts/doctype/payment_entry/payment_entry.json

@@ -48,7 +48,8 @@
   "base_received_amount",
   "base_received_amount_after_tax",
   "section_break_14",
-  "get_outstanding_invoice",
+  "get_outstanding_invoices",
+  "get_outstanding_orders",
   "references",
   "section_break_34",
   "total_allocated_amount",
@@ -353,12 +354,6 @@
    "fieldtype": "Section Break",
    "label": "Reference"
   },
-  {
-   "depends_on": "eval:doc.docstatus==0",
-   "fieldname": "get_outstanding_invoice",
-   "fieldtype": "Button",
-   "label": "Get Outstanding Invoice"
-  },
   {
    "fieldname": "references",
    "fieldtype": "Table",
@@ -726,12 +721,24 @@
    "fieldname": "section_break_60",
    "fieldtype": "Section Break",
    "hide_border": 1
+  },
+  {
+   "depends_on": "eval:doc.docstatus==0",
+   "fieldname": "get_outstanding_invoices",
+   "fieldtype": "Button",
+   "label": "Get Outstanding Invoices"
+  },
+  {
+   "depends_on": "eval:doc.docstatus==0",
+   "fieldname": "get_outstanding_orders",
+   "fieldtype": "Button",
+   "label": "Get Outstanding Orders"
   }
  ],
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-02-23 20:08:39.559814",
+ "modified": "2023-06-19 11:38:04.387219",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry",

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -7,7 +7,16 @@ from functools import reduce
 
 import frappe
 from frappe import ValidationError, _, scrub, throw
-from frappe.utils import cint, comma_or, flt, get_link_to_form, getdate, nowdate
+from frappe.utils import (
+	cint,
+	comma_and,
+	comma_or,
+	flt,
+	fmt_money,
+	get_link_to_form,
+	getdate,
+	nowdate,
+)
 from six import iteritems, string_types
 
 import erpnext
@@ -150,19 +159,69 @@ class PaymentEntry(AccountsController):
 			)
 
 	def validate_allocated_amount(self):
-		for d in self.get("references"):
-			if (flt(d.allocated_amount)) > 0:
-				if flt(d.allocated_amount) > flt(d.outstanding_amount):
+		if self.payment_type == "Internal Transfer":
+			return
+
+		if self.party_type in ("Customer", "Supplier"):
+			self.validate_allocated_amount_with_latest_data()
+		else:
+			fail_message = _("Row #{0}: Allocated Amount cannot be greater than outstanding amount.")
+			for d in self.get("references"):
+				if (flt(d.allocated_amount)) > 0 and flt(d.allocated_amount) > flt(d.outstanding_amount):
+					frappe.throw(fail_message.format(d.idx))
+
+				# Check for negative outstanding invoices as well
+				if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(d.outstanding_amount):
+					frappe.throw(fail_message.format(d.idx))
+
+	def validate_allocated_amount_with_latest_data(self):
+		if self.references:
+			latest_references = get_outstanding_reference_documents(
+				{
+					"posting_date": self.posting_date,
+					"company": self.company,
+					"party_type": self.party_type,
+					"payment_type": self.payment_type,
+					"party": self.party,
+					"party_account": self.paid_from if self.payment_type == "Receive" else self.paid_to,
+					"get_outstanding_invoices": True,
+					"get_orders_to_be_billed": True,
+				}
+			)
+
+			# Group latest_references by (voucher_type, voucher_no)
+			latest_lookup = {}
+			for d in latest_references:
+				d = frappe._dict(d)
+				latest_lookup.update({(d.voucher_type, d.voucher_no): d})
+
+			for d in self.get("references"):
+				latest = latest_lookup.get((d.reference_doctype, d.reference_name))
+
+				# The reference has already been fully paid
+				if not latest:
 					frappe.throw(
-						_("Row #{0}: Allocated Amount cannot be greater than outstanding amount.").format(d.idx)
+						_("{0} {1} has already been fully paid.").format(_(d.reference_doctype), d.reference_name)
+					)
+				# The reference has already been partly paid
+				elif latest.outstanding_amount < latest.invoice_amount and flt(
+					d.outstanding_amount, d.precision("outstanding_amount")
+				) != flt(latest.outstanding_amount, d.precision("outstanding_amount")):
+
+					frappe.throw(
+						_(
+							"{0} {1} has already been partly paid. Please use the 'Get Outstanding Invoice' or the 'Get Outstanding Orders' button to get the latest outstanding amounts."
+						).format(_(d.reference_doctype), d.reference_name)
 					)
 
-			# Check for negative outstanding invoices as well
-			if flt(d.allocated_amount) < 0:
-				if flt(d.allocated_amount) < flt(d.outstanding_amount):
-					frappe.throw(
-						_("Row #{0}: Allocated Amount cannot be greater than outstanding amount.").format(d.idx)
-					)
+				fail_message = _("Row #{0}: Allocated Amount cannot be greater than outstanding amount.")
+
+				if (flt(d.allocated_amount)) > 0 and flt(d.allocated_amount) > flt(latest.outstanding_amount):
+					frappe.throw(fail_message.format(d.idx))
+
+				# Check for negative outstanding invoices as well
+				if flt(d.allocated_amount) < 0 and flt(d.allocated_amount) < flt(latest.outstanding_amount):
+					frappe.throw(fail_message.format(d.idx))
 
 	def delink_advance_entry_references(self):
 		for reference in self.references:
@@ -270,7 +329,7 @@ class PaymentEntry(AccountsController):
 	def validate_party_details(self):
 		if self.party:
 			if not frappe.db.exists(self.party_type, self.party):
-				frappe.throw(_("Invalid {0}: {1}").format(self.party_type, self.party))
+				frappe.throw(_("{0} {1} does not exist").format(_(self.party_type), self.party))
 
 	def set_exchange_rate(self, ref_doc=None):
 		self.set_source_exchange_rate(ref_doc)
@@ -327,7 +386,9 @@ class PaymentEntry(AccountsController):
 				continue
 			if d.reference_doctype not in valid_reference_doctypes:
 				frappe.throw(
-					_("Reference Doctype must be one of {0}").format(comma_or(valid_reference_doctypes))
+					_("Reference Doctype must be one of {0}").format(
+						comma_or((_(d) for d in valid_reference_doctypes))
+					)
 				)
 
 			elif d.reference_name:
@@ -340,7 +401,7 @@ class PaymentEntry(AccountsController):
 						if self.party != ref_doc.get(scrub(self.party_type)):
 							frappe.throw(
 								_("{0} {1} is not associated with {2} {3}").format(
-									d.reference_doctype, d.reference_name, self.party_type, self.party
+									_(d.reference_doctype), d.reference_name, _(self.party_type), self.party
 								)
 							)
 					else:
@@ -361,18 +422,18 @@ class PaymentEntry(AccountsController):
 						if ref_party_account != self.party_account:
 							frappe.throw(
 								_("{0} {1} is associated with {2}, but Party Account is {3}").format(
-									d.reference_doctype, d.reference_name, ref_party_account, self.party_account
+									_(d.reference_doctype), d.reference_name, ref_party_account, self.party_account
 								)
 							)
 
 						if ref_doc.doctype == "Purchase Invoice" and ref_doc.get("on_hold"):
 							frappe.throw(
-								_("{0} {1} is on hold").format(d.reference_doctype, d.reference_name),
-								title=_("Invalid Invoice"),
+								_("{0} {1} is on hold").format(_(d.reference_doctype), d.reference_name),
+								title=_("Invalid Purchase Invoice"),
 							)
 
 					if ref_doc.docstatus != 1:
-						frappe.throw(_("{0} {1} must be submitted").format(d.reference_doctype, d.reference_name))
+						frappe.throw(_("{0} {1} must be submitted").format(_(d.reference_doctype), d.reference_name))
 
 	def validate_paid_invoices(self):
 		no_oustanding_refs = {}
@@ -388,14 +449,13 @@ class PaymentEntry(AccountsController):
 				if outstanding_amount <= 0 and not is_return:
 					no_oustanding_refs.setdefault(d.reference_doctype, []).append(d)
 
-		for k, v in no_oustanding_refs.items():
+		for reference_doctype, references in no_oustanding_refs.items():
 			frappe.msgprint(
 				_(
-					"{} - {} now have {} as they had no outstanding amount left before submitting the Payment Entry."
+					"References {0} of type {1} had no outstanding amount left before submitting the Payment Entry. Now they have a negative outstanding amount."
 				).format(
-					_(k),
-					frappe.bold(", ".join(d.reference_name for d in v)),
-					frappe.bold(_("negative outstanding amount")),
+					frappe.bold(comma_and((d.reference_name for d in references))),
+					_(reference_doctype),
 				)
 				+ "<br><br>"
 				+ _("If this is undesirable please cancel the corresponding Payment Entry."),
@@ -430,7 +490,7 @@ class PaymentEntry(AccountsController):
 					if not valid:
 						frappe.throw(
 							_("Against Journal Entry {0} does not have any unmatched {1} entry").format(
-								d.reference_name, dr_or_cr
+								d.reference_name, _(dr_or_cr)
 							)
 						)
 
@@ -497,7 +557,7 @@ class PaymentEntry(AccountsController):
 				if allocated_amount > outstanding:
 					frappe.throw(
 						_("Row #{0}: Cannot allocate more than {1} against payment term {2}").format(
-							idx, outstanding, key[0]
+							idx, fmt_money(outstanding), key[0]
 						)
 					)
 
@@ -557,7 +617,9 @@ class PaymentEntry(AccountsController):
 		if not self.apply_tax_withholding_amount:
 			return
 
-		net_total = self.paid_amount
+		order_amount = self.get_order_net_total()
+
+		net_total = flt(order_amount) + flt(self.unallocated_amount)
 
 		# Adding args as purchase invoice to get TDS amount
 		args = frappe._dict(
@@ -602,6 +664,20 @@ class PaymentEntry(AccountsController):
 		for d in to_remove:
 			self.remove(d)
 
+	def get_order_net_total(self):
+		if self.party_type == "Supplier":
+			doctype = "Purchase Order"
+		else:
+			doctype = "Sales Order"
+
+		docnames = [d.reference_name for d in self.references if d.reference_doctype == doctype]
+
+		tax_withholding_net_total = frappe.db.get_value(
+			doctype, {"name": ["in", docnames]}, ["sum(base_net_total)"]
+		)
+
+		return tax_withholding_net_total
+
 	def apply_taxes(self):
 		self.initialize_taxes()
 		self.determine_exclusive_rate()
@@ -774,7 +850,7 @@ class PaymentEntry(AccountsController):
 					_("Cannot {0} {1} {2} without any negative outstanding invoice").format(
 						_(self.payment_type),
 						(_("to") if self.party_type == "Customer" else _("from")),
-						self.party_type,
+						_(self.party_type),
 					),
 					InvalidPaymentEntry,
 				)
@@ -782,7 +858,7 @@ class PaymentEntry(AccountsController):
 			elif paid_amount - additional_charges > total_negative_outstanding:
 				frappe.throw(
 					_("Paid Amount cannot be greater than total negative outstanding amount {0}").format(
-						total_negative_outstanding
+						fmt_money(total_negative_outstanding)
 					),
 					InvalidPaymentEntry,
 				)
@@ -1278,6 +1354,9 @@ def get_outstanding_reference_documents(args):
 	if args.get("party_type") == "Member":
 		return
 
+	if not args.get("get_outstanding_invoices") and not args.get("get_orders_to_be_billed"):
+		args["get_outstanding_invoices"] = True
+
 	# confirm that Supplier is not blocked
 	if args.get("party_type") == "Supplier":
 		supplier_status = get_supplier_block_status(args["party"])
@@ -1318,32 +1397,48 @@ def get_outstanding_reference_documents(args):
 	if args.get("company"):
 		condition += " and company = {0}".format(frappe.db.escape(args.get("company")))
 
-	outstanding_invoices = get_outstanding_invoices(
-		args.get("party_type"),
-		args.get("party"),
-		args.get("party_account"),
-		args.get("company"),
-		filters=args,
-		condition=condition,
-	)
+	outstanding_invoices = []
+	negative_outstanding_invoices = []
 
-	outstanding_invoices = split_invoices_based_on_payment_terms(outstanding_invoices)
+	if args.get("get_outstanding_invoices"):
+		outstanding_invoices = get_outstanding_invoices(
+			args.get("party_type"),
+			args.get("party"),
+			args.get("party_account"),
+			args.get("company"),
+			filters=args,
+			condition=condition,
+		)
 
-	for d in outstanding_invoices:
-		d["exchange_rate"] = 1
-		if party_account_currency != company_currency:
-			if d.voucher_type in ("Sales Invoice", "Purchase Invoice", "Expense Claim"):
-				d["exchange_rate"] = frappe.db.get_value(d.voucher_type, d.voucher_no, "conversion_rate")
-			elif d.voucher_type == "Journal Entry":
-				d["exchange_rate"] = get_exchange_rate(
-					party_account_currency, company_currency, d.posting_date
-				)
-		if d.voucher_type in ("Purchase Invoice"):
-			d["bill_no"] = frappe.db.get_value(d.voucher_type, d.voucher_no, "bill_no")
+		outstanding_invoices = split_invoices_based_on_payment_terms(outstanding_invoices)
+
+		for d in outstanding_invoices:
+			d["exchange_rate"] = 1
+			if party_account_currency != company_currency:
+				if d.voucher_type in ("Sales Invoice", "Purchase Invoice", "Expense Claim"):
+					d["exchange_rate"] = frappe.db.get_value(d.voucher_type, d.voucher_no, "conversion_rate")
+				elif d.voucher_type == "Journal Entry":
+					d["exchange_rate"] = get_exchange_rate(
+						party_account_currency, company_currency, d.posting_date
+					)
+			if d.voucher_type in ("Purchase Invoice"):
+				d["bill_no"] = frappe.db.get_value(d.voucher_type, d.voucher_no, "bill_no")
+
+		# Get negative outstanding sales /purchase invoices
+		negative_outstanding_invoices = []
+		if args.get("party_type") not in ["Student", "Employee"] and not args.get("voucher_no"):
+			negative_outstanding_invoices = get_negative_outstanding_invoices(
+				args.get("party_type"),
+				args.get("party"),
+				args.get("party_account"),
+				party_account_currency,
+				company_currency,
+				condition=condition,
+			)
 
 	# Get all SO / PO which are not fully billed or against which full advance not paid
 	orders_to_be_billed = []
-	if args.get("party_type") != "Student":
+	if args.get("get_orders_to_be_billed") and args.get("party_type") != "Student":
 		orders_to_be_billed = get_orders_to_be_billed(
 			args.get("posting_date"),
 			args.get("party_type"),
@@ -1354,25 +1449,22 @@ def get_outstanding_reference_documents(args):
 			filters=args,
 		)
 
-	# Get negative outstanding sales /purchase invoices
-	negative_outstanding_invoices = []
-	if args.get("party_type") not in ["Student", "Employee"] and not args.get("voucher_no"):
-		negative_outstanding_invoices = get_negative_outstanding_invoices(
-			args.get("party_type"),
-			args.get("party"),
-			args.get("party_account"),
-			party_account_currency,
-			company_currency,
-			condition=condition,
-		)
-
 	data = negative_outstanding_invoices + outstanding_invoices + orders_to_be_billed
 
 	if not data:
+		if args.get("get_outstanding_invoices") and args.get("get_orders_to_be_billed"):
+			ref_document_type = "invoices or orders"
+		elif args.get("get_outstanding_invoices"):
+			ref_document_type = "invoices"
+		elif args.get("get_orders_to_be_billed"):
+			ref_document_type = "orders"
+
 		frappe.msgprint(
 			_(
-				"No outstanding invoices found for the {0} {1} which qualify the filters you have specified."
-			).format(_(args.get("party_type")).lower(), frappe.bold(args.get("party")))
+				"No outstanding {0} found for the {1} {2} which qualify the filters you have specified."
+			).format(
+				_(ref_document_type), _(args.get("party_type")).lower(), frappe.bold(args.get("party"))
+			)
 		)
 
 	return data
@@ -1446,66 +1538,71 @@ def get_orders_to_be_billed(
 	cost_center=None,
 	filters=None,
 ):
+	voucher_type = None
 	if party_type == "Customer":
 		voucher_type = "Sales Order"
 	elif party_type == "Supplier":
 		voucher_type = "Purchase Order"
-	elif party_type == "Employee":
-		voucher_type = None
+
+	if not voucher_type:
+		return []
 
 	# Add cost center condition
-	if voucher_type:
-		doc = frappe.get_doc({"doctype": voucher_type})
-		condition = ""
-		if doc and hasattr(doc, "cost_center"):
-			condition = " and cost_center='%s'" % cost_center
+	doc = frappe.get_doc({"doctype": voucher_type})
+	condition = ""
+	if doc and hasattr(doc, "cost_center") and doc.cost_center:
+		condition = " and cost_center='%s'" % cost_center
 
-	orders = []
-	if voucher_type:
-		if party_account_currency == company_currency:
-			grand_total_field = "base_grand_total"
-			rounded_total_field = "base_rounded_total"
-		else:
-			grand_total_field = "grand_total"
-			rounded_total_field = "rounded_total"
+	if party_account_currency == company_currency:
+		grand_total_field = "base_grand_total"
+		rounded_total_field = "base_rounded_total"
+	else:
+		grand_total_field = "grand_total"
+		rounded_total_field = "rounded_total"
 
-		orders = frappe.db.sql(
-			"""
-			select
-				name as voucher_no,
-				if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) as invoice_amount,
-				(if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) - advance_paid) as outstanding_amount,
-				transaction_date as posting_date
-			from
-				`tab{voucher_type}`
-			where
-				{party_type} = %s
-				and docstatus = 1
-				and company = %s
-				and ifnull(status, "") != "Closed"
-				and if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) > advance_paid
-				and abs(100 - per_billed) > 0.01
-				{condition}
-			order by
-				transaction_date, name
-		""".format(
-				**{
-					"rounded_total_field": rounded_total_field,
-					"grand_total_field": grand_total_field,
-					"voucher_type": voucher_type,
-					"party_type": scrub(party_type),
-					"condition": condition,
-				}
-			),
-			(party, company),
-			as_dict=True,
-		)
+	orders = frappe.db.sql(
+		"""
+		select
+			name as voucher_no,
+			if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) as invoice_amount,
+			(if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) - advance_paid) as outstanding_amount,
+			transaction_date as posting_date
+		from
+			`tab{voucher_type}`
+		where
+			{party_type} = %s
+			and docstatus = 1
+			and company = %s
+			and ifnull(status, "") != "Closed"
+			and if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) > advance_paid
+			and abs(100 - per_billed) > 0.01
+			{condition}
+		order by
+			transaction_date, name
+	""".format(
+			**{
+				"rounded_total_field": rounded_total_field,
+				"grand_total_field": grand_total_field,
+				"voucher_type": voucher_type,
+				"party_type": scrub(party_type),
+				"condition": condition,
+			}
+		),
+		(party, company),
+		as_dict=True,
+	)
 
 	order_list = []
 	for d in orders:
-		if not (
-			flt(d.outstanding_amount) >= flt(filters.get("outstanding_amt_greater_than"))
-			and flt(d.outstanding_amount) <= flt(filters.get("outstanding_amt_less_than"))
+		if (
+			filters
+			and filters.get("outstanding_amt_greater_than")
+			and filters.get("outstanding_amt_less_than")
+			and not (
+				flt(filters.get("outstanding_amt_greater_than"))
+				<= flt(d.outstanding_amount)
+				<= flt(filters.get("outstanding_amt_less_than"))
+			)
 		):
 			continue
 
@@ -1526,6 +1623,8 @@ def get_negative_outstanding_invoices(
 	cost_center=None,
 	condition=None,
 ):
+	if party_type not in ["Customer", "Supplier"]:
+		return []
 	voucher_type = "Sales Invoice" if party_type == "Customer" else "Purchase Invoice"
 	supplier_condition = ""
 	if voucher_type == "Purchase Invoice":
@@ -1574,7 +1673,7 @@ def get_negative_outstanding_invoices(
 def get_party_details(company, party_type, party, date, cost_center=None):
 	bank_account = ""
 	if not frappe.db.exists(party_type, party):
-		frappe.throw(_("Invalid {0}: {1}").format(party_type, party))
+		frappe.throw(_("{0} {1} does not exist").format(_(party_type), party))
 
 	party_account = get_party_account(party_type, party, company)
 
@@ -1855,8 +1954,11 @@ def get_payment_entry(
 ):
 	reference_doc = None
 	doc = frappe.get_doc(dt, dn)
-	if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) >= 99.99:
-		frappe.throw(_("Can only make payment against unbilled {0}").format(dt))
+	over_billing_allowance = frappe.db.get_single_value("Accounts Settings", "over_billing_allowance")
+	if dt in ("Sales Order", "Purchase Order") and flt(doc.per_billed, 2) >= (
+		100.0 + over_billing_allowance
+	):
+		frappe.throw(_("Can only make payment against unbilled {0}").format(_(dt)))
 
 	party_type = set_party_type(dt)
 	party_account = set_party_account(dt, dn, doc, party_type)

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -999,6 +999,30 @@ class TestPaymentEntry(unittest.TestCase):
 
 		self.assertTrue("is on hold" in str(err.exception).lower())
 
+	def test_duplicate_payment_entry_allocate_amount(self):
+		si = create_sales_invoice()
+
+		pe_draft = get_payment_entry("Sales Invoice", si.name)
+		pe_draft.insert()
+
+		pe = get_payment_entry("Sales Invoice", si.name)
+		pe.submit()
+
+		self.assertRaises(frappe.ValidationError, pe_draft.submit)
+
+	def test_duplicate_payment_entry_partial_allocate_amount(self):
+		si = create_sales_invoice()
+
+		pe_draft = get_payment_entry("Sales Invoice", si.name)
+		pe_draft.insert()
+
+		pe = get_payment_entry("Sales Invoice", si.name)
+		pe.received_amount = si.total / 2
+		pe.references[0].allocated_amount = si.total / 2
+		pe.submit()
+
+		self.assertRaises(frappe.ValidationError, pe_draft.submit)
+
 
 def create_payment_entry(**args):
 	payment_entry = frappe.new_doc("Payment Entry")

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -295,6 +295,7 @@ class PaymentReconciliation(Document):
 				"amount": pay.get("amount"),
 				"allocated_amount": allocated_amount,
 				"difference_amount": pay.get("difference_amount"),
+				"currency": inv.get("currency"),
 			}
 		)
 

erpnext/accounts/doctype/payment_reconciliation_allocation/payment_reconciliation_allocation.json

@@ -20,7 +20,8 @@
   "section_break_5",
   "difference_amount",
   "column_break_7",
-  "difference_account"
+  "difference_account",
+  "currency"
  ],
  "fields": [
   {
@@ -37,7 +38,7 @@
    "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Allocated Amount",
-   "options": "Currency",
+   "options": "currency",
    "reqd": 1
   },
   {
@@ -112,7 +113,7 @@
    "fieldtype": "Currency",
    "hidden": 1,
    "label": "Unreconciled Amount",
-   "options": "Currency",
+   "options": "currency",
    "read_only": 1
   },
   {
@@ -120,7 +121,7 @@
    "fieldtype": "Currency",
    "hidden": 1,
    "label": "Amount",
-   "options": "Currency",
+   "options": "currency",
    "read_only": 1
   },
   {
@@ -129,11 +130,18 @@
    "hidden": 1,
    "label": "Reference Row",
    "read_only": 1
+  },
+  {
+   "fieldname": "currency",
+   "fieldtype": "Link",
+   "hidden": 1,
+   "label": "Currency",
+   "options": "Currency"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2021-10-06 11:48:59.616562",
+ "modified": "2023-11-28 16:30:43.344612",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation Allocation",

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -169,21 +169,18 @@ class PeriodClosingVoucher(AccountsController):
 		return frappe.db.sql(
 			"""
 			select
-				t2.account_currency,
+				t1.account_currency,
 				{dimension_fields},
 				sum(t1.debit_in_account_currency) - sum(t1.credit_in_account_currency) as bal_in_account_currency,
 				sum(t1.debit) - sum(t1.credit) as bal_in_company_currency
-			from `tabGL Entry` t1, `tabAccount` t2
+			from `tabGL Entry` t1
 			where
 				t1.is_cancelled = 0
-				and t1.account = t2.name
-				and t2.report_type = 'Profit and Loss'
-				and t2.docstatus < 2
-				and t2.company = %s
+				and t1.account in (select name from `tabAccount` where report_type = 'Profit and Loss' and docstatus < 2 and company = %s)
 				and t1.posting_date between %s and %s
 			group by {dimension_fields}
 		""".format(
-				dimension_fields=", ".join(dimension_fields)
+				dimension_fields=", ".join(dimension_fields),
 			),
 			(self.company, self.get("year_start_date"), self.posting_date),
 			as_dict=1,

erpnext/accounts/doctype/pos_invoice/pos_invoice.json

@@ -345,7 +345,8 @@
    "no_copy": 1,
    "options": "POS Invoice",
    "print_hide": 1,
-   "read_only": 1
+   "read_only": 1,
+   "search_index": 1
   },
   {
    "default": "0",
@@ -1572,7 +1573,7 @@
  "icon": "fa fa-file-text",
  "is_submittable": 1,
  "links": [],
- "modified": "2022-09-27 13:00:24.166684",
+ "modified": "2022-09-30 03:49:50.455199",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Invoice",

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -1,9 +1,10 @@
 # Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors and contributors
 # For license information, please see license.txt
-
+import collections
 
 import frappe
 from frappe import _
+from frappe.query_builder.functions import IfNull, Sum
 from frappe.utils import cint, flt, get_link_to_form, getdate, nowdate
 from six import iteritems
 
@@ -43,6 +44,7 @@ class POSInvoice(SalesInvoice):
 		self.validate_debit_to_acc()
 		self.validate_write_off_account()
 		self.validate_change_amount()
+		self.validate_duplicate_serial_and_batch_no()
 		self.validate_change_account()
 		self.validate_item_cost_centers()
 		self.validate_warehouse()
@@ -153,6 +155,27 @@ class POSInvoice(SalesInvoice):
 				title=_("Item Unavailable"),
 			)
 
+	def validate_duplicate_serial_and_batch_no(self):
+		serial_nos = []
+		batch_nos = []
+
+		for row in self.get("items"):
+			if row.serial_no:
+				serial_nos = row.serial_no.split("\n")
+
+			if row.batch_no and not row.serial_no:
+				batch_nos.append(row.batch_no)
+
+		if serial_nos:
+			for key, value in collections.Counter(serial_nos).items():
+				if value > 1:
+					frappe.throw(_("Duplicate Serial No {0} found").format("key"))
+
+		if batch_nos:
+			for key, value in collections.Counter(batch_nos).items():
+				if value > 1:
+					frappe.throw(_("Duplicate Batch No {0} found").format("key"))
+
 	def validate_pos_reserved_batch_qty(self, item):
 		filters = {"item_code": item.item_code, "warehouse": item.warehouse, "batch_no": item.batch_no}
 
@@ -675,20 +698,24 @@ def get_bin_qty(item_code, warehouse):
 
 
 def get_pos_reserved_qty(item_code, warehouse):
-	reserved_qty = frappe.db.sql(
-		"""select sum(p_item.qty) as qty
-		from `tabPOS Invoice` p, `tabPOS Invoice Item` p_item
-		where p.name = p_item.parent
-		and ifnull(p.consolidated_invoice, '') = ''
-		and p_item.docstatus = 1
-		and p_item.item_code = %s
-		and p_item.warehouse = %s
-		""",
-		(item_code, warehouse),
-		as_dict=1,
-	)
+	p_inv = frappe.qb.DocType("POS Invoice")
+	p_item = frappe.qb.DocType("POS Invoice Item")
 
-	return reserved_qty[0].qty or 0 if reserved_qty else 0
+	reserved_qty = (
+		frappe.qb.from_(p_inv)
+		.from_(p_item)
+		.select(Sum(p_item.stock_qty).as_("stock_qty"))
+		.where(
+			(p_inv.name == p_item.parent)
+			& (IfNull(p_inv.consolidated_invoice, "") == "")
+			& (p_inv.is_return == 0)
+			& (p_item.docstatus == 1)
+			& (p_item.item_code == item_code)
+			& (p_item.warehouse == warehouse)
+		)
+	).run(as_dict=True)
+
+	return flt(reserved_qty[0].stock_qty) if reserved_qty else 0
 
 
 @frappe.whitelist()
@@ -747,7 +774,3 @@ def add_return_modes(doc, pos_profile):
 		]:
 			payment_mode = get_mode_of_payment_info(mode_of_payment, doc.company)
 			append_payment(payment_mode[0])
-
-
-def on_doctype_update():
-	frappe.db.add_index("POS Invoice", ["return_against"])

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -303,7 +303,7 @@ erpnext.accounts.PurchaseInvoice = erpnext.buying.BuyingController.extend({
 
 	apply_tds: function(frm) {
 		var me = this;
-
+		me.frm.set_value("tax_withheld_vouchers", []);
 		if (!me.frm.doc.apply_tds) {
 			me.frm.set_value("tax_withholding_category", '');
 			me.frm.set_df_property("tax_withholding_category", "hidden", 1);

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -261,9 +261,7 @@ class PurchaseInvoice(BuyingController):
 			stock_not_billed_account = self.get_company_default("stock_received_but_not_billed")
 			stock_items = self.get_stock_items()
 
-		asset_items = [d.is_fixed_asset for d in self.items if d.is_fixed_asset]
-		if len(asset_items) > 0:
-			asset_received_but_not_billed = self.get_company_default("asset_received_but_not_billed")
+		asset_received_but_not_billed = None
 
 		if self.update_stock:
 			self.validate_item_code()
@@ -357,6 +355,8 @@ class PurchaseInvoice(BuyingController):
 					)
 				item.expense_account = asset_category_account
 			elif item.is_fixed_asset and item.pr_detail:
+				if not asset_received_but_not_billed:
+					asset_received_but_not_billed = self.get_company_default("asset_received_but_not_billed")
 				item.expense_account = asset_received_but_not_billed
 			elif not item.expense_account and for_validate:
 				throw(_("Expense account is mandatory for item {0}").format(item.item_code or item.item_name))
@@ -924,8 +924,9 @@ class PurchaseInvoice(BuyingController):
 						)
 
 	def get_asset_gl_entry(self, gl_entries):
-		arbnb_account = self.get_company_default("asset_received_but_not_billed")
-		eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
+		arbnb_account = None
+		eiiav_account = None
+		asset_eiiav_currency = None
 
 		for item in self.get("items"):
 			if item.is_fixed_asset:
@@ -937,6 +938,8 @@ class PurchaseInvoice(BuyingController):
 					"Asset Received But Not Billed",
 					"Fixed Asset",
 				]:
+					if not arbnb_account:
+						arbnb_account = self.get_company_default("asset_received_but_not_billed")
 					item.expense_account = arbnb_account
 
 				if not self.update_stock:
@@ -959,7 +962,10 @@ class PurchaseInvoice(BuyingController):
 					)
 
 					if item.item_tax_amount:
-						asset_eiiav_currency = get_account_currency(eiiav_account)
+						if not eiiav_account or not asset_eiiav_currency:
+							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
+							asset_eiiav_currency = get_account_currency(eiiav_account)
+
 						gl_entries.append(
 							self.get_gl_dict(
 								{
@@ -1002,7 +1008,10 @@ class PurchaseInvoice(BuyingController):
 					)
 
 					if item.item_tax_amount and not cint(erpnext.is_perpetual_inventory_enabled(self.company)):
-						asset_eiiav_currency = get_account_currency(eiiav_account)
+						if not eiiav_account or not asset_eiiav_currency:
+							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
+							asset_eiiav_currency = get_account_currency(eiiav_account)
+
 						gl_entries.append(
 							self.get_gl_dict(
 								{
@@ -1022,47 +1031,46 @@ class PurchaseInvoice(BuyingController):
 							)
 						)
 
-					# When update stock is checked
 					# Assets are bought through this document then it will be linked to this document
-					if self.update_stock:
-						if flt(item.landed_cost_voucher_amount):
-							gl_entries.append(
-								self.get_gl_dict(
-									{
-										"account": eiiav_account,
-										"against": cwip_account,
-										"cost_center": item.cost_center,
-										"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
-										"credit": flt(item.landed_cost_voucher_amount),
-										"project": item.project or self.project,
-									},
-									item=item,
-								)
-							)
+					if flt(item.landed_cost_voucher_amount):
+						if not eiiav_account:
+							eiiav_account = self.get_company_default("expenses_included_in_asset_valuation")
 
-							gl_entries.append(
-								self.get_gl_dict(
-									{
-										"account": cwip_account,
-										"against": eiiav_account,
-										"cost_center": item.cost_center,
-										"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
-										"debit": flt(item.landed_cost_voucher_amount),
-										"project": item.project or self.project,
-									},
-									item=item,
-								)
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": eiiav_account,
+									"against": cwip_account,
+									"cost_center": item.cost_center,
+									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+									"credit": flt(item.landed_cost_voucher_amount),
+									"project": item.project or self.project,
+								},
+								item=item,
 							)
-
-						# update gross amount of assets bought through this document
-						assets = frappe.db.get_all(
-							"Asset", filters={"purchase_invoice": self.name, "item_code": item.item_code}
 						)
-						for asset in assets:
-							frappe.db.set_value("Asset", asset.name, "gross_purchase_amount", flt(item.valuation_rate))
-							frappe.db.set_value(
-								"Asset", asset.name, "purchase_receipt_amount", flt(item.valuation_rate)
+
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": cwip_account,
+									"against": eiiav_account,
+									"cost_center": item.cost_center,
+									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
+									"debit": flt(item.landed_cost_voucher_amount),
+									"project": item.project or self.project,
+								},
+								item=item,
 							)
+						)
+
+					# update gross amount of assets bought through this document
+					assets = frappe.db.get_all(
+						"Asset", filters={"purchase_invoice": self.name, "item_code": item.item_code}
+					)
+					for asset in assets:
+						frappe.db.set_value("Asset", asset.name, "gross_purchase_amount", flt(item.valuation_rate))
+						frappe.db.set_value("Asset", asset.name, "purchase_receipt_amount", flt(item.valuation_rate))
 
 		return gl_entries
 

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -1580,6 +1580,76 @@ class TestPurchaseInvoice(unittest.TestCase, StockTestMixin):
 
 		self.assertTrue(return_pi.docstatus == 1)
 
+	def test_payment_allocation_for_payment_terms(self):
+		from erpnext.buying.doctype.purchase_order.test_purchase_order import (
+			create_pr_against_po,
+			create_purchase_order,
+		)
+		from erpnext.selling.doctype.sales_order.test_sales_order import (
+			automatically_fetch_payment_terms,
+		)
+		from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
+			make_purchase_invoice as make_pi_from_pr,
+		)
+
+		automatically_fetch_payment_terms()
+		frappe.db.set_value(
+			"Payment Terms Template",
+			"_Test Payment Term Template",
+			"allocate_payment_based_on_payment_terms",
+			0,
+		)
+
+		po = create_purchase_order(do_not_save=1)
+		po.payment_terms_template = "_Test Payment Term Template"
+		po.save()
+		po.submit()
+
+		pr = create_pr_against_po(po.name, received_qty=4)
+		pi = make_pi_from_pr(pr.name)
+		self.assertEqual(pi.payment_schedule[0].payment_amount, 1000)
+
+		frappe.db.set_value(
+			"Payment Terms Template",
+			"_Test Payment Term Template",
+			"allocate_payment_based_on_payment_terms",
+			1,
+		)
+		pi = make_pi_from_pr(pr.name)
+		self.assertEqual(pi.payment_schedule[0].payment_amount, 2500)
+
+		automatically_fetch_payment_terms(enable=0)
+		frappe.db.set_value(
+			"Payment Terms Template",
+			"_Test Payment Term Template",
+			"allocate_payment_based_on_payment_terms",
+			0,
+		)
+
+	def test_default_cost_center_for_purchase(self):
+		from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
+
+		for c_center in ["_Test Cost Center Selling", "_Test Cost Center Buying"]:
+			create_cost_center(cost_center_name=c_center)
+
+		item = create_item(
+			"_Test Cost Center Item For Purchase",
+			is_stock_item=1,
+			buying_cost_center="_Test Cost Center Buying - _TC",
+			selling_cost_center="_Test Cost Center Selling - _TC",
+		)
+
+		pi = make_purchase_invoice(
+			item=item.name, qty=1, rate=1000, update_stock=True, do_not_submit=True, cost_center=""
+		)
+
+		pi.items[0].cost_center = ""
+		pi.set_missing_values()
+		pi.calculate_taxes_and_totals()
+		pi.save()
+
+		self.assertEqual(pi.items[0].cost_center, "_Test Cost Center Buying - _TC")
+
 
 def check_gl_entries(doc, voucher_no, expected_gle, posting_date):
 	gl_entries = frappe.db.sql(

erpnext/accounts/doctype/purchase_invoice_item/purchase_invoice_item.json

@@ -176,6 +176,7 @@
    "fieldname": "received_qty",
    "fieldtype": "Float",
    "label": "Received Qty",
+   "no_copy": 1,
    "read_only": 1
   },
   {
@@ -872,7 +873,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2022-10-12 03:37:29.032732",
+ "modified": "2023-07-02 18:39:41.495723",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice Item",

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -653,19 +653,6 @@ frappe.ui.form.on('Sales Invoice', {
 			}
 		}
 
-		// expense account
-		frm.fields_dict['items'].grid.get_field('expense_account').get_query = function(doc) {
-			if (erpnext.is_perpetual_inventory_enabled(doc.company)) {
-				return {
-					filters: {
-						'report_type': 'Profit and Loss',
-						'company': doc.company,
-						"is_group": 0
-					}
-				}
-			}
-		}
-
 		// discount account
 		frm.fields_dict['items'].grid.get_field('discount_account').get_query = function(doc) {
 			return {

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -1107,7 +1107,7 @@ class SalesInvoice(SellingController):
 
 					if self.is_return:
 						fixed_asset_gl_entries = get_gl_entries_on_asset_regain(
-							asset, item.base_net_amount, item.finance_book
+							asset, item.base_net_amount, item.finance_book, self.posting_date
 						)
 						asset.db_set("disposal_date", None)
 
@@ -1122,7 +1122,7 @@ class SalesInvoice(SellingController):
 							asset.reload()
 
 						fixed_asset_gl_entries = get_gl_entries_on_asset_disposal(
-							asset, item.base_net_amount, item.finance_book
+							asset, item.base_net_amount, item.finance_book, self.posting_date
 						)
 						asset.db_set("disposal_date", self.posting_date)
 
@@ -1580,15 +1580,13 @@ class SalesInvoice(SellingController):
 		frappe.db.set_value("Customer", self.customer, "loyalty_program_tier", lp_details.tier_name)
 
 	def get_returned_amount(self):
-		from frappe.query_builder.functions import Coalesce, Sum
+		from frappe.query_builder.functions import Sum
 
 		doc = frappe.qb.DocType(self.doctype)
 		returned_amount = (
 			frappe.qb.from_(doc)
 			.select(Sum(doc.grand_total))
-			.where(
-				(doc.docstatus == 1) & (doc.is_return == 1) & (Coalesce(doc.return_against, "") == self.name)
-			)
+			.where((doc.docstatus == 1) & (doc.is_return == 1) & (doc.return_against == self.name))
 		).run()
 
 		return abs(returned_amount[0][0]) if returned_amount[0][0] else 0

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -1783,6 +1783,10 @@ class TestSalesInvoice(unittest.TestCase):
 		)
 
 	def test_outstanding_amount_after_advance_payment_entry_cancellation(self):
+		"""Test impact of advance PE submission/cancellation on SI and SO."""
+		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+
+		sales_order = make_sales_order(item_code="138-CMS Shoe", qty=1, price_list_rate=500)
 		pe = frappe.get_doc(
 			{
 				"doctype": "Payment Entry",
@@ -1802,10 +1806,25 @@ class TestSalesInvoice(unittest.TestCase):
 				"paid_to": "_Test Cash - _TC",
 			}
 		)
+		pe.append(
+			"references",
+			{
+				"reference_doctype": "Sales Order",
+				"reference_name": sales_order.name,
+				"total_amount": sales_order.grand_total,
+				"outstanding_amount": sales_order.grand_total,
+				"allocated_amount": 300,
+			},
+		)
 		pe.insert()
 		pe.submit()
 
+		sales_order.reload()
+		self.assertEqual(sales_order.advance_paid, 300)
+
 		si = frappe.copy_doc(test_records[0])
+		si.items[0].sales_order = sales_order.name
+		si.items[0].so_detail = sales_order.get("items")[0].name
 		si.is_pos = 0
 		si.append(
 			"advances",
@@ -1813,6 +1832,7 @@ class TestSalesInvoice(unittest.TestCase):
 				"doctype": "Sales Invoice Advance",
 				"reference_type": "Payment Entry",
 				"reference_name": pe.name,
+				"reference_row": pe.references[0].name,
 				"advance_amount": 300,
 				"allocated_amount": 300,
 				"remarks": pe.remarks,
@@ -1821,7 +1841,13 @@ class TestSalesInvoice(unittest.TestCase):
 		si.insert()
 		si.submit()
 
-		si.load_from_db()
+		si.reload()
+		pe.reload()
+		sales_order.reload()
+
+		# Check if SO is unlinked/replaced by SI in PE & if SO advance paid is 0
+		self.assertEqual(pe.references[0].reference_name, si.name)
+		self.assertEqual(sales_order.advance_paid, 0.0)
 
 		# check outstanding after advance allocation
 		self.assertEqual(
@@ -1829,11 +1855,9 @@ class TestSalesInvoice(unittest.TestCase):
 			flt(si.rounded_total - si.total_advance, si.precision("outstanding_amount")),
 		)
 
-		# added to avoid Document has been modified exception
-		pe = frappe.get_doc("Payment Entry", pe.name)
 		pe.cancel()
+		si.reload()
 
-		si.load_from_db()
 		# check outstanding after advance cancellation
 		self.assertEqual(
 			flt(si.outstanding_amount),
@@ -2448,36 +2472,6 @@ class TestSalesInvoice(unittest.TestCase):
 		self.assertEqual(target_doc.company, "_Test Company 1")
 		self.assertEqual(target_doc.supplier, "_Test Internal Supplier")
 
-	def test_sle_for_target_warehouse(self):
-		se = make_stock_entry(
-			item_code="138-CMS Shoe",
-			target="Finished Goods - _TC",
-			company="_Test Company",
-			qty=1,
-			basic_rate=500,
-		)
-
-		si = frappe.copy_doc(test_records[0])
-		si.update_stock = 1
-		si.set_warehouse = "Finished Goods - _TC"
-		si.set_target_warehouse = "Stores - _TC"
-		si.get("items")[0].warehouse = "Finished Goods - _TC"
-		si.get("items")[0].target_warehouse = "Stores - _TC"
-		si.insert()
-		si.submit()
-
-		sles = frappe.get_all(
-			"Stock Ledger Entry", filters={"voucher_no": si.name}, fields=["name", "actual_qty"]
-		)
-
-		# check if both SLEs are created
-		self.assertEqual(len(sles), 2)
-		self.assertEqual(sum(d.actual_qty for d in sles), 0.0)
-
-		# tear down
-		si.cancel()
-		se.cancel()
-
 	def test_internal_transfer_gl_entry(self):
 		si = create_sales_invoice(
 			company="_Test Company with perpetual inventory",

erpnext/accounts/doctype/subscription/test_subscription.py

@@ -694,3 +694,23 @@ class TestSubscription(unittest.TestCase):
 		# Check the currency of the created invoice
 		currency = frappe.db.get_value("Sales Invoice", subscription.invoices[0].invoice, "currency")
 		self.assertEqual(currency, "USD")
+
+	def test_plan_rate_for_midmonth_start_date(self):
+		subscription = frappe.new_doc("Subscription")
+		subscription.party_type = "Supplier"
+		subscription.party = "_Test Supplier"
+		subscription.generate_invoice_at_period_start = 1
+		subscription.follow_calendar_months = 1
+		subscription.generate_new_invoices_past_due_date = 1
+		subscription.start_date = "2023-04-08"
+		subscription.end_date = "2024-02-27"
+		subscription.append("plans", {"plan": "_Test Plan Name 4", "qty": 1})
+		subscription.save()
+
+		subscription.process()
+
+		self.assertEqual(len(subscription.invoices), 1)
+		pi = frappe.get_doc("Purchase Invoice", subscription.invoices[0].invoice)
+		self.assertEqual(pi.total, 55333.33)
+
+		subscription.delete()

erpnext/accounts/doctype/subscription_plan/subscription_plan.py

@@ -56,18 +56,17 @@ def get_plan_rate(
 		prorate = frappe.db.get_single_value("Subscription Settings", "prorate")
 
 		if prorate:
-			prorate_factor = flt(
-				date_diff(start_date, get_first_day(start_date))
-				/ date_diff(get_last_day(start_date), get_first_day(start_date)),
-				1,
-			)
-
-			prorate_factor += flt(
-				date_diff(get_last_day(end_date), end_date)
-				/ date_diff(get_last_day(end_date), get_first_day(end_date)),
-				1,
-			)
-
-			cost -= plan.cost * prorate_factor
-
+			cost -= plan.cost * get_prorate_factor(start_date, end_date)
 		return cost
+
+
+def get_prorate_factor(start_date, end_date):
+	total_days_to_skip = date_diff(start_date, get_first_day(start_date))
+	total_days_in_month = int(get_last_day(start_date).strftime("%d"))
+	prorate_factor = flt(total_days_to_skip / total_days_in_month)
+
+	total_days_to_skip = date_diff(get_last_day(end_date), end_date)
+	total_days_in_month = int(get_last_day(end_date).strftime("%d"))
+	prorate_factor += flt(total_days_to_skip / total_days_in_month)
+
+	return prorate_factor

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py

@@ -5,7 +5,7 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.utils import cint, getdate
+from frappe.utils import cint, flt, getdate
 
 
 class TaxWithholdingCategory(Document):
@@ -274,7 +274,7 @@ def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
 		"docstatus": 1,
 	}
 
-	if not tax_details.get("consider_party_ledger_amount") and doctype != "Sales Invoice":
+	if doctype != "Sales Invoice":
 		filters.update(
 			{"apply_tds": 1, "tax_withholding_category": tax_details.get("tax_withholding_category")}
 		)
@@ -518,10 +518,19 @@ def get_invoice_total_without_tcs(inv, tax_details):
 
 def get_tds_amount_from_ldc(ldc, parties, pan_no, tax_details, posting_date, net_total):
 	tds_amount = 0
-	limit_consumed = frappe.db.get_value(
-		"Purchase Invoice",
-		{"supplier": ("in", parties), "apply_tds": 1, "docstatus": 1},
-		"sum(net_total)",
+
+	limit_consumed = flt(
+		frappe.db.get_all(
+			"Purchase Invoice",
+			filters={
+				"supplier": ("in", parties),
+				"apply_tds": 1,
+				"docstatus": 1,
+				"tax_withholding_category": ldc.tax_withholding_category,
+				"posting_date": ("between", (ldc.valid_from, ldc.valid_upto)),
+			},
+			fields=["sum(base_net_total) as limit_consumed"],
+		)[0].get("limit_consumed")
 	)
 
 	if is_valid_certificate(
@@ -535,10 +544,10 @@ def get_tds_amount_from_ldc(ldc, parties, pan_no, tax_details, posting_date, net
 
 
 def get_ltds_amount(current_amount, deducted_amount, certificate_limit, rate, tax_details):
-	if current_amount < (certificate_limit - deducted_amount):
+	if certificate_limit - flt(deducted_amount) - flt(current_amount) >= 0:
 		return current_amount * rate / 100
 	else:
-		ltds_amount = certificate_limit - deducted_amount
+		ltds_amount = certificate_limit - flt(deducted_amount)
 		tds_amount = current_amount - ltds_amount
 
 		return ltds_amount * rate / 100 + tds_amount * tax_details.rate / 100
@@ -549,9 +558,9 @@ def is_valid_certificate(
 ):
 	valid = False
 
-	if (
-		getdate(valid_from) <= getdate(posting_date) <= getdate(valid_upto)
-	) and certificate_limit > deducted_amount:
+	available_amount = flt(certificate_limit) - flt(deducted_amount)
+
+	if (getdate(valid_from) <= getdate(posting_date) <= getdate(valid_upto)) and available_amount > 0:
 		valid = True
 
 	return valid

erpnext/accounts/doctype/tax_withholding_category/test_tax_withholding_category.py

@@ -110,9 +110,9 @@ class TestTaxWithholdingCategory(unittest.TestCase):
 		invoices.append(pi1)
 
 		# Cumulative threshold is 30000
-		# Threshold calculation should be on both the invoices
-		# TDS should be applied only on 1000
-		self.assertEqual(pi1.taxes[0].tax_amount, 1000)
+		# Threshold calculation should be only on the Second invoice
+		# Second didn't breach, no TDS should be applied
+		self.assertEqual(pi1.taxes, [])
 
 		for d in reversed(invoices):
 			d.cancel()
@@ -186,6 +186,42 @@ class TestTaxWithholdingCategory(unittest.TestCase):
 		for d in reversed(invoices):
 			d.cancel()
 
+	def test_tds_deduction_for_po_via_payment_entry(self):
+		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+
+		frappe.db.set_value(
+			"Supplier", "Test TDS Supplier8", "tax_withholding_category", "Cumulative Threshold TDS"
+		)
+		order = create_purchase_order(supplier="Test TDS Supplier8", rate=40000, do_not_save=True)
+
+		# Add some tax on the order
+		order.append(
+			"taxes",
+			{
+				"category": "Total",
+				"charge_type": "Actual",
+				"account_head": "_Test Account VAT - _TC",
+				"cost_center": "Main - _TC",
+				"tax_amount": 8000,
+				"description": "Test",
+				"add_deduct_tax": "Add",
+			},
+		)
+
+		order.save()
+
+		order.apply_tds = 1
+		order.tax_withholding_category = "Cumulative Threshold TDS"
+		order.submit()
+
+		self.assertEqual(order.taxes[0].tax_amount, 4000)
+
+		payment = get_payment_entry(order.doctype, order.name)
+		payment.apply_tax_withholding_amount = 1
+		payment.tax_withholding_category = "Cumulative Threshold TDS"
+		payment.submit()
+		self.assertEqual(payment.taxes[0].tax_amount, 4000)
+
 	def test_multi_category_single_supplier(self):
 		frappe.db.set_value(
 			"Supplier", "Test TDS Supplier5", "tax_withholding_category", "Test Service Category"
@@ -275,6 +311,37 @@ def cancel_invoices():
 		frappe.get_doc("Sales Invoice", d).cancel()
 
 
+def create_purchase_order(**args):
+	# return purchase order doc object
+	item = frappe.db.get_value("Item", {"item_name": "TDS Item"}, "name")
+	args = frappe._dict(args)
+	po = frappe.get_doc(
+		{
+			"doctype": "Purchase Order",
+			"transaction_date": today(),
+			"schedule_date": today(),
+			"apply_tds": 0 if args.do_not_apply_tds else 1,
+			"supplier": args.supplier,
+			"company": "_Test Company",
+			"taxes_and_charges": "",
+			"currency": "INR",
+			"taxes": [],
+			"items": [
+				{
+					"doctype": "Purchase Order Item",
+					"item_code": item,
+					"qty": args.qty or 1,
+					"rate": args.rate or 10000,
+					"cost_center": "Main - _TC",
+					"expense_account": "Stock Received But Not Billed - _TC",
+				}
+			],
+		}
+	)
+	po.save()
+	return po
+
+
 def create_purchase_invoice(**args):
 	# return sales invoice doc object
 	item = frappe.db.get_value("Item", {"item_name": "TDS Item"}, "name")
@@ -351,6 +418,8 @@ def create_records():
 		"Test TDS Supplier4",
 		"Test TDS Supplier5",
 		"Test TDS Supplier6",
+		"Test TDS Supplier7",
+		"Test TDS Supplier8",
 	]:
 		if frappe.db.exists("Supplier", name):
 			continue

erpnext/accounts/party.py

@@ -4,12 +4,7 @@
 
 import frappe
 from frappe import _, msgprint, scrub
-from frappe.contacts.doctype.address.address import (
-	get_address_display,
-	get_company_address,
-	get_default_address,
-)
-from frappe.contacts.doctype.contact.contact import get_contact_details
+from frappe.contacts.doctype.address.address import get_company_address, get_default_address
 from frappe.core.doctype.user_permission.user_permission import get_permitted_documents
 from frappe.model.utils import get_fetch_values
 from frappe.utils import (
@@ -120,6 +115,7 @@ def _get_party_details(
 		party_address,
 		company_address,
 		shipping_address,
+		ignore_permissions=ignore_permissions,
 	)
 	set_contact_details(party_details, party, party_type)
 	set_other_values(party_details, party, party_type)
@@ -183,6 +179,8 @@ def set_address_details(
 	party_address=None,
 	company_address=None,
 	shipping_address=None,
+	*,
+	ignore_permissions=False
 ):
 	billing_address_field = (
 		"customer_address" if party_type == "Lead" else party_type.lower() + "_address"
@@ -195,13 +193,17 @@ def set_address_details(
 			get_fetch_values(doctype, billing_address_field, party_details[billing_address_field])
 		)
 	# address display
-	party_details.address_display = get_address_display(party_details[billing_address_field])
+	party_details.address_display = render_address(
+		party_details[billing_address_field], check_permissions=not ignore_permissions
+	)
 	# shipping address
 	if party_type in ["Customer", "Lead"]:
 		party_details.shipping_address_name = shipping_address or get_party_shipping_address(
 			party_type, party.name
 		)
-		party_details.shipping_address = get_address_display(party_details["shipping_address_name"])
+		party_details.shipping_address = render_address(
+			party_details["shipping_address_name"], check_permissions=not ignore_permissions
+		)
 		if doctype:
 			party_details.update(
 				get_fetch_values(doctype, "shipping_address_name", party_details.shipping_address_name)
@@ -224,7 +226,9 @@ def set_address_details(
 			party_details.update(
 				{
 					"shipping_address": shipping_address,
-					"shipping_address_display": get_address_display(shipping_address),
+					"shipping_address_display": render_address(
+						shipping_address, check_permissions=not ignore_permissions
+					),
 					**get_fetch_values(doctype, "shipping_address", shipping_address),
 				}
 			)
@@ -235,7 +239,8 @@ def set_address_details(
 				{
 					"billing_address": party_details.company_address,
 					"billing_address_display": (
-						party_details.company_address_display or get_address_display(party_details.company_address)
+						party_details.company_address_display
+						or render_address(party_details.company_address, check_permissions=True)
 					),
 					**get_fetch_values(doctype, "billing_address", party_details.company_address),
 				}
@@ -277,7 +282,34 @@ def set_contact_details(party_details, party, party_type):
 			}
 		)
 	else:
-		party_details.update(get_contact_details(party_details.contact_person))
+		fields = [
+			"name as contact_person",
+			"salutation",
+			"first_name",
+			"last_name",
+			"email_id as contact_email",
+			"mobile_no as contact_mobile",
+			"phone as contact_phone",
+			"designation as contact_designation",
+			"department as contact_department",
+		]
+
+		contact_details = frappe.db.get_value(
+			"Contact", party_details.contact_person, fields, as_dict=True
+		)
+
+		contact_details.contact_display = " ".join(
+			filter(
+				None,
+				[
+					contact_details.get("salutation"),
+					contact_details.get("first_name"),
+					contact_details.get("last_name"),
+				],
+			)
+		)
+
+		party_details.update(contact_details)
 
 
 def set_other_values(party_details, party, party_type):
@@ -938,3 +970,13 @@ def add_party_account(party_type, party, company, account):
 		doc.append("accounts", accounts)
 
 		doc.save()
+
+
+def render_address(address, check_permissions=True):
+	try:
+		from frappe.contacts.doctype.address.address import render_address as _render
+	except ImportError:
+		# Older frappe versions where this function is not available
+		from frappe.contacts.doctype.address.address import get_address_display as _render
+
+	return frappe.call(_render, address, check_permissions=check_permissions)

erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.json

@@ -1,20 +1,23 @@
 {
- "add_total_row": 0, 
- "apply_user_permissions": 1, 
- "creation": "2016-04-08 14:49:58.133098", 
- "disabled": 0, 
- "docstatus": 0, 
- "doctype": "Report", 
- "idx": 2, 
- "is_standard": "Yes", 
- "modified": "2017-02-24 20:08:26.084484", 
- "modified_by": "Administrator", 
- "module": "Accounts", 
- "name": "Asset Depreciation Ledger", 
- "owner": "Administrator", 
- "ref_doctype": "Asset", 
- "report_name": "Asset Depreciation Ledger", 
- "report_type": "Script Report", 
+ "add_total_row": 1,
+ "columns": [],
+ "creation": "2016-04-08 14:49:58.133098",
+ "disable_prepared_report": 0,
+ "disabled": 0,
+ "docstatus": 0,
+ "doctype": "Report",
+ "filters": [],
+ "idx": 2,
+ "is_standard": "Yes",
+ "modified": "2023-06-06 09:00:07.435151",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Asset Depreciation Ledger",
+ "owner": "Administrator",
+ "prepared_report": 0,
+ "ref_doctype": "Asset",
+ "report_name": "Asset Depreciation Ledger",
+ "report_type": "Script Report",
  "roles": [
   {
    "role": "Accounts User"

erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.json

@@ -1,20 +1,23 @@
 {
- "add_total_row": 0, 
- "apply_user_permissions": 1, 
- "creation": "2016-04-08 14:56:37.235981", 
- "disabled": 0, 
- "docstatus": 0, 
- "doctype": "Report", 
- "idx": 2, 
- "is_standard": "Yes", 
- "modified": "2017-02-24 20:08:18.660476", 
- "modified_by": "Administrator", 
- "module": "Accounts", 
- "name": "Asset Depreciations and Balances", 
- "owner": "Administrator", 
- "ref_doctype": "Asset", 
- "report_name": "Asset Depreciations and Balances", 
- "report_type": "Script Report", 
+ "add_total_row": 1,
+ "columns": [],
+ "creation": "2016-04-08 14:56:37.235981",
+ "disable_prepared_report": 0,
+ "disabled": 0,
+ "docstatus": 0,
+ "doctype": "Report",
+ "filters": [],
+ "idx": 2,
+ "is_standard": "Yes",
+ "modified": "2023-06-06 11:33:29.611277",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Asset Depreciations and Balances",
+ "owner": "Administrator",
+ "prepared_report": 0,
+ "ref_doctype": "Asset",
+ "report_name": "Asset Depreciations and Balances",
+ "report_type": "Script Report",
  "roles": [
   {
    "role": "Accounts User"

erpnext/accounts/report/financial_statements.py

@@ -524,11 +524,26 @@ def get_additional_conditions(from_date, ignore_closing_entries, filters):
 			additional_conditions.append("cost_center in %(cost_center)s")
 
 		if filters.get("include_default_book_entries"):
-			additional_conditions.append(
-				"(finance_book in (%(finance_book)s, %(company_fb)s, '') OR finance_book IS NULL)"
-			)
+			if filters.get("finance_book"):
+				if filters.get("company_fb") and cstr(filters.get("finance_book")) != cstr(
+					filters.get("company_fb")
+				):
+					frappe.throw(
+						_("To use a different finance book, please uncheck 'Include Default Book Entries'")
+					)
+				else:
+					additional_conditions.append(
+						"(finance_book in (%(finance_book)s, '') OR finance_book IS NULL)"
+					)
+			else:
+				additional_conditions.append("(finance_book in (%(company_fb)s, '') OR finance_book IS NULL)")
 		else:
-			additional_conditions.append("(finance_book in (%(finance_book)s, '') OR finance_book IS NULL)")
+			if filters.get("finance_book"):
+				additional_conditions.append(
+					"(finance_book in (%(finance_book)s, '') OR finance_book IS NULL)"
+				)
+			else:
+				additional_conditions.append("(finance_book in ('') OR finance_book IS NULL)")
 
 	if accounting_dimensions:
 		for dimension in accounting_dimensions:

erpnext/accounts/report/general_ledger/general_ledger.js

@@ -176,7 +176,8 @@ frappe.query_reports["General Ledger"] = {
 		{
 			"fieldname": "include_default_book_entries",
 			"label": __("Include Default Book Entries"),
-			"fieldtype": "Check"
+			"fieldtype": "Check",
+			"default": 1
 		},
 		{
 			"fieldname": "show_cancelled_entries",

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -287,13 +287,23 @@ def get_conditions(filters):
 	if filters.get("project"):
 		conditions.append("project in %(project)s")
 
-	if filters.get("finance_book"):
-		if filters.get("include_default_book_entries"):
-			conditions.append(
-				"(finance_book in (%(finance_book)s, %(company_fb)s, '') OR finance_book IS NULL)"
-			)
+	if filters.get("include_default_book_entries"):
+		if filters.get("finance_book"):
+			if filters.get("company_fb") and cstr(filters.get("finance_book")) != cstr(
+				filters.get("company_fb")
+			):
+				frappe.throw(
+					_("To use a different finance book, please uncheck 'Include Default Book Entries'")
+				)
+			else:
+				conditions.append("(finance_book in (%(finance_book)s, '') OR finance_book IS NULL)")
 		else:
-			conditions.append("finance_book in (%(finance_book)s)")
+			conditions.append("(finance_book in (%(company_fb)s, '') OR finance_book IS NULL)")
+	else:
+		if filters.get("finance_book"):
+			conditions.append("(finance_book in (%(finance_book)s, '') OR finance_book IS NULL)")
+		else:
+			conditions.append("(finance_book in ('') OR finance_book IS NULL)")
 
 	if not filters.get("show_cancelled_entries"):
 		conditions.append("is_cancelled = 0")

erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py

@@ -125,12 +125,14 @@ def get_revenue(data, period_list, include_in_gross=1):
 
 	data_to_be_removed = True
 	while data_to_be_removed:
-		revenue, data_to_be_removed = remove_parent_with_no_child(revenue, period_list)
-	revenue = adjust_account(revenue, period_list)
+		revenue, data_to_be_removed = remove_parent_with_no_child(revenue)
+
+	adjust_account_totals(revenue, period_list)
+
 	return copy.deepcopy(revenue)
 
 
-def remove_parent_with_no_child(data, period_list):
+def remove_parent_with_no_child(data):
 	data_to_be_removed = False
 	for parent in data:
 		if "is_group" in parent and parent.get("is_group") == 1:
@@ -147,16 +149,19 @@ def remove_parent_with_no_child(data, period_list):
 	return data, data_to_be_removed
 
 
-def adjust_account(data, period_list, consolidated=False):
-	leaf_nodes = [item for item in data if item["is_group"] == 0]
+def adjust_account_totals(data, period_list):
 	totals = {}
-	for node in leaf_nodes:
-		set_total(node, node["total"], data, totals)
-	for d in data:
-		for period in period_list:
-			key = period if consolidated else period.key
-			d["total"] = totals[d["account"]]
-	return data
+	for d in reversed(data):
+		if d.get("is_group"):
+			for period in period_list:
+				# reset totals for group accounts as totals set by get_data doesn't consider include_in_gross check
+				d[period.key] = sum(
+					item[period.key] for item in data if item.get("parent_account") == d.get("account")
+				)
+		else:
+			set_total(d, d["total"], data, totals)
+
+		d["total"] = totals[d["account"]]
 
 
 def set_total(node, value, complete_list, totals):
@@ -191,6 +196,9 @@ def get_profit(
 
 		if profit_loss[key]:
 			has_value = True
+			if not profit_loss.get("total"):
+				profit_loss["total"] = 0
+			profit_loss["total"] += profit_loss[key]
 
 	if has_value:
 		return profit_loss
@@ -229,6 +237,9 @@ def get_net_profit(
 
 		if profit_loss[key]:
 			has_value = True
+			if not profit_loss.get("total"):
+				profit_loss["total"] = 0
+			profit_loss["total"] += profit_loss[key]
 
 	if has_value:
 		return profit_loss

erpnext/accounts/report/gross_profit/gross_profit.py

@@ -1,6 +1,7 @@
 # Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
 # License: GNU General Public License v3. See license.txt
 
+from collections import OrderedDict
 
 import frappe
 from frappe import _, qb, scrub
@@ -456,6 +457,8 @@ class GrossProfitGenerator(object):
 						new_row.qty += flt(row.qty)
 						new_row.buying_amount += flt(row.buying_amount, self.currency_precision)
 						new_row.base_amount += flt(row.base_amount, self.currency_precision)
+						if self.filters.get("group_by") == "Sales Person":
+							new_row.allocated_amount += flt(row.allocated_amount, self.currency_precision)
 				new_row = self.set_average_rate(new_row)
 				self.grouped_data.append(new_row)
 			else:
@@ -666,7 +669,7 @@ class GrossProfitGenerator(object):
 	def load_invoice_items(self):
 		conditions = ""
 		if self.filters.company:
-			conditions += " and company = %(company)s"
+			conditions += " and `tabSales Invoice`.company = %(company)s"
 		if self.filters.from_date:
 			conditions += " and posting_date >= %(from_date)s"
 		if self.filters.to_date:
@@ -760,30 +763,30 @@ class GrossProfitGenerator(object):
 		Turns list of Sales Invoice Items to a tree of Sales Invoices with their Items as children.
 		"""
 
-		parents = []
+		grouped = OrderedDict()
 
 		for row in self.si_list:
-			if row.parent not in parents:
-				parents.append(row.parent)
+			# initialize list with a header row for each new parent
+			grouped.setdefault(row.parent, [self.get_invoice_row(row)]).append(
+				row.update(
+					{"indent": 1.0, "parent_invoice": row.parent, "invoice_or_item": row.item_code}
+				)  # descendant rows will have indent: 1.0 or greater
+			)
 
-		parents_index = 0
-		for index, row in enumerate(self.si_list):
-			if parents_index < len(parents) and row.parent == parents[parents_index]:
-				invoice = self.get_invoice_row(row)
-				self.si_list.insert(index, invoice)
-				parents_index += 1
+			# if item is a bundle, add it's components as seperate rows
+			if frappe.db.exists("Product Bundle", row.item_code):
+				bundled_items = self.get_bundle_items(row)
+				for x in bundled_items:
+					bundle_item = self.get_bundle_item_row(row, x)
+					grouped.get(row.parent).append(bundle_item)
 
-			else:
-				# skipping the bundle items rows
-				if not row.indent:
-					row.indent = 1.0
-					row.parent_invoice = row.parent
-					row.invoice_or_item = row.item_code
+		self.si_list.clear()
 
-					if frappe.db.exists("Product Bundle", row.item_code):
-						self.add_bundle_items(row, index)
+		for items in grouped.values():
+			self.si_list.extend(items)
 
 	def get_invoice_row(self, row):
+		# header row format
 		return frappe._dict(
 			{
 				"parent_invoice": "",
@@ -812,13 +815,6 @@ class GrossProfitGenerator(object):
 			}
 		)
 
-	def add_bundle_items(self, product_bundle, index):
-		bundle_items = self.get_bundle_items(product_bundle)
-
-		for i, item in enumerate(bundle_items):
-			bundle_item = self.get_bundle_item_row(product_bundle, item)
-			self.si_list.insert((index + i + 1), bundle_item)
-
 	def get_bundle_items(self, product_bundle):
 		return frappe.get_all(
 			"Product Bundle Item", filters={"parent": product_bundle.item_code}, fields=["item_code", "qty"]

erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py

@@ -87,7 +87,7 @@ def _execute(filters=None, additional_table_columns=None, additional_query_colum
 				"project": d.project,
 				"company": d.company,
 				"purchase_order": d.purchase_order,
-				"purchase_receipt": d.purchase_receipt,
+				"purchase_receipt": purchase_receipt,
 				"expense_account": expense_account,
 				"stock_qty": d.stock_qty,
 				"stock_uom": d.stock_uom,
@@ -241,7 +241,7 @@ def get_columns(additional_table_columns, filters):
 		},
 		{
 			"label": _("Purchase Receipt"),
-			"fieldname": "Purchase Receipt",
+			"fieldname": "purchase_receipt",
 			"fieldtype": "Link",
 			"options": "Purchase Receipt",
 			"width": 100,

erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py

@@ -399,8 +399,9 @@ def get_items(filters, additional_query_columns, additional_conditions=None):
 			`tabSales Invoice`.posting_date, `tabSales Invoice`.debit_to,
 			`tabSales Invoice`.unrealized_profit_loss_account,
 			`tabSales Invoice`.is_internal_customer,
-			`tabSales Invoice`.project, `tabSales Invoice`.customer, `tabSales Invoice`.remarks,
+			`tabSales Invoice`.customer, `tabSales Invoice`.remarks,
 			`tabSales Invoice`.territory, `tabSales Invoice`.company, `tabSales Invoice`.base_net_total,
+			`tabSales Invoice Item`.project,
 			`tabSales Invoice Item`.item_code, `tabSales Invoice Item`.description,
 			`tabSales Invoice Item`.`item_name`, `tabSales Invoice Item`.`item_group`,
 			`tabSales Invoice Item`.sales_order, `tabSales Invoice Item`.delivery_note,

erpnext/accounts/report/trial_balance/trial_balance.py

@@ -157,12 +157,25 @@ def get_rootwise_opening_balances(filters, report_type):
 	if filters.project:
 		additional_conditions += " and project = %(project)s"
 
+	company_fb = frappe.db.get_value("Company", filters.company, "default_finance_book")
+
 	if filters.get("include_default_book_entries"):
-		additional_conditions += (
-			" AND (finance_book in (%(finance_book)s, %(company_fb)s, '') OR finance_book IS NULL)"
-		)
+		if filters.get("finance_book"):
+			if company_fb and cstr(filters.get("finance_book")) != cstr(company_fb):
+				frappe.throw(
+					_("To use a different finance book, please uncheck 'Include Default Book Entries'")
+				)
+			else:
+				additional_conditions += (
+					" AND (finance_book in (%(finance_book)s, '') OR finance_book IS NULL)"
+				)
+		else:
+			additional_conditions += " AND (finance_book in (%(company_fb)s, '') OR finance_book IS NULL)"
 	else:
-		additional_conditions += " AND (finance_book in (%(finance_book)s, '') OR finance_book IS NULL)"
+		if filters.get("finance_book"):
+			additional_conditions += " AND (finance_book in (%(finance_book)s, '') OR finance_book IS NULL)"
+		else:
+			additional_conditions += " AND (finance_book in ('') OR finance_book IS NULL)"
 
 	accounting_dimensions = get_accounting_dimensions(as_list=False)
 
@@ -174,7 +187,7 @@ def get_rootwise_opening_balances(filters, report_type):
 		"year_start_date": filters.year_start_date,
 		"project": filters.project,
 		"finance_book": filters.finance_book,
-		"company_fb": frappe.db.get_value("Company", filters.company, "default_finance_book"),
+		"company_fb": company_fb,
 	}
 
 	if accounting_dimensions:

erpnext/accounts/utils.py

@@ -537,6 +537,10 @@ def update_reference_in_journal_entry(d, journal_entry, do_not_save=False):
 	"""
 	jv_detail = journal_entry.get("accounts", {"name": d["voucher_detail_no"]})[0]
 
+	# Update Advance Paid in SO/PO since they might be getting unlinked
+	if jv_detail.get("reference_type") in ("Sales Order", "Purchase Order"):
+		frappe.get_doc(jv_detail.reference_type, jv_detail.reference_name).set_total_advance_paid()
+
 	if flt(d["unadjusted_amount"]) - flt(d["allocated_amount"]) != 0:
 		# adjust the unreconciled balance
 		amount_in_account_currency = flt(d["unadjusted_amount"]) - flt(d["allocated_amount"])
@@ -596,6 +600,13 @@ def update_reference_in_payment_entry(d, payment_entry, do_not_save=False):
 
 	if d.voucher_detail_no:
 		existing_row = payment_entry.get("references", {"name": d["voucher_detail_no"]})[0]
+
+		# Update Advance Paid in SO/PO since they are getting unlinked
+		if existing_row.get("reference_doctype") in ("Sales Order", "Purchase Order"):
+			frappe.get_doc(
+				existing_row.reference_doctype, existing_row.reference_name
+			).set_total_advance_paid()
+
 		original_row = existing_row.as_dict().copy()
 		existing_row.update(reference_details)
 
@@ -810,7 +821,7 @@ def get_held_invoices(party_type, party):
 
 	if party_type == "Supplier":
 		held_invoices = frappe.db.sql(
-			"select name from `tabPurchase Invoice` where release_date IS NOT NULL and release_date > CURDATE()",
+			"select name from `tabPurchase Invoice` where on_hold = 1 and release_date IS NOT NULL and release_date > CURDATE()",
 			as_dict=1,
 		)
 		held_invoices = set(d["name"] for d in held_invoices)

erpnext/assets/doctype/asset/asset.py

@@ -27,6 +27,7 @@ from erpnext.accounts.general_ledger import make_reverse_gl_entries
 from erpnext.assets.doctype.asset.depreciation import (
 	get_depreciation_accounts,
 	get_disposal_account_and_cost_center,
+	is_first_day_of_the_month,
 	is_last_day_of_the_month,
 )
 from erpnext.assets.doctype.asset_category.asset_category import get_asset_category_account
@@ -40,6 +41,7 @@ class Asset(AccountsController):
 		self.validate_item()
 		self.validate_cost_center()
 		self.set_missing_values()
+		self.validate_finance_books()
 		self.prepare_depreciation_data()
 		self.validate_gross_and_purchase_amount()
 		if self.get("schedules"):
@@ -147,17 +149,33 @@ class Asset(AccountsController):
 			frappe.throw(_("Item {0} must be a non-stock item").format(self.item_code))
 
 	def validate_cost_center(self):
-		if not self.cost_center:
-			return
-
-		cost_center_company = frappe.db.get_value("Cost Center", self.cost_center, "company")
-		if cost_center_company != self.company:
-			frappe.throw(
-				_("Selected Cost Center {} doesn't belongs to {}").format(
-					frappe.bold(self.cost_center), frappe.bold(self.company)
-				),
-				title=_("Invalid Cost Center"),
+		if self.cost_center:
+			cost_center_company, cost_center_is_group = frappe.db.get_value(
+				"Cost Center", self.cost_center, ["company", "is_group"]
 			)
+			if cost_center_company != self.company:
+				frappe.throw(
+					_("Cost Center {} doesn't belong to Company {}").format(
+						frappe.bold(self.cost_center), frappe.bold(self.company)
+					),
+					title=_("Invalid Cost Center"),
+				)
+			if cost_center_is_group:
+				frappe.throw(
+					_(
+						"Cost Center {} is a group cost center and group cost centers cannot be used in transactions"
+					).format(frappe.bold(self.cost_center)),
+					title=_("Invalid Cost Center"),
+				)
+
+		else:
+			if not frappe.get_cached_value("Company", self.company, "depreciation_cost_center"):
+				frappe.throw(
+					_(
+						"Please set a Cost Center for the Asset or set an Asset Depreciation Cost Center for the Company {}"
+					).format(frappe.bold(self.company)),
+					title=_("Missing Cost Center"),
+				)
 
 	def validate_in_use_date(self):
 		if not self.available_for_use_date:
@@ -180,6 +198,27 @@ class Asset(AccountsController):
 			finance_books = get_item_details(self.item_code, self.asset_category)
 			self.set("finance_books", finance_books)
 
+	def validate_finance_books(self):
+		if not self.calculate_depreciation or len(self.finance_books) == 1:
+			return
+
+		finance_books = set()
+
+		for d in self.finance_books:
+			if d.finance_book in finance_books:
+				frappe.throw(
+					_("Row #{}: Please use a different Finance Book.").format(d.idx),
+					title=_("Duplicate Finance Book"),
+				)
+			else:
+				finance_books.add(d.finance_book)
+
+			if not d.finance_book:
+				frappe.throw(
+					_("Row #{}: Finance Book should not be empty since you're using multiple.").format(d.idx),
+					title=_("Missing Finance Book"),
+				)
+
 	def validate_asset_values(self):
 		if not self.asset_category:
 			self.asset_category = frappe.get_cached_value("Item", self.item_code, "asset_category")
@@ -339,13 +378,9 @@ class Asset(AccountsController):
 					if should_get_last_day:
 						schedule_date = get_last_day(schedule_date)
 
-					# schedule date will be a year later from start date
-					# so monthly schedule date is calculated by removing 11 months from it
-					monthly_schedule_date = add_months(schedule_date, -finance_book.frequency_of_depreciation + 1)
-
 				# if asset is being sold
 				if date_of_disposal:
-					from_date = self.get_from_date(finance_book.finance_book)
+					from_date = self.get_from_date_for_disposal(finance_book)
 					depreciation_amount, days, months = self.get_pro_rata_amt(
 						finance_book,
 						depreciation_amount,
@@ -369,9 +404,9 @@ class Asset(AccountsController):
 
 				# For first row
 				if (
-					(has_pro_rata or has_wdv_or_dd_non_yearly_pro_rata)
+					n == 0
+					and (has_pro_rata or has_wdv_or_dd_non_yearly_pro_rata)
 					and not self.opening_accumulated_depreciation
-					and n == 0
 				):
 					from_date = add_days(
 						self.available_for_use_date, -1
@@ -383,10 +418,26 @@ class Asset(AccountsController):
 						finance_book.depreciation_start_date,
 						has_wdv_or_dd_non_yearly_pro_rata,
 					)
-
-					# For first depr schedule date will be the start date
-					# so monthly schedule date is calculated by removing month difference between use date and start date
-					monthly_schedule_date = add_months(finance_book.depreciation_start_date, -months + 1)
+				elif n == 0 and has_wdv_or_dd_non_yearly_pro_rata and self.opening_accumulated_depreciation:
+					if not is_first_day_of_the_month(getdate(self.available_for_use_date)):
+						from_date = get_last_day(
+							add_months(
+								getdate(self.available_for_use_date),
+								((self.number_of_depreciations_booked - 1) * finance_book.frequency_of_depreciation),
+							)
+						)
+					else:
+						from_date = add_months(
+							getdate(add_days(self.available_for_use_date, -1)),
+							(self.number_of_depreciations_booked * finance_book.frequency_of_depreciation),
+						)
+					depreciation_amount, days, months = self.get_pro_rata_amt(
+						finance_book,
+						depreciation_amount,
+						from_date,
+						finance_book.depreciation_start_date,
+						has_wdv_or_dd_non_yearly_pro_rata,
+					)
 
 				# For last row
 				elif has_pro_rata and n == cint(number_of_pending_depreciations) - 1:
@@ -411,9 +462,7 @@ class Asset(AccountsController):
 						depreciation_amount_without_pro_rata, depreciation_amount, finance_book.finance_book
 					)
 
-					monthly_schedule_date = add_months(schedule_date, 1)
 					schedule_date = add_days(schedule_date, days)
-					last_schedule_date = schedule_date
 
 				if not depreciation_amount:
 					continue
@@ -432,7 +481,7 @@ class Asset(AccountsController):
 					)
 					skip_row = True
 
-				if depreciation_amount > 0:
+				if flt(depreciation_amount, self.precision("gross_purchase_amount")) > 0:
 					self.append(
 						"schedules",
 						{
@@ -490,16 +539,19 @@ class Asset(AccountsController):
 		for idx, s in enumerate(self.schedules, 1):
 			s.idx = idx
 
-	def get_from_date(self, finance_book):
+	def get_from_date_for_disposal(self, finance_book):
 		if not self.get("schedules"):
-			return self.available_for_use_date
+			return add_months(
+				getdate(self.available_for_use_date),
+				(self.number_of_depreciations_booked * finance_book.frequency_of_depreciation),
+			)
 
 		if len(self.finance_books) == 1:
 			return self.schedules[-1].schedule_date
 
 		from_date = ""
 		for schedule in self.get("schedules"):
-			if schedule.finance_book == finance_book:
+			if schedule.finance_book == finance_book.finance_book:
 				from_date = schedule.schedule_date
 
 		if from_date:
@@ -1281,9 +1333,11 @@ def get_straight_line_or_manual_depr_amount(asset, row):
 		)
 	# if the Depreciation Schedule is being prepared for the first time
 	else:
-		return (flt(asset.gross_purchase_amount) - flt(row.expected_value_after_useful_life)) / flt(
-			row.total_number_of_depreciations
-		)
+		return (
+			flt(asset.gross_purchase_amount)
+			- flt(asset.opening_accumulated_depreciation)
+			- flt(row.expected_value_after_useful_life)
+		) / flt(row.total_number_of_depreciations - asset.number_of_depreciations_booked)
 
 
 def get_wdv_or_dd_depr_amount(

erpnext/assets/doctype/asset/depreciation.py

@@ -8,6 +8,7 @@ from frappe.utils import (
 	add_months,
 	cint,
 	flt,
+	get_first_day,
 	get_last_day,
 	get_link_to_form,
 	getdate,
@@ -32,6 +33,7 @@ def post_depreciation_entries(date=None):
 		date = today()
 
 	failed_asset_names = []
+	error_log_names = []
 
 	for asset_name in get_depreciable_assets(date):
 		try:
@@ -40,10 +42,12 @@ def post_depreciation_entries(date=None):
 		except Exception as e:
 			frappe.db.rollback()
 			failed_asset_names.append(asset_name)
+			error_log = frappe.log_error(e)
+			error_log_names.append(error_log.name)
 
 	if failed_asset_names:
 		set_depr_entry_posting_status_for_failed_assets(failed_asset_names)
-		notify_depr_entry_posting_error(failed_asset_names)
+		notify_depr_entry_posting_error(failed_asset_names, error_log_names)
 
 	frappe.db.commit()
 
@@ -135,15 +139,15 @@ def make_depreciation_entry(asset_name, date=None):
 			je.flags.ignore_permissions = True
 			je.flags.planned_depr_entry = True
 			je.save()
-			if not je.meta.get_workflow():
-				je.submit()
 
 			d.db_set("journal_entry", je.name)
 
-			idx = cint(d.finance_book_id)
-			finance_books = asset.get("finance_books")[idx - 1]
-			finance_books.value_after_depreciation -= d.depreciation_amount
-			finance_books.db_update()
+			if not je.meta.get_workflow():
+				je.submit()
+				idx = cint(d.finance_book_id)
+				finance_books = asset.get("finance_books")[idx - 1]
+				finance_books.value_after_depreciation -= d.depreciation_amount
+				finance_books.db_update()
 
 	asset.db_set("depr_entry_posting_status", "Successful")
 
@@ -215,7 +219,7 @@ def set_depr_entry_posting_status_for_failed_assets(failed_asset_names):
 		frappe.db.set_value("Asset", asset_name, "depr_entry_posting_status", "Failed")
 
 
-def notify_depr_entry_posting_error(failed_asset_names):
+def notify_depr_entry_posting_error(failed_asset_names, error_log_names):
 	recipients = get_users_with_role("Accounts Manager")
 
 	if not recipients:
@@ -223,7 +227,8 @@ def notify_depr_entry_posting_error(failed_asset_names):
 
 	subject = _("Error while posting depreciation entries")
 
-	asset_links = get_comma_separated_asset_links(failed_asset_names)
+	asset_links = get_comma_separated_links(failed_asset_names, "Asset")
+	error_log_links = get_comma_separated_links(error_log_names, "Error Log")
 
 	message = (
 		_("Hello,")
@@ -233,23 +238,26 @@ def notify_depr_entry_posting_error(failed_asset_names):
 		)
 		+ "."
 		+ "<br><br>"
-		+ _(
-			"Please raise a support ticket and share this email, or forward this email to your development team so that they can find the issue in the developer console by manually creating the depreciation entry via the asset's depreciation schedule table."
+		+ _("Here are the error logs for the aforementioned failed depreciation entries: {0}").format(
+			error_log_links
 		)
+		+ "."
+		+ "<br><br>"
+		+ _("Please share this email with your support team so that they can find and fix the issue.")
 	)
 
 	frappe.sendmail(recipients=recipients, subject=subject, message=message)
 
 
-def get_comma_separated_asset_links(asset_names):
-	asset_links = []
+def get_comma_separated_links(names, doctype):
+	links = []
 
-	for asset_name in asset_names:
-		asset_links.append(get_link_to_form("Asset", asset_name))
+	for name in names:
+		links.append(get_link_to_form(doctype, name))
 
-	asset_links = ", ".join(asset_links)
+	links = ", ".join(links)
 
-	return asset_links
+	return links
 
 
 @frappe.whitelist()
@@ -279,7 +287,7 @@ def scrap_asset(asset_name):
 	je.company = asset.company
 	je.remark = "Scrap Entry for asset {0}".format(asset_name)
 
-	for entry in get_gl_entries_on_asset_disposal(asset):
+	for entry in get_gl_entries_on_asset_disposal(asset, date):
 		entry.update({"reference_type": "Asset", "reference_name": asset_name})
 		je.append("accounts", entry)
 
@@ -343,6 +351,9 @@ def modify_depreciation_schedule_for_asset_repairs(asset):
 def reverse_depreciation_entry_made_after_disposal(asset, date):
 	from erpnext.accounts.doctype.journal_entry.journal_entry import make_reverse_journal_entry
 
+	if not asset.calculate_depreciation:
+		return
+
 	row = -1
 	finance_book = asset.get("schedules")[0].get("finance_book")
 	for schedule in asset.get("schedules"):
@@ -403,7 +414,10 @@ def disposal_happens_in_the_future(posting_date_of_disposal):
 	return False
 
 
-def get_gl_entries_on_asset_regain(asset, selling_amount=0, finance_book=None):
+def get_gl_entries_on_asset_regain(asset, selling_amount=0, finance_book=None, date=None):
+	if not date:
+		date = getdate()
+
 	(
 		fixed_asset_account,
 		asset,
@@ -420,23 +434,30 @@ def get_gl_entries_on_asset_regain(asset, selling_amount=0, finance_book=None):
 			"debit_in_account_currency": asset.gross_purchase_amount,
 			"debit": asset.gross_purchase_amount,
 			"cost_center": depreciation_cost_center,
+			"posting_date": date,
 		},
 		{
 			"account": accumulated_depr_account,
 			"credit_in_account_currency": accumulated_depr_amount,
 			"credit": accumulated_depr_amount,
 			"cost_center": depreciation_cost_center,
+			"posting_date": date,
 		},
 	]
 
 	profit_amount = abs(flt(value_after_depreciation)) - abs(flt(selling_amount))
 	if profit_amount:
-		get_profit_gl_entries(profit_amount, gl_entries, disposal_account, depreciation_cost_center)
+		get_profit_gl_entries(
+			profit_amount, gl_entries, disposal_account, depreciation_cost_center, date
+		)
 
 	return gl_entries
 
 
-def get_gl_entries_on_asset_disposal(asset, selling_amount=0, finance_book=None):
+def get_gl_entries_on_asset_disposal(asset, selling_amount=0, finance_book=None, date=None):
+	if not date:
+		date = getdate()
+
 	(
 		fixed_asset_account,
 		asset,
@@ -453,18 +474,26 @@ def get_gl_entries_on_asset_disposal(asset, selling_amount=0, finance_book=None)
 			"credit_in_account_currency": asset.gross_purchase_amount,
 			"credit": asset.gross_purchase_amount,
 			"cost_center": depreciation_cost_center,
-		},
-		{
-			"account": accumulated_depr_account,
-			"debit_in_account_currency": accumulated_depr_amount,
-			"debit": accumulated_depr_amount,
-			"cost_center": depreciation_cost_center,
+			"posting_date": date,
 		},
 	]
 
+	if accumulated_depr_amount:
+		gl_entries.append(
+			{
+				"account": accumulated_depr_account,
+				"debit_in_account_currency": accumulated_depr_amount,
+				"debit": accumulated_depr_amount,
+				"cost_center": depreciation_cost_center,
+				"posting_date": date,
+			},
+		)
+
 	profit_amount = flt(selling_amount) - flt(value_after_depreciation)
 	if profit_amount:
-		get_profit_gl_entries(profit_amount, gl_entries, disposal_account, depreciation_cost_center)
+		get_profit_gl_entries(
+			profit_amount, gl_entries, disposal_account, depreciation_cost_center, date
+		)
 
 	return gl_entries
 
@@ -491,7 +520,12 @@ def get_asset_details(asset, finance_book=None):
 	)
 
 
-def get_profit_gl_entries(profit_amount, gl_entries, disposal_account, depreciation_cost_center):
+def get_profit_gl_entries(
+	profit_amount, gl_entries, disposal_account, depreciation_cost_center, date=None
+):
+	if not date:
+		date = getdate()
+
 	debit_or_credit = "debit" if profit_amount < 0 else "credit"
 	gl_entries.append(
 		{
@@ -499,6 +533,7 @@ def get_profit_gl_entries(profit_amount, gl_entries, disposal_account, depreciat
 			"cost_center": depreciation_cost_center,
 			debit_or_credit: abs(profit_amount),
 			debit_or_credit + "_in_account_currency": abs(profit_amount),
+			"posting_date": date,
 		}
 	)
 
@@ -523,3 +558,9 @@ def is_last_day_of_the_month(date):
 	last_day_of_the_month = get_last_day(date)
 
 	return getdate(last_day_of_the_month) == getdate(date)
+
+
+def is_first_day_of_the_month(date):
+	first_day_of_the_month = get_first_day(date)
+
+	return getdate(first_day_of_the_month) == getdate(date)

erpnext/assets/doctype/asset/test_asset.py

@@ -298,6 +298,79 @@ class TestAsset(AssetSetup):
 		si.cancel()
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "status"), "Partially Depreciated")
 
+	def test_gle_made_by_asset_sale_for_existing_asset(self):
+		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+
+		asset = create_asset(
+			calculate_depreciation=1,
+			available_for_use_date="2020-04-01",
+			purchase_date="2020-04-01",
+			expected_value_after_useful_life=0,
+			total_number_of_depreciations=5,
+			number_of_depreciations_booked=2,
+			frequency_of_depreciation=12,
+			depreciation_start_date="2023-03-31",
+			opening_accumulated_depreciation=24000,
+			gross_purchase_amount=60000,
+			submit=1,
+		)
+
+		expected_depr_values = [
+			["2023-03-31", 12000, 36000],
+			["2024-03-31", 12000, 48000],
+			["2025-03-31", 12000, 60000],
+		]
+
+		for i, schedule in enumerate(asset.schedules):
+			self.assertEqual(getdate(expected_depr_values[i][0]), schedule.schedule_date)
+			self.assertEqual(expected_depr_values[i][1], schedule.depreciation_amount)
+			self.assertEqual(expected_depr_values[i][2], schedule.accumulated_depreciation_amount)
+
+		post_depreciation_entries(date="2023-03-31")
+
+		si = create_sales_invoice(
+			item_code="Macbook Pro", asset=asset.name, qty=1, rate=40000, posting_date=getdate("2023-05-23")
+		)
+		asset.load_from_db()
+
+		self.assertEqual(frappe.db.get_value("Asset", asset.name, "status"), "Sold")
+
+		expected_values = [["2023-03-31", 12000, 36000], ["2023-05-23", 1742.47, 37742.47]]
+
+		for i, schedule in enumerate(asset.schedules):
+			self.assertEqual(getdate(expected_values[i][0]), schedule.schedule_date)
+			self.assertEqual(expected_values[i][1], schedule.depreciation_amount)
+			self.assertEqual(expected_values[i][2], schedule.accumulated_depreciation_amount)
+			self.assertTrue(schedule.journal_entry)
+
+		expected_gle = (
+			(
+				"_Test Accumulated Depreciations - _TC",
+				37742.47,
+				0.0,
+			),
+			(
+				"_Test Fixed Asset - _TC",
+				0.0,
+				60000.0,
+			),
+			(
+				"_Test Gain/Loss on Asset Disposal - _TC",
+				0.0,
+				17742.47,
+			),
+			("Debtors - _TC", 40000.0, 0.0),
+		)
+
+		gle = frappe.db.sql(
+			"""select account, debit, credit from `tabGL Entry`
+			where voucher_type='Sales Invoice' and voucher_no = %s
+			order by account""",
+			si.name,
+		)
+
+		self.assertSequenceEqual(gle, expected_gle)
+
 	def test_asset_with_maintenance_required_status_after_sale(self):
 		asset = create_asset(
 			calculate_depreciation=1,
@@ -569,7 +642,7 @@ class TestDepreciationMethods(AssetSetup):
 		)
 
 		self.assertEqual(asset.status, "Draft")
-		expected_schedules = [["2032-12-31", 30000.0, 77095.89], ["2033-06-06", 12904.11, 90000.0]]
+		expected_schedules = [["2032-12-31", 42904.11, 90000.0]]
 		schedules = [
 			[cstr(d.schedule_date), flt(d.depreciation_amount, 2), d.accumulated_depreciation_amount]
 			for d in asset.get("schedules")
@@ -613,14 +686,14 @@ class TestDepreciationMethods(AssetSetup):
 			number_of_depreciations_booked=1,
 			opening_accumulated_depreciation=50000,
 			expected_value_after_useful_life=10000,
-			depreciation_start_date="2030-12-31",
+			depreciation_start_date="2031-12-31",
 			total_number_of_depreciations=3,
 			frequency_of_depreciation=12,
 		)
 
 		self.assertEqual(asset.status, "Draft")
 
-		expected_schedules = [["2030-12-31", 33333.50, 83333.50], ["2031-12-31", 6666.50, 90000.0]]
+		expected_schedules = [["2031-12-31", 33333.50, 83333.50], ["2032-12-31", 6666.50, 90000.0]]
 
 		schedules = [
 			[cstr(d.schedule_date), d.depreciation_amount, d.accumulated_depreciation_amount]
@@ -1214,6 +1287,7 @@ class TestDepreciationBasics(AssetSetup):
 		asset.append(
 			"finance_books",
 			{
+				"finance_book": "Test Finance Book 1",
 				"depreciation_method": "Straight Line",
 				"frequency_of_depreciation": 1,
 				"total_number_of_depreciations": 3,
@@ -1224,6 +1298,7 @@ class TestDepreciationBasics(AssetSetup):
 		asset.append(
 			"finance_books",
 			{
+				"finance_book": "Test Finance Book 2",
 				"depreciation_method": "Straight Line",
 				"frequency_of_depreciation": 1,
 				"total_number_of_depreciations": 6,
@@ -1234,6 +1309,7 @@ class TestDepreciationBasics(AssetSetup):
 		asset.append(
 			"finance_books",
 			{
+				"finance_book": "Test Finance Book 3",
 				"depreciation_method": "Straight Line",
 				"frequency_of_depreciation": 12,
 				"total_number_of_depreciations": 3,
@@ -1263,6 +1339,7 @@ class TestDepreciationBasics(AssetSetup):
 		asset.append(
 			"finance_books",
 			{
+				"finance_book": "Test Finance Book 1",
 				"depreciation_method": "Straight Line",
 				"frequency_of_depreciation": 12,
 				"total_number_of_depreciations": 3,
@@ -1273,6 +1350,7 @@ class TestDepreciationBasics(AssetSetup):
 		asset.append(
 			"finance_books",
 			{
+				"finance_book": "Test Finance Book 2",
 				"depreciation_method": "Straight Line",
 				"frequency_of_depreciation": 12,
 				"total_number_of_depreciations": 6,
@@ -1508,6 +1586,15 @@ def create_asset_data():
 	if not frappe.db.exists("Location", "Test Location"):
 		frappe.get_doc({"doctype": "Location", "location_name": "Test Location"}).insert()
 
+	if not frappe.db.exists("Finance Book", "Test Finance Book 1"):
+		frappe.get_doc({"doctype": "Finance Book", "finance_book_name": "Test Finance Book 1"}).insert()
+
+	if not frappe.db.exists("Finance Book", "Test Finance Book 2"):
+		frappe.get_doc({"doctype": "Finance Book", "finance_book_name": "Test Finance Book 2"}).insert()
+
+	if not frappe.db.exists("Finance Book", "Test Finance Book 3"):
+		frappe.get_doc({"doctype": "Finance Book", "finance_book_name": "Test Finance Book 3"}).insert()
+
 
 def create_asset(**args):
 	args = frappe._dict(args)

erpnext/assets/doctype/asset_category/asset_category.js

@@ -33,6 +33,7 @@ frappe.ui.form.on('Asset Category', {
 			var d  = locals[cdt][cdn];
 			return {
 				"filters": {
+					"account_type": "Depreciation",
 					"root_type": ["in", ["Expense", "Income"]],
 					"is_group": 0,
 					"company": d.company_name

erpnext/assets/doctype/asset_category/asset_category.py

@@ -53,7 +53,7 @@ class AssetCategory(Document):
 		account_type_map = {
 			"fixed_asset_account": {"account_type": ["Fixed Asset"]},
 			"accumulated_depreciation_account": {"account_type": ["Accumulated Depreciation"]},
-			"depreciation_expense_account": {"root_type": ["Expense", "Income"]},
+			"depreciation_expense_account": {"account_type": ["Depreciation"]},
 			"capital_work_in_progress_account": {"account_type": ["Capital Work in Progress"]},
 		}
 		for d in self.accounts:
@@ -96,7 +96,6 @@ class AssetCategory(Document):
 				frappe.throw(msg, title=_("Missing Account"))
 
 
-@frappe.whitelist()
 def get_asset_category_account(
 	fieldname, item=None, asset=None, account=None, asset_category=None, company=None
 ):

erpnext/assets/doctype/asset_movement/asset_movement.js

@@ -63,26 +63,28 @@ frappe.ui.form.on('Asset Movement', {
 			fieldnames_to_be_altered = {
 				target_location: { read_only: 0, reqd: 1 },
 				source_location: { read_only: 1, reqd: 0 },
-				from_employee: { read_only: 0, reqd: 1 },
+				from_employee: { read_only: 0, reqd: 0 },
 				to_employee: { read_only: 1, reqd: 0 }
 			};
 		}
 		else if (frm.doc.purpose === 'Issue') {
 			fieldnames_to_be_altered = {
 				target_location: { read_only: 1, reqd: 0 },
-				source_location: { read_only: 1, reqd: 1 },
+				source_location: { read_only: 1, reqd: 0 },
 				from_employee: { read_only: 1, reqd: 0 },
 				to_employee: { read_only: 0, reqd: 1 }
 			};
 		}
-		Object.keys(fieldnames_to_be_altered).forEach(fieldname => {
-			let property_to_be_altered = fieldnames_to_be_altered[fieldname];
-			Object.keys(property_to_be_altered).forEach(property => {
-				let value = property_to_be_altered[property];
-				frm.set_df_property(fieldname, property, value, cdn, 'assets');
+		if (fieldnames_to_be_altered) {
+			Object.keys(fieldnames_to_be_altered).forEach(fieldname => {
+				let property_to_be_altered = fieldnames_to_be_altered[fieldname];
+				Object.keys(property_to_be_altered).forEach(property => {
+					let value = property_to_be_altered[property];
+					frm.fields_dict['assets'].grid.update_docfield_property(fieldname, property, value);
+				});
 			});
-		});
-		frm.refresh_field('assets');
+			frm.refresh_field('assets');
+		}
 	}
 });
 

erpnext/assets/doctype/asset_movement/asset_movement.json

@@ -37,6 +37,7 @@
    "reqd": 1
   },
   {
+   "default": "Now",
    "fieldname": "transaction_date",
    "fieldtype": "Datetime",
    "in_list_view": 1,
@@ -95,10 +96,11 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2021-01-22 12:30:55.295670",
+ "modified": "2023-06-28 16:54:26.571083",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset Movement",
+ "naming_rule": "Expression",
  "owner": "Administrator",
  "permissions": [
   {
@@ -148,5 +150,6 @@
   }
  ],
  "sort_field": "modified",
- "sort_order": "DESC"
+ "sort_order": "DESC",
+ "states": []
 }

erpnext/assets/doctype/asset_movement/asset_movement.py

@@ -28,26 +28,20 @@ class AssetMovement(Document):
 	def validate_location(self):
 		for d in self.assets:
 			if self.purpose in ["Transfer", "Issue"]:
-				if not d.source_location:
-					d.source_location = frappe.db.get_value("Asset", d.asset, "location")
-
-				if not d.source_location:
-					frappe.throw(_("Source Location is required for the Asset {0}").format(d.asset))
-
+				current_location = frappe.db.get_value("Asset", d.asset, "location")
 				if d.source_location:
-					current_location = frappe.db.get_value("Asset", d.asset, "location")
-
 					if current_location != d.source_location:
 						frappe.throw(
 							_("Asset {0} does not belongs to the location {1}").format(d.asset, d.source_location)
 						)
+				else:
+					d.source_location = current_location
 
 			if self.purpose == "Issue":
 				if d.target_location:
 					frappe.throw(
 						_(
-							"Issuing cannot be done to a location. \
-						Please enter employee who has issued Asset {0}"
+							"Issuing cannot be done to a location. Please enter employee to issue the Asset {0} to"
 						).format(d.asset),
 						title="Incorrect Movement Purpose",
 					)
@@ -69,28 +63,19 @@ class AssetMovement(Document):
 					frappe.throw(_("Source and Target Location cannot be same"))
 
 			if self.purpose == "Receipt":
-				# only when asset is bought and first entry is made
-				if not d.source_location and not (d.target_location or d.to_employee):
+				if not (d.source_location) and not (d.target_location or d.to_employee):
 					frappe.throw(
 						_("Target Location or To Employee is required while receiving Asset {0}").format(d.asset)
 					)
 				elif d.source_location:
-					# when asset is received from an employee
-					if d.target_location and not d.from_employee:
-						frappe.throw(
-							_("From employee is required while receiving Asset {0} to a target location").format(
-								d.asset
-							)
-						)
 					if d.from_employee and not d.target_location:
 						frappe.throw(
 							_("Target Location is required while receiving Asset {0} from an employee").format(d.asset)
 						)
-					if d.to_employee and d.target_location:
+					elif d.to_employee and d.target_location:
 						frappe.throw(
 							_(
-								"Asset {0} cannot be received at a location and \
-							given to employee in a single movement"
+								"Asset {0} cannot be received at a location and given to an employee in a single movement"
 							).format(d.asset)
 						)
 
@@ -110,12 +95,12 @@ class AssetMovement(Document):
 				)
 
 	def on_submit(self):
-		self.set_latest_location_in_asset()
+		self.set_latest_location_and_custodian_in_asset()
 
 	def on_cancel(self):
-		self.set_latest_location_in_asset()
+		self.set_latest_location_and_custodian_in_asset()
 
-	def set_latest_location_in_asset(self):
+	def set_latest_location_and_custodian_in_asset(self):
 		current_location, current_employee = "", ""
 		cond = "1=1"
 

erpnext/assets/doctype/asset_movement/test_asset_movement.py

@@ -47,7 +47,7 @@ class TestAssetMovement(unittest.TestCase):
 		if not frappe.db.exists("Location", "Test Location 2"):
 			frappe.get_doc({"doctype": "Location", "location_name": "Test Location 2"}).insert()
 
-		movement1 = create_asset_movement(
+		create_asset_movement(
 			purpose="Transfer",
 			company=asset.company,
 			assets=[
@@ -58,7 +58,7 @@ class TestAssetMovement(unittest.TestCase):
 		)
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location 2")
 
-		create_asset_movement(
+		movement1 = create_asset_movement(
 			purpose="Transfer",
 			company=asset.company,
 			assets=[
@@ -70,21 +70,32 @@ class TestAssetMovement(unittest.TestCase):
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location")
 
 		movement1.cancel()
-		self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location")
+		self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location 2")
 
 		employee = make_employee("testassetmovemp@example.com", company="_Test Company")
 		create_asset_movement(
 			purpose="Issue",
 			company=asset.company,
-			assets=[{"asset": asset.name, "source_location": "Test Location", "to_employee": employee}],
+			assets=[{"asset": asset.name, "source_location": "Test Location 2", "to_employee": employee}],
 			reference_doctype="Purchase Receipt",
 			reference_name=pr.name,
 		)
 
-		# after issuing asset should belong to an employee not at a location
+		# after issuing, asset should belong to an employee not at a location
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), None)
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "custodian"), employee)
 
+		create_asset_movement(
+			purpose="Receipt",
+			company=asset.company,
+			assets=[{"asset": asset.name, "from_employee": employee, "target_location": "Test Location"}],
+			reference_doctype="Purchase Receipt",
+			reference_name=pr.name,
+		)
+
+		# after receiving, asset should belong to a location not at an employee
+		self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location")
+
 	def test_last_movement_cancellation(self):
 		pr = make_purchase_receipt(
 			item_code="Macbook Pro", qty=1, rate=100000.0, location="Test Location"

erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py

@@ -119,7 +119,9 @@ class AssetValueAdjustment(Document):
 			if d.depreciation_method in ("Straight Line", "Manual"):
 				end_date = max(s.schedule_date for s in asset.schedules if cint(s.finance_book_id) == d.idx)
 				total_days = date_diff(end_date, self.date)
-				rate_per_day = flt(d.value_after_depreciation) / flt(total_days)
+				rate_per_day = flt(d.value_after_depreciation - d.expected_value_after_useful_life) / flt(
+					total_days
+				)
 				from_date = self.date
 			else:
 				no_of_depreciations = len(

erpnext/assets/report/fixed_asset_register/fixed_asset_register.js

@@ -19,56 +19,6 @@ frappe.query_reports["Fixed Asset Register"] = {
 			options: "\nIn Location\nDisposed",
 			default: 'In Location'
 		},
-		{
-			"fieldname":"filter_based_on",
-			"label": __("Period Based On"),
-			"fieldtype": "Select",
-			"options": ["Fiscal Year", "Date Range"],
-			"default": "Fiscal Year",
-			"reqd": 1
-		},
-		{
-			"fieldname":"from_date",
-			"label": __("Start Date"),
-			"fieldtype": "Date",
-			"default": frappe.datetime.add_months(frappe.datetime.nowdate(), -12),
-			"depends_on": "eval: doc.filter_based_on == 'Date Range'",
-			"reqd": 1
-		},
-		{
-			"fieldname":"to_date",
-			"label": __("End Date"),
-			"fieldtype": "Date",
-			"default": frappe.datetime.nowdate(),
-			"depends_on": "eval: doc.filter_based_on == 'Date Range'",
-			"reqd": 1
-		},
-		{
-			"fieldname":"from_fiscal_year",
-			"label": __("Start Year"),
-			"fieldtype": "Link",
-			"options": "Fiscal Year",
-			"default": frappe.defaults.get_user_default("fiscal_year"),
-			"depends_on": "eval: doc.filter_based_on == 'Fiscal Year'",
-			"reqd": 1
-		},
-		{
-			"fieldname":"to_fiscal_year",
-			"label": __("End Year"),
-			"fieldtype": "Link",
-			"options": "Fiscal Year",
-			"default": frappe.defaults.get_user_default("fiscal_year"),
-			"depends_on": "eval: doc.filter_based_on == 'Fiscal Year'",
-			"reqd": 1
-		},
-		{
-			"fieldname":"date_based_on",
-			"label": __("Date Based On"),
-			"fieldtype": "Select",
-			"options": ["Purchase Date", "Available For Use Date"],
-			"default": "Purchase Date",
-			"reqd": 1
-		},
 		{
 			fieldname:"asset_category",
 			label: __("Asset Category"),
@@ -89,22 +39,67 @@ frappe.query_reports["Fixed Asset Register"] = {
 			default: "--Select a group--",
 			reqd: 1
 		},
-		{
-			fieldname:"finance_book",
-			label: __("Finance Book"),
-			fieldtype: "Link",
-			options: "Finance Book",
-			depends_on: "eval: doc.filter_by_finance_book == 1",
-		},
-		{
-			fieldname:"filter_by_finance_book",
-			label: __("Filter by Finance Book"),
-			fieldtype: "Check"
-		},
 		{
 			fieldname:"only_existing_assets",
 			label: __("Only existing assets"),
 			fieldtype: "Check"
 		},
+		{
+			fieldname:"finance_book",
+			label: __("Finance Book"),
+			fieldtype: "Link",
+			options: "Finance Book",
+		},
+		{
+			"fieldname": "include_default_book_assets",
+			"label": __("Include Default Book Assets"),
+			"fieldtype": "Check",
+			"default": 1
+		},
+		{
+			"fieldname":"filter_based_on",
+			"label": __("Period Based On"),
+			"fieldtype": "Select",
+			"options": ["--Select a period--", "Fiscal Year", "Date Range"],
+			"default": "--Select a period--",
+		},
+		{
+			"fieldname":"from_date",
+			"label": __("Start Date"),
+			"fieldtype": "Date",
+			"default": frappe.datetime.add_months(frappe.datetime.nowdate(), -12),
+			"depends_on": "eval: doc.filter_based_on == 'Date Range'",
+		},
+		{
+			"fieldname":"to_date",
+			"label": __("End Date"),
+			"fieldtype": "Date",
+			"default": frappe.datetime.nowdate(),
+			"depends_on": "eval: doc.filter_based_on == 'Date Range'",
+		},
+		{
+			"fieldname":"from_fiscal_year",
+			"label": __("Start Year"),
+			"fieldtype": "Link",
+			"options": "Fiscal Year",
+			"default": frappe.defaults.get_user_default("fiscal_year"),
+			"depends_on": "eval: doc.filter_based_on == 'Fiscal Year'",
+		},
+		{
+			"fieldname":"to_fiscal_year",
+			"label": __("End Year"),
+			"fieldtype": "Link",
+			"options": "Fiscal Year",
+			"default": frappe.defaults.get_user_default("fiscal_year"),
+			"depends_on": "eval: doc.filter_based_on == 'Fiscal Year'",
+		},
+		{
+			"fieldname":"date_based_on",
+			"label": __("Date Based On"),
+			"fieldtype": "Select",
+			"options": ["Purchase Date", "Available For Use Date"],
+			"default": "Purchase Date",
+			"depends_on": "eval: doc.filter_based_on == 'Date Range' || doc.filter_based_on == 'Fiscal Year'",
+		},
 	]
 };

erpnext/assets/report/fixed_asset_register/fixed_asset_register.py

@@ -2,18 +2,20 @@
 # For license information, please see license.txt
 
 
+from itertools import chain
+
 import frappe
 from frappe import _
-from frappe.query_builder.functions import Sum
-from frappe.utils import cstr, flt, formatdate, getdate
+from frappe.query_builder.functions import IfNull, Sum
+from frappe.utils import add_months, cstr, flt, formatdate, getdate, nowdate, today
 
 from erpnext.accounts.report.financial_statements import (
 	get_fiscal_year_data,
 	get_period_list,
 	validate_fiscal_year,
 )
+from erpnext.accounts.utils import get_fiscal_year
 from erpnext.assets.doctype.asset.asset import get_asset_value_after_depreciation
-from erpnext.assets.doctype.asset.depreciation import get_depreciation_accounts
 
 
 def execute(filters=None):
@@ -36,15 +38,26 @@ def get_conditions(filters):
 
 	if filters.get("company"):
 		conditions["company"] = filters.company
+
 	if filters.filter_based_on == "Date Range":
+		if not filters.from_date and not filters.to_date:
+			filters.from_date = add_months(nowdate(), -12)
+			filters.to_date = nowdate()
+
 		conditions[date_field] = ["between", [filters.from_date, filters.to_date]]
-	if filters.filter_based_on == "Fiscal Year":
+	elif filters.filter_based_on == "Fiscal Year":
+		if not filters.from_fiscal_year and not filters.to_fiscal_year:
+			default_fiscal_year = get_fiscal_year(today())[0]
+			filters.from_fiscal_year = default_fiscal_year
+			filters.to_fiscal_year = default_fiscal_year
+
 		fiscal_year = get_fiscal_year_data(filters.from_fiscal_year, filters.to_fiscal_year)
 		validate_fiscal_year(fiscal_year, filters.from_fiscal_year, filters.to_fiscal_year)
 		filters.year_start_date = getdate(fiscal_year.year_start_date)
 		filters.year_end_date = getdate(fiscal_year.year_end_date)
 
 		conditions[date_field] = ["between", [filters.year_start_date, filters.year_end_date]]
+
 	if filters.get("only_existing_assets"):
 		conditions["is_existing_asset"] = filters.get("only_existing_assets")
 	if filters.get("asset_category"):
@@ -53,69 +66,73 @@ def get_conditions(filters):
 		conditions["cost_center"] = filters.get("cost_center")
 
 	if status:
-		# In Store assets are those that are not sold or scrapped
+		# In Store assets are those that are not sold or scrapped or capitalized or decapitalized
 		operand = "not in"
 		if status not in "In Location":
 			operand = "in"
 
-		conditions["status"] = (operand, ["Sold", "Scrapped"])
+		conditions["status"] = (operand, ["Sold", "Scrapped", "Capitalized", "Decapitalized"])
 
 	return conditions
 
 
 def get_data(filters):
-
 	data = []
 
 	conditions = get_conditions(filters)
-	depreciation_amount_map = get_finance_book_value_map(filters)
 	pr_supplier_map = get_purchase_receipt_supplier_map()
 	pi_supplier_map = get_purchase_invoice_supplier_map()
 
+	assets_linked_to_fb = get_assets_linked_to_fb(filters)
+
+	company_fb = frappe.get_cached_value("Company", filters.company, "default_finance_book")
+
+	if filters.include_default_book_assets and company_fb:
+		finance_book = company_fb
+	elif filters.finance_book:
+		finance_book = filters.finance_book
+	else:
+		finance_book = None
+
+	depreciation_amount_map = get_asset_depreciation_amount_map(filters, finance_book)
+
 	group_by = frappe.scrub(filters.get("group_by"))
 
-	if group_by == "asset_category":
-		fields = ["asset_category", "gross_purchase_amount", "opening_accumulated_depreciation"]
-		assets_record = frappe.db.get_all("Asset", filters=conditions, fields=fields, group_by=group_by)
+	if group_by in ("asset_category", "location"):
+		data = get_group_by_data(group_by, conditions, assets_linked_to_fb, depreciation_amount_map)
+		return data
 
-	elif group_by == "location":
-		fields = ["location", "gross_purchase_amount", "opening_accumulated_depreciation"]
-		assets_record = frappe.db.get_all("Asset", filters=conditions, fields=fields, group_by=group_by)
-
-	else:
-		fields = [
-			"name as asset_id",
-			"asset_name",
-			"status",
-			"department",
-			"company",
-			"cost_center",
-			"calculate_depreciation",
-			"purchase_receipt",
-			"asset_category",
-			"purchase_date",
-			"gross_purchase_amount",
-			"location",
-			"available_for_use_date",
-			"purchase_invoice",
-			"opening_accumulated_depreciation",
-		]
-		assets_record = frappe.db.get_all("Asset", filters=conditions, fields=fields)
-
-	assets_linked_to_fb = None
-
-	if filters.filter_by_finance_book:
-		assets_linked_to_fb = frappe.db.get_all(
-			doctype="Asset Finance Book",
-			filters={"finance_book": filters.finance_book or ("is", "not set")},
-			pluck="parent",
-		)
+	fields = [
+		"name as asset_id",
+		"asset_name",
+		"status",
+		"department",
+		"company",
+		"cost_center",
+		"calculate_depreciation",
+		"purchase_receipt",
+		"asset_category",
+		"purchase_date",
+		"gross_purchase_amount",
+		"location",
+		"available_for_use_date",
+		"purchase_invoice",
+		"opening_accumulated_depreciation",
+	]
+	assets_record = frappe.db.get_all("Asset", filters=conditions, fields=fields)
 
 	for asset in assets_record:
-		if assets_linked_to_fb and asset.asset_id not in assets_linked_to_fb:
+		if (
+			assets_linked_to_fb
+			and asset.calculate_depreciation
+			and asset.asset_id not in assets_linked_to_fb
+		):
 			continue
 
-		asset_value = get_asset_value_after_depreciation(asset.asset_id, filters.finance_book)
+		asset_value = get_asset_value_after_depreciation(
+			asset.asset_id, finance_book
+		) or get_asset_value_after_depreciation(asset.asset_id)
+
 		row = {
 			"asset_id": asset.asset_id,
 			"asset_name": asset.asset_name,
@@ -126,7 +143,7 @@ def get_data(filters):
 			or pi_supplier_map.get(asset.purchase_invoice),
 			"gross_purchase_amount": asset.gross_purchase_amount,
 			"opening_accumulated_depreciation": asset.opening_accumulated_depreciation,
-			"depreciated_amount": get_depreciation_amount_of_asset(asset, depreciation_amount_map, filters),
+			"depreciated_amount": depreciation_amount_map.get(asset.asset_id) or 0.0,
 			"available_for_use_date": asset.available_for_use_date,
 			"location": asset.location,
 			"asset_category": asset.asset_category,
@@ -140,14 +157,23 @@ def get_data(filters):
 
 def prepare_chart_data(data, filters):
 	labels_values_map = {}
-	date_field = frappe.scrub(filters.date_based_on)
+	if filters.filter_based_on not in ("Date Range", "Fiscal Year"):
+		filters_filter_based_on = "Date Range"
+		date_field = "purchase_date"
+		filters_from_date = min(data, key=lambda a: a.get(date_field)).get(date_field)
+		filters_to_date = max(data, key=lambda a: a.get(date_field)).get(date_field)
+	else:
+		filters_filter_based_on = filters.filter_based_on
+		date_field = frappe.scrub(filters.date_based_on)
+		filters_from_date = filters.from_date
+		filters_to_date = filters.to_date
 
 	period_list = get_period_list(
 		filters.from_fiscal_year,
 		filters.to_fiscal_year,
-		filters.from_date,
-		filters.to_date,
-		filters.filter_based_on,
+		filters_from_date,
+		filters_to_date,
+		filters_filter_based_on,
 		"Monthly",
 		company=filters.company,
 		ignore_fiscal_year=True,
@@ -184,57 +210,127 @@ def prepare_chart_data(data, filters):
 	}
 
 
-def get_depreciation_amount_of_asset(asset, depreciation_amount_map, filters):
-	if asset.calculate_depreciation:
-		depr_amount = depreciation_amount_map.get(asset.asset_id) or 0.0
-	else:
-		depr_amount = get_manual_depreciation_amount_of_asset(asset, filters)
+def get_assets_linked_to_fb(filters):
+	afb = frappe.qb.DocType("Asset Finance Book")
 
-	return flt(depr_amount, 2)
-
-
-def get_finance_book_value_map(filters):
-	date = filters.to_date if filters.filter_based_on == "Date Range" else filters.year_end_date
-
-	return frappe._dict(
-		frappe.db.sql(
-			""" Select
-		parent, SUM(depreciation_amount)
-		FROM `tabDepreciation Schedule`
-		WHERE
-			parentfield='schedules'
-			AND schedule_date<=%s
-			AND journal_entry IS NOT NULL
-			AND ifnull(finance_book, '')=%s
-		GROUP BY parent""",
-			(date, cstr(filters.finance_book or "")),
-		)
+	query = frappe.qb.from_(afb).select(
+		afb.parent,
 	)
 
+	if filters.include_default_book_assets:
+		company_fb = frappe.get_cached_value("Company", filters.company, "default_finance_book")
 
-def get_manual_depreciation_amount_of_asset(asset, filters):
-	date = filters.to_date if filters.filter_based_on == "Date Range" else filters.year_end_date
+		if filters.finance_book and company_fb and cstr(filters.finance_book) != cstr(company_fb):
+			frappe.throw(_("To use a different finance book, please uncheck 'Include Default Book Assets'"))
 
-	(_, _, depreciation_expense_account) = get_depreciation_accounts(asset)
+		query = query.where(
+			(afb.finance_book.isin([cstr(filters.finance_book), cstr(company_fb), ""]))
+			| (afb.finance_book.isnull())
+		)
+	else:
+		query = query.where(
+			(afb.finance_book.isin([cstr(filters.finance_book), ""])) | (afb.finance_book.isnull())
+		)
 
+	assets_linked_to_fb = list(chain(*query.run(as_list=1)))
+
+	return assets_linked_to_fb
+
+
+def get_asset_depreciation_amount_map(filters, finance_book):
+	start_date = (
+		filters.from_date if filters.filter_based_on == "Date Range" else filters.year_start_date
+	)
+	end_date = filters.to_date if filters.filter_based_on == "Date Range" else filters.year_end_date
+
+	asset = frappe.qb.DocType("Asset")
 	gle = frappe.qb.DocType("GL Entry")
+	aca = frappe.qb.DocType("Asset Category Account")
+	company = frappe.qb.DocType("Company")
 
-	result = (
+	query = (
 		frappe.qb.from_(gle)
-		.select(Sum(gle.debit))
-		.where(gle.against_voucher == asset.asset_id)
-		.where(gle.account == depreciation_expense_account)
+		.join(asset)
+		.on(gle.against_voucher == asset.name)
+		.join(aca)
+		.on((aca.parent == asset.asset_category) & (aca.company_name == asset.company))
+		.join(company)
+		.on(company.name == asset.company)
+		.select(asset.name.as_("asset"), Sum(gle.debit).as_("depreciation_amount"))
+		.where(
+			gle.account == IfNull(aca.depreciation_expense_account, company.depreciation_expense_account)
+		)
 		.where(gle.debit != 0)
 		.where(gle.is_cancelled == 0)
-		.where(gle.posting_date <= date)
-	).run()
+		.where(company.name == filters.company)
+		.where(asset.docstatus == 1)
+	)
 
-	if result and result[0] and result[0][0]:
-		depr_amount = result[0][0]
+	if filters.only_existing_assets:
+		query = query.where(asset.is_existing_asset == 1)
+	if filters.asset_category:
+		query = query.where(asset.asset_category == filters.asset_category)
+	if filters.cost_center:
+		query = query.where(asset.cost_center == filters.cost_center)
+	if filters.status:
+		if filters.status == "In Location":
+			query = query.where(asset.status.notin(["Sold", "Scrapped", "Capitalized", "Decapitalized"]))
+		else:
+			query = query.where(asset.status.isin(["Sold", "Scrapped", "Capitalized", "Decapitalized"]))
+	if finance_book:
+		query = query.where(
+			(gle.finance_book.isin([cstr(finance_book), ""])) | (gle.finance_book.isnull())
+		)
 	else:
-		depr_amount = 0
+		query = query.where((gle.finance_book.isin([""])) | (gle.finance_book.isnull()))
+	if filters.filter_based_on in ("Date Range", "Fiscal Year"):
+		query = query.where(gle.posting_date >= start_date)
+		query = query.where(gle.posting_date <= end_date)
 
-	return depr_amount
+	query = query.groupby(asset.name)
+
+	asset_depr_amount_map = query.run()
+
+	return dict(asset_depr_amount_map)
+
+
+def get_group_by_data(group_by, conditions, assets_linked_to_fb, depreciation_amount_map):
+	fields = [
+		group_by,
+		"name",
+		"gross_purchase_amount",
+		"opening_accumulated_depreciation",
+		"calculate_depreciation",
+	]
+	assets = frappe.db.get_all("Asset", filters=conditions, fields=fields)
+
+	data = []
+
+	for a in assets:
+		if assets_linked_to_fb and a.calculate_depreciation and a.name not in assets_linked_to_fb:
+			continue
+
+		a["depreciated_amount"] = depreciation_amount_map.get(a["name"], 0.0)
+		a["asset_value"] = (
+			a["gross_purchase_amount"] - a["opening_accumulated_depreciation"] - a["depreciated_amount"]
+		)
+
+		del a["name"]
+		del a["calculate_depreciation"]
+
+		idx = ([i for i, d in enumerate(data) if a[group_by] == d[group_by]] or [None])[0]
+		if idx is None:
+			data.append(a)
+		else:
+			for field in (
+				"gross_purchase_amount",
+				"opening_accumulated_depreciation",
+				"depreciated_amount",
+				"asset_value",
+			):
+				data[idx][field] = data[idx][field] + a[field]
+
+	return data
 
 
 def get_purchase_receipt_supplier_map():
@@ -275,35 +371,35 @@ def get_columns(filters):
 				"fieldtype": "Link",
 				"fieldname": frappe.scrub(filters.get("group_by")),
 				"options": filters.get("group_by"),
-				"width": 120,
+				"width": 216,
 			},
 			{
 				"label": _("Gross Purchase Amount"),
 				"fieldname": "gross_purchase_amount",
 				"fieldtype": "Currency",
 				"options": "company:currency",
-				"width": 100,
+				"width": 250,
 			},
 			{
 				"label": _("Opening Accumulated Depreciation"),
 				"fieldname": "opening_accumulated_depreciation",
 				"fieldtype": "Currency",
 				"options": "company:currency",
-				"width": 90,
+				"width": 250,
 			},
 			{
 				"label": _("Depreciated Amount"),
 				"fieldname": "depreciated_amount",
 				"fieldtype": "Currency",
 				"options": "company:currency",
-				"width": 100,
+				"width": 250,
 			},
 			{
 				"label": _("Asset Value"),
 				"fieldname": "asset_value",
 				"fieldtype": "Currency",
 				"options": "company:currency",
-				"width": 100,
+				"width": 250,
 			},
 		]
 

erpnext/buying/doctype/purchase_order/purchase_order.js

@@ -242,7 +242,7 @@ erpnext.buying.PurchaseOrderController = erpnext.buying.BuyingController.extend(
 			source_name: this.frm.doc.supplier,
 			target: this.frm,
 			setters: {
-				company: me.frm.doc.company
+				company: this.frm.doc.company
 			},
 			get_query_filters: {
 				docstatus: ["!=", 2],

erpnext/buying/report/purchase_order_analysis/purchase_order_analysis.py

@@ -84,7 +84,7 @@ def get_data(conditions, filters):
 			and po.docstatus = 1
 			{0}
 		GROUP BY poi.name
-		ORDER BY po.transaction_date ASC
+		ORDER BY po.transaction_date ASC, poi.item_code ASC
 	""".format(
 			conditions
 		),

erpnext/controllers/accounts_controller.py

@@ -891,6 +891,9 @@ class AccountsController(TransactionBase):
 
 		return is_inclusive
 
+	def should_show_taxes_as_table_in_print(self):
+		return cint(frappe.db.get_single_value("Accounts Settings", "show_taxes_as_table_in_print"))
+
 	def validate_advance_entries(self):
 		order_field = "sales_order" if self.doctype == "Sales Invoice" else "purchase_order"
 		order_list = list(set(d.get(order_field) for d in self.get("items") if d.get(order_field)))
@@ -1632,8 +1635,13 @@ class AccountsController(TransactionBase):
 				)
 				self.append("payment_schedule", data)
 
+		allocate_payment_based_on_payment_terms = frappe.db.get_value(
+			"Payment Terms Template", self.payment_terms_template, "allocate_payment_based_on_payment_terms"
+		)
+
 		if not (
 			automatically_fetch_payment_terms
+			and allocate_payment_based_on_payment_terms
 			and self.linked_order_has_payment_terms(po_or_so, fieldname, doctype)
 		):
 			for d in self.get("payment_schedule"):

erpnext/controllers/buying_controller.py

@@ -4,7 +4,7 @@
 
 import frappe
 from frappe import ValidationError, _, msgprint
-from frappe.contacts.doctype.address.address import get_address_display
+from frappe.contacts.doctype.address.address import render_address
 from frappe.utils import cint, cstr, flt, getdate
 
 from erpnext.accounts.doctype.budget.budget import validate_expense_against_budget
@@ -14,7 +14,8 @@ from erpnext.controllers.sales_and_purchase_return import get_rate_for_return
 from erpnext.controllers.stock_controller import StockController
 from erpnext.controllers.subcontracting import Subcontracting
 from erpnext.stock.get_item_details import get_conversion_factor
-from erpnext.stock.utils import get_incoming_rate
+from erpnext.stock.stock_ledger import get_previous_sle
+from erpnext.stock.utils import get_incoming_rate, get_valuation_method
 
 
 class QtyMismatchError(ValidationError):
@@ -186,7 +187,9 @@ class BuyingController(StockController, Subcontracting):
 
 		for address_field, address_display_field in address_dict.items():
 			if self.get(address_field):
-				self.set(address_display_field, get_address_display(self.get(address_field)))
+				self.set(
+					address_display_field, render_address(self.get(address_field), check_permissions=False)
+				)
 
 	def set_total_in_words(self):
 		from frappe.utils import money_in_words
@@ -504,9 +507,20 @@ class BuyingController(StockController, Subcontracting):
 					)
 
 					if self.is_return:
-						outgoing_rate = get_rate_for_return(
-							self.doctype, self.name, d.item_code, self.return_against, item_row=d
-						)
+						if get_valuation_method(d.item_code) == "Moving Average":
+							previous_sle = get_previous_sle(
+								{
+									"item_code": d.item_code,
+									"warehouse": d.warehouse,
+									"posting_date": self.posting_date,
+									"posting_time": self.posting_time,
+								}
+							)
+							outgoing_rate = flt(previous_sle.get("valuation_rate"))
+						else:
+							outgoing_rate = get_rate_for_return(
+								self.doctype, self.name, d.item_code, self.return_against, item_row=d
+							)
 
 						sle.update({"outgoing_rate": outgoing_rate, "recalculate_rate": 1})
 						if d.from_warehouse:

erpnext/controllers/print_settings.py

@@ -30,10 +30,16 @@ def set_print_templates_for_taxes(doc, settings):
 	doc.print_templates.update(
 		{
 			"total": "templates/print_formats/includes/total.html",
-			"taxes": "templates/print_formats/includes/taxes.html",
 		}
 	)
 
+	if not doc.should_show_taxes_as_table_in_print():
+		doc.print_templates.update(
+			{
+				"taxes": "templates/print_formats/includes/taxes.html",
+			}
+		)
+
 
 def format_columns(display_columns, compact_fields):
 	compact_fields = compact_fields + ["image", "item_code", "item_name"]

erpnext/controllers/selling_controller.py

@@ -4,9 +4,9 @@
 
 import frappe
 from frappe import _, bold, throw
-from frappe.contacts.doctype.address.address import get_address_display
 from frappe.utils import cint, cstr, flt, get_link_to_form, nowtime
 
+from erpnext.accounts.party import render_address
 from erpnext.controllers.accounts_controller import get_taxes_and_charges
 from erpnext.controllers.sales_and_purchase_return import get_rate_for_return
 from erpnext.controllers.stock_controller import StockController
@@ -583,7 +583,9 @@ class SellingController(StockController):
 
 		for address_field, address_display_field in address_dict.items():
 			if self.get(address_field):
-				self.set(address_display_field, get_address_display(self.get(address_field)))
+				self.set(
+					address_display_field, render_address(self.get(address_field), check_permissions=False)
+				)
 
 	def validate_for_duplicate_items(self):
 		check_list, chk_dupl_itm = [], []

erpnext/controllers/stock_controller.py

@@ -582,13 +582,21 @@ class StockController(AccountsController):
 				d.stock_uom_rate = d.rate / (d.conversion_factor or 1)
 
 	def validate_internal_transfer(self):
-		if (
-			self.doctype in ("Sales Invoice", "Delivery Note", "Purchase Invoice", "Purchase Receipt")
-			and self.is_internal_transfer()
-		):
-			self.validate_in_transit_warehouses()
-			self.validate_multi_currency()
-			self.validate_packed_items()
+		if self.doctype in ("Sales Invoice", "Delivery Note", "Purchase Invoice", "Purchase Receipt"):
+			if self.is_internal_transfer():
+				self.validate_in_transit_warehouses()
+				self.validate_multi_currency()
+				self.validate_packed_items()
+			else:
+				self.validate_internal_transfer_warehouse()
+
+	def validate_internal_transfer_warehouse(self):
+		for row in self.items:
+			if row.get("target_warehouse"):
+				row.target_warehouse = None
+
+			if row.get("from_warehouse"):
+				row.from_warehouse = None
 
 	def validate_in_transit_warehouses(self):
 		if (
@@ -678,7 +686,7 @@ class StockController(AccountsController):
 		message += _("Please adjust the qty or edit {0} to proceed.").format(rule_link)
 		return message
 
-	def repost_future_sle_and_gle(self):
+	def repost_future_sle_and_gle(self, force=False):
 		args = frappe._dict(
 			{
 				"posting_date": self.posting_date,
@@ -689,7 +697,10 @@ class StockController(AccountsController):
 			}
 		)
 
-		if future_sle_exists(args) or repost_required_for_queue(self):
+		if self.docstatus == 2:
+			force = True
+
+		if force or future_sle_exists(args) or repost_required_for_queue(self):
 			item_based_reposting = cint(
 				frappe.db.get_single_value("Stock Reposting Settings", "item_based_reposting")
 			)
@@ -903,8 +914,6 @@ def create_item_wise_repost_entries(voucher_type, voucher_no, allow_zero_rate=Fa
 
 		repost_entry = frappe.new_doc("Repost Item Valuation")
 		repost_entry.based_on = "Item and Warehouse"
-		repost_entry.voucher_type = voucher_type
-		repost_entry.voucher_no = voucher_no
 
 		repost_entry.item_code = sle.item_code
 		repost_entry.warehouse = sle.warehouse

erpnext/crm/report/lead_details/lead_details.py

@@ -4,6 +4,7 @@
 
 import frappe
 from frappe import _
+from frappe.query_builder.functions import Concat_ws, Date
 
 
 def execute(filters=None):
@@ -69,53 +70,41 @@ def get_columns():
 
 
 def get_data(filters):
-	return frappe.db.sql(
-		"""
-		SELECT
-			`tabLead`.name,
-			`tabLead`.lead_name,
-			`tabLead`.status,
-			`tabLead`.lead_owner,
-			`tabLead`.territory,
-			`tabLead`.source,
-			`tabLead`.email_id,
-			`tabLead`.mobile_no,
-			`tabLead`.phone,
-			`tabLead`.owner,
-			`tabLead`.company,
-			concat_ws(', ',
-				trim(',' from `tabAddress`.address_line1),
-				trim(',' from tabAddress.address_line2)
-			) AS address,
-			`tabAddress`.state,
-			`tabAddress`.pincode,
-			`tabAddress`.country
-		FROM
-			`tabLead` left join `tabDynamic Link` on (
-			`tabLead`.name = `tabDynamic Link`.link_name and
-			`tabDynamic Link`.parenttype = 'Address')
-			left join `tabAddress` on (
-			`tabAddress`.name=`tabDynamic Link`.parent)
-		WHERE
-			company = %(company)s
-			AND DATE(`tabLead`.creation) BETWEEN %(from_date)s AND %(to_date)s
-			{conditions}
-		ORDER BY
-			`tabLead`.creation asc """.format(
-			conditions=get_conditions(filters)
-		),
-		filters,
-		as_dict=1,
+	lead = frappe.qb.DocType("Lead")
+	address = frappe.qb.DocType("Address")
+	dynamic_link = frappe.qb.DocType("Dynamic Link")
+
+	query = (
+		frappe.qb.from_(lead)
+		.left_join(dynamic_link)
+		.on((lead.name == dynamic_link.link_name) & (dynamic_link.parenttype == "Address"))
+		.left_join(address)
+		.on(address.name == dynamic_link.parent)
+		.select(
+			lead.name,
+			lead.lead_name,
+			lead.status,
+			lead.lead_owner,
+			lead.territory,
+			lead.source,
+			lead.email_id,
+			lead.mobile_no,
+			lead.phone,
+			lead.owner,
+			lead.company,
+			(Concat_ws(", ", address.address_line1, address.address_line2)).as_("address"),
+			address.state,
+			address.pincode,
+			address.country,
+		)
+		.where(lead.company == filters.company)
+		.where(Date(lead.creation).between(filters.from_date, filters.to_date))
 	)
 
-
-def get_conditions(filters):
-	conditions = []
-
 	if filters.get("territory"):
-		conditions.append(" and `tabLead`.territory=%(territory)s")
+		query = query.where(lead.territory == filters.get("territory"))
 
 	if filters.get("status"):
-		conditions.append(" and `tabLead`.status=%(status)s")
+		query = query.where(lead.status == filters.get("status"))
 
-	return " ".join(conditions) if conditions else ""
+	return query.run(as_dict=1)

erpnext/e_commerce/doctype/website_item/website_item.json

@@ -188,7 +188,8 @@
    "in_list_view": 1,
    "label": "Item Group",
    "options": "Item Group",
-   "read_only": 1
+   "read_only": 1,
+   "search_index": 1
   },
   {
    "default": "1",
@@ -234,7 +235,8 @@
    "fieldname": "brand",
    "fieldtype": "Link",
    "label": "Brand",
-   "options": "Brand"
+   "options": "Brand",
+   "search_index": 1
   },
   {
    "collapsible": 1,
@@ -346,7 +348,7 @@
  "index_web_pages_for_search": 1,
  "links": [],
  "make_attachments_public": 1,
- "modified": "2022-09-13 04:05:11.614087",
+ "modified": "2022-09-30 04:01:52.090732",
  "modified_by": "Administrator",
  "module": "E-commerce",
  "name": "Website Item",

erpnext/e_commerce/doctype/website_item/website_item.py

@@ -409,9 +409,6 @@ def on_doctype_update():
 	# since route is a Text column, it needs a length for indexing
 	frappe.db.add_index("Website Item", ["route(500)"])
 
-	frappe.db.add_index("Website Item", ["item_group"])
-	frappe.db.add_index("Website Item", ["brand"])
-
 
 def check_if_user_is_customer(user=None):
 	from frappe.contacts.doctype.contact.contact import get_contact_name

erpnext/e_commerce/product_ui/list.js

@@ -78,9 +78,10 @@ erpnext.ProductList = class {
 		let title_html = `<div style="display: flex; margin-left: -15px;">`;
 		title_html += `
 			<div class="col-8" style="margin-right: -15px;">
-				<a class="" href="/${ item.route || '#' }"
-					style="color: var(--gray-800); font-weight: 500;">
+				<a href="/${ item.route || '#' }">
+					<div class="product-title">
 					${ title }
+					</div>
 				</a>
 			</div>
 		`;
@@ -201,4 +202,4 @@ erpnext.ProductList = class {
 		}
 	}
 
-};
+};

erpnext/e_commerce/shopping_cart/test_shopping_cart.py

@@ -17,7 +17,6 @@ from erpnext.e_commerce.shopping_cart.cart import (
 	request_for_quotation,
 	update_cart,
 )
-from erpnext.tests.utils import create_test_contact_and_address
 
 
 class TestShoppingCart(unittest.TestCase):
@@ -28,7 +27,6 @@ class TestShoppingCart(unittest.TestCase):
 
 	def setUp(self):
 		frappe.set_user("Administrator")
-		create_test_contact_and_address()
 		self.enable_shopping_cart()
 		if not frappe.db.exists("Website Item", {"item_code": "_Test Item"}):
 			make_website_item(frappe.get_cached_doc("Item", "_Test Item"))
@@ -46,48 +44,57 @@ class TestShoppingCart(unittest.TestCase):
 		frappe.db.sql("delete from `tabTax Rule`")
 
 	def test_get_cart_new_user(self):
-		self.login_as_new_user()
-
+		self.login_as_customer(
+			"test_contact_two_customer@example.com", "_Test Contact 2 For _Test Customer"
+		)
+		create_address_and_contact(
+			address_title="_Test Address for Customer 2",
+			first_name="_Test Contact for Customer 2",
+			email="test_contact_two_customer@example.com",
+			customer="_Test Customer 2",
+		)
 		# test if lead is created and quotation with new lead is fetched
-		quotation = _get_cart_quotation()
+		customer = frappe.get_doc("Customer", "_Test Customer 2")
+		quotation = _get_cart_quotation(party=customer)
 		self.assertEqual(quotation.quotation_to, "Customer")
 		self.assertEqual(
 			quotation.contact_person,
-			frappe.db.get_value("Contact", dict(email_id="test_cart_user@example.com")),
+			frappe.db.get_value("Contact", dict(email_id="test_contact_two_customer@example.com")),
 		)
 		self.assertEqual(quotation.contact_email, frappe.session.user)
 
 		return quotation
 
-	def test_get_cart_customer(self):
-		def validate_quotation():
+	def test_get_cart_customer(self, customer="_Test Customer 2"):
+		def validate_quotation(customer_name):
 			# test if quotation with customer is fetched
-			quotation = _get_cart_quotation()
+			party = frappe.get_doc("Customer", customer_name)
+			quotation = _get_cart_quotation(party=party)
 			self.assertEqual(quotation.quotation_to, "Customer")
-			self.assertEqual(quotation.party_name, "_Test Customer")
+			self.assertEqual(quotation.party_name, customer_name)
 			self.assertEqual(quotation.contact_email, frappe.session.user)
 			return quotation
 
-		self.login_as_customer(
-			"test_contact_two_customer@example.com", "_Test Contact 2 For _Test Customer"
-		)
-		validate_quotation()
-
-		self.login_as_customer()
-		quotation = validate_quotation()
-
+		quotation = validate_quotation(customer)
 		return quotation
 
 	def test_add_to_cart(self):
-		self.login_as_customer()
-
+		self.login_as_customer(
+			"test_contact_two_customer@example.com", "_Test Contact 2 For _Test Customer"
+		)
+		create_address_and_contact(
+			address_title="_Test Address for Customer 2",
+			first_name="_Test Contact for Customer 2",
+			email="test_contact_two_customer@example.com",
+			customer="_Test Customer 2",
+		)
 		# clear existing quotations
 		self.clear_existing_quotations()
 
 		# add first item
 		update_cart("_Test Item", 1)
 
-		quotation = self.test_get_cart_customer()
+		quotation = self.test_get_cart_customer("_Test Customer 2")
 
 		self.assertEqual(quotation.get("items")[0].item_code, "_Test Item")
 		self.assertEqual(quotation.get("items")[0].qty, 1)
@@ -95,7 +102,7 @@ class TestShoppingCart(unittest.TestCase):
 
 		# add second item
 		update_cart("_Test Item 2", 1)
-		quotation = self.test_get_cart_customer()
+		quotation = self.test_get_cart_customer("_Test Customer 2")
 		self.assertEqual(quotation.get("items")[1].item_code, "_Test Item 2")
 		self.assertEqual(quotation.get("items")[1].qty, 1)
 		self.assertEqual(quotation.get("items")[1].amount, 20)
@@ -108,7 +115,7 @@ class TestShoppingCart(unittest.TestCase):
 
 		# update first item
 		update_cart("_Test Item", 5)
-		quotation = self.test_get_cart_customer()
+		quotation = self.test_get_cart_customer("_Test Customer 2")
 		self.assertEqual(quotation.get("items")[0].item_code, "_Test Item")
 		self.assertEqual(quotation.get("items")[0].qty, 5)
 		self.assertEqual(quotation.get("items")[0].amount, 50)
@@ -121,7 +128,7 @@ class TestShoppingCart(unittest.TestCase):
 
 		# remove first item
 		update_cart("_Test Item", 0)
-		quotation = self.test_get_cart_customer()
+		quotation = self.test_get_cart_customer("_Test Customer 2")
 
 		self.assertEqual(quotation.get("items")[0].item_code, "_Test Item 2")
 		self.assertEqual(quotation.get("items")[0].qty, 1)
@@ -129,9 +136,20 @@ class TestShoppingCart(unittest.TestCase):
 		self.assertEqual(quotation.net_total, 20)
 		self.assertEqual(len(quotation.get("items")), 1)
 
+	@unittest.skip("Flaky in CI")
 	def test_tax_rule(self):
 		self.create_tax_rule()
-		self.login_as_customer()
+
+		self.login_as_customer(
+			"test_contact_two_customer@example.com", "_Test Contact 2 For _Test Customer"
+		)
+		create_address_and_contact(
+			address_title="_Test Address for Customer 2",
+			first_name="_Test Contact for Customer 2",
+			email="test_contact_two_customer@example.com",
+			customer="_Test Customer 2",
+		)
+
 		quotation = self.create_quotation()
 
 		from erpnext.accounts.party import set_taxes
@@ -319,7 +337,7 @@ class TestShoppingCart(unittest.TestCase):
 		if frappe.db.exists("User", email):
 			return
 
-		frappe.get_doc(
+		user = frappe.get_doc(
 			{
 				"doctype": "User",
 				"user_type": "Website User",
@@ -329,6 +347,40 @@ class TestShoppingCart(unittest.TestCase):
 			}
 		).insert(ignore_permissions=True)
 
+		user.add_roles("Customer")
+
+
+def create_address_and_contact(**kwargs):
+	if not frappe.db.get_value("Address", {"address_title": kwargs.get("address_title")}):
+		frappe.get_doc(
+			{
+				"doctype": "Address",
+				"address_title": kwargs.get("address_title"),
+				"address_type": kwargs.get("address_type") or "Office",
+				"address_line1": kwargs.get("address_line1") or "Station Road",
+				"city": kwargs.get("city") or "_Test City",
+				"state": kwargs.get("state") or "Test State",
+				"country": kwargs.get("country") or "India",
+				"links": [
+					{"link_doctype": "Customer", "link_name": kwargs.get("customer") or "_Test Customer"}
+				],
+			}
+		).insert()
+
+	if not frappe.db.get_value("Contact", {"first_name": kwargs.get("first_name")}):
+		contact = frappe.get_doc(
+			{
+				"doctype": "Contact",
+				"first_name": kwargs.get("first_name"),
+				"links": [
+					{"link_doctype": "Customer", "link_name": kwargs.get("customer") or "_Test Customer"}
+				],
+			}
+		)
+		contact.add_email(kwargs.get("email") or "test_contact_customer@example.com", is_primary=True)
+		contact.add_phone(kwargs.get("phone") or "+91 0000000000", is_primary_phone=True)
+		contact.insert()
+
 
 test_dependencies = [
 	"Sales Taxes and Charges Template",

erpnext/e_commerce/web_template/hero_slider/hero_slider.json

@@ -165,6 +165,7 @@
    "fieldname": "slide_3_content_align",
    "fieldtype": "Select",
    "label": "Content Align",
+   "options": "Left\nCentre\nRight",
    "reqd": 0
   },
   {
@@ -214,6 +215,7 @@
    "fieldname": "slide_4_content_align",
    "fieldtype": "Select",
    "label": "Content Align",
+   "options": "Left\nCentre\nRight",
    "reqd": 0
   },
   {
@@ -263,6 +265,7 @@
    "fieldname": "slide_5_content_align",
    "fieldtype": "Select",
    "label": "Content Align",
+   "options": "Left\nCentre\nRight",
    "reqd": 0
   },
   {
@@ -274,7 +277,7 @@
   }
  ],
  "idx": 2,
- "modified": "2021-02-24 15:57:05.889709",
+ "modified": "2023-05-12 15:03:57.604060",
  "modified_by": "Administrator",
  "module": "E-commerce",
  "name": "Hero Slider",

erpnext/erpnext_integrations/taxjar_integration.py

@@ -1,4 +1,5 @@
 import traceback
+<<<<<<< HEAD
 
 import frappe
 import taxjar
@@ -94,6 +95,26 @@ SUPPORTED_STATE_CODES = [
 	"WI",
 	"WY",
 ]
+=======
+import frappe
+import taxjar
+from erpnext import get_default_company
+from frappe import _
+from frappe.contacts.doctype.address.address import get_company_address
+from frappe.utils import cint
+
+TAX_ACCOUNT_HEAD = frappe.db.get_single_value("TaxJar Settings", "tax_account_head")
+SHIP_ACCOUNT_HEAD = frappe.db.get_single_value("TaxJar Settings", "shipping_account_head")
+TAXJAR_CREATE_TRANSACTIONS = frappe.db.get_single_value("TaxJar Settings", "taxjar_create_transactions")
+TAXJAR_CALCULATE_TAX = frappe.db.get_single_value("TaxJar Settings", "taxjar_calculate_tax")
+SUPPORTED_COUNTRY_CODES = ["AT", "AU", "BE", "BG", "CA", "CY", "CZ", "DE", "DK", "EE", "ES", "FI",
+	"FR", "GB", "GR", "HR", "HU", "IE", "IT", "LT", "LU", "LV", "MT", "NL", "PL", "PT", "RO",
+	"SE", "SI", "SK", "US"]
+SUPPORTED_STATE_CODES = ['AL', 'AK', 'AZ', 'AR', 'CA', 'CO', 'CT', 'DE', 'DC', 'FL', 'GA', 'HI', 'ID', 'IL',
+	'IN', 'IA', 'KS', 'KY', 'LA', 'ME', 'MD', 'MA', 'MI', 'MN', 'MS', 'MO', 'MT', 'NE',
+	'NV', 'NH', 'NJ', 'NM', 'NY', 'NC', 'ND', 'OH', 'OK', 'OR', 'PA', 'RI', 'SC', 'SD', 
+	'TN', 'TX', 'UT', 'VT', 'VA', 'WA', 'WV', 'WI', 'WY']
+>>>>>>> 7004944cc0 (feat: Taxjar Integration update (#27143))
 
 
 def get_client():
@@ -108,7 +129,13 @@ def get_client():
 
 	if api_key and api_url:
 		client = taxjar.Client(api_key=api_key, api_url=api_url)
+<<<<<<< HEAD
 		client.set_api_config("headers", {"x-api-version": "2022-01-24"})
+=======
+		client.set_api_config('headers', {
+				'x-api-version': '2020-08-07'
+			})
+>>>>>>> 7004944cc0 (feat: Taxjar Integration update (#27143))
 		return client
 
 
@@ -146,7 +173,11 @@ def create_transaction(doc, method):
 	try:
 		if doc.is_return:
 			client.create_refund(tax_dict)
+<<<<<<< HEAD
 		else:
+=======
+		else:	
+>>>>>>> 7004944cc0 (feat: Taxjar Integration update (#27143))
 			client.create_order(tax_dict)
 	except taxjar.exceptions.TaxJarResponseError as err:
 		frappe.throw(_(sanitize_error_response(err)))
@@ -186,6 +217,7 @@ def get_tax_data(doc):
 
 	shipping = sum([tax.tax_amount for tax in doc.taxes if tax.account_head == SHIP_ACCOUNT_HEAD])
 
+<<<<<<< HEAD
 	line_items = [get_line_item_dict(item, doc.docstatus) for item in doc.items]
 
 	if from_shipping_state not in SUPPORTED_STATE_CODES:
@@ -193,8 +225,18 @@ def get_tax_data(doc):
 
 	if to_shipping_state not in SUPPORTED_STATE_CODES:
 		to_shipping_state = get_state_code(to_address, "Shipping")
+=======
+	line_items = [get_line_item_dict(item) for item in doc.items]
+>>>>>>> 7004944cc0 (feat: Taxjar Integration update (#27143))
 
+	if from_shipping_state not in SUPPORTED_STATE_CODES:
+		from_shipping_state = get_state_code(from_address, 'Company')
+
+	if to_shipping_state not in SUPPORTED_STATE_CODES:
+		to_shipping_state = get_state_code(to_address, 'Shipping')
+	
 	tax_dict = {
+<<<<<<< HEAD
 		"from_country": from_country_code,
 		"from_zip": from_address.pincode,
 		"from_state": from_shipping_state,
@@ -234,9 +276,42 @@ def get_line_item_dict(item, docstatus):
 
 	if docstatus == 1:
 		tax_dict.update({"sales_tax": item.get("tax_collectable")})
+=======
+		'from_country': from_country_code,
+		'from_zip': from_address.pincode,
+		'from_state': from_shipping_state,
+		'from_city': from_address.city,
+		'from_street': from_address.address_line1,
+		'to_country': to_country_code,
+		'to_zip': to_address.pincode,
+		'to_city': to_address.city,
+		'to_street': to_address.address_line1,
+		'to_state': to_shipping_state,
+		'shipping': shipping,
+		'amount': doc.net_total,
+		'plugin': 'erpnext',
+		'line_items': line_items
+	}
+	return tax_dict	
+>>>>>>> 7004944cc0 (feat: Taxjar Integration update (#27143))
 
-	return tax_dict
+def get_state_code(address, location):
+	if address is not None:
+		state_code = get_iso_3166_2_state_code(address)
+		if state_code not in SUPPORTED_STATE_CODES:
+			frappe.throw(_("Please enter a valid State in the {0} Address").format(location))
+	else:
+		frappe.throw(_("Please enter a valid State in the {0} Address").format(location))
+	
+	return state_code
 
+def get_line_item_dict(item):
+	return dict( 
+		id = item.get('idx'),
+		quantity = item.get('qty'),
+		unit_price = item.get('rate'),
+		product_tax_code = item.get('product_tax_category')
+	)  	
 
 def set_sales_tax(doc, method):
 	TAX_ACCOUNT_HEAD = frappe.db.get_single_value("TaxJar Settings", "tax_account_head")
@@ -261,9 +336,12 @@ def set_sales_tax(doc, method):
 		setattr(doc, "taxes", [tax for tax in doc.taxes if tax.account_head != TAX_ACCOUNT_HEAD])
 		return
 
+<<<<<<< HEAD
 	# check if delivering within a nexus
 	check_for_nexus(doc, tax_dict)
 
+=======
+>>>>>>> 7004944cc0 (feat: Taxjar Integration update (#27143))
 	tax_data = validate_tax_request(tax_dict)
 	if tax_data is not None:
 		if not tax_data.amount_to_collect:
@@ -278,6 +356,7 @@ def set_sales_tax(doc, method):
 					doc.run_method("calculate_taxes_and_totals")
 					break
 			else:
+<<<<<<< HEAD
 				doc.append(
 					"taxes",
 					{
@@ -291,9 +370,36 @@ def set_sales_tax(doc, method):
 			for item in tax_data.breakdown.line_items:
 				doc.get("items")[cint(item.id) - 1].tax_collectable = item.tax_collectable
 				doc.get("items")[cint(item.id) - 1].taxable_amount = item.taxable_amount
+=======
+				doc.append("taxes", {
+					"charge_type": "Actual",
+					"description": "Sales Tax",
+					"account_head": TAX_ACCOUNT_HEAD,
+					"tax_amount": tax_data.amount_to_collect
+				})
+			# Assigning values to tax_collectable and taxable_amount fields in sales item table
+			for item in tax_data.breakdown.line_items:
+				doc.get('items')[cint(item.id)-1].tax_collectable = item.tax_collectable
+				doc.get('items')[cint(item.id)-1].taxable_amount = item.taxable_amount
+>>>>>>> 7004944cc0 (feat: Taxjar Integration update (#27143))
 
 			doc.run_method("calculate_taxes_and_totals")
 
+def check_sales_tax_exemption(doc):
+	# if the party is exempt from sales tax, then set all tax account heads to zero
+	sales_tax_exempted = hasattr(doc, "exempt_from_sales_tax") and doc.exempt_from_sales_tax \
+		or frappe.db.has_column("Customer", "exempt_from_sales_tax") \
+		and frappe.db.get_value("Customer", doc.customer, "exempt_from_sales_tax")
+
+	if sales_tax_exempted:
+		for tax in doc.taxes:
+			if tax.account_head == TAX_ACCOUNT_HEAD:
+				tax.tax_amount = 0
+				break
+		doc.run_method("calculate_taxes_and_totals")
+		return True
+	else: 
+		return False
 
 def check_for_nexus(doc, tax_dict):
 	TAX_ACCOUNT_HEAD = frappe.db.get_single_value("TaxJar Settings", "tax_account_head")
@@ -364,7 +470,11 @@ def get_shipping_address_details(doc):
 	if doc.shipping_address_name:
 		shipping_address = frappe.get_doc("Address", doc.shipping_address_name)
 	elif doc.customer_address:
+<<<<<<< HEAD
 		shipping_address = frappe.get_doc("Address", doc.customer_address)
+=======
+		shipping_address = frappe.get_doc("Address", doc.customer_address_name)
+>>>>>>> 7004944cc0 (feat: Taxjar Integration update (#27143))
 	else:
 		shipping_address = get_company_address_details(doc)
 

erpnext/hr/doctype/employee_advance/employee_advance.py

@@ -108,8 +108,8 @@ class EmployeeAdvance(Document):
 				EmployeeAdvanceOverPayment,
 			)
 
-		if flt(return_amount) > self.paid_amount - self.claimed_amount:
-			frappe.throw(_("Return amount cannot be greater unclaimed amount"))
+		if flt(return_amount) > 0 and flt(return_amount) > (self.paid_amount - self.claimed_amount):
+			frappe.throw(_("Return amount cannot be greater than unclaimed amount"))
 
 		self.db_set("paid_amount", paid_amount)
 		self.db_set("return_amount", return_amount)

erpnext/hr/doctype/leave_allocation/leave_allocation.py

@@ -296,18 +296,27 @@ class LeaveAllocation(Document):
 
 def get_previous_allocation(from_date, leave_type, employee):
 	"""Returns document properties of previous allocation"""
-	return frappe.db.get_value(
-		"Leave Allocation",
-		filters={
-			"to_date": ("<", from_date),
-			"leave_type": leave_type,
-			"employee": employee,
-			"docstatus": 1,
-		},
-		order_by="to_date DESC",
-		fieldname=["name", "from_date", "to_date", "employee", "leave_type"],
-		as_dict=1,
-	)
+	Allocation = frappe.qb.DocType("Leave Allocation")
+	allocations = (
+		frappe.qb.from_(Allocation)
+		.select(
+			Allocation.name,
+			Allocation.from_date,
+			Allocation.to_date,
+			Allocation.employee,
+			Allocation.leave_type,
+		)
+		.where(
+			(Allocation.employee == employee)
+			& (Allocation.leave_type == leave_type)
+			& (Allocation.to_date < from_date)
+			& (Allocation.docstatus == 1)
+		)
+		.orderby(Allocation.to_date, order=frappe.qb.desc)
+		.limit(1)
+	).run(as_dict=True)
+
+	return allocations[0] if allocations else None
 
 
 def get_leave_allocation_for_period(
@@ -333,7 +342,6 @@ def get_leave_allocation_for_period(
 	).run()[0][0] or 0.0
 
 
-@frappe.whitelist()
 def get_carry_forwarded_leaves(employee, leave_type, date, carry_forward=None):
 	"""Returns carry forwarded leaves for the given employee"""
 	unused_leaves = 0.0

erpnext/hr/doctype/leave_application/leave_application.py

@@ -706,19 +706,22 @@ def get_allocation_expiry_for_cf_leaves(
 	employee: str, leave_type: str, to_date: str, from_date: str
 ) -> str:
 	"""Returns expiry of carry forward allocation in leave ledger entry"""
-	expiry = frappe.get_all(
-		"Leave Ledger Entry",
-		filters={
-			"employee": employee,
-			"leave_type": leave_type,
-			"is_carry_forward": 1,
-			"transaction_type": "Leave Allocation",
-			"to_date": ["between", (from_date, to_date)],
-			"docstatus": 1,
-		},
-		fields=["to_date"],
-	)
-	return expiry[0]["to_date"] if expiry else ""
+	Ledger = frappe.qb.DocType("Leave Ledger Entry")
+	expiry = (
+		frappe.qb.from_(Ledger)
+		.select(Ledger.to_date)
+		.where(
+			(Ledger.employee == employee)
+			& (Ledger.leave_type == leave_type)
+			& (Ledger.is_carry_forward == 1)
+			& (Ledger.transaction_type == "Leave Allocation")
+			& (Ledger.to_date.between(from_date, to_date))
+			& (Ledger.docstatus == 1)
+		)
+		.limit(1)
+	).run()
+
+	return expiry[0][0] if expiry else ""
 
 
 @frappe.whitelist()
@@ -1017,7 +1020,7 @@ def get_leaves_for_period(
 			if leave_entry.leaves % 1:
 				half_day = 1
 				half_day_date = frappe.db.get_value(
-					"Leave Application", {"name": leave_entry.transaction_name}, ["half_day_date"]
+					"Leave Application", leave_entry.transaction_name, "half_day_date"
 				)
 
 			leave_days += (

erpnext/hr/doctype/leave_application/test_leave_application.py

@@ -713,25 +713,31 @@ class TestLeaveApplication(unittest.TestCase):
 		self.assertEqual(details.leave_balance, 30)
 
 	def test_earned_leaves_creation(self):
-		from erpnext.hr.utils import allocate_earned_leaves
+		from erpnext.hr.doctype.leave_policy_assignment.test_leave_policy_assignment import (
+			allocate_earned_leaves_for_months,
+		)
 
-		leave_period = get_leave_period()
+		year_start = get_year_start(getdate())
+		year_end = get_year_ending(getdate())
+		frappe.flags.current_date = year_start
+
+		leave_period = get_leave_period(year_start, year_end)
 		employee = get_employee()
 		leave_type = "Test Earned Leave Type"
+
 		make_policy_assignment(employee, leave_type, leave_period)
 
-		for i in range(0, 14):
-			allocate_earned_leaves()
-
-		self.assertEqual(get_leave_balance_on(employee.name, leave_type, nowdate()), 6)
+		# leaves for 6 months = 3, but max leaves restricts allocation to 2
+		frappe.db.set_value("Leave Type", leave_type, "max_leaves_allowed", 2)
+		allocate_earned_leaves_for_months(6)
+		self.assertEqual(get_leave_balance_on(employee.name, leave_type, frappe.flags.current_date), 2)
 
 		# validate earned leaves creation without maximum leaves
 		frappe.db.set_value("Leave Type", leave_type, "max_leaves_allowed", 0)
+		allocate_earned_leaves_for_months(5)
+		self.assertEqual(get_leave_balance_on(employee.name, leave_type, frappe.flags.current_date), 4.5)
 
-		for i in range(0, 6):
-			allocate_earned_leaves()
-
-		self.assertEqual(get_leave_balance_on(employee.name, leave_type, nowdate()), 9)
+		frappe.flags.current_date = None
 
 	# test to not consider current leave in leave balance while submitting
 	def test_current_leave_on_submit(self):
@@ -1254,7 +1260,7 @@ def set_leave_approver():
 	dept_doc.save(ignore_permissions=True)
 
 
-def get_leave_period():
+def get_leave_period(from_date=None, to_date=None):
 	leave_period_name = frappe.db.exists({"doctype": "Leave Period", "company": "_Test Company"})
 	if leave_period_name:
 		return frappe.get_doc("Leave Period", leave_period_name[0][0])
@@ -1263,8 +1269,8 @@ def get_leave_period():
 			dict(
 				name="Test Leave Period",
 				doctype="Leave Period",
-				from_date=add_months(nowdate(), -6),
-				to_date=add_months(nowdate(), 6),
+				from_date=from_date or add_months(nowdate(), -6),
+				to_date=to_date or add_months(nowdate(), 6),
 				company="_Test Company",
 				is_active=1,
 			)

erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.json

@@ -27,7 +27,8 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Employee",
-   "options": "Employee"
+   "options": "Employee",
+   "search_index": 1
   },
   {
    "fetch_from": "employee.employee_name",
@@ -57,13 +58,15 @@
    "fieldtype": "Link",
    "in_standard_filter": 1,
    "label": "Transaction Type",
-   "options": "DocType"
+   "options": "DocType",
+   "search_index": 1
   },
   {
    "fieldname": "transaction_name",
    "fieldtype": "Dynamic Link",
    "label": "Transaction Name",
-   "options": "transaction_type"
+   "options": "transaction_type",
+   "search_index": 1
   },
   {
    "fieldname": "leaves",
@@ -123,7 +126,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2021-01-04 18:47:45.146652",
+ "modified": "2023-11-17 12:36:36.963697",
  "modified_by": "Administrator",
  "module": "HR",
  "name": "Leave Ledger Entry",

erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py

@@ -225,3 +225,7 @@ def expire_carried_forward_allocation(allocation):
 			to_date=allocation.to_date,
 		)
 		create_leave_ledger_entry(allocation, args)
+
+
+def on_doctype_update():
+	frappe.db.add_index("Leave Ledger Entry", ["transaction_type", "transaction_name"])

erpnext/hr/doctype/leave_policy_assignment/leave_policy_assignment.py

@@ -8,7 +8,15 @@ from math import ceil
 import frappe
 from frappe import _, bold
 from frappe.model.document import Document
-from frappe.utils import date_diff, flt, formatdate, get_last_day, get_link_to_form, getdate
+from frappe.utils import (
+	comma_and,
+	date_diff,
+	flt,
+	formatdate,
+	get_last_day,
+	get_link_to_form,
+	getdate,
+)
 from six import string_types
 
 
@@ -66,7 +74,6 @@ class LeavePolicyAssignment(Document):
 				).format(frappe.bold(get_link_to_form("Leave Type", leave_type.name)))
 				frappe.msgprint(msg, indicator="orange", alert=True)
 
-	@frappe.whitelist()
 	def grant_leave_alloc_for_employee(self):
 		if self.leaves_allocated:
 			frappe.throw(_("Leave already have been assigned for this Leave Policy Assignment"))
@@ -93,7 +100,7 @@ class LeavePolicyAssignment(Document):
 			return leave_allocations
 
 	def create_leave_allocation(
-		self, leave_type, new_leaves_allocated, leave_type_details, date_of_joining
+		self, leave_type, annual_allocation, leave_type_details, date_of_joining
 	):
 		# Creates leave allocation for the given employee in the provided leave period
 		carry_forward = self.carry_forward
@@ -101,7 +108,7 @@ class LeavePolicyAssignment(Document):
 			carry_forward = 0
 
 		new_leaves_allocated = self.get_new_leaves(
-			leave_type, new_leaves_allocated, leave_type_details, date_of_joining
+			leave_type, annual_allocation, leave_type_details, date_of_joining
 		)
 
 		allocation = frappe.get_doc(
@@ -122,7 +129,7 @@ class LeavePolicyAssignment(Document):
 		allocation.submit()
 		return allocation.name, new_leaves_allocated
 
-	def get_new_leaves(self, leave_type, new_leaves_allocated, leave_type_details, date_of_joining):
+	def get_new_leaves(self, leave_type, annual_allocation, leave_type_details, date_of_joining):
 		from frappe.model.meta import get_field_precision
 
 		precision = get_field_precision(
@@ -139,20 +146,27 @@ class LeavePolicyAssignment(Document):
 			else:
 				# get leaves for past months if assignment is based on Leave Period / Joining Date
 				new_leaves_allocated = self.get_leaves_for_passed_months(
-					leave_type, new_leaves_allocated, leave_type_details, date_of_joining
+					leave_type, annual_allocation, leave_type_details, date_of_joining
 				)
 
 		# Calculate leaves at pro-rata basis for employees joining after the beginning of the given leave period
-		elif getdate(date_of_joining) > getdate(self.effective_from):
-			remaining_period = (date_diff(self.effective_to, date_of_joining) + 1) / (
-				date_diff(self.effective_to, self.effective_from) + 1
-			)
-			new_leaves_allocated = ceil(new_leaves_allocated * remaining_period)
+		else:
+			if getdate(date_of_joining) > getdate(self.effective_from):
+				remaining_period = (date_diff(self.effective_to, date_of_joining) + 1) / (
+					date_diff(self.effective_to, self.effective_from) + 1
+				)
+				new_leaves_allocated = ceil(annual_allocation * remaining_period)
+			else:
+				new_leaves_allocated = annual_allocation
+
+		# leave allocation should not exceed annual allocation as per policy assignment
+		if new_leaves_allocated > annual_allocation:
+			new_leaves_allocated = annual_allocation
 
 		return flt(new_leaves_allocated, precision)
 
 	def get_leaves_for_passed_months(
-		self, leave_type, new_leaves_allocated, leave_type_details, date_of_joining
+		self, leave_type, annual_allocation, leave_type_details, date_of_joining
 	):
 		from erpnext.hr.utils import get_monthly_earned_leave
 
@@ -177,7 +191,7 @@ class LeavePolicyAssignment(Document):
 
 		if months_passed > 0:
 			monthly_earned_leave = get_monthly_earned_leave(
-				new_leaves_allocated,
+				annual_allocation,
 				leave_type_details.get(leave_type).earned_leave_frequency,
 				leave_type_details.get(leave_type).rounding,
 			)
@@ -192,9 +206,9 @@ def add_current_month_if_applicable(months_passed, date_of_joining, based_on_doj
 	date = getdate(frappe.flags.current_date) or getdate()
 
 	if based_on_doj:
-		# if leave type allocation is based on DOJ, and the date of assignment creation is same as DOJ,
+		# if leave type allocation is based on DOJ, and the date of assignment creation is after DOJ,
 		# then the month should be considered
-		if date.day == date_of_joining.day:
+		if date.day >= date_of_joining.day:
 			months_passed += 1
 	else:
 		last_day_of_month = get_last_day(date)
@@ -207,7 +221,6 @@ def add_current_month_if_applicable(months_passed, date_of_joining, based_on_doj
 
 @frappe.whitelist()
 def create_assignment_for_multiple_employees(employees, data):
-
 	if isinstance(employees, string_types):
 		employees = json.loads(employees)
 
@@ -215,6 +228,8 @@ def create_assignment_for_multiple_employees(employees, data):
 		data = frappe._dict(json.loads(data))
 
 	docs_name = []
+	failed = []
+
 	for employee in employees:
 		assignment = frappe.new_doc("Leave Policy Assignment")
 		assignment.employee = employee
@@ -225,18 +240,45 @@ def create_assignment_for_multiple_employees(employees, data):
 		assignment.leave_period = data.leave_period or None
 		assignment.carry_forward = data.carry_forward
 		assignment.save()
-		try:
-			assignment.submit()
-		except frappe.exceptions.ValidationError:
-			continue
 
-		frappe.db.commit()
+		savepoint = "before_assignment_submission"
+
+		try:
+			frappe.db.savepoint(savepoint)
+			assignment.submit()
+		except Exception as e:
+			frappe.db.rollback(save_point=savepoint)
+			frappe.log_error(title=f"Leave Policy Assignment submission failed for {assignment.name}")
+			failed.append(assignment.name)
 
 		docs_name.append(assignment.name)
 
+	if failed:
+		show_assignment_submission_status(failed)
+
 	return docs_name
 
 
+def show_assignment_submission_status(failed):
+	frappe.clear_messages()
+	assignment_list = [get_link_to_form("Leave Policy Assignment", entry) for entry in failed]
+
+	msg = _("Failed to submit some leave policy assignments:")
+	msg += " " + comma_and(assignment_list, False) + "<hr>"
+	msg += (
+		_("Check {0} for more details")
+		.format("<a href='/app/List/Error Log?reference_doctype=Leave Policy Assignment'>{0}</a>")
+		.format(_("Error Log"))
+	)
+
+	frappe.msgprint(
+		msg,
+		indicator="red",
+		title=_("Submission Failed"),
+		is_minimizable=True,
+	)
+
+
 def get_leave_type_details():
 	leave_type_details = frappe._dict()
 	leave_types = frappe.get_all(

erpnext/hr/doctype/leave_policy_assignment/leave_policy_assignment_list.js

@@ -52,7 +52,7 @@ frappe.listview_settings['Leave Policy Assignment'] = {
 					get_query() {
 						let filters = {"is_active": 1};
 						if (cur_dialog.fields_dict.company.value)
-							filters["company"] = cur_dialog.fields_dict.company.value;
+							filters["company"] = cur_dialog?.fields_dict?.company?.value;
 
 						return {
 							filters: filters

erpnext/hr/doctype/leave_policy_assignment/test_leave_policy_assignment.py

@@ -5,8 +5,10 @@ import unittest
 
 import frappe
 from frappe.tests.utils import FrappeTestCase
-from frappe.utils import add_days, add_months, get_first_day, get_last_day, getdate
+from frappe.utils import add_days, add_months, get_first_day, get_last_day, get_year_start, getdate
 
+from erpnext.hr.doctype.leave_allocation.test_leave_allocation import create_leave_allocation
+from erpnext.hr.doctype.leave_application.leave_application import get_leave_balance_on
 from erpnext.hr.doctype.leave_application.test_leave_application import (
 	get_employee,
 	get_leave_period,
@@ -15,6 +17,7 @@ from erpnext.hr.doctype.leave_policy.test_leave_policy import create_leave_polic
 from erpnext.hr.doctype.leave_policy_assignment.leave_policy_assignment import (
 	create_assignment_for_multiple_employees,
 )
+from erpnext.hr.utils import allocate_earned_leaves
 
 test_dependencies = ["Employee"]
 
@@ -34,6 +37,8 @@ class TestLeavePolicyAssignment(FrappeTestCase):
 		self.original_doj = employee.date_of_joining
 		self.employee = employee
 
+		self.leave_type = "Test Earned Leave"
+
 	def test_grant_leaves(self):
 		leave_period = get_leave_period()
 		# allocation = 10
@@ -326,6 +331,90 @@ class TestLeavePolicyAssignment(FrappeTestCase):
 		self.assertEqual(effective_from, self.employee.date_of_joining)
 		self.assertEqual(leaves_allocated, 3)
 
+	def test_overallocation(self):
+		"""Tests if earned leave allocation does not exceed annual allocation"""
+		frappe.flags.current_date = get_year_start(getdate())
+		make_policy_assignment(
+			self.employee,
+			annual_allocation=22,
+			allocate_on_day="First Day",
+			start_date=frappe.flags.current_date,
+		)
+
+		# leaves for 12 months = 22
+		# With rounding, 22 leaves would be allocated in 11 months only
+		frappe.db.set_value("Leave Type", self.leave_type, "rounding", 1.0)
+		allocate_earned_leaves_for_months(11)
+		self.assertEqual(
+			get_leave_balance_on(self.employee.name, self.leave_type, frappe.flags.current_date), 22
+		)
+
+		# should not allocate more leaves than annual allocation
+		allocate_earned_leaves_for_months(1)
+		self.assertEqual(
+			get_leave_balance_on(self.employee.name, self.leave_type, frappe.flags.current_date), 22
+		)
+
+	def test_over_allocation_during_assignment_creation(self):
+		"""Tests backdated earned leave allocation does not exceed annual allocation"""
+		start_date = get_first_day(add_months(getdate(), -12))
+
+		# joining date set to 1Y ago
+		self.employee.date_of_joining = start_date
+		self.employee.save()
+
+		# create backdated assignment for last year
+		frappe.flags.current_date = get_first_day(getdate())
+
+		leave_policy_assignments = make_policy_assignment(
+			self.employee, start_date=start_date, allocate_on_day="Date of Joining"
+		)
+
+		# 13 months have passed but annual allocation = 12
+		# check annual allocation is not exceeded
+		leaves_allocated = get_allocated_leaves(leave_policy_assignments[0])
+		self.assertEqual(leaves_allocated, 12)
+
+	def test_overallocation_with_carry_forwarding(self):
+		"""Tests earned leave allocation with cf leaves does not exceed annual allocation"""
+		year_start = get_year_start(getdate())
+
+		# initial leave allocation = 5
+		leave_allocation = create_leave_allocation(
+			employee=self.employee.name,
+			employee_name=self.employee.employee_name,
+			leave_type=self.leave_type,
+			from_date=get_first_day(add_months(year_start, -1)),
+			to_date=get_last_day(add_months(year_start, -1)),
+			new_leaves_allocated=5,
+			carry_forward=0,
+		)
+		leave_allocation.submit()
+
+		frappe.flags.current_date = year_start
+		# carry forwarded leaves = 5
+		make_policy_assignment(
+			self.employee,
+			annual_allocation=22,
+			allocate_on_day="First Day",
+			start_date=year_start,
+			carry_forward=True,
+		)
+
+		frappe.db.set_value("Leave Type", self.leave_type, "rounding", 1.0)
+		allocate_earned_leaves_for_months(11)
+
+		# 5 carry forwarded leaves + 22 EL allocated = 27 leaves
+		self.assertEqual(
+			get_leave_balance_on(self.employee.name, self.leave_type, frappe.flags.current_date), 27
+		)
+
+		# should not allocate more leaves than annual allocation (22 excluding 5 cf leaves)
+		allocate_earned_leaves_for_months(1)
+		self.assertEqual(
+			get_leave_balance_on(self.employee.name, self.leave_type, frappe.flags.current_date), 27
+		)
+
 	def tearDown(self):
 		frappe.db.set_value("Employee", self.employee.name, "date_of_joining", self.original_doj)
 		frappe.flags.current_date = None
@@ -376,3 +465,51 @@ def setup_leave_period_and_policy(start_date, based_on_doj=False):
 	).insert()
 
 	return leave_period, leave_policy
+
+
+def make_policy_assignment(
+	employee,
+	allocate_on_day="Last Day",
+	earned_leave_frequency="Monthly",
+	start_date=None,
+	annual_allocation=12,
+	carry_forward=0,
+	assignment_based_on="Leave Period",
+):
+	leave_type = create_earned_leave_type("Test Earned Leave", allocate_on_day)
+	leave_period = create_leave_period("Test Earned Leave Period", start_date=start_date)
+	leave_policy = frappe.get_doc(
+		{
+			"doctype": "Leave Policy",
+			"title": "Test Earned Leave Policy",
+			"leave_policy_details": [
+				{"leave_type": leave_type.name, "annual_allocation": annual_allocation}
+			],
+		}
+	).insert()
+
+	data = {
+		"assignment_based_on": assignment_based_on,
+		"leave_policy": leave_policy.name,
+		"leave_period": leave_period.name,
+		"carry_forward": carry_forward,
+	}
+
+	leave_policy_assignments = create_assignment_for_multiple_employees(
+		[employee.name], frappe._dict(data)
+	)
+	return leave_policy_assignments
+
+
+def get_allocated_leaves(assignment):
+	return frappe.db.get_value(
+		"Leave Allocation",
+		{"leave_policy_assignment": assignment},
+		"total_leaves_allocated",
+	)
+
+
+def allocate_earned_leaves_for_months(months):
+	for i in range(0, months):
+		frappe.flags.current_date = add_months(frappe.flags.current_date, 1)
+		allocate_earned_leaves()

erpnext/hr/page/organizational_chart/organizational_chart.py

@@ -1,4 +1,5 @@
 import frappe
+from frappe.query_builder.functions import Count
 
 
 @frappe.whitelist()
@@ -15,31 +16,34 @@ def get_children(parent=None, company=None, exclude_node=None):
 	if exclude_node:
 		filters.append(["name", "!=", exclude_node])
 
-	employees = frappe.get_list(
+	employees = frappe.get_all(
 		"Employee",
-		fields=["employee_name as name", "name as id", "reports_to", "image", "designation as title"],
+		fields=[
+			"employee_name as name",
+			"name as id",
+			"lft",
+			"rgt",
+			"reports_to",
+			"image",
+			"designation as title",
+		],
 		filters=filters,
 		order_by="name",
 	)
 
 	for employee in employees:
-		is_expandable = frappe.db.count("Employee", filters={"reports_to": employee.get("id")})
-		employee.connections = get_connections(employee.id)
-		employee.expandable = 1 if is_expandable else 0
+		employee.connections = get_connections(employee.id, employee.lft, employee.rgt)
+		employee.expandable = bool(employee.connections)
 
 	return employees
 
 
-def get_connections(employee):
-	num_connections = 0
+def get_connections(employee: str, lft: int, rgt: int) -> int:
+	Employee = frappe.qb.DocType("Employee")
+	query = (
+		frappe.qb.from_(Employee)
+		.select(Count(Employee.name))
+		.where((Employee.lft > lft) & (Employee.rgt < rgt))
+	).run()
 
-	nodes_to_expand = frappe.get_list("Employee", filters=[["reports_to", "=", employee]])
-	num_connections += len(nodes_to_expand)
-
-	while nodes_to_expand:
-		parent = nodes_to_expand.pop(0)
-		descendants = frappe.get_list("Employee", filters=[["reports_to", "=", parent.name]])
-		num_connections += len(descendants)
-		nodes_to_expand.extend(descendants)
-
-	return num_connections
+	return query[0][0]

erpnext/hr/page/organizational_chart/test_organizational_chart.py

@@ -0,0 +1,52 @@
+# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+import unittest
+
+import frappe
+from frappe.tests.utils import FrappeTestCase
+
+from erpnext.hr.doctype.employee.test_employee import make_employee
+from erpnext.hr.page.organizational_chart.organizational_chart import get_children
+
+
+class TestOrganizationalChart(FrappeTestCase):
+	def setUp(self):
+		self.company = create_company("Test Org Chart").name
+		frappe.db.delete("Employee", {"company": self.company})
+
+	def test_get_children(self):
+		company = create_company("Test Org Chart").name
+		emp1 = make_employee("testemp1@mail.com", company=self.company)
+		emp2 = make_employee("testemp2@mail.com", company=self.company, reports_to=emp1)
+		emp3 = make_employee("testemp3@mail.com", company=self.company, reports_to=emp1)
+		make_employee("testemp4@mail.com", company=self.company, reports_to=emp2)
+
+		# root node
+		children = get_children(company=self.company)
+		self.assertEqual(len(children), 1)
+		self.assertEqual(children[0].id, emp1)
+		self.assertEqual(children[0].connections, 3)
+
+		# root's children
+		children = get_children(parent=emp1, company=self.company)
+		self.assertEqual(len(children), 2)
+		self.assertEqual(children[0].id, emp2)
+		self.assertEqual(children[0].connections, 1)
+		self.assertEqual(children[1].id, emp3)
+		self.assertEqual(children[1].connections, 0)
+
+
+def create_company(name):
+	if frappe.db.exists("Company", name):
+		return frappe.get_doc("Company", name)
+
+	company = frappe.new_doc("Company")
+	company.update(
+		{
+			"company_name": name,
+			"default_currency": "USD",
+			"country": "United States",
+		}
+	)
+	return company.insert()

erpnext/hr/report/employee_leave_balance/employee_leave_balance.json

@@ -1,26 +1,32 @@
 {
- "add_total_row": 0, 
- "apply_user_permissions": 1, 
- "creation": "2013-02-22 15:29:34", 
- "disabled": 0, 
- "docstatus": 0, 
- "doctype": "Report", 
- "idx": 3, 
- "is_standard": "Yes", 
- "modified": "2017-02-24 20:18:04.317397", 
- "modified_by": "Administrator", 
- "module": "HR", 
- "name": "Employee Leave Balance", 
- "owner": "Administrator", 
- "ref_doctype": "Employee", 
- "report_name": "Employee Leave Balance", 
- "report_type": "Script Report", 
+ "add_total_row": 0,
+ "columns": [],
+ "creation": "2013-02-22 15:29:34",
+ "disabled": 0,
+ "docstatus": 0,
+ "doctype": "Report",
+ "filters": [],
+ "idx": 3,
+ "is_standard": "Yes",
+ "letterhead": null,
+ "modified": "2023-11-17 13:28:40.669200",
+ "modified_by": "Administrator",
+ "module": "HR",
+ "name": "Employee Leave Balance",
+ "owner": "Administrator",
+ "prepared_report": 0,
+ "ref_doctype": "Employee",
+ "report_name": "Employee Leave Balance",
+ "report_type": "Script Report",
  "roles": [
   {
    "role": "HR User"
-  }, 
+  },
   {
    "role": "HR Manager"
+  },
+  {
+   "role": "Employee"
   }
  ]
 }

erpnext/hr/report/employee_leave_balance/employee_leave_balance.py

@@ -85,19 +85,10 @@ def get_columns() -> List[Dict]:
 
 
 def get_data(filters: Filters) -> List:
-	leave_types = frappe.db.get_list("Leave Type", pluck="name", order_by="name")
-	conditions = get_conditions(filters)
+	leave_types = get_leave_types()
+	active_employees = get_employees(filters)
 
-	user = frappe.session.user
-	department_approver_map = get_department_leave_approver_map(filters.department)
-
-	active_employees = frappe.get_list(
-		"Employee",
-		filters=conditions,
-		fields=["name", "employee_name", "department", "user_id", "leave_approver"],
-	)
-
-	precision = cint(frappe.db.get_single_value("System Settings", "float_precision", cache=True))
+	precision = cint(frappe.db.get_single_value("System Settings", "float_precision"))
 	consolidate_leave_types = len(active_employees) > 1 and filters.consolidate_leave_types
 	row = None
 
@@ -110,10 +101,6 @@ def get_data(filters: Filters) -> List:
 			row = frappe._dict({"leave_type": leave_type})
 
 		for employee in active_employees:
-			leave_approvers = department_approver_map.get(employee.department_name, []).append(
-				employee.leave_approver
-			)
-
 			if consolidate_leave_types:
 				row = frappe._dict()
 			else:
@@ -144,6 +131,35 @@ def get_data(filters: Filters) -> List:
 	return data
 
 
+def get_leave_types() -> List[str]:
+	LeaveType = frappe.qb.DocType("Leave Type")
+	leave_types = (frappe.qb.from_(LeaveType).select(LeaveType.name).orderby(LeaveType.name)).run(
+		as_dict=True
+	)
+	return [leave_type.name for leave_type in leave_types]
+
+
+def get_employees(filters: Filters) -> List[Dict]:
+	Employee = frappe.qb.DocType("Employee")
+	query = frappe.qb.from_(Employee).select(
+		Employee.name,
+		Employee.employee_name,
+		Employee.department,
+	)
+
+	for field in ["company", "department"]:
+		if filters.get(field):
+			query = query.where((getattr(Employee, field) == filters.get(field)))
+
+	if filters.get("employee"):
+		query = query.where(Employee.name == filters.get("employee"))
+
+	if filters.get("employee_status"):
+		query = query.where(Employee.status == filters.get("employee_status"))
+
+	return query.run(as_dict=True)
+
+
 def get_opening_balance(
 	employee: str, leave_type: str, filters: Filters, carry_forwarded_leaves: float
 ) -> float:
@@ -168,48 +184,6 @@ def get_opening_balance(
 	return opening_balance
 
 
-def get_conditions(filters: Filters) -> Dict:
-	conditions = {}
-
-	if filters.employee:
-		conditions["name"] = filters.employee
-
-	if filters.company:
-		conditions["company"] = filters.company
-
-	if filters.department:
-		conditions["department"] = filters.department
-
-	if filters.employee_status:
-		conditions["status"] = filters.employee_status
-
-	return conditions
-
-
-def get_department_leave_approver_map(department: Optional[str] = None):
-	# get current department and all its child
-	department_list = frappe.get_list(
-		"Department",
-		filters={"disabled": 0},
-		or_filters={"name": department, "parent_department": department},
-		pluck="name",
-	)
-	# retrieve approvers list from current department and from its subsequent child departments
-	approver_list = frappe.get_all(
-		"Department Approver",
-		filters={"parentfield": "leave_approvers", "parent": ("in", department_list)},
-		fields=["parent", "approver"],
-		as_list=True,
-	)
-
-	approvers = {}
-
-	for k, v in approver_list:
-		approvers.setdefault(k, []).append(v)
-
-	return approvers
-
-
 def get_allocated_and_expired_leaves(
 	from_date: str, to_date: str, employee: str, leave_type: str
 ) -> Tuple[float, float, float]:
@@ -244,7 +218,7 @@ def get_leave_ledger_entries(
 	from_date: str, to_date: str, employee: str, leave_type: str
 ) -> List[Dict]:
 	ledger = frappe.qb.DocType("Leave Ledger Entry")
-	records = (
+	return (
 		frappe.qb.from_(ledger)
 		.select(
 			ledger.employee,
@@ -270,8 +244,6 @@ def get_leave_ledger_entries(
 		)
 	).run(as_dict=True)
 
-	return records
-
 
 def get_chart_data(data: List, filters: Filters) -> Dict:
 	labels = []

erpnext/hr/report/employee_leave_balance_summary/employee_leave_balance_summary.py

@@ -6,9 +6,6 @@ import frappe
 from frappe import _
 
 from erpnext.hr.doctype.leave_application.leave_application import get_leave_details
-from erpnext.hr.report.employee_leave_balance.employee_leave_balance import (
-	get_department_leave_approver_map,
-)
 
 
 def execute(filters=None):
@@ -54,17 +51,11 @@ def get_data(filters, leave_types):
 	active_employees = frappe.get_all(
 		"Employee",
 		filters=conditions,
-		fields=["name", "employee_name", "department", "user_id", "leave_approver"],
+		fields=["name", "employee_name", "department", "user_id"],
 	)
 
-	department_approver_map = get_department_leave_approver_map(filters.get("department"))
-
 	data = []
 	for employee in active_employees:
-		leave_approvers = department_approver_map.get(employee.department_name, [])
-		if employee.leave_approver:
-			leave_approvers.append(employee.leave_approver)
-
 		row = [employee.name, employee.employee_name, employee.department]
 		available_leave = get_leave_details(employee.name, filters.date)
 		for leave_type in leave_types:

erpnext/hr/utils.py

@@ -459,7 +459,7 @@ def generate_leave_encashment():
 def allocate_earned_leaves():
 	"""Allocate earned leaves to Employees"""
 	e_leave_types = get_earned_leaves()
-	today = getdate()
+	today = frappe.flags.current_date or getdate()
 
 	for e_leave_type in e_leave_types:
 
@@ -496,18 +496,28 @@ def allocate_earned_leaves():
 
 
 def update_previous_leave_allocation(allocation, annual_allocation, e_leave_type):
+	allocation = frappe.get_doc("Leave Allocation", allocation.name)
+	annual_allocation = flt(annual_allocation, allocation.precision("total_leaves_allocated"))
+
 	earned_leaves = get_monthly_earned_leave(
 		annual_allocation, e_leave_type.earned_leave_frequency, e_leave_type.rounding
 	)
 
-	allocation = frappe.get_doc("Leave Allocation", allocation.name)
 	new_allocation = flt(allocation.total_leaves_allocated) + flt(earned_leaves)
+	new_allocation_without_cf = flt(
+		flt(allocation.get_existing_leave_count()) + flt(earned_leaves),
+		allocation.precision("total_leaves_allocated"),
+	)
 
 	if new_allocation > e_leave_type.max_leaves_allowed and e_leave_type.max_leaves_allowed > 0:
 		new_allocation = e_leave_type.max_leaves_allowed
 
-	if new_allocation != allocation.total_leaves_allocated:
-		today_date = today()
+	if (
+		new_allocation != allocation.total_leaves_allocated
+		# annual allocation as per policy should not be exceeded
+		and new_allocation_without_cf <= annual_allocation
+	):
+		today_date = frappe.flags.current_date or getdate()
 
 		allocation.db_set("total_leaves_allocated", new_allocation, update_modified=False)
 		create_additional_leave_ledger_entry(allocation, earned_leaves, today_date)

erpnext/loan_management/doctype/loan_disbursement/test_loan_disbursement.py

@@ -160,4 +160,3 @@ class TestLoanDisbursement(unittest.TestCase):
 		interest = per_day_interest * 15
 
 		self.assertEqual(amounts["pending_principal_amount"], 1500000)
-		self.assertEqual(amounts["interest_amount"], flt(interest + previous_interest, 2))

erpnext/loan_management/doctype/loan_interest_accrual/loan_interest_accrual.py

@@ -22,7 +22,7 @@ class LoanInterestAccrual(AccountsController):
 			frappe.throw(_("Interest Amount or Principal Amount is mandatory"))
 
 		if not self.last_accrual_date:
-			self.last_accrual_date = get_last_accrual_date(self.loan)
+			self.last_accrual_date = get_last_accrual_date(self.loan, self.posting_date)
 
 	def on_submit(self):
 		self.make_gl_entries()
@@ -274,14 +274,14 @@ def make_loan_interest_accrual_entry(args):
 
 
 def get_no_of_days_for_interest_accural(loan, posting_date):
-	last_interest_accrual_date = get_last_accrual_date(loan.name)
+	last_interest_accrual_date = get_last_accrual_date(loan.name, posting_date)
 
 	no_of_days = date_diff(posting_date or nowdate(), last_interest_accrual_date) + 1
 
 	return no_of_days
 
 
-def get_last_accrual_date(loan):
+def get_last_accrual_date(loan, posting_date):
 	last_posting_date = frappe.db.sql(
 		""" SELECT MAX(posting_date) from `tabLoan Interest Accrual`
 		WHERE loan = %s and docstatus = 1""",
@@ -289,12 +289,30 @@ def get_last_accrual_date(loan):
 	)
 
 	if last_posting_date[0][0]:
+		last_interest_accrual_date = last_posting_date[0][0]
 		# interest for last interest accrual date is already booked, so add 1 day
-		return add_days(last_posting_date[0][0], 1)
+		last_disbursement_date = get_last_disbursement_date(loan, posting_date)
+
+		if last_disbursement_date and getdate(last_disbursement_date) > add_days(
+			getdate(last_interest_accrual_date), 1
+		):
+			last_interest_accrual_date = last_disbursement_date
+
+		return add_days(last_interest_accrual_date, 1)
 	else:
 		return frappe.db.get_value("Loan", loan, "disbursement_date")
 
 
+def get_last_disbursement_date(loan, posting_date):
+	last_disbursement_date = frappe.db.get_value(
+		"Loan Disbursement",
+		{"docstatus": 1, "against_loan": loan, "posting_date": ("<=", posting_date)},
+		"MAX(posting_date)",
+	)
+
+	return last_disbursement_date
+
+
 def days_in_year(year):
 	days = 365
 

erpnext/loan_management/doctype/loan_repayment/loan_repayment.js

@@ -6,7 +6,12 @@
 frappe.ui.form.on('Loan Repayment', {
 	// refresh: function(frm) {
 
-	// }
+	// },
+
+	setup: function(frm) {
+		frm.add_fetch("against_loan", "repay_from_salary", "repay_from_salary");
+	},
+
 	onload: function(frm) {
 		frm.set_query('against_loan', function() {
 			return {

erpnext/loan_management/doctype/loan_repayment/loan_repayment.json

@@ -15,7 +15,6 @@
   "posting_date",
   "clearance_date",
   "rate_of_interest",
-  "payroll_payable_account",
   "is_term_loan",
   "repay_from_salary",
   "payment_details_section",
@@ -41,6 +40,7 @@
   "amended_from",
   "accounting_details_section",
   "payment_account",
+  "payroll_payable_account",
   "penalty_income_account",
   "column_break_36",
   "loan_account"
@@ -262,7 +262,6 @@
   },
   {
    "default": "0",
-   "fetch_from": "against_loan.repay_from_salary",
    "fieldname": "repay_from_salary",
    "fieldtype": "Check",
    "label": "Repay From Salary"
@@ -280,6 +279,7 @@
    "label": "Accounting Details"
   },
   {
+   "depends_on": "eval:!doc.repay_from_salary",
    "fetch_from": "against_loan.payment_account",
    "fetch_if_empty": 1,
    "fieldname": "payment_account",
@@ -311,11 +311,10 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-08-04 17:13:51.964203",
+ "modified": "2023-09-18 16:50:32.897005",
  "modified_by": "Administrator",
  "module": "Loan Management",
  "name": "Loan Repayment",
- "naming_rule": "Expression (old style)",
  "owner": "Administrator",
  "permissions": [
   {
@@ -351,6 +350,5 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "track_changes": 1
-}
+}

erpnext/loan_management/doctype/loan_repayment/loan_repayment.py

@@ -81,6 +81,11 @@ class LoanRepayment(AccountsController):
 		if amounts.get("due_date"):
 			self.due_date = amounts.get("due_date")
 
+		if self.repay_from_salary and not self.payroll_payable_account:
+			frappe.throw(_("Please set Payroll Payable Account in Loan Repayment"))
+		elif not self.repay_from_salary and self.payroll_payable_account:
+			self.repay_from_salary = 1
+
 	def check_future_entries(self):
 		future_repayment_date = frappe.db.get_value(
 			"Loan Repayment",
@@ -102,7 +107,7 @@ class LoanRepayment(AccountsController):
 		if flt(self.total_interest_paid, precision) > flt(self.interest_payable, precision):
 			if not self.is_term_loan:
 				# get last loan interest accrual date
-				last_accrual_date = get_last_accrual_date(self.against_loan)
+				last_accrual_date = get_last_accrual_date(self.against_loan, self.posting_date)
 
 				# get posting date upto which interest has to be accrued
 				per_day_interest = get_per_day_interest(
@@ -250,6 +255,9 @@ class LoanRepayment(AccountsController):
 		)
 
 	def check_future_accruals(self):
+		if self.is_term_loan:
+			return
+
 		future_accrual_date = frappe.db.get_value(
 			"Loan Interest Accrual",
 			{"posting_date": (">", self.posting_date), "docstatus": 1, "loan": self.against_loan},
@@ -724,7 +732,7 @@ def get_amounts(amounts, against_loan, posting_date):
 	if due_date:
 		pending_days = date_diff(posting_date, due_date) + 1
 	else:
-		last_accrual_date = get_last_accrual_date(against_loan_doc.name)
+		last_accrual_date = get_last_accrual_date(against_loan_doc.name, posting_date)
 		pending_days = date_diff(posting_date, last_accrual_date) + 1
 
 	if pending_days > 0:

erpnext/manufacturing/doctype/bom/bom.js

@@ -48,7 +48,8 @@ frappe.ui.form.on("BOM", {
 			return {
 				query: "erpnext.manufacturing.doctype.bom.bom.item_query",
 				filters: {
-					"item_code": doc.item
+					"include_item_in_manufacturing": 1,
+					"is_fixed_asset": 0
 				}
 			};
 		});

erpnext/manufacturing/doctype/bom/bom.py

@@ -1346,8 +1346,9 @@ def item_query(doctype, txt, searchfield, start, page_len, filters):
 		if not has_variants:
 			query_filters["has_variants"] = 0
 
-	if filters and filters.get("is_stock_item"):
-		query_filters["is_stock_item"] = 1
+	if filters:
+		for fieldname, value in filters.items():
+			query_filters[fieldname] = value
 
 	return frappe.get_list(
 		"Item",

erpnext/manufacturing/doctype/bom/test_bom.py

@@ -605,6 +605,45 @@ class TestBOM(FrappeTestCase):
 		bom.update_cost()
 		self.assertFalse(bom.flags.cost_updated)
 
+	def test_do_not_include_manufacturing_and_fixed_items(self):
+		from erpnext.manufacturing.doctype.bom.bom import item_query
+
+		if not frappe.db.exists("Asset Category", "Computers-Test"):
+			doc = frappe.get_doc({"doctype": "Asset Category", "asset_category_name": "Computers-Test"})
+			doc.flags.ignore_mandatory = True
+			doc.insert()
+
+		for item_code, properties in {
+			"_Test RM Item 1 Do Not Include In Manufacture": {
+				"is_stock_item": 1,
+				"include_item_in_manufacturing": 0,
+			},
+			"_Test RM Item 2 Fixed Asset Item": {
+				"is_fixed_asset": 1,
+				"is_stock_item": 0,
+				"asset_category": "Computers-Test",
+			},
+			"_Test RM Item 3 Manufacture Item": {"is_stock_item": 1, "include_item_in_manufacturing": 1},
+		}.items():
+			make_item(item_code, properties)
+
+		data = item_query(
+			"Item",
+			txt="_Test RM Item",
+			searchfield="name",
+			start=0,
+			page_len=20000,
+			filters={"include_item_in_manufacturing": 1, "is_fixed_asset": 0},
+		)
+
+		items = []
+		for row in data:
+			items.append(row[0])
+
+		self.assertTrue("_Test RM Item 1 Do Not Include In Manufacture" not in items)
+		self.assertTrue("_Test RM Item 2 Fixed Asset Item" not in items)
+		self.assertTrue("_Test RM Item 3 Manufacture Item" in items)
+
 
 def get_default_bom(item_code="_Test FG Item 2"):
 	return frappe.db.get_value("BOM", {"item": item_code, "is_active": 1, "is_default": 1})

erpnext/manufacturing/doctype/bom_update_log/bom_update_log.py

@@ -79,6 +79,7 @@ class BOMUpdateLog(Document):
 		else:
 			frappe.enqueue(
 				method="erpnext.manufacturing.doctype.bom_update_log.bom_update_log.process_boms_cost_level_wise",
+				queue="long",
 				update_doc=self,
 				now=frappe.flags.in_test,
 			)

erpnext/manufacturing/doctype/bom_update_log/bom_updation_utils.py

@@ -157,12 +157,21 @@ def get_next_higher_level_boms(
 def get_leaf_boms() -> List[str]:
 	"Get BOMs that have no dependencies."
 
-	return frappe.db.sql_list(
-		"""select name from `tabBOM` bom
-		where docstatus=1 and is_active=1
-			and not exists(select bom_no from `tabBOM Item`
-				where parent=bom.name and ifnull(bom_no, '')!='')"""
-	)
+	bom = frappe.qb.DocType("BOM")
+	bom_item = frappe.qb.DocType("BOM Item")
+
+	boms = (
+		frappe.qb.from_(bom)
+		.left_join(bom_item)
+		.on((bom.name == bom_item.parent) & (bom_item.bom_no != ""))
+		.select(bom.name)
+		.where((bom.docstatus == 1) & (bom.is_active == 1) & (bom_item.bom_no.isnull()))
+		.distinct()
+	).run(as_list=True)
+
+	boms = [bom[0] for bom in boms]
+
+	return boms
 
 
 def _generate_dependence_map() -> defaultdict:

erpnext/manufacturing/doctype/job_card/job_card.json

@@ -420,7 +420,7 @@
  ],
  "is_submittable": 1,
  "links": [],
- "modified": "2021-11-12 10:15:06.572401",
+ "modified": "2023-05-22 23:26:57.589331",
  "modified_by": "Administrator",
  "module": "Manufacturing",
  "name": "Job Card",

erpnext/manufacturing/doctype/job_card/job_card.py

@@ -657,7 +657,7 @@ class JobCard(Document):
 		self.status = {0: "Open", 1: "Submitted", 2: "Cancelled"}[self.docstatus or 0]
 
 		if self.docstatus < 2:
-			if self.for_quantity <= self.transferred_qty:
+			if flt(self.for_quantity) <= flt(self.transferred_qty):
 				self.status = "Material Transferred"
 
 			if self.time_logs:

erpnext/manufacturing/doctype/production_plan/production_plan.py

@@ -675,10 +675,9 @@ class ProductionPlan(Document):
 			material_request.flags.ignore_permissions = 1
 			material_request.run_method("set_missing_values")
 
+			material_request.save()
 			if self.get("submit_material_request"):
 				material_request.submit()
-			else:
-				material_request.save()
 
 		frappe.flags.mute_messages = False
 

erpnext/manufacturing/report/quality_inspection_summary/quality_inspection_summary.py

@@ -69,7 +69,7 @@ def get_columns(filters):
 			"label": _("Id"),
 			"fieldname": "name",
 			"fieldtype": "Link",
-			"options": "Work Order",
+			"options": "Quality Inspection",
 			"width": 100,
 		},
 		{"label": _("Report Date"), "fieldname": "report_date", "fieldtype": "Date", "width": 150},

erpnext/patches.txt

@@ -307,9 +307,15 @@ erpnext.patches.v13_0.remove_bad_selling_defaults
 erpnext.patches.v13_0.trim_whitespace_from_serial_nos  # 16-01-2022
 erpnext.patches.v13_0.migrate_stripe_api
 erpnext.patches.v13_0.reset_clearance_date_for_intracompany_payment_entries
+<<<<<<< HEAD
 execute:frappe.reload_doc("erpnext_integrations", "doctype", "TaxJar Settings")
 execute:frappe.reload_doc("erpnext_integrations", "doctype", "Product Tax Category")
 erpnext.patches.v13_0.custom_fields_for_taxjar_integration          #08-11-2021
+=======
+erpnext.patches.v13_0.einvoicing_deprecation_warning
+erpnext.patches.v13_0.custom_fields_for_taxjar_integration
+erpnext.patches.v14_0.delete_einvoicing_doctypes
+>>>>>>> 7004944cc0 (feat: Taxjar Integration update (#27143))
 erpnext.patches.v13_0.set_operation_time_based_on_operating_cost
 erpnext.patches.v13_0.create_website_items #30-09-2021
 erpnext.patches.v13_0.populate_e_commerce_settings
@@ -377,3 +383,5 @@ execute:frappe.db.set_value("Naming Series", "Naming Series", {"select_doc_for_s
 erpnext.patches.v13_0.update_schedule_type_in_loans
 erpnext.patches.v13_0.update_asset_value_for_manual_depr_entries
 erpnext.patches.v13_0.update_docs_link
+erpnext.patches.v13_0.correct_asset_value_if_je_with_workflow
+execute:frappe.db.set_value("Accounts Settings", "Accounts Settings", "service_provider", "frankfurter.app")

erpnext/patches/v13_0/convert_qi_parameter_to_link_field.py

@@ -3,23 +3,27 @@ import frappe
 
 def execute():
 	frappe.reload_doc("stock", "doctype", "quality_inspection_parameter")
+	params = set()
 
-	# get all distinct parameters from QI readigs table
-	reading_params = frappe.db.get_all(
-		"Quality Inspection Reading", fields=["distinct specification"]
-	)
-	reading_params = [d.specification for d in reading_params]
+	# get all parameters from QI readings table
+	for (p,) in frappe.db.get_all(
+		"Quality Inspection Reading", fields=["specification"], as_list=True
+	):
+		params.add(p.strip())
 
-	# get all distinct parameters from QI Template as some may be unused in QI
-	template_params = frappe.db.get_all(
-		"Item Quality Inspection Parameter", fields=["distinct specification"]
-	)
-	template_params = [d.specification for d in template_params]
+	# get all parameters from QI Template as some may be unused in QI
+	for (p,) in frappe.db.get_all(
+		"Item Quality Inspection Parameter", fields=["specification"], as_list=True
+	):
+		params.add(p.strip())
 
-	params = list(set(reading_params + template_params))
+	# because db primary keys are case insensitive, so duplicates will cause an exception
+	params = set({x.casefold(): x for x in params}.values())
 
 	for parameter in params:
-		if not frappe.db.exists("Quality Inspection Parameter", parameter):
-			frappe.get_doc(
-				{"doctype": "Quality Inspection Parameter", "parameter": parameter, "description": parameter}
-			).insert(ignore_permissions=True)
+		if frappe.db.exists("Quality Inspection Parameter", parameter):
+			continue
+
+		frappe.get_doc(
+			{"doctype": "Quality Inspection Parameter", "parameter": parameter, "description": parameter}
+		).insert(ignore_permissions=True)

erpnext/patches/v13_0/correct_asset_value_if_je_with_workflow.py

@@ -0,0 +1,119 @@
+import frappe
+from frappe.model.workflow import get_workflow_name
+from frappe.query_builder.functions import IfNull, Sum
+
+
+def execute():
+	active_je_workflow = get_workflow_name("Journal Entry")
+	if not active_je_workflow:
+		return
+
+	correct_value_for_assets_with_manual_depr_entries()
+
+	finance_books = frappe.db.get_all("Finance Book", pluck="name")
+
+	if finance_books:
+		for fb_name in finance_books:
+			correct_value_for_assets_with_auto_depr(fb_name)
+
+	correct_value_for_assets_with_auto_depr()
+
+
+def correct_value_for_assets_with_manual_depr_entries():
+	asset = frappe.qb.DocType("Asset")
+	gle = frappe.qb.DocType("GL Entry")
+	aca = frappe.qb.DocType("Asset Category Account")
+	company = frappe.qb.DocType("Company")
+
+	asset_details_and_depr_amount_map = (
+		frappe.qb.from_(gle)
+		.join(asset)
+		.on(gle.against_voucher == asset.name)
+		.join(aca)
+		.on((aca.parent == asset.asset_category) & (aca.company_name == asset.company))
+		.join(company)
+		.on(company.name == asset.company)
+		.select(
+			asset.name.as_("asset_name"),
+			asset.gross_purchase_amount.as_("gross_purchase_amount"),
+			asset.opening_accumulated_depreciation.as_("opening_accumulated_depreciation"),
+			Sum(gle.debit).as_("depr_amount"),
+		)
+		.where(
+			gle.account == IfNull(aca.depreciation_expense_account, company.depreciation_expense_account)
+		)
+		.where(gle.debit != 0)
+		.where(gle.is_cancelled == 0)
+		.where(asset.docstatus == 1)
+		.where(asset.calculate_depreciation == 0)
+		.groupby(asset.name)
+	)
+
+	frappe.qb.update(asset).join(asset_details_and_depr_amount_map).on(
+		asset_details_and_depr_amount_map.asset_name == asset.name
+	).set(
+		asset.value_after_depreciation,
+		asset_details_and_depr_amount_map.gross_purchase_amount
+		- asset_details_and_depr_amount_map.opening_accumulated_depreciation
+		- asset_details_and_depr_amount_map.depr_amount,
+	).run()
+
+
+def correct_value_for_assets_with_auto_depr(fb_name=None):
+	asset = frappe.qb.DocType("Asset")
+	gle = frappe.qb.DocType("GL Entry")
+	aca = frappe.qb.DocType("Asset Category Account")
+	company = frappe.qb.DocType("Company")
+	afb = frappe.qb.DocType("Asset Finance Book")
+
+	asset_details_and_depr_amount_map = (
+		frappe.qb.from_(gle)
+		.join(asset)
+		.on(gle.against_voucher == asset.name)
+		.join(aca)
+		.on((aca.parent == asset.asset_category) & (aca.company_name == asset.company))
+		.join(company)
+		.on(company.name == asset.company)
+		.select(
+			asset.name.as_("asset_name"),
+			asset.gross_purchase_amount.as_("gross_purchase_amount"),
+			asset.opening_accumulated_depreciation.as_("opening_accumulated_depreciation"),
+			Sum(gle.debit).as_("depr_amount"),
+		)
+		.where(
+			gle.account == IfNull(aca.depreciation_expense_account, company.depreciation_expense_account)
+		)
+		.where(gle.debit != 0)
+		.where(gle.is_cancelled == 0)
+		.where(asset.docstatus == 1)
+		.where(asset.calculate_depreciation == 1)
+		.groupby(asset.name)
+	)
+
+	if fb_name:
+		asset_details_and_depr_amount_map = asset_details_and_depr_amount_map.where(
+			gle.finance_book == fb_name
+		)
+	else:
+		asset_details_and_depr_amount_map = asset_details_and_depr_amount_map.where(
+			(gle.finance_book.isin([""])) | (gle.finance_book.isnull())
+		)
+
+	query = (
+		frappe.qb.update(afb)
+		.join(asset_details_and_depr_amount_map)
+		.on(asset_details_and_depr_amount_map.asset_name == afb.parent)
+		.set(
+			afb.value_after_depreciation,
+			asset_details_and_depr_amount_map.gross_purchase_amount
+			- asset_details_and_depr_amount_map.opening_accumulated_depreciation
+			- asset_details_and_depr_amount_map.depr_amount,
+		)
+	)
+
+	if fb_name:
+		query = query.where(afb.finance_book == fb_name)
+	else:
+		query = query.where((afb.finance_book.isin([""])) | (afb.finance_book.isnull()))
+
+	query.run()

erpnext/patches/v13_0/custom_fields_for_taxjar_integration.py

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 import frappe
 from frappe.custom.doctype.custom_field.custom_field import create_custom_fields
 
@@ -70,3 +71,34 @@ def execute():
 		"erpnext.erpnext_integrations.doctype.taxjar_settings.taxjar_settings.add_product_tax_categories",
 		now=True,
 	)
+=======
+from __future__ import unicode_literals
+import frappe
+from frappe.custom.doctype.custom_field.custom_field import create_custom_fields
+from erpnext.regional.united_states.setup import add_permissions
+
+def execute():
+	company = frappe.get_all('Company', filters = {'country': 'United States'}, fields=['name'])
+	if not company:
+		return
+
+	frappe.reload_doc("regional", "doctype", "product_tax_category")
+
+	custom_fields = {
+		'Sales Invoice Item': [
+			dict(fieldname='product_tax_category', fieldtype='Link', insert_after='description', options='Product Tax Category',
+				label='Product Tax Category', fetch_from='item_code.product_tax_category'),
+			dict(fieldname='tax_collectable', fieldtype='Currency', insert_after='net_amount', 
+				label='Tax Collectable', read_only=1),
+			dict(fieldname='taxable_amount', fieldtype='Currency', insert_after='tax_collectable', 
+				label='Taxable Amount', read_only=1)
+		],
+		'Item': [
+			dict(fieldname='product_tax_category', fieldtype='Link', insert_after='item_group', options='Product Tax Category',
+				label='Product Tax Category')
+		]
+	}
+	create_custom_fields(custom_fields, update=True)
+	add_permissions()
+	frappe.enqueue('erpnext.regional.united_states.setup.add_product_tax_categories', now=True)
+>>>>>>> 7004944cc0 (feat: Taxjar Integration update (#27143))