@things-factory/worksheet-base 4.3.651 → 4.3.652

package/dist-server/controllers/vas/vas-worksheet-controller.js

@@ -0,0 +1,792 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VasWorksheetController = void 0;
+const typeorm_1 = require("typeorm");
+const sales_base_1 = require("@things-factory/sales-base");
+const warehouse_base_1 = require("@things-factory/warehouse-base");
+const constants_1 = require("../../constants");
+const entities_1 = require("../../entities");
+const vas_transactions_1 = require("../../graphql/resolvers/worksheet/vas-transactions");
+const repackaging_1 = require("../../graphql/resolvers/worksheet/vas-transactions/interfaces/repackaging");
+const worksheet_controller_1 = require("../worksheet-controller");
+const controllers_1 = require("../../controllers");
+const uuid_1 = require("uuid");
+class VasWorksheetController extends worksheet_controller_1.WorksheetController {
+    constructor() {
+        super(...arguments);
+        this.COMPLETE_TRX_MAP = {
+            'vas-repalletizing': vas_transactions_1.completeRepalletizing,
+            'vas-repack': vas_transactions_1.completeRepackaging,
+            'vas-repack-relabel': vas_transactions_1.completeRepackaging,
+            'vas-relabel': vas_transactions_1.completeRelabeling,
+            'vas-unpack': vas_transactions_1.completeUnpacking
+        };
+    }
+    async generateVasWorksheet(referenceOrder) {
+        let orderStatus = referenceOrder.status;
+        let orderVASs;
+        if (referenceOrder instanceof sales_base_1.ArrivalNotice) {
+            const arrivalNotice = await this.findRefOrder(sales_base_1.ArrivalNotice, referenceOrder, ['orderVass']);
+            orderVASs = arrivalNotice.orderVass;
+        }
+        else if (referenceOrder instanceof sales_base_1.ReleaseGood) {
+            const releaseGood = await this.findRefOrder(sales_base_1.ReleaseGood, referenceOrder, ['orderVass']);
+            orderVASs = releaseGood.orderVass;
+        }
+        else {
+            const vasOrder = await this.findRefOrder(sales_base_1.VasOrder, referenceOrder, ['orderVass']);
+            orderVASs = vasOrder.orderVass;
+            orderStatus = sales_base_1.ORDER_STATUS.READY_TO_EXECUTE;
+        }
+        return await this.generateWorksheet(constants_1.WORKSHEET_TYPE.VAS, referenceOrder, orderVASs, orderStatus, sales_base_1.ORDER_VAS_STATUS.READY_TO_PROCESS);
+    }
+    async assignInventories(worksheetDetailIds, inventories) {
+        var _a, _b, _c;
+        const worksheetDetails = await this.trxMgr
+            .getRepository(entities_1.WorksheetDetail)
+            .findByIds(worksheetDetailIds, {
+            relations: [
+                'bizplace',
+                'worksheet',
+                'targetVas',
+                'targetVas.arrivalNotice',
+                'targetVas.releaseGood',
+                'targetVas.shippingOrder',
+                'targetVas.vasOrder',
+                'targetVas.vas',
+                'targetVas.targetProduct'
+            ]
+        });
+        let seq = 0;
+        for (let worksheetDetail of worksheetDetails) {
+            const bizplace = worksheetDetail.bizplace;
+            const worksheet = worksheetDetail.worksheet;
+            const targetVas = worksheetDetail.targetVas;
+            let newWorksheetDetail = Object.assign({}, worksheetDetail);
+            delete newWorksheetDetail.id;
+            // get accumulated inventories qty
+            const accInventoriesQty = inventories.reduce((acc, inv) => {
+                return acc + inv.qty;
+            }, 0);
+            let operationGuide = JSON.parse(targetVas.operationGuide);
+            let vasOperationGuide = (_a = targetVas.vas) === null || _a === void 0 ? void 0 : _a.operationGuide;
+            if (vasOperationGuide === 'vas-repack' || vasOperationGuide === 'vas-repack-relabel') {
+                const mainInventory = inventories[0];
+                const featuredInvs = [];
+                const foundInvs = await this.trxMgr
+                    .getRepository(warehouse_base_1.Inventory)
+                    .findByIds(inventories.filter(inv => inv.id !== mainInventory.id).map(inv => inv.id));
+                /* Update lockedQty of featuredInvs */
+                for (let inventory of foundInvs) {
+                    const transferQty = inventories.find(inv => inv.id === inventory.id).qty;
+                    const transferUomValue = Math.round((inventory.uomValue / inventory.qty) * transferQty * 100) / 100;
+                    inventory.lockedQty += transferQty;
+                    inventory.lockedUomValue += transferUomValue;
+                    await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(inventory);
+                    let featuredInv = {
+                        palletId: inventory.palletId,
+                        originalQty: transferQty,
+                        originalUomValue: transferUomValue,
+                        packingSize: inventory.packingSize,
+                        uomValuePerQty: inventory.uomValue / (inventory.qty * inventory.packingSize)
+                    };
+                    switch ((_b = operationGuide.data) === null || _b === void 0 ? void 0 : _b.packingUnit) {
+                        case repackaging_1.PackingUnits.QTY:
+                            featuredInv.currentUnitQty = transferQty * inventory.packingSize;
+                            break;
+                        case repackaging_1.PackingUnits.UOM:
+                            featuredInv.currentUomValue = transferUomValue;
+                            break;
+                    }
+                    featuredInvs.push(featuredInv);
+                }
+                /* assign featuredInvs inside operationGuide.data */
+                operationGuide.data = Object.assign(Object.assign({}, operationGuide.data), { featuredInvs });
+                /* assign main inventory as the only inventories */
+                inventories = [mainInventory];
+            }
+            for (let inventory of inventories) {
+                let newTargetVas = new sales_base_1.OrderVas();
+                const foundInventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).findOne(inventory.id);
+                if (!foundInventory)
+                    throw new Error(this.ERROR_MSG.FIND.NO_RESULT(inventory.id));
+                // assigned inventory qty that was passed from client side
+                const assignedQty = inventory.qty;
+                const unitUomValue = foundInventory.uomValue / foundInventory.qty;
+                // update unpack qty for unpacking vas
+                if (vasOperationGuide === 'vas-unpack') {
+                    operationGuide.data.unpackQty = Math.round(operationGuide.data.unpackQty / accInventoriesQty) * assignedQty;
+                }
+                if (vasOperationGuide === 'vas-repack' || vasOperationGuide === 'vas-repack-relabel') {
+                    switch ((_c = operationGuide.data) === null || _c === void 0 ? void 0 : _c.packingUnit) {
+                        case repackaging_1.PackingUnits.UOM:
+                            newTargetVas.qty = 1;
+                            newTargetVas.uomValue = targetVas.uomValue;
+                            break;
+                        default:
+                            newTargetVas.qty = accInventoriesQty;
+                            newTargetVas.uomValue = accInventoriesQty * unitUomValue;
+                    }
+                }
+                else {
+                    newTargetVas.qty = assignedQty;
+                    newTargetVas.uomValue = assignedQty * unitUomValue;
+                }
+                newTargetVas.set = targetVas.set;
+                newTargetVas.targetType = targetVas.targetType;
+                newTargetVas.targetBatchId = targetVas.targetBatchId;
+                newTargetVas.packingType = targetVas.packingType;
+                newTargetVas.operationGuide = operationGuide ? JSON.stringify(operationGuide) : null;
+                newTargetVas.type = targetVas.type;
+                newTargetVas.remark = targetVas.remark;
+                newTargetVas.status = targetVas.status;
+                newTargetVas.targetProduct = targetVas.targetProduct;
+                newTargetVas.vasOrder = targetVas.vasOrder;
+                newTargetVas.vas = targetVas.vas;
+                newTargetVas.domain = this.domain;
+                newTargetVas.name = sales_base_1.OrderNoGenerator.orderVas();
+                newTargetVas.inventory = foundInventory;
+                newTargetVas.bizplace = bizplace;
+                newTargetVas.creator = this.user;
+                newTargetVas.updater = this.user;
+                newTargetVas = await this.trxMgr.getRepository(sales_base_1.OrderVas).save(newTargetVas);
+                await this.createWorksheetDetails(worksheet, constants_1.WORKSHEET_TYPE.VAS, [newTargetVas]);
+                seq++;
+                // update inventory locked qty & uom value
+                const currentLockedQty = foundInventory.lockedQty || 0;
+                const currentLockedUomValue = foundInventory.lockedUomValue || 0;
+                await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(Object.assign(Object.assign({}, foundInventory), { lockedQty: inventory.qty + currentLockedQty, lockedUomValue: inventory.qty * unitUomValue + currentLockedUomValue, updater: this.user }));
+            }
+            await this.trxMgr.getRepository(entities_1.WorksheetDetail).delete(worksheetDetail.id);
+            await this.trxMgr.getRepository(sales_base_1.OrderVas).delete(targetVas.id);
+        }
+    }
+    async activateVAS(worksheetNo, vasWorksheetDetails) {
+        const worksheet = await this.findWorksheetByNo(worksheetNo, [
+            'vasOrder',
+            'worksheetDetails',
+            'worksheetDetails.targetVas'
+        ]);
+        const worksheetDetails = worksheet.worksheetDetails;
+        const targetVass = worksheetDetails.map((wsd) => {
+            let targetVas = wsd.targetVas;
+            targetVas.status = sales_base_1.ORDER_VAS_STATUS.PROCESSING;
+            targetVas.updater = this.user;
+            return targetVas;
+        });
+        // Update VAS Order if it's pure VAS Order (status: READY_TO_PROCESS => PROCESSING)
+        let vasOrder = worksheet.vasOrder;
+        if (vasOrder === null || vasOrder === void 0 ? void 0 : vasOrder.id) {
+            vasOrder.status = sales_base_1.ORDER_STATUS.PROCESSING;
+            vasOrder.updater = this.user;
+            await this.updateRefOrder(vasOrder);
+        }
+        await this.updateOrderTargets(targetVass);
+        return worksheet;
+    }
+    async unpackingWithPallet(worksheetDetailName, childProduct, unpackQty, unpackUomValue, palletId, locationName, refOrder) {
+        await this.checkPalletDuplication(palletId);
+        const worksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).findOne({
+            where: {
+                name: worksheetDetailName,
+                type: constants_1.WORKSHEET_TYPE.VAS,
+                status: (0, typeorm_1.Not)((0, typeorm_1.Equal)(constants_1.WORKSHEET_STATUS.DEACTIVATED))
+            },
+            relations: ['bizplace', 'worksheet', 'worksheet.vasOrder', 'targetVas', 'targetVas.inventory']
+        });
+        if (!worksheetDetail)
+            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName));
+        const targetVas = worksheetDetail.targetVas;
+        const bizplace = worksheetDetail.bizplace;
+        const location = await this.trxMgr.getRepository(warehouse_base_1.Location).findOne({
+            where: {
+                domain: this.domain,
+                name: locationName,
+                type: (0, typeorm_1.In)([warehouse_base_1.LOCATION_TYPE.SHELF, warehouse_base_1.LOCATION_TYPE.BUFFER, warehouse_base_1.LOCATION_TYPE.FLOOR])
+            },
+            relations: ['warehouse']
+        });
+        if (!location)
+            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName));
+        const warehouse = location.warehouse;
+        const zone = location.zone;
+        // create new unpacked inventory
+        let newInventory = new warehouse_base_1.Inventory();
+        newInventory.bizplace = bizplace;
+        newInventory.name = warehouse_base_1.InventoryNoGenerator.inventoryName();
+        newInventory.palletId = palletId;
+        newInventory.batchId = worksheetDetail.targetVas.targetBatchId;
+        newInventory.product = childProduct;
+        newInventory.packingType = childProduct.packingType;
+        newInventory.uom = childProduct.primaryUnit;
+        newInventory.remark = null;
+        newInventory.qty = unpackQty;
+        newInventory.uomValue = unpackUomValue * unpackQty;
+        newInventory.refOrderId = refOrder.id;
+        newInventory.warehouse = warehouse;
+        newInventory.location = location;
+        newInventory.zone = zone;
+        newInventory.orderVasId = targetVas.id;
+        newInventory.status = warehouse_base_1.INVENTORY_STATUS.STORED;
+        newInventory = await this.transactionInventory(newInventory, refOrder, newInventory.qty, newInventory.uomValue, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.UNPACKING);
+        // find inventory history that might exist due to undo unpacking process
+        const existInventoryHistories = await this.trxMgr.getRepository(warehouse_base_1.InventoryHistory).find({
+            where: {
+                domain: this.domain,
+                inventory: null,
+                palletId
+            },
+            relations: ['domain', 'inventory']
+        });
+        // if found any, update the inventory id
+        if (existInventoryHistories.length) {
+            existInventoryHistories.forEach(async (invHistory) => {
+                await this.trxMgr.getRepository(warehouse_base_1.InventoryHistory).save(Object.assign(Object.assign({}, invHistory), { inventory: newInventory }));
+            });
+            newInventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(Object.assign(Object.assign({}, newInventory), { lastSeq: Math.max(...existInventoryHistories.map(invHist => invHist.seq)) + 1 }));
+        }
+        // add picking and terminated for unpacking in RO
+        if (refOrder instanceof sales_base_1.ReleaseGood) {
+            newInventory.qty = 0;
+            newInventory.uomValue = 0;
+            newInventory = await this.transactionInventory(newInventory, refOrder, -newInventory.qty, -newInventory.uomValue, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.PICKING);
+            newInventory.status = warehouse_base_1.INVENTORY_STATUS.TERMINATED;
+            await this.transactionInventory(newInventory, refOrder, 0, 0, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.TERMINATED);
+        }
+        // update actual qty and actual uom value of order_vass
+        let actualQty = 0;
+        let actualUomValue = 0;
+        actualQty = Number(targetVas.actualQty) + Number(unpackQty);
+        actualUomValue = Number(targetVas.actualUomValue) + Number(unpackUomValue);
+        let newTargetVas = Object.assign({}, targetVas);
+        newTargetVas.actualQty = actualQty;
+        newTargetVas.actualUomValue = actualUomValue;
+        await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(newInventory);
+        await this.trxMgr.getRepository(sales_base_1.OrderVas).save(newTargetVas);
+    }
+    async executeVAS(worksheetDetail, palletId) {
+        const worksheetDetailName = worksheetDetail.name;
+        let foundWorksheetDetail = await this.findExecutableWorksheetDetailByName(worksheetDetailName, constants_1.WORKSHEET_TYPE.VAS, [
+            'bizplace',
+            'worksheet',
+            'worksheet.arrivalNotice',
+            'worksheet.releaseGood',
+            'targetVas',
+            'targetVas.vas',
+            'targetVas.arrivalNotice',
+            'targetVas.releaseGood',
+            'targetVas.vasOrder',
+            'targetVas.targetProduct',
+            'targetVas.inventory'
+        ]);
+        const bizplace = foundWorksheetDetail.bizplace;
+        const worksheet = foundWorksheetDetail.worksheet;
+        if (palletId) {
+            const inventory = await this.checkPalletAcceptable(palletId, worksheet, foundWorksheetDetail);
+            let targetVas = foundWorksheetDetail.targetVas;
+            const totalTargetQty = targetVas.qty;
+            // inventory assigment
+            targetVas.inventory = inventory;
+            // 현재 작업 대상 target vas의 수량을 inventory의 수량 만큼 감소 시킴
+            targetVas.qty = inventory.qty;
+            targetVas = await this.trxMgr.getRepository(sales_base_1.OrderVas).save(targetVas);
+            // 남은 수량이 있다면 새로운 worksheet detail과 target vas를 생성
+            const remainQty = totalTargetQty - inventory.qty;
+            if (remainQty > 0) {
+                let newTargetVas = Object.assign({}, targetVas);
+                delete newTargetVas.id;
+                newTargetVas.domain = this.domain;
+                newTargetVas.bizplace = bizplace;
+                newTargetVas.name = sales_base_1.OrderNoGenerator.orderVas();
+                newTargetVas.qty = remainQty;
+                newTargetVas.creator = this.user;
+                newTargetVas.updater = this.user;
+                newTargetVas = await this.trxMgr.getRepository(sales_base_1.OrderVas).save(newTargetVas);
+                // Create new worksheet detail
+                await this.createWorksheetDetails(worksheet, constants_1.WORKSHEET_TYPE.VAS, [newTargetVas], {
+                    status: foundWorksheetDetail.status
+                });
+            }
+        }
+        const targetVas = foundWorksheetDetail.targetVas;
+        if (!targetVas)
+            throw new Error(`VAS doesn't exists`);
+        const inventory = foundWorksheetDetail.targetVas.inventory;
+        // reset lockedQty if there's inventory found
+        if (inventory &&
+            inventory.lockedQty >= targetVas.qty &&
+            targetVas.vas.operationGuide &&
+            targetVas.vas.operationGuide !== 'vas-repack' &&
+            targetVas.vas.operationGuide !== 'vas-repack-relabel') {
+            await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(Object.assign(Object.assign({}, inventory), { lockedQty: inventory.lockedQty - targetVas.qty, lockedUomValue: inventory.lockedUomValue - targetVas.uomValue }));
+        }
+        // 1. update status of worksheetDetail (EXECUTING => DONE)
+        foundWorksheetDetail = Object.assign(foundWorksheetDetail, worksheetDetail);
+        foundWorksheetDetail.status = constants_1.WORKSHEET_STATUS.DONE;
+        foundWorksheetDetail.updater = this.user;
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(foundWorksheetDetail);
+        // 2. update vas
+        targetVas.status = sales_base_1.ORDER_VAS_STATUS.COMPLETED;
+        targetVas.updater = this.user;
+        await this.updateOrderTargets([targetVas]);
+    }
+    async undoVAS(worksheetDetail) {
+        const worksheetDetailName = worksheetDetail.name;
+        worksheetDetail = await this.findWorksheetDetailByName(worksheetDetailName, [
+            'worksheet',
+            'targetVas',
+            'targetVas.vas',
+            'targetVas.vasOrder',
+            'targetVas.inventory'
+        ]);
+        this.checkRecordValidity(worksheetDetail, { status: constants_1.WORKSHEET_STATUS.DONE, type: constants_1.WORKSHEET_TYPE.VAS });
+        let targetVas = worksheetDetail.targetVas;
+        const inventory = targetVas.inventory;
+        // update lockedQty if there's inventory found
+        if (inventory) {
+            await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(Object.assign(Object.assign({}, inventory), { lockedQty: inventory.lockedQty + targetVas.qty, lockedUomValue: inventory.lockedUomValue + targetVas.uomValue }));
+        }
+        targetVas.status = sales_base_1.ORDER_VAS_STATUS.PROCESSING;
+        targetVas.updater = this.user;
+        await this.updateOrderTargets([targetVas]);
+        worksheetDetail.status = constants_1.WORKSHEET_STATUS.EXECUTING;
+        worksheetDetail.issue = '';
+        worksheetDetail.updater = this.user;
+        await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetail);
+    }
+    async undoVasInventory(worksheetDetailName, palletId) {
+        const worksheetDetail = await this.findWorksheetDetailByName(worksheetDetailName, [
+            'domain',
+            'bizplace',
+            'worksheet',
+            'targetVas',
+            'targetVas.vas',
+            'targetVas.vasOrder',
+            'targetVas.inventory'
+        ]);
+        const bizplace = worksheetDetail.bizplace;
+        const targetVas = worksheetDetail.targetVas;
+        const { arrivalNotice, releaseGood, vasOrder } = targetVas;
+        const refOrder = arrivalNotice || releaseGood || vasOrder;
+        let vasInventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).findOne({
+            where: {
+                domain: this.domain,
+                bizplace,
+                orderVasId: targetVas.id,
+                palletId
+            }
+        });
+        let newTargetVas = new sales_base_1.OrderVas();
+        newTargetVas.id = targetVas.id;
+        newTargetVas.name = targetVas.name;
+        newTargetVas.description = targetVas.description;
+        newTargetVas.set = targetVas.set;
+        newTargetVas.targetType = targetVas.targetType;
+        newTargetVas.targetBatchId = targetVas.targetBatchId;
+        newTargetVas.packingType = targetVas.packingType;
+        newTargetVas.operationGuide = targetVas.operationGuide;
+        newTargetVas.type = targetVas.type;
+        newTargetVas.remark = targetVas.remark;
+        newTargetVas.status = targetVas.status;
+        newTargetVas.targetProduct = targetVas.targetProduct;
+        newTargetVas.vasOrder = targetVas.vasOrder;
+        newTargetVas.vas = targetVas.vas;
+        newTargetVas.domain = this.domain;
+        newTargetVas.name = targetVas.name;
+        newTargetVas.qty = targetVas.qty;
+        newTargetVas.uomValue = targetVas.uomValue;
+        newTargetVas.inventory = targetVas.inventory;
+        newTargetVas.bizplace = bizplace;
+        newTargetVas.creator = this.user;
+        newTargetVas.updater = this.user;
+        newTargetVas.actualQty = targetVas.actualQty - vasInventory.qty;
+        newTargetVas.actualUomValue =
+            targetVas.actualUomValue - Math.round((vasInventory.uomValue / vasInventory.qty) * 100) / 100;
+        vasInventory.lastSeq++;
+        vasInventory.status = warehouse_base_1.INVENTORY_STATUS.DELETED;
+        vasInventory = await this.transactionInventory(vasInventory, refOrder, -vasInventory.qty, -vasInventory.uomValue, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.UNDO_UNPACKING);
+        // vasInventory.qty = 0
+        // vasInventory.weight = 0
+        // vasInventory.uomValue = 0
+        // vasInventory.updater = this.user
+        await this.updateOrderTargets([newTargetVas]);
+        await this.trxMgr.getRepository(warehouse_base_1.InventoryHistory).update({ inventory: vasInventory }, { inventory: null });
+        await this.trxMgr.getRepository(warehouse_base_1.Inventory).delete({ id: vasInventory.id });
+    }
+    async checkPalletAcceptable(palletId, worksheet, worksheetDetail) {
+        // inventory가 존재해야함
+        const inventory = await this.trxMgr.getRepository(warehouse_base_1.Inventory).findOne({
+            where: { domain: this.domain, palletId },
+            relations: ['product']
+        });
+        if (!inventory)
+            throw new Error(`Can't find inventory by pallet ID (${palletId})`);
+        // 현재 작업 set에서 하나라도 모두 완료된 유형의 VAS가 존재할 경우
+        // 해당 VAS를 처리한 pallet 리스트에 한하여 작업을 수행 해야함 (동일한 SET는 동일한 군집의 Pallet을 대상으로 처리되어야 하기 때문에)
+        worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne(worksheet.id, {
+            relations: [
+                'worksheetDetails',
+                'worksheetDetails.targetVas',
+                'worksheetDetails.targetVas.inventory',
+                'worksheetDetails.targetVas.vas'
+            ]
+        });
+        const vasIds = worksheet.worksheetDetails
+            .filter((wsd) => wsd.targetVas.set === worksheetDetail.targetVas.set)
+            .map((wsd) => wsd.targetVas.vas.id);
+        let completedCnt = {};
+        vasIds.forEach((vasId) => (completedCnt[vasId] = 0));
+        worksheet.worksheetDetails.forEach((wsd) => {
+            if (wsd.status !== constants_1.WORKSHEET_STATUS.DONE) {
+                completedCnt[wsd.targetVas.vas.id]++;
+            }
+        });
+        let finishedVasId;
+        for (let vasId in completedCnt) {
+            if (completedCnt[vasId] === 0) {
+                finishedVasId = vasId;
+                break;
+            }
+        }
+        if (finishedVasId) {
+            const availPalletIds = worksheet.worksheetDetails
+                .filter((wsd) => wsd.targetVas.vas.id === finishedVasId)
+                .map((wsd) => wsd.targetVas.inventory.palletId);
+            if (availPalletIds.indexOf(inventory.palletId) >= 0) {
+                return inventory;
+            }
+            else {
+                throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('execute VAS', `${palletId} is not suitable for doing this VAS`));
+            }
+        }
+        // refOrder에 따라 적절한 상태를 가지고 있어야함
+        // Arrival Notice = 'PARTIALLY_UNLOADED or PUTTING_AWAY
+        const refOrder = worksheet.arrivalNotice || worksheet.releaseGood;
+        if (refOrder instanceof sales_base_1.ArrivalNotice) {
+            const acceptableStatus = [warehouse_base_1.INVENTORY_STATUS.PARTIALLY_UNLOADED, warehouse_base_1.INVENTORY_STATUS.PUTTING_AWAY];
+            if (acceptableStatus.indexOf(inventory.status) < 0)
+                throw new Error(`The pallet doesn't have right status for doing VAS`);
+        }
+        else if (refOrder instanceof sales_base_1.ReleaseGood) {
+            throw new Error('TODO: Status check for Release Good');
+        }
+        // target vas의 조건에 충족해야 함 (targetBatchId, targetProduct)
+        const { targetBatchId, targetProduct } = worksheetDetail.targetVas;
+        if (targetBatchId && targetBatchId !== inventory.batchId) {
+            throw new Error(`The pallet (${inventory.palletId}) doesn't have correct batch ID (${targetBatchId})`);
+        }
+        if ((targetProduct === null || targetProduct === void 0 ? void 0 : targetProduct.id) && targetProduct.id !== inventory.product.id) {
+            throw new Error(`The pallet (${inventory.palletId}) doesn't have correct product (${targetProduct.name})`);
+        }
+        // reference order와 관계되어 있는 inventory여야 함
+        if (refOrder instanceof sales_base_1.ArrivalNotice) {
+            if (inventory.refOrderId !== refOrder.id)
+                throw new Error(`The pallet ${inventory.palletId} is not related with GAN (${refOrder.name})`);
+        }
+        // 다른 vas order set에 포함되어 있지 않아야함
+        const relatedInvs = worksheet.worksheetDetails
+            .filter((wsd // 현재 작업대상이 아니고 현재 작업 대상과 같은 세트가 아니고 인벤토리 값이 있는
+        ) => wsd.id !== worksheetDetail.id &&
+            wsd.targetVas.set !== worksheetDetail.targetVas.set &&
+            wsd.targetVas.inventory)
+            .map((wsd) => wsd.targetVas.inventory);
+        if (relatedInvs.find((relInv) => relInv.palletId === inventory.palletId)) {
+            throw new Error(`The pallet (${inventory.palletId}) is already assigned for another VAS SET`);
+        }
+        // 현재 작업유형에 동이한 pallet으로 처리된 이력이 없어야함
+        const completedWSD = worksheet.worksheetDetails.filter((wsd) => wsd.status === constants_1.WORKSHEET_STATUS.DONE &&
+            wsd.targetVas.set === worksheetDetail.targetVas.set &&
+            wsd.targetVas.vas.id === worksheetDetail.targetVas.vas.id);
+        if (completedWSD.find((wsd) => wsd.targetVas.inventory.palletId === palletId)) {
+            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('execute VAS', `VAS is finished for pallet (${palletId}) already`));
+        }
+        return inventory;
+    }
+    async completeVAS(tx, domain, user, orderNo, orderType, vasWorksheetDetails) {
+        var _a;
+        const ENTITY_MAP = {
+            [sales_base_1.ORDER_TYPES.ARRIVAL_NOTICE]: sales_base_1.ArrivalNotice,
+            [sales_base_1.ORDER_TYPES.RELEASE_OF_GOODS]: sales_base_1.ReleaseGood,
+            [sales_base_1.ORDER_TYPES.VAS_ORDER]: sales_base_1.VasOrder
+        };
+        let saveOrderInventory = [];
+        let refOrder = await this.findRefOrder(ENTITY_MAP[orderType], {
+            domain: this.domain,
+            name: orderNo
+        });
+        let worksheet = await this.findWorksheetByRefOrder(refOrder, constants_1.WORKSHEET_TYPE.VAS, [
+            'worksheetDetails',
+            'worksheetDetails.targetVas',
+            'worksheetDetails.targetVas.vas',
+            'worksheetDetails.targetVas.inventory',
+            'worksheetDetails.targetVas.orderVasItems',
+            'worksheetDetails.targetVas.orderVasItems.vas'
+        ]);
+        const isPureVAS = refOrder instanceof sales_base_1.VasOrder;
+        if (isPureVAS) {
+            refOrder.status = sales_base_1.ORDER_STATUS.DONE;
+            await this.updateRefOrder(refOrder);
+        }
+        // Do complete operation transactions if there it is
+        let foundWorksheetDetails = worksheet.worksheetDetails;
+        let targetVASs = foundWorksheetDetails.map((wsd) => wsd.targetVas);
+        // assign issues brought from execute VAS page to foundWorksheetDetails
+        foundWorksheetDetails = foundWorksheetDetails.map(worksheetDetail => {
+            return Object.assign(Object.assign({}, worksheetDetail), { issue: vasWorksheetDetails.find(wsd => wsd.name === worksheetDetail.name).issue || null });
+        });
+        // reduce parent inventory qty if same parent is selected
+        targetVASs = targetVASs.reduce((acc, curr) => {
+            var _a, _b;
+            if (curr.inventory) {
+                for (let i = 0; i < acc.length; i++) {
+                    if (((_a = acc[i].inventory) === null || _a === void 0 ? void 0 : _a.id) === ((_b = curr.inventory) === null || _b === void 0 ? void 0 : _b.id)) {
+                        curr.inventory.qty -= acc[i].qty;
+                        curr.inventory.uomValue -= acc[i].uomValue;
+                        curr.inventory.lockedQty -= acc[i].qty;
+                        curr.inventory.lockedUomValue -= acc[i].uomValue;
+                    }
+                }
+            }
+            acc.push(curr);
+            return acc;
+        }, []);
+        for (const targetVas of targetVASs) {
+            if (targetVas.vas) {
+                // for old vas--> can be removed later
+                const { issue } = foundWorksheetDetails.find((wsd) => wsd.targetVas.id === targetVas.id);
+                // if (targetVas.operationGuide && (!issue || (targetVas.vas.name.toUpperCase() == VAS.REPACKAGING && issue))) {
+                //   await this.doOperationTransaction(targetVas)
+                // } /*else if (targetVas.operationGuide && targetVas.vas.name.toUpperCase() === VAS.REPACKAGING && issue) {
+                //   await this.doOperationTransaction(targetVas)
+                // }*/
+                if (targetVas.operationGuide && !issue) {
+                    await this.doOperationTransaction(targetVas);
+                }
+                if (((_a = targetVas === null || targetVas === void 0 ? void 0 : targetVas.vas) === null || _a === void 0 ? void 0 : _a.name.toUpperCase()) === sales_base_1.VAS.UNPACKING && !(refOrder instanceof sales_base_1.ArrivalNotice)) {
+                    // Update qty and uom value of parent inventory (only applies for pure vas and RO)
+                    const parentInventory = targetVas.inventory;
+                    let newParentInventory = Object.assign({}, parentInventory);
+                    newParentInventory.qty = parentInventory.qty - targetVas.qty;
+                    newParentInventory.uomValue = Math.round((parentInventory.uomValue - targetVas.uomValue) * 100) / 100;
+                    newParentInventory.lockedQty = parentInventory.lockedQty - targetVas.qty;
+                    newParentInventory.lockedUomValue =
+                        Math.round((parentInventory.lockedUomValue - targetVas.uomValue) * 100) / 100;
+                    // update qty and uomValue for VasOrder
+                    // if refOrder is from ReleaseGood, no need to update because this trxn is consider similar to LOADING trxn
+                    if (refOrder instanceof sales_base_1.VasOrder) {
+                        await this.transactionInventory(newParentInventory, refOrder, -targetVas.qty, -targetVas.uomValue, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.UNPACKED);
+                    }
+                    else if (refOrder instanceof sales_base_1.ReleaseGood) {
+                        await (0, warehouse_base_1.generateInventoryHistory)(newParentInventory, refOrder, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.UNPACKED, 0, 0, this.user, this.trxMgr);
+                    }
+                    // add TERMINATED status if inventory qty = 0
+                    if (newParentInventory.qty === 0) {
+                        newParentInventory.status = warehouse_base_1.INVENTORY_STATUS.TERMINATED;
+                        await this.transactionInventory(newParentInventory, refOrder, 0, 0, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.TERMINATED);
+                    }
+                }
+            }
+        }
+        // update worksheet details if there is any issue found from the list
+        if (foundWorksheetDetails.some((wsd) => wsd.issue)) {
+            const worksheetDetails = worksheet.worksheetDetails;
+            foundWorksheetDetails = this.renewWorksheetDetails(worksheetDetails, foundWorksheetDetails, 'name', {
+                updater: this.user
+            });
+            const worksheetDetailsWithIssue = foundWorksheetDetails.filter((wsd) => wsd.issue);
+            if (worksheetDetailsWithIssue.length) {
+                await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetailsWithIssue);
+            }
+        }
+        let orderStatus = refOrder instanceof sales_base_1.ArrivalNotice
+            ? sales_base_1.ORDER_STATUS.READY_TO_UNLOAD
+            : refOrder instanceof sales_base_1.ReleaseGood
+                ? sales_base_1.ORDER_STATUS.LOADING
+                : sales_base_1.ORDER_STATUS.DONE;
+        const releaseGood = await (0, typeorm_1.getRepository)(sales_base_1.ReleaseGood).findOne({
+            domain: domain.id,
+            name: orderNo
+        });
+        let qbOrderVas = await (0, typeorm_1.getRepository)(sales_base_1.OrderVas).createQueryBuilder('ov');
+        qbOrderVas
+            .leftJoinAndSelect(sales_base_1.OrderInventory, 'oi', 'oi.release_good_id = ov.release_good_id')
+            .leftJoinAndSelect('ov.releaseGood', 'releaseGood')
+            .leftJoinAndSelect('ov.product', 'product')
+            .leftJoinAndSelect('ov.productDetail', 'productDetail')
+            .leftJoinAndSelect('ov.newProduct', 'newProduct')
+            .leftJoinAndSelect('ov.newProductDetail', 'newProductDetail')
+            .andWhere('ov.domain_id = :domain')
+            .andWhere('ov.release_good_id = :releaseGood')
+            .andWhere('ov.new_product_id notnull')
+            .andWhere('ov.new_product_detail_id notnull')
+            .setParameters({ domain: domain.id, releaseGood: releaseGood.id });
+        const orderVasWithNewSku = await qbOrderVas.getMany();
+        // .find({
+        //   domain,
+        //   releaseGood,
+        //   newTargetProduct: Not(IsNull()),
+        //   newTargetProductDetail: Not(IsNull())
+        // })
+        if (orderVasWithNewSku.length > 0) {
+            // const productId = orderVasWithNewSku.map(ov => {
+            //   return ov.product.id
+            // })
+            let qbOrderInventories = await (0, typeorm_1.getRepository)(sales_base_1.OrderInventory)
+                .createQueryBuilder('oi')
+                .leftJoinAndSelect('oi.product', 'product')
+                .leftJoinAndSelect('oi.productDetail', 'productDetail')
+                .leftJoinAndSelect('oi.domain', 'domain')
+                .leftJoinAndSelect('oi.bizplace', 'bizplace')
+                .leftJoinAndSelect('oi.releaseGood', 'releaseGood')
+                .leftJoinAndSelect('oi.inventory', 'inventory')
+                .leftJoinAndSelect('oi.orderProduct', 'orderProduct')
+                .andWhere('oi.domain_id = :domain')
+                .andWhere('oi.product_id IN (:...productId)')
+                // .andWhere('inventory.batch_id IN (:...batchId)')
+                .andWhere('oi.release_good_id = :releaseGood')
+                .setParameters({
+                domain: domain.id,
+                productId: orderVasWithNewSku.map(ov => {
+                    return ov.product.id;
+                }),
+                // batchId: orderVasWithNewSku.map(ov => {
+                //   return ov.batchId
+                // }),
+                releaseGood: releaseGood.id
+            });
+            let orderInventoryOrderVas = await qbOrderInventories.getMany();
+            let updateOrderInventory = [];
+            let orderInventory = {};
+            // for saving oi
+            let newTargetInventory = new sales_base_1.OrderInventory();
+            let newOi;
+            // fix inventory
+            orderVasWithNewSku.forEach(ov => {
+                orderInventory = orderInventoryOrderVas.filter(oi => {
+                    if (oi.product.id == ov.product.id && oi.releaseQty > 0 && oi.batchId == ov.batchId) {
+                        if (oi.batchId == ov.batchId) {
+                            return oi;
+                        }
+                    }
+                });
+                let qtyVas = ov.qty;
+                try {
+                    for (let i = 0; qtyVas > 0; i++) {
+                        const oi = orderInventory[i];
+                        //update old OI
+                        const updatedReleaseQty = qtyVas <= oi.releaseQty ? oi.releaseQty - qtyVas : 0;
+                        const updatedReleaseUomValue = parseFloat((updatedReleaseQty * (oi.releaseUomValue / oi.releaseQty)).toFixed(2));
+                        updateOrderInventory = Object.assign(Object.assign({}, oi), { releaseQty: updatedReleaseQty, pickedQty: oi.pickedQty, status: updatedReleaseQty == 0 ? sales_base_1.ORDER_INVENTORY_STATUS.TERMINATED : oi.status, releaseUomValue: updatedReleaseUomValue, updater: user, updatedAt: new Date() });
+                        saveOrderInventory.push(updateOrderInventory);
+                        // Duplicate oi for newSKU =
+                        // new OrderInventory()
+                        const newOiReleaseQty = qtyVas <= oi.releaseQty ? qtyVas : oi.releaseQty;
+                        //can delete
+                        // const newOiReleaseUomValue: number = parseFloat((newOiReleaseQty * (ov.newUomValue / ov.qty)).toFixed(2))
+                        newOi = Object.assign(Object.assign({}, oi), { id: (0, uuid_1.v4)(), name: (0, uuid_1.v4)(), 
+                            // domain: orderInventory.domain,
+                            // bizplace: orderInventory.bizplace,
+                            // releaseGood: orderInventory.releaseGood,
+                            // inventory: orderInventory.inventory,
+                            orderProduct: null, 
+                            // status: orderInventory.status, // can remove
+                            batchId: newOi ? `${newOi.batchId} , ${oi.batchId}` : oi.batchId, type: sales_base_1.ORDER_TYPES.VAS_ORDER, status: sales_base_1.ORDER_INVENTORY_STATUS.LOADING, releaseQty: ov.outputQty, pickedQty: 0, packingType: ov.newPackingType, packingSize: ov.newProductDetail.packingSize, uom: ov.newUom, releaseUomValue: ov.newUomValue, product: ov.newProduct, productId: ov.newProduct.id, productDetail: ov.newProductDetail, creator: user, updater: user, createdAt: new Date(), updatedAt: new Date() });
+                        qtyVas = qtyVas - newOiReleaseQty;
+                        newTargetInventory = newOi;
+                    }
+                    saveOrderInventory.push(newTargetInventory);
+                }
+                catch (e) {
+                    console.log(e);
+                }
+            });
+            await tx.getRepository(sales_base_1.OrderInventory).save(saveOrderInventory);
+            // await tx.getRepository(OrderInventory).save(updateOrderInventory)
+            // .update({ id: orderInventory.id }, updateOrderInventory)
+        }
+        let orderInventories = await tx.getRepository(sales_base_1.OrderInventory).find({
+            where: { domain: domain.id, releaseGood: releaseGood.id, status: (0, typeorm_1.Not)((0, typeorm_1.In)([sales_base_1.ORDER_INVENTORY_STATUS.TERMINATED])) }
+            // relations: ['product', 'productDetail', 'domain', 'bizplace', 'releaseGood', 'inventory', 'orderProduct']
+        });
+        // complete VAS worksheet
+        worksheet = await this.completeWorksheet(worksheet, orderStatus);
+        // generate inventory histories
+        let inventoriesForVas = [];
+        let orderVasWithoutNewSku = await (0, typeorm_1.getRepository)(sales_base_1.OrderVas).find({
+            where: { releaseGood: releaseGood.id, newProduct: null, newProductDetail: null },
+            relations: ['product', 'productDetail']
+        });
+        // invenotries for without newSKu
+        if (orderVasWithoutNewSku.length > 0) {
+            let qbOrderInventoriesWithoutNewSku = await (0, typeorm_1.getRepository)(sales_base_1.OrderInventory)
+                .createQueryBuilder('oi')
+                .leftJoinAndSelect('oi.inventory', 'i')
+                .leftJoinAndSelect('oi.product', 'p')
+                .leftJoinAndSelect('oi.productDetail', 'pd')
+                .leftJoin(sales_base_1.OrderVas, 'ov', 'oi.batch_id = ov.batch_id and oi.product_id = ov.product_id and oi.product_detail_id = ov.product_detail_id')
+                .innerJoin('oi.releaseGood', 'rg')
+                .andWhere('oi.release_good_id = :releaseGood')
+                .andWhere('ov.new_product_id isnull')
+                .andWhere('ov.new_product_detail_id isnull')
+                .setParameters({ releaseGood: releaseGood.id });
+            const orderInventoryVasWithoutNewSku = await qbOrderInventoriesWithoutNewSku.getMany();
+            orderVasWithoutNewSku.forEach(ov => {
+                let orderInventory = orderInventoryVasWithoutNewSku.filter(oi => {
+                    var _a, _b, _c, _d;
+                    const isProductIdMatch = ((_a = ov.product) === null || _a === void 0 ? void 0 : _a.id) === ((_b = oi.product) === null || _b === void 0 ? void 0 : _b.id);
+                    const isProductDetailMatch = ((_c = ov.productDetail) === null || _c === void 0 ? void 0 : _c.id) === ((_d = oi.productDetail) === null || _d === void 0 ? void 0 : _d.id);
+                    const isBatchIdMatch = ov.batchId === oi.batchId;
+                    const hasReleaseQty = oi.releaseQty > 0;
+                    return isProductIdMatch && isProductDetailMatch && hasReleaseQty && isBatchIdMatch;
+                });
+                let qtyVas = ov.qty;
+                for (let i = 0; qtyVas > 0; i++) {
+                    inventoriesForVas.push(orderInventory[i].inventory);
+                    qtyVas = qtyVas - orderInventory[i].releaseQty;
+                }
+            });
+        }
+        // inventories for new SKU
+        if (orderVasWithNewSku.length > 0) {
+            let qbInventoriesWithNewSku = await (0, typeorm_1.getRepository)(warehouse_base_1.Inventory)
+                .createQueryBuilder('i')
+                .innerJoin(sales_base_1.OrderInventory, 'oi', 'oi.inventory_id = i.id and oi.product_id = i.product_id and oi.product_detail_id = i.product_detail_id and i.batch_id = oi.batch_id ')
+                .innerJoin('i.domain', 'domain')
+                .andWhere('i.domain_id = :domain')
+                .andWhere('oi.id IN (:...oiId)')
+                // .andWhere('inventory.batch_id IN (:...batchId)')
+                .setParameters({
+                domain: domain.id,
+                oiId: saveOrderInventory.map(ov => {
+                    return ov.id;
+                })
+            });
+            let inventoryVasWithNewSku = await qbInventoriesWithNewSku.getMany();
+            inventoriesForVas.push(...inventoryVasWithNewSku);
+        }
+        for (let i = 0; i < inventoriesForVas.length; i++) {
+            await (0, warehouse_base_1.generateInventoryHistory)(inventoriesForVas[i], releaseGood, warehouse_base_1.INVENTORY_TRANSACTION_TYPE.VAS_ORDER, 0, 0, this.user, this.trxMgr);
+        }
+        //generate and activate loading worksheet
+        if (releaseGood) {
+            const loadingWSCtrl = new controllers_1.LoadingWorksheetController(tx, domain, user);
+            let loadingWorksheet = await this.generateWorksheet(constants_1.WORKSHEET_TYPE.LOADING, releaseGood, orderInventories, sales_base_1.ORDER_STATUS.LOADING, sales_base_1.ORDER_INVENTORY_STATUS.LOADING);
+            const loadingWorksheetDetails = loadingWorksheet.worksheetDetails;
+            await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails);
+            // here
+            // const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+            // const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+            // await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
+        }
+        return worksheet;
+    }
+    async doOperationTransaction(targetVas) {
+        var _a;
+        const operationGuide = (_a = targetVas.vas) === null || _a === void 0 ? void 0 : _a.operationGuide;
+        if (operationGuide) {
+            await this.COMPLETE_TRX_MAP[operationGuide](this.trxMgr, targetVas, this.user);
+        }
+    }
+}
+exports.VasWorksheetController = VasWorksheetController;
+//# sourceMappingURL=vas-worksheet-controller.js.map