@things-factory/marketplace-base 3.6.3 → 3.6.8

package/dist-server/graphql/types/marketplace-order-shipping/marketplace-order-shipping-patch.js

@@ -12,6 +12,7 @@ exports.MarketplaceOrderShippingPatch = (0, graphql_tag_1.default) `
     description: String
     marketplaceOrderItems: [ObjectRef]
     orderNoRef: String
+    subOrderNoRef: String
     address1: String
     address2: String
     address3: String
@@ -19,6 +20,7 @@ exports.MarketplaceOrderShippingPatch = (0, graphql_tag_1.default) `
     address5: String
     attentionTo: String
     transporter: String
+    ownTransporter: String
     city: String
     state: String
     postCode: String
@@ -37,6 +39,7 @@ exports.MarketplaceOrderShippingPatch = (0, graphql_tag_1.default) `
     airwayBill: String
     invoice: String
     trackingNo: String
+    ownTrackingNo: String
     orderType: String
     freightType: Int
     parcelType: Int

package/dist-server/graphql/types/marketplace-order-shipping/marketplace-order-shipping-patch.js.map

@@ -1 +1 @@
-{"version":3,"file":"marketplace-order-shipping-patch.js","sourceRoot":"","sources":["../../../../server/graphql/types/marketplace-order-shipping/marketplace-order-shipping-patch.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA6B;AAEhB,QAAA,6BAA6B,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC/C,CAAA"}
+{"version":3,"file":"marketplace-order-shipping-patch.js","sourceRoot":"","sources":["../../../../server/graphql/types/marketplace-order-shipping/marketplace-order-shipping-patch.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA6B;AAEhB,QAAA,6BAA6B,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0C/C,CAAA"}

package/dist-server/graphql/types/marketplace-order-shipping/marketplace-order-shipping.js

@@ -15,6 +15,7 @@ exports.MarketplaceOrderShipping = (0, graphql_tag_1.default) `
     marketplaceOrderItems: [MarketplaceOrderItem]
     marketplaceStore: MarketplaceStore
     orderNoRef: String
+    subOrderNoRef: String
     shippingId: String
     address1: String
     address2: String
@@ -31,7 +32,9 @@ exports.MarketplaceOrderShipping = (0, graphql_tag_1.default) `
     email: String
     type: String
     transporter: String
+    ownTransporter: String
     trackingNo: String
+    ownTrackingNo: String
     airwayBill: String
     invoice: String
     weightUnit: String

package/dist-server/graphql/types/marketplace-order-shipping/marketplace-order-shipping.js.map

@@ -1 +1 @@
-{"version":3,"file":"marketplace-order-shipping.js","sourceRoot":"","sources":["../../../../server/graphql/types/marketplace-order-shipping/marketplace-order-shipping.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA6B;AAEhB,QAAA,wBAAwB,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8C1C,CAAA"}
+{"version":3,"file":"marketplace-order-shipping.js","sourceRoot":"","sources":["../../../../server/graphql/types/marketplace-order-shipping/marketplace-order-shipping.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA6B;AAEhB,QAAA,wBAAwB,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiD1C,CAAA"}

package/dist-server/graphql/types/marketplace-order-shipping/new-marketplace-order-shipping.js

@@ -11,6 +11,7 @@ exports.NewMarketplaceOrderShipping = (0, graphql_tag_1.default) `
     description: String
     marketplaceOrderItems: [ObjectRef]
     orderNoRef: String
+    subOrderNoRef: String
     shippingId: String
     address1: String
     address2: String
