Merge branch 'develop' into refactor/stock/reports

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -31,7 +31,7 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		super.onload();
 
 		// Ignore linked advances
-		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry'];
+		this.frm.ignore_doctypes_on_cancel_all = ['Journal Entry', 'Payment Entry', 'Purchase Invoice'];
 
 		if(!this.frm.doc.__islocal) {
 			// show credit_to in print format

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -1415,6 +1415,7 @@ class PurchaseInvoice(BuyingController):
 			"Stock Ledger Entry",
 			"Repost Item Valuation",
 			"Payment Ledger Entry",
+			"Purchase Invoice",
 		)
 		self.update_advance_tax_references(cancel=1)
 

erpnext/accounts/utils.py

@@ -1368,9 +1368,8 @@ def check_and_delete_linked_reports(report):
 			frappe.delete_doc("Desktop Icon", icon)
 
 
-def create_payment_ledger_entry(
+def get_payment_ledger_entries(gl_entries, cancel=0):
-	gl_entries, cancel=0, adv_adj=0, update_outstanding="Yes", from_repost=0
+	ple_map = []
-):
 	if gl_entries:
 		ple = None
 
@@ -1410,39 +1409,52 @@ def create_payment_ledger_entry(
 					dr_or_cr *= -1
 					dr_or_cr_account_currency *= -1
 
-				ple = frappe.get_doc(
+				ple = frappe._dict(
-					{
+					doctype="Payment Ledger Entry",
-						"doctype": "Payment Ledger Entry",
+					posting_date=gle.posting_date,
-						"posting_date": gle.posting_date,
+					company=gle.company,
-						"company": gle.company,
+					account_type=account_type,
-						"account_type": account_type,
+					account=gle.account,
-						"account": gle.account,
+					party_type=gle.party_type,
-						"party_type": gle.party_type,
+					party=gle.party,
-						"party": gle.party,
+					cost_center=gle.cost_center,
-						"cost_center": gle.cost_center,
+					finance_book=gle.finance_book,
-						"finance_book": gle.finance_book,
+					due_date=gle.due_date,
-						"due_date": gle.due_date,
+					voucher_type=gle.voucher_type,
-						"voucher_type": gle.voucher_type,
+					voucher_no=gle.voucher_no,
-						"voucher_no": gle.voucher_no,
+					against_voucher_type=gle.against_voucher_type
-						"against_voucher_type": gle.against_voucher_type
 					if gle.against_voucher_type
 					else gle.voucher_type,
-						"against_voucher_no": gle.against_voucher if gle.against_voucher else gle.voucher_no,
+					against_voucher_no=gle.against_voucher if gle.against_voucher else gle.voucher_no,
-						"account_currency": gle.account_currency,
+					account_currency=gle.account_currency,
-						"amount": dr_or_cr,
+					amount=dr_or_cr,
-						"amount_in_account_currency": dr_or_cr_account_currency,
+					amount_in_account_currency=dr_or_cr_account_currency,
-						"delinked": True if cancel else False,
+					delinked=True if cancel else False,
-						"remarks": gle.remarks,
+					remarks=gle.remarks,
-					}
 				)
 
 				dimensions_and_defaults = get_dimensions()
 				if dimensions_and_defaults:
 					for dimension in dimensions_and_defaults[0]:
-						ple.set(dimension.fieldname, gle.get(dimension.fieldname))
+						ple[dimension.fieldname] = gle.get(dimension.fieldname)
+
+				ple_map.append(ple)
+	return ple_map
+
+
+def create_payment_ledger_entry(
+	gl_entries, cancel=0, adv_adj=0, update_outstanding="Yes", from_repost=0
+):
+	if gl_entries:
+		ple_map = get_payment_ledger_entries(gl_entries, cancel=cancel)
+
+		for entry in ple_map:
+
+			ple = frappe.get_doc(entry)
 
 			if cancel:
 				delink_original_entry(ple)
+
 			ple.flags.ignore_permissions = 1
 			ple.flags.adv_adj = adv_adj
 			ple.flags.from_repost = from_repost

erpnext/buying/report/procurement_tracker/procurement_tracker.py

@@ -127,32 +127,27 @@ def get_columns(filters):
 	return columns
 
 
-def get_conditions(filters):
+def apply_filters_on_query(filters, parent, child, query):
-	conditions = ""
-
 	if filters.get("company"):
-		conditions += " AND parent.company=%s" % frappe.db.escape(filters.get("company"))
+		query = query.where(parent.company == filters.get("company"))
 
 	if filters.get("cost_center") or filters.get("project"):
-		conditions += """
+		query = query.where(
-			AND (child.`cost_center`=%s OR child.`project`=%s)
+			(child.cost_center == filters.get("cost_center")) | (child.project == filters.get("project"))
-			""" % (
-			frappe.db.escape(filters.get("cost_center")),
-			frappe.db.escape(filters.get("project")),
 		)
 
 	if filters.get("from_date"):
-		conditions += " AND parent.transaction_date>='%s'" % filters.get("from_date")
+		query = query.where(parent.transaction_date >= filters.get("from_date"))
 
 	if filters.get("to_date"):
-		conditions += " AND parent.transaction_date<='%s'" % filters.get("to_date")
+		query = query.where(parent.transaction_date <= filters.get("to_date"))
-	return conditions
+
+	return query
 
 
 def get_data(filters):
-	conditions = get_conditions(filters)
+	purchase_order_entry = get_po_entries(filters)
-	purchase_order_entry = get_po_entries(conditions)
+	mr_records, procurement_record_against_mr = get_mapped_mr_details(filters)
-	mr_records, procurement_record_against_mr = get_mapped_mr_details(conditions)
 	pr_records = get_mapped_pr_records()
 	pi_records = get_mapped_pi_records()
 
@@ -187,11 +182,15 @@ def get_data(filters):
 	return procurement_record
 
 
-def get_mapped_mr_details(conditions):
+def get_mapped_mr_details(filters):
 	mr_records = {}
-	mr_details = frappe.db.sql(
+	parent = frappe.qb.DocType("Material Request")
-		"""
+	child = frappe.qb.DocType("Material Request Item")
-		SELECT
+
+	query = (
+		frappe.qb.from_(parent)
+		.from_(child)
+		.select(
 			parent.transaction_date,
 			parent.per_ordered,
 			parent.owner,
@@ -203,18 +202,13 @@ def get_mapped_mr_details(conditions):
 			child.uom,
 			parent.status,
 			child.project,
-			child.cost_center
+			child.cost_center,
-		FROM `tabMaterial Request` parent, `tabMaterial Request Item` child
+		)
-		WHERE
+		.where((parent.per_ordered >= 0) & (parent.name == child.parent) & (parent.docstatus == 1))
-			parent.per_ordered>=0
+	)
-			AND parent.name=child.parent
+	query = apply_filters_on_query(filters, parent, child, query)
-			AND parent.docstatus=1
+
-			{conditions}
+	mr_details = query.run(as_dict=True)
-		""".format(
-			conditions=conditions
-		),
-		as_dict=1,
-	)  # nosec
 
 	procurement_record_against_mr = []
 	for record in mr_details:
@@ -241,46 +235,49 @@ def get_mapped_mr_details(conditions):
 
 
 def get_mapped_pi_records():
-	return frappe._dict(
+	po = frappe.qb.DocType("Purchase Order")
-		frappe.db.sql(
+	pi_item = frappe.qb.DocType("Purchase Invoice Item")
-			"""
+	pi_records = (
-		SELECT
+		frappe.qb.from_(pi_item)
-			pi_item.po_detail,
+		.inner_join(po)
-			pi_item.base_amount
+		.on(pi_item.purchase_order == po.name)
-		FROM `tabPurchase Invoice Item` as pi_item
+		.select(pi_item.po_detail, pi_item.base_amount)
-		INNER JOIN `tabPurchase Order` as po
+		.where(
-		ON pi_item.`purchase_order` = po.`name`
+			(pi_item.docstatus == 1)
-		WHERE
+			& (po.status.notin(("Closed", "Completed", "Cancelled")))
-			pi_item.docstatus = 1
+			& (pi_item.po_detail.isnotnull())
-			AND po.status not in ('Closed','Completed','Cancelled')
-			AND pi_item.po_detail IS NOT NULL
-		"""
-		)
 		)
+	).run()
+
+	return frappe._dict(pi_records)
 
 
 def get_mapped_pr_records():
-	return frappe._dict(
+	pr = frappe.qb.DocType("Purchase Receipt")
-		frappe.db.sql(
+	pr_item = frappe.qb.DocType("Purchase Receipt Item")
-			"""
+	pr_records = (
-		SELECT
+		frappe.qb.from_(pr)
-			pr_item.purchase_order_item,
+		.from_(pr_item)
-			pr.posting_date
+		.select(pr_item.purchase_order_item, pr.posting_date)
-		FROM `tabPurchase Receipt` pr, `tabPurchase Receipt Item` pr_item
+		.where(
-		WHERE
+			(pr.docstatus == 1)
-			pr.docstatus=1
+			& (pr.name == pr_item.parent)
-			AND pr.name=pr_item.parent
+			& (pr_item.purchase_order_item.isnotnull())
-			AND pr_item.purchase_order_item IS NOT NULL
+			& (pr.status.notin(("Closed", "Completed", "Cancelled")))
-			AND pr.status not in  ('Closed','Completed','Cancelled')
-		"""
-		)
 		)
+	).run()
+
+	return frappe._dict(pr_records)
 
 
-def get_po_entries(conditions):
+def get_po_entries(filters):
-	return frappe.db.sql(
+	parent = frappe.qb.DocType("Purchase Order")
-		"""
+	child = frappe.qb.DocType("Purchase Order Item")
-		SELECT
+
+	query = (
+		frappe.qb.from_(parent)
+		.from_(child)
+		.select(
 			child.name,
 			child.parent,
 			child.cost_center,
@@ -297,17 +294,15 @@ def get_po_entries(conditions):
 			parent.transaction_date,
 			parent.supplier,
 			parent.status,
-			parent.owner
+			parent.owner,
-		FROM `tabPurchase Order` parent, `tabPurchase Order Item` child
+		)
-		WHERE
+		.where(
-			parent.docstatus = 1
+			(parent.docstatus == 1)
-			AND parent.name = child.parent
+			& (parent.name == child.parent)
-			AND parent.status not in  ('Closed','Completed','Cancelled')
+			& (parent.status.notin(("Closed", "Completed", "Cancelled")))
-			{conditions}
+		)
-		GROUP BY
+		.groupby(parent.name, child.item_code)
-			parent.name, child.item_code
+	)
-		""".format(
+	query = apply_filters_on_query(filters, parent, child, query)
-			conditions=conditions
+
-		),
+	return query.run(as_dict=True)
-		as_dict=1,
-	)  # nosec

