@things-factory/operato-hub 6.1.83 → 6.1.85

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

@@ -1,1061 +0,0 @@
-import { EntityManager, getConnection, In, Not, Repository, SelectQueryBuilder } from 'typeorm'
-import { v4 as uuidv4 } from 'uuid'
-
-import { restfulApiRouter as router } from '@things-factory/api'
-import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
-import { logger } from '@things-factory/env'
-import { generateId } from '@things-factory/id-rule-base'
-import { createPayloadLog, PayloadType } from '@things-factory/integration-base'
-import { Sellercraft } from '@things-factory/integration-sellercraft'
-import { MarketplaceOrder } from '@things-factory/marketplace-base'
-import { ProductBundle, ProductDetail } from '@things-factory/product-base'
-import {
-  createDraftReleaseGoodFunction,
-  DRAFT_RELEASE_ORDER_STATUS,
-  DraftReleaseGood,
-  ORDER_INVENTORY_STATUS,
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  ORDER_PRODUCT_STATUS,
-  ORDER_STATUS,
-  ORDER_TYPES,
-  OrderInventory,
-  OrderNoGenerator,
-  OrderProduct,
-  ReleaseGood,
-  SellercraftController
-} from '@things-factory/sales-base'
-import { Setting } from '@things-factory/setting-base'
-import { Domain, getRepository } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS, LOCATION_TYPE } from '@things-factory/warehouse-base'
-
-import { ValidationError } from '../../../../errors/index'
-import { businessMiddleware } from '../../../../middlewares/business-middleware'
-import { warehouseMiddleware } from '../../../../middlewares/warehouse-middleware'
-
-const debug = require('debug')('things-factory:operato-hub:restful-api:unstable:add-release-order')
-const apiVersion = 'unstable'
-
-router.post(
-  `/${apiVersion}/warehouse/:warehouseId/add-release-order`,
-  businessMiddleware,
-  warehouseMiddleware,
-  async (context, next) => {
-    return await getConnection().transaction(async (tx: EntityManager) => {
-      const { client, domain, user, application } = context.state
-      const { warehouseId: customerBizplaceId } = context.params
-      const { t } = context
-      const bodyReq = context.request.body
-      const requiredDraft: Boolean = bodyReq.hasOwnProperty('requiredDraft') ? bodyReq.requiredDraft : true
-      let releaseGood
-      let massagedData = { orderProducts: [], combinedItems: [] }
-      // const isAutoAssign: Boolean = bodyReq.hasOwnProperty('isAutoAssign') ? bodyReq.isAutoAssign : true
-
-      try {
-        if (!customerBizplaceId) 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'))
-        }
-        debug('post:/add-release-order request.body', bodyReq)
-        await checkMandatoryKey(context, bodyReq)
-
-        // get customer company's bizplace
-        const custCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, customerBizplaceId, tx)
-        const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
-          where: { id: customerBizplaceId },
-          relations: ['domain']
-        })
-
-        releaseGood = {
-          domain,
-          bizplace: customerBizplace,
-          companyBizplace: custCompanyBizplace,
-          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,
-          transporter: bodyReq?.transporter,
-          trackingNo: bodyReq?.trackingNo,
-          airwayBill: bodyReq?.airwayBill,
-          invoice: bodyReq?.invoice,
-          packageId: bodyReq?.packageId,
-          storeName: bodyReq?.storeName,
-          storeId: bodyReq?.storeId,
-          routeId: bodyReq?.routeId,
-          stopId: bodyReq?.stopId,
-          source: application?.type
-        }
-
-        // check existing order
-        await checkExistingOrder(releaseGood, customerBizplace, bodyReq?.checkDuplicationValidation, context, tx)
-
-        //massage data
-        massagedData = await massageOrderItems(releaseGood, bodyReq.orderInventories, context)
-
-        // validation
-        let errorList = []
-        await Promise.all(
-          massagedData.combinedItems.map(async item => {
-            let itemList = await tx.query(
-              `
-            select wboi.* from warehouse_bizplace_onhand_inventories wboi 
-            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."remainQty" >= $7 and
-            wboi."remainUomValue" >= $8
-          `,
-              [
-                domain.id,
-                customerBizplace.id,
-                item.product.id,
-                item.packingType,
-                item.packingSize,
-                item.uom,
-                item.releaseQty,
-                item.releaseUomValue
-              ]
-            )
-            if (itemList.length <= 0) {
-              errorList.push(
-                JSON.stringify({
-                  code: 'insufficient stock',
-                  sku: item.product.sku,
-                  packingType: item.packingType,
-                  packingSize: item.packingSize,
-                  uom: item.uom,
-                  qty: item.releaseQty,
-                  uom_value: item.releaseUomValue
-                })
-              )
-            }
-            console.log()
-          })
-        )
-
-        if (errorList.length > 0) {
-          throw new ValidationError({
-            errorCode: 'INSUFFICIENT_STOCK',
-            message: 'insufficient stock',
-            detail: errorList.join(', ')
-          })
-        }
-        // assignment
-        // console.time('assign')
-        let assignedOrderProducts = await assignToInventory(massagedData.orderProducts, customerBizplace, context, tx)
-        // console.timeEnd('assign')
-
-        // create order
-        // console.time('save')
-        let result = await createReleaseGood(releaseGood, assignedOrderProducts, customerBizplace, context, tx)
-        // console.timeEnd('save')
-
-        let addReleaseGood = {
-          id: result.id,
-          name: result.name,
-          refNo: result.refNo,
-          refNo2: result.refNo2,
-          refNo3: result.refNo3,
-          status: result.status,
-          truckNo: result.truckNo,
-          ownTransport: result.ownTransport,
-          crossDocking: result.crossDocking,
-          marketplaceOrderStatus: result.marketplaceOrderStatus,
-          billingAddress: result.billingAddress,
-          deliveryAddress1: result.deliveryAddress1,
-          deliveryAddress2: result.deliveryAddress2,
-          deliveryAddress3: result.deliveryAddress3,
-          deliveryAddress4: result.deliveryAddress4,
-          deliveryAddress5: result.deliveryAddress5,
-          attentionTo: result.attentionTo,
-          attentionCompany: result.attentionCompany,
-          city: result.city,
-          state: result.state,
-          postalCode: result.postalCode,
-          country: result.country,
-          phone1: result.phone1,
-          phone2: result.phone2,
-          email: result.email,
-          transporter: result.transporter,
-          trackingNo: result.trackingNo,
-          airwayBill: result.airwayBill,
-          invoice: result.invoice,
-          type: result.type,
-          packageId: result.packageId,
-          storeName: result.storeName,
-          storeId: result.storeId,
-          routeId: result.routeId,
-          stopId: result.stopId,
-          exportOption: result.exportOption,
-          releaseDate: result.releaseDate,
-          collectionOrderNo: result.collectionOrderNo,
-          bizplace: { name: result.bizplace.name },
-          domain: { name: result.domain.name },
-          orderInventories: result.orderInventories
-        }
-        // return body
-        context.body = { result: { addReleaseGood } }
-        createPayloadLog(
-          customerBizplaceId,
-          `/${apiVersion}/warehouse/:warehouseId/add-release-order`,
-          bodyReq,
-          context.body,
-          context,
-          PayloadType.INGESTION
-        )
-      } catch (error) {
-        createPayloadLog(
-          customerBizplaceId,
-          `/${apiVersion}/warehouse/:warehouseId/add-release-order`,
-          bodyReq,
-          error,
-          context,
-          PayloadType.INGESTION
-        )
-
-        if (error.errorCode) {
-          if (error.errorCode == 'INSUFFICIENT_STOCK' && requiredDraft) {
-            const result = await createDraftOrder(releaseGood, massagedData.orderProducts, context)
-            let createdDraftOrder = {
-              id: result.id,
-              name: result.name,
-              refNo: result.refNo,
-              refNo2: result.refNo2,
-              refNo3: result.refNo3,
-              status: result.status,
-              truckNo: result.truckNo,
-              ownTransport: result.ownTransport,
-              marketplaceOrderStatus: result.marketplaceOrderStatus,
-              billingAddress: result.billingAddress,
-              deliveryAddress1: result.deliveryAddress1,
-              deliveryAddress2: result.deliveryAddress2,
-              deliveryAddress3: result.deliveryAddress3,
-              deliveryAddress4: result.deliveryAddress4,
-              deliveryAddress5: result.deliveryAddress5,
-              attentionTo: result.attentionTo,
-              attentionCompany: result.attentionCompany,
-              city: result.city,
-              state: result.state,
-              postalCode: result.postalCode,
-              country: result.country,
-              phone1: result.phone1,
-              phone2: result.phone2,
-              email: result.email,
-              type: result.type,
-              packageId: result.packageId,
-              exportOption: result.exportOption,
-              releaseDate: result.releaseDate,
-              collectionOrderNo: result.collectionOrderNo,
-              bizplace: { name: result.bizplace.name },
-              domain: { name: result.domain.name }
-            }
-            context.body = { result: { createdDraftOrder } }
-          } else if (error.errorCode == 'EXISTING_ORDER') {
-            context.body = {
-              responseCode: 'E05',
-              message: error.message,
-              details: error.detail
-            }
-          } else {
-            logger.error(`add-release-order: ${JSON.stringify(error)}`)
-            context.throw(400, context.t(error))
-          }
-        } else {
-          logger.error(`add-release-order: ${JSON.stringify(error)}`)
-          context.throw(400, context.t(error))
-        }
-      }
-    })
-  }
-)
-
-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
-}
-
-async function checkExistingOrder(releaseGood, bizplace, checkDuplicationValidation = true, context, tx) {
-  const { domain, user } = context.state
-  const refNo: string = releaseGood.refNo
-  const refNo2: string = releaseGood.refNo2
-  const refNo3: string = releaseGood.refNo3
-
-  if (checkDuplicationValidation) {
-    const foundDraftReleaseGood: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).findOne({
-      where: {
-        domain: { id: domain.id },
-        refNo: refNo || null,
-        refNo2: refNo2 || null,
-        refNo3: refNo3 || null,
-        status: Not(In([DRAFT_RELEASE_ORDER_STATUS.CANCELLED]))
-      }
-    })
-
-    if (foundDraftReleaseGood) {
-      throw new ValidationError({
-        errorCode: 'EXISTING_ORDER',
-        message: 'existing draft release order found',
-        detail: foundDraftReleaseGood.name
-      })
-    }
-
-    const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOneBy({ domain: bizplace.domain })
-
-    if (sellercraft) {
-      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, bizplace.domain, user)
-      await sellercraftCtrl.checkExistingReleaseGood(sellercraft, releaseGood)
-    } else {
-      const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-        where: {
-          domain: { id: domain.id },
-          refNo,
-          status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]))
-        },
-        relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
-      })
-
-      if (foundReleaseGood) {
-        const customerCompanyDomain: Domain = foundReleaseGood.bizplace.company.domain
-        const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-          where: { orderNo: refNo, domain: { id: customerCompanyDomain.id } }
-        })
-
-        // Need to restructure the validation
-        if (marketplaceOrder?.isSplitted) {
-          const refNo2: string = releaseGood.refNo2
-          const foundSplittedReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-            where: {
-              domain: { id: domain.id },
-              refNo2,
-              status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]))
-            },
-            relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
-          })
-
-          if (foundSplittedReleaseGood)
-            throw new ValidationError({
-              errorCode: 'EXISTING_ORDER',
-              message: 'existing release order found',
-              detail: foundSplittedReleaseGood.name
-            })
-        } else {
-          throw new ValidationError({
-            errorCode: 'EXISTING_ORDER',
-            message: 'existing release order found',
-            detail: foundReleaseGood.name
-          })
-        }
-      }
-    }
-  }
-}
-
-async function createDraftOrder(releaseGood, orderProducts, context) {
-  return await getConnection().transaction(async (tx: EntityManager) => {
-    return await createDraftReleaseGoodFunction(null, releaseGood, orderProducts, null, [], context, tx)
-  })
-}
-
-async function createReleaseGood(
-  releaseGood: any,
-  orderProducts: OrderProduct[],
-  bizplace: Bizplace,
-  context: any,
-  tx?: EntityManager
-): Promise<ReleaseGood> {
-  try {
-    const { domain, user } = context.state
-    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-    if (orderProducts.length <= 0) {
-      throw new ValidationError({
-        errorCode: 'ITEM_NOT_FOUND',
-        message: 'no order items found',
-        detail: JSON.stringify(releaseGood)
-      })
-    }
-
-    let newReleaseGood: ReleaseGood = new ReleaseGood()
-
-    // find RO number rule setting
-    const roNoSetting: Setting = await settingRepo.findOne({
-      where: {
-        domain: { id: domain.id },
-        name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
-      }
-    })
-
-    newReleaseGood = {
-      name: roNoSetting
-        ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RO_NUMBER, seed: {} })
-        : OrderNoGenerator.releaseGood(),
-      domain: domain,
-      bizplace: bizplace,
-      collectionOrderNo: releaseGood.collectionOrderNo,
-      courierOption: releaseGood.courierOption,
-      exportOption: releaseGood.exportOption,
-      ownTransport: releaseGood.ownTransport,
-      packingOption: releaseGood.packingOption,
-      marketplaceOrderStatus: releaseGood?.marketplaceOrderStatus || null,
-      billingAddress: releaseGood?.billingAddress || null,
-      deliveryAddress1: releaseGood?.deliveryAddress1 || null,
-      deliveryAddress2: releaseGood?.deliveryAddress2 || null,
-      deliveryAddress3: releaseGood?.deliveryAddress3 || null,
-      deliveryAddress4: releaseGood?.deliveryAddress4 || null,
-      deliveryAddress5: releaseGood?.deliveryAddress5 || null,
-      attentionTo: releaseGood?.attentionTo || null,
-      attentionCompany: releaseGood?.attentionCompany || null,
-      city: releaseGood?.city || null,
-      state: releaseGood?.state || null,
-      postalCode: releaseGood?.postalCode || null,
-      country: releaseGood?.country || null,
-      phone1: releaseGood?.phone1 || null,
-      phone2: releaseGood?.phone2 || null,
-      email: releaseGood?.email || null,
-      transporter: releaseGood?.transporter,
-      trackingNo: releaseGood?.trackingNo,
-      airwayBill: releaseGood?.airwayBill,
-      invoice: releaseGood?.invoice,
-      refNo: releaseGood.refNo,
-      refNo2: releaseGood.refNo2 || null,
-      refNo3: releaseGood.refNo3 || null,
-      remark: releaseGood?.remark || null,
-      releaseDate: releaseGood.releaseDate,
-      truckNo: releaseGood.truckNo,
-      type: releaseGood?.type ? releaseGood.type : 'b2b',
-      status: ORDER_STATUS.PENDING_WORKSHEET,
-      storeName: releaseGood?.storeName,
-      storeId: releaseGood?.storeId,
-      routeId: releaseGood?.routeId,
-      stopId: releaseGood?.stopId,
-      packageId: releaseGood?.packageId || null,
-      noOfItems: orderProducts.length,
-      source: releaseGood?.source,
-      creator: user,
-      updater: user,
-      acceptedBy: user,
-      acceptedAt: new Date()
-    }
-
-    let resultReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
-    let combinedOrderInventories: OrderInventory[] = []
-    let savedOrderProducts = await Promise.all(
-      orderProducts.map(async orderProduct => {
-        let orderInventories: OrderInventory[] = orderProduct.orderInventories
-        orderProduct = Object.assign(new OrderProduct(), {
-          ...orderProduct,
-          name: uuidv4(),
-          domain: domain,
-          bizplace: bizplace,
-          releaseGood: resultReleaseGood,
-          type: ORDER_TYPES.RELEASE_OF_GOODS,
-          status: ORDER_PRODUCT_STATUS.ASSIGNED
-        })
-        let result = await tx.getRepository(OrderProduct).save(orderProduct)
-
-        for (let oiIdx = 0; oiIdx < orderInventories.length; oiIdx++) {
-          let orderInventory = Object.assign(new OrderInventory(), {
-            ...orderInventories[oiIdx],
-            name: uuidv4(),
-            domain: domain,
-            bizplace: bizplace,
-            releaseGood: resultReleaseGood,
-            type: ORDER_TYPES.RELEASE_OF_GOODS,
-            status: ORDER_INVENTORY_STATUS.PENDING_WORKSHEET
-          })
-          await tx.getRepository(OrderInventory).save(orderInventory)
-
-          combinedOrderInventories.push({
-            product: { name: orderInventory.product.name, sku: orderInventory.product.sku },
-            batchId: orderInventory.batchId,
-            packingType: orderInventory.packingType,
-            packingSize: orderInventory.packingSize,
-            releaseQty: orderInventory.releaseQty,
-            releaseUomValue: orderInventory.releaseUomValue
-          })
-        }
-
-        return result
-      })
-    )
-
-    newReleaseGood.orderProducts = savedOrderProducts
-    newReleaseGood.orderInventories = combinedOrderInventories
-
-    return newReleaseGood
-  } catch (error) {
-    throw error
-  }
-}
-
-async function massageOrderItems(
-  releaseGood,
-  inputOrderProducts,
-  context
-): Promise<{ orderProducts: OrderProduct[]; combinedItems: OrderProduct[] }> {
-  const { t } = context
-  try {
-    let orderProducts: OrderProduct[] = []
-    let errorList = []
-    //combine any repeated skus
-    inputOrderProducts = inputOrderProducts.reduce((acc, itm, idx) => {
-      let { sku, refCode } = itm.product
-      let { packingType, packingSize, batchId, releaseQty } = itm
-
-      if (!sku && !refCode) {
-        errorList.push(
-          JSON.stringify({
-            code: 'INVALID_DATA',
-            message: 'sku or refCode not found',
-            sku: sku,
-            refCode: refCode,
-            packingType: packingType?.trim(),
-            packingSize: packingSize,
-            qty: releaseQty
-          })
-        )
-      }
-
-      if (releaseQty <= 0) {
-        errorList.push(
-          JSON.stringify({
-            code: 'INVALID_DATA',
-            message: 'negative stock request',
-            sku: sku,
-            refCode: refCode,
-            packingType: packingType?.trim(),
-            packingSize: packingSize,
-            qty: releaseQty
-          })
-        )
-      }
-
-      let existingIndex = acc.findIndex(
-        itm =>
-          itm?.sku == sku?.trim() &&
-          itm?.refCode == refCode?.trim() &&
-          itm?.packingType == packingType?.trim() &&
-          itm?.packingSize == packingSize
-      )
-
-      if (existingIndex >= 0 && releaseQty > 0) {
-        acc[existingIndex].releaseQty = acc[existingIndex].releaseQty + releaseQty
-      } else {
-        acc.push({
-          sku: sku?.trim(),
-          refCode: refCode?.trim(),
-          packingType: packingType?.trim(),
-          packingSize: packingSize,
-          releaseQty: releaseQty
-        })
-      }
-
-      return acc
-    }, [])
-
-    if (errorList.length > 0) {
-      throw new ValidationError({
-        errorCode: 'INVALID_DATA',
-        message: 'invalid data',
-        detail: errorList.join(', ')
-      })
-    }
-
-    //find customer sku in system
-    await Promise.all(
-      inputOrderProducts.map(async inputOrderItem => {
-        const sku: string = inputOrderItem.sku
-        const refCode: string = inputOrderItem.refCode
-        const packingType: string = inputOrderItem.packingType
-        const packingSize: string = inputOrderItem.packingSize
-
-        const qb: SelectQueryBuilder<ProductDetail> = getRepository(ProductDetail)
-          .createQueryBuilder('PD')
-          .innerJoinAndSelect('PD.product', 'PROD')
-          .where('PROD.bizplace_id = :bizplaceId', { bizplaceId: releaseGood.companyBizplace.id })
-
-        if (!sku && !refCode) {
-          context.throw(404, t('error.sku or refCode not found'))
-        }
-
-        if (refCode) {
-          qb.andWhere('PD.ref_code = :refCode', { refCode })
-        }
-
-        if (sku) {
-          qb.andWhere('PROD.sku = :sku', { sku })
-        }
-
-        if (packingType) {
-          qb.andWhere('PD.packing_type = :packingType', { packingType })
-        }
-
-        if ((!packingType && !refCode) || !packingSize) {
-          qb.andWhere('PD.is_default = :isDefault', { isDefault: true })
-        }
-
-        const productDetail: ProductDetail = await qb.getOne()
-
-        // order Product based on product detail
-        if (productDetail) {
-          let newOrderProduct: OrderInventory = Object.assign({}, inputOrderItem)
-          newOrderProduct = {
-            ...newOrderProduct,
-            product: productDetail.product,
-            productDetail: productDetail,
-            packingType: productDetail.packingType,
-            packingSize: packingSize || productDetail.packingSize,
-            uom: productDetail.uom,
-            uomValue: productDetail.uomValue,
-            refCode: inputOrderItem.refCode,
-            releaseQty: inputOrderItem.releaseQty,
-            releaseUomValue: inputOrderItem.releaseQty * (productDetail.uomValue || 1),
-            packQty: 0,
-            actualPackQty: 0,
-            palletQty: 0,
-            actualPalletQty: 0,
-            type: 'RELEASE_OF_GOODS',
-            status: ORDER_PRODUCT_STATUS.ASSIGNED,
-            batchId: '-'
-          }
-
-          newOrderProduct.orderInventories = [
-            {
-              ...newOrderProduct,
-              packQty: 0,
-              actualPackQty: 0,
-              palletQty: 0,
-              actualPalletQty: 0,
-              type: 'RELEASE_OF_GOODS',
-              status: ORDER_INVENTORY_STATUS.PENDING_WORKSHEET
-            }
-          ]
-
-          orderProducts.push(newOrderProduct)
-        }
-
-        if (!productDetail) {
-          const qb: SelectQueryBuilder<ProductDetail> = getRepository(ProductBundle)
-            .createQueryBuilder('PB')
-            .innerJoinAndSelect('PB.productBundleSettings', 'PBS')
-            .innerJoinAndSelect('PBS.productDetail', 'PBD')
-            .innerJoinAndSelect('PBD.product', 'PROD')
-            .where('PB.bizplace_id = :bizplaceId', { bizplaceId: releaseGood.companyBizplace.id })
-
-          if (!sku && !refCode) {
-            context.throw(404, t('error.sku or refCode not found'))
-          }
-
-          if (refCode) {
-            qb.andWhere('PB.ref_code = :refCode', { refCode })
-          }
-
-          if (sku) {
-            qb.andWhere('PB.sku = :sku', { sku })
-          }
-
-          if (packingType) {
-            qb.andWhere('PB.packing_type = :packingType', { packingType })
-          }
-
-          const foundProductBundle: ProductBundle = await qb.getOne()
-
-          if (foundProductBundle) {
-            let orderProduct = {
-              productBundle: foundProductBundle,
-              refCode,
-              packingType: foundProductBundle.packingType,
-              packingSize: packingSize || 1,
-              uom: inputOrderItem?.uom,
-              releaseQty: inputOrderItem.releaseQty,
-              releaseUomValue: inputOrderItem.releaseQty,
-              packQty: 0,
-              actualPackQty: 0,
-              palletQty: 0,
-              actualPalletQty: 0,
-              orderInventories: [],
-              type: 'RELEASE_OF_GOODS',
-              status: ORDER_PRODUCT_STATUS.ASSIGNED,
-              batchId: '-'
-            }
-
-            const bundleProductSettings: any[] = foundProductBundle.productBundleSettings
-            bundleProductSettings.map(bundleProductSetting => {
-              const productDetailBundle: ProductDetail = bundleProductSetting.productDetail
-
-              let newOrderInventory: OrderInventory = {
-                product: productDetailBundle.product,
-                productDetail: productDetailBundle,
-                sku: productDetailBundle.product.sku,
-                packingType: productDetailBundle.packingType,
-                packingSize: productDetailBundle.packingSize,
-                uom: productDetailBundle.uom,
-                packQty: 0,
-                actualPackQty: 0,
-                palletQty: 0,
-                actualPalletQty: 0,
-                releaseQty: inputOrderItem.releaseQty * bundleProductSetting.bundleQty,
-                releaseUomValue:
-                  inputOrderItem.releaseQty *
-                  bundleProductSetting.bundleQty *
-                  (productDetailBundle.uomValue <= 0 ? 1 : productDetailBundle.uomValue),
-                type: 'RELEASE_OF_GOODS',
-                status: ORDER_INVENTORY_STATUS.PENDING_WORKSHEET
-              }
-
-              orderProduct.orderInventories.push(newOrderInventory)
-            })
-            orderProducts.push(orderProduct)
-          } else {
-            if (sku && refCode) {
-              context.throw(404, t(`error.sku ${sku} and refCode ${refCode} not exist in product / bundle master`))
-            }
-
-            if (sku) {
-              context.throw(404, t(`error.sku ${sku} not exist in product / bundle master`))
-            }
-
-            if (refCode) {
-              context.throw(404, t(`error.refCode ${refCode} not exist in product / bundle master`))
-            }
-          }
-        }
-      })
-    )
-
-    //combine any repeated skus
-    let combinedItems: OrderProduct[] = orderProducts.reduce((acc, op, idx) => {
-      let oi = op?.orderInventories || []
-      oi.forEach(itm => {
-        let { sku, refCode } = itm.product
-        let { packingType, packingSize, batchId, releaseQty, product, productDetail, uom } = itm
-
-        if (!sku && !refCode) {
-          context.throw(404, t('error.sku or refCode not found'))
-        }
-        let existingIndex = acc.findIndex(
-          itm =>
-            itm?.sku == sku?.trim() &&
-            itm?.refCode == refCode?.trim() &&
-            itm?.packingType == packingType?.trim() &&
-            itm?.packingSize == packingSize &&
-            itm?.batchId == batchId?.trim() &&
-            itm?.uom == uom?.trim()
-        )
-
-        if (existingIndex >= 0 && releaseQty > 0) {
-          acc[existingIndex].releaseQty = acc[existingIndex].releaseQty + releaseQty
-          acc[existingIndex].releaseUomValue =
-            acc[existingIndex].releaseUomValue + releaseQty * (productDetail.uomValue <= 0 ? 1 : productDetail.uomValue)
-        } else {
-          let updateObj = {
-            sku: sku?.trim(),
-            packingType: packingType?.trim(),
-            packingSize: packingSize,
-            uom: uom?.trim(),
-            releaseQty: releaseQty,
-            releaseUomValue: releaseQty * (productDetail.uomValue <= 0 ? 1 : productDetail.uomValue),
-            product,
-            productDetail
-          }
-
-          if (refCode) updateObj['refCode'] = refCode.trim()
-          updateObj['batchId'] = batchId ? batchId?.trim() : '-'
-
-          acc.push(updateObj)
-        }
-      })
-      return acc
-    }, [])
-
-    return { orderProducts, combinedItems }
-  } catch (error) {
-    throw error
-  }
-}
-
-async function assignToInventory(orderProducts: OrderProduct[], customerBizplace, context, tx) {
-  const { client, domain, user } = context.state
-  for (let opIdx = 0; opIdx < orderProducts.length; opIdx++) {
-    let orderProduct = orderProducts[opIdx]
-
-    let assignedOrderInventories = []
-    const pickingProductSetting: Setting = await tx.getRepository(Setting).findOne({
-      where: { domain: { id: domain.id }, name: 'rule-for-picking-product' }
-    })
-
-    for (let oiIdx = 0; oiIdx < orderProducts[opIdx].orderInventories.length; oiIdx++) {
-      const orderInventory = orderProduct.orderInventories[oiIdx]
-      let sortings: any = []
-
-      switch (orderInventory.product.pickingStrategy) {
-        case 'LIFO':
-          sortings.push({ name: 'iv.created_at', desc: true })
-          if (pickingProductSetting?.value) {
-            for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
-              sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false })
-            }
-          } else {
-            sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false })
-          }
-
-          break
-        case 'FEFO':
-          sortings.push({ name: 'iv.expiration_date', desc: false }, { name: 'iv.created_at', desc: false })
-          if (pickingProductSetting?.value) {
-            for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
-              sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false })
-            }
-          } else {
-            sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false })
-          }
-
-          break
-        case 'FMFO':
-          sortings.push({ name: 'iv.manufacture_date', desc: false }, { name: 'iv.created_at', desc: false })
-          if (pickingProductSetting?.value) {
-            for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
-              sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false })
-            }
-          } else {
-            sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false })
-          }
-
-          break
-        case 'LOCATION':
-          if (pickingProductSetting?.value) {
-            for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
-              sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false })
-            }
-          } else {
-            sortings.push({ name: 'loc.name', desc: false }, { name: 'iv.created_at', desc: false })
-          }
-
-          break
-        //Every other case includes 'FIFO' will be applicable for this case
-        default:
-          sortings.push({ name: 'iv.created_at', desc: false })
-          if (pickingProductSetting?.value) {
-            for (const [key, value] of Object.entries(JSON.parse(pickingProductSetting.value))) {
-              sortings.push({ name: `loc.${key}`, desc: value == 'DESC' ? true : false })
-            }
-          } else {
-            sortings.push({ name: 'loc.name', desc: false })
-            sortings.push({ name: 'iv.pallet_id', desc: false })
-          }
-          break
-      }
-
-      let queryFilters = []
-
-      let queryStrings = queryFilters.reduce(
-        (acc, itm, idx, arr) => {
-          acc.values.push(itm.filters)
-
-          switch (itm?.operator) {
-            case 'notin':
-            case 'in':
-              acc.query.push(
-                `${itm.query} ${itm.operator == 'notin' ? 'NOT IN' : 'IN'} (${itm.filtes
-                  .map((itm, idx) => {
-                    return `$${acc.values.length + 1}`
-                  })
-                  .join(',')})`
-              )
-              break
-
-            default:
-              acc.query.push(`${itm.query} ${itm?.operator ? itm.operator : '='} $${acc.values.length + 1}`)
-              break
-          }
-          acc.query.push(`${itm.query} ${itm?.operator ? itm.operator : '='} $${acc.values.length + 1}`)
-        },
-        {
-          query: [],
-          values: []
-        }
-      )
-
-      let sortQuery = sortings
-        .map(itm => {
-          return `${itm.name} ${itm.desc ? 'DESC' : 'ASC'}`
-        })
-        .join(`,`)
-
-      let updatedInventories = await tx.getRepository(Inventory).query(
-        `
-        update inventories tgt set locked_qty = coalesce(locked_qty,0) + src.reserve_qty, 
-        locked_uom_value = coalesce(locked_uom_value,0) + src.reserve_uom_value,
-        updated_at = NOW(),
-        updater_id = $1
-        from (
-          select "id", "pallet_id","carton_id", "batch_id", "batch_id_ref", "unit", "uom", "packing_type", "packing_size", "manufacture_year",
-          "reserve_qty", (("uom_value"/"qty") * "reserve_qty") as "reserve_uom_value" from (	
-            select "sort_seq", "id", "pallet_id", "batch_id", "batch_id_ref", "unit", "uom", "packing_type", "packing_size", "manufacture_year", "carton_id", "uom_value", "locked_uom_value", "qty", "locked_qty", "created_at", 
-            "release_qty", "release_uom_value", lock_amount, 
-            case when "lock_amount" < 0 then "available_qty" else "available_qty" - "lock_amount" end as "reserve_qty"
-            from (
-              select *,
-              qty - locked_qty as available_qty,
-              sum(qty - locked_qty - release_qty) over (order by sort_seq asc rows between unbounded preceding and current row) as lock_amount
-              from (
-                SELECT 0 as sort_seq, null as id, null as pallet_id, null as batch_id, null as batch_id_ref, 
-                null as unit, '${orderInventory.uom}' as uom, '${orderInventory.packingType}' as packing_type, '${
-          orderInventory.packingSize
-        }' as packing_size,
-                null as manufacture_year, null as carton_id, 0 as uom_value, 0 as locked_uom_value, 0 as qty, 0 as locked_qty, null as created_at,
-                '${orderInventory.releaseQty}' as release_qty, '${orderInventory.releaseUomValue}' as release_uom_value
-                UNION
-                (
-                  SELECT ROW_NUMBER() OVER(PARTITION BY iv.domain_id ORDER BY ${sortQuery}) as sort_seq, 
-                  iv.id, iv.pallet_id, iv.batch_id, iv.batch_id_ref, 
-                  iv.unit, iv.uom, iv.packing_type, iv.packing_size, 
-                  iv.manufacture_year, iv.carton_id, iv.uom_value, 
-                  coalesce(iv.locked_uom_value,0) as locked_uom_value, iv.qty, coalesce(iv.locked_qty,0) as locked_qty, iv.created_at,
-                  0 as release_qty, 0 as release_uom_value
-                  FROM "inventories" "iv" 
-                  INNER JOIN "locations" "loc" ON "loc"."id"="iv"."location_id" 
-                  WHERE case when coalesce("iv"."locked_qty",0) < 0 then 0 else ("iv"."qty" - coalesce("iv"."locked_qty",0)) end > 0 AND 
-                   "iv"."domain_id" = $2 AND "iv"."bizplace_id" = $3 AND "iv"."packing_type" = $4 AND "iv"."packing_size" = $5 AND  "iv"."product_id" = $6 AND "iv"."status" = $7 AND "loc"."type" NOT IN ($8, $9)
-                  ${queryStrings.query.length > 0 ? `AND ${queryStrings.join(' AND ')}` : ''}
-                  ORDER BY ${sortQuery}
-                )
-              ) dt1
-            ) dt2 where case when "lock_amount" < 0 then "available_qty" else "available_qty" - "lock_amount" end > 0		
-          ) dt3 where sort_seq > 0
-        ) src where src.id = tgt.id
-        returning 
-          tgt."id", tgt."qty", tgt."pallet_id", tgt."carton_id", tgt."batch_id", tgt."batch_id_ref", tgt."unit", 
-          tgt."uom", tgt."packing_type", tgt."packing_size", tgt."manufacture_year", 
-          tgt."locked_qty", tgt."uom_value", tgt."locked_uom_value", src."reserve_qty", src."reserve_uom_value";`,
-        [
-          user.id,
-          domain.id,
-          customerBizplace.id,
-          orderInventory.packingType,
-          orderInventory.packingSize,
-          orderInventory.product.id,
-          INVENTORY_STATUS.STORED,
-          LOCATION_TYPE.QUARANTINE,
-          LOCATION_TYPE.RESERVE,
-          ...queryStrings.values
-        ]
-      )
-
-      let totalAssigned = updatedInventories[0].reduce((acc, inv) => {
-        return acc + inv.reserve_qty
-      }, 0)
-
-      if (orderInventory.releaseQty != totalAssigned) {
-        throw new ValidationError({
-          errorCode: 'INSUFFICIENT_STOCK',
-          message: 'insufficient stock',
-          detail: JSON.stringify({
-            code: 'insufficient stock',
-            sku: orderInventory.product.sku,
-            packingType: orderInventory.packingType,
-            packingSize: orderInventory.packingSize,
-            uom: orderInventory.uom,
-            qty: orderInventory.releaseQty,
-            uom_value: orderInventory.releaseUomValue
-          })
-        })
-      }
-
-      updatedInventories[0].forEach(inv => {
-        let oi = {
-          ...orderInventory,
-          inventory: { id: inv.id },
-          uom: inv.uom,
-          packingType: inv.packing_type,
-          batchId: inv.batch_id,
-          releaseQty: inv.reserve_qty,
-          releaseUomValue: inv.reserve_uom_value,
-          pickedQty: 0,
-          packedQty: 0,
-          type: ORDER_TYPES.RELEASE_OF_GOODS,
-          status: ORDER_INVENTORY_STATUS.PENDING_WORKSHEET,
-          domain: { id: domain.id },
-          bizplace: { id: customerBizplace.id }
-        }
-
-        assignedOrderInventories.push(oi)
-      })
-    }
-
-    orderProducts[opIdx].orderInventories = assignedOrderInventories
-  }
-
-  return orderProducts
-}