@@ -27,7 +28,9 @@ exports.NewMarketplaceOrderShipping = (0, graphql_tag_1.default) `
     email: String
     type: String
     transporter: String
+    ownTransporter: String
     trackingNo: String
+    ownTrackingNo: String
     airwayBill: String
     invoice: String
     weightUnit: String

package/dist-server/graphql/types/marketplace-order-shipping/new-marketplace-order-shipping.js.map

@@ -1 +1 @@
-{"version":3,"file":"new-marketplace-order-shipping.js","sourceRoot":"","sources":["../../../../server/graphql/types/marketplace-order-shipping/new-marketplace-order-shipping.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA6B;AAEhB,QAAA,2BAA2B,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC7C,CAAA"}
+{"version":3,"file":"new-marketplace-order-shipping.js","sourceRoot":"","sources":["../../../../server/graphql/types/marketplace-order-shipping/new-marketplace-order-shipping.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA6B;AAEhB,QAAA,2BAA2B,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyC7C,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/marketplace-base",
-  "version": "3.6.3",
+  "version": "3.6.8",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,9 +24,9 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/integration-fulfillment": "^3.6.3",
-    "@things-factory/integration-marketplace": "^3.6.3",
-    "@things-factory/shell": "^3.6.1"
+    "@things-factory/integration-fulfillment": "^3.6.8",
+    "@things-factory/integration-marketplace": "^3.6.7",
+    "@things-factory/shell": "^3.6.7"
   },
-  "gitHead": "2bc8415b0ef4f036ccede0c82437f2ee96616b0c"
+  "gitHead": "7f1c9066395c4dccecbc248216a828d9ae06de23"
 }

package/server/entities/marketplace-order-shipping.ts

@@ -1,5 +1,3 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
 import {
   Column,
   CreateDateColumn,
@@ -10,8 +8,13 @@ import {
   PrimaryGeneratedColumn,
   UpdateDateColumn
 } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
 import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Domain } from '@things-factory/shell'
+
 import { MarketplaceOrderItem } from '../entities'
+
 @Entity()
 @Index(
   'ix_marketplace-order-shipping_0',
@@ -40,6 +43,9 @@ export class MarketplaceOrderShipping {
   @Column({ nullable: true })
   orderNoRef: string
 
+  @Column({ nullable: true })
+  subOrderNoRef: string
+
   @Column()
   address1: string
 
@@ -82,6 +88,9 @@ export class MarketplaceOrderShipping {
   @Column({ nullable: true })
   transporter: string
 
+  @Column({ nullable: true })
+  ownTransporter: string
+
   @Column({ nullable: true })
   orderType: string
 
@@ -124,6 +133,9 @@ export class MarketplaceOrderShipping {
   @Column({ nullable: true })
   trackingNo: string
 
+  @Column({ nullable: true })
+  ownTrackingNo: string
+
   @Column({ nullable: true })
   airwayBill: string
 

package/server/entities/marketplace-order.ts

@@ -1,6 +1,3 @@
-import { User } from '@things-factory/auth-base'
-import { MarketplaceStore } from '@things-factory/integration-marketplace'
-import { Domain } from '@things-factory/shell'
 import {
   Column,
   CreateDateColumn,
@@ -11,8 +8,13 @@ import {
   PrimaryGeneratedColumn,
   UpdateDateColumn
 } from 'typeorm'
-import { MarketplaceOrderItem } from '../entities'
+
+import { User } from '@things-factory/auth-base'
 import { FulfillmentCenter } from '@things-factory/integration-fulfillment'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Domain } from '@things-factory/shell'
+
+import { MarketplaceOrderItem } from '../entities'
 
 @Entity()
 @Index(
@@ -72,9 +74,15 @@ export class MarketplaceOrder {
   @Column({ nullable: true })
   trackingNo: string
 
+  @Column({ nullable: true })
+  ownTrackingNo: string
+
   @Column({ nullable: true })
   shippingProvider: string
 
+  @Column({ nullable: true })
+  ownShippingProvider: string
+
   @Column()
   status: string
 
@@ -93,6 +101,9 @@ export class MarketplaceOrder {
   @Column({ nullable: true })
   otherInfoJSON: string
 
+  @Column({ nullable: true })
+  isSplitted: boolean
+
   @CreateDateColumn()
   createdAt: Date
 

package/server/graphql/resolvers/marketplace-order/cancel-marketplace-order.ts

@@ -33,14 +33,33 @@ export const cancelMarketplaceOrderResolver = {
 
     const cancelStatuses: string[] = ['cancelled', 'canceled']
     if (cancelStatuses.includes(marketplaceOrder.status) && marketplaceOrder?.releaseOrderId) {
-      const releaseOrderId: string = marketplaceOrder.releaseOrderId
-      const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
-      const centerId: string = fulfillmentCenter.centerId
-
-      const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
-      const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
-      const customerBizplaceId: string = customerBizplaces[0].id
-      await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
+      if (marketplaceOrder.isSplitted) {
+        const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
+        const centerId: string = fulfillmentCenter.centerId
+        const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
+        const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+        const customerBizplaceId: string = customerBizplaces[0].id
+
+        const { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
+          customerBizplaceId,
+          refNo: marketplaceOrder.orderNo
+        })
+        if (releaseOrders?.length) {
+          for (var a = 0; a < releaseOrders.length; a++) {
+            const releaseOrderId: string = releaseOrders[a].id
+            await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
+          }
+        }
+      } else {
+        const releaseOrderId: string = marketplaceOrder.releaseOrderId
+        const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
+        const centerId: string = fulfillmentCenter.centerId
+
+        const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
+        const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+        const customerBizplaceId: string = customerBizplaces[0].id
+        await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
+      }
     }
 
     return marketplaceOrder

package/server/graphql/resolvers/marketplace-order/generate-marketplace-order.ts

@@ -1,12 +1,14 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { MarketplaceStore as MarketplaceStoreEntity } from '@things-factory/integration-marketplace'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import {
   MarketplaceOrder as MarketplaceOrderEntity,
   MarketplaceOrderItem as MarketplaceOrderItemEntity,
-  MarketplaceProductVariation as MarketplaceProductVariationEntity,
-  MarketplaceOrderShipping as MarketplaceOrderShippingEntity
+  MarketplaceOrderShipping as MarketplaceOrderShippingEntity,
+  MarketplaceProductVariation as MarketplaceProductVariationEntity
 } from '../../../entities'
 import { NoGenerator } from '../../../utils/no-generator'
 
@@ -58,8 +60,13 @@ export async function generateMarketplaceOrder(
     newMarketplaceOrderShipping.name = marketplaceOrderShipping?.shippingId
       ? marketplaceOrderShipping.shippingId
       : NoGenerator.orderShipping()
+    newMarketplaceOrderShipping.transporter =
+      marketplaceOrderShipping?.transporter === '' ? null : marketplaceOrderShipping.transporter
+    newMarketplaceOrderShipping.ownTransporter =
+      marketplaceOrderShipping?.transporter === '' ? null : marketplaceOrderShipping.transporter
     newMarketplaceOrderShipping.marketplaceStore = marketplaceStore
     newMarketplaceOrderShipping.orderNoRef = newMarketplaceOrder.orderNo
+    newMarketplaceOrderShipping.subOrderNoRef = newMarketplaceOrder.orderNo
     newMarketplaceOrderShipping.domain = domain
     newMarketplaceOrderShipping.creator = user
     newMarketplaceOrderShipping = await tx

package/server/graphql/resolvers/marketplace-order/index.ts

@@ -21,9 +21,11 @@ import { marketplaceOrdersForBatchInitResolver } from './marketplace-orders-for-
 import { marketplaceOrdersForExport } from './marketplace-orders-for-export'
 import { setMarketplaceOrderDelivered } from './set-marketplace-order-delivered'
 import { setMarketplaceOrderFailedDelivery } from './set-marketplace-order-failed-delivery'
+import { setOwnShippingProviderByOrdersResolver } from './set-own-shipping-provider-by-orders'
 import { splitOrdersByBatch } from './split-orders-by-batch'
 import { syncAllMarketplaceOrder } from './sync-all-marketplace-order'
 import { syncMarketplaceOrder } from './sync-marketplace-order'
+import { updateMarketplaceOrder } from './update-marketplace-order'
 import { updateOrderReadyToShip } from './update-order-ready-to-ship'
 
 export const MarketplaceOrderResolver = {
@@ -56,7 +58,9 @@ export const MarketplaceOrderResolver = {
     ...initialiseShopeeLogisticsByBatch,
     ...initialiseLazadaLogisticsByBatch,
     ...cancelMarketplaceOrderResolver,
-    ...splitOrdersByBatch
+    ...splitOrdersByBatch,
+    ...updateMarketplaceOrder,
+    ...setOwnShippingProviderByOrdersResolver
   }
 }
 

package/server/graphql/resolvers/marketplace-order/initialise-logistics-by-batch.ts

@@ -26,9 +26,11 @@ export const initialiseLogisticsByBatch = {
 
         marketplaceOrderShipping.trackingNo = patch?.trackingNo
         marketplaceOrderShipping.transporter = patch?.shippingProvider
+        marketplaceOrderShipping.ownTransporter = patch?.shippingProvider
         await tx.getRepository(MarketplaceOrderShipping).save(marketplaceOrderShipping)
 
-        marketplaceOrder.shippingProvider = patch.shippingProvider
+        marketplaceOrder.shippingProvider = patch?.shippingProvider
+        marketplaceOrder.ownShippingProvider = patch?.shippingProvider
         marketplaceOrder.trackingNo = patch?.trackingNo
 
         await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)

package/server/graphql/resolvers/marketplace-order/initialise-shopee-logistics-by-batch.ts

@@ -1,12 +1,14 @@
-import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
 import { getRepository } from 'typeorm'
+
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+
 import { MarketplaceOrder } from '../../../entities'
 
 export const initialiseShopeeLogisticsByBatch = {
   async initialiseShopeeLogisticsByBatch(_: any, { patches }, context: any) {
     await Promise.all(
       patches.map(async patch => {
-        const foundMarketplaceOrder: MarketplaceOrder = await getRepository(MarketplaceOrder).findOne({
+        let foundMarketplaceOrder: MarketplaceOrder = await getRepository(MarketplaceOrder).findOne({
           where: { id: patch.id },
           relations: ['marketplaceStore', 'marketplaceOrderItems']
         })

package/server/graphql/resolvers/marketplace-order/set-own-shipping-provider-by-orders.ts

@@ -0,0 +1,43 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+
+import { MarketplaceOrder, MarketplaceOrderShipping } from '../../../entities'
+
+export const setOwnShippingProviderByOrdersResolver = {
+  async setOwnShippingProviderByOrders(_: any, { patches }, context: any) {
+    const { user, tx }: { user: User; tx: EntityManager } = context.state
+
+    await Promise.all(
+      patches.map(async patch => {
+        let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+          where: { id: patch.id },
+          relations: ['marketplaceStore']
+        })
+
+        if (!marketplaceOrder) throw new Error('No order is found')
+
+        let marketplaceOrderShippings: MarketplaceOrderShipping[] = await tx
+          .getRepository(MarketplaceOrderShipping)
+          .find({
+            where: { orderNoRef: marketplaceOrder.orderNo },
+            relations: ['marketplaceStore']
+          })
+
+        marketplaceOrder.ownShippingProvider = patch?.ownShippingProvider
+
+        await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)
+
+        marketplaceOrderShippings = marketplaceOrderShippings.map(marketplaceOrderShipping => {
+          return {
+            ...marketplaceOrderShipping,
+            ownTransporter: patch?.ownShippingProvider
+          }
+        })
+
+        await tx.getRepository(MarketplaceOrderShipping).save(marketplaceOrderShippings)
+      })
+    )
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-order/split-orders-by-batch.ts

@@ -1,7 +1,7 @@
 import { EntityManager } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { MarketplaceSetting, MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { MarketplaceSetting, MarketplaceStore } from '@things-factory/integration-marketplace'
 import { Domain } from '@things-factory/shell'
 
 import {
@@ -36,172 +36,110 @@ export const splitOrdersByBatch = {
       })
       if (!maxWeightSetting) throw new Error('marketplace_order_max_weight setting not found')
 
-      if (marketplaceStore.platform === 'shopee') {
-        let marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
-
-        if (marketplaceOrderItems.some(item => item.marketplaceProductVariation.primaryUnitValue == null)) {
-          throw new Error('some sku weight are empty')
-        }
-
-        marketplaceOrderItems.sort(function (a, b) {
-          if (
-            a.marketplaceProductVariation.primaryUnitValue * a.qty <
-            b.marketplaceProductVariation.primaryUnitValue * b.qty
-          )
-            return -1
-          if (
-            a.marketplaceProductVariation.primaryUnitValue * a.qty >
-            b.marketplaceProductVariation.primaryUnitValue * b.qty
-          )
-            return 1
-          return 0
+      let originalMarketplaceOrderShipping: MarketplaceOrderShipping = await tx
+        .getRepository(MarketplaceOrderShipping)
+        .findOne({
+          where: { domain, orderNoRef: marketplaceOrder.orderNo, marketplaceStore: marketplaceOrder.marketplaceStore }
         })
 
-        let splittedShipmentItems: any[] = []
-        for (let j: number = 0; j < marketplaceOrderItems.length; j++) {
-          const marketplaceOrderItem: MarketplaceOrderItem = marketplaceOrderItems[j]
-          const marketplaceProductVariation: MarketplaceProductVariation =
-            marketplaceOrderItem.marketplaceProductVariation
-          const qty: number = marketplaceOrderItem.qty
-          const primaryValue: number = parseFloat(marketplaceProductVariation.primaryUnitValue.toFixed(2)) * qty
+      const originalMarketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
+      let newMarketplaceOrderItems: MarketplaceOrderItem[] = []
+      let splittedShipmentItems: any[] = []
 
-          if (splittedShipmentItems.length == 0) {
-            let splittedShipment: any = {
-              shipments: [{ ...marketplaceOrderItem }],
-              totalWeight: primaryValue
-            }
-            splittedShipmentItems.push(splittedShipment)
-          } else {
-            let lastShipment: any = splittedShipmentItems[splittedShipmentItems.length - 1]
-            let lastTotalWeight: number = parseFloat(lastShipment.totalWeight.toFixed(2))
-            if (lastTotalWeight + primaryValue < parseFloat(maxWeightSetting.value)) {
-              splittedShipmentItems.map((shipmentItem, idx) => {
-                if (idx === splittedShipmentItems.length - 1) {
-                  let shipments: any[] = shipmentItem.shipments
-
-                  shipments = shipments.map(async shipment => {
-                    if (shipment.marketplaceProductVariation.id === marketplaceProductVariation.id) {
-                      shipment.qty += marketplaceOrderItem.qty
-                    } else {
-                      marketplaceOrderItem.marketplaceOrder = marketplaceOrder
-                      marketplaceOrderItem.marketplaceOrderShipping = shipment.marketplaceOrderShipping
-                      shipmentItem.shipments.push({ ...marketplaceOrderItem })
-                    }
-
-                    shipment.marketplaceOrderShipping.totalWeight = parseFloat(
-                      (lastTotalWeight + primaryValue).toFixed(2)
-                    )
-                    await tx.getRepository(MarketplaceOrderShipping).save(shipment.marketplaceOrderShipping)
-                  })
-
-                  shipmentItem.totalWeight += primaryValue
-                }
-              })
-            } else {
-              let splittedShipment: any = {
-                shipments: [{ ...marketplaceOrderItem }],
-                totalWeight: primaryValue
-              }
-              splittedShipmentItems.push(splittedShipment)
-            }
+      for (let a: number = 0; a < originalMarketplaceOrderItems.length; a++) {
+        const marketplaceOrderItem: MarketplaceOrderItem = originalMarketplaceOrderItems[a]
+
+        for (let b: number = 0; b < marketplaceOrderItem.qty; b++) {
+          const newItem: MarketplaceOrderItem = {
+            ...marketplaceOrderItem,
+            qty: 1
           }
+          newMarketplaceOrderItems.push(newItem)
         }
+      }
 
-        let parcels: any[] = []
+      newMarketplaceOrderItems.sort(function (a, b) {
+        if (a.marketplaceProductVariation.primaryUnitValue < b.marketplaceProductVariation.primaryUnitValue) return -1
+        if (a.marketplaceProductVariation.primaryUnitValue > b.marketplaceProductVariation.primaryUnitValue) return 1
+        return 0
+      })
 
-        splittedShipmentItems.forEach(shipmentItem => {
-          parcels.push(
-            shipmentItem.shipments.map(shipment => {
-              return {
-                item_id: parseFloat(shipment.name),
-                variation_id: parseFloat(shipment.marketplaceProductVariation.variationId),
-                order_item_id: parseFloat(shipment.name),
-                promotion_group_id: 0
+      for (let a: number = 0; a < newMarketplaceOrderItems.length; a++) {
+        const marketplaceOrderItem: MarketplaceOrderItem = newMarketplaceOrderItems[a]
+        const marketplaceProductVariation: MarketplaceProductVariation =
+          marketplaceOrderItem.marketplaceProductVariation
+        if (!marketplaceProductVariation.primaryUnitValue)
+          throw new Error(marketplaceProductVariation.variationSku + ' weight is empty')
+        const primaryUnitValue: number = parseFloat(marketplaceProductVariation.primaryUnitValue.toFixed(2))
+
+        delete marketplaceOrderItem.id
+
+        let newMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
+        newMarketplaceOrderShipping.name = NoGenerator.orderShipping()
+        newMarketplaceOrderShipping.address1 = originalMarketplaceOrderShipping.address1
+        newMarketplaceOrderShipping.address2 = originalMarketplaceOrderShipping.address2
+        newMarketplaceOrderShipping.address3 = originalMarketplaceOrderShipping.address3
+        newMarketplaceOrderShipping.address4 = originalMarketplaceOrderShipping.address4
+        newMarketplaceOrderShipping.address5 = originalMarketplaceOrderShipping.address5
+        newMarketplaceOrderShipping.attentionTo = originalMarketplaceOrderShipping.attentionTo
+        newMarketplaceOrderShipping.city = originalMarketplaceOrderShipping.city
+        newMarketplaceOrderShipping.country = originalMarketplaceOrderShipping.country
+        newMarketplaceOrderShipping.postCode = originalMarketplaceOrderShipping.postCode
+        newMarketplaceOrderShipping.phone1 = originalMarketplaceOrderShipping.phone1
+        newMarketplaceOrderShipping.phone2 = originalMarketplaceOrderShipping.phone2
+        newMarketplaceOrderShipping.orderNoRef = marketplaceOrder.orderNo
+        newMarketplaceOrderShipping.transporter = originalMarketplaceOrderShipping.transporter
+        newMarketplaceOrderShipping.marketplaceStore = marketplaceStore
+        newMarketplaceOrderShipping.creator = user
+        newMarketplaceOrderShipping.domain = marketplaceOrder.domain
+        newMarketplaceOrderShipping.weightUnit = 'KG'
+
+        if (splittedShipmentItems.length == 0) {
+          newMarketplaceOrderShipping.totalWeight = primaryUnitValue
+
+          newMarketplaceOrderShipping = await tx
+            .getRepository(MarketplaceOrderShipping)
+            .save(newMarketplaceOrderShipping)
+
+          marketplaceOrderItem.marketplaceOrder = marketplaceOrder
+          marketplaceOrderItem.marketplaceOrderShipping = newMarketplaceOrderShipping
+          marketplaceOrderItem.domain = marketplaceOrder.domain
+          marketplaceOrderItem.docRefNo = marketplaceOrder.orderNo
+
+          let splittedShipment: any = {
+            shipments: [{ ...marketplaceOrderItem }],
+            totalWeight: primaryUnitValue
+          }
+          splittedShipmentItems.push(splittedShipment)
+        } else {
+          let lastShipment: any = splittedShipmentItems[splittedShipmentItems.length - 1]
+          let lastTotalWeight: number = parseFloat(lastShipment.totalWeight.toFixed(2))
+          if (lastTotalWeight + primaryUnitValue < parseFloat(maxWeightSetting.value)) {
+            splittedShipmentItems.map((shipmentItem, idx) => {
+              if (idx === splittedShipmentItems.length - 1) {
+                let shipments: any[] = shipmentItem.shipments
+
+                shipments = shipments.map(async shipment => {
+                  if (shipment.marketplaceProductVariation.id === marketplaceProductVariation.id) {
+                    shipment.qty += marketplaceOrderItem.qty
+                  } else {
+                    marketplaceOrderItem.marketplaceOrder = marketplaceOrder
+                    marketplaceOrderItem.marketplaceOrderShipping = shipment.marketplaceOrderShipping
+                    marketplaceOrderItem.domain = marketplaceOrder.domain
+                    marketplaceOrderItem.docRefNo = marketplaceOrder.orderNo
+                    shipmentItem.shipments.push({ ...marketplaceOrderItem })
+                  }
+
+                  shipment.marketplaceOrderShipping.totalWeight = parseFloat(
+                    (lastTotalWeight + primaryUnitValue).toFixed(2)
+                  )
+                  await tx.getRepository(MarketplaceOrderShipping).save(shipment.marketplaceOrderShipping)
+                })
+
+                shipmentItem.totalWeight += primaryUnitValue
               }
             })
-          )
-        })
-
-        const splittedPackage: any = await StoreAPI.splitOrder(marketplaceStore, {
-          ordersn: marketplaceOrder.orderNo,
-          parcels
-        })
-
-        const packageLists: any[] = splittedPackage.packageList
-
-        for (let a: number = 0; a < packageLists.length; a++) {
-          const packageList: any = packageLists[a]
-          const packageNumber: string = packageList.packageNumber
-          const packageItems: any[] = packageList.items
-          for (let b: number = 0; b < marketplaceOrderItems.length; b++) {
-            let marketplaceOrderItem: any = marketplaceOrderItems[b]
-            if (packageItems.find(item => item.itemId === marketplaceOrderItem)) {
-              marketplaceOrderItem.packageId = packageNumber
-            }
-          }
-        }
-
-        await tx.getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
-      } else {
-        let originalMarketplaceOrderShipping: MarketplaceOrderShipping = await tx
-          .getRepository(MarketplaceOrderShipping)
-          .findOne({
-            where: { domain, orderNoRef: marketplaceOrder.orderNo, marketplaceStore: marketplaceOrder.marketplaceStore }
-          })
-
-        const originalMarketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
-        let newMarketplaceOrderItems: MarketplaceOrderItem[] = []
-        let splittedShipmentItems: any[] = []
-
-        for (let a: number = 0; a < originalMarketplaceOrderItems.length; a++) {
-          const marketplaceOrderItem: MarketplaceOrderItem = originalMarketplaceOrderItems[a]
-
-          for (let b: number = 0; b < marketplaceOrderItem.qty; b++) {
-            const newItem: MarketplaceOrderItem = {
-              ...marketplaceOrderItem,
-              qty: 1
-            }
-            newMarketplaceOrderItems.push(newItem)
-          }
-        }
-
-        newMarketplaceOrderItems.sort(function (a, b) {
-          if (a.marketplaceProductVariation.primaryUnitValue < b.marketplaceProductVariation.primaryUnitValue) return -1
-          if (a.marketplaceProductVariation.primaryUnitValue > b.marketplaceProductVariation.primaryUnitValue) return 1
-          return 0
-        })
-
-        for (let a: number = 0; a < newMarketplaceOrderItems.length; a++) {
-          const marketplaceOrderItem: MarketplaceOrderItem = newMarketplaceOrderItems[a]
-          const marketplaceProductVariation: MarketplaceProductVariation =
-            marketplaceOrderItem.marketplaceProductVariation
-          if (!marketplaceProductVariation.primaryUnitValue)
-            throw new Error(marketplaceProductVariation.variationSku + 'weight is empty')
-          const primaryUnitValue: number = parseFloat(marketplaceProductVariation.primaryUnitValue.toFixed(2))
-
-          delete marketplaceOrderItem.id
-
-          let newMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
-          newMarketplaceOrderShipping.name = NoGenerator.orderShipping()
-          newMarketplaceOrderShipping.address1 = originalMarketplaceOrderShipping.address1
-          newMarketplaceOrderShipping.address2 = originalMarketplaceOrderShipping.address2
-          newMarketplaceOrderShipping.address3 = originalMarketplaceOrderShipping.address3
-          newMarketplaceOrderShipping.address4 = originalMarketplaceOrderShipping.address4
-          newMarketplaceOrderShipping.address5 = originalMarketplaceOrderShipping.address5
-          newMarketplaceOrderShipping.attentionTo = originalMarketplaceOrderShipping.attentionTo
-          newMarketplaceOrderShipping.city = originalMarketplaceOrderShipping.city
-          newMarketplaceOrderShipping.country = originalMarketplaceOrderShipping.country
-          newMarketplaceOrderShipping.postCode = originalMarketplaceOrderShipping.postCode
-          newMarketplaceOrderShipping.phone1 = originalMarketplaceOrderShipping.phone1
-          newMarketplaceOrderShipping.phone2 = originalMarketplaceOrderShipping.phone2
-          newMarketplaceOrderShipping.orderNoRef = marketplaceOrder.orderNo
-          newMarketplaceOrderShipping.transporter = originalMarketplaceOrderShipping.transporter
-          newMarketplaceOrderShipping.marketplaceStore = marketplaceStore
-          newMarketplaceOrderShipping.creator = user
-          newMarketplaceOrderShipping.domain = marketplaceOrder.domain
-          newMarketplaceOrderShipping.weightUnit = 'KG'
-
-          if (splittedShipmentItems.length == 0) {
+          } else {
             newMarketplaceOrderShipping.totalWeight = primaryUnitValue
 
             newMarketplaceOrderShipping = await tx
@@ -210,71 +148,291 @@ export const splitOrdersByBatch = {
 
             marketplaceOrderItem.marketplaceOrder = marketplaceOrder
             marketplaceOrderItem.marketplaceOrderShipping = newMarketplaceOrderShipping
+            marketplaceOrderItem.domain = marketplaceOrder.domain
+            marketplaceOrderItem.docRefNo = marketplaceOrder.orderNo
 
             let splittedShipment: any = {
               shipments: [{ ...marketplaceOrderItem }],
               totalWeight: primaryUnitValue
             }
             splittedShipmentItems.push(splittedShipment)
-          } else {
-            let lastShipment: any = splittedShipmentItems[splittedShipmentItems.length - 1]
-            let lastTotalWeight: number = parseFloat(lastShipment.totalWeight.toFixed(2))
-            if (lastTotalWeight + primaryUnitValue < parseFloat(maxWeightSetting.value)) {
-              splittedShipmentItems.map((shipmentItem, idx) => {
-                if (idx === splittedShipmentItems.length - 1) {
-                  let shipments: any[] = shipmentItem.shipments
-
-                  shipments = shipments.map(async shipment => {
-                    if (shipment.marketplaceProductVariation.id === marketplaceProductVariation.id) {
-                      shipment.qty += marketplaceOrderItem.qty
-                    } else {
-                      marketplaceOrderItem.marketplaceOrder = marketplaceOrder
-                      marketplaceOrderItem.marketplaceOrderShipping = shipment.marketplaceOrderShipping
-                      shipmentItem.shipments.push({ ...marketplaceOrderItem })
-                    }
-
-                    shipment.marketplaceOrderShipping.totalWeight = parseFloat(
-                      (lastTotalWeight + primaryUnitValue).toFixed(2)
-                    )
-                    await tx.getRepository(MarketplaceOrderShipping).save(shipment.marketplaceOrderShipping)
-                  })
-
-                  shipmentItem.totalWeight += primaryUnitValue
-                }
-              })
-            } else {
-              newMarketplaceOrderShipping.totalWeight = primaryUnitValue
-
-              newMarketplaceOrderShipping = await tx
-                .getRepository(MarketplaceOrderShipping)
-                .save(newMarketplaceOrderShipping)
-
-              marketplaceOrderItem.marketplaceOrder = marketplaceOrder
-              marketplaceOrderItem.marketplaceOrderShipping = newMarketplaceOrderShipping
-
-              let splittedShipment: any = {
-                shipments: [{ ...marketplaceOrderItem }],
-                totalWeight: primaryUnitValue
-              }
-              splittedShipmentItems.push(splittedShipment)
-            }
           }
         }
+      }
 
-        let savedMarketplaceOrderItems: MarketplaceOrderItem[] = []
-        for (let a: number = 0; a < splittedShipmentItems.length; a++) {
-          const shipments: any[] = splittedShipmentItems[a].shipments
-          for (let b: number = 0; b < shipments.length; b++) {
-            savedMarketplaceOrderItems.push(shipments[b])
-          }
+      let savedMarketplaceOrderItems: MarketplaceOrderItem[] = []
+      for (let a: number = 0; a < splittedShipmentItems.length; a++) {
+        const shipments: any[] = splittedShipmentItems[a].shipments
+        for (let b: number = 0; b < shipments.length; b++) {
+          savedMarketplaceOrderItems.push(shipments[b])
         }
+      }
 
-        savedMarketplaceOrderItems = await tx.getRepository(MarketplaceOrderItem).save(savedMarketplaceOrderItems)
+      savedMarketplaceOrderItems = await tx.getRepository(MarketplaceOrderItem).save(savedMarketplaceOrderItems)
+
+      await tx.getRepository(MarketplaceOrderItem).delete(originalMarketplaceOrderItems.map(item => item.id))
+
+      await tx.getRepository(MarketplaceOrderShipping).delete(originalMarketplaceOrderShipping.id)
+
+      // if (marketplaceStore.platform === 'shopee') {
+      //   let marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
+
+      //   if (marketplaceOrderItems.some(item => item.marketplaceProductVariation.primaryUnitValue == null)) {
+      //     throw new Error('some sku weight are empty')
+      //   }
+
+      //   marketplaceOrderItems.sort(function (a, b) {
+      //     if (
+      //       a.marketplaceProductVariation.primaryUnitValue * a.qty <
+      //       b.marketplaceProductVariation.primaryUnitValue * b.qty
+      //     )
+      //       return -1
+      //     if (
+      //       a.marketplaceProductVariation.primaryUnitValue * a.qty >
+      //       b.marketplaceProductVariation.primaryUnitValue * b.qty
+      //     )
+      //       return 1
+      //     return 0
+      //   })
+
+      //   let splittedShipmentItems: any[] = []
+      //   for (let j: number = 0; j < marketplaceOrderItems.length; j++) {
+      //     const marketplaceOrderItem: MarketplaceOrderItem = marketplaceOrderItems[j]
+      //     const marketplaceProductVariation: MarketplaceProductVariation =
+      //       marketplaceOrderItem.marketplaceProductVariation
+      //     const qty: number = marketplaceOrderItem.qty
+      //     const primaryValue: number = parseFloat(marketplaceProductVariation.primaryUnitValue.toFixed(2)) * qty
+
+      //     if (splittedShipmentItems.length == 0) {
+      //       let splittedShipment: any = {
+      //         shipments: [{ ...marketplaceOrderItem }],
+      //         totalWeight: primaryValue
+      //       }
+      //       splittedShipmentItems.push(splittedShipment)
+      //     } else {
+      //       let lastShipment: any = splittedShipmentItems[splittedShipmentItems.length - 1]
+      //       let lastTotalWeight: number = parseFloat(lastShipment.totalWeight.toFixed(2))
+      //       if (lastTotalWeight + primaryValue < parseFloat(maxWeightSetting.value)) {
+      //         splittedShipmentItems.map((shipmentItem, idx) => {
+      //           if (idx === splittedShipmentItems.length - 1) {
+      //             let shipments: any[] = shipmentItem.shipments
+
+      //             shipments = shipments.map(async shipment => {
+      //               if (shipment.marketplaceProductVariation.id === marketplaceProductVariation.id) {
+      //                 shipment.qty += marketplaceOrderItem.qty
+      //               } else {
+      //                 marketplaceOrderItem.marketplaceOrder = marketplaceOrder
+      //                 marketplaceOrderItem.marketplaceOrderShipping = shipment.marketplaceOrderShipping
+      //                 shipmentItem.shipments.push({ ...marketplaceOrderItem })
+      //               }
+
+      //               shipment.marketplaceOrderShipping.totalWeight = parseFloat(
+      //                 (lastTotalWeight + primaryValue).toFixed(2)
+      //               )
+      //               await tx.getRepository(MarketplaceOrderShipping).save(shipment.marketplaceOrderShipping)
+      //             })
+
+      //             shipmentItem.totalWeight += primaryValue
+      //           }
+      //         })
+      //       } else {
+      //         let splittedShipment: any = {
+      //           shipments: [{ ...marketplaceOrderItem }],
+      //           totalWeight: primaryValue
+      //         }
+      //         splittedShipmentItems.push(splittedShipment)
+      //       }
+      //     }
+      //   }
+
+      //   let parcels: any[] = []
+
+      //   splittedShipmentItems.forEach(shipmentItem => {
+      //     parcels.push(
+      //       shipmentItem.shipments.map(shipment => {
+      //         return {
+      //           item_id: parseFloat(shipment.name),
+      //           variation_id: parseFloat(shipment.marketplaceProductVariation.variationId),
+      //           order_item_id: parseFloat(shipment.name),
+      //           promotion_group_id: 0
+      //         }
+      //       })
+      //     )
+      //   })
+
+      //   const splittedPackage: any = await StoreAPI.splitOrder(marketplaceStore, {
+      //     ordersn: marketplaceOrder.orderNo,
+      //     parcels
+      //   })
+
+      //   const packageLists: any[] = splittedPackage.packageList
+
+      //   for (let a: number = 0; a < packageLists.length; a++) {
+      //     const packageList: any = packageLists[a]
+      //     const packageNumber: string = packageList.packageNumber
+      //     const packageItems: any[] = packageList.items
+      //     for (let b: number = 0; b < marketplaceOrderItems.length; b++) {
+      //       let marketplaceOrderItem: any = marketplaceOrderItems[b]
+      //       if (packageItems.find(item => item.itemId === marketplaceOrderItem)) {
+      //         marketplaceOrderItem.packageId = packageNumber
+      //       }
+      //     }
+      //   }
+
+      //   await tx.getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
+      // } else {
+      //   let originalMarketplaceOrderShipping: MarketplaceOrderShipping = await tx
+      //     .getRepository(MarketplaceOrderShipping)
+      //     .findOne({
+      //       where: { domain, orderNoRef: marketplaceOrder.orderNo, marketplaceStore: marketplaceOrder.marketplaceStore }
+      //     })
+
+      //   const originalMarketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
+      //   let newMarketplaceOrderItems: MarketplaceOrderItem[] = []
+      //   let splittedShipmentItems: any[] = []
+
+      //   for (let a: number = 0; a < originalMarketplaceOrderItems.length; a++) {
+      //     const marketplaceOrderItem: MarketplaceOrderItem = originalMarketplaceOrderItems[a]
+
+      //     for (let b: number = 0; b < marketplaceOrderItem.qty; b++) {
+      //       const newItem: MarketplaceOrderItem = {
+      //         ...marketplaceOrderItem,
+      //         qty: 1
+      //       }
+      //       newMarketplaceOrderItems.push(newItem)
+      //     }
+      //   }
+
+      //   newMarketplaceOrderItems.sort(function (a, b) {
+      //     if (a.marketplaceProductVariation.primaryUnitValue < b.marketplaceProductVariation.primaryUnitValue) return -1
+      //     if (a.marketplaceProductVariation.primaryUnitValue > b.marketplaceProductVariation.primaryUnitValue) return 1
+      //     return 0
+      //   })
+
+      //   for (let a: number = 0; a < newMarketplaceOrderItems.length; a++) {
+      //     const marketplaceOrderItem: MarketplaceOrderItem = newMarketplaceOrderItems[a]
+      //     const marketplaceProductVariation: MarketplaceProductVariation =
+      //       marketplaceOrderItem.marketplaceProductVariation
+      //     if (!marketplaceProductVariation.primaryUnitValue)
+      //       throw new Error(marketplaceProductVariation.variationSku + 'weight is empty')
+      //     const primaryUnitValue: number = parseFloat(marketplaceProductVariation.primaryUnitValue.toFixed(2))
+
+      //     delete marketplaceOrderItem.id
+
+      //     let newMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
+      //     newMarketplaceOrderShipping.name = NoGenerator.orderShipping()
+      //     newMarketplaceOrderShipping.address1 = originalMarketplaceOrderShipping.address1
+      //     newMarketplaceOrderShipping.address2 = originalMarketplaceOrderShipping.address2
+      //     newMarketplaceOrderShipping.address3 = originalMarketplaceOrderShipping.address3
+      //     newMarketplaceOrderShipping.address4 = originalMarketplaceOrderShipping.address4
+      //     newMarketplaceOrderShipping.address5 = originalMarketplaceOrderShipping.address5
+      //     newMarketplaceOrderShipping.attentionTo = originalMarketplaceOrderShipping.attentionTo
+      //     newMarketplaceOrderShipping.city = originalMarketplaceOrderShipping.city
+      //     newMarketplaceOrderShipping.country = originalMarketplaceOrderShipping.country
+      //     newMarketplaceOrderShipping.postCode = originalMarketplaceOrderShipping.postCode
+      //     newMarketplaceOrderShipping.phone1 = originalMarketplaceOrderShipping.phone1
+      //     newMarketplaceOrderShipping.phone2 = originalMarketplaceOrderShipping.phone2
+      //     newMarketplaceOrderShipping.orderNoRef = marketplaceOrder.orderNo
+      //     newMarketplaceOrderShipping.transporter = originalMarketplaceOrderShipping.transporter
+      //     newMarketplaceOrderShipping.marketplaceStore = marketplaceStore
+      //     newMarketplaceOrderShipping.creator = user
+      //     newMarketplaceOrderShipping.domain = marketplaceOrder.domain
+      //     newMarketplaceOrderShipping.weightUnit = 'KG'
+
+      //     if (splittedShipmentItems.length == 0) {
+      //       newMarketplaceOrderShipping.totalWeight = primaryUnitValue
+
+      //       newMarketplaceOrderShipping = await tx
+      //         .getRepository(MarketplaceOrderShipping)
+      //         .save(newMarketplaceOrderShipping)
+
+      //       marketplaceOrderItem.marketplaceOrder = marketplaceOrder
+      //       marketplaceOrderItem.marketplaceOrderShipping = newMarketplaceOrderShipping
+
+      //       let splittedShipment: any = {
+      //         shipments: [{ ...marketplaceOrderItem }],
+      //         totalWeight: primaryUnitValue
+      //       }
+      //       splittedShipmentItems.push(splittedShipment)
+      //     } else {
+      //       let lastShipment: any = splittedShipmentItems[splittedShipmentItems.length - 1]
+      //       let lastTotalWeight: number = parseFloat(lastShipment.totalWeight.toFixed(2))
+      //       if (lastTotalWeight + primaryUnitValue < parseFloat(maxWeightSetting.value)) {
+      //         splittedShipmentItems.map((shipmentItem, idx) => {
+      //           if (idx === splittedShipmentItems.length - 1) {
+      //             let shipments: any[] = shipmentItem.shipments
+
+      //             shipments = shipments.map(async shipment => {
+      //               if (shipment.marketplaceProductVariation.id === marketplaceProductVariation.id) {
+      //                 shipment.qty += marketplaceOrderItem.qty
+      //               } else {
+      //                 marketplaceOrderItem.marketplaceOrder = marketplaceOrder
+      //                 marketplaceOrderItem.marketplaceOrderShipping = shipment.marketplaceOrderShipping
+      //                 shipmentItem.shipments.push({ ...marketplaceOrderItem })
+      //               }
+
+      //               shipment.marketplaceOrderShipping.totalWeight = parseFloat(
+      //                 (lastTotalWeight + primaryUnitValue).toFixed(2)
+      //               )
+      //               await tx.getRepository(MarketplaceOrderShipping).save(shipment.marketplaceOrderShipping)
+      //             })
+
+      //             shipmentItem.totalWeight += primaryUnitValue
+      //           }
+      //         })
+      //       } else {
+      //         newMarketplaceOrderShipping.totalWeight = primaryUnitValue
+
+      //         newMarketplaceOrderShipping = await tx
+      //           .getRepository(MarketplaceOrderShipping)
+      //           .save(newMarketplaceOrderShipping)
+
+      //         marketplaceOrderItem.marketplaceOrder = marketplaceOrder
+      //         marketplaceOrderItem.marketplaceOrderShipping = newMarketplaceOrderShipping
+
+      //         let splittedShipment: any = {
+      //           shipments: [{ ...marketplaceOrderItem }],
+      //           totalWeight: primaryUnitValue
+      //         }
+      //         splittedShipmentItems.push(splittedShipment)
+      //       }
+      //     }
+      //   }
+
+      //   let savedMarketplaceOrderItems: MarketplaceOrderItem[] = []
+      //   for (let a: number = 0; a < splittedShipmentItems.length; a++) {
+      //     const shipments: any[] = splittedShipmentItems[a].shipments
+      //     for (let b: number = 0; b < shipments.length; b++) {
+      //       savedMarketplaceOrderItems.push(shipments[b])
+      //     }
+      //   }
+
+      //   savedMarketplaceOrderItems = await tx.getRepository(MarketplaceOrderItem).save(savedMarketplaceOrderItems)
+
+      //   await tx.getRepository(MarketplaceOrderItem).delete(originalMarketplaceOrderItems.map(item => item.id))
+
+      //   await tx.getRepository(MarketplaceOrderShipping).delete(originalMarketplaceOrderShipping.id)
+      // }
+
+      let marketplaceOrderShippings: MarketplaceOrderShipping[] = await tx
+        .getRepository(MarketplaceOrderShipping)
+        .find({ where: { domain, orderNoRef: marketplaceOrder.orderNo } })
+
+      marketplaceOrderShippings = marketplaceOrderShippings.map((marketplaceOrderShipping, idx) => {
+        return {
+          ...marketplaceOrderShipping,
+          subOrderNoRef:
+            marketplaceOrderShipping.orderNoRef + ' - ' + (idx + 1) + '/' + marketplaceOrderShippings.length
+        }
+      })
 
-        await tx.getRepository(MarketplaceOrderItem).delete(originalMarketplaceOrderItems.map(item => item.id))
+      await tx.getRepository(MarketplaceOrderShipping).save(marketplaceOrderShippings)
 
-        await tx.getRepository(MarketplaceOrderShipping).delete(originalMarketplaceOrderShipping.id)
-      }
+      let newMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { id: patch.id }
+      })
+      newMarketplaceOrder.isSplitted = true
+      await tx.getRepository(MarketplaceOrder).save(newMarketplaceOrder)
     }
 
     return true