@things-factory/worksheet-base 4.0.7 → 4.0.12

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

@@ -17,7 +17,8 @@ import {
   INVENTORY_STATUS,
   INVENTORY_TRANSACTION_TYPE,
   Location,
-  LOCATION_TYPE
+  LOCATION_TYPE,
+  LOCATION_STATUS
 } from '@things-factory/warehouse-base'
 
 import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
@@ -190,7 +191,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       if (vasWorksheet) {
         await this.activateVAS(vasWorksheet.name, vasWorksheet.worksheetDetails)
       }
-    } catch (e) {}
+    } catch (e) { }
 
     const pendingSplitOIs: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
       where: { domain: this.domain, releaseGood, status: ORDER_INVENTORY_STATUS.PENDING_SPLIT }
@@ -386,106 +387,92 @@ export class PickingWorksheetController extends VasWorksheetController {
     worksheetType: string,
     productBarcode: string,
     cartonId: string,
-    binLocation?: string
-  ): Promise<void> {
-    let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
-      worksheetDetailName,
-      worksheetType,
-      [
-        'worksheet',
-        'worksheet.bizplace',
-        'targetInventory',
-        'targetInventory.releaseGood',
-        'targetInventory.inventory',
-        'targetInventory.product',
-        'targetInventory.product.productDetails',
-        'targetInventory.product.productDetails.product',
-        'targetInventory.product.productDetails.childProductDetail'
-      ]
-    )
+    binLocation?: string,
+    serialNumber?: string
+  ): Promise<OrderInventory> {
+    try {
+      let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
+        worksheetDetailName,
+        worksheetType,
+        [
+          'worksheet',
+          'worksheet.bizplace',
+          'targetInventory',
+          'targetInventory.releaseGood',
+          'targetInventory.inventory',
+          'targetInventory.product',
+          'targetInventory.product.productDetails',
+          'targetInventory.product.productDetails.product',
+          'targetInventory.product.productDetails.childProductDetail'
+        ]
+      )
 
-    const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    const product: Product = targetInventory.product
-    let inventory: Inventory = targetInventory.inventory
-    const packingType: string = inventory.packingType
-    const packingSize: number = inventory.packingSize
+      const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
+      let targetInventory: OrderInventory = worksheetDetail.targetInventory
+      const product: Product = targetInventory.product
+      let inventory: Inventory = targetInventory.inventory
 
-    let pickedQty: number = 1
-    const releaseQty: number = targetInventory.releaseQty
+      //validation to prevent duplicated picking      
+      let oiValidate: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
+        where: { domain: this.domain, id: targetInventory.id, status: ORDER_INVENTORY_STATUS.PICKING }
+      })
+      if (!oiValidate)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`))
 
-    if (inventory.cartonId !== cartonId)
-      throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Carton ID', cartonId, inventory.cartonId))
+      //validation to prevent over release
+      if (inventory.qty <= 0)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
 
-    // search for matching product barcode
-    const productDetails: ProductDetail[] = product?.productDetails.filter(detail => !detail.deletedAt)
-    const isMatchingBarcode: boolean = productDetails.map(detail => detail.gtin).includes(productBarcode)
-    if (!isMatchingBarcode) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+      if (inventory.cartonId !== cartonId)
+        throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Carton ID', cartonId, inventory.cartonId))
 
-    // case for scanning parent packing type, packing size
-    const foundProductDetail: ProductDetail = productDetails.find(
-      (detail: ProductDetail) =>
-        detail.gtin === productBarcode &&
-        detail.packingType === packingType &&
-        detail.packingSize == packingSize &&
-        detail.product?.id === product.id
-    )
+      const packingType: string = inventory.packingType
+      const packingSize: number = inventory.packingSize
 
-    if (!foundProductDetail) {
-      const roProductDetail: ProductDetail = productDetails.find(
-        (parentDetail: ProductDetail) =>
-          parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
-      )
-
-      pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
-      if (pickedQty > releaseQty) {
-        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
-      }
-    }
+      let pickedQty: number = 1
+      const releaseQty: number = targetInventory.releaseQty
 
-    targetInventory.pickedQty = Boolean(targetInventory?.pickedQty) ? targetInventory.pickedQty + pickedQty : pickedQty
-    if (targetInventory.pickedQty == releaseQty) {
-      const leftQty: number = inventory.qty - releaseQty
-      if (leftQty < 0) {
-        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`))
-      }
+      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
 
