@things-factory/worksheet-base 5.0.0-alpha.5 → 5.0.0-alpha.52

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

@@ -124,6 +124,9 @@ export class ReturningWorksheetController extends VasWorksheetController {
     // update status of order inventory
     targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
     targetInventory.updater = this.user
+    targetInventory.returnToLocationQty = targetInventory.releaseQty
+    targetInventory.returnToLocationUomValue = targetInventory.releaseUomValue
+
     await this.updateOrderTargets([targetInventory])
 
     // update status of worksheet detail (EXECUTING => DONE)
@@ -164,7 +167,13 @@ export class ReturningWorksheetController extends VasWorksheetController {
         where: {
           domain: this.domain,
           name: toLocationName,
-          type: In([LOCATION_TYPE.SHELF, LOCATION_TYPE.BUFFER, LOCATION_TYPE.FLOOR, LOCATION_TYPE.BIN])
+          type: In([
+            LOCATION_TYPE.SHELF,
+            LOCATION_TYPE.BUFFER,
+            LOCATION_TYPE.FLOOR,
+            LOCATION_TYPE.BIN,
+            LOCATION_TYPE.QUARANTINE
+          ])
         },
         relations: ['warehouse']
       })
@@ -189,6 +198,8 @@ export class ReturningWorksheetController extends VasWorksheetController {
 
       targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
       targetInventory.updater = this.user
+      targetInventory.returnToLocationQty = targetInventory.releaseQty
+      targetInventory.returnToLocationUomValue = targetInventory.releaseUomValue
       await this.updateOrderTargets([targetInventory])
 
       worksheetDetail.status = WORKSHEET_STATUS.DONE

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

@@ -1,9 +1,29 @@
+import { IsNull, In } from 'typeorm'
+
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 import { Product, ProductDetail } from '@things-factory/product-base'
-import { Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
-import { ReleaseGood, OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '@things-factory/sales-base'
+import {
+  Inventory,
+  INVENTORY_TRANSACTION_TYPE,
+  InventoryItem,
+  INVENTORY_STATUS,
+  InventoryNoGenerator,
+  INVENTORY_ITEM_SOURCE,
+  Tote,
+  TOTE_STATUS
+} from '@things-factory/warehouse-base'
+import {
+  ReleaseGood,
+  OrderInventory,
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderTote,
+  OrderToteItem,
+  OrderNoGenerator
+} from '@things-factory/sales-base'
 import { Worksheet, WorksheetDetail } from '../../entities'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
+import { temporaryGetRemainInventoryAmount } from 'server/graphql/resolvers/worksheet/vas-transactions/common-utils'
 
 export class SortingWorksheetController extends VasWorksheetController {
   async generateSortingWorksheet(
@@ -51,7 +71,13 @@ export class SortingWorksheetController extends VasWorksheetController {
     return await this.activateWorksheet(worksheet, worksheetDetails, sortingWorksheetDetails)
   }
 
-  async scanProductSorting(taskNo: string, releaseGoodNo: string, productBarcode: string): Promise<void> {
+  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: this.domain,
@@ -63,6 +89,8 @@ export class SortingWorksheetController extends VasWorksheetController {
         'worksheetDetails',
         'worksheetDetails.targetInventory',
         'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.orderProduct',
+        'worksheetDetails.targetInventory.bizplace',
         'worksheetDetails.targetInventory.inventory',
         'worksheetDetails.targetInventory.inventory.product',
         'worksheetDetails.targetInventory.inventory.product.productDetails',
@@ -113,8 +141,53 @@ export class SortingWorksheetController extends VasWorksheetController {
             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: this.domain, serialNumber: serialNumber, product } })
+
+                  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) {
@@ -128,12 +201,36 @@ export class SortingWorksheetController extends VasWorksheetController {
                 worksheetDetail.status = WORKSHEET_STATUS.DONE
                 worksheetDetail.updater = this.user
                 await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+                let inventoryItems: InventoryItem = await this.trxMgr
+                  .getRepository(InventoryItem)
+                  .find({ where: { outboundOrderId: releaseGood.id } })
+
+                if (inventoryItems.length > 0) {
+                  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
+                )
+              }
             }
           })
         )
@@ -141,7 +238,14 @@ export class SortingWorksheetController extends VasWorksheetController {
     }
   }
 
-  async sortingProduct(taskNo: string, releaseGoodNo: string, productId: string, sortingQty: number): Promise<void> {
+  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: this.domain,
@@ -153,6 +257,8 @@ export class SortingWorksheetController extends VasWorksheetController {
         'worksheetDetails',
         'worksheetDetails.targetInventory',
         'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.orderProduct',
+        'worksheetDetails.targetInventory.bizplace',
         'worksheetDetails.targetInventory.inventory',
         'worksheetDetails.targetInventory.inventory.product',
         'worksheetDetails.targetInventory.inventory.product.productDetails',
@@ -180,14 +286,81 @@ export class SortingWorksheetController extends VasWorksheetController {
           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: this.domain, serialNumber: serialNumber, product },
+              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) {
-            matchingOI.sortedQty = releaseQty
+            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)
 
+              let inventoryItems: InventoryItem = await this.trxMgr
+                .getRepository(InventoryItem)
+                .find({ where: { outboundOrderId: releaseGood.id } })
+
+              if (inventoryItems.length > 0) {
+                inventoryItems.forEach((itm: InventoryItem) => {
+                  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
               )
@@ -206,21 +379,50 @@ export class SortingWorksheetController extends VasWorksheetController {
   }
 
   async completeOrderSorting(releaseGoodNo: string): Promise<ReleaseGood> {
-    let releaseGood: ReleaseGood = await this.findRefOrder(
-      ReleaseGood,
-      {
-        domain: this.domain,
-        name: releaseGoodNo,
-        status: ORDER_STATUS.SORTING
-      },
-      ['bizplace', 'orderInventories']
-    )
+    try {
+      let releaseGood: ReleaseGood = await this.findRefOrder(
+        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, 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)
 
-    releaseGood.status = ORDER_STATUS.READY_TO_LOAD
-    releaseGood.updater = this.user
-    await this.trxMgr.getRepository(ReleaseGood).save(releaseGood)
+      let inventoryItems: InventoryItem = await this.trxMgr
+        .getRepository(InventoryItem)
+        .find({ where: { outboundOrderId: releaseGood.id } })
 
-    return releaseGood
+      if (inventoryItems.length > 0) {
+        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> {
@@ -238,6 +440,16 @@ export class SortingWorksheetController extends VasWorksheetController {
       ]
     })
 
+    let releaseGoodIds = worksheet.worksheetDetails.map(itm => itm.targetInventory.releaseGood.id)
+
+    const foundNotSealedOrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { releaseGood: 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
@@ -253,4 +465,77 @@ export class SortingWorksheetController extends VasWorksheetController {
 
     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, 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: this.domain, name: toteNo, releaseGood } })
+
+    //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).findOne({
+        domain: this.domain,
+        orderProduct: targetProduct,
+        orderInventory: targetInventory,
+        orderTote: foundOrderTote
+      })
+
+      //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
+        })
+      }
+    }
+  }
 }