@things-factory/operato-hub 4.3.120 → 4.3.123

package/server/routers/api/restful-apis/v1/warehouse/get-goods-received-note-list.ts

@@ -0,0 +1,105 @@
+import { Between, getRepository } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { GoodsReceivalNote } from '@things-factory/sales-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-goods-received-note-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      // get contact points for that bizplace
+      // optional query parameter filter
+      let filter = { ...context.query }
+      const { limit, offset, fromDate, toDate } = filter
+      filter['bizplace'] = filter['bizplaceId']
+      delete filter['bizplaceId']
+      filter['createdAt'] = Between(fromDate, toDate)
+
+      delete filter['fromDate']
+      delete filter['toDate']
+      delete filter['limit']
+      delete filter['offset']
+      const [goodsReceivedNotes, totalCount]: GoodsReceivalNote[] = await getRepository(GoodsReceivalNote).findAndCount(
+        {
+          where: filter,
+          relations: [
+            'bizplace',
+            'domain',
+            'arrivalNotice',
+            'arrivalNotice.orderProducts',
+            'arrivalNotice.orderProducts.product'
+          ],
+          skip: offset,
+          take: limit,
+          order: { createdAt: 'DESC' }
+        }
+      )
+
+      // create and format data response
+      let data = []
+      for (const goodsReceivedNote of goodsReceivedNotes) {
+        let orderProducts = []
+        for (const orderProduct of goodsReceivedNote.arrivalNotice.orderProducts) {
+          const orderProductsDataPoint = {
+            product: {
+              sku: orderProduct.product.sku,
+              brandSku: orderProduct.product.brandSku,
+              name: orderProduct.product.name,
+              description: orderProduct.product.description
+            },
+            type: orderProduct.type,
+            batchId: orderProduct.batchId,
+            packingType: orderProduct.packingType,
+            packingSize: orderProduct.packingSize,
+            releaseQty: orderProduct.releaseQty,
+            releaseUomValue: orderProduct.releaseUomValue,
+            status: orderProduct.status
+          }
+          orderProducts.push(orderProductsDataPoint)
+        }
+        const datapoint = {
+          id: goodsReceivedNote.id,
+          grnNo: goodsReceivedNote.grnNo,
+          refNo: goodsReceivedNote.refNo,
+          customerStatus: goodsReceivedNote.customerStatus,
+          status: goodsReceivedNote.status,
+          bizplace: {
+            id: goodsReceivedNote.bizplace.id,
+            name: goodsReceivedNote.bizplace.name,
+            description: goodsReceivedNote.bizplace.description
+          },
+          domain: {
+            id: goodsReceivedNote.domain.id,
+            name: goodsReceivedNote.domain.name
+          },
+          arrivalNotice: {
+            id: goodsReceivedNote.arrivalNotice.id,
+            ganNo: goodsReceivedNote.arrivalNotice.ganNo,
+            status: goodsReceivedNote.arrivalNotice.status,
+            refNo: goodsReceivedNote.arrivalNotice.refNo,
+            refNo2: goodsReceivedNote.arrivalNotice.refNo2,
+            refNo3: goodsReceivedNote.arrivalNotice.refNo3,
+            orderProducts
+          }
+        }
+        data.push(datapoint)
+      }
+
+      context.body = {
+        data,
+        totalCount,
+        limit,
+        offset
+      }
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)

package/server/routers/api/restful-apis/v1/warehouse/get-inbound-order-details.ts