-      targetInventory.status = ORDER_INVENTORY_STATUS.PICKED
+      // search for matching product barcode
+      const productDetails: ProductDetail[] = product?.productDetails.filter(detail => !detail.deletedAt)
+      const isMatchingBarcode: boolean = productDetails.map(detail => detail.gtin).includes(productBarcode)
+      if (!isMatchingBarcode) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
-      if (binLocation) {
-        const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
-          where: { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN }
-        })
+      // case for scanning parent packing type, packing size
+      const foundProductDetail: ProductDetail = productDetails.find(
+        (detail: ProductDetail) =>
+          detail.gtin === productBarcode &&
+          detail.packingType === packingType &&
+          detail.packingSize == packingSize &&
+          detail.product?.id === product.id
+      )
 
-        if (!foundBinLocation)
-          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+      if (!foundProductDetail) {
+        const roProductDetail: ProductDetail = productDetails.find(
+          (parentDetail: ProductDetail) =>
+            parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
+        )
 
-        targetInventory.binLocation = foundBinLocation
+        pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
+        if (pickedQty > releaseQty) {
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
+        }
       }
-      await this.updateOrderTargets([targetInventory])
 
-      inventory.qty -= targetInventory.releaseQty
-      inventory.uomValue = Math.round((inventory.uomValue - targetInventory.releaseUomValue) * 100) / 100
-      inventory.lockedQty = inventory.lockedQty - targetInventory.releaseQty
-      inventory.lockedUomValue = Math.round((inventory.lockedUomValue - targetInventory.releaseUomValue) * 100) / 100
-      inventory = await this.transactionInventory(
-        inventory,
-        releaseGood,
-        -targetInventory.releaseQty,
-        -targetInventory.releaseUomValue,
-        INVENTORY_TRANSACTION_TYPE.PICKING
-      )
+      if (product?.isRequireSerialNumberScanning) {
+        if ((!serialNumber || serialNumber == ''))
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
 
-      worksheetDetail.status = WORKSHEET_STATUS.DONE
-      worksheetDetail.updater = this.user
-      await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
-
-      if (leftQty === 0) {
-        inventory.status = INVENTORY_STATUS.TERMINATED
-        await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+        if (serialNumber) {
+          targetInventory.serialNumber = JSON.stringify(targetInventory.serialNumber ? [...(JSON.parse(targetInventory.serialNumber)), serialNumber] : [serialNumber])
+        }
       }
-    } else {
-      await this.updateOrderTargets([targetInventory])
+
+      await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
+
+    } catch (error) {
+      throw error
     }
   }
 
