@things-factory/worksheet-base 8.0.0-beta.8 → 8.0.0

package/server/controllers/outbound/sorting-worksheet-controller.ts

@@ -0,0 +1,554 @@
+import { In, IsNull } from 'typeorm'
+
+import { Product, ProductDetail } from '@things-factory/product-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderTote,
+  OrderToteItem,
+  ReleaseGood
+} from '@things-factory/sales-base'
+import {
+  Inventory,
+  INVENTORY_ITEM_SOURCE,
+  INVENTORY_STATUS,
+  INVENTORY_TRANSACTION_TYPE,
+  InventoryItem,
+  InventoryNoGenerator,
+  Tote,
+  TOTE_STATUS
+} from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
+import { Worksheet, WorksheetDetail } from '../../entities'
+import { VasWorksheetController } from '../vas/vas-worksheet-controller'
+
+export class SortingWorksheetController extends VasWorksheetController {
+  async generateSortingWorksheet(
+    batchPickingWorksheet: Worksheet,
+    targetInventories: Partial<OrderInventory>[]
+  ): Promise<Worksheet> {
+    const worksheet: Worksheet = await this.generateBatchWorksheet(
+      WORKSHEET_TYPE.SORTING,
+      batchPickingWorksheet,
+      //@ts-ignore
+      targetInventories,
+      ORDER_INVENTORY_STATUS.READY_TO_SORT
+    )
+
+    return worksheet
+  }
+
+  async activateSorting(worksheetNo: string, sortingWorksheetDetails: WorksheetDetail[]): Promise<Worksheet> {
+    const worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.SORTING, [
+      'worksheetDetails',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetInventory.releaseGood'
+    ])
+
+    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    let targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+
+    targetInventories = targetInventories
+      .filter(targetInventory => targetInventory.status == ORDER_INVENTORY_STATUS.READY_TO_SORT)
+      .map((targetInventory: OrderInventory) => {
+        targetInventory.status = ORDER_INVENTORY_STATUS.SORTING
+        targetInventory.updater = this.user
+        return targetInventory
+      })
+
+    let releaseGoods: ReleaseGood[] = worksheet.worksheetDetails.map(
+      (wsd: WorksheetDetail) => wsd.targetInventory.releaseGood
+    )
+    releaseGoods = [...new Map(releaseGoods.map(item => [item.id, item])).values()]
+    releaseGoods.forEach((releaseGood: ReleaseGood) => {
+      releaseGood.status = ORDER_STATUS.SORTING
+    })
+    await this.trxMgr.getRepository(ReleaseGood).save(releaseGoods)
+
+    if (targetInventories.length > 0) await this.updateOrderTargets(targetInventories)
+    return await this.activateWorksheet(worksheet, worksheetDetails, sortingWorksheetDetails)
+  }
+
+  async scanProductSorting(
+    taskNo: string,
+    releaseGoodNo: string,
+    productBarcode: string,
+    serialNumber: string,
+    toteNo: string
+  ): Promise<void> {
+    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: this.domain.id },
+        taskNo,
+        type: WORKSHEET_TYPE.SORTING,
+        status: WORKSHEET_STATUS.EXECUTING
+      },
+      relations: [
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.orderProduct',
+        'worksheetDetails.targetInventory.bizplace',
+        'worksheetDetails.targetInventory.inventory',
+        'worksheetDetails.targetInventory.inventory.product',
+        'worksheetDetails.targetInventory.inventory.product.productDetails',
+        'worksheetDetails.targetInventory.inventory.product.productDetails.product',
+        'worksheetDetails.targetInventory.releaseGood'
+      ]
+    })
+
+    this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
+
+    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    const orderInventories: OrderInventory[] = worksheetDetails
+      .map((wsd: WorksheetDetail) => wsd.targetInventory)
+      .filter((oi: OrderInventory) => oi.releaseGood.name === releaseGoodNo)
+
+    if (productBarcode) {
+      let productDetails: ProductDetail[] = []
+      orderInventories.map((oi: OrderInventory) => {
+        const foundPDs: ProductDetail[] = oi.inventory && oi.inventory.product && oi.inventory.product.productDetails
+        foundPDs.map(productDetail => {
+          productDetails.push(productDetail)
+        })
+      })
+
+      const matchingProductDetail: ProductDetail = productDetails.find(
+        (productDetail: ProductDetail) => productDetail.gtin === productBarcode
+      )
+      if (!matchingProductDetail) throw new Error('Unable to find product barcode.')
+      const packingType: string = matchingProductDetail.packingType
+      const packingSize: number = matchingProductDetail.packingSize
+      if (!matchingProductDetail)
+        throw new Error(this.ERROR_MSG.PRODUCT.BARCODE_NOT_EXIST(productBarcode, packingType, packingSize))
+
+      let matchingOIs: OrderInventory[] = orderInventories.filter(
+        (oi: OrderInventory) =>
+          oi.packingType === packingType &&
+          oi.packingSize === packingSize &&
+          oi.product?.id === matchingProductDetail.product?.id
+      )
+
+      let sortedQty: number = 1
+
+      if (!matchingOIs?.length) {
+        throw new Error(this.ERROR_MSG.ORDER_ITEM.NO_MATCHING_RESULT(packingType, packingSize))
+      } else {
+        await Promise.all(
+          matchingOIs.map(async (matchingOI: OrderInventory) => {
+            const releaseQty: number = matchingOI.releaseQty
+            const inventory: Inventory = matchingOI.inventory
+            const releaseGood: ReleaseGood = matchingOI.releaseGood
+            const product: Product = inventory.product
+
+            if (releaseQty != matchingOI?.sortedQty && sortedQty == 1) {
+              // Serial Number scanning for batch picking
+              if (matchingOI?.refWorksheetId) {
+                if (product?.isRequireSerialNumberScanningOutbound) {
+                  if (!serialNumber || serialNumber == '') {
+                    throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('sorting', `require serial number`))
+                  }
+
+                  let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+                    where: { domain: { id: this.domain.id }, serialNumber: serialNumber, product: { id: product.id } }
+                  })
+
+                  if (foundSerialNumber) {
+                    if (foundSerialNumber.inventoryId !== inventory.id) {
+                      throw new Error('Serial Number scanned is in another inventory')
+                    }
+
+                    if (foundSerialNumber.outboundOrderId) {
+                      let releaseGood: ReleaseGood = await this.trxMgr
+                        .getRepository(ReleaseGood)
+                        .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
+                      throw new Error(`Inventory Item is already picked/sorted in ${releaseGood.name}`)
+                    }
+
+                    foundSerialNumber.status = INVENTORY_STATUS.SORTING
+                    foundSerialNumber.updater = this.user
+                    foundSerialNumber.outboundOrderId = releaseGood.id
+
+                    await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+                  } else {
+                    let inventoryItem: InventoryItem = new InventoryItem()
+                    inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+                    inventoryItem.serialNumber = serialNumber
+                    inventoryItem.status = INVENTORY_STATUS.SORTING
+                    inventoryItem.outboundOrderId = releaseGood.id
+                    inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+                    inventoryItem.product = product
+                    inventoryItem.inventory = inventory
+                    inventoryItem.domain = this.domain
+
+                    await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+                  }
+                }
+              }
+
+              matchingOI.sortedQty = Boolean(matchingOI?.sortedQty) ? matchingOI.sortedQty + sortedQty : sortedQty
+              sortedQty -= 1
+              if (matchingOI.sortedQty == releaseQty) {
+                matchingOI.status = ORDER_INVENTORY_STATUS.SORTED
+                await this.updateOrderTargets([matchingOI])
+                await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.SORTING)
+
+                let worksheetDetail: WorksheetDetail = worksheetDetails.find(
+                  wsd => wsd.targetInventory.id === matchingOI.id
+                )
+                worksheetDetail.status = WORKSHEET_STATUS.DONE
+                worksheetDetail.updater = this.user
+                await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+                //@ts-ignore
+                let inventoryItems: InventoryItem = await this.trxMgr
+                  .getRepository(InventoryItem)
+                  .find({ where: { outboundOrderId: releaseGood.id } })
+
+                //@ts-ignore
+                if (inventoryItems.length > 0) {
+                  //@ts-ignore
+                  inventoryItems.forEach((itm: InventoryItem) => {
+                    itm.status = INVENTORY_STATUS.SORTED
+                    itm.updater = this.user
+                  })
+
+                  await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+                }
+              } else if (matchingOI?.sortedQty > releaseQty) {
+                const product: Product = matchingOI.inventory.product
+                throw new Error(this.ERROR_MSG.ORDER_ITEM.EXCESS_QTY(product.sku, packingType, packingSize))
+              } else {
+                await this.updateOrderTargets([matchingOI])
+              }
+
+              if (toteNo) {
+                await this.toteScanning(
+                  toteNo,
+                  matchingOI.orderProduct,
+                  matchingOI,
+                  1,
+                  releaseGood,
+                  matchingOI.bizplace
+                )
+              }
+            }
+          })
+        )
+      }
+    }
+  }
+
+  async sortingProduct(
+    taskNo: string,
+    releaseGoodNo: string,
+    productId: string,
+    sortingQty: number,
+    serialNumber: string,
+    toteNo: string
+  ): Promise<void> {
+    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: this.domain.id },
+        taskNo,
+        type: WORKSHEET_TYPE.SORTING,
+        status: WORKSHEET_STATUS.EXECUTING
+      },
+      relations: [
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.orderProduct',
+        'worksheetDetails.targetInventory.bizplace',
+        'worksheetDetails.targetInventory.inventory',
+        'worksheetDetails.targetInventory.inventory.product',
+        'worksheetDetails.targetInventory.inventory.product.productDetails',
+        'worksheetDetails.targetInventory.inventory.product.productDetails.product',
+        'worksheetDetails.targetInventory.releaseGood'
+      ]
+    })
+
+    this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
+
+    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    let orderInventories: OrderInventory[] = worksheetDetails
+      .map((wsd: WorksheetDetail) => wsd.targetInventory)
+      .filter((oi: OrderInventory) => oi.releaseGood.name === releaseGoodNo && oi.product.id === productId)
+
+    if (!orderInventories?.length) {
+      throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productId))
+    } else {
+      await Promise.all(
+        orderInventories.map(async (matchingOI: OrderInventory) => {
+          const releaseQty: number = matchingOI.releaseQty
+          const inventory: Inventory = matchingOI.inventory
+          const releaseGood: ReleaseGood = matchingOI.releaseGood
+          const product: Product = matchingOI.inventory.product
+          const packingType: string = matchingOI.packingType
+          const packingSize: number = matchingOI.packingSize
+
+          if (product?.isRequireSerialNumberScanningOutbound) {
+            if (!serialNumber || serialNumber == '') {
+              throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('sorting', `require serial number`))
+            }
+
+            let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+              where: { domain: { id: this.domain.id }, serialNumber: serialNumber, product: { id: product.id } },
+              relations: ['product', 'inventory']
+            })
+
+            if (foundSerialNumber) {
+              if (foundSerialNumber.outboundOrderId) {
+                let releaseGood: ReleaseGood = await this.trxMgr
+                  .getRepository(ReleaseGood)
+                  .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
+                throw new Error(`Inventory Item is already picked/sorted in ${releaseGood.name}`)
+              }
+
+              foundSerialNumber.status = INVENTORY_STATUS.SORTING
+              foundSerialNumber.updater = this.user
+              foundSerialNumber.outboundOrderId = releaseGood.id
+
+              await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+            } else {
+              let inventoryItem: InventoryItem = new InventoryItem()
+              inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+              inventoryItem.serialNumber = serialNumber
+              inventoryItem.status = INVENTORY_STATUS.SORTING
+              inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+              inventoryItem.outboundOrderId = releaseGood.id
+              inventoryItem.product = product
+              inventoryItem.inventory = inventory
+              inventoryItem.domain = this.domain
+
+              foundSerialNumber = await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+            }
+          }
+
+          if (toteNo) {
+            await this.toteScanning(
+              toteNo,
+              matchingOI.orderProduct,
+              matchingOI,
+              sortingQty,
+              releaseGood,
+              matchingOI.bizplace
+            )
+          }
+
+          if (releaseQty != matchingOI?.sortedQty && sortingQty != 0) {
+            if (product?.isRequireSerialNumberScanningOutbound) {
+              matchingOI.sortedQty += sortingQty
+            } else {
+              matchingOI.sortedQty = releaseQty
+            }
+
+            sortingQty -= releaseQty
+            if (matchingOI.sortedQty == releaseQty) {
+              matchingOI.status = ORDER_INVENTORY_STATUS.SORTED
+              await this.updateOrderTargets([matchingOI])
+              await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.SORTING)
+
+              //@ts-ignore
+              let inventoryItems: InventoryItem = await this.trxMgr
+                .getRepository(InventoryItem)
+                .find({ where: { outboundOrderId: releaseGood.id } })
+
+              //@ts-ignore
+              if (inventoryItems.length > 0) {
+                //@ts-ignore
+                inventoryItems.forEach((itm: InventoryItem) => {
+                  //@ts-ignore
+                  itm.status = INVENTORY_STATUS.PACKED
+                  itm.updater = this.user
+                })
+
+                await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+              }
+
+              let worksheetDetail: WorksheetDetail = worksheetDetails.find(
+                wsd => wsd.targetInventory.id === matchingOI.id
+              )
+              worksheetDetail.status = WORKSHEET_STATUS.DONE
+              worksheetDetail.updater = this.user
+              await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+            } else if (matchingOI?.sortedQty > releaseQty) {
+              throw new Error(this.ERROR_MSG.ORDER_ITEM.EXCESS_QTY(product.sku, packingType, packingSize))
+            } else {
+              await this.updateOrderTargets([matchingOI])
+            }
+          }
+        })
+      )
+    }
+  }
+
+  async completeOrderSorting(releaseGoodNo: string): Promise<ReleaseGood> {
+    try {
+      //@ts-ignore
+      let releaseGood: ReleaseGood = await this.findRefOrder(
+        //@ts-ignore
+        ReleaseGood,
+        {
+          domain: this.domain,
+          name: releaseGoodNo,
+          status: ORDER_STATUS.SORTING
+        },
+        ['bizplace', 'orderInventories']
+      )
+
+      if (!releaseGood) {
+        throw new Error('Order is already sorted')
+      }
+
+      const foundNotSealedOrderTote = await this.trxMgr
+        .getRepository(OrderTote)
+        .findOne({ where: { releaseGood: { id: releaseGood.id }, closedDate: IsNull() } })
+
+      if (foundNotSealedOrderTote) {
+        throw new Error('Please seal the tote(s) before proceeding')
+      }
+
+      releaseGood.status = ORDER_STATUS.READY_TO_LOAD
+      releaseGood.updater = this.user
+      await this.trxMgr.getRepository(ReleaseGood).save(releaseGood)
+
+      //@ts-ignore
+      let inventoryItems: InventoryItem = await this.trxMgr
+        .getRepository(InventoryItem)
+        .find({ where: { outboundOrderId: releaseGood.id } })
+
+      //@ts-ignore
+      if (inventoryItems.length > 0) {
+        //@ts-ignore
+        inventoryItems.forEach((itm: InventoryItem) => {
+          itm.status = INVENTORY_STATUS.TERMINATED
+          itm.updater = this.user
+        })
+
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+      }
+
+      return releaseGood
+    } catch (e) {
+      throw e
+    }
+  }
+
+  async completeWorksheetSorting(taskNo: string): Promise<Worksheet> {
+    let worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: this.domain.id },
+        taskNo,
+        type: WORKSHEET_TYPE.SORTING,
+        status: WORKSHEET_STATUS.EXECUTING
+      },
+      relations: [
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.releaseGood'
+      ]
+    })
+
+    let releaseGoodIds = worksheet.worksheetDetails.map(itm => itm.targetInventory.releaseGood.id)
+
+    const foundNotSealedOrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { releaseGood: { id: In(releaseGoodIds) }, closedDate: IsNull() } })
+
+    if (foundNotSealedOrderTote) {
+      throw new Error('Please seal the tote(s) before proceeding')
+    }
+
+    this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
+
+    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    const allTaskCompleted: boolean = worksheetDetails.every(wsd => wsd.status === WORKSHEET_STATUS.DONE)
+
+    if (!allTaskCompleted)
+      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('complete worksheet', 'few incompleted line items'))
+
+    worksheet.status = WORKSHEET_STATUS.DONE
+    worksheet.endedAt = new Date()
+    worksheet.updater = this.user
+    worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
+
+    return worksheet
+  }
+
+  private async toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace) {
+    //1. find tote
+    let foundTote: Tote = await this.trxMgr
+      .getRepository(Tote)
+      .findOne({ where: { bizplace: { id: bizplace.id }, name: toteNo, deletedAt: IsNull() } })
+
+    if (foundTote?.status == TOTE_STATUS.DAMAGED) {
+      throw new Error('Tote is damaged')
+    }
+
+    if (foundTote?.status == TOTE_STATUS.DISPATCHED) {
+      throw new Error('Tote is dispatched')
+    }
+
+    //2. find order tote
+    let foundOrderTote: OrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { domain: { id: this.domain.id }, name: toteNo, releaseGood: { id: releaseGood.id } } })
+
+    //if order tote not found the create one, if tote not found means it's tote box
+    //create order tote item
+    if (!foundOrderTote) {
+      const orderTote = await this.trxMgr.getRepository(OrderTote).save({
+        name: toteNo,
+        domain: this.domain,
+        releaseGood,
+        tote: foundTote ? foundTote : null,
+        updater: this.user
+      })
+
+      const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+        domain: this.domain,
+        name: OrderNoGenerator.orderToteItem(),
+        orderProduct: targetProduct,
+        orderInventory: targetInventory,
+        orderTote,
+        qty: pickedQty,
+        updater: this.user
+      })
+    } else {
+      if (foundOrderTote.closedDate) {
+        throw new Error('Tote has been sealed, please try another tote!')
+      }
+
+      //if found order tote then check if order tote item exist
+      const foundOrderToteItem: OrderToteItem = await this.trxMgr.getRepository(OrderToteItem).findOneBy({
+        domain: { id: this.domain.id },
+        orderProduct: { id: targetProduct.id },
+        orderInventory: { id: targetInventory.id },
+        orderTote: { id: foundOrderTote.id }
+      })
+
+      //if not order tote item doesnt exist then create one
+      if (!foundOrderToteItem) {
+        const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+          domain: this.domain,
+          name: OrderNoGenerator.orderToteItem(),
+          orderProduct: targetProduct,
+          orderInventory: targetInventory,
+          orderTote: foundOrderTote,
+          qty: pickedQty,
+          updater: this.user
+        })
+      } else {
+        //if found order tote item found then add the quantity
+        const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+          ...foundOrderToteItem,
+          qty: foundOrderToteItem.qty + pickedQty
+        })
+      }
+    }
+  }
+}