@things-factory/operato-hub 6.1.83 → 6.1.85

package/server/graphql/resolvers/synchronization/auto-update-all-marketplace-product-variation-quantity.ts

@@ -1,180 +0,0 @@
-import { getConnection, getRepository } from 'typeorm'
-
-import { logger } from '@things-factory/env'
-import { FulfillmentAPI } from '@things-factory/integration-fulfillment'
-import { MarketplaceSetting, MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
-import { MarketplaceProductVariation } from '@things-factory/marketplace-base'
-import { Product, ProductDetail } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
-import { getProductBundleInventory, Inventory, INVENTORY_STATUS, LOCATION_TYPE } from '@things-factory/warehouse-base'
-
-export const autoUpdateAllMarketplaceProductVariationQuantityResolver = {
-  async autoUpdateAllMarketplaceProductVariationQuantity(_: any, { companyDomainId, warehouseId }, context: any) {
-    const companyDomain: Domain = await getRepository(Domain).findOne(companyDomainId)
-
-    const marketplaceStores: MarketplaceStore[] = await getRepository(MarketplaceStore).find({
-      where: { domain: { id: companyDomain.id }, status: 'ACTIVE' },
-      relations: ['marketplaceDistributors']
-    })
-
-    const fulfilmentCenter = await FulfillmentAPI.getFulfillmentCenter(warehouseId)
-    const centerId: string = fulfilmentCenter.centerId
-    const warehouseDomain: Domain = await getRepository(Domain).findOne({ where: { subdomain: centerId } })
-
-    let products: Product[] = await getRepository(Product).find({
-      where: { domain: { id: companyDomain.id } },
-      relations: ['productDetails']
-    })
-
-    let inventoryProducts: any[] = await Promise.all(
-      products.map(async product => {
-        const productDetails: ProductDetail[] = product.productDetails
-        const defaultProductDetail: ProductDetail = productDetails.filter(productDetail => productDetail.isDefault)[0]
-
-        let qb = await getRepository(Inventory).createQueryBuilder('inv')
-        qb.leftJoinAndSelect('inv.location', 'loc')
-          .andWhere('"inv"."domain_id" = :domainId')
-          .andWhere('"inv"."product_id" = :productId')
-          .andWhere('"inv"."status" != :status')
-          .andWhere('"loc"."type" NOT IN (:...locationTypes)')
-          .setParameters({
-            domainId: warehouseDomain.id,
-            productId: product.id,
-            status: INVENTORY_STATUS.TERMINATED,
-            locationTypes: [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
-          })
-
-        let inventories: Inventory[] = await qb.getMany()
-
-        const inventoryQty: number = inventories.reduce((total, currentValue) => {
-          total += currentValue.qty
-          return total
-        }, 0)
-
-        const inventoryLockedQty: number = inventories.reduce((total, currentValue) => {
-          total += currentValue.lockedQty
-          return total
-        }, 0)
-
-        return {
-          product,
-          sku: product.sku,
-          name: product.name,
-          packingType: defaultProductDetail.packingType,
-          packingSize: defaultProductDetail.packingSize,
-          uom: defaultProductDetail.uom,
-          qty: inventoryQty - inventoryLockedQty
-        }
-      })
-    )
-
-    await getConnection().transaction(async tx => {
-      let bundleProductInventories: any[] = await getProductBundleInventory(
-        warehouseDomain,
-        companyDomain,
-        inventoryProducts,
-        tx
-      )
-
-      bundleProductInventories.map(bundleProductInventory => {
-        inventoryProducts.push(bundleProductInventory)
-      })
-    })
-
-    for (let i = 0; i < marketplaceStores.length; i++) {
-      try {
-        const marketplaceStore: MarketplaceStore = marketplaceStores[i]
-
-        const marketplaceSetting: MarketplaceSetting = await getRepository(MarketplaceSetting).findOne({
-          where: { marketplaceStore: { id: marketplaceStore.id }, category: 'stock_allocation' }
-        })
-
-        for (let j = 0; j < inventoryProducts.length; j++) {
-          try {
-            await getConnection().transaction(async tx => {
-              const inventoryProduct = inventoryProducts[j]
-              const marketplaceProductVariations: MarketplaceProductVariation[] = await tx
-                .getRepository(MarketplaceProductVariation)
-                .find({
-                  where: { domain: { id: companyDomain.id }, sku: inventoryProduct.sku },
-                  relations: ['marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-                })
-
-              let storeProductVariations: MarketplaceProductVariation[] = marketplaceProductVariations.filter(
-                productVariation => productVariation.marketplaceProduct.marketplaceStore.id === marketplaceStore.id
-              )
-
-              let percentageValue: number = 100
-              if (storeProductVariations) {
-                for (let k = 0; k < storeProductVariations.length; k++) {
-                  let storeProductVariation: MarketplaceProductVariation = storeProductVariations[k]
-                  if (marketplaceSetting) {
-                    percentageValue = parseInt(marketplaceSetting.value)
-                  }
-
-                  let remainQty: number = Math.floor(
-                    (inventoryProduct.qty - storeProductVariation.reserveQty) * (percentageValue / 100)
-                  )
-                  if (remainQty < 0) remainQty = 0
-
-                  let productVariationLocationId = storeProductVariation?.locationId
-                  let adjustQty: number = remainQty
-
-                  if (marketplaceStore.platform === 'shopify') {
-                    let locationIds: any[] = JSON.parse(productVariationLocationId)
-                    adjustQty = adjustQty - storeProductVariation.qty
-                    if (locationIds[0]?.location_id) productVariationLocationId = locationIds[0].location_id
-                  }
-
-                  let validMarketplaceDistributors: any[] = []
-                  if (marketplaceStore.marketplaceDistributors) {
-                    validMarketplaceDistributors = marketplaceStore.marketplaceDistributors.filter(
-                      distributor => distributor.status === 'ACTIVE'
-                    )
-                  }
-
-                  const hasVariation: boolean = storeProductVariation?.marketplaceProduct?.hasVariation
-
-                  if (hasVariation) {
-                    await StoreAPI.updateStoreProductVariationStock(marketplaceStore, [
-                      {
-                        itemId: storeProductVariation.marketplaceProduct.itemId,
-                        variationId: storeProductVariation.variationId,
-                        variationSku: storeProductVariation.variationSku,
-                        qty: adjustQty,
-                        locationId: productVariationLocationId,
-                        inventoryItemId: storeProductVariation.inventoryItemId,
-                        distributors: validMarketplaceDistributors
-                      }
-                    ])
-                  } else {
-                    await StoreAPI.updateStoreProductStock(marketplaceStore, [
-                      {
-                        itemId: storeProductVariation.marketplaceProduct.itemId,
-                        variationId: storeProductVariation.variationId,
-                        variationSku: storeProductVariation.variationSku,
-                        qty: adjustQty,
-                        distributors: validMarketplaceDistributors
-                      }
-                    ])
-                  }
-
-                  storeProductVariation.qty = remainQty
-                  await tx.getRepository(MarketplaceProductVariation).save(storeProductVariation)
-                }
-              }
-            })
-          } catch (error) {
-            logger.error(
-              `interface-with-hub[autoUpdateAllMarketplaceProductVariationQuantity]inventoryProducts: ${error}`
-            )
-          }
-        }
-      } catch (e) {
-        logger.error(`interface-with-hub[autoUpdateAllMarketplaceProductVariationQuantity]marketplaceStores: ${e}`)
-      }
-    }
-
-    return true
-  }
-}

package/server/graphql/resolvers/synchronization/create-dat-shipments.ts

@@ -1,64 +0,0 @@
-import { getConnection, MoreThan } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-import { logger } from '@things-factory/env'
-import { Sftp, SftpAPI } from '@things-factory/integration-sftp'
-import { ReleaseGood } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-
-export const createDatShipments = {
-  async createDatShipments(_: void, {}, context: ResolverContext): Promise<void> {
-    try {
-      await getConnection().transaction(async tx => {
-        const currentTime = new Date()
-        const batchSize = 80
-        let sftps: Sftp[] = await tx.getRepository(Sftp).find({
-          where: { status: 'ACTIVE' },
-          relations: ['domain', 'fulfillmentCenter']
-        })
-
-        for (let sftp of sftps) {
-          let warehouseDomain: Domain = await tx.getRepository(Domain).findOne({
-            where: { subdomain: sftp.fulfillmentCenter.centerId }
-          })
-
-          let bizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
-            where: { domain: { id: sftp.domain.id } }
-          })
-
-          let releaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
-            where: {
-              domain: { id: warehouseDomain.id },
-              bizplace: { id: bizplace.id },
-              status: 'DONE',
-              updatedAt: MoreThan(sftp.lastTimeSync)
-            },
-            relations: ['orderInventories', 'orderInventories.product']
-          })
-
-          while (releaseGoods.length > 0) {
-            let releaseGoodBatch = releaseGoods.splice(
-              0,
-              releaseGoods.length >= batchSize ? batchSize : releaseGoods.length
-            )
-
-            const responseFileTypes: any = JSON.parse(sftp.responseFileTypes)
-
-            if (releaseGoodBatch.length > 0) {
-              if (responseFileTypes.enableShipment) {
-                let shipmentResult: Sftp = await SftpAPI.createShipment(sftp, {
-                  releaseGoods: releaseGoodBatch,
-                  sftp: sftp
-                })
-                shipmentResult.lastTimeSync = currentTime
-                sftp = await tx.getRepository(Sftp).save(shipmentResult)
-              }
-            }
-          }
-        }
-      })
-    } catch (e) {
-      logger.error(`createDatShipment: ${e}`)
-    }
-  }
-}

package/server/graphql/resolvers/synchronization/fetch-sync-invoices.ts

@@ -1,52 +0,0 @@
-import { AccountingAPI } from '@things-factory/integration-accounting'
-import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
-
-export const fetchSyncInvoicesResolver = {
-  async fetchSyncInvoices(
-    _: void,
-    {
-      accountId,
-      warehouseId,
-      customerBizplaceId
-    }: {
-      accountId: string
-      warehouseId: string
-      customerBizplaceId: string
-    },
-    context: any
-  ): Promise<void> {
-    try {
-      await getAccountingInvoices(accountId, warehouseId, customerBizplaceId)
-      return
-    } catch (e) {
-      throw e
-    }
-  }
-}
-
-export async function getAccountingInvoices(accountId: string, warehouseId: string, customerBizplaceId: string) {
-  try {
-    const accounting: AccountingAPI = await AccountingAPI.getAccounting(accountId)
-
-    const fulfilmentCenter: FulfillmentCenter = await FulfillmentAPI.getFulfillmentCenter(warehouseId)
-    const invoices: any[] = await AccountingAPI.getInvoices(accounting, { Statuses: 'AUTHORISED' })
-
-    for (var i = 0; i < invoices.length; i++) {
-      const releaseOrder = invoices[i]
-
-      const existingReleaseOrder = await FulfillmentAPI.getOutboundOrder(fulfilmentCenter, {
-        customerBizplaceId,
-        refNo: releaseOrder.refNo
-      })
-
-      if (!existingReleaseOrder) {
-        await FulfillmentAPI.createOutboundOrder(fulfilmentCenter, {
-          customerBizplaceId,
-          releaseOrder
-        })
-      }
-    }
-  } catch (e) {
-    throw new Error(e.statusText)
-  }
-}

package/server/graphql/resolvers/synchronization/fetch-sync-products.ts

@@ -1,99 +0,0 @@
-import { Bizplace } from '@things-factory/biz-base'
-import { AccountingAPI } from '@things-factory/integration-accounting'
-import { Product } from '@things-factory/product-base'
-import { getRepository } from '@things-factory/shell'
-
-import { buildMap } from '../../../utils/build-map'
-
-export const fetchSyncProductsResolver = {
-  async fetchSyncProducts(
-    _: void,
-    {
-      accountId,
-      bizplaceId,
-      pagination
-    }: { accountId: string; bizplaceId: string; pagination: { page: number; limit: number } },
-    context: any
-  ): Promise<{ items: { bizplaceProduct: Product; platformProduct: Product }[]; total: number }> {
-    try {
-      const platformProducts: Product[] = await getAccountingProducts(accountId)
-      const platformProductsMap: Map<string, Product> = buildMap(platformProducts, 'sku')
-
-      const bizplace: Bizplace = await getRepository(Bizplace).findOneBy({ id: bizplaceId })
-      const bizplaceProducts: Product[] = await getRepository(Product).find({
-        where: { bizplace: { id: bizplace.id } }
-      })
-      const bizplaceProductsMap: Map<string, Product> = buildMap(bizplaceProducts, 'sku')
-
-      let items: { bizplaceProduct: Product; platformProduct: Product }[] = []
-
-      if (platformProductsMap.size) {
-        platformProductsMap.forEach((platformProduct: Product) => {
-          const { sku }: Product = platformProduct
-
-          let bizplaceProduct: Product = {}
-
-          if (bizplaceProductsMap.has(sku)) {
-            bizplaceProduct = bizplaceProductsMap.get(sku)
-            bizplaceProductsMap.delete(sku)
-          }
-
-          platformProductsMap.delete(sku)
-
-          items.push({
-            bizplaceProduct,
-            platformProduct
-          })
-        })
-      }
-
-      if (bizplaceProductsMap.size) {
-        bizplaceProductsMap.forEach((bizplaceProduct: Product) => {
-          const { sku }: Product = bizplaceProduct
-
-          let platformProduct: Product = {}
-
-          if (platformProductsMap.has(sku)) {
-            platformProduct = platformProductsMap.get(sku)
-            platformProductsMap.delete(sku)
-          }
-
-          bizplaceProductsMap.delete(sku)
-
-          items.push({
-            bizplaceProduct,
-            platformProduct
-          })
-        })
-      }
-
-      const { page, limit }: { page: number; limit: number } = pagination
-      const startIdx: number = (page - 1) * limit
-      const endIdx: number = page * limit
-
-      const total = items.length
-      items = items.slice(startIdx, endIdx)
-
-      return { items, total }
-    } catch (e) {
-      throw e
-    }
-  }
-}
-
-function sortBySku(products: Product[]): Product[] {
-  return products.sort((a: Product, b: Product) => {
-    if (a.sku > b.sku) return 1
-    if (a.sku < b.sku) return -1
-    return 0
-  })
-}
-
-export async function getAccountingProducts(accountId: string): Promise<Product[]> {
-  try {
-    const accounting: AccountingAPI = await AccountingAPI.getAccounting(accountId)
-    return await AccountingAPI.getItems(accounting)
-  } catch (e) {
-    throw new Error(e.statusText)
-  }
-}

package/server/graphql/resolvers/synchronization/fetch-sync-purchase-orders.ts

@@ -1,75 +0,0 @@
-import { AccountingAPI } from '@things-factory/integration-accounting'
-import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
-import { logger } from '@things-factory/env'
-
-export const fetchSyncPurchaseOrdersResolver = {
-  async fetchSyncPurchaseOrders(
-    _: void,
-    {
-      accountId,
-      warehouseId,
-      customerBizplaceId,
-      fromDate,
-      toDate
-    }: { accountId: string; warehouseId: string; customerBizplaceId: string; fromDate: string; toDate: string },
-    context: any
-  ): Promise<void> {
-    try {
-      await getAccountingPurchaseOrders(accountId, warehouseId, customerBizplaceId, fromDate, toDate)
-    } catch (e) {
-      logger.error(`Xero: fetchSyncPurchaseOrders: ${e}`)
-    }
-  }
-}
-
-export async function getAccountingPurchaseOrders(
-  accountId: string,
-  warehouseId: string,
-  customerBizplaceId: string,
-  fromDate: string,
-  toDate: string
-) {
-  try {
-    const accounting: AccountingAPI = await AccountingAPI.getAccounting(accountId)
-
-    const fulfilmentCenter: FulfillmentCenter = await FulfillmentAPI.getFulfillmentCenter(warehouseId)
-    let parameters: any = { status: 'AUTHORISED' }
-
-    if (fromDate) {
-      if (!toDate) throw new Error('From Date setting requires To Date')
-      parameters = { ...parameters, DateFrom: fromDate, DateTo: toDate }
-    }
-
-    const purchaseOrders: any[] = await AccountingAPI.getPurchaseOrders(accounting, { ...parameters })
-    await createInboundOrder(fulfilmentCenter, purchaseOrders, customerBizplaceId)
-  } catch (e) {
-    logger.error(`Xero: getAccountingPurchaseOrders: ${e}`)
-  }
-}
-
-export async function createInboundOrder(
-  fulfilmentCenter: FulfillmentCenter,
-  purchaseOrders: any[],
-  customerBizplaceId: string
-) {
-  for (var i = 0; i < purchaseOrders.length; i++) {
-    try {
-      const purchaseOrder = purchaseOrders[i]
-
-      const existingArrivalNotice = await FulfillmentAPI.getInboundOrder(fulfilmentCenter, {
-        customerBizplaceId,
-        refNo: purchaseOrder.refNo,
-        ganNo: null
-      })
-
-      if (!existingArrivalNotice?.id) {
-        await FulfillmentAPI.createInboundOrder(fulfilmentCenter, {
-          customerBizplaceId,
-          purchaseOrder
-        })
-      }
-    } catch (e) {
-      logger.error(`Xero: createInboundOrder: ${e}`)
-    }
-  }
-}

package/server/graphql/resolvers/synchronization/index.ts

@@ -1,26 +0,0 @@
-import { fetchSyncInvoicesResolver } from './fetch-sync-invoices'
-import { fetchSyncProductsResolver } from './fetch-sync-products'
-import { fetchSyncPurchaseOrdersResolver } from './fetch-sync-purchase-orders'
-import { sellercraftPackMarketplaceOrderResolver } from './sellercraft-pack-marketplace-order'
-import { syncAllProductsToSellercraftResolver } from './sync-all-products-to-sellercraft'
-import { syncProductsFromAccountResolver } from './sync-products-from-account'
-import { syncProductsToAccountResolver } from './sync-products-to-account'
-import { syncProductsToSellercraftResolver } from './sync-products-to-sellercraft'
-import { createDatShipments } from './create-dat-shipments'
-import { autoUpdateAllMarketplaceProductVariationQuantityResolver } from './auto-update-all-marketplace-product-variation-quantity'
-
-export const Query = {
-  ...fetchSyncProductsResolver,
-  ...fetchSyncPurchaseOrdersResolver,
-  ...fetchSyncInvoicesResolver
-}
-
-export const Mutation = {
-  ...syncProductsToSellercraftResolver,
-  ...syncProductsFromAccountResolver,
-  ...syncProductsToAccountResolver,
-  ...syncAllProductsToSellercraftResolver,
-  ...sellercraftPackMarketplaceOrderResolver,
-  ...createDatShipments,
-  ...autoUpdateAllMarketplaceProductVariationQuantityResolver
-}

package/server/graphql/resolvers/synchronization/sellercraft-pack-marketplace-order.ts

@@ -1,91 +0,0 @@
-import { getConnection, In, IsNull, Not, Repository } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-import { logger } from '@things-factory/env'
-import { createPayloadLog, PayloadType } from '@things-factory/integration-base'
-import { Sellercraft, SellercraftAPI, SellercraftStatus } from '@things-factory/integration-sellercraft'
-import { Product } from '@things-factory/product-base'
-import { ORDER_STATUS, OrderProduct, ReleaseGood } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-
-export const sellercraftPackMarketplaceOrderResolver = {
-  async sellercraftPackMarketplaceOrder(_: void, {}, context: ResolverContext): Promise<void> {
-    try {
-      await getConnection().transaction(async tx => {
-        const sellercrafts: Sellercraft[] = await tx
-          .getRepository(Sellercraft)
-          .find({ where: { status: SellercraftStatus.ACTIVE }, relations: ['domain'] })
-
-        for (const sellercraft of sellercrafts) {
-          try {
-            const sellercraftDomain: Domain = sellercraft.domain
-            const bizplace: Bizplace = await tx
-              .getRepository(Bizplace)
-              .findOne({ where: { domain: { id: sellercraftDomain.id } } })
-
-            let releaseGoodsWithoutPackageId: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
-              where: {
-                bizplace: { id: bizplace.id },
-                type: 'b2c',
-                packageId: IsNull(),
-                status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL, ORDER_STATUS.DONE]))
-              },
-              relations: ['domain', 'orderProducts', 'orderProducts.product']
-            })
-
-            if (releaseGoodsWithoutPackageId?.length > 0) {
-              await Promise.all(
-                releaseGoodsWithoutPackageId.map(async releaseGood => {
-                  const orderProducts: OrderProduct[] = releaseGood.orderProducts
-                  let sellercraftOPs: any[] = []
-
-                  sellercraftOPs = orderProducts.map(orderProduct => {
-                    const product: Product = orderProduct.product
-
-                    return {
-                      sku: product.sku,
-                      releaseQty: orderProduct.releaseQty,
-                      uom: 'EA'
-                    }
-                  })
-
-                  const orderInformation: any = {
-                    accountId: sellercraft.accountId,
-                    orderId: releaseGood.refNo2,
-                    sellercraftOPs
-                  }
-
-                  const packageId: string = await SellercraftAPI.packMarketplaceOrder(sellercraft, {
-                    ...orderInformation,
-                    context: { state: { domain: releaseGood?.domain, user: null } }
-                  })
-
-                  createPayloadLog(
-                    sellercraft.accountId,
-                    `/order/pack`,
-                    orderInformation,
-                    packageId,
-                    context,
-                    PayloadType.EGESTION,
-                    'scheduler'
-                  )
-
-                  if (packageId) {
-                    await (tx.getRepository(ReleaseGood) as Repository<ReleaseGood>).update(
-                      { id: releaseGood.id },
-                      { packageId: packageId }
-                    )
-                  }
-                })
-              )
-            }
-          } catch (e) {
-            logger.error(`sellercraftPackMarketplaceOrder: ${e}`)
-          }
-        }
-      })
-    } catch (e) {
-      logger.error(`sellercraftPackMarketplaceOrder: ${e}`)
-    }
-  }
-}

