@things-factory/marketplace-base 8.0.0-beta.9 → 8.0.2

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

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

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

@@ -0,0 +1,245 @@
+import { v4 as uuidv4 } from 'uuid'
+
+import { MarketplaceSetting, MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Product } from '@things-factory/product-base'
+
+import {
+  MarketplaceOrder,
+  MarketplaceOrderItem,
+  MarketplaceOrderShipping,
+  MarketplaceOrderShippingItem,
+  MarketplaceProductVariation
+} from '../../../entities'
+import { NoGenerator } from '../../../utils'
+
+export const splitOrdersByBatch = {
+  async splitOrdersByBatch(_: any, { patches }, context: ResolverContext) {
+    const { user, tx, domain } = context.state
+
+    for (let i: number = 0; i < patches.length; i++) {
+      const patch: any = patches[i]
+      let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { id: patch.id },
+        relations: [
+          'domain',
+          'marketplaceStore',
+          'marketplaceOrderItems',
+          'marketplaceOrderItems.marketplaceProductVariation'
+        ]
+      })
+      if (!marketplaceOrder) throw new Error('No order is found')
+
+      const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+      const maxWeightSetting: MarketplaceSetting = await tx.getRepository(MarketplaceSetting).findOne({
+        where: {
+          domain: { id: domain.id },
+          category: 'marketplace_order_max_weight',
+          marketplaceStore: { id: marketplaceStore.id }
+        }
+      })
+      if (!maxWeightSetting) throw new Error('marketplace_order_max_weight setting not found')
+
+      const marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
+      if (!marketplaceOrderItems.every(marketplaceOrderItem => marketplaceOrderItem.marketplaceProductVariation.sku))
+        throw new Error('all items must be linked before split order')
+
+      let originalMarketplaceOrderShipping: MarketplaceOrderShipping = await tx
+        .getRepository(MarketplaceOrderShipping)
+        .findOne({
+          where: {
+            domain: { id: domain.id },
+            orderNoRef: marketplaceOrder.orderNo,
+            marketplaceStore: { id: marketplaceOrder.marketplaceStore.id }
+          },
+          relations: [
+            'marketplaceOrderShippingItems',
+            'marketplaceOrderShippingItems.product',
+            'marketplaceOrderShippingItems.product.productDetails',
+            'marketplaceOrderShippingItems.marketplaceOrderItem',
+            'marketplaceOrderShippingItems.marketplaceOrderItem.marketplaceProductVariation'
+          ]
+        })
+
+      const originalMarketplaceOrderShippingItems: MarketplaceOrderShippingItem[] =
+        originalMarketplaceOrderShipping.marketplaceOrderShippingItems
+      let newMarketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = []
+      let splittedShipmentItems: any[] = []
+
+      for (let a: number = 0; a < originalMarketplaceOrderShippingItems.length; a++) {
+        const marketplaceOrderShippingItem: MarketplaceOrderShippingItem = originalMarketplaceOrderShippingItems[a]
+
+        for (let b: number = 0; b < marketplaceOrderShippingItem.qty; b++) {
+          const newItem: MarketplaceOrderShippingItem = {
+            ...marketplaceOrderShippingItem,
+            qty: 1
+          }
+          newMarketplaceOrderShippingItems.push(newItem)
+        }
+      }
+
+      newMarketplaceOrderShippingItems.sort(function (a, b) {
+        if (
+          a.marketplaceOrderItem.marketplaceProductVariation.primaryUnitValue <
+          b.marketplaceOrderItem.marketplaceProductVariation.primaryUnitValue
+        )
+          return -1
+        if (
+          a.marketplaceOrderItem.marketplaceProductVariation.primaryUnitValue >
+          b.marketplaceOrderItem.marketplaceProductVariation.primaryUnitValue
+        )
+          return 1
+        return 0
+      })
+
+      for (let a: number = 0; a < newMarketplaceOrderShippingItems.length; a++) {
+        let marketplaceOrderShippingItem: MarketplaceOrderShippingItem = newMarketplaceOrderShippingItems[a]
+        const product: Product = marketplaceOrderShippingItem.product
+        const marketplaceOrderItem: MarketplaceOrderItem = marketplaceOrderShippingItem.marketplaceOrderItem
+
+        const marketplaceProductVariation: MarketplaceProductVariation =
+          marketplaceOrderItem.marketplaceProductVariation
+
+        if (!marketplaceProductVariation?.primaryUnitValue)
+          throw new Error(marketplaceProductVariation.variationSku + ' weight is empty')
+
+        const primaryUnitValue: number = parseFloat(marketplaceProductVariation.primaryUnitValue.toFixed(2)) || 0
+
+        delete marketplaceOrderShippingItem.id
+
+        let newMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
+        newMarketplaceOrderShipping.name = NoGenerator.orderShipping()
+        newMarketplaceOrderShipping.address1 = originalMarketplaceOrderShipping.address1
+        newMarketplaceOrderShipping.address2 = originalMarketplaceOrderShipping.address2
+        newMarketplaceOrderShipping.address3 = originalMarketplaceOrderShipping.address3
+        newMarketplaceOrderShipping.address4 = originalMarketplaceOrderShipping.address4
+        newMarketplaceOrderShipping.address5 = originalMarketplaceOrderShipping.address5
+        newMarketplaceOrderShipping.attentionTo = originalMarketplaceOrderShipping.attentionTo
+        newMarketplaceOrderShipping.city = originalMarketplaceOrderShipping.city
+        newMarketplaceOrderShipping.country = originalMarketplaceOrderShipping.country
+        newMarketplaceOrderShipping.postCode = originalMarketplaceOrderShipping.postCode
+        newMarketplaceOrderShipping.phone1 = originalMarketplaceOrderShipping.phone1
+        newMarketplaceOrderShipping.phone2 = originalMarketplaceOrderShipping.phone2
+        newMarketplaceOrderShipping.orderNoRef = marketplaceOrder.orderNo
+        newMarketplaceOrderShipping.transporter = originalMarketplaceOrderShipping.transporter
+        newMarketplaceOrderShipping.marketplaceStore = marketplaceStore
+        newMarketplaceOrderShipping.creator = user
+        newMarketplaceOrderShipping.domain = marketplaceOrder.domain
+        newMarketplaceOrderShipping.weightUnit = 'KG'
+
+        if (splittedShipmentItems.length == 0) {
+          newMarketplaceOrderShipping.totalWeight = primaryUnitValue
+
+          newMarketplaceOrderShipping = await tx
+            .getRepository(MarketplaceOrderShipping)
+            .save(newMarketplaceOrderShipping)
+
+          marketplaceOrderShippingItem.name = uuidv4()
+          marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem
+          marketplaceOrderShippingItem.marketplaceOrderShipping = newMarketplaceOrderShipping
+          marketplaceOrderShippingItem.product = product
+          marketplaceOrderShippingItem.domain = marketplaceOrder.domain
+
+          let splittedShipment: any = {
+            shipments: [{ ...marketplaceOrderShippingItem }],
+            totalWeight: primaryUnitValue
+          }
+          splittedShipmentItems.push(splittedShipment)
+        } else {
+          let lastShipment: any = splittedShipmentItems[splittedShipmentItems.length - 1]
+          let lastTotalWeight: number = parseFloat(lastShipment.totalWeight.toFixed(2))
+          if (lastTotalWeight + primaryUnitValue < parseFloat(maxWeightSetting.value)) {
+            splittedShipmentItems.map((shipmentItem, idx) => {
+              if (idx === splittedShipmentItems.length - 1) {
+                let shipments: any[] = shipmentItem.shipments
+
+                shipments = shipments.map(async shipment => {
+                  if (shipment.product.id === product.id) {
+                    shipment.qty += marketplaceOrderShippingItem.qty
+                  } else {
+                    const matchedProduct = shipments.find(shipment => shipment.product.id == product.id)
+                    if (!matchedProduct) {
+                      marketplaceOrderShippingItem.name = uuidv4()
+                      marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem
+                      marketplaceOrderShippingItem.marketplaceOrderShipping = shipment.marketplaceOrderShipping
+                      marketplaceOrderShippingItem.product = product
+                      marketplaceOrderShippingItem.domain = marketplaceOrder.domain
+                      shipmentItem.shipments.push({ ...marketplaceOrderShippingItem })
+                    }
+                  }
+
+                  shipment.marketplaceOrderShipping.totalWeight = parseFloat(
+                    (lastTotalWeight + primaryUnitValue).toFixed(2)
+                  )
+                  await tx.getRepository(MarketplaceOrderShipping).save(shipment.marketplaceOrderShipping)
+                })
+
+                shipmentItem.totalWeight += primaryUnitValue
+              }
+            })
+          } else {
+            newMarketplaceOrderShipping.totalWeight = primaryUnitValue
+
+            newMarketplaceOrderShipping = await tx
+              .getRepository(MarketplaceOrderShipping)
+              .save(newMarketplaceOrderShipping)
+
+            marketplaceOrderShippingItem.name = uuidv4()
+            marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem
+            marketplaceOrderShippingItem.marketplaceOrderShipping = newMarketplaceOrderShipping
+            marketplaceOrderShippingItem.product = product
+            marketplaceOrderShippingItem.domain = marketplaceOrder.domain
+
+            let splittedShipment: any = {
+              shipments: [{ ...marketplaceOrderShippingItem }],
+              totalWeight: primaryUnitValue
+            }
+            splittedShipmentItems.push(splittedShipment)
+          }
+        }
+      }
+
+      let savedMarketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = []
+      for (let a: number = 0; a < splittedShipmentItems.length; a++) {
+        const shipments: any[] = splittedShipmentItems[a].shipments
+        for (let b: number = 0; b < shipments.length; b++) {
+          savedMarketplaceOrderShippingItems.push(shipments[b])
+        }
+      }
+
+      savedMarketplaceOrderShippingItems = await tx
+        .getRepository(MarketplaceOrderShippingItem)
+        .save(savedMarketplaceOrderShippingItems)
+
+      await tx
+        .getRepository(MarketplaceOrderShippingItem)
+        .delete(originalMarketplaceOrderShippingItems.map(item => item.id))
+
+      await tx.getRepository(MarketplaceOrderShipping).delete(originalMarketplaceOrderShipping.id)
+
+      let marketplaceOrderShippings: MarketplaceOrderShipping[] = await tx
+        .getRepository(MarketplaceOrderShipping)
+        .find({ where: { domain: { id: domain.id }, orderNoRef: marketplaceOrder.orderNo } })
+
+      marketplaceOrderShippings = marketplaceOrderShippings.map((marketplaceOrderShipping, idx) => {
+        return {
+          ...marketplaceOrderShipping,
+          subOrderNoRef:
+            marketplaceOrderShippings.length == 1
+              ? marketplaceOrderShipping.orderNoRef
+              : marketplaceOrderShipping.orderNoRef + ' - ' + (idx + 1) + '/' + marketplaceOrderShippings.length
+        }
+      })
+
+      await tx.getRepository(MarketplaceOrderShipping).save(marketplaceOrderShippings)
+
+      let newMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { id: patch.id }
+      })
+      newMarketplaceOrder.isSplitted = true
+      await tx.getRepository(MarketplaceOrder).save(newMarketplaceOrder)
+    }
+
+    return true
+  }
+}

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

