Sagar Sharma | 29a1cb8 | 2022-04-26 17:29:45 +0530 | [diff] [blame] | 1 | # Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors |
| 2 | # For license information, please see license.txt |
| 3 | |
| 4 | import copy |
| 5 | from collections import defaultdict |
| 6 | |
| 7 | import frappe |
| 8 | from frappe import _ |
| 9 | from frappe.utils import cint, cstr, flt, get_link_to_form |
| 10 | |
| 11 | from erpnext.controllers.stock_controller import StockController |
| 12 | from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos |
| 13 | from erpnext.stock.utils import get_incoming_rate |
| 14 | |
| 15 | |
| 16 | class SubcontractingController(StockController): |
| 17 | def before_validate(self): |
| 18 | self.remove_empty_rows() |
| 19 | self.set_items_conversion_factor() |
| 20 | |
| 21 | def validate(self): |
| 22 | self.validate_items() |
| 23 | self.create_raw_materials_supplied() |
| 24 | |
| 25 | def remove_empty_rows(self): |
| 26 | for key in ["service_items", "items", "supplied_items"]: |
| 27 | if self.get(key): |
| 28 | idx = 1 |
| 29 | for item in self.get(key)[:]: |
| 30 | if not (item.get("item_code") or item.get("main_item_code")): |
| 31 | self.get(key).remove(item) |
| 32 | else: |
| 33 | item.idx = idx |
| 34 | idx += 1 |
| 35 | |
| 36 | def set_items_conversion_factor(self): |
| 37 | for item in self.get("items"): |
| 38 | if not item.conversion_factor: |
| 39 | item.conversion_factor = 1 |
| 40 | |
| 41 | def validate_items(self): |
| 42 | for item in self.items: |
| 43 | if not frappe.get_value("Item", item.item_code, "is_sub_contracted_item"): |
| 44 | msg = f"Item {item.item_name} must be a subcontracted item." |
| 45 | frappe.throw(_(msg)) |
| 46 | if item.bom: |
| 47 | bom = frappe.get_doc("BOM", item.bom) |
| 48 | if not bom.is_active: |
| 49 | msg = f"Please select an active BOM for Item {item.item_name}." |
| 50 | frappe.throw(_(msg)) |
| 51 | if bom.item != item.item_code: |
| 52 | msg = f"Please select an valid BOM for Item {item.item_name}." |
| 53 | frappe.throw(_(msg)) |
| 54 | |
| 55 | def __get_data_before_save(self): |
| 56 | item_dict = {} |
| 57 | if self.doctype == "Subcontracting Receipt" and self._doc_before_save: |
| 58 | for row in self._doc_before_save.get("items"): |
| 59 | item_dict[row.name] = (row.item_code, row.qty) |
| 60 | |
| 61 | return item_dict |
| 62 | |
| 63 | def __identify_change_in_item_table(self): |
| 64 | self.__changed_name = [] |
| 65 | self.__reference_name = [] |
| 66 | |
| 67 | if self.doctype == "Subcontracting Order" or self.is_new(): |
| 68 | self.set(self.raw_material_table, []) |
| 69 | return |
| 70 | |
| 71 | item_dict = self.__get_data_before_save() |
| 72 | if not item_dict: |
| 73 | return True |
| 74 | |
| 75 | for row in self.items: |
| 76 | self.__reference_name.append(row.name) |
| 77 | if (row.name not in item_dict) or (row.item_code, row.qty) != item_dict[row.name]: |
| 78 | self.__changed_name.append(row.name) |
| 79 | |
| 80 | if item_dict.get(row.name): |
| 81 | del item_dict[row.name] |
| 82 | |
| 83 | self.__changed_name.extend(item_dict.keys()) |
| 84 | |
| 85 | def __get_backflush_based_on(self): |
| 86 | self.backflush_based_on = frappe.db.get_single_value( |
| 87 | "Buying Settings", "backflush_raw_materials_of_subcontract_based_on" |
| 88 | ) |
| 89 | |
| 90 | def initialized_fields(self): |
| 91 | self.available_materials = frappe._dict() |
| 92 | self.__transferred_items = frappe._dict() |
| 93 | self.alternative_item_details = frappe._dict() |
| 94 | self.__get_backflush_based_on() |
| 95 | |
| 96 | def __get_subcontracting_orders(self): |
| 97 | self.subcontracting_orders = [] |
| 98 | |
| 99 | if self.doctype == "Subcontracting Order": |
| 100 | return |
| 101 | |
| 102 | self.subcontracting_orders = [ |
| 103 | item.subcontracting_order for item in self.items if item.subcontracting_order |
| 104 | ] |
| 105 | |
| 106 | def __get_pending_qty_to_receive(self): |
| 107 | """Get qty to be received against the subcontracting order.""" |
| 108 | |
| 109 | self.qty_to_be_received = defaultdict(float) |
| 110 | |
| 111 | if ( |
| 112 | self.doctype != "Subcontracting Order" |
| 113 | and self.backflush_based_on != "BOM" |
| 114 | and self.subcontracting_orders |
| 115 | ): |
| 116 | for row in frappe.get_all( |
| 117 | "Subcontracting Order Item", |
| 118 | fields=["item_code", "(qty - received_qty) as qty", "parent", "name"], |
| 119 | filters={"docstatus": 1, "parent": ("in", self.subcontracting_orders)}, |
| 120 | ): |
| 121 | |
| 122 | self.qty_to_be_received[(row.item_code, row.parent)] += row.qty |
| 123 | |
| 124 | def __get_transferred_items(self): |
| 125 | fields = ["`tabStock Entry`.`subcontracting_order`"] |
| 126 | alias_dict = { |
| 127 | "item_code": "rm_item_code", |
| 128 | "subcontracted_item": "main_item_code", |
| 129 | "basic_rate": "rate", |
| 130 | } |
| 131 | |
| 132 | child_table_fields = [ |
| 133 | "item_code", |
| 134 | "item_name", |
| 135 | "description", |
| 136 | "qty", |
| 137 | "basic_rate", |
| 138 | "amount", |
| 139 | "serial_no", |
| 140 | "uom", |
| 141 | "subcontracted_item", |
| 142 | "stock_uom", |
| 143 | "batch_no", |
| 144 | "conversion_factor", |
| 145 | "s_warehouse", |
| 146 | "t_warehouse", |
| 147 | "item_group", |
| 148 | "sco_rm_detail", |
| 149 | ] |
| 150 | |
| 151 | if self.backflush_based_on == "BOM": |
| 152 | child_table_fields.append("original_item") |
| 153 | |
| 154 | for field in child_table_fields: |
| 155 | fields.append(f"`tabStock Entry Detail`.`{field}` As {alias_dict.get(field, field)}") |
| 156 | |
| 157 | filters = [ |
| 158 | ["Stock Entry", "docstatus", "=", 1], |
| 159 | ["Stock Entry", "purpose", "=", "Send to Subcontractor"], |
| 160 | ["Stock Entry", "subcontracting_order", "in", self.subcontracting_orders], |
| 161 | ] |
| 162 | |
| 163 | return frappe.get_all("Stock Entry", fields=fields, filters=filters) |
| 164 | |
| 165 | def __set_alternative_item_details(self, row): |
| 166 | if row.get("original_item"): |
| 167 | self.alternative_item_details[row.get("original_item")] = row |
| 168 | |
| 169 | def __get_received_items(self, doctype): |
| 170 | fields = [] |
| 171 | self.sco_field = "subcontracting_order" |
| 172 | |
| 173 | for field in ["name", self.sco_field, "parent"]: |
| 174 | fields.append(f"`tab{doctype} Item`.`{field}`") |
| 175 | |
| 176 | filters = [ |
| 177 | [doctype, "docstatus", "=", 1], |
| 178 | [f"{doctype} Item", self.sco_field, "in", self.subcontracting_orders], |
| 179 | ] |
| 180 | |
| 181 | return frappe.get_all(f"{doctype}", fields=fields, filters=filters) |
| 182 | |
| 183 | def __get_consumed_items(self, doctype, scr_items): |
| 184 | return frappe.get_all( |
| 185 | "Subcontracting Receipt Supplied Item", |
| 186 | fields=[ |
| 187 | "serial_no", |
| 188 | "rm_item_code", |
| 189 | "reference_name", |
| 190 | "batch_no", |
| 191 | "consumed_qty", |
| 192 | "main_item_code", |
| 193 | ], |
| 194 | filters={"docstatus": 1, "reference_name": ("in", list(scr_items)), "parenttype": doctype}, |
| 195 | ) |
| 196 | |
| 197 | def __update_consumed_materials(self, doctype, return_consumed_items=False): |
| 198 | """Deduct the consumed materials from the available materials.""" |
| 199 | |
| 200 | scr_items = self.__get_received_items(doctype) |
| 201 | if not scr_items: |
| 202 | return ([], {}) if return_consumed_items else None |
| 203 | |
| 204 | scr_items = { |
| 205 | item.name: item.get(self.get("sco_field") or "subcontracting_order") for item in scr_items |
| 206 | } |
| 207 | consumed_materials = self.__get_consumed_items(doctype, scr_items.keys()) |
| 208 | |
| 209 | if return_consumed_items: |
| 210 | return (consumed_materials, scr_items) |
| 211 | |
| 212 | for row in consumed_materials: |
| 213 | key = (row.rm_item_code, row.main_item_code, scr_items.get(row.reference_name)) |
| 214 | if not self.available_materials.get(key): |
| 215 | continue |
| 216 | |
| 217 | self.available_materials[key]["qty"] -= row.consumed_qty |
| 218 | if row.serial_no: |
| 219 | self.available_materials[key]["serial_no"] = list( |
| 220 | set(self.available_materials[key]["serial_no"]) - set(get_serial_nos(row.serial_no)) |
| 221 | ) |
| 222 | |
| 223 | if row.batch_no: |
| 224 | self.available_materials[key]["batch_no"][row.batch_no] -= row.consumed_qty |
| 225 | |
| 226 | def get_available_materials(self): |
| 227 | """Get the available raw materials which has been transferred to the supplier. |
| 228 | available_materials = { |
| 229 | (item_code, subcontracted_item, subcontracting_order): { |
| 230 | 'qty': 1, 'serial_no': [ABC], 'batch_no': {'batch1': 1}, 'data': item_details |
| 231 | } |
| 232 | } |
| 233 | """ |
| 234 | if not self.subcontracting_orders: |
| 235 | return |
| 236 | |
| 237 | for row in self.__get_transferred_items(): |
| 238 | key = (row.rm_item_code, row.main_item_code, row.subcontracting_order) |
| 239 | |
| 240 | if key not in self.available_materials: |
| 241 | self.available_materials.setdefault( |
| 242 | key, |
| 243 | frappe._dict( |
| 244 | { |
| 245 | "qty": 0, |
| 246 | "serial_no": [], |
| 247 | "batch_no": defaultdict(float), |
| 248 | "item_details": row, |
| 249 | "sco_rm_details": [], |
| 250 | } |
| 251 | ), |
| 252 | ) |
| 253 | |
| 254 | details = self.available_materials[key] |
| 255 | details.qty += row.qty |
| 256 | details.sco_rm_details.append(row.sco_rm_detail) |
| 257 | |
| 258 | if row.serial_no: |
| 259 | details.serial_no.extend(get_serial_nos(row.serial_no)) |
| 260 | |
| 261 | if row.batch_no: |
| 262 | details.batch_no[row.batch_no] += row.qty |
| 263 | |
| 264 | self.__set_alternative_item_details(row) |
| 265 | |
| 266 | self.__transferred_items = copy.deepcopy(self.available_materials) |
| 267 | self.__update_consumed_materials("Subcontracting Receipt") |
| 268 | |
| 269 | def __remove_changed_rows(self): |
| 270 | if not self.__changed_name: |
| 271 | return |
| 272 | |
| 273 | i = 1 |
| 274 | self.set(self.raw_material_table, []) |
| 275 | for item in self._doc_before_save.supplied_items: |
| 276 | if item.reference_name in self.__changed_name: |
| 277 | continue |
| 278 | |
| 279 | if item.reference_name not in self.__reference_name: |
| 280 | continue |
| 281 | |
| 282 | item.idx = i |
| 283 | self.append("supplied_items", item) |
| 284 | |
| 285 | i += 1 |
| 286 | |
| 287 | def __get_materials_from_bom(self, item_code, bom_no, exploded_item=0): |
| 288 | doctype = "BOM Item" if not exploded_item else "BOM Explosion Item" |
| 289 | fields = [f"`tab{doctype}`.`stock_qty` / `tabBOM`.`quantity` as qty_consumed_per_unit"] |
| 290 | |
| 291 | alias_dict = { |
| 292 | "item_code": "rm_item_code", |
| 293 | "name": "bom_detail_no", |
| 294 | "source_warehouse": "reserve_warehouse", |
| 295 | } |
| 296 | for field in [ |
| 297 | "item_code", |
| 298 | "name", |
| 299 | "rate", |
| 300 | "stock_uom", |
| 301 | "source_warehouse", |
| 302 | "description", |
| 303 | "item_name", |
| 304 | "stock_uom", |
| 305 | ]: |
| 306 | fields.append(f"`tab{doctype}`.`{field}` As {alias_dict.get(field, field)}") |
| 307 | |
| 308 | filters = [ |
| 309 | [doctype, "parent", "=", bom_no], |
| 310 | [doctype, "docstatus", "=", 1], |
| 311 | ["BOM", "item", "=", item_code], |
| 312 | [doctype, "sourced_by_supplier", "=", 0], |
| 313 | ] |
| 314 | |
| 315 | return ( |
| 316 | frappe.get_all("BOM", fields=fields, filters=filters, order_by=f"`tab{doctype}`.`idx`") or [] |
| 317 | ) |
| 318 | |
| 319 | def __update_reserve_warehouse(self, row, item): |
| 320 | if self.doctype == "Subcontracting Order": |
| 321 | row.reserve_warehouse = self.set_reserve_warehouse or item.warehouse |
| 322 | |
| 323 | def __set_alternative_item(self, bom_item): |
| 324 | if self.alternative_item_details.get(bom_item.rm_item_code): |
| 325 | bom_item.update(self.alternative_item_details[bom_item.rm_item_code]) |
| 326 | |
| 327 | def __set_serial_nos(self, item_row, rm_obj): |
| 328 | key = (rm_obj.rm_item_code, item_row.item_code, item_row.subcontracting_order) |
| 329 | if self.available_materials.get(key) and self.available_materials[key]["serial_no"]: |
| 330 | used_serial_nos = self.available_materials[key]["serial_no"][0 : cint(rm_obj.consumed_qty)] |
| 331 | rm_obj.serial_no = "\n".join(used_serial_nos) |
| 332 | |
| 333 | # Removed the used serial nos from the list |
| 334 | for sn in used_serial_nos: |
| 335 | self.available_materials[key]["serial_no"].remove(sn) |
| 336 | |
| 337 | def __set_batch_no_as_per_qty(self, item_row, rm_obj, batch_no, qty): |
| 338 | rm_obj.update( |
| 339 | { |
| 340 | "consumed_qty": qty, |
| 341 | "batch_no": batch_no, |
| 342 | "required_qty": qty, |
| 343 | "subcontracting_order": item_row.subcontracting_order, |
| 344 | } |
| 345 | ) |
| 346 | |
| 347 | self.__set_serial_nos(item_row, rm_obj) |
| 348 | |
| 349 | def __set_consumed_qty(self, rm_obj, consumed_qty, required_qty=0): |
| 350 | rm_obj.required_qty = required_qty |
| 351 | rm_obj.consumed_qty = consumed_qty |
| 352 | |
| 353 | def __set_batch_nos(self, bom_item, item_row, rm_obj, qty): |
| 354 | key = (rm_obj.rm_item_code, item_row.item_code, item_row.subcontracting_order) |
| 355 | |
| 356 | if self.available_materials.get(key) and self.available_materials[key]["batch_no"]: |
| 357 | new_rm_obj = None |
| 358 | for batch_no, batch_qty in self.available_materials[key]["batch_no"].items(): |
| 359 | if batch_qty >= qty: |
| 360 | self.__set_batch_no_as_per_qty(item_row, rm_obj, batch_no, qty) |
| 361 | self.available_materials[key]["batch_no"][batch_no] -= qty |
| 362 | return |
| 363 | |
| 364 | elif qty > 0 and batch_qty > 0: |
| 365 | qty -= batch_qty |
| 366 | new_rm_obj = self.append(self.raw_material_table, bom_item) |
| 367 | new_rm_obj.reference_name = item_row.name |
| 368 | self.__set_batch_no_as_per_qty(item_row, new_rm_obj, batch_no, batch_qty) |
| 369 | self.available_materials[key]["batch_no"][batch_no] = 0 |
| 370 | |
| 371 | if abs(qty) > 0 and not new_rm_obj: |
| 372 | self.__set_consumed_qty(rm_obj, qty) |
| 373 | else: |
| 374 | self.__set_consumed_qty(rm_obj, qty, bom_item.required_qty or qty) |
| 375 | self.__set_serial_nos(item_row, rm_obj) |
| 376 | |
| 377 | def __add_supplied_item(self, item_row, bom_item, qty): |
| 378 | bom_item.conversion_factor = item_row.conversion_factor |
| 379 | rm_obj = self.append(self.raw_material_table, bom_item) |
| 380 | rm_obj.reference_name = item_row.name |
| 381 | |
| 382 | if self.doctype == "Subcontracting Receipt": |
| 383 | args = frappe._dict( |
| 384 | { |
| 385 | "item_code": rm_obj.rm_item_code, |
| 386 | "warehouse": self.supplier_warehouse, |
| 387 | "posting_date": self.posting_date, |
| 388 | "posting_time": self.posting_time, |
| 389 | "qty": -1 * flt(rm_obj.consumed_qty), |
| 390 | "serial_no": rm_obj.serial_no, |
| 391 | "batch_no": rm_obj.batch_no, |
| 392 | "voucher_type": self.doctype, |
| 393 | "voucher_no": self.name, |
| 394 | "company": self.company, |
| 395 | "allow_zero_valuation": 1, |
| 396 | } |
| 397 | ) |
| 398 | rm_obj.rate = get_incoming_rate(args) |
| 399 | |
| 400 | if self.doctype == "Subcontracting Order": |
| 401 | rm_obj.required_qty = qty |
| 402 | rm_obj.amount = rm_obj.required_qty * rm_obj.rate |
| 403 | else: |
| 404 | rm_obj.consumed_qty = 0 |
| 405 | rm_obj.subcontracting_order = item_row.subcontracting_order |
| 406 | self.__set_batch_nos(bom_item, item_row, rm_obj, qty) |
| 407 | |
| 408 | def __get_qty_based_on_material_transfer(self, item_row, transfer_item): |
| 409 | key = (item_row.item_code, item_row.subcontracting_order) |
| 410 | |
| 411 | if self.qty_to_be_received == item_row.qty: |
| 412 | return transfer_item.qty |
| 413 | |
| 414 | if self.qty_to_be_received: |
| 415 | qty = (flt(item_row.qty) * flt(transfer_item.qty)) / flt(self.qty_to_be_received.get(key, 0)) |
| 416 | transfer_item.item_details.required_qty = transfer_item.qty |
| 417 | |
| 418 | if transfer_item.serial_no or frappe.get_cached_value( |
| 419 | "UOM", transfer_item.item_details.stock_uom, "must_be_whole_number" |
| 420 | ): |
| 421 | return frappe.utils.ceil(qty) |
| 422 | |
| 423 | return qty |
| 424 | |
| 425 | def __set_supplied_items(self): |
| 426 | self.bom_items = {} |
| 427 | |
| 428 | has_supplied_items = True if self.get(self.raw_material_table) else False |
| 429 | for row in self.items: |
| 430 | if self.doctype != "Subcontracting Order" and ( |
| 431 | (self.__changed_name and row.name not in self.__changed_name) |
| 432 | or (has_supplied_items and not self.__changed_name) |
| 433 | ): |
| 434 | continue |
| 435 | |
| 436 | if self.doctype == "Subcontracting Order" or self.backflush_based_on == "BOM": |
| 437 | for bom_item in self.__get_materials_from_bom( |
| 438 | row.item_code, row.bom, row.get("include_exploded_items") |
| 439 | ): |
| 440 | qty = flt(bom_item.qty_consumed_per_unit) * flt(row.qty) * row.conversion_factor |
| 441 | bom_item.main_item_code = row.item_code |
| 442 | self.__update_reserve_warehouse(bom_item, row) |
| 443 | self.__set_alternative_item(bom_item) |
| 444 | self.__add_supplied_item(row, bom_item, qty) |
| 445 | |
| 446 | elif self.backflush_based_on != "BOM": |
| 447 | for key, transfer_item in self.available_materials.items(): |
| 448 | if (key[1], key[2]) == (row.item_code, row.subcontracting_order) and transfer_item.qty > 0: |
| 449 | qty = self.__get_qty_based_on_material_transfer(row, transfer_item) or 0 |
| 450 | transfer_item.qty -= qty |
| 451 | self.__add_supplied_item(row, transfer_item.get("item_details"), qty) |
| 452 | |
| 453 | if self.qty_to_be_received: |
| 454 | self.qty_to_be_received[(row.item_code, row.subcontracting_order)] -= row.qty |
| 455 | |
| 456 | def __prepare_supplied_items(self): |
| 457 | self.initialized_fields() |
| 458 | self.__get_subcontracting_orders() |
| 459 | self.__get_pending_qty_to_receive() |
| 460 | self.get_available_materials() |
| 461 | self.__remove_changed_rows() |
| 462 | self.__set_supplied_items() |
| 463 | |
| 464 | def __validate_batch_no(self, row, key): |
| 465 | if row.get("batch_no") and row.get("batch_no") not in self.__transferred_items.get(key).get( |
| 466 | "batch_no" |
| 467 | ): |
| 468 | link = get_link_to_form("Subcontracting Order", row.subcontracting_order) |
| 469 | msg = f'The Batch No {frappe.bold(row.get("batch_no"))} has not supplied against the Subcontracting Order {link}' |
| 470 | frappe.throw(_(msg), title=_("Incorrect Batch Consumed")) |
| 471 | |
| 472 | def __validate_serial_no(self, row, key): |
| 473 | if row.get("serial_no"): |
| 474 | serial_nos = get_serial_nos(row.get("serial_no")) |
| 475 | incorrect_sn = set(serial_nos).difference(self.__transferred_items.get(key).get("serial_no")) |
| 476 | |
| 477 | if incorrect_sn: |
| 478 | incorrect_sn = "\n".join(incorrect_sn) |
| 479 | link = get_link_to_form("Subcontracting Order", row.subcontracting_order) |
| 480 | msg = f"The Serial Nos {incorrect_sn} has not supplied against the Subcontracting Order {link}" |
| 481 | frappe.throw(_(msg), title=_("Incorrect Serial Number Consumed")) |
| 482 | |
| 483 | def __validate_supplied_items(self): |
| 484 | if self.doctype != "Subcontracting Receipt": |
| 485 | return |
| 486 | |
| 487 | for row in self.get(self.raw_material_table): |
| 488 | key = (row.rm_item_code, row.main_item_code, row.subcontracting_order) |
| 489 | if not self.__transferred_items or not self.__transferred_items.get(key): |
| 490 | return |
| 491 | |
| 492 | self.__validate_batch_no(row, key) |
| 493 | self.__validate_serial_no(row, key) |
| 494 | |
| 495 | def set_materials_for_subcontracted_items(self, raw_material_table): |
| 496 | self.raw_material_table = raw_material_table |
| 497 | self.__identify_change_in_item_table() |
| 498 | self.__prepare_supplied_items() |
| 499 | self.__validate_supplied_items() |
| 500 | |
| 501 | def create_raw_materials_supplied(self, raw_material_table="supplied_items"): |
| 502 | self.set_materials_for_subcontracted_items(raw_material_table) |
| 503 | |
| 504 | if self.doctype == "Subcontracting Receipt": |
| 505 | for item in self.get("items"): |
| 506 | item.rm_supp_cost = 0.0 |
| 507 | |
| 508 | def __update_consumed_qty_in_sco(self, itemwise_consumed_qty): |
| 509 | fields = ["main_item_code", "rm_item_code", "parent", "supplied_qty", "name"] |
| 510 | filters = {"docstatus": 1, "parent": ("in", self.subcontracting_orders)} |
| 511 | |
| 512 | for row in frappe.get_all( |
| 513 | "Subcontracting Order Supplied Item", fields=fields, filters=filters, order_by="idx" |
| 514 | ): |
| 515 | key = (row.rm_item_code, row.main_item_code, row.parent) |
| 516 | consumed_qty = itemwise_consumed_qty.get(key, 0) |
| 517 | |
| 518 | if row.supplied_qty < consumed_qty: |
| 519 | consumed_qty = row.supplied_qty |
| 520 | |
| 521 | itemwise_consumed_qty[key] -= consumed_qty |
| 522 | frappe.db.set_value( |
| 523 | "Subcontracting Order Supplied Item", row.name, "consumed_qty", consumed_qty |
| 524 | ) |
| 525 | |
| 526 | def set_consumed_qty_in_sco(self): |
| 527 | # Update consumed qty back in the subcontracting order |
| 528 | self.__get_subcontracting_orders() |
| 529 | itemwise_consumed_qty = defaultdict(float) |
| 530 | consumed_items, scr_items = self.__update_consumed_materials( |
| 531 | "Subcontracting Receipt", return_consumed_items=True |
| 532 | ) |
| 533 | |
| 534 | for row in consumed_items: |
| 535 | key = (row.rm_item_code, row.main_item_code, scr_items.get(row.reference_name)) |
| 536 | itemwise_consumed_qty[key] += row.consumed_qty |
| 537 | |
| 538 | self.__update_consumed_qty_in_sco(itemwise_consumed_qty) |
| 539 | |
| 540 | def update_ordered_and_reserved_qty(self): |
| 541 | sco_map = {} |
| 542 | for item in self.get("items"): |
| 543 | if self.doctype == "Subcontracting Receipt" and item.subcontracting_order: |
| 544 | sco_map.setdefault(item.subcontracting_order, []).append(item.subcontracting_order_item) |
| 545 | |
| 546 | for sco, sco_item_rows in sco_map.items(): |
| 547 | if sco and sco_item_rows: |
| 548 | sco_doc = frappe.get_doc("Subcontracting Order", sco) |
| 549 | |
| 550 | if sco_doc.status in ["Closed", "Cancelled"]: |
| 551 | frappe.throw( |
| 552 | _("{0} {1} is cancelled or closed").format(_("Subcontracting Order"), sco), |
| 553 | frappe.InvalidStatusError, |
| 554 | ) |
| 555 | |
| 556 | sco_doc.update_ordered_qty_for_subcontracting(sco_item_rows) |
| 557 | sco_doc.update_reserved_qty_for_subcontracting() |
| 558 | |
| 559 | def make_sl_entries_for_supplier_warehouse(self, sl_entries): |
| 560 | if hasattr(self, "supplied_items"): |
| 561 | for item in self.get("supplied_items"): |
| 562 | # negative quantity is passed, as raw material qty has to be decreased |
| 563 | # when SCR is submitted and it has to be increased when SCR is cancelled |
| 564 | sl_entries.append( |
| 565 | self.get_sl_entries( |
| 566 | item, |
| 567 | { |
| 568 | "item_code": item.rm_item_code, |
| 569 | "warehouse": self.supplier_warehouse, |
| 570 | "actual_qty": -1 * flt(item.consumed_qty), |
| 571 | "dependant_sle_voucher_detail_no": item.reference_name, |
| 572 | }, |
| 573 | ) |
| 574 | ) |
| 575 | |
| 576 | def update_stock_ledger(self, allow_negative_stock=False, via_landed_cost_voucher=False): |
| 577 | self.update_ordered_and_reserved_qty() |
| 578 | |
| 579 | sl_entries = [] |
| 580 | stock_items = self.get_stock_items() |
| 581 | |
| 582 | for item in self.get("items"): |
| 583 | if item.item_code in stock_items and item.warehouse: |
| 584 | scr_qty = flt(item.qty) * flt(item.conversion_factor) |
| 585 | |
| 586 | if scr_qty: |
| 587 | sle = self.get_sl_entries( |
| 588 | item, {"actual_qty": flt(scr_qty), "serial_no": cstr(item.serial_no).strip()} |
| 589 | ) |
| 590 | rate_db_precision = 6 if cint(self.precision("rate", item)) <= 6 else 9 |
| 591 | incoming_rate = flt(item.rate, rate_db_precision) |
| 592 | sle.update( |
| 593 | { |
| 594 | "incoming_rate": incoming_rate, |
| 595 | "recalculate_rate": 1, |
| 596 | } |
| 597 | ) |
| 598 | sl_entries.append(sle) |
| 599 | |
| 600 | if flt(item.rejected_qty) != 0: |
| 601 | sl_entries.append( |
| 602 | self.get_sl_entries( |
| 603 | item, |
| 604 | { |
| 605 | "warehouse": item.rejected_warehouse, |
| 606 | "actual_qty": flt(item.rejected_qty) * flt(item.conversion_factor), |
| 607 | "serial_no": cstr(item.rejected_serial_no).strip(), |
| 608 | "incoming_rate": 0.0, |
| 609 | "recalculate_rate": 1, |
| 610 | }, |
| 611 | ) |
| 612 | ) |
| 613 | |
| 614 | self.make_sl_entries_for_supplier_warehouse(sl_entries) |
| 615 | self.make_sl_entries( |
| 616 | sl_entries, |
| 617 | allow_negative_stock=allow_negative_stock, |
| 618 | via_landed_cost_voucher=via_landed_cost_voucher, |
| 619 | ) |
| 620 | |
| 621 | def get_supplied_items_cost(self, item_row_id): |
| 622 | supplied_items_cost = 0.0 |
| 623 | for item in self.get("supplied_items"): |
| 624 | if item.reference_name == item_row_id: |
| 625 | item.amount = flt(flt(item.consumed_qty) * flt(item.rate), item.precision("amount")) |
| 626 | supplied_items_cost += item.amount |
| 627 | |
| 628 | return supplied_items_cost |
| 629 | |
Sagar Sharma | 249726b | 2022-04-22 17:09:19 +0530 | [diff] [blame] | 630 | def set_subcontracting_order_status(self): |
| 631 | if self.doctype == "Subcontracting Order": |
| 632 | self.update_status() |
| 633 | elif self.doctype == "Subcontracting Receipt": |
| 634 | self.__get_subcontracting_orders |
| 635 | |
| 636 | if self.subcontracting_orders: |
| 637 | for sco in set(self.subcontracting_orders): |
| 638 | sco_doc = frappe.get_doc("Subcontracting Order", sco) |
| 639 | sco_doc.update_status() |
| 640 | |
Sagar Sharma | 29a1cb8 | 2022-04-26 17:29:45 +0530 | [diff] [blame] | 641 | @property |
| 642 | def sub_contracted_items(self): |
| 643 | if not hasattr(self, "_sub_contracted_items"): |
| 644 | self._sub_contracted_items = [] |
| 645 | item_codes = list(set(item.item_code for item in self.get("items"))) |
| 646 | if item_codes: |
| 647 | items = frappe.get_all( |
| 648 | "Item", filters={"name": ["in", item_codes], "is_sub_contracted_item": 1} |
| 649 | ) |
| 650 | self._sub_contracted_items = [item.name for item in items] |
| 651 | |
| 652 | return self._sub_contracted_items |