@things-factory/operato-hub 4.3.82 → 4.3.87

package/server/routers/api/restful-apis/v2/add-inbound-order.ts

@@ -0,0 +1,242 @@
+import gql from 'graphql-tag'
+import { getRepository, In } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Bizplace, ContactPoint, getCompanyBizplace } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+
+import { businessMiddleware } from '../../../../middlewares/business-middleware'
+import { warehouseMiddleware } from '../../../../middlewares/warehouse-middleware'
+
+const debug = require('debug')('things-factory:operato-hub:restful-api:v2:add-inbound-order')
+
+router.post(
+  '/v2/warehouse/:warehouseId/add-inbound-order',
+  businessMiddleware,
+  warehouseMiddleware,
+  async (context, next) => {
+    const { client, domain } = context.state
+    const { warehouseId } = context.params
+    const { t } = context
+    const attachments = undefined
+    let bodyReq = context.request.body
+
+    if (!warehouseId) context.throw(404, t('error.warehouse id not found'))
+
+    if (typeof bodyReq === undefined || !Object.keys(bodyReq)?.length) {
+      context.throw(400, t('error.invalid body request format'))
+    }
+
+    await checkMandatoryKey(context, bodyReq)
+    debug('post:/add-inbound-order request.body', bodyReq)
+
+    // get customer company's bizplace
+    const custCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, warehouseId)
+    const customerBizplace: Bizplace = await getRepository(Bizplace).findOne({
+      where: { id: warehouseId }
+    })
+
+    //#1 to get all product list
+    const productDetails: ProductDetail[] = await getRepository(ProductDetail).find({
+      where: {
+        domain: custCompanyBizplace.domain,
+        refCode: In(bodyReq.orderProducts.map(orderProduct => orderProduct.product.sku))
+      },
+      relations: ['product']
+    })
+
+    //#2 assign product id found to order product
+    bodyReq.orderProducts = bodyReq.orderProducts.map(orderProduct => {
+      productDetails.forEach(productDetail => {
+        const product: Product = productDetail.product
+        const packingType: string = productDetail.packingType
+        const packingSize: number = productDetail.packingSize
+
+        if (orderProduct.product.sku === productDetail.refCode) {
+          orderProduct.product.id = product.id
+
+          if (packingType) {
+            orderProduct.packingType = packingType
+            orderProduct.packingSize = packingSize
+            orderProduct.uom = productDetail.uom
+            orderProduct.uomValue = productDetail.uomValue
+            orderProduct.totalUomValue = `${(productDetail.uomValue * orderProduct.packQty).toFixed(2)} ${
+              productDetail.uom
+            }`
+          } else {
+            productDetail = productDetails.find(productDetail => productDetail.isDefault)
+
+            orderProduct.packingType = productDetail.packingType
+            orderProduct.packingSize = productDetail.packingSize
+            orderProduct.uom = productDetail.uom
+            orderProduct.uomValue = productDetail.uomValue
+            orderProduct.totalUomValue = `${(productDetail.uomValue * orderProduct.packQty).toFixed(2)} ${
+              productDetail.uom
+            }`
+          }
+        }
+      })
+
+      return orderProduct
+    })
+
+    //#3 check if product is not found
+    bodyReq.orderProducts.forEach(orderProduct => {
+      if (!orderProduct.product?.id) context.throw(404, t(`error.sku code ${orderProduct.product.sku} is not exist`))
+    })
+
+    //#4 include supplier id if there's any
+    if (bodyReq?.supplier) {
+      const supplierInfo = bodyReq.supplier
+      const foundSupplier: ContactPoint = await getRepository(ContactPoint).findOne({
+        where: {
+          domain,
+          bizplace: warehouseId,
+          name: supplierInfo.name,
+          companyName: supplierInfo.companyName,
+          email: supplierInfo.email,
+          accountNo: supplierInfo.accountNo,
+          type: 'SUPPLIER'
+        }
+      })
+
+      if (foundSupplier) bodyReq.supplier = foundSupplier.id
+      else context.throw(404, t('error.supplier not found'))
+    }
+
+    context.body = {
+      result: (
+        await client.mutate({
+          mutation: gql`
+            mutation addArrivalNotice($arrivalNotice: NewArrivalNotice!, $attachments: Upload) {
+              addArrivalNotice(arrivalNotice: $arrivalNotice, file: $attachments) {
+                name
+                refNo
+                etaDate
+                containerNo
+                ownTransport
+                crossDocking
+                releaseGood {
+                  name
+                }
+                etaDate
+                looseItem
+                deliveryOrderNo
+                status
+                truckNo
+                refNo
+                importCargo
+                orderProducts {
+                  batchId
+                  product {
+                    sku
+                    name
+                    description
+                    packingType
+                    type
+                  }
+                  packingType
+                  uom
+                  uomValue
+                  packQty
+                  totalUomValue
+                  palletQty
+                }
+                orderVass {
+                  vas {
+                    name
+                    operationGuide
+                    operationGuideType
+                  }
+                  set
+                  targetType
+                  targetBatchId
+                  targetProduct {
+                    name
+                    description
+                  }
+                  packingType
+                  qty
+                  uomValue
+                  otherTarget
+                  description
+                  remark
+                  operationGuide
+                }
+                supplier {
+                  companyName
+                  name
+                  phone
+                  email
+                  address
+                }
+              }
+            }
+          `,
+          variables: { arrivalNotice: { ...bodyReq, warehouseId }, attachments },
+          context: {
+            ...context,
+            hasUpload: true,
+            state: {
+              ...context.state,
+              bizplace: customerBizplace,
+              domain,
+              type: 'api'
+            }
+          }
+        } as any)
+      ).data
+    }
+  }
+)
+
+export function checkMandatoryKey(context, params) {
+  let noparams = []
+
+  if ('container' in params) {
+    if (params.container === true) {
+      if (!params.hasOwnProperty('containerNo') || !params.hasOwnProperty('containerSize')) {
+        noparams.push('containerInfo')
+      }
+    }
+  }
+
+  if ('orderProducts' in params) {
+    params.orderProducts.forEach((param, key) => {
+      let noSubParams = []
+
+      if (!param.batchId) noSubParams.push('batchId')
+
+      if (!param.packQty) noSubParams.push('packQty')
+
+      if (!param.product.sku) noSubParams.push('sku')
+
+      if (noSubParams?.length)
+        context.throw(400, context.t('error.required param x not found', { x: `${noSubParams.join(', ')}` }))
+    })
+  } else {
+    noparams.push('orderProducts')
+  }
+
+  if ('etaDate' in params) {
+    const etaDate = new Date(params.etaDate)
+
+    if (isNaN(etaDate.getDate())) context.throw(400, context.t('error.eta date is invalid'))
+  }
+
+  if ('supplier' in params) {
+    const supplierInfo = params.supplier
+    if (!supplierInfo?.name)
+      context.throw(400, context.t('error.required param x not found', { x: 'supplierInfo.name' }))
+    if (!supplierInfo?.companyName)
+      context.throw(400, context.t('error.required param x not found', { x: 'supplierInfo.companyName' }))
+    if (!supplierInfo?.email)
+      context.throw(400, context.t('error.required param x not found', { x: 'supplierInfo.email' }))
+    if (!supplierInfo?.accountNo)
+      context.throw(400, context.t('error.required param x not found', { x: 'supplierInfo.accountNo' }))
+  }
+
+  if (noparams.length > 0) {
+    context.throw(400, context.t('error.required param x not found', { x: `${noparams.join(', ')}` }))
+  }
+}

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

