@things-factory/integration-sellercraft 5.0.0-alpha.5 → 5.0.0-alpha.52

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

@@ -0,0 +1,418 @@
+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 { 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(
+    @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 channels: MarketplaceChannel[] = await getRepository(MarketplaceChannel).find({ where: { isActive: true } })
+
+    for (var i = 0; i < channels.length; i++) {
+      try {
+        const channel: MarketplaceChannel = channels[i]
+        let shops: any = await getShops(channel.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: channel.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
+
+            let orderResult = []
+            let page: number = store.platform == 'magento' ? 1 : 0
+            let hasMorePage: boolean = true
+            let lastOrderId: string
+            let cursor: string
+            var limit: number = 50
+
+            while (hasMorePage) {
+              const {
+                results: marketplaceOrders,
+                more,
+                nextCursor
+              } = await StoreAPI.getStoreOrders(store, {
+                fromCreatedDate,
+                toCreatedDate,
+                fromUpdatedDate,
+                toUpdatedDate,
+                pagination: { page, limit },
+                lastOrderId,
+                nextCursor: cursor
+              })
+
+              orderResult.push(...marketplaceOrders)
+
+              if (more) page++
+              hasMorePage = more
+              cursor = nextCursor
+            }
+
+            var sellercraftStore = { ...store, platform: 'sellercraftChannelIntegration' }
+
+            let mappedOrderResult = orderResult.map(order => {
+              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
+
+              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 orderPackage = order?.orderPackage || {}
+
+              let orderItems = order.orderItems.map(item => {
+                let {
+                  name: id,
+                  variationId: variationId,
+                  slaExpiresAt,
+                  total,
+                  totalTax,
+                  subtotal,
+                  subtotalTax,
+                  qty
+                } = item
+
+                return {
+                  id,
+                  variationId,
+                  currency: order.orderShipping.collectionCurrency,
+                  createdAt: order.orderCreatedAt,
+                  updatedAt: order.orderUpdatedAt,
+                  charges: [
+                    {
+                      name: 'CHARGES_MARKETING',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'CLAIMS_DAMAGE',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'CLAIMS_LOST',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'COMMISSION_PLATFORM',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'DEPOSIT_PRESALE',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'FEE_MISCELLANEOUS',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'FEE_TRANSACTION',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'PRICE_NORMAL_SELLING',
+                      grossAmount: total,
+                      nettAmount: subtotal
+                    },
+                    {
+                      name: 'PRICE_RECOMMENDED_RETAIL',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'PROMOTIONS_CUSTOMER_RECEIVED',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'PROMOTIONS_REBATE_PLATFORM',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'PROMOTIONS_REBATE_SELLER',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'REVERSAL_CHARGES_MARKETING',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'REVERSAL_COMMISSION',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'REVERSAL_FEE_MISCELLANEOUS',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'REVERSAL_PROMOTIONS_CUSTOMER_RECEIVED',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'REVERSAL_SELLER_RETURN_REFUND_AMOUNT',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'REVERSAL_SHIPPING_CUSTOMER_PAID',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'REVERSAL_SHIPPING_REBATE_PLATFORM',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'REVERSAL_SHIPPING_SELLER_PAID',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'SHIPPING_COST_TOTAL',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'SHIPPING_CUSTOMER_PAID',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'SHIPPING_REBATE_PLATFORM',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'SHIPPING_SELLER_PAID',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'TAXES',
+                      grossAmount: totalTax,
+                      nettAmount: subtotalTax
+                    },
+                    {
+                      name: 'VOUCHERS_CUSTOMER_RECEIVED',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'VOUCHERS_REBATE_PLATFORM',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    },
+                    {
+                      name: 'VOUCHERS_REBATE_SELLER',
+                      grossAmount: 0,
+                      nettAmount: 0
+                    }
+                  ],
+                  slaExpiresAt,
+                  qty
+                }
+              })
+
+              let mappedOrderItems = []
+              orderItems.map(oi => {
+                for (let i = 0; i < oi.qty; i++) {
+                  mappedOrderItems.push({
+                    ...oi,
+                    id: `${oi.id}-${i + 1}`
+                  })
+                }
+              })
+
+              return {
+                custFirstName,
+                custLastName,
+                createdAt,
+                updatedAt,
+                id,
+                billFirstName,
+                billLastName,
+                billAddress1: billAddress1.toString() || shipAddress1.toString(),
+                billAddress2: billAddress2 || shipAddress2,
+                billAddress3: billAddress3 || shipAddress3,
+                billAddress4: billAddress4 || shipAddress4,
+                billAddress5: billAddress5 || shipAddress5,
+                billCity: billCity || shipCity,
+                billPostalCode: billPostalCode || shipPostalCode,
+                billCountry: billCountry || shipCountry,
+                billPhone1: billPhone1 || shipPhone1,
+                billPhone2: billPhone2 || shipPhone2,
+                shipFirstName,
+                shipLastName,
+                shipAddress1: shipAddress1.toString(),
+                shipAddress2,
+                shipAddress3,
+                shipAddress4,
+                shipAddress5,
+                shipCity,
+                shipPostalCode,
+                shipCountry,
+                shipPhone1,
+                shipPhone2,
+                mappedOrderItems,
+                channelShopId,
+                organisationId,
+                status: sellercraftStatus || status,
+                isSOF: isSOF ? isSOF : false,
+                orderPackage,
+                charges: getOrderCharges(mappedOrderItems)
+              }
+            })
+
+            if (mappedOrderResult.length > 0) {
+              while (mappedOrderResult.length > 0) {
+                let spliceResult = mappedOrderResult.splice(
+                  0,
+                  mappedOrderResult.length >= 20 ? 20 : mappedOrderResult.length
+                )
+
+                try {
+                  await SellercraftChannelIntegrationAPI.ingestChannelOrder(sellercraftStore, {
+                    orders: spliceResult
+                  })
+                } catch (e) {}
+
+                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) {}
+        }
+      } catch (e) {}
+    }
+    return true
+  }
+}
+
+function getOrderCharges(mappedOrderItems) {
+  let chargesList = []
+
+  for (let i = 0; i < mappedOrderItems.length; i++) {
+    for (let j = 0; j < mappedOrderItems[i].charges.length; j++) {
+      let charge = mappedOrderItems[i].charges[j]
+      let foundCharge = chargesList.find(cl => cl.name == charge.name)
+      if (foundCharge) {
+        foundCharge.grossAmount = parseFloat(foundCharge.grossAmount) + parseFloat(charge.grossAmount)
+        foundCharge.nettAmount = parseFloat(foundCharge.nettAmount) + parseFloat(charge.nettAmount)
+        chargesList = chargesList.filter(cl => cl.name != charge.name)
+      } else {
+        foundCharge = {
+          name: charge.name,
+          grossAmount: charge.grossAmount,
+          nettAmount: charge.nettAmount
+        }
+      }
+      chargesList.push(foundCharge)
+    }
+  }
+  return chargesList
+}

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

@@ -0,0 +1,221 @@
+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 { 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,
+    @Arg('fromUpdatedDate', { nullable: true }) fromUpdatedDate?: string,
+    @Arg('toUpdatedDate', { nullable: true }) toUpdatedDate?: string
+  ): Promise<boolean> {
+    const sellercraftChannelIntegrationConfig = config.get('sellercraftChannelIntegrationConfig', {})
+
+    const channels: MarketplaceChannel[] = await getRepository(MarketplaceChannel).find({ where: { isActive: true } })
+
+    for (var i = 0; i < channels.length; i++) {
+      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)
+            }
+
+            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) {}
+
+            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/marketplace-channel/marketplace-channel.ts

@@ -0,0 +1,68 @@
+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
+
+  @Column({ default: true })
+  @Field()
+  isActive: boolean
+
+  @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
+}