956 lines
20 KiB
Python
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 "",
|
|
) |