@things-factory/sales-base 4.0.24 → 4.0.28

package/server/controllers/order-controller.ts

@@ -1,9 +1,12 @@
+import { EntityManager, EntitySchema, FindOneOptions } from 'typeorm'
+
 import { Role, User } from '@things-factory/auth-base'
 import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
 import { sendNotification } from '@things-factory/notification'
+import { ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
-import { EntityManager, EntitySchema, FindOneOptions } from 'typeorm'
+
 import {
   ArrivalNotice,
   DeliveryOrder,
@@ -48,7 +51,9 @@ export type NotificationMsgInterface = {
 export class OrderController {
   public readonly ERROR_MSG = {
     FIND: {
-      NO_RESULT: (condition: any) => `There's no results matched with condition ${condition}`
+      NO_RESULT: (condition: any) => `There's no results matched with condition ${condition}`,
+      NO_CHILD_RESULT: (condition: any) => `There's no child result matched with condition ${condition}`,
+      NOT_MATCH: (source: any, target: any) => `Unable to find matching ${target} using ${source}`
     },
     CREATE: {
       ID_EXISTS: 'Target has ID already',
@@ -217,6 +222,54 @@ export class OrderController {
     return await this.trxMgr.getRepository(Inventory).save(inventory)
   }
 
+  async getChildPackingSize(
+    productDetails: ProductDetail[],
+    defaultProductDetail: ProductDetail,
+    unmatchingProductDetail: ProductDetail
+  ): Promise<number> {
+    let hasChildRelation: boolean = Boolean(unmatchingProductDetail?.childProductDetail)
+    let hasMatchingChild: boolean
+    let packingSize: number = 1
+    let currentChildProductDetail: ProductDetail
+
+    if (hasChildRelation) {
+      currentChildProductDetail = productDetails.find(
+        (productDetail: ProductDetail) => productDetail.id === unmatchingProductDetail.childProductDetail.id
+      )
+
+      if (!currentChildProductDetail) {
+        throw new Error(this.ERROR_MSG.FIND.NOT_MATCH('packing type', `GTIN (${unmatchingProductDetail.gtin})`))
+      }
+
+      hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id)
+      if (hasMatchingChild) {
+        packingSize = unmatchingProductDetail.packingSize
+      } else {
+        packingSize = unmatchingProductDetail.packingSize * packingSize
+      }
+    } else {
+      throw new Error(this.ERROR_MSG.FIND.NO_CHILD_RESULT(`${unmatchingProductDetail.gtin}`))
+    }
+
+    while (hasChildRelation && !hasMatchingChild) {
+      if (hasMatchingChild) {
+        packingSize = currentChildProductDetail.packingSize * packingSize // 12 x 10
+      } else if (!hasMatchingChild && hasChildRelation) {
+        packingSize = currentChildProductDetail.packingSize * packingSize // 12 x 10
+        currentChildProductDetail = productDetails.find(
+          (productDetail: ProductDetail) => productDetail.id === currentChildProductDetail.childProductDetail.id
+        )
+
+        hasChildRelation = Boolean(currentChildProductDetail?.childProductDetail)
+        hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id)
+      } else if (!hasChildRelation && !hasMatchingChild) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(unmatchingProductDetail.gtin))
+      }
+    }
+
+    return packingSize
+  }
+
   /**
    * @summary set common stamp like domain, creator, updater
    * @description Set common stamp to passed record

package/server/service/arrival-notice/arrival-notice-mutation.ts

@@ -1,6 +1,6 @@
 import { FileUpload, GraphQLUpload } from 'graphql-upload'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository, In, Repository } from 'typeorm'
+import { EntityManager, getConnection, getRepository, In, Repository } from 'typeorm'
 
 import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
@@ -38,10 +38,13 @@ import {
   ORDER_VAS_STATUS
 } from '../../constants'
 import { ATTACHMENT_TYPE } from '../../constants/attachment-type'
+import { ValidationError } from '../../errors'
 import { OrderNoGenerator } from '../../utils/order-no-generator'
 import { generateJobSheet } from '../job-sheet/job-sheet-mutation'
 import { confirmReleaseGood, deleteReleaseGood, rejectReleaseGood } from '../release-good/release-good-mutation'
+import { validateBulkArrivalNoticesFunction } from './'
 import { ArrivalNotice } from './arrival-notice'
+import { ArrivalNoticeList, RawArrivalNotice } from './arrival-notice-types'
 
 const debug = require('debug')('things-factory:operato-wms:addArrivalNotice')
 
@@ -230,6 +233,139 @@ export class ArrivalNoticeMutation {
     await tx.getRepository(ArrivalNotice).update(existingArrivalNotice.id, arrivalNotice)
     return await tx.getRepository(ArrivalNotice).findOne(existingArrivalNotice.id)
   }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ArrivalNoticeList)
+  async bulkGenerateArrivalNotices(
+    @Ctx() context: any,
+    @Arg('rawArrivalNotices', type => [NewArrivalNotice], { nullable: true }) rawArrivalNotices: NewArrivalNotice[],
+    @Arg('bizplaceId', type => String) bizplaceId: string
+  ): Promise<ArrivalNoticeList> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+    let createdArrivalNoticeIds: string[] = [],
+      createdOrderProductIds: string[] = [],
+      errorsCaught: any[] = [],
+      finalArrivalNoticeList: ArrivalNotice[] = []
+
+    const foundBizplace: Bizplace = await tx.getRepository(Bizplace).findOne(bizplaceId)
+
+    if (!foundBizplace) throw new Error('company not found')
+
+    // to check whether the raw data are valid
+    const validatedArrivalNotices: RawArrivalNotice[] = await validateBulkArrivalNoticesFunction(
+      rawArrivalNotices,
+      bizplaceId,
+      tx
+    )
+
+    // check for custom GAN order no setting
+    const ganNoSetting: Setting = await tx.getRepository(Setting).findOne({
+      where: {
+        domain,
+        name: ORDER_NUMBER_SETTING_KEY.GAN_NUMBER_RULE
+      }
+    })
+
+    // extract rawArrivalNotices data into normal ArrivalNotice format
+    let arrivalNotices: Partial<ArrivalNotice[]> = extractArrivalNotices(validatedArrivalNotices)
+
+    for (let i = 0, l = arrivalNotices.length; i < l; i++) {
+      try {
+        await getConnection().transaction(async childTx => {
+          // check for duplication
+          const duplicatedArrivalNotice: ArrivalNotice = await childTx.getRepository(ArrivalNotice).findOne({
+            where: {
+              refNo: arrivalNotices[i].refNo,
+              refNo2: arrivalNotices[i].refNo2,
+              refNo3: arrivalNotices[i].refNo3,
+              etaDate: arrivalNotices[i].etaDate,
+              truckNo: arrivalNotices[i].truckNo,
+              containerNo: arrivalNotices[i].containerNo,
+              containerSize: arrivalNotices[i].containerSize,
+              looseItem: arrivalNotices[i].looseItem,
+              importCargo: arrivalNotices[i].importCargo
+            }
+          })
+
+          if (duplicatedArrivalNotice) {
+            throw new Error(`duplicated with ${duplicatedArrivalNotice.name}`)
+          }
+
+          // save new arrival notice
+          const createdArrivalNotice: ArrivalNotice = await childTx.getRepository(ArrivalNotice).save({
+            ...arrivalNotices[i],
+            name: ganNoSetting
+              ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.GAN_NUMBER, seed: {} })
+              : OrderNoGenerator.arrivalNotice(),
+            domain,
+            bizplace: foundBizplace,
+            status: ORDER_STATUS.PENDING,
+            creator: user,
+            updater: user
+          })
+
+          // save new order products
+          let createdOrderProducts: OrderProduct[] = await Promise.all(
+            arrivalNotices[i].orderProducts.map(async (op: OrderProduct) => {
+              return {
+                ...op,
+                domain,
+                bizplace: foundBizplace,
+                name: OrderNoGenerator.orderProduct(),
+                // product: await childTx.getRepository(Product).findOne(op.product.id),
+                status: ORDER_PRODUCT_STATUS.PENDING,
+                arrivalNotice: createdArrivalNotice,
+                creator: user
+              }
+            })
+          )
+          createdOrderProducts = await childTx.getRepository(OrderProduct).save(createdOrderProducts)
+
+          // generate new jobsheet
+          await generateJobSheet(domain, user, createdArrivalNotice, childTx)
+
+          // push arrivalNotice and orderProducts IDs if successfully saved
+          createdArrivalNoticeIds.push(createdArrivalNotice.id)
+          createdOrderProductIds.push(...createdOrderProducts.map(op => op.id))
+        })
+      } catch (error) {
+        // collect the arrivalNotice details and its error
+        let rawArrivalNotices: RawArrivalNotice[] = formRawArrivalNotices(arrivalNotices[i], error.message)
+        errorsCaught.push(...rawArrivalNotices)
+      }
+    }
+
+    if (createdArrivalNoticeIds.length && createdOrderProductIds.length) {
+      await getConnection().transaction(async childTx => {
+        // update arrivalNotices status to PENDING_RECEIVE
+        await childTx
+          .getRepository(ArrivalNotice)
+          .update({ id: In(createdArrivalNoticeIds) }, { status: ORDER_STATUS.PENDING_RECEIVE, updater: user })
+
+        // update orderProducts status to PENDING_RECEIVE
+        await childTx
+          .getRepository(OrderProduct)
+          .update({ id: In(createdOrderProductIds) }, { status: ORDER_PRODUCT_STATUS.PENDING_RECEIVE, updater: user })
+
+        finalArrivalNoticeList = await childTx.getRepository(ArrivalNotice).find({
+          where: { id: In(createdArrivalNoticeIds) },
+          relations: ['orderProducts', 'orderProducts.product', 'bizplace']
+        })
+      })
+    }
+
+    if (errorsCaught.length) {
+      // should return this error list in the grist so that user know which gan need to amend
+      throw new ValidationError({
+        ...ValidationError.ERROR_CODES.INVALID_DATA_FOUND,
+        detail: { data: JSON.stringify(errorsCaught) }
+      })
+    }
+
+    // return arrivalNotices with its orderProducts list
+    return { items: finalArrivalNoticeList, total: 0 }
+  }
 }
 
 export async function deleteArrivalNotice(
@@ -780,3 +916,103 @@ export async function editArrivalNoticeProducts(
   debug('gan-updated-order-products', updatedOrderProducts)
   await orderProductRepo.save(updatedOrderProducts)
 }
+
+function extractArrivalNotices(rawArrivalNotices): Partial<ArrivalNotice[]> {
+  return rawArrivalNotices.reduce((arrivalNotices, raw) => {
+    // discard the item that has no productId or productDetailId
+    if (!raw.productId || !raw.productDetailId) return
+
+    const idx: number = arrivalNotices.findIndex(an => {
+      // consider these attributes if they are exist in "item"
+      const comparison = [
+        'refNo2',
+        'refNo3',
+        'truckNo',
+        'ownTransport',
+        'container',
+        'containerNo',
+        'containerSize',
+        'looseItem',
+        'importCargo'
+      ]
+
+      let a: any = {},
+        b: any = {}
+
+      comparison.forEach(cc => {
+        if (raw[cc] !== null) {
+          a[cc] = raw[cc]
+          b[cc] = an[cc]
+        }
+      })
+
+      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
+      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
+
+      return an.refNo == raw.refNo && an.etaDate == raw.etaDate && a === b
+    })
+
+    const product: Product = Object.assign(new Product(), { id: raw.productId, sku: raw.sku })
+    const orderProduct: Partial<OrderProduct> = {
+      product,
+      batchId: raw.batchId,
+      packingType: raw.packingType,
+      packingSize: raw.packingSize,
+      packQty: raw.packQty,
+      uomValue: raw.uomValue,
+      uom: raw.uom,
+      totalUomValue: raw.totalUomValue,
+      palletQty: raw.palletQty,
+      unitPrice: raw.unitPrice,
+      manufactureYear: raw.manufactureYear
+    }
+
+    if (idx >= 0) {
+      const duplicateSkuIdx: number = arrivalNotices[idx].orderProducts.findIndex(
+        op =>
+          op.sku === raw.sku &&
+          op.packingType === raw.packingType &&
+          op.packingSize === raw.packingSize &&
+          op.batchId === raw.batchId
+      )
+
+      if (duplicateSkuIdx >= 0) arrivalNotices[idx].orderProducts[duplicateSkuIdx].packQty += raw.packQty
+      else arrivalNotices[idx].orderProducts.push(orderProduct)
+    } else {
+      arrivalNotices.push({
+        refNo: raw.refNo,
+        refNo2: raw.refNo2,
+        refNo3: raw.refNo3,
+        etaDate: raw.etaDate,
+        truckNo: raw.truckNo,
+        ownTransport: raw.ownTransport,
+        container: raw.container,
+        containerNo: raw.containerNo,
+        containerSize: raw.containerSize,
+        importCargo: raw.importCargo,
+        looseItem: raw.looseItem,
+        orderProducts: [orderProduct]
+      })
+    }
+
+    return arrivalNotices
+  }, [])
+}
+
+function formRawArrivalNotices(arrivalNotice, errorMessage) {
+  let rawArrivalNotices = []
+  for (let i = 0, l = arrivalNotice.orderProducts.length; i < l; i++) {
+    let rawArrivalNotice = {
+      ...arrivalNotice,
+      ...arrivalNotice.orderProducts[i],
+      sku: arrivalNotice.orderProducts[i].product.sku,
+      remark: errorMessage
+    }
+
+    delete rawArrivalNotice.orderProducts
+    delete rawArrivalNotice.product
+
+    rawArrivalNotices.push(rawArrivalNotice)
+  }
+  return rawArrivalNotices
+}

package/server/service/arrival-notice/arrival-notice-query.ts

@@ -1,13 +1,13 @@
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, In, SelectQueryBuilder } from 'typeorm'
+import { EntityManager, getRepository, In, SelectQueryBuilder } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { checkUserBelongsDomain, User } from '@things-factory/auth-base'
+import { Bizplace, getCompanyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { ProductDetail } from '@things-factory/product-base'
 import { buildQuery, Domain, ListParam } from '@things-factory/shell'
 
-import { ArrivalNoticeList } from '../'
+import { ArrivalNoticeList, NewArrivalNotice, RawArrivalNotice } from '../'
 import { ATTACHMENT_TYPE, ORDER_STATUS } from '../../constants'
 import { OrderInventory, OrderProduct } from '../../service'
 import { ArrivalNotice } from './arrival-notice'
@@ -34,6 +34,7 @@ export class ArrivalNoticeQuery {
       relations: [
         'domain',
         'bizplace',
+        'bizplace.domain',
         'releaseGood',
         'purchaseOrder',
         'purchaseOrder.bufferLocation',
@@ -117,6 +118,17 @@ export class ArrivalNoticeQuery {
   async arrivalNotices(@Ctx() context: any, @Args() params: ListParam): Promise<ArrivalNoticeList> {
     const { domain, user }: { domain: Domain; user: User } = context.state
 
+    if (await checkUserBelongsDomain(domain, user)) {
+      if (!params.filters.some(e => e.name === 'status') && !params.filters.some(e => e.name === 'name')) {
+        params.filters.push({
+          name: 'status',
+          operator: 'notin',
+          value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING],
+          relation: false
+        })
+      }
+    }
+
     if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
       params.filters.push({
         name: 'bizplaceId',
@@ -287,6 +299,17 @@ export class ArrivalNoticeQuery {
     }
   }
 
+  @Directive('@transaction')
+  @Query(returns => [RawArrivalNotice])
+  async validateBulkArrivalNotices(
+    @Ctx() context: any,
+    @Arg('rawArrivalNotices', type => [NewArrivalNotice], { nullable: true }) rawArrivalNotices: NewArrivalNotice[],
+    @Arg('bizplaceId', type => String) bizplaceId: string
+  ): Promise<RawArrivalNotice[]> {
+    const tx: EntityManager = context.state.tx
+    return await validateBulkArrivalNoticesFunction(rawArrivalNotices, bizplaceId, tx)
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() arrivalNotice: ArrivalNotice): Promise<Domain> {
     return await getRepository(Domain).findOne(arrivalNotice.domainId)
@@ -302,3 +325,190 @@ export class ArrivalNoticeQuery {
     return await getRepository(User).findOne(arrivalNotice.updaterId)
   }
 }
+
+export async function validateBulkArrivalNoticesFunction(
+  rawArrivalNotices: NewArrivalNotice[],
+  bizplaceId: string,
+  trxMgr: EntityManager
+): Promise<RawArrivalNotice[]> {
+  const companyBizplace: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
+
+  const json_oi = JSON.stringify(
+    rawArrivalNotices.map(raw => {
+      return {
+        ref_no: raw.refNo || null,
+        ref_no_2: raw.refNo2 || null,
+        ref_no_3: raw.refNo3 || null,
+        eta_date: raw.etaDate || null,
+        truck_no: raw.truckNo || null,
+        own_transport: !!raw.truckNo || false,
+        loose_item: raw.looseItem || false,
+        import_cargo: raw.importCargo || false,
+        container: (!!raw.containerNo && !!raw.containerSize) || false,
+        container_no: raw.containerNo || null,
+        container_size: raw.containerSize || null,
+        sku: raw.sku || null,
+        batch_id: raw.batchId || null,
+        packing_type: raw.packingType || null,
+        packing_size: raw.packingSize || null,
+        uom: raw.uom || null,
+        pack_qty: raw.packQty || null,
+        pallet_qty: raw.palletQty || null,
+        unit_price: raw.unitPrice || null,
+        manufacture_year: raw.manufactureYear || null
+      }
+    })
+  )
+
+  await trxMgr.query(
+    `
+      CREATE TEMP TABLE temp_order_products(
+        ref_no VARCHAR(150),
+        ref_no_2 VARCHAR(150),
+        ref_no_3 VARCHAR(150),
+        eta_date VARCHAR(24),
+        truck_no VARCHAR(10),
+        own_transport BOOLEAN,
+        container BOOLEAN,
+        container_no VARCHAR(50),
+        container_size VARCHAR(24),
+        import_cargo BOOLEAN,
+        loose_item BOOLEAN,
+        sku VARCHAR(150),
+        batch_id VARCHAR(100),
+        packing_type VARCHAR(50),
+        packing_size INT,
+        uom VARCHAR(10),
+        pack_qty INT,
+        pallet_qty INT,
+        unit_price FLOAT8,
+        manufacture_year INT4
+      );
+    `
+  )
+
+  await trxMgr.query(
+    `
+      INSERT INTO temp_order_products 
+      SELECT 
+        js.ref_no, 
+        js.ref_no_2, 
+        js.ref_no_3, 
+        js.eta_date, 
+        js.truck_no, 
+        js.own_transport, 
+        js.container, 
+        js.container_no, 
+        js.container_size, 
+        js.import_cargo, 
+        js.loose_item, 
+        js.sku, 
+        js.batch_id, 
+        js.packing_type, 
+        js.packing_size, 
+        js.uom, 
+        js.pack_qty, 
+        js.pallet_qty, 
+        js.unit_price, 
+        js.manufacture_year 
+      FROM 
+        JSON_POPULATE_RECORDSET(NULL :: temp_order_products, $1) js;
+    `,
+    [json_oi]
+  )
+
+  let validatedItems = await trxMgr.query(
+    `
+      SELECT 
+        tp.ref_no, 
+        tp.ref_no_2, 
+        tp.ref_no_3, 
+        tp.eta_date, 
+        tp.truck_no, 
+        tp.own_transport, 
+        tp.container, 
+        tp.container_no, 
+        tp.container_size, 
+        tp.import_cargo, 
+        tp.loose_item, 
+        pr.id AS product_id, 
+        pd.id AS product_detail_id, 
+        pr.sku AS sku, 
+        CASE WHEN pr.description NOT IN (NULL, '', '-') THEN CONCAT(pr.name, '(', pr.description, ')') ELSE pr.name END AS product_info, 
+        tp.batch_id, 
+        pd.packing_type, 
+        pd.packing_size, 
+        tp.pack_qty, 
+        pd.uom_value, 
+        pd.uom, 
+        CONCAT(COALESCE(ROUND(pd.uom_value :: numeric, 2), 0) * tp.pack_qty, ' ', pd.uom) AS total_uom_value, 
+        tp.pallet_qty, 
+        tp.unit_price, 
+        tp.manufacture_year, 
+        CASE WHEN an.id NOTNULL THEN CONCAT('duplicated with ', an.name) ELSE CASE WHEN pr.id ISNULL OR pd.id ISNULL OR tp.sku ISNULL THEN 'product not found'
+        ELSE CASE WHEN tp.pack_qty <= 0  THEN 'pack qty must be integer'
+        ELSE CASE WHEN tp.batch_id ISNULL THEN 'batch no. is required'
+        ELSE CASE WHEN tp.ref_no ISNULL OR tp.ref_no = '' THEN 'ref no. is required'
+        ELSE CASE WHEN tp.eta_date ISNULL OR tp.eta_date = '' THEN 'eta date is required'
+        ELSE CASE WHEN tp.eta_date::date < now()::date THEN 'backdate is not allowed'
+        ELSE CASE WHEN tp.container_no NOTNULL AND tp.container_size ISNULL OR tp.container_no ISNULL AND tp.container_size NOTNULL THEN 'incomplete container information'
+        ELSE '' END END END END END END END END AS remark 
+      FROM 
+        temp_order_products tp 
+        LEFT JOIN arrival_notices an ON tp.ref_no = an.ref_no 
+        AND CASE WHEN tp.ref_no_2 NOTNULL THEN tp.ref_no_2 = an.ref_no_2 ELSE 1 = 1 END 
+        AND CASE WHEN tp.ref_no_3 NOTNULL THEN tp.ref_no_3 = an.ref_no_3 ELSE 1 = 1 END 
+        AND CASE WHEN tp.truck_no NOTNULL THEN tp.truck_no = an.truck_no ELSE 1 = 1 END 
+        AND CASE WHEN tp.own_transport NOTNULL THEN tp.own_transport = an.own_transport ELSE 1 = 1 END 
+        AND CASE WHEN tp.container NOTNULL THEN tp.container = an.container ELSE 1 = 1 END 
+        AND CASE WHEN tp.container_no NOTNULL THEN tp.container_no = an.container_no ELSE 1 = 1 END 
+        AND CASE WHEN tp.container_size NOTNULL THEN tp.container_size = an.container_size ELSE 1 = 1 END 
+        AND CASE WHEN tp.loose_item NOTNULL THEN tp.loose_item = an.loose_item ELSE 1 = 1 END 
+        AND CASE WHEN tp.import_cargo NOTNULL THEN tp.import_cargo = an.import_cargo ELSE 1 = 1 END 
+        LEFT JOIN products pr ON pr.sku = tp.sku 
+        LEFT JOIN product_details pd ON pr.id = pd.product_id 
+        AND CASE WHEN tp.packing_type NOTNULL 
+        AND tp.packing_size NOTNULL 
+        AND tp.uom NOTNULL THEN pd.packing_type = tp.packing_type 
+        AND pd.packing_size = tp.packing_size 
+        AND pd.uom = tp.uom ELSE pd.is_default = TRUE END 
+      WHERE 
+        pr.bizplace_id = $1
+
+    `,
+    [companyBizplace.id]
+  )
+
+  await trxMgr.query('DROP TABLE temp_order_products')
+
+  return validatedItems.map(item => {
+    return {
+      refNo: item.ref_no,
+      refNo2: item.ref_no_2,
+      refNo3: item.ref_no_3,
+      etaDate: item.eta_date,
+      truckNo: item.truck_no,
+      ownTransport: !!item.own_transport,
+      container: item.container,
+      containerNo: item.container_no,
+      containerSize: item.container_size,
+      importCargo: !!item.import_cargo,
+      looseItem: !!item.loose_item,
+      productId: item.product_id,
+      productDetailId: item.product_detail_id,
+      sku: item.sku,
+      productInfo: item.product_info,
+      batchId: item.batch_id,
+      packingType: item.packing_type,
+      packingSize: item.packing_size,
+      uom: item.uom,
+      packQty: item.pack_qty,
+      uomValue: item.uom_value,
+      totalUomValue: item.total_uom_value,
+      palletQty: item.pallet_qty,
+      unitPrice: item.unit_price,
+      manufactureYear: item.manufacture_year,
+      remark: item.remark
+    }
+  })
+}