@things-factory/worksheet-base 4.3.388 → 4.3.390

package/server/controllers/inspect/cycle-count-worksheet-controller.ts

@@ -18,6 +18,7 @@ import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
 import { Worksheet, WorksheetDetail } from '../../entities'
 import { WorksheetNoGenerator } from '../../utils'
 import { WorksheetController } from '../worksheet-controller'
+import { cycleCountAdjustment } from '../../graphql/resolvers/worksheet/cycle-count-adjustment'
 
 export class CycleCountWorksheetController extends WorksheetController {
   private async createCycleCountWorksheet(
@@ -265,6 +266,16 @@ export class CycleCountWorksheetController extends WorksheetController {
       })
 
       if (notDoneCount === 0) {
+        if (currentCycleCountWorksheet.checkCount != 1) {
+          await cycleCountAdjustment(
+            this.trxMgr,
+            this.domain,
+            this.user,
+            currentCycleCountWorksheet.name,
+            existingInventoryCheck.name
+          )
+        }
+
         // Step 11: Update status of existing InventoryCheck
         existingInventoryCheck.status = ORDER_STATUS.INSPECTING
         existingInventoryCheck.updater = this.user
@@ -282,11 +293,134 @@ export class CycleCountWorksheetController extends WorksheetController {
 
       return nextRoundWorksheet
     } catch (error) {
-      console.error('An error occurred while creating the next round cycle count worksheet:', error)
       throw new Error('Failed to create next round cycle count worksheet')
     }
   }
 
+  private async sameCycleCountWorksheet(
+    customerId: string,
+    existingInventoryCheck: InventoryCheck,
+    executionDate: string,
+    executingWorksheet: Worksheet,
+    notTallyWorksheet: Worksheet,
+    inventoryCheckItemIds: string[]
+  ): Promise<Worksheet> {
+    try {
+      // Step 1: Fetch current InventoryCheckItems
+      const currentInventoryCheckItems: InventoryCheckItem[] = await this.trxMgr
+        .getRepository(InventoryCheckItem)
+        .findByIds(inventoryCheckItemIds)
+
+      // Step 2: Create new InventoryCheckItems based on the current ones
+      const continuedInventoryCheckItems = currentInventoryCheckItems.map(currentItem => {
+        let newItem: InventoryCheckItem = new InventoryCheckItem()
+
+        Object.assign(newItem, currentItem)
+        newItem.id = undefined
+        newItem.domain = this.domain
+        newItem.bizplace = customerId
+        newItem.inventoryCheck = currentItem.inventoryCheckId
+        newItem.status = INVENTORY_CHECK_ITEM_STATUS.INSPECTING
+        newItem.name = OrderNoGenerator.inventoryCheckItem()
+        newItem.originQty = currentItem.inspectedQty || currentItem.originQty
+        newItem.originUomValue = currentItem.inspectedUomValue || currentItem.originUomValue
+        newItem.originBatchNo = currentItem.inspectedBatchNo || currentItem.originBatchNo
+        newItem.originLocation = currentItem.inspectedLocationId || currentItem.originLocationId
+        newItem.inspectedQty = null
+        newItem.inspectedUomValue = null
+        newItem.inspectedBatchNo = null
+        newItem.inspectedLocationId = null
+        newItem.countNo = currentItem.countNo + 1
+        newItem.inventory = currentItem.inventoryId
+        newItem.product = currentItem.productId
+        newItem.productDetail = currentItem.productDetailId
+        newItem.creator = this.user
+        newItem.updater = this.user
+
+        return newItem
+      })
+
+      // Step 3: Save the new InventoryCheckItems
+      await this.trxMgr.getRepository(InventoryCheckItem).save(continuedInventoryCheckItems, { chunk: 500 })
+
+      // Step 4: Create new Worksheet Details based on new InventoryCheckItems
+      let continuedWorksheetDetails = continuedInventoryCheckItems.map(newItem => {
+        let detail: WorksheetDetail = new WorksheetDetail()
+
+        detail.domain = this.domain
+        detail.bizplace = customerId
+        detail.worksheet = executingWorksheet
+        detail.name = WorksheetNoGenerator.cycleCountDetail()
+        detail.targetInventoryCheckItem = newItem
+        detail.type = WORKSHEET_TYPE.CYCLE_COUNT
+        detail.status = WORKSHEET_STATUS.EXECUTING
+        detail.creator = this.user
+        detail.updater = this.user
+
+        return detail
+      })
+
+      // Step 5: Save the new Worksheet Details
+      await this.trxMgr.getRepository(WorksheetDetail).save(continuedWorksheetDetails, { chunk: 500 })
+
+      // Step 6: Mark the selected inventory as TERMINATED
+      currentInventoryCheckItems.forEach(item => {
+        item.status = INVENTORY_CHECK_ITEM_STATUS.TERMINATED
+        item.updater = this.user
+      })
+      await this.trxMgr.getRepository(InventoryCheckItem).save(currentInventoryCheckItems)
+
+      // Step 7: Directly update the worksheet details
+      await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .createQueryBuilder()
+        .update(WorksheetDetail)
+        .set({
+          status: WORKSHEET_STATUS.DONE,
+          updater: this.user
+        })
+        .where('targetInventoryCheckItem IN (:...ids)', { ids: currentInventoryCheckItems.map(item => item.id) })
+        .execute()
+
+      // Check if any record is not DONE
+      const notDoneCount = await this.trxMgr.getRepository(WorksheetDetail).count({
+        where: {
+          worksheet: notTallyWorksheet,
+          status: Not(Equal(WORKSHEET_STATUS.DONE))
+        }
+      })
+
+      if (notDoneCount === 0) {
+        if (notTallyWorksheet.checkCount != 1) {
+          await cycleCountAdjustment(
+            this.trxMgr,
+            this.domain,
+            this.user,
+            notTallyWorksheet.name,
+            existingInventoryCheck.name
+          )
+        }
+        // Step 11: Update status of existing InventoryCheck
+        existingInventoryCheck.status = ORDER_STATUS.INSPECTING
+        existingInventoryCheck.updater = this.user
+        await this.trxMgr.getRepository(InventoryCheck).save(existingInventoryCheck)
+
+        // Step 12: Mark the current worksheet as DONE
+        notTallyWorksheet.status = WORKSHEET_STATUS.DONE
+        notTallyWorksheet.updater = this.user
+        await this.trxMgr.getRepository(Worksheet).save(notTallyWorksheet)
+      }
+
+      existingInventoryCheck.executionDate = executionDate
+      existingInventoryCheck.updater = this.user
+      await this.trxMgr.getRepository(InventoryCheck).save(existingInventoryCheck)
+
+      return executingWorksheet // Return the same executing worksheet
+    } catch (error) {
+      throw new Error('Failed to use same cycle count worksheet')
+    }
+  }
+
   async generateCycleCountWorksheet(
     executionDate: string,
     customerId: string,
@@ -307,7 +441,7 @@ export class CycleCountWorksheetController extends WorksheetController {
     })
 
     const worksheetRepository = this.trxMgr.getRepository(Worksheet)
-    const foundCycleCountWorksheet: Worksheet | undefined = await worksheetRepository.findOne({
+    const foundCycleCountWorksheets: Worksheet[] = await worksheetRepository.find({
       where: {
         domain: this.domain,
         bizplace: customerBizplace,
@@ -320,16 +454,39 @@ export class CycleCountWorksheetController extends WorksheetController {
       relations: ['worksheetDetails', 'worksheetDetails.targetInventoryCheckItem', 'inventoryCheck']
     })
 
-    if (inventoryCheckItemIds.length) {
-      return await this.createNextRoundCycleCountWorksheet(
-        customerId,
-        foundInventoryCheck,
-        executionDate,
-        foundCycleCountWorksheet,
-        inventoryCheckItemIds
+    const worksheetStatuses = foundCycleCountWorksheets.map(worksheet => worksheet.status)
+
+    if (foundCycleCountWorksheets.length >= 1 && inventoryCheckItemIds.length) {
+      const executingWorksheet = foundCycleCountWorksheets.find(
+        worksheet => worksheet.status === WORKSHEET_STATUS.EXECUTING
+      )
+      const notTallyWorksheet = foundCycleCountWorksheets.find(
+        worksheet => worksheet.status === WORKSHEET_STATUS.NOT_TALLY
       )
+
+      if (
+        worksheetStatuses.includes(WORKSHEET_STATUS.EXECUTING) &&
+        worksheetStatuses.includes(WORKSHEET_STATUS.NOT_TALLY)
+      ) {
+        return await this.sameCycleCountWorksheet(
+          customerId,
+          foundInventoryCheck,
+          executionDate,
+          executingWorksheet,
+          notTallyWorksheet,
+          inventoryCheckItemIds
+        )
+      } else if (worksheetStatuses.includes(WORKSHEET_STATUS.NOT_TALLY)) {
+        return await this.createNextRoundCycleCountWorksheet(
+          customerId,
+          foundInventoryCheck,
+          executionDate,
+          notTallyWorksheet,
+          inventoryCheckItemIds
+        )
+      }
     } else {
-      if (foundCycleCountWorksheet) {
+      if (foundCycleCountWorksheets.length >= 1) {
         throw new Error('Unfinished cycle count worksheet exists.')
       }
       return await this.createCycleCountWorksheet(
@@ -364,7 +521,7 @@ export class CycleCountWorksheetController extends WorksheetController {
     })
 
     const worksheetRepository = this.trxMgr.getRepository(Worksheet)
-    const foundCycleCountWorksheet: Worksheet | undefined = await worksheetRepository.findOne({
+    const foundCycleCountWorksheets: Worksheet[] = await worksheetRepository.find({
       where: {
         domain: this.domain,
         bizplace: customerBizplace,
@@ -377,6 +534,8 @@ export class CycleCountWorksheetController extends WorksheetController {
       relations: ['worksheetDetails', 'worksheetDetails.targetInventoryCheckItem', 'inventoryCheck']
     })
 
+    const worksheetStatuses = foundCycleCountWorksheets.map(worksheet => worksheet.status)
+
     const qb = this.trxMgr.getRepository(InventoryCheckItem).createQueryBuilder('inventoryCheckItem')
     qb.innerJoinAndSelect('inventoryCheckItem.inventory', 'inventory')
       .innerJoinAndSelect('inventoryCheckItem.productDetail', 'productDetail')
@@ -395,13 +554,31 @@ export class CycleCountWorksheetController extends WorksheetController {
     const inventoryCheckItems: InventoryCheckItem[] = await qb.getMany()
 
     const inventoryCheckItemIds = inventoryCheckItems.map(item => item.id)
+    const executingWorksheet = foundCycleCountWorksheets.find(
+      worksheet => worksheet.status === WORKSHEET_STATUS.EXECUTING
+    )
+    const notTallyWorksheet = foundCycleCountWorksheets.find(
+      worksheet => worksheet.status === WORKSHEET_STATUS.NOT_TALLY
+    )
 
-    if (inventoryCheckItemIds.length) {
+    if (
+      worksheetStatuses.includes(WORKSHEET_STATUS.EXECUTING) &&
+      worksheetStatuses.includes(WORKSHEET_STATUS.NOT_TALLY)
+    ) {
+      return await this.sameCycleCountWorksheet(
+        customerId,
+        foundInventoryCheck,
+        executionDate,
+        executingWorksheet,
+        notTallyWorksheet,
+        inventoryCheckItemIds
+      )
+    } else if (worksheetStatuses.includes(WORKSHEET_STATUS.NOT_TALLY)) {
       return await this.createNextRoundCycleCountWorksheet(
         customerId,
         foundInventoryCheck,
         executionDate,
-        foundCycleCountWorksheet,
+        notTallyWorksheet,
         inventoryCheckItemIds
       )
     }
@@ -461,8 +638,9 @@ export class CycleCountWorksheetController extends WorksheetController {
     const {
       originBatchNo,
       originQty,
-      originUomValue
-    }: { originBatchNo: string; originQty: number; originUomValue: number } = targetInventoryCheckItem
+      originUomValue,
+      originLocationId
+    }: { originBatchNo: string; originQty: number; originUomValue: number, originLocationId: string } = targetInventoryCheckItem
 
     const isChanged: boolean =
       originBatchNo !== inspectedBatchNo || originQty !== inspectedQty || originUomValue !== inspectedUomValue
@@ -478,7 +656,7 @@ export class CycleCountWorksheetController extends WorksheetController {
     targetInventoryCheckItem.inspectedBatchNo = inspectedBatchNo
     targetInventoryCheckItem.inspectedQty = inspectedQty
     targetInventoryCheckItem.inspectedUomValue = inspectedUomValue
-    targetInventoryCheckItem.inspectedLocation = targetInventoryCheckItem.inventory.location
+    targetInventoryCheckItem.inspectedLocation = originLocationId
     targetInventoryCheckItem.status = targetInventoryCheckItemStatus
     targetInventoryCheckItem.updater = this.user
     await this.updateOrderTargets([targetInventoryCheckItem])
@@ -1079,57 +1257,67 @@ export class CycleCountWorksheetController extends WorksheetController {
     this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
 
     const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    const doneWorksheetDetails = worksheetDetails.filter(wsd => wsd.status === 'DONE')
     const targetInventoryCheckItems: InventoryCheckItem[] = worksheetDetails.map(
       (wsd: WorksheetDetail) => wsd.targetInventoryCheckItem
     )
+    if (doneWorksheetDetails.length === worksheetDetails.length && worksheet.checkCount != 1) {
+      await cycleCountAdjustment(this.trxMgr, this.domain, this.user, worksheet.name, inventoryCheck.name)
 
-    const {
-      tallyTargetInventoryCheckItems,
-      notTallyTargetInventoryCheckItems
-    }: {
-      tallyTargetInventoryCheckItems: InventoryCheckItem[]
-      notTallyTargetInventoryCheckItems: InventoryCheckItem[]
-    } = targetInventoryCheckItems.reduce(
-      (result, targetInventoryCheckItem: InventoryCheckItem) => {
-        if (targetInventoryCheckItem.status !== INVENTORY_CHECK_ITEM_STATUS.INSPECTED) {
-          result.notTallyTargetInventoryCheckItems.push(targetInventoryCheckItem)
-        } else {
-          result.tallyTargetInventoryCheckItems.push(targetInventoryCheckItem)
+      worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+        domain: this.domain,
+        type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+        inventoryCheck
+      })
+    } else {
+      const {
+        tallyTargetInventoryCheckItems,
+        notTallyTargetInventoryCheckItems
+      }: {
+        tallyTargetInventoryCheckItems: InventoryCheckItem[]
+        notTallyTargetInventoryCheckItems: InventoryCheckItem[]
+      } = targetInventoryCheckItems.reduce(
+        (result, targetInventoryCheckItem: InventoryCheckItem) => {
+          if (targetInventoryCheckItem.status !== INVENTORY_CHECK_ITEM_STATUS.INSPECTED) {
+            result.notTallyTargetInventoryCheckItems.push(targetInventoryCheckItem)
+          } else {
+            result.tallyTargetInventoryCheckItems.push(targetInventoryCheckItem)
+          }
+
+          return result
+        },
+        {
+          tallyTargetInventoryCheckItems: [],
+          notTallyTargetInventoryCheckItems: []
         }
+      )
 
-        return result
-      },
-      {
-        tallyTargetInventoryCheckItems: [],
-        notTallyTargetInventoryCheckItems: []
-      }
-    )
-
-    const tallyInventories: Inventory[] = tallyTargetInventoryCheckItems.map(
-      targetInventoryCheckItem => targetInventoryCheckItem.inventory
-    )
-    tallyTargetInventoryCheckItems.forEach((targetInventoryCheckItem: InventoryCheckItem) => {
-      targetInventoryCheckItem.status = INVENTORY_CHECK_ITEM_STATUS.TERMINATED
-      targetInventoryCheckItem.updater = this.user
-    })
-    await this.trxMgr.getRepository(InventoryCheckItem).save(tallyTargetInventoryCheckItems, { chunk: 500 })
+      const tallyInventories: Inventory[] = tallyTargetInventoryCheckItems.map(
+        targetInventoryCheckItem => targetInventoryCheckItem.inventory
+      )
+      tallyTargetInventoryCheckItems.forEach((targetInventoryCheckItem: InventoryCheckItem) => {
+        targetInventoryCheckItem.status = INVENTORY_CHECK_ITEM_STATUS.TERMINATED
+        targetInventoryCheckItem.updater = this.user
+      })
+      await this.trxMgr.getRepository(InventoryCheckItem).save(tallyTargetInventoryCheckItems, { chunk: 500 })
 
-    await this.trxMgr.getRepository(Inventory).save(tallyInventories, { chunk: 500 })
+      await this.trxMgr.getRepository(Inventory).save(tallyInventories, { chunk: 500 })
 
-    if (notTallyTargetInventoryCheckItems.length) {
-      worksheet.status = WORKSHEET_STATUS.NOT_TALLY
-      inventoryCheck.status = ORDER_STATUS.PENDING_REVIEW
-    } else {
-      worksheet.status = WORKSHEET_STATUS.DONE
-      inventoryCheck.status = ORDER_STATUS.DONE
-    }
+      if (notTallyTargetInventoryCheckItems.length) {
+        worksheet.status = WORKSHEET_STATUS.NOT_TALLY
+        inventoryCheck.status = ORDER_STATUS.PENDING_REVIEW
+      } else {
+        worksheet.status = WORKSHEET_STATUS.DONE
+        inventoryCheck.status = ORDER_STATUS.DONE
+      }
 
-    worksheet.endedAt = new Date()
-    worksheet.updater = this.user
-    await this.trxMgr.getRepository(Worksheet).save(worksheet)
+      worksheet.endedAt = new Date()
+      worksheet.updater = this.user
+      await this.trxMgr.getRepository(Worksheet).save(worksheet)
 
-    inventoryCheck.updater = this.user
-    await this.trxMgr.getRepository(InventoryCheck).save(inventoryCheck)
+      inventoryCheck.updater = this.user
+      await this.trxMgr.getRepository(InventoryCheck).save(inventoryCheck)
+    }
 
     return worksheet
   }

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

@@ -1,4 +1,4 @@
-import { EntityManager, In } from 'typeorm'
+import { EntityManager, In, Not } from 'typeorm'
 
 import { Application, ApplicationType, User } from '@things-factory/auth-base'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
@@ -52,6 +52,16 @@ export async function cycleCountAdjustment(
     }
   })
 
+  const inspectingItems: InventoryCheckItem[] = await tx.getRepository(InventoryCheckItem).find({
+    where: {
+      inventoryCheck: cycleCount,
+      status: 'INSPECTING'
+    },
+    relations: ['inventory']
+  })
+
+  const inspectingInventoryIds = new Set(inspectingItems.map(item => item.inventory.id))
+
   let worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
     where: {
       domain,
@@ -66,8 +76,7 @@ export async function cycleCountAdjustment(
     where: {
       domain,
       worksheet,
-      type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
-      status: WORKSHEET_STATUS.NOT_TALLY
+      type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK])
     },
     relations: [
       'targetInventoryCheckItem',
@@ -87,7 +96,29 @@ export async function cycleCountAdjustment(
     ]
   })
 
-  for (let worksheetDetail of worksheetDetails) {
+  // Filter worksheetDetails that meet any of the specified conditions
+  const relevantWorksheetDetails = worksheetDetails.filter(worksheetDetail => {
+    const checkItem = worksheetDetail.targetInventoryCheckItem
+    const inventory = checkItem.inventory
+
+    // Exclude items that are under inspection elsewhere
+    if (inspectingInventoryIds.has(inventory.id)) {
+      return false
+    }
+
+    return (
+      checkItem.status === ORDER_INVENTORY_STATUS.MISSING ||
+      checkItem.inspectedQty === 0 ||
+      checkItem.status === INVENTORY_CHECK_ITEM_STATUS.ADDED ||
+      inventory.status === 'CC_ADDED' ||
+      checkItem.inspectedQty !== inventory.qty ||
+      checkItem.inspectedBatchNo !== inventory.batchId ||
+      checkItem.inspectedLocation.id !== inventory.location.id ||
+      checkItem.inspectedUomValue !== inventory.uomValue
+    )
+  })
+
+  for (let worksheetDetail of relevantWorksheetDetails) {
     const targetInventoryCheckItem: InventoryCheckItem = worksheetDetail.targetInventoryCheckItem
     let inventory: Inventory = targetInventoryCheckItem.inventory
 
@@ -176,12 +207,17 @@ export async function cycleCountAdjustment(
         const powrupController: PowrupController = new PowrupController()
         powrupController.updateStock([inventory], customerDomain, user, tx)
       }
-    } else if (targetInventoryCheckItem.status === INVENTORY_CHECK_ITEM_STATUS.ADDED) {
+    } else if (
+      targetInventoryCheckItem.status === INVENTORY_CHECK_ITEM_STATUS.ADDED ||
+      inventory.status === 'CC_ADDED'
+    ) {
       const inventories: Inventory[] = await tx.getRepository(Inventory).find({
         where: { id: targetInventoryCheckItem.inventory.id, domain, status: INVENTORY_STATUS.CC_ADDED }
       })
 
       for (let inventory of inventories) {
+        inventory.qty = targetInventoryCheckItem.inspectedQty
+        inventory.uomValue = targetInventoryCheckItem.inspectedUomValue
         inventory.status = INVENTORY_STATUS.STORED
         inventory.creator = user
         inventory.updater = user
@@ -218,7 +254,12 @@ export async function cycleCountAdjustment(
           location: targetInventoryCheckItem.inventory.location
         })
       }
-    } else {
+    } else if (
+      targetInventoryCheckItem.inspectedQty !== inventory.qty ||
+      targetInventoryCheckItem.inspectedBatchNo !== inventory.batchId ||
+      targetInventoryCheckItem.inspectedLocation.id !== inventory.location.id ||
+      targetInventoryCheckItem.inspectedUomValue !== inventory.uomValue
+    ) {
       const prevLocationId: string = inventory.location.id
 
       if (targetInventoryCheckItem.inspectedBatchNo !== inventory.batchId) {

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

@@ -34,6 +34,7 @@ export const cycleCountWorksheetForCartonResolver = {
     qb.leftJoinAndSelect('WSD.targetInventoryCheckItem', 'T_INV')
       .leftJoinAndSelect('T_INV.inventory', 'INV')
       .leftJoinAndSelect('T_INV.inspectedLocation', 'INS_LOC')
+      .leftJoinAndSelect('T_INV.originLocation', 'ORG_LOC')
       .leftJoinAndSelect('INV.location', 'LOC_INV')
       .leftJoinAndSelect('T_INV.product', 'PROD')
       .leftJoinAndSelect('INV.product', 'PROD_INV')
@@ -51,7 +52,10 @@ export const cycleCountWorksheetForCartonResolver = {
     }
 
     if (locationName) {
-      qb.andWhere('("LOC_INV"."name" = :locationName OR "INS_LOC"."name" = :locationName)', { locationName })
+      qb.andWhere(
+        '("ORG_LOC"."name" = :locationName OR "LOC_INV"."name" = :locationName OR "INS_LOC"."name" = :locationName',
+        { locationName }
+      )
     }
 
     if (cartonId) {
@@ -93,6 +97,7 @@ export const cycleCountWorksheetForCartonResolver = {
             qty: inventory?.qty,
             uomValue: inventory?.uomValue,
             uom: inventory?.uom,
+            originLocation: targetInventoryCheckItem?.originLocation,
             inspectedQty: targetInventoryCheckItem?.inspectedQty,
             inspectedUomValue: targetInventoryCheckItem?.inspectedUomValue,
             inspectedLocation: targetInventoryCheckItem?.inspectedLocation,

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

@@ -35,6 +35,7 @@ export const cycleCountWorksheetForPalletResolver = {
     qb.leftJoinAndSelect('WSD.targetInventoryCheckItem', 'T_INV')
       .leftJoinAndSelect('T_INV.inventory', 'INV')
       .leftJoinAndSelect('T_INV.inspectedLocation', 'INS_LOC')
+      .leftJoinAndSelect('T_INV.originLocation', 'ORG_LOC')
       .leftJoinAndSelect('INV.location', 'LOC_INV')
       .leftJoinAndSelect('T_INV.product', 'PROD')
       .leftJoinAndSelect('INV.product', 'PROD_INV')
@@ -52,7 +53,10 @@ export const cycleCountWorksheetForPalletResolver = {
     }
 
     if (locationName) {
-      qb.andWhere('("LOC_INV"."name" = :locationName OR "INS_LOC"."name" = :locationName)', { locationName })
+      qb.andWhere(
+        '("ORG_LOC"."name" = :locationName OR "LOC_INV"."name" = :locationName OR "INS_LOC"."name" = :locationName',
+        { locationName }
+      )
     }
 
     if (cartonId) {
@@ -94,6 +98,7 @@ export const cycleCountWorksheetForPalletResolver = {
             qty: inventory?.qty,
             uomValue: inventory?.uomValue,
             uom: inventory?.uom,
+            originLocation: targetInventoryCheckItem?.originLocation,
             inspectedQty: targetInventoryCheckItem?.inspectedQty,
             inspectedUomValue: targetInventoryCheckItem?.inspectedUomValue,
             inspectedLocation: targetInventoryCheckItem?.inspectedLocation,
@@ -101,7 +106,11 @@ export const cycleCountWorksheetForPalletResolver = {
             status: cycleCountWSD.status,
             targetName: targetInventoryCheckItem?.name,
             packingType: inventory?.packingType ? inventory.packingType : productDetails.packingType,
-            location: inventory?.location ? inventory.location : targetInventoryCheckItem.inspectedLocation,
+            location: targetInventoryCheckItem?.originLocation
+              ? targetInventoryCheckItem.originLocation
+              : inventory?.location
+              ? inventory.location
+              : targetInventoryCheckItem.inspectedLocation,
             relatedInvCheckItem: targetInventoryCheckItem
           }
         })

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

@@ -529,12 +529,12 @@ async function queryPackingWorksheet(tx, domain, assignee, binLocation) {
     .innerJoinAndSelect('rg.orderInventories', 'oi')
     .innerJoinAndSelect('oi.binLocation', 'l')
     .leftJoinAndSelect('rg.orderPackages', 'op')
-    .innerJoinAndSelect('op.orderPackageItems', 'opi')
-    .innerJoinAndSelect('opi.orderProduct', 'opr')
-    .innerJoinAndSelect('opi.productDetail', 'pd')
-    .innerJoinAndSelect('pd.product', 'p')
-    .innerJoinAndSelect('p.productDetails', 'pd2')
-    .innerJoinAndSelect('pd2.productBarcodes', 'pb')
+    .leftJoinAndSelect('op.orderPackageItems', 'opi')
+    .leftJoinAndSelect('opi.orderProduct', 'opr')
+    .leftJoinAndSelect('opi.productDetail', 'pd')
+    .leftJoinAndSelect('pd.product', 'p')
+    .leftJoinAndSelect('p.productDetails', 'pd2')
+    .leftJoinAndSelect('pd2.productBarcodes', 'pb')
     .innerJoin('worksheets', 'w', 'w.release_good_id = rg.id')
     .where('rg.domain_id = :domainId', { domainId: domain.id })
     .andWhere('oi.status IN (:...orderInventoryStatus)', {
@@ -555,19 +555,6 @@ async function queryPackingWorksheet(tx, domain, assignee, binLocation) {
     .addOrderBy('rg.status', 'ASC')
     .addOrderBy('w.created_at', 'ASC')
 
-  if (assignee) {
-    qb.andWhere('ws.assignee_id = :assigneeId', { assigneeId: assignee.id })
-  } else {
-    qb.andWhere('ws.assignee_id is null')
-  }
-
-  qb.orderBy('releaseGood.status', 'ASC')
-    .addOrderBy('ws.created_at', 'ASC')
-    .addOrderBy('releaseGood.name', 'ASC')
-    .groupBy('ws.created_at')
-    .addGroupBy('releaseGood.name')
-    .addGroupBy('releaseGood.id')
-
   let releaseGood = await qb.getOne()
 
   if (!releaseGood) {

package/server/graphql/types/worksheet/worksheet-detail-info.ts

@@ -73,5 +73,6 @@ export const WorksheetDetailInfo = gql`
     reusablePalletName: String
     expirationPeriod: Int
     productDetail: ProductDetail
+    originLocation: Location
   }
 `

package/server/utils/lmd-util.ts

@@ -123,7 +123,7 @@ export async function createLmdParcel(releaseGoods, tx, domain, user, marketplac
         address3: releaseGood?.deliveryAddress3,
         ward: releaseGood?.ward?.toUpperCase(), //only for viettel lmd
         city: releaseGood.city?.toUpperCase(),
-        postcode: releaseGood.postalCode,
+        postcode: releaseGood?.postalCode,
         district: releaseGood?.district?.toUpperCase() || releaseGood.city?.toUpperCase(),
         state:
           releaseGood?.state?.toUpperCase() ||