@things-factory/worksheet-base 8.0.0-beta.0 → 8.0.0-beta.2

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

@@ -1,164 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,330 +0,0 @@
-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
-  }
-}