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

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

@@ -1,150 +0,0 @@
-import { Brackets, OrderByCondition, SelectQueryBuilder } from 'typeorm'
-
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
-import { buildCondition, buildQuery, getRepository } from '@things-factory/shell'
-import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
-
-export const inventoriesByPalletResolver = {
-  async inventoriesByPallet(_: any, { filters, pagination, sortings, locationSortingRules }, context: ResolverContext) {
-    const { domain, user } = context.state
-    const params = { filters, pagination }
-    let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
-    const productFilters = params.filters.filter(x => x.name == 'productName')
-    const recallFilters = params.filters.find(x => x.name === 'recall')
-    const skipLockCheckFilters = params.filters.find(x => x.name === 'skipLockCheck')
-    let skipLockCheck: Boolean =
-      skipLockCheckFilters && skipLockCheckFilters?.value ? skipLockCheckFilters?.value : false
-    const productFilterColumns = ['sku', 'brandSku', 'name', 'description', 'brand', 'subBrand']
-    params.filters = params.filters.filter(x => x.name != 'productName')
-
-    if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
-      params.filters.push({
-        name: 'bizplace',
-        operator: 'in',
-        value: permittedBizplaceIds,
-        relation: true
-      })
-    } else {
-      permittedBizplaceIds = params.filters.find(filter => filter.name === 'bizplace').value
-      params.filters.find(filter => filter.name === 'bizplace').relation = true
-    }
-
-    const locationFilters = params.filters.find(x => x.name == 'locationName')
-    params.filters = params.filters.filter(x => x.name != 'locationName')
-
-    const qb: SelectQueryBuilder<Inventory> = getRepository(Inventory).createQueryBuilder('iv')
-    buildQuery(qb, params, context)
-
-    qb.leftJoinAndSelect('iv.domain', 'domain')
-      .leftJoinAndSelect('iv.bizplace', 'bizplace')
-      .leftJoinAndSelect('iv.product', 'product')
-      .leftJoinAndSelect('iv.warehouse', 'warehouse')
-      .leftJoinAndSelect('iv.location', 'location')
-      .leftJoinAndSelect('iv.creator', 'creator')
-      .leftJoinAndSelect('iv.updater', 'updater')
-      .andWhere('iv.qty > 0')
-      .andWhere(
-        `location.type ${recallFilters?.value === true ? '' : 'NOT'} IN ('${LOCATION_TYPE.QUARANTINE}', '${
-          LOCATION_TYPE.RESERVE
-        }')`
-      )
-      .andWhere(
-        `(iv.batch_id, product.name, iv.packing_type, product.brand) NOT IN (
-        SELECT 
-          oi.batch_id, p2.name, oi.packing_type, p2.brand
-        FROM 
-          order_inventories oi
-        LEFT JOIN
-          products p2
-        ON
-          oi.product_id = p2.id
-        WHERE 
-          oi.status = '${ORDER_INVENTORY_STATUS.PENDING_SPLIT}'
-        AND oi.bizplace_id IN (:...permittedBizplaceIds)
-        AND oi.domain_id = (:domainId)
-      )`,
-        { permittedBizplaceIds, domainId: domain.id }
-      )
-
-    if (!skipLockCheck) {
-      qb.andWhere('CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END >= 0')
-      qb.andWhere('iv.qty - CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END > 0')
-    }
-
-    if (locationFilters) {
-      qb.andWhere(`location.name ilike '${locationFilters.value}'`)
-    }
-
-    if (sortings?.length !== 0) {
-      const arrChildSortData = ['productName', 'productSKU']
-
-      const remapChildSortData = ['name', 'sku']
-      const sort: OrderByCondition = (sortings || []).reduce(
-        (acc, sort, idx) => ({
-          ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? 'product' + '.' + remapChildSortData[idx] : 'iv.' + sort.name]:
-            sort.desc ? 'DESC' : 'ASC'
-        }),
-        {}
-      )
-      qb.orderBy(sort)
-    }
-
-    if (locationSortingRules?.length > 0) {
-      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
-        qb.addOrderBy(`location.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-      })
-    } else {
-      qb.addOrderBy('location.name', 'DESC')
-    }
-
-    if (productFilters && productFilters.length > 0) {
-      let productInfo = productFilters[0]
-      qb.andWhere(
-        new Brackets(qb2 => {
-          productFilterColumns.forEach(filter => {
-            const condition = buildCondition(
-              'product',
-              filter,
-              'i_like',
-              productInfo.value,
-              false,
-              Object.keys(qb.getParameters()).length
-            )
-
-            qb2.orWhere(condition.clause, condition.parameters)
-          })
-        })
-      )
-    }
-    let [items, total] = await qb.getManyAndCount()
-
-    items = await Promise.all(
-      items.map(async (item: Inventory) => {
-        const { remainQty, remainUomValue } = await getRemainAmount(item)
-
-        return {
-          ...item,
-          remainQty,
-          remainUomValue,
-          remainUomValueWithUom: remainUomValue + ' ' + item.uom,
-          // product: item.product,
-          productName: item.product.name,
-          productSKU: item.product.sku,
-          productBrand: item.product.brand,
-          productId: item.product.id
-        }
-      })
-    )
-
-    return { items, total }
-  }
-}
-
-async function getRemainAmount(inventory: Inventory): Promise<{ remainQty: number; remainUomValue: number }> {
-  return {
-    remainQty: inventory.qty - (inventory.lockedQty || 0),
-    remainUomValue: inventory.uomValue - (inventory.lockedUomValue || 0)
-  }
-}

package/server/graphql/resolvers/worksheet/loaded-inventories.ts

@@ -1,40 +0,0 @@
-import { In } from 'typeorm'
-
-import { DeliveryOrder, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
-import { getRepository } from '@things-factory/shell'
-
-export const loadedInventories = {
-  async loadedInventories(_: any, { releaseGoodNo }, context: ResolverContext) {
-    const { domain } = context.state
-    const foundRO: ReleaseGood = await getRepository(ReleaseGood).findOne({
-      where: {
-        domain: { id: domain.id },
-        name: releaseGoodNo,
-        status: ORDER_STATUS.LOADING
-      },
-      relations: ['bizplace']
-    })
-    if (!foundRO) throw new Error('Release order is not found')
-
-    const deliveryOrders: DeliveryOrder[] = await getRepository(DeliveryOrder).find({
-      where: { releaseGood: { id: foundRO.id } }
-    })
-
-    if (deliveryOrders?.length) {
-      return await getRepository(OrderInventory).find({
-        where: {
-          deliveryOrder: { id: In(deliveryOrders.map((deliveryOrder: DeliveryOrder) => deliveryOrder.id)) }
-        },
-        relations: [
-          'inventory',
-          'inventory.product',
-          'deliveryOrder',
-          'deliveryOrder.transportDriver',
-          'deliveryOrder.transportVehicle'
-        ]
-      })
-    } else {
-      return []
-    }
-  }
-}

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

@@ -1,73 +0,0 @@
-import { EntityManager, Equal, Not } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
-import { LoadingWorksheetController } from '../../../../controllers'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
-
-export const activateLoadingResolver = {
-  async activateLoading(_: any, { worksheetNo, loadingWorksheetDetails }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    const foundWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-      where: {
-        domain: { id: domain.id },
-        name: worksheetNo,
-        status: WORKSHEET_STATUS.DEACTIVATED,
-        type: WORKSHEET_TYPE.LOADING
-      },
-      relations: ['bizplace', 'releaseGood', 'worksheetDetails', 'worksheetDetails.targetInventory']
-    })
-
-    if (!foundWorksheet) throw new Error(`Worksheet doesn't exists`)
-
-    const relatedPickingWorksheetCnt: number = await tx.getRepository(Worksheet).count({
-      where: {
-        domain: { id: domain.id },
-        releaseGood: { id: foundWorksheet.releaseGood.id },
-        type: WORKSHEET_TYPE.PICKING,
-        status: Not(Equal(WORKSHEET_STATUS.DONE))
-      }
-    })
-
-    const relatedWorksheetCnt: number = await tx.getRepository(Worksheet).count({
-      where: {
-        domain: { id: domain.id },
-        releaseGood: { id: foundWorksheet.releaseGood.id },
-        type: WORKSHEET_TYPE.VAS,
-        status: Not(Equal(WORKSHEET_STATUS.DONE))
-      }
-    })
-
-    let errMsg = []
-
-    // Stop to activate loading worksheet with Exception
-    // This resolver is being called from client side not from other resolver.
-    // So if there's a related worksheet, it should throw an Error to inform user about non-finished order.
-    if (relatedPickingWorksheetCnt) {
-      errMsg.push(`Picking Worksheet with RO: ${foundWorksheet.releaseGood.name} is still under processing.`)
-    }
-
-    if (relatedWorksheetCnt) {
-      errMsg.push(`Related VAS order with RO: ${foundWorksheet.releaseGood.name} is still under processing.`)
-    }
-
-    if (errMsg.length > 0) {
-      throw errMsg.join('')
-    }
-
-    return await activateLoading(tx, domain, user, worksheetNo, loadingWorksheetDetails)
-  }
-}
-
-export async function activateLoading(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  worksheetNo: string,
-  loadingWorksheetDetails: Partial<WorksheetDetail>[]
-): Promise<Worksheet> {
-  const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  return await worksheetController.activateLoading(worksheetNo, loadingWorksheetDetails)
-}

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

