fix: remove return pos from pos reconciliation tool

fix: make `po_detail` or `sco_rm_detail` mandatory for SE Send to Subcontractor (backport #32250)

README.md

@@ -65,6 +65,8 @@ GNU/General Public License (see [license.txt](license.txt))
 
 The ERPNext code is licensed as GNU General Public License (v3) and the Documentation is licensed as Creative Commons (CC-BY-SA-3.0) and the copyright is owned by Frappe Technologies Pvt Ltd (Frappe) and Contributors.
 
+By contributing to ERPNext, you agree that your contributions will be licensed under its GNU General Public License (v3).
+
 ---
 
 ## Contributing

erpnext/__init__.py

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

erpnext/accounts/utils.py

@@ -818,6 +818,31 @@ def get_held_invoices(party_type, party):
 	return held_invoices
 
 
+def remove_return_pos_invoices(party_type, party, invoice_list):
+	if invoice_list:
+
+		if party_type == "Customer":
+			sinv = frappe.qb.DocType("Sales Invoice")
+			return_pos = (
+				frappe.qb.from_(sinv)
+				.select(sinv.name)
+				.where((sinv.is_pos == 1) & (sinv.docstatus == 1) & (sinv.is_return == 1))
+				.run()
+			)
+
+			if return_pos:
+				return_pos = [x[0] for x in return_pos]
+			else:
+				return invoice_list
+
+			# remove pos return invoices from invoice_list
+			for idx, inv in enumerate(invoice_list, 0):
+				if inv.voucher_no in return_pos:
+					del invoice_list[idx]
+
+	return invoice_list
+
+
 def get_outstanding_invoices(party_type, party, account, condition=None, filters=None):
 	outstanding_invoices = []
 	precision = frappe.get_precision("Sales Invoice", "outstanding_amount") or 2
@@ -868,6 +893,8 @@ def get_outstanding_invoices(party_type, party, account, condition=None, filters
 		as_dict=True,
 	)
 
+	invoice_list = remove_return_pos_invoices(party_type, party, invoice_list)
+
 	payment_entries = frappe.db.sql(
 		"""
 		select against_voucher_type, against_voucher,

erpnext/controllers/buying_controller.py

@@ -303,7 +303,11 @@ class BuyingController(StockController, Subcontracting):
 					rate = flt(outgoing_rate * (d.conversion_factor or 1), d.precision("rate"))
 				else:
 					field = "incoming_rate" if self.get("is_internal_supplier") else "rate"
-					rate = frappe.db.get_value(ref_doctype, d.get(frappe.scrub(ref_doctype)), field)
+					rate = flt(
+						frappe.db.get_value(ref_doctype, d.get(frappe.scrub(ref_doctype)), field)
+						* (d.conversion_factor or 1),
+						d.precision("rate"),
+					)
 
 				if self.is_internal_transfer():
 					if rate != d.rate:

erpnext/hr/doctype/attendance/test_attendance.py

@@ -19,7 +19,7 @@ from erpnext.hr.doctype.attendance.attendance import (
 	mark_attendance,
 )
 from erpnext.hr.doctype.employee.test_employee import make_employee
-from erpnext.hr.doctype.leave_application.test_leave_application import get_first_sunday
+from erpnext.hr.tests.test_utils import get_first_sunday
 
 test_records = frappe.get_test_records("Attendance")
 

erpnext/hr/doctype/leave_application/test_leave_application.py

@@ -33,6 +33,7 @@ from erpnext.hr.doctype.leave_policy_assignment.leave_policy_assignment import (
 	create_assignment_for_multiple_employees,
 )
 from erpnext.hr.doctype.leave_type.test_leave_type import create_leave_type
+from erpnext.hr.tests.test_utils import get_first_sunday
 from erpnext.payroll.doctype.salary_slip.test_salary_slip import (
 	make_holiday_list,
 	make_leave_application,
@@ -1105,23 +1106,6 @@ def allocate_leaves(employee, leave_period, leave_type, new_leaves_allocated, el
 	allocate_leave.submit()
 
 
-def get_first_sunday(holiday_list, for_date=None):
-	date = for_date or getdate()
-	month_start_date = get_first_day(date)
-	month_end_date = get_last_day(date)
-	first_sunday = frappe.db.sql(
-		"""
-		select holiday_date from `tabHoliday`
-		where parent = %s
-			and holiday_date between %s and %s
-		order by holiday_date
-	""",
-		(holiday_list, month_start_date, month_end_date),
-	)[0][0]
-
-	return first_sunday
-
-
 def make_policy_assignment(employee, leave_type, leave_period):
 	frappe.delete_doc_if_exists("Leave Type", leave_type, force=1)
 	frappe.get_doc(

erpnext/hr/report/employee_leave_balance/test_employee_leave_balance.py

@@ -9,13 +9,11 @@ from frappe.utils import add_days, add_months, flt, get_year_ending, get_year_st
 
 from erpnext.hr.doctype.employee.test_employee import make_employee
 from erpnext.hr.doctype.holiday_list.test_holiday_list import set_holiday_list
-from erpnext.hr.doctype.leave_application.test_leave_application import (
-	get_first_sunday,
-	make_allocation_record,
-)
+from erpnext.hr.doctype.leave_application.test_leave_application import make_allocation_record
 from erpnext.hr.doctype.leave_ledger_entry.leave_ledger_entry import process_expired_allocation
 from erpnext.hr.doctype.leave_type.test_leave_type import create_leave_type
 from erpnext.hr.report.employee_leave_balance.employee_leave_balance import execute
+from erpnext.hr.tests.test_utils import get_first_sunday
 from erpnext.payroll.doctype.salary_slip.test_salary_slip import (
 	make_holiday_list,
 	make_leave_application,

erpnext/hr/report/employee_leave_balance_summary/employee_leave_balance_summary.py

@@ -22,9 +22,9 @@ def execute(filters=None):
 
 def get_columns(leave_types):
 	columns = [
-		_("Employee") + ":Link.Employee:150",
+		_("Employee") + ":Link/Employee:150",
 		_("Employee Name") + "::200",
-		_("Department") + "::150",
+		_("Department") + ":Link/Department:150",
 	]
 
 	for leave_type in leave_types:

erpnext/hr/report/employee_leave_balance_summary/test_employee_leave_balance_summary.py

@@ -9,12 +9,10 @@ from frappe.utils import add_days, flt, get_year_ending, get_year_start, getdate
 
 from erpnext.hr.doctype.employee.test_employee import make_employee
 from erpnext.hr.doctype.holiday_list.test_holiday_list import set_holiday_list
-from erpnext.hr.doctype.leave_application.test_leave_application import (
-	get_first_sunday,
-	make_allocation_record,
-)
+from erpnext.hr.doctype.leave_application.test_leave_application import make_allocation_record
 from erpnext.hr.doctype.leave_ledger_entry.leave_ledger_entry import process_expired_allocation
 from erpnext.hr.report.employee_leave_balance_summary.employee_leave_balance_summary import execute
+from erpnext.hr.tests.test_utils import get_first_sunday
 from erpnext.payroll.doctype.salary_slip.test_salary_slip import (
 	make_holiday_list,
 	make_leave_application,

erpnext/hr/tests/test_utils.py

@@ -0,0 +1,19 @@
+import frappe
+from frappe.utils import get_first_day, get_last_day, getdate
+
+
+def get_first_sunday(holiday_list="Salary Slip Test Holiday List", for_date=None):
+	date = for_date or getdate()
+	month_start_date = get_first_day(date)
+	month_end_date = get_last_day(date)
+	first_sunday = frappe.db.sql(
+		"""
+		select holiday_date from `tabHoliday`
+		where parent = %s
+			and holiday_date between %s and %s
+		order by holiday_date
+	""",
+		(holiday_list, month_start_date, month_end_date),
+	)[0][0]
+
+	return first_sunday

erpnext/loan_management/doctype/loan/loan.json

@@ -17,6 +17,7 @@
   "posting_date",
   "status",
   "repay_from_salary",
+  "manually_update_paid_amount_in_salary_slip",
   "section_break_8",
   "loan_type",
   "loan_amount",
@@ -51,10 +52,10 @@
   "refund_amount",
   "debit_adjustment_amount",
   "credit_adjustment_amount",
-  "is_npa",
   "column_break_19",
   "total_interest_payable",
   "total_amount_paid",
+  "is_npa",
   "amended_from"
  ],
  "fields": [
@@ -410,16 +411,23 @@
    "fieldname": "is_npa",
    "fieldtype": "Check",
    "label": "Is NPA"
+  },
+  {
+   "allow_on_submit": 1,
+   "default": "0",
+   "depends_on": "repay_from_salary",
+   "fieldname": "manually_update_paid_amount_in_salary_slip",
+   "fieldtype": "Check",
+   "label": "Manually Update Paid Amount in Salary Slip"
   }
  ],
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2022-06-30 12:04:13.728880",
+ "modified": "2022-09-13 02:05:25.017190",
  "modified_by": "Administrator",
  "module": "Loan Management",
  "name": "Loan",
- "naming_rule": "Expression (old style)",
  "owner": "Administrator",
  "permissions": [
   {
@@ -445,6 +453,5 @@
  "search_fields": "posting_date",
  "sort_field": "creation",
  "sort_order": "DESC",
- "states": [],
  "track_changes": 1
-}
+}

erpnext/loan_management/doctype/loan_repayment/loan_repayment.py

@@ -520,6 +520,8 @@ def get_accrued_interest_entries(against_loan, posting_date=None):
 	if not posting_date:
 		posting_date = getdate()
 
+	precision = cint(frappe.db.get_default("currency_precision")) or 2
+
 	unpaid_accrued_entries = frappe.db.sql(
 		"""
 			SELECT name, posting_date, interest_amount - paid_interest_amount as interest_amount,
@@ -540,6 +542,13 @@ def get_accrued_interest_entries(against_loan, posting_date=None):
 		as_dict=1,
 	)
 
+	# Skip entries with zero interest amount & payable principal amount
+	unpaid_accrued_entries = [
+		d
+		for d in unpaid_accrued_entries
+		if flt(d.interest_amount, precision) > 0 or flt(d.payable_principal_amount, precision) > 0
+	]
+
 	return unpaid_accrued_entries
 
 

erpnext/manufacturing/doctype/production_plan/production_plan.py

@@ -8,6 +8,7 @@ import json
 import frappe
 from frappe import _, msgprint
 from frappe.model.document import Document
+from frappe.query_builder.functions import IfNull, Sum
 from frappe.utils import (
 	add_days,
 	ceil,
@@ -20,6 +21,7 @@ from frappe.utils import (
 	nowdate,
 )
 from frappe.utils.csvutils import build_csv_response
+from pypika.terms import ExistsCriterion
 from six import iteritems
 
 from erpnext.manufacturing.doctype.bom.bom import get_children, validate_bom_no
@@ -100,39 +102,46 @@ class ProductionPlan(Document):
 	@frappe.whitelist()
 	def get_pending_material_requests(self):
 		"""Pull Material Requests that are pending based on criteria selected"""
-		mr_filter = item_filter = ""
+
+		bom = frappe.qb.DocType("BOM")
+		mr = frappe.qb.DocType("Material Request")
+		mr_item = frappe.qb.DocType("Material Request Item")
+
+		pending_mr_query = (
+			frappe.qb.from_(mr)
+			.from_(mr_item)
+			.select(mr.name, mr.transaction_date)
+			.distinct()
+			.where(
+				(mr_item.parent == mr.name)
+				& (mr.material_request_type == "Manufacture")
+				& (mr.docstatus == 1)
+				& (mr.status != "Stopped")
+				& (mr.company == self.company)
+				& (mr_item.qty > IfNull(mr_item.ordered_qty, 0))
+				& (
+					ExistsCriterion(
+						frappe.qb.from_(bom)
+						.select(bom.name)
+						.where((bom.item == mr_item.item_code) & (bom.is_active == 1))
+					)
+				)
+			)
+		)
+
 		if self.from_date:
-			mr_filter += " and mr.transaction_date >= %(from_date)s"
+			pending_mr_query = pending_mr_query.where(mr.transaction_date >= self.from_date)
+
 		if self.to_date:
-			mr_filter += " and mr.transaction_date <= %(to_date)s"
+			pending_mr_query = pending_mr_query.where(mr.transaction_date <= self.to_date)
+
 		if self.warehouse:
-			mr_filter += " and mr_item.warehouse = %(warehouse)s"
+			pending_mr_query = pending_mr_query.where(mr_item.warehouse == self.warehouse)
 
 		if self.item_code:
-			item_filter += " and mr_item.item_code = %(item)s"
+			pending_mr_query = pending_mr_query.where(mr_item.item_code == self.item_code)
 
-		pending_mr = frappe.db.sql(
-			"""
-			select distinct mr.name, mr.transaction_date
-			from `tabMaterial Request` mr, `tabMaterial Request Item` mr_item
-			where mr_item.parent = mr.name
-				and mr.material_request_type = "Manufacture"
-				and mr.docstatus = 1 and mr.status != "Stopped" and mr.company = %(company)s
-				and mr_item.qty > ifnull(mr_item.ordered_qty,0) {0} {1}
-				and (exists (select name from `tabBOM` bom where bom.item=mr_item.item_code
-					and bom.is_active = 1))
-			""".format(
-				mr_filter, item_filter
-			),
-			{
-				"from_date": self.from_date,
-				"to_date": self.to_date,
-				"warehouse": self.warehouse,
-				"item": self.item_code,
-				"company": self.company,
-			},
-			as_dict=1,
-		)
+		pending_mr = pending_mr_query.run(as_dict=True)
 
 		self.add_mr_in_table(pending_mr)
 
@@ -160,16 +169,17 @@ class ProductionPlan(Document):
 		so_mr_list = [d.get(field) for d in self.get(table) if d.get(field)]
 		return so_mr_list
 
-	def get_bom_item(self):
+	def get_bom_item_condition(self):
 		"""Check if Item or if its Template has a BOM."""
-		bom_item = None
+		bom_item_condition = None
 		has_bom = frappe.db.exists({"doctype": "BOM", "item": self.item_code, "docstatus": 1})
+
 		if not has_bom:
+			bom = frappe.qb.DocType("BOM")
 			template_item = frappe.db.get_value("Item", self.item_code, ["variant_of"])
-			bom_item = (
-				"bom.item = {0}".format(frappe.db.escape(template_item)) if template_item else bom_item
-			)
-		return bom_item
+			bom_item_condition = bom.item == template_item or None
+
+		return bom_item_condition
 
 	def get_so_items(self):
 		# Check for empty table or empty rows
@@ -178,46 +188,75 @@ class ProductionPlan(Document):
 
 		so_list = self.get_so_mr_list("sales_order", "sales_orders")
 
-		item_condition = ""
-		bom_item = "bom.item = so_item.item_code"
-		if self.item_code and frappe.db.exists("Item", self.item_code):
-			bom_item = self.get_bom_item() or bom_item
-			item_condition = " and so_item.item_code = {0}".format(frappe.db.escape(self.item_code))
+		bom = frappe.qb.DocType("BOM")
+		so_item = frappe.qb.DocType("Sales Order Item")
 
-		items = frappe.db.sql(
-			"""
-			select
-				distinct parent, item_code, warehouse,
-				(qty - work_order_qty) * conversion_factor as pending_qty,
-				description, name
-			from
-				`tabSales Order Item` so_item
-			where
-				parent in (%s) and docstatus = 1 and qty > work_order_qty
-				and exists (select name from `tabBOM` bom where %s
-				and bom.is_active = 1) %s"""
-			% (", ".join(["%s"] * len(so_list)), bom_item, item_condition),
-			tuple(so_list),
-			as_dict=1,
+		items_subquery = frappe.qb.from_(bom).select(bom.name).where(bom.is_active == 1)
+		items_query = (
+			frappe.qb.from_(so_item)
+			.select(
+				so_item.parent,
+				so_item.item_code,
+				so_item.warehouse,
+				(
+					(so_item.qty - so_item.work_order_qty - so_item.delivered_qty) * so_item.conversion_factor
+				).as_("pending_qty"),
+				so_item.description,
+				so_item.name,
+			)
+			.distinct()
+			.where(
+				(so_item.parent.isin(so_list))
+				& (so_item.docstatus == 1)
+				& (so_item.qty > so_item.work_order_qty)
+			)
+		)
+
+		if self.item_code and frappe.db.exists("Item", self.item_code):
+			items_query = items_query.where(so_item.item_code == self.item_code)
+			items_subquery = items_subquery.where(
+				self.get_bom_item_condition() or bom.item == so_item.item_code
+			)
+
+		items_query = items_query.where(ExistsCriterion(items_subquery))
+
+		items = items_query.run(as_dict=True)
+
+		pi = frappe.qb.DocType("Packed Item")
+
+		packed_items_query = (
+			frappe.qb.from_(so_item)
+			.from_(pi)
+			.select(
+				pi.parent,
+				pi.item_code,
+				pi.warehouse.as_("warehouse"),
+				(((so_item.qty - so_item.work_order_qty) * pi.qty) / so_item.qty).as_("pending_qty"),
+				pi.parent_item,
+				pi.description,
+				so_item.name,
+			)
+			.distinct()
+			.where(
+				(so_item.parent == pi.parent)
+				& (so_item.docstatus == 1)
+				& (pi.parent_item == so_item.item_code)
+				& (so_item.parent.isin(so_list))
+				& (so_item.qty > so_item.work_order_qty)
+				& (
+					ExistsCriterion(
+						frappe.qb.from_(bom)
+						.select(bom.name)
+						.where((bom.item == pi.item_code) & (bom.is_active == 1))
+					)
+				)
+			)
 		)
 
 		if self.item_code:
-			item_condition = " and so_item.item_code = {0}".format(frappe.db.escape(self.item_code))
+			packed_items_query = packed_items_query.where(so_item.item_code == self.item_code)
 
-		packed_items = frappe.db.sql(
-			"""select distinct pi.parent, pi.item_code, pi.warehouse as warehouse,
-			(((so_item.qty - so_item.work_order_qty) * pi.qty) / so_item.qty)
-				as pending_qty, pi.parent_item, pi.description, so_item.name
-			from `tabSales Order Item` so_item, `tabPacked Item` pi
-			where so_item.parent = pi.parent and so_item.docstatus = 1
-			and pi.parent_item = so_item.item_code
-			and so_item.parent in (%s) and so_item.qty > so_item.work_order_qty
-			and exists (select name from `tabBOM` bom where bom.item=pi.item_code
-					and bom.is_active = 1) %s"""
-			% (", ".join(["%s"] * len(so_list)), item_condition),
-			tuple(so_list),
-			as_dict=1,
-		)
+		packed_items = packed_items_query.run(as_dict=True)
 
 		self.add_items(items + packed_items)
 		self.calculate_total_planned_qty()
@@ -233,22 +272,39 @@ class ProductionPlan(Document):
 
 		mr_list = self.get_so_mr_list("material_request", "material_requests")
 
-		item_condition = ""
-		if self.item_code:
-			item_condition = " and mr_item.item_code ={0}".format(frappe.db.escape(self.item_code))
+		bom = frappe.qb.DocType("BOM")
+		mr_item = frappe.qb.DocType("Material Request Item")
 
-		items = frappe.db.sql(
-			"""select distinct parent, name, item_code, warehouse, description,
-			(qty - ordered_qty) * conversion_factor as pending_qty
-			from `tabMaterial Request Item` mr_item
-			where parent in (%s) and docstatus = 1 and qty > ordered_qty
-			and exists (select name from `tabBOM` bom where bom.item=mr_item.item_code
-				and bom.is_active = 1) %s"""
-			% (", ".join(["%s"] * len(mr_list)), item_condition),
-			tuple(mr_list),
-			as_dict=1,
+		items_query = (
+			frappe.qb.from_(mr_item)
+			.select(
+				mr_item.parent,
+				mr_item.name,
+				mr_item.item_code,
+				mr_item.warehouse,
+				mr_item.description,
+				((mr_item.qty - mr_item.ordered_qty) * mr_item.conversion_factor).as_("pending_qty"),
+			)
+			.distinct()
+			.where(
+				(mr_item.parent.isin(mr_list))
+				& (mr_item.docstatus == 1)
+				& (mr_item.qty > mr_item.ordered_qty)
+				& (
+					ExistsCriterion(
+						frappe.qb.from_(bom)
+						.select(bom.name)
+						.where((bom.item == mr_item.item_code) & (bom.is_active == 1))
+					)
+				)
+			)
 		)
 
+		if self.item_code:
+			items_query = items_query.where(mr_item.item_code == self.item_code)
+
+		items = items_query.run(as_dict=True)
+
 		self.add_items(items)
 		self.calculate_total_planned_qty()
 
@@ -754,29 +810,45 @@ def download_raw_materials(doc, warehouses=None):
 
 
 def get_exploded_items(item_details, company, bom_no, include_non_stock_items, planned_qty=1):
-	for d in frappe.db.sql(
-		"""select bei.item_code, item.default_bom as bom,
-			ifnull(sum(bei.stock_qty/ifnull(bom.quantity, 1)), 0)*%s as qty, item.item_name,
-			bei.description, bei.stock_uom, item.min_order_qty, bei.source_warehouse,
-			item.default_material_request_type, item.min_order_qty, item_default.default_warehouse,
-			item.purchase_uom, item_uom.conversion_factor, item.safety_stock
-		from
-			`tabBOM Explosion Item` bei
-			JOIN `tabBOM` bom ON bom.name = bei.parent
-			JOIN `tabItem` item ON item.name = bei.item_code
-			LEFT JOIN `tabItem Default` item_default
-				ON item_default.parent = item.name and item_default.company=%s
-			LEFT JOIN `tabUOM Conversion Detail` item_uom
-				ON item.name = item_uom.parent and item_uom.uom = item.purchase_uom
-		where
-			bei.docstatus < 2
-			and bom.name=%s and item.is_stock_item in (1, {0})
-		group by bei.item_code, bei.stock_uom""".format(
-			0 if include_non_stock_items else 1
-		),
-		(planned_qty, company, bom_no),
-		as_dict=1,
-	):
+	bei = frappe.qb.DocType("BOM Explosion Item")
+	bom = frappe.qb.DocType("BOM")
+	item = frappe.qb.DocType("Item")
+	item_default = frappe.qb.DocType("Item Default")
+	item_uom = frappe.qb.DocType("UOM Conversion Detail")
+
+	data = (
+		frappe.qb.from_(bei)
+		.join(bom)
+		.on(bom.name == bei.parent)
+		.join(item)
+		.on(item.name == bei.item_code)
+		.left_join(item_default)
+		.on((item_default.parent == item.name) & (item_default.company == company))
+		.left_join(item_uom)
+		.on((item.name == item_uom.parent) & (item_uom.uom == item.purchase_uom))
+		.select(
+			(IfNull(Sum(bei.stock_qty / IfNull(bom.quantity, 1)), 0) * planned_qty).as_("qty"),
+			item.item_name,
+			bei.description,
+			bei.stock_uom,
+			item.min_order_qty,
+			bei.source_warehouse,
+			item.default_material_request_type,
+			item.min_order_qty,
+			item_default.default_warehouse,
+			item.purchase_uom,
+			item_uom.conversion_factor,
+			item.safety_stock,
+		)
+		.where(
+			(bei.docstatus < 2)
+			& (bom.name == bom_no)
+			& (item.is_stock_item.isin([0, 1]) if include_non_stock_items else item.is_stock_item == 1)
+		)
+		.groupby(bei.item_code, bei.stock_uom)
+	).run(as_dict=True)
+
+	for d in data:
 		if not d.conversion_factor and d.purchase_uom:
 			d.conversion_factor = get_uom_conversion_factor(d.item_code, d.purchase_uom)
 		item_details.setdefault(d.get("item_code"), d)
@@ -801,33 +873,47 @@ def get_subitems(
 	parent_qty,
 	planned_qty=1,
 ):
-	items = frappe.db.sql(
-		"""
-		SELECT
-			bom_item.item_code, default_material_request_type, item.item_name,
-			ifnull(%(parent_qty)s * sum(bom_item.stock_qty/ifnull(bom.quantity, 1)) * %(planned_qty)s, 0) as qty,
-			item.is_sub_contracted_item as is_sub_contracted, bom_item.source_warehouse,
-			item.default_bom as default_bom, bom_item.description as description,
-			bom_item.stock_uom as stock_uom, item.min_order_qty as min_order_qty, item.safety_stock as safety_stock,
-			item_default.default_warehouse, item.purchase_uom, item_uom.conversion_factor
-		FROM
-			`tabBOM Item` bom_item
-			JOIN `tabBOM` bom ON bom.name = bom_item.parent
-			JOIN tabItem item ON bom_item.item_code = item.name
-			LEFT JOIN `tabItem Default` item_default
-				ON item.name = item_default.parent and item_default.company = %(company)s
-			LEFT JOIN `tabUOM Conversion Detail` item_uom
-				ON item.name = item_uom.parent and item_uom.uom = item.purchase_uom
-		where
-			bom.name = %(bom)s
-			and bom_item.docstatus < 2
-			and item.is_stock_item in (1, {0})
-		group by bom_item.item_code""".format(
-			0 if include_non_stock_items else 1
-		),
-		{"bom": bom_no, "parent_qty": parent_qty, "planned_qty": planned_qty, "company": company},
-		as_dict=1,
-	)
+	bom_item = frappe.qb.DocType("BOM Item")
+	bom = frappe.qb.DocType("BOM")
+	item = frappe.qb.DocType("Item")
+	item_default = frappe.qb.DocType("Item Default")
+	item_uom = frappe.qb.DocType("UOM Conversion Detail")
+
+	items = (
+		frappe.qb.from_(bom_item)
+		.join(bom)
+		.on(bom.name == bom_item.parent)
+		.join(item)
+		.on(bom_item.item_code == item.name)
+		.left_join(item_default)
+		.on((item.name == item_default.parent) & (item_default.company == company))
+		.left_join(item_uom)
+		.on((item.name == item_uom.parent) & (item_uom.uom == item.purchase_uom))
+		.select(
+			bom_item.item_code,
+			item.default_material_request_type,
+			item.item_name,
+			IfNull(parent_qty * Sum(bom_item.stock_qty / IfNull(bom.quantity, 1)) * planned_qty, 0).as_(
+				"qty"
+			),
+			item.is_sub_contracted_item.as_("is_sub_contracted"),
+			bom_item.source_warehouse,
+			item.default_bom.as_("default_bom"),
+			bom_item.description.as_("description"),
+			bom_item.stock_uom.as_("stock_uom"),
+			item.min_order_qty.as_("min_order_qty"),
+			item.safety_stock.as_("safety_stock"),
+			item_default.default_warehouse,
+			item.purchase_uom,
+			item_uom.conversion_factor,
+		)
+		.where(
+			(bom.name == bom_no)
+			& (bom_item.docstatus < 2)
+			& (item.is_stock_item.isin([0, 1]) if include_non_stock_items else item.is_stock_item == 1)
+		)
+		.groupby(bom_item.item_code)
+	).run(as_dict=True)
 
 	for d in items:
 		if not data.get("include_exploded_items") or not d.default_bom:
@@ -915,48 +1001,69 @@ def get_material_request_items(
 
 
 def get_sales_orders(self):
-	so_filter = item_filter = ""
-	bom_item = "bom.item = so_item.item_code"
+	bom = frappe.qb.DocType("BOM")
+	pi = frappe.qb.DocType("Packed Item")
+	so = frappe.qb.DocType("Sales Order")
+	so_item = frappe.qb.DocType("Sales Order Item")
+
+	open_so_subquery1 = frappe.qb.from_(bom).select(bom.name).where(bom.is_active == 1)
+
+	open_so_subquery2 = (
+		frappe.qb.from_(pi)
+		.select(pi.name)
+		.where(
+			(pi.parent == so.name)
+			& (pi.parent_item == so_item.item_code)
+			& (
+				ExistsCriterion(
+					frappe.qb.from_(bom).select(bom.name).where((bom.item == pi.item_code) & (bom.is_active == 1))
+				)
+			)
+		)
+	)
+
+	open_so_query = (
+		frappe.qb.from_(so)
+		.from_(so_item)
+		.select(so.name, so.transaction_date, so.customer, so.base_grand_total)
+		.distinct()
+		.where(
+			(so_item.parent == so.name)
+			& (so.docstatus == 1)
+			& (so.status.notin(["Stopped", "Closed"]))
+			& (so.company == self.company)
+			& (so_item.qty > so_item.work_order_qty)
+		)
+	)
 
 	date_field_mapper = {
-		"from_date": (">=", "so.transaction_date"),
-		"to_date": ("<=", "so.transaction_date"),
-		"from_delivery_date": (">=", "so_item.delivery_date"),
-		"to_delivery_date": ("<=", "so_item.delivery_date"),
+		"from_date": self.from_date >= so.transaction_date,
+		"to_date": self.to_date <= so.transaction_date,
+		"from_delivery_date": self.from_delivery_date >= so_item.delivery_date,
+		"to_delivery_date": self.to_delivery_date <= so_item.delivery_date,
 	}
 
 	for field, value in date_field_mapper.items():
 		if self.get(field):
-			so_filter += f" and {value[1]} {value[0]} %({field})s"
+			open_so_query = open_so_query.where(value)
 
-	for field in ["customer", "project", "sales_order_status"]:
+	for field in ("customer", "project", "sales_order_status"):
 		if self.get(field):
 			so_field = "status" if field == "sales_order_status" else field
-			so_filter += f" and so.{so_field} = %({field})s"
+			open_so_query = open_so_query.where(so[so_field] == self.get(field))
 
 	if self.item_code and frappe.db.exists("Item", self.item_code):
-		bom_item = self.get_bom_item() or bom_item
-		item_filter += " and so_item.item_code = %(item_code)s"
+		open_so_query = open_so_query.where(so_item.item_code == self.item_code)
+		open_so_subquery1 = open_so_subquery1.where(
+			self.get_bom_item_condition() or bom.item == so_item.item_code
+		)
 
-	open_so = frappe.db.sql(
-		f"""
-		select distinct so.name, so.transaction_date, so.customer, so.base_grand_total
-		from `tabSales Order` so, `tabSales Order Item` so_item
-		where so_item.parent = so.name
-			and so.docstatus = 1 and so.status not in ("Stopped", "Closed")
-			and so.company = %(company)s
-			and so_item.qty > so_item.work_order_qty {so_filter} {item_filter}
-			and (exists (select name from `tabBOM` bom where {bom_item}
-					and bom.is_active = 1)
-				or exists (select name from `tabPacked Item` pi
-					where pi.parent = so.name and pi.parent_item = so_item.item_code
-						and exists (select name from `tabBOM` bom where bom.item=pi.item_code
-							and bom.is_active = 1)))
-		""",
-		self.as_dict(),
-		as_dict=1,
+	open_so_query = open_so_query.where(
+		(ExistsCriterion(open_so_subquery1) | ExistsCriterion(open_so_subquery2))
 	)
 
+	open_so = open_so_query.run(as_dict=True)
+
 	return open_so
 
 
@@ -965,37 +1072,34 @@ def get_bin_details(row, company, for_warehouse=None, all_warehouse=False):
 	if isinstance(row, str):
 		row = frappe._dict(json.loads(row))
 
-	company = frappe.db.escape(company)
-	conditions, warehouse = "", ""
+	bin = frappe.qb.DocType("Bin")
+	wh = frappe.qb.DocType("Warehouse")
+
+	subquery = frappe.qb.from_(wh).select(wh.name).where(wh.company == company)
 
-	conditions = " and warehouse in (select name from `tabWarehouse` where company = {0})".format(
-		company
-	)
 	if not all_warehouse:
 		warehouse = for_warehouse or row.get("source_warehouse") or row.get("default_warehouse")
 
 	if warehouse:
 		lft, rgt = frappe.db.get_value("Warehouse", warehouse, ["lft", "rgt"])
-		conditions = """ and warehouse in (select name from `tabWarehouse`
-			where lft >= {0} and rgt <= {1} and name=`tabBin`.warehouse and company = {2})
-		""".format(
-			lft, rgt, company
-		)
+		subquery = subquery.where((wh.lft >= lft) & (wh.rgt <= rgt) & (wh.name == bin.warehouse))
 
-	return frappe.db.sql(
-		""" select ifnull(sum(projected_qty),0) as projected_qty,
-		ifnull(sum(actual_qty),0) as actual_qty, ifnull(sum(ordered_qty),0) as ordered_qty,
-		ifnull(sum(reserved_qty_for_production),0) as reserved_qty_for_production, warehouse,
-		ifnull(sum(planned_qty),0) as planned_qty
-		from `tabBin` where item_code = %(item_code)s {conditions}
-		group by item_code, warehouse
-	""".format(
-			conditions=conditions
-		),
-		{"item_code": row["item_code"]},
-		as_dict=1,
+	query = (
+		frappe.qb.from_(bin)
+		.select(
+			bin.warehouse,
+			IfNull(Sum(bin.projected_qty), 0).as_("projected_qty"),
+			IfNull(Sum(bin.actual_qty), 0).as_("actual_qty"),
+			IfNull(Sum(bin.ordered_qty), 0).as_("ordered_qty"),
+			IfNull(Sum(bin.reserved_qty_for_production), 0).as_("reserved_qty_for_production"),
+			IfNull(Sum(bin.planned_qty), 0).as_("planned_qty"),
+		)
+		.where((bin.item_code == row["item_code"]) & (bin.warehouse.isin(subquery)))
+		.groupby(bin.item_code, bin.warehouse)
 	)
 
+	return query.run(as_dict=True)
+
 
 @frappe.whitelist()
 def get_so_details(sales_order):

erpnext/manufacturing/doctype/production_plan/test_production_plan.py

@@ -12,6 +12,7 @@ from erpnext.manufacturing.doctype.production_plan.production_plan import (
 )
 from erpnext.manufacturing.doctype.work_order.work_order import OverProductionError
 from erpnext.manufacturing.doctype.work_order.work_order import make_stock_entry as make_se_from_wo
+from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.stock.doctype.item.test_item import create_item, make_item
 from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
@@ -538,15 +539,21 @@ class TestProductionPlan(FrappeTestCase):
 		"""
 		from erpnext.manufacturing.doctype.work_order.test_work_order import make_wo_order_test_record
 
+		make_stock_entry(item_code="_Test Item", target="Work In Progress - _TC", qty=2, basic_rate=100)
 		make_stock_entry(
-			item_code="Raw Material Item 1", target="Work In Progress - _TC", qty=2, basic_rate=100
-		)
-		make_stock_entry(
-			item_code="Raw Material Item 2", target="Work In Progress - _TC", qty=2, basic_rate=100
+			item_code="_Test Item Home Desktop 100", target="Work In Progress - _TC", qty=4, basic_rate=100
 		)
 
-		item = "Test Production Item 1"
-		so = make_sales_order(item_code=item, qty=1)
+		item = "_Test FG Item"
+
+		make_stock_entry(item_code=item, target="_Test Warehouse - _TC", qty=1)
+
+		so = make_sales_order(item_code=item, qty=2)
+
+		dn = make_delivery_note(so.name)
+		dn.items[0].qty = 1
+		dn.save()
+		dn.submit()
 
 		pln = create_production_plan(
 			company=so.company, get_items_from="Sales Order", sales_order=so, skip_getting_mr_items=True

erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js

@@ -11,17 +11,24 @@ frappe.query_reports["BOM Stock Calculated"] = {
 			"options": "BOM",
 			"reqd": 1
 		},
-        	{
-	            "fieldname": "qty_to_make",
-        	    "label": __("Quantity to Make"),
-        	    "fieldtype": "Int",
-        	    "default": "1"
-	       },
-
-		 {
+		{
+			"fieldname": "warehouse",
+			"label": __("Warehouse"),
+			"fieldtype": "Link",
+			"options": "Warehouse",
+		},
+		{
+			"fieldname": "qty_to_make",
+			"label": __("Quantity to Make"),
+			"fieldtype": "Float",
+			"default": "1.0",
+			"reqd": 1
+		},
+		{
 			"fieldname": "show_exploded_view",
 			"label": __("Show exploded view"),
-			"fieldtype": "Check"
+			"fieldtype": "Check",
+			"default": false,
 		}
 	]
 }

erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py

@@ -4,29 +4,31 @@
 
 import frappe
 from frappe import _
+from frappe.query_builder.functions import IfNull, Sum
 from frappe.utils.data import comma_and
+from pypika.terms import ExistsCriterion
 
 
 def execute(filters=None):
-	# if not filters: filters = {}
 	columns = get_columns()
-	summ_data = []
+	data = []
 
-	data = get_bom_stock(filters)
+	bom_data = get_bom_data(filters)
 	qty_to_make = filters.get("qty_to_make")
-
 	manufacture_details = get_manufacturer_records()
-	for row in data:
-		reqd_qty = qty_to_make * row.actual_qty
-		last_pur_price = frappe.db.get_value("Item", row.item_code, "last_purchase_rate")
 
-		summ_data.append(get_report_data(last_pur_price, reqd_qty, row, manufacture_details))
-	return columns, summ_data
+	for row in bom_data:
+		required_qty = qty_to_make * row.qty_per_unit
+		last_purchase_rate = frappe.db.get_value("Item", row.item_code, "last_purchase_rate")
+
+		data.append(get_report_data(last_purchase_rate, required_qty, row, manufacture_details))
+
+	return columns, data
 
 
-def get_report_data(last_pur_price, reqd_qty, row, manufacture_details):
-	to_build = row.to_build if row.to_build > 0 else 0
-	diff_qty = to_build - reqd_qty
+def get_report_data(last_purchase_rate, required_qty, row, manufacture_details):
+	qty_per_unit = row.qty_per_unit if row.qty_per_unit > 0 else 0
+	difference_qty = row.actual_qty - required_qty
 	return [
 		row.item_code,
 		row.description,
@@ -34,85 +36,126 @@ def get_report_data(last_pur_price, reqd_qty, row, manufacture_details):
 		comma_and(
 			manufacture_details.get(row.item_code, {}).get("manufacturer_part", []), add_quotes=False
 		),
+		qty_per_unit,
 		row.actual_qty,
-		str(to_build),
-		reqd_qty,
-		diff_qty,
-		last_pur_price,
+		required_qty,
+		difference_qty,
+		last_purchase_rate,
 	]
 
 
 def get_columns():
-	"""return columns"""
-	columns = [
-		_("Item") + ":Link/Item:100",
-		_("Description") + "::150",
-		_("Manufacturer") + "::250",
-		_("Manufacturer Part Number") + "::250",
-		_("Qty") + ":Float:50",
-		_("Stock Qty") + ":Float:100",
-		_("Reqd Qty") + ":Float:100",
-		_("Diff Qty") + ":Float:100",
-		_("Last Purchase Price") + ":Float:100",
+	return [
+		{
+			"fieldname": "item",
+			"label": _("Item"),
+			"fieldtype": "Link",
+			"options": "Item",
+			"width": 120,
+		},
+		{
+			"fieldname": "description",
+			"label": _("Description"),
+			"fieldtype": "Data",
+			"width": 150,
+		},
+		{
+			"fieldname": "manufacturer",
+			"label": _("Manufacturer"),
+			"fieldtype": "Data",
+			"width": 120,
+		},
+		{
+			"fieldname": "manufacturer_part_number",
+			"label": _("Manufacturer Part Number"),
+			"fieldtype": "Data",
+			"width": 150,
+		},
+		{
+			"fieldname": "qty_per_unit",
+			"label": _("Qty Per Unit"),
+			"fieldtype": "Float",
+			"width": 110,
+		},
+		{
+			"fieldname": "available_qty",
+			"label": _("Available Qty"),
+			"fieldtype": "Float",
+			"width": 120,
+		},
+		{
+			"fieldname": "required_qty",
+			"label": _("Required Qty"),
+			"fieldtype": "Float",
+			"width": 120,
+		},
+		{
+			"fieldname": "difference_qty",
+			"label": _("Difference Qty"),
+			"fieldtype": "Float",
+			"width": 130,
+		},
+		{
+			"fieldname": "last_purchase_rate",
+			"label": _("Last Purchase Rate"),
+			"fieldtype": "Float",
+			"width": 160,
+		},
 	]
-	return columns
 
 
-def get_bom_stock(filters):
-	conditions = ""
-	bom = filters.get("bom")
-
-	table = "`tabBOM Item`"
-	qty_field = "qty"
-
+def get_bom_data(filters):
 	if filters.get("show_exploded_view"):
-		table = "`tabBOM Explosion Item`"
-		qty_field = "stock_qty"
+		bom_item_table = "BOM Explosion Item"
+	else:
+		bom_item_table = "BOM Item"
+
+	bom_item = frappe.qb.DocType(bom_item_table)
+	bin = frappe.qb.DocType("Bin")
+
+	query = (
+		frappe.qb.from_(bom_item)
+		.left_join(bin)
+		.on(bom_item.item_code == bin.item_code)
+		.select(
+			bom_item.item_code,
+			bom_item.description,
+			bom_item.qty_consumed_per_unit.as_("qty_per_unit"),
+			IfNull(Sum(bin.actual_qty), 0).as_("actual_qty"),
+		)
+		.where((bom_item.parent == filters.get("bom")) & (bom_item.parenttype == "BOM"))
+		.groupby(bom_item.item_code)
+	)
 
 	if filters.get("warehouse"):
 		warehouse_details = frappe.db.get_value(
 			"Warehouse", filters.get("warehouse"), ["lft", "rgt"], as_dict=1
 		)
+
 		if warehouse_details:
-			conditions += (
-				" and exists (select name from `tabWarehouse` wh \
-				where wh.lft >= %s and wh.rgt <= %s and ledger.warehouse = wh.name)"
-				% (warehouse_details.lft, warehouse_details.rgt)
+			wh = frappe.qb.DocType("Warehouse")
+			query = query.where(
+				ExistsCriterion(
+					frappe.qb.from_(wh)
+					.select(wh.name)
+					.where(
+						(wh.lft >= warehouse_details.lft)
+						& (wh.rgt <= warehouse_details.rgt)
+						& (bin.warehouse == wh.name)
+					)
+				)
 			)
 		else:
-			conditions += " and ledger.warehouse = %s" % frappe.db.escape(filters.get("warehouse"))
+			query = query.where(bin.warehouse == frappe.db.escape(filters.get("warehouse")))
 
-	else:
-		conditions += ""
-
-	return frappe.db.sql(
-		"""
-			SELECT
-				bom_item.item_code,
-				bom_item.description,
-				bom_item.{qty_field},
-				ifnull(sum(ledger.actual_qty), 0) as actual_qty,
-				ifnull(sum(FLOOR(ledger.actual_qty / bom_item.{qty_field})), 0) as to_build
-			FROM
-				{table} AS bom_item
-				LEFT JOIN `tabBin` AS ledger
-				ON bom_item.item_code = ledger.item_code
-				{conditions}
-
-			WHERE
-				bom_item.parent = '{bom}' and bom_item.parenttype='BOM'
-
-			GROUP BY bom_item.item_code""".format(
-			qty_field=qty_field, table=table, conditions=conditions, bom=bom
-		),
-		as_dict=1,
-	)
+	return query.run(as_dict=True)
 
 
 def get_manufacturer_records():
 	details = frappe.get_all(
 		"Item Manufacturer", fields=["manufacturer", "manufacturer_part_no", "item_code"]
 	)
+
 	manufacture_details = frappe._dict()
 	for detail in details:
 		dic = manufacture_details.setdefault(detail.get("item_code"), {})

erpnext/manufacturing/report/bom_stock_calculated/test_bom_stock_calculated.py

@@ -0,0 +1,115 @@
+# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+from frappe.tests.utils import FrappeTestCase
+
+from erpnext.manufacturing.doctype.production_plan.test_production_plan import make_bom
+from erpnext.manufacturing.report.bom_stock_calculated.bom_stock_calculated import (
+	execute as bom_stock_calculated_report,
+)
+from erpnext.stock.doctype.item.test_item import make_item
+
+
+class TestBOMStockCalculated(FrappeTestCase):
+	def setUp(self):
+		self.fg_item, self.rm_items = create_items()
+		self.boms = create_boms(self.fg_item, self.rm_items)
+
+	def test_bom_stock_calculated(self):
+		qty_to_make = 10
+
+		# Case 1: When Item(s) Qty and Stock Qty are equal.
+		data = bom_stock_calculated_report(
+			filters={
+				"qty_to_make": qty_to_make,
+				"bom": self.boms[0].name,
+			}
+		)[1]
+		expected_data = get_expected_data(self.boms[0], qty_to_make)
+		self.assertSetEqual(set(tuple(x) for x in data), set(tuple(x) for x in expected_data))
+
+		# Case 2: When Item(s) Qty and Stock Qty are different and BOM Qty is 1.
+		data = bom_stock_calculated_report(
+			filters={
+				"qty_to_make": qty_to_make,
+				"bom": self.boms[1].name,
+			}
+		)[1]
+		expected_data = get_expected_data(self.boms[1], qty_to_make)
+		self.assertSetEqual(set(tuple(x) for x in data), set(tuple(x) for x in expected_data))
+
+		# Case 3: When Item(s) Qty and Stock Qty are different and BOM Qty is greater than 1.
+		data = bom_stock_calculated_report(
+			filters={
+				"qty_to_make": qty_to_make,
+				"bom": self.boms[2].name,
+			}
+		)[1]
+		expected_data = get_expected_data(self.boms[2], qty_to_make)
+		self.assertSetEqual(set(tuple(x) for x in data), set(tuple(x) for x in expected_data))
+
+
+def create_items():
+	fg_item = make_item(properties={"is_stock_item": 1}).name
+	rm_item1 = make_item(
+		properties={
+			"is_stock_item": 1,
+			"standard_rate": 100,
+			"opening_stock": 100,
+			"last_purchase_rate": 100,
+		}
+	).name
+	rm_item2 = make_item(
+		properties={
+			"is_stock_item": 1,
+			"standard_rate": 200,
+			"opening_stock": 200,
+			"last_purchase_rate": 200,
+		}
+	).name
+
+	return fg_item, [rm_item1, rm_item2]
+
+
+def create_boms(fg_item, rm_items):
+	def update_bom_items(bom, uom, conversion_factor):
+		for item in bom.items:
+			item.uom = uom
+			item.conversion_factor = conversion_factor
+
+		return bom
+
+	bom1 = make_bom(item=fg_item, quantity=1, raw_materials=rm_items, rm_qty=10)
+
+	bom2 = make_bom(item=fg_item, quantity=1, raw_materials=rm_items, rm_qty=10, do_not_submit=True)
+	bom2 = update_bom_items(bom2, "Box", 10)
+	bom2.save()
+	bom2.submit()
+
+	bom3 = make_bom(item=fg_item, quantity=2, raw_materials=rm_items, rm_qty=10, do_not_submit=True)
+	bom3 = update_bom_items(bom3, "Box", 10)
+	bom3.save()
+	bom3.submit()
+
+	return [bom1, bom2, bom3]
+
+
+def get_expected_data(bom, qty_to_make):
+	expected_data = []
+
+	for idx in range(len(bom.items)):
+		expected_data.append(
+			[
+				bom.items[idx].item_code,
+				bom.items[idx].item_code,
+				"",
+				"",
+				float(bom.items[idx].stock_qty / bom.quantity),
+				float(100 * (idx + 1)),
+				float(qty_to_make * (bom.items[idx].stock_qty / bom.quantity)),
+				float((100 * (idx + 1)) - (qty_to_make * (bom.items[idx].stock_qty / bom.quantity))),
+				float(100 * (idx + 1)),
+			]
+		)
+
+	return expected_data

erpnext/patches.txt

@@ -373,3 +373,4 @@ erpnext.patches.v13_0.fix_number_and_frequency_for_monthly_depreciation
 erpnext.patches.v13_0.reset_corrupt_defaults
 erpnext.patches.v13_0.show_hr_payroll_deprecation_warning
 erpnext.patches.v13_0.create_accounting_dimensions_for_asset_repair
+execute:frappe.db.set_value("Naming Series", "Naming Series", {"select_doc_for_series": "", "set_options": "", "prefix": "", "current_value": 0, "user_must_always_select": 0})

erpnext/payroll/doctype/employee_benefit_application/test_employee_benefit_application.py

@@ -9,7 +9,7 @@ from frappe.utils import add_days, date_diff, get_year_ending, get_year_start, g
 
 from erpnext.hr.doctype.employee.test_employee import make_employee
 from erpnext.hr.doctype.holiday_list.test_holiday_list import set_holiday_list
-from erpnext.hr.doctype.leave_application.test_leave_application import get_first_sunday
+from erpnext.hr.tests.test_utils import get_first_sunday
 from erpnext.hr.utils import get_holiday_dates_for_employee
 from erpnext.payroll.doctype.employee_benefit_application.employee_benefit_application import (
 	calculate_lwp,

erpnext/payroll/doctype/salary_slip/salary_slip.py

@@ -587,7 +587,7 @@ class SalarySlip(TransactionBase):
 		if self.salary_structure:
 			self.calculate_component_amounts("deductions")
 
-		self.set_loan_repayment()
+		self.add_applicable_loans()
 		self.set_precision_for_component_amounts()
 		self.set_net_pay()
 
@@ -632,9 +632,19 @@ class SalarySlip(TransactionBase):
 				continue
 
 			amount = self.eval_condition_and_formula(struct_row, data)
-			if (
-				amount or (struct_row.amount_based_on_formula and amount is not None)
-			) and struct_row.statistical_component == 0:
+
+			if struct_row.statistical_component:
+				# update statitical component amount in reference data based on payment days
+				# since row for statistical component is not added to salary slip
+				if struct_row.depends_on_payment_days:
+					joining_date, relieving_date = self.get_joining_and_relieving_dates()
+					default_data[struct_row.abbr] = amount
+					data[struct_row.abbr] = flt(
+						(flt(amount) * flt(self.payment_days) / cint(self.total_working_days)),
+						struct_row.precision("amount"),
+					)
+
+			elif amount or struct_row.amount_based_on_formula and amount is not None:
 				default_amount = self.eval_condition_and_formula(struct_row, default_data)
 				self.update_component_row(
 					struct_row, amount, component_type, data=data, default_amount=default_amount
@@ -687,8 +697,8 @@ class SalarySlip(TransactionBase):
 
 		for key in ("earnings", "deductions"):
 			for d in self.get(key):
-				default_data[d.abbr] = d.default_amount
-				data[d.abbr] = d.amount
+				default_data[d.abbr] = d.default_amount or 0
+				data[d.abbr] = d.amount or 0
 
 		return data, default_data
 
@@ -1370,44 +1380,47 @@ class SalarySlip(TransactionBase):
 
 		return joining_date, relieving_date
 
-	def set_loan_repayment(self):
+	def add_applicable_loans(self):
 		self.total_loan_repayment = 0
 		self.total_interest_amount = 0
 		self.total_principal_amount = 0
 
-		self.set("loans", [])
+		loans = [d.loan for d in self.get("loans")]
+
 		for loan in self.get_loan_details():
-			amounts = calculate_amounts(loan.name, self.posting_date, "Regular Payment")
+			if loan.name not in loans:
+				amounts = calculate_amounts(loan.name, self.posting_date, "Regular Payment")
+				if (
+					amounts["interest_amount"] + amounts["payable_principal_amount"]
+					> amounts["written_off_amount"]
+				):
+					if amounts["interest_amount"] > amounts["written_off_amount"]:
+						amounts["interest_amount"] -= amounts["written_off_amount"]
+						amounts["written_off_amount"] = 0
+					else:
+						amounts["written_off_amount"] -= amounts["interest_amount"]
+						amounts["interest_amount"] = 0
 
-			if (amounts["interest_amount"] or amounts["payable_principal_amount"]) and (
-				amounts["payable_principal_amount"] + amounts["interest_amount"]
-				> amounts["written_off_amount"]
-			):
+					if amounts["payable_principal_amount"] > amounts["written_off_amount"]:
+						amounts["payable_principal_amount"] -= amounts["written_off_amount"]
+						amounts["written_off_amount"] = 0
+					else:
+						amounts["written_off_amount"] -= amounts["payable_principal_amount"]
+						amounts["payable_principal_amount"] = 0
 
-				if amounts["interest_amount"] > amounts["written_off_amount"]:
-					amounts["interest_amount"] -= amounts["written_off_amount"]
-					amounts["written_off_amount"] = 0
-				else:
-					amounts["written_off_amount"] -= amounts["interest_amount"]
-					amounts["interest_amount"] = 0
-
-				if amounts["payable_principal_amount"] > amounts["written_off_amount"]:
-					amounts["payable_principal_amount"] -= amounts["written_off_amount"]
-					amounts["written_off_amount"] = 0
-				else:
-					amounts["written_off_amount"] -= amounts["payable_principal_amount"]
-					amounts["payable_principal_amount"] = 0
-
-				self.append(
-					"loans",
-					{
-						"loan": loan.name,
-						"interest_amount": amounts["interest_amount"],
-						"principal_amount": amounts["payable_principal_amount"],
-						"loan_account": loan.loan_account,
-						"interest_income_account": loan.interest_income_account,
-					},
-				)
+					self.append(
+						"loans",
+						{
+							"loan": loan.name,
+							"interest_amount": amounts["interest_amount"],
+							"principal_amount": amounts["payable_principal_amount"],
+							"total_payment": amounts["interest_amount"] + amounts["payable_principal_amount"]
+							if not loan.manually_update_paid_amount_in_salary_slip
+							else 0,
+							"loan_account": loan.loan_account,
+							"interest_income_account": loan.interest_income_account,
+						},
+					)
 
 		for payment in self.get("loans"):
 			amounts = calculate_amounts(payment.loan, self.posting_date, "Regular Payment")
@@ -1432,7 +1445,14 @@ class SalarySlip(TransactionBase):
 	def get_loan_details(self):
 		loan_details = frappe.get_all(
 			"Loan",
-			fields=["name", "interest_income_account", "loan_account", "loan_type", "is_term_loan"],
+			fields=[
+				"name",
+				"interest_income_account",
+				"loan_account",
+				"loan_type",
+				"is_term_loan",
+				"manually_update_paid_amount_in_salary_slip",
+			],
 			filters={
 				"applicant": self.employee,
 				"docstatus": 1,

erpnext/payroll/doctype/salary_slip/test_salary_slip.py

@@ -27,6 +27,7 @@ from erpnext.hr.doctype.attendance.attendance import mark_attendance
 from erpnext.hr.doctype.employee.test_employee import make_employee
 from erpnext.hr.doctype.leave_allocation.test_leave_allocation import create_leave_allocation
 from erpnext.hr.doctype.leave_type.test_leave_type import create_leave_type
+from erpnext.hr.tests.test_utils import get_first_sunday
 from erpnext.payroll.doctype.employee_tax_exemption_declaration.test_employee_tax_exemption_declaration import (
 	create_exemption_category,
 	create_payroll_period,
@@ -55,18 +56,7 @@ class TestSalarySlip(FrappeTestCase):
 
 		frappe.db.set_value("Leave Type", "Leave Without Pay", "include_holiday", 0)
 
-		month_start_date = get_first_day(nowdate())
-		month_end_date = get_last_day(nowdate())
-
-		first_sunday = frappe.db.sql(
-			"""
-			select holiday_date from `tabHoliday`
-			where parent = 'Salary Slip Test Holiday List'
-				and holiday_date between %s and %s
-			order by holiday_date
-		""",
-			(month_start_date, month_end_date),
-		)[0][0]
+		first_sunday = get_first_sunday()
 
 		mark_attendance(emp_id, first_sunday, "Absent", ignore_validate=True)  # invalid lwp
 		mark_attendance(
@@ -273,19 +263,7 @@ class TestSalarySlip(FrappeTestCase):
 
 		frappe.db.set_value("Leave Type", "Leave Without Pay", "include_holiday", 0)
 
-		month_start_date = get_first_day(nowdate())
-		month_end_date = get_last_day(nowdate())
-
-		first_sunday = frappe.db.sql(
-			"""
-			select holiday_date from `tabHoliday`
-			where parent = 'Salary Slip Test Holiday List'
-				and holiday_date between %s and %s
-			order by holiday_date
-		""",
-			(month_start_date, month_end_date),
-		)[0][0]
-
+		first_sunday = get_first_sunday()
 		make_leave_application(emp_id, first_sunday, add_days(first_sunday, 3), "Leave Without Pay")
 
 		leave_type_ppl = create_leave_type(leave_type_name="Test Partially Paid Leave", is_ppl=1)
@@ -338,19 +316,7 @@ class TestSalarySlip(FrappeTestCase):
 		frappe.db.set_value("Employee", emp, {"relieving_date": None, "status": "Active"})
 
 		# mark attendance
-		month_start_date = get_first_day(nowdate())
-		month_end_date = get_last_day(nowdate())
-
-		first_sunday = frappe.db.sql(
-			"""
-			select holiday_date from `tabHoliday`
-			where parent = 'Salary Slip Test Holiday List'
-				and holiday_date between %s and %s
-			order by holiday_date
-		""",
-			(month_start_date, month_end_date),
-		)[0][0]
-
+		first_sunday = get_first_sunday()
 		mark_attendance(
 			emp, add_days(first_sunday, 1), "Absent", ignore_validate=True
 		)  # counted as absent
@@ -359,8 +325,8 @@ class TestSalarySlip(FrappeTestCase):
 		make_salary_structure_for_timesheet(emp)
 		timesheet = make_timesheet(emp, simulate=True, is_billable=1)
 		salary_slip = make_salary_slip_for_timesheet(timesheet.name)
-		salary_slip.start_date = month_start_date
-		salary_slip.end_date = month_end_date
+		salary_slip.start_date = get_first_day(nowdate())
+		salary_slip.end_date = get_last_day(nowdate())
 		salary_slip.save()
 		salary_slip.submit()
 		salary_slip.reload()
@@ -402,18 +368,7 @@ class TestSalarySlip(FrappeTestCase):
 		)
 
 		# mark employee absent for a day since this case works fine if payment days are equal to working days
-		month_start_date = get_first_day(nowdate())
-		month_end_date = get_last_day(nowdate())
-
-		first_sunday = frappe.db.sql(
-			"""
-			select holiday_date from `tabHoliday`
-			where parent = 'Salary Slip Test Holiday List'
-				and holiday_date between %s and %s
-			order by holiday_date
-		""",
-			(month_start_date, month_end_date),
-		)[0][0]
+		first_sunday = get_first_sunday()
 
 		mark_attendance(
 			employee, add_days(first_sunday, 1), "Absent", ignore_validate=True
@@ -1032,6 +987,42 @@ class TestSalarySlip(FrappeTestCase):
 		components = [row.salary_component for row in new_ss.get("earnings")]
 		self.assertNotIn("Statistical Component", components)
 
+	@change_settings(
+		"Payroll Settings",
+		{"payroll_based_on": "Attendance", "consider_unmarked_attendance_as": "Present"},
+	)
+	def test_statistical_component_based_on_payment_days(self):
+		"""
+		Tests whether component using statistical component in the formula
+		gets the updated value based on payment days
+		"""
+		from erpnext.payroll.doctype.salary_structure.test_salary_structure import (
+			create_salary_structure_assignment,
+		)
+
+		emp = make_employee("test_statistical_component@salary.com")
+		first_sunday = get_first_sunday()
+		mark_attendance(emp, add_days(first_sunday, 1), "Absent", ignore_validate=True)
+		salary_structure = make_salary_structure_for_payment_days_based_component_dependency(
+			test_statistical_comp=True
+		)
+		create_salary_structure_assignment(
+			emp, salary_structure.name, company="_Test Company", currency="INR"
+		)
+		# make salary slip and assert payment days
+		ss = make_salary_slip_for_payment_days_dependency_test(
+			"test_statistical_component@salary.com", salary_structure.name
+		)
+
+		amount = precision = None
+		for entry in ss.earnings:
+			if entry.salary_component == "Dependency Component":
+				amount = entry.amount
+				precision = entry.precision("amount")
+				break
+
+		self.assertEqual(amount, flt((1000 * ss.payment_days / ss.total_working_days) * 0.5, precision))
+
 	def make_activity_for_employee(self):
 		activity_type = frappe.get_doc("Activity Type", "_Test Activity Type")
 		activity_type.billing_rate = 50
@@ -1151,7 +1142,11 @@ def create_account(account_name, company, parent_account, account_type=None):
 
 
 def make_earning_salary_component(
-	setup=False, test_tax=False, company_list=None, include_flexi_benefits=False
+	setup=False,
+	test_tax=False,
+	company_list=None,
+	include_flexi_benefits=False,
+	test_statistical_comp=False,
 ):
 	data = [
 		{
@@ -1517,7 +1512,7 @@ def make_holiday_list(list_name=None, from_date=None, to_date=None):
 	return holiday_list
 
 
-def make_salary_structure_for_payment_days_based_component_dependency():
+def make_salary_structure_for_payment_days_based_component_dependency(test_statistical_comp=False):
 	earnings = [
 		{
 			"salary_component": "Basic Salary - Payment Days",
@@ -1535,6 +1530,27 @@ def make_salary_structure_for_payment_days_based_component_dependency():
 			"formula": "base * 0.20",
 		},
 	]
+	if test_statistical_comp:
+		earnings.extend(
+			[
+				{
+					"salary_component": "Statistical Component",
+					"abbr": "SC",
+					"type": "Earning",
+					"statistical_component": 1,
+					"amount": 1000,
+					"depends_on_payment_days": 1,
+				},
+				{
+					"salary_component": "Dependency Component",
+					"abbr": "DC",
+					"type": "Earning",
+					"amount_based_on_formula": 1,
+					"formula": "SC * 0.5",
+					"depends_on_payment_days": 0,
+				},
+			]
+		)
 
 	make_salary_component(earnings, False, company_list=["_Test Company"])
 

erpnext/projects/doctype/project/project.js

@@ -134,6 +134,7 @@ function open_form(frm, doctype, child_doctype, parentfield) {
 		new_child_doc.parentfield = parentfield;
 		new_child_doc.parenttype = doctype;
 		new_doc[parentfield] = [new_child_doc];
+		new_doc.project = frm.doc.name;
 
 		frappe.ui.form.make_quick_entry(doctype, null, null, new_doc);
 	});

erpnext/selling/doctype/sales_order/sales_order.py

@@ -950,6 +950,9 @@ def get_events(start, end, filters=None):
 @frappe.whitelist()
 def make_purchase_order_for_default_supplier(source_name, selected_items=None, target_doc=None):
 	"""Creates Purchase Order for each Supplier. Returns a list of doc objects."""
+
+	from erpnext.setup.utils import get_exchange_rate
+
 	if not selected_items:
 		return
 
@@ -958,10 +961,20 @@ def make_purchase_order_for_default_supplier(source_name, selected_items=None, t
 
 	def set_missing_values(source, target):
 		target.supplier = supplier
+		target.currency = frappe.db.get_value(
+			"Supplier", filters={"name": supplier}, fieldname=["default_currency"]
+		)
+		company_currency = frappe.db.get_value(
+			"Company", filters={"name": target.company}, fieldname=["default_currency"]
+		)
+
+		target.conversion_rate = get_exchange_rate(target.currency, company_currency, args="for_buying")
+
 		target.apply_discount_on = ""
 		target.additional_discount_percentage = 0.0
 		target.discount_amount = 0.0
 		target.inter_company_order_reference = ""
+		target.shipping_rule = ""
 
 		default_price_list = frappe.get_value("Supplier", supplier, "default_price_list")
 		if default_price_list:
@@ -1080,6 +1093,7 @@ def make_purchase_order(source_name, selected_items=None, target_doc=None):
 		target.additional_discount_percentage = 0.0
 		target.discount_amount = 0.0
 		target.inter_company_order_reference = ""
+		target.shipping_rule = ""
 		target.customer = ""
 		target.customer_name = ""
 		target.run_method("set_missing_values")

erpnext/stock/doctype/item_barcode/item_barcode.json

@@ -16,6 +16,7 @@
    "in_list_view": 1,
    "label": "Barcode",
    "no_copy": 1,
+   "reqd": 1,
    "unique": 1
   },
   {
@@ -28,7 +29,7 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2022-04-01 05:54:27.314030",
+ "modified": "2022-08-24 19:59:47.871677",
  "modified_by": "Administrator",
  "module": "Stock",
  "name": "Item Barcode",

erpnext/stock/doctype/item_supplier/item_supplier.json

@@ -1,95 +1,43 @@
 {
- "allow_copy": 0, 
- "allow_import": 0, 
- "allow_rename": 0, 
- "beta": 0, 
- "creation": "2013-02-22 01:28:01", 
- "custom": 0, 
- "docstatus": 0, 
- "doctype": "DocType", 
- "editable_grid": 1, 
- "engine": "InnoDB", 
+ "actions": [],
+ "creation": "2013-02-22 01:28:01",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "supplier",
+  "supplier_part_no"
+ ],
  "fields": [
   {
-   "allow_on_submit": 0, 
-   "bold": 0, 
-   "collapsible": 0, 
-   "columns": 0, 
-   "fieldname": "supplier", 
-   "fieldtype": "Link", 
-   "hidden": 0, 
-   "ignore_user_permissions": 0, 
-   "ignore_xss_filter": 0, 
-   "in_filter": 0, 
-   "in_global_search": 0, 
-   "in_list_view": 1, 
-   "in_standard_filter": 0, 
-   "label": "Supplier", 
-   "length": 0, 
-   "no_copy": 0, 
-   "options": "Supplier", 
-   "permlevel": 0, 
-   "print_hide": 0, 
-   "print_hide_if_no_value": 0, 
-   "read_only": 0, 
-   "remember_last_selected_value": 0, 
-   "report_hide": 0, 
-   "reqd": 0, 
-   "search_index": 0, 
-   "set_only_once": 0, 
-   "unique": 0
-  }, 
+   "fieldname": "supplier",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "Supplier",
+   "options": "Supplier",
+   "reqd": 1
+  },
   {
-   "allow_on_submit": 0, 
-   "bold": 0, 
-   "collapsible": 0, 
-   "columns": 0, 
-   "fieldname": "supplier_part_no", 
-   "fieldtype": "Data", 
-   "hidden": 0, 
-   "ignore_user_permissions": 0, 
-   "ignore_xss_filter": 0, 
-   "in_filter": 0, 
-   "in_global_search": 1, 
-   "in_list_view": 1, 
-   "in_standard_filter": 0, 
-   "label": "Supplier Part Number", 
-   "length": 0, 
-   "no_copy": 0, 
-   "permlevel": 0, 
-   "print_hide": 0, 
-   "print_hide_if_no_value": 0, 
-   "print_width": "200px", 
-   "read_only": 0, 
-   "remember_last_selected_value": 0, 
-   "report_hide": 0, 
-   "reqd": 0, 
-   "search_index": 0, 
-   "set_only_once": 0, 
-   "unique": 0, 
+   "fieldname": "supplier_part_no",
+   "fieldtype": "Data",
+   "in_global_search": 1,
+   "in_list_view": 1,
+   "label": "Supplier Part Number",
+   "print_width": "200px",
    "width": "200px"
   }
- ], 
- "hide_heading": 0, 
- "hide_toolbar": 0, 
- "idx": 1, 
- "image_view": 0, 
- "in_create": 0, 
-
- "is_submittable": 0, 
- "issingle": 0, 
- "istable": 1, 
- "max_attachments": 0, 
- "modified": "2017-02-20 13:29:32.569715", 
- "modified_by": "Administrator", 
- "module": "Stock", 
- "name": "Item Supplier", 
- "owner": "Administrator", 
- "permissions": [], 
- "quick_entry": 0, 
- "read_only": 0, 
- "read_only_onload": 0, 
- "show_name_in_global_search": 0, 
- "track_changes": 1, 
- "track_seen": 0
+ ],
+ "idx": 1,
+ "istable": 1,
+ "links": [],
+ "modified": "2022-09-07 12:33:55.780062",
+ "modified_by": "Administrator",
+ "module": "Stock",
+ "name": "Item Supplier",
+ "owner": "Administrator",
+ "permissions": [],
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "states": [],
+ "track_changes": 1
 }

erpnext/stock/doctype/pick_list/pick_list.py

@@ -174,7 +174,7 @@ class PickList(Document):
 				frappe.throw("Row #{0}: Item Code is Mandatory".format(item.idx))
 			item_code = item.item_code
 			reference = item.sales_order_item or item.material_request_item
-			key = (item_code, item.uom, reference)
+			key = (item_code, item.uom, item.warehouse, reference)
 
 			item.idx = None
 			item.name = None

erpnext/stock/doctype/purchase_receipt/purchase_receipt.py

@@ -367,6 +367,12 @@ class PurchaseReceipt(BuyingController):
 						if credit_currency == self.company_currency
 						else flt(d.net_amount, d.precision("net_amount"))
 					)
+
+					outgoing_amount = d.base_net_amount
+					if self.is_internal_supplier and d.valuation_rate:
+						outgoing_amount = d.valuation_rate * d.stock_qty
+						credit_amount = outgoing_amount
+
 					if credit_amount:
 						account = warehouse_account[d.from_warehouse]["account"] if d.from_warehouse else stock_rbnb
 
@@ -374,7 +380,7 @@ class PurchaseReceipt(BuyingController):
 							gl_entries=gl_entries,
 							account=account,
 							cost_center=d.cost_center,
-							debit=-1 * flt(d.base_net_amount, d.precision("base_net_amount")),
+							debit=-1 * flt(outgoing_amount, d.precision("base_net_amount")),
 							credit=0.0,
 							remarks=remarks,
 							against_account=warehouse_account_name,
@@ -423,7 +429,7 @@ class PurchaseReceipt(BuyingController):
 
 					# divisional loss adjustment
 					valuation_amount_as_per_doc = (
-						flt(d.base_net_amount, d.precision("base_net_amount"))
+						flt(outgoing_amount, d.precision("base_net_amount"))
 						+ flt(d.landed_cost_voucher_amount)
 						+ flt(d.rm_supp_cost)
 						+ flt(d.item_tax_amount)

erpnext/stock/doctype/purchase_receipt/test_purchase_receipt.py

@@ -9,6 +9,7 @@ from collections import defaultdict
 import frappe
 from frappe.tests.utils import FrappeTestCase, change_settings
 from frappe.utils import add_days, cint, cstr, flt, today
+from pypika import functions as fn
 from six import iteritems
 
 import erpnext
@@ -1361,6 +1362,125 @@ class TestPurchaseReceipt(FrappeTestCase):
 			if gle.account == account:
 				self.assertEqual(gle.credit, 50)
 
+	def test_backdated_transaction_for_internal_transfer(self):
+		from erpnext.stock.doctype.delivery_note.delivery_note import make_inter_company_purchase_receipt
+		from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
+
+		prepare_data_for_internal_transfer()
+		customer = "_Test Internal Customer 2"
+		company = "_Test Company with perpetual inventory"
+
+		from_warehouse = create_warehouse("_Test Internal From Warehouse New", company=company)
+		to_warehouse = create_warehouse("_Test Internal To Warehouse New", company=company)
+		item_doc = create_item("Test Internal Transfer Item")
+
+		target_warehouse = create_warehouse("_Test Internal GIT Warehouse New", company=company)
+
+		make_purchase_receipt(
+			item_code=item_doc.name,
+			company=company,
+			posting_date=add_days(today(), -1),
+			warehouse=from_warehouse,
+			qty=1,
+			rate=100,
+		)
+
+		dn1 = create_delivery_note(
+			item_code=item_doc.name,
+			company=company,
+			customer=customer,
+			cost_center="Main - TCP1",
+			expense_account="Cost of Goods Sold - TCP1",
+			qty=1,
+			rate=500,
+			warehouse=from_warehouse,
+			target_warehouse=target_warehouse,
+		)
+
+		self.assertEqual(dn1.items[0].rate, 100)
+
+		pr1 = make_inter_company_purchase_receipt(dn1.name)
+		pr1.items[0].warehouse = to_warehouse
+		self.assertEqual(pr1.items[0].rate, 100)
+		pr1.submit()
+
+		# Backdated purchase receipt entry, the valuation rate should be updated for DN1 and PR1
+		make_purchase_receipt(
+			item_code=item_doc.name,
+			company=company,
+			posting_date=add_days(today(), -2),
+			warehouse=from_warehouse,
+			qty=1,
+			rate=200,
+		)
+
+		dn_value = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Delivery Note", "voucher_no": dn1.name, "warehouse": target_warehouse},
+			"stock_value_difference",
+		)
+
+		self.assertEqual(abs(dn_value), 200.00)
+
+		pr_value = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr1.name, "warehouse": to_warehouse},
+			"stock_value_difference",
+		)
+
+		self.assertEqual(abs(pr_value), 200.00)
+		pr1.load_from_db()
+
+		self.assertEqual(pr1.items[0].valuation_rate, 200)
+		self.assertEqual(pr1.items[0].rate, 100)
+
+		Gl = frappe.qb.DocType("GL Entry")
+
+		query = (
+			frappe.qb.from_(Gl)
+			.select(
+				(fn.Sum(Gl.debit) - fn.Sum(Gl.credit)).as_("value"),
+			)
+			.where((Gl.voucher_type == pr1.doctype) & (Gl.voucher_no == pr1.name))
+		).run(as_dict=True)
+
+		self.assertEqual(query[0].value, 0)
+
+
+def prepare_data_for_internal_transfer():
+	from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_internal_supplier
+	from erpnext.selling.doctype.customer.test_customer import create_internal_customer
+
+	company = "_Test Company with perpetual inventory"
+
+	create_internal_customer(
+		"_Test Internal Customer 2",
+		company,
+		company,
+	)
+
+	create_internal_supplier(
+		"_Test Internal Supplier 2",
+		company,
+		company,
+	)
+
+	if not frappe.db.get_value("Company", company, "unrealized_profit_loss_account"):
+		account = "Unrealized Profit and Loss - TCP1"
+		if not frappe.db.exists("Account", account):
+			frappe.get_doc(
+				{
+					"doctype": "Account",
+					"account_name": "Unrealized Profit and Loss",
+					"parent_account": "Direct Income - TCP1",
+					"company": company,
+					"is_group": 0,
+					"account_type": "Income Account",
+				}
+			).insert()
+
+		frappe.db.set_value("Company", company, "unrealized_profit_loss_account", account)
+
 
 def get_sl_entries(voucher_type, voucher_no):
 	return frappe.db.sql(

erpnext/stock/doctype/repost_item_valuation/repost_item_valuation.js

@@ -58,6 +58,21 @@ frappe.ui.form.on('Repost Item Valuation', {
 		}
 
 		frm.trigger('show_reposting_progress');
+
+		if (frm.doc.status === 'Queued' && frm.doc.docstatus === 1) {
+			frm.trigger('execute_reposting');
+		}
+	},
+
+	execute_reposting(frm) {
+		frm.add_custom_button(__("Start Reposting"), () => {
+			frappe.call({
+				method: 'erpnext.stock.doctype.repost_item_valuation.repost_item_valuation.execute_repost_item_valuation',
+				callback: function() {
+					frappe.msgprint(__('Reposting has been started in the background.'));
+				}
+			});
+		});
 	},
 
 	show_reposting_progress: function(frm) {

erpnext/stock/doctype/repost_item_valuation/repost_item_valuation.py

@@ -302,3 +302,9 @@ def in_configured_timeslot(repost_settings=None, current_time=None):
 		return end_time >= now_time >= start_time
 	else:
 		return now_time >= start_time or now_time <= end_time
+
+
+@frappe.whitelist()
+def execute_repost_item_valuation():
+	"""Execute repost item valuation via scheduler."""
+	frappe.get_doc("Scheduled Job Type", "repost_item_valuation.repost_entries").enqueue(force=True)

erpnext/stock/doctype/stock_entry/stock_entry.py

@@ -879,6 +879,27 @@ class StockEntry(StockController):
 							se_item.idx, se_item.item_code, total_allowed, self.purchase_order
 						)
 					)
+				elif not se_item.get("po_detail"):
+					filters = {
+						"parent": self.purchase_order,
+						"docstatus": 1,
+						"rm_item_code": se_item.item_code,
+						"main_item_code": se_item.subcontracted_item,
+					}
+
+					order_rm_detail = frappe.db.get_value("Purchase Order Item Supplied", filters, "name")
+					if order_rm_detail:
+						se_item.db_set("po_detail", order_rm_detail)
+					else:
+						if not se_item.allow_alternative_item:
+							frappe.throw(
+								_("Row {0}# Item {1} not found in 'Raw Materials Supplied' table in {2} {3}").format(
+									se_item.idx,
+									se_item.item_code,
+									"Purchase Order",
+									self.purchase_order,
+								)
+							)
 		elif backflush_raw_materials_based_on == "Material Transferred for Subcontract":
 			for row in self.items:
 				if not row.subcontracted_item:

erpnext/stock/report/stock_ageing/stock_ageing.py

@@ -34,6 +34,9 @@ def format_report_data(filters: Filters, item_details: Dict, to_date: str) -> Li
 	precision = cint(frappe.db.get_single_value("System Settings", "float_precision", cache=True))
 
 	for item, item_dict in item_details.items():
+		if not flt(item_dict.get("total_qty"), precision):
+			continue
+
 		earliest_age, latest_age = 0, 0
 		details = item_dict["details"]
 

erpnext/stock/stock_ledger.py

@@ -638,21 +638,25 @@ class update_entries_after(object):
 
 			elif (
 				sle.voucher_type in ["Purchase Receipt", "Purchase Invoice"]
-				and sle.actual_qty > 0
+				and sle.voucher_detail_no
 				and frappe.get_cached_value(sle.voucher_type, sle.voucher_no, "is_internal_supplier")
 			):
-				sle_details = frappe.db.get_value(
-					"Stock Ledger Entry",
-					{
-						"voucher_type": sle.voucher_type,
-						"voucher_no": sle.voucher_no,
-						"dependant_sle_voucher_detail_no": sle.voucher_detail_no,
-					},
-					["stock_value_difference", "actual_qty"],
-					as_dict=1,
+				field = (
+					"delivery_note_item" if sle.voucher_type == "Purchase Receipt" else "sales_invoice_item"
+				)
+				doctype = (
+					"Delivery Note Item" if sle.voucher_type == "Purchase Receipt" else "Sales Invoice Item"
+				)
+				refernce_name = frappe.get_cached_value(
+					sle.voucher_type + " Item", sle.voucher_detail_no, field
 				)
 
-				rate = abs(sle_details.stock_value_difference / sle.actual_qty)
+				if refernce_name:
+					rate = frappe.get_cached_value(
+						doctype,
+						refernce_name,
+						"incoming_rate",
+					)
 			else:
 				if sle.voucher_type in ("Purchase Receipt", "Purchase Invoice"):
 					rate_field = "valuation_rate"
@@ -728,7 +732,12 @@ class update_entries_after(object):
 	def update_rate_on_purchase_receipt(self, sle, outgoing_rate):
 		if frappe.db.exists(sle.voucher_type + " Item", sle.voucher_detail_no):
 			frappe.db.set_value(
-				sle.voucher_type + " Item", sle.voucher_detail_no, "base_net_rate", outgoing_rate
+				sle.voucher_type + " Item",
+				sle.voucher_detail_no,
+				{
+					"base_net_rate": outgoing_rate,
+					"valuation_rate": outgoing_rate,
+				},
 			)
 		else:
 			frappe.db.set_value(