Files
manufacturing_utilities/manufacturing_utilities/manufacturing_overview/api.py
T
2026-11-14 14:42:02 +00:00

956 lines
20 KiB
Python

import frappe
from frappe.utils import flt, getdate
from manufacturing_utilities.manufacturing_overview.cache import (
get_cached_overview,
set_cached_overview,
)
@frappe.whitelist()
def get_manufacturing_overview():
cached = get_cached_overview()
if cached is not None:
return cached
settings = frappe.get_cached_doc(
"Manufacturing Overview Settings"
)
item_groups = [
row.item_group
for row in settings.item_groups
if row.item_group
]
warehouses = [
row.warehouse
for row in settings.warehouse
if row.warehouse
]
maximum_rows = int(
settings.maximum_rows or 0
)
if not item_groups:
result = {"items": []}
set_cached_overview(result)
return result
rows = get_sales_order_items(
item_groups
)
if not rows:
result = {"items": []}
set_cached_overview(result)
return result
work_orders = get_work_orders(
rows
)
subcontracting = get_subcontracting_data(
rows
)
warehouse_qty = get_warehouse_quantities(
rows,
warehouses,
)
prepared_rows = []
for row in rows:
work_order = work_orders.get(
row.sales_order_item
)
subcontracting_rows = list(
subcontracting.get(
row.sales_order_item,
[],
)
)
planned_end_date = (
work_order.planned_end_date
if work_order
else None
)
# A Planned End Date means subcontracting
# is expected.
#
# Even if purchasing has not created a PO
# yet, show a placeholder card.
if (
planned_end_date
and not subcontracting_rows
):
subcontracting_rows.append(
get_planned_subcontracting_entry(
row=row,
)
)
effective_sort_date = get_effective_sort_date(
delivery_date=row.delivery_date,
planned_end_date=planned_end_date,
subcontracting_rows=subcontracting_rows,
)
prepared_rows.append(
{
"row": row,
"work_order": work_order,
"planned_end_date": planned_end_date,
"effective_sort_date": effective_sort_date,
"subcontracting": subcontracting_rows,
}
)
# Sort by the operationally relevant date:
#
# - customer delivery date normally
# - planned end date while subcontracting
# material still needs to leave
prepared_rows.sort(
key=overview_sort_key
)
remaining_stock = dict(
warehouse_qty
)
items = []
for prepared in prepared_rows:
row = prepared["row"]
work_order = prepared["work_order"]
qty = flt(
row.qty
)
delivered_qty = flt(
row.delivered_qty
)
remaining_qty = flt(
row.remaining_qty
)
work_order_qty = flt(
row.work_order_qty
)
current_warehouse_qty = flt(
remaining_stock.get(
row.item_code,
0,
)
)
if delivered_qty > 0:
status = "partially_delivered"
elif (
current_warehouse_qty
>= remaining_qty
):
status = "in_warehouse"
elif work_order_qty > 0:
status = "to_produce"
else:
status = "no_work_order"
remaining_stock[
row.item_code
] = max(
current_warehouse_qty
- remaining_qty,
0,
)
items.append(
{
"sales_order":
row.sales_order,
"sales_order_item":
row.sales_order_item,
"work_order":
(
work_order.name
if work_order
else None
),
"work_order_planned_end_date":
prepared[
"planned_end_date"
],
"effective_sort_date":
prepared[
"effective_sort_date"
],
"item_code":
row.item_code,
"item_name":
row.item_name,
"customer":
row.customer,
"qty":
qty,
"delivered_qty":
delivered_qty,
"remaining_qty":
remaining_qty,
"delivery_date":
row.delivery_date,
"warehouse_qty":
current_warehouse_qty,
"work_order_qty":
work_order_qty,
"status":
status,
"subcontracting":
prepared[
"subcontracting"
],
}
)
if maximum_rows > 0:
items = items[
:maximum_rows
]
result = {
"items": items,
}
set_cached_overview(
result
)
return result
def get_sales_order_items(
item_groups,
):
placeholders = ", ".join(
["%s"] * len(item_groups)
)
return frappe.db.sql(
f"""
SELECT
soi.name AS sales_order_item,
soi.parent AS sales_order,
soi.item_code,
soi.item_name,
so.customer,
soi.qty,
soi.delivered_qty,
(
soi.qty
- soi.delivered_qty
) AS remaining_qty,
soi.delivery_date,
soi.work_order_qty
FROM
`tabSales Order Item` soi
INNER JOIN
`tabSales Order` so
ON so.name = soi.parent
INNER JOIN
`tabItem` item
ON item.name = soi.item_code
WHERE
so.docstatus = 1
AND so.status NOT IN (
'Closed',
'Completed'
)
AND soi.delivered_qty
< soi.qty
AND item.item_group
IN ({placeholders})
ORDER BY
soi.delivery_date ASC,
soi.item_code ASC,
soi.name ASC
""",
tuple(item_groups),
as_dict=True,
)
def get_work_orders(
rows,
):
sales_order_items = list(
{
row.sales_order_item
for row in rows
if row.sales_order_item
}
)
if not sales_order_items:
return {}
# Draft + Submitted Work Orders are useful
# for the manufacturing overview.
#
# Submitted is preferred if both exist.
work_order_rows = frappe.get_all(
"Work Order",
filters={
"sales_order_item": [
"in",
sales_order_items,
],
"docstatus": [
"<",
2,
],
},
fields=[
"name",
"sales_order_item",
"planned_end_date",
"docstatus",
"creation",
],
order_by="docstatus desc, creation desc",
)
result = {}
for work_order in work_order_rows:
sales_order_item = (
work_order.sales_order_item
)
if sales_order_item not in result:
result[
sales_order_item
] = work_order
return result
def get_planned_subcontracting_entry(
row,
):
return {
"source":
"planning",
"purchase_order":
None,
"purchase_order_item":
None,
"subcontracting_order":
None,
"supplier":
None,
"process":
"Subcontracting",
"qty":
flt(
row.remaining_qty
),
"received_qty":
0,
"status":
"No Purchase Order",
"material_transferred":
False,
}
def get_warehouse_quantities(
rows,
warehouses,
):
if (
not rows
or not warehouses
):
return {}
item_codes = list(
{
row.item_code
for row in rows
if row.item_code
}
)
if not item_codes:
return {}
item_placeholders = ", ".join(
["%s"] * len(item_codes)
)
warehouse_placeholders = ", ".join(
["%s"] * len(warehouses)
)
values = (
tuple(item_codes)
+ tuple(warehouses)
)
bin_rows = frappe.db.sql(
f"""
SELECT
item_code,
SUM(actual_qty)
AS actual_qty
FROM
`tabBin`
WHERE
item_code IN (
{item_placeholders}
)
AND warehouse IN (
{warehouse_placeholders}
)
GROUP BY
item_code
""",
values,
as_dict=True,
)
return {
row.item_code:
flt(row.actual_qty)
for row in bin_rows
}
def get_subcontracting_data(
rows,
):
if not rows:
return {}
sales_order_items = list(
{
row.sales_order_item
for row in rows
if row.sales_order_item
}
)
if not sales_order_items:
return {}
placeholders = ", ".join(
["%s"]
* len(sales_order_items)
)
# Include both Draft and Submitted POs.
# Cancelled documents are ignored.
purchase_order_items = frappe.db.sql(
f"""
SELECT
poi.name
AS purchase_order_item,
poi.sales_order_item,
poi.parent
AS purchase_order,
poi.item_code,
poi.item_name,
poi.fg_item,
poi.fg_item_qty,
poi.qty,
poi.schedule_date,
poi.expected_delivery_date,
po.supplier,
po.supplier_name,
po.status
AS purchase_order_status,
po.docstatus
AS purchase_order_docstatus,
po.creation
FROM
`tabPurchase Order Item` poi
INNER JOIN
`tabPurchase Order` po
ON po.name = poi.parent
WHERE
poi.sales_order_item
IN ({placeholders})
AND po.docstatus < 2
AND po.is_subcontracted = 1
ORDER BY
po.docstatus DESC,
po.creation DESC
""",
tuple(
sales_order_items
),
as_dict=True,
)
if not purchase_order_items:
return {}
purchase_orders_by_so_item = {}
for poi in purchase_order_items:
purchase_orders_by_so_item\
.setdefault(
poi.sales_order_item,
[],
)\
.append(poi)
selected_purchase_order_items = []
for (
sales_order_item,
linked_purchase_orders,
) in purchase_orders_by_so_item.items():
submitted = [
poi
for poi in linked_purchase_orders
if poi.purchase_order_docstatus == 1
]
drafts = [
poi
for poi in linked_purchase_orders
if poi.purchase_order_docstatus == 0
]
# Once a submitted PO exists, do not
# also show its old draft planning PO.
if submitted:
selected_purchase_order_items.extend(
submitted
)
else:
selected_purchase_order_items.extend(
drafts
)
if not selected_purchase_order_items:
return {}
submitted_purchase_order_items = [
row
for row in selected_purchase_order_items
if row.purchase_order_docstatus == 1
]
sco_by_purchase_order_item = {}
if submitted_purchase_order_items:
submitted_poi_names = [
row.purchase_order_item
for row in submitted_purchase_order_items
]
poi_placeholders = ", ".join(
["%s"]
* len(submitted_poi_names)
)
subcontracting_orders = frappe.db.sql(
f"""
SELECT
sco.name
AS subcontracting_order,
sco.purchase_order,
sco.supplier,
sco.supplier_name,
sco.schedule_date,
sco.status,
scoi.purchase_order_item,
scoi.qty,
scoi.received_qty,
sco.creation
FROM
`tabSubcontracting Order Item`
scoi
INNER JOIN
`tabSubcontracting Order`
sco
ON sco.name =
scoi.parent
WHERE
scoi.purchase_order_item
IN ({poi_placeholders})
AND sco.docstatus = 1
ORDER BY
sco.creation DESC
""",
tuple(
submitted_poi_names
),
as_dict=True,
)
for row in subcontracting_orders:
# Prefer newest submitted SCO.
if (
row.purchase_order_item
not in sco_by_purchase_order_item
):
sco_by_purchase_order_item[
row.purchase_order_item
] = row
result = {}
for poi in selected_purchase_order_items:
sales_order_item = (
poi.sales_order_item
)
result.setdefault(
sales_order_item,
[],
)
# -------------------------------------------------------------
# Draft Purchase Order
# -------------------------------------------------------------
if (
poi.purchase_order_docstatus
== 0
):
result[
sales_order_item
].append(
{
"source":
"purchase_order_draft",
"purchase_order":
poi.purchase_order,
"purchase_order_item":
poi.purchase_order_item,
"subcontracting_order":
None,
"supplier":
(
poi.supplier_name
or poi.supplier
),
"process":
(
poi.item_name
or poi.item_code
),
"qty":
flt(
poi.fg_item_qty
or poi.qty
),
"received_qty":
0,
"status":
"Draft",
"material_transferred":
False,
}
)
continue
# -------------------------------------------------------------
# Submitted Purchase Order
# -------------------------------------------------------------
sco = (
sco_by_purchase_order_item.get(
poi.purchase_order_item
)
)
# PO submitted but SCO not yet
# created/submitted.
if not sco:
result[
sales_order_item
].append(
{
"source":
"purchase_order",
"purchase_order":
poi.purchase_order,
"purchase_order_item":
poi.purchase_order_item,
"subcontracting_order":
None,
"supplier":
(
poi.supplier_name
or poi.supplier
),
"process":
(
poi.item_name
or poi.item_code
),
"qty":
flt(
poi.fg_item_qty
or poi.qty
),
"received_qty":
0,
"status":
"To Transfer",
"material_transferred":
False,
}
)
continue
# -------------------------------------------------------------
# Submitted Subcontracting Order
# -------------------------------------------------------------
material_transferred = (
has_material_been_transferred(
sco.status
)
)
result[
sales_order_item
].append(
{
"source":
"subcontracting_order",
"purchase_order":
poi.purchase_order,
"purchase_order_item":
poi.purchase_order_item,
"subcontracting_order":
sco.subcontracting_order,
"supplier":
(
sco.supplier_name
or sco.supplier
),
"process":
(
poi.item_name
or poi.item_code
),
"qty":
flt(
sco.qty
or poi.fg_item_qty
or poi.qty
),
"received_qty":
flt(
sco.received_qty
),
"status":
sco.status,
"material_transferred":
material_transferred,
}
)
return result
def has_material_been_transferred(
status,
):
# Partial Material Transferred deliberately
# does not count as complete handoff.
return status in {
"Material Transferred",
"Partially Received",
"Completed",
}
def get_effective_sort_date(
delivery_date,
planned_end_date,
subcontracting_rows,
):
# While subcontracting still requires our
# material, Planned End Date is the
# operational deadline.
if (
planned_end_date
and subcontracting_rows
):
all_material_transferred = all(
row.get(
"material_transferred",
False,
)
for row in subcontracting_rows
)
if not all_material_transferred:
return getdate(
planned_end_date
)
# Once material has left us, return the
# card to its customer-delivery position.
if delivery_date:
return getdate(
delivery_date
)
return None
def overview_sort_key(
prepared,
):
maximum_date = getdate(
"9999-12-31"
)
effective_date = prepared[
"effective_sort_date"
]
delivery_date = prepared[
"row"
].delivery_date
return (
(
getdate(effective_date)
if effective_date
else maximum_date
),
(
getdate(delivery_date)
if delivery_date
else maximum_date
),
prepared["row"].item_code
or "",
prepared["row"].sales_order_item
or "",
)