@things-factory/worksheet-base 3.7.2 → 3.7.7

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-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,

package/server/graphql/resolvers/worksheet/loading-worksheet.ts

@@ -1,7 +1,9 @@
-import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { Equal, getRepository, In, Not, SelectQueryBuilder } from 'typeorm'
+
+import { ORDER_STATUS, ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { Equal, getRepository, Not } from 'typeorm'
+import { Inventory, Location } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { fetchExecutingWorksheet } from '../../../utils'
@@ -9,11 +11,34 @@ import { fetchExecutingWorksheet } from '../../../utils'
 export const loadingWorksheetResolver = {
   async loadingWorksheet(_: any, { releaseGoodNo }, context: any) {
     const { domain }: { domain: Domain } = context.state
-    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+    let releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
       where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.LOADING*/ },
       relations: ['bizplace']
     })
 
+    // Find Release Order based on Bin
+    if (!releaseGood) {
+      const binLocation: Location = await getRepository(Location).findOne({
+        where: { domain, name: releaseGoodNo }
+      })
+
+      const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('orderInventory')
+      qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
+        .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
+        .innerJoinAndSelect('bizplace.domain', 'domain')
+        .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
+        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', { orderInventoryStatus: [ORDER_INVENTORY_STATUS.LOADING, ORDER_INVENTORY_STATUS.LOADED] })
+        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
+        .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.LOADING })
+
+      const orderInventoryByBin = await qb.getOne()
+
+      if (orderInventoryByBin?.releaseGood) {
+        releaseGoodNo = orderInventoryByBin.releaseGood.name
+        releaseGood = orderInventoryByBin.releaseGood
+      }
+    }
+
     if (!releaseGood) throw new Error(`Release good doesn't exists.`)
 
     const foundWorksheet: Worksheet = await fetchExecutingWorksheet(
@@ -40,6 +65,7 @@ export const loadingWorksheetResolver = {
 
     return {
       worksheetInfo: {
+        releaseGood,
         bizplaceName: releaseGood.bizplace.name,
         startedAt: foundWorksheet.startedAt,
         refNo: releaseGood.refNo,

package/server/graphql/resolvers/worksheet/packing-worksheet.ts

@@ -1,16 +1,17 @@
-import { EntityManager } from 'typeorm'
+import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { MarketplaceOrder, MarketplaceOrderItem, MarketplaceOrderShipping } from '@things-factory/marketplace-base'
-import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
+import { Inventory, Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_TYPE } from '../../../constants'
 import { SellercraftController } from '../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { fetchExecutingWorksheet } from '../../../utils'
+import { ORDER_STATUS } from '@things-factory/sales-base'
 
 export const packingWorksheetResolver = {
   async packingWorksheet(_: any, { releaseGoodNo }, context: any) {
@@ -23,7 +24,30 @@ export const packingWorksheetResolver = {
       relations: ['bizplace', 'bizplace.domain']
     })
 
+    // Find Release Order based on Bin
+    if (!releaseGood) {
+      const binLocation: Location = await tx.getRepository(Location).findOne({
+        where: { domain, name: releaseGoodNo }
+      })
+
+      const qb: SelectQueryBuilder<OrderInventory> = tx.getRepository(OrderInventory).createQueryBuilder('orderInventory')
+      qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
+        .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
+        .innerJoinAndSelect('bizplace.domain', 'domain')
+        .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
+        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', { orderInventoryStatus: [ORDER_INVENTORY_STATUS.PACKING, ORDER_INVENTORY_STATUS.PACKED] })
+        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
+        .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.PACKING })
+
+      const orderInventoryByBin = await qb.getOne()
+      if (orderInventoryByBin?.releaseGood) {
+        releaseGoodNo = orderInventoryByBin.releaseGood.name
+        releaseGood = orderInventoryByBin.releaseGood
+      }
+    }
+
     if (!releaseGood) throw new Error(`Release good dosen't exist.`)
+
     const worksheet: Worksheet = await fetchExecutingWorksheet(
       domain,
       releaseGood.bizplace,
@@ -110,6 +134,7 @@ export const packingWorksheetResolver = {
 
     return {
       worksheetInfo: {
+        releaseGood,
         bizplaceName: releaseGood.bizplace.name,
         refNo: releaseGood.refNo,
         refNo2: releaseGood.refNo2,