@things-factory/marketplace-base 3.8.27 → 3.8.31

package/dist-server/graphql/types/marketplace-report/marketplace-sales-report.js

@@ -12,7 +12,7 @@ exports.MarketplaceSalesReport = (0, graphql_tag_1.default) `
     shippingRebate: Float
     commissionFee: Float
     serviceFee: Float
-    transactionFee: String
+    transactionFee: Float
     totalRealeasedAmount: Float
     voucherCode: String
     shippingMode: String
@@ -20,6 +20,7 @@ exports.MarketplaceSalesReport = (0, graphql_tag_1.default) `
     orderNo: String
     orderCreatedAt: String
     buyerUsername: String
+    payoutDate: String
     payTime: String
     totalAmount: Float
     refundAmount: Float
@@ -60,6 +61,13 @@ exports.MarketplaceSalesReport = (0, graphql_tag_1.default) `
     fulfillmentCenter: String
     variationSku: String
     itemCommissionFee: Float
+    address1: String
+    address2: String
+    address3: String
+    city: String
+    state: String
+    postcode: String
+    trackingNo: String
   }
 `;
 //# sourceMappingURL=marketplace-sales-report.js.map

package/dist-server/graphql/types/marketplace-report/marketplace-sales-report.js.map

@@ -1 +1 @@
-{"version":3,"file":"marketplace-sales-report.js","sourceRoot":"","sources":["../../../../server/graphql/types/marketplace-report/marketplace-sales-report.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA6B;AAEhB,QAAA,sBAAsB,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDxC,CAAA"}
+{"version":3,"file":"marketplace-sales-report.js","sourceRoot":"","sources":["../../../../server/graphql/types/marketplace-report/marketplace-sales-report.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA6B;AAEhB,QAAA,sBAAsB,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgExC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/marketplace-base",
-  "version": "3.8.27",
+  "version": "3.8.31",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,9 +24,10 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/integration-fulfillment": "^3.8.26",
-    "@things-factory/integration-marketplace": "^3.8.27",
+    "@things-factory/integration-fulfillment": "^3.8.29",
+    "@things-factory/integration-marketplace": "^3.8.29",
+    "@things-factory/product-base": "^3.8.31",
     "@things-factory/shell": "^3.8.0"
   },
-  "gitHead": "6e1de7441570bf9d6f42324f7d1c96e42881b46e"
+  "gitHead": "5deb948aa45a0aea4d787b5380667dc0c9d1f889"
 }

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

@@ -10,6 +10,7 @@ import {
 } from 'typeorm'
 
 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'
 
@@ -154,6 +155,12 @@ export class MarketplaceOrderShipping {
   @Column({ type: 'float', nullable: true })
   sellerShippingFeeVoucher: number
 
+  @Column({ nullable: true })
+  releaseOrderId: string
+
+  @ManyToOne(type => FulfillmentCenter, { nullable: true })
+  fulfillmentCenter: FulfillmentCenter
+
   @CreateDateColumn()
   createdAt: Date
 

package/server/entities/marketplace-order.ts

@@ -131,6 +131,9 @@ export class MarketplaceOrder {
   @Column({ nullable: true })
   shippingMode: String 
 
+  @Column({ nullable: true })
+  payoutDate: Date
+
   @CreateDateColumn()
   createdAt: Date
 

package/server/graphql/resolvers/marketplace-order/sync-all-marketplace-order.ts

@@ -5,6 +5,7 @@ import { Bizplace, getCustomerBizplaces } from '@things-factory/biz-base'
 import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
 import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
 import { Domain } from '@things-factory/shell'
+import { Product, ProductBundle, ProductBundleSetting } from '@things-factory/product-base'
 
 import {
   MarketplaceOrder,
@@ -134,6 +135,36 @@ export const syncAllMarketplaceOrder = {
                   updater: user
                 }
 
+                if (
+                  !marketplaceOrder?.releaseOrderId &&
+                  cancelStatuses.includes(marketplaceOrder.status) &&
+                  !cancelStatuses.includes(existingMarketplaceOrder.status)
+                ) {
+                  for (let item of marketplaceOrder.marketplaceOrderItems) {
+                    let foundVariations = await getRepository(MarketplaceProductVariation).find({
+                      where: {
+                        domain: marketplaceOrder.domain,
+                        sku: item.marketplaceProductVariation.sku
+                      },
+                      relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
+                    })
+
+                    let activeVariations: MarketplaceProductVariation[] = foundVariations.filter(
+                      variation =>
+                        variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED' && variation.sku != null
+                    )
+
+                    await Promise.all(
+                      activeVariations.map(async variation => {
+                        await this.calculateReserveQtyForBundle(variation, marketplaceOrder.domain, item.qty, '-')
+
+                        variation.reserveQty -= item.qty
+                        variation.qty += item.qty
+                        await getRepository(MarketplaceProductVariation).save(variation)
+                      })
+                    )
+                  }
+                }
                 if (marketplaceOrder?.releaseOrderId) {
                   const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
                   const centerId: string = fulfillmentCenter.centerId
@@ -330,13 +361,17 @@ export const syncAllMarketplaceOrder = {
               }
 
               let orderTotalWeight: number = 0
-              let foundVariation
+              let foundVariations = []
               for (var j = 0; j < order.orderItems.length; j++) {
                 var item = order.orderItems[j]
-                foundVariation = await getRepository(MarketplaceProductVariation).findOne({
+                let foundVariation = await getRepository(MarketplaceProductVariation).findOne({
                   where: { domain: marketplaceStore.domain, variationId: item.variationId }
                 })
 
+                if (foundVariation) {
+                  foundVariations.push(foundVariation)
+                }
+
                 if (!foundVariation) {
                   let newVariation: any = {
                     variationId: item.variationId,
@@ -424,158 +459,199 @@ export const syncAllMarketplaceOrder = {
                     if (nonMatchedOrderItems.length > 0 && !cancelStatuses.includes(marketplaceOrder.status)) {
                       await Promise.all(
                         nonMatchedOrderItems.map(async item => {
-                          if (foundVariation.sku) {
-                            let allVariations: MarketplaceProductVariation[] = await getRepository(
-                              MarketplaceProductVariation
-                            ).find({
-                              where: { domain: foundVariation.domain, sku: foundVariation.sku },
-                              relations: [
-                                'domain',
-                                'marketplaceProduct',
-                                'marketplaceProduct.marketplaceStore',
-                                'marketplaceProduct.marketplaceStore.marketplaceDistributors'
-                              ]
-                            })
-
-                            let variationsFromOtherStores: MarketplaceProductVariation[] = allVariations.filter(
-                              variation =>
-                                variation.id != foundVariation.id &&
-                                variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
-                            )
-
-                            variationsFromOtherStores.map(async variation => {
-                              variation.reserveQty -= item.qty
-
-                              variation = await getRepository(MarketplaceProductVariation).save(variation)
-                            })
+                          for (var foundVariation of foundVariations) {
+                            if (foundVariation.sku) {
+                              let allVariations: MarketplaceProductVariation[] = await getRepository(
+                                MarketplaceProductVariation
+                              ).find({
+                                where: { domain: foundVariation.domain, sku: foundVariation.sku },
+                                relations: [
+                                  'domain',
+                                  'marketplaceProduct',
+                                  'marketplaceProduct.marketplaceStore',
+                                  'marketplaceProduct.marketplaceStore.marketplaceDistributors'
+                                ]
+                              })
+
+                              let activeVariations: MarketplaceProductVariation[] = allVariations.filter(
+                                variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
+                              )
+
+                              await Promise.all(
+                                activeVariations.map(async variation => {
+                                  await this.calculateReserveQtyForBundle(
+                                    variation,
+                                    marketplaceOrder.domain,
+                                    item.qty,
+                                    '-'
+                                  )
+
+                                  variation.reserveQty -= item.qty
+                                  variation.qty += item.qty
+
+                                  variation = await getRepository(MarketplaceProductVariation).save(variation)
+                                })
+                              )
+                            }
                           }
-
-                          foundVariation.qty += item.qty
-                          foundVariation = await getRepository(MarketplaceProductVariation).save(foundVariation)
                         })
                       )
 
                       await getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
                     }
 
-                    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) {
-                          if (foundVariation.sku) {
-                            let allVariations: MarketplaceProductVariation[] = await getRepository(
-                              MarketplaceProductVariation
-                            ).find({
-                              where: { domain: foundVariation.domain, sku: foundVariation.sku },
-                              relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-                            })
-
-                            let variationsFromOtherStores: MarketplaceProductVariation[] = allVariations.filter(
-                              variation =>
-                                variation.id != foundVariation.id &&
-                                variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
-                            )
-
-                            variationsFromOtherStores.map(async variation => {
-                              variation.reserveQty = existingMarketplaceOrder?.releaseOrderId
-                                ? variation.reserveQty + matchedOrderItem.qty
-                                : variation.reserveQty - item.qty + matchedOrderItem.qty
-
-                              variation = await getRepository(MarketplaceProductVariation).save(variation)
-                            })
-                          }
-
-                          foundVariation.qty = existingMarketplaceOrder?.releaseOrderId
-                            ? foundVariation.qty - matchedOrderItem.qty
-                            : foundVariation.qty + item.qty - matchedOrderItem.qty
-                          foundVariation = await getRepository(MarketplaceProductVariation).save(foundVariation)
-
-                          return {
-                            ...matchedOrderItem,
-                            ...item,
-                            updater: user
+                    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) {
+                            for (var foundVariation of foundVariations) {
+                              if (foundVariation.sku) {
+                                let allVariations: MarketplaceProductVariation[] = await getRepository(
+                                  MarketplaceProductVariation
+                                ).find({
+                                  where: { domain: foundVariation.domain, sku: foundVariation.sku },
+                                  relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
+                                })
+
+                                let activeVariations: MarketplaceProductVariation[] = allVariations.filter(
+                                  variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
+                                )
+
+                                await Promise.all(
+                                  activeVariations.map(async variation => {
+                                    if (
+                                      !existingMarketplaceOrder?.releaseOrderId &&
+                                      matchedOrderItem.qty - item.qty != 0
+                                    ) {
+                                      await this.calculateReserveQtyForBundle(
+                                        variation,
+                                        marketplaceOrder.domain,
+                                        matchedOrderItem.qty - item.qty
+                                      )
+                                    }
+
+                                    variation.reserveQty = existingMarketplaceOrder?.releaseOrderId
+                                      ? variation.reserveQty
+                                      : variation.reserveQty - item.qty + matchedOrderItem.qty
+
+                                    variation.qty = existingMarketplaceOrder?.releaseOrderId
+                                      ? variation.qty
+                                      : variation.qty + item.qty - matchedOrderItem.qty
+
+                                    variation = await getRepository(MarketplaceProductVariation).save(variation)
+                                  })
+                                )
+                              }
+                            }
+                            return {
+                              ...matchedOrderItem,
+                              ...item,
+                              updater: user
+                            }
                           }
-                        }
-                      })
-                    )
+                        })
+                      )
+                    }
                   } else {
-                    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) {
-                          if (foundVariation.sku) {
-                            let allVariations: MarketplaceProductVariation[] = await getRepository(
-                              MarketplaceProductVariation
-                            ).find({
-                              where: { domain: foundVariation.domain, sku: foundVariation.sku },
-                              relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-                            })
-
-                            let variationsFromOtherStores: MarketplaceProductVariation[] = allVariations.filter(
-                              variation =>
-                                variation.id != foundVariation.id &&
-                                variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
-                            )
-
-                            variationsFromOtherStores.map(async variation => {
-                              variation.reserveQty = existingMarketplaceOrder?.releaseOrderId
-                                ? variation.reserveQty + matchedOrderItem.qty
-                                : variation.reserveQty - item.qty + matchedOrderItem.qty
-
-                              variation = await getRepository(MarketplaceProductVariation).save(variation)
-                            })
-                          }
-
-                          foundVariation.qty = existingMarketplaceOrder?.releaseOrderId
-                            ? foundVariation.qty - matchedOrderItem.qty
-                            : foundVariation.qty + item.qty - matchedOrderItem.qty
-                          foundVariation = await getRepository(MarketplaceProductVariation).save(foundVariation)
-
-                          return {
-                            ...matchedOrderItem,
-                            ...item,
-                            updater: user
-                          }
-                        } else {
-                          if (foundVariation.sku) {
-                            let allVariations: MarketplaceProductVariation[] = await getRepository(
-                              MarketplaceProductVariation
-                            ).find({
-                              where: { domain: foundVariation.domain, sku: foundVariation.sku },
-                              relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-                            })
-
-                            let variationsFromOtherStores: MarketplaceProductVariation[] = allVariations.filter(
-                              variation =>
-                                variation.id != foundVariation.id &&
-                                variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
-                            )
-
-                            variationsFromOtherStores.map(async variation => {
-                              variation.reserveQty += item.qty
-
-                              variation = await getRepository(MarketplaceProductVariation).save(variation)
-                            })
+                    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) {
+                            for (var foundVariation of foundVariations) {
+                              if (foundVariation.sku) {
+                                let allVariations: MarketplaceProductVariation[] = await getRepository(
+                                  MarketplaceProductVariation
+                                ).find({
+                                  where: { domain: foundVariation.domain, sku: foundVariation.sku },
+                                  relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
+                                })
+
+                                let activeVariations: MarketplaceProductVariation[] = allVariations.filter(
+                                  variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
+                                )
+
+                                await Promise.all(
+                                  activeVariations.map(async variation => {
+                                    if (
+                                      !existingMarketplaceOrder?.releaseOrderId &&
+                                      matchedOrderItem.qty - item.qty != 0
+                                    ) {
+                                      await this.calculateReserveQtyForBundle(
+                                        variation,
+                                        marketplaceOrder.domain,
+                                        matchedOrderItem.qty - item.qty
+                                      )
+                                    }
+
+                                    variation.reserveQty = existingMarketplaceOrder?.releaseOrderId
+                                      ? variation.reserveQty
+                                      : variation.reserveQty - item.qty + matchedOrderItem.qty
+
+                                    variation.qty = existingMarketplaceOrder?.releaseOrderId
+                                      ? variation.qty
+                                      : variation.qty + item.qty - matchedOrderItem.qty
+
+                                    variation = await getRepository(MarketplaceProductVariation).save(variation)
+                                  })
+                                )
+                              }
+                            }
+                            return {
+                              ...matchedOrderItem,
+                              ...item,
+                              updater: user
+                            }
+                          } else {
+                            for (var foundVariation of foundVariations) {
+                              if (foundVariation.sku) {
+                                let allVariations: MarketplaceProductVariation[] = await getRepository(
+                                  MarketplaceProductVariation
+                                ).find({
+                                  where: { domain: foundVariation.domain, sku: foundVariation.sku },
+                                  relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
+                                })
+
+                                let activeVariations: MarketplaceProductVariation[] = allVariations.filter(
+                                  variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
+                                )
+
+                                await Promise.all(
+                                  activeVariations.map(async variation => {
+                                    await this.calculateReserveQtyForBundle(
+                                      variation,
+                                      marketplaceOrder.domain,
+                                      item.qty
+                                    )
+
+                                    variation.reserveQty += item.qty
+                                    if (variation.qty - item.qty >= 0) {
+                                      variation.qty -= item.qty
+                                    }
+                                    variation = await getRepository(MarketplaceProductVariation).save(variation)
+                                  })
+                                )
+                              }
+                            }
+                            return {
+                              ...item,
+                              updater: user
+                            }
                           }
-
-                          foundVariation.qty -= item.qty
-                          foundVariation = await getRepository(MarketplaceProductVariation).save(foundVariation)
-
-                          return {
-                            ...item,
-                            updater: user
-                          }
-                        }
-                      })
-                    )
+                        })
+                      )
+                    }
                   }
 
                   marketplaceOrderItems = existingOrderItems
