@things-factory/operato-mms 6.1.82 → 6.1.84

package/server/graphql/resolvers/interface-with-hub/auto-update-all-marketplace-product-variation-quantity.ts

@@ -1,184 +0,0 @@
-import { getConnection } 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, getRepository } 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: ResolverContext
-  ) {
-    const companyDomain: Domain = await getRepository(Domain).findOneBy({ id: 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/interface-with-hub/generate-replenishment-order.ts

@@ -1,32 +0,0 @@
-import { Bizplace, getSubdomainBizplace } from '@things-factory/biz-base'
-import { FulfillmentAPI } from '@things-factory/integration-fulfillment'
-import { StoreReplenishment } from '@things-factory/marketplace-base'
-
-export const generateReplenishmentOrderResolver = {
-  async generateReplenishmentOrder(
-    _: void,
-    { storeReplenishmentId, warehouseId }: { storeReplenishmentId: string; warehouseId: string },
-    context: ResolverContext
-  ): Promise<any> {
-    const { tx } = context.state
-
-    let storeReplenishment: StoreReplenishment = await tx.getRepository(StoreReplenishment).findOne({
-      where: { id: storeReplenishmentId },
-      relations: ['storeReplenishmentItems']
-    })
-
-    var fulfillmentCenter = await FulfillmentAPI.getFulfillmentCenter(warehouseId)
-    var centerId: string = fulfillmentCenter.centerId
-
-    var subdominBizplace: Bizplace = await getSubdomainBizplace(centerId)
-    var warehouseBizplaceId: string = subdominBizplace?.id
-
-    var arrivalNotice = await FulfillmentAPI.createInboundOrder(fulfillmentCenter, {
-      warehouseBizplaceId,
-      storeReplenishment
-    })
-
-    storeReplenishment.arrivalNoticeId = arrivalNotice.id
-    await tx.getRepository(StoreReplenishment).save(storeReplenishment)
-  }
-}

package/server/graphql/resolvers/interface-with-hub/index.ts

@@ -1,18 +0,0 @@
-import { addReleaseOrderResolver } from './add-release-order'
-import { autoAddReleaseOrderResolver } from './auto-add-release-order'
-import { autoUpdateAllMarketplaceProductVariationQuantityResolver } from './auto-update-all-marketplace-product-variation-quantity'
-import { generateReplenishmentOrderResolver } from './generate-replenishment-order'
-import { warehouseMarketplaceProduct, warehouseMarketplaceProductsResolver } from './warehouse-marketplace-products'
-
-export const Query = {
-  ...warehouseMarketplaceProductsResolver
-}
-
-export const Mutation = {
-  ...addReleaseOrderResolver,
-  ...autoAddReleaseOrderResolver,
-  ...generateReplenishmentOrderResolver,
-  ...autoUpdateAllMarketplaceProductVariationQuantityResolver
-}
-
-export { warehouseMarketplaceProduct }

package/server/graphql/resolvers/interface-with-hub/warehouse-marketplace-products.ts

@@ -1,247 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getCompanyBizplace, getMyBizplace } from '@things-factory/biz-base'
-import { Domain, ListParam } from '@things-factory/shell'
-
-export const warehouseMarketplaceProductsResolver = {
-  async warehouseMarketplaceProducts(_: any, params: ListParam, context: ResolverContext): Promise<any> {
-    try {
-      const { domain, user, tx } = context.state
-      return warehouseMarketplaceProduct(params, domain, user, tx)
-    } catch (error) {
-      throw error
-    }
-  }
-}
-
-export async function warehouseMarketplaceProduct(params: ListParam, domain: Domain, user: User, tx?: EntityManager) {
-  const productFilters = params.filters.filter(x => x.name == 'product_info')
-  const filters = params.filters.filter(x => x.name != 'product_info')
-
-  const companyBizplace: Bizplace = await getCompanyBizplace(domain, user)
-  const myBizplace: Bizplace = await getMyBizplace(domain, user)
-
-  params.filters = [...filters, { name: 'bizplace_id', operator: 'in', value: [companyBizplace.id, myBizplace.id] }]
-
-  const bizplaceIds: string = params.filters
-    .find((filter: any) => filter.name === 'bizplace_id')
-    .value.map((id: string) => `'${id}'`)
-    .join()
-
-  let productQuery = ''
-  if (productFilters && productFilters.length > 0) {
-    let productInfo = productFilters[0]
-    productQuery = ` AND (
-      Lower("Product"."sku") LIKE '${productInfo.value.toLowerCase()}'
-      OR Lower("Product"."name") LIKE '${productInfo.value.toLowerCase()}'
-      OR Lower("Product"."description") LIKE '${productInfo.value.toLowerCase()}')`
-  }
-
-  await tx.query(`
-    CREATE TEMP TABLE "temp_products" ON COMMIT DROP AS (
-      SELECT * FROM (
-        SELECT "Product"."id" AS "product_id", "Product"."sku" AS "product_sku", "Product"."name" AS "product_name", 
-        "Product"."description" AS "product_description", "Product"."creator_id", "Product"."updater_id", 
-        "Product"."bizplace_id" AS "product_bizplace_id", 'PRODUCT' AS "type" 
-        FROM products "Product" 
-        WHERE 1=1
-        AND "Product"."deleted_at" IS NULL 
-        AND "Product"."bizplace_id" IN (${bizplaceIds})
-        ${productQuery}
-      ) d1
-      UNION ALL
-      SELECT * FROM
-      (
-        SELECT "Product"."id" AS "product_id", "Product"."sku" AS "product_sku", "Product"."name" AS "product_name",
-        "Product"."description" AS "product_description", "Product"."creator_id", "Product"."updater_id", 
-        "Product"."bizplace_id" AS "product_bizplace_id", 'BUNDLE' AS "type" 
-        FROM product_bundles "Product" 
-        WHERE 1 = 1
-        AND "Product"."status" = 'ACTIVATED'
-        AND "Product"."bizplace_id" IN (${bizplaceIds})
-        ${productQuery}
-      ) d2
-    )
-  `)
-
-  await tx.query(
-    `
-    CREATE TEMP TABLE "temp_order_inventories" ON COMMIT DROP AS (	
-      SELECT
-          SUM(oi.release_qty) AS release_qty, SUM(oi.release_uom_value) AS release_uom_value, oi.batch_id, oi.batch_id_ref,       
-          oi.product_id, p.product_name, oi.packing_type, oi.packing_size, oi.uom
-        FROM
-          order_inventories oi
-        LEFT JOIN
-          temp_products p ON oi.product_id = p.product_id
-        INNER JOIN 
-          domains d2 on d2.id = oi.domain_id and d2.ext_type ='warehouse'
-        INNER JOIN 
-          fulfillment_centers fc ON fc.center_id = d2.subdomain 
-        WHERE
-          fc.domain_id = $1
-          AND (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
-        AND oi.batch_id NOTNULL AND oi.product_id NOTNULL AND oi.packing_type NOTNULL AND oi.packing_size NOTNULL AND oi.inventory_id IS NULL 
-        GROUP BY
-          oi.batch_id, oi.batch_id_ref, oi.product_id, oi.packing_type,
-          oi.packing_size, oi.uom, p.product_name
-    );
-    `,
-    [domain.id]
-  )
-
-  await tx.query(
-    `
-    CREATE TEMP TABLE "temp_inventory" ON COMMIT DROP AS (	
-      select "i2".*, coalesce("oi".release_qty,0) + coalesce("i2".locked_qty,0) as "inventory_locked_qty" from (
-        select "fc"."id" as "fulfillment_id", "fc"."name" as "fulfillment_name",
-        "i2"."product_id", sum(coalesce("locked_qty",0)) as "locked_qty", sum(coalesce("qty",0)) as "inventory_qty",
-        "i2"."domain_id", "i2"."packing_type", "i2"."packing_size", "i2"."uom"
-        from inventories "i2"
-          inner join warehouses "w" on "w"."id" = "i2"."warehouse_id" 
-          inner join domains "d2" on "d2"."id" = "w"."domain_id" and "d2"."ext_type" ='warehouse'
-          inner join fulfillment_centers "fc" ON "fc"."center_id" = "d2"."subdomain" 
-          inner join (
-            select "Product"."product_id" from (
-              select case when "Product"."type" = 'PRODUCT' then "Product"."product_id" else "pbs"."product_id" end as "product_id"
-              from temp_products "Product" 
-              left join product_bundles "pb" on "pb"."id" =  "Product"."product_id" 
-              left join product_bundle_settings "pbs" on "pbs"."product_bundle_id" = "pb"."id"
-            ) "Product" 
-            group by "Product"."product_id"
-          ) "Product" on "Product"."product_id" = "i2"."product_id" 
-          where "fc"."domain_id" = $1
-          and "i2"."status" = 'STORED'
-          group by "i2"."domain_id", "fc"."id", "fc"."name", "i2"."product_id", "i2"."packing_type", "i2"."packing_size", "i2"."uom"
-      ) as "i2"
-      left join temp_order_inventories "oi" on "i2"."product_id" = "oi"."product_id" 
-      AND "i2"."packing_type" = "oi"."packing_type" 
-      AND "i2"."packing_size" = "oi"."packing_size" 
-      AND "i2"."uom" = "oi"."uom"
-    )
-  `,
-    [domain.id]
-  )
-
-  await tx.query(`
-    CREATE TEMP TABLE "temp_json_warehouse_marketplace_products" ON COMMIT DROP AS (
-      select "product_id", array_to_json(array_agg(row_to_json(dt))) AS "Json_marketplaceProducts" FROM (
-        select "dt"."marketplace_store_id", "dt"."product_id", "dt"."sku", array_agg(row_to_json(dt)) as product_variation
-        from (
-            select "mp"."marketplace_store_id" as "marketplace_store_id", "mpv"."sku", "mpv"."id" as "marketplace_product_variation_id",
-            concat("mpv"."variation_sku", ' (', "mpv"."name", ')') as "name", "mpv"."qty" as "qty", "mpv"."reserve_qty" as "reserve_qty",
-            "Product"."product_id" AS "product_id"
-            from marketplace_product_variations "mpv"
-            inner join marketplace_products "mp" on "mp"."id" = "mpv"."marketplace_product_id"
-            inner join temp_products "Product" on "mpv"."sku" = "Product"."product_sku"
-        ) as "dt"
-        group by "dt"."marketplace_store_id", "dt"."sku", "dt"."product_id"
-      ) "dt" group by "dt"."product_id"
-    )
-  `)
-
-  await tx.query(
-    `
-    CREATE TEMP TABLE temp_json_warehouse_inventory ON COMMIT DROP AS (
-      select "product_id", array_to_json(array_agg((row_to_json("dt")))) AS "Json_warehouseInventory" from(
-        select "domain_id", "fulfillment_id", "fulfillment_name",
-        "product_id", "inventory_locked_qty", "inventory_qty"
-        from temp_inventory
-        union 
-        select "bundledInv"."domain_id", "bundledInv"."fulfillment_id", "bundledInv"."fulfillment_name", "bundledInv"."product_id", 
-        max("bundledInv"."inventory_locked_qty") as "inventory_locked_qty", min("bundledInv"."inventory_qty") as "inventory_qty" from (
-          select "Product"."product_id", fc.domain_id, "fc"."id" as "fulfillment_id", "fc"."name" as "fulfillment_name",
-          "pbs"."bundle_qty",
-          case when "pbs"."bundle_qty" <= 0 then 0 else floor(greatest("i2"."inventory_qty", 0)/ "pbs"."bundle_qty")- floor((greatest("i2"."inventory_qty", 0) - greatest("i2"."inventory_locked_qty",0)) / "pbs"."bundle_qty") end AS "inventory_locked_qty",
-          case when "pbs"."bundle_qty" <= 0 then 0 else floor(greatest("i2"."inventory_qty", 0)/ "pbs"."bundle_qty") end AS "inventory_qty"
-          from temp_products "Product" 
-          inner join product_bundle_settings pbs ON pbs.product_bundle_id = "Product"."product_id"
-          inner join products p on p.id = pbs.product_id 
-          cross join fulfillment_centers fc 
-          inner join domains "d2" on "d2"."ext_type" ='warehouse' and "fc"."center_id" = "d2"."subdomain"
-          left join temp_inventory i2 ON i2.product_id = pbs.product_id and "d2"."id" = "i2"."domain_id" 
-          where "fc"."domain_id" = $1
-          order by fc.id, "Product"."product_sku", p.sku
-        ) "bundledInv"
-        group by "domain_id","fulfillment_id","fulfillment_name","product_id"
-      ) "dt" group by "dt"."product_id"
-    )
-  `,
-    [domain.id]
-  )
-
-  await tx.query(`
-    CREATE TEMP TABLE temp_warehouse_marketplace_products ON COMMIT DROP as (
-      SELECT "Product"."product_id" AS "Product_id", "Product"."product_sku" AS "Product_sku", 
-      "Product"."product_name" AS "Product_name", "Product"."product_description" AS "Product_description", 
-      "Product"."product_bizplace_id" AS "Product_bizplace_id", 
-      "Product"."creator_id" AS "Product_creator_id", "Product"."updater_id" AS "Product_updater_id", 
-      "Bizplace"."name" AS "Bizplace_name", "Bizplace"."description" AS "Bizplace_description", "Bizplace"."address" AS "Bizplace_address", "Bizplace"."postal_code" AS "Bizplace_postal_code", 
-      "Bizplace"."latlng" AS "Bizplace_latlng", "Bizplace"."status" AS "Bizplace_status", "Bizplace"."created_at" AS "Bizplace_created_at", "Bizplace"."updated_at" AS "Bizplace_updated_at", 
-      "Bizplace"."domain_id" AS "Bizplace_domain_id", "Bizplace"."company_id" AS "Bizplace_company_id", "Bizplace"."creator_id" AS "Bizplace_creator_id", "Bizplace"."updater_id" AS "Bizplace_updater_id", 
-      "Creator"."id" AS "Creator_id", "Creator"."name" AS "Creator_name", "Creator"."description" AS "Creator_description", "Creator"."email" AS "Creator_email",
-      "Updater"."id" AS "Updater_id", "Updater"."name" AS "Updater_name", "Updater"."description" AS "Updater_description", "Updater"."email" AS "Updater_email"
-      ,COALESCE("whInv"."Json_warehouseInventory", null) AS "Json_warehouseInventory"
-      ,COALESCE("mktPrd"."Json_marketplaceProducts", null) AS "Json_marketplaceProducts"
-      FROM "temp_products" "Product"
-      LEFT JOIN "bizplaces" "Bizplace" ON "Bizplace"."id" = "Product"."product_bizplace_id"
-      LEFT JOIN "users" "Creator" ON "Creator"."id"="Product"."creator_id"  
-      LEFT JOIN "users" "Updater" ON "Updater"."id"="Product"."updater_id"
-      LEFT JOIN "temp_json_warehouse_inventory" "whInv" ON "whInv"."product_id" = "Product"."product_id"
-      LEFT JOIN "temp_json_warehouse_marketplace_products" "mktPrd" ON "mktPrd"."product_id" = "Product"."product_id"
-    )
-  `)
-
-  const offsetQuery: string = params?.pagination
-    ? `OFFSET ${(params.pagination.page - 1) * params.pagination.limit} LIMIT ${params.pagination.limit}`
-    : ''
-
-  const total: any = await tx.query(`select count(*) from temp_warehouse_marketplace_products`)
-
-  const items: any[] = await tx.query(
-    `
-    select * from temp_warehouse_marketplace_products ${offsetQuery}
-  `
-  )
-
-  return {
-    items: items.map((itm, index) => {
-      return {
-        seq: index + (params?.pagination ? (params.pagination.page - 1) * params.pagination.limit + 1 : 0),
-        id: itm.Product_id,
-        sku: itm.Product_sku,
-        name: itm.Product_name,
-        description: itm.Product_description,
-        marketplaceProduct: itm.Json_marketplaceProducts
-          ? itm.Json_marketplaceProducts.map(product => {
-              return {
-                marketplaceStore: { id: product.marketplace_store_id },
-                marketplaceProductVariations: product.product_variation.map(variation => {
-                  return {
-                    id: variation.marketplace_product_variation_id,
-                    name: variation.name,
-                    qty: variation.qty,
-                    reserveQty: variation.reserve_qty
-                  }
-                })
-              }
-            })
-          : null,
-        warehouseInventory: itm.Json_warehouseInventory
-          ? itm.Json_warehouseInventory.map(inventory => {
-              return {
-                bizplace: { id: inventory.fulfillment_id, name: inventory.fulfillment_name },
-                product: { id: inventory.product_id },
-                qty: inventory.inventory_qty,
-                lockedQty: inventory.inventory_locked_qty ? inventory.inventory_locked_qty : 0,
-                remainQty:
-                  inventory.inventory_qty - (inventory.inventory_locked_qty ? inventory.inventory_locked_qty : 0)
-              }
-            })
-          : null
-      }
-    }),
-    total: total[0].count
-  }
-}

package/server/graphql/resolvers/shipping-provider/index.ts

@@ -1,5 +0,0 @@
-import { shippingProviders } from './shipping-providers'
-
-export const Query = {
-    ...shippingProviders
-}

package/server/graphql/resolvers/shipping-provider/shipping-providers.ts

@@ -1,39 +0,0 @@
-import { MarketplaceOrder } from '@things-factory/marketplace-base'
-import { getRepository, ListParam } from '@things-factory/shell'
-
-export const shippingProviders = {
-  async shippingProviders(
-    _: any,
-    params: ListParam & { statuses?: string[]; storeId?: string },
-    context: ResolverContext
-  ) {
-    try {
-      const { domain } = context.state
-
-      let statusFilter = ``
-      if (params.statuses) {
-        statusFilter = `AND status in (${params.statuses.map(e => {
-          return `'` + e + `'`
-        })})`
-      }
-
-      let items: any[] = await getRepository(MarketplaceOrder).query(
-        `
-        SELECT DISTINCT shipping_provider FROM marketplace_orders WHERE domain_id = '${domain.id}' AND marketplace_store_id = '${params.storeId}' AND shipping_provider IS NOT null AND shipping_provider != ''
-      ` + statusFilter
-      )
-
-      items = items.map(e => {
-        const { shipping_provider: shippingProvider } = e
-
-        return {
-          shippingProvider
-        }
-      })
-
-      return { items }
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/warehouse-product/auto-link-warehouse-marketplace-product-variations.ts

@@ -1,87 +0,0 @@
-import { In, IsNull } from 'typeorm'
-
-import { MarketplaceProduct, MarketplaceProductVariation } from '@things-factory/marketplace-base'
-import { publishProgress } from '@things-factory/shell'
-
-import { warehouseMarketplaceProduct } from '../interface-with-hub/warehouse-marketplace-products'
-
-export const autoLinkWarehouseMarketplaceProductVariationsResolver = {
-  async autoLinkWarehouseMarketplaceProductVariations(
-    _: any,
-    { marketplaceStoreIds, isCheckedSku },
-    context: ResolverContext
-  ): Promise<Boolean> {
-    const { domain, user, tx } = context.state
-
-    const tag = `progress-link-product`
-
-    await linkMarketplaceProductVariations({
-      domain,
-      user,
-      tag,
-      marketplaceStoreIds,
-      isCheckedSku,
-      tx
-    })
-
-    return true
-  }
-}
-
-async function linkMarketplaceProductVariations({ domain, user, tag, marketplaceStoreIds, isCheckedSku, tx }) {
-  try {
-    const params: any = { filters: [], sortings: [] }
-    const warehouseMarketplaceProducts = await warehouseMarketplaceProduct(params, domain, user, tx)
-
-    const marketplaceProducts: MarketplaceProduct[] = await tx.getRepository(MarketplaceProduct).find({
-      where: { domain: { id: domain.id }, marketplaceStore: In(marketplaceStoreIds) }
-    })
-
-    let marketplaceProductVariations: MarketplaceProductVariation[] = await tx
-      .getRepository(MarketplaceProductVariation)
-      .find({
-        where: {
-          domain: { id: domain.id },
-          marketplaceProduct: In(marketplaceProducts.map(product => product.id)),
-          sku: IsNull()
-        }
-      })
-
-    let total: number = marketplaceProductVariations?.length
-
-    const linkedProductVariations: MarketplaceProductVariation[] = await Promise.all(
-      marketplaceProductVariations.map((productVariation: MarketplaceProductVariation, idx) => {
-        let foundSku: any
-
-        if (isCheckedSku) {
-          foundSku = warehouseMarketplaceProducts.items.find(
-            warehouseProd => warehouseProd.sku === productVariation.variationSku
-          )
-        }
-
-        productVariation.sku = foundSku?.sku ? foundSku.sku : null
-        productVariation.updater = user
-
-        publishProgress({
-          domain: { id: domain.id },
-          tag,
-          progress: Math.floor((idx / total) * 100),
-          message: `${idx} / ${total}`
-        })
-
-        return productVariation
-      })
-    )
-
-    await tx.getRepository(MarketplaceProductVariation).save(linkedProductVariations)
-  } catch (ex) {
-    publishProgress({
-      domain,
-      tag,
-      progress: -1,
-      message: 'failed'
-    })
-
-    throw ex
-  }
-}

package/server/graphql/resolvers/warehouse-product/index.ts

@@ -1,5 +0,0 @@
-import { autoLinkWarehouseMarketplaceProductVariationsResolver } from './auto-link-warehouse-marketplace-product-variations'
-
-export const Mutation = {
-  ...autoLinkWarehouseMarketplaceProductVariationsResolver
-}

package/server/graphql/types/index.ts

@@ -1,9 +0,0 @@
-import * as InterfaceWithHub from './interface-with-hub'
-import * as WarehouseProduct from './warehouse-product'
-import * as ShippingProvider from './shipping-provider'
-
-export const queries = [InterfaceWithHub.Query, ShippingProvider.Query]
-
-export const mutations = [InterfaceWithHub.Mutation, WarehouseProduct.Mutation]
-
-export const types = [...InterfaceWithHub.Types, ...WarehouseProduct.Types, ...ShippingProvider.Types]

package/server/graphql/types/interface-with-hub/index.ts

@@ -1,28 +0,0 @@
-import { NewStockReplenishment } from './new-stock-replenishment'
-import { ReplenishmentOrderProduct } from './replenishment-order-product'
-import { StockReplenishment } from './stock-replenishment'
-import { StockReplenishmentList } from './stock-replenishment-list'
-import { WarehouseInventory } from './warehouse-inventory'
-import { WarehouseMarketplaceProduct } from './warehouse-marketplace-product'
-import { WarehouseMarketplaceProductList } from './warehouse-marketplace-product-list'
-
-export const Mutation = /* GraphQL */ `
-  addReleaseOrder(marketplaceOrderIds: [String]!, warehouseId: String!): Boolean @transaction
-  autoAddReleaseOrder(warehouseId: String): Boolean @transaction
-  generateReplenishmentOrder(stockReplenishmentId: String!, warehouseId: String!): StockReplenishment @transaction
-  autoUpdateAllMarketplaceProductVariationQuantity(companyDomainId: String, warehouseId: String): Boolean @transaction
-`
-
-export const Query = /* GraphQL */ `
-  warehouseMarketplaceProducts(filters: [Filter], pagination: Pagination, sortings: [Sorting]): WarehouseMarketplaceProductList @transaction
-`
-
-export const Types = [
-  StockReplenishment,
-  NewStockReplenishment,
-  ReplenishmentOrderProduct,
-  StockReplenishmentList,
-  WarehouseInventory,
-  WarehouseMarketplaceProduct,
-  WarehouseMarketplaceProductList
-]