@things-factory/integration-sellercraft 5.0.0-alpha.2 → 5.0.0-alpha.22

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

@@ -0,0 +1,6 @@
+import { MarketplaceChannel } from './marketplace-channel'
+import { MarketplaceChannelOrderMutation } from './marketplace-channel-order-mutation'
+import { MarketplaceChannelProductMutation } from './marketplace-channel-product-mutation'
+
+export const entities = [MarketplaceChannel]
+export const resolvers = [MarketplaceChannelOrderMutation, MarketplaceChannelProductMutation]

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

@@ -0,0 +1,182 @@
+import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { MarketplaceChannel } from './marketplace-channel'
+
+import { config } from '@things-factory/env'
+import { StoreAPI } from '@things-factory/integration-marketplace'
+import { SellercraftChannelIntegrationAPI } from '../../controllers/sellercraft-channel-integration-api'
+
+@Resolver()
+export class MarketplaceChannelOrderMutation {
+  @Mutation(returns => Boolean)
+  async syncAllMarketplaceChannelOrders(
+    @Arg('fromDate') fromDate: string,
+    @Arg('toDate') toDate: string,
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const sellercraftChannelIntegrationConfig = config.get('sellercraftChannelIntegrationConfig', {})
+    const { tokenCraftApiKey: apiKey, getShopsTokenCraftUrl } = sellercraftChannelIntegrationConfig
+
+    const channels: MarketplaceChannel[] = await getRepository(MarketplaceChannel).find()
+
+    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
+        }
+
+        // let countryCode = shops[j].country_code
+        // let channelCode = shops[j].org_prefix
+        let organisationId = shops[j].credential.account_id
+        let channelShopId = shops[j].credential.channel_shop_id 
+
+        const orderReq = {
+          fromDate: fromDate,
+          toDate: toDate
+        }
+        const orderResult = await StoreAPI.getStoreOrders(store, orderReq)
+
+        var sellercraftStore = { ...store, platform: 'sellercraftChannelIntegration' }
+
+        let mappedOrderResult = orderResult.results.map(order => {
+          let {
+            firstName: custFirstName,
+            lastName: custLastName,
+            orderCreatedAt: createdAt,
+            orderUpdatedAt: updatedAt,
+            orderNo: id,
+            status
+          } = order
+
+          let {
+            first_name: billFirstName,
+            last_name: billLastName,
+            address_1: billAddress1,
+            address_2: billAddress2,
+            address_3: billAddress3,
+            address_4: billAddress4,
+            address_5: billAddress5,
+            city: billCity,
+            postcode: billPostalCode,
+            country: billCountry,
+            phone: billPhone1,
+            phone_2: billPhone2
+          } = order.billing
+
+          let {
+            first_name: shipFirstName,
+            last_name: shipLastName,
+            address_1: shipAddress1,
+            address_2: shipAddress2,
+            address_3: shipAddress3,
+            address_4: shipAddress4,
+            address_5: shipAddress5,
+            city: shipCity,
+            postcode: shipPostalCode,
+            country: shipCountry,
+            phone: shipPhone1,
+            phone_2: shipPhone2
+          } = order.shipping
+
+          let orderItems = order.orderItems.map(item => {
+            let { 
+              name: id,
+              variationId: variationId,
+              slaExpiresAt,
+              total,
+              totalTax,
+              subtotal,
+              subtotalTax
+            } = item
+
+            return {
+              id,
+              variationId,
+              currency: order.orderShipping.collectionCurrency,
+              createdAt: order.orderCreatedAt,
+              updatedAt: order.orderUpdatedAt,
+              charges: [
+                {
+                  name: 'PRICE_NORMAL_SELLING',
+                  grossAmount: total,
+                  nettAmount: subtotal
+                },
+                {
+                  name: 'TAXES',
+                  grossAmount: totalTax,
+                  nettAmount: subtotalTax
+                }
+              ],
+              slaExpiresAt
+            }
+          })
+
+          return {
+            custFirstName,
+            custLastName,
+            createdAt,
+            updatedAt,
+            id,
+            billFirstName,
+            billLastName,
+            billAddress1,
+            billAddress2,
+            billAddress3,
+            billAddress4,
+            billAddress5,
+            billCity,
+            billPostalCode,
+            billCountry,
+            billPhone1,
+            billPhone2,
+            shipFirstName,
+            shipLastName,
+            shipAddress1,
+            shipAddress2,
+            shipAddress3,
+            shipAddress4,
+            shipAddress5,
+            shipCity,
+            shipPostalCode,
+            shipCountry,
+            shipPhone1,
+            shipPhone2,
+            orderItems,
+            channelShopId,
+            organisationId,
+            status
+          }
+
+        })
+
+        if (mappedOrderResult.length > 0) {
+          const ingestOrder = await SellercraftChannelIntegrationAPI.ingestChannelOrder(
+            sellercraftStore,
+            { orders: mappedOrderResult }
+          )
+        }
+      }
+
+      return true
+    }
+  }
+}

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

