@things-factory/operato-hub 4.3.122 → 4.3.123

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

@@ -0,0 +1,976 @@
+import { EntityManager, getConnection, getRepository, In, Not, Repository, SelectQueryBuilder, ILike } from 'typeorm'
+import { v4 as uuidv4 } from 'uuid'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
+import { generateId } from '@things-factory/id-rule-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,
+  ShippingOrder
+} from '@things-factory/sales-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS, LOCATION_TYPE } from '@things-factory/warehouse-base'
+import { GeoCountry } from '@things-factory/geography'
+
+import { businessMiddleware, loggingMiddleware, validationMiddleware } from '../middlewares'
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+
+const debug = require('debug')('things-factory:operato-hub:restful-api:unstable:add-release-order')
+const apiVersion = 'v1'
+
+router.post(
+  `/${apiVersion}/warehouse/add-release-order`,
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    return await getConnection().transaction(async (tx: EntityManager) => {
+      const { client, domain, user, application } = context.state
+      const { bizplaceId: customerBizplaceId } = context.request.body.data
+      const { t } = context
+      const bodyReq = context.request.body.data
+      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) throw new ApiError('E04', 'warehouse id not found')
+
+        if (typeof bodyReq === undefined || !Object.keys(bodyReq)?.length) {
+          throw new ApiError('E01', 'invalid body request format')
+        }
+        debug('post:/add-release-order request.body', 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']
+        })
+
+        // conditional validation
+        if (bodyReq.ownTransport && !bodyReq.collectionOrderNo) throw new ApiError('E03', 'collectionOrderNo')
+        if (bodyReq.exportOption && !bodyReq.shippingOrder) throw new ApiError('E03', 'shippingOrder')
+        if (bodyReq.exportOption && !bodyReq.ownTransport) throw new ApiError('E01', 'ownTransport')
+
+        bodyReq.exportOption
+        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,
+          platformCode: bodyReq?.platformCode,
+          platformCountry: bodyReq?.platformCountry,
+          platformName: bodyReq?.platformName,
+          discountAmount: bodyReq?.discountAmount,
+          taxAmount: bodyReq?.taxAmount,
+          shippingFee: bodyReq?.shippingFee,
+          shippingOrder: {
+            shipName: bodyReq?.shippingOrder.shipName,
+            containerNo: bodyReq?.shippingOrder.containerNo,
+            loadType: bodyReq?.shippingOrder?.loadType,
+            from: bodyReq?.shippingOrder?.from,
+            to: bodyReq?.shippingOrder?.to,
+            containerArrivalDate: bodyReq?.shippingOrder.containerArrivalDate,
+            containerLeavingDate: bodyReq?.shippingOrder.containerLeavingDate
+          }
+        }
+
+        // check existing order
+        await checkExistingOrder(releaseGood, customerBizplace, bodyReq?.checkDuplicationValidation, context, tx)
+
+        // massage data
+        massagedData = await massageOrderItems(releaseGood, bodyReq.orderInventories, context)
+
+        // validation
+        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) {
+              throw new ApiError('E01', 'INSUFFICIENT_STOCK')
+            }
+            console.log()
+          })
+        )
+
+        // 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 data = {
+          id: result.id,
+          roNo: 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,
+          platformCode: result?.platformCode,
+          platformCountry: result?.platformCountry,
+          platformName: result?.platformName,
+          discountAmount: result?.discountAmount,
+          taxAmount: result?.taxAmount,
+          shippingFee: result?.shippingFee,
+          bizplace: { name: result.bizplace.name },
+          domain: { name: result.domain.name },
+          orderInventories: result.orderInventories
+        }
+        // return body
+        context.body = { result: { data } }
+      } catch (error) {
+        if (error.details) {
+          if (error.details == 'INSUFFICIENT_STOCK' && requiredDraft) {
+            const result = await createDraftOrder(releaseGood, massagedData.orderProducts, context)
+            let data = {
+              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,
+              platformCode: result?.platformCode,
+              platformCountry: result?.platformCountry,
+              platformName: result?.platformName,
+              discountAmount: result?.discountAmount,
+              taxAmount: result?.taxAmount,
+              shippingFee: result?.shippingFee,
+              bizplace: { name: result.bizplace.name },
+              domain: { name: result.domain.name }
+            }
+            context.body = { result: { data } }
+          } else {
+            if (error instanceof ApiError) ApiErrorHandler(context, error)
+            else throwInternalServerError(context, error)
+          }
+        } else {
+          if (error instanceof ApiError) ApiErrorHandler(context, error)
+          else throwInternalServerError(context, error)
+        }
+      }
+    })
+  }
+)
+
+async function checkExistingOrder(releaseGood, bizplace, checkDuplicationValidation = true, context, tx) {
+  const { domain, user }: { domain: Domain; user: 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,
+        refNo: refNo || null,
+        refNo2: refNo2 || null,
+        refNo3: refNo3 || null,
+        status: Not(In([DRAFT_RELEASE_ORDER_STATUS.CANCELLED]))
+      }
+    })
+
+    if (foundDraftReleaseGood) {
+      throw new ApiError('E05', `existing draft release order found: ${foundDraftReleaseGood.name}`)
+    }
+
+    const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({ 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: domain,
+          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: customerCompanyDomain }
+        })
+
+        // Need to restructure the validation
+        if (marketplaceOrder?.isSplitted) {
+          const refNo2: string = releaseGood.refNo2
+          const foundSplittedReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+            where: {
+              domain,
+              refNo2,
+              status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]))
+            },
+            relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
+          })
+
+          if (foundSplittedReleaseGood)
+            throw new ApiError('E05', `existing release order found: ${foundSplittedReleaseGood.name}`)
+        } else {
+          throw new ApiError('E05', `existing release order found: ${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> {
+  const { domain, user }: { domain: Domain; user: User } = context.state
+  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+  const geoCountryRepo: Repository<GeoCountry> = tx?.getRepository(GeoCountry) || getRepository(GeoCountry)
+
+  if (orderProducts.length <= 0) {
+    throw new ApiError('E04', `no order items found: ${JSON.stringify(releaseGood)}`)
+  }
+
+  let newReleaseGood: ReleaseGood = new ReleaseGood()
+
+  // find RO number rule setting
+  const roNoSetting: Setting = await settingRepo.findOne({
+    where: {
+      domain,
+      name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
+    }
+  })
+
+  let shippingOrder: ShippingOrder
+  if (releaseGood?.shippingOrder) {
+    shippingOrder = await tx.getRepository(ShippingOrder).save({
+      name: OrderNoGenerator.shippingOrder(),
+      shipName: releaseGood.shippingOrder.shipName,
+      containerNo: releaseGood.shippingOrder.containerNo,
+      loadType: releaseGood.shippingOrder.loadType,
+      from: releaseGood.shippingOrder.from,
+      to: releaseGood.shippingOrder.to,
+      containerArrivalDate: releaseGood.shippingOrder.containerArrivalDate,
+      containerLeavingDate: releaseGood.shippingOrder.containerLeavingDate,
+      status: ORDER_STATUS.PENDING,
+      creator: user,
+      updater: user
+    })
+  }
+
+    // standardise country
+    let deliveryCountry: GeoCountry = releaseGood?.country ? await geoCountryRepo.findOne({
+      where: [{ name: ILike(releaseGood?.country) }, { description: ILike(releaseGood?.country) }]
+    }) : null
+
+    let platformCountry: GeoCountry = releaseGood?.platformCountry ? await geoCountryRepo.findOne({
+      where: [{ name: ILike(releaseGood.platformCountry) }, { description: ILike(releaseGood.platformCountry) }]
+    }) : null
+
+  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: deliveryCountry?.description || 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,
+    platformCode: releaseGood?.platformCode,
+    platformCountry: platformCountry?.description || releaseGood?.platformCountry || null,
+    platformName: releaseGood?.platformName,
+    discountAmount: releaseGood?.discountAmount,
+    taxAmount: releaseGood?.taxAmount,
+    shippingFee: releaseGood?.shippingFee,
+    creator: user,
+    updater: user,
+    acceptedBy: user,
+    acceptedAt: new Date(),
+    shippingOrder: shippingOrder ? shippingOrder : null
+  }
+
+  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
+}
+
+async function massageOrderItems(
+  releaseGood,
+  inputOrderProducts,
+  context
+): Promise<{ orderProducts: OrderProduct[]; combinedItems: OrderProduct[] }> {
+  const { t } = context
+  let orderProducts: OrderProduct[] = []
+  //combine any repeated skus
+  inputOrderProducts = inputOrderProducts.reduce((acc, itm, idx) => {
+    let { sku, refCode } = itm.product
+    let { packingType, packingSize, batchId, releaseQty, sellingPrice, paidAmount } = itm
+
+    if (!sku && !refCode) {
+      throw new ApiError('E01', 'sku or refCode not found')
+    }
+
+    if (releaseQty <= 0) {
+      throw new ApiError('E01', 'negative stock request')
+    }
+    if (releaseQty % 1 !== 0) throw new ApiError('E01', `releaseQty is not an integer: ${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,
+        sellingPrice: sellingPrice,
+        paidAmount: paidAmount
+      })
+    }
+
+    return acc
+  }, [])
+
+  //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) {
+        throw new ApiError('E04', t('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) {
+          throw new ApiError('E04', '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) {
+            throw new ApiError('E04', t(`error.sku ${sku} and refCode ${refCode} not exist in product / bundle master`))
+          }
+
+          if (sku) {
+            throw new ApiError('E04', t(`error.sku ${sku} not exist in product / bundle master`))
+          }
+
+          if (refCode) {
+            throw new ApiError('E04', 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) {
+        throw new ApiError('E04', 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 }
+}
+
+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, 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 ApiError('E01', 'INSUFFICIENT_STOCK')
+      }
+
+      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
+}