@things-factory/worksheet-base 4.3.356 → 4.3.357

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

@@ -1,15 +1,18 @@
-import { Brackets, Equal, In, Not, SelectQueryBuilder } from 'typeorm'
+import { Brackets, Equal, In, Not, SelectQueryBuilder, MoreThan } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
 import {
   generateCycleCount,
   InventoryCheck,
-  ORDER_INVENTORY_STATUS,
+  InventoryCheckItem,
   ORDER_STATUS,
-  OrderInventory,
-  OrderNoGenerator
+  OrderNoGenerator,
+  INVENTORY_CHECK_ITEM_STATUS
 } from '@things-factory/sales-base'
-import { Inventory, INVENTORY_STATUS, Location } from '@things-factory/warehouse-base'
+import { Inventory, INVENTORY_STATUS, Location, InventoryNoGenerator, Warehouse } from '@things-factory/warehouse-base'
+import { ProductDetail, Product } from '@things-factory/product-base'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
+import { generateId } from '@things-factory/id-rule-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
 import { Worksheet, WorksheetDetail } from '../../entities'
@@ -17,194 +20,388 @@ import { WorksheetNoGenerator } from '../../utils'
 import { WorksheetController } from '../worksheet-controller'
 
 export class CycleCountWorksheetController extends WorksheetController {
+  private async createCycleCountWorksheet(
+    customerBizplace: Bizplace,
+    customerId: string,
+    executionDate: string,
+    inventoryCheckItem: InventoryCheckItem[],
+    selectedLocation: string[],
+    limit: number
+  ): Promise<Worksheet> {
+    const cycleCount: InventoryCheck = await generateCycleCount(
+      this.trxMgr,
+      this.domain,
+      this.user,
+      executionDate,
+      customerId
+    )
+
+    // Find out inventories which is target for cycle counting
+    const qb: SelectQueryBuilder<Inventory> = this.trxMgr.getRepository(Inventory).createQueryBuilder('INV')
+    qb.leftJoinAndSelect('INV.location', 'LOC')
+      .leftJoinAndSelect('INV.product', 'PROD')
+      .leftJoinAndSelect('INV.productDetail', 'PD')
+      .where('INV.domain_id = :domainId', { domainId: this.domain.id })
+      .andWhere('INV.bizplace_id = :bizplaceId', { bizplaceId: customerBizplace.id })
+      .andWhere('INV.status = :status', { status: INVENTORY_STATUS.STORED })
+
+    if (inventoryCheckItem && inventoryCheckItem.length > 0) {
+      let keyval = {
+        batchId: 'batch_id',
+        batchIdRef: 'batch_id_ref',
+        productDetailId: 'product_detail_id'
+      }
+
+      qb.andWhere(
+        new Brackets(qb => {
+          inventoryCheckItem.forEach((itm, idx) => {
+            qb.orWhere(
+              new Brackets(qb2 => {
+                let first = true
+                for (var prop in itm) {
+                  if (first) {
+                    first = false
+                    qb2.where(`INV.${keyval[prop]} ${itm[prop] == null ? 'is null' : " = '" + itm[prop] + "'"}`)
+                  } else {
+                    qb2.andWhere(`INV.${keyval[prop]} ${itm[prop] == null ? 'is null' : " = '" + itm[prop] + "'"}`)
+                  }
+                }
+              })
+            )
+          })
+        })
+      )
+    } else if (selectedLocation && selectedLocation.length > 0) {
+      // If selectedLocation is provided
+      // Query inventory items located at the selected location
+      qb.andWhere('INV.location_id IN (:...locationIds)', { locationIds: selectedLocation })
+    } else {
+      if (limit > 0) {
+        qb.orderBy('RANDOM()').limit(limit)
+      }
+    }
+
+    let inventories: Inventory[] = await qb.getMany()
+
+    if (!inventories.length) {
+      throw new Error(`Failed to find inventories`)
+    }
+
+    let cycleCountWorksheet: Worksheet = new Worksheet()
+    cycleCountWorksheet.domain = this.domain
+    cycleCountWorksheet.bizplace = customerBizplace
+    cycleCountWorksheet.name = WorksheetNoGenerator.cycleCount()
+    cycleCountWorksheet.inventoryCheck = cycleCount
+    cycleCountWorksheet.type = WORKSHEET_TYPE.CYCLE_COUNT
+    cycleCountWorksheet.status = WORKSHEET_STATUS.DEACTIVATED
+    cycleCountWorksheet.checkCount = 1
+    cycleCountWorksheet.creator = this.user
+    cycleCountWorksheet.updater = this.user
+    cycleCountWorksheet = await this.trxMgr.getRepository(Worksheet).save(cycleCountWorksheet)
+
+    // generate order inventory mapping with inventory ID
+    let targetInventoryCheckItems: InventoryCheckItem[] = []
+    for (let i: number = 0; i < inventories.length; i++) {
+      const inventory: Inventory = inventories[i]
+
+      let targetInventoryCheckItem: InventoryCheckItem = new InventoryCheckItem()
+      targetInventoryCheckItem.domain = this.domain
+      targetInventoryCheckItem.bizplace = customerBizplace
+      targetInventoryCheckItem.status = INVENTORY_CHECK_ITEM_STATUS.PENDING
+      targetInventoryCheckItem.name = OrderNoGenerator.inventoryCheckItem()
+      targetInventoryCheckItem.inventoryCheck = cycleCount
+      targetInventoryCheckItem.originQty = inventory.qty
+      targetInventoryCheckItem.originWeight = 0
+      targetInventoryCheckItem.originUomValue = inventory.uomValue
+      targetInventoryCheckItem.originBatchNo = inventory.batchId
+      targetInventoryCheckItem.originLocation = inventory.location
+      targetInventoryCheckItem.inventory = inventory
+      targetInventoryCheckItem.product = inventory.product
+      targetInventoryCheckItem.productDetail = inventory.productDetail
+      targetInventoryCheckItem.countNo = 1
+      targetInventoryCheckItem.creator = this.user
+      targetInventoryCheckItem.updater = this.user
+      targetInventoryCheckItems.push(targetInventoryCheckItem)
+
+      inventory.updater = this.user
+    }
+
+    targetInventoryCheckItems = await this.trxMgr
+      .getRepository(InventoryCheckItem)
+      .save(targetInventoryCheckItems, { chunk: 500 })
+
+    inventories = await this.trxMgr.getRepository(Inventory).save(inventories, { chunk: 500 })
+
+    let cycleCountWorksheetDetails: WorksheetDetail[] = []
+    for (let i: number = 0; i < targetInventoryCheckItems.length; i++) {
+      let targetInventoryCheckItem: InventoryCheckItem = targetInventoryCheckItems[i]
+
+      let cycleCountWorksheetDetail: WorksheetDetail = new WorksheetDetail()
+      cycleCountWorksheetDetail.domain = this.domain
+      cycleCountWorksheetDetail.bizplace = customerBizplace
+      cycleCountWorksheetDetail.worksheet = cycleCountWorksheet
+      cycleCountWorksheetDetail.name = WorksheetNoGenerator.cycleCountDetail()
+      cycleCountWorksheetDetail.targetInventoryCheckItem = targetInventoryCheckItem
+      cycleCountWorksheetDetail.type = WORKSHEET_TYPE.CYCLE_COUNT
+      cycleCountWorksheetDetail.status = WORKSHEET_STATUS.DEACTIVATED
+      cycleCountWorksheetDetail.creator = this.user
+      cycleCountWorksheetDetail.updater = this.user
+
+      cycleCountWorksheetDetails.push(cycleCountWorksheetDetail)
+    }
+
+    await this.trxMgr.getRepository(WorksheetDetail).save(cycleCountWorksheetDetails, { chunk: 500 })
+
+    return cycleCountWorksheet
+  }
+
+  private async createNextRoundCycleCountWorksheet(
+    customerId: string,
+    existingInventoryCheck: InventoryCheck,
+    nextExecutionDate: string,
+    currentCycleCountWorksheet: Worksheet,
+    inventoryCheckItemIds: string[]
+  ): Promise<Worksheet> {
+    try {
+      // Step 1: Create a new cycle count worksheet for the next round
+      let nextRoundWorksheet: Worksheet = new Worksheet()
+      Object.assign(nextRoundWorksheet, currentCycleCountWorksheet)
+      nextRoundWorksheet.id = undefined
+      nextRoundWorksheet.domain = this.domain
+      nextRoundWorksheet.bizplace = customerId
+      nextRoundWorksheet.name = WorksheetNoGenerator.cycleCount()
+      nextRoundWorksheet.status = WORKSHEET_STATUS.EXECUTING
+      nextRoundWorksheet.endedAt = null
+      nextRoundWorksheet.updater = this.user
+      nextRoundWorksheet.worksheetDetails = null
+      nextRoundWorksheet.checkCount = currentCycleCountWorksheet.checkCount + 1
+      nextRoundWorksheet.inventoryCheck = existingInventoryCheck
+      nextRoundWorksheet.type = WORKSHEET_TYPE.CYCLE_COUNT
+
+      // Step 2: Save the new Worksheet
+      await this.trxMgr.getRepository(Worksheet).save(nextRoundWorksheet)
+
+      // Step 3: Fetch current InventoryCheckItems
+      const currentInventoryCheckItems: InventoryCheckItem[] = await this.trxMgr
+        .getRepository(InventoryCheckItem)
+        .findByIds(inventoryCheckItemIds)
+
+      // Step 4: Create new InventoryCheckItems based on the current ones
+      const nextRoundInventoryCheckItems = currentInventoryCheckItems.map(currentItem => {
+        let nextRoundItem: InventoryCheckItem = new InventoryCheckItem()
+
+        Object.assign(nextRoundItem, currentItem)
+        nextRoundItem.id = undefined
+        nextRoundItem.domain = this.domain
+        nextRoundItem.bizplace = customerId
+        nextRoundItem.inventoryCheck = currentItem.inventoryCheckId
+        nextRoundItem.status = INVENTORY_CHECK_ITEM_STATUS.INSPECTING
+        nextRoundItem.name = OrderNoGenerator.inventoryCheckItem()
+        nextRoundItem.originQty = currentItem.inspectedQty || currentItem.originQty
+        nextRoundItem.originUomValue = currentItem.inspectedUomValue || currentItem.originUomValue
+        nextRoundItem.originBatchNo = currentItem.inspectedBatchNo || currentItem.originBatchNo
+        nextRoundItem.originLocation = currentItem.inspectedLocationId || currentItem.originLocationId
+        nextRoundItem.inspectedQty = null
+        nextRoundItem.inspectedUomValue = null
+        nextRoundItem.inspectedBatchNo = null
+        nextRoundItem.inspectedLocationId = null
+        nextRoundItem.countNo = currentItem.countNo + 1
+        nextRoundItem.inventory = currentItem.inventoryId
+        nextRoundItem.product = currentItem.productId
+        nextRoundItem.productDetail = currentItem.productDetailId
+        nextRoundItem.creator = this.user
+        nextRoundItem.updater = this.user
+        return nextRoundItem
+      })
+
+      // Step 5: Save the new InventoryCheckItems
+      await this.trxMgr.getRepository(InventoryCheckItem).save(nextRoundInventoryCheckItems, { chunk: 500 })
+
+      // Step 6: Create a new cycle count worksheet details for the next round
+      let nextRoundWorksheetDetails = nextRoundInventoryCheckItems.map(newItem => {
+        let detail: WorksheetDetail = new WorksheetDetail()
+
+        detail.domain = this.domain
+        detail.bizplace = customerId
+        detail.worksheet = nextRoundWorksheet
+        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 7: Save the new Worksheet Details
+      await this.trxMgr.getRepository(WorksheetDetail).save(nextRoundWorksheetDetails, { chunk: 500 })
+
+      // Step 8: 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 9: 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: currentCycleCountWorksheet,
+          status: Not(Equal(WORKSHEET_STATUS.DONE))
+        }
+      })
+
+      if (notDoneCount === 0) {
+        // 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
+        currentCycleCountWorksheet.status = WORKSHEET_STATUS.DONE
+        currentCycleCountWorksheet.updater = this.user
+        await this.trxMgr.getRepository(Worksheet).save(currentCycleCountWorksheet)
+      }
+
+      existingInventoryCheck.executionDate = nextExecutionDate
+      existingInventoryCheck.updater = this.user
+      await this.trxMgr.getRepository(InventoryCheck).save(existingInventoryCheck)
+
+      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')
+    }
+  }
+
   async generateCycleCountWorksheet(
     executionDate: string,
     customerId: string,
-    orderInventoryIds: string[] = [],
-    orderInventory: OrderInventory[],
-    limit: number
+    inventoryCheckItemIds: string[] = [],
+    inventoryCheckItem: InventoryCheckItem[] = [],
+    limit: number = 0,
+    selectedLocation: string[] = [],
+    cycleCountNo: string
   ): Promise<Worksheet> {
-    // Find out warehouse and customer bizplace
     const customerBizplace: Bizplace = await this.trxMgr.getRepository(Bizplace).findOne(customerId)
-    let foundCycleCountWorksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+
+    const foundInventoryCheck: InventoryCheck = await this.trxMgr.getRepository(InventoryCheck).findOne({
+      where: {
+        domain: this.domain,
+        bizplace: customerBizplace,
+        name: cycleCountNo
+      }
+    })
+
+    const worksheetRepository = this.trxMgr.getRepository(Worksheet)
+    const foundCycleCountWorksheet: Worksheet | undefined = await worksheetRepository.findOne({
       where: {
         domain: this.domain,
         bizplace: customerBizplace,
         type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
         status: Not(WORKSHEET_STATUS.DONE)
       },
-      relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'inventoryCheck']
+      order: {
+        checkCount: 'DESC'
+      },
+      relations: ['worksheetDetails', 'worksheetDetails.targetInventoryCheckItem', 'inventoryCheck']
     })
 