package/server/graphql/resolvers/synchronization/sync-all-products-to-sellercraft.ts

@@ -1,39 +0,0 @@
-import { getConnection } from 'typeorm'
-
-import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
-import { FulfillmentCenter } from '@things-factory/integration-fulfillment'
-import { Sellercraft } from '@things-factory/integration-sellercraft'
-
-import { syncProductsToSellercraftResolver as resolver } from './sync-products-to-sellercraft'
-
-export const syncAllProductsToSellercraftResolver = {
-  async syncAllProductsToSellercraft(_: any, {}, context: ResolverContext): Promise<void> {
-    const { user } = context.state
-    try {
-      await getConnection().transaction(async tx => {
-        const qb = await tx
-          .getRepository(Sellercraft)
-          .createQueryBuilder('sellercraft')
-          .innerJoinAndSelect('sellercraft.domain', 'domain')
-          .innerJoinAndSelect(Bizplace, 'bizplace', 'bizplace.domain_id = domain.id')
-          .where('sellercraft.status = :status', { status: 'ACTIVE' })
-
-        const sellercrafts: Sellercraft[] = await qb.getRawMany()
-
-        for (const sellercraft of sellercrafts) {
-          const companyBizplace: Bizplace = await getCompanyBizplace(null, null, sellercraft.bizplace_id, tx)
-          const fulfillmentCenter: FulfillmentCenter = await tx.getRepository(FulfillmentCenter).find({
-            where: { domain: { id: companyBizplace.domain.id } }
-          })
-          await resolver.syncProductsToSellercraft(
-            null,
-            { sellercraftId: sellercraft.id, fulfillmentCenterId: fulfillmentCenter.id, toCreateSku: false },
-            context
-          )
-        }
-      })
-    } catch (e) {
-      console.log(e)
-    }
-  }
-}

