@things-factory/integration-sellercraft 8.0.0-beta.0 → 8.0.0-beta.2

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

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

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

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

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

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

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

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