@things-factory/marketplace-base 4.0.39 → 4.0.43

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

@@ -4,6 +4,7 @@ import { User } from '@things-factory/auth-base'
 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 { Product, ProductBundle, ProductBundleSetting } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 
 import {
@@ -119,6 +120,34 @@ export const syncMarketplaceOrder = {
             updater: user
           }
 
+          if (
+            !marketplaceOrder?.releaseOrderId &&
+            cancelStatuses.includes(marketplaceOrder.status) &&
+            !cancelStatuses.includes(existingMarketplaceOrder.status)
+          ) {
+            for (let item of marketplaceOrder.marketplaceOrderItems) {
+              let foundVariations = await tx.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(tx, variation, marketplaceOrder.domain, item.qty, '-')
+
+                  variation.reserveQty -= item.qty
+                  variation.qty += item.qty
+                  await tx.getRepository(MarketplaceProductVariation).save(variation)
+                })
+              )
+            }
+          }
+
           if (marketplaceOrder?.releaseOrderId) {
             const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
             const centerId: string = fulfillmentCenter.centerId
@@ -316,14 +345,18 @@ export const syncMarketplaceOrder = {
         }
 
         let orderTotalWeight: number = 0
-        let foundVariation
+        let foundVariations = []
         for (var j = 0; j < order.orderItems.length; j++) {
           var item = order.orderItems[j]
-          foundVariation = await tx.getRepository(MarketplaceProductVariation).findOne({
+          let foundVariation = await tx.getRepository(MarketplaceProductVariation).findOne({
             where: { domain: marketplaceStore.domain, variationId: item.variationId },
             relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
           })
 
+          if (foundVariation) {
+            foundVariations.push(foundVariation)
+          }
+
           if (!foundVariation) {
             let newVariation: any = {
               variationId: item.variationId,
@@ -411,158 +444,192 @@ export const syncMarketplaceOrder = {
               if (nonMatchedOrderItems.length > 0 && !cancelStatuses.includes(marketplaceOrder.status)) {
                 await Promise.all(
                   nonMatchedOrderItems.map(async item => {
-                    if (foundVariation.sku) {
-                      let allVariations: MarketplaceProductVariation[] = await tx
-                        .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 tx.getRepository(MarketplaceProductVariation).save(variation)
-                      })
+                    for (var foundVariation of foundVariations) {
+                      if (foundVariation.sku) {
+                        let allVariations: MarketplaceProductVariation[] = await tx
+                          .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(
+                              tx,
+                              variation,
+                              marketplaceOrder.domain,
+                              item.qty,
+                              '-'
+                            )
+
+                            variation.reserveQty -= item.qty
+                            variation.qty += item.qty
+
+                            variation = await tx.getRepository(MarketplaceProductVariation).save(variation)
+                          })
+                        )
+                      }
                     }
-
-                    foundVariation.qty += item.qty
-                    foundVariation = await tx.getRepository(MarketplaceProductVariation).save(foundVariation)
                   })
                 )
 
                 await tx.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 tx
-                        .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 tx.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 tx
+                            .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(
+                                  tx,
+                                  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 tx.getRepository(MarketplaceProductVariation).save(variation)
+                            })
+                          )
+                        }
+                      }
+                      return {
+                        ...matchedOrderItem,
+                        ...item,
+                        updater: user
+                      }
                     }