-    // Create second round of cycle count with specified order inventories
-    if (orderInventoryIds.length) {
-      // Update status of target inventories (NOT_TALLY => INSPECTING)
-      let targetInventories: OrderInventory[] = await this.trxMgr
-        .getRepository(OrderInventory)
-        .findByIds(orderInventoryIds)
-      targetInventories.forEach((targetInventory: OrderInventory) => {
-        targetInventory.status = ORDER_INVENTORY_STATUS.INSPECTING
-        targetInventory.updater = this.user
-      })
-      await this.trxMgr.getRepository(OrderInventory).save(targetInventories)
-
-      // Update status of worksheet (NOT_TALLY => EXECUTING)
-      foundCycleCountWorksheet.type = WORKSHEET_TYPE.CYCLE_COUNT_RECHECK
-      foundCycleCountWorksheet.status = WORKSHEET_STATUS.EXECUTING
-      foundCycleCountWorksheet.endedAt = null
-      foundCycleCountWorksheet.updater = this.user
-      await this.trxMgr.getRepository(Worksheet).save(foundCycleCountWorksheet)
-
-      // Update status of worksheet details (NOT_TALLY => EXECUTING)
-      let worksheetDetails = foundCycleCountWorksheet.worksheetDetails.filter(
-        (wsd: WorksheetDetail) => orderInventoryIds.indexOf(wsd.targetInventory.id) >= 0
+    if (inventoryCheckItemIds.length) {
+      return await this.createNextRoundCycleCountWorksheet(
+        customerId,
+        foundInventoryCheck,
+        executionDate,
+        foundCycleCountWorksheet,
+        inventoryCheckItemIds
       )
-      worksheetDetails.forEach((wsd: WorksheetDetail) => {
-        wsd.status = WORKSHEET_STATUS.EXECUTING
-        wsd.updater = this.user
-      })
-      await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
-
-      // Update status of cycle count
-      const cycleCount: InventoryCheck = foundCycleCountWorksheet.inventoryCheck
-      cycleCount.status = ORDER_STATUS.INSPECTING
-      cycleCount.updater = this.user
-      await this.trxMgr.getRepository(InventoryCheck).save(cycleCount)
-
-      return foundCycleCountWorksheet
     } else {
-      // Create first round of cycle count with whole pallets
       if (foundCycleCountWorksheet) {
-        throw new Error(`Unfinished cycle count worksheet exists.`)
+        throw new Error('Unfinished cycle count worksheet exists.')
       }
-
-      const cycleCount: InventoryCheck = await generateCycleCount(
-        this.trxMgr,
-        this.domain,
-        this.user,
+      return await this.createCycleCountWorksheet(
+        customerBizplace,
+        customerId,
         executionDate,
-        customerId
+        inventoryCheckItem,
+        selectedLocation,
+        limit
       )
+    }
+  }
 
-      // Find out inventories which is target for cycle counting
-      const qb: SelectQueryBuilder<Inventory> = this.trxMgr.getRepository(Inventory).createQueryBuilder('INV')
-      qb.leftJoinAndSelect('INV.location', 'LOC')
-        .where('INV.domain_id = :domainId', { domainId: this.domain.id })
-        .andWhere('INV.bizplace_id = :bizplaceId', { bizplaceId: customerBizplace.id })
-        .andWhere('INV.status = :status', { status: INVENTORY_STATUS.STORED })
-        .andWhere(
-          new Brackets(qb => {
-            qb.where('"INV"."locked_qty" ISNULL')
-            qb.orWhere('"INV"."locked_qty" = 0')
-          })
-        )
-
-      if (orderInventory && orderInventory.length > 0) {
-        let keyval = {
-          batchId: 'batch_id',
-          batchIdRef: 'batch_id_ref',
-          productDetailId: 'product_detail_id'
-        }
-
-        qb.andWhere(
-          new Brackets(qb => {
-            orderInventory.forEach((itm, idx) => {
-              // sample itm value
-              // batchId: 'WO00019730', batchIdRef: null, productDetailId: '1d679587-c713-42d6-bd0a-74e587e39cc7'
-              qb.orWhere(
-                new Brackets(qb2 => {
-                  let first = true
-                  for (var prop in itm) {
-                    if (first) {
-                      first = false
-                      qb2.where(`INV.${keyval[prop]} ${itm[prop] == null ? 'is null' : " = '" + itm[prop] + "'"}`)
-                    } else {
-                      qb2.andWhere(`INV.${keyval[prop]} ${itm[prop] == null ? 'is null' : " = '" + itm[prop] + "'"}`)
-                    }
-                  }
-                })
-              )
-            })
-          })
-        )
-      } else {
-        if (limit > 0) {
-          qb.orderBy('RANDOM()').limit(limit)
-        }
-      }
-
-      let inventories: Inventory[] = await qb.getMany()
-
-      if (!inventories.length) {
-        throw new Error(`Failed to find inventories`)
-      }
+  async generateCycleCountWorksheetCarton(
+    executionDate: string,
+    customerId: string,
+    cycleCountNo: string,
+    cartonIds: string[] = [],
+    batchIds: string[] = [],
+    productDetailIds: string[] = [],
+    locationNames: string[] = []
+  ): Promise<Worksheet> {
+    const customerBizplace: Bizplace = await this.trxMgr.getRepository(Bizplace).findOne(customerId)
 
-      let cycleCountWorksheet: Worksheet = new Worksheet()
-      cycleCountWorksheet.domain = this.domain
-      cycleCountWorksheet.bizplace = customerBizplace
-      cycleCountWorksheet.name = WorksheetNoGenerator.cycleCount()
-      cycleCountWorksheet.inventoryCheck = cycleCount
-      cycleCountWorksheet.type = WORKSHEET_TYPE.CYCLE_COUNT
-      cycleCountWorksheet.status = WORKSHEET_STATUS.DEACTIVATED
-      cycleCountWorksheet.creator = this.user
-      cycleCountWorksheet.updater = this.user
-      cycleCountWorksheet = await this.trxMgr.getRepository(Worksheet).save(cycleCountWorksheet)
-
-      // generate order inventory mapping with inventory ID
-      let targetInventories: OrderInventory[] = []
-      for (let i: number = 0; i < inventories.length; i++) {
-        const inventory: Inventory = inventories[i]
-
-        let targetInventory: OrderInventory = new OrderInventory()
-        targetInventory.domain = this.domain
-        targetInventory.bizplace = customerBizplace
-        targetInventory.status = ORDER_INVENTORY_STATUS.PENDING
-        targetInventory.name = OrderNoGenerator.orderInventory()
-        targetInventory.inventoryCheck = cycleCount
-        targetInventory.originQty = inventory.qty
-        targetInventory.originWeight = 0
-        targetInventory.originUomValue = inventory.uomValue
-        targetInventory.originBatchNo = inventory.batchId
-        targetInventory.originLocation = inventory.location
-        targetInventory.releaseQty = 0
-        targetInventory.releaseWeight = 0
-        targetInventory.releaseUomValue = 0
-        targetInventory.inventory = inventory
-        targetInventory.creator = this.user
-        targetInventory.updater = this.user
-        targetInventories.push(targetInventory)
-
-        inventory.lockedQty = inventory.qty
-        inventory.lockedWeight = 0
-        inventory.lockedUomValue = inventory.uomValue
-        inventory.updater = this.user
+    const foundInventoryCheck: InventoryCheck = await this.trxMgr.getRepository(InventoryCheck).findOne({
+      where: {
+        domain: this.domain,
+        bizplace: customerBizplace,
+        name: cycleCountNo
       }
+    })
 
-      targetInventories = await this.trxMgr.getRepository(OrderInventory).save(targetInventories, { chunk: 500 })
-
-      inventories = await this.trxMgr.getRepository(Inventory).save(inventories, { chunk: 500 })
-
-      let cycleCountWorksheetDetails: WorksheetDetail[] = []
-      for (let i: number = 0; i < targetInventories.length; i++) {
-        let targetInventory: OrderInventory = targetInventories[i]
+    const worksheetRepository = this.trxMgr.getRepository(Worksheet)
+    const foundCycleCountWorksheet: Worksheet | undefined = await worksheetRepository.findOne({
+      where: {
+        domain: this.domain,
+        bizplace: customerBizplace,
+        type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+        status: Not(WORKSHEET_STATUS.DONE)
+      },
+      order: {
+        checkCount: 'DESC'
+      },
+      relations: ['worksheetDetails', 'worksheetDetails.targetInventoryCheckItem', 'inventoryCheck']
+    })
 
-        let cycleCountWorksheetDetail: WorksheetDetail = new WorksheetDetail()
-        cycleCountWorksheetDetail.domain = this.domain
-        cycleCountWorksheetDetail.bizplace = customerBizplace
-        cycleCountWorksheetDetail.worksheet = cycleCountWorksheet
-        cycleCountWorksheetDetail.name = WorksheetNoGenerator.cycleCountDetail()
-        cycleCountWorksheetDetail.targetInventory = targetInventory
-        cycleCountWorksheetDetail.type = WORKSHEET_TYPE.CYCLE_COUNT
-        cycleCountWorksheetDetail.status = WORKSHEET_STATUS.DEACTIVATED
-        cycleCountWorksheetDetail.creator = this.user
-        cycleCountWorksheetDetail.updater = this.user
+    const qb = this.trxMgr.getRepository(InventoryCheckItem).createQueryBuilder('inventoryCheckItem')
+    qb.innerJoinAndSelect('inventoryCheckItem.inventory', 'inventory')
+      .innerJoinAndSelect('inventoryCheckItem.productDetail', 'productDetail')
+      .innerJoinAndSelect('inventoryCheckItem.originLocation', 'location')
+      .where('inventory.cartonId IN (:...cartonIds)', { cartonIds })
+      .andWhere('inventory.batchId IN (:...batchIds)', { batchIds })
+      .andWhere('productDetail.id IN (:...productDetailIds)', { productDetailIds })
+      .andWhere('location.name IN (:...locationNames)', { locationNames })
+      .andWhere('inventoryCheckItem.domain_id = :domainId', { domainId: this.domain.id })
+      .andWhere('inventoryCheckItem.bizplace_id = :bizplaceId', { bizplaceId: customerBizplace.id })
+      .andWhere('inventoryCheckItem.inventory_check_id = :inventoryCheckId', {
+        inventoryCheckId: foundInventoryCheck.id
+      })
 
-        cycleCountWorksheetDetails.push(cycleCountWorksheetDetail)
-      }
+    const inventoryCheckItems: InventoryCheckItem[] = await qb.getMany()
 
-      await this.trxMgr.getRepository(WorksheetDetail).save(cycleCountWorksheetDetails, { chunk: 500 })
+    const inventoryCheckItemIds = inventoryCheckItems.map(item => item.id)
 
-      return cycleCountWorksheet
+    if (inventoryCheckItemIds.length) {
+      return await this.createNextRoundCycleCountWorksheet(
+        customerId,
+        foundInventoryCheck,
+        executionDate,
+        foundCycleCountWorksheet,
+        inventoryCheckItemIds
+      )
     }
   }
 
@@ -212,18 +409,20 @@ export class CycleCountWorksheetController extends WorksheetController {
     let worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.CYCLE_COUNT, [
       'inventoryCheck',
       'worksheetDetails',
-      'worksheetDetails.targetInventory'
+      'worksheetDetails.targetInventoryCheckItem'
     ])
 
     let worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-    let targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+    let targetInventoryCheckItems: InventoryCheckItem[] = worksheetDetails.map(
+      (wsd: WorksheetDetail) => wsd.targetInventoryCheckItem
+    )
 
-    for (let i: number = 0; i < targetInventories.length; i++) {
-      let targetInventory: OrderInventory = targetInventories[i]
-      targetInventory.status = ORDER_INVENTORY_STATUS.INSPECTING
-      targetInventory.updater = this.user
+    for (let i: number = 0; i < targetInventoryCheckItems.length; i++) {
+      let targetInventoryCheckItem: InventoryCheckItem = targetInventoryCheckItems[i]
+      targetInventoryCheckItem.status = INVENTORY_CHECK_ITEM_STATUS.INSPECTING
+      targetInventoryCheckItem.updater = this.user
     }
-    await this.trxMgr.getRepository(OrderInventory).save(targetInventories, { chunk: 500 })
+    await this.trxMgr.getRepository(InventoryCheckItem).save(targetInventoryCheckItems, { chunk: 500 })
 
     for (let i: number = 0; i < worksheetDetails.length; i++) {
       let foundWSD: WorksheetDetail = worksheetDetails[i]
@@ -244,7 +443,7 @@ export class CycleCountWorksheetController extends WorksheetController {
     return worksheet
   }
 
-  async inspecting(
+  async inspectingPallet(
     worksheetDetailName: string,
     inspectedBatchNo: string,
     inspectedQty: number,
@@ -253,124 +452,312 @@ export class CycleCountWorksheetController extends WorksheetController {
     let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
       worksheetDetailName,
       WORKSHEET_TYPE.CYCLE_COUNT,
-      ['targetInventory', 'targetInventory.inventory', 'targetInventory.inventory.location']
+      ['targetInventoryCheckItem', 'targetInventoryCheckItem.inventory', 'targetInventoryCheckItem.inventory.location']
     )
 
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    const inventory: Inventory = targetInventory.inventory
-    const { batchId, qty, uomValue }: { batchId: string; qty: number; uomValue: number } = inventory
+    let targetInventoryCheckItem: InventoryCheckItem = worksheetDetail.targetInventoryCheckItem
+    const {
+      originBatchNo,
+      originQty,
+      originUomValue
+    }: { originBatchNo: string; originQty: number; originUomValue: number } = targetInventoryCheckItem
 
-    const isChanged: boolean = batchId !== inspectedBatchNo || qty !== inspectedQty || uomValue !== inspectedUomValue
+    const isChanged: boolean =
+      originBatchNo !== inspectedBatchNo || originQty !== inspectedQty || originUomValue !== inspectedUomValue
     const worksheetDetailStatus: string = isChanged ? WORKSHEET_STATUS.NOT_TALLY : WORKSHEET_STATUS.DONE
-    const targetInventoryStatus: string = isChanged
-      ? ORDER_INVENTORY_STATUS.NOT_TALLY
-      : ORDER_INVENTORY_STATUS.INSPECTED
+    const targetInventoryCheckItemStatus: string = isChanged
+      ? INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY
+      : INVENTORY_CHECK_ITEM_STATUS.INSPECTED
 
     worksheetDetail.status = worksheetDetailStatus
     worksheetDetail.updater = this.user
     await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
 
-    targetInventory.inspectedBatchNo = inspectedBatchNo
-    targetInventory.inspectedQty = inspectedQty
-    targetInventory.inspectedUomValue = inspectedUomValue
-    targetInventory.inspectedLocation = targetInventory.inventory.location
-    targetInventory.status = targetInventoryStatus
-    targetInventory.updater = this.user
-    await this.updateOrderTargets([targetInventory])
-
-    //If all tally, remove lockedQty, lockedWeight, lockedUomValue
-    if (!isChanged) {
-      inventory.lockedQty = 0
-      inventory.lockedWeight = 0
-      inventory.lockedUomValue = 0
-      inventory.updater = this.user
-      await this.trxMgr.getRepository(Inventory).save(inventory, { chunk: 500 })
+    targetInventoryCheckItem.inspectedBatchNo = inspectedBatchNo
+    targetInventoryCheckItem.inspectedQty = inspectedQty
+    targetInventoryCheckItem.inspectedUomValue = inspectedUomValue
+    targetInventoryCheckItem.inspectedLocation = targetInventoryCheckItem.inventory.location
+    targetInventoryCheckItem.status = targetInventoryCheckItemStatus
+    targetInventoryCheckItem.updater = this.user
+    await this.updateOrderTargets([targetInventoryCheckItem])
+  }
+
+  async inspectingCarton(
+    productDetailId: string,
+    cartonId: string,
+    batchId: string,
+    locationId: string,
+    inspectedBatchNo: string,
+    inspectedQty: number,
+    inspectedUomValue: number
+  ): Promise<void> {
+    const productDetail: ProductDetail = await this.trxMgr.getRepository(ProductDetail).findOne({
+      where: { id: productDetailId },
+      relations: ['product']
+    })
+
+    let qb: SelectQueryBuilder<Inventory> = this.trxMgr
+      .getRepository(Inventory)
+      .createQueryBuilder('inv')
+      .where('inv.product_detail_id = :productDetailId', { productDetailId })
+      .andWhere('inv.carton_id = :cartonId', { cartonId })
+      .andWhere('inv.batch_id = :batchId', { batchId })
+      .andWhere('inv.location_id = :locationId', { locationId })
+
+    let orderByField = 'created_at'
+    let orderByDirection: 'ASC' | 'DESC' = 'ASC'
+
+    switch (productDetail.product.pickingStrategy) {
+      case 'LIFO':
+        orderByDirection = 'DESC'
+        break
+      case 'FEFO':
+        orderByField = 'expiration_date'
+        break
+      case 'FMFO':
+        orderByField = 'manufacture_date'
+        break
+    }
+    qb.addOrderBy(`"inv"."${orderByField}"`, orderByDirection)
+
+    if (['FEFO', 'FMFO'].includes(productDetail.product.pickingStrategy)) {
+      qb.addOrderBy('"inv"."created_at"', 'ASC')
+    }
+
+    const inventories: Inventory[] = await qb.getMany()
+
+    const inventoryIds = inventories.map(inv => inv.id)
+    const inventoryCheckItems: InventoryCheckItem[] = await this.trxMgr
+      .getRepository(InventoryCheckItem)
+      .createQueryBuilder('inventoryCheckItem')
+      .leftJoinAndSelect('inventoryCheckItem.inventory', 'inventory')
+      .where('inventory.id IN (:...ids)', { ids: inventoryIds })
+      .andWhere('inventoryCheckItem.status = :status', { status: 'INSPECTING' })
+      .getMany()
+
+    const totalOriginQty = inventoryCheckItems.reduce((total, item) => total + (item.originQty || 0), 0)
+    const totalOriginUomValue = inventoryCheckItems.reduce((total, item) => total + (item.originUomValue || 0), 0)
+
+    const hasQtyDiscrepancy = totalOriginQty !== inspectedQty
+    const hasUomValueDiscrepancy = totalOriginUomValue !== inspectedUomValue
+
+    const hasBatchNoDiscrepancy = inventoryCheckItems.some(checkItem => checkItem.originBatchNo !== inspectedBatchNo)
+
+    const hasDiscrepancies = hasQtyDiscrepancy || hasUomValueDiscrepancy || hasBatchNoDiscrepancy
+
+    let inventoryCheckItemStatus
+    let worksheetDetailStatus
+
+    if (inventoryCheckItems.length > 1) {
+      inventoryCheckItemStatus = hasDiscrepancies
+        ? INVENTORY_CHECK_ITEM_STATUS.GROUP_NOT_TALLY
+        : INVENTORY_CHECK_ITEM_STATUS.INSPECTED
+      worksheetDetailStatus = hasDiscrepancies ? WORKSHEET_STATUS.NOT_TALLY : WORKSHEET_STATUS.DONE
+    } else {
+      inventoryCheckItemStatus = hasDiscrepancies
+        ? INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY
+        : INVENTORY_CHECK_ITEM_STATUS.INSPECTED
+      worksheetDetailStatus = hasDiscrepancies ? WORKSHEET_STATUS.NOT_TALLY : WORKSHEET_STATUS.DONE
+    }
+
+    let totalInspectedQty = inspectedQty
+    let totalInspectedUomValue = inspectedUomValue
+
+    for (const checkItem of inventoryCheckItems) {
+      const qtyToInspect = totalInspectedQty > 0 ? Math.min(totalInspectedQty, checkItem.originQty) : 0
+      const uomValueToInspect =
+        totalInspectedUomValue > 0 ? Math.min(totalInspectedUomValue, checkItem.originUomValue) : 0
+
+      checkItem.inspectedQty = (checkItem.inspectedQty ?? 0) + qtyToInspect
+      totalInspectedQty -= qtyToInspect
+
+      checkItem.inspectedUomValue = (checkItem.inspectedUomValue ?? 0) + uomValueToInspect
+      totalInspectedUomValue -= uomValueToInspect
+
+      checkItem.inspectedBatchNo = inspectedBatchNo
+      checkItem.inspectedLocation = checkItem.originLocationId
+      checkItem.status = inventoryCheckItemStatus
+      checkItem.updater = this.user
+
+      await this.trxMgr.getRepository(InventoryCheckItem).save(checkItem)
+
+      let worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
+        where: { targetInventoryCheckItem: checkItem.id, type: WORKSHEET_TYPE.CYCLE_COUNT }
+      })
+
+      if (worksheetDetail) {
+        worksheetDetail.status = worksheetDetailStatus
+        worksheetDetail.updater = this.user
+        await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+      }
+    }
+
+    if (totalInspectedQty > 0 && totalInspectedUomValue > 0 && inventoryCheckItems.length > 0) {
+      const lastItem = inventoryCheckItems[inventoryCheckItems.length - 1]
+      lastItem.inspectedQty = (lastItem.inspectedQty ?? 0) + totalInspectedQty
+      lastItem.inspectedUomValue = (lastItem.inspectedUomValue ?? 0) + totalInspectedUomValue
+      await this.trxMgr.getRepository(InventoryCheckItem).save(lastItem)
     }
   }
 
   async undoInspection(worksheetDetailName: string): Promise<void> {
     let worksheetDetail: WorksheetDetail = await this.findWorksheetDetail(
       { domain: this.domain, name: worksheetDetailName, status: Not(Equal(WORKSHEET_STATUS.EXECUTING)) },
-      ['targetInventory', 'targetInventory.inventory']
+      ['targetInventoryCheckItem', 'targetInventoryCheckItem.inventory']
     )
 
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    targetInventory.inspectedBatchNo = null
-    targetInventory.inspectedQty = null
-    targetInventory.inspectedWeight = null
-    targetInventory.inspectedUomValue = null
-    targetInventory.inspectedLocation = null
-    targetInventory.status =
-      targetInventory.status === ORDER_INVENTORY_STATUS.RELOCATED
-        ? ORDER_INVENTORY_STATUS.MISSING
-        : ORDER_INVENTORY_STATUS.INSPECTING
-    targetInventory.updater = this.user
-    await this.updateOrderTargets([targetInventory])
+    let targetInventoryCheckItem: InventoryCheckItem = worksheetDetail.targetInventoryCheckItem
+    targetInventoryCheckItem.inspectedBatchNo = null
+    targetInventoryCheckItem.inspectedQty = null
+    targetInventoryCheckItem.inspectedWeight = null
+    targetInventoryCheckItem.inspectedUomValue = null
+    targetInventoryCheckItem.inspectedLocation = null
+    targetInventoryCheckItem.status =
+      targetInventoryCheckItem.status === INVENTORY_CHECK_ITEM_STATUS.RELOCATED
+        ? INVENTORY_CHECK_ITEM_STATUS.MISSING
+        : INVENTORY_CHECK_ITEM_STATUS.INSPECTING
+    targetInventoryCheckItem.updater = this.user
+    await this.updateOrderTargets([targetInventoryCheckItem])
 
     worksheetDetail.status =
-      targetInventory.status === ORDER_INVENTORY_STATUS.MISSING
+      targetInventoryCheckItem.status === INVENTORY_CHECK_ITEM_STATUS.MISSING
         ? WORKSHEET_STATUS.NOT_TALLY
         : WORKSHEET_STATUS.EXECUTING
     worksheetDetail.updater = this.user
     await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+  }
+
+  async undoInspectionCarton(
+    productDetailId: string,
+    cartonId: string,
+    batchId: string,
+    locationId: string
+  ): Promise<void> {
+    let qb: SelectQueryBuilder<Inventory> = this.trxMgr.getRepository(Inventory).createQueryBuilder('inv')
+    qb.where('inv.product_detail_id = :productDetailId', { productDetailId })
+      .andWhere('inv.carton_id = :cartonId', { cartonId })
+      .andWhere('inv.batch_id = :batchId', { batchId })
+      .andWhere('inv.location_id = :locationId', { locationId })
+
+    const inventories: Inventory[] = await qb.getMany()
+
+    const inventoryCheckItems: InventoryCheckItem[] = await Promise.all(
+      inventories.map(inventory =>
+        this.trxMgr.getRepository(InventoryCheckItem).findOne({ where: { inventory: inventory.id } })
+      )
+    )
+
+    for (const checkItem of inventoryCheckItems) {
+      checkItem.inspectedBatchNo = null
+      checkItem.inspectedQty = null
+      checkItem.inspectedWeight = null
+      checkItem.inspectedUomValue = null
+      checkItem.inspectedLocation = null
+      checkItem.status = INVENTORY_CHECK_ITEM_STATUS.INSPECTING
+      checkItem.updater = this.user
+
+      let worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
+        where: { targetInventoryCheckItem: checkItem.id, type: WORKSHEET_TYPE.CYCLE_COUNT },
+        relations: ['targetInventoryCheckItem']
+      })
 
-    const inventory: Inventory = targetInventory.inventory
-    inventory.lockedQty = inventory.qty
-    inventory.lockedWeight = inventory.weight
-    inventory.lockedUomValue = inventory.uomValue
-    inventory.updater = this.user
-    await this.trxMgr.getRepository(Inventory).save(inventory, { chunk: 500 })
+      if (worksheetDetail) {
+        worksheetDetail.status = WORKSHEET_STATUS.EXECUTING
+        worksheetDetail.updater = this.user
+        await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+      }
+      await this.trxMgr.getRepository(InventoryCheckItem).save(checkItem)
+    }
   }
 
-  async checkMissingPallet(worksheetDetailName: string): Promise<void> {
+  async checkMissingInventory(worksheetDetailName: string): Promise<void> {
     let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
       worksheetDetailName,
       WORKSHEET_TYPE.CYCLE_COUNT,
-      ['targetInventory']
+      ['targetInventoryCheckItem']
     )
 
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
+    let targetInventoryCheckItem: InventoryCheckItem = worksheetDetail.targetInventoryCheckItem
     worksheetDetail.status = WORKSHEET_STATUS.NOT_TALLY
     worksheetDetail.updater = this.user
     await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
 
-    targetInventory.status = ORDER_INVENTORY_STATUS.MISSING
-    targetInventory.updater = this.user
-    await this.updateOrderTargets([targetInventory])
+    targetInventoryCheckItem.status = INVENTORY_CHECK_ITEM_STATUS.MISSING
+    targetInventoryCheckItem.updater = this.user
+    await this.updateOrderTargets([targetInventoryCheckItem])
   }
 
-  async addExtraPallet(
+  async checkMissingInventoryCarton(
+    productDetailId: string,
+    cartonId: string,
+    batchId: string,
+    locationId: string
+  ): Promise<void> {
+    let qb: SelectQueryBuilder<Inventory> = this.trxMgr.getRepository(Inventory).createQueryBuilder('inv')
+    qb.where('inv.product_detail_id = :productDetailId', { productDetailId })
+      .andWhere('inv.carton_id = :cartonId', { cartonId })
+      .andWhere('inv.batch_id = :batchId', { batchId })
+      .andWhere('inv.location_id = :locationId', { locationId })
+
+    const inventories: Inventory[] = await qb.getMany()
+
+    const inventoryCheckItems: InventoryCheckItem[] = await Promise.all(
+      inventories.map(inventory =>
+        this.trxMgr.getRepository(InventoryCheckItem).findOne({ where: { inventory: inventory.id } })
+      )
+    )
+
+    for (const checkItem of inventoryCheckItems) {
+      checkItem.inspectedBatchNo = null
+      checkItem.inspectedQty = null
+      checkItem.inspectedWeight = null
+      checkItem.inspectedUomValue = null
+      checkItem.inspectedLocation = null
+      checkItem.status = INVENTORY_CHECK_ITEM_STATUS.MISSING
+      checkItem.updater = this.user
+
+      let worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
+        where: { targetInventoryCheckItem: checkItem.id, type: WORKSHEET_TYPE.CYCLE_COUNT },
+        relations: ['targetInventoryCheckItem']
+      })
+
+      if (worksheetDetail) {
+        worksheetDetail.status = WORKSHEET_STATUS.NOT_TALLY
+        worksheetDetail.updater = this.user
+        await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+      }
+      await this.trxMgr.getRepository(InventoryCheckItem).save(checkItem)
+    }
+  }
+
+  async addExtraInventory(
     cycleCountNo: string,
-    palletId: string,
+    inspectedLocation: string,
+    productDetailId: string,
+    productId: string,
     inspectedBatchNo: string,
     inspectedQty: number,
     inspectedUomValue: number,
-    locationName: string
+    countNo: number
   ): Promise<void> {
+    let today = new Date(),
+      year = today.getFullYear(),
+      month = today.getMonth(),
+      date = today.getDate()
+
     const inventoryCheck: InventoryCheck = await this.findRefOrder(
       InventoryCheck,
       {
         name: cycleCountNo,
         status: ORDER_STATUS.INSPECTING
       },
-      ['bizplace']
+      ['bizplace', 'bizplace.domain']
     )
 
-    const bizplace: Bizplace = inventoryCheck.bizplace
-    const qb: SelectQueryBuilder<Inventory> = this.trxMgr.getRepository(Inventory).createQueryBuilder('INV')
-    let inventory: Inventory = await qb
-      .where('INV.domain = :domainId', { domainId: this.domain.id })
-      .andWhere('INV.bizplace = :bizplaceId', { bizplaceId: bizplace.id })
-      .andWhere('INV.palletId = :palletId', { palletId })
-      .andWhere('INV.status = :status', { status: INVENTORY_STATUS.STORED })
-      .andWhere(
-        new Brackets(qb => {
-          qb.where('INV.lockedQty ISNULL')
-          qb.orWhere('INV.lockedQty = 0')
-        })
-      )
-      .getOne()
-    if (!inventory) throw new Error('Failed to find inventory')
+    const bizplace: Bizplace = await this.trxMgr.getRepository(Bizplace).findOne({
+      where: { id: inventoryCheck.bizplace.id },
+      relations: ['domain']
+    })
 
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
@@ -381,31 +768,104 @@ export class CycleCountWorksheetController extends WorksheetController {
       }
     })
     const location: Location = await this.trxMgr.getRepository(Location).findOne({
-      where: { domain: this.domain, name: locationName }
+      where: { domain: this.domain, name: inspectedLocation },
+      relations: ['warehouse']
+    })
+
+    const productDetail: ProductDetail = await this.trxMgr.getRepository(ProductDetail).findOne({
+      where: { id: productDetailId }
+    })
+
+    const product: Product = await this.trxMgr.getRepository(Product).findOne({
+      where: { id: productId }
+    })
+
+    const total = await this.trxMgr.getRepository(Inventory).count({
+      createdAt: MoreThan(new Date(year, month, date))
+    })
+
+    const yy = String(year).substr(String(year).length - 2)
+    const mm = String(month + 1).padStart(2, '0')
+    const dd = String(date).padStart(2, '0')
+
+    const dateStr = yy + mm + dd
+
+    let newInventory: Partial<Inventory> = new Inventory()
+    newInventory.bizplace = bizplace
+    newInventory.domain = this.domain
+    newInventory.name = InventoryNoGenerator.inventoryName()
+    newInventory.palletId = await generateId({
+      domain: this.domain,
+      type: 'adjustment_pallet_id',
+      seed: {
+        batchId: inspectedBatchNo,
+        date: dateStr
+      }
     })
 
-    let targetInventory: OrderInventory = new OrderInventory()
-    targetInventory.domain = this.domain
-    targetInventory.bizplace = bizplace
-    targetInventory.status = ORDER_INVENTORY_STATUS.ADDED
-    targetInventory.name = OrderNoGenerator.orderInventory()
-    targetInventory.inventoryCheck = inventoryCheck
-    targetInventory.inventory = inventory
-    targetInventory.inspectedBatchNo = inspectedBatchNo
-    targetInventory.inspectedQty = inspectedQty
-    targetInventory.inspectedWeight = 0
-    targetInventory.inspectedUomValue = inspectedUomValue
-    targetInventory.inspectedLocation = location
-    targetInventory.creator = this.user
-    targetInventory.updater = this.user
-    await this.trxMgr.getRepository(OrderInventory).save(targetInventory)
+    const warehouseCartonSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+      where: { domain: this.domain, category: 'id-rule', name: 'enable-carton-label', value: true }
+    })
+
+    const partnerCartonSetting: PartnerSetting = await this.trxMgr.getRepository(PartnerSetting).findOne({
+      where: {
+        setting: warehouseCartonSetting,
+        domain: this.domain,
+        partnerDomain: inventoryCheck.bizplace?.domain,
+        value: true
+      }
+    })
+
+    if (partnerCartonSetting?.value || warehouseCartonSetting?.value) {
+      let cartonId = await generateId({
+        domain: this.domain,
+        type: 'adjustment_carton_id',
+        seed: { date: dateStr }
+      })
+      if (!cartonId) throw new Error('No adjustment carton id setting rule found')
+
+      newInventory.cartonId = cartonId
+    }
+    newInventory.batchId = inspectedBatchNo
+    newInventory.product = product
+    newInventory.productDetail = productDetail
+    newInventory.packingType = productDetail.packingType
+    newInventory.packingSize = productDetail.packingSize
+    newInventory.uom = productDetail.uom
+    newInventory.qty = inspectedQty
+    newInventory.uomValue = inspectedUomValue
+    newInventory.location = location
+    newInventory.warehouse = location.warehouse
+    newInventory.zone = location.zone
+    newInventory.status = INVENTORY_STATUS.CC_ADDED
+    newInventory.creator = this.user
+    newInventory.updater = this.user
+    await this.trxMgr.getRepository(Inventory).save(newInventory)
+
+    let targetInventoryCheckItem: InventoryCheckItem = new InventoryCheckItem()
+    targetInventoryCheckItem.domain = this.domain
+    targetInventoryCheckItem.bizplace = bizplace
+    targetInventoryCheckItem.status = INVENTORY_CHECK_ITEM_STATUS.ADDED
+    targetInventoryCheckItem.name = OrderNoGenerator.inventoryCheckItem()
+    targetInventoryCheckItem.inventoryCheck = inventoryCheck
+    targetInventoryCheckItem.inventory = newInventory
+    targetInventoryCheckItem.inspectedBatchNo = inspectedBatchNo
+    targetInventoryCheckItem.inspectedQty = inspectedQty
+    targetInventoryCheckItem.inspectedUomValue = inspectedUomValue
+    targetInventoryCheckItem.inspectedLocation = location
+    targetInventoryCheckItem.productDetail = productDetail
+    targetInventoryCheckItem.product = product
+    targetInventoryCheckItem.countNo = countNo
+    targetInventoryCheckItem.creator = this.user
+    targetInventoryCheckItem.updater = this.user
+    await this.trxMgr.getRepository(InventoryCheckItem).save(targetInventoryCheckItem)
 
     let worksheetDetail: WorksheetDetail = new WorksheetDetail()
     worksheetDetail.domain = this.domain
     worksheetDetail.bizplace = bizplace
     worksheetDetail.worksheet = worksheet
     worksheetDetail.name = WorksheetNoGenerator.cycleCountDetail()
