@things-factory/integration-sellercraft 5.0.0-alpha.50 → 5.0.0-alpha.54

package/server/service/marketplace-channel/marketplace-channel-order-mutation.ts

@@ -7,37 +7,26 @@ import { StoreAPI } from '@things-factory/integration-marketplace'
 import { SHIPPING_TYPE } from '../../constants'
 import { SellercraftChannelIntegrationAPI } from '../../controllers/sellercraft-channel-integration-api'
 import { MarketplaceChannel } from './marketplace-channel'
+import { getShops } from '../../utils/tokencraft-util'
 
 @Resolver()
 export class MarketplaceChannelOrderMutation {
   @Mutation(returns => Boolean)
   async syncAllMarketplaceChannelOrders(
-    @Arg('fromDate') fromDate: string,
-    @Arg('toDate') toDate: string,
-    @Ctx() context: any
+    @Ctx() context: any,
+    @Arg('fromCreatedDate', { nullable: true }) fromCreatedDate?: string,
+    @Arg('toCreatedDate', { nullable: true }) toCreatedDate?: string,
+    @Arg('fromUpdatedDate', { nullable: true }) fromUpdatedDate?: string,
+    @Arg('toUpdatedDate', { nullable: true }) toUpdatedDate?: string
   ): Promise<boolean> {
     const sellercraftChannelIntegrationConfig = config.get('sellercraftChannelIntegrationConfig', {})
-    const { tokenCraftApiKey: apiKey, getShopsTokenCraftUrl } = sellercraftChannelIntegrationConfig
 
     const channels: MarketplaceChannel[] = await getRepository(MarketplaceChannel).find({ where: { isActive: true } })
 
     for (var i = 0; i < channels.length; i++) {
       try {
         const channel: MarketplaceChannel = channels[i]
-        var channelsFullPath = getShopsTokenCraftUrl + '?channel_id=' + channel.channelId
-        const channelResponse: any = await fetch(channelsFullPath, {
-          method: 'get',
-          headers: {
-            'Content-Type': 'application/json',
-            'x-api-key': apiKey
-          }
-        })
-
-        if (!channelResponse.ok) {
-          throw new Error(channelResponse)
-        }
-        var shopsResponse = await channelResponse.json()
-        var shops = shopsResponse.shops
+        let shops: any = await getShops(channel.channelId)
 
         for (var j = 0; j < shops.length; j++) {
           try {
@@ -47,7 +36,8 @@ export class MarketplaceChannelOrderMutation {
               storeURL: shops[j]?.credential?.store_url || '',
               platform: channel.name,
               accessToken: shops[j]?.credential?.access_token, // Magento+, Tiktok
-              channelShopId: shops[j]?.channel_shop_id
+              channelShopId: shops[j]?.channel_shop_id,
+              storeId: shops[j]?.credential?.store_url || ''
             }
 
             // let countryCode = shops[j].country_code
@@ -68,8 +58,10 @@ export class MarketplaceChannelOrderMutation {
                 more,
                 nextCursor
               } = await StoreAPI.getStoreOrders(store, {
-                fromDate,
-                toDate,
+                fromCreatedDate,
+                toCreatedDate,
+                fromUpdatedDate,
+                toUpdatedDate,
                 pagination: { page, limit },
                 lastOrderId,
                 nextCursor: cursor
@@ -85,13 +77,14 @@ export class MarketplaceChannelOrderMutation {
             var sellercraftStore = { ...store, platform: 'sellercraftChannelIntegration' }
 
             let mappedOrderResult = orderResult.map(order => {
-              let id = store.platform == 'magento' ? order.name : order.orderNo
+              let id = store.platform == 'magento' || store.platform == 'shopify' ? order.name : order.orderNo
               let {
                 firstName: custFirstName,
                 lastName: custLastName,
                 orderCreatedAt: createdAt,
                 orderUpdatedAt: updatedAt,
                 status,
+                sellercraftStatus,
                 isSOF
               } = order
 
@@ -335,7 +328,7 @@ export class MarketplaceChannelOrderMutation {
                 mappedOrderItems,
                 channelShopId,
                 organisationId,
-                status,
+                status: sellercraftStatus || status,
                 isSOF: isSOF ? isSOF : false,
                 orderPackage,
                 charges: getOrderCharges(mappedOrderItems)
@@ -343,41 +336,54 @@ export class MarketplaceChannelOrderMutation {
             })
 
             if (mappedOrderResult.length > 0) {
-              await SellercraftChannelIntegrationAPI.ingestChannelOrder(sellercraftStore, {
-                orders: mappedOrderResult
-              })
+              while (mappedOrderResult.length > 0) {
+                let spliceResult = mappedOrderResult.splice(
+                  0,
+                  mappedOrderResult.length >= 20 ? 20 : mappedOrderResult.length
+                )
 
-              await Promise.all(
-                mappedOrderResult.map(async result => {
-                  if (!result?.isSOF && result?.orderPackage?.packageId) {
-                    let orderPackage: any = result.orderPackage
-                    let newOrderPackage: any = {
-                      channelShopId,
-                      nativeOrderId: result.id,
-                      nativePackageId: orderPackage.packageId,
-                      shippingTrackingCode: orderPackage.trackingNumber,
-                      shippingTypeValue: orderPackage?.shippingType
-                        ? orderPackage.shippingType
-                        : SHIPPING_TYPE.DROP_SHIPPING,
-                      warehouseCode: SHIPPING_TYPE.DROP_SHIPPING,
-                      shipper: {
-                        name: orderPackage.shippingProvider,
-                        isCodSupported: orderPackage?.isCodSupport ? orderPackage.isCodSupport : false
-                      },
-                      documents: orderPackage?.orderDocument || [],
-                      shipperLastMile: {
-                        name: orderPackage.shippingProvider,
-                        isCodSupported: orderPackage?.isCodSupport ? orderPackage.isCodSupport : false
-                      },
-                      orderItemIds: orderPackage?.orderListIdList
-                        ? orderPackage.orderListIdList
-                        : result.mappedOrderItems.map(orderItem => orderItem.id)
-                    }
+                try {
+                  await SellercraftChannelIntegrationAPI.ingestChannelOrder(sellercraftStore, {
+                    orders: spliceResult
+                  })
+                } catch (e) {}
 
-                    await SellercraftChannelIntegrationAPI.ingestChannelOrderPackage(sellercraftStore, newOrderPackage)
-                  }
-                })
-              )
+                await Promise.all(
+                  spliceResult.map(async result => {
+                    if (!result?.isSOF && result?.orderPackage?.packageId) {
+                      let orderPackage: any = result.orderPackage
+                      let newOrderPackage: any = {
+                        channelShopId,
+                        nativeOrderId: result.id,
+                        nativePackageId: orderPackage.packageId,
+                        shippingTrackingCode: orderPackage.trackingNumber,
+                        shippingTypeValue: orderPackage?.shippingType
+                          ? orderPackage.shippingType
+                          : SHIPPING_TYPE.DROP_SHIPPING,
+                        warehouseCode: SHIPPING_TYPE.DROP_SHIPPING,
+                        shipper: {
+                          name: orderPackage.shippingProvider,
+                          isCodSupported: orderPackage?.isCodSupport ? orderPackage.isCodSupport : false
+                        },
+                        documents: orderPackage?.orderDocument || [],
+                        shipperLastMile: {
+                          name: orderPackage.shippingProvider,
+                          isCodSupported: orderPackage?.isCodSupport ? orderPackage.isCodSupport : false
+                        },
+                        orderItemIds: orderPackage?.orderListIdList
+                          ? orderPackage.orderListIdList
+                          : result.mappedOrderItems.map(orderItem => orderItem.id)
+                      }
+                      try {
+                        await SellercraftChannelIntegrationAPI.ingestChannelOrderPackage(
+                          sellercraftStore,
+                          newOrderPackage
+                        )
+                      } catch (e) {}
+                    }
+                  })
+                )
+              }
             }
           } catch (e) {}
         }

package/server/service/marketplace-channel/marketplace-channel-product-mutation.ts

@@ -1,4 +1,4 @@
-import { Ctx, Mutation, Resolver } from 'type-graphql'
+import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
 import { getRepository } from 'typeorm'
 
 import { config } from '@things-factory/env'
@@ -6,212 +6,215 @@ import { StoreAPI } from '@things-factory/integration-marketplace'
 
 import { SellercraftChannelIntegrationAPI } from '../../controllers/sellercraft-channel-integration-api'
 import { MarketplaceChannel } from './marketplace-channel'
+import { getShops } from '../../utils/tokencraft-util'
 
 @Resolver()
 export class MarketplaceChannelProductMutation {
   @Mutation(returns => Boolean)
-  async syncAllMarketplaceChannelProducts(@Ctx() context: any): Promise<boolean> {
+  async syncAllMarketplaceChannelProducts(
+    @Ctx() context: any,
+    @Arg('fromUpdatedDate', { nullable: true }) fromUpdatedDate?: string,
+    @Arg('toUpdatedDate', { nullable: true }) toUpdatedDate?: string
+  ): Promise<boolean> {
     const sellercraftChannelIntegrationConfig = config.get('sellercraftChannelIntegrationConfig', {})
-    const { tokenCraftApiKey: apiKey, getShopsTokenCraftUrl } = sellercraftChannelIntegrationConfig
 
     const channels: MarketplaceChannel[] = await getRepository(MarketplaceChannel).find({ where: { isActive: true } })
 
     for (var i = 0; i < channels.length; i++) {
-      var channelsFullPath = getShopsTokenCraftUrl + '?channel_id=' + channels[i].channelId
-      const channelResponse: any = await fetch(channelsFullPath, {
-        method: 'get',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-api-key': apiKey
-        }
-      })
-
-      if (!channelResponse.ok) {
-        throw new Error(channelResponse)
-      }
-      var shopsResponse = await channelResponse.json()
-      var shops = shopsResponse.shops
-
-      for (var j = 0; j < shops.length; j++) {
-        var store = {
-          accessKey: shops[j]?.credential?.consumer_key || '',
-          accessSecret: shops[j]?.credential?.consumer_secret || '',
-          storeURL: shops[j]?.credential?.store_url || '',
-          platform: channels[i].name,
-          accessToken: shops[j]?.credential?.access_token, // Magento+, Tiktok
-          channelShopId: shops[j]?.channel_shop_id
-        }
+      try {
+        let shops: any = await getShops(channels[i].channelId)
+
+        for (var j = 0; j < shops.length; j++) {
+          try {
+            var store = {
+              accessKey: shops[j]?.credential?.consumer_key || '',
+              accessSecret: shops[j]?.credential?.consumer_secret || '',
+              storeURL: shops[j]?.credential?.store_url || '',
+              platform: channels[i].name,
+              accessToken: shops[j]?.credential?.access_token, // Magento+, Tiktok
+              channelShopId: shops[j]?.channel_shop_id,
+              storeId: shops[j]?.credential?.store_url || ''
+            }
 
-        let countryCode = shops[j].country_code
-        let channelCode = shops[j].org_prefix
-        let organisationId = shops[j].account_id
-        let channelShopId = shops[j].channel_shop_id
-
-        var sellercraftStore = { ...store, platform: 'sellercraftChannelIntegration' }
-
-        const productResult = []
-        let totalPages: number = 1
-        let limit: number = 50
-        let parentLinks = []
-
-        for (let page = 0; page < totalPages; page++) {
-          const { results, total, parentLinkList } = await StoreAPI.getStoreProducts(store, {
-            pagination: { page, limit }
-          })
-          totalPages = Math.ceil(total / limit)
-          productResult.push(...results)
-          if (store.platform == 'magento') parentLinks.push(...parentLinkList)
-        }
+            let countryCode = shops[j].country_code
+            let channelCode = shops[j].org_prefix
+            let organisationId = shops[j].account_id
+            let channelShopId = shops[j].channel_shop_id
+
+            var sellercraftStore = { ...store, platform: 'sellercraftChannelIntegration' }
+
+            const productResult = []
+            let totalPages: number = 1
+            let limit: number = 50
+            let parentLinks = []
+
+            for (let page = 0; page < totalPages; page++) {
+              const { results, total, parentLinkList } = await StoreAPI.getStoreProducts(store, {
+                pagination: { page, limit }
+              })
+              totalPages = Math.ceil(total / limit)
+              productResult.push(...results)
+              if (store.platform == 'magento') parentLinks.push(...parentLinkList)
+            }
 
-        const categoryResult = []
-        let totalPagesCategory: number = 1
-        let limitCategory: number = 100
+            const categoryResult = []
+            let totalPagesCategory: number = 1
+            let limitCategory: number = 100
 
-        for (let page = 0; page < totalPagesCategory; page++) {
-          const { results, total } = await StoreAPI.getStoreProductCategories(store, {
-            pagination: { page, limitCategory }
-          })
-          totalPagesCategory = Math.ceil(total / limitCategory)
-          categoryResult.push(...results)
-        }
+            if (store.platform != 'shopify') {
+              for (let page = 0; page < totalPagesCategory; page++) {
+                const { results, total } = await StoreAPI.getStoreProductCategories(store, {
+                  pagination: { page, limitCategory }
+                })
+                totalPagesCategory = Math.ceil(total / limitCategory)
+                categoryResult.push(...results)
+              }
+            } else {
+              categoryResult.push({ id: 1, name: 'default', isActive: true })
+            }
 
-        let mappedProducts = productResult.map(item => {
-          let { categoryId, itemId: productId, name, brand, isVerified, images, attributes, variations } = item
-
-          variations = variations.map(variation => {
-            let {
-              variationSku,
-              variationId,
-              name,
-              isEnabled: isEnabled,
-              isSellable: isSellable,
-              attributes,
-              stockLocked,
-              qty: stockReported,
-              costPrice: fullPrice,
-              sellPrice: priceDiscounted,
-              length,
-              width,
-              height,
-              weight
-            } = variation
-
-            return {
-              variationSku,
-              variationId,
-              name,
-              isEnabled,
-              isSellable,
-              attributes,
-              stockLocked,
-              stockReported,
-              fullPrice,
-              priceDiscounted,
-              inventoryProducts: [
-                {
-                  qty: 1,
-                  name: `${name} - ${variationSku}`,
-                  sku: variationSku,
-                  productVersions: [
+            let mappedProducts = productResult.map(item => {
+              let { categoryId, itemId: productId, name, brand, isVerified, images, sellercraftAttributes, variations } = item
+
+              variations = variations.map(variation => {
+                let {
+                  variationSku,
+                  variationId,
+                  name,
+                  isEnabled: isEnabled,
+                  isSellable: isSellable,
+                  sellercraftAttributes,
+                  stockLocked,
+                  qty: stockReported,
+                  costPrice: fullPrice,
+                  sellPrice: priceDiscounted,
+                  length,
+                  width,
+                  height,
+                  weight,
+                  extraMetadata
+                } = variation
+
+                return {
+                  variationSku,
+                  variationId,
+                  name,
+                  isEnabled,
+                  isSellable,
+                  attributes: sellercraftAttributes || [],
+                  stockLocked,
+                  stockReported,
+                  fullPrice: parseFloat(fullPrice) || 0,
+                  priceDiscounted: parseFloat(priceDiscounted) || 0,
+                  inventoryProducts: [
                     {
-                      label: 'Default',
-                      packageLengthMM: length,
-                      packageWidthMM: width,
-                      packageHeightMM: height,
-                      packageWeightGram: weight,
-                      qty: stockReported
+                      qty: 1,
+                      name: `${name} - ${variationSku}`,
+                      sku: variationSku,
+                      productVersions: [
+                        {
+                          label: 'Default',
+                          packageLengthMM: length,
+                          packageWidthMM: width,
+                          packageHeightMM: height,
+                          packageWeightGram: weight,
+                          qty: stockReported
+                        }
+                      ]
                     }
-                  ]
+                  ],
+                  extraMetadata
                 }
-              ]
-            }
-          })
+              })
 
-          images = images?.map(image => {
-            return {
-              url: image
-            }
-          })
-
-          return {
-            organisationId,
-            channelShopId: channelShopId,
-            channelCode: channels[i].channelCode,
-            channelCountry: shops[j].country_code,
-            categoryId,
-            productId: parentLinks.find(e => e.children.includes(productId))?.id || productId,
-            name,
-            brand,
-            isVerified,
-            images,
-            attributes,
-            variations
-          }
-        })
-
-        let mappedCategories = categoryResult.map(category => {
-          let { id: categoryId, name: categoryName, parent, isActive } = category
-
-          return {
-            categoryId,
-            categoryName,
-            parent,
-            isActive: isActive || true,
-            channelCode,
-            countryCode,
-            childrenCategories: []
-          }
-        })
-
-        if (store.platform == 'magento') {
-          let newList = []
-          for (let np of mappedProducts) {
-            if (np.productId == np.variations[0].variationId) {
-              let vars = mappedProducts
-                .filter(e => e.productId == np.productId)
-                .map(e => {
-                  return e.variations[0]
-                })
-              np.variations = vars
-              if (np.variations.length > 1) {
-                np.variations = np.variations.filter(v => v.variationId != np.productId)
+              images = images?.map(image => {
+                return {
+                  url: image
+                }
+              })
+
+              return {
+                organisationId,
+                channelShopId: channelShopId,
+                channelCode: channels[i].channelCode,
+                channelCountry: shops[j].country_code,
+                categoryId: store.platform == 'shopify' ? 1 : categoryId,
+                productId: parentLinks.find(e => e.children.includes(productId))?.id || productId,
+                name,
+                brand,
+                isVerified,
+                images,
+                attributes: sellercraftAttributes || [],
+                variations
               }
-              newList.push(np)
-            }
-          }
-          mappedProducts = newList
-        }
+            })
 
-        try {
-          let filterList = []
-          mappedCategories = mappedCategories.map(category => {
-            if (mappedCategories.filter(e => e.parent == category.categoryId).length > 0) {
-              category.childrenCategories = mappedCategories.filter(e => e.parent == category.categoryId)
-              filterList.push(...mappedCategories.filter(e => e.parent == category.categoryId))
-            }
-            return category
-          })
+            let mappedCategories = categoryResult.map(category => {
+              let { id: categoryId, name: categoryName, parent, isActive } = category
+
+              return {
+                categoryId,
+                categoryName,
+                parent,
+                isActive: isActive || true,
+                channelCode,
+                countryCode,
+                childrenCategories: []
+              }
+            })
 
-          mappedCategories = mappedCategories.map(mc => {
-            if (filterList.indexOf(mc) == -1) {
-              return mc
+            if (store.platform == 'magento') {
+              let newList = []
+              for (let np of mappedProducts) {
+                if (np.productId == np.variations[0].variationId) {
+                  let vars = mappedProducts
+                    .filter(e => e.productId == np.productId)
+                    .map(e => {
+                      return e.variations[0]
+                    })
+                  np.variations = vars
+                  if (np.variations.length > 1) {
+                    np.variations = np.variations.filter(v => v.variationId != np.productId)
+                  }
+                  newList.push(np)
+                }
+              }
+              mappedProducts = newList
             }
-          }).filter(e => e)
 
-          await SellercraftChannelIntegrationAPI.ingestChannelCategories(sellercraftStore, {
-            categories: mappedCategories
-          })
-        } catch (e) {}
+            try {
+              let filterList = []
+              mappedCategories = mappedCategories.map(category => {
+                if (mappedCategories.filter(e => e.parent == category.categoryId).length > 0) {
+                  category.childrenCategories = mappedCategories.filter(e => e.parent == category.categoryId)
+                  filterList.push(...mappedCategories.filter(e => e.parent == category.categoryId))
+                }
+                return category
+              })
+
+              mappedCategories = mappedCategories
+                .map(mc => {
+                  if (filterList.indexOf(mc) == -1) {
+                    return mc
+                  }
+                })
+                .filter(e => e)
 
-        try {
-          for (let k = 0, l = mappedProducts.length; k < l; k++) {
-            await SellercraftChannelIntegrationAPI.ingestChannelProduct(sellercraftStore, {
-              products: [mappedProducts[k]]
-            })
-          }
-        } catch (e) {}
-      }
+              await SellercraftChannelIntegrationAPI.ingestChannelCategories(sellercraftStore, {
+                categories: mappedCategories
+              })
+            } catch (e) {}
 
+            try {
+              for (let k = 0, l = mappedProducts.length; k < l; k++) {
+                await SellercraftChannelIntegrationAPI.ingestChannelProduct(sellercraftStore, {
+                  products: [mappedProducts[k]]
+                })
+              }
+            } catch (e) {}
+          } catch (e) {}
+        }
+      } catch (e) {}
     }
     return true
   }

package/server/service/sellercraft/sellercraft-mutation.ts

@@ -1,6 +1,6 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { In } from 'typeorm'
-import uuid from 'uuid/v4'
+import { v4 as uuidv4 } from 'uuid'
 
 import { Sellercraft, SellercraftPlatform, SellercraftStatus } from './sellercraft'
 import { NewSellercraft, SellercraftPatch } from './sellercraft-type'
@@ -14,7 +14,7 @@ export class SellercraftMutation {
 
     return await tx.getRepository(Sellercraft).save({
       ...sellercraft,
-      name: uuid(),
+      name: uuidv4(),
       domain,
       creator: user,
       updater: user
@@ -60,7 +60,7 @@ export class SellercraftMutation {
         const result = await sellercraftRepo.save({
           ...newRecord,
           domain,
-          name: uuid(),
+          name: uuidv4(),
           status: SellercraftStatus.ACTIVE,
           platform: SellercraftPlatform.SELLERCRAFT,
           creator: user,

package/server/service/sellercraft/sellercraft-query.ts

@@ -18,7 +18,7 @@ export class SellercraftQuery {
   async sellercrafts(@Args() params: ListParam, @Ctx() context: any): Promise<SellercraftList> {
     const { domain } = context.state
 
-    const convertedParams = convertListParams(params, domain.id)
+    const convertedParams = convertListParams(params, { domain })
     const [items, total] = await getRepository(Sellercraft).findAndCount(convertedParams)
 
     return { items, total }