@@ -0,0 +1,39 @@
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { syncMarketplaceOrder } from './sync-marketplace-order'
+
+export const syncAllMarketplaceOrder = {
+  async syncAllMarketplaceOrder(
+    _: any,
+    { companyDomainId, fromCreatedDate, toCreatedDate, blackListStores },
+    context: any
+  ) {
+    const { user } = context.state
+
+    const companyDomain: Domain = await getRepository(Domain).findOneBy({ id: companyDomainId })
+
+    // Step 1: get all available marketplace-store
+    const marketplaceStores: MarketplaceStore[] = await StoreAPI.getMarketplaceStores(companyDomain)
+
+    // Step 2: get marketplace order based on each marketplace-store
+    if (marketplaceStores?.length === 0) throw new Error('No active marketplace store')
+    let whiteListStores: MarketplaceStore[] = marketplaceStores
+
+    if (blackListStores) {
+      blackListStores = blackListStores.split(',')
+      whiteListStores = marketplaceStores.filter(store => blackListStores.indexOf(store.name) < 0)
+    }
+
+    for (var i = 0; i < whiteListStores?.length; i++) {
+      const marketplaceStore = whiteListStores[i]
+      syncMarketplaceOrder.syncMarketplaceOrder(
+        _,
+        { storeId: marketplaceStore.id, fromCreatedDate, toCreatedDate, scheduler: true },
+        context
+      )
+    }
+
+    return true
+  }
+}