@things-factory/integration-sellercraft 5.0.14 → 6.0.0-alpha.3

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

@@ -1,29 +1,42 @@
 import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { config } from '@things-factory/env'
 import { StoreAPI } from '@things-factory/integration-marketplace'
+import { getRepository } from '@things-factory/shell'
 
 import { SellercraftChannelIntegrationAPI } from '../../controllers/sellercraft-channel-integration-api'
-import { MarketplaceChannel } from './marketplace-channel'
 import { getShops } from '../../utils/tokencraft-util'
+import { MarketplaceChannel } from './marketplace-channel'
 
 @Resolver()
 export class MarketplaceChannelProductMutation {
   @Mutation(returns => Boolean)
   async syncAllMarketplaceChannelProducts(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('fromUpdatedDate', { nullable: true }) fromUpdatedDate?: string,
-    @Arg('toUpdatedDate', { nullable: true }) toUpdatedDate?: string
+    @Arg('toUpdatedDate', { nullable: true }) toUpdatedDate?: string,
+    @Arg('productBatchSize', { nullable: true }) productBatchSize?: string,
+    @Arg('channelId', { nullable: true }) channelId?: string,
+    @Arg('shopId', { nullable: true }) shopId?: string,
+    @Arg('airflow', { nullable: true }) airflow?: boolean
   ): Promise<boolean> {
     const sellercraftChannelIntegrationConfig = config.get('sellercraftChannelIntegrationConfig', {})
 
-    const channels: MarketplaceChannel[] = await getRepository(MarketplaceChannel).find({ where: { isActive: true } })
+    let channels: MarketplaceChannel[] = await getRepository(MarketplaceChannel).find({ where: { isActive: true } })
+    let errors: any = []
+
+    if (channelId) {
+      channels = channels.filter(channel => channel.channelId == channelId)
+    }
 
     for (var i = 0; i < channels.length; i++) {
       try {
         let shops: any = await getShops(channels[i].channelId)
 
+        if (shopId) {
+          shops = shops.filter(shop => shop.channel_shop_id == shopId)
+        }
+
         for (var j = 0; j < shops.length; j++) {
           try {
             var store = {
@@ -47,14 +60,24 @@ export class MarketplaceChannelProductMutation {
             let totalPages: number = 1
             let limit: number = 50
             let parentLinks = []
+            let cursor: string
 
             for (let page = 0; page < totalPages; page++) {
-              const { results, total, parentLinkList } = await StoreAPI.getStoreProducts(store, {
-                pagination: { page, limit }
+              const {
+                results,
+                total,
+                parentLinkList,
+                page_info: nextCursor
+              } = await StoreAPI.getStoreProducts(store, {
+                pagination: { page, limit },
+                pageInfo: cursor,
+                fromUpdatedDate,
+                toUpdatedDate
               })
               totalPages = Math.ceil(total / limit)
               productResult.push(...results)
               if (store.platform == 'magento') parentLinks.push(...parentLinkList)
+              cursor = nextCursor
             }
 
             const categoryResult = []
@@ -74,7 +97,16 @@ export class MarketplaceChannelProductMutation {
             }
 
             let mappedProducts = productResult.map(item => {
-              let { categoryId, itemId: productId, name, brand, isVerified, images, sellercraftAttributes, variations } = item
+              let {
+                categoryId,
+                itemId: productId,
+                name,
+                brand,
+                isVerified,
+                images,
+                sellercraftAttributes,
+                variations
+              } = item
 
               variations = variations.map(variation => {
                 let {
@@ -203,18 +235,47 @@ export class MarketplaceChannelProductMutation {
               await SellercraftChannelIntegrationAPI.ingestChannelCategories(sellercraftStore, {
                 categories: mappedCategories
               })
-            } catch (e) {}
+            } catch (e) {
+              errors.push({
+                name: 'Category Ingestion Error',
+                msg: JSON.stringify(e) || {}
+              })
+            }
 
-            try {
-              for (let k = 0, l = mappedProducts.length; k < l; k++) {
-                await SellercraftChannelIntegrationAPI.ingestChannelProduct(sellercraftStore, {
-                  products: [mappedProducts[k]]
-                })
+            let bs = parseInt(productBatchSize) || mappedProducts.length
+
+            if (mappedProducts.length > 0) {
+              while (mappedProducts.length > 0) {
+                let spliceResult = mappedProducts.splice(0, mappedProducts.length >= bs ? bs : mappedProducts.length)
+
+                try {
+                  await SellercraftChannelIntegrationAPI.ingestChannelProduct(sellercraftStore, {
+                    products: spliceResult
+                  })
+                } catch (e) {
+                  errors.push({
+                    name: 'Product Ingestion Error',
+                    msg: JSON.stringify(e) || {}
+                  })
+                }
               }
-            } catch (e) {}
-          } catch (e) {}
+            }
+          } catch (e) {
+            errors.push({
+              name: 'Product Processing / Mapping Error',
+              msg: JSON.stringify(e) || {}
+            })
+          }
         }
-      } catch (e) {}
+      } catch (e) {
+        errors.push({
+          name: 'Store Error',
+          msg: JSON.stringify(e) || {}
+        })
+      }
+    }
+    if (errors.length > 1 && airflow) {
+      throw errors
     }
     return true
   }

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

@@ -40,6 +40,10 @@ export class MarketplaceChannel {
   @Field()
   channelId: string
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  countryCode: string
+
   @Column({ default: true })
   @Field()
   isActive: boolean

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

@@ -9,7 +9,10 @@ import { NewSellercraft, SellercraftPatch } from './sellercraft-type'
 export class SellercraftMutation {
   @Directive('@transaction')
   @Mutation(returns => Sellercraft, { description: 'To create new Sellercraft' })
-  async createSellercraft(@Arg('sellercraft') sellercraft: NewSellercraft, @Ctx() context: any): Promise<Sellercraft> {
+  async createSellercraft(
+    @Arg('sellercraft') sellercraft: NewSellercraft,
+    @Ctx() context: ResolverContext
+  ): Promise<Sellercraft> {
     const { domain, user, tx } = context.state
 
     return await tx.getRepository(Sellercraft).save({
@@ -26,12 +29,12 @@ export class SellercraftMutation {
   async updateSellercraft(
     @Arg('id') id: string,
     @Arg('patch') patch: SellercraftPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Sellercraft> {
     const { user, tx } = context.state
 
     const repository = tx.getRepository(Sellercraft)
-    const sellercraft = await repository.findOne(id)
+    const sellercraft = await repository.findOneBy({ id })
 
     return await repository.save({
       ...sellercraft,
@@ -44,7 +47,7 @@ export class SellercraftMutation {
   @Mutation(returns => [Sellercraft], { description: "To modify multiple Sellercrafts' information" })
   async updateMultipleSellercraft(
     @Arg('patches', type => [SellercraftPatch]) patches: SellercraftPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Sellercraft[]> {
     const { domain, user, tx } = context.state
 
@@ -74,7 +77,7 @@ export class SellercraftMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const sellercraft = await sellercraftRepo.findOne(newRecord.id)
+        const sellercraft = await sellercraftRepo.findOneBy({ id: newRecord.id })
 
         const result = await sellercraftRepo.save({
           ...sellercraft,
@@ -91,18 +94,23 @@ export class SellercraftMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete Sellercraft' })
-  async deleteSellercraft(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteSellercraft(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(Sellercraft).delete({ domain, id })
+    await tx.getRepository(Sellercraft).delete({ domain: { id: domain.id }, id })
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple sellercrafts' })
-  async deleteSellercrafts(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteSellercrafts(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx, user } = context.state
-    let sellercrafts: Sellercraft[] = await tx.getRepository(Sellercraft).find({ where: { domain, id: In(ids) } })
+    let sellercrafts: Sellercraft[] = await tx
+      .getRepository(Sellercraft)
+      .find({ where: { domain: { id: domain.id }, id: In(ids) } })
 
     sellercrafts = sellercrafts.map((sellercraft: Sellercraft) => {
       return {

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

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
 
 import { Sellercraft } from './sellercraft'
 import { SellercraftList } from './sellercraft-type'
@@ -10,12 +9,12 @@ import { SellercraftList } from './sellercraft-type'
 @Resolver(Sellercraft)
 export class SellercraftQuery {
   @Query(returns => Sellercraft, { description: 'To fetch a Sellercraft' })
-  async sellercraft(@Arg('id') id: string, @Ctx() context: any): Promise<Sellercraft> {
-    return await getRepository(Sellercraft).findOne(id)
+  async sellercraft(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Sellercraft> {
+    return await getRepository(Sellercraft).findOneBy({ id })
   }
 
   @Query(returns => SellercraftList, { description: 'To fetch multiple Sellercrafts' })
-  async sellercrafts(@Args() params: ListParam, @Ctx() context: any): Promise<SellercraftList> {
+  async sellercrafts(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<SellercraftList> {
     const { domain } = context.state
 
     const convertedParams = convertListParams(params, { domain })
@@ -26,16 +25,16 @@ export class SellercraftQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() sellercraft: Sellercraft): Promise<Domain> {
-    return await getRepository(Domain).findOne(sellercraft.domainId)
+    return await getRepository(Domain).findOneBy({ id: sellercraft.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() sellercraft: Sellercraft): Promise<User> {
-    return await getRepository(User).findOne(sellercraft.updaterId)
+    return await getRepository(User).findOneBy({ id: sellercraft.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() sellercraft: Sellercraft): Promise<User> {
-    return await getRepository(User).findOne(sellercraft.creatorId)
+    return await getRepository(User).findOneBy({ id: sellercraft.creatorId })
   }
 }

package/server/service/sellercraft/sellercraft.ts

@@ -11,7 +11,7 @@ import {
 } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
+import { Domain, ScalarObject } from '@things-factory/shell'
 
 export enum SellercraftStatus {
   ACTIVE = 'ACTIVE',
@@ -68,6 +68,10 @@ export class Sellercraft {
   @Field({ nullable: true })
   status?: SellercraftStatus
 
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  sellercraftSetting?: object
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date