@things-factory/marketplace-base 3.6.3 → 3.6.8

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

@@ -113,6 +113,7 @@ export const syncAllMarketplaceOrder = {
             marketplaceOrder = await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)
 
             let savedMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
+            let savedMarketplaceOrderShippings: MarketplaceOrderShipping[] = []
 
             if (order?.orderShipping) {
               const orderShipping: any = order.orderShipping
@@ -132,30 +133,66 @@ export const syncAllMarketplaceOrder = {
               marketplaceOrderShipping.phone2 = orderShipping.phone2
               marketplaceOrderShipping.trackingNo = order.trackingNo
               marketplaceOrderShipping.orderNoRef = marketplaceOrder.orderNo
+              marketplaceOrderShipping.subOrderNoRef = marketplaceOrder.orderNo
               marketplaceOrderShipping.marketplaceStore = marketplaceStore
               marketplaceOrderShipping.creator = user
               marketplaceOrderShipping.domain = marketplaceStore.domain
 
               if (existingMarketplaceOrder) {
-                let existingOrderShipping: MarketplaceOrderShipping
-                existingOrderShipping = existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShipping
+                if (existingMarketplaceOrder.isSplitted) {
+                  let existingOrderShippings: MarketplaceOrderShipping[] = await tx
+                    .getRepository(MarketplaceOrderShipping)
+                    .find({
+                      where: { domain, marketplaceStore, orderNoRef: marketplaceOrder.orderNo }
+                    })
+
+                  existingOrderShippings = existingOrderShippings.map(item => {
+                    return {
+                      ...item,
+                      address1: orderShipping.address1,
+                      address2: orderShipping.address2,
+                      address3: orderShipping.address3,
+                      address4: orderShipping.address4,
+                      address5: orderShipping.address5,
+                      attentionTo: orderShipping.attentionTo,
+                      city: orderShipping.city,
+                      country: orderShipping.country,
+                      postCode: orderShipping.postCode,
+                      phone1: orderShipping.phone1,
+                      phone2: orderShipping.phone2,
+                      trackingNo: order.trackingNo
+                    }
+                  })
+
+                  savedMarketplaceOrderShippings = await tx
+                    .getRepository(MarketplaceOrderShipping)
+                    .save(existingOrderShippings)
+                } else {
+                  let existingOrderShipping: MarketplaceOrderShipping
+                  existingOrderShipping = existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShipping
+
+                  marketplaceOrderShipping = {
+                    ...existingOrderShipping,
+                    ...marketplaceOrderShipping,
+                    updater: user
+                  }
 
-                marketplaceOrderShipping = {
-                  ...existingOrderShipping,
-                  ...marketplaceOrderShipping,
-                  updater: user
+                  savedMarketplaceOrderShipping = await tx
+                    .getRepository(MarketplaceOrderShipping)
+                    .save(marketplaceOrderShipping)
                 }
+              } else {
+                savedMarketplaceOrderShipping = await tx
+                  .getRepository(MarketplaceOrderShipping)
+                  .save(marketplaceOrderShipping)
               }
-
-              savedMarketplaceOrderShipping = await tx
-                .getRepository(MarketplaceOrderShipping)
-                .save(marketplaceOrderShipping)
             }
 
             let orderTotalWeight: number = 0
+            let foundVariation
             for (var j = 0; j < order.orderItems.length; j++) {
               var item = order.orderItems[j]
-              let foundVariation = await tx
+              foundVariation = await tx
                 .getRepository(MarketplaceProductVariation)
                 .findOne({ where: { variationId: item.variationId } })
 
@@ -180,6 +217,7 @@ export const syncAllMarketplaceOrder = {
               marketplaceOrderItem.status = marketplaceOrder.status
               marketplaceOrderItem.marketplaceProductVariation = foundVariation
               marketplaceOrderItem.marketplaceOrder = marketplaceOrder
+              marketplaceOrderItem.trackingCode = order.trackingNo
               marketplaceOrderItem.marketplaceOrderShipping = savedMarketplaceOrderShipping
               marketplaceOrderItem.creator = user
 
@@ -190,58 +228,73 @@ export const syncAllMarketplaceOrder = {
             }
 
             if (existingMarketplaceOrder) {
-              let existingOrderItems: MarketplaceOrderItem[] = []
-              existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
-
-              if (existingOrderItems.length > marketplaceOrderItems.length) {
-                const nonMatchedOrderItems = []
-                existingOrderItems.map(item => {
-                  const matchedOrderItem = marketplaceOrderItems.find(itm => itm.name == item.name)
-                  if (!matchedOrderItem) {
-                    nonMatchedOrderItems.push({ ...item })
-                  }
-                })
-                if (nonMatchedOrderItems.length > 0)
-                  await tx.getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
-
-                existingOrderItems = marketplaceOrderItems.map(item => {
-                  const matchedOrderItem = existingOrderItems.find(itm => itm.name == item.name)
-                  if (matchedOrderItem) {
-                    return {
-                      ...matchedOrderItem,
-                      ...item,
-                      updater: user
-                    }
+              if (existingMarketplaceOrder.isSplitted) {
+                let existingOrderItems: MarketplaceOrderItem[] = []
+                existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
+
+                marketplaceOrderItems = existingOrderItems.filter(itm => itm.name == item.name)
+                marketplaceOrderItems = marketplaceOrderItems.map(marketplaceOrderitem => {
+                  return {
+                    ...marketplaceOrderitem,
+                    status: order.status,
+                    marketplaceProductVariation: foundVariation,
+                    trackingCode: order.trackingNo
                   }
                 })
               } else {
-                existingOrderItems = marketplaceOrderItems.map(item => {
-                  const matchedOrderItem = existingOrderItems.find(itm => itm.name == item.name)
-                  if (matchedOrderItem) {
-                    return {
-                      ...matchedOrderItem,
-                      ...item,
-                      updater: user
+                let existingOrderItems: MarketplaceOrderItem[] = []
+                existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
+
+                if (existingOrderItems.length > marketplaceOrderItems.length) {
+                  let nonMatchedOrderItems = []
+                  existingOrderItems.map(item => {
+                    const matchedOrderItem = marketplaceOrderItems.find(itm => itm.name === item.name)
+                    if (!matchedOrderItem) {
+                      nonMatchedOrderItems.push({ ...item })
                     }
-                  } else {
-                    return {
-                      ...item,
-                      updater: user
+                  })
+                  if (nonMatchedOrderItems.length > 0)
+                    await tx.getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
+
+                  existingOrderItems = marketplaceOrderItems.map(item => {
+                    const matchedOrderItem = existingOrderItems.find(itm => itm.name == item.name)
+                    if (matchedOrderItem) {
+                      return {
+                        ...matchedOrderItem,
+                        ...item,
+                        updater: user
+                      }
                     }
-                  }
-                })
-              }
+                  })
+                } else {
+                  existingOrderItems = marketplaceOrderItems.map(item => {
+                    const matchedOrderItem = existingOrderItems.find(itm => itm.name == item.name)
+                    if (matchedOrderItem) {
+                      return {
+                        ...matchedOrderItem,
+                        ...item,
+                        updater: user
+                      }
+                    } else {
+                      return {
+                        ...item,
+                        updater: user
+                      }
+                    }
+                  })
+                }
 
-              marketplaceOrderItems = existingOrderItems
+                marketplaceOrderItems = existingOrderItems
+
+                savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
+                savedMarketplaceOrderShipping = await tx
+                  .getRepository(MarketplaceOrderShipping)
+                  .save(savedMarketplaceOrderShipping)
+              }
             }
 
             await tx.getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
 
-            savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
-            savedMarketplaceOrderShipping = await tx
-              .getRepository(MarketplaceOrderShipping)
-              .save(savedMarketplaceOrderShipping)
-
             if (j == marketplaceOrders.length - 1) {
               lastOrderId = order.name
             }

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

@@ -87,20 +87,41 @@ export const syncMarketplaceOrder = {
 
           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 (existingMarketplaceOrder.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 })
+            }
           }
         }
 
         marketplaceOrder = await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)
 
         let savedMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
+        let savedMarketplaceOrderShippings: MarketplaceOrderShipping[] = []
 
         if (order?.orderShipping) {
           const orderShipping: any = order.orderShipping
@@ -120,30 +141,66 @@ export const syncMarketplaceOrder = {
           marketplaceOrderShipping.phone2 = orderShipping.phone2
           marketplaceOrderShipping.trackingNo = order.trackingNo
           marketplaceOrderShipping.orderNoRef = marketplaceOrder.orderNo
+          marketplaceOrderShipping.subOrderNoRef = marketplaceOrder.orderNo
           marketplaceOrderShipping.marketplaceStore = marketplaceStore
           marketplaceOrderShipping.creator = user
           marketplaceOrderShipping.domain = marketplaceStore.domain
 
           if (existingMarketplaceOrder) {
-            let existingOrderShipping: MarketplaceOrderShipping
-            existingOrderShipping = existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShipping
+            if (existingMarketplaceOrder.isSplitted) {
+              let existingOrderShippings: MarketplaceOrderShipping[] = await tx
+                .getRepository(MarketplaceOrderShipping)
+                .find({
+                  where: { domain, marketplaceStore, orderNoRef: marketplaceOrder.orderNo }
+                })
+
+              existingOrderShippings = existingOrderShippings.map(item => {
+                return {
+                  ...item,
+                  address1: orderShipping.address1,
+                  address2: orderShipping.address2,
+                  address3: orderShipping.address3,
+                  address4: orderShipping.address4,
+                  address5: orderShipping.address5,
+                  attentionTo: orderShipping.attentionTo,
+                  city: orderShipping.city,
+                  country: orderShipping.country,
+                  postCode: orderShipping.postCode,
+                  phone1: orderShipping.phone1,
+                  phone2: orderShipping.phone2,
+                  trackingNo: order.trackingNo
+                }
+              })
+
+              savedMarketplaceOrderShippings = await tx
+                .getRepository(MarketplaceOrderShipping)
+                .save(existingOrderShippings)
+            } else {
+              let existingOrderShipping: MarketplaceOrderShipping
+              existingOrderShipping = existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShipping
+
+              marketplaceOrderShipping = {
+                ...existingOrderShipping,
+                ...marketplaceOrderShipping,
+                updater: user
+              }
 
-            marketplaceOrderShipping = {
-              ...existingOrderShipping,
-              ...marketplaceOrderShipping,
-              updater: user
+              savedMarketplaceOrderShipping = await tx
+                .getRepository(MarketplaceOrderShipping)
+                .save(marketplaceOrderShipping)
             }
+          } else {
+            savedMarketplaceOrderShipping = await tx
+              .getRepository(MarketplaceOrderShipping)
+              .save(marketplaceOrderShipping)
           }
-
-          savedMarketplaceOrderShipping = await tx
-            .getRepository(MarketplaceOrderShipping)
-            .save(marketplaceOrderShipping)
         }
 
         let orderTotalWeight: number = 0
+        let foundVariation
         for (var j = 0; j < order.orderItems.length; j++) {
           var item = order.orderItems[j]
-          let foundVariation = await tx
+          foundVariation = await tx
             .getRepository(MarketplaceProductVariation)
             .findOne({ where: { domain: marketplaceStore.domain, variationId: item.variationId } })
 
@@ -180,58 +237,78 @@ export const syncMarketplaceOrder = {
         }
 
         if (existingMarketplaceOrder) {
-          let existingOrderItems: MarketplaceOrderItem[] = []
-          existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
-
-          if (existingOrderItems.length > marketplaceOrderItems.length) {
-            const nonMatchedOrderItems = []
-            existingOrderItems.map(item => {
-              const matchedOrderItem = marketplaceOrderItems.find(itm => itm.name == item.name)
-              if (!matchedOrderItem) {
-                nonMatchedOrderItems.push({ ...item })
-              }
-            })
-            if (nonMatchedOrderItems.length > 0)
-              await tx.getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
-
-            existingOrderItems = marketplaceOrderItems.map(item => {
-              const matchedOrderItem = existingOrderItems.find(itm => itm.name == item.name)
-              if (matchedOrderItem) {
-                return {
-                  ...matchedOrderItem,
-                  ...item,
-                  updater: user
-                }
+          if (existingMarketplaceOrder.isSplitted) {
+            let existingOrderItems: MarketplaceOrderItem[] = []
+            existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
+
+            marketplaceOrderItems = existingOrderItems.filter(itm => itm.name == item.name)
+            marketplaceOrderItems = marketplaceOrderItems.map(marketplaceOrderitem => {
+              return {
+                ...marketplaceOrderitem,
+                status: order.status,
+                marketplaceProductVariation: foundVariation,
+                trackingCode: order.trackingNo
               }
             })
           } else {
-            existingOrderItems = marketplaceOrderItems.map(item => {
-              const matchedOrderItem = existingOrderItems.find(itm => itm.name == item.name)
-              if (matchedOrderItem) {
-                return {
-                  ...matchedOrderItem,
-                  ...item,
-                  updater: user
+            let existingOrderItems: MarketplaceOrderItem[] = []
+            existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
+
+            if (existingOrderItems.length > marketplaceOrderItems.length) {
+              let nonMatchedOrderItems = []
+              existingOrderItems.map(item => {
+                const matchedOrderItem = marketplaceOrderItems.find(itm => itm.name === item.name)
+                if (!matchedOrderItem) {
+                  nonMatchedOrderItems.push({ ...item })
                 }
-              } else {
-                return {
-                  ...item,
-                  updater: user
+              })
+              if (nonMatchedOrderItems.length > 0)
+                await tx.getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
+
+              existingOrderItems = marketplaceOrderItems.map(item => {
+                const matchedOrderItem = existingOrderItems.find(itm => itm.name == item.name)
+                if (matchedOrderItem) {
+                  return {
+                    ...matchedOrderItem,
+                    ...item,
+                    updater: user
+                  }
                 }
-              }
-            })
-          }
+              })
+            } else {
+              existingOrderItems = marketplaceOrderItems.map(item => {
+                const matchedOrderItem = existingOrderItems.find(itm => itm.name == item.name)
+                if (matchedOrderItem) {
+                  return {
+                    ...matchedOrderItem,
+                    ...item,
+                    updater: user
+                  }
+                } else {
+                  return {
+                    ...item,
+                    updater: user
+                  }
+                }
+              })
+            }
 
-          marketplaceOrderItems = existingOrderItems
+            marketplaceOrderItems = existingOrderItems
+
+            savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
+            savedMarketplaceOrderShipping = await tx
+              .getRepository(MarketplaceOrderShipping)
+              .save(savedMarketplaceOrderShipping)
+          }
+        } else {
+          savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
+          savedMarketplaceOrderShipping = await tx
+            .getRepository(MarketplaceOrderShipping)
+            .save(savedMarketplaceOrderShipping)
         }
 
         await tx.getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
 
-        savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
-        savedMarketplaceOrderShipping = await tx
-          .getRepository(MarketplaceOrderShipping)
-          .save(savedMarketplaceOrderShipping)
-
         if (i == marketplaceOrders.length - 1) {
           lastOrderId = order.name
         }