@things-factory/operato-hub 4.3.107 → 4.3.108

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

@@ -1,11 +1,10 @@
-import { EntityManager, getRepository } from 'typeorm'
+import { EntityManager } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
 import { logger } from '@things-factory/env'
 import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
 import { Sellercraft, SellercraftAPI } from '@things-factory/integration-sellercraft'
-import { Product, ProductDetail } from '@things-factory/product-base'
-import { WarehouseBizplaceOnhandInventory } from '@things-factory/worksheet-base'
+import { ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 
 export const syncProductsToSellercraftResolver = {
@@ -24,16 +23,19 @@ export const syncProductsToSellercraftResolver = {
       let hasMorePage: boolean = true
       const limit: number = 50
 
-      const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({ where: { id: sellercraftId }, relations: ['domain'] })
+      const sellercraft: Sellercraft = await tx
+        .getRepository(Sellercraft)
+        .findOne({ where: { id: sellercraftId }, relations: ['domain'] })
       const customerDomain: Domain = sellercraft.domain
       const fulfilmentCenter: FulfillmentCenter = await FulfillmentAPI.getFulfillmentCenter(fulfillmentCenterId)
       const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({ where: { domain: customerDomain } })
 
-      await tx.query(`
+      await tx.query(
+        `
         create temp table temp_warehouse_product_inventory ON COMMIT DROP as (
           select p.id, p.sku as product_sku, p.name as product_name, p.description as product_description, 
           pd.gtin, pd.uom, pd.packing_size, coalesce(pd.nett_weight, 0) as nett_weight, pd.width, pd."depth", pd.height,
-          coalesce(src.qty, 0) as available_qty, coalesce(src.qty - src."remainQty", 0) as reserved_qty, coalesce(src."remainQty",0) as remain_qty
+          coalesce(src.qty, 0) as available_qty, coalesce(src.qty - src."remain_qty", 0) as reserved_qty, coalesce(src."remain_qty",0) as remain_qty
           from bizplaces b
           inner join companies c on c.id = b.company_id 
           inner join domains d on d.id = c.domain_id
@@ -41,18 +43,19 @@ export const syncProductsToSellercraftResolver = {
           inner join product_details pd on pd.product_id = p.id
           left join (
             select wboi.* from warehouse_bizplace_onhand_inventories wboi 
-            inner join domains d on d.id = wboi."domainId"
+            inner join domains d on d.id = wboi."domain_id"
             inner join fulfillment_centers fc on d.subdomain = fc.center_id 
             where fc.id= $1 
-              and wboi."bizplaceId" = $2 and "groupType" = 'SINGLE'
-          ) src on src."productId" = pd."product_id" 
-            and src."packingType" = pd."packing_type" 
-            and src."packingSize" = pd."packing_size" 
+              and wboi."bizplaceId" = $2 and "group_type" = 'SINGLE'
+          ) src on src."product_id" = pd."product_id" 
+            and src."packing_type" = pd."packing_type" 
+            and src."packing_size" = pd."packing_size" 
             and src."uom" = pd."uom" 
           where b.id = $2
-          and pd."is_default" = true
         )
-      `, [fulfilmentCenter.id, customerBizplace.id])
+      `,
+        [fulfilmentCenter.id, customerBizplace.id]
+      )
 
       let total = await tx.query(`
         select count(*) from temp_warehouse_product_inventory            
@@ -67,9 +70,12 @@ export const syncProductsToSellercraftResolver = {
           //   paginationOffset: page
           // })
 
-          const items = await tx.query(`
+          const items = await tx.query(
+            `
             select * from temp_warehouse_product_inventory limit $1 offset $2
-          `, [limit, page * limit])
+          `,
+            [limit, page * limit]
+          )
 
           let sellercraftInv: any[] = []
 
@@ -102,9 +108,11 @@ export const syncProductsToSellercraftResolver = {
           await SellercraftAPI.updateProduct(sellercraft, { context, accountId: sellercraft.accountId, sellercraftInv })
 
           page++
-          hasMorePage = (total[0]?.count || 0) > (page * limit)
+          hasMorePage = (total[0]?.count || 0) > page * limit
         } catch (e) {
-          logger.error(`[syncProductsToSellercraftResolver] sellercraftID:${sellercraftId} fulfillmentCenterId:${fulfillmentCenterId} page:${page} - ${e}`)
+          logger.error(
+            `[syncProductsToSellercraftResolver] sellercraftID:${sellercraftId} fulfillmentCenterId:${fulfillmentCenterId} page:${page} - ${e}`
+          )
         }
       }
     } catch (e) {

package/server/middlewares/store-middleware.ts

@@ -1,4 +1,5 @@
 import { getRepository } from 'typeorm'
+
 import { MarketplaceStore as MarketplaceStoreEntity } from '@things-factory/integration-marketplace'
 
 const debug = require('debug')('things-factory:operato-hub:store-middleware')

package/server/routers/api/index.ts

@@ -1,3 +1,2 @@
 import './restful-apis/v1'
-import './restful-apis/v2'
 import './restful-apis/unstable'

package/server/routers/api/restful-apis/unstable/add-release-order.ts

@@ -130,15 +130,15 @@ router.post(
             let itemList = await tx.query(
               `
             select wboi.* from warehouse_bizplace_onhand_inventories wboi 
-            where wboi."domainId"= $1 and 
-            wboi."bizplaceId" = $2 and 
-            wboi."groupType" = 'SINGLE' and 
-            wboi."productId" = $3 and
-            wboi."packingType" = $4 and
-            wboi."packingSize" = $5 and
+            where wboi."domain_id"= $1 and 
+            wboi."bizplace_id" = $2 and 
+            wboi."group_type" = 'SINGLE' and 
+            wboi."product_id" = $3 and
+            wboi."packing_type" = $4 and
+            wboi."packing_size" = $5 and
             wboi."uom" = $6 and
-            wboi."remainQty" >= $7 and
-            wboi."remainUomValue" >= $8
+            wboi."remain_qty" >= $7 and
+            wboi."remain_uom_value" >= $8
           `,
               [
                 domain.id,

package/server/routers/api/restful-apis/v1/company/add-contact-points.ts

@@ -0,0 +1,111 @@
+import { getConnection, EntityManager, In, Brackets } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { ContactPoint } from '@things-factory/biz-base'
+import { Bizplace } from '@things-factory/biz-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { businessMiddleware, loggingMiddleware, validationMiddleware } from '../middlewares'
+
+router.post(
+  '/v1/company/add-contact-points',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      if (!Array.isArray(context.request.body.data)) throw new ApiError('E01', 'data field is not an array')
+      if (!context.request.body.hasOwnProperty('bizplaceId')) throw new ApiError('E03', 'bizplaceId')
+      if (!context.request.body.bizplaceId) throw new ApiError('E01', 'bizplaceId')
+      await getConnection().transaction(async (tx: EntityManager) => {
+        // create and format values to be inserted
+        const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+          where: { id: context.request.body.bizplaceId }
+        })
+
+        // check if phone or email already belongs in bizplace
+        const phones = []
+        const emails = []
+        let values = []
+        for (const datapoint of context.request.body.data) {
+          phones.push(datapoint.phone)
+          emails.push(datapoint.email)
+          const value = {
+            name: datapoint.name,
+            description: datapoint.description,
+            companyName: datapoint.companyName,
+            email: datapoint.email,
+            fax: datapoint.fax,
+            phone: datapoint.phone,
+            billingAddress: datapoint.billingAddress,
+            accountNo: datapoint.accountNo,
+            address: datapoint.address,
+            address2: datapoint.address2,
+            city: datapoint.city,
+            state: datapoint.state,
+            postCode: datapoint.postCode,
+            type: datapoint.type,
+            domain: context.state.domain,
+            bizplace: bizplace,
+            creator: context.state.user,
+            updater: context.state.user
+          }
+          values.push(value)
+        }
+
+        const checkDuplicateEmailPhone: ContactPoint = await tx
+          .getRepository(ContactPoint)
+          .createQueryBuilder('cp')
+          .where('cp.bizplace_id = :bizplaceId', { bizplaceId: context.request.body.bizplaceId })
+          .andWhere(
+            new Brackets(qb => {
+              qb.where('cp.email in(:email)', { email: emails.toString() })
+              qb.orWhere('cp.phone in(:phone)', { phone: phones.toString() })
+            })
+          )
+          .getOne()
+        if (checkDuplicateEmailPhone) throw new ApiError('E05', 'email or phone number')
+
+        // insert values to DB
+        const result = await tx
+          .getRepository(ContactPoint)
+          .createQueryBuilder()
+          .insert()
+          .into(ContactPoint)
+          .values(values)
+          .returning('*')
+          .execute()
+
+        // create and format response
+        let data = []
+        for (const contactPoint of result.generatedMaps) {
+          const datapoint = {
+            name: contactPoint.name,
+            description: contactPoint.description,
+            companyName: contactPoint.companyName,
+            email: contactPoint.email,
+            fax: contactPoint.fax,
+            phone: contactPoint.phone,
+            billingAddress: contactPoint.billingAddress,
+            accountNo: contactPoint.accountNo,
+            address: contactPoint.address,
+            address2: contactPoint.address2,
+            city: contactPoint.city,
+            state: contactPoint.state,
+            postCode: contactPoint.postCode,
+            type: contactPoint.type,
+            createdAt: contactPoint.createdAt
+          }
+          data.push(datapoint)
+        }
+
+        context.body = {
+          data
+        }
+      })
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)

package/server/routers/api/restful-apis/v1/company/add-marketplace-order.ts

@@ -0,0 +1,234 @@
+import { getConnection, EntityManager, IsNull, SelectQueryBuilder } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { v4 as uuidv4 } from 'uuid'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Product, ProductBundle, ProductBundleSetting } from '@things-factory/product-base'
+import {
+  MarketplaceOrder as MarketplaceOrderEntity,
+  MarketplaceOrderItem as MarketplaceOrderItemEntity,
+  MarketplaceOrderShipping as MarketplaceOrderShippingEntity,
+  MarketplaceOrderShippingItem as MarketplaceOrderShippingItemEntity,
+  MarketplaceProductVariation as MarketplaceProductVariationEntity,
+  NoGenerator
+} from '@things-factory/marketplace-base'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.post(
+  '/v1/company/add-marketplace-order',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      await getConnection().transaction(async (tx: EntityManager) => {
+        const { user, domain } = context.state
+        const marketplaceOrder = context.request.body.data
+
+        const marketplaceStore: MarketplaceStore = await tx.getRepository(MarketplaceStore).findOne({
+          where: { name: marketplaceOrder.storeId, domain }
+        })
+        if (!marketplaceStore) throw new ApiError('E04', 'storeId')
+
+        let invalidQty = marketplaceOrder.marketplaceOrderItems.find(itm => itm.qty <= 0)
+        if (invalidQty) {
+          throw new ApiError('E01', 'qty')
+        }
+
+        let marketplaceOrderItems: MarketplaceOrderItemEntity[] = []
+
+        let newMarketplaceOrder: MarketplaceOrderEntity = Object.assign({}, marketplaceOrder)
+        const itemCount: number = marketplaceOrder.marketplaceOrderItems?.length
+
+        const currentDate = new Date()
+        newMarketplaceOrder.name = `MO-${currentDate.getFullYear()}${
+          currentDate.getMonth() + 1
+        }${currentDate.getDate()}${currentDate.getHours()}${currentDate.getMinutes()}${currentDate.getSeconds()}${currentDate.getMilliseconds()}`
+        newMarketplaceOrder.itemCount = itemCount
+        newMarketplaceOrder.marketplaceStore = marketplaceStore
+        newMarketplaceOrder.domain = domain
+        newMarketplaceOrder.creator = user
+        newMarketplaceOrder = await tx.getRepository(MarketplaceOrderEntity).save(newMarketplaceOrder)
+
+        let newMarketplaceOrderShipping: MarketplaceOrderShippingEntity
+        if (marketplaceOrder?.marketplaceOrderShipping) {
+          const marketplaceOrderShipping: any = marketplaceOrder.marketplaceOrderShipping
+          newMarketplaceOrderShipping = Object.assign({}, marketplaceOrderShipping)
+          newMarketplaceOrderShipping.name = marketplaceOrderShipping?.shippingId
+            ? marketplaceOrderShipping.shippingId
+            : NoGenerator.orderShipping()
+          newMarketplaceOrderShipping.transporter =
+            marketplaceOrderShipping?.transporter === '' ? null : marketplaceOrderShipping.transporter
+          newMarketplaceOrderShipping.ownTransporter =
+            marketplaceOrderShipping?.transporter === '' ? null : marketplaceOrderShipping.transporter
+          newMarketplaceOrderShipping.marketplaceStore = marketplaceStore
+          newMarketplaceOrderShipping.orderNoRef = newMarketplaceOrder.orderNo
+          newMarketplaceOrderShipping.subOrderNoRef = newMarketplaceOrder.orderNo
+          newMarketplaceOrderShipping.domain = domain
+          newMarketplaceOrderShipping.creator = user
+          newMarketplaceOrderShipping = await tx
+            .getRepository(MarketplaceOrderShippingEntity)
+            .save(newMarketplaceOrderShipping)
+        }
+
+        marketplaceOrderItems = await Promise.all(
+          marketplaceOrder?.marketplaceOrderItems.map(async orderItem => {
+            let marketplaceOrderItem: MarketplaceOrderItemEntity = Object.assign({}, orderItem)
+
+            const marketplaceProductVariation = orderItem.marketplaceProductVariation
+            const qb: SelectQueryBuilder<MarketplaceProductVariationEntity> = await tx
+              .getRepository(MarketplaceProductVariationEntity)
+              .createQueryBuilder('mpv')
+              .leftJoin('mpv.marketplaceProduct', 'mp')
+              .leftJoin('mp.marketplaceStore', 'ms')
+              .where('mpv.domain_id = :domainId')
+              .andWhere('mpv.variation_id = :variationId')
+              .andWhere('ms.id = :marketplaceStoreId')
+              .setParameters({
+                domainId: domain.id,
+                variationId: marketplaceProductVariation.variationId,
+                marketplaceStoreId: marketplaceStore.id
+              })
+
+            let foundVariation: MarketplaceProductVariationEntity = await qb.getOne()
+
+            if (!foundVariation) {
+              let newVariation: MarketplaceProductVariationEntity = Object.assign({}, marketplaceProductVariation)
+              newVariation.status = 'ACTIVE'
+              newVariation.domain = domain
+
+              await tx.getRepository(MarketplaceProductVariationEntity).save(newVariation)
+              foundVariation = newVariation
+            }
+
+            marketplaceOrderItem.marketplaceProductVariation = foundVariation
+            marketplaceOrderItem.name = orderItem.orderItemId
+            marketplaceOrderItem.marketplaceOrder = newMarketplaceOrder
+            marketplaceOrderItem.domain = domain
+            marketplaceOrderItem.creator = user
+
+            return marketplaceOrderItem
+          })
+        )
+
+        marketplaceOrderItems = await tx.getRepository(MarketplaceOrderItemEntity).save(marketplaceOrderItems)
+
+        await Promise.all(
+          marketplaceOrderItems.map(async marketplaceOrderItem => {
+            const marketplaceProductVariation = marketplaceOrderItem.marketplaceProductVariation
+
+            let product: Product = await tx.getRepository(Product).findOne({
+              where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku, deletedAt: IsNull() },
+              relations: ['productDetails']
+            })
+
+            let productBundle: ProductBundle
+            if (!product) {
+              productBundle = await tx.getRepository(ProductBundle).findOne({
+                where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku },
+                relations: ['productBundleSettings', 'productBundleSettings.product']
+              })
+            }
+
+            let existingMarketplaceOrderShippingItems: MarketplaceOrderShippingItemEntity[] = await tx
+              .getRepository(MarketplaceOrderShippingItemEntity)
+              .find({
+                where: { domain: marketplaceStore.domain, marketplaceOrderItem }
+              })
+
+            if (existingMarketplaceOrderShippingItems && existingMarketplaceOrderShippingItems?.length) {
+            } else {
+              if (productBundle) {
+                const productBundleSettings: ProductBundleSetting[] = productBundle.productBundleSettings
+                let marketplaceOrderShippingItems: MarketplaceOrderShippingItemEntity[] = []
+                productBundleSettings.map(productBundleSetting => {
+                  let marketplaceOrderShippingItem: MarketplaceOrderShippingItemEntity =
+                    new MarketplaceOrderShippingItemEntity()
+                  marketplaceOrderShippingItem.name = uuidv4()
+                  marketplaceOrderShippingItem.qty = marketplaceOrderItem.qty * productBundleSetting.bundleQty
+                  marketplaceOrderShippingItem.domain = marketplaceStore.domain
+                  marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem
+                  marketplaceOrderShippingItem.marketplaceOrderShipping = newMarketplaceOrderShipping
+                  marketplaceOrderShippingItem.product = productBundleSetting.product
+
+                  marketplaceOrderShippingItems.push(marketplaceOrderShippingItem)
+                })
+
+                await tx.getRepository(MarketplaceOrderShippingItemEntity).save(marketplaceOrderShippingItems)
+              } else {
+                let marketplaceOrderShippingItem: MarketplaceOrderShippingItemEntity =
+                  new MarketplaceOrderShippingItemEntity()
+                marketplaceOrderShippingItem.name = uuidv4()
+                marketplaceOrderShippingItem.qty = marketplaceOrderItem.qty
+                marketplaceOrderShippingItem.domain = marketplaceStore.domain
+                marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem
+                marketplaceOrderShippingItem.marketplaceOrderShipping = newMarketplaceOrderShipping
+                marketplaceOrderShippingItem.product = product ? product : null
+
+                await tx.getRepository(MarketplaceOrderShippingItemEntity).save(marketplaceOrderShippingItem)
+              }
+            }
+          })
+        )
+
+        let marketplaceOrderItemsData = []
+        for (const item of marketplaceOrderItems) {
+          const datapoint = {
+            marketplaceOrderVariation: {
+              variationId: item.marketplaceProductVariation.variationId,
+              sku: item.marketplaceProductVariation.sku,
+              variationSku: item.marketplaceProductVariation.variationSku,
+              variationName: item.marketplaceProductVariation.variationName
+            },
+            marketplaceOrderShipping: {
+              attentionTo: item.marketplaceOrderShipping.attentionTo,
+              address1: item.marketplaceOrderShipping.address1,
+              address2: item.marketplaceOrderShipping.address2,
+              address3: item.marketplaceOrderShipping.address3,
+              address4: item.marketplaceOrderShipping.address4,
+              address5: item.marketplaceOrderShipping.address5,
+              state: item.marketplaceOrderShipping.state,
+              city: item.marketplaceOrderShipping.city,
+              postCode: item.marketplaceOrderShipping.postCode,
+              country: item.marketplaceOrderShipping.country,
+              phone1: item.marketplaceOrderShipping.phone1,
+              phone2: item.marketplaceOrderShipping.phone2,
+              email: item.marketplaceOrderShipping.email,
+              freightType: item.marketplaceOrderShipping.freightType,
+              parcelType: item.marketplaceOrderShipping.parcelType,
+              deliveryMethod: item.marketplaceOrderShipping.deliveryMethod,
+              totalWeight: item.marketplaceOrderShipping.totalWeight,
+              totalVolume: item.marketplaceOrderShipping.totalVolume,
+              transporter: item.marketplaceOrderShipping.transporter
+            }
+          }
+          marketplaceOrderItemsData.push(datapoint)
+        }
+        const data = {
+          orderNo: newMarketplaceOrder.orderNo,
+          itemCount,
+          paymentMethod: newMarketplaceOrder.paymentMethod,
+          remark: newMarketplaceOrder.remark,
+          giftOption: newMarketplaceOrder.giftOption,
+          orderCreatedAt: newMarketplaceOrder.orderCreatedAt,
+          orderUpdatedAt: newMarketplaceOrder.orderUpdatedAt,
+          marketplaceOrderItems: marketplaceOrderItemsData,
+          orderItemId: newMarketplaceOrder.orderItemId,
+          qty: newMarketplaceOrder.qty,
+          cancelBy: newMarketplaceOrder.cancelBy,
+          returnStatus: newMarketplaceOrder.returnStatus,
+          packageId: newMarketplaceOrder.packageId,
+          status: newMarketplaceOrder.status
+        }
+
+        context.body = {
+          data
+        }
+      })
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)

package/server/routers/api/restful-apis/v1/company/add-products.ts

@@ -0,0 +1,96 @@
+import { getRepository, In, getConnection, EntityManager } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Bizplace } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import _ from 'lodash'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.post(
+  '/v1/company/add-products',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      await getConnection().transaction(async (tx: EntityManager) => {
+        if (!Array.isArray(context.request.body.data)) throw new ApiError('E01', 'data field is not an array')
+
+        const products = context.request.body.data
+        const skus = products.map(p => p.sku)
+        const { user, domain } = context.state
+
+        // find bizplace
+        const bizplace = await getRepository(Bizplace).findOne({
+          where: {
+            domain
+          }
+        })
+
+        //check duplicate sku from request
+        let duplicateSku = skus.filter((item, index) => skus.indexOf(item) != index)
+
+        if (duplicateSku?.length > 0) {
+          throw new ApiError('E05', `duplicated products found: ${[...new Set(duplicateSku)]}`)
+        }
+
+        //check if sku existed in db
+        let existedProducts: Product = await getRepository(Product).find({
+          where: {
+            sku: In(skus),
+            bizplace
+          }
+        })
+
+        if (existedProducts?.length > 0) {
+          throw new ApiError('E05', `existing products found: ${existedProducts.map(ep => ep.sku)}`)
+        }
+
+        // save product
+        await Promise.all(
+          products.map(async p => {
+            const product = p
+            const productDetails = p.productDetails
+
+            product.domain = domain
+            product.bizplace = bizplace
+            product.creator = user
+            product.updater = user
+            delete product.productDetails
+
+            const result = await tx.getRepository(Product).save(products)
+
+            const newProduct = result[0]
+
+            // save product details
+            await Promise.all(
+              productDetails.map(async pd => {
+                if (pd.packingSize < 0) throw new ApiError('E01', `${pd.gtin}: packing size cannot be negative`)
+                const productDetails = pd
+                await tx.getRepository(ProductDetail).save({
+                  ...productDetails,
+                  name: productDetails.gtin,
+                  product: newProduct,
+                  childProductDetail: null,
+                  childQty: 0,
+                  domain: domain,
+                  creator: user,
+                  updater: user
+                })
+              })
+            )
+          })
+        )
+
+        context.body = {
+          data: context.request.body
+        }
+      })
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)

package/server/routers/api/restful-apis/v1/company/cancel-marketplace-order.ts

@@ -0,0 +1,94 @@
+import { getConnection, EntityManager } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Domain } from '@things-factory/shell'
+import { MarketplaceOrder, MarketplaceOrderItem } from '@things-factory/marketplace-base'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getCustomerBizplaces } from '@things-factory/biz-base'
+import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.post('/v1/company/cancel-marketplace-order', businessMiddleware, validationMiddleware, loggingMiddleware, async (context, next) => {
+  try {
+    const { orderNo, remark, cancelBy } = context.request.body.data
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const marketplaceStore: MarketplaceStore = await tx.getRepository(MarketplaceStore).findOne({
+        where: { name: context.request.body.data.storeId, domain: context.state.domain }
+      })
+      if (!marketplaceStore) throw new ApiError('E04', 'storeId')
+
+      let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { domain, orderNo, marketplaceStore },
+        relations: ['fulfillmentCenter', 'marketplaceStore', 'marketplaceOrderItems']
+      })
+      if (!marketplaceOrder) throw new ApiError('E04', 'orderNo')
+
+      let marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems.map(orderItem => {
+        let marketplaceOrderItem: MarketplaceOrderItem = Object.assign({}, orderItem)
+        marketplaceOrderItem.reason = remark
+        marketplaceOrderItem.status = 'cancelled'
+        marketplaceOrderItem.updater = user
+        marketplaceOrderItem.cancelBy = cancelBy
+
+        return marketplaceOrderItem
+      })
+      await tx.getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
+
+      marketplaceOrder.status = 'cancelled'
+      marketplaceOrder.remark = remark
+      marketplaceOrder.updater = user
+      marketplaceOrder = await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)
+
+      const cancelStatuses: string[] = ['cancelled', 'canceled']
+      if (cancelStatuses.includes(marketplaceOrder.status) && marketplaceOrder?.releaseOrderId) {
+        if (marketplaceOrder.isSplitted) {
+          const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
+          const centerId: string = fulfillmentCenter.centerId
+          const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
+          const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+          const customerBizplaceId: string = customerBizplaces[0].id
+
+          const { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
+            customerBizplaceId,
+            refNo: marketplaceOrder.orderNo
+          })
+          if (releaseOrders?.length) {
+            for (var a = 0; a < releaseOrders.length; a++) {
+              const releaseOrderId: string = releaseOrders[a].id
+              await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
+            }
+          }
+        } else {
+          const releaseOrderId: string = marketplaceOrder.releaseOrderId
+          const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
+          const centerId: string = fulfillmentCenter.centerId
+
+          const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
+          const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+          const customerBizplaceId: string = customerBizplaces[0].id
+          await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
+        }
+      }
+      const data = {
+        orderNo: marketplaceOrder.orderNo,
+        status: marketplaceOrder.status,
+        remark: marketplaceOrder.remark,
+        cancelBy: cancelBy || null,
+        createdAt: marketplaceOrder.createdAt,
+        updatedAt: marketplaceOrder.updatedAt
+      }
+
+      context.body = {
+        data
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})