-    worksheetDetail.targetInventory = targetInventory
+    worksheetDetail.targetInventoryCheckItem = targetInventoryCheckItem
     worksheetDetail.type = WORKSHEET_TYPE.CYCLE_COUNT
     worksheetDetail.status = WORKSHEET_STATUS.NOT_TALLY
     worksheetDetail.creator = this.user
@@ -413,7 +873,7 @@ export class CycleCountWorksheetController extends WorksheetController {
     await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
   }
 
-  async relocatePallet(
+  async relocateInventory(
     worksheetDetailName: string,
     inspectedBatchNo: string,
     inspectedQty: number,
@@ -422,13 +882,17 @@ export class CycleCountWorksheetController extends WorksheetController {
   ): Promise<void> {
     let worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
       where: { domain: this.domain, name: worksheetDetailName, type: WORKSHEET_TYPE.CYCLE_COUNT },
-      relations: ['targetInventory', 'targetInventory.inventory', 'targetInventory.inventory.location']
+      relations: [
+        'targetInventoryCheckItem',
+        'targetInventoryCheckItem.inventory',
+        'targetInventoryCheckItem.inventory.location'
+      ]
     })
 
     if (!worksheetDetail) throw new Error('Failed to find worksheet detail')
 
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    const location: Location = targetInventory?.inventory?.location
+    let targetInventoryCheckItem: InventoryCheckItem = worksheetDetail.targetInventoryCheckItem
+    const location: Location = targetInventoryCheckItem?.inventory?.location
     if (location.name === inspectedLocationName) throw new Error(`You can't relocate at same location`)
 
     const inspectedLocation: Location = await this.trxMgr.getRepository(Location).findOne({
@@ -439,14 +903,156 @@ export class CycleCountWorksheetController extends WorksheetController {
     worksheetDetail.updater = this.user
     await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
 
-    targetInventory.inspectedLocation = inspectedLocation
-    targetInventory.inspectedBatchNo = inspectedBatchNo
-    targetInventory.inspectedQty = inspectedQty
-    targetInventory.inspectedWeight = 0
-    targetInventory.inspectedUomValue = inspectedUomValue
-    targetInventory.status = ORDER_INVENTORY_STATUS.RELOCATED
-    targetInventory.updater = this.user
-    await this.updateOrderTargets([targetInventory])
+    targetInventoryCheckItem.inspectedLocation = inspectedLocation
+    targetInventoryCheckItem.inspectedBatchNo = inspectedBatchNo
+    targetInventoryCheckItem.inspectedQty = inspectedQty
+    targetInventoryCheckItem.inspectedWeight = 0
+    targetInventoryCheckItem.inspectedUomValue = inspectedUomValue
+    targetInventoryCheckItem.status = INVENTORY_CHECK_ITEM_STATUS.RELOCATED
+    targetInventoryCheckItem.updater = this.user
+    await this.updateOrderTargets([targetInventoryCheckItem])
+  }
+
+  async relocateInventoryCarton(
+    productDetailId: string,
+    cartonId: string,
+    batchId: string,
+    locationId: string,
+    inspectedBatchNo: string,
+    inspectedQty: number,
+    inspectedUomValue: number,
+    inspectedLocationName: string
+  ): Promise<void> {
+    const productDetail: ProductDetail = await this.trxMgr.getRepository(ProductDetail).findOne({
+      where: { id: productDetailId },
+      relations: ['product']
+    })
+
+    let qb: SelectQueryBuilder<Inventory> = this.trxMgr
+      .getRepository(Inventory)
+      .createQueryBuilder('inv')
+      .where('inv.product_detail_id = :productDetailId', { productDetailId })
+      .andWhere('inv.carton_id = :cartonId', { cartonId })
+      .andWhere('inv.batch_id = :batchId', { batchId })
+      .andWhere('inv.location_id = :locationId', { locationId })
+
+    let orderByField = 'created_at'
+    let orderByDirection: 'ASC' | 'DESC' = 'ASC'
+
+    switch (productDetail.product.pickingStrategy) {
+      case 'LIFO':
+        orderByDirection = 'DESC'
+        break
+      case 'FEFO':
+        orderByField = 'expiration_date'
+        break
+      case 'FMFO':
+        orderByField = 'manufacture_date'
+        break
+    }
+    qb.addOrderBy(`"inv"."${orderByField}"`, orderByDirection)
+
+    if (['FEFO', 'FMFO'].includes(productDetail.product.pickingStrategy)) {
+      qb.addOrderBy('"inv"."created_at"', 'ASC')
+    }
+
+    const inventories: Inventory[] = await qb.getMany()
+    if (inventories.length === 0) {
+      throw new Error('No inventories found.')
+    }
+
+    const location: Location = await this.trxMgr.getRepository(Location).findOne({
+      where: { id: locationId }
+    })
+    if (location.name === inspectedLocationName) {
+      throw new Error(`You can't relocate to the same location.`)
+    }
+
+    const inspectedLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+      where: { name: inspectedLocationName, domain: this.domain }
+    })
+    if (!inspectedLocation) {
+      throw new Error(`Inspected location "${inspectedLocationName}" not found.`)
+    }
+
+    const inventoryIds = inventories.map(inv => inv.id)
+    const inventoryCheckItems: InventoryCheckItem[] = await this.trxMgr
+      .getRepository(InventoryCheckItem)
+      .createQueryBuilder('inventoryCheckItem')
+      .leftJoinAndSelect('inventoryCheckItem.inventory', 'inventory')
+      .where('inventory.id IN (:...ids)', { ids: inventoryIds })
+      .andWhere('inventoryCheckItem.status = :status', { status: 'INSPECTING' })
+      .getMany()
+
+    if (inventoryCheckItems.length === 0) {
+      throw new Error('No inventory check items found.')
+    }
+
+    const totalOriginQty = inventoryCheckItems.reduce((total, item) => total + (item.originQty || 0), 0)
+    const totalOriginUomValue = inventoryCheckItems.reduce((total, item) => total + (item.originUomValue || 0), 0)
+
+    const hasQtyDiscrepancy = totalOriginQty !== inspectedQty
+    const hasUomValueDiscrepancy = totalOriginUomValue !== inspectedUomValue
+
+    const hasBatchNoDiscrepancy = inventoryCheckItems.some(checkItem => checkItem.originBatchNo !== inspectedBatchNo)
+
+    const hasLocationDiscrepancy = inventoryCheckItems.some(
+      checkItem => checkItem.originLocationId !== inspectedLocation.id
+    )
+
+    const hasDiscrepancies =
+      hasQtyDiscrepancy || hasUomValueDiscrepancy || hasBatchNoDiscrepancy || hasLocationDiscrepancy
+
+    let inventoryCheckItemStatus, worksheetDetailStatus
+
+    if (inventoryCheckItems.length > 1) {
+      inventoryCheckItemStatus = hasDiscrepancies
+        ? INVENTORY_CHECK_ITEM_STATUS.RELOCATED
+        : INVENTORY_CHECK_ITEM_STATUS.INSPECTED
+      worksheetDetailStatus = hasDiscrepancies ? WORKSHEET_STATUS.NOT_TALLY : WORKSHEET_STATUS.DONE
+    } else {
+      inventoryCheckItemStatus = hasDiscrepancies
+        ? INVENTORY_CHECK_ITEM_STATUS.RELOCATED
+        : INVENTORY_CHECK_ITEM_STATUS.INSPECTED
+      worksheetDetailStatus = hasDiscrepancies ? WORKSHEET_STATUS.NOT_TALLY : WORKSHEET_STATUS.DONE
+    }
+
+    let totalInspectedQty = inspectedQty
+    let totalInspectedUomValue = inspectedUomValue
+
+    for (const checkItem of inventoryCheckItems) {
+      const qtyToInspect = totalInspectedQty > 0 ? Math.min(totalInspectedQty, checkItem.originQty) : 0
+      const uomValueToInspect =
+        totalInspectedUomValue > 0 ? Math.min(totalInspectedUomValue, checkItem.originUomValue) : 0
+      checkItem.inspectedQty = (checkItem.inspectedQty ?? 0) + qtyToInspect
+      totalInspectedQty -= qtyToInspect
+      checkItem.inspectedUomValue = (checkItem.inspectedUomValue ?? 0) + uomValueToInspect
+      totalInspectedUomValue -= uomValueToInspect
+
+      checkItem.inspectedBatchNo = inspectedBatchNo
+      checkItem.inspectedLocation = inspectedLocation
+      checkItem.status = inventoryCheckItemStatus
+      checkItem.updater = this.user
+
+      await this.trxMgr.getRepository(InventoryCheckItem).save(checkItem)
+
+      let worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
+        where: { targetInventoryCheckItem: checkItem.id, type: WORKSHEET_TYPE.CYCLE_COUNT }
+      })
+
+      if (worksheetDetail) {
+        worksheetDetail.status = worksheetDetailStatus
+        worksheetDetail.updater = this.user
+        await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+      }
+    }
+
+    if (totalInspectedQty > 0 && totalInspectedUomValue > 0 && inventoryCheckItems.length > 0) {
+      const lastItem = inventoryCheckItems[inventoryCheckItems.length - 1]
+      lastItem.inspectedQty = (lastItem.inspectedQty ?? 0) + totalInspectedQty
+      lastItem.inspectedUomValue = (lastItem.inspectedUomValue ?? 0) + totalInspectedUomValue
+      await this.trxMgr.getRepository(InventoryCheckItem).save(lastItem)
+    }
   }
 
   async completeCycleCount(inventoryCheckNo: string): Promise<Worksheet> {
@@ -462,51 +1068,53 @@ export class CycleCountWorksheetController extends WorksheetController {
         type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
         inventoryCheck
       },
-      relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
+      relations: [
+        'worksheetDetails',
+        'worksheetDetails.targetInventoryCheckItem',
+        'worksheetDetails.targetInventoryCheckItem.inventory'
+      ]
     })
     this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
 
     const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-    const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+    const targetInventoryCheckItems: InventoryCheckItem[] = worksheetDetails.map(
+      (wsd: WorksheetDetail) => wsd.targetInventoryCheckItem
+    )
 
     const {
-      tallyTargetInventories,
-      notTallyTargetInventories
+      tallyTargetInventoryCheckItems,
+      notTallyTargetInventoryCheckItems
     }: {
-      tallyTargetInventories: OrderInventory[]
-      notTallyTargetInventories: OrderInventory[]
-    } = targetInventories.reduce(
-      (result, targetInventory: OrderInventory) => {
-        if (targetInventory.status !== ORDER_INVENTORY_STATUS.INSPECTED) {
-          result.notTallyTargetInventories.push(targetInventory)
+      tallyTargetInventoryCheckItems: InventoryCheckItem[]
+      notTallyTargetInventoryCheckItems: InventoryCheckItem[]
+    } = targetInventoryCheckItems.reduce(
+      (result, targetInventoryCheckItem: InventoryCheckItem) => {
+        if (targetInventoryCheckItem.status !== INVENTORY_CHECK_ITEM_STATUS.INSPECTED) {
+          result.notTallyTargetInventoryCheckItems.push(targetInventoryCheckItem)
         } else {
-          result.tallyTargetInventories.push(targetInventory)
+          result.tallyTargetInventoryCheckItems.push(targetInventoryCheckItem)
         }
 
         return result
       },
       {
-        tallyTargetInventories: [],
-        notTallyTargetInventories: []
+        tallyTargetInventoryCheckItems: [],
+        notTallyTargetInventoryCheckItems: []
       }
     )
 
-    const tallyInventories: Inventory[] = tallyTargetInventories.map(targetInventory => targetInventory.inventory)
-    tallyTargetInventories.forEach((targetInventory: OrderInventory) => {
-      targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
-      targetInventory.updater = this.user
+    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(OrderInventory).save(tallyTargetInventories, { chunk: 500 })
+    await this.trxMgr.getRepository(InventoryCheckItem).save(tallyTargetInventoryCheckItems, { chunk: 500 })
 
-    tallyInventories.forEach((inventory: Inventory) => {
-      inventory.lockedQty = 0
-      inventory.lockedWeight = 0
-      inventory.lockedUomValue = 0
-      inventory.updater = this.user
-    })
     await this.trxMgr.getRepository(Inventory).save(tallyInventories, { chunk: 500 })
 
-    if (notTallyTargetInventories.length) {
+    if (notTallyTargetInventoryCheckItems.length) {
       worksheet.status = WORKSHEET_STATUS.NOT_TALLY
       inventoryCheck.status = ORDER_STATUS.PENDING_REVIEW
     } else {