@@ -494,70 +481,75 @@ export class PickingWorksheetController extends VasWorksheetController {
     worksheetType: string,
     palletId: string,
     locationName: string,
-    releaseQty: number
+    pickedQty: number,
+    binLocation?: string,
+    serialNumber?: string
   ): Promise<void> {
-    let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
-      worksheetDetailName,
-      worksheetType,
-      [
-        'worksheet',
-        'targetInventory',
-        'targetInventory.releaseGood',
-        'targetInventory.inventory',
-        'targetInventory.inventory.location'
-      ]
-    )
-    const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    let inventory: Inventory = targetInventory.inventory
-    if (inventory.palletId !== palletId)
-      throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
-
-    const leftQty: number = inventory.qty - releaseQty
-    if (leftQty < 0) {
-      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`))
-    }
+    try {
+      let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
+        worksheetDetailName,
+        worksheetType,
+        [
+          'worksheet',
+          'targetInventory',
+          'targetInventory.releaseGood',
+          'targetInventory.inventory',
+          'targetInventory.inventory.location',
+          'targetInventory.product',
+        ]
+      )
 
-    targetInventory.pickedQty = releaseQty
-    targetInventory.status = ORDER_INVENTORY_STATUS.PICKED
-    await this.updateOrderTargets([targetInventory])
-
-    inventory.qty -= targetInventory.releaseQty
-    inventory.uomValue = Math.round((inventory.uomValue - targetInventory.releaseUomValue) * 100) / 100
-    inventory.lockedQty = inventory.lockedQty - targetInventory.releaseQty
-    inventory.lockedUomValue = Math.round((inventory.lockedUomValue - targetInventory.releaseUomValue) * 100) / 100
-    inventory = await this.transactionInventory(
-      inventory,
-      releaseGood,
-      -targetInventory.releaseQty,
-      -targetInventory.releaseUomValue,
-      INVENTORY_TRANSACTION_TYPE.PICKING
-    )
+      const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
+      let targetInventory: OrderInventory = worksheetDetail.targetInventory
+      const product: Product = targetInventory.product
+      let inventory: Inventory = targetInventory.inventory
 
-    worksheetDetail.status = WORKSHEET_STATUS.DONE
-    worksheetDetail.updater = this.user
-    await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+      //validation to prevent duplicated picking      
+      let oiValidate: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
+        where: { domain: this.domain, id: targetInventory.id, status: ORDER_INVENTORY_STATUS.PICKING }
+      })
+      if (!oiValidate)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`))
 
-    if (leftQty === 0) {
-      inventory.status = INVENTORY_STATUS.TERMINATED
-      await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
-    }
+      //validation to prevent over release
+      if (inventory.qty <= 0)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
 
-    const fromLocation: Location = targetInventory.inventory.location
-    if (locationName) {
-      const toLocation: Location = await this.trxMgr.getRepository(Location).findOne({
-        where: { domain: this.domain, name: locationName },
-        relations: ['warehouse']
-      })
+      if (inventory.palletId !== palletId)
+        throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
 
-      if (!toLocation) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName))
 
-      if (fromLocation.id !== toLocation.id) {
-        inventory.location = toLocation
-        inventory.warehouse = toLocation.warehouse
-        inventory.zone = toLocation.zone
-        inventory = await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.RELOCATE)
+      if (product?.isRequireSerialNumberScanning) {
+        if ((!serialNumber || serialNumber == ''))
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
+
+        if (serialNumber) {
+          targetInventory.serialNumber = JSON.stringify(targetInventory.serialNumber ? [...(JSON.parse(targetInventory.serialNumber)), serialNumber] : [serialNumber])
+        }
       }
+
+      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
+
+      await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
+
+      const fromLocation: Location = targetInventory.inventory.location
+      if (locationName) {
+        const toLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+          where: { domain: this.domain, name: locationName },
+          relations: ['warehouse']
+        })
+
+        if (!toLocation) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName))
+
+        if (fromLocation.id !== toLocation.id) {
+          inventory.location = toLocation
+          inventory.warehouse = toLocation.warehouse
+          inventory.zone = toLocation.zone
+          inventory = await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.RELOCATE)
+        }
+      }
+    } catch (error) {
+      throw error
     }
   }
 
@@ -937,4 +929,70 @@ export class PickingWorksheetController extends VasWorksheetController {
 
     return worksheetDetails
   }
