@things-factory/marketplace-base 8.0.7 → 9.0.0-beta.12

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

@@ -1,39 +0,0 @@
-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

@@ -1,245 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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
-  }
-}