@things-factory/operato-hub 4.3.78 → 4.3.79-alpha.0

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

@@ -0,0 +1,139 @@
+import { EntityManager, getConnection } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { ArrivalNotice, ReleaseGood, rejectReleaseGood } from '@things-factory/sales-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { expectedParams, reqParams } from '../utils/expected-parameters'
+import { validateBizplaceOfCompany, validateFilter, validateReqParams } from '../utils/validate-util'
+import _ from 'lodash'
+
+// import for cancelling Inbound Order Purpose
+import { ORDER_STATUS } from '@things-factory/sales-base'
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { OrderProduct, OrderVas, CollectionOrder } from '@things-factory/sales-base'
+import { ORDER_PRODUCT_STATUS, ORDER_VAS_STATUS } from '@things-factory/sales-base'
+import { getDomainUsers } from '@things-factory/biz-base'
+import { loggingMiddleware, businessMiddleware } from '../middlewares'
+
+router.post('/v1/warehouse/cancel-inbound-order', businessMiddleware, loggingMiddleware, async (context, next) => {
+  try {
+    //try to validate bizplace
+    validateReqParams(context.request.body, reqParams.cancelInboundOrder)
+    validateFilter(context.request.body, expectedParams.cancelInboundOrder)
+    validateReqParams(context.request.body.data, reqParams.cancelInboundOrderData)
+    validateFilter(context.request.body.data, expectedParams.cancelInboundOrderData)
+
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const validateArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+        where: { name: context.request.body.data.ganNo }
+      })
+      if (!validateArrivalNotice) throw new ApiError('E01', 'ganNo does not exist')
+
+      // take from arrival-notice-mutation (line 120)
+      const arrivalNotice: ArrivalNotice = await rejectArrivalNotice(
+        tx,
+        validateArrivalNotice.name,
+        context.request.body.data.remark,
+        context
+      )
+
+      if (arrivalNotice.crossDocking) {
+        const { releaseGood }: ReleaseGood = await tx.getRepository(arrivalNotice).findOne(arrivalNotice.id, {
+          relations: ['releaseGood']
+        })
+
+        if (releaseGood.status !== ORDER_STATUS.REJECTED) {
+          await rejectReleaseGood(tx, releaseGood.name, context.request.body.data.remark, context)
+        }
+      }
+
+      // what to show in response
+      const data = {
+        responseCode: '200',
+        message: 'success',
+        data: {
+          ganNo: arrivalNotice.name
+          //remark: arrivalNotice.remark // <-- is not needed to be seen
+        }
+      }
+
+      context.body = {
+        data
+      }
+    })
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+})
+
+async function rejectArrivalNotice(
+  tx: EntityManager,
+  name: string,
+  remark: string,
+  context: any
+): Promise<ArrivalNotice> {
+  const { user, domain }: { user: User; domain: Domain } = context.state
+
+  const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+    where: { name, status: ORDER_STATUS.PENDING_RECEIVE }, // try remove domain
+    relations: ['bizplace', 'orderProducts', 'orderVass', 'collectionOrders']
+  })
+
+  if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
+  if (!remark) throw new Error('Remark is not exist.')
+
+  let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
+  let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
+  let foundCOs: CollectionOrder[] = foundArrivalNotice.collectionOrders
+
+  // 1. Update status of order products (PENDING_RECEIVE => REJECTED)
+  foundOPs = foundOPs.map((op: OrderProduct) => {
+    op.status = ORDER_PRODUCT_STATUS.REJECTED
+    op.updater = user
+    return op
+  })
+  await tx.getRepository(OrderProduct).save(foundOPs)
+
+  // 2. Update status of order vass if it exists (PENDING_RECEIVE => REJECTED)
+  if (foundOVs && foundOVs.length) {
+    foundOVs = foundOVs.map((ov: OrderVas) => {
+      ov.status = ORDER_VAS_STATUS.REJECTED
+      ov.updater = user
+      return ov
+    })
+    await tx.getRepository(OrderVas).save(foundOVs)
+  }
+
+  // 3. If there's collection order, update status of collection order (PENDING_RECEIVE => REJECTED)
+  if (foundCOs) {
+    foundCOs = foundCOs.map((co: CollectionOrder) => {
+      co.status = ORDER_STATUS.REJECTED
+      co.updater = user
+      return co
+    })
+    await tx.getRepository(CollectionOrder).save(foundCOs)
+  }
+
+  foundArrivalNotice.remark = remark
+  foundArrivalNotice.status = ORDER_STATUS.REJECTED
+  foundArrivalNotice.updater = user
+  await tx.getRepository(ArrivalNotice).save(foundArrivalNotice)
+
+  // notification logics
+  const users: any[] = await getDomainUsers(foundArrivalNotice?.bizplace, tx)
+
+  // send notification to Customer Users
+  if (users?.length && context.header?.referer) {
+    const receivers: any[] = users.map(user => user.id)
+    const msg = {
+      title: `Latest status for ${foundArrivalNotice.name}`,
+      body: `Your GAN has been rejected.`,
+      url: context.header.referer,
+      data: { url: context.header.referer }
+    }
+  }
+  return foundArrivalNotice
+}

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