@@ -1,165 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { ApplicationType, User } from '@things-factory/auth-base'
-import { Bizplace, Company } from '@things-factory/biz-base'
-import { FulfillmentCenter } from '@things-factory/integration-fulfillment'
-import { Sftp, SftpAPI } from '@things-factory/integration-sftp'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { InventoryItem } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_TYPE } from '../../../../constants'
-import { LoadingWorksheetController, ReturningWorksheetController } from '../../../../controllers'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
-
-export const completeLoadingResolver = {
-  async completeLoading(_: any, { releaseGoodNo }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    await completeLoading(tx, domain, user, releaseGoodNo)
-  }
-}
-
-export async function completeLoading(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  releaseGoodNo: string
-): Promise<void> {
-  const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  //@ts-ignore
-  const releaseGood: ReleaseGood = await worksheetController.findRefOrder(
-    //@ts-ignore
-    ReleaseGood,
-    {
-      domain: { id: domain.id },
-      name: releaseGoodNo,
-      status: ORDER_STATUS.LOADING
-    },
-    ['bizplace', 'bizplace.domain']
-  )
-  const worksheet: Worksheet = await worksheetController.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.LOADING, [
-    'worksheetDetails',
-    'worksheetDetails.targetInventory',
-    'worksheetDetails.targetInventory.product'
-  ])
-  const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-  const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
-  const remainInventories: OrderInventory[] = targetInventories.filter(
-    (targetInventory: OrderInventory) => targetInventory.status === ORDER_INVENTORY_STATUS.LOADING
-  )
-
-  // Search Warehouse Company Domain
-  const warehouseCompanyBizplace: Bizplace = await tx
-    .getRepository(Bizplace)
-    .findOne({ where: { domain: { id: domain.id } }, relations: ['company'] })
-
-  const warehouseCompany: Company = warehouseCompanyBizplace.company
-  const warehouseBizplaces: Bizplace[] = await tx
-    .getRepository(Bizplace)
-    .find({ where: { company: { id: warehouseCompany.id } }, relations: ['domain'] })
-  const warehouseCompanyBizplaces: Bizplace[] = warehouseBizplaces.filter(biz => biz.domain.extType == 'company')
-  const warehouseCompanyDomain: Domain = warehouseCompanyBizplaces[0].domain
-
-  const orderSource: string = releaseGood.source
-  switch (orderSource) {
-    case ApplicationType.SFTP:
-      const customerDomain: Domain = releaseGood.bizplace.domain
-      const fulfillmentCenter: FulfillmentCenter = await tx
-        .getRepository(FulfillmentCenter)
-        .findOneBy({ domain: { id: warehouseCompanyDomain.id }, centerId: domain.subdomain, status: 'active' })
-
-      if (fulfillmentCenter) {
-        let customerAvailableSftp: Sftp = await tx.getRepository(Sftp).findOneBy({
-          //@ts-ignore
-          where: {
-            domain: { id: customerDomain.id },
-            status: 'ACTIVE',
-            fulfillmentCenter: { id: fulfillmentCenter.id }
-          }
-        })
-        if (customerAvailableSftp) {
-          const responseFileTypes: any = JSON.parse(customerAvailableSftp.responseFileTypes)
-
-          let inventoryItems: InventoryItem[] = await tx.getRepository(InventoryItem).find({
-            where: { domain: { id: domain.id }, outboundOrderId: releaseGood.id }
-          })
-
-          // if (responseFileTypes.enableShipment) {
-          //   let shipmentResult: Sftp = await SftpAPI.createShipment(customerAvailableSftp, {
-          //     releaseGood,
-          //     orderInventories: targetInventories,
-          //     sftp: customerAvailableSftp
-          //   })
-          //   customerAvailableSftp = await tx.getRepository(Sftp).save(shipmentResult)
-          // }
-
-          if (responseFileTypes.enableSerialNumber) {
-            let snResult: Sftp = await SftpAPI.createSerialNumber(customerAvailableSftp, {
-              releaseGood,
-              inventoryItems,
-              sftp: customerAvailableSftp
-            })
-            customerAvailableSftp = await tx.getRepository(Sftp).save(snResult)
-          }
-        }
-      }
-      break
-
-    default:
-      break
-  }
-
-  // const customerDomain: Domain = releaseGood.bizplace.domain
-  // const fulfillmentCenter: FulfillmentCenter = await tx
-  //   .getRepository(FulfillmentCenter)
-  //   .findOne({ domain: warehouseCompanyDomain, centerId: domain.subdomain, status: 'active' })
-
-  // if (fulfillmentCenter) {
-  //   let customerAvailableSftp: Sftp = await tx.getRepository(Sftp).findOne({
-  //     where: { domain: customerDomain, status: 'ACTIVE', fulfillmentCenter }
-  //   })
-  //   if (customerAvailableSftp) {
-  //     const responseFileTypes: any = JSON.parse(customerAvailableSftp.responseFileTypes)
-
-  //     let inventoryItems: InventoryItem[] = await tx.getRepository(InventoryItem).find({
-  //       where: { domain, outboundOrderId: releaseGood.id }
-  //     })
-
-  //     // if (responseFileTypes.enableShipment) {
-  //     //   let shipmentResult: Sftp = await SftpAPI.createShipment(customerAvailableSftp, {
-  //     //     releaseGood,
-  //     //     orderInventories: targetInventories,
-  //     //     sftp: customerAvailableSftp
-  //     //   })
-  //     //   customerAvailableSftp = await tx.getRepository(Sftp).save(shipmentResult)
-  //     // }
-
-  //     if (responseFileTypes.enableSerialNumber) {
-  //       let snResult: Sftp = await SftpAPI.createSerialNumber(customerAvailableSftp, {
-  //         releaseGood,
-  //         inventoryItems,
-  //         sftp: customerAvailableSftp
-  //       })
-  //       customerAvailableSftp = await tx.getRepository(Sftp).save(snResult)
-  //     }
-  //   }
-  // }
-
-  await worksheetController.completeLoading(releaseGoodNo)
-
-  if (remainInventories.length) {
-    await createReturnWorksheet(tx, domain, user, releaseGoodNo, remainInventories)
-  }
-}
-
-// Generating worksheet for returning process
-export async function createReturnWorksheet(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  releaseGoodNo: string,
-  orderInventories: OrderInventory[]
-): Promise<Worksheet> {
-  const worksheetController: ReturningWorksheetController = new ReturningWorksheetController(tx, domain, user)
-  return await worksheetController.generateReturningWorksheet(releaseGoodNo, orderInventories)
-}

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