erpnext/buying/report/purchase_order_analysis/purchase_order_analysis.py

@@ -6,6 +6,7 @@ import copy
 
 import frappe
 from frappe import _
+from frappe.query_builder.functions import IfNull
 from frappe.utils import date_diff, flt, getdate
 
 
@@ -16,9 +17,7 @@ def execute(filters=None):
 	validate_filters(filters)
 
 	columns = get_columns(filters)
-	conditions = get_conditions(filters)
+	data = get_data(filters)
-
-	data = get_data(conditions, filters)
 
 	if not data:
 		return [], [], None, []
@@ -37,60 +36,61 @@ def validate_filters(filters):
 		frappe.throw(_("To Date cannot be before From Date."))
 
 
-def get_conditions(filters):
+def get_data(filters):
-	conditions = ""
+	po = frappe.qb.DocType("Purchase Order")
-	if filters.get("from_date") and filters.get("to_date"):
+	po_item = frappe.qb.DocType("Purchase Order Item")
-		conditions += " and po.transaction_date between %(from_date)s and %(to_date)s"
+	pi_item = frappe.qb.DocType("Purchase Invoice Item")
 
-	for field in ["company", "name"]:
+	query = (
+		frappe.qb.from_(po)
+		.from_(po_item)
+		.left_join(pi_item)
+		.on(pi_item.po_detail == po_item.name)
+		.select(
+			po.transaction_date.as_("date"),
+			po_item.schedule_date.as_("required_date"),
+			po_item.project,
+			po.name.as_("purchase_order"),
+			po.status,
+			po.supplier,
+			po_item.item_code,
+			po_item.qty,
+			po_item.received_qty,
+			(po_item.qty - po_item.received_qty).as_("pending_qty"),
+			IfNull(pi_item.qty, 0).as_("billed_qty"),
+			po_item.base_amount.as_("amount"),
+			(po_item.received_qty * po_item.base_rate).as_("received_qty_amount"),
+			(po_item.billed_amt * IfNull(po.conversion_rate, 1)).as_("billed_amount"),
+			(po_item.base_amount - (po_item.billed_amt * IfNull(po.conversion_rate, 1))).as_(
+				"pending_amount"
+			),
+			po.set_warehouse.as_("warehouse"),
+			po.company,
+			po_item.name,
+		)
+		.where(
+			(po_item.parent == po.name) & (po.status.notin(("Stopped", "Closed"))) & (po.docstatus == 1)
+		)
+		.groupby(po_item.name)
+		.orderby(po.transaction_date)
+	)
+
+	for field in ("company", "name"):
 		if filters.get(field):
