@things-factory/worksheet-base 5.0.0-alpha.50 → 5.0.0-alpha.53

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

@@ -1,4 +1,4 @@
-import { Equal, Not } from 'typeorm'
+import { Equal, Not, In } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
 import {
@@ -8,9 +8,11 @@ import {
   ORDER_TYPES,
   OrderInventory,
   OrderNoGenerator,
-  ReleaseGood
+  ReleaseGood,
+  OrderToteItem,
+  OrderTote
 } from '@things-factory/sales-base'
-import { Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
+import { Inventory, INVENTORY_TRANSACTION_TYPE, Tote, TOTE_STATUS } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
 import { Worksheet, WorksheetDetail } from '../../entities'
@@ -95,8 +97,8 @@ export class LoadingWorksheetController extends VasWorksheetController {
 
   async loading(
     releaseGoodNo: string,
-    worksheetDetails: Partial<WorksheetDetail & { loadedQty: number }>[]
-  ): Promise<void> {
+    worksheetDetails: Partial<WorksheetDetail & { loadedQty: number } & { toteName: string }>[]
+  ): Promise<any> {
     const releaseGood: ReleaseGood = await this.findRefOrder(
       ReleaseGood,
       { domain: this.domain, name: releaseGoodNo },
@@ -104,14 +106,14 @@ export class LoadingWorksheetController extends VasWorksheetController {
     )
     const bizplace: Bizplace = releaseGood.bizplace
 
-    for (let worksheetDetail of worksheetDetails) {
-      const loadedQty: number = worksheetDetail.loadedQty
-      worksheetDetail = await this.findExecutableWorksheetDetailByName(worksheetDetail.name, WORKSHEET_TYPE.LOADING, [
-        'worksheet',
-        'targetInventory',
-        'targetInventory.inventory',
-        'targetInventory.product'
-      ])
+    for (let i = 0; i < worksheetDetails.length; i++) {
+      const loadedQty: number = worksheetDetails[i].loadedQty
+      const toteName: string = worksheetDetails[i].toteName
+      let worksheetDetail = await this.findExecutableWorksheetDetailByName(
+        worksheetDetails[i].name,
+        WORKSHEET_TYPE.LOADING,
+        ['worksheet', 'targetInventory', 'targetInventory.inventory', 'targetInventory.product']
+      )
 
       const worksheet: Worksheet = worksheetDetail.worksheet
       let targetInventory: OrderInventory = worksheetDetail.targetInventory
@@ -119,9 +121,9 @@ export class LoadingWorksheetController extends VasWorksheetController {
       let inventory: Inventory = targetInventory.inventory
 
       targetInventory.loadedAt = new Date()
-      targetInventory.loadedByUser = this.user;
+      targetInventory.loadedByUser = this.user
 
-      let loadedBy: string[] = targetInventory.loadedBy ? (targetInventory.loadedBy).split(',') : []
+      let loadedBy: string[] = targetInventory.loadedBy ? targetInventory.loadedBy.split(',') : []
       if (!loadedBy.find(x => x == this.user.name)) {
         loadedBy.push(this.user.name)
         targetInventory.loadedBy = loadedBy.join(',')
@@ -174,11 +176,56 @@ export class LoadingWorksheetController extends VasWorksheetController {
         newTargetInventory.updater = this.user
         newTargetInventory = await this.trxMgr.getRepository(OrderInventory).save(newTargetInventory)
 
-        await this.createWorksheetDetails(worksheet, WORKSHEET_TYPE.LOADING, [newTargetInventory], {
-          status: WORKSHEET_STATUS.EXECUTING
+        if (toteName) {
+          let foundOrderTote = await this.trxMgr
+            .getRepository(OrderTote)
+            .findOne({ where: { name: toteName, releaseGood } })
+
+          let foundOrderToteItems = await this.trxMgr
+            .getRepository(OrderToteItem)
+            .find({ where: { orderInventory: targetInventory.id } })
+
+          let foundOrderToteItemIds = foundOrderToteItems.map((itm: OrderToteItem) => itm.id)
+
+          await this.trxMgr
+            .getRepository(OrderToteItem)
+            .update({ id: In(foundOrderToteItemIds) }, { orderInventory: newTargetInventory })
+
+          let foundOrderToteItem: OrderToteItem = await this.trxMgr
+            .getRepository(OrderToteItem)
+            .findOne({ where: { orderInventory: newTargetInventory.id, orderTote: foundOrderTote, qty: loadedQty } })
+
+          await this.trxMgr
+            .getRepository(OrderToteItem)
+            .update({ id: foundOrderToteItem.id }, { orderInventory: targetInventory.id })
+        }
+
+        let newWorksheetDetail: any = await this.createWorksheetDetails(
+          worksheet,
+          WORKSHEET_TYPE.LOADING,
+          [newTargetInventory],
+          {
+            status: WORKSHEET_STATUS.EXECUTING
+          }
+        )
+
+        let worksheetDetailName = worksheetDetails[i].name
+        worksheetDetails = worksheetDetails.map(record => {
+          if (record.name == worksheetDetailName && !record?.targetInventory) {
+            return {
+              ...record,
+              name: newWorksheetDetail[0].name
+            }
+          } else {
+            return record
+          }
         })
+
+        worksheetDetails[i].name = worksheetDetailName
       }
 
+      worksheetDetails[i].targetInventory = targetInventory
+
       await generateInventoryHistory(
         inventory,
         releaseGood,
@@ -189,6 +236,8 @@ export class LoadingWorksheetController extends VasWorksheetController {
         this.trxMgr
       )
     }
+
+    return worksheetDetails
   }
 
   async undoLoading(deliveryOrder: Partial<DeliveryOrder>, palletIds: string[]): Promise<void> {
@@ -228,6 +277,10 @@ export class LoadingWorksheetController extends VasWorksheetController {
         }
       })
 
+      let undoOrderToteItem: OrderToteItem = await this.trxMgr
+        .getRepository(OrderToteItem)
+        .findOne({ where: { orderInventory: undoTargetOrderInventory } })
+
       if (prevTargetInventory) {
         // If there's prev target inventory
         // Merge qty and uomValue into prev target inventory
@@ -236,6 +289,13 @@ export class LoadingWorksheetController extends VasWorksheetController {
         prevTargetInventory.updater = this.user
         await this.updateOrderTargets([prevTargetInventory])
 
+        //Update order tote item if any
+        if (undoOrderToteItem) {
+          undoOrderToteItem.orderInventoryId = prevTargetInventory.id
+          undoOrderToteItem.orderInventory = prevTargetInventory
+          await this.trxMgr.getRepository(OrderToteItem).save(undoOrderToteItem)
+        }
+
         // Terminate undo target order inventory
         undoTargetOrderInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
         await this.updateOrderTargets([undoTargetOrderInventory])
@@ -282,6 +342,12 @@ export class LoadingWorksheetController extends VasWorksheetController {
       status: ORDER_STATUS.LOADING
     })
 
+    const orderToteIds = await (
+      await this.trxMgr.getRepository(OrderTote).find({ where: { releaseGood }, relations: ['tote'] })
+    ).map((record: OrderTote) => record?.toteId)
+
+    await this.trxMgr.getRepository(Tote).update({ id: In(orderToteIds) }, { status: TOTE_STATUS.DISPATCHED })
+
     const worksheet: Worksheet = await this.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.LOADING, [
       'worksheetDetails',
       'worksheetDetails.targetInventory'

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

@@ -1,13 +1,18 @@
-import { Equal, In, Not } from 'typeorm'
+import { Equal, In, IsNull, Not } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
 import { Product, ProductDetail } from '@things-factory/product-base'
 import {
   ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
   ORDER_STATUS,
   OrderInventory,
   OrderNoGenerator,
+  OrderProduct,
+  OrderTote,
+  OrderToteItem,
+  OrderToteSeal,
   OrderVas,
   ReleaseGood
 } from '@things-factory/sales-base'
@@ -20,7 +25,9 @@ import {
   InventoryItem,
   InventoryNoGenerator,
   Location,
-  LOCATION_TYPE
+  LOCATION_TYPE,
+  Tote,
+  TOTE_STATUS
 } from '@things-factory/warehouse-base'
 
 import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
@@ -338,7 +345,8 @@ export class PickingWorksheetController extends VasWorksheetController {
       'worksheetDetails',
       'worksheetDetails.targetInventory',
       'worksheetDetails.targetInventory.inventory',
-      'worksheetDetails.targetInventory.product'
+      'worksheetDetails.targetInventory.product',
+      'worksheetDetails.targetInventory.orderProduct'
     ])
 
     const worksheetDetails: WorksheetDetail[] = await this.extractMatchedWorksheetDetails(
@@ -347,7 +355,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       productId,
       packingType,
       packingSize,
-      ['targetInventory', 'targetInventory.inventory']
+      ['targetInventory', 'targetInventory.inventory', 'targetInventory.orderProduct']
     )
 
     let worksheetDetailIds: string[] = []
@@ -364,6 +372,13 @@ export class PickingWorksheetController extends VasWorksheetController {
       inventory.lockedQty = inventory.lockedQty - targetInventory.releaseQty
       inventory.lockedUomValue = inventory.lockedUomValue - targetInventory.releaseUomValue
       await this.updateInventory(inventory)
+
+      await this.trxMgr
+        .getRepository(OrderProduct)
+        .update(
+          { id: targetInventory.orderProduct.id },
+          { status: ORDER_PRODUCT_STATUS.PENDING_ASSIGN, updater: this.user }
+        )
     }
 
     await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetailIds)
@@ -388,7 +403,8 @@ export class PickingWorksheetController extends VasWorksheetController {
     productBarcode: string,
     cartonId: string,
     binLocation?: string,
-    serialNumber?: string
+    serialNumber?: string,
+    toteNo?: string
   ): Promise<OrderInventory> {
     try {
       let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
@@ -401,6 +417,7 @@ export class PickingWorksheetController extends VasWorksheetController {
           'targetInventory.releaseGood',
           'targetInventory.inventory',
           'targetInventory.product',
+          'targetInventory.orderProduct',
           'targetInventory.product.productDetails',
           'targetInventory.product.productDetails.product',
           'targetInventory.product.productDetails.childProductDetail'
@@ -409,8 +426,10 @@ export class PickingWorksheetController extends VasWorksheetController {
 
       const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
       let targetInventory: OrderInventory = worksheetDetail.targetInventory
+      let targetProduct: OrderProduct = targetInventory.orderProduct
       const product: Product = targetInventory.product
       let inventory: Inventory = targetInventory.inventory
+      let bizplace: Bizplace = worksheetDetail.worksheet.bizplace
 
       //validation to prevent duplicated picking
       let oiValidate: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
@@ -512,6 +531,10 @@ export class PickingWorksheetController extends VasWorksheetController {
         }
       }
 
+      if (toteNo) {
+        await this.toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace)
+      }
+
       await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
     } catch (error) {
       throw error
@@ -525,7 +548,8 @@ export class PickingWorksheetController extends VasWorksheetController {
     locationName: string,
     pickedQty: number,
     binLocation?: string,
-    serialNumber?: string
+    serialNumber?: string,
+    toteNo?: string
   ): Promise<void> {
     try {
       let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
@@ -533,8 +557,10 @@ export class PickingWorksheetController extends VasWorksheetController {
         worksheetType,
         [
           'worksheet',
+          'worksheet.bizplace',
           'targetInventory',
           'targetInventory.releaseGood',
+          'targetInventory.orderProduct',
           'targetInventory.inventory',
           'targetInventory.inventory.location',
           'targetInventory.product'
@@ -545,6 +571,8 @@ export class PickingWorksheetController extends VasWorksheetController {
       let targetInventory: OrderInventory = worksheetDetail.targetInventory
       const product: Product = targetInventory.product
       let inventory: Inventory = targetInventory.inventory
+      let targetProduct: OrderProduct = targetInventory.orderProduct
+      let bizplace: Bizplace = worksheetDetail.worksheet.bizplace
 
       //validation to prevent duplicated picking
       let oiValidate: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
@@ -649,6 +677,10 @@ export class PickingWorksheetController extends VasWorksheetController {
 
       targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
 
+      if (toteNo) {
+        await this.toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace)
+      }
+
       await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
 
       const fromLocation: Location = targetInventory.inventory.location
@@ -947,6 +979,14 @@ export class PickingWorksheetController extends VasWorksheetController {
       status: ORDER_STATUS.PICKING
     })
 
+    const foundNotSealedOrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { releaseGood, closedDate: IsNull() } })
+
+    if (foundNotSealedOrderTote) {
+      throw new Error('Please seal the tote(s) before completing')
+    }
+
     let worksheet: Worksheet = await this.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PICKING, [
       'worksheetDetails',
       'worksheetDetails.targetInventory'
@@ -1008,14 +1048,14 @@ export class PickingWorksheetController extends VasWorksheetController {
     worksheet.updater = this.user
     worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
 
-    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    const worksheetDetails: any = worksheet.worksheetDetails.filter(wsD => wsD.status != 'MISSING')
     worksheetDetails.forEach((wsd: WorksheetDetail) => {
       wsd.status = WORKSHEET_STATUS.DONE
       wsd.updater = this.user
     })
     await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
 
-    const targetInventories: OrderInventory[] = worksheet.worksheetDetails.map((wsd: WorksheetDetail) => {
+    const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
       let targetInventory: OrderInventory = wsd.targetInventory
       targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
       targetInventory.updater = this.user
@@ -1023,7 +1063,7 @@ export class PickingWorksheetController extends VasWorksheetController {
     })
     await this.updateOrderTargets(targetInventories)
 
-    const releaseGoods: ReleaseGood[] = worksheet.worksheetDetails.map((wsd: WorksheetDetail) => {
+    const releaseGoods: ReleaseGood[] = worksheetDetails.map((wsd: WorksheetDetail) => {
       let releaseGood: ReleaseGood = wsd.targetInventory.releaseGood
 
       let orderStatus: string
@@ -1108,6 +1148,9 @@ export class PickingWorksheetController extends VasWorksheetController {
       }
 
       orderInventory.status = ORDER_INVENTORY_STATUS.PICKED
+      orderInventory.pickedBy = this.user?.name
+      orderInventory.pickedByUser = this.user
+      orderInventory.pickedAt = new Date()
 
       inventory.qty -= orderInventory.releaseQty
       inventory.uomValue = Math.round((inventory.uomValue - orderInventory.releaseUomValue) * 100) / 100
@@ -1367,6 +1410,75 @@ export class PickingWorksheetController extends VasWorksheetController {
     } catch (e) {}
   }
 
+  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 || foundTote?.status == TOTE_STATUS.DISPATCHED) {
+      foundTote = null
+    }
+
+    //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
+        })
+      }
+    }
+  }
+
   async undoSerialNumberPicking(worksheetDetailName: string, inventoryItemId: string): Promise<void> {
     const worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
       where: { name: worksheetDetailName, domain: this.domain, status: Not(Equal(WORKSHEET_STATUS.DEACTIVATED)) },
@@ -1438,4 +1550,72 @@ export class PickingWorksheetController extends VasWorksheetController {
     targetInventory.updater = this.user
     await this.updateOrderTargets([targetInventory])
   }
+
+  async sealTote(sealNo: string, toteNo: string, orderNo: string): Promise<void> {
+    const checkDuplicateSeal = await this.trxMgr.getRepository(OrderToteSeal).findOne({
+      where: {
+        name: sealNo
+      }
+    })
+
+    if (checkDuplicateSeal) {
+      throw new Error('Seal has been scanned before')
+    }
+
+    const releaseGood: ReleaseGood = await this.trxMgr
+      .getRepository(ReleaseGood)
+      .findOne({ where: { domain: this.domain, name: orderNo }, relations: ['bizplace', 'bizplace.domain'] })
+
+    let sealNoSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+      where: {
+        domain: releaseGood.bizplace.domain,
+        name: 'minimum-seal-number'
+      }
+    })
+
+    if (!sealNoSetting) {
+      sealNoSetting = await this.trxMgr.getRepository(Setting).findOne({
+        where: {
+          domain: this.domain,
+          name: 'minimum-seal-number'
+        }
+      })
+    }
+
+    const foundOrderTote: OrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { domain: this.domain, name: toteNo, releaseGood } })
+
+    if (!foundOrderTote) {
+      throw new Error('Tote not scanned under this order')
+    }
+
+    let totalOrderToteItems = await this.trxMgr.getRepository(OrderToteItem).count({
+      where: {
+        orderTote: foundOrderTote
+      }
+    })
+
+    if (totalOrderToteItems < 1) {
+      throw new Error('Tote carton is empty')
+    }
+
+    const newToteOrderSeal: OrderToteSeal = await this.trxMgr.getRepository(OrderToteSeal).save({
+      domain: this.domain,
+      name: sealNo,
+      orderTote: foundOrderTote,
+      updater: this.user
+    })
+
+    const totalSeal = await this.trxMgr.getRepository(OrderToteSeal).count({
+      orderTote: foundOrderTote
+    })
+
+    if (totalSeal >= parseInt(sealNoSetting?.value || 0)) {
+      await this.trxMgr.getRepository(OrderTote).save({
+        ...foundOrderTote,
+        closedDate: new Date()
+      })
+    }
+  }
 }