@things-factory/worksheet-base 4.3.356 → 4.3.358

package/server/controllers/outbound/picking-worksheet-controller.ts

@@ -28,6 +28,7 @@ import {
   ORDER_INVENTORY_STATUS,
   ORDER_PRODUCT_STATUS,
   ORDER_STATUS,
+  INVENTORY_CHECK_ITEM_STATUS,
   ORDER_TYPES,
   OrderInventory,
   OrderNoGenerator,
@@ -37,7 +38,8 @@ import {
   OrderToteSeal,
   OrderVas,
   PowrupController,
-  ReleaseGood
+  ReleaseGood,
+  InventoryCheckItem
 } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
@@ -750,6 +752,29 @@ export class PickingWorksheetController extends VasWorksheetController {
       let pickedUomValue = pickedQty * productDetail.uomValue
       let matchingProduct
 
+      // validation to prevent picking if the inventory is involved in cycle count
+      let inventoryCheckItem: InventoryCheckItem = await this.trxMgr.getRepository(InventoryCheckItem).findOne({
+        where: {
+          domain: this.domain,
+          inventory: inventory.id,
+          status: In([
+            INVENTORY_CHECK_ITEM_STATUS.PENDING,
+            INVENTORY_CHECK_ITEM_STATUS.INSPECTING,
+            INVENTORY_CHECK_ITEM_STATUS.INSPECTED,
+            INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY,
+            INVENTORY_CHECK_ITEM_STATUS.GROUP_NOT_TALLY,
+            INVENTORY_CHECK_ITEM_STATUS.MISSING,
+            INVENTORY_CHECK_ITEM_STATUS.ADDED
+          ])
+        }
+      })
+
+      if (inventoryCheckItem) {
+        throw new Error(
+          `Inventory currently involved in an ongoing cycle count. Please complete the cycle count to proceed with picking.`
+        )
+      }
+
       //validation to prevent duplicated picking
       if (targetInventory?.status != ORDER_INVENTORY_STATUS.PICKING)
         throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`))
@@ -1018,6 +1043,29 @@ export class PickingWorksheetController extends VasWorksheetController {
       let targetProduct: OrderProduct = targetInventory.orderProduct
       let bizplace: Bizplace = worksheetDetail.worksheet.bizplace
 
+      // validation to prevent picking if the inventory is involved in cycle count
+      let inventoryCheckItem: InventoryCheckItem = await this.trxMgr.getRepository(InventoryCheckItem).findOne({
+        where: {
+          domain: this.domain,
+          inventory: inventory.id,
+          status: In([
+            INVENTORY_CHECK_ITEM_STATUS.PENDING,
+            INVENTORY_CHECK_ITEM_STATUS.INSPECTING,
+            INVENTORY_CHECK_ITEM_STATUS.INSPECTED,
+            INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY,
+            INVENTORY_CHECK_ITEM_STATUS.GROUP_NOT_TALLY,
+            INVENTORY_CHECK_ITEM_STATUS.MISSING,
+            INVENTORY_CHECK_ITEM_STATUS.ADDED
+          ])
+        }
+      })
+
+      if (inventoryCheckItem) {
+        throw new Error(
+          `Inventory currently involved in an ongoing cycle count. Please complete the cycle count to proceed with picking.`
+        )
+      }
+
       //validation to prevent duplicated picking
       let oiValidate: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
         where: { domain: this.domain, id: targetInventory.id, status: ORDER_INVENTORY_STATUS.PICKING }
@@ -1202,6 +1250,29 @@ export class PickingWorksheetController extends VasWorksheetController {
         where: { domain: this.domain, id: targetInventory.inventory.id }
       })
 
+      // validation to prevent picking if the inventory is involved in cycle count
+      let inventoryCheckItem: InventoryCheckItem = await this.trxMgr.getRepository(InventoryCheckItem).findOne({
+        where: {
+          domain: this.domain,
+          inventory: inventory.id,
+          status: In([
+            INVENTORY_CHECK_ITEM_STATUS.PENDING,
+            INVENTORY_CHECK_ITEM_STATUS.INSPECTING,
+            INVENTORY_CHECK_ITEM_STATUS.INSPECTED,
+            INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY,
+            INVENTORY_CHECK_ITEM_STATUS.GROUP_NOT_TALLY,
+            INVENTORY_CHECK_ITEM_STATUS.MISSING,
+            INVENTORY_CHECK_ITEM_STATUS.ADDED
+          ])
+        }
+      })
+
+      if (inventoryCheckItem) {
+        throw new Error(
+          `Inventory currently involved in an ongoing cycle count. Please complete the cycle count to proceed with picking.`
+        )
+      }
+
       const releaseGood: ReleaseGood = targetInventory.releaseGood
 
       if (inventory.palletId !== palletId)
@@ -1365,6 +1436,29 @@ export class PickingWorksheetController extends VasWorksheetController {
         const releaseGood: ReleaseGood = targetInventory.releaseGood
         if (pickedQty <= 0) break
 
+        // validation to prevent picking if the inventory is involved in cycle count
+        let inventoryCheckItem: InventoryCheckItem = await this.trxMgr.getRepository(InventoryCheckItem).findOne({
+          where: {
+            domain: this.domain,
+            inventory: inventory.id,
+            status: In([
+              INVENTORY_CHECK_ITEM_STATUS.PENDING,
+              INVENTORY_CHECK_ITEM_STATUS.INSPECTING,
+              INVENTORY_CHECK_ITEM_STATUS.INSPECTED,
+              INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY,
+              INVENTORY_CHECK_ITEM_STATUS.GROUP_NOT_TALLY,
+              INVENTORY_CHECK_ITEM_STATUS.MISSING,
+              INVENTORY_CHECK_ITEM_STATUS.ADDED
+            ])
+          }
+        })
+
+        if (inventoryCheckItem) {
+          throw new Error(
+            `Inventory currently involved in an ongoing cycle count. Please complete the cycle count to proceed with picking.`
+          )
+        }
+
         if (
           targetInventory.status === ORDER_INVENTORY_STATUS.PICKING &&
           targetReleaseQty > targetPickedQty &&

package/server/controllers/worksheet-controller.ts

@@ -24,6 +24,7 @@ import {
   ArrivalNotice,
   DeliveryOrder,
   InventoryCheck,
+  InventoryCheckItem,
   ORDER_INVENTORY_STATUS,
   ORDER_PRODUCT_STATUS,
   ORDER_VAS_STATUS,
@@ -62,7 +63,7 @@ export type ReferenceOrderType =
   | DeliveryOrder
   | ReturnOrder
   | Replenishment
-export type OrderTargetTypes = OrderProduct | OrderInventory | OrderVas
+export type OrderTargetTypes = OrderProduct | OrderInventory | OrderVas | InventoryCheckItem
 
 export enum ReferenceOrderFields {
   ArrivalNotice = 'arrivalNotice',
@@ -76,7 +77,8 @@ export enum ReferenceOrderFields {
 export enum OrderTargetFields {
   OrderProduct = 'targetProduct',
   OrderInventory = 'targetInventory',
-  OrderVas = 'targetVas'
+  OrderVas = 'targetVas',
+  InventoryCheckItem = 'targetInventoryCheckItem'
 }
 
 export interface BasicInterface {
@@ -168,6 +170,8 @@ export class WorksheetController {
       return OrderTargetFields.OrderInventory
     } else if (orderTarget instanceof OrderVas) {
       return OrderTargetFields.OrderVas
+    } else if (orderTarget instanceof InventoryCheckItem) {
+      return OrderTargetFields.InventoryCheckItem
     } else {
       this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('orderTarget', 'One of order target type', orderTarget)
     }
@@ -591,9 +595,9 @@ export class WorksheetController {
   }
 
   /**
-   * @summary Update order targets (OrderProduct, OrderInventory, OrderVas)
+   * @summary Update order targets (OrderProduct, OrderInventory, OrderVas, InventoryCheckItem)
    * @description
-   * Update order targets like (OrderProduct, OrderInventory, OrderVas)
+   * Update order targets like (OrderProduct, OrderInventory, OrderVas, InventoryCheckItem)
    */
   async updateOrderTargets(orderTargets: OrderTargetTypes[], entitySchema?: EntitySchema): Promise<any> {
     if (orderTargets.some((orderTarget: any) => !orderTarget.id)) throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS)
@@ -609,6 +613,8 @@ export class WorksheetController {
         entitySchema = OrderInventory
       } else if (orderTargets[0] instanceof OrderVas) {
         entitySchema = OrderVas
+      } else if (orderTargets[0] instanceof InventoryCheckItem) {
+        entitySchema = InventoryCheckItem
       }
     }
 

package/server/entities/worksheet-detail.ts

@@ -1,6 +1,6 @@
 import { User } from '@things-factory/auth-base'
 import { Bizplace, Worker } from '@things-factory/biz-base'
-import { OrderInventory, OrderProduct, OrderVas } from '@things-factory/sales-base'
+import { OrderInventory, OrderProduct, OrderVas, InventoryCheckItem } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Location } from '@things-factory/warehouse-base'
 import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
@@ -12,15 +12,9 @@ import { Worksheet } from './worksheet'
   (worksheetDetail: WorksheetDetail) => [worksheetDetail.domain, worksheetDetail.bizplace, worksheetDetail.name],
   { unique: true }
 )
-@Index(
-  'ix_worksheet-detail_1',
-  (worksheetDetail: WorksheetDetail) => [worksheetDetail.targetInventory]
-)
-@Index(
-  'ix_worksheet-detail_2',
-  (worksheetDetail: WorksheetDetail) => [worksheetDetail.id],
-  { unique: true }
-)
+@Index('ix_worksheet-detail_1', (worksheetDetail: WorksheetDetail) => [worksheetDetail.targetInventory])
+@Index('ix_worksheet-detail_2', (worksheetDetail: WorksheetDetail) => [worksheetDetail.id], { unique: true })
+@Index('ix_worksheet-detail_3', (worksheetDetail: WorksheetDetail) => [worksheetDetail.targetInventoryCheckItem])
 export class WorksheetDetail {
   @PrimaryGeneratedColumn('uuid')
   id: string
@@ -78,6 +72,9 @@ export class WorksheetDetail {
   @ManyToOne(type => Location)
   toLocation: Location
 
+  @ManyToOne(type => InventoryCheckItem)
+  targetInventoryCheckItem: InventoryCheckItem
+
   @Column({
     nullable: true
   })

package/server/entities/worksheet.ts

@@ -90,6 +90,9 @@ export class Worksheet {
   @Column({ nullable: true })
   endedAt: Date
 
+  @Column({ nullable: true })
+  checkCount: number
+
   @ManyToOne(type => User, { nullable: true })
   creator: User
 

package/server/graphql/resolvers/worksheet/check-stock-take-current-location.ts

@@ -1,7 +1,7 @@
 import { Domain } from '@things-factory/shell'
 import { getRepository, Repository } from 'typeorm'
 import { Inventory } from '@things-factory/warehouse-base'
-import { InventoryCheck, OrderInventory } from '@things-factory/sales-base'
+import { InventoryCheck, InventoryCheckItem } from '@things-factory/sales-base'
 import { WorksheetDetail } from '../../../entities'
 
 export const checkStockTakeCurrentLocationResolver = {
@@ -16,29 +16,33 @@ export const checkStockTakeCurrentLocationResolver = {
         where: { domain, palletId },
         relations: ['bizplace']
       })
-
+      // need to change InventoryCheckItem
       const cycleCount: InventoryCheck = await inventoryCheckRepo.findOne({
         where: { domain, name: cycleCountNo },
         relations: [
-          'orderInventories',
-          'orderInventories.inventory',
-          'orderInventories.inventory.location',
-          'orderInventories.inventory.product'
+          'inventoryCheckItems',
+          'inventoryCheckItems.inventory',
+          'inventoryCheckItems.inventory.location',
+          'inventoryCheckItems.inventory.product'
         ]
       })
 
-      const orderInventories: OrderInventory[] = cycleCount.orderInventories
+      if (!cycleCount) {
+        throw new Error('Cycle count not found')
+      }
+
+      const inventoryCheckItems: InventoryCheckItem[] = cycleCount.inventoryCheckItems
 
-      const foundInventory: Inventory = orderInventories.find(
-        (oi: OrderInventory) => oi.inventory.palletId === inventory.palletId
+      const foundInventory: Inventory = inventoryCheckItems.find(
+        (ici: InventoryCheckItem) => ici.inventory.palletId === inventory.palletId
       )?.inventory
 
       const foundWSD: any[] = await Promise.all(
-        orderInventories
-          .filter((oi: OrderInventory) => oi.inventory.palletId === inventory.palletId)
-          .map(async (oi: OrderInventory) => {
+        inventoryCheckItems
+          .filter((ici: InventoryCheckItem) => ici.inventory.palletId === inventory.palletId)
+          .map(async (ici: InventoryCheckItem) => {
             const matchingWSD = await worksheetDetailRepo.findOne({
-              where: { domain, targetInventory: oi }
+              where: { domain, targetInventoryCheckItem: ici }
             })
 
             return matchingWSD
@@ -50,6 +54,7 @@ export const checkStockTakeCurrentLocationResolver = {
       return {
         worksheetDetailName: foundWSD[0].name,
         currentLocation: foundInventory.location.name,
+        cartonId: foundInventory.cartonId,
         palletId: foundInventory.palletId,
         batchId: foundInventory.batchId,
         qty: foundInventory.qty,
@@ -58,6 +63,8 @@ export const checkStockTakeCurrentLocationResolver = {
         productName: foundInventory.product.name,
         productDescription: foundInventory.product.description
       }
-    } catch (e) {}
+    } catch (e) {
+      console.error(e)
+    }
   }
 }

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

@@ -4,10 +4,11 @@ import { Application, ApplicationType, User } from '@things-factory/auth-base'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import {
   InventoryCheck,
+  InventoryCheckItem,
   ORDER_INVENTORY_STATUS,
   ORDER_STATUS,
-  OrderInventory,
-  PowrupController
+  PowrupController,
+  INVENTORY_CHECK_ITEM_STATUS
 } from '@things-factory/sales-base'
 
 import { Domain } from '@things-factory/shell'
@@ -16,19 +17,23 @@ import {
   INVENTORY_STATUS,
   INVENTORY_TRANSACTION_TYPE,
   Location,
-  generateInventoryHistory
+  generateInventoryHistory,
+  InventoryNoGenerator,
+  InventoryHistory
 } from '@things-factory/warehouse-base'
 import { Bizplace, getCompanyBizplace } from '@things-factory/biz-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 { SellercraftController } from '../../../controllers'
+import { SellercraftController, WorksheetController } from '../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { switchLocationStatus } from '../../../utils'
 
 export const cycleCountAdjustmentResolver = {
-  async cycleCountAdjustment(_: any, { cycleCountNo }, context: any) {
+  async cycleCountAdjustment(_: any, { worksheetNo, cycleCountNo }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await cycleCountAdjustment(tx, domain, user, cycleCountNo)
+    await cycleCountAdjustment(tx, domain, user, worksheetNo, cycleCountNo)
   }
 }
 
@@ -36,20 +41,21 @@ export async function cycleCountAdjustment(
   tx: EntityManager,
   domain: Domain,
   user: User,
+  worksheetNo: string,
   cycleCountNo: string
 ): Promise<void> {
   // get cycle count no
   const cycleCount: InventoryCheck = await tx.getRepository(InventoryCheck).findOne({
     where: {
       domain,
-      name: cycleCountNo,
-      status: ORDER_STATUS.PENDING_REVIEW
+      name: cycleCountNo
     }
   })
 
   let worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
     where: {
       domain,
+      name: worksheetNo,
       type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
       inventoryCheck: cycleCount
     }
@@ -64,36 +70,37 @@ export async function cycleCountAdjustment(
       status: WORKSHEET_STATUS.NOT_TALLY
     },
     relations: [
-      'targetInventory',
-      'targetInventory.inventory',
-      'targetInventory.inventory.product',
-      'targetInventory.inventory.productDetail',
-      'targetInventory.inventory.product.productDetails',
-      'targetInventory.inventory.product.productDetails.childProductDetail',
-      'targetInventory.inventory.bizplace',
-      'targetInventory.inventory.domain',
-      'targetInventory.inventory.bizplace.domain',
-      'targetInventory.inventory.warehouse',
-      'targetInventory.inventory.location',
-      'targetInventory.inspectedLocation',
-      'targetInventory.inspectedLocation.warehouse'
+      'targetInventoryCheckItem',
+      'targetInventoryCheckItem.inventoryCheck',
+      'targetInventoryCheckItem.inventory',
+      'targetInventoryCheckItem.inventory.product',
+      'targetInventoryCheckItem.inventory.productDetail',
+      'targetInventoryCheckItem.inventory.product.productDetails',
+      'targetInventoryCheckItem.inventory.product.productDetails.childProductDetail',
+      'targetInventoryCheckItem.inventory.bizplace',
+      'targetInventoryCheckItem.inventory.domain',
+      'targetInventoryCheckItem.inventory.bizplace.domain',
+      'targetInventoryCheckItem.inventory.warehouse',
+      'targetInventoryCheckItem.inventory.location',
+      'targetInventoryCheckItem.inspectedLocation',
+      'targetInventoryCheckItem.inspectedLocation.warehouse'
     ]
   })
 
   for (let worksheetDetail of worksheetDetails) {
-    const targetInventory: OrderInventory = worksheetDetail.targetInventory
-    let inventory: Inventory = targetInventory.inventory
+    const targetInventoryCheckItem: InventoryCheckItem = worksheetDetail.targetInventoryCheckItem
+    let inventory: Inventory = targetInventoryCheckItem.inventory
 
-    let transactQty: number = targetInventory.inspectedQty - inventory.qty
-    let transactUomValue: number = targetInventory.inspectedUomValue - inventory.uomValue
+    let transactQty: number = targetInventoryCheckItem.inspectedQty - inventory.qty
+    let transactUomValue: number = targetInventoryCheckItem.inspectedUomValue - inventory.uomValue
 
     const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
       where: { domain: inventory.bizplace.domain, status: SellercraftStatus.ACTIVE },
       relations: ['domain']
     })
 
-    const customerDomain: Domain = targetInventory.inventory.bizplace.domain
-    const customerBizplaceId: string = targetInventory.inventory.bizplace.id
+    const customerDomain: Domain = targetInventoryCheckItem.inventory.bizplace.domain
+    const customerBizplaceId: string = targetInventoryCheckItem.inventory.bizplace.id
     const companyBizplace: Bizplace = await getCompanyBizplace(domain, null, customerBizplaceId, tx)
     const application: Application = await tx.getRepository(Application).findOne({
       domain: companyBizplace.domain,
@@ -101,7 +108,7 @@ export async function cycleCountAdjustment(
       type: ApplicationType.POWRUP
     })
 
-    if (targetInventory.status === ORDER_INVENTORY_STATUS.MISSING) {
+    if (targetInventoryCheckItem.status === ORDER_INVENTORY_STATUS.MISSING) {
       // create STORED, CC_ADJUSTMENT history
       await generateInventoryHistory(
         inventory,
@@ -133,7 +140,7 @@ export async function cycleCountAdjustment(
         const powrupController: PowrupController = new PowrupController()
         powrupController.updateStock([inventory], customerDomain, user, tx)
       }
-    } else if (targetInventory.inspectedQty == 0) {
+    } else if (targetInventoryCheckItem.inspectedQty == 0) {
       // create STORED, CC_ADJUSTMENT history
       await generateInventoryHistory(
         inventory,
@@ -146,13 +153,13 @@ export async function cycleCountAdjustment(
       )
 
       // change inventory qty to 0 and terminate it
-      inventory.batchId = targetInventory.inspectedBatchNo
-      inventory.qty = targetInventory.inspectedQty
+      inventory.batchId = targetInventoryCheckItem.inspectedBatchNo
+      inventory.qty = targetInventoryCheckItem.inspectedQty
       inventory.lockedQty = 0
-      inventory.uomValue = targetInventory.inspectedUomValue
+      inventory.uomValue = targetInventoryCheckItem.inspectedUomValue
       inventory.lockedUomValue = 0
-      inventory.location = targetInventory.inspectedLocation
-      inventory.warehouse = targetInventory.inspectedLocation.warehouse
+      inventory.location = targetInventoryCheckItem.inspectedLocation
+      inventory.warehouse = targetInventoryCheckItem.inspectedLocation.warehouse
       inventory.status = INVENTORY_STATUS.TERMINATED
       inventory.updater = user
       inventory = await tx.getRepository(Inventory).save(inventory)
@@ -169,10 +176,52 @@ export async function cycleCountAdjustment(
         const powrupController: PowrupController = new PowrupController()
         powrupController.updateStock([inventory], customerDomain, user, tx)
       }
+    } else if (targetInventoryCheckItem.status === INVENTORY_CHECK_ITEM_STATUS.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.status = INVENTORY_STATUS.STORED
+        inventory.creator = user
+        inventory.updater = user
+        await tx.getRepository(Inventory).save(inventory)
+
+        await tx.getRepository(InventoryHistory).save({
+          ...targetInventoryCheckItem,
+          seq: inventory.lastSeq,
+          refOrderId: targetInventoryCheckItem.inventoryCheckId,
+          orderNo: targetInventoryCheckItem.inventoryCheck.name,
+          name: InventoryNoGenerator.inventoryHistoryName(),
+          palletId: inventory.palletId,
+          batchId: inventory.batchId,
+          zone: inventory.zone,
+          packingType: inventory.packingType,
+          qty: inventory.qty || 0,
+          openingQty: 0,
+          uomValue: inventory.uomValue || 0,
+          openingUomValue: 0,
+          status: inventory.status,
+          transactionType: INVENTORY_TRANSACTION_TYPE.CC_ADJUSTMENT,
+          createdAt: inventory.createdAt,
+          updatedAt: inventory.updatedAt,
+          domain: domain,
+          bizplace: targetInventoryCheckItem.inventory.bizplace,
+          inventory: inventory.id,
+          cartonId: inventory.cartonId,
+          creator: user,
+          updater: user,
+          product: targetInventoryCheckItem.inventory.product,
+          productDetail: targetInventoryCheckItem.inventory.productDetail,
+          packingSize: inventory.packingSize,
+          warehouse: targetInventoryCheckItem.inventory.warehouse,
+          location: targetInventoryCheckItem.inventory.location
+        })
+      }
     } else {
       const prevLocationId: string = inventory.location.id
 
-      if (targetInventory.inspectedBatchNo !== inventory.batchId) {
+      if (targetInventoryCheckItem.inspectedBatchNo !== inventory.batchId) {
         // generate TERMINATED, ADJUSTMENT history
         const { qty, uomValue }: { qty: number; uomValue: number } = inventory
         inventory.status = INVENTORY_STATUS.TERMINATED
@@ -189,22 +238,20 @@ export async function cycleCountAdjustment(
           tx
         )
 
-        transactQty = targetInventory.inspectedQty
-        transactUomValue = targetInventory.inspectedUomValue
+        transactQty = targetInventoryCheckItem.inspectedQty
+        transactUomValue = targetInventoryCheckItem.inspectedUomValue
       }
 
-      inventory.batchId = targetInventory.inspectedBatchNo
-      inventory.qty = targetInventory.inspectedQty
-      inventory.lockedQty = 0
-      inventory.uomValue = targetInventory.inspectedUomValue
-      inventory.lockedUomValue = 0
-      inventory.location = targetInventory.inspectedLocation
-      inventory.warehouse = targetInventory.inspectedLocation.warehouse
+      inventory.batchId = targetInventoryCheckItem.inspectedBatchNo
+      inventory.qty = targetInventoryCheckItem.inspectedQty
+      inventory.uomValue = targetInventoryCheckItem.inspectedUomValue
+      inventory.location = targetInventoryCheckItem.inspectedLocation || inventory.location
+      inventory.warehouse = targetInventoryCheckItem.inspectedLocation.warehouse || inventory.warehouse
       inventory.status = INVENTORY_STATUS.STORED
       inventory.updater = user
       inventory = await tx.getRepository(Inventory).save(inventory)
 
-      if (prevLocationId !== targetInventory.inspectedLocation.id) {
+      if (prevLocationId !== targetInventoryCheckItem.inspectedLocation.id) {
         const prevLocation: Location = await tx.getRepository(Location).findOne(prevLocationId)
         await switchLocationStatus(domain, prevLocation, user, tx)
       }
@@ -230,9 +277,9 @@ export async function cycleCountAdjustment(
       powrupController.updateStock([inventory], customerDomain, user, tx)
     }
 
-    targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
-    targetInventory.updater = user
-    await tx.getRepository(OrderInventory).save(targetInventory)
+    targetInventoryCheckItem.status = ORDER_INVENTORY_STATUS.TERMINATED
+    targetInventoryCheckItem.updater = user
+    await tx.getRepository(InventoryCheckItem).save(targetInventoryCheckItem)
 
     worksheetDetail.status = WORKSHEET_STATUS.ADJUSTED
     worksheetDetail.updater = user
@@ -242,8 +289,24 @@ export async function cycleCountAdjustment(
   worksheet.status = WORKSHEET_STATUS.DONE
   await tx.getRepository(Worksheet).save(worksheet)
 
-  // change cycle count status to DONE
-  cycleCount.status = ORDER_STATUS.DONE
-  cycleCount.updater = user
+  // Search for any worksheets in EXECUTING
+  let worksheets: Worksheet[] = await tx.getRepository(Worksheet).find({
+    where: {
+      domain,
+      type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+      inventoryCheck: cycleCount,
+      status: WORKSHEET_STATUS.EXECUTING
+    }
+  })
+
+  // Check if there is worksheets in executing, cycle count status change to INSPECTING
+  if (worksheets.length > 0 && cycleCount.status !== 'INSPECTING') {
+    cycleCount.status = ORDER_STATUS.INSPECTING
+    cycleCount.updater = user
+  } else if ((worksheets.length == 0 && cycleCount.status !== 'DONE') || cycleCount.status == 'PENDING_REVIEW') {
+    // change cycle count status to DONE
+    cycleCount.status = ORDER_STATUS.DONE
+    cycleCount.updater = user
+  }
   await tx.getRepository(InventoryCheck).save(cycleCount)
 }