@@ -0,0 +1,167 @@
+import { Ctx, Mutation, Resolver } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { MarketplaceChannel } from './marketplace-channel'
+
+import { config } from '@things-factory/env'
+import { StoreAPI } from '@things-factory/integration-marketplace'
+import { SellercraftChannelIntegrationAPI } from '../../controllers/sellercraft-channel-integration-api'
+
+@Resolver()
+export class MarketplaceChannelProductMutation {
+  @Mutation(returns => Boolean)
+  async syncAllMarketplaceChannelProducts(
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const sellercraftChannelIntegrationConfig = config.get('sellercraftChannelIntegrationConfig', {})
+    const { tokenCraftApiKey: apiKey, getShopsTokenCraftUrl } = sellercraftChannelIntegrationConfig
+
+    const channels: MarketplaceChannel[] = await getRepository(MarketplaceChannel).find()
+
+    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
+        }
+
+        let countryCode = shops[j].country_code
+        let channelCode = shops[j].org_prefix
+        let organisationId = shops[j].credential.account_id
+        let channelShopId = shops[j].credential.channel_shop_id 
+
+        var sellercraftStore = { ...store, platform: 'sellercraftChannelIntegration' }
+
+        const productResult = await StoreAPI.getStoreProducts(store, {})
+
+        const categoryResult = await StoreAPI.getStoreProductCategories(store, {})
+
+        let mappedProducts = productResult.results.map((item) => {
+          let {
+            categoryId,
+            itemId: productId,
+            name,
+            brand,
+            isVerified,
+            images,
+            attributes,
+            variations
+          } = item
+
+          variations = variations.map(variation => {
+            let {
+              variationSku,
+              variationId,
+              name,
+              isEnabled: isEnabled,
+              isEnabled: 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: stockReported,
+                name: `${name} - ${variationSku}`,
+                sku: variationSku,
+                productVersions: [{
+                  label: 'Default',
+                  packageLengthMM: length,
+                  packageWidthMM: width,
+                  packageHeightMM: height,
+                  packageWeightGram: weight,
+                  qty: 1
+                }]
+              }]
+            }
+          })
+
+          images = images.map(image => {
+            return {
+              url: image
+            }
+          })
+
+          return {
+            organisationId,
+            channelShopId: channelShopId,
+            channelCode: channels[i].channelCode,
+            channelCountry: shops[j].country_code,
+            categoryId,
+            productId,
+            name,
+            brand,
+            isVerified,
+            images,
+            attributes,
+            variations
+          }
+        })
+
+        let mappedCategories = categoryResult.results.map((category) => {
+          let {
+            id: categoryId,
+            name: categoryName,
+            parent,
+            isActive
+          } = category
+
+          return {
+            categoryId,
+            categoryName,
+            parent,
+            isLeaf: parent == 0 ? false : true,
+            isActive: isActive || true,
+            channelCode,
+            countryCode
+          }
+        })
+
+        mappedCategories.map((category) => {
+          category.childrenCategories = mappedCategories.filter(e => e.parent == category.categoryId )
+        })
+
+        const ingestCategory = await SellercraftChannelIntegrationAPI.ingestChannelCategories(sellercraftStore, { categories: mappedCategories})
+        
+        const ingestProduct = await SellercraftChannelIntegrationAPI.ingestChannelProduct(sellercraftStore, { products: mappedProducts })
+        
+      }
+
+      return true
+    }
+  }
+}

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

@@ -0,0 +1,64 @@
+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({ nullable: true })
+  domain?: Domain
+
+  @RelationId((marketplaceChannel: MarketplaceChannel) => marketplaceChannel.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column()
+  @Field()
+  channelCode: string
+
+  @Column()
+  @Field()
+  channelId: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((marketplaceChannel: MarketplaceChannel) => marketplaceChannel.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((marketplaceChannel: MarketplaceChannel) => marketplaceChannel.updater)
+  updaterId?: string
+}

package/server/service/sellercraft/sellercraft.ts

@@ -87,6 +87,6 @@ export class Sellercraft {
   @Field({ nullable: true })
   updater?: User
 
-  @RelationId((sellercraft: Sellercraft) => sellercraft.creator)
+  @RelationId((sellercraft: Sellercraft) => sellercraft.updater)
   updaterId?: string
 }