@@ -0,0 +1,172 @@
+/** Customer list to inform when there are changes */
+/** 1. Bridzia */
+/** 2. Sweetmag */
+
+import gql from 'graphql-tag'
+import { EntityManager, getConnection } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { createPayloadLog, PayloadType } from '@things-factory/integration-base'
+import { MarketplaceOrder } from '@things-factory/marketplace-base'
+
+import { businessMiddleware } from '../../../../middlewares/business-middleware'
+import { storeMiddleware } from '../../../../middlewares/store-middleware'
+
+const debug = require('debug')('things-factory:operato-hub:restful-api:unstable:add-marketplace-order')
+const apiVersion = 'v2'
+
+router.post(
+  `/${apiVersion}/warehouse/:storeId/add-marketplace-order`,
+  businessMiddleware,
+  storeMiddleware,
+  async (context, next) => {
+    return await getConnection().transaction(async (tx: EntityManager) => {
+      const { client, marketplaceStore, domain } = context.state
+      const { t } = context
+      const bodyReq = context.request.body
+
+      if (typeof bodyReq === undefined || !Object.keys(bodyReq)?.length) {
+        context.throw(400, t('error.invalid body request format'))
+      }
+
+      await checkMandatoryKey(context, bodyReq)
+      debug('post:/add-marketplace-order body request', bodyReq)
+
+      let existingMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { name: bodyReq.name, domain, marketplaceStore }
+      })
+
+      if (existingMarketplaceOrder) {
+        context.throw(400, `error.duplicate entry for order ${bodyReq.name}`)
+      }
+
+      context.body = {
+        result: (
+          await client.mutate({
+            mutation: gql`
+              mutation generateMarketplaceOrder($marketplaceOrder: NewMarketplaceOrder!) {
+                generateMarketplaceOrder(marketplaceOrder: $marketplaceOrder) {
+                  id
+                  orderNo
+                  currency
+                  itemCount
+                  totalAmount
+                  paymentMethod
+                  remark
+                  giftOption
+                  orderCreatedAt
+                  orderUpdatedAt
+                  marketplaceStore {
+                    storeId
+                  }
+                  marketplaceOrderItems {
+                    id
+                    name
+                    qty
+                    cancelBy
+                    returnStatus
+                    paidPrice
+                    packageId
+                    invoiceNo
+                    status
+                    marketplaceOrderShippingItems {
+                      marketplaceOrderShipping {
+                        attentionTo
+                        address1
+                        address2
+                        address3
+                        address4
+                        address5
+                        state
+                        city
+                        postCode
+                        country
+                        phone1
+                        phone2
+                        email
+                        orderType
+                        freightType
+                        parcelType
+                        goodsType
+                        deliveryMethod
+                        totalWeight
+                        totalVolume
+                        transporter
+                      }
+                    }
+                    marketplaceProductVariation {
+                      id
+                      sku
+                      variationId
+                      variationSku
+                      channelSku
+                      name
+                      costPrice
+                      sellPrice
+                      marketplaceStatus
+                    }
+                  }
+                }
+              }
+            `,
+            variables: { marketplaceOrder: bodyReq },
+            context: {
+              ...context,
+              state: {
+                ...context.state,
+                marketplaceStore,
+                domain,
+                type: 'api'
+              }
+            }
+          } as any)
+        ).data
+      }
+
+      createPayloadLog(
+        marketplaceStore.id,
+        `/${apiVersion}/warehouse/:storeId/add-marketplace-order`,
+        bodyReq,
+        context.body.result,
+        context,
+        PayloadType.INGESTION,
+        'hub-api'
+      )
+    })
+  }
+)
+
+export function checkMandatoryKey(context, params) {
+  let noparams = []
+
+  if (!params?.orderNo) {
+    noparams.push('orderNo')
+  }
+
+  if (!params?.status) {
+    noparams.push('status')
+  }
+
+  if (params.marketplaceOrderItems) {
+    params.marketplaceOrderItems.forEach(param => {
+      let noSubParams = []
+
+      if (!param?.qty) noSubParams.push('qty')
+
+      if (!param?.status) noSubParams.push('status')
+
+      if (!param?.marketplaceProductVariation) noSubParams.push('marketplaceProductVariation')
+
+      if (!param?.marketplaceProductVariation?.variationId) noSubParams.push('variationId')
+
+      if (noSubParams?.length)
+        context.throw(400, context.t('error.required param x not found', { x: `${noSubParams.join(', ')}` }))
+    })
+  } else {
+    noparams.push('marketplaceOrderItems')
+  }
+
+  if (noparams.length > 0) {
+    context.throw(400, context.t('error.required param x not found', { x: `${noparams.join(', ')}` }))
+  }
+}

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

