@things-factory/worksheet-base 4.3.649 → 4.3.651

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

@@ -1,1049 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorksheetController = exports.OrderTargetFields = exports.ReferenceOrderFields = void 0;
-const typeorm_1 = require("typeorm");
-const integration_base_1 = require("@things-factory/integration-base");
-const auth_base_1 = require("@things-factory/auth-base");
-const biz_base_1 = require("@things-factory/biz-base");
-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 utils_1 = require("../utils");
-var ReferenceOrderFields;
-(function (ReferenceOrderFields) {
-    ReferenceOrderFields["ArrivalNotice"] = "arrivalNotice";
-    ReferenceOrderFields["ReleaseGood"] = "releaseGood";
-    ReferenceOrderFields["VasOrder"] = "vasOrder";
-    ReferenceOrderFields["InventoryCheck"] = "inventoryCheck";
-    ReferenceOrderFields["ReturnOrder"] = "returnOrder";
-    ReferenceOrderFields["Replenishment"] = "replenishment";
-})(ReferenceOrderFields = exports.ReferenceOrderFields || (exports.ReferenceOrderFields = {}));
-var OrderTargetFields;
-(function (OrderTargetFields) {
-    OrderTargetFields["OrderProduct"] = "targetProduct";
-    OrderTargetFields["OrderInventory"] = "targetInventory";
-    OrderTargetFields["OrderVas"] = "targetVas";
-    OrderTargetFields["InventoryCheckItem"] = "targetInventoryCheckItem";
-})(OrderTargetFields = exports.OrderTargetFields || (exports.OrderTargetFields = {}));
-class WorksheetController {
-    constructor(trxMgr, domain, user) {
-        this.ERROR_MSG = {
-            FIND: {
-                NO_RESULT: (condition) => `There's no results matched with condition ${condition}`,
-                NO_CHILD_RESULT: (condition) => `There's no child result matched with condition ${condition}`,
-                NOT_MATCH: (source, target) => `Unable to find matching ${target} using ${source}`
-            },
-            ORDER_ITEM: {
-                NO_MATCHING_RESULT: (condition, condition2) => `Current item with ${condition} (${condition2}) not belong to this order`,
-                EXCESS_QTY: (condition, condition2, condition3) => `Excess qty is scanned for item ${condition}, ${condition2} (${condition3})`
-            },
-            PRODUCT: {
-                NO_MATCHING_RESULT: (condition, condition2) => `Order packing type and packing size not match with product master, ${condition} (${condition2})`,
-                BARCODE_NOT_EXIST: (condition, condition2, condition3) => `Product barcode - ${condition} with ${condition2} ${condition3}, not exist in master data.`
-            },
-            CREATE: {
-                ID_EXISTS: 'Target has ID already',
-                EMPTY_CREATOR: 'Cannot create without creator',
-                EMPTY_UPDATER: 'Cannot create without updater'
-            },
-            UPDATE: {
-                ID_NOT_EXISTS: `Target doesn't have ID`,
-                EMPTY_UPDATER: 'Cannot update without updater'
-            },
-            VALIDITY: {
-                UNEXPECTED_FIELD_VALUE: (field, expectedValue, actualValue) => `Expected ${field} value is ${expectedValue} but got ${actualValue}`,
-                DUPLICATED: (field, value) => `There is duplicated ${field} value (${value})`,
-                CANT_PROCEED_STEP_BY: (step, reason) => `Can't proceed to ${step} because ${reason}`
-            }
-        };
-        this.ROLE_NAMES = {
-            OFFICE_ADMIN: 'Office Admin'
-        };
-        this.trxMgr = trxMgr;
-        this.domain = domain;
-        this.user = user;
-    }
-    getRefOrderField(refOrder) {
-        if (refOrder instanceof sales_base_1.ArrivalNotice) {
-            return ReferenceOrderFields.ArrivalNotice;
-        }
-        else if (refOrder instanceof sales_base_1.ReleaseGood) {
-            return ReferenceOrderFields.ReleaseGood;
-        }
-        else if (refOrder instanceof sales_base_1.VasOrder) {
-            return ReferenceOrderFields.VasOrder;
-        }
-        else if (refOrder instanceof sales_base_1.InventoryCheck) {
-            return ReferenceOrderFields.InventoryCheck;
-        }
-        else if (refOrder instanceof sales_base_1.ReturnOrder) {
-            return ReferenceOrderFields.ReturnOrder;
-        }
-        else if (refOrder instanceof sales_base_1.Replenishment) {
-            return ReferenceOrderFields.Replenishment;
-        }
-        else {
-            throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('refOrder', 'One of reference order type', refOrder));
-        }
-    }
-    getOrderTargetField(orderTarget) {
-        if (orderTarget instanceof sales_base_1.OrderProduct) {
-            return OrderTargetFields.OrderProduct;
-        }
-        else if (orderTarget instanceof sales_base_1.OrderInventory) {
-            return OrderTargetFields.OrderInventory;
-        }
-        else if (orderTarget instanceof sales_base_1.OrderVas) {
-            return OrderTargetFields.OrderVas;
-        }
-        else if (orderTarget instanceof sales_base_1.InventoryCheckItem) {
-            return OrderTargetFields.InventoryCheckItem;
-        }
-        else {
-            this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('orderTarget', 'One of order target type', orderTarget);
-        }
-    }
-    /**
-     * @summary Find reference order (ArrivalNotice, ReleaseGood, VasOrder, etc...)
-     * @description
-     * Find and return reference order with its relations based on passed condition & reltaions
-     */
-    async findRefOrder(entitySchema, condition, relations) {
-        var _a;
-        condition = this.tidyConditions(condition);
-        let findOption = { where: condition };
-        if ((relations === null || relations === void 0 ? void 0 : relations.length) > 0)
-            findOption.relations = relations;
-        const refOrder = await this.trxMgr.getRepository(entitySchema).findOne(findOption);
-        if (!refOrder)
-            throw new Error(this.ERROR_MSG.FIND.NO_RESULT((_a = findOption === null || findOption === void 0 ? void 0 : findOption.where) === null || _a === void 0 ? void 0 : _a.name));
-        return refOrder;
-    }
-    /**
-     * @summary find worksheet by passed condition
-     * @description find worksheey based on passed condition
-     * It will return worksheetDetail as its relation by default
-     * If you want to get additional relations you need to define reltaions
-     * ex) findWorksheet(condition, ['arrivalNotice', 'releaseGood'])
-     */
-    async findWorksheet(condition, relations = ['worksheetDetails']) {
-        condition = this.tidyConditions(condition);
-        const worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne({
-            where: Object.assign({ domain: this.domain }, condition),
-            relations
-        });
-        if (!worksheet)
-            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(condition));
-        return worksheet;
-    }
-    /**
-     * @summary Find worksheet by passed params
-     * @description Find and return worksheet based on passed ID
-     * It will return worksheetDetail as its relation by default
-     * If you want to get additional relations you need to define reltaions
-     * ex) findWorksheetById(id, ['arrivalNotice', 'releaseGood'])
-     */
-    async findWorksheetById(id, relations = ['worksheetDetails']) {
-        const worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne(id, { relations });
-        if (!worksheet)
-            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(id));
-        return worksheet;
-    }
-    /**
-     * @summary Find worksheet by passed params
-     * @description Find and return worksheet based on worksheet no
-     * It will return worksheetDetail as its relation by default
-     * If you want to get additional relations you need to define reltaions
-     * ex) findWorksheetByNo(worksheetNo, ['arrivalNotice', 'releaseGood'])
-     */
-    async findWorksheetByNo(worksheetNo, relations = ['worksheetDetails']) {
-        const worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne({
-            where: { domain: this.domain, name: worksheetNo },
-            relations
-        });
-        if (!worksheet)
-            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetNo));
-        return worksheet;
-    }
-    /**
-     * @summary Find worksheet by passed params.
-     * @description Find and return worksheet based on worksheet no
-     * It will return worksheetDetail as its relation by default
-     * If you want to get additional relations you need to define reltaions
-     * ex) findWorksheetByNo(worksheetNo, ['arrivalNotice', 'releaseGood'])
-     */
-    async findWorksheetByRefOrder(refOrder, type, relations = ['worksheetDetails']) {
-        var _a;
-        const refOrderField = this.getRefOrderField(refOrder);
-        if (!((_a = refOrder.bizplace) === null || _a === void 0 ? void 0 : _a.id)) {
-            switch (refOrderField) {
-                case ReferenceOrderFields.ArrivalNotice:
-                    refOrder = await this.findRefOrder(sales_base_1.ArrivalNotice, refOrder, ['bizplace']);
-                    break;
-                case ReferenceOrderFields.ReleaseGood:
-                    refOrder = await this.findRefOrder(sales_base_1.ReleaseGood, refOrder, ['bizplace']);
-                    break;
-                case ReferenceOrderFields.VasOrder:
-                    refOrder = await this.findRefOrder(sales_base_1.VasOrder, refOrder, ['bizplace']);
-                    break;
-                case ReferenceOrderFields.InventoryCheck:
-                    refOrder = await this.findRefOrder(sales_base_1.InventoryCheck, refOrder, ['bizplace']);
-                    break;
-                case ReferenceOrderFields.ReturnOrder:
-                    refOrder = await this.findRefOrder(sales_base_1.ReturnOrder, refOrder, ['bizplace']);
-                    break;
-                case ReferenceOrderFields.Replenishment:
-                    refOrder = await this.findRefOrder(sales_base_1.Replenishment, refOrder, ['bizplace']);
-                    break;
-            }
-        }
-        const bizplace = refOrder === null || refOrder === void 0 ? void 0 : refOrder.bizplace;
-        const condition = {
-            where: {
-                bizplace: bizplace ? bizplace : null,
-                domain: this.domain,
-                type,
-                [refOrderField]: refOrder
-            },
-            relations
-        };
-        const worksheet = await this.trxMgr.getRepository(entities_1.Worksheet).findOne(condition);
-        if (!worksheet)
-            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(type));
-        return worksheet;
-    }
-    /**
-     * @summary Find activatable worksheet by worksheet no and type
-     * @description Find worksheet by passed worksheet no
-     * and check validity by passed type and status (DEACTIVATED)
-     * It will return worksheetDetail as its relation by default
-     * If you want to get additional relations you need to define reltaions
-     * ex) findActivatableWorksheet(worksheetNo, type, ['arrivalNotice])
-     */
-    async findActivatableWorksheet(worksheetNo, type, relations = ['worksheetDetails']) {
-        const worksheet = await this.findWorksheetByNo(worksheetNo, relations);
-        this.checkRecordValidity(worksheet, { type, status: constants_1.WORKSHEET_STATUS.DEACTIVATED });
-        return worksheet;
-    }
-    /**
-     * @summary Find executable worksheet detail by its name
-     * @description Find worksheet detail by passwd worksheet detail name
-     * and check validity by passed type and status (EXECUTING)
-     * If you want to get additional relations you need to define relations
-     * ex) findExecutableWorksheetDetailByName(worksheetDetailName, type, ['arrivalNotice'])
-     */
-    async findActivatableWorksheetDetailByName(worksheetDetailName, type, relations = []) {
-        const worksheetDetail = await this.findWorksheetDetailByName(worksheetDetailName, relations);
-        this.checkRecordValidity(worksheetDetail, { type, status: constants_1.WORKSHEET_STATUS.DEACTIVATED });
-        return worksheetDetail;
-    }
-    /**
-     * @summary find worksheet detail by passed condition
-     * @description find worksheet detail based on passed condition
-     * If you want to get additional relations you need to define reltaions
-     * ex) findWorksheetDetail(condition, ['worksheet'])
-     */
-    async findWorksheetDetail(condition, relations) {
-        condition = this.tidyConditions(condition);
-        const worksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).findOne({
-            where: Object.assign({ domain: this.domain }, condition),
-            relations
-        });
-        if (!worksheetDetail)
-            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(condition));
-        return worksheetDetail;
-    }
-    /**
-     * @summary find worksheet detail by passed worksheet detail name
-     * @description find worksheey based on passed name of worksheet detail
-     * If you want to get additional relations you need to define reltaions
-     * ex) findWorksheetDetail(condition, ['worksheet'])
-     */
-    async findWorksheetDetailByName(worksheetDetailName, relations) {
-        const worksheetDetail = await this.trxMgr.getRepository(entities_1.WorksheetDetail).findOne({
-            where: { domain: this.domain, name: worksheetDetailName },
-            relations
-        });
-        if (!worksheetDetail)
-            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName));
-        return worksheetDetail;
-    }
-    async findWorksheetDetailByNames(worksheetDetailNames, relations) {
-        const worksheetDetails = await this.trxMgr.getRepository(entities_1.WorksheetDetail).find({
-            where: { domain: this.domain, name: (0, typeorm_1.In)(worksheetDetailNames) },
-            relations
-        });
-        if (!(worksheetDetails === null || worksheetDetails === void 0 ? void 0 : worksheetDetails.length))
-            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailNames.toString()));
-        return worksheetDetails;
-    }
-    /**
-     * @summary Find executable worksheet detail by its name
-     * @description Find worksheet detail by passwd worksheet detail name
-     * and check validity by passed type and status (EXECUTING)
-     * If you want to get additional relations you need to define relations
-     * ex) findExecutableWorksheetDetailByName(worksheetDetailName, type, ['arrivalNotice'])
-     */
-    async findExecutableWorksheetDetailByName(worksheetDetailName, type, relations = []) {
-        const worksheetDetail = await this.findWorksheetDetailByName(worksheetDetailName, relations);
-        this.checkRecordValidity(worksheetDetail, { type, status: constants_1.WORKSHEET_STATUS.EXECUTING });
-        return worksheetDetail;
-    }
-    async findExecutableWorksheetDetailByNames(worksheetDetailNames, type, relations = []) {
-        const worksheetDetails = await this.findWorksheetDetailByNames(worksheetDetailNames, relations);
-        worksheetDetails.map(worksheetDetail => {
-            this.checkRecordValidity(worksheetDetail, { type, status: constants_1.WORKSHEET_STATUS.EXECUTING });
-        });
-        return worksheetDetails;
-    }
-    /**
-     * @summary Creating worksheet
-     * @description creating worksheet by passed params
-     * It will set status as DEACTIVATED by default
-     * If you want to define status by yourself, need to pass status in additionalProps
-     * ex) createWorksheet(refOrder, type, { status: WORKSHEET_STATUS.ACTIVATED })
-     */
-    async createWorksheet(refOrder, type, additionalProps = {}) {
-        let refOrderType = await this.getRefOrderField(refOrder);
-        let bizplace = await this.extractBizplaceFromRefOrder(refOrder);
-        let existingWorksheet;
-        try {
-            existingWorksheet = await this.findWorksheetByRefOrder(refOrder, type);
-        }
-        catch (e) { }
-        if (existingWorksheet)
-            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY(`create ${type.toLocaleLowerCase()} worksheet`, 'existing worksheet is found'));
-        const worksheet = Object.assign({ domain: this.domain, bizplace: bizplace ? bizplace : null, name: utils_1.WorksheetNoGenerator.generate(type), type, status: (refOrderType == 'replenishment' && type == constants_1.WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT) || type == constants_1.WORKSHEET_TYPE.VAS
-                ? constants_1.WORKSHEET_STATUS.EXECUTING
-                : constants_1.WORKSHEET_STATUS.DEACTIVATED, creator: this.user, updater: this.user, [refOrderType]: refOrder }, additionalProps);
-        if (worksheet.id)
-            throw new Error(this.ERROR_MSG.CREATE.ID_EXISTS);
-        return await this.trxMgr.getRepository(entities_1.Worksheet).save(worksheet);
-    }
-    async createBatchWorksheet(taskNo, bizplace, type, additionalProps = {}) {
-        const worksheet = Object.assign({ domain: this.domain, bizplace, name: utils_1.WorksheetNoGenerator.generate(type), type,
-            taskNo, status: constants_1.WORKSHEET_STATUS.DEACTIVATED, creator: this.user, updater: this.user }, additionalProps);
-        if (worksheet.id)
-            throw new Error(this.ERROR_MSG.CREATE.ID_EXISTS);
-        return await this.trxMgr.getRepository(entities_1.Worksheet).save(worksheet);
-    }
-    /**
-     * @summary Creating worksheet details
-     * @description creating worksheet details by passed params
-     * It will set status as DEACTIVATED by default
-     * If you want to define status by yourself, need to pass status in additionalProps
-     * ex) createWorksheetDetails(refOrder, type, { status: WORKSHEET_STATUS.ACTIVATED })
-     *
-     */
-    async createWorksheetDetails(worksheet, type, orderTargets, additionalProps = {}) {
-        worksheet = await this.findWorksheetById(worksheet.id, ['bizplace']);
-        const bizplace = worksheet.bizplace;
-        const worksheetDetails = orderTargets.map((orderTarget) => {
-            const orderTargetField = this.getOrderTargetField(orderTarget);
-            return Object.assign({ domain: this.domain, bizplace: bizplace ? bizplace : orderTarget.bizplace, worksheet, name: utils_1.WorksheetNoGenerator.generate(type, true), type, status: type == constants_1.WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT || type == constants_1.WORKSHEET_TYPE.VAS
-                    ? constants_1.WORKSHEET_STATUS.EXECUTING
-                    : constants_1.WORKSHEET_STATUS.DEACTIVATED, [orderTargetField]: orderTarget, creator: this.user, updater: this.user }, additionalProps);
-        });
-        if (worksheetDetails.some((wsd) => wsd.id))
-            throw new Error(this.ERROR_MSG.CREATE.ID_EXISTS);
-        return await this.trxMgr.getRepository(entities_1.WorksheetDetail).save(worksheetDetails);
-    }
-    /**
-     * @summary Update reference order (ArrivalNotice, ReleaseGood, VasOrder, InventoryCheck)
-     * @description
-     * Update reference order like (ArrivalNotice, ReleaseGood, VasOrder, InventoryCheck)
-     */
-    async updateRefOrder(refOrder, entitySchema, currentStatus) {
-        var _a;
-        if (!entitySchema) {
-            if (refOrder instanceof sales_base_1.ArrivalNotice) {
-                entitySchema = sales_base_1.ArrivalNotice;
-            }
-            else if (refOrder instanceof sales_base_1.ReleaseGood) {
-                entitySchema = sales_base_1.ReleaseGood;
-            }
-            else if (refOrder instanceof sales_base_1.VasOrder) {
-                entitySchema = sales_base_1.VasOrder;
-            }
-            else if (refOrder instanceof sales_base_1.InventoryCheck) {
-                entitySchema = sales_base_1.InventoryCheck;
-            }
-            else if (refOrder instanceof sales_base_1.ReturnOrder) {
-                entitySchema = sales_base_1.ReturnOrder;
-            }
-            else if (refOrder instanceof sales_base_1.Replenishment) {
-                entitySchema = sales_base_1.Replenishment;
-            }
-        }
-        if (!refOrder.id)
-            throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS);
-        if (!((_a = refOrder.updater) === null || _a === void 0 ? void 0 : _a.id))
-            refOrder = this.setStamp(refOrder);
-        if (currentStatus && entitySchema == sales_base_1.ReleaseGood) {
-            let res = await (0, typeorm_1.getRepository)(entitySchema).query(`
-        update release_goods
-        set status = $1
-        where id = $2
-        and status = $3
-        returning id
-      `, [refOrder.status, refOrder.id, currentStatus]);
-            if (res[1] == 0) {
-                this.trxMgr.queryRunner.rollbackTransaction();
-                throw new Error('Worksheet has already been created');
-            }
-        }
-        return await this.trxMgr.getRepository(entitySchema).save(refOrder);
-    }
-    /**
-     * @summary Update order targets (OrderProduct, OrderInventory, OrderVas, InventoryCheckItem)
-     * @description
-     * Update order targets like (OrderProduct, OrderInventory, OrderVas, InventoryCheckItem)
-     */
-    async updateOrderTargets(orderTargets, entitySchema) {
-        if (orderTargets.some((orderTarget) => !orderTarget.id))
-            throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS);
-        orderTargets.forEach((orderTarget) => {
-            var _a;
-            if (!((_a = orderTarget.updater) === null || _a === void 0 ? void 0 : _a.id))
-                orderTarget = this.setStamp(orderTarget);
-        });
-        if (!entitySchema) {
-            if (orderTargets[0] instanceof sales_base_1.OrderProduct) {
-                entitySchema = sales_base_1.OrderProduct;
-            }
-            else if (orderTargets[0] instanceof sales_base_1.OrderInventory) {
-                entitySchema = sales_base_1.OrderInventory;
-            }
-            else if (orderTargets[0] instanceof sales_base_1.OrderVas) {
-                entitySchema = sales_base_1.OrderVas;
-            }
-            else if (orderTargets[0] instanceof sales_base_1.InventoryCheckItem) {
-                entitySchema = sales_base_1.InventoryCheckItem;
-            }
-        }
-        if (!entitySchema) {
-            throw new Error('updateOrderTargets - missing entity Schema.');
-        }
-        if (entitySchema === sales_base_1.OrderProduct) {
-            // update all order targets with 1 action
-            await Promise.all(orderTargets.map(async (orderTarget) => {
-                // Exclude the relationId field from the update
-                delete orderTarget.domainId,
-                    delete orderTarget.bizplaceId,
-                    delete orderTarget.arrivalNoticeId,
-                    delete orderTarget.releaseGoodId,
-                    delete orderTarget.replenishmentId,
-                    delete orderTarget.draftReleaseGoodId,
-                    delete orderTarget.collectionOrderId,
-                    delete orderTarget.purchaseOrderId,
-                    delete orderTarget.retailReplenishmentOrderId,
-                    delete orderTarget.deliveryOrderId,
-                    delete orderTarget.fromInventoryId,
-                    delete orderTarget.currentInventoryId,
-                    delete orderTarget.toInventoryId,
-                    delete orderTarget.productId,
-                    delete orderTarget.productDetailId,
-                    delete orderTarget.productBundleId,
-                    delete orderTarget.creatorId,
-                    delete orderTarget.updaterId;
-                try {
-                    await this.trxMgr.getRepository(sales_base_1.OrderProduct).update({
-                        id: orderTarget.id
-                    }, orderTarget);
-                }
-                catch (error) {
-                    console.error(error);
-                }
-            }));
-            // Find all based on Ids
-            return await this.trxMgr.getRepository(entitySchema).findByIds(orderTargets.map(ot => ot.id));
-        }
-        else {
-            return await this.trxMgr.getRepository(entitySchema).save(orderTargets);
-        }
-    }
-    /**
-     * @summary generate worksheet and worksheet details
-     * @description It will generate worksheet and worksheet details in onetime
-     * Step 1. Call createWorksheet to create worksheet
-     *  The status of worksheet will be DEACTIVATED by default
-     *  You can change it through passing additionalProps
-     * Step 2. Update status of order targets
-     *  Beacuse its status can be different based on type of worksheet
-     * Step 3. Call createWorksheetDetails to create worksheet details
-     * Step 4. Call updateRefOrder to change status of reference order
-     */
-    async generateWorksheet(worksheetType, refOrder, orderTargets, refOrderStatus, orderTargetStatus, additionalProps = {}) {
-        const worksheet = await this.createWorksheet(refOrder, worksheetType, additionalProps);
-        orderTargets.forEach((orderTarget) => {
-            orderTarget.status = orderTargetStatus;
-        });
-        orderTargets = await this.updateOrderTargets(orderTargets);
-        worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, worksheetType, orderTargets);
-        refOrder.status = refOrderStatus;
-        await this.updateRefOrder(refOrder);
-        return worksheet;
-    }
-    async updateLoadWorksheet(worksheetType, refOrder, worksheet, orderTargets, refOrderStatus, orderTargetStatus) {
-        let newOrderTarget = [];
-        orderTargets.forEach((orderTarget) => {
-            orderTarget.status = orderTargetStatus;
-        });
-        orderTargets = await this.updateOrderTargets(orderTargets);
-        for (let orderTarget of orderTargets) {
-            try {
-                await this.findWorksheetDetail({
-                    targetInventory: orderTarget.id,
-                    type: constants_1.WORKSHEET_TYPE.LOADING
-                });
-            }
-            catch (e) {
-                newOrderTarget.push(orderTarget);
-            }
-        }
-        worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, worksheetType, newOrderTarget);
-        // find worksheet details that doesnt exist based on order inventory
-        //worksheet.worksheetDetails = await this.findWorksheetDetail(worksheet.id)
-        refOrder.status = refOrderStatus;
-        await this.updateRefOrder(refOrder);
-        return worksheet;
-    }
-    async generateBatchWorksheet(worksheetType, batchPickingWorksheet, orderTargets, orderTargetStatus, additionalProps = {}) {
-        const worksheet = await this.createBatchWorksheet(batchPickingWorksheet.taskNo, batchPickingWorksheet.bizplace, worksheetType, additionalProps);
-        orderTargets.forEach((orderTarget) => {
-            orderTarget.status = orderTargetStatus;
-        });
-        orderTargets = await this.updateOrderTargets(orderTargets);
-        worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, worksheetType, orderTargets);
-        return worksheet;
-    }
-    /**
-     * @summary Activate worksheet
-     * @description It will activate passed worksheet
-     * Every passed worksheet and worksheet details should have value on its id field
-     * Because this function has logic to update worksheet and worksheet details
-     * Step 1. Check whether every passed worksheet and worksheet details has id
-     * Step 2. Change worksheet properly and update it
-     * Step 3. Change worksheet details properly and update it
-     */
-    async activateWorksheet(worksheet, worksheetDetails, changedWorksheetDetails, tx) {
-        const transaction = tx ? tx : this.trxMgr;
-        if (!worksheet.id || worksheetDetails.some((wsd) => !wsd.id)) {
-            throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS);
-        }
-        worksheet.status = constants_1.WORKSHEET_STATUS.EXECUTING;
-        worksheet.startedAt = new Date();
-        worksheet.updater = this.user;
-        worksheet = await transaction.getRepository(entities_1.Worksheet).save(worksheet);
-        worksheetDetails = this.renewWorksheetDetails(worksheetDetails, changedWorksheetDetails, 'name', {
-            status: constants_1.WORKSHEET_STATUS.EXECUTING,
-            updater: this.user
-        });
-        worksheet.worksheetDetails = await transaction.getRepository(entities_1.WorksheetDetail).save(worksheetDetails);
-        return worksheet;
-    }
-    /**
-     * @summary Complete worksheet
-     * @description It will activate passed worksheet
-     * Passed worksheet should have value on its id field
-     * Because this function has logic to update worksheet
-     * Step 1. Check whether passed worksheet has id
-     * Step 2. Change worksheet properly and update it
-     * Step 3. Renew worksheet with relations which is needed to complete worksheet
-     * Step 4. Change order targets properly and update it based on type of worksheet
-     * Step 5. If passed updatedRefOrderStatus has value it update reference order status
-     */
-    async completeWorksheet(worksheet, updatedRefOrderStatus) {
-        if (!worksheet.id)
-            throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS);
-        let worksheetDetails = worksheet.worksheetDetails;
-        if (worksheet.type === constants_1.WORKSHEET_TYPE.PICKING) {
-            //find OI that has pickedQty === releaseQty -- this due to not refresh picking product page allow to complete picking
-            let incompleteWSD = worksheetDetails.find(wsd => wsd.targetInventory.pickedQty !== wsd.targetInventory.releaseQty &&
-                (wsd.targetInventory.status === sales_base_1.ORDER_INVENTORY_STATUS.PICKING ||
-                    wsd.targetInventory.status === sales_base_1.ORDER_INVENTORY_STATUS.MISSING));
-            if (incompleteWSD) {
-                let sku = incompleteWSD.targetInventory.product.sku;
-                throw new Error(`SKU ${sku} has not been picked yet. Please reload the page again.`);
-            }
-        }
-        await this.trxMgr
-            .getRepository(entities_1.Worksheet)
-            .update({ id: worksheet.id }, { status: constants_1.WORKSHEET_STATUS.DONE, endedAt: new Date(), updater: this.user });
-        const worksheetType = worksheet.type;
-        await this.trxMgr.getRepository(entities_1.WorksheetDetail).update({
-            id: (0, typeorm_1.In)(worksheetDetails.map(wd => {
-                if (wd.status !== sales_base_1.ORDER_INVENTORY_STATUS.REPLACED)
-                    return wd.id;
-            }))
-        }, { status: constants_1.WORKSHEET_STATUS.DONE, updater: this.user });
-        if (worksheetType === constants_1.WORKSHEET_TYPE.UNLOADING) {
-            let targetProducts = worksheet.worksheetDetails.map((wsd) => {
-                let targetProduct = wsd.targetProduct;
-                targetProduct.status = sales_base_1.ORDER_PRODUCT_STATUS.TERMINATED;
-                targetProduct.updater = this.user;
-                return targetProduct;
-            });
-            await this.updateOrderTargets(targetProducts);
-        }
-        else if (worksheetType === constants_1.WORKSHEET_TYPE.VAS) {
-            let targetVASs = worksheet.worksheetDetails.map((wsd) => {
-                let targetVAS = wsd.targetVas;
-                targetVAS.status = sales_base_1.ORDER_VAS_STATUS.TERMINATED;
-                targetVAS.updater = this.user;
-                return targetVAS;
-            });
-            await this.updateOrderTargets(targetVASs);
-        }
-        else if (worksheetType === constants_1.WORKSHEET_TYPE.PUTAWAY ||
-            worksheetType === constants_1.WORKSHEET_TYPE.PICKING ||
-            worksheetType === constants_1.WORKSHEET_TYPE.PACKING ||
-            worksheetType === constants_1.WORKSHEET_TYPE.LOADING ||
-            worksheetType === constants_1.WORKSHEET_TYPE.WAREHOUSE_RETURN ||
-            worksheetType === constants_1.WORKSHEET_TYPE.UNLOADING_RETURN ||
-            worksheetType === constants_1.WORKSHEET_TYPE.PICKING_REPLENISHMENT ||
-            worksheetType === constants_1.WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT) {
-            let targetInventories = [];
-            // can update this later for easier to understand and cleaner code
-            if (updatedRefOrderStatus == 'VAS') {
-                targetInventories = worksheet.worksheetDetails
-                    .filter((wsd) => wsd.status !== sales_base_1.ORDER_INVENTORY_STATUS.REPLACED)
-                    .map((wsd) => {
-                    let targetInventory = wsd.targetInventory;
-                    targetInventory.status = updatedRefOrderStatus;
-                    targetInventory.updater = this.user;
-                    return targetInventory;
-                });
-            }
-            else {
-                targetInventories = worksheet.worksheetDetails
-                    .filter((wsd) => wsd.status !== sales_base_1.ORDER_INVENTORY_STATUS.REPLACED)
-                    .map((wsd) => {
-                    let targetInventory = wsd.targetInventory;
-                    targetInventory.status = sales_base_1.ORDER_INVENTORY_STATUS.TERMINATED;
-                    targetInventory.updater = this.user;
-                    return targetInventory;
-                });
-            }
-            await this.updateOrderTargets(targetInventories);
-        }
-        if (updatedRefOrderStatus) {
-            const refOrder = await this.extractRefOrderFromWorksheet(worksheet);
-            refOrder.status = updatedRefOrderStatus;
-            refOrder.updater = this.user;
-            await this.updateRefOrder(refOrder);
-            if (!(worksheetType === constants_1.WORKSHEET_TYPE.PUTAWAY) && updatedRefOrderStatus === 'DONE') {
-                (0, integration_base_1.webhookHandler)(refOrder, refOrder.bizplace, integration_base_1.WebhookEventsEnum.ReleaseOrderCompleted);
-            }
-        }
-        return worksheet;
-    }
-    /**
-     * @summary Renew worksheet details by changed worksheet details
-     * @description When you want to merge changed worksheet detail list into original worksheet detail list
-     * you can use this function
-     * it will loop through whole passed original worksheet details and find out matched changed one by value of 'ID' or its 'name'
-     * Because of this, every passed origin worksheet details and changed worksheet details should have one of those values
-     */
-    renewWorksheetDetails(originWSDs, changedWSDs, identifier, additionalProps = {}) {
-        if (originWSDs.some((wsd) => !wsd[identifier]) ||
-            changedWSDs.some((wsd) => !wsd[identifier])) {
-            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('renew worksheet details', `some passed parameter doesn't have identifier (${identifier})`));
-        }
-        return originWSDs.map((originWSD) => {
-            const changedWSD = this.findMatchedWSD(originWSD[identifier], changedWSDs);
-            return Object.assign(Object.assign(Object.assign({}, originWSD), changedWSD), additionalProps);
-        });
-    }
-    /**
-     * @summary Find out matched worksheet detail by identifier
-     * @description Find out matched worksheet detail by identifier
-     * identifier can be 'ID' or 'name' of worksheet detail
-     */
-    findMatchedWSD(identifier, candidates) {
-        return candidates.find((candidate) => candidate.id === identifier || candidate.name === identifier);
-    }
-    /**
-     * @summary Valitiy checker
-     * @description It will try to check whether passed record has same properties with passed conditions
-     * Basically it will check equality of value
-     * If you want to check advanced validation you can pass function to customize the logic of validation
-     * Passed function will be call with actual value of record as parameter
-     */
-    checkRecordValidity(record, conditions) {
-        for (let field in conditions) {
-            let isValid = false;
-            if (typeof conditions[field] === 'function') {
-                isValid = conditions[field](record[field]);
-            }
-            else {
-                isValid = conditions[field] === record[field];
-            }
-            if (!isValid)
-                throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE(field, conditions[field], record[field]));
-        }
-    }
-    /**
-     * @summary Notify to passed users
-     * @description Passed notification message will be sent to passed users
-     */
-    async notifyToUsers(users, message) {
-        const receivers = users.map(user => user.id);
-        /**
-         * @notes Temporary off sendNotification due to suspect of causing wms down
-         */
-        // await sendNotification({
-        //   receivers,
-        //   message
-        // })
-    }
-    /**
-     * @summary Notify to office admin
-     * @description Passed notification message will be sent to office admin of current domain
-     * default role name is defiend as ROLE_NAME.OFFICE_ADMIn by default
-     * You can change role name by passing roleName as parameter
-     */
-    async notifyToOfficeAdmin(message, roleName) {
-        const users = await this.trxMgr
-            .getRepository('users_roles')
-            .createQueryBuilder('ur')
-            .select('ur.users_id', 'id')
-            .where(qb => {
-            const subQuery = qb
-                .subQuery()
-                .select('role.id')
-                .from(auth_base_1.Role, 'role')
-                .where('role.name = :roleName', { roleName: roleName || this.ROLE_NAMES.OFFICE_ADMIN })
-                .andWhere('role.domain_id = :domainId', { domainId: this.domain.id })
-                .getQuery();
-            return 'ur.roles_id IN ' + subQuery;
-        })
-            .getRawMany();
-        this.notifyToUsers(users, message);
-    }
-    /**
-     * @summary Notify to customer of passed bizplace
-     * @description Passed notification message will be sent to customer of passed bizplace
-     */
-    async notifyToCustomer(bizplace, message) {
-        const users = await (0, biz_base_1.getDomainUsers)(bizplace, this.trxMgr);
-        this.notifyToUsers(users, message);
-    }
-    /**
-     * @summary extract out referenc order from given worksheet
-     * @description If it doesn't have any reference order
-     * find worksheet with every possible reference order once again
-     * and extract out reference order from found worksheet
-     */
-    async extractRefOrderFromWorksheet(worksheet) {
-        let refOrder = worksheet.arrivalNotice ||
-            worksheet.releaseGood ||
-            worksheet.vasOrder ||
-            worksheet.inventoryCheck ||
-            worksheet.returnOrder ||
-            worksheet.replenishment ||
-            null;
-        if (!refOrder) {
-            const wsWithRefOrd = await this.trxMgr.getRepository(entities_1.Worksheet).findOne(worksheet.id, {
-                relations: [
-                    'arrivalNotice',
-                    'releaseGood',
-                    'releaseGood.domain',
-                    'releaseGood.bizplace',
-                    'vasOrder',
-                    'inventoryCheck',
-                    'returnOrder',
-                    'replenishment'
-                ]
-            });
-            refOrder =
-                wsWithRefOrd.arrivalNotice ||
-                    wsWithRefOrd.releaseGood ||
-                    wsWithRefOrd.vasOrder ||
-                    wsWithRefOrd.inventoryCheck ||
-                    wsWithRefOrd.returnOrder ||
-                    wsWithRefOrd.replenishment ||
-                    null;
-            if (!refOrder)
-                throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheet.id));
-        }
-        return refOrder;
-    }
-    /**
-     * @summary extract out reference orders from given merged order worksheet
-     * @description If it doesn't have any reference order
-     * find worksheet with every possible reference order once again
-     * and extract out reference order from found worksheet
-     */
-    async extractMultipleRefOrderFromWorksheet(worksheet) {
-        const wsdWithRefOrd = await this.trxMgr.getRepository(entities_1.WorksheetDetail).find({
-            where: { domain: this.domain, worksheet },
-            relations: ['targetInventory', 'targetInventory.releaseGood']
-        });
-        let refOrder = wsdWithRefOrd.map((ord) => ord.targetInventory.releaseGood);
-        if (!refOrder)
-            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheet.id));
-        return refOrder;
-    }
-    /**
-     * @summary Check whether passed pallet is existing alreay
-     * @description It will try to count inventories which has same domain and same pallet Id and not terminated one
-     * If there's positive result it will throw an error cause pallet is duplicated
-     */
-    async checkPalletDuplication(palletId) {
-        const duplicatedPalletCnt = await this.trxMgr.getRepository(warehouse_base_1.Inventory).count({
-            domain: this.domain,
-            palletId,
-            status: (0, typeorm_1.Not)((0, typeorm_1.Equal)(warehouse_base_1.INVENTORY_STATUS.TERMINATED))
-        });
-        if (duplicatedPalletCnt)
-            throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Pallet ID', palletId));
-        const duplicatedReusablePalletCnt = await this.trxMgr.getRepository(warehouse_base_1.Pallet).count({
-            where: {
-                domain: this.domain,
-                name: palletId
-            }
-        });
-        if (duplicatedReusablePalletCnt)
-            throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Pallet ID', palletId));
-    }
-    /**
-     * @summary Check whether passed carton is existing alreay
-     * @description It will try to count inventories which has same domain and same carton Id and not terminated one
-     * If there's positive result it will throw an error cause carton is duplicated
-     */
-    async checkCartonDuplication(cartonId, orderId) {
-        const duplicatedCartonCnt = await this.trxMgr.getRepository(warehouse_base_1.Inventory).count({
-            domain: this.domain,
-            cartonId,
-            refOrderId: (0, typeorm_1.Not)((0, typeorm_1.Equal)(orderId)),
-            status: (0, typeorm_1.Not)((0, typeorm_1.Equal)(warehouse_base_1.INVENTORY_STATUS.TERMINATED))
-        });
-        if (duplicatedCartonCnt)
-            throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Carton ID', cartonId));
-    }
-    /**
-     * @summary Check whether passed serial number is existing already
-     * @description It will try to count inventories which has same domain and same serial number and  and not terminated one
-     * If there's positive result it will throw an error cause serial number is duplicated
-     */
-    async checkSerialNumberDuplication(serialNumber, product) {
-        const duplicatedSerialNumberCnt = await this.trxMgr.getRepository(warehouse_base_1.InventoryItem).count({
-            domain: this.domain,
-            product,
-            serialNumber,
-            status: (0, typeorm_1.Not)((0, typeorm_1.Equal)(warehouse_base_1.INVENTORY_STATUS.DELETED))
-        });
-        if (duplicatedSerialNumberCnt)
-            throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Serial Number', serialNumber));
-    }
-    /**
-     * @summary Check for product child qty at any scanned level
-     * @description It will check every level of product detail by comparing scanned level and GAN registered level.
-     * By getting the level that has relation, child qty will be retrieved
-     * 1st level: PALLET -> 2 CARTONS (scan), 2nd level: CARTON -> 6 BAGS, 3rd level: BAG -> 10 UNITS, lowest: UNIT (order registered packing type)
-     */
-    async getChildQty(productDetails, productBarcode, orderProductDetail, scannedProductDetail) {
-        let hasChildRelation = Boolean(scannedProductDetail === null || scannedProductDetail === void 0 ? void 0 : scannedProductDetail.childProductDetail);
-        let hasMatchingChild;
-        let childQty;
-        let currentProductDetail;
-        if (hasChildRelation) {
-            hasMatchingChild = Boolean(orderProductDetail.id === scannedProductDetail.childProductDetail.id);
-            currentProductDetail = productDetails.find((productDetail) => productDetail.id === scannedProductDetail.childProductDetail.id);
-            if (!currentProductDetail)
-                throw new Error(this.ERROR_MSG.FIND.NOT_MATCH('inner pack', `GTIN (${productBarcode})`));
-            childQty = scannedProductDetail.packingSize;
-        }
-        else {
-            throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode));
-        }
-        if (hasMatchingChild) {
-            childQty = scannedProductDetail.packingSize;
-        }
-        else {
-            while (hasChildRelation && !hasMatchingChild) {
-                hasChildRelation = Boolean(currentProductDetail === null || currentProductDetail === void 0 ? void 0 : currentProductDetail.childProductDetail);
-                if (hasChildRelation)
-                    hasMatchingChild = Boolean(orderProductDetail.id === currentProductDetail.childProductDetail.id);
-                if (hasMatchingChild) {
-                    childQty = currentProductDetail.packingSize * childQty;
-                }
-                else if (!hasMatchingChild && hasChildRelation) {
-                    childQty = currentProductDetail.packingSize * childQty;
-                    currentProductDetail = productDetails.find((productDetail) => productDetail.id === currentProductDetail.childProductDetail.id);
-                }
-                else if (!hasChildRelation && !hasMatchingChild) {
-                    throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode));
-                }
-            }
-        }
-        return childQty;
-    }
-    async getDirectQty(productDetail, productBarcode, qty) {
-        console.time(`getDirectQty ${productDetail.id} - ${productBarcode}`);
-        try {
-            let results = await this.trxMgr.query(`
-        WITH RECURSIVE cte as (
-        select * from (
-          select pd2.product_id as "productId", pd2.id, pd2.packing_size as "packingSize",
-          pd2.packing_type as "packingType", pd2.uom as "uom", (pd2.uom_value * $2::float) as "uomValue", $2::float as "qty", pb.gtin            
-          from product_details pd 
-          inner join product_details pd2 on pd.product_id = pd2.product_id and pd.packing_type = pd2.packing_type and pd.packing_size = pd2.packing_size and pd.uom = pd2.uom
-          inner join product_barcodes pb on pb.product_detail_id = pd2.id
-          where pd.id = $1
-          ) as dt
-          union all
-          select pd.product_id as "productId", pd.id, pd.packing_size as "packingSize",
-          pd.packing_type as "packingType", pd.uom,
-          dt1.qty * pd.uom_value as "uomValue", dt1.qty * pd.packing_size as "qty", pb.gtin
-          from product_details pd
-          inner join product_barcodes pb on pb.product_detail_id = pd.id
-          inner join cte dt1 on dt1.id = pd.child_product_detail_id 
-          where pd.deleted_at is null
-        )
-        select * from cte where gtin = $3
-      `, [productDetail.id, qty, productBarcode]);
-            if (results.length <= 0)
-                throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode));
-            console.timeEnd(`getDirectQty ${productDetail.id} - ${productBarcode}`);
-            return results[0];
-        }
-        catch (error) {
-            console.timeEnd(`getDirectQty ${productDetail.id} - ${productBarcode}`);
-            throw error;
-        }
-    }
-    /**
-     * @summary Check for product child qty at any scanned level
-     * @description It will check every level of product detail by comparing scanned level and GAN registered level.
-     * By getting the level that has relation, child qty will be retrieved
-     * 1st level: PALLET -> 2 CARTONS (scan), 2nd level: CARTON -> 6 BAGS, 3rd level: BAG -> 10 UNITS, lowest: UNIT (order registered packing type)
-     */
-    async getChildPackingSize(productDetails, defaultProductDetail, unmatchingProductDetail) {
-        let hasChildRelation = Boolean(unmatchingProductDetail === null || unmatchingProductDetail === void 0 ? void 0 : unmatchingProductDetail.childProductDetail);
-        let hasMatchingChild;
-        let packingSize = 1;
-        let currentChildProductDetail;
-        if (hasChildRelation) {
-            currentChildProductDetail = productDetails.find((productDetail) => productDetail.id === unmatchingProductDetail.childProductDetail.id);
-            if (!currentChildProductDetail) {
-                throw new Error(this.ERROR_MSG.FIND.NOT_MATCH('packing type', `GTIN (${unmatchingProductDetail.gtin})`));
-            }
-            hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id);
-            if (hasMatchingChild) {
-                packingSize = unmatchingProductDetail.packingSize;
-            }
-            else {
-                packingSize = unmatchingProductDetail.packingSize * packingSize;
-            }
-        }
-        else {
-            throw new Error(this.ERROR_MSG.FIND.NO_CHILD_RESULT(`${unmatchingProductDetail.gtin}`));
-        }
-        while (hasChildRelation && !hasMatchingChild) {
-            if (hasMatchingChild) {
-                packingSize = currentChildProductDetail.packingSize * packingSize; // 12 x 10
-            }
-            else if (!hasMatchingChild && hasChildRelation) {
-                packingSize = currentChildProductDetail.packingSize * packingSize; // 12 x 10
-                currentChildProductDetail = productDetails.find((productDetail) => productDetail.id === currentChildProductDetail.childProductDetail.id);
-                hasChildRelation = Boolean(currentChildProductDetail === null || currentChildProductDetail === void 0 ? void 0 : currentChildProductDetail.childProductDetail);
-                hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id);
-            }
-            else if (!hasChildRelation && !hasMatchingChild) {
-                throw new Error(this.ERROR_MSG.FIND.NO_RESULT(unmatchingProductDetail.gtin));
-            }
-        }
-        return packingSize;
-    }
-    async createInventory(inventory) {
-        inventory = this.setStamp(inventory);
-        return await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(inventory);
-    }
-    /**
-     * @summary Update inventory record
-     * @description It will update inventory after set a stamp (domain, updater)
-     * The special point of this function is that this changes won't generate inventory history
-     * If you want to generate inventory history automatically you would better to use transactionInventory function
-     */
-    async updateInventory(inventory) {
-        if (!inventory.id)
-            throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS);
-        inventory = this.setStamp(inventory);
-        return await this.trxMgr.getRepository(warehouse_base_1.Inventory).save(inventory);
-    }
-    /**
-     * @summary Do transaction on inventory record
-     * @description It will update inventory after set a temp (domain, updater)
-     * and then generate inventory history based on current changes
-     */
-    async transactionInventory(inventory, referencOrder, changedQty, changedWeight, transactionType) {
-        if (inventory.id) {
-            inventory = await this.updateInventory(inventory);
-        }
-        else {
-            inventory = await this.createInventory(inventory);
-        }
-        await (0, warehouse_base_1.generateInventoryHistory)(inventory, referencOrder, transactionType, changedQty, changedWeight, this.user, this.trxMgr);
-        return inventory;
-    }
-    /**
-     * @summary set common stamp like domain, creator, updater
-     * @description Set common stamp to passed record
-     * If it doesn't have id it will handle it as creating one
-     * If it has id it will handle it as updating one
-     */
-    setStamp(record) {
-        if (!record.domain)
-            record.domain = this.domain;
-        if (!record.id && !record.creator)
-            record.creator = this.user;
-        if (!record.updater)
-            record.updater = this.user;
-        return record;
-    }
-    /**
-     * @summary Extract bizplace from reference order
-     * @description It will find reference order with bizplace and return only bizplace to extract it out
-     */
-    async extractBizplaceFromRefOrder(refOrder, entitySchema) {
-        if (!entitySchema) {
-            if (refOrder instanceof sales_base_1.ArrivalNotice) {
-                entitySchema = sales_base_1.ArrivalNotice;
-            }
-            else if (refOrder instanceof sales_base_1.ReleaseGood) {
-                entitySchema = sales_base_1.ReleaseGood;
-            }
-            else if (refOrder instanceof sales_base_1.VasOrder) {
-                entitySchema = sales_base_1.VasOrder;
-            }
-            else if (refOrder instanceof sales_base_1.InventoryCheck) {
-                entitySchema = sales_base_1.InventoryCheck;
-            }
-            else if (refOrder instanceof sales_base_1.ReturnOrder) {
-                entitySchema = sales_base_1.ReturnOrder;
-            }
-            else if (refOrder instanceof sales_base_1.Replenishment) {
-                entitySchema = sales_base_1.Replenishment;
-            }
-        }
-        const { bizplace } = await this.findRefOrder(entitySchema, refOrder, ['bizplace']);
-        return bizplace;
-    }
-    tidyConditions(record) {
-        if ('id' in record) {
-            return { id: record.id };
-        }
-        else {
-            Object.keys(record).forEach((key) => {
-                if (record[key] === null || record[key] instanceof Date || Array.isArray(record[key]))
-                    delete record[key];
-            });
-        }
-        return record;
-    }
-}
-exports.WorksheetController = WorksheetController;
-//# sourceMappingURL=worksheet-controller.js.map