package/server/graphql/resolvers/synchronization/sync-products-from-account.ts

@@ -1,40 +0,0 @@
-import { Bizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-
-import { buildMap } from '../../../utils/build-map'
-import { getAccountingProducts } from './fetch-sync-products'
-
-export const syncProductsFromAccountResolver = {
-  async syncProductsFromAccount(
-    _: void,
-    { accountId, bizplaceId }: { accountId: string; bizplaceId: string },
-    context: ResolverContext
-  ): Promise<void> {
-    try {
-      const { tx } = context.state
-      let platformProducts: Product[] = await getAccountingProducts(accountId)
-      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({ id: bizplaceId })
-      const platformProductsMap: Map<string, Product> = buildMap(platformProducts, 'sku')
-
-      let bizplaceProducts: Product[] = await tx
-        .getRepository(Product)
-        .find({ where: { bizplace: { id: bizplace.id } } })
-
-      const updateTargetProducts: Product[] = bizplaceProducts
-        .filter(({ sku }: Product) => platformProductsMap.has(sku))
-        .map((bizplaceProduct: Product) => {
-          const platformProduct: Product = platformProductsMap.get(bizplaceProduct.sku)
-
-          Object.keys(platformProduct).forEach((key: string) => {
-            bizplaceProduct[key] = platformProduct[key] === undefined ? null : platformProduct[key]
-          })
-
-          return bizplaceProduct
-        })
-
-      await tx.getRepository(Product).save(updateTargetProducts, { chunk: 500 })
-    } catch (e) {
-      throw e
-    }
-  }
-}