-			conditions += f" and po.{field} = %({field})s"
+			query = query.where(po[field] == filters.get(field))
+
+	if filters.get("from_date") and filters.get("to_date"):
+		query = query.where(
+			po.transaction_date.between(filters.get("from_date"), filters.get("to_date"))
+		)
 
 	if filters.get("status"):
-		conditions += " and po.status in %(status)s"
+		query = query.where(po.status.isin(filters.get("status")))
 
 	if filters.get("project"):
-		conditions += " and poi.project = %(project)s"
+		query = query.where(po_item.project == filters.get("project"))
 
-	return conditions
+	data = query.run(as_dict=True)
-
-
-def get_data(conditions, filters):
-	data = frappe.db.sql(
-		"""
-		SELECT
-			po.transaction_date as date,
-			poi.schedule_date as required_date,
-			poi.project,
-			po.name as purchase_order,
-			po.status, po.supplier, poi.item_code,
-			poi.qty, poi.received_qty,
-			(poi.qty - poi.received_qty) AS pending_qty,
-			IFNULL(pii.qty, 0) as billed_qty,
-			poi.base_amount as amount,
-			(poi.received_qty * poi.base_rate) as received_qty_amount,
-			(poi.billed_amt * IFNULL(po.conversion_rate, 1)) as billed_amount,
-			(poi.base_amount - (poi.billed_amt * IFNULL(po.conversion_rate, 1))) as pending_amount,
-			po.set_warehouse as warehouse,
-			po.company, poi.name
-		FROM
-			`tabPurchase Order` po,
-			`tabPurchase Order Item` poi
-		LEFT JOIN `tabPurchase Invoice Item` pii
-			ON pii.po_detail = poi.name
-		WHERE
-			poi.parent = po.name
-			and po.status not in ('Stopped', 'Closed')
-			and po.docstatus = 1
-			{0}
-		GROUP BY poi.name
-		ORDER BY po.transaction_date ASC
-	""".format(
-			conditions
-		),
-		filters,
-		as_dict=1,
-	)
 
 	return data
 

