Merge branch 'version-13' of https://github.com/frappe/erpnext into enterprise-hotfix

.github/helper/install.sh

@@ -2,13 +2,6 @@
 
 set -e
 
-# Check for merge conflicts before proceeding
-python -m compileall -f "${GITHUB_WORKSPACE}"
-if grep -lr --exclude-dir=node_modules "^<<<<<<< " "${GITHUB_WORKSPACE}"
-    then echo "Found merge conflicts"
-    exit 1
-fi
-
 cd ~ || exit
 
 sudo apt-get install redis-server libcups2-dev

.github/workflows/release.yml

@@ -1,31 +0,0 @@
-name: Generate Semantic Release
-on:
-  push:
-    branches:
-      - version-13
-jobs:
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Entire Repository
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-          persist-credentials: false
-      - name: Setup Node.js v14
-        uses: actions/setup-node@v2
-        with:
-          node-version: 14
-      - name: Setup dependencies
-        run: |
-          npm install @semantic-release/git @semantic-release/exec --no-save
-      - name: Create Release
-        env:
-          GH_TOKEN: ${{ secrets.RELEASE_TOKEN }}
-          GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
-          GIT_AUTHOR_NAME: "Frappe PR Bot"
-          GIT_AUTHOR_EMAIL: "developers@frappe.io"
-          GIT_COMMITTER_NAME: "Frappe PR Bot"
-          GIT_COMMITTER_EMAIL: "developers@frappe.io"
-        run: npx semantic-release

.releaserc

@@ -1,24 +0,0 @@
-{
-	"branches": ["version-13"],
-	"plugins": [
-		"@semantic-release/commit-analyzer", {
-			"preset": "angular",
-			"releaseRules": [
-				{"breaking": true, "release": false}
-			]
-		},
-		"@semantic-release/release-notes-generator",
-		[
-			"@semantic-release/exec", {
-				"prepareCmd": 'sed -ir "s/[0-9]*\.[0-9]*\.[0-9]*/${nextRelease.version}/" erpnext/__init__.py'
-			}
-		],
-		[
-			"@semantic-release/git", {
-				"assets": ["erpnext/__init__.py"],
-				"message": "chore(release): Bumped to Version ${nextRelease.version}\n\n${nextRelease.notes}"
-			}
-		],
-		"@semantic-release/github"
-	]
-}

erpnext/__init__.py

@@ -4,8 +4,7 @@ import frappe
 
 from erpnext.hooks import regional_overrides
 
-__version__ = "13.30.0"
-
+__version__ = "13.26.0"
 
 def get_default_company(user=None):
 	"""Get default company for user"""

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -99,7 +99,7 @@ def make_dimension_in_accounting_doctypes(doc, doclist=None):
 			if doctype == "Budget":
 				add_dimension_to_budget_doctype(df.copy(), doc)
 			else:
-				create_custom_field(doctype, df, ignore_validate=True)
+				create_custom_field(doctype, df)
 
 		count += 1
 
@@ -115,7 +115,7 @@ def add_dimension_to_budget_doctype(df, doc):
 		}
 	)
 
-	create_custom_field("Budget", df, ignore_validate=True)
+	create_custom_field("Budget", df)
 
 	property_setter = frappe.db.exists("Property Setter", "Budget-budget_against-options")
 
@@ -205,16 +205,10 @@ def get_doctypes_with_dimensions():
 	return frappe.get_hooks("accounting_dimension_doctypes")
 
 
-def get_accounting_dimensions(as_list=True, filters=None):
-
-	if not filters:
-		filters = {"disabled": 0}
-
+def get_accounting_dimensions(as_list=True):
 	if frappe.flags.accounting_dimensions is None:
 		frappe.flags.accounting_dimensions = frappe.get_all(
-			"Accounting Dimension",
-			fields=["label", "fieldname", "disabled", "document_type"],
-			filters=filters,
+			"Accounting Dimension", fields=["label", "fieldname", "disabled", "document_type"]
 		)
 
 	if as_list:
@@ -234,19 +228,17 @@ def get_checks_for_pl_and_bs_accounts():
 	return dimensions
 
 
-def get_dimension_with_children(doctype, dimensions):
+def get_dimension_with_children(doctype, dimension):
 
-	if isinstance(dimensions, str):
-		dimensions = [dimensions]
+	if isinstance(dimension, list):
+		dimension = dimension[0]
 
 	all_dimensions = []
-
-	for dimension in dimensions:
-		lft, rgt = frappe.db.get_value(doctype, dimension, ["lft", "rgt"])
-		children = frappe.get_all(
-			doctype, filters={"lft": [">=", lft], "rgt": ["<=", rgt]}, order_by="lft"
-		)
-		all_dimensions += [c.name for c in children]
+	lft, rgt = frappe.db.get_value(doctype, dimension, ["lft", "rgt"])
+	children = frappe.get_all(
+		doctype, filters={"lft": [">=", lft], "rgt": ["<=", rgt]}, order_by="lft"
+	)
+	all_dimensions += [c.name for c in children]
 
 	return all_dimensions
 

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -5,10 +5,7 @@
 import frappe
 from frappe import _, msgprint
 from frappe.model.document import Document
-from frappe.query_builder.custom import ConstantColumn
-from frappe.utils import flt, fmt_money, getdate
-
-import erpnext
+from frappe.utils import flt, fmt_money, getdate, nowdate
 
 form_grid_templates = {"journal_entries": "templates/form_grid/bank_reconciliation_grid.html"}
 
@@ -79,53 +76,6 @@ class BankClearance(Document):
 			as_dict=1,
 		)
 
-		loan_disbursement = frappe.qb.DocType("Loan Disbursement")
-
-		loan_disbursements = (
-			frappe.qb.from_(loan_disbursement)
-			.select(
-				ConstantColumn("Loan Disbursement").as_("payment_document"),
-				loan_disbursement.name.as_("payment_entry"),
-				loan_disbursement.disbursed_amount.as_("credit"),
-				ConstantColumn(0).as_("debit"),
-				loan_disbursement.reference_number.as_("cheque_number"),
-				loan_disbursement.reference_date.as_("cheque_date"),
-				loan_disbursement.disbursement_date.as_("posting_date"),
-				loan_disbursement.applicant.as_("against_account"),
-			)
-			.where(loan_disbursement.docstatus == 1)
-			.where(loan_disbursement.disbursement_date >= self.from_date)
-			.where(loan_disbursement.disbursement_date <= self.to_date)
-			.where(loan_disbursement.clearance_date.isnull())
-			.where(loan_disbursement.disbursement_account.isin([self.bank_account, self.account]))
-			.orderby(loan_disbursement.disbursement_date)
-			.orderby(loan_disbursement.name, frappe.qb.desc)
-		).run(as_dict=1)
-
-		loan_repayment = frappe.qb.DocType("Loan Repayment")
-
-		loan_repayments = (
-			frappe.qb.from_(loan_repayment)
-			.select(
-				ConstantColumn("Loan Repayment").as_("payment_document"),
-				loan_repayment.name.as_("payment_entry"),
-				loan_repayment.amount_paid.as_("debit"),
-				ConstantColumn(0).as_("credit"),
-				loan_repayment.reference_number.as_("cheque_number"),
-				loan_repayment.reference_date.as_("cheque_date"),
-				loan_repayment.applicant.as_("against_account"),
-				loan_repayment.posting_date,
-			)
-			.where(loan_repayment.docstatus == 1)
-			.where(loan_repayment.clearance_date.isnull())
-			.where(loan_repayment.repay_from_salary == 0)
-			.where(loan_repayment.posting_date >= self.from_date)
-			.where(loan_repayment.posting_date <= self.to_date)
-			.where(loan_repayment.payment_account.isin([self.bank_account, self.account]))
-			.orderby(loan_repayment.posting_date)
-			.orderby(loan_repayment.name, frappe.qb.desc)
-		).run(as_dict=1)
-
 		pos_sales_invoices, pos_purchase_invoices = [], []
 		if self.include_pos_transactions:
 			pos_sales_invoices = frappe.db.sql(
@@ -164,29 +114,20 @@ class BankClearance(Document):
 
 		entries = sorted(
 			list(payment_entries)
-			+ list(journal_entries)
-			+ list(pos_sales_invoices)
-			+ list(pos_purchase_invoices)
-			+ list(loan_disbursements)
-			+ list(loan_repayments),
-			key=lambda k: getdate(k["posting_date"]),
+			+ list(journal_entries + list(pos_sales_invoices) + list(pos_purchase_invoices)),
+			key=lambda k: k["posting_date"] or getdate(nowdate()),
 		)
 
 		self.set("payment_entries", [])
 		self.total_amount = 0.0
-		default_currency = erpnext.get_default_currency()
 
 		for d in entries:
 			row = self.append("payment_entries", {})
 
 			amount = flt(d.get("debit", 0)) - flt(d.get("credit", 0))
 
-			if not d.get("account_currency"):
-				d.account_currency = default_currency
-
 			formatted_amount = fmt_money(abs(amount), 2, d.account_currency)
 			d.amount = formatted_amount + " " + (_("Dr") if amount > 0 else _("Cr"))
-			d.posting_date = getdate(d.posting_date)
 
 			d.pop("credit")
 			d.pop("debit")

erpnext/accounts/doctype/bank_clearance/test_bank_clearance.py

@@ -1,96 +1,9 @@
 # Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+# import frappe
 import unittest
 
-import frappe
-from frappe.utils import add_months, getdate
-
-from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
-from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
-from erpnext.loan_management.doctype.loan.test_loan import (
-	create_loan,
-	create_loan_accounts,
-	create_loan_type,
-	create_repayment_entry,
-	make_loan_disbursement_entry,
-)
-
 
 class TestBankClearance(unittest.TestCase):
-	@classmethod
-	def setUpClass(cls):
-		make_bank_account()
-		create_loan_accounts()
-		create_loan_masters()
-		add_transactions()
-
-	# Basic test case to test if bank clearance tool doesn't break
-	# Detailed test can be added later
-	def test_bank_clearance(self):
-		bank_clearance = frappe.get_doc("Bank Clearance")
-		bank_clearance.account = "_Test Bank Clearance - _TC"
-		bank_clearance.from_date = add_months(getdate(), -1)
-		bank_clearance.to_date = getdate()
-		bank_clearance.get_payment_entries()
-		self.assertEqual(len(bank_clearance.payment_entries), 3)
-
-
-def make_bank_account():
-	if not frappe.db.get_value("Account", "_Test Bank Clearance - _TC"):
-		frappe.get_doc(
-			{
-				"doctype": "Account",
-				"account_type": "Bank",
-				"account_name": "_Test Bank Clearance",
-				"company": "_Test Company",
-				"parent_account": "Bank Accounts - _TC",
-			}
-		).insert()
-
-
-def create_loan_masters():
-	create_loan_type(
-		"Clearance Loan",
-		2000000,
-		13.5,
-		25,
-		0,
-		5,
-		"Cash",
-		"_Test Bank Clearance - _TC",
-		"_Test Bank Clearance - _TC",
-		"Loan Account - _TC",
-		"Interest Income Account - _TC",
-		"Penalty Income Account - _TC",
-	)
-
-
-def add_transactions():
-	make_payment_entry()
-	make_loan()
-
-
-def make_loan():
-	loan = create_loan(
-		"_Test Customer",
-		"Clearance Loan",
-		280000,
-		"Repay Over Number of Periods",
-		20,
-		applicant_type="Customer",
-	)
-	loan.submit()
-	make_loan_disbursement_entry(loan.name, loan.loan_amount, disbursement_date=getdate())
-	repayment_entry = create_repayment_entry(loan.name, "_Test Customer", getdate(), loan.loan_amount)
-	repayment_entry.save()
-	repayment_entry.submit()
-
-
-def make_payment_entry():
-	pi = make_purchase_invoice(supplier="_Test Supplier", qty=1, rate=690)
-	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank Clearance - _TC")
-	pe.reference_no = "Conrad Oct 18"
-	pe.reference_date = "2018-10-24"
-	pe.insert()
-	pe.submit()
+	pass

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -467,7 +467,6 @@ def get_lr_matching_query(bank_account, amount_condition, filters):
 			loan_repayment.posting_date,
 		)
 		.where(loan_repayment.docstatus == 1)
-		.where(loan_repayment.repay_from_salary == 0)
 		.where(loan_repayment.clearance_date.isnull())
 		.where(loan_repayment.payment_account == bank_account)
 	)

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -19,6 +19,7 @@ from erpnext.accounts.doctype.tax_withholding_category.tax_withholding_category
 )
 from erpnext.accounts.party import get_party_account
 from erpnext.accounts.utils import (
+	check_if_stock_and_account_balance_synced,
 	get_account_currency,
 	get_balance_on,
 	get_stock_accounts,
@@ -87,6 +88,9 @@ class JournalEntry(AccountsController):
 		self.update_expense_claim()
 		self.update_inter_company_jv()
 		self.update_invoice_discounting()
+		check_if_stock_and_account_balance_synced(
+			self.posting_date, self.company, self.doctype, self.name
+		)
 
 	def on_cancel(self):
 		from erpnext.accounts.utils import unlink_ref_doc_from_payment_entries

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py

@@ -114,13 +114,10 @@ class OpeningInvoiceCreationTool(Document):
 				)
 				or {}
 			)
-
-			default_currency = frappe.db.get_value(row.party_type, row.party, "default_currency")
-
 			if company_details:
 				invoice.update(
 					{
-						"currency": default_currency or company_details.get("default_currency"),
+						"currency": company_details.get("default_currency"),
 						"letter_head": company_details.get("default_letter_head"),
 					}
 				)

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -357,12 +357,6 @@ class PaymentEntry(AccountsController):
 								)
 							)
 
-						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"),
-							)
-
 					if ref_doc.docstatus != 1:
 						frappe.throw(_("{0} {1} must be submitted").format(d.reference_doctype, d.reference_name))
 

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -743,21 +743,6 @@ class TestPaymentEntry(unittest.TestCase):
 			flt(payment_entry.total_taxes_and_charges, 2), flt(10 / payment_entry.target_exchange_rate, 2)
 		)
 
-	def test_payment_entry_against_onhold_purchase_invoice(self):
-		pi = make_purchase_invoice()
-
-		pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank USD - _TC")
-		pe.reference_no = "1"
-		pe.reference_date = "2016-01-01"
-
-		# block invoice after creating payment entry
-		# since `get_payment_entry` will not attach blocked invoice to payment
-		pi.block_invoice()
-		with self.assertRaises(frappe.ValidationError) as err:
-			pe.save()
-
-		self.assertTrue("is on hold" in str(err.exception).lower())
-
 
 def create_payment_entry(**args):
 	payment_entry = frappe.new_doc("Payment Entry")

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and Contributors
+// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
 // For license information, please see license.txt
 
 frappe.provide("erpnext.accounts");
@@ -38,15 +38,6 @@ erpnext.accounts.PaymentReconciliationController = frappe.ui.form.Controller.ext
 				]
 			};
 		});
-
-		this.frm.set_query("cost_center", () => {
-			return {
-				"filters": {
-					"company": this.frm.doc.company,
-					"is_group": 0
-				}
-			}
-		});
 	},
 
 	refresh: function() {

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.json

@@ -24,7 +24,6 @@
   "invoice_limit",
   "payment_limit",
   "bank_cash_account",
-  "cost_center",
   "sec_break1",
   "invoices",
   "column_break_15",
@@ -179,19 +178,13 @@
   {
    "fieldname": "column_break_11",
    "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "cost_center",
-   "fieldtype": "Link",
-   "label": "Cost Center",
-   "options": "Cost Center"
   }
  ],
  "hide_toolbar": 1,
  "icon": "icon-resize-horizontal",
  "issingle": 1,
  "links": [],
- "modified": "2022-04-29 15:37:10.246831",
+ "modified": "2021-10-04 20:27:11.114194",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reconciliation",
@@ -216,6 +209,5 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "track_changes": 1
 }

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -332,9 +332,6 @@ class PaymentReconciliation(Document):
 	def get_conditions(self, get_invoices=False, get_payments=False, get_return_invoices=False):
 		condition = " and company = '{0}' ".format(self.company)
 
-		if self.get("cost_center") and (get_invoices or get_payments or get_return_invoices):
-			condition = " and cost_center = '{0}' ".format(self.cost_center)
-
 		if get_invoices:
 			condition += (
 				" and posting_date >= {0}".format(frappe.db.escape(self.from_invoice_date))
@@ -353,13 +350,9 @@ class PaymentReconciliation(Document):
 			)
 
 			if self.minimum_invoice_amount:
-				condition += " and {dr_or_cr} >= {amount}".format(
-					dr_or_cr=dr_or_cr, amount=flt(self.minimum_invoice_amount)
-				)
+				condition += " and `{0}` >= {1}".format(dr_or_cr, flt(self.minimum_invoice_amount))
 			if self.maximum_invoice_amount:
-				condition += " and {dr_or_cr} <= {amount}".format(
-					dr_or_cr=dr_or_cr, amount=flt(self.maximum_invoice_amount)
-				)
+				condition += " and `{0}` <= {1}".format(dr_or_cr, flt(self.maximum_invoice_amount))
 
 		elif get_return_invoices:
 			condition = " and doc.company = '{0}' ".format(self.company)
@@ -374,19 +367,15 @@ class PaymentReconciliation(Document):
 				else ""
 			)
 			dr_or_cr = (
-				"debit_in_account_currency"
+				"gl.debit_in_account_currency"
 				if erpnext.get_party_account_type(self.party_type) == "Receivable"
-				else "credit_in_account_currency"
+				else "gl.credit_in_account_currency"
 			)
 
 			if self.minimum_invoice_amount:
-				condition += " and gl.{dr_or_cr} >= {amount}".format(
-					dr_or_cr=dr_or_cr, amount=flt(self.minimum_payment_amount)
-				)
+				condition += " and `{0}` >= {1}".format(dr_or_cr, flt(self.minimum_payment_amount))
 			if self.maximum_invoice_amount:
