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

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

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

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

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

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

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

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

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

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