@things-factory/marketplace-base 4.3.671 → 4.3.675

package/dist-server/graphql/resolvers/marketplace-order/sync-marketplace-order.js

@@ -0,0 +1,779 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncMarketplaceOrder = void 0;
+const typeorm_1 = require("typeorm");
+const uuid_1 = require("uuid");
+const biz_base_1 = require("@things-factory/biz-base");
+const env_1 = require("@things-factory/env");
+const integration_fulfillment_1 = require("@things-factory/integration-fulfillment");
+const integration_marketplace_1 = require("@things-factory/integration-marketplace");
+const product_base_1 = require("@things-factory/product-base");
+const shell_1 = require("@things-factory/shell");
+const reserve_qty_order_statuses_1 = require("../../../constants/reserve-qty-order-statuses");
+const entities_1 = require("../../../entities");
+const utils_1 = require("../../../utils");
+const cancelStatuses = [
+    'cancelled',
+    'canceled',
+    'failed',
+    'shipped_back_success',
+    'shipped_back',
+    'returned',
+    'to_return',
+    'refunded'
+];
+exports.syncMarketplaceOrder = {
+    async syncMarketplaceOrder(_, { storeId, fromCreatedDate, toCreatedDate, scheduler = false }, context) {
+        const { domain, user } = context.state;
+        const marketplaceStore = await integration_marketplace_1.StoreAPI.getMarketplaceStore(storeId);
+        let page = 0;
+        let hasMorePage = true;
+        let lastOrderId;
+        var limit = 100;
+        const disallowCancelStatuses = ['CANCELLED', 'PENDING_CANCEL'];
+        let nextCursor;
+        while (hasMorePage) {
+            const { results: marketplaceOrders, more, cursor } = await integration_marketplace_1.StoreAPI.getStoreOrders(marketplaceStore, {
+                fromCreatedDate,
+                toCreatedDate,
+                pagination: { page, limit },
+                lastOrderId,
+                nextCursor
+            });
+            nextCursor = cursor;
+            if ((marketplaceOrders === null || marketplaceOrders === void 0 ? void 0 : marketplaceOrders.length) == 0)
+                throw new Error('There is no order available to sync');
+            for (var i = 0; i < marketplaceOrders.length; i++) {
+                await (0, typeorm_1.getConnection)().transaction(async (tx) => {
+                    var _a;
+                    try {
+                        var order = marketplaceOrders[i];
+                        let marketplaceOrderItems = [];
+                        let tracking_code = '';
+                        let deliveryProvider;
+                        let dropPickProvider;
+                        if (marketplaceStore.platform == 'lazada') {
+                            if (order.trackingNo != '') {
+                                tracking_code = ((_a = JSON.parse(order.trackingNo)[0]) === null || _a === void 0 ? void 0 : _a.tracking_code) || null;
+                                // .reduce((newItem, item) => {
+                                //   if (newItem.indexOf(item.tracking_code) < 0) {
+                                //     newItem.push(item.tracking_code)
+                                //   }
+                                //   return newItem
+                                // }, [])
+                                // .join(',')
+                            }
+                            const shippingProviderInfo = {};
+                            order.shippingProvider.split(', ').forEach(s => {
+                                var [key, value] = s.split(': ');
+                                shippingProviderInfo[key] = value;
+                            });
+                            dropPickProvider = (shippingProviderInfo === null || shippingProviderInfo === void 0 ? void 0 : shippingProviderInfo.Pickup)
+                                ? shippingProviderInfo['Pickup']
+                                : shippingProviderInfo['Drop-off'];
+                            deliveryProvider = shippingProviderInfo['Delivery'];
+                        }
+                        const marketplaceTransporter = await tx
+                            .getRepository(integration_marketplace_1.MarketplaceTransporter)
+                            .findOne({
+                            where: { marketplaceStore },
+                            relations: ['pickupTransporter']
+                        });
+                        let marketplaceOrder = new entities_1.MarketplaceOrder();
+                        marketplaceOrder.name = order.name;
+                        marketplaceOrder.orderNo = order.orderNo;
+                        marketplaceOrder.itemCount = order.itemCount;
+                        marketplaceOrder.totalAmount = order.totalAmount;
+                        marketplaceOrder.status = order.status;
+                        marketplaceOrder.remark = order === null || order === void 0 ? void 0 : order.remark;
+                        marketplaceOrder.trackingNo = tracking_code ? tracking_code : order.trackingNo;
+                        marketplaceOrder.shippingProvider =
+                            marketplaceStore.eTrax && marketplaceTransporter
+                                ? marketplaceTransporter.pickupTransporter.name
+                                : order.shippingProvider;
+                        marketplaceOrder.orderCreatedAt = order.orderCreatedAt;
+                        marketplaceOrder.orderUpdatedAt = order.orderUpdatedAt;
+                        marketplaceOrder.marketplaceStore = marketplaceStore;
+                        marketplaceOrder.domain = marketplaceStore.domain;
+                        marketplaceOrder.buyerUsername = order.buyerUsername;
+                        marketplaceOrder.payTime = order.payTime;
+                        marketplaceOrder.serviceFee = order.serviceFee;
+                        marketplaceOrder.commissionFee = order.commissionFee;
+                        marketplaceOrder.transactionFee = order.transactionFee;
+                        marketplaceOrder.shippingMode = order.shippingMode;
+                        marketplaceOrder.voucherAmount = order.voucherAmount;
+                        marketplaceOrder.totalRealeasedAmount = order.totalRealeasedAmount;
+                        marketplaceOrder.voucherCode = order.voucherCode;
+                        marketplaceOrder.shippingRebate = order.shippingRebate;
+                        marketplaceOrder.sellerVoucherAmount = (order === null || order === void 0 ? void 0 : order.sellerVoucherAmount) || null;
+                        marketplaceOrder.platformVoucherAmount = (order === null || order === void 0 ? void 0 : order.platformVoucherAmount) || null;
+                        marketplaceOrder.sellerDiscount = (order === null || order === void 0 ? void 0 : order.sellerDiscount) || null;
+                        marketplaceOrder.platformCoins = (order === null || order === void 0 ? void 0 : order.platformCoins) || null;
+                        const existingMarketplaceOrder = await tx.getRepository(entities_1.MarketplaceOrder).findOne({
+                            where: { domain: marketplaceStore.domain, name: order.name, marketplaceStore },
+                            relations: [
+                                'domain',
+                                'fulfillmentCenter',
+                                'marketplaceOrderItems',
+                                'marketplaceOrderItems.marketplaceOrderShippingItems',
+                                'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+                                'marketplaceOrderItems.marketplaceProductVariation',
+                                'marketplaceStore'
+                            ]
+                        });
+                        if (existingMarketplaceOrder) {
+                            let otherInfoJSON = {};
+                            if ((existingMarketplaceOrder === null || existingMarketplaceOrder === void 0 ? void 0 : existingMarketplaceOrder.otherInfoJSON) && deliveryProvider) {
+                                otherInfoJSON = JSON.parse(existingMarketplaceOrder.otherInfoJSON);
+                                otherInfoJSON.shippingProvider = deliveryProvider;
+                            }
+                            marketplaceOrder = Object.assign(Object.assign(Object.assign({}, existingMarketplaceOrder), marketplaceOrder), { otherInfoJSON: otherInfoJSON ? JSON.stringify(otherInfoJSON) : null, updater: user });
+                            if (!(marketplaceOrder === null || marketplaceOrder === void 0 ? void 0 : marketplaceOrder.releaseOrderId) &&
+                                reserve_qty_order_statuses_1.RESERVE_QTY_ORDER_STATUSES[marketplaceOrder.marketplaceStore.platform.toUpperCase()].includes(existingMarketplaceOrder.status) &&
+                                cancelStatuses.includes(marketplaceOrder.status)) {
+                                for (let item of marketplaceOrder.marketplaceOrderItems) {
+                                    await updateQtyAndReserveQty(tx, item.marketplaceProductVariation, marketplaceOrder, item.qty * -1, null, existingMarketplaceOrder);
+                                }
+                            }
+                            if (marketplaceOrder === null || marketplaceOrder === void 0 ? void 0 : marketplaceOrder.releaseOrderId) {
+                                const fulfillmentCenter = marketplaceOrder.fulfillmentCenter;
+                                const centerId = fulfillmentCenter.centerId;
+                                const warehouseDomain = await tx
+                                    .getRepository(shell_1.Domain)
+                                    .findOne({ where: { subdomain: centerId } });
+                                const customerBizplaces = await (0, biz_base_1.getCustomerBizplaces)(warehouseDomain);
+                                const customerBizplaceId = customerBizplaces.find(customerBizplace => customerBizplace.company.domain.id == domain.id).id;
+                                let { items: releaseOrders } = await integration_fulfillment_1.FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
+                                    customerBizplaceId,
+                                    refNo: marketplaceOrder.orderNo
+                                });
+                                if (existingMarketplaceOrder.isSplitted) {
+                                    for (let a = 0; a < releaseOrders.length; a++) {
+                                        const releaseOrder = releaseOrders[a];
+                                        const foundMarketplaceOrderShipping = await tx
+                                            .getRepository(entities_1.MarketplaceOrderShipping)
+                                            .findOne({
+                                            where: { domain: marketplaceStore.domain, subOrderNoRef: releaseOrder.refNo2 }
+                                        });
+                                        let patch = {
+                                            id: releaseOrder.id,
+                                            marketplaceOrderStatus: marketplaceOrder.status,
+                                            trackingNo: _extractTrackingNo(foundMarketplaceOrderShipping.ownTrackingNo, foundMarketplaceOrderShipping.trackingNo),
+                                            transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
+                                        };
+                                        await integration_fulfillment_1.FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
+                                            customerBizplaceId,
+                                            releaseOrder: Object.assign({}, patch),
+                                            shippingOrder: null
+                                        });
+                                    }
+                                }
+                                else {
+                                    let releaseOrder = Object.assign({}, releaseOrders[0]);
+                                    const foundMarketplaceOrderShipping = await tx
+                                        .getRepository(entities_1.MarketplaceOrderShipping)
+                                        .findOne({
+                                        where: { domain: marketplaceStore.domain, orderNoRef: releaseOrder.refNo }
+                                    });
+                                    let patch = {
+                                        id: releaseOrder.id,
+                                        marketplaceOrderStatus: marketplaceOrder.status,
+                                        trackingNo: _extractTrackingNo(foundMarketplaceOrderShipping.ownTrackingNo, foundMarketplaceOrderShipping.trackingNo),
+                                        transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
+                                    };
+                                    await integration_fulfillment_1.FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
+                                        customerBizplaceId,
+                                        releaseOrder: Object.assign({}, patch),
+                                        shippingOrder: null
+                                    });
+                                }
+                                if (cancelStatuses.includes(marketplaceOrder.status)) {
+                                    if (existingMarketplaceOrder.isSplitted) {
+                                        releaseOrders = releaseOrders.filter(function (order) {
+                                            return !disallowCancelStatuses.includes(order.status);
+                                        });
+                                        if (releaseOrders === null || releaseOrders === void 0 ? void 0 : releaseOrders.length) {
+                                            for (let a = 0; a < releaseOrders.length; a++) {
+                                                const releaseOrderId = releaseOrders[a].id;
+                                                await integration_fulfillment_1.FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, {
+                                                    customerBizplaceId,
+                                                    releaseOrderId
+                                                });
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        const fulfillmentCenter = marketplaceOrder.fulfillmentCenter;
+                                        const centerId = fulfillmentCenter.centerId;
+                                        const warehouseDomain = await tx
+                                            .getRepository(shell_1.Domain)
+                                            .findOne({ where: { subdomain: centerId } });
+                                        const customerBizplaces = await (0, biz_base_1.getCustomerBizplaces)(warehouseDomain);
+                                        const customerBizplaceId = customerBizplaces[0].id;
+                                        const { items: releaseOrders } = await integration_fulfillment_1.FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
+                                            customerBizplaceId,
+                                            refNo: marketplaceOrder.orderNo
+                                        });
+                                        const releaseOrderStatus = releaseOrders[0].status;
+                                        if (!disallowCancelStatuses.includes(releaseOrderStatus)) {
+                                            await integration_fulfillment_1.FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, {
+                                                customerBizplaceId,
+                                                releaseOrderId: releaseOrders[0].id
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        let savedMarketplaceOrderShipping = new entities_1.MarketplaceOrderShipping();
+                        let savedMarketplaceOrderShippings = [];
+                        if (order === null || order === void 0 ? void 0 : order.orderShipping) {
+                            const orderShipping = order.orderShipping;
+                            let marketplaceOrderShipping = new entities_1.MarketplaceOrderShipping();
+                            marketplaceOrderShipping.name = utils_1.NoGenerator.orderShipping();
+                            marketplaceOrderShipping.address1 = orderShipping.address1;
+                            marketplaceOrderShipping.address2 = orderShipping.address2;
+                            marketplaceOrderShipping.address3 = orderShipping.address3;
+                            marketplaceOrderShipping.address4 = orderShipping.address4;
+                            marketplaceOrderShipping.address5 = orderShipping.address5;
+                            marketplaceOrderShipping.attentionTo = orderShipping.attentionTo;
+                            marketplaceOrderShipping.city = orderShipping.city;
+                            marketplaceOrderShipping.country = orderShipping.country;
+                            marketplaceOrderShipping.state = (orderShipping === null || orderShipping === void 0 ? void 0 : orderShipping.state) || null;
+                            marketplaceOrderShipping.postCode = orderShipping.postCode;
+                            marketplaceOrderShipping.phone1 = orderShipping.phone1;
+                            marketplaceOrderShipping.phone2 = orderShipping.phone2;
+                            marketplaceOrderShipping.trackingNo = tracking_code || (order === null || order === void 0 ? void 0 : order.trackingNo) || null;
+                            marketplaceOrderShipping.orderNoRef = marketplaceOrder.orderNo;
+                            marketplaceOrderShipping.subOrderNoRef = marketplaceOrder.orderNo;
+                            marketplaceOrderShipping.marketplaceStore = marketplaceStore;
+                            marketplaceOrderShipping.creator = user;
+                            marketplaceOrderShipping.domain = marketplaceStore.domain;
+                            marketplaceOrderShipping.shippingFee = orderShipping.shippingFee;
+                            marketplaceOrderShipping.actualShippingFee = orderShipping.actualShippingFee;
+                            marketplaceOrderShipping.marketplaceShippingFeeVoucher = orderShipping.marketplaceShippingFeeVoucher;
+                            marketplaceOrderShipping.sellerShippingFeeVoucher = orderShipping.sellerShippingFeeVoucher;
+                            if (existingMarketplaceOrder) {
+                                if (existingMarketplaceOrder.isSplitted) {
+                                    let existingOrderShippings = await tx
+                                        .getRepository(entities_1.MarketplaceOrderShipping)
+                                        .find({
+                                        where: { domain, marketplaceStore, orderNoRef: marketplaceOrder.orderNo }
+                                    });
+                                    existingOrderShippings = existingOrderShippings.map(item => {
+                                        return Object.assign(Object.assign({}, item), { address1: orderShipping.address1, address2: orderShipping.address2, address3: orderShipping.address3, address4: orderShipping.address4, address5: orderShipping.address5, attentionTo: orderShipping.attentionTo, city: orderShipping.city, country: orderShipping.country, state: orderShipping === null || orderShipping === void 0 ? void 0 : orderShipping.state, postCode: orderShipping.postCode, phone1: orderShipping.phone1, phone2: orderShipping.phone2, email: orderShipping === null || orderShipping === void 0 ? void 0 : orderShipping.email, trackingNo: marketplaceStore.eTrax || existingMarketplaceOrder.marketplaceStore.platform == 'lazada'
+                                                ? item.trackingNo
+                                                : order === null || order === void 0 ? void 0 : order.trackingNo, shippingFee: orderShipping.shippingFee, actualShippingFee: orderShipping.actualShippingFee, marketplaceShippingFeeVoucher: orderShipping.marketplaceShippingFeeVoucher, sellerShippingFeeVoucher: orderShipping.sellerShippingFeeVoucher });
+                                    });
+                                    savedMarketplaceOrderShippings = await tx
+                                        .getRepository(entities_1.MarketplaceOrderShipping)
+                                        .save(existingOrderShippings);
+                                }
+                                else {
+                                    if (existingMarketplaceOrder === null || existingMarketplaceOrder === void 0 ? void 0 : existingMarketplaceOrder.marketplaceOrderItems) {
+                                        let existingOrderShipping;
+                                        existingOrderShipping =
+                                            existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShippingItems[0]
+                                                .marketplaceOrderShipping;
+                                        marketplaceOrderShipping = Object.assign(Object.assign(Object.assign({}, existingOrderShipping), marketplaceOrderShipping), { trackingNo: marketplaceStore.eTrax
+                                                ? existingOrderShipping.trackingNo
+                                                : (marketplaceOrderShipping === null || marketplaceOrderShipping === void 0 ? void 0 : marketplaceOrderShipping.trackingNo)
+                                                    ? marketplaceOrderShipping.trackingNo
+                                                    : (existingOrderShipping === null || existingOrderShipping === void 0 ? void 0 : existingOrderShipping.trackingNo)
+                                                        ? existingOrderShipping.trackingNo
+                                                        : marketplaceOrderShipping.trackingNo, updater: user });
+                                        savedMarketplaceOrderShipping = await tx
+                                            .getRepository(entities_1.MarketplaceOrderShipping)
+                                            .save(marketplaceOrderShipping);
+                                    }
+                                }
+                            }
+                            else {
+                                if (marketplaceStore.eTrax)
+                                    delete marketplaceOrderShipping.trackingNo;
+                                savedMarketplaceOrderShipping = await tx
+                                    .getRepository(entities_1.MarketplaceOrderShipping)
+                                    .save(marketplaceOrderShipping);
+                            }
+                        }
+                        let orderTotalWeight = 0;
+                        let foundVariations = [];
+                        for (var j = 0; j < order.orderItems.length; j++) {
+                            var item = order.orderItems[j];
+                            const qb = await tx
+                                .getRepository(entities_1.MarketplaceProductVariation)
+                                .createQueryBuilder('mpv')
+                                .leftJoin('mpv.marketplaceProduct', 'mp')
+                                .leftJoin('mp.marketplaceStore', 'ms')
+                                .where('mpv.domain_id = :domainId')
+                                .andWhere('mpv.variation_id = :variationId')
+                                .andWhere('ms.id = :marketplaceStoreId')
+                                .setParameters({
+                                domainId: marketplaceStore.domain.id,
+                                variationId: item.variationId,
+                                marketplaceStoreId: marketplaceStore.id
+                            });
+                            let foundVariation = await qb.getOne();
+                            if (foundVariation) {
+                                foundVariations.push(foundVariation);
+                            }
+                            else {
+                                let newVariation = {
+                                    variationId: item.variationId,
+                                    name: item.variationName,
+                                    variationSku: item.variationSku,
+                                    channelSku: item.sku,
+                                    status: 'INACTIVE',
+                                    domain: marketplaceStore.domain
+                                };
+                                await tx.getRepository(entities_1.MarketplaceProductVariation).save(newVariation);
+                                foundVariation = newVariation;
+                            }
+                            let marketplaceOrderItem = new entities_1.MarketplaceOrderItem();
+                            marketplaceOrderItem.domain = marketplaceStore.domain;
+                            marketplaceOrderItem.name = item.name;
+                            marketplaceOrderItem.qty = item.qty;
+                            marketplaceOrderItem.paidPrice = item.paidPrice;
+                            marketplaceOrderItem.status = marketplaceOrder.status;
+                            marketplaceOrderItem.docRefNo = item.docRefNo;
+                            marketplaceOrderItem.marketplaceProductVariation = foundVariation;
+                            marketplaceOrderItem.trackingCode = order.trackingNo;
+                            marketplaceOrderItem.marketplaceOrder = marketplaceOrder;
+                            marketplaceOrderItem.originalPrice = item.originalPrice;
+                            marketplaceOrderItem.discount = item.discount;
+                            marketplaceOrderItem.promotionId = item.promotionId;
+                            marketplaceOrderItem.creator = user;
+                            marketplaceOrderItem.paymentFee = item.paymentFee || null;
+                            marketplaceOrderItem.commissionFee = item.commissionFee || null;
+                            marketplaceOrderItem.shippingFeePaidByCustomer = item.shippingFeePaidByCustomer || null;
+                            marketplaceOrderItem.itemPriceCredit = item.itemPriceCredit || null;
+                            marketplaceOrderItem.promotionalCharges = item.promotionalCharges || null;
+                            marketplaceOrderItem.ordersMarketplaceFeesTotal = item.ordersMarketplaceFeesTotal || null;
+                            marketplaceOrderItem.ordersSalesTotal = item.ordersSalesTotal || null;
+                            marketplaceOrderItem.ordersMarketingFeesTotal = item.ordersMarketingFeesTotal || null;
+                            marketplaceOrderItem.ordersLogisticsTotal = item.ordersLogisticsTotal || null;
+                            marketplaceOrderItem.marketplaceBonus = item.marketplaceBonus;
+                            marketplaceOrderItem.marketplaceBonusSeller = item.marketplaceBonusSeller;
+                            marketplaceOrderItem.shippingFeeDiscountMarketplace = item.shippingFeeDiscountMarketplace;
+                            marketplaceOrderItem.shippingFeeDiscountSeller = item.shippingFeeDiscountSeller;
+                            marketplaceOrderItem.promotionalChargesFlexiCombo = item.promotionalChargesFlexiCombo;
+                            marketplaceOrderItem.autoShippingSubsidyMarketplace = item.autoShippingSubsidyMarketplace;
+                            marketplaceOrderItem.originalShippingFee = item.originalShippingFee;
+                            marketplaceOrderItem.taxAmount = item.taxAmount;
+                            marketplaceOrderItem.orderId =
+                                (item === null || item === void 0 ? void 0 : item.orderItemId) != null || (item === null || item === void 0 ? void 0 : item.orderItemId) != undefined ? item.orderItemId : item.name;
+                            marketplaceOrderItems.push(Object.assign({}, marketplaceOrderItem));
+                            if (foundVariation === null || foundVariation === void 0 ? void 0 : foundVariation.primaryUnitValue)
+                                orderTotalWeight += parseFloat(foundVariation.primaryUnitValue.toFixed(3)) * item.qty || 0;
+                        }
+                        if (existingMarketplaceOrder) {
+                            let existingOrderItems = [];
+                            existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems;
+                            existingOrderItems = await checkUpdateItemId(existingOrderItems, marketplaceOrderItems);
+                            if (existingMarketplaceOrder.isSplitted) {
+                                marketplaceOrderItems = existingOrderItems.filter(itm => itm.name == item.name && itm.marketplaceProductVariation.variationId == item.variationId);
+                                marketplaceOrderItems = marketplaceOrderItems.map(marketplaceOrderitem => {
+                                    return Object.assign(Object.assign({}, marketplaceOrderitem), { status: order.status, trackingCode: order.trackingNo });
+                                });
+                            }
+                            else {
+                                if (existingOrderItems.length > marketplaceOrderItems.length) {
+                                    let nonMatchedOrderItems = [];
+                                    existingOrderItems.map(item => {
+                                        const matchedOrderItem = marketplaceOrderItems.find(itm => itm.name === item.name &&
+                                            itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId);
+                                        if (!matchedOrderItem) {
+                                            nonMatchedOrderItems.push(Object.assign({}, item));
+                                        }
+                                    });
+                                    if (nonMatchedOrderItems.length > 0 && !cancelStatuses.includes(marketplaceOrder.status)) {
+                                        await Promise.all(nonMatchedOrderItems.map(async (item) => {
+                                            let foundVariation = foundVariations.find(fv => fv.sku == item.marketplaceProductVariation.sku);
+                                            if (foundVariation.sku) {
+                                                await updateQtyAndReserveQty(tx, foundVariation, marketplaceOrder, item.qty * -1);
+                                            }
+                                        }));
+                                        await tx.getRepository(entities_1.MarketplaceOrderItem).delete(nonMatchedOrderItems);
+                                    }
+                                    if (!cancelStatuses.includes(marketplaceOrder.status)) {
+                                        existingOrderItems = await Promise.all(marketplaceOrderItems.map(async (item) => {
+                                            const matchedOrderItem = existingOrderItems.find(itm => itm.name == item.name &&
+                                                itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId);
+                                            if (matchedOrderItem) {
+                                                foundVariation = foundVariations.find(fv => fv.variationId == matchedOrderItem.marketplaceProductVariation.variationId);
+                                                if (foundVariation.sku) {
+                                                    await updateQtyAndReserveQty(tx, foundVariation, marketplaceOrder, item.qty, matchedOrderItem.qty, existingMarketplaceOrder);
+                                                }
+                                                return Object.assign(Object.assign(Object.assign({}, matchedOrderItem), item), { updater: user });
+                                            }
+                                        }));
+                                    }
+                                }
+                                else {
+                                    if (!cancelStatuses.includes(marketplaceOrder.status)) {
+                                        existingOrderItems = await Promise.all(marketplaceOrderItems.map(async (item) => {
+                                            const matchedOrderItem = existingOrderItems.find(itm => itm.name == item.name &&
+                                                itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId);
+                                            if (matchedOrderItem) {
+                                                foundVariation = foundVariations.find(fv => fv.variationId == matchedOrderItem.marketplaceProductVariation.variationId);
+                                                if (foundVariation.sku) {
+                                                    await updateQtyAndReserveQty(tx, foundVariation, marketplaceOrder, item.qty, matchedOrderItem.qty, existingMarketplaceOrder);
+                                                }
+                                                return Object.assign(Object.assign(Object.assign({}, matchedOrderItem), item), { updater: user });
+                                            }
+                                            else {
+                                                let foundVariation = foundVariations.find(fv => (fv.sku = item.marketplaceProductVariation.sku));
+                                                if (foundVariation.sku) {
+                                                    await updateQtyAndReserveQty(tx, foundVariation, marketplaceOrder, item.qty);
+                                                }
+                                                return Object.assign(Object.assign({}, item), { updater: user });
+                                            }
+                                        }));
+                                    }
+                                }
+                                marketplaceOrderItems = existingOrderItems;
+                                if (order === null || order === void 0 ? void 0 : order.orderShipping) {
+                                    savedMarketplaceOrderShipping.totalWeight = orderTotalWeight;
+                                    if (marketplaceStore.eTrax)
+                                        delete savedMarketplaceOrderShipping.trackingNo;
+                                    savedMarketplaceOrderShipping = await tx
+                                        .getRepository(entities_1.MarketplaceOrderShipping)
+                                        .save(savedMarketplaceOrderShipping);
+                                }
+                            }
+                        }
+                        else {
+                            if (!cancelStatuses.includes(marketplaceOrder.status)) {
+                                for (var foundVariation of foundVariations) {
+                                    if (foundVariation.sku) {
+                                        let item = order.orderItems.find(e => e.variationId == foundVariation.variationId);
+                                        await updateQtyAndReserveQty(tx, foundVariation, marketplaceOrder, item.qty);
+                                    }
+                                    if (order === null || order === void 0 ? void 0 : order.orderShipping) {
+                                        savedMarketplaceOrderShipping.totalWeight = orderTotalWeight;
+                                        if (marketplaceStore.eTrax)
+                                            delete savedMarketplaceOrderShipping.trackingNo;
+                                        savedMarketplaceOrderShipping = await tx
+                                            .getRepository(entities_1.MarketplaceOrderShipping)
+                                            .save(savedMarketplaceOrderShipping);
+                                    }
+                                }
+                            }
+                        }
+                        await tx.getRepository(entities_1.MarketplaceOrder).save(marketplaceOrder);
+                        await tx.getRepository(entities_1.MarketplaceOrderItem).save(marketplaceOrderItems);
+                        for (let i = 0; i < marketplaceOrderItems.length; i++) {
+                            const marketplaceOrderItem = marketplaceOrderItems[i];
+                            const marketplaceProductVariation = marketplaceOrderItem.marketplaceProductVariation;
+                            let existingMarketplaceOrderShippingItems = await tx
+                                .getRepository(entities_1.MarketplaceOrderShippingItem)
+                                .find({
+                                where: { domain: marketplaceStore.domain, marketplaceOrderItem },
+                                relations: ['product']
+                            });
+                            let product = await tx.getRepository(product_base_1.Product).findOne({
+                                where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku, deletedAt: (0, typeorm_1.IsNull)() },
+                                relations: ['productDetails']
+                            });
+                            let productBundle;
+                            if (!product) {
+                                productBundle = await tx.getRepository(product_base_1.ProductBundle).findOne({
+                                    where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku, status: 'ACTIVATED' },
+                                    relations: ['productBundleSettings', 'productBundleSettings.product']
+                                });
+                            }
+                            if (!marketplaceOrder.isSplitted && !marketplaceOrder.releaseOrderId) {
+                                if ((existingMarketplaceOrderShippingItems === null || existingMarketplaceOrderShippingItems === void 0 ? void 0 : existingMarketplaceOrderShippingItems.length) &&
+                                    existingMarketplaceOrderShippingItems
+                                        .map(e => {
+                                        return e.product;
+                                    })
+                                        .indexOf(null) != -1) {
+                                    await tx.getRepository(entities_1.MarketplaceOrderShippingItem).remove(existingMarketplaceOrderShippingItems);
+                                }
+                                if (((existingMarketplaceOrderShippingItems === null || existingMarketplaceOrderShippingItems === void 0 ? void 0 : existingMarketplaceOrderShippingItems.length) &&
+                                    existingMarketplaceOrderShippingItems
+                                        .map(e => {
+                                        return e.product;
+                                    })
+                                        .indexOf(null) != -1) ||
+                                    !(existingMarketplaceOrderShippingItems === null || existingMarketplaceOrderShippingItems === void 0 ? void 0 : existingMarketplaceOrderShippingItems.length)) {
+                                    if (productBundle) {
+                                        const productBundleSettings = productBundle.productBundleSettings;
+                                        let marketplaceOrderShippingItems = [];
+                                        productBundleSettings.map(productBundleSetting => {
+                                            let marketplaceOrderShippingItem = new entities_1.MarketplaceOrderShippingItem();
+                                            marketplaceOrderShippingItem.name = (0, uuid_1.v4)();
+                                            marketplaceOrderShippingItem.qty = marketplaceOrderItem.qty * productBundleSetting.bundleQty;
+                                            marketplaceOrderShippingItem.domain = marketplaceStore.domain;
+                                            marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem;
+                                            marketplaceOrderShippingItem.marketplaceOrderShipping = savedMarketplaceOrderShipping;
+                                            marketplaceOrderShippingItem.product = productBundleSetting.product;
+                                            marketplaceOrderShippingItems.push(marketplaceOrderShippingItem);
+                                        });
+                                        await tx.getRepository(entities_1.MarketplaceOrderShippingItem).save(marketplaceOrderShippingItems);
+                                    }
+                                    else {
+                                        let marketplaceOrderShippingItem = new entities_1.MarketplaceOrderShippingItem();
+                                        marketplaceOrderShippingItem.name = (0, uuid_1.v4)();
+                                        marketplaceOrderShippingItem.qty = marketplaceOrderItem.qty;
+                                        marketplaceOrderShippingItem.domain = marketplaceStore.domain;
+                                        marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem;
+                                        marketplaceOrderShippingItem.marketplaceOrderShipping = savedMarketplaceOrderShipping;
+                                        marketplaceOrderShippingItem.product = product ? product : null;
+                                        await tx.getRepository(entities_1.MarketplaceOrderShippingItem).save(marketplaceOrderShippingItem);
+                                    }
+                                }
+                            }
+                        }
+                        // Save marketplaceOrderPackage and marketplaceOrderPacakgeItem in the db
+                        if (marketplaceStore.platform === 'shopee') {
+                            let marketplaceOrderPackage = new entities_1.MarketplaceOrderPackage();
+                            let marketplaceOrderPackageItem = new entities_1.MarketplaceOrderPackageItem();
+                            let existMarketplacePackages = await tx
+                                .getRepository(entities_1.MarketplaceOrderPackage)
+                                .find({ where: { marketplaceOrder: marketplaceOrder.id } });
+                            if ((existMarketplacePackages === null || existMarketplacePackages === void 0 ? void 0 : existMarketplacePackages.length) > 0)
+                                return;
+                            for (let j = 0; j < order.packageList.length; j++) {
+                                let marketplacePackage = order.packageList[j];
+                                let packageItems = marketplacePackage.packageItem;
+                                let marketplaceOrderItem;
+                                marketplaceOrderPackage.id = (0, uuid_1.v4)();
+                                marketplaceOrderPackage.name = order.name;
+                                marketplaceOrderPackage.packageId = marketplacePackage.packageId;
+                                marketplaceOrderPackage.transporter = marketplacePackage.transporter;
+                                marketplaceOrderPackage.marketplaceOrder = marketplaceOrder;
+                                marketplaceOrderPackage.domain = domain;
+                                // use insert instead of save
+                                await tx.getRepository(entities_1.MarketplaceOrderPackage).insert(marketplaceOrderPackage);
+                                for (let i = 0; i < packageItems.length; i++) {
+                                    let packageItem = packageItems[i];
+                                    marketplaceOrderItem = marketplaceOrderItems.find(itm => {
+                                        return itm.orderId == packageItem.orderItemId;
+                                    });
+                                    marketplaceOrderPackageItem.id = (0, uuid_1.v4)();
+                                    marketplaceOrderPackageItem.name = marketplaceOrderItem.name;
+                                    marketplaceOrderPackageItem.qty = marketplaceOrderItem.qty;
+                                    marketplaceOrderPackageItem.domain = domain;
+                                    marketplaceOrderPackageItem.marketplaceOrderPackage = marketplaceOrderPackage;
+                                    marketplaceOrderPackageItem.marketplaceOrderItem = marketplaceOrderItem;
+                                    // use insert
+                                    await tx.getRepository(entities_1.MarketplaceOrderPackageItem).insert(marketplaceOrderPackageItem);
+                                }
+                            }
+                        }
+                        if (i == marketplaceOrders.length - 1) {
+                            lastOrderId = order.name;
+                        }
+                    }
+                    catch (e) {
+                        if (scheduler) {
+                            env_1.logger.error(`Order no: ${marketplaceOrders[i].name}: ${e}`);
+                        }
+                        else {
+                            throw new Error(e);
+                        }
+                    }
+                });
+            }
+            if (more)
+                page++;
+            hasMorePage = more;
+        }
+        try {
+            if (marketplaceStore.platform === 'shopee') {
+                let pageNo = 1;
+                let hasMore = true;
+                let perPage = 100;
+                var payoutDateList = [];
+                while (hasMore) {
+                    const { result: payoutDates, more } = await integration_marketplace_1.StoreAPI.getStoreOrderPayoutDates(marketplaceStore, {
+                        fromCreatedDate,
+                        toCreatedDate,
+                        pagination: { page: pageNo, limit: perPage }
+                    });
+                    payoutDateList.push(...payoutDates);
+                    if (more)
+                        pageNo++;
+                    hasMore = more;
+                }
+                await (0, typeorm_1.getConnection)().transaction(async (tx) => {
+                    await Promise.all(payoutDateList.map(async (item) => {
+                        await tx.getRepository(entities_1.MarketplaceOrder).update({
+                            orderNo: item.orderNo
+                        }, {
+                            payoutDate: item.payoutDate
+                        });
+                    }));
+                });
+            }
+        }
+        catch (e) { }
+        return true;
+    }
+};
+async function updateQtyAndReserveQtyBundle(tx, variation, domain, qty, marketplaceOrder, existingMarketplaceOrder = null, matchedOrderItemQty = null) {
+    let statusAllowed = reserve_qty_order_statuses_1.RESERVE_QTY_ORDER_STATUSES[marketplaceOrder.marketplaceStore.platform.toUpperCase()].includes(marketplaceOrder.status);
+    let existingStatusNotAllowed = existingMarketplaceOrder
+        ? !reserve_qty_order_statuses_1.RESERVE_QTY_ORDER_STATUSES[existingMarketplaceOrder.marketplaceStore.platform.toUpperCase()].includes(existingMarketplaceOrder.status)
+        : false;
+    const productBundle = await tx.getRepository(product_base_1.ProductBundle).findOne({
+        where: { sku: variation.sku, domain },
+        relations: ['productBundleSettings', 'productBundleSettings.product']
+    });
+    if (productBundle) {
+        for (let setting of productBundle.productBundleSettings) {
+            const mpvs = await tx.getRepository(entities_1.MarketplaceProductVariation).find({
+                where: { domain, sku: setting.product.sku },
+                relations: ['domain']
+            });
+            for (let mpv of mpvs) {
+                let updatedReserveQty = 0;
+                let updatedQty = 0;
+                if (existingMarketplaceOrder) {
+                    if (((statusAllowed && existingStatusNotAllowed) ||
+                        (cancelStatuses.includes(marketplaceOrder.status) && !existingStatusNotAllowed)) &&
+                        marketplaceOrder.marketplaceStore.reserveEnabled) {
+                        updatedReserveQty += setting.bundleQty * qty;
+                    }
+                    updatedQty += setting.bundleQty * qty - matchedOrderItemQty * setting.bundleQty;
+                }
+                else {
+                    if (statusAllowed && qty > 0 && marketplaceOrder.marketplaceStore.reserveEnabled) {
+                        updatedReserveQty += setting.bundleQty * qty;
+                    }
+                    if (mpv.qty - setting.bundleQty * qty >= 0) {
+                        updatedQty += setting.bundleQty * qty;
+                    }
+                }
+                await tx
+                    .createQueryBuilder()
+                    .update(entities_1.MarketplaceProductVariation)
+                    .set({
+                    qty: () => `COALESCE("qty", 0) - ${updatedQty}`,
+                    reserveQty: () => `COALESCE("reserve_qty", 0) + ${updatedReserveQty}`
+                })
+                    .where('id = :id', { id: mpv.id })
+                    .execute();
+                // reserve qty log
+                try {
+                    let log = {
+                        marketplaceOrder: marketplaceOrder.name,
+                        releaseOrder: marketplaceOrder === null || marketplaceOrder === void 0 ? void 0 : marketplaceOrder.releaseOrderId,
+                        mpvId: mpv.id,
+                        sku: mpv === null || mpv === void 0 ? void 0 : mpv.sku,
+                        qty: updatedQty,
+                        reservedQty: updatedReserveQty,
+                        bundleProduct: true
+                    };
+                    env_1.logger.info(`[reserveQty] ${JSON.stringify(log)}`);
+                }
+                catch (e) {
+                    env_1.logger.error('[marketplace-base] cannot create reserve qty log');
+                }
+            }
+        }
+    }
+}
+function checkUpdateItemId(existingOrderItems, marketplaceOrderItems) {
+    for (let item of marketplaceOrderItems) {
+        let existingItem = existingOrderItems.find(i => i.name == item.name);
+        if (!existingItem) {
+            let existingItemByVariation = existingOrderItems.find(i => i.marketplaceProductVariation.id == item.marketplaceProductVariation.id);
+            if (existingItemByVariation) {
+                existingOrderItems = existingOrderItems.filter(i => i != existingItemByVariation);
+                existingItemByVariation.name = item.name;
+                existingOrderItems.push(existingItemByVariation);
+            }
+        }
+    }
+    return existingOrderItems;
+}
+async function updateQtyAndReserveQty(tx, foundVariation, marketplaceOrder, qty, matchedOrderItemQty = null, existingMarketplaceOrder = null) {
+    let roCreated = existingMarketplaceOrder ? existingMarketplaceOrder === null || existingMarketplaceOrder === void 0 ? void 0 : existingMarketplaceOrder.releaseOrderId : false;
+    let existingStatusNotAllowed = existingMarketplaceOrder
+        ? !reserve_qty_order_statuses_1.RESERVE_QTY_ORDER_STATUSES[existingMarketplaceOrder.marketplaceStore.platform.toUpperCase()].includes(existingMarketplaceOrder.status)
+        : false;
+    let activeVariations = await tx
+        .getRepository(entities_1.MarketplaceProductVariation)
+        .createQueryBuilder('mpv')
+        .innerJoin('mpv.marketplaceProduct', 'marketplaceProduct')
+        .innerJoin('marketplaceProduct.marketplaceStore', 'marketplaceStore')
+        .where('mpv.domain_id = :domainId', { domainId: marketplaceOrder.domain.id })
+        .andWhere('mpv.sku = :sku', { sku: foundVariation.sku })
+        .andWhere(`marketplaceStore.status != 'TERMINATED'`)
+        .getMany();
+    let statusAllowed = reserve_qty_order_statuses_1.RESERVE_QTY_ORDER_STATUSES[marketplaceOrder.marketplaceStore.platform.toUpperCase()].includes(marketplaceOrder.status);
+    if (existingMarketplaceOrder && !roCreated) {
+        await updateQtyAndReserveQtyBundle(tx, foundVariation, marketplaceOrder.domain, qty, marketplaceOrder, existingMarketplaceOrder, matchedOrderItemQty);
+    }
+    else {
+        await updateQtyAndReserveQtyBundle(tx, foundVariation, marketplaceOrder.domain, qty, marketplaceOrder);
+    }
+    await Promise.all(activeVariations.map(async (variation) => {
+        let updatedReserveQty = 0;
+        let updatedQty = 0;
+        if (matchedOrderItemQty) {
+            if (marketplaceOrder.marketplaceStore.reserveEnabled) {
+                updatedReserveQty = roCreated
+                    ? 0
+                    : statusAllowed && existingStatusNotAllowed
+                        ? qty
+                        : qty - matchedOrderItemQty;
+            }
+            updatedQty = roCreated ? 0 : qty - matchedOrderItemQty;
+        }
+        else {
+            if (((statusAllowed && qty > 0) || qty < 0) && marketplaceOrder.marketplaceStore.reserveEnabled) {
+                updatedReserveQty = qty;
+            }
+            if (variation.qty - qty >= 0) {
+                updatedQty = qty;
+            }
+        }
+        await tx
+            .createQueryBuilder()
+            .update(entities_1.MarketplaceProductVariation)
+            .set({
+            qty: () => `COALESCE("qty", 0) - ${updatedQty}`,
+            reserveQty: () => `COALESCE("reserve_qty", 0) + ${updatedReserveQty}`
+        })
+            .where('id = :id', { id: variation.id })
+            .execute();
+        // reserve qty log
+        try {
+            let log = {
+                marketplaceOrder: marketplaceOrder.name,
+                releaseOrder: marketplaceOrder === null || marketplaceOrder === void 0 ? void 0 : marketplaceOrder.releaseOrderId,
+                mpvId: variation.id,
+                sku: variation === null || variation === void 0 ? void 0 : variation.sku,
+                qty: updatedQty,
+                reservedQty: updatedReserveQty,
+                bundle: false
+            };
+            env_1.logger.info(`[reserveQty] ${JSON.stringify(log)}`);
+        }
+        catch (e) {
+            env_1.logger.error('[marketplace-base] cannot create reserve qty log');
+        }
+    }));
+}
+function _extractTrackingNo(ownTrackingNo, trackingNo) {
+    let finalTrackingNo = trackingNo == '[]' || !trackingNo ? ownTrackingNo : trackingNo;
+    // For lazada order, tracking code is passed as JSON
+    // which will produce error in manifest stage later on
+    // solution: extract the tracking code as follows:
+    if (finalTrackingNo === null || finalTrackingNo === void 0 ? void 0 : finalTrackingNo.includes('tracking_code')) {
+        let extratedTrackingNo = JSON.parse(finalTrackingNo);
+        finalTrackingNo = extratedTrackingNo
+            .reduce((trackingNos, item) => {
+            if (!trackingNos.find(num => num === item.tracking_code))
+                trackingNos.push(item.tracking_code);
+            return trackingNos;
+        }, [])
+            .join(', ');
+    }
+    return finalTrackingNo;
+}
+//# sourceMappingURL=sync-marketplace-order.js.map