@@ -0,0 +1,83 @@
+import { getRepository } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { ArrivalNotice } from '@things-factory/sales-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import _ from 'lodash'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-inbound-order-details',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      // get contact points for that bizplace
+      // optional query parameter filter
+      let filter = { ...context.query }
+      filter['bizplace'] = filter['bizplaceId']
+      delete filter['bizplaceId']
+      if (_.has(filter, 'ganNo')) {
+        filter['name'] = filter['ganNo']
+        delete filter['ganNo']
+      }
+
+      const arrivalNotice: ArrivalNotice = await getRepository(ArrivalNotice).findOne({
+        where: filter,
+        relations: ['orderProducts', 'orderProducts.product']
+      })
+
+      if (!arrivalNotice) {
+        throw new ApiError('E04', 'arrival notice')
+      }
+      // create and format data response
+      let orderProducts = []
+      for (const orderProduct of arrivalNotice.orderProducts) {
+        const orderProductsDataPoint = {
+          product: {
+            sku: orderProduct.product.sku,
+            uom: orderProduct.product.uom,
+            uomValue: orderProduct.product.uomValue
+          },
+          batchId: orderProduct.batchId,
+          packingType: orderProduct.packingType,
+          packingSize: orderProduct.packingSize,
+          qty: orderProduct.packQty,
+          palletQty: orderProduct.palletQty
+        }
+        orderProducts.push(orderProductsDataPoint)
+      }
+      const data = {
+        id: arrivalNotice.id,
+        ganNo: arrivalNotice.name,
+        refNo: arrivalNotice.refNo,
+        refNo2: arrivalNotice.refNo2,
+        refNo3: arrivalNotice.refNo3,
+        etaDate: arrivalNotice.etaDate,
+        ownTransport: arrivalNotice.ownTransport,
+        importCargo: arrivalNotice.importCargo,
+        container: arrivalNotice.container,
+        truckNo: arrivalNotice.truckNo,
+        deliveryOrderNo: arrivalNotice.deliveryOrderNo,
+        containerNo: arrivalNotice.containerNo,
+        containerSize: arrivalNotice.containerSize,
+        orderProducts,
+        supplier: {
+          name: arrivalNotice?.supplier?.name || null,
+          companyName: arrivalNotice?.supplier?.companyName || null,
+          email: arrivalNotice?.supplier?.email || null,
+          accountNo: arrivalNotice?.supplier?.accountNo || null
+        }
+      }
+
+      context.body = {
+        data
+      }
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)

package/server/routers/api/restful-apis/v1/warehouse/get-inbound-order-list.ts

@@ -0,0 +1,96 @@
+import { Between, getRepository } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { ArrivalNotice } from '@things-factory/sales-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import _ from 'lodash'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-inbound-order-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      // get contact points for that bizplace
+      // optional query parameter filter
+      let filter = { ...context.query }
+      const { fromDate, toDate, offset, limit } = filter
+      filter['bizplace'] = filter['bizplaceId']
+      delete filter['bizplaceId']
+      if (_.has(filter, 'ganNo')) {
+        filter['name'] = filter['ganNo']
+        delete filter['ganNo']
+      }
+      filter['createdAt'] = Between(fromDate, toDate)
+
+      delete filter['fromDate']
+      delete filter['toDate']
+      delete filter['limit']
+      delete filter['offset']
+      const [arrivalNotices, totalCount]: ArrivalNotice[] = await getRepository(ArrivalNotice).findAndCount({
+        where: filter,
+        relations: ['orderProducts', 'orderProducts.product'],
+        skip: offset,
+        take: limit,
+        order: { createdAt: 'DESC' }
+      })
+
+      // create and format data response
+      let data = []
+      for (const arrivalNotice of arrivalNotices) {
+        let orderProducts = []
+        for (const orderProduct of arrivalNotice.orderProducts) {
+          const orderProductsDataPoint = {
+            product: {
+              sku: orderProduct.product.sku,
+              uom: orderProduct.product.uom,
+              uomValue: orderProduct.product.uomValue
+            },
+            batchId: orderProduct.batchId,
+            packingType: orderProduct.packingType,
+            packingSize: orderProduct.packingSize,
+            qty: orderProduct.packQty,
+            palletQty: orderProduct.palletQty
+          }
+          orderProducts.push(orderProductsDataPoint)
+        }
+        const datapoint = {
+          id: arrivalNotice.id,
+          ganNo: arrivalNotice.ganNo,
+          refNo: arrivalNotice.refNo,
+          refNo2: arrivalNotice.refNo2,
+          refNo3: arrivalNotice.refNo3,
+          etaDate: arrivalNotice.etaDate,
+          ownTransport: arrivalNotice.ownTransport,
+          importCargo: arrivalNotice.importCargo,
+          container: arrivalNotice.container,
+          truckNo: arrivalNotice.truckNo,
+          deliveryOrderNo: arrivalNotice.deliveryOrderNo,
+          containerNo: arrivalNotice.containerNo,
+          containerSize: arrivalNotice.containerSize,
+          orderProducts,
+          supplier: {
+            name: arrivalNotice?.supplier?.name || null,
+            companyName: arrivalNotice?.supplier?.companyName || null,
+            email: arrivalNotice?.supplier?.email || null,
+            accountNo: arrivalNotice?.supplier?.accountNo || null
+          }
+        }
+        data.push(datapoint)
+      }
+
+      context.body = {
+        data,
+        totalCount,
+        limit,
+        offset
+      }
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)

package/server/routers/api/restful-apis/v1/warehouse/get-inventory-product-group-list.ts