erpnext/buying/report/supplier_quotation_comparison/supplier_quotation_comparison.py

@@ -16,8 +16,7 @@ def execute(filters=None):
 		return [], []
 
 	columns = get_columns(filters)
-	conditions = get_conditions(filters)
+	supplier_quotation_data = get_data(filters)
-	supplier_quotation_data = get_data(filters, conditions)
 
 	data, chart_data = prepare_data(supplier_quotation_data, filters)
 	message = get_message()
@@ -25,50 +24,51 @@ def execute(filters=None):
 	return columns, data, message, chart_data
 
 
-def get_conditions(filters):
+def get_data(filters):
-	conditions = ""
+	sq = frappe.qb.DocType("Supplier Quotation")
+	sq_item = frappe.qb.DocType("Supplier Quotation Item")
+
+	query = (
+		frappe.qb.from_(sq_item)
+		.from_(sq)
+		.select(
+			sq_item.parent,
+			sq_item.item_code,
+			sq_item.qty,
+			sq_item.stock_qty,
+			sq_item.amount,
+			sq_item.uom,
+			sq_item.stock_uom,
+			sq_item.request_for_quotation,
+			sq_item.lead_time_days,
+			sq.supplier.as_("supplier_name"),
+			sq.valid_till,
+		)
+		.where(
+			(sq_item.parent == sq.name)
+			& (sq_item.docstatus < 2)
+			& (sq.company == filters.get("company"))
+			& (sq.transaction_date.between(filters.get("from_date"), filters.get("to_date")))
+		)
+		.orderby(sq.transaction_date, sq_item.item_code)
+	)
+
 	if filters.get("item_code"):
-		conditions += " AND sqi.item_code = %(item_code)s"
+		query = query.where(sq_item.item_code == filters.get("item_code"))
 
 	if filters.get("supplier_quotation"):
-		conditions += " AND sqi.parent in %(supplier_quotation)s"
+		query = query.where(sq_item.parent.isin(filters.get("supplier_quotation")))
 
 	if filters.get("request_for_quotation"):
-		conditions += " AND sqi.request_for_quotation = %(request_for_quotation)s"
+		query = query.where(sq_item.request_for_quotation == filters.get("request_for_quotation"))
 
 	if filters.get("supplier"):
-		conditions += " AND sq.supplier in %(supplier)s"
+		query = query.where(sq.supplier.isin(filters.get("supplier")))
 
 	if not filters.get("include_expired"):
-		conditions += " AND sq.status != 'Expired'"
+		query = query.where(sq.status != "Expired")
 
-	return conditions
+	supplier_quotation_data = query.run(as_dict=True)
-
-
-def get_data(filters, conditions):
-	supplier_quotation_data = frappe.db.sql(
-		"""
-		SELECT
-			sqi.parent, sqi.item_code,
-			sqi.qty, sqi.stock_qty, sqi.amount,
-			sqi.uom, sqi.stock_uom,
-			sqi.request_for_quotation,
-			sqi.lead_time_days, sq.supplier as supplier_name, sq.valid_till
-		FROM
-			`tabSupplier Quotation Item` sqi,
-			`tabSupplier Quotation` sq
-		WHERE
-			sqi.parent = sq.name
-			AND sqi.docstatus < 2
-			AND sq.company = %(company)s
-			AND sq.transaction_date between %(from_date)s and %(to_date)s
-			{0}
-			order by sq.transaction_date, sqi.item_code""".format(
-			conditions
-		),
-		filters,
-		as_dict=1,
-	)
 
 	return supplier_quotation_data