@@ -1,11 +0,0 @@
-import { activateLoadingResolver } from './activate-loading'
-import { loadingResolver } from './loading'
-import { undoLoadingResolver } from './undo-loading'
-import { completeLoadingResolver } from './complete-loading'
-
-export const Mutations = {
-  ...activateLoadingResolver,
-  ...loadingResolver,
-  ...undoLoadingResolver,
-  ...completeLoadingResolver
-}

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

@@ -1,46 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { generateDeliveryOrder, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-
-import { LoadingWorksheetController, WorksheetController } from '../../../../controllers'
-import { WorksheetDetail } from '../../../../entities'
-
-export const loadingResolver = {
-  async loading(_: any, { loadedWorksheetDetails, releaseGoodNo, orderInfo }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    const worksheetDetails = await loading(tx, domain, user, loadedWorksheetDetails, releaseGoodNo)
-    const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
-    //@ts-ignore
-    const releaseGood: ReleaseGood = await worksheetController.findRefOrder(
-      //@ts-ignore
-      ReleaseGood,
-      { domain, name: releaseGoodNo },
-      ['bizplace', 'deliverTo']
-    )
-
-    const loadingWorksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-    let targetInventories: OrderInventory[] = worksheetDetails.map(itm => itm.targetInventory)
-
-    const bizplace: Bizplace = releaseGood.bizplace
-    orderInfo = {
-      ...orderInfo,
-      contactPointRefId: releaseGood.deliverTo?.id || null
-    }
-
-    await generateDeliveryOrder(orderInfo, targetInventories, bizplace, releaseGood, domain, user, tx)
-  }
-}
-
-export async function loading(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  worksheetDetails: Partial<WorksheetDetail & { loadedQty: number } & { toteName: string }>[],
-  releaseGoodNo: string
-): Promise<any> {
-  const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  return await worksheetController.loading(releaseGoodNo, worksheetDetails)
-}

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

@@ -1,25 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { DeliveryOrder } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-
-import { LoadingWorksheetController } from '../../../../controllers'
-
-export const undoLoadingResolver = {
-  async undoLoading(_: any, { deliveryOrder, palletIds }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    await undoLoading(tx, domain, user, deliveryOrder, palletIds)
-  }
-}
-
-export async function undoLoading(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  deliveryOrder: Partial<DeliveryOrder>,
-  palletIds: string[]
-): Promise<void> {
-  const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  await worksheetController.undoLoading(deliveryOrder, palletIds)
-}

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

@@ -1,150 +0,0 @@
-import { Equal, In, Not, SelectQueryBuilder } from 'typeorm'
-
-import {
-  ORDER_INVENTORY_STATUS,
-  ORDER_STATUS,
-  OrderInventory,
-  OrderTote,
-  OrderToteItem,
-  ReleaseGood
-} from '@things-factory/sales-base'
-import { getRepository } from '@things-factory/shell'
-import { Inventory, Location } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
-import { Worksheet, WorksheetDetail } from '../../../entities'
-import { fetchExecutingWorksheet } from '../../../utils'
-
-export const loadingWorksheetResolver = {
-  async loadingWorksheet(_: any, { releaseGoodNo }, context: ResolverContext) {
-    const { domain } = context.state
-    let releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-      where: { domain: { id: domain.id }, name: releaseGoodNo /*status: ORDER_STATUS.LOADING*/ },
-      relations: ['bizplace', 'deliverTo', 'deliverTo.bizplace']
-    })
-
-    // Find Release Order based on Bin
-    if (!releaseGood) {
-      const binLocation: Location = await getRepository(Location).findOne({
-        where: { domain: { id: domain.id }, 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.`)
-
-    //@ts-ignore
-    let [orderTotes, orderTotesTotal]: OrderTote = await getRepository(OrderTote).findAndCount({
-      where: { releaseGood: { id: releaseGood.id } }
-    })
-
-    const foundWorksheet: Worksheet = await fetchExecutingWorksheet(
-      domain,
-      releaseGood.bizplace,
-      ['bizplace', 'worksheetDetails'],
-      WORKSHEET_TYPE.LOADING,
-      releaseGood
-    )
-    let foundWSD: any[] = await getRepository(WorksheetDetail).find({
-      where: {
-        domain: { id: domain.id },
-        worksheet: { id: foundWorksheet.id },
-        type: WORKSHEET_TYPE.LOADING,
-        status: Not(Equal(WORKSHEET_STATUS.DONE))
-      },
-      relations: [
-        'targetInventory',
-        'targetInventory.orderProduct',
-        'targetInventory.inventory',
-        'targetInventory.inventory.location',
-        'targetInventory.inventory.product'
-      ]
-    })
-
-    if (orderTotesTotal > 0) {
-      //@ts-ignore
-      let [toteItems, toteItemsTotal]: OrderToteItem = await getRepository(OrderToteItem).findAndCount({
-        where: { orderTote: { id: In(orderTotes.map(itm => itm.id)) } },
-        relations: ['orderTote', 'orderInventory']
-      })
-
-      let toteWsd = []
-
-      for (let i = 0; i < toteItemsTotal; i++) {
-        let wsdIndex = foundWSD.findIndex(
-          itm => !itm?.toteName && itm.targetInventory.id == toteItems[i].orderInventory.id
-        )
-
-        if (wsdIndex >= 0) {
-          let filterWSD: any = JSON.parse(JSON.stringify(foundWSD[wsdIndex]))
-          let uomValue =
-            Math.round((filterWSD.targetInventory.releaseUomValue / filterWSD.targetInventory.releaseQty) * 100) / 100
-
-          foundWSD[wsdIndex].targetInventory.releaseQty -= toteItems[i].qty
-          foundWSD[wsdIndex].targetInventory.pickedQty -= toteItems[i].qty
-          foundWSD[wsdIndex].targetInventory.releaseUomValue = foundWSD[wsdIndex].targetInventory.releaseQty * uomValue
-
-          filterWSD.targetInventory.releaseQty = toteItems[i].qty
-          filterWSD.targetInventory.pickedQty = toteItems[i].qty
-          filterWSD.targetInventory.releaseUomValue = toteItems[i].qty * uomValue
-          filterWSD.toteName = toteItems[i].orderTote.name
-          toteWsd.push(filterWSD)
-        }
-      }
-
-      foundWSD = foundWSD.concat(toteWsd)
-      foundWSD.sort((a, b) => (a.toteName > b.toteName ? 1 : -1))
-    }
-
-    let worksheetDetailInfos = foundWSD
-      .filter(itm => itm.targetInventory.releaseQty > 0)
-      .map((loadingWSD: any) => {
-        const targetInventory: OrderInventory = loadingWSD.targetInventory
-        const inventory: Inventory = targetInventory.inventory
-        return {
-          name: loadingWSD.name,
-          palletId: inventory.palletId,
-          batchId: inventory.batchId,
-          batchIdRef: inventory.batchIdRef,
-          product: inventory.product,
-          releaseQty: targetInventory.releaseQty,
-          releaseUomValue: targetInventory.releaseUomValue,
-          status: loadingWSD.status,
-          description: loadingWSD.description,
-          targetName: targetInventory.name,
-          packingType: inventory.packingType,
-          packingSize: inventory.packingSize,
-          inventory: targetInventory.inventory,
-          toteName: loadingWSD.toteName
-        }
-      })
-
-    return {
-      worksheetInfo: {
-        releaseGood,
-        bizplaceName: releaseGood.bizplace.name,
-        startedAt: foundWorksheet.startedAt,
-        refNo: releaseGood.refNo,
-        ownCollection: releaseGood.ownTransport
-      },
-      worksheetDetailInfos
-    }
-  }
-}