-				condition += " and gl.{dr_or_cr} <= {amount}".format(
-					dr_or_cr=dr_or_cr, amount=flt(self.maximum_payment_amount)
-				)
+				condition += " and `{0}` <= {1}".format(dr_or_cr, flt(self.maximum_payment_amount))
 
 		else:
 			condition += (

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -1,96 +1,9 @@
 # Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+# import frappe
 import unittest
 
-import frappe
-from frappe.utils import add_days, getdate
-
-from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-
 
 class TestPaymentReconciliation(unittest.TestCase):
-	@classmethod
-	def setUpClass(cls):
-		make_customer()
-		make_invoice_and_payment()
-
-	def test_payment_reconciliation(self):
-		payment_reco = frappe.get_doc("Payment Reconciliation")
-		payment_reco.company = "_Test Company"
-		payment_reco.party_type = "Customer"
-		payment_reco.party = "_Test Payment Reco Customer"
-		payment_reco.receivable_payable_account = "Debtors - _TC"
-		payment_reco.from_invoice_date = add_days(getdate(), -1)
-		payment_reco.to_invoice_date = getdate()
-		payment_reco.from_payment_date = add_days(getdate(), -1)
-		payment_reco.to_payment_date = getdate()
-		payment_reco.maximum_invoice_amount = 1000
-		payment_reco.maximum_payment_amount = 1000
-		payment_reco.invoice_limit = 10
-		payment_reco.payment_limit = 10
-		payment_reco.bank_cash_account = "_Test Bank - _TC"
-		payment_reco.cost_center = "_Test Cost Center - _TC"
-		payment_reco.get_unreconciled_entries()
-
-		self.assertEqual(len(payment_reco.get("invoices")), 1)
-		self.assertEqual(len(payment_reco.get("payments")), 1)
-
-		payment_entry = payment_reco.get("payments")[0].reference_name
-		invoice = payment_reco.get("invoices")[0].invoice_number
-
-		payment_reco.allocate_entries(
-			{
-				"payments": [payment_reco.get("payments")[0].as_dict()],
-				"invoices": [payment_reco.get("invoices")[0].as_dict()],
-			}
-		)
-		payment_reco.reconcile()
-
-		payment_entry_doc = frappe.get_doc("Payment Entry", payment_entry)
-		self.assertEqual(payment_entry_doc.get("references")[0].reference_name, invoice)
-
-
-def make_customer():
-	if not frappe.db.get_value("Customer", "_Test Payment Reco Customer"):
-		frappe.get_doc(
-			{
-				"doctype": "Customer",
-				"customer_name": "_Test Payment Reco Customer",
-				"customer_type": "Individual",
-				"customer_group": "_Test Customer Group",
-				"territory": "_Test Territory",
-			}
-		).insert()
-
-
-def make_invoice_and_payment():
-	si = create_sales_invoice(
-		customer="_Test Payment Reco Customer", qty=1, rate=690, do_not_save=True
-	)
-	si.cost_center = "_Test Cost Center - _TC"
-	si.save()
-	si.submit()
-
-	pe = frappe.get_doc(
-		{
-			"doctype": "Payment Entry",
-			"payment_type": "Receive",
-			"party_type": "Customer",
-			"party": "_Test Payment Reco Customer",
-			"company": "_Test Company",
-			"paid_from_account_currency": "INR",
-			"paid_to_account_currency": "INR",
-			"source_exchange_rate": 1,
-			"target_exchange_rate": 1,
-			"reference_no": "1",
-			"reference_date": getdate(),
-			"received_amount": 690,
-			"paid_amount": 690,
-			"paid_from": "Debtors - _TC",
-			"paid_to": "_Test Bank - _TC",
-			"cost_center": "_Test Cost Center - _TC",
-		}
-	)
-	pe.insert()
-	pe.submit()
+	pass

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -166,7 +166,7 @@ class PeriodClosingVoucher(AccountsController):
 				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
-			where t1.is_cancelled = 0 and t1.account = t2.name and t2.report_type = 'Profit and Loss'
+			where t1.account = t2.name and t2.report_type = 'Profit and Loss'
 			and t2.docstatus < 2 and t2.company = %s
 			and t1.posting_date between %s and %s
 			group by t1.account, {dimension_fields}

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -34,9 +34,8 @@ class ProcessStatementOfAccounts(Document):
 			frappe.throw(_("Customers not selected."))
 
 		if self.enable_auto_email:
-			if self.start_date and getdate(self.start_date) >= getdate(today()):
-				self.to_date = self.start_date
-				self.from_date = add_months(self.to_date, -1 * self.filter_duration)
+			self.to_date = self.start_date
+			self.from_date = add_months(self.to_date, -1 * self.filter_duration)
 
 
 def get_report_pdf(doc, consolidated=True):

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -30,9 +30,6 @@ erpnext.accounts.PurchaseInvoice = erpnext.buying.BuyingController.extend({
 	onload: function() {
 		this._super();
 
-		// Ignore linked advances
-		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry'];
-
 		if(!this.frm.doc.__islocal) {
 			// show credit_to in print format
 			if(!this.frm.doc.supplier && this.frm.doc.credit_to) {

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -801,9 +801,7 @@ class PurchaseInvoice(BuyingController):
 
 					if provisional_accounting_for_non_stock_items:
 						if item.purchase_receipt:
-							provisional_account = frappe.db.get_value(
-								"Purchase Receipt Item", item.pr_detail, "provisional_expense_account"
-							) or self.get_company_default("default_provisional_account")
+							provisional_account = self.get_company_default("default_provisional_account")
 							purchase_receipt_doc = purchase_receipt_doc_map.get(item.purchase_receipt)
 
 							if not purchase_receipt_doc:
@@ -826,7 +824,7 @@ class PurchaseInvoice(BuyingController):
 							if expense_booked_in_pr:
 								# Intentionally passing purchase invoice item to handle partial billing
 								purchase_receipt_doc.add_provisional_gl_entry(
-									item, gl_entries, self.posting_date, provisional_account, reverse=1
+									item, gl_entries, self.posting_date, reverse=1
 								)
 
 					if not self.is_internal_transfer():
@@ -1317,9 +1315,7 @@ class PurchaseInvoice(BuyingController):
 		if (
 			not self.is_internal_transfer() and self.rounding_adjustment and self.base_rounding_adjustment
 		):
-			round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(
-				self.company, "Purchase Invoice", self.name
-			)
+			round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(self.company)
 
 			gl_entries.append(
 				self.get_gl_dict(

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -1449,8 +1449,7 @@ class TestPurchaseInvoice(unittest.TestCase):
 		self.assertEqual(payment_entry.taxes[0].allocated_amount, 0)
 
 	def test_provisional_accounting_entry(self):
-		create_item("_Test Non Stock Item", is_stock_item=0)
-
+		item = create_item("_Test Non Stock Item", is_stock_item=0)
 		provisional_account = create_account(
 			account_name="Provision Account",
 			parent_account="Current Liabilities - _TC",
@@ -1473,8 +1472,6 @@ class TestPurchaseInvoice(unittest.TestCase):
 		pi.save()
 		pi.submit()
 
-		self.assertEquals(pr.items[0].provisional_expense_account, "Provision Account - _TC")
-
 		# Check GLE for Purchase Invoice
 		expected_gle = [
 			["Cost of Goods Sold - _TC", 250, 0, add_days(pr.posting_date, -1)],

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -34,9 +34,7 @@ erpnext.accounts.SalesInvoiceController = erpnext.selling.SellingController.exte
 		var me = this;
 		this._super();
 
-		this.frm.ignore_doctypes_on_cancel_all = ['POS Invoice', 'Timesheet', 'POS Invoice Merge Log',
-			'POS Closing Entry', 'Journal Entry', 'Payment Entry'];
-
+		this.frm.ignore_doctypes_on_cancel_all = ['POS Invoice', 'Timesheet', 'POS Invoice Merge Log', 'POS Closing Entry'];
 		if(!this.frm.doc.__islocal && !this.frm.doc.customer && this.frm.doc.debit_to) {
 			// show debit_to in print format
 			this.frm.set_df_property("debit_to", "print_hide", 0);

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -1473,9 +1473,7 @@ class SalesInvoice(SellingController):
 			and self.base_rounding_adjustment
 			and not self.is_internal_transfer()
 		):
-			round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(
-				self.company, "Sales Invoice", self.name
-			)
+			round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(self.company)
 
 			gl_entries.append(
 				self.get_gl_dict(

erpnext/accounts/doctype/sales_invoice/sales_invoice_dashboard.py

@@ -12,10 +12,7 @@ def get_data():
 			"Sales Invoice": "return_against",
 			"Auto Repeat": "reference_document",
 		},
-		"internal_links": {
-			"Sales Order": ["items", "sales_order"],
-			"Timesheet": ["timesheets", "time_sheet"],
-		},
+		"internal_links": {"Sales Order": ["items", "sales_order"]},
 		"transactions": [
 			{
 				"label": _("Payment"),

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -2007,13 +2007,6 @@ class TestSalesInvoice(unittest.TestCase):
 			self.assertEqual(expected_values[gle.account][2], gle.credit)
 
 	def test_rounding_adjustment_3(self):
-		from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension import (
-			create_dimension,
-			disable_dimension,
-		)
-
-		create_dimension()
-
 		si = create_sales_invoice(do_not_save=True)
 		si.items = []
 		for d in [(1122, 2), (1122.01, 1), (1122.01, 1)]:
@@ -2041,10 +2034,6 @@ class TestSalesInvoice(unittest.TestCase):
 					"included_in_print_rate": 1,
 				},
 			)
-
-		si.cost_center = "_Test Cost Center 2 - _TC"
-		si.location = "Block 1"
-
 		si.save()
 		si.submit()
 		self.assertEqual(si.net_total, 4007.16)
@@ -2080,18 +2069,6 @@ class TestSalesInvoice(unittest.TestCase):
 
 		self.assertEqual(debit_credit_diff, 0)
 
-		round_off_gle = frappe.db.get_value(
-			"GL Entry",
-			{"voucher_type": "Sales Invoice", "voucher_no": si.name, "account": "Round Off - _TC"},
-			["cost_center", "location"],
-			as_dict=1,
-		)
-
-		self.assertEqual(round_off_gle.cost_center, "_Test Cost Center 2 - _TC")
-		self.assertEqual(round_off_gle.location, "Block 1")
-
-		disable_dimension()
-
 	def test_sales_invoice_with_shipping_rule(self):
 		from erpnext.accounts.doctype.shipping_rule.test_shipping_rule import create_shipping_rule
 
@@ -2585,7 +2562,6 @@ class TestSalesInvoice(unittest.TestCase):
 		# reset
 		einvoice_settings = frappe.get_doc("E Invoice Settings")
 		einvoice_settings.enable = 0
-		einvoice_settings.save()
 		frappe.flags.country = country
 
 	def test_einvoice_json(self):
@@ -3086,95 +3062,6 @@ class TestSalesInvoice(unittest.TestCase):
 		si.reload()
 		self.assertTrue(si.items[0].serial_no)
 
-	def test_sales_invoice_with_disabled_account(self):
-		try:
-			account = frappe.get_doc("Account", "VAT 5% - _TC")
-			account.disabled = 1
-			account.save()
-
-			si = create_sales_invoice(do_not_save=True)
-			si.posting_date = add_days(getdate(), 1)
-			si.taxes = []
-
-			si.append(
-				"taxes",
-				{
-					"charge_type": "On Net Total",
-					"account_head": "VAT 5% - _TC",
-					"cost_center": "Main - _TC",
-					"description": "VAT @ 5.0",
-					"rate": 9,
-				},
-			)
-			si.save()
-
-			with self.assertRaises(frappe.ValidationError) as err:
-				si.submit()
-
-			self.assertTrue(
-				"Cannot create accounting entries against disabled accounts" in str(err.exception)
-			)
-
-		finally:
-			account.disabled = 0
-			account.save()
-
-	def test_gain_loss_with_advance_entry(self):
-		from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
-
-		unlink_enabled = frappe.db.get_value(
-			"Accounts Settings", "Accounts Settings", "unlink_payment_on_cancel_of_invoice"
-		)
-
-		frappe.db.set_value(
-			"Accounts Settings", "Accounts Settings", "unlink_payment_on_cancel_of_invoice", 1
-		)
-
-		jv = make_journal_entry("_Test Receivable USD - _TC", "_Test Bank - _TC", -7000, save=False)
-
-		jv.accounts[0].exchange_rate = 70
-		jv.accounts[0].credit_in_account_currency = 100
-		jv.accounts[0].party_type = "Customer"
-		jv.accounts[0].party = "_Test Customer USD"
-
-		jv.save()
-		jv.submit()
-
-		si = create_sales_invoice(
-			customer="_Test Customer USD",
-			debit_to="_Test Receivable USD - _TC",
-			currency="USD",
-			conversion_rate=75,
-			do_not_save=1,
-			rate=100,
-		)
-
-		si.append(
-			"advances",
-			{
-				"reference_type": "Journal Entry",
-				"reference_name": jv.name,
-				"reference_row": jv.accounts[0].name,
-				"advance_amount": 100,
-				"allocated_amount": 100,
-				"ref_exchange_rate": 70,
-			},
-		)
-		si.save()
-		si.submit()
-
-		expected_gle = [
-			["_Test Receivable USD - _TC", 7500.0, 500],
-			["Exchange Gain/Loss - _TC", 500.0, 0.0],
-			["Sales - _TC", 0.0, 7500.0],
-		]
-
-		check_gl_entries(self, si.name, expected_gle, nowdate())
-
-		frappe.db.set_value(
-			"Accounts Settings", "Accounts Settings", "unlink_payment_on_cancel_of_invoice", unlink_enabled
-		)
-
 
 def get_sales_invoice_for_e_invoice():
 	si = make_sales_invoice_for_ewaybill()

erpnext/accounts/general_ledger.py

@@ -29,7 +29,6 @@ def make_gl_entries(
 	if gl_map:
 		if not cancel:
 			validate_accounting_period(gl_map)
-			validate_disabled_accounts(gl_map)
 			gl_map = process_gl_map(gl_map, merge_entries)
 			if gl_map and len(gl_map) > 1:
 				save_entries(gl_map, adv_adj, update_outstanding, from_repost)
@@ -44,26 +43,6 @@ def make_gl_entries(
 			make_reverse_gl_entries(gl_map, adv_adj=adv_adj, update_outstanding=update_outstanding)
 
 
-def validate_disabled_accounts(gl_map):
-	accounts = [d.account for d in gl_map if d.account]
-
-	Account = frappe.qb.DocType("Account")
-
-	disabled_accounts = (
-		frappe.qb.from_(Account)
-		.where(Account.name.isin(accounts) & Account.disabled == 1)
-		.select(Account.name, Account.disabled)
-	).run(as_dict=True)
-
-	if disabled_accounts:
-		account_list = "<br>"
-		account_list += ", ".join([frappe.bold(d.name) for d in disabled_accounts])
-		frappe.throw(
-			_("Cannot create accounting entries against disabled accounts: {0}").format(account_list),
-			title=_("Disabled Account Selected"),
-		)
-
-
 def validate_accounting_period(gl_map):
 	accounting_periods = frappe.db.sql(
 		""" SELECT
@@ -294,7 +273,7 @@ def round_off_debit_credit(gl_map):
 
 def make_round_off_gle(gl_map, debit_credit_diff, precision):
 	round_off_account, round_off_cost_center = get_round_off_account_and_cost_center(
-		gl_map[0].company, gl_map[0].voucher_type, gl_map[0].voucher_no
+		gl_map[0].company
 	)
 	round_off_account_exists = False
 	round_off_gle = frappe._dict()
@@ -331,43 +310,14 @@ def make_round_off_gle(gl_map, debit_credit_diff, precision):
 		}
 	)
 
-	update_accounting_dimensions(round_off_gle)
-
 	if not round_off_account_exists:
 		gl_map.append(round_off_gle)
 
 
-def update_accounting_dimensions(round_off_gle):
-	dimensions = get_accounting_dimensions()
-	meta = frappe.get_meta(round_off_gle["voucher_type"])
-	has_all_dimensions = True
-
-	for dimension in dimensions:
-		if not meta.has_field(dimension):
-			has_all_dimensions = False
-
-	if dimensions and has_all_dimensions:
-		dimension_values = frappe.db.get_value(
-			round_off_gle["voucher_type"], round_off_gle["voucher_no"], dimensions, as_dict=1
-		)
-
-		for dimension in dimensions:
-			round_off_gle[dimension] = dimension_values.get(dimension)
-
-
-def get_round_off_account_and_cost_center(company, voucher_type, voucher_no):
+def get_round_off_account_and_cost_center(company):
 	round_off_account, round_off_cost_center = frappe.get_cached_value(
 		"Company", company, ["round_off_account", "round_off_cost_center"]
 	) or [None, None]
-
-	meta = frappe.get_meta(voucher_type)
-
-	# Give first preference to parent cost center for round off GLE
-	if meta.has_field("cost_center"):
-		parent_cost_center = frappe.db.get_value(voucher_type, voucher_no, "cost_center")
-		if parent_cost_center:
-			round_off_cost_center = parent_cost_center
-
 	if not round_off_account:
 		frappe.throw(_("Please mention Round Off Account in Company"))
 

erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py

@@ -203,7 +203,7 @@ def get_loan_entries(filters):
 			posting_date = (loan_doc.posting_date).as_("posting_date")
 			account = loan_doc.payment_account
 
-		query = (
+		entries = (
 			frappe.qb.from_(loan_doc)
 			.select(
 				ConstantColumn(doctype).as_("payment_document"),
@@ -217,12 +217,9 @@ def get_loan_entries(filters):
 			.where(account == filters.get("account"))
 			.where(posting_date <= getdate(filters.get("report_date")))
 			.where(ifnull(loan_doc.clearance_date, "4000-01-01") > getdate(filters.get("report_date")))
+			.run(as_dict=1)
 		)
 
-		if doctype == "Loan Repayment":
-			query.where(loan_doc.repay_from_salary == 0)
-
-		entries = query.run(as_dict=1)
 		loan_docs.extend(entries)
 
 	return loan_docs

erpnext/accounts/report/financial_statements.py

@@ -539,7 +539,7 @@ def get_additional_conditions(from_date, ignore_closing_entries, filters):
 					)
 					additional_conditions.append("{0} in %({0})s".format(dimension.fieldname))
 				else:
-					additional_conditions.append("{0} in %({0})s".format(dimension.fieldname))
+					additional_conditions.append("{0} in (%({0})s)".format(dimension.fieldname))
 
 	return " and {}".format(" and ".join(additional_conditions)) if additional_conditions else ""
 

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -318,7 +318,7 @@ def get_conditions(filters):
 							)
 							conditions.append("{0} in %({0})s".format(dimension.fieldname))
 						else:
-							conditions.append("{0} in %({0})s".format(dimension.fieldname))
+							conditions.append("{0} in (%({0})s)".format(dimension.fieldname))
 
 	return "and {}".format(" and ".join(conditions)) if conditions else ""
 
@@ -478,13 +478,7 @@ def get_accountwise_gle(filters, accounting_dimensions, gl_entries, gle_map):
 				gle_map[group_by_value].entries.append(gle)
 
 			elif group_by_voucher_consolidated:
-				keylist = [
-					gle.get("voucher_type"),
-					gle.get("voucher_no"),
-					gle.get("account"),
-					gle.get("party_type"),
-					gle.get("party"),
-				]
+				keylist = [gle.get("voucher_type"), gle.get("voucher_no"), gle.get("account")]
 				if filters.get("include_dimensions"):
 					for dim in accounting_dimensions:
 						keylist.append(gle.get(dim))

erpnext/accounts/report/pos_register/pos_register.py

@@ -62,7 +62,7 @@ def get_pos_entries(filters, group_by_field):
 		"""
 		SELECT
 			p.posting_date, p.name as pos_invoice, p.pos_profile,
-			p.owner, p.base_grand_total as grand_total, p.base_paid_amount - p.change_amount  as paid_amount,
+			p.owner, p.base_grand_total as grand_total, p.base_paid_amount as paid_amount,
 			p.customer, p.is_return {select_mop_field}
 		FROM
 			`tabPOS Invoice` p {from_sales_invoice_payment}

erpnext/accounts/report/purchase_register/purchase_register.py

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

erpnext/accounts/report/sales_register/sales_register.py

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

erpnext/accounts/report/trial_balance/trial_balance.py

@@ -188,9 +188,9 @@ def get_rootwise_opening_balances(filters, report_type):
 					filters[dimension.fieldname] = get_dimension_with_children(
 						dimension.document_type, filters.get(dimension.fieldname)
 					)
-					additional_conditions += " and {0} in %({0})s".format(dimension.fieldname)
+					additional_conditions += "and {0} in %({0})s".format(dimension.fieldname)
 				else:
-					additional_conditions += " and {0} in %({0})s".format(dimension.fieldname)
+					additional_conditions += "and {0} in (%({0})s)".format(dimension.fieldname)
 
 				query_filters.update({dimension.fieldname: filters.get(dimension.fieldname)})
 

erpnext/accounts/test/test_utils.py

@@ -1,17 +1,10 @@
 import unittest
 
-import frappe
 from frappe.test_runner import make_test_objects
 
 from erpnext.accounts.party import get_party_shipping_address
-from erpnext.accounts.utils import (
-	get_future_stock_vouchers,
-	get_voucherwise_gl_entries,
-	sort_stock_vouchers_by_posting_date,
-)
-from erpnext.stock.doctype.item.test_item import make_item
+from erpnext.accounts.utils import get_future_stock_vouchers, get_voucherwise_gl_entries
 from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
-from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry
 
 
 class TestUtils(unittest.TestCase):
@@ -54,25 +47,6 @@ class TestUtils(unittest.TestCase):
 			msg="get_voucherwise_gl_entries not returning expected GLes",
 		)
 
-	def test_stock_voucher_sorting(self):
-		vouchers = []
-
-		item = make_item().name
-
-		stock_entry = {"item": item, "to_warehouse": "_Test Warehouse - _TC", "qty": 1, "rate": 10}
-
-		se1 = make_stock_entry(posting_date="2022-01-01", **stock_entry)
-		se2 = make_stock_entry(posting_date="2022-02-01", **stock_entry)
-		se3 = make_stock_entry(posting_date="2022-03-01", **stock_entry)
-
-		for doc in (se1, se2, se3):
-			vouchers.append((doc.doctype, doc.name))
-
-		vouchers.append(("Stock Entry", "Wat"))
-
-		sorted_vouchers = sort_stock_vouchers_by_posting_date(list(reversed(vouchers)))
-		self.assertEqual(sorted_vouchers, vouchers)
-
 
 ADDRESS_RECORDS = [
 	{

erpnext/accounts/utils.py

@@ -3,7 +3,6 @@
 
 
 from json import loads
-from typing import List, Tuple
 
 import frappe
 import frappe.defaults
@@ -20,6 +19,10 @@ from erpnext.stock import get_warehouse_account_map
 from erpnext.stock.utils import get_stock_value_on
 
 
+class StockValueAndAccountBalanceOutOfSync(frappe.ValidationError):
+	pass
+
+
 class FiscalYearError(frappe.ValidationError):
 	pass
 
@@ -1124,9 +1127,6 @@ def update_gl_entries_after(
 def repost_gle_for_stock_vouchers(
 	stock_vouchers, posting_date, company=None, warehouse_account=None
 ):
-	if not stock_vouchers:
-		return
-
 	def _delete_gl_entries(voucher_type, voucher_no):
 		frappe.db.sql(
 			"""delete from `tabGL Entry`
@@ -1134,8 +1134,6 @@ def repost_gle_for_stock_vouchers(
 			(voucher_type, voucher_no),
 		)
 
-	stock_vouchers = sort_stock_vouchers_by_posting_date(stock_vouchers)
-
 	if not warehouse_account:
 		warehouse_account = get_warehouse_account_map(company)
 
@@ -1156,27 +1154,6 @@ def repost_gle_for_stock_vouchers(
 			_delete_gl_entries(voucher_type, voucher_no)
 
 
-def sort_stock_vouchers_by_posting_date(
-	stock_vouchers: List[Tuple[str, str]]
-) -> List[Tuple[str, str]]:
-	sle = frappe.qb.DocType("Stock Ledger Entry")
-	voucher_nos = [v[1] for v in stock_vouchers]
-
-	sles = (
-		frappe.qb.from_(sle)
-		.select(sle.voucher_type, sle.voucher_no, sle.posting_date, sle.posting_time, sle.creation)
-		.where((sle.is_cancelled == 0) & (sle.voucher_no.isin(voucher_nos)))
-		.groupby(sle.voucher_type, sle.voucher_no)
-	).run(as_dict=True)
-	sorted_vouchers = [(sle.voucher_type, sle.voucher_no) for sle in sles]
-
-	unknown_vouchers = set(stock_vouchers) - set(sorted_vouchers)
-	if unknown_vouchers:
-		sorted_vouchers.extend(unknown_vouchers)
-
-	return sorted_vouchers
-
-
 def get_future_stock_vouchers(
 	posting_date, posting_time, for_warehouses=None, for_items=None, company=None
 ):
@@ -1270,6 +1247,47 @@ def compare_existing_and_expected_gle(existing_gle, expected_gle, precision):
 	return matched
 
 
+def check_if_stock_and_account_balance_synced(
+	posting_date, company, voucher_type=None, voucher_no=None
+):
+	if not cint(erpnext.is_perpetual_inventory_enabled(company)):
+		return
+
+	accounts = get_stock_accounts(company, voucher_type, voucher_no)
+	stock_adjustment_account = frappe.db.get_value("Company", company, "stock_adjustment_account")
+
+	for account in accounts:
+		account_bal, stock_bal, warehouse_list = get_stock_and_account_balance(
+			account, posting_date, company
+		)
+
+		if abs(account_bal - stock_bal) > 0.1:
+			precision = get_field_precision(
+				frappe.get_meta("GL Entry").get_field("debit"),
+				currency=frappe.get_cached_value("Company", company, "default_currency"),
+			)
+
+			diff = flt(stock_bal - account_bal, precision)
+
+			error_reason = _(
+				"Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses as on {3}."
+			).format(stock_bal, account_bal, frappe.bold(account), posting_date)
+			error_resolution = _("Please create an adjustment Journal Entry for amount {0} on {1}").format(
+				frappe.bold(diff), frappe.bold(posting_date)
+			)
+
+			frappe.msgprint(
+				msg="""{0}<br></br>{1}<br></br>""".format(error_reason, error_resolution),
+				raise_exception=StockValueAndAccountBalanceOutOfSync,
+				title=_("Values Out Of Sync"),
+				primary_action={
+					"label": _("Make Journal Entry"),
+					"client_action": "erpnext.route_to_adjustment_jv",
+					"args": get_journal_entry(account, stock_adjustment_account, diff),
+				},
+			)
+
+
 def get_stock_accounts(company, voucher_type=None, voucher_no=None):
 	stock_accounts = [
 		d.name

erpnext/assets/doctype/asset/asset.js

@@ -108,6 +108,10 @@ frappe.ui.form.on('Asset', {
 				frm.trigger("create_asset_repair");
 			}, __("Manage"));
 
+			frm.add_custom_button(__("Split Asset"), function() {
+				frm.trigger("split_asset");
+			}, __("Manage"));
+
 			if (frm.doc.status != 'Fully Depreciated') {
 				frm.add_custom_button(__("Adjust Asset Value"), function() {
 					frm.trigger("create_asset_value_adjustment");
@@ -322,6 +326,43 @@ frappe.ui.form.on('Asset', {
 		});
 	},
 
+	split_asset: function(frm) {
+		const title = __('Split Asset');
+
+		const fields = [
+			{
+				fieldname: 'split_qty',
+				fieldtype: 'Int',
+				label: __('Split Qty'),
+				reqd: 1
+			}
+		];
+
+		let dialog = new frappe.ui.Dialog({
+			title: title,
+			fields: fields
+		});
+
+		dialog.set_primary_action(__('Split'), function() {
+			const dialog_data = dialog.get_values();
+			frappe.call({
+				args: {
+					"asset_name": frm.doc.name,
+					"split_qty": cint(dialog_data.split_qty)
+				},
+				method: "erpnext.assets.doctype.asset.asset.split_asset",
+				callback: function(r) {
+					let doclist = frappe.model.sync(r.message);
+					frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
+				}
+			});
+
+			dialog.hide();
+		});
+
+		dialog.show();
+	},
+
 	create_asset_value_adjustment: function(frm) {
 		frappe.call({
 			args: {

erpnext/assets/doctype/asset/asset.json

@@ -3,7 +3,7 @@
  "allow_import": 1,
  "allow_rename": 1,
  "autoname": "naming_series:",
- "creation": "2016-03-01 17:01:27.920130",
+ "creation": "2022-01-18 02:26:55.975005",
  "doctype": "DocType",
  "document_type": "Document",
  "engine": "InnoDB",
@@ -23,6 +23,7 @@
   "asset_name",
   "asset_category",
   "location",
+  "split_from",
   "custodian",
   "department",
   "disposal_date",
@@ -35,6 +36,7 @@
   "available_for_use_date",
   "column_break_23",
   "gross_purchase_amount",
+  "asset_quantity",
   "purchase_date",
   "section_break_23",
   "calculate_depreciation",
@@ -481,6 +483,18 @@
    "fieldname": "section_break_36",
    "fieldtype": "Section Break",
    "label": "Finance Books"
+  },
+  {
+   "fieldname": "split_from",
+   "fieldtype": "Link",
+   "label": "Split From",
+   "options": "Asset",
+   "read_only": 1
+  },
+  {
+   "fieldname": "asset_quantity",
+   "fieldtype": "Int",
+   "label": "Asset Quantity"
   }
  ],
  "idx": 72,
@@ -507,6 +521,7 @@
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset",
+ "naming_rule": "By \"Naming Series\" field",
  "owner": "Administrator",
  "permissions": [
   {
@@ -543,6 +558,7 @@
  "show_name_in_global_search": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
+ "states": [],
  "title_field": "asset_name",
  "track_changes": 1
 }

erpnext/assets/doctype/asset/asset.py

@@ -39,7 +39,8 @@ class Asset(AccountsController):
 		self.validate_item()
 		self.validate_cost_center()
 		self.set_missing_values()
-		self.prepare_depreciation_data()
+		if not self.split_from:
+			self.prepare_depreciation_data()
 		self.validate_gross_and_purchase_amount()
 		if self.get("schedules"):
 			self.validate_expected_value_after_useful_life()
@@ -235,175 +236,180 @@ class Asset(AccountsController):
 		start = self.clear_depreciation_schedule()
 
 		for finance_book in self.get("finance_books"):
-			self.validate_asset_finance_books(finance_book)
+			self._make_depreciation_schedule(finance_book, start, date_of_sale)
 
-			# value_after_depreciation - current Asset value
-			if self.docstatus == 1 and finance_book.value_after_depreciation:
-				value_after_depreciation = flt(finance_book.value_after_depreciation)
-			else:
-				value_after_depreciation = flt(self.gross_purchase_amount) - flt(
-					self.opening_accumulated_depreciation
+	def _make_depreciation_schedule(self, finance_book, start, date_of_sale):
+		self.validate_asset_finance_books(finance_book)
+
+		value_after_depreciation = self._get_value_after_depreciation(finance_book)
+		finance_book.value_after_depreciation = value_after_depreciation
+
+		number_of_pending_depreciations = cint(finance_book.total_number_of_depreciations) - cint(
+			self.number_of_depreciations_booked
+		)
+
+		has_pro_rata = self.check_is_pro_rata(finance_book)
+		if has_pro_rata:
+			number_of_pending_depreciations += 1
+
+		skip_row = False
+
+		for n in range(start[finance_book.idx - 1], number_of_pending_depreciations):
+			# If depreciation is already completed (for double declining balance)
+			if skip_row:
+				continue
+
+			depreciation_amount = get_depreciation_amount(self, value_after_depreciation, finance_book)
+
+			if not has_pro_rata or n < cint(number_of_pending_depreciations) - 1:
+				schedule_date = add_months(
+					finance_book.depreciation_start_date, n * cint(finance_book.frequency_of_depreciation)
 				)
 
-			finance_book.value_after_depreciation = value_after_depreciation
+				# 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)
 
-			number_of_pending_depreciations = cint(finance_book.total_number_of_depreciations) - cint(
-				self.number_of_depreciations_booked
-			)
-
-			has_pro_rata = self.check_is_pro_rata(finance_book)
-
-			if has_pro_rata:
-				number_of_pending_depreciations += 1
-
-			skip_row = False
-
-			for n in range(start[finance_book.idx - 1], number_of_pending_depreciations):
-				# If depreciation is already completed (for double declining balance)
-				if skip_row:
-					continue
-
-				depreciation_amount = get_depreciation_amount(self, value_after_depreciation, finance_book)
-
-				if not has_pro_rata or n < cint(number_of_pending_depreciations) - 1:
-					schedule_date = add_months(
-						finance_book.depreciation_start_date, n * cint(finance_book.frequency_of_depreciation)
-					)
-
-					# 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_sale:
-					from_date = self.get_from_date(finance_book.finance_book)
-					depreciation_amount, days, months = self.get_pro_rata_amt(
-						finance_book, depreciation_amount, from_date, date_of_sale
-					)
-
-					if depreciation_amount > 0:
-						self.append(
-							"schedules",
-							{
-								"schedule_date": date_of_sale,
-								"depreciation_amount": depreciation_amount,
-								"depreciation_method": finance_book.depreciation_method,
-								"finance_book": finance_book.finance_book,
-								"finance_book_id": finance_book.idx,
-							},
-						)
-
-					break
-
-				# For first row
-				if has_pro_rata and not self.opening_accumulated_depreciation and n == 0:
-					from_date = add_days(
-						self.available_for_use_date, -1
-					)  # needed to calc depr amount for available_for_use_date too
-					depreciation_amount, days, months = self.get_pro_rata_amt(
-						finance_book, depreciation_amount, from_date, finance_book.depreciation_start_date
-					)
-
-					# 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)
-
-				# For last row
-				elif has_pro_rata and n == cint(number_of_pending_depreciations) - 1:
-					if not self.flags.increase_in_asset_life:
-						# In case of increase_in_asset_life, the self.to_date is already set on asset_repair submission
-						self.to_date = add_months(
-							self.available_for_use_date,
-							(n + self.number_of_depreciations_booked) * cint(finance_book.frequency_of_depreciation),
-						)
-
-					depreciation_amount_without_pro_rata = depreciation_amount
-
-					depreciation_amount, days, months = self.get_pro_rata_amt(
-						finance_book, depreciation_amount, schedule_date, self.to_date
-					)
-
-					depreciation_amount = self.get_adjusted_depreciation_amount(
-						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
-				value_after_depreciation -= flt(depreciation_amount, self.precision("gross_purchase_amount"))
-
-				# Adjust depreciation amount in the last period based on the expected value after useful life
-				if finance_book.expected_value_after_useful_life and (
-					(
-						n == cint(number_of_pending_depreciations) - 1
-						and value_after_depreciation != finance_book.expected_value_after_useful_life
-					)
-					or value_after_depreciation < finance_book.expected_value_after_useful_life
-				):
-					depreciation_amount += (
-						value_after_depreciation - finance_book.expected_value_after_useful_life
-					)
-					skip_row = True
+			# if asset is being sold
+			if date_of_sale:
+				from_date = self.get_from_date(finance_book.finance_book)
+				depreciation_amount, days, months = self.get_pro_rata_amt(
+					finance_book, depreciation_amount, from_date, date_of_sale
+				)
 
 				if depreciation_amount > 0:
-					# With monthly depreciation, each depreciation is divided by months remaining until next date
-					if self.allow_monthly_depreciation:
-						# month range is 1 to 12
-						# In pro rata case, for first and last depreciation, month range would be different
-						if (has_pro_rata and n == 0 and not self.number_of_depreciations_booked) or (
-							has_pro_rata and n == cint(number_of_pending_depreciations) - 1
-						):
-							month_range = months
-						else:
-							month_range = finance_book.frequency_of_depreciation
+					self._add_depreciation_row(
+						date_of_sale,
+						depreciation_amount,
+						finance_book.depreciation_method,
+						finance_book.finance_book,
+						finance_book.idx,
+					)
 
-						for r in range(month_range):
-							if has_pro_rata and n == 0 and not self.number_of_depreciations_booked:
-								# For first entry of monthly depr
-								if r == 0:
-									days_until_first_depr = date_diff(monthly_schedule_date, self.available_for_use_date) + 1
-									per_day_amt = depreciation_amount / days
-									depreciation_amount_for_current_month = per_day_amt * days_until_first_depr
-									depreciation_amount -= depreciation_amount_for_current_month
-									date = monthly_schedule_date
-									amount = depreciation_amount_for_current_month
-								else:
-									date = add_months(monthly_schedule_date, r)
-									amount = depreciation_amount / (month_range - 1)
-							elif (has_pro_rata and n == cint(number_of_pending_depreciations) - 1) and r == cint(
-								month_range
-							) - 1:
-								# For last entry of monthly depr
-								date = last_schedule_date
-								amount = depreciation_amount / month_range
+				break
+
+			# For first row
+			if has_pro_rata and not self.opening_accumulated_depreciation and n == 0:
+				from_date = add_days(
+					self.available_for_use_date, -1
+				)  # needed to calc depr amount for available_for_use_date too
+				depreciation_amount, days, months = self.get_pro_rata_amt(
+					finance_book, depreciation_amount, from_date, finance_book.depreciation_start_date
+				)
+
+				# 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)
+
+			# For last row
+			elif has_pro_rata and n == cint(number_of_pending_depreciations) - 1:
+				if not self.flags.increase_in_asset_life:
+					# In case of increase_in_asset_life, the self.to_date is already set on asset_repair submission
+					self.to_date = add_months(
+						self.available_for_use_date,
+						(n + self.number_of_depreciations_booked) * cint(finance_book.frequency_of_depreciation),
+					)
+
+				depreciation_amount_without_pro_rata = depreciation_amount
+
+				depreciation_amount, days, months = self.get_pro_rata_amt(
+					finance_book, depreciation_amount, schedule_date, self.to_date
+				)
+
+				depreciation_amount = self.get_adjusted_depreciation_amount(
+					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
+			value_after_depreciation -= flt(depreciation_amount, self.precision("gross_purchase_amount"))
+
+			# Adjust depreciation amount in the last period based on the expected value after useful life
+			if finance_book.expected_value_after_useful_life and (
+				(
+					n == cint(number_of_pending_depreciations) - 1
+					and value_after_depreciation != finance_book.expected_value_after_useful_life
+				)
+				or value_after_depreciation < finance_book.expected_value_after_useful_life
+			):
+				depreciation_amount += value_after_depreciation - finance_book.expected_value_after_useful_life
+				skip_row = True
+
+			if depreciation_amount > 0:
+				# With monthly depreciation, each depreciation is divided by months remaining until next date
+				if self.allow_monthly_depreciation:
+					# month range is 1 to 12
+					# In pro rata case, for first and last depreciation, month range would be different
+					month_range = (
+						months
+						if (has_pro_rata and n == 0)
+						or (has_pro_rata and n == cint(number_of_pending_depreciations) - 1)
+						else finance_book.frequency_of_depreciation
+					)
+
+					for r in range(month_range):
+						if has_pro_rata and n == 0:
+							# For first entry of monthly depr
+							if r == 0:
+								days_until_first_depr = date_diff(monthly_schedule_date, self.available_for_use_date)
+								per_day_amt = depreciation_amount / days
+								depreciation_amount_for_current_month = per_day_amt * days_until_first_depr
+								depreciation_amount -= depreciation_amount_for_current_month
+								date = monthly_schedule_date
+								amount = depreciation_amount_for_current_month
 							else:
 								date = add_months(monthly_schedule_date, r)
-								amount = depreciation_amount / month_range
+								amount = depreciation_amount / (month_range - 1)
+						elif (has_pro_rata and n == cint(number_of_pending_depreciations) - 1) and r == cint(
+							month_range
+						) - 1:
+							# For last entry of monthly depr
+							date = last_schedule_date
+							amount = depreciation_amount / month_range
+						else:
+							date = add_months(monthly_schedule_date, r)
+							amount = depreciation_amount / month_range
 
-							self.append(
-								"schedules",
-								{
-									"schedule_date": date,
-									"depreciation_amount": amount,
-									"depreciation_method": finance_book.depreciation_method,
-									"finance_book": finance_book.finance_book,
-									"finance_book_id": finance_book.idx,
-								},
-							)
-					else:
-						self.append(
-							"schedules",
-							{
-								"schedule_date": schedule_date,
-								"depreciation_amount": depreciation_amount,
-								"depreciation_method": finance_book.depreciation_method,
-								"finance_book": finance_book.finance_book,
-								"finance_book_id": finance_book.idx,
-							},
+						self._add_depreciation_row(
+							date, amount, finance_book.depreciation_method, finance_book.finance_book, finance_book.idx
 						)
+				else:
+					self._add_depreciation_row(
+						schedule_date,
+						depreciation_amount,
+						finance_book.depreciation_method,
+						finance_book.finance_book,
+						finance_book.idx,
+					)
+
+	def _add_depreciation_row(
+		self, schedule_date, depreciation_amount, depreciation_method, finance_book, finance_book_id
+	):
+		self.append(
+			"schedules",
+			{
+				"schedule_date": schedule_date,
+				"depreciation_amount": depreciation_amount,
+				"depreciation_method": depreciation_method,
+				"finance_book": finance_book,
+				"finance_book_id": finance_book_id,
+			},
+		)
+
+	def _get_value_after_depreciation(self, finance_book):
+		# value_after_depreciation - current Asset value
+		if self.docstatus == 1 and finance_book.value_after_depreciation:
+			value_after_depreciation = flt(finance_book.value_after_depreciation)
+		else:
+			value_after_depreciation = flt(self.gross_purchase_amount) - flt(
+				self.opening_accumulated_depreciation
+			)
+
+		return value_after_depreciation
 
 	# depreciation schedules need to be cleared before modification due to increase in asset life/asset sales
 	# JE: Journal Entry, FB: Finance Book
@@ -413,7 +419,6 @@ class Asset(AccountsController):
 		depr_schedule = []
 
 		for schedule in self.get("schedules"):
-
 			# to update start when there are JEs linked with all the schedule rows corresponding to an FB
 			if len(start) == (int(schedule.finance_book_id) - 2):
 				start.append(num_of_depreciations_completed)
@@ -628,7 +633,7 @@ class Asset(AccountsController):
 
 				asset_value_after_full_schedule = flt(
 					flt(self.gross_purchase_amount) - flt(accumulated_depreciation_after_full_schedule),
-					row.precision("expected_value_after_useful_life"),
+					self.precision("gross_purchase_amount"),
 				)
 
 				if (
@@ -1124,3 +1129,150 @@ def get_depreciation_amount(asset, depreciable_value, row):
 		depreciation_amount = flt(depreciable_value * (flt(row.rate_of_depreciation) / 100))
 
 	return depreciation_amount
+
+
+@frappe.whitelist()
+def split_asset(asset_name, split_qty):
+	asset = frappe.get_doc("Asset", asset_name)
+	split_qty = cint(split_qty)
+
+	if split_qty >= asset.asset_quantity:
+		frappe.throw(_("Split qty cannot be grater than or equal to asset qty"))
+
+	remaining_qty = asset.asset_quantity - split_qty
+
+	new_asset = create_new_asset_after_split(asset, split_qty)
+	update_existing_asset(asset, remaining_qty)
+
+	return new_asset
+
+
+def update_existing_asset(asset, remaining_qty):
+	remaining_gross_purchase_amount = flt(
+		(asset.gross_purchase_amount * remaining_qty) / asset.asset_quantity
+	)
+	opening_accumulated_depreciation = flt(
+		(asset.opening_accumulated_depreciation * remaining_qty) / asset.asset_quantity
+	)
+
+	frappe.db.set_value(
+		"Asset",
+		asset.name,
+		{
+			"opening_accumulated_depreciation": opening_accumulated_depreciation,
+			"gross_purchase_amount": remaining_gross_purchase_amount,
+			"asset_quantity": remaining_qty,
+		},
+	)
+
+	for finance_book in asset.get("finance_books"):
+		value_after_depreciation = flt(
+			(finance_book.value_after_depreciation * remaining_qty) / asset.asset_quantity
+		)
+		expected_value_after_useful_life = flt(
+			(finance_book.expected_value_after_useful_life * remaining_qty) / asset.asset_quantity
+		)
+		frappe.db.set_value(
+			"Asset Finance Book", finance_book.name, "value_after_depreciation", value_after_depreciation
+		)
+		frappe.db.set_value(
+			"Asset Finance Book",
+			finance_book.name,
+			"expected_value_after_useful_life",
+			expected_value_after_useful_life,
+		)
+
+	accumulated_depreciation = 0
+
+	for term in asset.get("schedules"):
+		depreciation_amount = flt((term.depreciation_amount * remaining_qty) / asset.asset_quantity)
+		frappe.db.set_value(
+			"Depreciation Schedule", term.name, "depreciation_amount", depreciation_amount
+		)
+		accumulated_depreciation += depreciation_amount
+		frappe.db.set_value(
+			"Depreciation Schedule", term.name, "accumulated_depreciation_amount", accumulated_depreciation
+		)
+
+
+def create_new_asset_after_split(asset, split_qty):
+	new_asset = frappe.copy_doc(asset)
+	new_gross_purchase_amount = flt((asset.gross_purchase_amount * split_qty) / asset.asset_quantity)
+	opening_accumulated_depreciation = flt(
+		(asset.opening_accumulated_depreciation * split_qty) / asset.asset_quantity
+	)
+
+	new_asset.gross_purchase_amount = new_gross_purchase_amount
+	new_asset.opening_accumulated_depreciation = opening_accumulated_depreciation
+	new_asset.asset_quantity = split_qty
+	new_asset.split_from = asset.name
+	accumulated_depreciation = 0
+
+	for finance_book in new_asset.get("finance_books"):
+		finance_book.value_after_depreciation = flt(
+			(finance_book.value_after_depreciation * split_qty) / asset.asset_quantity
+		)
+		finance_book.expected_value_after_useful_life = flt(
+			(finance_book.expected_value_after_useful_life * split_qty) / asset.asset_quantity
+		)
+
+	for term in new_asset.get("schedules"):
+		depreciation_amount = flt((term.depreciation_amount * split_qty) / asset.asset_quantity)
+		term.depreciation_amount = depreciation_amount
+		accumulated_depreciation += depreciation_amount
+		term.accumulated_depreciation_amount = accumulated_depreciation
+
+	new_asset.submit()
+	new_asset.set_status()
+
+	for term in new_asset.get("schedules"):
+		# Update references in JV
+		if term.journal_entry:
+			add_reference_in_jv_on_split(
+				term.journal_entry, new_asset.name, asset.name, term.depreciation_amount
+			)
+
+	return new_asset
+
+
+def add_reference_in_jv_on_split(entry_name, new_asset_name, old_asset_name, depreciation_amount):
+	journal_entry = frappe.get_doc("Journal Entry", entry_name)
+	entries_to_add = []
+	idx = len(journal_entry.get("accounts")) + 1
+
+	for account in journal_entry.get("accounts"):
+		if account.reference_name == old_asset_name:
+			entries_to_add.append(frappe.copy_doc(account).as_dict())
+			if account.credit:
+				account.credit = account.credit - depreciation_amount
+				account.credit_in_account_currency = (
+					account.credit_in_account_currency - account.exchange_rate * depreciation_amount
+				)
+			elif account.debit:
+				account.debit = account.debit - depreciation_amount
+				account.debit_in_account_currency = (
+					account.debit_in_account_currency - account.exchange_rate * depreciation_amount
+				)
+
+	for entry in entries_to_add:
+		entry.reference_name = new_asset_name
+		if entry.credit:
+			entry.credit = depreciation_amount
+			entry.credit_in_account_currency = entry.exchange_rate * depreciation_amount
+		elif entry.debit:
+			entry.debit = depreciation_amount
+			entry.debit_in_account_currency = entry.exchange_rate * depreciation_amount
+
+		entry.idx = idx
+		idx += 1
+
+		journal_entry.append("accounts", entry)
+
+	journal_entry.flags.ignore_validate_update_after_submit = True
+	journal_entry.save()
+
+	# Repost GL Entries
+	journal_entry.docstatus = 2
+	journal_entry.make_gl_entries(1)
+	journal_entry.docstatus = 1
+	journal_entry.make_gl_entries()

erpnext/assets/doctype/asset/test_asset.py

@@ -7,7 +7,7 @@ import frappe
 from frappe.utils import add_days, add_months, cstr, flt, get_last_day, getdate, nowdate
 
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
-from erpnext.assets.doctype.asset.asset import make_sales_invoice
+from erpnext.assets.doctype.asset.asset import make_sales_invoice, split_asset
 from erpnext.assets.doctype.asset.depreciation import (
 	post_depreciation_entries,
 	restore_asset,
@@ -232,6 +232,57 @@ class TestAsset(AssetSetup):
 		si.cancel()
 		self.assertEqual(frappe.db.get_value("Asset", asset.name, "status"), "Partially Depreciated")
 
+	def test_asset_splitting(self):
+		asset = create_asset(
+			calculate_depreciation=1,
+			asset_quantity=10,
+			available_for_use_date="2020-01-01",
+			purchase_date="2020-01-01",
+			expected_value_after_useful_life=0,
+			total_number_of_depreciations=6,
+			number_of_depreciations_booked=1,
+			frequency_of_depreciation=10,
+			depreciation_start_date="2021-01-01",
+			opening_accumulated_depreciation=20000,
+			gross_purchase_amount=120000,
+			submit=1,
+		)
+
+		post_depreciation_entries(date="2021-01-01")
+
+		self.assertEqual(asset.asset_quantity, 10)
+		self.assertEqual(asset.gross_purchase_amount, 120000)
+		self.assertEqual(asset.opening_accumulated_depreciation, 20000)
+
+		new_asset = split_asset(asset.name, 2)
+		asset.load_from_db()
+
+		self.assertEqual(new_asset.asset_quantity, 2)
+		self.assertEqual(new_asset.gross_purchase_amount, 24000)
+		self.assertEqual(new_asset.opening_accumulated_depreciation, 4000)
+		self.assertEqual(new_asset.split_from, asset.name)
+		self.assertEqual(new_asset.schedules[0].depreciation_amount, 4000)
+		self.assertEqual(new_asset.schedules[1].depreciation_amount, 4000)
+
+		self.assertEqual(asset.asset_quantity, 8)
+		self.assertEqual(asset.gross_purchase_amount, 96000)
+		self.assertEqual(asset.opening_accumulated_depreciation, 16000)
+		self.assertEqual(asset.schedules[0].depreciation_amount, 16000)
+		self.assertEqual(asset.schedules[1].depreciation_amount, 16000)
+
+		journal_entry = asset.schedules[0].journal_entry
+
+		jv = frappe.get_doc("Journal Entry", journal_entry)
+		self.assertEqual(jv.accounts[0].credit_in_account_currency, 16000)
+		self.assertEqual(jv.accounts[1].debit_in_account_currency, 16000)
+		self.assertEqual(jv.accounts[2].credit_in_account_currency, 4000)
+		self.assertEqual(jv.accounts[3].debit_in_account_currency, 4000)
+
+		self.assertEqual(jv.accounts[0].reference_name, asset.name)
+		self.assertEqual(jv.accounts[1].reference_name, asset.name)
+		self.assertEqual(jv.accounts[2].reference_name, new_asset.name)
+		self.assertEqual(jv.accounts[3].reference_name, new_asset.name)
+
 	def test_expense_head(self):
 		pr = make_purchase_receipt(
 			item_code="Macbook Pro", qty=2, rate=200000.0, location="Test Location"
@@ -1291,6 +1342,7 @@ def create_asset(**args):
 			"location": args.location or "Test Location",
 			"asset_owner": args.asset_owner or "Company",
 			"is_existing_asset": args.is_existing_asset or 1,
+			"asset_quantity": args.get("asset_quantity") or 1,
 		}
 	)
 

erpnext/assets/doctype/asset_repair/asset_repair.py

@@ -41,46 +41,40 @@ class AssetRepair(AccountsController):
 
 		if self.get("stock_consumption") or self.get("capitalize_repair_cost"):
 			self.increase_asset_value()
+		if self.get("stock_consumption"):
+			self.check_for_stock_items_and_warehouse()
+			self.decrease_stock_quantity()
+		if self.get("capitalize_repair_cost"):
+			self.make_gl_entries()
+			if (
+				frappe.db.get_value("Asset", self.asset, "calculate_depreciation")
+				and self.increase_in_asset_life
+			):
+				self.modify_depreciation_schedule()
 
-			if self.get("stock_consumption"):
-				self.check_for_stock_items_and_warehouse()
-				self.decrease_stock_quantity()
-
-			if self.get("capitalize_repair_cost"):
-				self.make_gl_entries()
-
-				if (
-					frappe.db.get_value("Asset", self.asset, "calculate_depreciation")
-					and self.increase_in_asset_life
-				):
-					self.modify_depreciation_schedule()
-
-			self.asset_doc.flags.ignore_validate_update_after_submit = True
-			self.asset_doc.prepare_depreciation_data()
-			self.asset_doc.save()
+		self.asset_doc.flags.ignore_validate_update_after_submit = True
+		self.asset_doc.prepare_depreciation_data()
+		self.asset_doc.save()
 
 	def before_cancel(self):
 		self.asset_doc = frappe.get_doc("Asset", self.asset)
 
 		if self.get("stock_consumption") or self.get("capitalize_repair_cost"):
 			self.decrease_asset_value()
+		if self.get("stock_consumption"):
+			self.increase_stock_quantity()
+		if self.get("capitalize_repair_cost"):
+			self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry")
+			self.make_gl_entries(cancel=True)
+			if (
+				frappe.db.get_value("Asset", self.asset, "calculate_depreciation")
+				and self.increase_in_asset_life
+			):
+				self.revert_depreciation_schedule_on_cancellation()
 
-			if self.get("stock_consumption"):
-				self.increase_stock_quantity()
-
-			if self.get("capitalize_repair_cost"):
-				self.ignore_linked_doctypes = ("GL Entry", "Stock Ledger Entry")
-				self.make_gl_entries(cancel=True)
-
-				if (
-					frappe.db.get_value("Asset", self.asset, "calculate_depreciation")
-					and self.increase_in_asset_life
-				):
-					self.revert_depreciation_schedule_on_cancellation()
-
-			self.asset_doc.flags.ignore_validate_update_after_submit = True
-			self.asset_doc.prepare_depreciation_data()
-			self.asset_doc.save()
+		self.asset_doc.flags.ignore_validate_update_after_submit = True
+		self.asset_doc.prepare_depreciation_data()
+		self.asset_doc.save()
 
 	def check_repair_status(self):
 		if self.repair_status == "Pending":

erpnext/buying/doctype/purchase_order/purchase_order.json

@@ -23,10 +23,6 @@
   "order_confirmation_no",
   "order_confirmation_date",
   "amended_from",
-  "accounting_dimensions_section",
-  "cost_center",
-  "dimension_col_break",
-  "project",
   "drop_ship",
   "customer",
   "customer_name",
@@ -1142,39 +1138,16 @@
    "fieldtype": "Link",
    "label": "Tax Withholding Category",
    "options": "Tax Withholding Category"
-  },
-  {
-   "collapsible": 1,
-   "fieldname": "accounting_dimensions_section",
-   "fieldtype": "Section Break",
-   "label": "Accounting Dimensions "
-  },
-  {
-   "fieldname": "cost_center",
-   "fieldtype": "Link",
-   "label": "Cost Center",
-   "options": "Cost Center"
-  },
-  {
-   "fieldname": "dimension_col_break",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "project",
-   "fieldtype": "Link",
-   "label": "Project",
-   "options": "Project"
   }
  ],
  "icon": "fa fa-file-text",
  "idx": 105,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-04-26 12:16:38.694276",
+ "modified": "2021-09-28 13:10:47.955401",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Purchase Order",
- "naming_rule": "By \"Naming Series\" field",
  "owner": "Administrator",
  "permissions": [
   {
@@ -1221,7 +1194,6 @@
  "show_name_in_global_search": 1,
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "timeline_field": "supplier",
  "title_field": "supplier_name",
  "track_changes": 1

erpnext/buying/doctype/purchase_order/purchase_order.py

@@ -637,8 +637,6 @@ def make_rm_stock_entry(purchase_order, rm_items):
 						}
 					}
 					stock_entry.add_to_stock_entry_detail(items_dict)
-
-		stock_entry.set_missing_values()
 		return stock_entry.as_dict()
 	else:
 		frappe.throw(_("No Items selected for transfer"))
@@ -726,7 +724,7 @@ def make_return_stock_entry_for_subcontract(available_materials, po_doc, po_deta
 			add_items_in_ste(ste_doc, value, value.qty, po_details)
 
 	ste_doc.set_stock_entry_type()
-	ste_doc.set_missing_values()
+	ste_doc.calculate_rate_and_amount()
 
 	return ste_doc
 

erpnext/buying/doctype/request_for_quotation/request_for_quotation.js

@@ -31,7 +31,7 @@ frappe.ui.form.on("Request for Quotation",{
 		if (frm.doc.docstatus === 1) {
 
 			frm.add_custom_button(__('Supplier Quotation'),
-				function(){ frm.trigger("make_supplier_quotation") }, __("Create"));
+				function(){ frm.trigger("make_suppplier_quotation") }, __("Create"));
 
 
 			frm.add_custom_button(__("Send Emails to Suppliers"), function() {
@@ -87,24 +87,16 @@ frappe.ui.form.on("Request for Quotation",{
 
 	},
 
-	make_supplier_quotation: function(frm) {
+	make_suppplier_quotation: function(frm) {
 		var doc = frm.doc;
 		var dialog = new frappe.ui.Dialog({
 			title: __("Create Supplier Quotation"),
 			fields: [
-				{	"fieldtype": "Link",
-					"label": __("Supplier"),
+				{	"fieldtype": "Select", "label": __("Supplier"),
 					"fieldname": "supplier",
-					"options": 'Supplier',
+					"options": doc.suppliers.map(d => d.supplier),
 					"reqd": 1,
-					get_query: () => {
-						return {
-							filters: [
-								["Supplier", "name", "in", frm.doc.suppliers.map((row) => {return row.supplier;})]
-							]
-						}
-					}
-				}
+					"default": doc.suppliers.length === 1 ? doc.suppliers[0].supplier_name : "" },
 			],
 			primary_action_label: __("Create"),
 			primary_action: (args) => {

erpnext/buying/doctype/request_for_quotation/request_for_quotation.json

@@ -32,9 +32,7 @@
   "terms",
   "printing_settings",
   "select_print_heading",
-  "letter_head",
-  "more_info",
-  "opportunity"
+  "letter_head"
  ],
  "fields": [
   {
@@ -195,23 +193,6 @@
    "options": "Letter Head",
    "print_hide": 1
   },
-  {
-   "collapsible": 1,
-   "fieldname": "more_info",
-   "fieldtype": "Section Break",
-   "label": "More Information",
-   "oldfieldtype": "Section Break",
-   "options": "fa fa-file-text",
-   "print_hide": 1
-  },
-  {
-   "fieldname": "opportunity",
-   "fieldtype": "Link",
-   "label": "Opportunity",
-   "options": "Opportunity",
-   "print_hide": 1,
-   "read_only": 1
-  },
   {
    "fieldname": "status",
    "fieldtype": "Select",
@@ -277,7 +258,7 @@
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-04-06 17:47:49.909000",
+ "modified": "2021-11-24 17:47:49.909000",
  "modified_by": "Administrator",
  "module": "Buying",
  "name": "Request for Quotation",
@@ -346,4 +327,4 @@
  "show_name_in_global_search": 1,
  "sort_field": "modified",
  "sort_order": "DESC"
-}
+}

erpnext/controllers/accounts_controller.py

@@ -149,7 +149,6 @@ class AccountsController(TransactionBase):
 
 		self.validate_inter_company_reference()
 
-		self.disable_pricing_rule_on_internal_transfer()
 		self.set_incoming_rate()
 
 		if self.meta.get_field("currency"):
@@ -384,14 +383,6 @@ class AccountsController(TransactionBase):
 				msg += _("Please create purchase from internal sale or delivery document itself")
 				frappe.throw(msg, title=_("Internal Sales Reference Missing"))
 
-	def disable_pricing_rule_on_internal_transfer(self):
-		if not self.get("ignore_pricing_rule") and self.is_internal_transfer():
-			self.ignore_pricing_rule = 1
-			frappe.msgprint(
-				_("Disabled pricing rules since this {} is an internal transfer").format(self.doctype),
-				alert=1,
-			)
-
 	def validate_due_date(self):
 		if self.get("is_pos"):
 			return
@@ -1126,10 +1117,11 @@ class AccountsController(TransactionBase):
 							{
 								"account": item.discount_account,
 								"against": supplier_or_customer,
-								dr_or_cr: flt(
+								dr_or_cr: flt(discount_amount, item.precision("discount_amount")),
+								dr_or_cr
+								+ "_in_account_currency": flt(
 									discount_amount * self.get("conversion_rate"), item.precision("discount_amount")
 								),
-								dr_or_cr + "_in_account_currency": flt(discount_amount, item.precision("discount_amount")),
 								"cost_center": item.cost_center,
 								"project": item.project,
 							},
@@ -1144,11 +1136,11 @@ class AccountsController(TransactionBase):
 							{
 								"account": income_or_expense_account,
 								"against": supplier_or_customer,
-								rev_dr_cr: flt(
+								rev_dr_cr: flt(discount_amount, item.precision("discount_amount")),
+								rev_dr_cr
+								+ "_in_account_currency": flt(
 									discount_amount * self.get("conversion_rate"), item.precision("discount_amount")
 								),
-								rev_dr_cr
-								+ "_in_account_currency": flt(discount_amount, item.precision("discount_amount")),
 								"cost_center": item.cost_center,
 								"project": item.project or self.project,
 							},
@@ -1744,8 +1736,6 @@ class AccountsController(TransactionBase):
 			internal_party_field = "is_internal_customer"
 		elif self.doctype in ("Purchase Invoice", "Purchase Receipt", "Purchase Order"):
 			internal_party_field = "is_internal_supplier"
-		else:
-			return False
 
 		if self.get(internal_party_field) and (self.represents_company == self.company):
 			return True
@@ -2010,13 +2000,12 @@ def get_advance_journal_entries(
 
 	reference_condition = " and (" + " or ".join(conditions) + ")" if conditions else ""
 
-	# nosemgrep
 	journal_entries = frappe.db.sql(
 		"""
 		select
 			"Journal Entry" as reference_type, t1.name as reference_name,
 			t1.remark as remarks, t2.{0} as amount, t2.name as reference_row,
-			t2.reference_name as against_order, t2.exchange_rate
+			t2.reference_name as against_order
 		from
 			`tabJournal Entry` t1, `tabJournal Entry Account` t2
 		where
@@ -2459,21 +2448,11 @@ def update_child_qty_rate(parent_doctype, trans_items, parent_doctype_name, chil
 			parent_doctype, parent_doctype_name, child_doctype, child_docname, item_row
 		)
 
-	def validate_quantity(child_item, new_data):
-		if not flt(new_data.get("qty")):
-			frappe.throw(
-				_("Row # {0}: Quantity for Item {1} cannot be zero").format(
-					new_data.get("idx"), frappe.bold(new_data.get("item_code"))
-				),
-				title=_("Invalid Qty"),
-			)
-
-		if parent_doctype == "Sales Order" and flt(new_data.get("qty")) < flt(child_item.delivered_qty):
+	def validate_quantity(child_item, d):
+		if parent_doctype == "Sales Order" and flt(d.get("qty")) < flt(child_item.delivered_qty):
 			frappe.throw(_("Cannot set quantity less than delivered quantity"))
 
-		if parent_doctype == "Purchase Order" and flt(new_data.get("qty")) < flt(
-			child_item.received_qty
-		):
+		if parent_doctype == "Purchase Order" and flt(d.get("qty")) < flt(child_item.received_qty):
 			frappe.throw(_("Cannot set quantity less than received quantity"))
 
 	data = json.loads(trans_items)

erpnext/controllers/buying_controller.py

@@ -306,15 +306,14 @@ class BuyingController(StockController, Subcontracting):
 				if self.is_internal_transfer():
 					if rate != d.rate:
 						d.rate = rate
+						d.discount_percentage = 0
+						d.discount_amount = 0
 						frappe.msgprint(
 							_(
 								"Row {0}: Item rate has been updated as per valuation rate since its an internal stock transfer"
 							).format(d.idx),
 							alert=1,
 						)
-					d.discount_percentage = 0.0
-					d.discount_amount = 0.0
-					d.margin_rate_or_amount = 0.0
 
 	def get_supplied_items_cost(self, item_row_id, reset_outgoing_rate=True):
 		supplied_items_cost = 0.0
@@ -628,7 +627,7 @@ class BuyingController(StockController, Subcontracting):
 					}
 				)
 
-				validate_expense_against_budget(args)
+			validate_expense_against_budget(args)
 
 	def process_fixed_asset(self):
 		if self.doctype == "Purchase Invoice" and not self.update_stock:

erpnext/controllers/queries.py

@@ -162,7 +162,6 @@ def tax_account_query(doctype, txt, searchfield, start, page_len, filters):
 				{account_type_condition}
 				AND is_group = 0
 				AND company = %(company)s
-				AND disabled = %(disabled)s
 				AND (account_currency = %(currency)s or ifnull(account_currency, '') = '')
 				AND `{searchfield}` LIKE %(txt)s
 				{mcond}
@@ -176,7 +175,6 @@ def tax_account_query(doctype, txt, searchfield, start, page_len, filters):
 			dict(
 				account_types=filters.get("account_type"),
 				company=filters.get("company"),
-				disabled=filters.get("disabled", 0),
 				currency=company_currency,
 				txt="%{}%".format(txt),
 				offset=start,

erpnext/controllers/selling_controller.py

@@ -446,16 +446,15 @@ class SellingController(StockController):
 						rate = flt(d.incoming_rate * d.conversion_factor, d.precision("rate"))
 						if d.rate != rate:
 							d.rate = rate
-							frappe.msgprint(
-								_(
-									"Row {0}: Item rate has been updated as per valuation rate since its an internal stock transfer"
-								).format(d.idx),
-								alert=1,
-							)
 
-						d.discount_percentage = 0.0
-						d.discount_amount = 0.0
-						d.margin_rate_or_amount = 0.0
+						d.discount_percentage = 0
+						d.discount_amount = 0
+						frappe.msgprint(
+							_(
+								"Row {0}: Item rate has been updated as per valuation rate since its an internal stock transfer"
+							).format(d.idx),
+							alert=1,
+						)
 
 			elif self.get("return_against"):
 				# Get incoming rate of return entry from reference document

erpnext/crm/doctype/opportunity/opportunity.py

@@ -8,7 +8,7 @@ import frappe
 from frappe import _
 from frappe.email.inbox import link_communication_to_document
 from frappe.model.mapper import get_mapped_doc
-from frappe.utils import cint, get_fullname
+from frappe.utils import cint, cstr, get_fullname
 
 from erpnext.accounts.party import get_party_account_currency
 from erpnext.setup.utils import get_exchange_rate
@@ -193,20 +193,20 @@ class Opportunity(TransactionBase):
 
 		if self.party_name and self.opportunity_from == "Customer":
 			if self.contact_person:
-				opts.description = f"Contact {self.contact_person}"
+				opts.description = "Contact " + cstr(self.contact_person)
 			else:
-				opts.description = f"Contact customer {self.party_name}"
+				opts.description = "Contact customer " + cstr(self.party_name)
 		elif self.party_name and self.opportunity_from == "Lead":
 			if self.contact_display:
-				opts.description = f"Contact {self.contact_display}"
+				opts.description = "Contact " + cstr(self.contact_display)
 			else:
-				opts.description = f"Contact lead {self.party_name}"
+				opts.description = "Contact lead " + cstr(self.party_name)
 
 		opts.subject = opts.description
-		opts.description += f". By : {self.contact_by}"
+		opts.description += ". By : " + cstr(self.contact_by)
 
 		if self.to_discuss:
-			opts.description += f" To Discuss : {frappe.render_template(self.to_discuss, {'doc': self})}"
+			opts.description += " To Discuss : " + cstr(self.to_discuss)
 
 		super(Opportunity, self).add_calendar_event(opts, force)
 

erpnext/crm/doctype/opportunity/opportunity_dashboard.py

@@ -2,6 +2,6 @@ def get_data():
 	return {
 		"fieldname": "opportunity",
 		"transactions": [
-			{"items": ["Quotation", "Request for Quotation", "Supplier Quotation"]},
+			{"items": ["Quotation", "Supplier Quotation"]},
 		],
 	}

erpnext/crm/doctype/opportunity/test_opportunity.py

@@ -4,7 +4,7 @@
 import unittest
 
 import frappe
-from frappe.utils import add_days, now_datetime, random_string, today
+from frappe.utils import random_string, today
 
 from erpnext.crm.doctype.lead.lead import make_customer
 from erpnext.crm.doctype.opportunity.opportunity import make_quotation
@@ -58,22 +58,6 @@ class TestOpportunity(unittest.TestCase):
 		self.assertEqual(opp_doc.opportunity_from, "Customer")
 		self.assertEqual(opp_doc.party_name, customer.name)
 
-	def test_render_template_for_to_discuss(self):
-		doc = make_opportunity(with_items=0, opportunity_from="Lead")
-		doc.contact_by = "test@example.com"
-		doc.contact_date = add_days(today(), days=2)
-		doc.to_discuss = "{{ doc.name }} test data"
-		doc.save()
-
-		event = frappe.get_all(
-			"Event Participants",
-			fields=["parent"],
-			filters={"reference_doctype": doc.doctype, "reference_docname": doc.name},
-		)
-
-		event_description = frappe.db.get_value("Event", event[0].parent, "description")
-		self.assertTrue(doc.name in event_description)
-
 
 def make_opportunity(**args):
 	args = frappe._dict(args)

erpnext/e_commerce/doctype/e_commerce_settings/e_commerce_settings.js

@@ -24,17 +24,17 @@ frappe.ui.form.on("E Commerce Settings", {
 			);
 		}
 
-		frappe.model.with_doctype("Website Item", () => {
+		frappe.model.with_doctype("Item", () => {
 			const web_item_meta = frappe.get_meta('Website Item');
 
 			const valid_fields = web_item_meta.fields.filter(
 				df => ["Link", "Table MultiSelect"].includes(df.fieldtype) && !df.hidden
 			).map(df => ({ label: df.label, value: df.fieldname }));
 
-			frm.get_field("filter_fields").grid.update_docfield_property(
+			frm.fields_dict.filter_fields.grid.update_docfield_property(
 				'fieldname', 'fieldtype', 'Select'
 			);
-			frm.get_field("filter_fields").grid.update_docfield_property(
+			frm.fields_dict.filter_fields.grid.update_docfield_property(
 				'fieldname', 'options', valid_fields
 			);
 		});

erpnext/e_commerce/doctype/e_commerce_settings/e_commerce_settings.py

@@ -26,7 +26,7 @@ class ECommerceSettings(Document):
 		self.is_redisearch_loaded = is_search_module_loaded()
 
 	def validate(self):
-		self.validate_field_filters(self.filter_fields, self.enable_field_filters)
+		self.validate_field_filters()
 		self.validate_attribute_filters()
 		self.validate_checkout()
 		self.validate_search_index_fields()
@@ -50,22 +50,21 @@ class ECommerceSettings(Document):
 			define_autocomplete_dictionary()
 			create_website_items_index()
 
-	@staticmethod
-	def validate_field_filters(filter_fields, enable_field_filters):
-		if not (enable_field_filters and filter_fields):
+	def validate_field_filters(self):
+		if not (self.enable_field_filters and self.filter_fields):
 			return
 
-		web_item_meta = frappe.get_meta("Website Item")
+		item_meta = frappe.get_meta("Item")
 		valid_fields = [
-			df.fieldname for df in web_item_meta.fields if df.fieldtype in ["Link", "Table MultiSelect"]
+			df.fieldname for df in item_meta.fields if df.fieldtype in ["Link", "Table MultiSelect"]
 		]
 
-		for row in filter_fields:
-			if row.fieldname not in valid_fields:
+		for f in self.filter_fields:
+			if f.fieldname not in valid_fields:
 				frappe.throw(
 					_(
-						"Filter Fields Row #{0}: Fieldname {1} must be of type 'Link' or 'Table MultiSelect'"
-					).format(row.idx, frappe.bold(row.fieldname))
+						"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type 'Link' or 'Table MultiSelect'"
+					).format(f.idx, f.fieldname)
 				)
 
 	def validate_attribute_filters(self):

erpnext/e_commerce/doctype/e_commerce_settings/test_e_commerce_settings.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
 import unittest
@@ -11,34 +11,42 @@ from erpnext.e_commerce.doctype.e_commerce_settings.e_commerce_settings import (
 
 
 class TestECommerceSettings(unittest.TestCase):
-	def tearDown(self):
-		frappe.db.rollback()
+	def setUp(self):
+		frappe.db.sql("""delete from `tabSingles` where doctype="Shipping Cart Settings" """)
+
+	def get_cart_settings(self):
+		return frappe.get_doc({"doctype": "E Commerce Settings", "company": "_Test Company"})
+
+	# NOTE: Exchangrate API has all enabled currencies that ERPNext supports.
+	# We aren't checking just currency exchange record anymore
+	# while validating price list currency exchange rate to that of company.
+	# The API is being used to fetch the rate which again almost always
+	# gives back a valid value (for valid currencies).
+	# This makes the test obsolete.
+	# Commenting because im not sure if there's a better test we can write
+
+	# def test_exchange_rate_exists(self):
+	# 	frappe.db.sql("""delete from `tabCurrency Exchange`""")
+
+	# 	cart_settings = self.get_cart_settings()
+	# 	cart_settings.price_list = "_Test Price List Rest of the World"
+	# 	self.assertRaises(ShoppingCartSetupError, cart_settings.validate_price_list_exchange_rate)
+
+	# 	from erpnext.setup.doctype.currency_exchange.test_currency_exchange import test_records as \
+	# 		currency_exchange_records
+	# 	frappe.get_doc(currency_exchange_records[0]).insert()
+	# 	cart_settings.validate_price_list_exchange_rate()
 
 	def test_tax_rule_validation(self):
 		frappe.db.sql("update `tabTax Rule` set use_for_shopping_cart = 0")
 
-		cart_settings = frappe.get_doc("E Commerce Settings")
+		cart_settings = self.get_cart_settings()
 		cart_settings.enabled = 1
 		if not frappe.db.get_value("Tax Rule", {"use_for_shopping_cart": 1}, "name"):
 			self.assertRaises(ShoppingCartSetupError, cart_settings.validate_tax_rule)
 
 		frappe.db.sql("update `tabTax Rule` set use_for_shopping_cart = 1")
 
-	def test_invalid_filter_fields(self):
-		"Check if Item fields are blocked in E Commerce Settings filter fields."
-		from frappe.custom.doctype.custom_field.custom_field import create_custom_field
-
-		setup_e_commerce_settings({"enable_field_filters": 1})
-
-		create_custom_field(
-			"Item",
-			dict(owner="Administrator", fieldname="test_data", label="Test", fieldtype="Data"),
-		)
-		settings = frappe.get_doc("E Commerce Settings")
-		settings.append("filter_fields", {"fieldname": "test_data"})
-
-		self.assertRaises(frappe.ValidationError, settings.save)
-
 
 def setup_e_commerce_settings(values_dict):
 	"Accepts a dict of values that updates E Commerce Settings."

erpnext/e_commerce/product_data_engine/filters.py

@@ -22,14 +22,12 @@ class ProductFiltersBuilder:
 		fields, filter_data = [], []
 		filter_fields = [row.fieldname for row in self.doc.filter_fields]  # fields in settings
 
-		# filter valid field filters i.e. those that exist in Website Item
-		web_item_meta = frappe.get_meta("Website Item", cached=True)
-		fields = [
-			web_item_meta.get_field(field) for field in filter_fields if web_item_meta.has_field(field)
-		]
+		# filter valid field filters i.e. those that exist in Item
+		item_meta = frappe.get_meta("Item", cached=True)
+		fields = [item_meta.get_field(field) for field in filter_fields if item_meta.has_field(field)]
 
 		for df in fields:
-			item_filters, item_or_filters = {"published": 1}, []
+			item_filters, item_or_filters = {"published_in_website": 1}, []
 			link_doctype_values = self.get_filtered_link_doctype_records(df)
 
 			if df.fieldtype == "Link":
@@ -52,13 +50,9 @@ class ProductFiltersBuilder:
 							]
 						)
 
-				# exclude variants if mentioned in settings
-				if frappe.db.get_single_value("E Commerce Settings", "hide_variants"):
-					item_filters["variant_of"] = ["is", "not set"]
-
 				# Get link field values attached to published items
 				item_values = frappe.get_all(
-					"Website Item",
+					"Item",
 					fields=[df.fieldname],
 					filters=item_filters,
 					or_filters=item_or_filters,

erpnext/e_commerce/product_data_engine/test_product_data_engine.py

@@ -277,54 +277,6 @@ class TestProductDataEngine(unittest.TestCase):
 		# tear down
 		setup_e_commerce_settings({"enable_attribute_filters": 1, "hide_variants": 0})
 
-	def test_custom_field_as_filter(self):
-		"Test if custom field functions as filter correctly."
-		from frappe.custom.doctype.custom_field.custom_field import create_custom_field
-
-		create_custom_field(
-			"Website Item",
-			dict(
-				owner="Administrator",
-				fieldname="supplier",
-				label="Supplier",
-				fieldtype="Link",
-				options="Supplier",
-				insert_after="on_backorder",
-			),
-		)
-
-		frappe.db.set_value(
-			"Website Item", {"item_code": "Test 11I Laptop"}, "supplier", "_Test Supplier"
-		)
-		frappe.db.set_value(
-			"Website Item", {"item_code": "Test 12I Laptop"}, "supplier", "_Test Supplier 1"
-		)
-
-		settings = frappe.get_doc("E Commerce Settings")
-		settings.append("filter_fields", {"fieldname": "supplier"})
-		settings.save()
-
-		filter_engine = ProductFiltersBuilder()
-		field_filters = filter_engine.get_field_filters()
-		custom_filter = field_filters[1]
-		filter_values = custom_filter[1]
-
-		self.assertEqual(custom_filter[0].options, "Supplier")
-		self.assertEqual(len(filter_values), 2)
-		self.assertIn("_Test Supplier", filter_values)
-
-		# test if custom filter works in query
-		field_filters = {"supplier": "_Test Supplier 1"}
-		engine = ProductQuery()
-		result = engine.query(
-			attributes={}, fields=field_filters, search_term=None, start=0, item_group=None
-		)
-		items = result.get("items")
-
-		# check if only 'Raw Material' are fetched in the right order
-		self.assertEqual(len(items), 1)
-		self.assertEqual(items[0].get("item_code"), "Test 12I Laptop")
-
 
 def create_variant_web_item():
 	"Create Variant and Template Website Items."

erpnext/hooks.py

@@ -382,7 +382,6 @@ doc_events = {
 		"validate": [
 			"erpnext.regional.india.utils.validate_document_name",
 			"erpnext.regional.india.utils.update_taxable_values",
-			"erpnext.regional.india.utils.validate_sez_and_export_invoices",
 		],
 	},
 	"POS Invoice": {"on_submit": ["erpnext.regional.saudi_arabia.utils.create_qr_code"]},
@@ -593,9 +592,6 @@ accounting_dimension_doctypes = [
 	"Subscription Plan",
 	"POS Invoice",
 	"POS Invoice Item",
-	"Purchase Order",
-	"Purchase Receipt",
-	"Sales Order",
 ]
 
 regional_overrides = {

erpnext/hr/doctype/attendance/attendance.py

@@ -21,9 +21,6 @@ class Attendance(Document):
 		self.validate_employee_status()
 		self.check_leave_record()
 
-	def on_cancel(self):
-		self.unlink_attendance_from_checkins()
-
 	def validate_attendance_date(self):
 		date_of_joining = frappe.db.get_value("Employee", self.employee, "date_of_joining")
 
@@ -105,35 +102,6 @@ class Attendance(Document):
 		if not emp:
 			frappe.throw(_("Employee {0} is not active or does not exist").format(self.employee))
 
-	def unlink_attendance_from_checkins(self):
-		from frappe.utils import get_link_to_form
-
-		EmployeeCheckin = frappe.qb.DocType("Employee Checkin")
-		linked_logs = (
-			frappe.qb.from_(EmployeeCheckin)
-			.select(EmployeeCheckin.name)
-			.where(EmployeeCheckin.attendance == self.name)
-			.for_update()
-			.run(as_dict=True)
-		)
-
-		if linked_logs:
-			(
-				frappe.qb.update(EmployeeCheckin)
-				.set("attendance", "")
-				.where(EmployeeCheckin.attendance == self.name)
-			).run()
-
-			frappe.msgprint(
-				msg=_("Unlinked Attendance record from Employee Checkins: {}").format(
-					", ".join(get_link_to_form("Employee Checkin", log.name) for log in linked_logs)
-				),
-				title=_("Unlinked logs"),
-				indicator="blue",
-				is_minimizable=True,
-				wide=True,
-			)
-
 
 @frappe.whitelist()
 def get_events(start, end, filters=None):

erpnext/hr/doctype/employee_advance/employee_advance.js

@@ -65,10 +65,9 @@ frappe.ui.form.on('Employee Advance', {
 			);
 		}
 
-		if (
-			frm.doc.docstatus === 1
-			&& (flt(frm.doc.claimed_amount) < flt(frm.doc.paid_amount) - flt(frm.doc.return_amount))
-		) {
+		if (frm.doc.docstatus === 1 &&
+			(flt(frm.doc.claimed_amount) < flt(frm.doc.paid_amount) && flt(frm.doc.paid_amount) != flt(frm.doc.return_amount))) {
+
 			if (frm.doc.repay_unclaimed_amount_from_salary == 0 && frappe.model.can_create("Journal Entry")) {
 				frm.add_custom_button(__("Return"), function() {
 					frm.trigger('make_return_entry');

erpnext/hr/doctype/employee_checkin/employee_checkin.py

@@ -5,7 +5,7 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.utils import cint, get_datetime, get_link_to_form
+from frappe.utils import cint, get_datetime
 
 from erpnext.hr.doctype.shift_assignment.shift_assignment import (
 	get_actual_start_end_datetime_of_shift,
@@ -127,17 +127,19 @@ def mark_attendance_and_link_log(
 	log_names = [x.name for x in logs]
 	employee = logs[0].employee
 	if attendance_status == "Skip":
-		skip_attendance_in_checkins(log_names)
+		frappe.db.sql(
+			"""update `tabEmployee Checkin`
+			set skip_auto_attendance = %s
+			where name in %s""",
+			("1", log_names),
+		)
 		return None
-
 	elif attendance_status in ("Present", "Absent", "Half Day"):
 		employee_doc = frappe.get_doc("Employee", employee)
-		duplicate = frappe.db.exists(
+		if not frappe.db.exists(
 			"Attendance",
 			{"employee": employee, "attendance_date": attendance_date, "docstatus": ("!=", "2")},
-		)
-
-		if not duplicate:
+		):
 			doc_dict = {
 				"doctype": "Attendance",
 				"employee": employee,
@@ -153,12 +155,6 @@ def mark_attendance_and_link_log(
 			}
 			attendance = frappe.get_doc(doc_dict).insert()
 			attendance.submit()
-
-			if attendance_status == "Absent":
-				attendance.add_comment(
-					text=_("Employee was marked Absent for not meeting the working hours threshold.")
-				)
-
 			frappe.db.sql(
 				"""update `tabEmployee Checkin`
 				set attendance = %s
@@ -167,10 +163,12 @@ def mark_attendance_and_link_log(
 			)
 			return attendance
 		else:
-			skip_attendance_in_checkins(log_names)
-			if duplicate:
-				add_comment_in_checkins(log_names, duplicate)
-
+			frappe.db.sql(
+				"""update `tabEmployee Checkin`
+				set skip_auto_attendance = %s
+				where name in %s""",
+				("1", log_names),
+			)
 			return None
 	else:
 		frappe.throw(_("{} is an invalid Attendance Status.").format(attendance_status))
@@ -225,15 +223,11 @@ def calculate_working_hours(logs, check_in_out_type, working_hours_calc_type):
 					in_log = out_log = None
 				if not in_log:
 					in_log = log if log.log_type == "IN" else None
-					if in_log and not in_time:
-						in_time = in_log.time
 				elif not out_log:
 					out_log = log if log.log_type == "OUT" else None
-
 			if in_log and out_log:
 				out_time = out_log.time
 				total_hours += time_diff_in_hours(in_log.time, out_log.time)
-
 	return total_hours, in_time, out_time
 
 
@@ -243,29 +237,3 @@ def time_diff_in_hours(start, end):
 
 def find_index_in_dict(dict_list, key, value):
 	return next((index for (index, d) in enumerate(dict_list) if d[key] == value), None)
-
-
-def add_comment_in_checkins(log_names, duplicate):
-	text = _("Auto Attendance skipped due to duplicate attendance record: {}").format(
-		get_link_to_form("Attendance", duplicate)
-	)
-
-	for name in log_names:
-		frappe.get_doc(
-			{
-				"doctype": "Comment",
-				"comment_type": "Comment",
-				"reference_doctype": "Employee Checkin",
-				"reference_name": name,
-				"content": text,
-			}
-		).insert(ignore_permissions=True)
-
-
-def skip_attendance_in_checkins(log_names):
-	EmployeeCheckin = frappe.qb.DocType("Employee Checkin")
-	(
-		frappe.qb.update(EmployeeCheckin)
-		.set("skip_auto_attendance", 1)
-		.where(EmployeeCheckin.name.isin(log_names))
-	).run()

erpnext/hr/doctype/employee_checkin/test_employee_checkin.py

@@ -54,17 +54,6 @@ class TestEmployeeCheckin(unittest.TestCase):
 		)
 		self.assertEqual(attendance_count, 1)
 
-	def test_unlink_attendance_on_cancellation(self):
-		employee = make_employee("test_mark_attendance_and_link_log@example.com")
-		logs = make_n_checkins(employee, 3)
-
-		frappe.db.delete("Attendance", {"employee": employee})
-		attendance = mark_attendance_and_link_log(logs, "Present", nowdate(), 8.2)
-		attendance.cancel()
-
-		linked_logs = frappe.db.get_all("Employee Checkin", {"attendance": attendance.name})
-		self.assertEquals(len(linked_logs), 0)
-
 	def test_calculate_working_hours(self):
 		check_in_out_type = [
 			"Alternating entries as IN and OUT during the same shift",
@@ -114,11 +103,6 @@ class TestEmployeeCheckin(unittest.TestCase):
 		)
 		self.assertEqual(working_hours, (4.5, logs_type_2[1].time, logs_type_2[-1].time))
 
-		working_hours = calculate_working_hours(
-			[logs_type_2[1], logs_type_2[-1]], check_in_out_type[1], working_hours_calc_type[1]
-		)
-		self.assertEqual(working_hours, (5.0, logs_type_2[1].time, logs_type_2[-1].time))
-
 
 def make_n_checkins(employee, n, hours_to_reverse=1):
 	logs = [make_checkin(employee, now_datetime() - timedelta(hours=hours_to_reverse, minutes=n + 1))]

erpnext/hr/doctype/leave_allocation/leave_allocation.js

@@ -34,6 +34,15 @@ frappe.ui.form.on("Leave Allocation", {
 				});
 			}
 		}
+
+		// make new leaves allocated field read only if allocation is created via leave policy assignment
+		// and leave type is earned leave, since these leaves would be allocated via the scheduler
+		if (frm.doc.leave_policy_assignment) {
+			frappe.db.get_value("Leave Type", frm.doc.leave_type, "is_earned_leave", (r) => {
+				if (r && cint(r.is_earned_leave))
+					frm.set_df_property("new_leaves_allocated", "read_only", 1);
+			});
+		}
 	},
 
 	expire_allocation: function(frm) {

erpnext/hr/doctype/leave_allocation/leave_allocation.py

@@ -254,18 +254,7 @@ class LeaveAllocation(Document):
 		# Adding a day to include To Date in the difference
 		date_difference = date_diff(self.to_date, self.from_date) + 1
 		if date_difference < self.total_leaves_allocated:
-			if frappe.db.get_value("Leave Type", self.leave_type, "allow_over_allocation"):
-				frappe.msgprint(
-					_("<b>Total Leaves Allocated</b> are more than the number of days in the allocation period"),
-					indicator="orange",
-					alert=True,
-				)
-			else:
-				frappe.throw(
-					_("<b>Total Leaves Allocated</b> are more than the number of days in the allocation period"),
-					exc=OverAllocationError,
-					title=_("Over Allocation"),
-				)
+			frappe.throw(_("Total allocated leaves are more than days in the period"), OverAllocationError)
 
 	def create_leave_ledger_entry(self, submit=True):
 		if self.unused_leaves:

erpnext/hr/doctype/leave_allocation/test_leave_allocation.py

@@ -68,44 +68,22 @@ class TestLeaveAllocation(FrappeTestCase):
 		self.assertRaises(frappe.ValidationError, doc.save)
 
 	def test_validation_for_over_allocation(self):
-		leave_type = create_leave_type(leave_type_name="Test Over Allocation", is_carry_forward=1)
-		leave_type.save()
-
 		doc = frappe.get_doc(
 			{
 				"doctype": "Leave Allocation",
 				"__islocal": 1,
 				"employee": self.employee.name,
 				"employee_name": self.employee.employee_name,
-				"leave_type": leave_type.name,
+				"leave_type": "_Test Leave Type",
 				"from_date": getdate("2015-09-1"),
 				"to_date": getdate("2015-09-30"),
 				"new_leaves_allocated": 35,
-				"carry_forward": 1,
 			}
 		)
 
 		# allocated leave more than period
 		self.assertRaises(OverAllocationError, doc.save)
 
-		leave_type.allow_over_allocation = 1
-		leave_type.save()
-
-		# allows creating a leave allocation with more leave days than period days
-		doc = frappe.get_doc(
-			{
-				"doctype": "Leave Allocation",
-				"__islocal": 1,
-				"employee": self.employee.name,
-				"employee_name": self.employee.employee_name,
-				"leave_type": leave_type.name,
-				"from_date": getdate("2015-09-1"),
-				"to_date": getdate("2015-09-30"),
-				"new_leaves_allocated": 35,
-				"carry_forward": 1,
-			}
-		).insert()
-
 	def test_validation_for_over_allocation_post_submission(self):
 		allocation = frappe.get_doc(
 			{

erpnext/hr/doctype/leave_application/test_leave_application.py

@@ -744,7 +744,7 @@ class TestLeaveApplication(unittest.TestCase):
 
 		i = 0
 		while i < 14:
-			allocate_earned_leaves()
+			allocate_earned_leaves(ignore_duplicates=True)
 			i += 1
 		self.assertEqual(get_leave_balance_on(employee.name, leave_type, nowdate()), 6)
 
@@ -752,7 +752,7 @@ class TestLeaveApplication(unittest.TestCase):
 		frappe.db.set_value("Leave Type", leave_type, "max_leaves_allowed", 0)
 		i = 0
 		while i < 6:
-			allocate_earned_leaves()
+			allocate_earned_leaves(ignore_duplicates=True)
 			i += 1
 		self.assertEqual(get_leave_balance_on(employee.name, leave_type, nowdate()), 9)
 

erpnext/hr/doctype/leave_policy_assignment/test_leave_policy_assignment.py

@@ -4,7 +4,6 @@
 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 erpnext.hr.doctype.leave_application.test_leave_application import (
@@ -19,7 +18,7 @@ from erpnext.hr.doctype.leave_policy_assignment.leave_policy_assignment import (
 test_dependencies = ["Employee"]
 
 
-class TestLeavePolicyAssignment(FrappeTestCase):
+class TestLeavePolicyAssignment(unittest.TestCase):
 	def setUp(self):
 		for doctype in [
 			"Leave Period",
@@ -40,9 +39,6 @@ class TestLeavePolicyAssignment(FrappeTestCase):
 		leave_policy = create_leave_policy()
 		leave_policy.submit()
 
-		self.employee.date_of_joining = get_first_day(leave_period.from_date)
-		self.employee.save()
-
 		data = {
 			"assignment_based_on": "Leave Period",
 			"leave_policy": leave_policy.name,
@@ -191,6 +187,19 @@ class TestLeavePolicyAssignment(FrappeTestCase):
 		)
 		self.assertEqual(leaves_allocated, 3)
 
+		# if the daily job is not completed yet, there is another check present
+		# to ensure leave is not already allocated to avoid duplication
+		from erpnext.hr.utils import allocate_earned_leaves
+
+		allocate_earned_leaves()
+
+		leaves_allocated = frappe.db.get_value(
+			"Leave Allocation",
+			{"leave_policy_assignment": leave_policy_assignments[0]},
+			"total_leaves_allocated",
+		)
+		self.assertEqual(leaves_allocated, 3)
+
 	def test_earned_leave_alloc_for_passed_months_with_cf_leaves_based_on_leave_period(self):
 		from erpnext.hr.doctype.leave_allocation.test_leave_allocation import create_leave_allocation
 
@@ -232,6 +241,20 @@ class TestLeavePolicyAssignment(FrappeTestCase):
 		self.assertEqual(details.unused_leaves, 5)
 		self.assertEqual(details.total_leaves_allocated, 7)
 
+		# if the daily job is not completed yet, there is another check present
+		# to ensure leave is not already allocated to avoid duplication
+		from erpnext.hr.utils import is_earned_leave_already_allocated
+
+		frappe.flags.current_date = get_last_day(getdate())
+
+		allocation = frappe.get_doc("Leave Allocation", details.name)
+		# 1 leave is still pending to be allocated, irrespective of carry forwarded leaves
+		self.assertFalse(
+			is_earned_leave_already_allocated(
+				allocation, leave_policy.leave_policy_details[0].annual_allocation
+			)
+		)
+
 	def test_earned_leave_alloc_for_passed_months_based_on_joining_date(self):
 		# tests leave alloc for earned leaves for assignment based on joining date in policy assignment
 		leave_type = create_earned_leave_type("Test Earned Leave")
@@ -264,6 +287,19 @@ class TestLeavePolicyAssignment(FrappeTestCase):
 		self.assertEqual(effective_from, self.employee.date_of_joining)
 		self.assertEqual(leaves_allocated, 3)
 
+		# to ensure leave is not already allocated to avoid duplication
+		from erpnext.hr.utils import allocate_earned_leaves
+
+		frappe.flags.current_date = get_last_day(getdate())
+		allocate_earned_leaves()
+
+		leaves_allocated = frappe.db.get_value(
+			"Leave Allocation",
+			{"leave_policy_assignment": leave_policy_assignments[0]},
+			"total_leaves_allocated",
+		)
+		self.assertEqual(leaves_allocated, 3)
+
 	def test_grant_leaves_on_doj_for_earned_leaves_based_on_leave_period(self):
 		# tests leave alloc based on leave period for earned leaves with "based on doj" configuration in leave type
 		leave_period, leave_policy = setup_leave_period_and_policy(
@@ -293,6 +329,20 @@ class TestLeavePolicyAssignment(FrappeTestCase):
 		)
 		self.assertEqual(leaves_allocated, 3)
 
+		# if the daily job is not completed yet, there is another check present
+		# to ensure leave is not already allocated to avoid duplication
+		from erpnext.hr.utils import allocate_earned_leaves
+
+		frappe.flags.current_date = get_first_day(getdate())
+		allocate_earned_leaves()
+
+		leaves_allocated = frappe.db.get_value(
+			"Leave Allocation",
+			{"leave_policy_assignment": leave_policy_assignments[0]},
+			"total_leaves_allocated",
+		)
+		self.assertEqual(leaves_allocated, 3)
+
 	def test_grant_leaves_on_doj_for_earned_leaves_based_on_joining_date(self):
 		# tests leave alloc based on joining date for earned leaves with "based on doj" configuration in leave type
 		leave_type = create_earned_leave_type("Test Earned Leave", based_on_doj=True)
@@ -326,7 +376,21 @@ class TestLeavePolicyAssignment(FrappeTestCase):
 		self.assertEqual(effective_from, self.employee.date_of_joining)
 		self.assertEqual(leaves_allocated, 3)
 
+		# to ensure leave is not already allocated to avoid duplication
+		from erpnext.hr.utils import allocate_earned_leaves
+
+		frappe.flags.current_date = get_first_day(getdate())
+		allocate_earned_leaves()
+
+		leaves_allocated = frappe.db.get_value(
+			"Leave Allocation",
+			{"leave_policy_assignment": leave_policy_assignments[0]},
+			"total_leaves_allocated",
+		)
+		self.assertEqual(leaves_allocated, 3)
+
 	def tearDown(self):
+		frappe.db.rollback()
 		frappe.db.set_value("Employee", self.employee.name, "date_of_joining", self.original_doj)
 		frappe.flags.current_date = None
 

erpnext/hr/doctype/leave_type/leave_type.json

@@ -19,7 +19,6 @@
   "fraction_of_daily_salary_per_leave",
   "is_optional_leave",
   "allow_negative",
-  "allow_over_allocation",
   "include_holiday",
   "is_compensatory",
   "carry_forward_section",
@@ -212,23 +211,15 @@
    "fieldtype": "Float",
    "label": "Fraction of Daily Salary per Leave",
    "mandatory_depends_on": "eval:doc.is_ppl == 1"
-  },
-  {
-   "default": "0",
-   "description": "Allows allocating more leaves than the number of days in the allocation period.",
-   "fieldname": "allow_over_allocation",
-   "fieldtype": "Check",
-   "label": "Allow Over Allocation"
   }
  ],
  "icon": "fa fa-flag",
  "idx": 1,
  "links": [],
- "modified": "2022-05-09 05:01:38.957545",
+ "modified": "2021-10-02 11:59:40.503359",
  "modified_by": "Administrator",
  "module": "HR",
  "name": "Leave Type",
- "naming_rule": "By fieldname",
  "owner": "Administrator",
  "permissions": [
   {
@@ -260,6 +251,5 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
- "states": [],
  "track_changes": 1
 }

erpnext/hr/doctype/shift_assignment/shift_assignment.py

@@ -84,7 +84,7 @@ class ShiftAssignment(Document):
 
 @frappe.whitelist()
 def get_events(start, end, filters=None):
-	from frappe.desk.calendar import get_event_conditions
+	events = []
 
 	employee = frappe.db.get_value(
 		"Employee", {"user_id": frappe.session.user}, ["name", "company"], as_dict=True
@@ -95,22 +95,20 @@ def get_events(start, end, filters=None):
 		employee = ""
 		company = frappe.db.get_value("Global Defaults", None, "default_company")
 
-	conditions = get_event_conditions("Shift Assignment", filters)
-	events = add_assignments(start, end, conditions=conditions)
+	from frappe.desk.reportview import get_filters_cond
+
+	conditions = get_filters_cond("Shift Assignment", filters, [])
+	add_assignments(events, start, end, conditions=conditions)
 	return events
 
 
-def add_assignments(start, end, conditions=None):
-	events = []
-
+def add_assignments(events, start, end, conditions=None):
 	query = """select name, start_date, end_date, employee_name,
 		employee, docstatus, shift_type
 		from `tabShift Assignment` where
-		(
-			start_date >= %(start_date)s
-			or end_date <=  %(end_date)s
-			or (%(start_date)s between start_date and end_date and %(end_date)s between start_date and end_date)
-		)
+		start_date >= %(start_date)s
+		or end_date <=  %(end_date)s
+		or (%(start_date)s between start_date and end_date and %(end_date)s between start_date and end_date)
 		and docstatus = 1"""
 	if conditions:
 		query += conditions

erpnext/hr/doctype/shift_assignment/test_shift_assignment.py

@@ -4,22 +4,14 @@
 import unittest
 
 import frappe
-from frappe.tests.utils import FrappeTestCase
 from frappe.utils import add_days, nowdate
 
-from erpnext.hr.doctype.employee.test_employee import make_employee
-from erpnext.hr.doctype.shift_assignment.shift_assignment import get_events
-
 test_dependencies = ["Shift Type"]
 
 
-class TestShiftAssignment(FrappeTestCase):
+class TestShiftAssignment(unittest.TestCase):
 	def setUp(self):
-		frappe.db.delete("Shift Assignment")
-		if not frappe.db.exists("Shift Type", "Day Shift"):
-			frappe.get_doc(
-				{"doctype": "Shift Type", "name": "Day Shift", "start_time": "9:00:00", "end_time": "18:00:00"}
-			).insert()
+		frappe.db.sql("delete from `tabShift Assignment`")
 
 	def test_make_shift_assignment(self):
 		shift_assignment = frappe.get_doc(
@@ -94,36 +86,3 @@ class TestShiftAssignment(FrappeTestCase):
 		)
 
 		self.assertRaises(frappe.ValidationError, shift_assignment_3.save)
-
-	def test_shift_assignment_calendar(self):
-		employee1 = make_employee("test_shift_assignment1@example.com", company="_Test Company")
-		employee2 = make_employee("test_shift_assignment2@example.com", company="_Test Company")
-		date = nowdate()
-
-		shift_1 = frappe.get_doc(
-			{
-				"doctype": "Shift Assignment",
-				"shift_type": "Day Shift",
-				"company": "_Test Company",
-				"employee": employee1,
-				"start_date": date,
-				"status": "Active",
-			}
-		).submit()
-
-		frappe.get_doc(
-			{
-				"doctype": "Shift Assignment",
-				"shift_type": "Day Shift",
-				"company": "_Test Company",
-				"employee": employee2,
-				"start_date": date,
-				"status": "Active",
-			}
-		).submit()
-
-		events = get_events(
-			start=date, end=date, filters=[["Shift Assignment", "employee", "=", employee1, False]]
-		)
-		self.assertEqual(len(events), 1)
-		self.assertEqual(events[0]["name"], shift_1.name)

erpnext/hr/doctype/shift_type/shift_type.py

@@ -139,17 +139,7 @@ class ShiftType(Document):
 		for date in dates:
 			shift_details = get_employee_shift(employee, date, True)
 			if shift_details and shift_details.shift_type.name == self.name:
-				attendance = mark_attendance(employee, date, "Absent", self.name)
-				if attendance:
-					frappe.get_doc(
-						{
-							"doctype": "Comment",
-							"comment_type": "Comment",
-							"reference_doctype": "Attendance",
-							"reference_name": attendance,
-							"content": frappe._("Employee was marked Absent due to missing Employee Checkins."),
-						}
-					).insert(ignore_permissions=True)
+				mark_attendance(employee, date, "Absent", self.name)
 
 	def get_assigned_employee(self, from_date=None, consider_default_shift=False):
 		filters = {"start_date": (">", from_date), "shift_type": self.name, "docstatus": "1"}

erpnext/hr/report/employee_leave_balance/employee_leave_balance.js

@@ -4,21 +4,21 @@
 frappe.query_reports["Employee Leave Balance"] = {
 	"filters": [
 		{
-			"fieldname": "from_date",
+			"fieldname":"from_date",
 			"label": __("From Date"),
 			"fieldtype": "Date",
 			"reqd": 1,
 			"default": frappe.defaults.get_default("year_start_date")
 		},
 		{
-			"fieldname": "to_date",
+			"fieldname":"to_date",
 			"label": __("To Date"),
 			"fieldtype": "Date",
 			"reqd": 1,
 			"default": frappe.defaults.get_default("year_end_date")
 		},
 		{
-			"fieldname": "company",
+			"fieldname":"company",
 			"label": __("Company"),
 			"fieldtype": "Link",
 			"options": "Company",
@@ -26,29 +26,16 @@ frappe.query_reports["Employee Leave Balance"] = {
 			"default": frappe.defaults.get_user_default("Company")
 		},
 		{
-			"fieldname": "department",
+			"fieldname":"department",
 			"label": __("Department"),
 			"fieldtype": "Link",
 			"options": "Department",
 		},
 		{
-			"fieldname": "employee",
+			"fieldname":"employee",
 			"label": __("Employee"),
 			"fieldtype": "Link",
 			"options": "Employee",
-		},
-		{
-			"fieldname": "employee_status",
-			"label": __("Employee Status"),
-			"fieldtype": "Select",
-			"options": [
-				"",
-				{ "value": "Active", "label": __("Active") },
-				{ "value": "Inactive", "label": __("Inactive") },
-				{ "value": "Suspended", "label": __("Suspended") },
-				{ "value": "Left", "label": __("Left") },
-			],
-			"default": "Active",
 		}
 	],
 

erpnext/hr/report/employee_leave_balance/employee_leave_balance.py

@@ -168,8 +168,9 @@ def get_opening_balance(
 
 
 def get_conditions(filters: Filters) -> Dict:
-	conditions = {}
-
+	conditions = {
+		"status": "Active",
+	}
 	if filters.get("employee"):
 		conditions["name"] = filters.get("employee")
 
@@ -179,9 +180,6 @@ def get_conditions(filters: Filters) -> Dict:
 	if filters.get("department"):
 		conditions["department"] = filters.get("department")
 
-	if filters.get("employee_status"):
-		conditions["status"] = filters.get("employee_status")
-
 	return conditions
 
 

erpnext/hr/report/employee_leave_balance/test_employee_leave_balance.py

@@ -207,40 +207,3 @@ class TestEmployeeLeaveBalance(unittest.TestCase):
 			allocation1.new_leaves_allocated - leave_application.total_leave_days
 		)
 		self.assertEqual(report[1][0].opening_balance, opening_balance)
-
-	@set_holiday_list("_Test Emp Balance Holiday List", "_Test Company")
-	def test_employee_status_filter(self):
-		frappe.get_doc(test_records[0]).insert()
-		inactive_emp = make_employee("test_emp_status@example.com", company="_Test Company")
-
-		allocation = make_allocation_record(
-			employee=inactive_emp,
-			from_date=self.year_start,
-			to_date=self.year_end,
-			leaves=5,
-		)
-
-		# set employee as inactive
-		frappe.db.set_value("Employee", inactive_emp, "status", "Inactive")
-
-		filters = frappe._dict(
-			{
-				"from_date": allocation.from_date,
-				"to_date": allocation.to_date,
-				"employee": inactive_emp,
-				"employee_status": "Active",
-			}
-		)
-		report = execute(filters)
-		self.assertEqual(len(report[1]), 0)
-
-		filters = frappe._dict(
-			{
-				"from_date": allocation.from_date,
-				"to_date": allocation.to_date,
-				"employee": inactive_emp,
-				"employee_status": "Inactive",
-			}
-		)
-		report = execute(filters)
-		self.assertEqual(len(report[1]), 1)

erpnext/hr/report/employee_leave_balance_summary/employee_leave_balance_summary.js

@@ -30,19 +30,6 @@ frappe.query_reports['Employee Leave Balance Summary'] = {
 			label: __('Department'),
 			fieldtype: 'Link',
 			options: 'Department',
-		},
-		{
-			fieldname: "employee_status",
-			label: __("Employee Status"),
-			fieldtype: "Select",
-			options: [
-				"",
-				{ "value": "Active", "label": __("Active") },
-				{ "value": "Inactive", "label": __("Inactive") },
-				{ "value": "Suspended", "label": __("Suspended") },
-				{ "value": "Left", "label": __("Left") },
-			],
-			default: "Active",
 		}
 	]
 };

erpnext/hr/report/employee_leave_balance_summary/employee_leave_balance_summary.py

@@ -35,10 +35,9 @@ def get_columns(leave_types):
 
 def get_conditions(filters):
 	conditions = {
+		"status": "Active",
 		"company": filters.company,
 	}
-	if filters.get("employee_status"):
-		conditions.update({"status": filters.get("employee_status")})
 	if filters.get("department"):
 		conditions.update({"department": filters.get("department")})
 	if filters.get("employee"):

erpnext/hr/report/employee_leave_balance_summary/test_employee_leave_balance_summary.py

@@ -36,6 +36,7 @@ class TestEmployeeLeaveBalance(unittest.TestCase):
 
 		frappe.set_user("Administrator")
 
+		self.employee_id = make_employee("test_emp_leave_balance@example.com", company="_Test Company")
 		self.employee_id = make_employee("test_emp_leave_balance@example.com", company="_Test Company")
 
 		self.date = getdate()
@@ -145,37 +146,3 @@ class TestEmployeeLeaveBalance(unittest.TestCase):
 		]
 
 		self.assertEqual(report[1], expected_data)
-
-	@set_holiday_list("_Test Emp Balance Holiday List", "_Test Company")
-	def test_employee_status_filter(self):
-		frappe.get_doc(test_records[0]).insert()
-
-		inactive_emp = make_employee("test_emp_status@example.com", company="_Test Company")
-		allocation = make_allocation_record(
-			employee=inactive_emp, from_date=self.year_start, to_date=self.year_end
-		)
-
-		# set employee as inactive
-		frappe.db.set_value("Employee", inactive_emp, "status", "Inactive")
-
-		filters = frappe._dict(
-			{
-				"date": allocation.from_date,
-				"company": "_Test Company",
-				"employee": inactive_emp,
-				"employee_status": "Active",
-			}
-		)
-		report = execute(filters)
-		self.assertEqual(len(report[1]), 0)
-
-		filters = frappe._dict(
-			{
-				"date": allocation.from_date,
-				"company": "_Test Company",
-				"employee": inactive_emp,
-				"employee_status": "Inactive",
-			}
-		)
-		report = execute(filters)
-		self.assertEqual(len(report[1]), 1)

erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py

@@ -57,10 +57,11 @@ def execute(filters=None):
 
 	data = []
 
-	leave_types = None
+	leave_list = None
 	if filters.summarized_view:
-		leave_types = frappe.get_all("Leave Type", pluck="name")
-		columns.extend([leave_type + ":Float:120" for leave_type in leave_types])
+		leave_types = frappe.db.sql("""select name from `tabLeave Type`""", as_list=True)
+		leave_list = [d[0] + ":Float:120" for d in leave_types]
+		columns.extend(leave_list)
 		columns.extend([_("Total Late Entries") + ":Float:120", _("Total Early Exits") + ":Float:120"])
 
 	if filters.group_by:
@@ -80,19 +81,13 @@ def execute(filters=None):
 					holiday_map,
 					conditions,
 					default_holiday_list,
-					leave_types=leave_types,
+					leave_list=leave_list,
 				)
 				emp_att_map.update(emp_att_data)
 				data += record
 	else:
 		record, emp_att_map = add_data(
-			emp_map,
-			att_map,
-			filters,
-			holiday_map,
-			conditions,
-			default_holiday_list,
-			leave_types=leave_types,
+			emp_map, att_map, filters, holiday_map, conditions, default_holiday_list, leave_list=leave_list
 		)
 		data += record
 
@@ -109,10 +104,12 @@ def get_chart_data(emp_att_map, days):
 		{"name": "Leave", "values": []},
 	]
 	for idx, day in enumerate(days, start=0):
+		p = day.replace("::65", "")
 		labels.append(day.replace("::65", ""))
 		total_absent_on_day = 0
 		total_leave_on_day = 0
 		total_present_on_day = 0
+		total_holiday = 0
 		for emp in emp_att_map.keys():
 			if emp_att_map[emp][idx]:
 				if emp_att_map[emp][idx] == "A":
@@ -137,8 +134,9 @@ def get_chart_data(emp_att_map, days):
 
 
 def add_data(
-	employee_map, att_map, filters, holiday_map, conditions, default_holiday_list, leave_types=None
+	employee_map, att_map, filters, holiday_map, conditions, default_holiday_list, leave_list=None
 ):
+
 	record = []
 	emp_att_map = {}
 	for emp in employee_map:
@@ -224,7 +222,7 @@ def add_data(
 				else:
 					leaves[d.leave_type] = d.count
 
-			for d in leave_types:
+			for d in leave_list:
 				if d in leaves:
 					row.append(leaves[d])
 				else:

erpnext/hr/utils.py

@@ -428,7 +428,7 @@ def generate_leave_encashment():
 		create_leave_encashment(leave_allocation=leave_allocation)
 
 
-def allocate_earned_leaves():
+def allocate_earned_leaves(ignore_duplicates=False):
 	"""Allocate earned leaves to Employees"""
 	e_leave_types = get_earned_leaves()
 	today = getdate()
@@ -464,10 +464,14 @@ def allocate_earned_leaves():
 			if check_effective_date(
 				from_date, today, e_leave_type.earned_leave_frequency, e_leave_type.based_on_date_of_joining
 			):
-				update_previous_leave_allocation(allocation, annual_allocation, e_leave_type)
+				update_previous_leave_allocation(
+					allocation, annual_allocation, e_leave_type, ignore_duplicates
+				)
 
 
-def update_previous_leave_allocation(allocation, annual_allocation, e_leave_type):
+def update_previous_leave_allocation(
+	allocation, annual_allocation, e_leave_type, ignore_duplicates=False
+):
 	earned_leaves = get_monthly_earned_leave(
 		annual_allocation, e_leave_type.earned_leave_frequency, e_leave_type.rounding
 	)
@@ -481,19 +485,20 @@ def update_previous_leave_allocation(allocation, annual_allocation, e_leave_type
 	if new_allocation != allocation.total_leaves_allocated:
 		today_date = today()
 
-		allocation.db_set("total_leaves_allocated", new_allocation, update_modified=False)
-		create_additional_leave_ledger_entry(allocation, earned_leaves, today_date)
+		if ignore_duplicates or not is_earned_leave_already_allocated(allocation, annual_allocation):
+			allocation.db_set("total_leaves_allocated", new_allocation, update_modified=False)
+			create_additional_leave_ledger_entry(allocation, earned_leaves, today_date)
 
-		if e_leave_type.based_on_date_of_joining:
-			text = _("allocated {0} leave(s) via scheduler on {1} based on the date of joining").format(
-				frappe.bold(earned_leaves), frappe.bold(formatdate(today_date))
-			)
-		else:
-			text = _("allocated {0} leave(s) via scheduler on {1}").format(
-				frappe.bold(earned_leaves), frappe.bold(formatdate(today_date))
-			)
+			if e_leave_type.based_on_date_of_joining:
+				text = _("allocated {0} leave(s) via scheduler on {1} based on the date of joining").format(
+					frappe.bold(earned_leaves), frappe.bold(formatdate(today_date))
+				)
+			else:
+				text = _("allocated {0} leave(s) via scheduler on {1}").format(
+					frappe.bold(earned_leaves), frappe.bold(formatdate(today_date))
+				)
 
-		allocation.add_comment(comment_type="Info", text=text)
+			allocation.add_comment(comment_type="Info", text=text)
 
 
 def get_monthly_earned_leave(annual_leaves, frequency, rounding):

erpnext/loan_management/doctype/loan_repayment/loan_repayment.py

@@ -265,7 +265,6 @@ class LoanRepayment(AccountsController):
 			regenerate_repayment_schedule(self.against_loan, cancel)
 
 	def allocate_amounts(self, repayment_details):
-		precision = cint(frappe.db.get_default("currency_precision")) or 2
 		self.set("repayment_details", [])
 		self.principal_amount_paid = 0
 		self.total_penalty_paid = 0
@@ -280,9 +279,9 @@ class LoanRepayment(AccountsController):
 
 		if interest_paid > 0:
 			if self.penalty_amount and interest_paid > self.penalty_amount:
-				self.total_penalty_paid = flt(self.penalty_amount, precision)
+				self.total_penalty_paid = self.penalty_amount
 			elif self.penalty_amount:
-				self.total_penalty_paid = flt(interest_paid, precision)
+				self.total_penalty_paid = interest_paid
 
 			interest_paid -= self.total_penalty_paid
 

erpnext/manufacturing/doctype/job_card/job_card.js

@@ -73,18 +73,7 @@ frappe.ui.form.on('Job Card', {
 		if (frm.doc.docstatus == 0 && !frm.is_new() &&
 			(frm.doc.for_quantity > frm.doc.total_completed_qty || !frm.doc.for_quantity)
 			&& (frm.doc.items || !frm.doc.items.length || frm.doc.for_quantity == frm.doc.transferred_qty)) {
-
-			// if Job Card is link to Work Order, the job card must not be able to start if Work Order not "Started"
-			// and if stock mvt for WIP is required
-			if (frm.doc.work_order) {
-				frappe.db.get_value('Work Order', frm.doc.work_order, ['skip_transfer', 'status'], (result) => {
-					if (result.skip_transfer === 1 || result.status == 'In Process') {
-						frm.trigger("prepare_timer_buttons");
-					}
-				});
-			} else {
-				frm.trigger("prepare_timer_buttons");
-			}
+			frm.trigger("prepare_timer_buttons");
 		}
 		frm.trigger("setup_quality_inspection");
 

erpnext/manufacturing/doctype/job_card/job_card.py

@@ -764,6 +764,8 @@ def make_stock_entry(source_name, target_doc=None):
 		pending_fg_qty = flt(source.get("for_quantity", 0)) - flt(source.get("transferred_qty", 0))
 		target.fg_completed_qty = pending_fg_qty if pending_fg_qty > 0 else 0
 
+		target.set_transfer_qty()
+		target.calculate_rate_and_amount()
 		target.set_missing_values()
 		target.set_stock_entry_type()
 

erpnext/manufacturing/doctype/production_plan/production_plan.py

@@ -462,7 +462,6 @@ class ProductionPlan(Document):
 			work_order_data = {
 				"wip_warehouse": default_warehouses.get("wip_warehouse"),
 				"fg_warehouse": default_warehouses.get("fg_warehouse"),
-				"company": self.get("company"),
 			}
 
 			self.prepare_data_for_sub_assembly_items(row, work_order_data)
@@ -500,7 +499,6 @@ class ProductionPlan(Document):
 
 		for supplier, po_list in subcontracted_po.items():
 			po = frappe.new_doc("Purchase Order")
-			po.company = self.company
 			po.supplier = supplier
 			po.schedule_date = getdate(po_list[0].schedule_date) if po_list[0].schedule_date else nowdate()
 			po.is_subcontracted = "Yes"

erpnext/non_profit/workspace/non_profit/non_profit.json

@@ -109,7 +109,7 @@
    "dependencies": "",
    "hidden": 0,
    "is_query_report": 0,
-   "label": "Non Profit Settings",
+   "label": "Membership Settings",
    "link_to": "Non Profit Settings",
    "link_type": "DocType",
    "onboard": 0,
@@ -213,7 +213,7 @@
    "type": "Link"
   }
  ],
- "modified": "2022-05-09 11:38:09.140655",
+ "modified": "2021-03-11 11:38:09.140655",
  "modified_by": "Administrator",
  "module": "Non Profit",
  "name": "Non Profit",

erpnext/patches.txt

@@ -350,7 +350,6 @@ erpnext.patches.v13_0.enable_provisional_accounting
 erpnext.patches.v13_0.update_disbursement_account
 erpnext.patches.v13_0.update_reserved_qty_closed_wo
 erpnext.patches.v13_0.amazon_mws_deprecation_warning
-erpnext.patches.v13_0.datev_deprecation_warning
 erpnext.patches.v13_0.set_work_order_qty_in_so_from_mr
 erpnext.patches.v13_0.update_accounts_in_loan_docs
 erpnext.patches.v13_0.remove_unknown_links_to_prod_plan_items # 24-03-2022
@@ -358,11 +357,4 @@ erpnext.patches.v13_0.rename_non_profit_fields
 erpnext.patches.v13_0.enable_ksa_vat_docs #1
 erpnext.patches.v13_0.create_gst_custom_fields_in_quotation
 erpnext.patches.v13_0.update_expense_claim_status_for_paid_advances
-erpnext.patches.v13_0.change_default_item_manufacturer_fieldtype
 erpnext.patches.v13_0.set_return_against_in_pos_invoice_references
-erpnext.patches.v13_0.copy_custom_field_filters_to_website_item
-erpnext.patches.v13_0.set_available_for_use_date_if_missing
-erpnext.patches.v13_0.education_deprecation_warning
-erpnext.patches.v13_0.requeue_recoverable_reposts
-erpnext.patches.v13_0.create_accounting_dimensions_in_orders
-erpnext.patches.v13_0.set_per_billed_in_return_delivery_note

erpnext/patches/v13_0/change_default_item_manufacturer_fieldtype.py

@@ -1,16 +0,0 @@
-import frappe
-
-
-def execute():
-
-	# Erase all default item manufacturers that dont exist.
-	item = frappe.qb.DocType("Item")
-	manufacturer = frappe.qb.DocType("Manufacturer")
-
-	(
-		frappe.qb.update(item)
-		.set(item.default_item_manufacturer, None)
-		.left_join(manufacturer)
-		.on(item.default_item_manufacturer == manufacturer.name)
-		.where(manufacturer.name.isnull() & item.default_item_manufacturer.isnotnull())
-	).run()

erpnext/patches/v13_0/copy_custom_field_filters_to_website_item.py

@@ -1,94 +0,0 @@
-import frappe
-from frappe.custom.doctype.custom_field.custom_field import create_custom_field
-
-
-def execute():
-	"Add Field Filters, that are not standard fields in Website Item, as Custom Fields."
-
-	def move_table_multiselect_data(docfield):
-		"Copy child table data (Table Multiselect) from Item to Website Item for a docfield."
-		table_multiselect_data = get_table_multiselect_data(docfield)
-		field = docfield.fieldname
-
-		for row in table_multiselect_data:
-			# add copied multiselect data rows in Website Item
-			web_item = frappe.db.get_value("Website Item", {"item_code": row.parent})
-			web_item_doc = frappe.get_doc("Website Item", web_item)
-
-			child_doc = frappe.new_doc(docfield.options, web_item_doc, field)
-
-			for field in ["name", "creation", "modified", "idx"]:
-				row[field] = None
-
-			child_doc.update(row)
-
-			child_doc.parenttype = "Website Item"
-			child_doc.parent = web_item
-
-			child_doc.insert()
-
-	def get_table_multiselect_data(docfield):
-		child_table = frappe.qb.DocType(docfield.options)
-		item = frappe.qb.DocType("Item")
-
-		table_multiselect_data = (  # query table data for field
-			frappe.qb.from_(child_table)
-			.join(item)
-			.on(item.item_code == child_table.parent)
-			.select(child_table.star)
-			.where((child_table.parentfield == docfield.fieldname) & (item.published_in_website == 1))
-		).run(as_dict=True)
-
-		return table_multiselect_data
-
-	settings = frappe.get_doc("E Commerce Settings")
-
-	if not (settings.enable_field_filters or settings.filter_fields):
-		return
-
-	item_meta = frappe.get_meta("Item")
-	valid_item_fields = [
-		df.fieldname for df in item_meta.fields if df.fieldtype in ["Link", "Table MultiSelect"]
-	]
-
-	web_item_meta = frappe.get_meta("Website Item")
-	valid_web_item_fields = [
-		df.fieldname for df in web_item_meta.fields if df.fieldtype in ["Link", "Table MultiSelect"]
-	]
-
-	for row in settings.filter_fields:
-		# skip if illegal field
-		if row.fieldname not in valid_item_fields:
-			continue
-
-		# if Item field is not in Website Item, add it as a custom field
-		if row.fieldname not in valid_web_item_fields:
-			df = item_meta.get_field(row.fieldname)
-			create_custom_field(
-				"Website Item",
-				dict(
-					owner="Administrator",
-					fieldname=df.fieldname,
-					label=df.label,
-					fieldtype=df.fieldtype,
-					options=df.options,
-					description=df.description,
-					read_only=df.read_only,
-					no_copy=df.no_copy,
-					insert_after="on_backorder",
-				),
-			)
-
-			# map field values
-			if df.fieldtype == "Table MultiSelect":
-				move_table_multiselect_data(df)
-			else:
-				frappe.db.sql(  # nosemgrep
-					"""
-						UPDATE `tabWebsite Item` wi, `tabItem` i
-						SET wi.{0} = i.{0}
-						WHERE wi.item_code = i.item_code
-					""".format(
-						row.fieldname
-					)
-				)

erpnext/patches/v13_0/create_accounting_dimensions_in_orders.py

@@ -1,39 +0,0 @@
-import frappe
-from frappe.custom.doctype.custom_field.custom_field import create_custom_field
-
-
-def execute():
-	accounting_dimensions = frappe.db.get_all(
-		"Accounting Dimension", fields=["fieldname", "label", "document_type", "disabled"]
-	)
-
-	if not accounting_dimensions:
-		return
-
-	count = 1
-	for d in accounting_dimensions:
-
-		if count % 2 == 0:
-			insert_after_field = "dimension_col_break"
-		else:
-			insert_after_field = "accounting_dimensions_section"
-
-		for doctype in ["Purchase Order", "Purchase Receipt", "Sales Order"]:
-
-			field = frappe.db.get_value("Custom Field", {"dt": doctype, "fieldname": d.fieldname})
-
-			if field:
-				continue
-
-			df = {
-				"fieldname": d.fieldname,
-				"label": d.label,
-				"fieldtype": "Link",
-				"options": d.document_type,
-				"insert_after": insert_after_field,
-			}
-
-			create_custom_field(doctype, df, ignore_validate=True)
-			frappe.clear_cache(doctype=doctype)
-
-		count += 1

erpnext/patches/v13_0/datev_deprecation_warning.py

@@ -1,9 +0,0 @@
-import click
-
-
-def execute():
-	click.secho(
-		"DATEV reports are moved to a separate app and will be removed from ERPNext in version-14.\n"
-		"Please install the app to continue using them: https://github.com/alyf-de/erpnext_datev",
-		fg="yellow",
-	)

erpnext/patches/v13_0/education_deprecation_warning.py

@@ -1,10 +0,0 @@
-import click
-
-
-def execute():
-
-	click.secho(
-		"Education Domain is moved to a separate app and will be removed from ERPNext in version-14.\n"
-		"When upgrading to ERPNext version-14, please install the app to continue using the Education domain: https://github.com/frappe/education",
-		fg="yellow",
-	)

erpnext/patches/v13_0/patch_to_fix_reverse_linking_in_additional_salary_encashment_and_incentive.py

@@ -10,58 +10,54 @@ def execute():
 
 	frappe.reload_doc("hr", "doctype", "Leave Encashment")
 
-	if frappe.db.has_column("Leave Encashment", "additional_salary"):
-		leave_encashments = frappe.get_all(
-			"Leave Encashment",
-			fields=["name", "additional_salary"],
-			filters={"additional_salary": ["!=", ""]},
+	additional_salaries = frappe.get_all(
+		"Additional Salary",
+		fields=["name", "salary_slip", "type", "salary_component"],
+		filters={"salary_slip": ["!=", ""]},
+		group_by="salary_slip",
+	)
+	leave_encashments = frappe.get_all(
+		"Leave Encashment",
+		fields=["name", "additional_salary"],
+		filters={"additional_salary": ["!=", ""]},
+	)
+	employee_incentives = frappe.get_all(
+		"Employee Incentive",
+		fields=["name", "additional_salary"],
+		filters={"additional_salary": ["!=", ""]},
+	)
+
+	for incentive in employee_incentives:
+		frappe.db.sql(
+			""" UPDATE `tabAdditional Salary`
+			SET ref_doctype = 'Employee Incentive', ref_docname = %s
+			WHERE name = %s
+		""",
+			(incentive["name"], incentive["additional_salary"]),
 		)
-		for leave_encashment in leave_encashments:
+
+	for leave_encashment in leave_encashments:
+		frappe.db.sql(
+			""" UPDATE `tabAdditional Salary`
+			SET ref_doctype = 'Leave Encashment', ref_docname = %s
+			WHERE name = %s
+		""",
+			(leave_encashment["name"], leave_encashment["additional_salary"]),
+		)
+
+	salary_slips = [sal["salary_slip"] for sal in additional_salaries]
+
+	for salary in additional_salaries:
+		comp_type = "earnings" if salary["type"] == "Earning" else "deductions"
+		if salary["salary_slip"] and salary_slips.count(salary["salary_slip"]) == 1:
 			frappe.db.sql(
-				""" UPDATE `tabAdditional Salary`
-				SET ref_doctype = 'Leave Encashment', ref_docname = %s
-				WHERE name = %s
+				"""
+				UPDATE `tabSalary Detail`
+				SET additional_salary = %s
+				WHERE parenttype = 'Salary Slip'
+					and parentfield = %s
+					and parent = %s
+					and salary_component = %s
 			""",
-				(leave_encashment["name"], leave_encashment["additional_salary"]),
+				(salary["name"], comp_type, salary["salary_slip"], salary["salary_component"]),
 			)
-
-	if frappe.db.has_column("Employee Incentive", "additional_salary"):
-		employee_incentives = frappe.get_all(
-			"Employee Incentive",
-			fields=["name", "additional_salary"],
-			filters={"additional_salary": ["!=", ""]},
-		)
-
-		for incentive in employee_incentives:
-			frappe.db.sql(
-				""" UPDATE `tabAdditional Salary`
-				SET ref_doctype = 'Employee Incentive', ref_docname = %s
-				WHERE name = %s
-			""",
-				(incentive["name"], incentive["additional_salary"]),
-			)
-
-	if frappe.db.has_column("Additional Salary", "salary_slip"):
-		additional_salaries = frappe.get_all(
-			"Additional Salary",
-			fields=["name", "salary_slip", "type", "salary_component"],
-			filters={"salary_slip": ["!=", ""]},
-			group_by="salary_slip",
-		)
-
-		salary_slips = [sal["salary_slip"] for sal in additional_salaries]
-
-		for salary in additional_salaries:
-			comp_type = "earnings" if salary["type"] == "Earning" else "deductions"
-			if salary["salary_slip"] and salary_slips.count(salary["salary_slip"]) == 1:
-				frappe.db.sql(
-					"""
-					UPDATE `tabSalary Detail`
-					SET additional_salary = %s
-					WHERE parenttype = 'Salary Slip'
-						and parentfield = %s
-						and parent = %s
-						and salary_component = %s
-				""",
-					(salary["name"], comp_type, salary["salary_slip"], salary["salary_component"]),
-				)

erpnext/patches/v13_0/rename_membership_settings_to_non_profit_settings.py

@@ -3,11 +3,11 @@ from frappe.model.utils.rename_field import rename_field
 
 
 def execute():
-	if frappe.db.exists("DocType", "Membership Settings"):
+	if frappe.db.table_exists("Membership Settings"):
 		frappe.rename_doc("DocType", "Membership Settings", "Non Profit Settings")
 		frappe.reload_doctype("Non Profit Settings", force=True)
 
-	if frappe.db.exists("DocType", "Non Profit Settings"):
+	if frappe.db.table_exists("Non Profit Settings"):
 		rename_fields_map = {
 			"enable_invoicing": "allow_invoicing",
 			"create_for_web_forms": "automate_membership_invoicing",
@@ -20,5 +20,3 @@ def execute():
 
 		for old_name, new_name in rename_fields_map.items():
 			rename_field("Non Profit Settings", old_name, new_name)
-
-		frappe.delete_doc_if_exists("DocType", "Membership Settings")

erpnext/patches/v13_0/requeue_recoverable_reposts.py

@@ -1,21 +0,0 @@
-import frappe
-
-
-def execute():
-	recoverable = ("QueryDeadlockError", "QueryTimeoutError", "JobTimeoutException")
-
-	failed_reposts = frappe.get_all(
-		"Repost Item Valuation",
-		fields=["name", "error_log"],
-		filters={
-			"status": "Failed",
-			"docstatus": 1,
-			"modified": (">", "2022-04-20"),
-			"error_log": ("is", "set"),
-		},
-	)
-	for riv in failed_reposts:
-		for exc in recoverable:
-			if exc in riv.error_log:
-				frappe.db.set_value("Repost Item Valuation", riv.name, "status", "Queued")
-				break

erpnext/patches/v13_0/set_available_for_use_date_if_missing.py

@@ -1,19 +0,0 @@
-import frappe
-
-
-def execute():
-	"""
-	Sets available-for-use date for Assets created in older versions of ERPNext,
-	before the field was introduced.
-	"""
-
-	assets = get_assets_without_available_for_use_date()
-
-	for asset in assets:
-		frappe.db.set_value("Asset", asset.name, "available_for_use_date", asset.purchase_date)
-
-
-def get_assets_without_available_for_use_date():
-	return frappe.get_all(
-		"Asset", filters={"available_for_use_date": ["in", ["", None]]}, fields=["name", "purchase_date"]
-	)

erpnext/patches/v13_0/set_per_billed_in_return_delivery_note.py

@@ -1,29 +0,0 @@
-# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
-# For license information, please see license.txt
-
-import frappe
-
-
-def execute():
-	dn = frappe.qb.DocType("Delivery Note")
-	dn_item = frappe.qb.DocType("Delivery Note Item")
-
-	dn_list = (
-		frappe.qb.from_(dn)
-		.inner_join(dn_item)
-		.on(dn.name == dn_item.parent)
-		.select(dn.name)
-		.where(dn.docstatus == 1)
-		.where(dn.is_return == 1)
-		.where(dn.per_billed < 100)
-		.where(dn_item.returned_qty > 0)
-		.run(as_dict=True)
-	)
-
-	frappe.qb.update(dn_item).inner_join(dn).on(dn.name == dn_item.parent).set(
-		dn_item.returned_qty, 0
-	).where(dn.is_return == 1).where(dn_item.returned_qty > 0).run()
-
-	for d in dn_list:
-		dn_doc = frappe.get_doc("Delivery Note", d.get("name"))
-		dn_doc.run_method("update_billing_status")

erpnext/payroll/doctype/salary_slip/salary_slip.py

@@ -376,19 +376,13 @@ class SalarySlip(TransactionBase):
 		if joining_date and (getdate(self.start_date) < joining_date <= getdate(self.end_date)):
 			start_date = joining_date
 			unmarked_days = self.get_unmarked_days_based_on_doj_or_relieving(
-				unmarked_days,
-				include_holidays_in_total_working_days,
-				self.start_date,
-				add_days(joining_date, -1),
+				unmarked_days, include_holidays_in_total_working_days, self.start_date, joining_date
 			)
 
 		if relieving_date and (getdate(self.start_date) <= relieving_date < getdate(self.end_date)):
 			end_date = relieving_date
 			unmarked_days = self.get_unmarked_days_based_on_doj_or_relieving(
-				unmarked_days,
-				include_holidays_in_total_working_days,
-				add_days(relieving_date, 1),
-				self.end_date,
+				unmarked_days, include_holidays_in_total_working_days, relieving_date, self.end_date
 			)
 
 		# exclude days for which attendance has been marked
@@ -414,10 +408,10 @@ class SalarySlip(TransactionBase):
 		from erpnext.hr.doctype.employee.employee import is_holiday
 
 		if include_holidays_in_total_working_days:
-			unmarked_days -= date_diff(end_date, start_date) + 1
+			unmarked_days -= date_diff(end_date, start_date)
 		else:
 			# exclude only if not holidays
-			for days in range(date_diff(end_date, start_date) + 1):
+			for days in range(date_diff(end_date, start_date)):
 				date = add_days(end_date, -days)
 				if not is_holiday(self.employee, date):
 					unmarked_days -= 1

erpnext/payroll/doctype/salary_slip/test_salary_slip.py

@@ -128,72 +128,6 @@ class TestSalarySlip(unittest.TestCase):
 		},
 	)
 	def test_payment_days_for_mid_joinee_including_holidays(self):
-		no_of_days = self.get_no_of_days()
-		month_start_date, month_end_date = get_first_day(nowdate()), get_last_day(nowdate())
-
-		new_emp_id = make_employee("test_payment_days_based_on_joining_date@salary.com")
-		joining_date, relieving_date = add_days(month_start_date, 3), add_days(month_end_date, -5)
-
-		for days in range(date_diff(month_end_date, month_start_date) + 1):
-			date = add_days(month_start_date, days)
-			mark_attendance(new_emp_id, date, "Present", ignore_validate=True)
-
-		# Case 1: relieving in mid month
-		frappe.db.set_value(
-			"Employee",
-			new_emp_id,
-			{"date_of_joining": month_start_date, "relieving_date": relieving_date, "status": "Active"},
-		)
-
-		new_ss = make_employee_salary_slip(
-			"test_payment_days_based_on_joining_date@salary.com",
-			"Monthly",
-			"Test Payment Based On Attendence",
-		)
-		self.assertEqual(new_ss.payment_days, no_of_days[0] - 5)
-
-		# Case 2: joining in mid month
-		frappe.db.set_value(
-			"Employee",
-			new_emp_id,
-			{"date_of_joining": joining_date, "relieving_date": month_end_date, "status": "Active"},
-		)
-
-		frappe.delete_doc("Salary Slip", new_ss.name, force=True)
-		new_ss = make_employee_salary_slip(
-			"test_payment_days_based_on_joining_date@salary.com",
-			"Monthly",
-			"Test Payment Based On Attendence",
-		)
-		self.assertEqual(new_ss.payment_days, no_of_days[0] - 3)
-
-		# Case 3: joining and relieving in mid-month
-		frappe.db.set_value(
-			"Employee",
-			new_emp_id,
-			{"date_of_joining": joining_date, "relieving_date": relieving_date, "status": "Left"},
-		)
-
-		frappe.delete_doc("Salary Slip", new_ss.name, force=True)
-		new_ss = make_employee_salary_slip(
-			"test_payment_days_based_on_joining_date@salary.com",
-			"Monthly",
-			"Test Payment Based On Attendence",
-		)
-
-		self.assertEqual(new_ss.total_working_days, no_of_days[0])
-		self.assertEqual(new_ss.payment_days, no_of_days[0] - 8)
-
-	@change_settings(
-		"Payroll Settings",
-		{
-			"payroll_based_on": "Attendance",
-			"consider_unmarked_attendance_as": "Absent",
-			"include_holidays_in_total_working_days": True,
-		},
-	)
-	def test_payment_days_for_mid_joinee_including_holidays_and_unmarked_days(self):
-		# tests mid month joining and relieving along with unmarked days
 		from erpnext.hr.doctype.holiday_list.holiday_list import is_holiday
 
 		no_of_days = self.get_no_of_days()
@@ -201,6 +135,12 @@ class TestSalarySlip(unittest.TestCase):
 
 		new_emp_id = make_employee("test_payment_days_based_on_joining_date@salary.com")
 		joining_date, relieving_date = add_days(month_start_date, 3), add_days(month_end_date, -5)
+		frappe.db.set_value(
+			"Employee",
+			new_emp_id,
+			{"date_of_joining": joining_date, "relieving_date": relieving_date, "status": "Left"},
+		)
+
 		holidays = 0
 
 		for days in range(date_diff(relieving_date, joining_date) + 1):
@@ -210,12 +150,6 @@ class TestSalarySlip(unittest.TestCase):
 			else:
 				holidays += 1
 
-		frappe.db.set_value(
-			"Employee",
-			new_emp_id,
-			{"date_of_joining": joining_date, "relieving_date": relieving_date, "status": "Left"},
-		)
-
 		new_ss = make_employee_salary_slip(
 			"test_payment_days_based_on_joining_date@salary.com",
 			"Monthly",

erpnext/projects/doctype/project/project.py

@@ -84,7 +84,6 @@ class Project(Document):
 				type=task_details.type,
 				issue=task_details.issue,
 				is_group=task_details.is_group,
-				color=task_details.color,
 			)
 		).insert()
 

erpnext/public/js/controllers/accounts.js

@@ -27,8 +27,7 @@ frappe.ui.form.on(cur_frm.doctype, {
 					query: "erpnext.controllers.queries.tax_account_query",
 					filters: {
 						"account_type": account_type,
-						"company": doc.company,
-						"disabled": 0
+						"company": doc.company
 					}
 				}
 			});

erpnext/public/js/controllers/buying.js

@@ -90,7 +90,7 @@ erpnext.buying.BuyingController = erpnext.TransactionController.extend({
 			else {
 				return{
 					query: "erpnext.controllers.queries.item_query",
-					filters: { 'supplier': me.frm.doc.supplier, 'is_purchase_item': 1, 'has_variants': 0}
+					filters: { 'supplier': me.frm.doc.supplier, 'is_purchase_item': 1 }
 				}
 			}
 		});

erpnext/public/js/controllers/transaction.js

@@ -1035,11 +1035,12 @@ erpnext.TransactionController = erpnext.taxes_and_totals.extend({
 	},
 
 	currency: function() {
-		let transaction_date = this.frm.doc.transaction_date || this.frm.doc.posting_date;
-
-		let me = this;
+		/* manqala 19/09/2016: let the translation date be whichever of the transaction_date or posting_date is available */
+		var transaction_date = this.frm.doc.transaction_date || this.frm.doc.posting_date;
+		/* end manqala */
+		var me = this;
 		this.set_dynamic_labels();
-		let company_currency = this.get_company_currency();
+		var company_currency = this.get_company_currency();
 		// Added `ignore_price_list` to determine if document is loading after mapping from another doc
 		if(this.frm.doc.currency && this.frm.doc.currency !== company_currency
 				&& !(this.frm.doc.__onload && this.frm.doc.__onload.ignore_price_list)) {
@@ -1053,9 +1054,7 @@ erpnext.TransactionController = erpnext.taxes_and_totals.extend({
 					}
 				});
 		} else {
-			// company currency and doc currency is same
-			// this will prevent unnecessary conversion rate triggers
-			this.frm.set_value("conversion_rate", 1.0);
+			this.conversion_rate();
 		}
 	},
 
@@ -1497,15 +1496,7 @@ erpnext.TransactionController = erpnext.taxes_and_totals.extend({
 		var me = this;
 		var args = this._get_args(item);
 		if (!(args.items && args.items.length)) {
-			if (calculate_taxes_and_totals) me.calculate_taxes_and_totals();
-			return;
-		}
-
-		// Target doc created from a mapped doc
-		if (this.frm.doc.__onload && this.frm.doc.__onload.ignore_price_list) {
-			// Calculate totals even though pricing rule is not applied.
-			// `apply_pricing_rule` is triggered due to change in data which most likely contributes to Total.
-			if (calculate_taxes_and_totals) me.calculate_taxes_and_totals();
+			if(calculate_taxes_and_totals) me.calculate_taxes_and_totals();
 			return;
 		}
 
@@ -1625,7 +1616,7 @@ erpnext.TransactionController = erpnext.taxes_and_totals.extend({
 				me.remove_pricing_rule(frappe.get_doc(d.doctype, d.name));
 			}
 
-			if (d.free_item_data.length > 0) {
+			if (d.free_item_data) {
 				me.apply_product_discount(d);
 			}