From 29a1cb89c245f68a4db6190ccd2d83ea91c348fe Mon Sep 17 00:00:00 2001 From: Sagar Sharma Date: Tue, 26 Apr 2022 17:29:45 +0530 Subject: [PATCH] feat: SubcontractingController --- .../controllers/subcontracting_controller.py | 641 ++++++++++++++++++ 1 file changed, 641 insertions(+) create mode 100644 erpnext/controllers/subcontracting_controller.py diff --git a/erpnext/controllers/subcontracting_controller.py b/erpnext/controllers/subcontracting_controller.py new file mode 100644 index 0000000000..b393737740 --- /dev/null +++ b/erpnext/controllers/subcontracting_controller.py @@ -0,0 +1,641 @@ +# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors +# For license information, please see license.txt + +import copy +from collections import defaultdict + +import frappe +from frappe import _ +from frappe.utils import cint, cstr, flt, get_link_to_form + +from erpnext.controllers.stock_controller import StockController +from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos +from erpnext.stock.utils import get_incoming_rate + + +class SubcontractingController(StockController): + def before_validate(self): + self.remove_empty_rows() + self.set_items_conversion_factor() + + def validate(self): + self.validate_items() + self.create_raw_materials_supplied() + + def remove_empty_rows(self): + for key in ["service_items", "items", "supplied_items"]: + if self.get(key): + idx = 1 + for item in self.get(key)[:]: + if not (item.get("item_code") or item.get("main_item_code")): + self.get(key).remove(item) + else: + item.idx = idx + idx += 1 + + def set_items_conversion_factor(self): + for item in self.get("items"): + if not item.conversion_factor: + item.conversion_factor = 1 + + def validate_items(self): + for item in self.items: + if not frappe.get_value("Item", item.item_code, "is_sub_contracted_item"): + msg = f"Item {item.item_name} must be a subcontracted item." + frappe.throw(_(msg)) + if item.bom: + bom = frappe.get_doc("BOM", item.bom) + if not bom.is_active: + msg = f"Please select an active BOM for Item {item.item_name}." + frappe.throw(_(msg)) + if bom.item != item.item_code: + msg = f"Please select an valid BOM for Item {item.item_name}." + frappe.throw(_(msg)) + + def __get_data_before_save(self): + item_dict = {} + if self.doctype == "Subcontracting Receipt" and self._doc_before_save: + for row in self._doc_before_save.get("items"): + item_dict[row.name] = (row.item_code, row.qty) + + return item_dict + + def __identify_change_in_item_table(self): + self.__changed_name = [] + self.__reference_name = [] + + if self.doctype == "Subcontracting Order" or self.is_new(): + self.set(self.raw_material_table, []) + return + + item_dict = self.__get_data_before_save() + if not item_dict: + return True + + for row in self.items: + self.__reference_name.append(row.name) + if (row.name not in item_dict) or (row.item_code, row.qty) != item_dict[row.name]: + self.__changed_name.append(row.name) + + if item_dict.get(row.name): + del item_dict[row.name] + + self.__changed_name.extend(item_dict.keys()) + + def __get_backflush_based_on(self): + self.backflush_based_on = frappe.db.get_single_value( + "Buying Settings", "backflush_raw_materials_of_subcontract_based_on" + ) + + def initialized_fields(self): + self.available_materials = frappe._dict() + self.__transferred_items = frappe._dict() + self.alternative_item_details = frappe._dict() + self.__get_backflush_based_on() + + def __get_subcontracting_orders(self): + self.subcontracting_orders = [] + + if self.doctype == "Subcontracting Order": + return + + self.subcontracting_orders = [ + item.subcontracting_order for item in self.items if item.subcontracting_order + ] + + def __get_pending_qty_to_receive(self): + """Get qty to be received against the subcontracting order.""" + + self.qty_to_be_received = defaultdict(float) + + if ( + self.doctype != "Subcontracting Order" + and self.backflush_based_on != "BOM" + and self.subcontracting_orders + ): + for row in frappe.get_all( + "Subcontracting Order Item", + fields=["item_code", "(qty - received_qty) as qty", "parent", "name"], + filters={"docstatus": 1, "parent": ("in", self.subcontracting_orders)}, + ): + + self.qty_to_be_received[(row.item_code, row.parent)] += row.qty + + def __get_transferred_items(self): + fields = ["`tabStock Entry`.`subcontracting_order`"] + alias_dict = { + "item_code": "rm_item_code", + "subcontracted_item": "main_item_code", + "basic_rate": "rate", + } + + child_table_fields = [ + "item_code", + "item_name", + "description", + "qty", + "basic_rate", + "amount", + "serial_no", + "uom", + "subcontracted_item", + "stock_uom", + "batch_no", + "conversion_factor", + "s_warehouse", + "t_warehouse", + "item_group", + "sco_rm_detail", + ] + + if self.backflush_based_on == "BOM": + child_table_fields.append("original_item") + + for field in child_table_fields: + fields.append(f"`tabStock Entry Detail`.`{field}` As {alias_dict.get(field, field)}") + + filters = [ + ["Stock Entry", "docstatus", "=", 1], + ["Stock Entry", "purpose", "=", "Send to Subcontractor"], + ["Stock Entry", "subcontracting_order", "in", self.subcontracting_orders], + ] + + return frappe.get_all("Stock Entry", fields=fields, filters=filters) + + def __set_alternative_item_details(self, row): + if row.get("original_item"): + self.alternative_item_details[row.get("original_item")] = row + + def __get_received_items(self, doctype): + fields = [] + self.sco_field = "subcontracting_order" + + for field in ["name", self.sco_field, "parent"]: + fields.append(f"`tab{doctype} Item`.`{field}`") + + filters = [ + [doctype, "docstatus", "=", 1], + [f"{doctype} Item", self.sco_field, "in", self.subcontracting_orders], + ] + + return frappe.get_all(f"{doctype}", fields=fields, filters=filters) + + def __get_consumed_items(self, doctype, scr_items): + return frappe.get_all( + "Subcontracting Receipt Supplied Item", + fields=[ + "serial_no", + "rm_item_code", + "reference_name", + "batch_no", + "consumed_qty", + "main_item_code", + ], + filters={"docstatus": 1, "reference_name": ("in", list(scr_items)), "parenttype": doctype}, + ) + + def __update_consumed_materials(self, doctype, return_consumed_items=False): + """Deduct the consumed materials from the available materials.""" + + scr_items = self.__get_received_items(doctype) + if not scr_items: + return ([], {}) if return_consumed_items else None + + scr_items = { + item.name: item.get(self.get("sco_field") or "subcontracting_order") for item in scr_items + } + consumed_materials = self.__get_consumed_items(doctype, scr_items.keys()) + + if return_consumed_items: + return (consumed_materials, scr_items) + + for row in consumed_materials: + key = (row.rm_item_code, row.main_item_code, scr_items.get(row.reference_name)) + if not self.available_materials.get(key): + continue + + self.available_materials[key]["qty"] -= row.consumed_qty + if row.serial_no: + self.available_materials[key]["serial_no"] = list( + set(self.available_materials[key]["serial_no"]) - set(get_serial_nos(row.serial_no)) + ) + + if row.batch_no: + self.available_materials[key]["batch_no"][row.batch_no] -= row.consumed_qty + + def get_available_materials(self): + """Get the available raw materials which has been transferred to the supplier. + available_materials = { + (item_code, subcontracted_item, subcontracting_order): { + 'qty': 1, 'serial_no': [ABC], 'batch_no': {'batch1': 1}, 'data': item_details + } + } + """ + if not self.subcontracting_orders: + return + + for row in self.__get_transferred_items(): + key = (row.rm_item_code, row.main_item_code, row.subcontracting_order) + + if key not in self.available_materials: + self.available_materials.setdefault( + key, + frappe._dict( + { + "qty": 0, + "serial_no": [], + "batch_no": defaultdict(float), + "item_details": row, + "sco_rm_details": [], + } + ), + ) + + details = self.available_materials[key] + details.qty += row.qty + details.sco_rm_details.append(row.sco_rm_detail) + + if row.serial_no: + details.serial_no.extend(get_serial_nos(row.serial_no)) + + if row.batch_no: + details.batch_no[row.batch_no] += row.qty + + self.__set_alternative_item_details(row) + + self.__transferred_items = copy.deepcopy(self.available_materials) + self.__update_consumed_materials("Subcontracting Receipt") + + def __remove_changed_rows(self): + if not self.__changed_name: + return + + i = 1 + self.set(self.raw_material_table, []) + for item in self._doc_before_save.supplied_items: + if item.reference_name in self.__changed_name: + continue + + if item.reference_name not in self.__reference_name: + continue + + item.idx = i + self.append("supplied_items", item) + + i += 1 + + def __get_materials_from_bom(self, item_code, bom_no, exploded_item=0): + doctype = "BOM Item" if not exploded_item else "BOM Explosion Item" + fields = [f"`tab{doctype}`.`stock_qty` / `tabBOM`.`quantity` as qty_consumed_per_unit"] + + alias_dict = { + "item_code": "rm_item_code", + "name": "bom_detail_no", + "source_warehouse": "reserve_warehouse", + } + for field in [ + "item_code", + "name", + "rate", + "stock_uom", + "source_warehouse", + "description", + "item_name", + "stock_uom", + ]: + fields.append(f"`tab{doctype}`.`{field}` As {alias_dict.get(field, field)}") + + filters = [ + [doctype, "parent", "=", bom_no], + [doctype, "docstatus", "=", 1], + ["BOM", "item", "=", item_code], + [doctype, "sourced_by_supplier", "=", 0], + ] + + return ( + frappe.get_all("BOM", fields=fields, filters=filters, order_by=f"`tab{doctype}`.`idx`") or [] + ) + + def __update_reserve_warehouse(self, row, item): + if self.doctype == "Subcontracting Order": + row.reserve_warehouse = self.set_reserve_warehouse or item.warehouse + + def __set_alternative_item(self, bom_item): + if self.alternative_item_details.get(bom_item.rm_item_code): + bom_item.update(self.alternative_item_details[bom_item.rm_item_code]) + + def __set_serial_nos(self, item_row, rm_obj): + key = (rm_obj.rm_item_code, item_row.item_code, item_row.subcontracting_order) + if self.available_materials.get(key) and self.available_materials[key]["serial_no"]: + used_serial_nos = self.available_materials[key]["serial_no"][0 : cint(rm_obj.consumed_qty)] + rm_obj.serial_no = "\n".join(used_serial_nos) + + # Removed the used serial nos from the list + for sn in used_serial_nos: + self.available_materials[key]["serial_no"].remove(sn) + + def __set_batch_no_as_per_qty(self, item_row, rm_obj, batch_no, qty): + rm_obj.update( + { + "consumed_qty": qty, + "batch_no": batch_no, + "required_qty": qty, + "subcontracting_order": item_row.subcontracting_order, + } + ) + + self.__set_serial_nos(item_row, rm_obj) + + def __set_consumed_qty(self, rm_obj, consumed_qty, required_qty=0): + rm_obj.required_qty = required_qty + rm_obj.consumed_qty = consumed_qty + + def __set_batch_nos(self, bom_item, item_row, rm_obj, qty): + key = (rm_obj.rm_item_code, item_row.item_code, item_row.subcontracting_order) + + if self.available_materials.get(key) and self.available_materials[key]["batch_no"]: + new_rm_obj = None + for batch_no, batch_qty in self.available_materials[key]["batch_no"].items(): + if batch_qty >= qty: + self.__set_batch_no_as_per_qty(item_row, rm_obj, batch_no, qty) + self.available_materials[key]["batch_no"][batch_no] -= qty + return + + elif qty > 0 and batch_qty > 0: + qty -= batch_qty + new_rm_obj = self.append(self.raw_material_table, bom_item) + new_rm_obj.reference_name = item_row.name + self.__set_batch_no_as_per_qty(item_row, new_rm_obj, batch_no, batch_qty) + self.available_materials[key]["batch_no"][batch_no] = 0 + + if abs(qty) > 0 and not new_rm_obj: + self.__set_consumed_qty(rm_obj, qty) + else: + self.__set_consumed_qty(rm_obj, qty, bom_item.required_qty or qty) + self.__set_serial_nos(item_row, rm_obj) + + def __add_supplied_item(self, item_row, bom_item, qty): + bom_item.conversion_factor = item_row.conversion_factor + rm_obj = self.append(self.raw_material_table, bom_item) + rm_obj.reference_name = item_row.name + + if self.doctype == "Subcontracting Receipt": + args = frappe._dict( + { + "item_code": rm_obj.rm_item_code, + "warehouse": self.supplier_warehouse, + "posting_date": self.posting_date, + "posting_time": self.posting_time, + "qty": -1 * flt(rm_obj.consumed_qty), + "serial_no": rm_obj.serial_no, + "batch_no": rm_obj.batch_no, + "voucher_type": self.doctype, + "voucher_no": self.name, + "company": self.company, + "allow_zero_valuation": 1, + } + ) + rm_obj.rate = get_incoming_rate(args) + + if self.doctype == "Subcontracting Order": + rm_obj.required_qty = qty + rm_obj.amount = rm_obj.required_qty * rm_obj.rate + else: + rm_obj.consumed_qty = 0 + rm_obj.subcontracting_order = item_row.subcontracting_order + self.__set_batch_nos(bom_item, item_row, rm_obj, qty) + + def __get_qty_based_on_material_transfer(self, item_row, transfer_item): + key = (item_row.item_code, item_row.subcontracting_order) + + if self.qty_to_be_received == item_row.qty: + return transfer_item.qty + + if self.qty_to_be_received: + qty = (flt(item_row.qty) * flt(transfer_item.qty)) / flt(self.qty_to_be_received.get(key, 0)) + transfer_item.item_details.required_qty = transfer_item.qty + + if transfer_item.serial_no or frappe.get_cached_value( + "UOM", transfer_item.item_details.stock_uom, "must_be_whole_number" + ): + return frappe.utils.ceil(qty) + + return qty + + def __set_supplied_items(self): + self.bom_items = {} + + has_supplied_items = True if self.get(self.raw_material_table) else False + for row in self.items: + if self.doctype != "Subcontracting Order" and ( + (self.__changed_name and row.name not in self.__changed_name) + or (has_supplied_items and not self.__changed_name) + ): + continue + + if self.doctype == "Subcontracting Order" or self.backflush_based_on == "BOM": + for bom_item in self.__get_materials_from_bom( + row.item_code, row.bom, row.get("include_exploded_items") + ): + qty = flt(bom_item.qty_consumed_per_unit) * flt(row.qty) * row.conversion_factor + bom_item.main_item_code = row.item_code + self.__update_reserve_warehouse(bom_item, row) + self.__set_alternative_item(bom_item) + self.__add_supplied_item(row, bom_item, qty) + + elif self.backflush_based_on != "BOM": + for key, transfer_item in self.available_materials.items(): + if (key[1], key[2]) == (row.item_code, row.subcontracting_order) and transfer_item.qty > 0: + qty = self.__get_qty_based_on_material_transfer(row, transfer_item) or 0 + transfer_item.qty -= qty + self.__add_supplied_item(row, transfer_item.get("item_details"), qty) + + if self.qty_to_be_received: + self.qty_to_be_received[(row.item_code, row.subcontracting_order)] -= row.qty + + def __prepare_supplied_items(self): + self.initialized_fields() + self.__get_subcontracting_orders() + self.__get_pending_qty_to_receive() + self.get_available_materials() + self.__remove_changed_rows() + self.__set_supplied_items() + + def __validate_batch_no(self, row, key): + if row.get("batch_no") and row.get("batch_no") not in self.__transferred_items.get(key).get( + "batch_no" + ): + link = get_link_to_form("Subcontracting Order", row.subcontracting_order) + msg = f'The Batch No {frappe.bold(row.get("batch_no"))} has not supplied against the Subcontracting Order {link}' + frappe.throw(_(msg), title=_("Incorrect Batch Consumed")) + + def __validate_serial_no(self, row, key): + if row.get("serial_no"): + serial_nos = get_serial_nos(row.get("serial_no")) + incorrect_sn = set(serial_nos).difference(self.__transferred_items.get(key).get("serial_no")) + + if incorrect_sn: + incorrect_sn = "\n".join(incorrect_sn) + link = get_link_to_form("Subcontracting Order", row.subcontracting_order) + msg = f"The Serial Nos {incorrect_sn} has not supplied against the Subcontracting Order {link}" + frappe.throw(_(msg), title=_("Incorrect Serial Number Consumed")) + + def __validate_supplied_items(self): + if self.doctype != "Subcontracting Receipt": + return + + for row in self.get(self.raw_material_table): + key = (row.rm_item_code, row.main_item_code, row.subcontracting_order) + if not self.__transferred_items or not self.__transferred_items.get(key): + return + + self.__validate_batch_no(row, key) + self.__validate_serial_no(row, key) + + def set_materials_for_subcontracted_items(self, raw_material_table): + self.raw_material_table = raw_material_table + self.__identify_change_in_item_table() + self.__prepare_supplied_items() + self.__validate_supplied_items() + + def create_raw_materials_supplied(self, raw_material_table="supplied_items"): + self.set_materials_for_subcontracted_items(raw_material_table) + + if self.doctype == "Subcontracting Receipt": + for item in self.get("items"): + item.rm_supp_cost = 0.0 + + def __update_consumed_qty_in_sco(self, itemwise_consumed_qty): + fields = ["main_item_code", "rm_item_code", "parent", "supplied_qty", "name"] + filters = {"docstatus": 1, "parent": ("in", self.subcontracting_orders)} + + for row in frappe.get_all( + "Subcontracting Order Supplied Item", fields=fields, filters=filters, order_by="idx" + ): + key = (row.rm_item_code, row.main_item_code, row.parent) + consumed_qty = itemwise_consumed_qty.get(key, 0) + + if row.supplied_qty < consumed_qty: + consumed_qty = row.supplied_qty + + itemwise_consumed_qty[key] -= consumed_qty + frappe.db.set_value( + "Subcontracting Order Supplied Item", row.name, "consumed_qty", consumed_qty + ) + + def set_consumed_qty_in_sco(self): + # Update consumed qty back in the subcontracting order + self.__get_subcontracting_orders() + itemwise_consumed_qty = defaultdict(float) + consumed_items, scr_items = self.__update_consumed_materials( + "Subcontracting Receipt", return_consumed_items=True + ) + + for row in consumed_items: + key = (row.rm_item_code, row.main_item_code, scr_items.get(row.reference_name)) + itemwise_consumed_qty[key] += row.consumed_qty + + self.__update_consumed_qty_in_sco(itemwise_consumed_qty) + + def update_ordered_and_reserved_qty(self): + sco_map = {} + for item in self.get("items"): + if self.doctype == "Subcontracting Receipt" and item.subcontracting_order: + sco_map.setdefault(item.subcontracting_order, []).append(item.subcontracting_order_item) + + for sco, sco_item_rows in sco_map.items(): + if sco and sco_item_rows: + sco_doc = frappe.get_doc("Subcontracting Order", sco) + + if sco_doc.status in ["Closed", "Cancelled"]: + frappe.throw( + _("{0} {1} is cancelled or closed").format(_("Subcontracting Order"), sco), + frappe.InvalidStatusError, + ) + + sco_doc.update_ordered_qty_for_subcontracting(sco_item_rows) + sco_doc.update_reserved_qty_for_subcontracting() + + def make_sl_entries_for_supplier_warehouse(self, sl_entries): + if hasattr(self, "supplied_items"): + for item in self.get("supplied_items"): + # negative quantity is passed, as raw material qty has to be decreased + # when SCR is submitted and it has to be increased when SCR is cancelled + sl_entries.append( + self.get_sl_entries( + item, + { + "item_code": item.rm_item_code, + "warehouse": self.supplier_warehouse, + "actual_qty": -1 * flt(item.consumed_qty), + "dependant_sle_voucher_detail_no": item.reference_name, + }, + ) + ) + + def update_stock_ledger(self, allow_negative_stock=False, via_landed_cost_voucher=False): + self.update_ordered_and_reserved_qty() + + sl_entries = [] + stock_items = self.get_stock_items() + + for item in self.get("items"): + if item.item_code in stock_items and item.warehouse: + scr_qty = flt(item.qty) * flt(item.conversion_factor) + + if scr_qty: + sle = self.get_sl_entries( + item, {"actual_qty": flt(scr_qty), "serial_no": cstr(item.serial_no).strip()} + ) + rate_db_precision = 6 if cint(self.precision("rate", item)) <= 6 else 9 + incoming_rate = flt(item.rate, rate_db_precision) + sle.update( + { + "incoming_rate": incoming_rate, + "recalculate_rate": 1, + } + ) + sl_entries.append(sle) + + if flt(item.rejected_qty) != 0: + sl_entries.append( + self.get_sl_entries( + item, + { + "warehouse": item.rejected_warehouse, + "actual_qty": flt(item.rejected_qty) * flt(item.conversion_factor), + "serial_no": cstr(item.rejected_serial_no).strip(), + "incoming_rate": 0.0, + "recalculate_rate": 1, + }, + ) + ) + + self.make_sl_entries_for_supplier_warehouse(sl_entries) + self.make_sl_entries( + sl_entries, + allow_negative_stock=allow_negative_stock, + via_landed_cost_voucher=via_landed_cost_voucher, + ) + + def get_supplied_items_cost(self, item_row_id): + supplied_items_cost = 0.0 + for item in self.get("supplied_items"): + if item.reference_name == item_row_id: + item.amount = flt(flt(item.consumed_qty) * flt(item.rate), item.precision("amount")) + supplied_items_cost += item.amount + + return supplied_items_cost + + @property + def sub_contracted_items(self): + if not hasattr(self, "_sub_contracted_items"): + self._sub_contracted_items = [] + item_codes = list(set(item.item_code for item in self.get("items"))) + if item_codes: + items = frappe.get_all( + "Item", filters={"name": ["in", item_codes], "is_sub_contracted_item": 1} + ) + self._sub_contracted_items = [item.name for item in items] + + return self._sub_contracted_items