@things-factory/worksheet-base 4.3.356 → 4.3.358

package/server/graphql/resolvers/worksheet/cycle-count-worksheet-for-carton.ts

@@ -0,0 +1,90 @@
+import { createQueryBuilder, getRepository, In, SelectQueryBuilder } from 'typeorm'
+
+import { InventoryCheck, ORDER_STATUS, InventoryCheckItem } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+import { ProductDetail, Product } from '@things-factory/product-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const cycleCountWorksheetForCartonResolver = {
+  async cycleCountWorksheetForCarton(_: any, { inventoryCheckNo, locationSortingRules }, context: any) {
+    const { domain }: { domain: Domain } = context.state
+    const cycleCount: InventoryCheck = await getRepository(InventoryCheck).findOne({
+      where: { domain, name: inventoryCheckNo, status: ORDER_STATUS.INSPECTING }
+    })
+
+    if (!cycleCount) throw new Error('Failed to find cycle count worksheet')
+
+    const worksheet: Worksheet = await getRepository(Worksheet).findOne({
+      where: {
+        domain,
+        inventoryCheck: cycleCount,
+        type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+        status: WORKSHEET_STATUS.EXECUTING
+      },
+      relations: ['bizplace', 'bizplace.domain']
+    })
+    const qb: SelectQueryBuilder<WorksheetDetail> = createQueryBuilder(WorksheetDetail, 'WSD')
+    qb.leftJoinAndSelect('WSD.targetInventoryCheckItem', 'T_INV')
+      .leftJoinAndSelect('T_INV.inventory', 'INV')
+      .leftJoinAndSelect('T_INV.inspectedLocation', 'INS_LOC')
+      .leftJoinAndSelect('INV.location', 'LOC_INV')
+      .leftJoinAndSelect('T_INV.product', 'PROD')
+      .leftJoinAndSelect('INV.product', 'PROD_INV')
+      .leftJoinAndSelect('T_INV.productDetail', 'PD')
+      .leftJoinAndSelect('INV.productDetail', 'PD_INV')
+      .leftJoinAndSelect('LOC_INV.warehouse', 'WH')
+      .leftJoinAndSelect('INS_LOC.warehouse', 'INS_WH')
+
+    if (locationSortingRules?.length > 0) {
+      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
+        qb.addOrderBy(`LOC_INV.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+      })
+    }
+
+    const worksheetDetails: WorksheetDetail[] = await qb
+      .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
+      .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
+      .getMany()
+
+    return {
+      worksheetInfo: {
+        status: worksheet.status,
+        startedAt: worksheet.startedAt,
+        bizplace: worksheet.bizplace,
+        partnerDomainId: worksheet.bizplace?.domain.id
+      },
+      worksheetDetailInfos: await Promise.all(
+        worksheetDetails.map(async (cycleCountWSD: WorksheetDetail) => {
+          const targetInventoryCheckItem: InventoryCheckItem = cycleCountWSD.targetInventoryCheckItem
+          const inventory = targetInventoryCheckItem?.inventory
+          const products = targetInventoryCheckItem?.product
+          const productDetails = targetInventoryCheckItem?.productDetail
+
+          return {
+            name: cycleCountWSD.name,
+            cartonId: inventory?.cartonId,
+            palletId: inventory?.palletId,
+            batchId: inventory?.batchId,
+            product: inventory?.product ? inventory.product : products,
+            productDetail: inventory?.productDetail ? inventory.productDetail : productDetails,
+            qty: inventory?.qty,
+            uomValue: inventory?.uomValue,
+            uom: inventory?.uom,
+            inspectedQty: targetInventoryCheckItem?.inspectedQty,
+            inspectedUomValue: targetInventoryCheckItem?.inspectedUomValue,
+            inspectedLocation: targetInventoryCheckItem?.inspectedLocation,
+            inspectedBatchNo: targetInventoryCheckItem?.inspectedBatchNo,
+            status: cycleCountWSD.status,
+            targetName: targetInventoryCheckItem?.name,
+            packingType: inventory?.packingType ? inventory.packingType : productDetails.packingType,
+            location: inventory?.location ? inventory.location : targetInventoryCheckItem.inspectedLocation,
+            relatedInvCheckItem: targetInventoryCheckItem
+          }
+        })
+      )
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/cycle-count-worksheet-for-pallet.ts

@@ -0,0 +1,91 @@
+import { createQueryBuilder, getRepository, In, SelectQueryBuilder } from 'typeorm'
+
+import { InventoryCheck, ORDER_STATUS, InventoryCheckItem } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+import { ProductDetail, Product } from '@things-factory/product-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const cycleCountWorksheetForPalletResolver = {
+  async cycleCountWorksheetForPallet(_: any, { inventoryCheckNo, locationSortingRules }, context: any) {
+    const { domain }: { domain: Domain } = context.state
+    const cycleCount: InventoryCheck = await getRepository(InventoryCheck).findOne({
+      where: { domain, name: inventoryCheckNo, status: ORDER_STATUS.INSPECTING }
+    })
+
+    if (!cycleCount) throw new Error('Failed to find cycle count worksheet')
+
+    const worksheet: Worksheet = await getRepository(Worksheet).findOne({
+      where: {
+        domain,
+        inventoryCheck: cycleCount,
+        type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+        status: WORKSHEET_STATUS.EXECUTING
+      },
+      relations: ['bizplace', 'bizplace.domain']
+    })
+
+    const qb: SelectQueryBuilder<WorksheetDetail> = createQueryBuilder(WorksheetDetail, 'WSD')
+    qb.leftJoinAndSelect('WSD.targetInventoryCheckItem', 'T_INV')
+      .leftJoinAndSelect('T_INV.inventory', 'INV')
+      .leftJoinAndSelect('T_INV.inspectedLocation', 'INS_LOC')
+      .leftJoinAndSelect('INV.location', 'LOC_INV')
+      .leftJoinAndSelect('T_INV.product', 'PROD')
+      .leftJoinAndSelect('INV.product', 'PROD_INV')
+      .leftJoinAndSelect('T_INV.productDetail', 'PD')
+      .leftJoinAndSelect('INV.productDetail', 'PD_INV')
+      .leftJoinAndSelect('LOC_INV.warehouse', 'WH')
+      .leftJoinAndSelect('INS_LOC.warehouse', 'INS_WH')
+
+    if (locationSortingRules?.length > 0) {
+      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
+        qb.addOrderBy(`LOC_INV.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+      })
+    }
+
+    const worksheetDetails: WorksheetDetail[] = await qb
+      .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
+      .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
+      .getMany()
+
+    return {
+      worksheetInfo: {
+        status: worksheet.status,
+        startedAt: worksheet.startedAt,
+        bizplace: worksheet.bizplace,
+        partnerDomainId: worksheet.bizplace?.domain.id
+      },
+      worksheetDetailInfos: await Promise.all(
+        worksheetDetails.map(async (cycleCountWSD: WorksheetDetail) => {
+          const targetInventoryCheckItem: InventoryCheckItem = cycleCountWSD.targetInventoryCheckItem
+          const inventory = targetInventoryCheckItem?.inventory
+          const products = targetInventoryCheckItem?.product
+          const productDetails = targetInventoryCheckItem?.productDetail
+
+          return {
+            name: cycleCountWSD.name,
+            cartonId: inventory?.cartonId,
+            palletId: inventory?.palletId,
+            batchId: inventory?.batchId,
+            product: inventory?.product ? inventory.product : products,
+            productDetail: inventory?.productDetail ? inventory.productDetail : productDetails,
+            qty: inventory?.qty,
+            uomValue: inventory?.uomValue,
+            uom: inventory?.uom,
+            inspectedQty: targetInventoryCheckItem?.inspectedQty,
+            inspectedUomValue: targetInventoryCheckItem?.inspectedUomValue,
+            inspectedLocation: targetInventoryCheckItem?.inspectedLocation,
+            inspectedBatchNo: targetInventoryCheckItem?.inspectedBatchNo,
+            status: cycleCountWSD.status,
+            targetName: targetInventoryCheckItem?.name,
+            packingType: inventory?.packingType ? inventory.packingType : productDetails.packingType,
+            location: inventory?.location ? inventory.location : targetInventoryCheckItem.inspectedLocation,
+            relatedInvCheckItem: targetInventoryCheckItem
+          }
+        })
+      )
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-cycle-count-worksheet-carton.ts

@@ -0,0 +1,57 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { OrderInventory, InventoryCheckItem } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { CycleCountWorksheetController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const generateCycleCountWorksheetCartonResolver = {
+  async generateCycleCountWorksheetCarton(
+    _: any,
+    { executionDate, customerId, cycleCountNo, cartonIds, batchIds, productDetailIds, locationNames },
+    context: any
+  ) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const cycleCountWorksheet: Worksheet = await generateCycleCountWorksheetCarton(
+      tx,
+      domain,
+      user,
+      executionDate,
+      customerId,
+      cycleCountNo,
+      cartonIds,
+      batchIds,
+      productDetailIds,
+      locationNames
+    )
+
+    return cycleCountWorksheet
+  }
+}
+
+export async function generateCycleCountWorksheetCarton(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  executionDate: string,
+  customerId: string,
+  cycleCountNo: string,
+  cartonIds: string[] = [],
+  batchIds: string[] = [],
+  productDetailIds: string[] = [],
+  locationNames: string[] = []
+): Promise<Worksheet> {
+  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
+  return await worksheetController.generateCycleCountWorksheetCarton(
+    executionDate,
+    customerId,
+    cycleCountNo,
+    cartonIds,
+    batchIds,
+    productDetailIds,
+    locationNames
+  )
+}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-cycle-count-worksheet.ts

@@ -1,7 +1,7 @@
 import { EntityManager } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { OrderInventory } from '@things-factory/sales-base'
+import { OrderInventory, InventoryCheckItem } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 
 import { CycleCountWorksheetController } from '../../../../controllers'
@@ -10,7 +10,7 @@ import { Worksheet } from '../../../../entities'
 export const generateCycleCountWorksheetResolver = {
   async generateCycleCountWorksheet(
     _: any,
-    { executionDate, customerId, orderInventoryIds, orderInventories, limit },
+    { executionDate, customerId, inventoryCheckItemIds, inventoryCheckItems, limit, selectedLocation, cycleCountNo },
     context: any
   ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
@@ -21,9 +21,11 @@ export const generateCycleCountWorksheetResolver = {
       user,
       executionDate,
       customerId,
-      orderInventoryIds,
-      orderInventories,
-      limit
+      inventoryCheckItemIds,
+      inventoryCheckItems,
+      limit,
+      selectedLocation,
+      cycleCountNo
     )
 
     return cycleCountWorksheet
@@ -36,16 +38,20 @@ export async function generateCycleCountWorksheet(
   user: User,
   executionDate: string,
   customerId: string,
-  orderInventoryIds: string[] = [],
-  orderInventories: OrderInventory[],
-  limit: number
+  inventoryCheckItemIds: string[] = [],
+  inventoryCheckItems: InventoryCheckItem[],
+  limit: number,
+  selectedLocation: string[] = [],
+  cycleCountNo: string
 ): Promise<Worksheet> {
   const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
   return await worksheetController.generateCycleCountWorksheet(
     executionDate,
     customerId,
-    orderInventoryIds,
-    orderInventories,
-    limit
+    inventoryCheckItemIds,
+    inventoryCheckItems,
+    limit,
+    selectedLocation,
+    cycleCountNo
   )
 }

package/server/graphql/resolvers/worksheet/generate-worksheet/index.ts

@@ -1,6 +1,7 @@
 import { generateArrivalNoticeWorksheetResolver } from './generate-arrival-notice-worksheet'
 import { generateBatchPickingWorksheetResolver } from './generate-batch-picking-worksheet'
 import { generateCycleCountWorksheetResolver } from './generate-cycle-count-worksheet'
+import { generateCycleCountWorksheetCartonResolver } from './generate-cycle-count-worksheet-carton'
 import { generatePartialPutawayWorksheetResolver } from './generate-partial-putaway-worksheet'
 import { generatePutawayWorksheetResolver } from './generate-putaway-worksheet'
 import { generateReleaseGoodWorksheetResolver } from './generate-release-good-worksheet'
@@ -14,6 +15,7 @@ export const Mutations = {
   ...generateArrivalNoticeWorksheetResolver,
   ...generateBatchPickingWorksheetResolver,
   ...generateCycleCountWorksheetResolver,
+  ...generateCycleCountWorksheetCartonResolver,
   ...generatePartialPutawayWorksheetResolver,
   ...generatePutawayWorksheetResolver,
   ...generateReleaseGoodWorksheetResolver,

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

@@ -7,7 +7,8 @@ import { confirmCancellationReleaseOrder } from './confirm-cancellation-release-
 import { createWorksheet } from './create-worksheet'
 import { crossDockPickingResolver } from './cross-dock-picking'
 import { cycleCountAdjustmentResolver } from './cycle-count-adjustment'
-import { cycleCountWorksheetResolver } from './cycle-count-worksheet'
+import { cycleCountWorksheetForPalletResolver } from './cycle-count-worksheet-for-pallet'
+import { cycleCountWorksheetForCartonResolver } from './cycle-count-worksheet-for-carton'
 import { deleteWorksheet } from './delete-worksheet'
 import { deliveryOrderByWorksheetResolver } from './delivery-order-by-worksheet'
 import { fetchDeliveryOrderROResolver } from './fetch-delivery-order-ro'
@@ -85,7 +86,8 @@ export const Query = {
   ...putawayReturningWorksheetResolver,
   ...returnWorksheetResolver,
   ...pickingWorksheetResolver,
-  ...cycleCountWorksheetResolver,
+  ...cycleCountWorksheetForPalletResolver,
+  ...cycleCountWorksheetForCartonResolver,
   ...vasWorksheetResolver,
   ...loadingWorksheetResolver,
   ...unloadedInventories,

package/server/graphql/resolvers/worksheet/inspecting/{add-extra-pallet.ts → add-extra-inventory.ts}

@@ -3,45 +3,60 @@ import { Domain } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
 import { CycleCountWorksheetController } from '../../../../controllers'
 
-export const addExtraPalletResolver = {
-  async addExtraPallet(
+export const addExtraInventoryResolver = {
+  async addExtraInventory(
     _: any,
-    { cycleCountNo, palletId, inspectedBatchNo, inspectedQty, inspectedUomValue, locationName },
+    {
+      cycleCountNo,
+      inspectedLocation,
+      productDetailId,
+      productId,
+      inspectedBatchNo,
+      inspectedQty,
+      inspectedUomValue,
+      countNo
+    },
     context: any
   ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await addExtraPallet(
+    await addExtraInventory(
       tx,
       domain,
       user,
       cycleCountNo,
-      palletId,
+      inspectedLocation,
+      productDetailId,
+      productId,
       inspectedBatchNo,
       inspectedQty,
       inspectedUomValue,
-      locationName
+      countNo
     )
   }
 }
 
-export async function addExtraPallet(
+export async function addExtraInventory(
   tx: EntityManager,
   domain: Domain,
   user: User,
   cycleCountNo: string,
-  palletId: string,
+  inspectedLocation: string,
+  productDetailId: string,
+  productId: string,
   inspectedBatchNo: string,
   inspectedQty: number,
   inspectedUomValue: number,
-  locationName: string
+  countNo: number
 ) {
   const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
-  await worksheetController.addExtraPallet(
+  await worksheetController.addExtraInventory(
     cycleCountNo,
-    palletId,
+    inspectedLocation,
+    productDetailId,
+    productId,
     inspectedBatchNo,
     inspectedQty,
     inspectedUomValue,
-    locationName
+    countNo
   )
 }

package/server/graphql/resolvers/worksheet/inspecting/check-missing-inventory-carton.ts

@@ -0,0 +1,24 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { EntityManager } from 'typeorm'
+import { CycleCountWorksheetController } from '../../../../controllers'
+
+export const checkMissingInventoryCartonResolver = {
+  async checkMissingInventoryCarton(_: any, { productDetailId, cartonId, batchId, locationId }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await checkMissingInventoryCarton(tx, domain, user, productDetailId, cartonId, batchId, locationId)
+  }
+}
+
+export async function checkMissingInventoryCarton(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  productDetailId: string,
+  cartonId: string,
+  batchId: string,
+  locationId: string
+) {
+  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
+  await worksheetController.checkMissingInventoryCarton(productDetailId, cartonId, batchId, locationId)
+}

package/server/graphql/resolvers/worksheet/inspecting/{check-missing-pallet.ts → check-missing-inventory.ts}

@@ -3,14 +3,19 @@ import { Domain } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
 import { CycleCountWorksheetController } from '../../../../controllers'
 
-export const checkMissingPalletResolver = {
-  async checkMissingPallet(_: any, { worksheetDetailName }, context: any) {
+export const checkMissingInventoryResolver = {
+  async checkMissingInventory(_: any, { worksheetDetailName }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await checkMissingPallet(tx, domain, user, worksheetDetailName)
+    await checkMissingInventory(tx, domain, user, worksheetDetailName)
   }
 }
 
-export async function checkMissingPallet(tx: EntityManager, domain: Domain, user: User, worksheetDetailName: string) {
+export async function checkMissingInventory(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string
+) {
   const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
-  await worksheetController.checkMissingPallet(worksheetDetailName)
+  await worksheetController.checkMissingInventory(worksheetDetailName)
 }

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

@@ -1,17 +1,25 @@
 import { activateCycleCountResolver } from './activate-cycle-count'
-import { inspectingResolver } from './inspecting'
-import { checkMissingPalletResolver } from './check-missing-pallet'
-import { addExtraPalletResolver } from './add-extra-pallet'
-import { relocatePalletResolver } from './relocate-pallet'
+import { inspectingPalletResolver } from './inspecting-pallet'
+import { inspectingCartonResolver } from './inspecting-carton'
+import { checkMissingInventoryResolver } from './check-missing-inventory'
+import { addExtraInventoryResolver } from './add-extra-inventory'
+import { relocateInventoryResolver } from './relocate-inventory'
 import { undoInspectionResolver } from './undo-inspection'
 import { completeInspectionResolver } from './complete-inspection'
+import { undoInspectionCartonResolver } from './undo-inspection-carton'
+import { relocateInventoryCartonResolver } from './relocate-inventory-carton'
+import { checkMissingInventoryCartonResolver } from './check-missing-inventory-carton'
 
 export const Mutations = {
   ...activateCycleCountResolver,
-  ...inspectingResolver,
-  ...addExtraPalletResolver,
-  ...relocatePalletResolver,
-  ...checkMissingPalletResolver,
+  ...inspectingPalletResolver,
+  ...inspectingCartonResolver,
+  ...addExtraInventoryResolver,
+  ...relocateInventoryResolver,
+  ...checkMissingInventoryResolver,
   ...undoInspectionResolver,
-  ...completeInspectionResolver
+  ...completeInspectionResolver,
+  ...undoInspectionCartonResolver,
+  ...relocateInventoryCartonResolver,
+  ...checkMissingInventoryCartonResolver
 }

package/server/graphql/resolvers/worksheet/inspecting/inspecting-carton.ts

@@ -0,0 +1,51 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { EntityManager } from 'typeorm'
+import { CycleCountWorksheetController } from '../../../../controllers'
+import { Product } from 'puppeteer'
+
+export const inspectingCartonResolver = {
+  async inspectingCarton(
+    _: any,
+    { productDetailId, cartonId, batchId, locationId, inspectedBatchNo, inspectedQty, inspectedUomValue },
+    context: any
+  ) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await executeInspectionCarton(
+      tx,
+      domain,
+      user,
+      productDetailId,
+      cartonId,
+      batchId,
+      locationId,
+      inspectedBatchNo,
+      inspectedQty,
+      inspectedUomValue
+    )
+  }
+}
+
+export async function executeInspectionCarton(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  productDetailId: string,
+  cartonId: string,
+  batchId: string,
+  locationId: string,
+  inspectedBatchNo: string,
+  inspectedQty: number,
+  inspectedUomValue: number
+) {
+  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
+  await worksheetController.inspectingCarton(
+    productDetailId,
+    cartonId,
+    batchId,
+    locationId,
+    inspectedBatchNo,
+    inspectedQty,
+    inspectedUomValue
+  )
+}

package/server/graphql/resolvers/worksheet/inspecting/{inspecting.ts → inspecting-pallet.ts}

@@ -3,14 +3,14 @@ import { Domain } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
 import { CycleCountWorksheetController } from '../../../../controllers'
 
-export const inspectingResolver = {
-  async inspecting(_: any, { worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue }, context: any) {
+export const inspectingPalletResolver = {
+  async inspectingPallet(_: any, { worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await executeInspection(tx, domain, user, worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue)
+    await executeInspectionPallet(tx, domain, user, worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue)
   }
 }
 
-export async function executeInspection(
+export async function executeInspectionPallet(
   tx: EntityManager,
   domain: Domain,
   user: User,
@@ -20,5 +20,5 @@ export async function executeInspection(
   inspectedUomValue: number
 ) {
   const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
-  await worksheetController.inspecting(worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue)
+  await worksheetController.inspectingPallet(worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue)
 }

package/server/graphql/resolvers/worksheet/inspecting/relocate-inventory-carton.ts

@@ -0,0 +1,62 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { EntityManager } from 'typeorm'
+import { CycleCountWorksheetController } from '../../../../controllers'
+
+export const relocateInventoryCartonResolver = {
+  async relocateInventoryCarton(
+    _: any,
+    {
+      productDetailId,
+      cartonId,
+      batchId,
+      locationId,
+      inspectedBatchNo,
+      inspectedQty,
+      inspectedUomValue,
+      inspectedLocationName
+    },
+    context: any
+  ) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await relocateInventoryCarton(
+      tx,
+      domain,
+      user,
+      productDetailId,
+      cartonId,
+      batchId,
+      locationId,
+      inspectedBatchNo,
+      inspectedQty,
+      inspectedUomValue,
+      inspectedLocationName
+    )
+  }
+}
+
+export async function relocateInventoryCarton(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  productDetailId: string,
+  cartonId: string,
+  batchId: string,
+  locationId: string,
+  inspectedBatchNo: string,
+  inspectedQty: number,
+  inspectedUomValue: number,
+  inspectedLocationName: string
+) {
+  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
+  await worksheetController.relocateInventoryCarton(
+    productDetailId,
+    cartonId,
+    batchId,
+    locationId,
+    inspectedBatchNo,
+    inspectedQty,
+    inspectedUomValue,
+    inspectedLocationName
+  )
+}