@@ -0,0 +1,112 @@
+import { EntityManager, getConnection } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
+import { Product, ProductBundle } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+
+import { businessMiddleware, loggingMiddleware, validationMiddleware } from '../middlewares'
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+
+router.get(
+  '/v1/warehouse/get-inventory-product-group-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      // optional query parameter filter
+      let filter = { ...context.query }
+      const { limit, offset } = filter
+
+      delete filter['limit']
+      delete filter['offset']
+
+      await getConnection().transaction(async (tx: EntityManager) => {
+        let customerBizplaceId = filter.bizplaceId
+        const customerCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, customerBizplaceId, tx)
+
+        if (filter.hasOwnProperty('sku')) {
+          let product: Product = await tx.getRepository(Product).findOne({
+            where: { bizplace: customerCompanyBizplace, sku: filter['sku'] }
+          })
+
+          filter.productId = product?.id || null
+
+          if (!product) {
+            let productBundle: ProductBundle = await tx.getRepository(ProductBundle).findOne({
+              where: { bizplace: customerCompanyBizplace, sku: filter['sku'] }
+            })
+
+            filter.productBundleId = productBundle.id
+          }
+        }
+
+        const params: any = { filter, pagination: { page: offset, limit: limit } }
+
+        const { items, total } = await warehouseBizplaceOnhandInventory(customerBizplaceId, params, context, tx)
+
+        let data: any[] = items.map(item => {
+          return {
+            product: {
+              sku: item?.product?.sku || item?.productBundle?.sku,
+              name: item?.product?.name || item?.productBundle?.name,
+              description: item?.product?.description || item?.productBundle?.description,
+              type: item.groupType
+            },
+            batchId: item?.batchId,
+            packingType: item.packingType,
+            packingSize: item.packingSize,
+            qty: item.remainQty,
+            reservedQty: item.qty - item.remainQty,
+            uomValue: item.remainUomValue,
+            uom: item.uom
+          }
+        })
+
+        context.body = {
+          data,
+          totalCount: total,
+          limit,
+          offset
+        }
+      })
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)
+
+async function warehouseBizplaceOnhandInventory(
+  customerBizplaceId: string,
+  params,
+  context: any,
+  trxMgr: EntityManager
+) {
+  let filter = params.filter
+  const { domain }: { domain: Domain } = context.state
+
+  let qb = trxMgr
+    .getRepository('WarehouseBizplaceOnhandInventory')
+    .createQueryBuilder('wboi')
+    .leftJoinAndMapOne('wboi.product', Product, 'prd', 'prd.id = wboi."productId"')
+    .leftJoinAndMapOne('wboi.productBundle', ProductBundle, 'pb', 'pb.id = wboi."productBundleId"')
+    .where('wboi."bizplaceId"=:bizplaceId', { bizplaceId: customerBizplaceId })
+    .andWhere('wboi."domainId"=:domainId', { domainId: domain.id })
+
+  if (filter?.productId) {
+    qb.andWhere('wboi."productId"=:productId', { productId: filter.productId })
+  }
+
+  if (filter?.productBundleId) {
+    qb.andWhere('wboi."productBundleId"=:productBundleId', { productBundleId: filter.productBundleId })
+  }
+
+  qb.limit(params.pagination.limit).offset(params.pagination.page)
+
+  const items: any[] = await qb.getMany()
+  const { total } = await qb.select('COUNT(*)', 'total').getRawOne()
+
+  return { items, total: parseInt(total) }
+}

package/server/routers/api/restful-apis/v1/warehouse/get-onhand-inventory-list.ts

