@things-factory/integration-sellercraft 8.0.0-beta.8 → 8.0.0

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

@@ -0,0 +1,282 @@
+import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
+
+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 { getShops } from '../../utils/tokencraft-util'
+import { MarketplaceChannel } from './marketplace-channel'
+
+@Resolver()
+export class MarketplaceChannelProductMutation {
+  @Mutation(returns => Boolean)
+  async syncAllMarketplaceChannelProducts(
+    @Ctx() context: ResolverContext,
+    @Arg('fromUpdatedDate', { nullable: true }) fromUpdatedDate?: 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', {})
+
+    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 = {
+              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 = []
+            let cursor: string
+
+            for (let page = 0; page < totalPages; page++) {
+              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 = []
+            let totalPagesCategory: number = 1
+            let limitCategory: number = 100
+
+            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,
+                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: [
+                    {
+                      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: store.platform == 'shopify' ? 1 : categoryId,
+                productId: parentLinks.find(e => e.children.includes(productId))?.id || productId,
+                name,
+                brand,
+                isVerified,
+                images,
+                attributes: sellercraftAttributes || [],
+                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)
+                  }
+                  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
+              })
+
+              mappedCategories = mappedCategories
+                .map(mc => {
+                  if (filterList.indexOf(mc) == -1) {
+                    return mc
+                  }
+                })
+                .filter(e => e)
+
+              await SellercraftChannelIntegrationAPI.ingestChannelCategories(sellercraftStore, {
+                categories: mappedCategories
+              })
+            } catch (e) {
+              errors.push({
+                name: 'Category Ingestion Error',
+                msg: JSON.stringify(e) || {}
+              })
+            }
+
+            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) {
+            errors.push({
+              name: 'Product Processing / Mapping Error',
+              msg: JSON.stringify(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

@@ -0,0 +1,76 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+@Entity()
+@Index(
+  'ix_marketplace_channel_0 ',
+  (marketplaceChannel: MarketplaceChannel) => [marketplaceChannel.domain, marketplaceChannel.name],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for Marketplace Channel' })
+export class MarketplaceChannel {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((marketplaceChannel: MarketplaceChannel) => marketplaceChannel.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column()
+  @Field()
+  channelCode: string
+
+  @Column()
+  @Field()
+  channelId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  countryCode: string
+
+  @Column({ default: true })
+  @Field()
+  isActive: boolean
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((marketplaceChannel: MarketplaceChannel) => marketplaceChannel.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((marketplaceChannel: MarketplaceChannel) => marketplaceChannel.updater)
+  updaterId?: string
+}

package/server/service/sellercraft/index.ts

@@ -0,0 +1,6 @@
+import { Sellercraft } from './sellercraft'
+import { SellercraftQuery } from './sellercraft-query'
+import { SellercraftMutation } from './sellercraft-mutation'
+
+export const entities = [Sellercraft]
+export const resolvers = [SellercraftQuery, SellercraftMutation]

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

@@ -0,0 +1,126 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+import { v4 as uuidv4 } from 'uuid'
+
+import { Sellercraft, SellercraftPlatform, SellercraftStatus } from './sellercraft'
+import { NewSellercraft, SellercraftPatch } from './sellercraft-type'
+
+@Resolver(Sellercraft)
+export class SellercraftMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Sellercraft, { description: 'To create new Sellercraft' })
+  async createSellercraft(
+    @Arg('sellercraft') sellercraft: NewSellercraft,
+    @Ctx() context: ResolverContext
+  ): Promise<Sellercraft> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(Sellercraft).save({
+      ...sellercraft,
+      name: uuidv4(),
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Sellercraft, { description: 'To modify Sellercraft information' })
+  async updateSellercraft(
+    @Arg('id') id: string,
+    @Arg('patch') patch: SellercraftPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Sellercraft> {
+    const { user, tx } = context.state
+
+    const repository = tx.getRepository(Sellercraft)
+    const sellercraft = await repository.findOneBy({ id })
+
+    return await repository.save({
+      ...sellercraft,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Sellercraft], { description: "To modify multiple Sellercrafts' information" })
+  async updateMultipleSellercraft(
+    @Arg('patches', type => [SellercraftPatch]) patches: SellercraftPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Sellercraft[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const sellercraftRepo = tx.getRepository(Sellercraft)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await sellercraftRepo.save({
+          ...newRecord,
+          domain,
+          name: uuidv4(),
+          status: SellercraftStatus.ACTIVE,
+          platform: SellercraftPlatform.SELLERCRAFT,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const sellercraft = await sellercraftRepo.findOneBy({ id: newRecord.id })
+
+        const result = await sellercraftRepo.save({
+          ...sellercraft,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Sellercraft' })
+  async deleteSellercraft(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    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: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx, user } = context.state
+    let sellercrafts: Sellercraft[] = await tx
+      .getRepository(Sellercraft)
+      .find({ where: { domain: { id: domain.id }, id: In(ids) } })
+
+    sellercrafts = sellercrafts.map((sellercraft: Sellercraft) => {
+      return {
+        ...sellercraft,
+        status: SellercraftStatus.TERMINATED,
+        updater: user
+      }
+    })
+
+    await tx.getRepository(Sellercraft).save(sellercrafts)
+    return true
+  }
+}

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

@@ -0,0 +1,43 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
+
+import { Sellercraft } from './sellercraft'
+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: ResolverContext): Promise<Sellercraft> {
+    return await getRepository(Sellercraft).findOneBy({ id })
+  }
+
+  @Query(returns => SellercraftList, { description: 'To fetch multiple Sellercrafts' })
+  async sellercrafts(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<SellercraftList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, { domain })
+    const [items, total] = await getRepository(Sellercraft).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() sellercraft: Sellercraft): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: sellercraft.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() sellercraft: Sellercraft): Promise<User> {
+    return await getRepository(User).findOneBy({ id: sellercraft.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() sellercraft: Sellercraft): Promise<User> {
+    return await getRepository(User).findOneBy({ id: sellercraft.creatorId })
+  }
+}

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

@@ -0,0 +1,54 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Sellercraft, SellercraftPlatform, SellercraftStatus } from './sellercraft'
+
+@InputType()
+export class NewSellercraft {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => SellercraftPlatform, { nullable: true })
+  platform: SellercraftPlatform
+
+  @Field()
+  accountId: string
+
+  @Field(type => SellercraftStatus, { nullable: true })
+  status?: SellercraftStatus
+}
+
+@InputType()
+export class SellercraftPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => SellercraftPlatform, { nullable: true })
+  platform?: SellercraftPlatform
+
+  @Field({ nullable: true })
+  accountId?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => SellercraftStatus, { nullable: true })
+  status?: SellercraftStatus
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class SellercraftList {
+  @Field(type => [Sellercraft])
+  items: Sellercraft[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/sellercraft/sellercraft.ts

@@ -0,0 +1,96 @@
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, ScalarObject } from '@things-factory/shell'
+
+export enum SellercraftStatus {
+  ACTIVE = 'ACTIVE',
+  INACTIVE = 'INACTIVE',
+  TERMINATED = 'TERMINATED'
+}
+
+registerEnumType(SellercraftStatus, {
+  name: 'SellercraftStatus',
+  description: 'state enumeration of a sellercraft'
+})
+
+export enum SellercraftPlatform {
+  SELLERCRAFT = 'SELLERCRAFT'
+}
+
+registerEnumType(SellercraftPlatform, {
+  name: 'SellercraftPlatform',
+  description: 'platform enumeration of a sellercraft'
+})
+
+@Entity()
+@Index('ix_sellercraft_0', (sellercraft: Sellercraft) => [sellercraft.domain, sellercraft.name], { unique: true })
+@ObjectType({ description: 'Entity for Sellercraft' })
+export class Sellercraft {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((sellercraft: Sellercraft) => sellercraft.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column()
+  @Field()
+  accountId: string
+
+  @Column()
+  @Field()
+  platform: SellercraftPlatform
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  status?: SellercraftStatus
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  sellercraftSetting?: object
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((sellercraft: Sellercraft) => sellercraft.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((sellercraft: Sellercraft) => sellercraft.updater)
+  updaterId?: string
+}