-
-                    foundVariation.qty = existingMarketplaceOrder?.releaseOrderId
-                      ? foundVariation.qty - matchedOrderItem.qty
-                      : foundVariation.qty + item.qty - matchedOrderItem.qty
-                    foundVariation = await tx.getRepository(MarketplaceProductVariation).save(foundVariation)
-
-                    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 tx
-                        .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 tx.getRepository(MarketplaceProductVariation).save(variation)
-                      })
-                    }
-
-                    foundVariation.qty = existingMarketplaceOrder?.releaseOrderId
-                      ? foundVariation.qty - matchedOrderItem.qty
-                      : foundVariation.qty + item.qty - matchedOrderItem.qty
-                    foundVariation = await tx.getRepository(MarketplaceProductVariation).save(foundVariation)
-
-                    return {
-                      ...matchedOrderItem,
-                      ...item,
-                      updater: user
-                    }
-                  } else {
-                    if (foundVariation.sku) {
-                      let allVariations: MarketplaceProductVariation[] = await tx
-                        .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 tx.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 tx
+                            .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(
+                                  tx,
+                                  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 tx.getRepository(MarketplaceProductVariation).save(variation)
+                            })
+                          )
+                        }
+                      }
+                      return {
+                        ...matchedOrderItem,
+                        ...item,
+                        updater: user
+                      }
+                    } else {
+                      for (var foundVariation of foundVariations) {
+                        if (foundVariation.sku) {
+                          let allVariations: MarketplaceProductVariation[] = await tx
+                            .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(tx, variation, marketplaceOrder.domain, item.qty)
+
+                              variation.reserveQty += item.qty
+
+                              if (variation.qty - item.qty >= 0) {
+                                variation.qty -= item.qty
+                              }
+
+                              variation = await tx.getRepository(MarketplaceProductVariation).save(variation)
+                            })
+                          )
+                        }
+                      }
+                      return {
+                        ...item,
+                        updater: user
+                      }
                     }
-
-                    foundVariation.qty -= item.qty
-                    foundVariation = await tx.getRepository(MarketplaceProductVariation).save(foundVariation)
-
-                    return {
-                      ...item,
-                      updater: user
-                    }
-                  }
-                })
-              )
+                  })
+                )
+              }
             }
 
             marketplaceOrderItems = existingOrderItems
@@ -575,35 +642,42 @@ export const syncMarketplaceOrder = {
             }
           }
         } else {
-          if (foundVariation.sku) {
-            let allVariations: MarketplaceProductVariation[] = await tx
-              .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 tx
+                  .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 activeVariations: MarketplaceProductVariation[] = allVariations.filter(
+                  variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
+                )
+                let item = order.orderItems.find(e => e.variationId == foundVariation.variationId)
+                await Promise.all(
+                  activeVariations.map(async variation => {
+                    await this.calculateReserveQtyForBundle(tx, variation, marketplaceOrder.domain, item.qty)
 
-            variationsFromOtherStores.map(async variation => {
-              variation.reserveQty += item.qty
+                    variation.reserveQty += item.qty
 
-              variation = await tx.getRepository(MarketplaceProductVariation).save(variation)
-            })
-          }
+                    if (variation.qty - item.qty >= 0) {
+                      variation.qty -= item.qty
+                    }
 
-          foundVariation.qty -= item.qty
-          foundVariation = await tx.getRepository(MarketplaceProductVariation).save(foundVariation)
+                    variation = await tx.getRepository(MarketplaceProductVariation).save(variation)
+                  })
+                )
+              }
 
-          if (order?.orderShipping) {
-            savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
-            savedMarketplaceOrderShipping = await tx
-              .getRepository(MarketplaceOrderShipping)
-              .save(savedMarketplaceOrderShipping)
+              if (order?.orderShipping) {
+                savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
+                savedMarketplaceOrderShipping = await tx
+                  .getRepository(MarketplaceOrderShipping)
+                  .save(savedMarketplaceOrderShipping)
+              }
+            }
           }
         }
 
@@ -618,6 +692,75 @@ export const syncMarketplaceOrder = {
       hasMorePage = more
     }
 
+    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 tx.getRepository(MarketplaceOrder).update(
+            {
+              orderNo: item.orderNo
+            },
+            {
+              payoutDate: item.payoutDate
+            }
+          )
+        })
+      )
+    }
     return true
   }
 }
+
+export async function calculateReserveQtyForBundle(tx, variation, domain, qty, operator = '+') {
+  const productBundle: ProductBundle = await tx.getRepository(ProductBundle).findOne({
+    where: { sku: variation.sku, domain }
+  })
+
+  if (productBundle) {
+    const productBundleSettings: ProductBundleSetting[] = await tx.getRepository(ProductBundleSetting).find({
+      where: { productBundle },
+      relations: ['productBundle', 'product']
+    })
+
+    for (let setting of productBundleSettings) {
+      const product: Product = await tx.getRepository(Product).findOne({
+        where: { id: setting.product.id }
+      })
+
+      const mpvs: MarketplaceProductVariation[] = await tx.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 tx.getRepository(MarketplaceProductVariation).save(mpv)
+      }
+    }
+  }
+}