@@ -0,0 +1,144 @@
+import _ from 'lodash'
+import { Between, getRepository } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { DeliveryOrder } from '@things-factory/sales-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { validateFromToDate, validateLimitOffset } from '../utils/validate-util'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-delivery-order-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
+      const { fromDate, toDate } = validateFromToDate(context.query.fromDate, context.query.toDate)
+
+      // get contact points for that bizplace
+      // optional query parameter filter
+      let filter = { ...context.query }
+      filter['bizplace'] = filter['bizplaceId']
+      delete filter['bizplaceId']
+      if (_.has(filter, 'doNo')) {
+        filter['name'] = filter['doNo']
+        delete filter['doNo']
+      }
+      filter['createdAt'] = Between(fromDate, toDate)
+
+      delete filter['fromDate']
+      delete filter['toDate']
+      delete filter['limit']
+      delete filter['offset']
+      const [deliveryOrders, totalCount]: DeliveryOrder[] = await getRepository(DeliveryOrder).findAndCount({
+        where: filter,
+        relations: ['releaseGood', 'releaseGood.orderInventories', 'bizplace', 'domain'],
+        skip: offset,
+        take: limit,
+        order: { createdAt: 'DESC' }
+      })
+
+      // create and format data response
+      let data = []
+      for (const deliveryOrder of deliveryOrders) {
+        let orderInventories = []
+        for (const orderInventory of deliveryOrder.releaseGood.orderInventories) {
+          orderInventories.push(orderInventory)
+        }
+        const datapoint = {
+          id: deliveryOrder.id,
+          doNo: deliveryOrder.name,
+          from: deliveryOrder.from,
+          to: deliveryOrder.to,
+          contactPointRefId: deliveryOrder.contactPointRefId,
+          truckNo: deliveryOrder.truckNo,
+          deliveryDate: deliveryOrder.deliveryDate,
+          status: deliveryOrder.status,
+          ownCollection: deliveryOrder.ownCollection,
+          looseItem: deliveryOrder.looseItem,
+          deliveryDateTime: deliveryOrder.deliveryDateTime,
+          loadWeight: deliveryOrder.loadWeight,
+          cargoType: deliveryOrder.cargoType,
+          urgency: deliveryOrder.urgency,
+          telNo: deliveryOrder.telNo,
+          refNo: deliveryOrder.refNo,
+          otherDriver: deliveryOrder.otherDriver,
+          palletQty: deliveryOrder.palletQty,
+          remark: deliveryOrder.remark,
+          description: deliveryOrder.description,
+          reusablePallet: deliveryOrder.reusablePallet,
+          bizplace: {
+            id: deliveryOrder.bizplace.id,
+            name: deliveryOrder.bizplace.name,
+            description: deliveryOrder.bizplace.description
+          },
+          domain: {
+            id: deliveryOrder.domain.id,
+            name: deliveryOrder.domain.name
+          },
+          releaseGood: {
+            id: deliveryOrder.releaseGood.id,
+            roNo: deliveryOrder.releaseGood.name,
+            description: deliveryOrder.releaseGood.description,
+            status: deliveryOrder.releaseGood.status,
+            refNo: deliveryOrder.releaseGood.refNo,
+            refNo2: deliveryOrder.releaseGood.refNo2,
+            refNo3: deliveryOrder.releaseGood.refNo3,
+            truckNo: deliveryOrder.releaseGood.truckNo,
+            exportOption: deliveryOrder.releaseGood.exportOption,
+            ownTransport: deliveryOrder.releaseGood.ownTransport,
+            crossDocking: deliveryOrder.releaseGood.crossDocking,
+            releaseDateTime: deliveryOrder.releaseGood.releaseDateTime,
+            releaseDate: deliveryOrder.releaseGood.releaseDate,
+            remark: deliveryOrder.releaseGood.remark,
+            courierOption: deliveryOrder.releaseGood.courierOption,
+            packingOption: deliveryOrder.releaseGood.packingOption,
+            type: deliveryOrder.releaseGood.type,
+            acceptedAt: deliveryOrder.releaseGood.acceptedAt,
+            marketplaceOrderStatus: deliveryOrder.releaseGood.marketplaceOrderStatus,
+            billingAddress: deliveryOrder.releaseGood.billingAddress,
+            deliveryAddress1: deliveryOrder.releaseGood.deliveryAddress1,
+            deliveryAddress2: deliveryOrder.releaseGood.deliveryAddress2,
+            deliveryAddress3: deliveryOrder.releaseGood.deliveryAddress3,
+            deliveryAddress4: deliveryOrder.releaseGood.deliveryAddress4,
+            deliveryAddress5: deliveryOrder.releaseGood.deliveryAddress5,
+            attentionTo: deliveryOrder.releaseGood.attentionTo,
+            attentionCompany: deliveryOrder.releaseGood.attentionCompany,
+            city: deliveryOrder.releaseGood.city,
+            state: deliveryOrder.releaseGood.state,
+            postalCode: deliveryOrder.releaseGood.postalCode,
+            country: deliveryOrder.releaseGood.country,
+            phone1: deliveryOrder.releaseGood.phone1,
+            phone2: deliveryOrder.releaseGood.phone2,
+            email: deliveryOrder.releaseGood.email,
+            transporter: deliveryOrder.releaseGood.transporter,
+            trackingNo: deliveryOrder.releaseGood.trackingNo,
+            airwayBill: deliveryOrder.releaseGood.airwayBill,
+            invoice: deliveryOrder.releaseGood.invoice,
+            pickupAddress: deliveryOrder.releaseGood.pickupAddress,
+            pickupTime: deliveryOrder.releaseGood.pickupTime,
+            handoverType: deliveryOrder.releaseGood.handoverType,
+            dropoffAddress: deliveryOrder.releaseGood.dropoffAddress,
+            noOfItems: deliveryOrder.releaseGood.noOfItems,
+            orderProducts: []
+          },
+          orderInventories
+        }
+        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-goods-received-note-list.ts

@@ -0,0 +1,109 @@
+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 { validateFromToDate, validateLimitOffset } from '../utils/validate-util'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-goods-received-note-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
+      const { fromDate, toDate } = validateFromToDate(context.query.fromDate, context.query.toDate)
+
+      // get contact points for that bizplace
+      // optional query parameter filter
+      let filter = { ...context.query }
+      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' }
+        }
+      )
+      const limitedGoodsReceivedNotes: GoodsReceivalNote[] = goodsReceivedNotes.slice(offset, offset + limit)
+
+      // create and format data response
+      let data = []
+      for (const goodsReceivedNote of limitedGoodsReceivedNotes) {
+        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,74 @@
+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']
+    })
+
+    // 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,
+        packQty: 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,99 @@
+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 { validateFromToDate, validateLimitOffset } from '../utils/validate-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 {
+      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
+      const { fromDate, toDate } = validateFromToDate(context.query.fromDate, context.query.toDate)
+
+      // 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']
+      }
+      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,
+            packQty: 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)
+    }
+  }
+)