@things-factory/marketplace-base 3.8.10 → 3.8.19

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

@@ -124,26 +124,53 @@ export const syncMarketplaceOrder = {
             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 customerBizplaceId: string = customerBizplaces.find(
+              customerBizplace => customerBizplace.company.domain.id == domain.id
+            ).id
 
             let { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
               customerBizplaceId,
               refNo: marketplaceOrder.orderNo
             })
 
-            let releaseOrder = Object.assign({}, releaseOrders[0])
-            let patch = {
-              id: releaseOrder.id,
-              marketplaceOrderStatus: marketplaceOrder.status,
-              trackingNo: marketplaceOrder.trackingNo,
-              transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
-            }
+            if (existingMarketplaceOrder.isSplitted) {
+              for (let a = 0; a < releaseOrders.length; a++) {
+                const releaseOrder: any = releaseOrders[a]
+                const foundMarketplaceOrderShipping: MarketplaceOrderShipping = await tx
+                  .getRepository(MarketplaceOrderShipping)
+                  .findOne({
+                    where: { domain: marketplaceStore.domain, subOrderNoRef: releaseOrder.refNo2 }
+                  })
+                let patch = {
+                  id: releaseOrder.id,
+                  marketplaceOrderStatus: marketplaceOrder.status,
+                  trackingNo: foundMarketplaceOrderShipping?.trackingNo
+                    ? foundMarketplaceOrderShipping.trackingNo
+                    : foundMarketplaceOrderShipping.ownTrackingNo,
+                  transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
+                }
 
-            await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
-              customerBizplaceId,
-              releaseOrder: { ...patch },
-              shippingOrder: null
-            })
+                await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
+                  customerBizplaceId,
+                  releaseOrder: { ...patch },
+                  shippingOrder: null
+                })
+              }
+            } else {
+              let releaseOrder = Object.assign({}, releaseOrders[0])
+              let patch = {
+                id: releaseOrder.id,
+                marketplaceOrderStatus: marketplaceOrder.status,
+                trackingNo: marketplaceOrder.trackingNo,
+                transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
+              }
+
+              await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
+                customerBizplaceId,
+                releaseOrder: { ...patch },
+                shippingOrder: null
+              })
+            }
 
             if (cancelStatuses.includes(marketplaceOrder.status)) {
               if (existingMarketplaceOrder.isSplitted) {
@@ -152,7 +179,7 @@ export const syncMarketplaceOrder = {
                 })
 
                 if (releaseOrders?.length) {
-                  for (var a = 0; a < releaseOrders.length; a++) {
+                  for (let a = 0; a < releaseOrders.length; a++) {
                     const releaseOrderId: string = releaseOrders[a].id
                     await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
                   }
@@ -285,9 +312,10 @@ export const syncMarketplaceOrder = {
         let foundVariation
         for (var j = 0; j < order.orderItems.length; j++) {
           var item = order.orderItems[j]
-          foundVariation = await tx
-            .getRepository(MarketplaceProductVariation)
-            .findOne({ where: { domain: marketplaceStore.domain, variationId: item.variationId } })
+          foundVariation = await tx.getRepository(MarketplaceProductVariation).findOne({
+            where: { domain: marketplaceStore.domain, variationId: item.variationId },
+            relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
+          })
 
           if (!foundVariation) {
             let newVariation: any = {
@@ -373,43 +401,161 @@ export const syncMarketplaceOrder = {
                   nonMatchedOrderItems.push({ ...item })
                 }
               })
-              if (nonMatchedOrderItems.length > 0 && !cancelStatuses.includes(marketplaceOrder.status))
+              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)
+                      })
+                    }
+
+                    foundVariation.qty += item.qty
+                    foundVariation = await tx.getRepository(MarketplaceProductVariation).save(foundVariation)
+                  })
+                )
+
                 await tx.getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
+              }
 
-              existingOrderItems = marketplaceOrderItems.map(item => {
-                const matchedOrderItem = existingOrderItems.find(
-                  itm =>
-                    itm.name == item.name &&
-                    itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
-                )
-                if (matchedOrderItem) {
-                  return {
-                    ...matchedOrderItem,
-                    ...item,
-                    updater: user
+              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 {
-              existingOrderItems = marketplaceOrderItems.map(item => {
-                const matchedOrderItem = existingOrderItems.find(
-                  itm =>
-                    itm.name == item.name &&
-                    itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
-                )
-                if (matchedOrderItem) {
-                  return {
-                    ...matchedOrderItem,
-                    ...item,
-                    updater: user
-                  }
-                } else {
-                  return {
-                    ...item,
-                    updater: user
+              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)
+                      })
+                    }
+
+                    foundVariation.qty -= item.qty
+                    foundVariation = await tx.getRepository(MarketplaceProductVariation).save(foundVariation)
+
+                    return {
+                      ...item,
+                      updater: user
+                    }
                   }
-                }
-              })
+                })
+              )
             }
 
             marketplaceOrderItems = existingOrderItems
@@ -422,6 +568,30 @@ 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']
+              })
+
+            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)
+            })
+          }
+
+          foundVariation.qty -= item.qty
+          foundVariation = await tx.getRepository(MarketplaceProductVariation).save(foundVariation)
+
           if (order?.orderShipping) {
             savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
             savedMarketplaceOrderShipping = await tx

package/server/graphql/types/marketplace-product-variation/marketplace-product-variation-patch.ts

@@ -14,6 +14,7 @@ export const MarketplaceProductVariationPatch = gql`
     type: String
     description: String
     qty: Float
+    reserveQty: Float
     bufferQty: Float
     thresholdQty: Float
     costPrice: Float

package/server/graphql/types/marketplace-product-variation/marketplace-product-variation.ts

@@ -11,6 +11,7 @@ export const MarketplaceProductVariation = gql`
     variationSku: String
     channelSku: String
     qty: Float
+    reserveQty: Float
     bufferQty: Float
     thresholdQty: Float
     name: String

package/server/graphql/types/marketplace-product-variation/new-marketplace-product-variation.ts

@@ -10,6 +10,7 @@ export const NewMarketplaceProductVariation = gql`
     variationSku: String
     channelSku: String
     qty: Float
+    reserveQty: Float
     bufferQty: Float
     thresholdQty: Float
     costPrice: Float