package/server/graphql/resolvers/marketplace-report/marketplace-sales-report.ts

@@ -74,6 +74,7 @@ export const marketplaceSalesReportsResolver = {
         orderNo: item.mo_name,
         orderCreatedAt: item.mo_order_created_at,
         buyerUsername: item.mo_buyer_username,
+        payoutDate: item.mo_payout_date,
         payTime: item.mo_pay_time,
         totalAmount: item.mo_total_amount,
         refundAmount: item.mro_amount,
@@ -117,11 +118,22 @@ export const marketplaceSalesReportsResolver = {
         shippingFeeDiscountSeller: item.moi_shipping_fee_discount_seller,
         promotionalChargesFlexiCombo: item.moi_promotional_charges_flexi_combo,
         autoShippingSubsidyMarketplace: item.moi_auto_shipping_subsidy_marketplace,
-        grandTotal: item.moi_orders_marketplace_fees_total + item.moi_orders_marketing_fees_total + item.moi_orders_sales_total + item.moi_orders_logistics_total,
+        grandTotal:
+          item.moi_orders_marketplace_fees_total +
+          item.moi_orders_marketing_fees_total +
+          item.moi_orders_sales_total +
+          item.moi_orders_logistics_total,
         originalShippingFee: item.moi_original_shipping_fee,
         taxAmount: item.moi_tax_amount,
         itemCommissionFee: item.moi_commission_fee,
-        variationSku: item.mpv_variation_sku
+        variationSku: item.mpv_variation_sku,
+        address1: item.mos_address_1,
+        address2: item.mos_address_2,
+        address3: item.mos_address_3,
+        city: item.mos_city,
+        state: item.mos_state,
+        postcode: item.mos_post_code,
+        trackingNo: item.moi_tracking_code
       }
     })
 

package/server/graphql/types/marketplace-order-shipping/marketplace-order-shipping-patch.ts

@@ -40,6 +40,7 @@ export const MarketplaceOrderShippingPatch = gql`
     parcelType: Int
     goodsType: Int
     deliveryMethod: Int
+    releaseOrderId: String
     cuFlag: String
   }
 `

package/server/graphql/types/marketplace-order-shipping/marketplace-order-shipping.ts

@@ -48,6 +48,8 @@ export const MarketplaceOrderShipping = gql`
     actualShippingFee: Float
     marketplaceShippingFeeVoucher: Float
     sellerShippingFeeVoucher: Float
+    releaseOrderId: String
+    fulfillmentCenter: FulfillmentCenter
     updater: User
     creator: User
     updatedAt: String

package/server/graphql/types/marketplace-order-shipping/new-marketplace-order-shipping.ts

@@ -35,6 +35,7 @@ export const NewMarketplaceOrderShipping = gql`
     collectionType: String
     collectionCurrency: String
     collectionAmount: Float
+    releaseOrderId: String
     orderType: String
     freightType: Int
     parcelType: Int

package/server/graphql/types/marketplace-report/marketplace-sales-report.ts

@@ -7,7 +7,7 @@ export const MarketplaceSalesReport = gql`
     shippingRebate: Float
     commissionFee: Float
     serviceFee: Float
-    transactionFee: String
+    transactionFee: Float
     totalRealeasedAmount: Float
     voucherCode: String
     shippingMode: String
@@ -15,6 +15,7 @@ export const MarketplaceSalesReport = gql`
     orderNo: String
     orderCreatedAt: String
     buyerUsername: String
+    payoutDate: String
     payTime: String
     totalAmount: Float
     refundAmount: Float
@@ -55,5 +56,12 @@ export const MarketplaceSalesReport = gql`
     fulfillmentCenter: String
     variationSku: String
     itemCommissionFee: Float
+    address1: String
+    address2: String
+    address3: String
+    city: String
+    state: String
+    postcode: String
+    trackingNo: String
   }
 `