@things-factory/operato-hub 4.3.108 → 4.3.109

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."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
+            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
             wboi."uom" = $6 and
-            wboi."remain_qty" >= $7 and
-            wboi."remain_uom_value" >= $8
+            wboi."remainQty" >= $7 and
+            wboi."remainUomValue" >= $8
           `,
               [
                 domain.id,

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

@@ -0,0 +1,77 @@
+import { restfulApiRouter as router } from '@things-factory/api'
+import gql from 'graphql-tag'
+import { businessMiddleware } from '../../../../middlewares/business-middleware'
+import { warehouseMiddleware } from '../../../../middlewares/warehouse-middleware'
+
+const debug = require('debug')('things-factory:operato-hub:restful-api:v1:add-contact-point')
+
+router.post(
+  '/v1/warehouse/:warehouseId/add-contact-point',
+  businessMiddleware,
+  warehouseMiddleware,
+  async (context, next) => {
+    const { client, warehouse: bizplace, domain } = context.state
+    const { warehouseId } = context.params
+    const { t } = context
+    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, context.t('error.invalid body request format'))
+    }
+
+    await checkMandatoryKey(context, bodyReq)
+    debug('post:/add-contact-point request.body', bodyReq)
+
+    let patches: any[] = bodyReq.map(record => {
+      let patch = Object.assign({}, record)
+      patch.cuFlag = '+'
+
+      return patch
+    })
+
+    context.body = {
+      result: (
+        await client.query({
+          query: gql`
+            mutation updateMultipleContactPoint($patches: [ContactPointPatch]!) {
+              updateMultipleContactPoint(patches: $patches) {
+                name
+                companyName
+                phone
+                address
+                address2
+                city
+                state
+                postalCode
+                type
+                fax
+                email
+                address
+                billingAddress
+                accountNo
+              }
+            }
+          `,
+          variables: { patches },
+          context: {
+            ...context,
+            state: {
+              ...context.state,
+              bizplace,
+              domain
+            }
+          }
+        } as any)
+      ).data
+    }
+  }
+)
+
+export async function checkMandatoryKey(context, params) {
+  let noparams = ['name', 'email', 'phone', 'address', 'billingAddress', 'type'].filter(param => !(param in params))
+
+  if (noparams?.length)
+    context.throw(400, context.t('error.required param x not found', { x: `${noparams.join(', ')}` }))
+}

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

@@ -0,0 +1,196 @@
+import gql from 'graphql-tag'
+import { EntityManager, getConnection } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderInventory } from '@things-factory/sales-base'
+
+import { businessMiddleware } from '../../../../middlewares/business-middleware'
+import { warehouseMiddleware } from '../../../../middlewares/warehouse-middleware'
+
+const debug = require('debug')('things-factory:operato-hub:restful-api:unstable:add-draft-release-order')
+
+router.post(
+  '/v1/warehouse/:warehouseId/add-draft-release-order',
+  businessMiddleware,
+  warehouseMiddleware,
+  async (context, next) => {
+    return await getConnection().transaction(async (tx: EntityManager) => {
+      const { client, domain } = context.state
+      const { warehouseId: customerBizplaceId } = context.params
+      const { t } = context
+
+      if (!customerBizplaceId) context.throw(404, t('error.warehouse id not found'))
+
+      let bodyReq = context.request.body
+      if (typeof bodyReq === undefined || !Object.keys(bodyReq)?.length) {
+        context.throw(400, t('error.invalid body request format'))
+      }
+      debug('post:/add-draft-release-order request.body', bodyReq)
+      await checkMandatoryKey(context, bodyReq)
+
+      // get customer company's bizplace
+      const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+        where: { id: customerBizplaceId }
+      })
+
+      const orderInventories: OrderInventory[] = bodyReq.orderInventories
+
+      context.body = {
+        result: (
+          await client.mutate({
+            mutation: gql`
+              mutation upsertDraftReleaseGood(
+                $draftReleaseGood: DraftReleaseGoodPatch!
+                $orderProducts: [OrderProductPatch!]!
+                $files: [Upload!]
+              ) {
+                upsertDraftReleaseGood(
+                  draftReleaseGood: $draftReleaseGood
+                  orderProducts: $orderProducts
+                  files: $files
+                ) {
+                  id
+                  name
+                  refNo
+                  refNo2
+                  refNo3
+                  status
+                  truckNo
+                  ownTransport
+                  marketplaceOrderStatus
+                  billingAddress
+                  deliveryAddress1
+                  deliveryAddress2
+                  deliveryAddress3
+                  deliveryAddress4
+                  deliveryAddress5
+                  attentionTo
+                  attentionCompany
+                  city
+                  state
+                  postalCode
+                  country
+                  phone1
+                  phone2
+                  email
+                  type
+                  exportOption
+                  releaseDate
+                  collectionOrderNo
+                  bizplace {
+                    name
+                  }
+                  orderProducts {
+                    product {
+                      sku
+                      name
+                      description
+                    }
+                    packingType
+                    packingSize
+                    releaseQty
+                  }
+                }
+              }
+            `,
+            variables: {
+              draftReleaseGood: {
+                bizplace: {
+                  id: customerBizplace.id
+                },
+                courierOption: bodyReq.courierOption,
+                collectionOrderNo: bodyReq.collectionOrderNo,
+                exportOption: bodyReq.exportOption,
+                ownTransport: bodyReq.ownTransport,
+                packingOption: bodyReq.packingOption,
+                refNo: bodyReq.refNo,
+                refNo2: bodyReq?.refNo2,
+                refNo3: bodyReq?.refNo3,
+                releaseDate: bodyReq.releaseDate,
+                type: bodyReq.type,
+                marketplaceOrderStatus: bodyReq?.marketplaceOrderStatus,
+                remark: bodyReq?.remark || null,
+                billingAddress: bodyReq?.billTo?.billingAddress || null,
+                deliveryAddress1: bodyReq?.deliverTo?.deliveryAddress1 || null,
+                deliveryAddress2: bodyReq?.deliverTo?.deliveryAddress2 || null,
+                deliveryAddress3: bodyReq?.deliverTo?.deliveryAddress3 || null,
+                deliveryAddress4: bodyReq?.deliverTo?.deliveryAddress4 || null,
+                deliveryAddress5: bodyReq?.deliverTo?.deliveryAddress5 || null,
+                attentionTo: bodyReq?.deliverTo?.attentionTo || null,
+                attentionCompany: bodyReq?.deliverTo?.attentionCompany || null,
+                city: bodyReq?.deliverTo?.city || null,
+                state: bodyReq?.deliverTo?.state || null,
+                postalCode: bodyReq?.deliverTo?.postalCode || null,
+                country: bodyReq?.deliverTo?.country || null,
+                phone1: bodyReq?.deliverTo?.phone1 || null,
+                phone2: bodyReq?.deliverTo?.phone2 || null,
+                email: bodyReq?.deliverTo?.email || null
+              },
+              orderProducts: orderInventories,
+              files: []
+            },
+            context: {
+              ...context,
+              hasUpload: true,
+              state: {
+                ...context.state,
+                customerBizplace,
+                domain,
+                type: 'api'
+              }
+            }
+          } as any)
+        ).data
+      }
+    })
+  }
+)
+
+export async function checkMandatoryKey(context, params) {
+  let noparams = ['releaseDate', 'exportOption'].filter(param => !(param in params))
+
+  if ('ownTransport' in params) {
+    if (params.ownTransport == true) {
+      if (!params.hasOwnProperty('collectionOrderNo')) {
+        noparams.push('collectionOrderNo')
+      }
+    }
+  } else {
+    noparams.push('ownTransport')
+  }
+
+  if ('exportOption' in params) {
+    if (params.exportOption === true) {
+      if (
+        params.exportOption.filter(
+          record =>
+            !record.containerNo || !record.containerArrivalDate || !record.containerLeavingDate || !record.shipName
+        ).length
+      ) {
+        noparams.push('exportOption')
+      }
+    }
+  }
+
+  if ('orderInventories' in params) {
+    params.orderInventories.forEach((param, key) => {
+      let noSubParams = []
+
+      if (!param?.releaseQty) noSubParams.push('releaseQty')
+
+      if (!param?.product) noSubParams.push('product')
+
+      if (noSubParams?.length)
+        context.throw(400, context.t('error.required param x not found', { x: `${noSubParams.join(', ')}` }))
+    })
+  } else {
+    noparams.push('orderInventories')
+  }
+
+  if (noparams?.length) {
+    context.throw(400, context.t('error.required param x not found', { x: `${noparams.join(', ')}` }))
+  }
+
+  return params
+}

package/server/routers/api/restful-apis/v1/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:v1:add-inbound-order')
+
+router.post(
+  '/v1/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(', ')}` }))
+  }
+}