@things-factory/operato-hub 4.3.79-alpha.1 → 4.3.79

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

@@ -1,139 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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)
-    }
-  }
-)