@things-factory/worksheet-base 8.0.0-beta.8 → 8.0.0

package/server/graphql/resolvers/worksheet/vas-transactions/unpacking/unpacking.ts

@@ -0,0 +1,164 @@
+import { Bizplace } from '@things-factory/biz-base'
+import { generateId } from '@things-factory/id-rule-base'
+import { Product } from '@things-factory/product-base'
+import { ORDER_PRODUCT_STATUS, OrderNoGenerator, OrderProduct, OrderVas, ReleaseGood } from '@things-factory/sales-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../../constants'
+import { VasWorksheetController } from '../../../../../controllers/vas/vas-worksheet-controller'
+import { Worksheet, WorksheetDetail } from '../../../../../entities'
+import { WorksheetNoGenerator } from '../../../../../utils'
+import { executeVas } from '../../vas/execute-vas'
+import { getWorksheetDetailByName } from '../common-utils'
+import { RefOrderType } from '../interfaces'
+
+export const unpackingResolver = {
+  async unpacking(
+    _: any,
+    { worksheetDetailName, childProductId, unpackQty, unpackUomValue, palletId, locationName },
+    context: any
+  ) {
+    const { tx, domain, user } = context.state
+
+    const childProduct: Product = await tx.getRepository(Product).findOne({
+      where: { id: childProductId },
+      relations: ['domain']
+    })
+    if (!childProduct) throw new Error(`Couldn't find product by its sku (${childProduct.sku})`)
+
+    // Find target worksheet detail & target order vas & bizplace
+    const wsd: WorksheetDetail = await getWorksheetDetailByName(tx, domain, worksheetDetailName)
+    let { bizplace, targetVas }: { bizplace: Bizplace; targetVas: OrderVas } = wsd
+
+    // Init refOrder
+    //@ts-ignore
+    const { arrivalNotice, releaseGood, vasOrder }: { [key: string]: RefOrderType } = targetVas
+    const refOrder: RefOrderType = arrivalNotice || releaseGood || vasOrder || null
+    if (!refOrder) throw new Error(`Couldn't find reference order with current order vas`)
+
+    if (!palletId && refOrder instanceof ReleaseGood) {
+      // auto generate pallet ID for release order
+      const today = new Date()
+      const year = today.getFullYear()
+      const month = today.getMonth()
+      const day = today.getDate()
+
+      const yy = String(year).substr(String(year).length - 2)
+      const mm = String(month + 1).padStart(2, '0')
+      const dd = String(day).padStart(2, '0')
+
+      const date = yy + mm + dd
+      palletId = await generateId({
+        domain,
+        type: 'vas_pallet_id',
+        seed: {
+          batchId: targetVas.targetBatchId,
+          date: date
+        }
+      })
+
+      // to get refInventory location to assign as new inventory location
+      if (!locationName) {
+        const foundOrderVas: OrderVas = await tx.getRepository(OrderVas).findOne({
+          where: { id: targetVas.id },
+          relations: ['targetProduct', 'inventory', 'inventory.location']
+        })
+
+        locationName = foundOrderVas?.inventory?.location.name
+      }
+    }
+
+    if (palletId) {
+      const worksheetController: VasWorksheetController = new VasWorksheetController(tx, domain, user)
+      await worksheetController.unpackingWithPallet(
+        worksheetDetailName,
+        childProduct,
+        unpackQty,
+        unpackUomValue,
+        palletId,
+        locationName,
+        refOrder
+      )
+    } else {
+      let foundOP: OrderProduct = await tx.getRepository(OrderProduct).findOne({
+        where: {
+          domain: { id: domain.id },
+          arrivalNotice: { id: arrivalNotice.id },
+          batchId: targetVas.targetBatchId,
+          product: { id: targetVas.targetProduct.id }
+        }
+      })
+
+      //Create new order product for unpacked products
+      let newOP: OrderProduct = new OrderProduct()
+      newOP.domain = domain
+      newOP.bizplace = bizplace
+      newOP.name = OrderNoGenerator.orderProduct()
+      newOP.batchId = targetVas.targetBatchId
+      newOP.packingType = childProduct.packingType
+      newOP.uom = childProduct.primaryUnit
+      newOP.packQty = unpackQty
+      newOP.uomValue = unpackUomValue
+      newOP.palletQty = null
+      newOP.totalUomValue =
+        (Number(unpackQty) * Number(unpackUomValue)).toFixed(2) + ' ' + (childProduct.primaryUnit || '')
+      newOP.status = ORDER_PRODUCT_STATUS.READY_TO_UNLOAD
+      //@ts-ignore
+      newOP.arrivalNotice = arrivalNotice
+      newOP.product = childProduct
+      newOP.creator = user
+      newOP.updater = user
+
+      await tx.getRepository(OrderProduct).save(newOP)
+
+      // update unpackQty and unpackUomValue of original product
+      foundOP.unpackQty = unpackQty
+      foundOP.unpackUomValue = unpackUomValue
+
+      // update packQty and totalUomValue of original product
+      foundOP.packQty -= targetVas.qty
+      foundOP.totalUomValue = `${(foundOP.uomValue * foundOP.packQty).toFixed(2)} ${foundOP.uom}`
+
+      // update the order product status to DONE if remaining packQty is 0
+      // -- so that the user will never see this product during unloading and putaway stages
+      // if (foundOP.packQty === 0) foundOP.status = ORDER_PRODUCT_STATUS.TERMINATED
+
+      await tx.getRepository(OrderProduct).save(foundOP)
+
+      let worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+        where: {
+          domain: { id: domain.id },
+          arrivalNotice: { id: arrivalNotice.id },
+          type: WORKSHEET_TYPE.UNLOADING
+        }
+      })
+
+      let worksheetDetails: WorksheetDetail = new WorksheetDetail()
+      worksheetDetails.name = WorksheetNoGenerator.generate(WORKSHEET_TYPE.UNLOADING, true)
+      worksheetDetails.seq = 0
+      worksheetDetails.type = WORKSHEET_TYPE.UNLOADING
+      worksheetDetails.status = WORKSHEET_STATUS.DEACTIVATED
+      worksheetDetails.domain = domain
+      worksheetDetails.bizplace = bizplace
+      worksheetDetails.worksheet = worksheet
+      worksheetDetails.targetProduct = newOP
+      worksheetDetails.creator = user
+      worksheetDetails.updater = user
+
+      await tx.getRepository(WorksheetDetail).save(worksheetDetails)
+
+      // update actualQty & actualUomValue of order vas
+      let actualQty: number = 0
+      let actualUomValue: number = 0
+
+      actualQty = Number(targetVas.actualQty) + Number(unpackQty)
+      actualUomValue = Number(targetVas.actualUomValue) + Number(unpackUomValue)
+
+      let newTargetVas: OrderVas = Object.assign({}, targetVas)
+      newTargetVas.actualQty = actualQty
+      newTargetVas.actualUomValue = actualUomValue
+      await tx.getRepository(OrderVas).save(newTargetVas)
+
+      await executeVas(tx, domain, user, wsd)
+    }
+  }
+}

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

