@things-factory/worksheet-base 4.0.11 → 4.0.16

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,

package/server/graphql/resolvers/worksheet/pending-cancellation-release-order.ts

@@ -1,18 +1,19 @@
-import { Role } from '@things-factory/auth-base'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
+import { EntityManager, In } from 'typeorm'
+
+import { Role, User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { sendNotification } from '@things-factory/notification'
-import { EntityManager, In } from 'typeorm'
 import {
+  DeliveryOrder,
   ORDER_INVENTORY_STATUS,
   ORDER_STATUS,
   ORDER_VAS_STATUS,
   OrderInventory,
-  DeliveryOrder,
   OrderVas,
   ReleaseGood
 } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
 export const pendingCancellationReleaseOrder = {
@@ -46,13 +47,18 @@ export const pendingCancellationReleaseOrder = {
         }
       })
       await tx.getRepository(OrderInventory).save(pickedOIs)
-    } else if (foundRO.status === ORDER_STATUS.PICKING || foundRO.status === ORDER_STATUS.READY_TO_PICK) {
+    } else if (
+      foundRO.status === ORDER_STATUS.PICKING ||
+      foundRO.status === ORDER_STATUS.READY_TO_PICK ||
+      foundRO.status === ORDER_STATUS.PENDING_WORKSHEET
+    ) {
       pickingOIs = targetOIs
         .filter(
           (oi: OrderInventory) =>
             oi.status === ORDER_INVENTORY_STATUS.PICKING ||
             oi.status === ORDER_INVENTORY_STATUS.READY_TO_PICK ||
-            oi.status === ORDER_INVENTORY_STATUS.PENDING_SPLIT
+            oi.status === ORDER_INVENTORY_STATUS.PENDING_SPLIT ||
+            oi.status === ORDER_INVENTORY_STATUS.PENDING_WORKSHEET
         )
         .map((targetOI: OrderInventory) => {
           return {

package/server/graphql/resolvers/worksheet/picking/activate-picking.ts

@@ -7,7 +7,7 @@ import { MarketplaceOrder } from '@things-factory/marketplace-base'
 import { ORDER_STATUS, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 
-import { EcommerceController, PickingWorksheetController, SellercraftController } from '../../../../controllers'
+import { EcommerceController, PickingWorksheetController } from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
 
 export const activatePickingResolver = {
@@ -40,11 +40,6 @@ export async function activatePicking(
       .getRepository(Sellercraft)
       .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
-    if (sellercraft) {
-      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-      await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
-    }
-
     if (marketplaceStores?.length && !sellercraft) {
       if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
         const worksheetDetails = worksheet.worksheetDetails

package/server/graphql/resolvers/worksheet/picking/complete-picking.ts

@@ -7,6 +7,7 @@ import { MarketplaceStore, MarketplaceTransporter } from '@things-factory/integr
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { MarketplaceOrder, MarketplaceOrderItem, MarketplaceOrderShipping } from '@things-factory/marketplace-base'
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
@@ -83,6 +84,7 @@ export async function completePicking(
 
     if (sellercraft) {
       const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
       await sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
     } else {
       const companyDomain: Domain = releaseGood.bizplace.company.domain
@@ -187,10 +189,29 @@ export async function completePicking(
 
   if (releaseGood.packingOption) {
     const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-    await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+
+    const directActivatePackingWorksheet: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain: domain, category: 'id-rule', name: 'enable-direct-activate-packing-worksheet' }
+    })
+    const partnerDirectActivatePackingWorksheetSetting: PartnerSetting = await tx
+      .getRepository(PartnerSetting)
+      .findOne({
+        where: { setting: directActivatePackingWorksheet, domain: domain, partnerDomain: releaseGood.bizplace?.domain }
+      })
+
+    let packingWorksheet: Worksheet = await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+
+    if (directActivatePackingWorksheet != undefined && directActivatePackingWorksheet.value.toLowerCase() == 'true') {
+      if (partnerDirectActivatePackingWorksheetSetting != undefined) {
+        if (partnerDirectActivatePackingWorksheetSetting.value.toLowerCase() == 'true')
+          await packingWSCtrl.activatePacking(packingWorksheet.name)
+      } else {
+        await packingWSCtrl.activatePacking(packingWorksheet.name)
+      }
+    }
   } else {
     // Find Existing Loading Worksheet if any
-    const existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+    let existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
       where: {
         releaseGood,
         type: WORKSHEET_TYPE.LOADING,
@@ -212,9 +233,19 @@ export async function completePicking(
       const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
       await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
     } else {
-      throw new Error(
-        'Picking completion has been triggered twice, loading worksheet has been generated. Kindly proceed to loading.'
+      const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+      let loadingWorksheet: Worksheet = await loadingWSCtrl.updateLoadingWorksheet(
+        releaseGoodNo,
+        pickedTargetInventories,
+        existLoadingWorksheet
       )
+
+      if (!loadingWorksheet.worksheetDetails?.length) {
+        loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+      }
+
+      const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
     }
   }
 }

package/server/graphql/resolvers/worksheet/picking/fetch-and-assign-picking-task.ts

@@ -0,0 +1,78 @@
+import { EntityManager, getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
+import { Worksheet } from '../../../../entities'
+import { pickingWorksheet } from '../picking-worksheet'
+import { activatePicking } from './activate-picking'
+
+export const fetchAndAssignPickingTaskResolver = {
+  async fetchAndAssignPickingTask(_: any, {}, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const assignee: User = await tx.getRepository(User).findOne(user.id, { relations: ['domains'] })
+    if ((assignee?.domains || []).every((userDomain: Domain) => userDomain.id !== domain.id))
+      throw new Error('Target user is not belong to current domain')
+
+    if (!assignee) throw new Error('failed to find target user')
+
+    let worksheet: Worksheet
+    worksheet = await tx.getRepository(Worksheet).findOne({
+      relations: ['releaseGood'],
+      where: [
+        {
+          domain,
+          type: WORKSHEET_TYPE.PICKING,
+          status: WORKSHEET_STATUS.EXECUTING,
+          assignee: assignee
+        },
+        {
+          domain,
+          type: WORKSHEET_TYPE.PICKING,
+          status: WORKSHEET_STATUS.DEACTIVATED,
+          assignee: assignee
+        }
+      ],
+      order: {
+        name: 'ASC'
+      }
+    })
+
+    if (!worksheet) {
+      worksheet = await tx.getRepository(Worksheet).findOne({
+        relations: ['releaseGood'],
+        where: [
+          {
+            domain,
+            type: WORKSHEET_TYPE.PICKING,
+            status: WORKSHEET_STATUS.EXECUTING,
+            assignee: null
+          },
+          {
+            domain,
+            type: WORKSHEET_TYPE.PICKING,
+            status: WORKSHEET_STATUS.DEACTIVATED,
+            assignee: null
+          }
+        ]
+      })
+
+      await getRepository(Worksheet).update({ id: worksheet.id }, { assignee: assignee })
+    }
+
+    if (worksheet.status == WORKSHEET_STATUS.DEACTIVATED) await activatePicking(tx, domain, user, worksheet.name)
+
+    const locationSortingRules: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain, name: 'rule-for-picking-product' }
+    })
+
+    const sortingRule = JSON.parse(locationSortingRules.value)
+    const locationSortingRule = Object.keys(sortingRule).map(field => {
+      return { name: field, desc: sortingRule[field] === 'DESC' }
+    })
+
+    return await pickingWorksheet(domain, worksheet.releaseGood.name, locationSortingRule, tx)
+  }
+}

package/server/graphql/resolvers/worksheet/picking/index.ts

@@ -2,6 +2,7 @@ import { activateBatchPickingResolver } from './activate-batch-picking'
 import { activatePickingResolver } from './activate-picking'
 import { assignPickingInventoriesResolver } from './assign-picking-inventories'
 import { assignPickingWorkerResolver } from './assign-picking-worker'
+import { fetchAndAssignPickingTaskResolver } from './fetch-and-assign-picking-task'
 import { batchPickingResolver } from './batch-picking'
 import { completeBatchPickingResolver } from './complete-batch-picking'
 import { completePickingResolver } from './complete-picking'
@@ -21,5 +22,6 @@ export const Mutations = {
   ...batchPickingResolver,
   ...completePickingResolver,
   ...completeBatchPickingResolver,
-  ...assignPickingWorkerResolver
+  ...assignPickingWorkerResolver,
+  ...fetchAndAssignPickingTaskResolver
 }

package/server/graphql/resolvers/worksheet/picking/picking.ts

@@ -4,9 +4,9 @@ import { EntityManager } from 'typeorm'
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const pickingResolver = {
-  async picking(_: any, { worksheetDetailName, worksheetType, palletId, locationName, releaseQty }, context: any) {
+  async picking(_: any, { worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await picking(tx, domain, user, worksheetDetailName, worksheetType, palletId, locationName, releaseQty)
+    await picking(tx, domain, user, worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber)
   }
 }
 
@@ -18,8 +18,10 @@ export async function picking(
   worksheetType: string,
   palletId: string,
   locationName: string,
-  releaseQty: number
+  releaseQty: number,
+  binLocation?: string,
+  serialNumber?: string
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.picking(worksheetDetailName, worksheetType, palletId, locationName, releaseQty)
+  await worksheetController.picking(worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber)
 }

package/server/graphql/resolvers/worksheet/picking/scan-product-picking.ts

@@ -6,7 +6,7 @@ import { PickingWorksheetController } from '../../../../controllers'
 export const scanProductPickingResolver = {
   async scanProductPicking(
     _: any,
-    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation },
+    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber },
     context: any
   ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
@@ -18,7 +18,8 @@ export const scanProductPickingResolver = {
       worksheetType,
       productBarcode,
       cartonId,
-      binLocation
+      binLocation,
+      serialNumber
     )
   }
 }
@@ -31,7 +32,8 @@ export async function scanProductPicking(
   worksheetType: string,
   productBarcode: string,
   cartonId: string,
-  binLocation?: string
+  binLocation?: string,
+  serialNumber?: string
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   await worksheetController.scanProductPicking(
@@ -39,6 +41,7 @@ export async function scanProductPicking(
     worksheetType,
     productBarcode,
     cartonId,
-    binLocation
+    binLocation,
+    serialNumber
   )
 }

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

@@ -1,8 +1,8 @@
-import { createQueryBuilder, getRepository, SelectQueryBuilder } from 'typeorm'
+import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
 
 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_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
@@ -10,71 +10,111 @@ import { fetchExecutingWorksheet } from '../../../utils'
 
 export const pickingWorksheetResolver = {
   async pickingWorksheet(_: any, { releaseGoodNo, locationSortingRules }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-      where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.PICKING*/ },
-      relations: ['bizplace', 'bizplace.domain']
-    })
-    if (!releaseGood) throw new Error(`Couldn't find picking worksheet by order no (${releaseGoodNo})`)
-
-    const worksheet = await fetchExecutingWorksheet(
-      domain,
-      releaseGood.bizplace,
-      ['bizplace'],
-      WORKSHEET_TYPE.PICKING,
-      releaseGood
-    )
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
 
-    const qb: SelectQueryBuilder<WorksheetDetail> = createQueryBuilder(WorksheetDetail, 'WSD')
-    qb.leftJoinAndSelect('WSD.targetInventory', 'T_INV')
-      .leftJoinAndSelect('T_INV.inventory', 'INV')
-      .leftJoinAndSelect('T_INV.product', 'PROD')
-      .leftJoinAndSelect('INV.location', 'LOC')
+    return await pickingWorksheet(domain, releaseGoodNo, locationSortingRules, tx)
+  }
+}
 
-    if (locationSortingRules?.length > 0) {
-      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
-        qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-      })
-    }
+export async function pickingWorksheet(
+  domain: Domain,
+  releaseGoodNo: String,
+  locationSortingRules: any,
+  tx: EntityManager
+) {
+  let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+    where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.PICKING*/ },
+    relations: ['bizplace', 'bizplace.domain']
+  })
 
-    const worksheetDetails: WorksheetDetail[] = await qb
-      .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
-      .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
-      .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
-      .getMany()
+  // Find Release Order based on Bin
+  if (!releaseGood) {
+    const binLocation: Location = await tx.getRepository(Location).findOne({
+      where: { domain, name: releaseGoodNo }
+    })
 
-    return {
-      worksheetInfo: {
-        bizplaceName: releaseGood.bizplace.name,
-        partnerDomainId: releaseGood.bizplace?.domain.id,
-        startedAt: worksheet.startedAt,
-        refNo: releaseGood.refNo,
-        refNo2: releaseGood.refNo2,
-        releaseGood
+    const orderInventoryByBin: OrderInventory = await tx.getRepository(OrderInventory).findOne({
+      where: {
+        domain,
+        binLocation,
+        status: In([ORDER_INVENTORY_STATUS.PICKING, ORDER_INVENTORY_STATUS.PICKED])
+      },
+      order: {
+        createdAt: 'ASC'
       },
-      worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
-        const targetInventory: OrderInventory = pickingWSD.targetInventory
-        const inventory: Inventory = targetInventory.inventory
-        return {
-          name: pickingWSD.name,
-          palletId: inventory?.palletId,
-          cartonId: inventory?.cartonId,
-          batchId: inventory?.batchId,
-          batchIdRef: inventory?.batchIdRef,
-          product: inventory?.product,
-          qty: inventory?.qty,
-          releaseQty: targetInventory.releaseQty,
-          pickedQty: targetInventory.pickedQty,
-          status: pickingWSD.status,
-          description: pickingWSD.description,
-          targetName: targetInventory.name,
-          packingType: inventory?.packingType,
-          packingSize: inventory?.packingSize,
-          expirationDate: inventory?.expirationDate,
-          location: inventory?.location,
-          relatedOrderInv: targetInventory
-        }
-      })
+      relations: ['releaseGood', 'releaseGood.bizplace', 'releaseGood.bizplace.domain']
+    })
+
+    if (orderInventoryByBin?.releaseGood) {
+      releaseGoodNo = orderInventoryByBin.releaseGood.name
+      releaseGood = orderInventoryByBin.releaseGood
     }
   }
+
+  if (!releaseGood) throw new Error(`Couldn't find picking worksheet by order no (${releaseGoodNo})`)
+
+  const worksheet = await fetchExecutingWorksheet(
+    domain,
+    releaseGood.bizplace,
+    ['bizplace'],
+    WORKSHEET_TYPE.PICKING,
+    releaseGood,
+    tx
+  )
+
+  const qb: SelectQueryBuilder<WorksheetDetail> = tx.createQueryBuilder(WorksheetDetail, 'WSD')
+  qb.leftJoinAndSelect('WSD.targetInventory', 'T_INV')
+    .leftJoinAndSelect('T_INV.binLocation', 'BIN_LOC')
+    .leftJoinAndSelect('T_INV.inventory', 'INV')
+    .leftJoinAndSelect('T_INV.product', 'PROD')
+    .leftJoinAndSelect('INV.location', 'LOC')
+
+  if (locationSortingRules?.length > 0) {
+    locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
+      qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+    })
+  }
+
+  qb.addOrderBy(`PROD.name`, 'ASC')
+
+  const worksheetDetails: WorksheetDetail[] = await qb
+    .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
+    .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
+    .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
+    .getMany()
+
+  return {
+    worksheetInfo: {
+      bizplaceName: releaseGood.bizplace.name,
+      partnerDomainId: releaseGood.bizplace?.domain.id,
+      startedAt: worksheet.startedAt,
+      refNo: releaseGood.refNo,
+      refNo2: releaseGood.refNo2,
+      releaseGood
+    },
+    worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
+      const targetInventory: OrderInventory = pickingWSD.targetInventory
+      const inventory: Inventory = targetInventory.inventory
+      return {
+        name: pickingWSD.name,
+        palletId: inventory?.palletId,
+        cartonId: inventory?.cartonId,
+        batchId: inventory?.batchId,
+        batchIdRef: inventory?.batchIdRef,
+        product: inventory?.product,
+        qty: inventory?.qty,
+        binLocation: targetInventory?.binLocation || '',
+        releaseQty: targetInventory.releaseQty,
+        pickedQty: targetInventory.pickedQty,
+        status: pickingWSD.status,
+        description: pickingWSD.description,
+        targetName: targetInventory.name,
+        packingType: inventory?.packingType,
+        packingSize: inventory?.packingSize,
+        expirationDate: inventory?.expirationDate,
+        location: inventory?.location,
+        relatedOrderInv: targetInventory
+      }
+    })
+  }
 }