+
+  private async checkAndSetBinPicking(orderInventory, binLocation) {
+    // bin picking validation
+    const binPickingSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+      where: {
+        domain: this.domain,
+        name: 'enable-bin-picking'
+      }
+    })
+    if (binPickingSetting != undefined && (binPickingSetting.value).toLowerCase() == 'true') {
+      if (binLocation) {
+        const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+          where: { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN }
+        })
+
+        if (!foundBinLocation)
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+
+        orderInventory.binLocation = foundBinLocation
+      } else {
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+      }
+    }
+
+    return orderInventory
+  }
+
+  private async updatePickingTransaction(releaseGood, orderInventory, worksheetDetail, inventory, pickedQty) {
+    const releaseQty: number = orderInventory.releaseQty
+
+    orderInventory.pickedQty = Boolean(orderInventory?.pickedQty) ? orderInventory.pickedQty + pickedQty : pickedQty
+    if (orderInventory.pickedQty == releaseQty) {
+      const leftQty: number = inventory.qty - releaseQty
+      if (leftQty < 0) {
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`))
+      }
+
+      orderInventory.status = ORDER_INVENTORY_STATUS.PICKED
+
+      inventory.qty -= orderInventory.releaseQty
+      inventory.uomValue = Math.round((inventory.uomValue - orderInventory.releaseUomValue) * 100) / 100
+      inventory.lockedQty = inventory.lockedQty - orderInventory.releaseQty
+      inventory.lockedUomValue = Math.round((inventory.lockedUomValue - orderInventory.releaseUomValue) * 100) / 100
+      inventory = await this.transactionInventory(
+        inventory,
+        releaseGood,
+        -orderInventory.releaseQty,
+        -orderInventory.releaseUomValue,
+        INVENTORY_TRANSACTION_TYPE.PICKING
+      )
+
+      worksheetDetail.status = WORKSHEET_STATUS.DONE
+      worksheetDetail.updater = this.user
+      await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+      if (leftQty === 0) {
+        inventory.status = INVENTORY_STATUS.TERMINATED
+        await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+      }
+    }
+
+    await this.updateOrderTargets([orderInventory])
+
+    return orderInventory
+  }
 }
+

package/server/controllers/render-elccl-grn.ts

@@ -1,11 +1,13 @@
+import FormData from 'form-data'
+import fetch from 'node-fetch'
+import { EntityManager, getManager, getRepository } from 'typeorm'
+
 import { Attachment, STORAGE } from '@things-factory/attachment-base'
 import { Bizplace, ContactPoint } from '@things-factory/biz-base'
 import { config } from '@things-factory/env'
 import { ArrivalNotice, GoodsReceivalNote, ORDER_PRODUCT_STATUS, ORDER_STATUS } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import FormData from 'form-data'
-import fetch from 'node-fetch'
-import { EntityManager, getManager, getRepository } from 'typeorm'
+
 import { TEMPLATE_TYPE, TRANSACTION_TYPE } from '../constants'
 import { Worksheet } from '../entities'
 import { DateTimeConverter } from '../utils/datetime-util'
@@ -117,19 +119,19 @@ export async function renderElcclGRN({ grnNo }, context: any) {
       `
       create temp table tmp2 on commit drop as(
         select id,seq,ref_order_id,order_no,"name",pallet_id,batch_id,product_id,warehouse_id,location_id,"zone",order_ref_no,packing_type,uom as unit,qty,
-        opening_qty,uom_value,opening_weight,description,status,transaction_type,created_at,updated_at,domain_id,bizplace_id,creator_id,updater_id,
+        opening_qty,uom_value,description,status,transaction_type,created_at,updated_at,domain_id,bizplace_id,creator_id,updater_id,
         reusable_pallet_id,release_order_id,release_qty,inbound_qty,remaining_qty, inbound_qty as loose_amt, release_uom_value, inbound_uom_value,remaining_uom_value, 
         inbound_uom_value as loose_wgt, null as cross_dock, inventory_id
         from tmp where release_qty > 0 or release_qty is null
         union all 
         select id,seq,ref_order_id,order_no,"name",pallet_id,batch_id,product_id,warehouse_id,location_id,"zone",order_ref_no,packing_type,uom as unit,qty,
-        opening_qty,uom_value,opening_weight,description,status,transaction_type,created_at,updated_at,domain_id,bizplace_id,creator_id,updater_id,
+        opening_qty,uom_value,description,status,transaction_type,created_at,updated_at,domain_id,bizplace_id,creator_id,updater_id,
         reusable_pallet_id,release_order_id,release_qty,inbound_qty,remaining_qty, remaining_qty as loose_amt, release_uom_value, inbound_uom_value,remaining_uom_value, 
         remaining_uom_value as loose_wgt, null as cross_dock, inventory_id
         from tmp where release_qty < 0 and remaining_qty > 0
         union all 
         select id,seq,ref_order_id,order_no,"name",pallet_id,batch_id,product_id,warehouse_id,location_id,"zone",order_ref_no,packing_type,uom as unit,qty,
-        opening_qty,uom_value,opening_weight,description,status,transaction_type,created_at,updated_at,domain_id,bizplace_id,creator_id,updater_id,
+        opening_qty,uom_value,description,status,transaction_type,created_at,updated_at,domain_id,bizplace_id,creator_id,updater_id,
         reusable_pallet_id,release_order_id,release_qty,inbound_qty,remaining_qty, -release_qty as loose_amt, release_uom_value,inbound_uom_value,remaining_uom_value, 
         -release_uom_value as loose_wgt, '[C/D]' as cross_dock, inventory_id
         from tmp where release_qty < 0

package/server/controllers/render-manifest.ts

@@ -0,0 +1,68 @@
+import FormData from 'form-data'
+import fetch from 'node-fetch'
+import { getRepository } from 'typeorm'
+
+import { Attachment, STORAGE } from '@things-factory/attachment-base'
+import { config } from '@things-factory/env'
+import { Manifest, ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { TEMPLATE_TYPE } from '../constants'
+import { DateTimeConverter } from '../utils/datetime-util'
+
+const REPORT_API_URL = config.get('reportApiUrl', 'http://localhost:8888/rest/report/show_html')
+
+export async function renderManifest({ manifestNo }, context: any) {
+  // 1. find domain
+  const domain: Domain = await getRepository(Domain).findOne({
+    where: { id: context.state.domain.id }
+  })
+
+  // 2. find manifest
+  const manifest: Manifest = await getRepository(Manifest).findOne({
+    where: { domain, name: manifestNo },
+    relations: ['domain']
+  })
+
+  // find release good
+  const releaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
+    where: { domain, manifest }
+  })
+
+  // 7. find grn template based on category
+  const foundTemplate: Attachment = await getRepository(Attachment).findOne({
+    where: { domain, category: TEMPLATE_TYPE.MANIFEST_TEMPLATE }
+  })
+
+  const template = await STORAGE.readFile(foundTemplate.path, 'utf-8')
+
+  const data = {
+    shipping_provider: manifest?.shippingProvider,
+    manifest_no: manifest?.name,
+    manifest_date: DateTimeConverter.date(manifest?.createdAt).toString(),
+    total_list: releaseGoods?.length || 0,
+    product_list: releaseGoods.map((item, idx) => {
+      return {
+        list_no: idx + 1,
+        order_no: item?.refNo,
+        tracking_no: item?.trackingNo,
+        phone: item?.phone1,
+        delivery_date: DateTimeConverter.date(manifest?.dispatchedAt).toString(),
+        attention_to: item?.attentionTo,
+        delivery_address: item?.deliveryAddress1,
+        postal_code_city: `${item?.postalCode}, ${item?.city}`
+      }
+    })
+  }
+
+  const formData = new FormData()
+  formData.append('template', template)
+  formData.append('jsonString', JSON.stringify(data))
+
+  const response = await fetch(REPORT_API_URL, {
+    method: 'POST',
+    body: formData
+  })
+
+  return await response.text()
+}

package/server/controllers/worksheet-controller.ts

@@ -555,6 +555,44 @@ export class WorksheetController {
     return worksheet
   }
 
+  // @chernhaoee I think the naming of this function is not proper. Seems like it should be something like "updateLoadingWorksheet" since the logic targets only Loading Order Target
+  async updateWorksheet(
+    worksheetType: string,
+    refOrder: ReferenceOrderType,
+    worksheet: Worksheet,
+    orderTargets: OrderTargetTypes[],
+    refOrderStatus: string,
+    orderTargetStatus: string
+  ): Promise<Worksheet> {
+    let newOrderTarget = []
+
+    orderTargets.forEach((orderTarget: OrderTargetTypes) => {
+      orderTarget.status = orderTargetStatus
+    })
+    orderTargets = await this.updateOrderTargets(orderTargets)
+
+    for (let orderTarget of orderTargets) {
+      try {
+        await this.findWorksheetDetail({
+          targetInventory: orderTarget.id,
+          type: WORKSHEET_TYPE.LOADING
+        })
+      } catch (e) {
+        newOrderTarget.push(orderTarget)
+      }
+    }
+
+    worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, worksheetType, newOrderTarget)
+
+    // find worksheet details that doesnt exist based on order inventory
+    //worksheet.worksheetDetails = await this.findWorksheetDetail(worksheet.id)
+
+    refOrder.status = refOrderStatus
+    await this.updateRefOrder(refOrder)
+
+    return worksheet
+  }
+
   async generateBatchWorksheet(
     worksheetType: string,
     batchPickingWorksheet: Worksheet,
@@ -669,6 +707,7 @@ export class WorksheetController {
     } else if (
       worksheetType === WORKSHEET_TYPE.PUTAWAY ||
       worksheetType === WORKSHEET_TYPE.PICKING ||
+      worksheetType === WORKSHEET_TYPE.PACKING ||
       worksheetType === WORKSHEET_TYPE.LOADING ||
       worksheetType === WORKSHEET_TYPE.WAREHOUSE_RETURN ||
       worksheetType === WORKSHEET_TYPE.UNLOADING_RETURN
@@ -928,13 +967,13 @@ export class WorksheetController {
       )
       if (!currentProductDetail)
         throw new Error(this.ERROR_MSG.FIND.NOT_MATCH('inner pack', `GTIN (${productBarcode})`))
-      childQty = scannedProductDetail.childQty
+      childQty = scannedProductDetail.packingSize
     } else {
       throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
     }
 
     if (hasMatchingChild) {
-      childQty = scannedProductDetail.childQty
+      childQty = scannedProductDetail.packingSize
     } else {
       while (hasChildRelation && !hasMatchingChild) {
         hasChildRelation = Boolean(currentProductDetail?.childProductDetail)

package/server/graphql/resolvers/pallet/pallet-outbound.ts

@@ -1,10 +1,9 @@
-import { EntityManager, In } from 'typeorm'
-
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Pallet, PalletHistory } from '@things-factory/warehouse-base'
+import { EntityManager, getRepository, In } from 'typeorm'
 
 export const palletOutbound = {
   async palletOutbound(_: any, { refOrderNo, patches }, context: any) {

package/server/graphql/resolvers/worksheet/inventories-by-pallet.ts

@@ -1,10 +1,10 @@
-import { buildQuery, buildCondition } from '@things-factory/shell'
-import { Domain } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder, Brackets } from 'typeorm'
+import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Inventory } from '@things-factory/warehouse-base'
 import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
-import { User } from '@things-factory/auth-base'
+import { buildCondition, buildQuery, Domain } from '@things-factory/shell'
+import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
 
 export const inventoriesByPalletResolver = {
   async inventoriesByPallet(_: any, { filters, pagination, sortings, locationSortingRules }, context: any) {
@@ -41,10 +41,11 @@ export const inventoriesByPalletResolver = {
       .andWhere('iv.qty > 0')
       .andWhere('CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END >= 0')
       .andWhere('iv.qty - CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END > 0')
+      .andWhere(`location.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')`)
       .andWhere(
-        `(iv.batch_id, product.name, iv.packing_type) NOT IN (
+        `(iv.batch_id, product.name, iv.packing_type, product.brand) NOT IN (
         SELECT 
-          oi.batch_id, p2.name, oi.packing_type
+          oi.batch_id, p2.name, oi.packing_type, p2.brand
         FROM 
           order_inventories oi
         LEFT JOIN
@@ -112,7 +113,8 @@ export const inventoriesByPalletResolver = {
           remainUomValueWithUom: remainUomValue + ' ' + item.uom,
           // product: item.product,
           productName: item.product.name,
-          productSKU: item.product.sku
+          productSKU: item.product.sku,
+          productBrand: item.product.brand
         }
       })
     )