@things-factory/worksheet-base 4.3.651 → 4.3.653

package/dist-server/controllers/inspect/cycle-count-worksheet-controller.js

@@ -0,0 +1,1039 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CycleCountWorksheetController = void 0;
+const typeorm_1 = require("typeorm");
+const biz_base_1 = require("@things-factory/biz-base");
+const id_rule_base_1 = require("@things-factory/id-rule-base");
+const product_base_1 = require("@things-factory/product-base");
+const sales_base_1 = require("@things-factory/sales-base");
+const setting_base_1 = require("@things-factory/setting-base");
+const warehouse_base_1 = require("@things-factory/warehouse-base");
+const constants_1 = require("../../constants");
+const entities_1 = require("../../entities");
+const cycle_count_adjustment_1 = require("../../graphql/resolvers/worksheet/cycle-count-adjustment");
+const utils_1 = require("../../utils");
+const worksheet_controller_1 = require("../worksheet-controller");
+class CycleCountWorksheetController extends worksheet_controller_1.WorksheetController {
+    async createCycleCountWorksheet(customerBizplace, customerId, executionDate, inventoryCheckItem, selectedLocation, limit, lockInventory, foundCycleCountWorksheets) {
+        const cycleCount = await (0, sales_base_1.generateCycleCount)(this.trxMgr, this.domain, this.user, executionDate, customerId);
+        const enableMultipleCC = await this.trxMgr.getRepository(setting_base_1.Setting).findOne({
+            where: { domain: this.domain, category: 'id-rule', name: 'enable-multiple-cycle-count' }
+        });
+        // Find out inventories which is target for cycle counting
+        const qb = this.trxMgr.getRepository(warehouse_base_1.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: warehouse_base_1.INVENTORY_STATUS.STORED });
+        if (enableMultipleCC != undefined && enableMultipleCC.value === 'true') {
+            let executingInventoryCheckItemId = [];
+            foundCycleCountWorksheets.forEach(worksheet => {
+                worksheet.worksheetDetails.forEach(worksheetDetail => {
+                    executingInventoryCheckItemId.push(worksheetDetail.targetInventoryCheckItem.inventoryId);
+                });
+            });
+            if (executingInventoryCheckItemId && executingInventoryCheckItemId.length > 0) {
+                qb.andWhere('INV.id NOT IN (:...inventoryIds)', { inventoryIds: executingInventoryCheckItemId });
+            }
+        }
+        if (inventoryCheckItem && inventoryCheckItem.length > 0) {
+            let keyval = {
+                batchId: 'batch_id',
+                batchIdRef: 'batch_id_ref',
+                productDetailId: 'product_detail_id'
+            };
+            qb.andWhere(new typeorm_1.Brackets(qb => {
+                inventoryCheckItem.forEach((itm, idx) => {
+                    qb.orWhere(new typeorm_1.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 = await qb.getMany();
+        if (!inventories.length) {
+            throw new Error(`Failed to find inventories`);
+        }
+        let cycleCountWorksheet = new entities_1.Worksheet();
+        cycleCountWorksheet.domain = this.domain;
+        cycleCountWorksheet.bizplace = customerBizplace;
+        cycleCountWorksheet.name = utils_1.WorksheetNoGenerator.cycleCount();
+        cycleCountWorksheet.inventoryCheck = cycleCount;
+        cycleCountWorksheet.type = constants_1.WORKSHEET_TYPE.CYCLE_COUNT;
+        cycleCountWorksheet.status = constants_1.WORKSHEET_STATUS.DEACTIVATED;
+        cycleCountWorksheet.checkCount = 1;
+        cycleCountWorksheet.creator = this.user;
+        cycleCountWorksheet.updater = this.user;
+        cycleCountWorksheet = await this.trxMgr.getRepository(entities_1.Worksheet).save(cycleCountWorksheet);
+        // generate order inventory mapping with inventory ID
+        let targetInventoryCheckItems = [];
+        for (let i = 0; i < inventories.length; i++) {
+            const inventory = inventories[i];
+            let targetInventoryCheckItem = new sales_base_1.InventoryCheckItem();
+            targetInventoryCheckItem.domain = this.domain;
+            targetInventoryCheckItem.bizplace = customerBizplace;
+            targetInventoryCheckItem.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.PENDING;
+            targetInventoryCheckItem.name = sales_base_1.OrderNoGenerator.inventoryCheckItem();
+            targetInventoryCheckItem.inventoryCheck = cycleCount;
+            targetInventoryCheckItem.originQty = inventory.qty;
+            targetInventoryCheckItem.originWeight = 0;
+            targetInventoryCheckItem.originUomValue = inventory.uomValue;
+            targetInventoryCheckItem.originExpirationDate = inventory.expirationDate;
+            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);
+        }
+        targetInventoryCheckItems = await this.trxMgr
+            .getRepository(sales_base_1.InventoryCheckItem)
+            .save(targetInventoryCheckItems, { chunk: 500 });
+        await this.trxMgr.getRepository(warehouse_base_1.Inventory).update(inventories.map(itm => itm.id), { updater: this.user, lockInventory: lockInventory });
+        let cycleCountWorksheetDetails = [];
+        for (let i = 0; i < targetInventoryCheckItems.length; i++) {
+            let targetInventoryCheckItem = targetInventoryCheckItems[i];
+            let cycleCountWorksheetDetail = new entities_1.WorksheetDetail();
+            cycleCountWorksheetDetail.domain = this.domain;
+            cycleCountWorksheetDetail.bizplace = customerBizplace;
+            cycleCountWorksheetDetail.worksheet = cycleCountWorksheet;
+            cycleCountWorksheetDetail.name = utils_1.WorksheetNoGenerator.cycleCountDetail();
+            cycleCountWorksheetDetail.targetInventoryCheckItem = targetInventoryCheckItem;
+            cycleCountWorksheetDetail.type = constants_1.WORKSHEET_TYPE.CYCLE_COUNT;
+            cycleCountWorksheetDetail.status = constants_1.WORKSHEET_STATUS.DEACTIVATED;
+            cycleCountWorksheetDetail.creator = this.user;
+            cycleCountWorksheetDetail.updater = this.user;
+            cycleCountWorksheetDetails.push(cycleCountWorksheetDetail);
+        }
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(cycleCountWorksheetDetails, { chunk: 500 });
+        return cycleCountWorksheet;
+    }
+    async createNextRoundCycleCountWorksheet(customerId, existingInventoryCheck, nextExecutionDate, currentCycleCountWorksheet, inventoryCheckItemIds) {
+        try {
+            // Check if the next cycle count worksheet is already exist
+            const count = currentCycleCountWorksheet.checkCount + 1;
+            const newCountWorksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne({
+                where: {
+                    inventoryCheck: existingInventoryCheck,
+                    domain: this.domain,
+                    bizplace: customerId,
+                    type: constants_1.WORKSHEET_TYPE.CYCLE_COUNT,
+                    status: constants_1.WORKSHEET_STATUS.EXECUTING,
+                    checkCount: count
+                }
+            });
+            // Step 1: Create a new cycle count worksheet for the next round
+            let nextRoundWorksheet;
+            if (newCountWorksheet) {
+                nextRoundWorksheet = newCountWorksheet;
+            }
+            else {
+                nextRoundWorksheet = new entities_1.Worksheet();
+                Object.assign(nextRoundWorksheet, currentCycleCountWorksheet);
+                nextRoundWorksheet.id = undefined;
+                nextRoundWorksheet.domain = this.domain;
+                nextRoundWorksheet.bizplace = customerId;
+                nextRoundWorksheet.name = utils_1.WorksheetNoGenerator.cycleCount();
+                nextRoundWorksheet.status = constants_1.WORKSHEET_STATUS.EXECUTING;
+                nextRoundWorksheet.endedAt = null;
+                nextRoundWorksheet.updater = this.user;
+                nextRoundWorksheet.worksheetDetails = null;
+                nextRoundWorksheet.checkCount = count;
+                nextRoundWorksheet.inventoryCheck = existingInventoryCheck;
+                nextRoundWorksheet.type = constants_1.WORKSHEET_TYPE.CYCLE_COUNT;
+            }
+            // Step 2: Save the new Worksheet
+            await this.trxMgr.getRepository(entities_1.Worksheet).save(nextRoundWorksheet);
+            // Step 3: Fetch current InventoryCheckItems
+            const currentInventoryCheckItems = await this.trxMgr
+                .getRepository(sales_base_1.InventoryCheckItem)
+                .findByIds(inventoryCheckItemIds);
+            // Step 4: Create new InventoryCheckItems based on the current ones
+            const nextRoundInventoryCheckItems = currentInventoryCheckItems.map(currentItem => {
+                let nextRoundItem = new sales_base_1.InventoryCheckItem();
+                Object.assign(nextRoundItem, currentItem);
+                nextRoundItem.id = undefined;
+                nextRoundItem.domain = this.domain;
+                nextRoundItem.bizplace = customerId;
+                nextRoundItem.inventoryCheck = currentItem.inventoryCheckId;
+                nextRoundItem.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTING;
+                nextRoundItem.name = sales_base_1.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.originExpirationDate = currentItem.inspectedExpirationDate;
+                nextRoundItem.inspectedQty = null;
+                nextRoundItem.inspectedUomValue = null;
+                nextRoundItem.inspectedBatchNo = null;
+                nextRoundItem.inspectedLocationId = null;
+                nextRoundItem.inspectedExpirationDate = null;
+                nextRoundItem.countNo = currentItem.countNo + 1;
+                nextRoundItem.inventory = currentItem.inventoryId;
+                nextRoundItem.product = currentItem.productId;
+                nextRoundItem.productDetail = currentItem.productDetailId;
+                nextRoundItem.creator = this.user;
+                nextRoundItem.createdAt = new Date();
+                nextRoundItem.updater = this.user;
+                return nextRoundItem;
+            });
+            // Step 5: Save the new InventoryCheckItems
+            await this.trxMgr.getRepository(sales_base_1.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 = new entities_1.WorksheetDetail();
+                detail.domain = this.domain;
+                detail.bizplace = customerId;
+                detail.worksheet = nextRoundWorksheet;
+                detail.name = utils_1.WorksheetNoGenerator.cycleCountDetail();
+                detail.targetInventoryCheckItem = newItem;
+                detail.type = constants_1.WORKSHEET_TYPE.CYCLE_COUNT;
+                detail.status = constants_1.WORKSHEET_STATUS.EXECUTING;
+                detail.creator = this.user;
+                detail.updater = this.user;
+                return detail;
+            });
+            // Step 7: Save the new Worksheet Details
+            await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(nextRoundWorksheetDetails, { chunk: 500 });
+            // Step 8: Mark the selected inventory as TERMINATED
+            currentInventoryCheckItems.forEach(item => {
+                item.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.TERMINATED;
+                item.updater = this.user;
+            });
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).save(currentInventoryCheckItems);
+            // Step 9: Directly update the worksheet details
+            await this.trxMgr
+                .getRepository(entities_1.WorksheetDetail)
+                .createQueryBuilder()
+                .update(entities_1.WorksheetDetail)
+                .set({
+                status: constants_1.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(entities_1.WorksheetDetail).count({
+                where: {
+                    worksheet: currentCycleCountWorksheet,
+                    status: (0, typeorm_1.Not)((0, typeorm_1.Equal)(constants_1.WORKSHEET_STATUS.DONE))
+                }
+            });
+            if (notDoneCount === 0) {
+                if (currentCycleCountWorksheet.checkCount != 1) {
+                    await (0, cycle_count_adjustment_1.cycleCountAdjustment)(this.trxMgr, this.domain, this.user, currentCycleCountWorksheet.name, existingInventoryCheck.name);
+                }
+                // Step 11: Update status of existing InventoryCheck
+                existingInventoryCheck.status = sales_base_1.ORDER_STATUS.INSPECTING;
+                existingInventoryCheck.updater = this.user;
+                await this.trxMgr.getRepository(sales_base_1.InventoryCheck).save(existingInventoryCheck);
+                // Step 12: Mark the current worksheet as DONE
+                currentCycleCountWorksheet.status = constants_1.WORKSHEET_STATUS.DONE;
+                currentCycleCountWorksheet.updater = this.user;
+                await this.trxMgr.getRepository(entities_1.Worksheet).save(currentCycleCountWorksheet);
+            }
+            existingInventoryCheck.executionDate = nextExecutionDate;
+            existingInventoryCheck.updater = this.user;
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheck).save(existingInventoryCheck);
+            return nextRoundWorksheet;
+        }
+        catch (error) {
+            throw new Error('Failed to create next round cycle count worksheet');
+        }
+    }
+    async sameCycleCountWorksheet(customerId, existingInventoryCheck, executionDate, executingWorksheet, notTallyWorksheet, inventoryCheckItemIds) {
+        try {
+            // Step 1: Fetch current InventoryCheckItems
+            const currentInventoryCheckItems = await this.trxMgr
+                .getRepository(sales_base_1.InventoryCheckItem)
+                .findByIds(inventoryCheckItemIds);
+            // Step 2: Create new InventoryCheckItems based on the current ones
+            const continuedInventoryCheckItems = currentInventoryCheckItems.map(currentItem => {
+                let newItem = new sales_base_1.InventoryCheckItem();
+                Object.assign(newItem, currentItem);
+                newItem.id = undefined;
+                newItem.domain = this.domain;
+                newItem.bizplace = customerId;
+                newItem.inventoryCheck = currentItem.inventoryCheckId;
+                newItem.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTING;
+                newItem.name = sales_base_1.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(sales_base_1.InventoryCheckItem).save(continuedInventoryCheckItems, { chunk: 500 });
+            // Step 4: Create new Worksheet Details based on new InventoryCheckItems
+            let continuedWorksheetDetails = continuedInventoryCheckItems.map(newItem => {
+                let detail = new entities_1.WorksheetDetail();
+                detail.domain = this.domain;
+                detail.bizplace = customerId;
+                detail.worksheet = executingWorksheet;
+                detail.name = utils_1.WorksheetNoGenerator.cycleCountDetail();
+                detail.targetInventoryCheckItem = newItem;
+                detail.type = constants_1.WORKSHEET_TYPE.CYCLE_COUNT;
+                detail.status = constants_1.WORKSHEET_STATUS.EXECUTING;
+                detail.creator = this.user;
+                detail.updater = this.user;
+                return detail;
+            });
+            // Step 5: Save the new Worksheet Details
+            await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(continuedWorksheetDetails, { chunk: 500 });
+            // Step 6: Mark the selected inventory as TERMINATED
+            currentInventoryCheckItems.forEach(item => {
+                item.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.TERMINATED;
+                item.updater = this.user;
+            });
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).save(currentInventoryCheckItems);
+            // Step 7: Directly update the worksheet details
+            await this.trxMgr
+                .getRepository(entities_1.WorksheetDetail)
+                .createQueryBuilder()
+                .update(entities_1.WorksheetDetail)
+                .set({
+                status: constants_1.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(entities_1.WorksheetDetail).count({
+                where: {
+                    worksheet: notTallyWorksheet,
+                    status: (0, typeorm_1.Not)((0, typeorm_1.Equal)(constants_1.WORKSHEET_STATUS.DONE))
+                }
+            });
+            if (notDoneCount === 0) {
+                if (notTallyWorksheet.checkCount != 1) {
+                    await (0, cycle_count_adjustment_1.cycleCountAdjustment)(this.trxMgr, this.domain, this.user, notTallyWorksheet.name, existingInventoryCheck.name);
+                }
+                // Step 11: Update status of existing InventoryCheck
+                existingInventoryCheck.status = sales_base_1.ORDER_STATUS.INSPECTING;
+                existingInventoryCheck.updater = this.user;
+                await this.trxMgr.getRepository(sales_base_1.InventoryCheck).save(existingInventoryCheck);
+                // Step 12: Mark the current worksheet as DONE
+                notTallyWorksheet.status = constants_1.WORKSHEET_STATUS.DONE;
+                notTallyWorksheet.updater = this.user;
+                await this.trxMgr.getRepository(entities_1.Worksheet).save(notTallyWorksheet);
+            }
+            existingInventoryCheck.executionDate = executionDate;
+            existingInventoryCheck.updater = this.user;
+            await this.trxMgr.getRepository(sales_base_1.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, customerId, inventoryCheckItemIds = [], inventoryCheckItem = [], limit = 0, selectedLocation = [], cycleCountNo, lockInventory) {
+        const customerBizplace = await this.trxMgr.getRepository(biz_base_1.Bizplace).findOne(customerId);
+        const enableMultipleCC = await this.trxMgr.getRepository(setting_base_1.Setting).findOne({
+            where: { domain: this.domain, category: 'id-rule', name: 'enable-multiple-cycle-count' }
+        });
+        const foundInventoryCheck = await this.trxMgr.getRepository(sales_base_1.InventoryCheck).findOne({
+            where: {
+                domain: this.domain,
+                bizplace: customerBizplace,
+                name: cycleCountNo
+            }
+        });
+        const worksheetRepository = this.trxMgr.getRepository(entities_1.Worksheet);
+        const foundCycleCountWorksheets = await worksheetRepository.find({
+            where: {
+                domain: this.domain,
+                bizplace: customerBizplace,
+                type: (0, typeorm_1.In)([constants_1.WORKSHEET_TYPE.CYCLE_COUNT, constants_1.WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+                status: (0, typeorm_1.Not)(constants_1.WORKSHEET_STATUS.DONE)
+            },
+            order: {
+                checkCount: 'DESC'
+            },
+            relations: ['worksheetDetails', 'worksheetDetails.targetInventoryCheckItem', 'inventoryCheck']
+        });
+        //generate next count cc worksheet
+        if (foundCycleCountWorksheets.length >= 1 && inventoryCheckItemIds.length) {
+            const executingWorksheet = foundCycleCountWorksheets.find(worksheet => worksheet.status === constants_1.WORKSHEET_STATUS.EXECUTING);
+            const notTallyWorksheet = foundCycleCountWorksheets.find(worksheet => worksheet.status === constants_1.WORKSHEET_STATUS.NOT_TALLY);
+            if (executingWorksheet && notTallyWorksheet && (!enableMultipleCC || (enableMultipleCC === null || enableMultipleCC === void 0 ? void 0 : enableMultipleCC.value) !== 'true')) {
+                return await this.sameCycleCountWorksheet(customerId, foundInventoryCheck, executionDate, executingWorksheet, notTallyWorksheet, inventoryCheckItemIds);
+            }
+            else if (notTallyWorksheet) {
+                return await this.createNextRoundCycleCountWorksheet(customerId, foundInventoryCheck, executionDate, notTallyWorksheet, inventoryCheckItemIds);
+            }
+        }
+        else {
+            //generate new cc worksheet
+            if (foundCycleCountWorksheets.length >= 1 && (!enableMultipleCC || (enableMultipleCC === null || enableMultipleCC === void 0 ? void 0 : enableMultipleCC.value) !== 'true')) {
+                throw new Error('Unfinished cycle count worksheet exists.');
+            }
+            return await this.createCycleCountWorksheet(customerBizplace, customerId, executionDate, inventoryCheckItem, selectedLocation, limit, lockInventory, foundCycleCountWorksheets);
+        }
+    }
+    async generateCycleCountWorksheetCarton(executionDate, customerId, cycleCountNo, inventoryCheckItemIdsParam = []) {
+        const customerBizplace = await this.trxMgr.getRepository(biz_base_1.Bizplace).findOne(customerId);
+        const enableMultipleCC = await this.trxMgr.getRepository(setting_base_1.Setting).findOne({
+            where: { domain: this.domain, category: 'id-rule', name: 'enable-multiple-cycle-count' }
+        });
+        const foundInventoryCheck = await this.trxMgr.getRepository(sales_base_1.InventoryCheck).findOne({
+            where: {
+                domain: this.domain,
+                bizplace: customerBizplace,
+                name: cycleCountNo
+            }
+        });
+        const worksheetRepository = this.trxMgr.getRepository(entities_1.Worksheet);
+        const foundCycleCountWorksheets = await worksheetRepository.find({
+            where: {
+                domain: this.domain,
+                inventoryCheck: foundInventoryCheck,
+                bizplace: customerBizplace,
+                type: (0, typeorm_1.In)([constants_1.WORKSHEET_TYPE.CYCLE_COUNT, constants_1.WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+                status: (0, typeorm_1.Not)(constants_1.WORKSHEET_STATUS.DONE)
+            },
+            order: {
+                checkCount: 'DESC'
+            },
+            relations: ['worksheetDetails', 'worksheetDetails.targetInventoryCheckItem', 'inventoryCheck']
+        });
+        const worksheetStatuses = foundCycleCountWorksheets.map(worksheet => worksheet.status);
+        const itemStatus = [
+            sales_base_1.INVENTORY_CHECK_ITEM_STATUS.RELOCATED,
+            sales_base_1.INVENTORY_CHECK_ITEM_STATUS.ADDED,
+            sales_base_1.INVENTORY_CHECK_ITEM_STATUS.MISSING,
+            sales_base_1.INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY
+        ];
+        const qb = this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).createQueryBuilder('inventoryCheckItem');
+        qb.innerJoinAndSelect('inventoryCheckItem.inventory', 'inventory')
+            .where('inventoryCheckItem.inventory_check_id = :inventoryCheckId', { inventoryCheckId: foundInventoryCheck.id })
+            .andWhere('inventoryCheckItem.id IN (:...itemIds)', { itemIds: inventoryCheckItemIdsParam })
+            .andWhere('inventoryCheckItem.domain_id = :domainId', { domainId: this.domain.id })
+            .andWhere('inventoryCheckItem.bizplace_id = :bizplaceId', { bizplaceId: customerBizplace.id })
+            .andWhere('inventoryCheckItem.status IN (:...status)', { status: itemStatus });
+        const inventoryCheckItems = await qb.getMany();
+        const inventoryCheckItemIds = inventoryCheckItems.map(item => item.id);
+        const executingWorksheet = foundCycleCountWorksheets.find(worksheet => worksheet.status === constants_1.WORKSHEET_STATUS.EXECUTING);
+        const notTallyWorksheet = foundCycleCountWorksheets.find(worksheet => worksheet.status === constants_1.WORKSHEET_STATUS.NOT_TALLY);
+        if (worksheetStatuses.includes(constants_1.WORKSHEET_STATUS.EXECUTING) &&
+            worksheetStatuses.includes(constants_1.WORKSHEET_STATUS.NOT_TALLY) &&
+            (!enableMultipleCC || (enableMultipleCC === null || enableMultipleCC === void 0 ? void 0 : enableMultipleCC.value) !== 'true')) {
+            return await this.sameCycleCountWorksheet(customerId, foundInventoryCheck, executionDate, executingWorksheet, notTallyWorksheet, inventoryCheckItemIds);
+        }
+        else if (worksheetStatuses.includes(constants_1.WORKSHEET_STATUS.NOT_TALLY)) {
+            return await this.createNextRoundCycleCountWorksheet(customerId, foundInventoryCheck, executionDate, notTallyWorksheet, inventoryCheckItemIds);
+        }
+    }
+    async activateCycleCount(worksheetNo) {
+        let worksheet = await this.findActivatableWorksheet(worksheetNo, constants_1.WORKSHEET_TYPE.CYCLE_COUNT, [
+            'inventoryCheck',
+            'worksheetDetails',
+            'worksheetDetails.targetInventoryCheckItem'
+        ]);
+        let worksheetDetails = worksheet.worksheetDetails;
+        let targetInventoryCheckItems = worksheetDetails.map((wsd) => wsd.targetInventoryCheckItem);
+        for (let i = 0; i < targetInventoryCheckItems.length; i++) {
+            let targetInventoryCheckItem = targetInventoryCheckItems[i];
+            targetInventoryCheckItem.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTING;
+            targetInventoryCheckItem.updater = this.user;
+        }
+        await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).save(targetInventoryCheckItems, { chunk: 500 });
+        for (let i = 0; i < worksheetDetails.length; i++) {
+            let foundWSD = worksheetDetails[i];
+            foundWSD.status = constants_1.WORKSHEET_STATUS.EXECUTING;
+            foundWSD.updater = this.user;
+        }
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetails, { chunk: 500 });
+        worksheet.status = constants_1.WORKSHEET_STATUS.EXECUTING;
+        worksheet.startedAt = new Date();
+        worksheet.updater = this.user;
+        worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).save(worksheet);
+        let cycleCount = worksheet.inventoryCheck;
+        cycleCount.status = sales_base_1.ORDER_STATUS.INSPECTING;
+        cycleCount.updater = this.user;
+        await this.updateRefOrder(cycleCount);
+        return worksheet;
+    }
+    async inspectingPallet(worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue, inspectedExpirationDate) {
+        let worksheetDetail = await this.findExecutableWorksheetDetailByName(worksheetDetailName, constants_1.WORKSHEET_TYPE.CYCLE_COUNT, ['targetInventoryCheckItem', 'targetInventoryCheckItem.inventory', 'targetInventoryCheckItem.inventory.location']);
+        let targetInventoryCheckItem = worksheetDetail.targetInventoryCheckItem;
+        const { originBatchNo, originQty, originUomValue, originExpirationDate, originLocationId } = targetInventoryCheckItem;
+        let checkedExpDate = inspectedExpirationDate ? formatDate(inspectedExpirationDate) : null;
+        let checkOrgExpDate = (originExpirationDate === null || originExpirationDate === void 0 ? void 0 : originExpirationDate.toString()) || null;
+        const isChanged = originBatchNo !== inspectedBatchNo ||
+            originQty !== inspectedQty ||
+            originUomValue !== inspectedUomValue ||
+            checkedExpDate !== checkOrgExpDate;
+        const worksheetDetailStatus = isChanged ? constants_1.WORKSHEET_STATUS.NOT_TALLY : constants_1.WORKSHEET_STATUS.DONE;
+        const targetInventoryCheckItemStatus = isChanged
+            ? sales_base_1.INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY
+            : sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTED;
+        worksheetDetail.status = worksheetDetailStatus;
+        worksheetDetail.updater = this.user;
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+        targetInventoryCheckItem.inspectedBatchNo = inspectedBatchNo;
+        targetInventoryCheckItem.inspectedQty = inspectedQty;
+        targetInventoryCheckItem.inspectedUomValue = inspectedUomValue;
+        targetInventoryCheckItem.inspectedExpirationDate = checkedExpDate;
+        targetInventoryCheckItem.inspectedLocation = originLocationId;
+        targetInventoryCheckItem.status = targetInventoryCheckItemStatus;
+        targetInventoryCheckItem.updater = this.user;
+        await this.updateOrderTargets([targetInventoryCheckItem]);
+    }
+    async inspectingCarton(productDetailId, cartonId, batchId, locationId, inspectedBatchNo, inspectedQty, inspectedUomValue, inspectedExpirationDate) {
+        var _a, _b, _c;
+        const productDetail = await this.trxMgr.getRepository(product_base_1.ProductDetail).findOne({
+            where: { id: productDetailId },
+            relations: ['product']
+        });
+        let qb = this.trxMgr
+            .getRepository(warehouse_base_1.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';
+        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 = await qb.getMany();
+        const inventoryIds = inventories.map(inv => inv.id);
+        const inventoryCheckItems = await this.trxMgr
+            .getRepository(sales_base_1.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.totalOriginQty += item.originQty || 0;
+            return total;
+        }, { totalOriginQty: 0 });
+        const hasDiscrepancies = totalOriginQty !== inspectedQty ||
+            inventoryCheckItems.some(checkItem => checkItem.originExpirationDate !== formatDate(inspectedExpirationDate) ||
+                checkItem.originBatchNo !== inspectedBatchNo);
+        let totalInspectedQty = inspectedQty;
+        for (const checkItem of inventoryCheckItems) {
+            const qtyToInspect = totalInspectedQty > 0 ? Math.min(totalInspectedQty, checkItem.originQty) : 0;
+            checkItem.inspectedQty = ((_a = checkItem.inspectedQty) !== null && _a !== void 0 ? _a : 0) + qtyToInspect;
+            totalInspectedQty -= qtyToInspect;
+            checkItem.inspectedUomValue = (_b = checkItem.originUomValue) !== null && _b !== void 0 ? _b : 0;
+            checkItem.inspectedBatchNo = inspectedBatchNo;
+            checkItem.inspectedExpirationDate = inspectedExpirationDate;
+            checkItem.inspectedLocation = checkItem.originLocationId;
+            checkItem.status = hasDiscrepancies
+                ? sales_base_1.INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY
+                : sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTED;
+            checkItem.updater = this.user;
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).update(checkItem.id, {
+                inspectedQty: checkItem.inspectedQty,
+                inspectedUomValue: checkItem.inspectedQty * productDetail.uomValue,
+                inspectedBatchNo: checkItem.inspectedBatchNo,
+                inspectedExpirationDate: checkItem.inspectedExpirationDate,
+                inspectedLocation: checkItem.inspectedLocation,
+                status: checkItem.status,
+                updater: this.user
+            });
+            let worksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).findOne({
+                where: { targetInventoryCheckItem: checkItem.id, type: constants_1.WORKSHEET_TYPE.CYCLE_COUNT }
+            });
+            if (worksheetDetail) {
+                await this.trxMgr.getRepository(entities_1.WorksheetDetail).update(worksheetDetail.id, {
+                    status: hasDiscrepancies ? constants_1.WORKSHEET_STATUS.NOT_TALLY : constants_1.WORKSHEET_STATUS.DONE,
+                    updater: this.user
+                });
+            }
+        }
+        if (totalInspectedQty > 0 && inventoryCheckItems.length > 0) {
+            const lastItem = inventoryCheckItems[inventoryCheckItems.length - 1];
+            lastItem.inspectedQty = ((_c = lastItem.inspectedQty) !== null && _c !== void 0 ? _c : 0) + totalInspectedQty;
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).update(lastItem.id, {
+                inspectedQty: lastItem.inspectedQty,
+                updater: this.user
+            });
+        }
+    }
+    async undoInspection(worksheetDetailName) {
+        let worksheetDetail = await this.findWorksheetDetail({ domain: this.domain, name: worksheetDetailName, status: (0, typeorm_1.Not)((0, typeorm_1.Equal)(constants_1.WORKSHEET_STATUS.EXECUTING)) }, ['targetInventoryCheckItem', 'targetInventoryCheckItem.inventory']);
+        let targetInventoryCheckItem = worksheetDetail.targetInventoryCheckItem;
+        targetInventoryCheckItem.inspectedBatchNo = null;
+        targetInventoryCheckItem.inspectedQty = null;
+        targetInventoryCheckItem.inspectedWeight = null;
+        targetInventoryCheckItem.inspectedUomValue = null;
+        targetInventoryCheckItem.inspectedLocation = null;
+        targetInventoryCheckItem.inspectedExpirationDate = null;
+        targetInventoryCheckItem.status = targetInventoryCheckItem.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTING;
+        targetInventoryCheckItem.updater = this.user;
+        await this.updateOrderTargets([targetInventoryCheckItem]);
+        worksheetDetail.status = constants_1.WORKSHEET_STATUS.EXECUTING;
+        worksheetDetail.updater = this.user;
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+    }
+    async undoInspectionCarton(productDetailId, cartonId, batchId, locationId, inventoryCheckNo, countNo) {
+        let qb = this.trxMgr.getRepository(warehouse_base_1.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 })
+            .andWhere('inv.domain_id = :domainId', { domainId: this.domain.id })
+            .andWhere('inv.status = :status', { status: warehouse_base_1.INVENTORY_STATUS.STORED });
+        const inventories = await qb.getMany();
+        const foundInventoryCheck = await this.trxMgr.getRepository(sales_base_1.InventoryCheck).findOne({
+            where: {
+                domain: this.domain,
+                name: inventoryCheckNo
+            }
+        });
+        const inventoryCheckItems = await Promise.all(inventories.map(inventory => this.trxMgr
+            .getRepository(sales_base_1.InventoryCheckItem)
+            .findOne({ where: { inventory: inventory.id, inventoryCheck: foundInventoryCheck.id, countNo } })));
+        for (const checkItem of inventoryCheckItems) {
+            checkItem.inspectedBatchNo = null;
+            checkItem.inspectedQty = null;
+            checkItem.inspectedWeight = null;
+            checkItem.inspectedUomValue = null;
+            checkItem.inspectedExpirationDate = null;
+            checkItem.inspectedLocation = null;
+            checkItem.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTING;
+            checkItem.updater = this.user;
+            let worksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).findOne({
+                where: { targetInventoryCheckItem: checkItem.id, type: constants_1.WORKSHEET_TYPE.CYCLE_COUNT },
+                relations: ['targetInventoryCheckItem']
+            });
+            if (worksheetDetail) {
+                worksheetDetail.status = constants_1.WORKSHEET_STATUS.EXECUTING;
+                worksheetDetail.updater = this.user;
+                await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+            }
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).save(checkItem);
+        }
+    }
+    async checkMissingInventory(worksheetDetailName) {
+        let worksheetDetail = await this.findExecutableWorksheetDetailByName(worksheetDetailName, constants_1.WORKSHEET_TYPE.CYCLE_COUNT, ['targetInventoryCheckItem']);
+        let targetInventoryCheckItem = worksheetDetail.targetInventoryCheckItem;
+        worksheetDetail.status = constants_1.WORKSHEET_STATUS.NOT_TALLY;
+        worksheetDetail.updater = this.user;
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+        targetInventoryCheckItem.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.MISSING;
+        targetInventoryCheckItem.updater = this.user;
+        await this.updateOrderTargets([targetInventoryCheckItem]);
+    }
+    async checkMissingInventoryCarton(productDetailId, cartonId, batchId, locationId) {
+        let qb = this.trxMgr.getRepository(warehouse_base_1.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 = await qb.getMany();
+        const inventoryCheckItems = await Promise.all(inventories.map(inventory => this.trxMgr.getRepository(sales_base_1.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 = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.MISSING;
+            checkItem.updater = this.user;
+            let worksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).findOne({
+                where: { targetInventoryCheckItem: checkItem.id, type: constants_1.WORKSHEET_TYPE.CYCLE_COUNT },
+                relations: ['targetInventoryCheckItem']
+            });
+            if (worksheetDetail) {
+                worksheetDetail.status = constants_1.WORKSHEET_STATUS.NOT_TALLY;
+                worksheetDetail.updater = this.user;
+                await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+            }
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).save(checkItem);
+        }
+    }
+    async addExtraInventory(cycleCountNo, inspectedLocation, productDetailId, productId, inspectedBatchNo, inspectedQty, inspectedUomValue, countNo, inspectedExpirationDate) {
+        var _a;
+        let today = new Date(), year = today.getFullYear(), month = today.getMonth(), date = today.getDate();
+        const inventoryCheck = await this.findRefOrder(sales_base_1.InventoryCheck, {
+            name: cycleCountNo,
+            status: sales_base_1.ORDER_STATUS.INSPECTING
+        }, ['bizplace', 'bizplace.domain']);
+        const bizplace = await this.trxMgr.getRepository(biz_base_1.Bizplace).findOne({
+            where: { id: inventoryCheck.bizplace.id },
+            relations: ['domain']
+        });
+        const worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne({
+            where: {
+                domain: this.domain,
+                type: constants_1.WORKSHEET_TYPE.CYCLE_COUNT,
+                status: constants_1.WORKSHEET_STATUS.EXECUTING,
+                inventoryCheck
+            }
+        });
+        const location = await this.trxMgr.getRepository(warehouse_base_1.Location).findOne({
+            where: { domain: this.domain, name: inspectedLocation },
+            relations: ['warehouse']
+        });
+        const productDetail = await this.trxMgr.getRepository(product_base_1.ProductDetail).findOne({
+            where: { id: productDetailId }
+        });
+        const product = await this.trxMgr.getRepository(product_base_1.Product).findOne({
+            where: { id: productId }
+        });
+        // Check if quantity has decimals and validate against product settings
+        if (inspectedQty % 1 !== 0 && !product.isInventoryDecimal) {
+            throw new Error('Decimal quantities are not allowed for this product');
+        }
+        const total = await this.trxMgr.getRepository(warehouse_base_1.Inventory).count({
+            createdAt: (0, typeorm_1.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 = new warehouse_base_1.Inventory();
+        newInventory.bizplace = bizplace;
+        newInventory.domain = this.domain;
+        newInventory.name = warehouse_base_1.InventoryNoGenerator.inventoryName();
+        newInventory.palletId = await (0, id_rule_base_1.generateId)({
+            domain: this.domain,
+            type: 'adjustment_pallet_id',
+            seed: {
+                batchId: inspectedBatchNo,
+                date: dateStr
+            }
+        });
+        const warehouseCartonSetting = await this.trxMgr.getRepository(setting_base_1.Setting).findOne({
+            where: { domain: this.domain, category: 'id-rule', name: 'enable-carton-label', value: true }
+        });
+        const partnerCartonSetting = await this.trxMgr.getRepository(setting_base_1.PartnerSetting).findOne({
+            where: {
+                setting: warehouseCartonSetting,
+                domain: this.domain,
+                partnerDomain: (_a = inventoryCheck.bizplace) === null || _a === void 0 ? void 0 : _a.domain,
+                value: true
+            }
+        });
+        if ((partnerCartonSetting === null || partnerCartonSetting === void 0 ? void 0 : partnerCartonSetting.value) || (warehouseCartonSetting === null || warehouseCartonSetting === void 0 ? void 0 : warehouseCartonSetting.value)) {
+            let cartonId = await (0, id_rule_base_1.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.expirationDate = inspectedExpirationDate;
+        newInventory.location = location;
+        newInventory.warehouse = location.warehouse;
+        newInventory.zone = location.zone;
+        newInventory.status = warehouse_base_1.INVENTORY_STATUS.CC_ADDED;
+        newInventory.creator = this.user;
+        newInventory.updater = this.user;
+        await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(newInventory);
+        let targetInventoryCheckItem = new sales_base_1.InventoryCheckItem();
+        targetInventoryCheckItem.domain = this.domain;
+        targetInventoryCheckItem.bizplace = bizplace;
+        targetInventoryCheckItem.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.ADDED;
+        targetInventoryCheckItem.name = sales_base_1.OrderNoGenerator.inventoryCheckItem();
+        targetInventoryCheckItem.inventoryCheck = inventoryCheck;
+        targetInventoryCheckItem.inventory = newInventory;
+        targetInventoryCheckItem.inspectedBatchNo = inspectedBatchNo;
+        targetInventoryCheckItem.inspectedQty = inspectedQty;
+        targetInventoryCheckItem.inspectedUomValue = inspectedUomValue;
+        targetInventoryCheckItem.inspectedExpirationDate = inspectedExpirationDate;
+        targetInventoryCheckItem.inspectedLocation = location;
+        targetInventoryCheckItem.productDetail = productDetail;
+        targetInventoryCheckItem.product = product;
+        targetInventoryCheckItem.countNo = countNo;
+        targetInventoryCheckItem.creator = this.user;
+        targetInventoryCheckItem.updater = this.user;
+        await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).save(targetInventoryCheckItem);
+        let worksheetDetail = new entities_1.WorksheetDetail();
+        worksheetDetail.domain = this.domain;
+        worksheetDetail.bizplace = bizplace;
+        worksheetDetail.worksheet = worksheet;
+        worksheetDetail.name = utils_1.WorksheetNoGenerator.cycleCountDetail();
+        worksheetDetail.targetInventoryCheckItem = targetInventoryCheckItem;
+        worksheetDetail.type = constants_1.WORKSHEET_TYPE.CYCLE_COUNT;
+        worksheetDetail.status = constants_1.WORKSHEET_STATUS.NOT_TALLY;
+        worksheetDetail.creator = this.user;
+        worksheetDetail.updater = this.user;
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+    }
+    async relocateInventory(worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue, inspectedLocationName) {
+        var _a;
+        let worksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).findOne({
+            where: { domain: this.domain, name: worksheetDetailName, type: constants_1.WORKSHEET_TYPE.CYCLE_COUNT },
+            relations: [
+                'targetInventoryCheckItem',
+                'targetInventoryCheckItem.inventory',
+                'targetInventoryCheckItem.inventory.location'
+            ]
+        });
+        if (!worksheetDetail)
+            throw new Error('Failed to find worksheet detail');
+        let targetInventoryCheckItem = worksheetDetail.targetInventoryCheckItem;
+        const location = (_a = targetInventoryCheckItem === null || targetInventoryCheckItem === void 0 ? void 0 : targetInventoryCheckItem.inventory) === null || _a === void 0 ? void 0 : _a.location;
+        if (location.name === inspectedLocationName)
+            throw new Error(`You can't relocate at same location`);
+        const inspectedLocation = await this.trxMgr.getRepository(warehouse_base_1.Location).findOne({
+            where: { name: inspectedLocationName, domain: this.domain }
+        });
+        worksheetDetail.status = constants_1.WORKSHEET_STATUS.NOT_TALLY;
+        worksheetDetail.updater = this.user;
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+        targetInventoryCheckItem.inspectedLocation = inspectedLocation;
+        targetInventoryCheckItem.inspectedBatchNo = inspectedBatchNo;
+        targetInventoryCheckItem.inspectedQty = inspectedQty;
+        targetInventoryCheckItem.inspectedWeight = 0;
+        targetInventoryCheckItem.inspectedUomValue = inspectedUomValue;
+        targetInventoryCheckItem.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.RELOCATED;
+        targetInventoryCheckItem.updater = this.user;
+        await this.updateOrderTargets([targetInventoryCheckItem]);
+    }
+    async relocateInventoryCarton(productDetailId, cartonId, batchId, locationId, inspectedBatchNo, inspectedQty, inspectedUomValue, inspectedLocationName) {
+        var _a, _b, _c, _d;
+        const productDetail = await this.trxMgr.getRepository(product_base_1.ProductDetail).findOne({
+            where: { id: productDetailId },
+            relations: ['product']
+        });
+        let qb = this.trxMgr
+            .getRepository(warehouse_base_1.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';
+        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 = await qb.getMany();
+        if (inventories.length === 0) {
+            throw new Error('No inventories found.');
+        }
+        const location = await this.trxMgr.getRepository(warehouse_base_1.Location).findOne({
+            where: { id: locationId }
+        });
+        if (location.name === inspectedLocationName) {
+            throw new Error(`You can't relocate to the same location.`);
+        }
+        const inspectedLocation = await this.trxMgr.getRepository(warehouse_base_1.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 = await this.trxMgr
+            .getRepository(sales_base_1.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
+                ? sales_base_1.INVENTORY_CHECK_ITEM_STATUS.RELOCATED
+                : sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTED;
+            worksheetDetailStatus = hasDiscrepancies ? constants_1.WORKSHEET_STATUS.NOT_TALLY : constants_1.WORKSHEET_STATUS.DONE;
+        }
+        else {
+            inventoryCheckItemStatus = hasDiscrepancies
+                ? sales_base_1.INVENTORY_CHECK_ITEM_STATUS.RELOCATED
+                : sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTED;
+            worksheetDetailStatus = hasDiscrepancies ? constants_1.WORKSHEET_STATUS.NOT_TALLY : constants_1.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 = ((_a = checkItem.inspectedQty) !== null && _a !== void 0 ? _a : 0) + qtyToInspect;
+            totalInspectedQty -= qtyToInspect;
+            checkItem.inspectedUomValue = ((_b = checkItem.inspectedUomValue) !== null && _b !== void 0 ? _b : 0) + uomValueToInspect;
+            totalInspectedUomValue -= uomValueToInspect;
+            checkItem.inspectedBatchNo = inspectedBatchNo;
+            checkItem.inspectedLocation = inspectedLocation;
+            checkItem.status = inventoryCheckItemStatus;
+            checkItem.updater = this.user;
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).save(checkItem);
+            let worksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).findOne({
+                where: { targetInventoryCheckItem: checkItem.id, type: constants_1.WORKSHEET_TYPE.CYCLE_COUNT }
+            });
+            if (worksheetDetail) {
+                worksheetDetail.status = worksheetDetailStatus;
+                worksheetDetail.updater = this.user;
+                await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+            }
+        }
+        if (totalInspectedQty > 0 && totalInspectedUomValue > 0 && inventoryCheckItems.length > 0) {
+            const lastItem = inventoryCheckItems[inventoryCheckItems.length - 1];
+            lastItem.inspectedQty = ((_c = lastItem.inspectedQty) !== null && _c !== void 0 ? _c : 0) + totalInspectedQty;
+            lastItem.inspectedUomValue = ((_d = lastItem.inspectedUomValue) !== null && _d !== void 0 ? _d : 0) + totalInspectedUomValue;
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).save(lastItem);
+        }
+    }
+    async completeCycleCount(inventoryCheckNo) {
+        const inventoryCheck = await this.findRefOrder(sales_base_1.InventoryCheck, {
+            name: inventoryCheckNo,
+            status: sales_base_1.ORDER_STATUS.INSPECTING
+        });
+        let worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne({
+            where: {
+                domain: this.domain,
+                status: constants_1.WORKSHEET_STATUS.EXECUTING,
+                type: (0, typeorm_1.In)([constants_1.WORKSHEET_TYPE.CYCLE_COUNT, constants_1.WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+                inventoryCheck
+            },
+            relations: [
+                'worksheetDetails',
+                'worksheetDetails.targetInventoryCheckItem',
+                'worksheetDetails.targetInventoryCheckItem.inventory'
+            ]
+        });
+        this.checkRecordValidity(worksheet, { status: constants_1.WORKSHEET_STATUS.EXECUTING });
+        const worksheetDetails = worksheet.worksheetDetails;
+        const doneWorksheetDetails = worksheetDetails.filter(wsd => wsd.status === 'DONE');
+        const targetInventoryCheckItems = worksheetDetails.map((wsd) => wsd.targetInventoryCheckItem);
+        if (doneWorksheetDetails.length === worksheetDetails.length && worksheet.checkCount != 1) {
+            await (0, cycle_count_adjustment_1.cycleCountAdjustment)(this.trxMgr, this.domain, this.user, worksheet.name, inventoryCheck.name);
+            worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne({
+                domain: this.domain,
+                type: (0, typeorm_1.In)([constants_1.WORKSHEET_TYPE.CYCLE_COUNT, constants_1.WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+                inventoryCheck
+            });
+        }
+        else {
+            const { tallyTargetInventoryCheckItems, notTallyTargetInventoryCheckItems } = targetInventoryCheckItems.reduce((result, targetInventoryCheckItem) => {
+                if (targetInventoryCheckItem.status !== sales_base_1.INVENTORY_CHECK_ITEM_STATUS.INSPECTED) {
+                    result.notTallyTargetInventoryCheckItems.push(targetInventoryCheckItem);
+                }
+                else {
+                    result.tallyTargetInventoryCheckItems.push(targetInventoryCheckItem);
+                }
+                return result;
+            }, {
+                tallyTargetInventoryCheckItems: [],
+                notTallyTargetInventoryCheckItems: []
+            });
+            const tallyInventories = tallyTargetInventoryCheckItems.map(targetInventoryCheckItem => targetInventoryCheckItem.inventory);
+            tallyTargetInventoryCheckItems.forEach((targetInventoryCheckItem) => {
+                targetInventoryCheckItem.status = sales_base_1.INVENTORY_CHECK_ITEM_STATUS.TERMINATED;
+                targetInventoryCheckItem.updater = this.user;
+            });
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheckItem).save(tallyTargetInventoryCheckItems, { chunk: 500 });
+            // await this.trxMgr.getRepository(Inventory).save(tallyInventories, { chunk: 500 })
+            if (tallyInventories.length > 0) {
+                await this.trxMgr.getRepository(warehouse_base_1.Inventory).update(tallyInventories.map(inv => inv.id), {
+                    updater: this.user,
+                    lockInventory: false
+                });
+            }
+            if (notTallyTargetInventoryCheckItems.length) {
+                worksheet.status = constants_1.WORKSHEET_STATUS.NOT_TALLY;
+                inventoryCheck.status = sales_base_1.ORDER_STATUS.PENDING_REVIEW;
+            }
+            else {
+                worksheet.status = constants_1.WORKSHEET_STATUS.DONE;
+                inventoryCheck.status = sales_base_1.ORDER_STATUS.DONE;
+            }
+            worksheet.endedAt = new Date();
+            worksheet.updater = this.user;
+            await this.trxMgr.getRepository(entities_1.Worksheet).save(worksheet);
+            inventoryCheck.updater = this.user;
+            await this.trxMgr.getRepository(sales_base_1.InventoryCheck).save(inventoryCheck);
+        }
+        return worksheet;
+    }
+}
+exports.CycleCountWorksheetController = CycleCountWorksheetController;
+function formatDate(data) {
+    if (data) {
+        let date = {
+            year: data.getFullYear().toString(),
+            month: (data.getMonth() + 1).toString(),
+            day: data.getDate().toString()
+        };
+        return `${date.year}-${date.month.padStart(2, '0')}-${date.day.padStart(2, '0')}`;
+    }
+    return null;
+}
+//# sourceMappingURL=cycle-count-worksheet-controller.js.map