From eb90186d3f58d9adb7dba66ff3fbdc5e282458fe Mon Sep 17 00:00:00 2001 From: Mihir Kandoi Date: Sat, 1 Aug 2026 18:34:31 +0530 Subject: [PATCH 1/2] feat(job_card): print quantities with their stock uom (#57689) * feat(job_card): carry the stock uom on the job card Every quantity the job card reports belongs to the item it produces, but the document had no unit of its own, so messages could only print bare numbers. Add the Stock UOM field, set from the finished good or the final product, and backfill the job cards that already exist. * fix(job_card): print quantities with their unit A bare 5 in an error says nothing about what was counted. Every message that reports a quantity now names its unit, taking it from the job card's stock uom, from the previous operation's finished good when the message compares two operations, and from the item itself for a raw material transfer. The completion dialogs read the same unit off the job card. * refactor(job_card): move the stock uom next to the qty it measures * fix(job_card): keep the stock uom backfill atomic Drop the auto commit toggle so the backfill is a single transaction with no connection flag left behind when it raises, and select the job cards to fill with an explicit unset filter instead of a value list. (cherry picked from commit 07ac4d83ef097c83e18b246dac5196d6c7b0656b) # Conflicts: # erpnext/manufacturing/doctype/job_card/job_card.js # erpnext/manufacturing/doctype/job_card/job_card.json # erpnext/manufacturing/doctype/job_card/job_card.py # erpnext/manufacturing/doctype/job_card/test_job_card.py # erpnext/manufacturing/page/shop_floor/shop_floor.py # erpnext/patches.txt # erpnext/public/js/shop_floor/shop_floor.js --- .../doctype/job_card/job_card.js | 66 +- .../doctype/job_card/job_card.json | 14 +- .../doctype/job_card/job_card.py | 255 +++ .../doctype/job_card/test_job_card.py | 177 ++ .../page/shop_floor/shop_floor.py | 834 ++++++++ erpnext/patches.txt | 4 + .../v16_0/set_stock_uom_in_job_card.py | 36 + erpnext/public/js/shop_floor/shop_floor.js | 1758 +++++++++++++++++ 8 files changed, 3142 insertions(+), 2 deletions(-) create mode 100644 erpnext/manufacturing/page/shop_floor/shop_floor.py create mode 100644 erpnext/patches/v16_0/set_stock_uom_in_job_card.py create mode 100644 erpnext/public/js/shop_floor/shop_floor.js diff --git a/erpnext/manufacturing/doctype/job_card/job_card.js b/erpnext/manufacturing/doctype/job_card/job_card.js index 0a4026672cf..a4e4d58d253 100644 --- a/erpnext/manufacturing/doctype/job_card/job_card.js +++ b/erpnext/manufacturing/doctype/job_card/job_card.js @@ -67,7 +67,11 @@ frappe.ui.form.on("Job Card", { if (remaining_qty < frm.doc.pending_qty) { frm.doc.pending_qty = 0.0; refresh_field("pending_qty"); - frappe.throw(__("Pending Quantity cannot be greater than {0}", [remaining_qty])); + frappe.throw( + __("Pending Quantity cannot be greater than {0}", [ + get_qty_with_uom(remaining_qty, frm.doc.stock_uom), + ]) + ); } const process_loss_qty = flt(remaining_qty) - flt(frm.doc.pending_qty); @@ -261,8 +265,28 @@ frappe.ui.form.on("Job Card", { default: pending_qty, change() { const dialog = frm.job_completion_dialog; +<<<<<<< HEAD const remaining = dialog.get_value("for_quantity") - dialog.get_value("completed_qty"); if (remaining > 0 && remaining != dialog.get_value("pending_qty")) { +======= + const remaining = + dialog.get_value("for_quantity") - + dialog.get_value("completed_qty") - + dialog.get_value("process_loss_qty"); + + if (remaining < 0) { + const max_completed_qty = + flt(dialog.get_value("for_quantity")) - flt(dialog.get_value("process_loss_qty")); + dialog.set_value("completed_qty", max_completed_qty); + frappe.throw( + __("Completed Quantity cannot be greater than {0}", [ + get_qty_with_uom(max_completed_qty, frm.doc.stock_uom), + ]) + ); + } + + if (remaining != dialog.get_value("pending_qty")) { +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) dialog.set_value("pending_qty", remaining); } }, @@ -278,7 +302,25 @@ frappe.ui.form.on("Job Card", { dialog.get_value("for_quantity") - dialog.get_value("completed_qty") - dialog.get_value("pending_qty"); +<<<<<<< HEAD if (process_loss_qty >= 0 && process_loss_qty != dialog.get_value("process_loss_qty")) { +======= + + if (process_loss_qty < 0) { + dialog.set_value("pending_qty", 0); + frappe.throw( + __("Pending Quantity cannot be greater than {0}", [ + get_qty_with_uom( + flt(dialog.get_value("for_quantity")) - + flt(dialog.get_value("completed_qty")), + frm.doc.stock_uom + ), + ]) + ); + } + + if (process_loss_qty != dialog.get_value("process_loss_qty")) { +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) dialog.set_value("process_loss_qty", process_loss_qty); } }, @@ -293,7 +335,25 @@ frappe.ui.form.on("Job Card", { dialog.get_value("for_quantity") - dialog.get_value("completed_qty") - dialog.get_value("process_loss_qty"); +<<<<<<< HEAD if (remaining >= 0 && remaining != dialog.get_value("pending_qty")) { +======= + + if (remaining < 0) { + dialog.set_value("process_loss_qty", 0); + frappe.throw( + __("Process Loss Quantity cannot be greater than {0}", [ + get_qty_with_uom( + flt(dialog.get_value("for_quantity")) - + flt(dialog.get_value("completed_qty")), + frm.doc.stock_uom + ), + ]) + ); + } + + if (remaining != dialog.get_value("pending_qty")) { +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) dialog.set_value("pending_qty", remaining); } }, @@ -886,3 +946,7 @@ function get_last_completed_row(time_logs) { function get_last_row(time_logs) { return time_logs[time_logs.length - 1] || {}; } + +function get_qty_with_uom(qty, stock_uom) { + return stock_uom ? `${flt(qty)} ${stock_uom}` : flt(qty); +} diff --git a/erpnext/manufacturing/doctype/job_card/job_card.json b/erpnext/manufacturing/doctype/job_card/job_card.json index c215aee42d4..a6fb3790d89 100644 --- a/erpnext/manufacturing/doctype/job_card/job_card.json +++ b/erpnext/manufacturing/doctype/job_card/job_card.json @@ -13,10 +13,11 @@ "work_order", "column_break_uqjq", "production_item", + "bom_no", "column_break_qrpg", "for_quantity", "column_break_yecz", - "bom_no", + "stock_uom", "section_break_oisd", "company", "naming_series", @@ -164,6 +165,13 @@ "in_preview": 1, "label": "Qty To Manufacture" }, + { + "fieldname": "stock_uom", + "fieldtype": "Link", + "label": "Stock UOM", + "options": "UOM", + "read_only": 1 + }, { "fieldname": "wip_warehouse", "fieldtype": "Link", @@ -695,7 +703,11 @@ "grid_page_length": 50, "is_submittable": 1, "links": [], +<<<<<<< HEAD "modified": "2026-06-19 17:39:42.293242", +======= + "modified": "2026-08-01 14:22:19.926911", +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) "modified_by": "Administrator", "module": "Manufacturing", "name": "Job Card", diff --git a/erpnext/manufacturing/doctype/job_card/job_card.py b/erpnext/manufacturing/doctype/job_card/job_card.py index 3b4f8008f08..db7cab39c44 100644 --- a/erpnext/manufacturing/doctype/job_card/job_card.py +++ b/erpnext/manufacturing/doctype/job_card/job_card.py @@ -130,6 +130,7 @@ class JobCard(Document): "Cancelled", "Completed", ] + stock_uom: DF.Link | None sub_operations: DF.Table[JobCardOperation] target_warehouse: DF.Link | None time_logs: DF.Table[JobCardTimeLog] @@ -158,6 +159,7 @@ class JobCard(Document): def before_validate(self): self.set_wip_warehouse() + self.set_stock_uom() def validate(self): self.validate_time_logs() @@ -906,11 +908,21 @@ class JobCard(Document): qty_to_manufacture = bold(_("Qty to Manufacture")) frappe.throw( +<<<<<<< HEAD _("The {0} ({1}) must be equal to {2} ({3})").format( total_completed_qty_label, bold(flt(total_completed_qty, precision)), qty_to_manufacture, bold(self.for_quantity), +======= + _( + "Total Completed Qty ({0}), Process Loss Qty ({1}) and Pending Qty ({2}) must add up to the Qty to Manufacture ({3})." + ).format( + bold(self.get_qty_with_uom(self.total_completed_qty)), + bold(self.get_qty_with_uom(self.process_loss_qty)), + bold(self.get_qty_with_uom(self.pending_qty)), + bold(self.get_qty_with_uom(self.for_quantity)), +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) ) ) @@ -1184,6 +1196,51 @@ class JobCard(Document): self.set_status(update_status=True) +<<<<<<< HEAD +======= + def get_job_card_items_transferred_qty(self, ste_doc): + from frappe.query_builder.functions import Sum + + job_card_items = [x.get("job_card_item") for x in ste_doc.get("items") if x.get("job_card_item")] + if not job_card_items: + return {} + + se = frappe.qb.DocType("Stock Entry") + sed = frappe.qb.DocType("Stock Entry Detail") + + query = ( + frappe.qb.from_(sed) + .join(se) + .on(sed.parent == se.name) + .select(sed.job_card_item, Sum(sed.qty)) + .where( + (sed.job_card_item.isin(job_card_items)) + & (se.docstatus == 1) + & (se.purpose == "Material Transfer for Manufacture") + ) + .groupby(sed.job_card_item) + ) + + return frappe._dict(query.run(as_list=True)) + + def validate_over_transfer(self, ste_doc, row, transferred_qty): + "Block over transfer of items if not allowed in settings." + required_qty = frappe.db.get_value("Job Card Item", row.job_card_item, "required_qty") + if flt(transferred_qty) > flt(required_qty): + frappe.throw( + _( + "Row #{0}: Cannot transfer more than Required Qty {1} for Item {2} against Job Card {3}" + ).format( + row.idx, + frappe.bold(self.get_qty_with_uom(required_qty, row.item_code)), + frappe.bold(row.item_code), + ste_doc.job_card, + ), + title=_("Excess Transfer"), + exc=JobCardOverTransferError, + ) + +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) def set_transferred_qty(self, update_status=False): from frappe.query_builder.functions import Sum @@ -1280,10 +1337,66 @@ class JobCard(Document): if self.workstation: self.update_workstation_status() +<<<<<<< HEAD +======= + def get_qty_to_produce(self): + """Qty this job card is expected to produce, the pending qty is left to another job card.""" + return flt(self.for_quantity) - flt(self.pending_qty) + + def get_qty_with_uom(self, qty, item_code=None): + """A quantity in a message reads as a count of nothing without the unit it is measured in.""" + uom = self.stock_uom + if item_code: + uom = frappe.get_cached_value("Item", item_code, "stock_uom") + + return f"{flt(qty, self.precision('total_completed_qty'))} {uom or ''}".strip() + + def set_finished_good_status(self): + # Only reached for a submitted job card (docstatus == 1) with a finished good, see set_status(). + qty_to_produce = self.get_qty_to_produce() + + if (self.manufactured_qty + self.process_loss_qty) >= qty_to_produce: + self.status = "Completed" + elif (self.total_completed_qty + self.process_loss_qty) >= qty_to_produce: + # Production is done and the card is submitted, but the finished goods have not been + # booked into stock yet (Manufacture Stock Entry pending) — distinct from active WIP. + self.status = "To Manufacture" + elif self.transferred_qty > 0 or self.skip_material_transfer: + self.status = "Work In Progress" + + def set_non_semi_fg_status(self): + if self.items: + item_data = frappe.get_all( + "Job Card Item", + filters={"parent": self.name}, + fields=["transferred_qty", "required_qty"], + ) + all_transferred = item_data and all( + flt(d.transferred_qty) >= flt(d.required_qty) for d in item_data + ) + any_transferred = any(flt(d.transferred_qty) > 0 for d in item_data) + + if all_transferred: + self.status = "Material Transferred" + elif any_transferred: + self.status = "Partially Transferred" + elif flt(self.for_quantity) <= flt(self.transferred_qty): + self.status = "Material Transferred" + + if self.time_logs: + self.status = "Work In Progress" + + if self.docstatus == 1 and ( + self.get_qty_to_produce() <= (self.total_completed_qty + self.process_loss_qty) or not self.items + ): + self.status = "Completed" + +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) def set_wip_warehouse(self): if not self.wip_warehouse: self.wip_warehouse = frappe.get_cached_value("Company", self.company, "default_wip_warehouse") +<<<<<<< HEAD def validate_operation_id(self): if ( self.get("operation_id") @@ -1294,6 +1407,36 @@ class JobCard(Document): != self.operation_id ): work_order = bold(get_link_to_form("Work Order", self.work_order)) +======= + def set_stock_uom(self): + item_code = self.finished_good or self.production_item + if item_code: + self.stock_uom = frappe.get_cached_value("Item", item_code, "stock_uom") + + def set_operation_id(self): + if not (self.work_order and self.operation): + return + + if self.operation_id and self.docstatus != 0: + return + + operation_rows = frappe.get_all( + "Work Order Operation", + filters={"parent": self.work_order, "operation": self.operation}, + pluck="name", + ) + + if self.operation_id: + if operation_rows and self.operation_id not in operation_rows: + frappe.throw( + _("Operation {0} does not belong to the work order {1}").format( + bold(self.operation), get_link_to_form("Work Order", self.work_order) + ) + ) + elif len(operation_rows) == 1: + self.operation_id = operation_rows[0] + elif operation_rows and self.docstatus == 0: +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) frappe.throw( _("Operation {0} does not belong to the work order {1}").format( bold(self.operation), work_order @@ -1339,6 +1482,53 @@ class JobCard(Document): if not (self.work_order and self.sequence_id): return +<<<<<<< HEAD +======= + current_operation_qty = self.get_current_operation_completed_qty() + + for row in self.get_previous_operations(): + if self.track_semi_finished_goods: + self.validate_previous_operation_manufactured_qty(row, current_operation_qty) + else: + self.validate_previous_operation(row, current_operation_qty) + + def get_previous_operations(self): + previous_operations = frappe.get_all( + "Work Order Operation", + fields=["name", "operation", "status", "completed_qty", "sequence_id", "finished_good"], + filters={"docstatus": 1, "parent": self.work_order, "sequence_id": ("<", self.sequence_id)}, + order_by="sequence_id, idx", + ) + + if self.track_semi_finished_goods and previous_operations: + manufactured_qty = self.get_manufactured_qty_per_operation( + [row.name for row in previous_operations] + ) + + for row in previous_operations: + row.manufactured_qty = flt(manufactured_qty.get(row.name)) + + return previous_operations + + def get_manufactured_qty_per_operation(self, operation_ids): + job_card = frappe.qb.DocType("Job Card") + + data = ( + frappe.qb.from_(job_card) + .select(job_card.operation_id, Sum(job_card.manufactured_qty)) + .where( + (job_card.work_order == self.work_order) + & (job_card.docstatus == 1) + & (IfNull(job_card.is_corrective_job_card, 0) == 0) + & (job_card.operation_id.isin(operation_ids)) + ) + .groupby(job_card.operation_id) + ).run() + + return dict(data) + + def get_current_operation_completed_qty(self): +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) current_operation_qty = 0.0 data = self.get_current_operation_data() if data and len(data) > 0: @@ -1353,6 +1543,7 @@ class JobCard(Document): order_by="sequence_id, idx", ) +<<<<<<< HEAD message = "Job Card {}: As per the sequence of the operations in the work order {}".format( bold(self.name), bold(get_link_to_form("Work Order", self.work_order)) ) @@ -1364,6 +1555,17 @@ class JobCard(Document): message, bold(row.operation), bold(self.operation) ), OperationSequenceError, +======= + if row.completed_qty < current_operation_qty: + frappe.throw( + _( + "The completed quantity {0} of an operation {1} cannot be greater than the completed quantity {2} of a previous operation {3}." + ).format( + bold(self.get_qty_with_uom(current_operation_qty)), + bold(self.operation), + bold(self.get_qty_with_uom(row.completed_qty, row.finished_good)), + bold(row.operation), +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) ) if row.status != "Completed" and row.completed_qty < current_operation_qty: @@ -1374,6 +1576,7 @@ class JobCard(Document): OperationSequenceError, ) +<<<<<<< HEAD if row.completed_qty < current_operation_qty: frappe.throw( _( @@ -1385,6 +1588,33 @@ class JobCard(Document): bold(row.operation), ) ) +======= + if not manufactured_qty: + frappe.throw( + _( + "Job Card {0}: As per the sequence of the operations in the work order {1}, submit the manufacturing entry for the operation {2} before the operation {3}." + ).format( + bold(self.name), + bold(get_link_to_form("Work Order", self.work_order)), + bold(row.operation), + bold(self.operation), + ), + OperationSequenceError, + ) + + if manufactured_qty < current_operation_qty: + frappe.throw( + _( + "The completed quantity {0} of an operation {1} cannot be greater than the manufactured quantity {2} of a previous operation {3}. Submit the manufacturing entry for the operation {3} first." + ).format( + bold(self.get_qty_with_uom(current_operation_qty)), + bold(self.operation), + bold(self.get_qty_with_uom(manufactured_qty, row.finished_good)), + bold(row.operation), + ), + OperationSequenceError, + ) +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) def validate_work_order(self): if self.is_work_order_closed(): @@ -1536,6 +1766,31 @@ class JobCard(Document): self.pending_qty = flt(kwargs.pending_qty) self.process_loss_qty = flt(kwargs.process_loss_qty) +<<<<<<< HEAD +======= + def validate_completion_qty_split(self, kwargs): + if not flt(kwargs.for_quantity): + return + + precision = self.precision("total_completed_qty") + accounted_qty = flt(kwargs.qty) + flt(kwargs.pending_qty) + flt(kwargs.process_loss_qty) + + if flt(accounted_qty, precision) == flt(kwargs.for_quantity, precision): + return + + frappe.throw( + _( + "Completed Quantity ({0}), Pending Quantity ({1}) and Process Loss Quantity ({2}) must add up to the Qty to Manufacture ({3})." + ).format( + bold(self.get_qty_with_uom(kwargs.qty)), + bold(self.get_qty_with_uom(kwargs.pending_qty)), + bold(self.get_qty_with_uom(kwargs.process_loss_qty)), + bold(self.get_qty_with_uom(kwargs.for_quantity)), + ) + ) + + def add_completion_time_logs(self, kwargs): +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) if kwargs.end_time: self.add_time_logs( to_time=kwargs.end_time, diff --git a/erpnext/manufacturing/doctype/job_card/test_job_card.py b/erpnext/manufacturing/doctype/job_card/test_job_card.py index 826d558e830..f07ae2ea2b1 100644 --- a/erpnext/manufacturing/doctype/job_card/test_job_card.py +++ b/erpnext/manufacturing/doctype/job_card/test_job_card.py @@ -888,6 +888,85 @@ class TestJobCard(ERPNextTestSuite): self.assertEqual(wo_doc.process_loss_qty, 2) self.assertEqual(wo_doc.status, "Completed") +<<<<<<< HEAD +======= + def get_first_job_card(self, work_order): + return frappe.get_doc( + "Job Card", + frappe.get_all( + "Job Card", + filters={"work_order": work_order}, + order_by="sequence_id, creation", + limit=1, + pluck="name", + )[0], + ) + + def test_stock_uom_is_set_from_the_produced_item(self): + work_order = make_wo_order_test_record(item="_Test FG Item 2", qty=5) + + job_card = self.get_first_job_card(work_order.name) + item_code = job_card.finished_good or job_card.production_item + + self.assertEqual(job_card.stock_uom, frappe.db.get_value("Item", item_code, "stock_uom")) + + def test_completion_qty_reduces_for_quantity_without_process_loss(self): + work_order = make_wo_order_test_record(item="_Test FG Item 2", qty=5) + + job_card = self.get_first_job_card(work_order.name) + job_card.append("time_logs", {"from_time": "2024-03-01 08:00:00"}) + job_card.save() + + job_card.complete_job_card( + qty=3, + for_quantity=3, + pending_qty=0, + process_loss_qty=0, + end_time="2024-03-01 09:00:00", + ) + + job_card.reload() + self.assertEqual(flt(job_card.for_quantity), 3) + self.assertEqual(flt(job_card.total_completed_qty), 3) + self.assertEqual(flt(job_card.process_loss_qty), 0) + + def test_completion_qty_keeps_for_quantity_across_cycles(self): + work_order = make_wo_order_test_record(item="_Test FG Item 2", qty=5) + + job_card = self.get_first_job_card(work_order.name) + job_card.append("time_logs", {"from_time": "2024-03-02 08:00:00"}) + job_card.save() + + job_card.complete_job_card( + qty=3, + for_quantity=5, + pending_qty=2, + process_loss_qty=0, + end_time="2024-03-02 09:00:00", + ) + + job_card.reload() + self.assertEqual(flt(job_card.for_quantity), 5) + self.assertEqual(flt(job_card.pending_qty), 2) + self.assertEqual(flt(job_card.process_loss_qty), 0) + + job_card.append("time_logs", {"from_time": "2024-03-02 10:00:00"}) + job_card.save() + + job_card.complete_job_card( + qty=2, + for_quantity=2, + pending_qty=0, + process_loss_qty=0, + end_time="2024-03-02 11:00:00", + ) + + job_card.reload() + self.assertEqual(flt(job_card.for_quantity), 5) + self.assertEqual(flt(job_card.total_completed_qty), 5) + self.assertEqual(flt(job_card.process_loss_qty), 0) + +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) def test_op_cost_calculation(self): from erpnext.manufacturing.doctype.routing.test_routing import ( create_routing, @@ -1879,3 +1958,101 @@ def create_semi_fg_bom(semi_fg_item, raw_item, inspection_required): bom.append("items", {"item_code": raw_item, "qty": 1}) bom.submit() return bom.name +<<<<<<< HEAD +======= + + +class TestJobCardLogic(ERPNextTestSuite): + """Field-level validations and pure quantity/capacity helpers, exercised on the + document directly so they don't need a Work Order / BOM (the integration suite does).""" + + def test_processing_a_submitted_or_cancelled_card_is_blocked(self): + submitted = frappe.new_doc("Job Card") + submitted.docstatus = 1 + self.assertRaises(frappe.ValidationError, submitted.validate_docstatus) + + cancelled = frappe.new_doc("Job Card") + cancelled.docstatus = 2 + self.assertRaises(frappe.ValidationError, cancelled.validate_docstatus) + + def test_complete_job_card_qty_guards(self): + jc = frappe.new_doc("Job Card") + jc.for_quantity = 5 + jc.validate_complete_job_card_qty(frappe._dict(pending_qty=3)) # within range -> passes + self.assertRaises( + frappe.ValidationError, jc.validate_complete_job_card_qty, frappe._dict(pending_qty=-1) + ) + self.assertRaises( + frappe.ValidationError, jc.validate_complete_job_card_qty, frappe._dict(process_loss_qty=-1) + ) + self.assertRaises( + frappe.ValidationError, jc.validate_complete_job_card_qty, frappe._dict(pending_qty=10) + ) + + def test_qty_in_messages_carries_the_uom(self): + jc = frappe.new_doc("Job Card") + jc.stock_uom = "Nos" + + self.assertEqual(jc.get_qty_with_uom(5), "5.0 Nos") + self.assertEqual(jc.get_qty_with_uom(0), "0.0 Nos") + + def test_completion_qty_split_must_add_up(self): + jc = frappe.new_doc("Job Card") + jc.for_quantity = 5 + + # 3 completed + 2 pending + 0 lost == 5 to manufacture -> passes + jc.validate_complete_job_card_qty( + frappe._dict(for_quantity=5, qty=3, pending_qty=2, process_loss_qty=0) + ) + + self.assertRaises( + frappe.ValidationError, + jc.validate_complete_job_card_qty, + frappe._dict(for_quantity=3, qty=3, pending_qty=2, process_loss_qty=0), + ) + + def test_completed_qty_must_reconcile_with_for_quantity(self): + jc = frappe.new_doc("Job Card") + jc.for_quantity = 10 + jc.total_completed_qty = 6 + jc.process_loss_qty = 0 + jc.pending_qty = 0 + # 6 + 0 + 0 != 10 -> throws + self.assertRaises(frappe.ValidationError, jc.validate_completed_qty_matches_for_quantity) + # completed + loss + pending == for_quantity -> passes + jc.pending_qty = 4 + jc.validate_completed_qty_matches_for_quantity() + + def test_set_process_loss(self): + jc = frappe.new_doc("Job Card") + jc.for_quantity = 10 + jc.total_completed_qty = 6 + jc.pending_qty = 1 + jc.set_process_loss() + self.assertEqual(jc.process_loss_qty, 3) # 10 - 6 - 1 + + # no loss when nothing completed yet + nothing_done = frappe.new_doc("Job Card") + nothing_done.for_quantity = 10 + nothing_done.total_completed_qty = 0 + nothing_done.set_process_loss() + self.assertEqual(nothing_done.process_loss_qty, 0) + + def test_capacity_overlap_detection(self): + jc = frappe.new_doc("Job Card") + sequential = [ + {"from_time": "2026-01-01 10:00:00", "to_time": "2026-01-01 11:00:00"}, + {"from_time": "2026-01-01 11:00:00", "to_time": "2026-01-01 12:00:00"}, + ] + overlapping = [ + {"from_time": "2026-01-01 10:00:00", "to_time": "2026-01-01 11:00:00"}, + {"from_time": "2026-01-01 10:30:00", "to_time": "2026-01-01 11:30:00"}, + ] + # sequential logs share one capacity slot; overlapping logs need two + self.assertEqual(len(jc.get_alloted_capacity(sequential)), 1) + self.assertEqual(len(jc.get_alloted_capacity(overlapping)), 2) + # capacity 1 overlaps with any log; capacity 2 only when both slots are taken + self.assertTrue(jc.has_overlap(1, sequential)) + self.assertFalse(jc.has_overlap(2, sequential)) + self.assertTrue(jc.has_overlap(2, overlapping)) +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) diff --git a/erpnext/manufacturing/page/shop_floor/shop_floor.py b/erpnext/manufacturing/page/shop_floor/shop_floor.py new file mode 100644 index 00000000000..0ef5b99613e --- /dev/null +++ b/erpnext/manufacturing/page/shop_floor/shop_floor.py @@ -0,0 +1,834 @@ +import frappe +from frappe import _ +from frappe.query_builder import Order +from frappe.query_builder.functions import Count, Date +from frappe.utils import cint, flt, get_datetime, getdate, now_datetime, time_diff_in_seconds +from pypika.terms import ExistsCriterion + +from erpnext.manufacturing.doctype.workstation.workstation import ( + get_status_color, + get_time_logs, +) +from erpnext.stock.doctype.quality_inspection_template.quality_inspection_template import ( + get_template_details, +) + +JOB_CARD_FIELDS = [ + "name", + "docstatus", + "production_item", + "work_order", + "operation", + "total_completed_qty", + "for_quantity", + "process_loss_qty", + "stock_uom", + "finished_good", + "transferred_qty", + "status", + "expected_start_date", + "expected_end_date", + "time_required", + "wip_warehouse", + "skip_material_transfer", + "backflush_from_wip_warehouse", + "is_paused", + "manufactured_qty", + "is_subcontracted", + "workstation", + "sequence_id", + "bom_no", + "operation_id", + "quality_inspection", + "quality_inspection_template", +] + +TODAY_SESSION_FIELDS = [ + "name", + "docstatus", + "production_item", + "finished_good", + "operation", + "total_completed_qty", + "for_quantity", + "process_loss_qty", + "total_time_in_mins", + "status", + "modified", +] + +# Roles that unlock the Shop Floor manager board (work-order overview). Anyone else gets the +# operator view. System Manager is included so admins always see the full picture. +MANAGER_ROLES = {"Shop Floor Manager", "Manufacturing Manager", "System Manager"} + +# Maps the manager buckets to the underlying Work Order statuses. "open" spans pending AND +# in-progress: starting a job card flips the Work Order to In Process, and separate tabs made +# it jump tabs on the next refresh — the operator would lose the card they were working on. +WORK_ORDER_STATUS_GROUPS = { + "open": ["In Process", "Not Started", "Submitted", "Stock Reserved", "Stock Partially Reserved"], + "completed": ["Completed"], +} + +WORK_ORDER_FIELDS = [ + "name", + "production_item", + "item_name", + "qty", + "produced_qty", + "status", + "planned_start_date", + "sales_order", + "bom_no", +] + + +@frappe.whitelist() +def submit_job_card(job_card: str): + """Submit a draft job card whose quantity has already been recorded via End Session.""" + frappe.has_permission("Job Card", "submit", throw=True) + jc = frappe.get_doc("Job Card", job_card) + if jc.docstatus == 0: + jc.submit() + return {"name": jc.name, "docstatus": jc.docstatus} + + +def _record_session(job_card, qty, for_quantity, pending_qty, process_loss_qty, end_time): + """Record the session qty + close the active time log via Job Card's complete_job_card. + + auto_submit=0 so the backend doesn't auto-create+submit a Manufacture Stock Entry — that's + a separate manual step driven by the post-submit prompt. Returns the reloaded doc. + """ + frappe.has_permission("Job Card", "write", throw=True) + + doc = frappe.get_doc("Job Card", job_card) + doc.run_method( + "complete_job_card", + qty=flt(qty), + for_quantity=flt(for_quantity), + pending_qty=flt(pending_qty), + process_loss_qty=flt(process_loss_qty), + end_time=end_time, + auto_submit=0, + ) + doc.reload() + return doc + + +@frappe.whitelist() +def save_and_continue( + job_card: str, + qty: float, + for_quantity: float, + pending_qty: float, + process_loss_qty: float, + end_time: str, +): + """Record the session qty + close the time log, then mark the JC as paused + so the MES keeps it in the active slot for the next session.""" + frappe.has_permission("Job Card", "write", throw=True) + doc = _record_session(job_card, qty, for_quantity, pending_qty, process_loss_qty, end_time) + if doc.docstatus == 0: + doc.db_set("is_paused", 1) + return {"name": doc.name} + + +@frappe.whitelist() +def complete_and_submit( + job_card: str, + qty: float, + for_quantity: float, + pending_qty: float, + process_loss_qty: float, + end_time: str, +): + """Record the session qty + close the time log + submit the JC.""" + frappe.has_permission("Job Card", "submit", throw=True) + doc = _record_session(job_card, qty, for_quantity, pending_qty, process_loss_qty, end_time) + if doc.docstatus == 0: + doc.submit() + return {"name": doc.name, "finished_good": doc.finished_good} + + +@frappe.whitelist() +def make_manufacture_stock_entry(job_card: str): + """Build a "Manufacture" Stock Entry for the finished goods and save as draft. + + Mirrors the Job Card form's "Make Stock Entry" button — uses the doc's own + make_stock_entry_for_semi_fg_item (purpose="Manufacture", job card linked) rather than + the generic make_stock_entry, which would produce a "Material Transfer for Manufacture". + Returns the draft SE name so the client can open it in a new tab. + """ + frappe.has_permission("Job Card", "read", throw=True) + frappe.has_permission("Stock Entry", "submit", throw=True) + doc = frappe.get_doc("Job Card", job_card) + se = doc.make_stock_entry_for_semi_fg_item(auto_submit=False) + return {"name": se.get("name")} + + +@frappe.whitelist() +def get_quality_inspection_checklist(job_card: str): + """Template parameters for the inline quality check an operator fills before submitting a + job card. Returns the resolved template, its parameter rows, any already-linked inspection, + and the item being inspected. + """ + frappe.has_permission("Job Card", "read", throw=True) + + jc = frappe.db.get_value( + "Job Card", + job_card, + [ + "quality_inspection", + "quality_inspection_template", + "operation", + "production_item", + "finished_good", + ], + as_dict=True, + ) + if not jc: + frappe.throw(_("Job Card {0} not found").format(job_card)) + + template = jc.quality_inspection_template + if not template and jc.operation: + template = frappe.get_cached_value("Operation", jc.operation, "quality_inspection_template") + + parameters = [] + for p in get_template_details(template): + parameters.append( + { + "specification": p.specification, + "value": p.value, + "numeric": cint(p.numeric), + "min_value": p.min_value, + "max_value": p.max_value, + "formula_based_criteria": cint(p.formula_based_criteria), + "acceptance_formula": p.acceptance_formula, + } + ) + + return { + "template": template, + "parameters": parameters, + "existing": jc.quality_inspection, + "item_code": jc.finished_good or jc.production_item, + } + + +@frappe.whitelist() +def submit_quality_inspection(job_card: str, readings: str | None = None): + """Create + submit an In-Process Quality Inspection for the job card and link it back, so the + standard Job Card.validate_inspection() gate passes when the card is submitted. + + `readings` is a JSON list of {specification, status, reading_value} captured inline. For numeric + / formula parameters the measured value is stored and the Quality Inspection auto-evaluates + pass/fail against min/max (or the formula); for qualitative parameters the operator's explicit + Accepted/Rejected is taken as authoritative (manual_inspection). The QI's own validation then + sets the overall Accepted/Rejected status. + """ + frappe.has_permission("Job Card", "write", throw=True) + frappe.has_permission("Quality Inspection", "submit", throw=True) + + jc = frappe.get_doc("Job Card", job_card) + + # Idempotent: if a submitted inspection is already linked, don't create another. + if jc.quality_inspection: + existing = frappe.db.get_value( + "Quality Inspection", jc.quality_inspection, ["status", "docstatus"], as_dict=True + ) + if existing and existing.docstatus == 1: + return {"name": jc.quality_inspection, "status": existing.status} + + template = jc.quality_inspection_template + if not template and jc.operation: + template = frappe.get_cached_value("Operation", jc.operation, "quality_inspection_template") + if not template: + frappe.throw(_("No Quality Inspection Template is configured for this operation.")) + + reading_map = {r.get("specification"): r for r in (frappe.parse_json(readings) or [])} + + qi = frappe.new_doc("Quality Inspection") + qi.inspection_type = "In Process" + qi.reference_type = "Job Card" + qi.reference_name = job_card + qi.item_code = jc.finished_good or jc.production_item + qi.bom_no = jc.bom_no + qi.quality_inspection_template = template + qi.inspected_by = frappe.session.user + qi.get_item_specification_details() # load readings from the template + + for reading in qi.readings: + entry = reading_map.get(reading.specification) + if not entry: + continue + value = entry.get("reading_value") + if reading.numeric or reading.formula_based_criteria: + # Measured value → let the Quality Inspection judge it against min/max or the formula. + if value not in (None, ""): + reading.reading_value = value + reading.reading_1 = value + else: + # Qualitative check → the operator's explicit pass/fail wins. + reading.manual_inspection = 1 + reading.status = entry.get("status") or "Accepted" + if value not in (None, ""): + reading.reading_value = value + + qi.insert() + qi.submit() # validate() → inspect_and_set_status() sets the overall Accepted/Rejected status + + # Link explicitly: the QI's own back-reference matches on production_item, which can differ + # from the operation's finished_good, so we set it directly to be safe. + jc.db_set("quality_inspection", qi.name) + return {"name": qi.name, "status": qi.status} + + +@frappe.whitelist() +def get_shop_floor_context(): + """Which experience to render — the manager board or the operator view — plus the + signed-in operator's Employee (so Start Job can pre-fill them).""" + roles = set(frappe.get_roles()) + can_manage = bool(roles & MANAGER_ROLES) + return { + "role_view": "manager" if can_manage else "operator", + "can_manage": can_manage, + "user_employee": frappe.db.get_value("Employee", {"user_id": frappe.session.user}, "name"), + } + + +@frappe.whitelist() +def get_work_orders( + status_group: str, + start: int = 0, + page_length: int = 20, + search: str | None = None, + with_job_cards_only: bool | int = 0, +): + """Paginated Work Orders for one manager bucket (open / completed), + each decorated with a job-card status breakdown for the card's progress chip. + + When `with_job_cards_only` is set, only Work Orders that have at least one (non-cancelled) + Job Card are returned — the board's opt-in "With job cards only" toggle. + """ + frappe.has_permission("Work Order", "read", throw=True) + + if status_group not in WORK_ORDER_STATUS_GROUPS: + frappe.throw(_("Invalid status group: {0}").format(status_group)) + + start = cint(start) + page_length = cint(page_length) or 20 + with_job_cards_only = cint(with_job_cards_only) + + # Active buckets show the oldest-planned first (work the floor next); completed shows newest first. + order = Order.desc if status_group == "completed" else Order.asc + + wo = frappe.qb.DocType("Work Order") + query = _apply_work_order_filters(frappe.qb.from_(wo), wo, status_group, search, with_job_cards_only) + work_orders = ( + query.select(*[wo[field] for field in WORK_ORDER_FIELDS]) + .orderby(wo.planned_start_date, order=order) + .limit(page_length) + .offset(start) + ).run(as_dict=True) + + total = _count_work_orders(status_group, search, with_job_cards_only) + + _enrich_work_orders(work_orders) + + return { + "work_orders": work_orders, + "total": cint(total), + "start": start, + "page_length": page_length, + } + + +def _has_job_cards_criterion(wo, docstatus): + jc = frappe.qb.DocType("Job Card") + return ExistsCriterion( + frappe.qb.from_(jc).select(jc.name).where((jc.work_order == wo.name) & (jc.docstatus == docstatus)) + ) + + +def _bucket_criterion(wo, status_group): + """The floor is done with a Work Order once every job card is submitted, even though the + Work Order stays "In Process" until the finished goods are received. Such operationally + complete orders belong on the Completed tab — not stranded under Pending / In Progress.""" + open_statuses = WORK_ORDER_STATUS_GROUPS["open"] + all_job_cards_done = _has_job_cards_criterion(wo, 1) & _has_job_cards_criterion(wo, 0).negate() + if status_group == "completed": + return (wo.status == "Completed") | (wo.status.isin(open_statuses) & all_job_cards_done) + return wo.status.isin(open_statuses) & ( + _has_job_cards_criterion(wo, 1).negate() | _has_job_cards_criterion(wo, 0) + ) + + +def _apply_work_order_filters(query, wo, status_group, search, with_job_cards_only): + """Shared WHERE clauses for the board's row + count queries (bucket, search, job-card toggle).""" + query = query.where((wo.docstatus == 1) & _bucket_criterion(wo, status_group)) + if search: + like = f"%{search}%" + query = query.where(wo.name.like(like) | wo.production_item.like(like) | wo.item_name.like(like)) + if with_job_cards_only: + jc = frappe.qb.DocType("Job Card") + wo_with_job_cards = frappe.qb.from_(jc).select(jc.work_order).where(jc.docstatus < 2) + query = query.where(wo.name.isin(wo_with_job_cards)) + return query + + +def _count_work_orders(status_group: str, search: str | None, with_job_cards_only: int = 0) -> int: + """Total Work Orders in a bucket (drives pagination), honouring the same filters as the rows.""" + wo = frappe.qb.DocType("Work Order") + query = _apply_work_order_filters(frappe.qb.from_(wo), wo, status_group, search, with_job_cards_only) + return cint(query.select(Count("*")).run()[0][0]) + + +def _enrich_work_orders(work_orders: list[dict]) -> None: + """Attach item/workstation image, status colour, % complete and a job-card breakdown to each row.""" + wo_names = [row.name for row in work_orders] + jc_counts = _get_job_card_status_counts(wo_names) + workstation_map = _get_current_workstation_map(wo_names) + for row in work_orders: + row.item_image = ( + frappe.get_cached_value("Item", row.production_item, "image") if row.production_item else None + ) + row.status_colour = get_status_color(row.status) + row.per_completed = round(flt(row.produced_qty) / flt(row.qty) * 100, 1) if flt(row.qty) else 0 + counts = jc_counts.get(row.name, {}) + row.job_card_status = counts.get("by_status", {}) + row.total_operations = counts.get("total", 0) + row.completed_operations = counts.get("completed", 0) + row.in_progress_operations = counts.get("in_progress", 0) + # Two segments for the card's progress bar: green (done) + orange (in progress); the rest + # of the track stays grey (pending / not started). + row.per_operations = ( + round(row.completed_operations / row.total_operations * 100, 1) if row.total_operations else 0 + ) + row.per_in_progress = ( + round(row.in_progress_operations / row.total_operations * 100, 1) if row.total_operations else 0 + ) + # Current/active operation's workstation (name + Active-Status image) for the card header. + workstation = workstation_map.get(row.name, {}) + row.workstation = workstation.get("workstation") + row.workstation_name = workstation.get("workstation_name") + row.workstation_image = workstation.get("image") + row.current_operation = workstation.get("operation") + + +def _get_current_workstation_map(wo_names: list[str]) -> dict[str, dict]: + """Map each Work Order to its current operation's workstation (name + Active-Status image). + + The "current" operation is the first not-yet-completed operation in the routing (by idx); + if every operation is complete, the last one is used so finished cards still show a workstation. + """ + if not wo_names: + return {} + + operations = frappe.get_all( + "Work Order Operation", + filters={"parent": ["in", wo_names]}, + fields=["parent", "idx", "operation", "status", "workstation"], + order_by="parent, idx", + ) + + ops_by_wo: dict[str, list] = {} + for op in operations: + ops_by_wo.setdefault(op.parent, []).append(op) + + chosen_by_wo = {} + workstations = set() + for wo_name, ops in ops_by_wo.items(): + current = next((op for op in ops if (op.status or "") != "Completed"), ops[-1]) + if current.workstation: + chosen_by_wo[wo_name] = current + workstations.add(current.workstation) + + ws_details = {} + if workstations: + for ws in frappe.get_all( + "Workstation", + filters={"name": ["in", list(workstations)]}, + fields=["name", "workstation_name", "on_status_image"], + ): + ws_details[ws.name] = ws + + result = {} + for wo_name, op in chosen_by_wo.items(): + detail = ws_details.get(op.workstation, {}) + result[wo_name] = { + "workstation": op.workstation, + "workstation_name": detail.get("workstation_name") or op.workstation, + "image": detail.get("on_status_image"), + "operation": op.operation, + } + return result + + +def _get_job_card_status_counts(wo_names: list[str]) -> dict[str, dict]: + """One batched query → {work_order: {by_status: {status: n}, total, completed}} for the WO cards.""" + if not wo_names: + return {} + + rows = frappe.get_all( + "Job Card", + filters={"work_order": ["in", wo_names], "docstatus": ["<", 2]}, + fields=["work_order", "status"], + ) + result: dict[str, dict] = {} + for row in rows: + entry = result.setdefault( + row.work_order, {"by_status": {}, "total": 0, "completed": 0, "in_progress": 0} + ) + status = "Not Started" if (row.status or "Open") == "Open" else row.status + entry["by_status"][status] = entry["by_status"].get(status, 0) + 1 + entry["total"] += 1 + # "To Manufacture" = operation done, only the Manufacture Stock Entry is pending — count it + # as completed so the work order's progress bar reflects the finished operation. + if status in ("Completed", "Submitted", "To Manufacture"): + entry["completed"] += 1 + elif status == "Work In Progress": + entry["in_progress"] += 1 + return result + + +@frappe.whitelist() +def get_data(workstation: str | None = None, work_order: str | None = None): + """ + Returns job-card data for the Shop Floor page. + + When `work_order` is set it wins over `workstation` and the result spans every + operation of that Work Order (including subcontracted job cards). When only + `workstation` is set, the result is the open + in-progress job cards for that + workstation, excluding subcontracted. + """ + if not (workstation or work_order): + return {"job_cards": [], "capacity": 1, "mode": None} + if not frappe.has_permission("Job Card", "read"): + return {"job_cards": [], "capacity": 1, "mode": None} + + filters, mode = _build_job_card_filters(workstation, work_order) + jc_data = _fetch_job_cards(filters, mode) + _enrich_job_cards(jc_data) + + capacity, oee = 1, None + if mode == "workstation": + capacity = frappe.db.get_value("Workstation", workstation, "production_capacity") or 1 + oee = get_workstation_oee(workstation) + + return { + "job_cards": jc_data, + "capacity": capacity, + "mode": mode, + "oee": oee, + "user_employee": frappe.db.get_value("Employee", {"user_id": frappe.session.user}, "name"), + "today_sessions": get_today_sessions(workstation, work_order), + } + + +def _build_job_card_filters(workstation, work_order): + """Filters + mode for the job-card query. work_order spans all ops; workstation is operator view.""" + filters = {"docstatus": ("<", 2)} + if work_order: + filters["work_order"] = work_order + return filters, "work_order" + + filters["workstation"] = workstation + filters["is_subcontracted"] = 0 + filters["status"] = ["!=", "Stopped"] + return filters, "workstation" + + +def _fetch_job_cards(filters, mode): + """Job cards matching filters. In workstation mode only drafts matter — submitted JCs are + done from MES's perspective and missed ones are picked up via the standard Job Card list. + + In work_order mode the whole routing is shown (incl. completed/submitted job cards), ordered + by the operation sequence so the operator reads them in manufacturing order. + """ + order_by = ( + "sequence_id asc, expected_start_date, expected_end_date" + if mode == "work_order" + else "expected_start_date, expected_end_date" + ) + # Drafts are the operator's working set; submitted "To Manufacture" cards are also kept so + # the station shows what still needs a Manufacture Stock Entry (its own section, client-side). + # This must be part of the query, not a post-filter: a busy workstation's history would + # otherwise fill the row limit with old submitted cards and hide the active drafts. + or_filters = [["docstatus", "=", 0], ["status", "=", "To Manufacture"]] if mode == "workstation" else None + return frappe.get_all( + "Job Card", + fields=JOB_CARD_FIELDS, + filters=filters, + or_filters=or_filters, + order_by=order_by, + limit=50, + ) + + +def _enrich_job_cards(jc_data): + """Decorate every row with display + material-availability data for the page.""" + job_card_names = [row.name for row in jc_data] + time_logs = get_time_logs(job_card_names) if job_card_names else {} + allow_excess_transfer = frappe.db.get_single_value("Manufacturing Settings", "job_card_excess_transfer") + for row in jc_data: + _enrich_job_card_row(row, time_logs, allow_excess_transfer) + + +def _enrich_job_card_row(row, time_logs, allow_excess_transfer): + """Attach status label, item image/uom, time logs and material availability to one row.""" + if row.status == "Open": + row.status = "Not Started" + + item_code = row.finished_good or row.production_item + row.fg_uom = frappe.get_cached_value("Item", item_code, "stock_uom") if item_code else None + row.item_image = frappe.get_cached_value("Item", item_code, "image") if item_code else None + row.status_colour = get_status_color(row.status) + row.time_logs = time_logs.get(row.name, []) + row.make_material_request = bool(row.for_quantity > row.transferred_qty or allow_excess_transfer) + # Required vs transferred + on-hand in source — operator sees shortages before starting work. + row.materials = get_job_card_materials(row.name) + # Guided execution: per-operation work instructions + quality-check state for the card. + row.instructions = _get_operation_instructions(row.operation) + row.qc = _get_job_card_qc(row) + + +def _get_operation_instructions(operation: str | None) -> dict | None: + """Description + rich Work Instructions from the Operation master, for the card's + Instructions panel. Returns None when the operation has neither, so the panel stays hidden. + + `work_instruction` is a Text Editor field (HTML) — Frappe bleach-sanitizes it on save, so it + is safe to render as-is on the client. `description` is plain text and must be escaped there. + """ + if not operation: + return None + + op = frappe.get_cached_value("Operation", operation, ["description", "work_instruction"], as_dict=True) + if not op: + return None + + description = (op.description or "").strip() + work_instruction = (op.work_instruction or "").strip() + if not description and not work_instruction: + return None + return {"description": description, "work_instruction": work_instruction} + + +def _get_job_card_qc(row) -> dict: + """Quality-check state for a job card row: whether an inspection is required before submit, + which template to use, and any inspection already linked (name + status + docstatus). + + "Required" mirrors Job Card.validate_inspection() — BOM inspection_required AND the Work Order + Operation's quality_inspection_required. When only a template is configured the check is + offered but not enforced. + """ + required = bool( + row.get("bom_no") + and frappe.get_cached_value("BOM", row.bom_no, "inspection_required") + and row.get("operation_id") + and frappe.db.get_value("Work Order Operation", row.operation_id, "quality_inspection_required") + ) + + template = row.get("quality_inspection_template") + if not template and row.get("operation"): + template = frappe.get_cached_value("Operation", row.operation, "quality_inspection_template") + + info = { + "required": required, + "template": template, + "has_checklist": bool(template), + "name": None, + "status": None, + "docstatus": None, + } + if row.get("quality_inspection"): + qi = frappe.db.get_value( + "Quality Inspection", row.quality_inspection, ["name", "status", "docstatus"], as_dict=True + ) + if qi: + info.update({"name": qi.name, "status": qi.status, "docstatus": qi.docstatus}) + return info + + +def get_job_card_materials(job_card: str) -> list[dict]: + """Required vs transferred + on-hand stock for each raw material in the source warehouse. + + Powers the active-job Materials side panel — operator sees shortages before starting work. + """ + items = frappe.get_all( + "Job Card Item", + filters={"parent": job_card}, + fields=["item_code", "item_name", "source_warehouse", "required_qty", "transferred_qty", "uom"], + order_by="idx", + ) + if not items: + return [] + + on_hand_map = _get_on_hand_map(items) + return [_build_material_row(it, on_hand_map) for it in items] + + +def _get_on_hand_map(items) -> dict[tuple[str, str], float]: + """Map (item_code, warehouse) → on-hand qty via batched Bin lookups.""" + pairs = {(it.item_code, it.source_warehouse) for it in items if it.source_warehouse} + if not pairs: + return {} + + bin_rows = frappe.get_all( + "Bin", + filters={ + "item_code": ["in", list({p[0] for p in pairs})], + "warehouse": ["in", list({p[1] for p in pairs})], + }, + fields=["item_code", "warehouse", "actual_qty"], + ) + return {(b.item_code, b.warehouse): flt(b.actual_qty) for b in bin_rows} + + +def _build_material_row(it, on_hand_map) -> dict: + """One material entry with shortage + status pill for the side panel.""" + required = flt(it.required_qty) + transferred = flt(it.transferred_qty) + on_hand = on_hand_map.get((it.item_code, it.source_warehouse), 0.0) + shortage = max(required - transferred, 0.0) + if transferred >= required: + status = "ready" + elif on_hand >= shortage: + status = "available" + else: + status = "short" + return { + "item_code": it.item_code, + "item_name": it.item_name or it.item_code, + "source_warehouse": it.source_warehouse, + "required_qty": required, + "transferred_qty": transferred, + "on_hand_qty": on_hand, + "shortage": shortage, + "uom": it.uom or "", + "status": status, + } + + +def get_today_sessions(workstation: str | None, work_order: str | None) -> list[dict]: + """Submitted job cards finalized today — used for the bottom 'Today's Sessions' strip. + + Filtered on docstatus=1 only (draft/cancelled excluded). The status pill follows the + job card's own status (e.g. Work In Progress → orange, Completed → green). + """ + filters = _today_sessions_filters(workstation, work_order) + if filters is None: + return [] + + rows = frappe.get_all( + "Job Card", + filters=filters, + fields=TODAY_SESSION_FIELDS, + order_by="modified desc", + limit=10, + ) + for r in rows: + item_code = r.finished_good or r.production_item + r.item_image = frappe.get_cached_value("Item", item_code, "image") if item_code else None + r.status_colour = get_status_color(r.status) + return rows + + +def _today_sessions_filters(workstation, work_order) -> dict | None: + """Submitted-today filter scoped to a work order or workstation; None if neither given. + + "To Manufacture" cards are excluded — they aren't finalized yet (Manufacture Stock Entry + pending) and get their own section, so they shouldn't appear among finished sessions. + """ + filters = { + "docstatus": 1, + "modified": [">=", get_datetime(f"{getdate()} 00:00:00")], + "status": ["!=", "To Manufacture"], + } + if work_order: + filters["work_order"] = work_order + elif workstation: + filters["workstation"] = workstation + else: + return None + return filters + + +def get_workstation_oee(workstation: str) -> dict | None: + """ + OEE = Availability X Performance X Quality, computed for today only. + + Caveat: without a downtime-reason capture step, Availability is just + (actual_run_time / scheduled_time) — it cannot distinguish planned breaks + from unplanned breakdowns. The number is directional, not audit-grade. + """ + today = getdate() + scheduled_min = flt(frappe.db.get_value("Workstation", workstation, "total_working_hours")) * 60 + actual_run_min, ideal_min = _get_run_and_ideal_minutes(workstation, today) + completed_jcs = _get_completed_jcs_today(workstation, today) + + # No activity at all today — nothing to display. + if actual_run_min == 0 and not completed_jcs: + return None + return _build_oee(scheduled_min, actual_run_min, ideal_min, completed_jcs) + + +def _get_run_and_ideal_minutes(workstation, today) -> tuple[float, float]: + """Sum actual run minutes (clipped to today) and the ideal minutes for produced qty.""" + today_start = get_datetime(f"{today} 00:00:00") + today_end = get_datetime(f"{today} 23:59:59") + now = now_datetime() + actual_run_min = 0.0 + ideal_min = 0.0 + for log in _get_oee_time_logs(workstation, today_start, today_end): + # Clip the log's interval to today's window for fair attribution. + start = max(get_datetime(log.from_time), today_start) + end = min(get_datetime(log.to_time) if log.to_time else now, today_end) + if end > start: + actual_run_min += time_diff_in_seconds(end, start) / 60 + if log.completed_qty and log.for_quantity and log.time_required: + ideal_min += (flt(log.time_required) / flt(log.for_quantity)) * flt(log.completed_qty) + return actual_run_min, ideal_min + + +def _get_oee_time_logs(workstation, today_start, today_end) -> list[dict]: + """Job Card time logs whose interval overlaps today's window.""" + tl = frappe.qb.DocType("Job Card Time Log") + jc = frappe.qb.DocType("Job Card") + return ( + frappe.qb.from_(tl) + .inner_join(jc) + .on(jc.name == tl.parent) + .select(tl.from_time, tl.to_time, tl.completed_qty, jc.for_quantity, jc.time_required) + .where(jc.workstation == workstation) + .where(jc.docstatus < 2) + .where(tl.from_time <= today_end) + .where(tl.to_time.isnull() | (tl.to_time >= today_start)) + ).run(as_dict=True) + + +def _get_completed_jcs_today(workstation, today) -> list[dict]: + """Job cards completed/submitted today — process loss is finalized at submission.""" + jc = frappe.qb.DocType("Job Card") + return ( + frappe.qb.from_(jc) + .select(jc.total_completed_qty, jc.process_loss_qty) + .where(jc.workstation == workstation) + .where(jc.status.isin(["Completed", "Submitted"])) + .where(Date(jc.modified) == today) + ).run(as_dict=True) + + +def _build_oee(scheduled_min, actual_run_min, ideal_min, completed_jcs) -> dict: + """Combine the three OEE factors into the response payload.""" + total_completed = sum(flt(j.total_completed_qty) for j in completed_jcs) + total_loss = sum(flt(j.process_loss_qty) for j in completed_jcs) + availability = min(actual_run_min / scheduled_min, 1.0) if scheduled_min > 0 else None + performance = min(ideal_min / actual_run_min, 1.0) if actual_run_min > 0 else 0.0 + quality = max(total_completed - total_loss, 0.0) / total_completed if total_completed > 0 else 1.0 + # OEE requires all three factors; without a schedule, Availability is unknown. + oee_val = round(availability * performance * quality * 100, 1) if availability is not None else None + return { + "oee": oee_val, + "availability": round(availability * 100, 1) if availability is not None else None, + "performance": round(performance * 100, 1), + "quality": round(quality * 100, 1), + } diff --git a/erpnext/patches.txt b/erpnext/patches.txt index 1d893d4d8ae..0ec66c41087 100644 --- a/erpnext/patches.txt +++ b/erpnext/patches.txt @@ -496,4 +496,8 @@ erpnext.patches.v16_0.rename_ar_ap_ageing_filter erpnext.patches.v16_0.fix_subcontracting_titles erpnext.patches.v16_0.backfill_repost_accounting_ledger_status erpnext.patches.v16_0.merge_seeded_item_group_root +<<<<<<< HEAD erpnext.patches.v16_0.rename_italy_customer_name_fields +======= +erpnext.patches.v16_0.set_stock_uom_in_job_card +>>>>>>> 07ac4d83ef (feat(job_card): print quantities with their stock uom (#57689)) diff --git a/erpnext/patches/v16_0/set_stock_uom_in_job_card.py b/erpnext/patches/v16_0/set_stock_uom_in_job_card.py new file mode 100644 index 00000000000..35abf69df05 --- /dev/null +++ b/erpnext/patches/v16_0/set_stock_uom_in_job_card.py @@ -0,0 +1,36 @@ +import frappe + + +def execute(): + job_cards = frappe.get_all( + "Job Card", + filters={"stock_uom": ("is", "not set")}, + fields=["name", "finished_good", "production_item"], + ) + + if not job_cards: + return + + item_codes = {code for row in job_cards if (code := row.finished_good or row.production_item)} + if not item_codes: + return + + stock_uoms = dict( + frappe.get_all( + "Item", + filters={"name": ("in", list(item_codes))}, + fields=["name", "stock_uom"], + as_list=True, + ) + ) + + updates = {} + for row in job_cards: + stock_uom = stock_uoms.get(row.finished_good or row.production_item) + if stock_uom: + updates[row.name] = {"stock_uom": stock_uom} + + if not updates: + return + + frappe.db.bulk_update("Job Card", updates) diff --git a/erpnext/public/js/shop_floor/shop_floor.js b/erpnext/public/js/shop_floor/shop_floor.js new file mode 100644 index 00000000000..a595102c004 --- /dev/null +++ b/erpnext/public/js/shop_floor/shop_floor.js @@ -0,0 +1,1758 @@ +// Shop Floor — an immersive, keyboard-first operator/manager interface. +// +// Two experiences share one app shell (see get_shop_floor_context on the server): +// • manager — a paginated board of work orders bucketed Pending / In Progress and Completed. +// Drilling into a work order opens its job cards in the operator pane. +// • operator — a focused workstation/work-order view to start, pause, complete and submit jobs. +// +// The whole surface is driveable from the keyboard (press ? for the cheat sheet) so an operator +// at a terminal never needs the mouse. + +// Job Card status → indicator colour, mirrored from workstation.get_status_color so the manager +// board can paint per-operation chips without a round-trip. +const JC_STATUS_COLORS = { + Completed: "green", + Submitted: "blue", + "Work In Progress": "orange", + "Material Transferred": "yellow", + "On Hold": "red", + Open: "gray", + "Not Started": "gray", +}; + +const MANAGER_BUCKETS = [ + { key: "open", label: __("Pending / In Progress"), dot: "orange" }, + { key: "completed", label: __("Completed"), dot: "green" }, +]; + +const PAGE_LENGTH = 20; + +class ShopFloor { + constructor({ wrapper }, page) { + this.wrapper = $(wrapper); + this.page = page; + this.timer_intervals = {}; + this.capacity = 1; + this.mode = null; + // Remembers each Materials panel's open/closed state (keyed by job card) so it + // survives re-renders — otherwise a reload right after a click resets the panel. + this.materials_open = {}; + // Same idea for the per-operation Work Instructions panel. + this.instructions_open = {}; + + // View state. + this.view = "operator"; // overwritten once context loads + this.active_bucket = "open"; + this.with_job_cards_only = true; // board default: hide WOs that have no job cards + this.buckets = {}; // key -> { rows, total, start, loaded } + this.selected_wo = null; + this.focus_index = -1; + this.op_state = { workstation: null, work_order: null }; + + this.make(); + this.bind_realtime(); + this.bind_lifecycle(); + this.init(); + } + + init() { + frappe.call("erpnext.manufacturing.page.shop_floor.shop_floor.get_shop_floor_context").then((r) => { + const ctx = r.message || {}; + this.view = ctx.role_view === "manager" ? "manager" : "operator"; + this.can_manage = !!ctx.can_manage; + this.user_employee = ctx.user_employee || null; + this.render_shell_controls(); + this.render_view(); + this.bind_keys(); + this.initialized = true; + this.apply_route_options(); + }); + } + + // ── App shell ──────────────────────────────────────────────────────────── + make() { + this.wrapper.append(` + ${this.styles()} +
+
+
+
+
+ + + + + +
+
+
+
+
+
+
+
+ `); + + this.app = this.wrapper.find(".sf-app"); + this.brand_icon = `${__( + `; + this.topbar_left = this.wrapper.find(".sf-topbar-left"); + this.topbar_center = this.wrapper.find(".sf-topbar-center"); + this.body = this.wrapper.find(".sf-body"); + this.board_container = this.wrapper.find(".sf-board"); + this.detail_container = this.wrapper.find(".sf-detail"); + this.op_container = this.wrapper.find(".sf-operator"); + + this.wrapper.find(".sf-btn-home").on("click", () => (window.location.href = "/app")); + this.wrapper.find(".sf-btn-refresh").on("click", () => this.refresh()); + this.wrapper.find(".sf-btn-scan").on("click", () => this.open_scanner()); + this.wrapper.find(".sf-btn-help").on("click", () => this.show_help()); + this.wrapper.find(".sf-btn-theme").on("click", () => this.toggle_theme()); + this.update_theme_button(); + } + + // Kiosk-friendly light/dark switch: flips the standard desk theme and persists it on the + // User (same as the Ctrl+Shift+G switcher), so the choice survives reloads and follows the + // operator's login on any device. + toggle_theme() { + const next = frappe.ui.get_current_theme() === "dark" ? "light" : "dark"; + document.documentElement.setAttribute("data-theme-mode", next); + frappe.ui.set_theme(next); + frappe.xcall("frappe.core.doctype.user.user.switch_theme", { + theme: next.charAt(0).toUpperCase() + next.slice(1), + }); + this.update_theme_button(); + } + + update_theme_button() { + const dark = frappe.ui.get_current_theme() === "dark"; + this.wrapper + .find(".sf-btn-theme") + .html(dark ? "☀" : "☾") + .attr("title", dark ? __("Switch to Light Theme") : __("Switch to Dark Theme")); + } + + render_shell_controls() { + this.topbar_left.empty(); + this.topbar_center.empty(); + + // View toggle — only managers can flip between the board and a bare operator view. + const toggle = this.can_manage + ? `
+ + +
` + : ""; + + if (this.view === "manager") { + this.topbar_left.html(` + ${this.brand_icon}${__("Shop Floor")} + ${toggle} +
+ ${MANAGER_BUCKETS.map( + (b) => `` + ).join("")} +
+ `); + this.topbar_center.html(` +
+ ${frappe.utils.icon("search", "sm")} + +
+ + `); + + this.topbar_left.find(".sf-tab").on("click", (e) => { + this.switch_bucket($(e.currentTarget).attr("data-bucket")); + }); + let timer = null; + this.topbar_center.find(".sf-search-input").on("input", (e) => { + const val = e.target.value; + clearTimeout(timer); + timer = setTimeout(() => this.search_work_orders(val), 300); + }); + this.topbar_center.find(".sf-jc-toggle").on("change", (e) => { + this.toggle_job_cards_only(e.target.checked); + }); + } else { + this.topbar_left.html( + `${this.brand_icon}${__("Shop Floor")}${toggle}` + ); + this.build_operator_filters(); + } + + this.topbar_left.find(".sf-view-btn").on("click", (e) => { + this.set_view($(e.currentTarget).attr("data-view")); + }); + } + + build_operator_filters() { + this.topbar_center.html('
'); + const $filters = this.topbar_center.find(".sf-filters"); + + this.workstation_filter = frappe.ui.form.make_control({ + df: { + fieldtype: "Link", + options: "Workstation", + fieldname: "workstation", + placeholder: __("Machine"), + onchange: () => this.load_operator(), + }, + parent: $filters, + render_input: true, + }); + this.workstation_filter.$wrapper.addClass("sf-filter-control"); + + this.work_order_filter = frappe.ui.form.make_control({ + df: { + fieldtype: "Link", + options: "Work Order", + fieldname: "work_order", + placeholder: __("Work Order"), + onchange: () => this.load_operator(), + }, + parent: $filters, + render_input: true, + }); + this.work_order_filter.$wrapper.addClass("sf-filter-control"); + } + + set_view(view) { + if (!view || view === this.view) return; + this.view = view; + this.selected_wo = null; + this.focus_index = -1; + this.render_shell_controls(); + this.render_view(); + } + + render_view() { + const manager = this.view === "manager"; + this.board_container.toggle(manager); + this.detail_container.toggle(manager && !!this.selected_wo); + this.op_container.toggle(!manager); + this.body.toggleClass("detail-open", manager && !!this.selected_wo); + + if (manager) { + this.load_bucket(this.active_bucket); + } else { + this.load_operator(); + } + } + + // ── Manager board ──────────────────────────────────────────────────────── + switch_bucket(bucket) { + if (!bucket || bucket === this.active_bucket) return; + this.active_bucket = bucket; + this.selected_wo = null; + this.focus_index = -1; + this.topbar_left.find(".sf-tab").removeClass("active"); + this.topbar_left.find(`.sf-tab[data-bucket="${bucket}"]`).addClass("active"); + this.detail_container.hide(); + this.body.removeClass("detail-open"); + this.load_bucket(bucket); + } + + search_work_orders(term) { + this.search_term = term; + // Re-query every bucket from scratch on the next visit; reload the active one now. + this.buckets = {}; + this.load_bucket(this.active_bucket); + } + + toggle_job_cards_only(checked) { + this.with_job_cards_only = !!checked; + // Filter changes every bucket's contents + counts; drop caches and clear stale counts. + this.buckets = {}; + this.topbar_left.find(".sf-tab-count").text(""); + this.load_bucket(this.active_bucket); + } + + load_bucket(bucket, append = false) { + const state = this.buckets[bucket] || { rows: [], total: 0, start: 0, loaded: false }; + const start = append ? state.start : 0; + + frappe.call({ + method: "erpnext.manufacturing.page.shop_floor.shop_floor.get_work_orders", + args: { + status_group: bucket, + start: start, + page_length: PAGE_LENGTH, + search: this.search_term || null, + with_job_cards_only: this.with_job_cards_only ? 1 : 0, + }, + callback: (r) => { + const data = r.message || {}; + const rows = data.work_orders || []; + this.buckets[bucket] = { + rows: append ? state.rows.concat(rows) : rows, + total: cint(data.total), + start: start + rows.length, + loaded: true, + }; + this.update_tab_count(bucket); + if (bucket === this.active_bucket) this.render_board(); + }, + }); + } + + update_tab_count(bucket) { + const state = this.buckets[bucket]; + if (!state) return; + this.topbar_left.find(`[data-bucket-count="${bucket}"]`).text(state.total ? state.total : ""); + } + + render_board() { + const state = this.buckets[this.active_bucket] || { rows: [], total: 0 }; + this.focus_index = -1; + + if (!state.rows.length) { + this.board_container.html(`
${__("No work orders here.")}
`); + return; + } + + const cards = state.rows.map((wo) => this.work_order_card(wo)).join(""); + const more = + state.rows.length < state.total + ? `` + : `
${__("Showing all {0}", [state.total])}
`; + + this.board_container.html( + `
${cards}
${more}
` + ); + + this.board_container.find(".sf-wo-card").on("click", (e) => { + this.open_wo($(e.currentTarget).attr("data-name")); + }); + this.board_container + .find(".sf-load-more") + .on("click", () => this.load_bucket(this.active_bucket, true)); + } + + work_order_card(wo) { + const item = wo.item_name || wo.production_item; + + // Hero image = the current operation's workstation. No item-image fallback — when the + // workstation has no image uploaded we show its initials, never the product image. + const image = wo.workstation_image + ? `` + : `${frappe.get_abbr(wo.workstation_name || item, 2)}`; + + const workstation_line = wo.workstation_name + ? `
🏭 ${frappe.utils.escape_html( + wo.workstation_name + )}${wo.current_operation ? ` · ${frappe.utils.escape_html(wo.current_operation)}` : ""}
` + : ""; + + // Operations bar: green segment (done) + orange segment (in progress); grey track = pending. + const done_pct = Math.min(cint(wo.per_operations), 100); + const wip_pct = Math.min(cint(wo.per_in_progress), 100 - done_pct); + + return ` +
+
+
${image}
+
+
${frappe.utils.escape_html(item)}
+ ${workstation_line} +
+ + ${wo.name} +
+
+
+
+
+ ${__("Operations")} + ${cint(wo.completed_operations)} / ${cint(wo.total_operations)} +
+
+
+
+
+
+
+ `; + } + + open_wo(name) { + if (!name) return; + this.selected_wo = name; + this.op_state = { workstation: null, work_order: name }; + this.detail_container.show(); + this.body.addClass("detail-open"); + this.board_container + .find(".sf-wo-card") + .removeClass("sf-selected") + .filter(`[data-name="${name}"]`) + .addClass("sf-selected"); + // The detail pane reuses the operator rendering for a single work order. + this.detail_container.html(` +
+ + ${frappe.utils.escape_html(name)} + ${__("Open")} +
+
+ `); + this.detail_container.find(".sf-detail-back").on("click", () => this.close_wo()); + this.op_container_target = this.detail_container.find(".sf-detail-body"); + this.load_operator_data(this.op_container_target, { work_order: name }); + } + + close_wo() { + this.selected_wo = null; + this.op_container_target = null; + this.detail_container.hide().empty(); + this.body.removeClass("detail-open"); + this.board_container.find(".sf-wo-card").removeClass("sf-selected"); + } + + // ── Operator pane ────────────────────────────────────────────────────────── + // Resolves the container the operator content renders into: the standalone operator + // view, or the manager's drill-down detail pane. + current_op_container() { + return this.view === "manager" ? this.op_container_target : this.op_container; + } + + load_operator() { + const workstation = this.workstation_filter ? this.workstation_filter.get_value() : null; + const work_order = this.work_order_filter ? this.work_order_filter.get_value() : null; + this.op_state = { workstation, work_order }; + + if (!workstation && !work_order) { + this.clear_timers(); + this.op_container.html( + `
${__("Select a machine or work order to begin")}
` + ); + return; + } + this.load_operator_data(this.op_container, { workstation, work_order }); + } + + load_operator_data($container, { workstation, work_order }) { + frappe.call({ + method: "erpnext.manufacturing.page.shop_floor.shop_floor.get_data", + args: { + workstation: work_order ? null : workstation, + work_order: work_order || null, + }, + callback: (r) => { + const data = r.message || {}; + this.job_cards = data.job_cards || []; + this.capacity = cint(data.capacity) || 1; + this.mode = data.mode || (work_order ? "work_order" : "workstation"); + this.oee = data.oee || null; + if (data.user_employee) this.user_employee = data.user_employee; + this.today_sessions = data.today_sessions || []; + this.workstation = workstation; + this.work_order = work_order; + this.compute_state(); + this.dedupe_today_sessions(); + this.render_operator($container); + }, + }); + } + + // A job card already shown under Completed Operations shouldn't repeat in + // Today's Sessions — keep it in Completed Operations only. + dedupe_today_sessions() { + const shown = new Set((this.completed || []).map((jc) => jc.name)); + this.today_sessions = (this.today_sessions || []).filter((s) => !shown.has(s.name)); + } + + // Re-fetch whichever operator content is currently on screen (used after every action). + reload() { + if (this.view === "manager" && this.selected_wo) { + this.load_operator_data(this.op_container_target, { work_order: this.selected_wo }); + // Keep the board chips fresh too. + this.buckets = {}; + this.load_bucket(this.active_bucket); + } else if (this.view === "manager") { + this.load_bucket(this.active_bucket); + } else { + this.load_operator(); + } + } + + refresh() { + if (this.view === "manager") { + this.buckets = {}; + } + this.reload(); + } + + compute_state() { + this.active_jobs = []; + this.queue = []; + this.pending_submission = []; + this.completed = []; + // Submitted but the finished goods aren't booked yet (status "To Manufacture") — its own + // actionable section, kept out of Completed Operations / Today's Sessions. + this.to_manufacture = []; + + for (const jc of this.job_cards) { + // Same materials-ready rule as job_card.js make_dashboard. + jc._materials_ready = !!( + jc.skip_material_transfer || + flt(jc.transferred_qty) >= flt(jc.for_quantity) + flt(jc.process_loss_qty) || + !jc.finished_good + ); + + // Submitted JCs are historical from the Shop Floor's POV — only appear here in work_order + // mode (and, for "To Manufacture", in workstation mode too — see _fetch_job_cards). + if (jc.docstatus === 1) { + if (jc.status === "To Manufacture") { + this.to_manufacture.push(jc); + } else { + this.completed.push(jc); + } + continue; + } + + const last_log = + jc.time_logs && jc.time_logs.length ? jc.time_logs[jc.time_logs.length - 1] : null; + const is_running = last_log && !last_log.to_time && !jc.is_paused; + const is_paused = jc.is_paused; + + if (is_running || is_paused) { + this.active_jobs.push(jc); + } else if (jc.status === "Completed") { + // All qty accounted for but still draft — waiting on Submit. + this.pending_submission.push(jc); + } else { + this.queue.push(jc); + } + } + + // Slot rules — all active jobs are always shown; the grid (col-md-6) wraps them 2 per row. + // workstation mode: capacity-many slots, expanded to fit every active job (+ empty placeholders). + // work_order mode: one slot per active job (no empty placeholders). + let slot_count; + if (this.mode === "work_order") { + slot_count = this.active_jobs.length; + } else { + slot_count = Math.max(this.capacity, this.active_jobs.length, 1); + } + + this.slots = []; + for (let i = 0; i < slot_count; i++) { + this.slots.push(this.active_jobs[i] || null); + } + + // Auto-pick: when nothing is running, surface the next queue item in the slot. + if (this.active_jobs.length === 0 && this.queue.length > 0) { + const next_up = this.queue.shift(); + next_up._is_next_up = true; + this.slots[0] = next_up; + } + + this.summary = { + active_count: this.active_jobs.length, + // "To Manufacture" (submitted, qty done, but the Manufacture Stock Entry is still pending) + // isn't actually finished — count it as Pending, not Completed. + queue_count: this.queue.length + this.to_manufacture.length, + completed_count: this.completed.length + this.pending_submission.length, + capacity: this.capacity, + }; + } + + render_operator($container) { + this.clear_timers(); + $container.empty(); + + const html = frappe.render_template("shop_floor_template", { + workstation: this.workstation, + work_order: this.work_order, + mode: this.mode, + slots: this.slots, + active_jobs: this.active_jobs, + queue: this.queue, + pending_submission: this.pending_submission, + to_manufacture: this.to_manufacture, + completed: this.completed, + today_sessions: this.today_sessions || [], + summary: this.summary, + oee: this.oee, + }); + $container.html(html); + + // Restore each Materials panel to its remembered open/closed state. + $container.find(".mes-materials-inline").each((i, el) => { + const $el = $(el); + const name = $el.attr("data-job-card"); + if (!name) return; + if (name in this.materials_open) { + $el.toggleClass("is-open", this.materials_open[name]); + } else { + this.materials_open[name] = $el.hasClass("is-open"); + } + }); + + // Restore each Work Instructions panel to its remembered open/closed state. + $container.find(".mes-instructions-inline").each((i, el) => { + const $el = $(el); + const name = $el.attr("data-job-card"); + if (name && name in this.instructions_open) { + $el.toggleClass("is-open", this.instructions_open[name]); + } + }); + + this.bind_events($container); + + for (const jc of this.active_jobs) { + if (jc.is_paused) { + this.render_timer(jc.name, this.elapsed_seconds(jc), $container); + } else { + this.start_timer_for(jc, $container); + } + } + } + + clear_timers() { + for (const id of Object.values(this.timer_intervals)) { + clearInterval(id); + } + this.timer_intervals = {}; + } + + bind_events($container) { + const me = this; + + $container.find(".mes-materials-summary").on("click", function (e) { + if ($(e.target).closest(".mes-btn-transfer").length) return; + const $inline = $(this).closest(".mes-materials-inline"); + const open = !$inline.hasClass("is-open"); + $inline.toggleClass("is-open", open); + const name = $inline.attr("data-job-card"); + if (name) me.materials_open[name] = open; + }); + + $container.find(".mes-instructions-summary").on("click", function () { + const $inline = $(this).closest(".mes-instructions-inline"); + const open = !$inline.hasClass("is-open"); + $inline.toggleClass("is-open", open); + const name = $inline.attr("data-job-card"); + if (name) me.instructions_open[name] = open; + }); + + // Clicking a "QC Required" / "QC Available" pill runs the inline check ahead of End Session. + $container.find(".mes-qc-pill").on("click", function () { + const name = $(this).attr("data-job-card"); + const jc = (me.active_jobs || []).find((j) => j.name === name); + if (jc) me.run_quality_check(jc, () => me.reload()); + }); + + $container.find(".mes-btn-start").on("click", function () { + me.start_job($(this).attr("data-job-card")); + }); + $container.find(".mes-btn-pause").on("click", function () { + me.pause_job($(this).attr("data-job-card")); + }); + $container.find(".mes-btn-resume").on("click", function () { + me.resume_job($(this).attr("data-job-card")); + }); + $container.find(".mes-btn-end-session").on("click", function () { + me.end_session($(this).attr("data-job-card")); + }); + $container.find(".mes-btn-submit").on("click", function () { + me.submit_job_card($(this).attr("data-job-card")); + }); + $container.find(".mes-btn-make-entry").on("click", function () { + me.make_manufacture_entry($(this).attr("data-job-card")); + }); + $container.find(".mes-btn-transfer").on("click", function (e) { + e.preventDefault(); + me.transfer_materials($(this).attr("data-job-card")); + }); + } + + // ── Operator actions (unchanged behaviour, reload() instead of load()) ───── + start_job(job_card) { + const me = this; + if (this.mode === "workstation" && this.active_jobs.length >= this.capacity) { + frappe.msgprint({ + title: __("Capacity Reached"), + message: __( + "This machine can run at most {0} job(s) in parallel. Pause or complete a running job before starting another.", + [this.capacity] + ), + indicator: "orange", + }); + return; + } + + const default_employee = this.user_employee; + const dialog = new frappe.ui.Dialog({ + title: __("Start Job"), + fields: [ + { + label: __("Start Time"), + fieldname: "start_time", + fieldtype: "Datetime", + default: frappe.datetime.now_datetime(), + }, + { fieldtype: "Section Break" }, + { + label: __("Employees"), + fieldname: "employees", + fieldtype: "Table", + data: default_employee ? [{ employee: default_employee }] : [], + fields: [ + { + label: __("Employee"), + fieldname: "employee", + fieldtype: "Link", + options: "Employee", + in_list_view: 1, + }, + ], + }, + ], + primary_action_label: __("Start"), + primary_action: (values) => { + dialog.hide(); + me.update_job_card(job_card, "start_timer", { + start_time: values.start_time, + employees: values.employees || [], + }); + }, + }); + dialog.show(); + this.bind_enter_submit(dialog); + } + + // Make a dialog fully keyboard-operable: Enter triggers the primary action, so an operator + // never has to reach for the mouse. Enter is left alone inside multi-line fields and while an + // autocomplete (Link/Select) dropdown is open, so it can still pick a value. + bind_enter_submit(dialog) { + dialog.$wrapper.on("keydown.sfenter", (e) => { + if (e.key !== "Enter" || e.shiftKey) return; + if ($(e.target).is("textarea")) return; + if ($(".awesomplete > ul:not([hidden])").length) return; + const $btn = dialog.get_primary_btn(); + if ( + $btn && + $btn.length && + $btn.is(":visible") && + !$btn.hasClass("disabled") && + !$btn.prop("disabled") + ) { + e.preventDefault(); + e.stopPropagation(); + $btn.trigger("click"); + } + }); + } + + pause_job(jc_name) { + this.update_job_card(jc_name, "pause_job", { end_time: frappe.datetime.now_datetime() }); + } + + resume_job(jc_name) { + this.update_job_card(jc_name, "resume_job", { start_time: frappe.datetime.now_datetime() }); + } + + end_session(jc_name) { + const me = this; + const jc = this.active_jobs.find((j) => j.name === jc_name); + if (!jc) return; + + let pending = flt(jc.for_quantity) - flt(jc.total_completed_qty); + if (flt(jc.pending_qty) > 0) { + pending = flt(jc.pending_qty); + } + + const qty_with_uom = (qty) => `${flt(qty)} ${jc.stock_uom || ""}`.trim(); + + const fields = [ + { + fieldtype: "Float", + label: __("Qty to Manufacture in this Cycle"), + fieldname: "for_quantity", + reqd: 1, + default: pending, + description: __("Completed, Pending and Process Loss quantities must add up to this."), + change() { + const d = me.session_dialog; + d.set_value("completed_qty", d.get_value("for_quantity")); + d.set_value("pending_qty", 0); + d.set_value("process_loss_qty", 0); + }, + }, + { + fieldtype: "Float", + label: __("Completed Quantity"), + fieldname: "completed_qty", + reqd: 1, + default: pending, + change() { + const d = me.session_dialog; + const remaining = + flt(d.get_value("for_quantity")) - + flt(d.get_value("completed_qty")) - + flt(d.get_value("process_loss_qty")); + + if (remaining < 0) { + const max_completed_qty = + flt(d.get_value("for_quantity")) - flt(d.get_value("process_loss_qty")); + d.set_value("completed_qty", max_completed_qty); + frappe.throw( + __("Completed Quantity cannot be greater than {0}", [ + qty_with_uom(max_completed_qty), + ]) + ); + } + + if (remaining !== flt(d.get_value("pending_qty"))) { + d.set_value("pending_qty", remaining); + } + }, + }, + { + fieldtype: "Float", + label: __("Pending Quantity"), + fieldname: "pending_qty", + default: 0.0, + description: __("Qty left for a later cycle or for another job card."), + change() { + const d = me.session_dialog; + const pl = + flt(d.get_value("for_quantity")) - + flt(d.get_value("completed_qty")) - + flt(d.get_value("pending_qty")); + + if (pl < 0) { + d.set_value("pending_qty", 0); + frappe.throw( + __("Pending Quantity cannot be greater than {0}", [ + qty_with_uom( + flt(d.get_value("for_quantity")) - flt(d.get_value("completed_qty")) + ), + ]) + ); + } + + if (pl !== flt(d.get_value("process_loss_qty"))) { + d.set_value("process_loss_qty", pl); + } + }, + }, + { + fieldtype: "Float", + label: __("Process Loss Quantity"), + fieldname: "process_loss_qty", + default: 0.0, + description: __("Qty scrapped in this cycle, nobody will produce it."), + change() { + const d = me.session_dialog; + const remaining = + flt(d.get_value("for_quantity")) - + flt(d.get_value("completed_qty")) - + flt(d.get_value("process_loss_qty")); + + if (remaining < 0) { + d.set_value("process_loss_qty", 0); + frappe.throw( + __("Process Loss Quantity cannot be greater than {0}", [ + qty_with_uom( + flt(d.get_value("for_quantity")) - flt(d.get_value("completed_qty")) + ), + ]) + ); + } + + if (remaining !== flt(d.get_value("pending_qty"))) { + d.set_value("pending_qty", remaining); + } + }, + }, + { fieldtype: "Section Break" }, + { + fieldtype: "Datetime", + label: __("End Time"), + fieldname: "end_time", + default: frappe.datetime.now_datetime(), + }, + ]; + + const get_payload = () => { + const data = me.session_dialog.get_values(); + if (!data) return null; + if (flt(data.completed_qty) <= 0) { + frappe.throw(__("Completed Quantity should be greater than 0")); + } + return { + job_card: jc.name, + qty: flt(data.completed_qty), + for_quantity: flt(data.for_quantity), + pending_qty: flt(data.pending_qty), + process_loss_qty: flt(data.process_loss_qty), + end_time: data.end_time, + }; + }; + + const save_and_continue = () => { + const args = get_payload(); + if (!args) return; + me.session_dialog.hide(); + frappe.call({ + method: "erpnext.manufacturing.page.shop_floor.shop_floor.save_and_continue", + args: args, + freeze: true, + freeze_message: __("Saving job card..."), + callback: () => me.reload(), + }); + }; + + const finalize_submit = (args) => { + frappe.call({ + method: "erpnext.manufacturing.page.shop_floor.shop_floor.complete_and_submit", + args: args, + freeze: true, + freeze_message: __("Submitting job card..."), + callback: (r) => { + me.reload(); + if (r.message && r.message.finished_good) { + me.prompt_manufacture_entry(jc.name); + } + }, + }); + }; + + const submit_session = () => { + const args = get_payload(); + if (!args) return; + me.session_dialog.hide(); + // Guided QC gate: a job card that requires inspection must pass an inline Quality Check + // before it is submitted (mirrors Job Card.validate_inspection on the server). Once the + // inspection is recorded, finalize the session submit. + if (jc.qc && jc.qc.required && jc.qc.status !== "Accepted") { + me.run_quality_check(jc, () => finalize_submit(args)); + } else { + finalize_submit(args); + } + }; + + me.session_dialog = new frappe.ui.Dialog({ + title: __("End Session"), + fields: fields, + primary_action_label: __("Submit"), + primary_action: submit_session, + secondary_action_label: __("Save & Continue"), + secondary_action: save_and_continue, + }); + me.session_dialog.show(); + me.bind_enter_submit(me.session_dialog); + } + + // ── Inline Quality Check ───────────────────────────────────────────────────── + // Fetch the operation's Quality Inspection template and open a guided pass/fail checklist. + // `on_pass` runs once the inspection has been recorded (and is not rejected). + run_quality_check(jc, on_pass) { + const me = this; + frappe.call({ + method: "erpnext.manufacturing.page.shop_floor.shop_floor.get_quality_inspection_checklist", + args: { job_card: jc.name }, + freeze: true, + freeze_message: __("Loading quality checklist..."), + callback: (r) => { + const info = r.message || {}; + if (!info.template || !(info.parameters || []).length) { + // Inspection is required but the operation has no template/parameters to fill — + // there is nothing to capture inline. Point the user at the configuration. + frappe.msgprint({ + title: __("Quality Inspection Template Missing"), + indicator: "orange", + message: __( + "This operation requires a Quality Inspection but no template with parameters is configured. Set a Quality Inspection Template on Operation {0} to inspect from the Shop Floor.", + [jc.operation || ""] + ), + }); + return; + } + me.show_qc_dialog(jc, info, on_pass); + }, + }); + } + + show_qc_dialog(jc, info, on_pass) { + const me = this; + const params = info.parameters || []; + // Per-row operator input, keyed by row index (avoids escaping issues with parameter names). + const state = {}; // idx -> "Accepted" | "Rejected" + + const rows = params + .map((p, i) => { + const spec = frappe.utils.escape_html(p.specification); + let criteria = ""; + if (p.numeric) { + const lo = p.min_value !== null && p.min_value !== undefined ? p.min_value : "−∞"; + const hi = p.max_value !== null && p.max_value !== undefined ? p.max_value : "∞"; + criteria = __("Acceptable range: {0} to {1}", [lo, hi]); + } else if (p.value) { + criteria = __("Expected: {0}", [frappe.utils.escape_html(p.value)]); + } + const control = p.numeric + ? `` + : ` + + + `; + return `
+
+
${spec}
+ ${criteria ? `
${criteria}
` : ""} +
+
${control}
+
`; + }) + .join(""); + + const dialog = new frappe.ui.Dialog({ + title: __("Quality Check"), + size: "large", + fields: [ + { + fieldtype: "HTML", + options: `
${__( + "Inspect {0} for job card {1}", + [frappe.utils.escape_html(info.item_code || ""), frappe.utils.escape_html(jc.name)] + )}
${rows}
`, + }, + ], + primary_action_label: __("Submit Inspection"), + primary_action: () => { + const readings = []; + let missing = false; + params.forEach((p, i) => { + if (p.numeric) { + const val = dialog.$wrapper.find(`.mes-qc-reading[data-idx="${i}"]`).val(); + if (val === "" || val === undefined || val === null) missing = true; + readings.push({ specification: p.specification, reading_value: val }); + } else { + if (!state[i]) missing = true; + readings.push({ + specification: p.specification, + status: state[i], + reading_value: "", + }); + } + }); + if (missing) { + frappe.msgprint(__("Please complete every check before submitting the inspection.")); + return; + } + dialog.hide(); + frappe.call({ + method: "erpnext.manufacturing.page.shop_floor.shop_floor.submit_quality_inspection", + args: { job_card: jc.name, readings: JSON.stringify(readings) }, + freeze: true, + freeze_message: __("Recording inspection..."), + callback: (r) => { + const res = r.message || {}; + if (res.status === "Rejected") { + // Don't auto-proceed on a rejected inspection — the server gate may block the + // submit anyway (per Stock Settings), and the operator should decide next steps. + frappe.msgprint({ + title: __("Inspection Rejected"), + indicator: "red", + message: __( + "Quality Inspection {0} is Rejected. Resolve the issue or follow your rejection process before submitting the job card.", + [res.name || ""] + ), + }); + me.reload(); + return; + } + if (on_pass) on_pass(); + }, + }); + }, + }); + + dialog.show(); + // Pass/Fail toggles for qualitative parameters. + dialog.$wrapper.find(".mes-qc-passfail button").on("click", function () { + const $btn = $(this); + const $grp = $btn.closest(".mes-qc-passfail"); + $grp.find("button").removeClass("active"); + $btn.addClass("active"); + state[$grp.attr("data-idx")] = $btn.attr("data-val"); + }); + } + + prompt_manufacture_entry(jc_name) { + const me = this; + const dialog = new frappe.ui.Dialog({ + title: __("Job Card Submitted"), + fields: [ + { + fieldtype: "HTML", + options: ` +
+
+ ${__("Job card {0} has been submitted.", [frappe.utils.escape_html(jc_name)])} +
+
+ ${__("Create a Manufacture stock entry for the finished goods?")} +
+
+ `, + }, + ], + primary_action_label: __("Make Manufacture Entry"), + primary_action: () => { + dialog.hide(); + me.make_manufacture_entry(jc_name); + }, + secondary_action_label: __("Skip"), + secondary_action: () => dialog.hide(), + }); + dialog.show(); + this.bind_enter_submit(dialog); + } + + submit_job_card(jc_name) { + const me = this; + frappe.confirm(__("Submit job card {0}? This finalizes the job card.", [jc_name]), () => { + frappe.call({ + method: "erpnext.manufacturing.page.shop_floor.shop_floor.submit_job_card", + args: { job_card: jc_name }, + freeze: true, + freeze_message: __("Submitting job card..."), + callback: () => me.reload(), + }); + }); + } + + make_manufacture_entry(jc_name) { + frappe.call({ + method: "erpnext.manufacturing.page.shop_floor.shop_floor.make_manufacture_stock_entry", + args: { job_card: jc_name }, + freeze: true, + freeze_message: __("Preparing stock entry..."), + callback: (r) => { + if (r.message && r.message.name) { + window.open(`/app/stock-entry/${encodeURIComponent(r.message.name)}`, "_blank"); + } + }, + }); + } + + transfer_materials(jc_name) { + if (!jc_name) return; + frappe.call({ + method: "erpnext.manufacturing.doctype.job_card.job_card.make_stock_entry", + args: { source_name: jc_name }, + callback: (r) => { + const doc = frappe.model.sync(r.message); + frappe.set_route("Form", doc[0].doctype, doc[0].name); + }, + }); + } + + update_job_card(job_card, method, data, on_success) { + const me = this; + frappe.call({ + method: "erpnext.manufacturing.doctype.workstation.workstation.update_job_card", + args: { + job_card: job_card, + method: method, + start_time: data.start_time || "", + employees: data.employees || [], + end_time: data.end_time || "", + qty: data.qty || 0, + for_quantity: data.for_quantity || 0, + pending_qty: data.pending_qty || 0, + process_loss_qty: data.process_loss_qty || 0, + auto_submit: data.auto_submit || 0, + }, + freeze: true, + freeze_message: __("Updating job card..."), + callback: () => { + me.reload(); + if (on_success) on_success(); + }, + }); + } + + // ── Timers ──────────────────────────────────────────────────────────────── + start_timer_for(jc, $container) { + let elapsed = this.elapsed_seconds(jc); + this.render_timer(jc.name, elapsed, $container); + this.timer_intervals[jc.name] = setInterval(() => { + elapsed += 1; + this.render_timer(jc.name, elapsed, $container); + }, 1000); + } + + elapsed_seconds(jc) { + let total = 0; + for (const log of jc.time_logs || []) { + if (log.to_time) { + if (log.time_in_mins) { + total += flt(log.time_in_mins, 2) * 60; + } else { + total += moment(log.to_time).diff(log.from_time, "seconds"); + } + } else { + total += moment().diff(log.from_time, "seconds"); + } + } + return total; + } + + render_timer(jc_name, seconds, $container) { + const h = Math.floor(seconds / 3600); + const m = Math.floor((seconds - h * 3600) / 60); + const s = cint(seconds - h * 3600 - m * 60); + const pad = (n) => (n < 10 ? "0" + n : String(n)); + + const scope = $container || this.wrapper; + const timer = scope.find(`.mes-job-timer[data-job-card="${jc_name}"]`); + timer.find(".h").text(pad(h)); + timer.find(".m").text(pad(m)); + timer.find(".s").text(pad(s)); + } + + // ── Realtime + lifecycle ─────────────────────────────────────────────────── + bind_realtime() { + frappe.realtime.on("update_workstation_status", (data) => { + if (data && data.name === this.op_state.workstation) { + this.reload(); + } + }); + } + + bind_lifecycle() { + // Frappe has no on_page_hide hook, so toggle immersive mode + keyboard binding on + // route changes ourselves. + this._route_handler = () => { + const on_page = (frappe.get_route_str() || "").startsWith("shop-floor"); + if (on_page) { + $(document.body).addClass("shop-floor-active"); + this.bind_keys(); + } else { + $(document.body).removeClass("shop-floor-active"); + this.unbind_keys(); + this.clear_timers(); + } + }; + frappe.router.on("change", this._route_handler); + } + + on_show() { + $(document.body).addClass("shop-floor-active"); + this.bind_keys(); + // Cached re-navigation (e.g. the Work Order "Shop Floor" button) lands here with fresh + // route_options; init() handles the very first load before we're initialized. + if (this.initialized) this.apply_route_options(); + } + + // ── Keyboard ──────────────────────────────────────────────────────────────── + bind_keys() { + $(document).off("keydown.shopfloor"); + $(document).on("keydown.shopfloor", (e) => this.handle_key(e)); + } + + unbind_keys() { + $(document).off("keydown.shopfloor"); + } + + is_typing(e) { + const tag = (e.target.tagName || "").toLowerCase(); + return tag === "input" || tag === "textarea" || tag === "select" || e.target.isContentEditable; + } + + handle_key(e) { + // Let dialogs own the keyboard while open. + if ($(".modal:visible").length) return; + + const typing = this.is_typing(e); + + // Escape works even while typing (blur the search / close the detail pane). + if (e.key === "Escape") { + if (typing) { + e.target.blur(); + return; + } + if (this.view === "manager" && this.selected_wo) { + this.close_wo(); + e.preventDefault(); + } + return; + } + + if (typing) return; + + switch (e.key) { + case "?": + this.show_help(); + e.preventDefault(); + return; + case "/": + this.topbar_center.find(".sf-search-input").focus(); + e.preventDefault(); + return; + case "r": + this.refresh(); + e.preventDefault(); + return; + case "b": + this.open_scanner(); + e.preventDefault(); + return; + case "1": + case "2": + if (this.view === "manager" && MANAGER_BUCKETS[cint(e.key) - 1]) { + this.switch_bucket(MANAGER_BUCKETS[cint(e.key) - 1].key); + e.preventDefault(); + } + return; + } + + // View switch chord: "g" then "m"/"o". + if (e.key === "g") { + this._g_pending = true; + setTimeout(() => (this._g_pending = false), 600); + return; + } + if (this._g_pending && (e.key === "m" || e.key === "o")) { + this._g_pending = false; + if (this.can_manage) this.set_view(e.key === "m" ? "manager" : "operator"); + return; + } + + // Navigation. + if (e.key === "ArrowDown" || e.key === "j") { + this.move_focus(1); + e.preventDefault(); + return; + } + if (e.key === "ArrowUp" || e.key === "k") { + this.move_focus(-1); + e.preventDefault(); + return; + } + if (e.key === "Enter") { + this.activate_focus(); + e.preventDefault(); + return; + } + + // Job actions on the focused card — reuse the rendered buttons. + const map = { + s: ".mes-btn-start, .mes-btn-resume", + p: ".mes-btn-pause, .mes-btn-resume", + e: ".mes-btn-end-session", + t: ".mes-btn-transfer", + }; + if (e.key === "S" && e.shiftKey) { + this.click_job_action(".mes-btn-submit"); + e.preventDefault(); + return; + } + if (map[e.key]) { + this.click_job_action(map[e.key]); + e.preventDefault(); + } + } + + // Job actions act on the focused job card (operator view); when the focus is on a board + // work order (manager view with the detail open) they fall back to the detail's active job. + click_job_action(selector) { + const $el = this.focused_el(); + if ($el && $el.attr("data-kind") === "job") { + const $btn = $el.find(selector).filter(":visible").first(); + if ($btn.length) { + $btn.trigger("click"); + return; + } + } + const scope = this.current_op_container(); + if (scope && scope.length) { + const $btn = scope.find(selector).filter(":visible").first(); + if ($btn.length) $btn.trigger("click"); + } + } + + focusables() { + // Manager always navigates the board work orders — even with the detail open, so the + // arrow keys switch work orders. The standalone operator view navigates its job cards. + const scope = this.view === "manager" ? this.board_container : this.current_op_container(); + if (!scope || !scope.length) return $(); + return scope.find("[data-sf-focusable]"); + } + + move_focus(delta) { + const $items = this.focusables(); + if (!$items.length) return; + this.focus_index = Math.max(0, Math.min($items.length - 1, this.focus_index + delta)); + $items.removeClass("sf-focused"); + const $target = $items.eq(this.focus_index); + $target.addClass("sf-focused"); + $target[0].scrollIntoView({ block: "nearest", behavior: "smooth" }); + // Browsing work orders with the detail already open → switch the detail to the focused one. + if (this.view === "manager" && this.selected_wo && $target.attr("data-kind") === "wo") { + this.open_wo($target.attr("data-name")); + } + } + + focused_el() { + const $items = this.focusables(); + if (this.focus_index < 0 || this.focus_index >= $items.length) return null; + return $items.eq(this.focus_index); + } + + activate_focus() { + const $el = this.focused_el(); + if (!$el) return; + if ($el.attr("data-kind") === "wo") { + this.open_wo($el.attr("data-name")); + } else { + // First visible primary button drives the job card (Start / Resume / End Session). + const $btn = $el.find(".btn-primary:visible").first(); + if ($btn.length) $btn.trigger("click"); + } + } + + show_help() { + const rows = [ + ["?", __("Show this help")], + ["/", __("Search work orders")], + ["r", __("Refresh")], + ["b", __("Scan job card")], + ["g then m / o", __("Switch Board / Operator view")], + ["1 / 2", __("Switch board tab")], + ["↑ / ↓ or j / k", __("Move selection")], + ["Enter", __("Open work order / run primary action")], + ["Esc", __("Close detail / blur search")], + ["s", __("Start / Resume job")], + ["p", __("Pause / Resume job")], + ["e", __("End session for active job")], + ["t", __("Transfer materials")], + ["Shift + S", __("Submit focused job card")], + ]; + const html = `
${rows + .map((r) => `
${r[0]}${r[1]}
`) + .join("")}
`; + const d = new frappe.ui.Dialog({ + title: __("Keyboard Shortcuts"), + fields: [{ fieldtype: "HTML", options: html }], + }); + d.show(); + } + + // ── Scanner ────────────────────────────────────────────────────────────── + open_scanner() { + const me = this; + const dialog = new frappe.ui.Dialog({ + title: __("Scan Job Card"), + fields: [ + { + label: __("Scan or enter Job Card"), + fieldname: "job_card", + fieldtype: "Data", + options: "Barcode", + }, + ], + primary_action_label: __("Continue"), + primary_action: (values) => { + if (!values.job_card) return; + dialog.hide(); + me.handle_scanned_job_card(values.job_card); + }, + }); + dialog.show(); + this.bind_enter_submit(dialog); + } + + handle_scanned_job_card(job_card) { + const me = this; + const jc = (this.job_cards || []).find((j) => j.name === job_card); + if (jc) { + me.route_scanned_action(jc); + return; + } + frappe.db.get_value("Job Card", job_card, ["status", "is_paused", "docstatus"]).then((r) => { + const data = r && r.message; + if (!data || !data.status) { + frappe.msgprint(__("Job Card {0} was not found.", [job_card])); + return; + } + if (cint(data.docstatus) === 1) { + frappe.msgprint(__("Job Card {0} is already submitted.", [job_card])); + } else if (cint(data.is_paused)) { + me.resume_job(job_card); + } else if (data.status === "Work In Progress") { + frappe.msgprint( + __( + "Job Card {0} is already running. Open its machine or work order to pause or complete it.", + [job_card] + ) + ); + } else if (data.status === "Completed") { + me.submit_job_card(job_card); + } else { + me.start_job(job_card); + } + }); + } + + route_scanned_action(jc) { + const me = this; + if (jc.docstatus === 1) { + frappe.msgprint(__("Job Card {0} is already submitted.", [jc.name])); + return; + } + if (jc.status === "Completed") { + me.submit_job_card(jc.name); + return; + } + if (jc.is_paused) { + me.resume_job(jc.name); + return; + } + const last_log = jc.time_logs && jc.time_logs.length ? jc.time_logs[jc.time_logs.length - 1] : null; + const is_running = !!(last_log && !last_log.to_time); + if (is_running) { + me.prompt_running_action(jc); + } else { + me.start_job(jc.name); + } + } + + prompt_running_action(jc) { + const me = this; + const dialog = new frappe.ui.Dialog({ + title: __("Job {0} is running", [jc.name]), + fields: [ + { + fieldtype: "HTML", + options: ` +
+ ${__("{0} is already in progress. Pause it or complete the session.", [ + frappe.utils.escape_html(jc.finished_good || jc.production_item || jc.name), + ])} +
+ `, + }, + ], + primary_action_label: __("Complete"), + primary_action: () => { + dialog.hide(); + me.end_session(jc.name); + }, + secondary_action_label: __("Pause"), + secondary_action: () => { + dialog.hide(); + me.pause_job(jc.name); + }, + }); + dialog.show(); + this.bind_enter_submit(dialog); + } + + // ── Route options (e.g. the Work Order "Shop Floor" button) ──────────────── + apply_route_options() { + const opts = frappe.route_options; + if (!opts || (!opts.work_order && !opts.workstation)) { + return; + } + frappe.route_options = null; + + // A specific work order / machine was requested — show it in the operator view. + this.view = "operator"; + this.render_shell_controls(); + this.render_view(); + Promise.all([ + this.work_order_filter.set_value(opts.work_order || ""), + this.workstation_filter.set_value(opts.workstation || ""), + ]).then(() => this.load_operator()); + } + + // ── Styles ────────────────────────────────────────────────────────────────── + styles() { + return ``; + } +} + +frappe.ui.ShopFloor = ShopFloor; From 94c81965a7c08c084119ecfb2356d5e2c9d1e1ae Mon Sep 17 00:00:00 2001 From: Mihir Kandoi Date: Sun, 9 Aug 2026 23:02:58 +0530 Subject: [PATCH 2/2] test(manufacturing): cover job card UOM backfill --- .../doctype/job_card/test_job_card.py | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/erpnext/manufacturing/doctype/job_card/test_job_card.py b/erpnext/manufacturing/doctype/job_card/test_job_card.py index cfd559202be..1d58ebb5bce 100644 --- a/erpnext/manufacturing/doctype/job_card/test_job_card.py +++ b/erpnext/manufacturing/doctype/job_card/test_job_card.py @@ -22,6 +22,7 @@ from erpnext.manufacturing.doctype.job_card.job_card import ( from erpnext.manufacturing.doctype.work_order.test_work_order import make_wo_order_test_record from erpnext.manufacturing.doctype.work_order.work_order import WorkOrder, make_work_order from erpnext.manufacturing.doctype.workstation.test_workstation import make_workstation +from erpnext.patches.v16_0.set_stock_uom_in_job_card import execute as set_stock_uom_in_job_card from erpnext.stock.doctype.item.test_item import create_item from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry from erpnext.tests.utils import ERPNextTestSuite @@ -909,6 +910,47 @@ class TestJobCard(ERPNextTestSuite): self.assertEqual(job_card.stock_uom, frappe.db.get_value("Item", item_code, "stock_uom")) + def test_stock_uom_patch_backfills_legacy_job_cards(self): + suffix = random_string(8) + finished_good = create_item(f"Stock UOM Patch FG {suffix}", stock_uom="Kg") + production_item = create_item(f"Stock UOM Patch Product {suffix}", stock_uom="Nos") + + finished_good_job_card = self.get_first_job_card( + make_wo_order_test_record(item="_Test FG Item 2", qty=5).name + ) + production_item_job_card = self.get_first_job_card( + make_wo_order_test_record(item="_Test FG Item 2", qty=6).name + ) + + frappe.db.set_value( + "Job Card", + finished_good_job_card.name, + { + "finished_good": finished_good.name, + "production_item": production_item.name, + "stock_uom": None, + }, + update_modified=False, + ) + frappe.db.set_value( + "Job Card", + production_item_job_card.name, + {"finished_good": None, "production_item": production_item.name, "stock_uom": None}, + update_modified=False, + ) + + set_stock_uom_in_job_card() + + self.assertEqual(frappe.db.get_value("Job Card", finished_good_job_card.name, "stock_uom"), "Kg") + self.assertEqual(frappe.db.get_value("Job Card", production_item_job_card.name, "stock_uom"), "Nos") + + frappe.db.set_value( + "Job Card", finished_good_job_card.name, "stock_uom", "Nos", update_modified=False + ) + set_stock_uom_in_job_card() + + self.assertEqual(frappe.db.get_value("Job Card", finished_good_job_card.name, "stock_uom"), "Nos") + def test_completion_qty_reduces_for_quantity_without_process_loss(self): work_order = make_wo_order_test_record(item="_Test FG Item 2", qty=5)