@@ -0,0 +1,90 @@
+import { Between, getRepository } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Inventory } from '@things-factory/warehouse-base'
+
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import _ from 'lodash'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-onhand-inventory-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      let filter = { ...context.query }
+      const { limit, offset, fromDate, toDate } = filter
+      filter['bizplace'] = filter['bizplaceId']
+      delete filter['bizplaceId']
+      if (_.has(filter, 'sku')) {
+        filter.product = { sku: filter['sku']}
+        delete filter['sku']
+      }
+      filter['createdAt'] = Between(fromDate, toDate)
+      filter['status'] = 'STORED'
+
+      delete filter['fromDate']
+      delete filter['toDate']
+      delete filter['limit']
+      delete filter['offset']
+
+      const [inventories, totalCount]: Inventory[] = await getRepository(Inventory).findAndCount({
+        where: filter,
+        relations: ['product', 'location'],
+        skip: offset,
+        take: limit,
+        order: { createdAt: 'DESC' }
+      })
+
+      let data = []
+      for (const inventory of inventories) {
+        const datapoint = {
+          id: inventory.id,
+          name: inventory.name,
+          palletId: inventory.palletId,
+          cartonId: inventory.cartonId,
+          batchId: inventory.batchId,
+          packingType: inventory.packingType,
+          packingSize: inventory.packingSize,
+          qty: inventory.qty,
+          reservedQty: inventory.lockedQty,
+          expirationDate: inventory.expirationDate,
+          weight: inventory.product.weight ? `${inventory.product.weight * inventory.qty} ${inventory.product.weightUnit}` : null,
+          lastSeq: inventory?.lastSeq,
+          status: 'STORED',
+          product: {
+            sku: inventory.product.sku,
+            name: inventory.product.name,
+            description: inventory.product.description,
+            type: inventory.product.type,
+            weightUnit: inventory.product.weightUnit,
+            weight: inventory.product.weight,
+            lengthUnit: inventory.product.lengthUnit,
+            width: inventory.product.width,
+            depth: inventory.product.depth,
+            height: inventory.product.height
+          },
+          location: {
+            name: inventory.location.name,
+            type: inventory.location.type,
+            zone: inventory.location.zone
+          }
+        }
+        data.push(datapoint)
+      }
+
+      context.body = {
+        data,
+        totalCount,
+        limit,
+        offset
+      }
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)

package/server/routers/api/restful-apis/v1/warehouse/get-release-order-details.ts

@@ -0,0 +1,99 @@
+import { getRepository } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { ReleaseGood } from '@things-factory/sales-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import _ from 'lodash'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-release-order-details',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      // get contact points for that bizplace
+      // optional query parameter filter
+      let filter = { ...context.query }
+      filter['bizplace'] = filter['bizplaceId']
+      delete filter['bizplaceId']
+      if (_.has(filter, 'roNo')) {
+        filter['name'] = filter['roNo']
+        delete filter['roNo']
+      }
+
+      const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+        where: filter,
+        relations: ['orderInventories', 'orderInventories.product']
+      })
+
+      if (!releaseGood) throw new ApiError('E04', `release order: ${filter['name']}`)
+
+      // create and format data response
+      let orderInventories = []
+      for (const orderInventory of releaseGood.orderInventories) {
+        const orderInventoriesDataPoint = {
+          product: {
+            sku: orderInventory.product.sku,
+            refCode: orderInventory.product.refCode
+          },
+          batchId: orderInventory.batchId,
+          packingType: orderInventory.packingType,
+          releaseQty: orderInventory.releaseQty,
+          packingSize: orderInventory.packingSize
+        }
+        orderInventories.push(orderInventoriesDataPoint)
+      }
+      const data = {
+        id: releaseGood.id,
+        roNo: releaseGood.roNo,
+        refNo: releaseGood.refNo,
+        refNo2: releaseGood.refNo2,
+        refNo3: releaseGood.refNo3,
+        type: releaseGood.type,
+        releaseDate: releaseGood.releaseDate,
+        collectionOrderNo: releaseGood.collectionOrderNo,
+        ownTransport: releaseGood.ownTransport,
+        exportOption: releaseGood.exportOption,
+        transporter: releaseGood.transporter,
+        trackingNo: releaseGood.trackingNo,
+        marketplaceOrderStatus: releaseGood.marketplaceOrderStatus,
+        airwayBill: releaseGood.airwayBill,
+        invoice: releaseGood.invoice,
+        storeName: releaseGood.storeName,
+        storeId: releaseGood.storeId,
+        routeId: releaseGood.routeId,
+        stopId: releaseGood.stopId,
+        billTo: {
+          billingAddress: releaseGood.billingAddress
+        },
+        deliverTo: {
+          deliveryAddress1: releaseGood.deliveryAddress1,
+          deliveryAddress2: releaseGood.deliveryAddress2,
+          deliveryAddress3: releaseGood.deliveryAddress3,
+          deliveryAddress4: releaseGood.deliveryAddress4,
+          deliveryAddress5: releaseGood.deliveryAddress5,
+          attentionTo: releaseGood.attentionTo,
+          attentionCompany: releaseGood.attentionCompany,
+          city: releaseGood.city,
+          state: releaseGood.state,
+          postalCode: releaseGood.postalCode,
+          country: releaseGood.country,
+          phone1: releaseGood.phone1,
+          phone2: releaseGood.phone2,
+          email: releaseGood.email
+        },
+        orderInventories
+      }
+
+      context.body = {
+        data
+      }
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)