@@ -0,0 +1,112 @@
+import gql from 'graphql-tag'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
+
+import { businessMiddleware } from '../../../../middlewares/business-middleware'
+import { warehouseMiddleware } from '../../../../middlewares/warehouse-middleware'
+
+const debug = require('debug')('things-factory:operato-hub:restful-api:v2:add-products')
+
+router.post(
+  '/v2/warehouse/:warehouseId/add-products',
+  businessMiddleware,
+  warehouseMiddleware,
+  async (context, next) => {
+    const { client, domain } = context.state
+    const { warehouseId } = context.params
+    const { t } = context
+    const bodyReq = context.request.body
+
+    if (!warehouseId) context.throw(404, t('error.warehouse id not found'))
+
+    if (typeof bodyReq === undefined || !Object.keys(bodyReq)?.length) {
+      context.throw(400, context.t('error.invalid body request format'))
+    }
+
+    const custCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, warehouseId)
+
+    await checkMandatoryKey(context, bodyReq)
+    debug('post:/add-product request.body', bodyReq)
+
+    let products = checkProductDetails(bodyReq)
+
+    context.body = {
+      result: (
+        await client.mutate({
+          mutation: gql`
+            mutation createProducts($products: [NewProduct!]!) {
+              createProducts(products: $products) {
+                id
+              }
+            }
+          `,
+          variables: { products },
+          context: {
+            ...context,
+            state: {
+              ...context.state,
+              bizplace: custCompanyBizplace,
+              domain: custCompanyBizplace?.domain
+            }
+          }
+        } as any)
+      ).data
+    }
+  }
+)
+
+export async function checkMandatoryKey(context, params) {
+  params.forEach((param, key) => {
+    let noparams = []
+
+    if (!param.sku) noparams.push('sku')
+
+    if (!param.name) noparams.push('name')
+
+    if (!param.type) noparams.push('type')
+
+    if (param?.productDetails) {
+      let noSubParams = []
+      if (param.productDetails.length == 0) {
+        context.throw(
+          400,
+          context.t('error.required param {x} not found in productDetails', {
+            x: 'gtin, packingType, packingSize, uom, uomValue'
+          })
+        )
+      } else {
+        param.productDetails.forEach((subParam, key) => {
+          if (!subParam.gtin) noSubParams.push('gtin')
+
+          if (!subParam.packingType) noSubParams.push('packingType')
+
+          if (!subParam.packingSize) noSubParams.push('packingSize')
+
+          if (!subParam.uom) noSubParams.push('uom')
+
+          if (!subParam.uomValue) noSubParams.push('uomValue')
+
+          if (noSubParams?.length)
+            context.throw(
+              400,
+              context.t('error.required param {x} not found in productDetails', { x: `${noSubParams.join(', ')}` })
+            )
+        })
+      }
+    }
+
+    if (noparams?.length)
+      context.throw(400, context.t('error.required param {x} not found', { x: `${noparams.join(', ')}` }))
+  })
+}
+
+function checkProductDetails(params) {
+  params.forEach(param => {
+    if (!param?.productDetails.some(pd => pd.isDefault)) {
+      param.productDetails[0].isDefault = true
+    }
+  })
+
+  return params
+}