@@ -588,35 +664,43 @@ export const syncAllMarketplaceOrder = {
                   }
                 }
               } else {
-                if (foundVariation.sku) {
-                  let allVariations: MarketplaceProductVariation[] = await getRepository(
-                    MarketplaceProductVariation
-                  ).find({
-                    where: { domain: foundVariation.domain, sku: foundVariation.sku },
-                    relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-                  })
+                if (!cancelStatuses.includes(marketplaceOrder.status)) {
+                  for (var foundVariation of foundVariations) {
+                    if (foundVariation.sku) {
+                      let allVariations: MarketplaceProductVariation[] = await getRepository(
+                        MarketplaceProductVariation
+                      ).find({
+                        where: { domain: foundVariation.domain, sku: foundVariation.sku },
+                        relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
+                      })
 
-                  let variationsFromOtherStores: MarketplaceProductVariation[] = allVariations.filter(
-                    variation =>
-                      variation.id != foundVariation.id &&
-                      variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
-                  )
+                      let item = order.orderItems.find(e => e.variationId == foundVariation.variationId)
+                      let activeVariations: MarketplaceProductVariation[] = allVariations.filter(
+                        variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
+                      )
 
-                  variationsFromOtherStores.map(async variation => {
-                    variation.reserveQty += item.qty
+                      await Promise.all(
+                        activeVariations.map(async variation => {
+                          await this.calculateReserveQtyForBundle(variation, marketplaceOrder.domain, item.qty)
+                          variation.reserveQty += item.qty
+                          if (variation.qty - item.qty >= 0) {
+                            variation.qty -= item.qty
+                          }
 
-                    variation = await getRepository(MarketplaceProductVariation).save(variation)
-                  })
-                }
+                          variation = await getRepository(MarketplaceProductVariation).save(variation)
+                        })
+                      )
+                    }
 
-                foundVariation.qty -= item.qty
-                foundVariation = await getRepository(MarketplaceProductVariation).save(foundVariation)
+                    foundVariation = await getRepository(MarketplaceProductVariation).save(foundVariation)
 
-                if (order?.orderShipping) {
-                  savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
-                  savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
-                    savedMarketplaceOrderShipping
-                  )
+                    if (order?.orderShipping) {
+                      savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
+                      savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
+                        savedMarketplaceOrderShipping
+                      )
+                    }
+                  }
                 }
               }
 