@@ -0,0 +1,110 @@
+import { Equal, Not } from 'typeorm'
+
+import {
+  ArrivalNotice,
+  ORDER_STATUS,
+  ORDER_TYPES,
+  OrderInventory,
+  OrderVas,
+  ReleaseGood,
+  VasOrder
+} from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
+
+export const vasWorksheetResolver = {
+  async vasWorksheet(_: any, { orderNo, orderType }, context: ResolverContext) {
+    const { domain } = context.state
+    let refOrder: ArrivalNotice | ReleaseGood | VasOrder
+    if (orderType === ORDER_TYPES.ARRIVAL_NOTICE) {
+      refOrder = await getRepository(ArrivalNotice).findOne({
+        where: { domain: { id: domain.id }, name: orderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
+        relations: ['bizplace']
+      })
+    } else if (orderType === ORDER_TYPES.RELEASE_OF_GOODS) {
+      refOrder = await getRepository(ReleaseGood).findOne({
+        where: { domain: { id: domain.id }, name: orderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
+        relations: ['bizplace']
+      })
+    } else if (orderType === ORDER_TYPES.VAS_ORDER) {
+      refOrder = await getRepository(VasOrder).findOne({
+        where: { domain: { id: domain.id }, name: orderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
+        relations: ['bizplace']
+      })
+    }
+
+    if (!refOrder) throw new Error(`Couldn't find VAS worksheet by order no (${orderNo})`)
+
+    const worksheet: Worksheet = await fetchExecutingWorksheet(
+      domain,
+      refOrder.bizplace,
+      [
+        'worksheetDetails',
+        'worksheetDetails.targetVas',
+        'worksheetDetails.targetVas.vas',
+        'worksheetDetails.targetVas.inventory',
+        'worksheetDetails.targetVas.targetProduct',
+        'worksheetDetails.targetVas.inventory.location',
+        'creator',
+        'updater'
+      ],
+      WORKSHEET_TYPE.VAS,
+      refOrder
+    )
+
+    if (orderType === ORDER_TYPES.RELEASE_OF_GOODS) {
+      for (let wsd of worksheet.worksheetDetails) {
+        const inventory: Inventory = wsd.targetVas.inventory
+        const orderInv: OrderInventory = await getRepository(OrderInventory).findOne({
+          where: { domain: { id: domain.id }, releaseGood: { id: refOrder.id }, inventory: { id: inventory.id } }
+        })
+
+        wsd.targetInventory = orderInv
+      }
+    }
+
+    return {
+      worksheetInfo: {
+        bizplaceName: refOrder.bizplace.name,
+        //@ts-ignore
+        containerNo: refOrder?.containerNo,
+        startedAt: worksheet.startedAt
+      },
+      worksheetDetailInfos: worksheet.worksheetDetails
+        .sort((a: WorksheetDetail, b: WorksheetDetail) => a.seq - b.seq)
+        .map((wsd: WorksheetDetail) => {
+          const targetVas: OrderVas = wsd.targetVas
+          return {
+            name: wsd.name,
+            seq: wsd.seq,
+            status: wsd.status,
+            issue: wsd.issue,
+            relatedOrderInv: wsd.targetInventory,
+            batchId: targetVas?.batchId,
+            targetName: targetVas?.name,
+            vas: targetVas?.vas,
+            set: targetVas?.set,
+            inventory: targetVas?.inventory,
+            locationInv: targetVas?.inventory?.location?.name,
+            targetType: targetVas?.targetType,
+            targetBatchId: targetVas?.targetBatchId,
+            targetProduct: targetVas?.targetProduct,
+            otherTarget: targetVas?.otherTarget,
+            qty: targetVas?.qty,
+            //@ts-ignore
+            weight: targetVas?.weight,
+            uomValue: targetVas?.uomValue,
+            operationGuide: targetVas?.operationGuide,
+            description: wsd.description,
+            remark: targetVas?.remark,
+            actualQty: targetVas?.actualQty,
+            actualUomValue: targetVas?.actualUomValue
+          }
+        })
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/worksheet-by-order-no.ts

@@ -0,0 +1,43 @@
+import { EntityManager, FindOneOptions, Repository } from 'typeorm'
+
+import { ArrivalNotice, ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet } from '../../../entities'
+
+export const worksheetByOrderNoResolver = {
+  async worksheetByOrderNo(
+    _: any,
+    { orderType, orderNo }: { orderType: string; orderNo: string },
+    context: any
+  ): Promise<Worksheet> {
+    const { tx, domain } = context.state
+    return await worksheetByOrderNo(domain, orderNo, orderType, tx)
+  }
+}
+
+export async function worksheetByOrderNo(
+  domain: Domain,
+  orderNo: string,
+  type: string,
+  tx: EntityManager
+): Promise<Worksheet> {
+  let findOption: FindOneOptions<Worksheet> = {
+    where: { domain: { id: domain.id }, type },
+    relations: ['worksheetDetails']
+  }
+
+  if (type === WORKSHEET_TYPE.UNLOADING || type === WORKSHEET_TYPE.PUTAWAY) {
+    const ganRepo: Repository<ArrivalNotice> = tx.getRepository(ArrivalNotice)
+    findOption.where['arrivalNotice'] = await ganRepo.findOneBy({ domain: { id: domain.id }, name: orderNo })
+    ;(findOption.relations as string[]).push('worksheetDetails.targetProduct')
+  } else if (type === WORKSHEET_TYPE.PICKING || type === WORKSHEET_TYPE.LOADING) {
+    const roRepo: Repository<ReleaseGood> = tx.getRepository(ReleaseGood)
+    findOption.where['releaseGood'] = await roRepo.findOneBy({ domain: { id: domain.id }, name: orderNo })
+    ;(findOption.relations as string[]).push('worksheetDetails.targetInventory')
+  }
+
+  const wsRepo: Repository<Worksheet> = tx.getRepository(Worksheet)
+  return await wsRepo.findOne(findOption)
+}

package/server/graphql/resolvers/worksheet/worksheet-with-pagination.ts

@@ -0,0 +1,46 @@
+import { FindManyOptions } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const worksheetWithPaginationResolver = {
+  async worksheetWithPagination(
+    _: any,
+    { name, pagination }: { name: string; pagination?: { page: number; limit: number } },
+    context: any
+  ): Promise<{ worksheet: Worksheet; worksheetDetails: WorksheetDetail[]; total: number }> {
+    const { domain } = context.state
+    const worksheet: Worksheet = await getRepository(Worksheet).findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: ['bizplace', 'arrivalNotice', 'releaseGood', 'inventoryCheck']
+    })
+
+    let findManyOptions: FindManyOptions<WorksheetDetail> = {
+      where: { domain: { id: domain.id }, worksheet: { id: worksheet.id } },
+      relations: [
+        'targetInventory',
+        'targetInventory.originLocation',
+        'targetInventory.inspectedLocation',
+        'targetInventory.inventory',
+        'targetInventory.inventory.location',
+        'targetInventory.inventory.product'
+      ]
+    }
+
+    if (pagination?.page && pagination?.limit) {
+      const { page, limit }: { page: number; limit: number } = pagination
+      const offset: number = (page - 1) * limit
+      findManyOptions.skip = offset
+      findManyOptions.take = limit
+    }
+
+    const [worksheetDetails, total] = await getRepository(WorksheetDetail).findAndCount(findManyOptions)
+
+    return {
+      worksheet,
+      worksheetDetails,
+      total
+    }
+  }
+}

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

@@ -0,0 +1,330 @@
+import { Equal, Not } from 'typeorm'
+
+import { MarketplaceOrder, MarketplaceOrderShipping } from '@things-factory/marketplace-base'
+import { ORDER_INVENTORY_STATUS, OrderInventory, OrderProduct, OrderVas } from '@things-factory/sales-base'
+import { Setting } from '@things-factory/setting-base'
+import { getRepository } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS, InventoryHistory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+interface WorksheetInterface extends Worksheet {
+  orderProducts: OrderProduct[]
+  orderInventories: OrderInventory[]
+  orderVass: OrderVas[]
+  marketplaceOrder: MarketplaceOrder
+}
+
+export const worksheetResolver = {
+  async worksheet(_: any, { name }, context: ResolverContext) {
+    const { domain } = context.state
+    let worksheet: WorksheetInterface
+    worksheet = (await getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        name
+      },
+      relations: [
+        'domain',
+        'bizplace',
+        'bizplace.domain',
+        'bufferLocation',
+        'bufferLocation.warehouse',
+        'arrivalNotice',
+        'arrivalNotice.releaseGood',
+        'arrivalNotice.supplier',
+        'releaseGood',
+        'releaseGood.arrivalNotice',
+        'releaseGood.shippingOrder',
+        'releaseGood.deliverTo',
+        'releaseGood.deliverTo.bizplace',
+        'releaseGood.manifest',
+        'returnOrder',
+        'inventoryCheck',
+        'vasOrder',
+        'assignee',
+        'worksheetDetails',
+        'worksheetDetails.toLocation',
+        'worksheetDetails.targetProduct',
+        'worksheetDetails.targetProduct.product',
+        'worksheetDetails.targetVas',
+        'worksheetDetails.targetVas.vas',
+        'worksheetDetails.targetVas.inventory',
+        'worksheetDetails.targetVas.inventory.location',
+        'worksheetDetails.targetVas.targetProduct',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.releaseGood',
+        'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.inventory',
+        'worksheetDetails.targetInventory.inventory.product',
+        'worksheetDetails.targetInventory.inventory.warehouse',
+        'worksheetDetails.targetInventory.inventory.location',
+        'worksheetDetails.targetInventory.inspectedLocation',
+        'creator',
+        'updater'
+      ]
+    })) as WorksheetInterface
+
+    if (!worksheet) {
+      worksheet = (await getRepository(Worksheet).findOne({
+        where: {
+          domain: { id: domain.id },
+          arrivalNotice: { id: name } /* CONFIRMME regarding TYPEORM - name means id ? */
+        },
+        relations: [
+          'domain',
+          'bizplace',
+          'bizplace.domain',
+          'worksheetDetails',
+          'worksheetDetails.targetProduct',
+          'worksheetDetails.targetProduct.product',
+          'worksheetDetails.targetInventory',
+          'worksheetDetails.targetInventory.releaseGood',
+          'worksheetDetails.targetInventory.product',
+          'worksheetDetails.targetInventory.inventory',
+          'worksheetDetails.targetInventory.inventory.product',
+          'worksheetDetails.targetInventory.inventory.warehouse',
+          'worksheetDetails.targetInventory.inventory.location',
+          'worksheetDetails.targetInventory.inspectedLocation',
+          'creator',
+          'updater'
+        ]
+      })) as WorksheetInterface
+    }
+
+    let pWorksheetPickingItemSorting = getRepository(Setting).findOne({
+      where: { domain: { id: domain.id }, category: 'location', name: 'rule-for-picking-product' }
+    })
+
+    if (worksheet?.arrivalNotice?.id) {
+      worksheet.orderProducts = await getRepository(OrderProduct).find({
+        where: {
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          arrivalNotice: { id: worksheet.arrivalNotice.id }
+        }
+      })
+
+      worksheet.orderVass = await getRepository(OrderVas).find({
+        where: {
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          arrivalNotice: { id: worksheet.arrivalNotice.id }
+        },
+        relations: ['targetProduct']
+      })
+
+      // update inventory data >> unloaded inventory history data
+      if (
+        worksheet.type === WORKSHEET_TYPE.PUTAWAY &&
+        worksheet.worksheetDetails.every(wsd => wsd.targetInventory.inventory)
+      ) {
+        worksheet.worksheetDetails = await Promise.all(
+          worksheet.worksheetDetails.map(async (wsd: WorksheetDetail) => {
+            let inventory: Inventory = wsd.targetInventory.inventory
+
+            let foundHistory: InventoryHistory = await getRepository(InventoryHistory).findOne({
+              where: [
+                {
+                  inventory: { id: inventory.id },
+                  refOrderId: worksheet.arrivalNotice.id,
+                  status: INVENTORY_STATUS.UNLOADED
+                },
+                {
+                  inventory: { id: inventory.id },
+                  refOrderId: worksheet.arrivalNotice.id,
+                  status: INVENTORY_STATUS.PARTIALLY_UNLOADED
+                },
+                {
+                  inventory: { id: inventory.id },
+                  refOrderId: worksheet.arrivalNotice.id,
+                  status: INVENTORY_STATUS.CHECKED
+                },
+                {
+                  inventory: { id: inventory.id },
+                  refOrderId: worksheet.arrivalNotice.id,
+                  status: INVENTORY_STATUS.STORED
+                }
+              ],
+              relations: ['location', 'product'],
+              order: { seq: 'DESC' }
+            })
+
+            wsd.targetInventory.inventory = {
+              ...inventory,
+              qty: foundHistory?.qty || foundHistory?.openingQty || 0,
+              uomValue: foundHistory?.uomValue || foundHistory?.openingUomValue || 0,
+              location: foundHistory?.location,
+              product: foundHistory?.product,
+              cartonId: foundHistory?.cartonId,
+              batchId: foundHistory?.batchId,
+              batchIdRef: foundHistory?.batchIdRef,
+              packingType: foundHistory?.packingType,
+              packingSize: foundHistory?.packingSize,
+              uom: foundHistory?.uom
+            }
+
+            return wsd
+          })
+        )
+      }
+    }
+
+    if (worksheet.type === WORKSHEET_TYPE.BATCH_PICKING) {
+      let qbOrderInventories = getRepository(OrderInventory)
+        .createQueryBuilder('oi')
+        .leftJoinAndSelect('oi.releaseGood', 'releaseGood')
+        .leftJoinAndSelect('oi.inventory', 'inventory')
+        .leftJoinAndSelect('oi.product', 'product')
+        .leftJoinAndSelect('oi.orderProduct', 'orderProduct')
+        .leftJoinAndSelect('inventory.location', 'location')
+        .leftJoinAndSelect('oi.bizplace', 'bizplace')
+        .where('"oi"."domain_id" = :domain')
+        .andWhere('"oi"."bizplace_id" = :bizplace')
+        .andWhere('"oi"."ref_worksheet_id" = :refWorksheetId')
+        .setParameters({
+          domain: domain.id,
+          bizplace: worksheet.bizplace.id,
+          refWorksheetId: worksheet.id
+        })
+
+      let sortingSetting: Setting = await pWorksheetPickingItemSorting
+      if (sortingSetting?.value) {
+        let settingValue = JSON.parse(sortingSetting.value)
+        for (const key in settingValue) {
+          qbOrderInventories.addOrderBy(`location.${key}`, settingValue[key] == 'ASC' ? 'ASC' : 'DESC')
+        }
+      }
+
+      qbOrderInventories.addOrderBy(`product.name`, 'ASC')
+
+      let orderInventories: OrderInventory[] = await qbOrderInventories.getMany()
+      worksheet.orderInventories = orderInventories
+    }
+
+    if (worksheet?.releaseGood?.id) {
+      let qbOrderInventories = getRepository(OrderInventory)
+        .createQueryBuilder('oi')
+        .leftJoinAndSelect('oi.releaseGood', 'releaseGood')
+        .leftJoinAndSelect('oi.inventory', 'inventory')
+        .leftJoinAndSelect('oi.product', 'product')
+        .leftJoinAndSelect('oi.orderProduct', 'orderProduct')
+        .leftJoinAndSelect('inventory.location', 'location')
+        .leftJoinAndSelect('oi.bizplace', 'bizplace')
+        .where('"oi"."domain_id" = :domain')
+        .andWhere('"oi"."bizplace_id" = :bizplace')
+        .andWhere('"oi"."release_good_id" = :releaseGood')
+        .andWhere('"oi"."status" NOT IN (:...statuses)')
+        .setParameters({
+          domain: domain.id,
+          bizplace: worksheet.bizplace.id,
+          releaseGood: worksheet.releaseGood.id,
+          statuses: [ORDER_INVENTORY_STATUS.CANCELLED, ORDER_INVENTORY_STATUS.REPLACED]
+        })
+
+      let sortingSetting: Setting = await pWorksheetPickingItemSorting
+      if (sortingSetting?.value) {
+        let settingValue = JSON.parse(sortingSetting.value)
+        for (const key in settingValue) {
+          qbOrderInventories.addOrderBy(`location.${key}`, settingValue[key] == 'ASC' ? 'ASC' : 'DESC')
+        }
+      }
+
+      qbOrderInventories.addOrderBy(`product.name`, 'ASC')
+
+      let orderInventories: OrderInventory[] = await qbOrderInventories.getMany()
+      worksheet.orderInventories = orderInventories
+
+      if (worksheet.releaseGood.type == 'b2c') {
+        worksheet.marketplaceOrder = await getRepository(MarketplaceOrder).findOne({
+          where: { orderNo: worksheet.releaseGood.refNo },
+          relations: ['marketplaceOrderItems', 'marketplaceStore']
+        })
+
+        if (worksheet.marketplaceOrder) {
+          let marketplaceOrderShipping: MarketplaceOrderShipping
+          if (worksheet.marketplaceOrder.isSplitted) {
+            marketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).findOne({
+              where: { subOrderNoRef: worksheet.releaseGood.refNo2 }
+            })
+          } else {
+            marketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).findOne({
+              where: { orderNoRef: worksheet.releaseGood.refNo }
+            })
+          }
+
+          worksheet.marketplaceOrder.trackingNo = marketplaceOrderShipping.ownTrackingNo
+            ? marketplaceOrderShipping.ownTrackingNo
+            : marketplaceOrderShipping.trackingNo
+          worksheet.marketplaceOrder.shippingProvider = marketplaceOrderShipping.ownTransporter
+            ? marketplaceOrderShipping.ownTransporter
+            : marketplaceOrderShipping.transporter
+        }
+      }
+
+      worksheet.orderVass = await getRepository(OrderVas).find({
+        where: {
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          releaseGood: { id: worksheet.releaseGood.id }
+        },
+        relations: ['targetProduct']
+      })
+    }
+
+    if (worksheet.orderInventories) {
+      worksheet.worksheetDetails.sort(function (a, b) {
+        return (
+          worksheet.orderInventories.map(oi => oi.id).indexOf(a.targetInventory.id) -
+          worksheet.orderInventories.map(oi => oi.id).indexOf(b.targetInventory.id)
+        )
+      })
+    }
+
+    if (worksheet?.returnOrder?.id) {
+      worksheet.orderInventories = await getRepository(OrderInventory).find({
+        where: {
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          returnOrder: { id: worksheet.returnOrder.id },
+          status: Not(Equal(ORDER_INVENTORY_STATUS.CANCELLED))
+        },
+        relations: ['product', 'inventory', 'inventory.location']
+      })
+
+      worksheet.orderVass = await getRepository(OrderVas).find({
+        where: {
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          returnOrder: { id: worksheet.returnOrder.id }
+        },
+        relations: ['targetProduct']
+      })
+    }
+
+    if (worksheet?.inventoryCheck?.id) {
+      worksheet.orderInventories = await getRepository(OrderInventory).find({
+        where: {
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          inventoryCheck: { id: worksheet.inventoryCheck.id }
+        },
+        relations: ['product', 'inventory', 'inventory.location']
+      })
+    }
+
+    if (worksheet?.vasOrder?.id) {
+      worksheet.orderVass = await getRepository(OrderVas).find({
+        where: {
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          vasOrder: { id: worksheet.vasOrder.id }
+        },
+        relations: ['targetProduct']
+      })
+    }
+
+    return worksheet
+  }
+}