@things-factory/worksheet-base 8.0.0-beta.1 → 8.0.0-beta.2

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

@@ -1,554 +0,0 @@
-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
-        })
-      }
-    }
-  }
-}