@@ -634,8 +718,77 @@ export const syncAllMarketplaceOrder = {
           hasMorePage = false
         }
       }
+
+      if (marketplaceStore.platform === 'shopee') {
+        let pageNo: number = 0
+        let hasMore = true
+        let perPage: number = 100
+        var payoutDateList = []
+
+        while (hasMore) {
+          const { result: payoutDates, more } = await StoreAPI.getStoreOrderPayoutDates(marketplaceStore, {
+            fromDate,
+            toDate,
+            pagination: { page: pageNo, limit: perPage }
+          })
+
+          payoutDateList.push(...payoutDates)
+          if (more) pageNo++
+          hasMore = more
+        }
+
+        await Promise.all(
+          payoutDateList.map(async item => {
+            await getRepository(MarketplaceOrder).update(
+              {
+                orderNo: item.orderNo
+              },
+              {
+                payoutDate: item.payoutDate
+              }
+            )
+          })
+        )
+      }
     }
 
     return true
+  },
+  async calculateReserveQtyForBundle(variation, domain, qty, operator = '+') {
+    const productBundle: ProductBundle = await getRepository(ProductBundle).findOne({
+      where: { sku: variation.sku, domain }
+    })
+
+    if (productBundle) {
+      const productBundleSettings: ProductBundleSetting[] = await getRepository(ProductBundleSetting).find({
+        where: { productBundle },
+        relations: ['productBundle', 'product']
+      })
+
+      for (let setting of productBundleSettings) {
+        const product: Product = await getRepository(Product).findOne({
+          where: { id: setting.product.id }
+        })
+
+        const mpvs: MarketplaceProductVariation[] = await getRepository(MarketplaceProductVariation).find({
+          where: { domain, sku: product.sku },
+          relations: ['domain']
+        })
+
+        for (let mpv of mpvs) {
+          if (operator === '+') {
+            mpv.reserveQty += setting.bundleQty * qty
+            if (mpv.qty - setting.bundleQty * qty >= 0) {
+              mpv.qty -= setting.bundleQty * qty
+            }
+          }
+          if (operator === '-') {
+            mpv.reserveQty -= setting.bundleQty * qty
+            mpv.qty += setting.bundleQty * qty
+          }
+          await getRepository(MarketplaceProductVariation).save(mpv)
+        }
+      }
+    }
   }
 }