@things-factory/sales-base 4.3.212 → 4.3.213

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

@@ -50,7 +50,6 @@ export class ArrivalNoticeMutation {
   @Mutation(returns => Boolean)
   async deleteArrivalNotice(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
     const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
-
     return await deleteArrivalNotice(tx, name, user, domain)
   }
 
@@ -81,7 +80,6 @@ export class ArrivalNoticeMutation {
   async confirmArrivalNotice(@Arg('name') name: string, @Ctx() context: any): Promise<ArrivalNotice> {
     const { tx }: { tx: EntityManager } = context.state
     const arrivalNotice: ArrivalNotice = await confirmArrivalNoticeFunction(name, context, tx)
-
     // If current GAN has cross docking
     if (arrivalNotice.crossDocking) {
       const { releaseGood } = await tx.getRepository(ArrivalNotice).findOne(arrivalNotice.id, {
@@ -399,11 +397,11 @@ export async function deleteArrivalNotice(
   user: User,
   domain: Domain
 ): Promise<boolean> {
+  try{
   let foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
     where: { domain, name },
     relations: ['bizplace', 'releaseGood', 'orderProducts', 'orderVass', 'collectionOrders', 'creator', 'updater']
   })
-
   if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
 
   const foundJS: JobSheet = await tx.getRepository(JobSheet).findOne({
@@ -412,17 +410,24 @@ export async function deleteArrivalNotice(
       arrivalNoticeRefNo: foundArrivalNotice.name
     }
   })
-
-  if (foundJS) await tx.getRepository(JobSheet).delete({ arrivalNoticeRefNo: foundArrivalNotice.name })
+  
+  if (foundJS){ 
+    await tx.getRepository(JobSheet).createQueryBuilder()
+      .delete()
+      .from(JobSheet)
+      .where('id = :id', { id: foundJS.id })
+      .execute()
+  }
 
   const foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
   const foundOVs: OrderVas[] = foundArrivalNotice.orderVass
 
   // 1. delete order products
-  const productIds = foundOPs.map((product: OrderProduct) => product.id)
-  if (productIds.length) {
-    await tx.getRepository(OrderProduct).delete({ id: In(productIds) })
-  }
+  await tx.getRepository(OrderProduct).createQueryBuilder('op')
+    .delete()
+    .from(OrderProduct)
+    .where('arrival_notice_id = :arrivalNoticeId', { arrivalNoticeId: foundArrivalNotice.id })
+    .execute()
 
   // 2. delete order vass
   const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
@@ -448,6 +453,9 @@ export async function deleteArrivalNotice(
     await tx.getRepository(ArrivalNotice).delete({ domain, name })
   }
   return true
+  } catch(e) {
+    console.log(e)
+  }
 }
 
 export async function generateArrivalNoticeFunction(
@@ -567,6 +575,7 @@ export async function confirmArrivalNoticeFunction(
   context: any,
   tx?: EntityManager
 ): Promise<ArrivalNotice> {
+  try{
   const { user, domain }: { user: User; domain: Domain } = context.state
 
   const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
@@ -602,6 +611,7 @@ export async function confirmArrivalNoticeFunction(
   })
 
   // If status of GAN is PENDING_RECEIVE then directly to assign warehouse
+
   if (ganProcessingSetting) {
     let setting = !isNaN(partnerGanProcessingSetting?.value)
       ? partnerGanProcessingSetting?.value
@@ -620,18 +630,20 @@ export async function confirmArrivalNoticeFunction(
   if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
 
   // 1. GAN Status change (PENDING => PENDING_RECEIVE)
-  let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).save({
-    ...foundArrivalNotice,
+  await tx.getRepository(ArrivalNotice).update({ id: foundArrivalNotice.id },{
     status: anStatus,
     updater: user,
     acceptedBy: acceptedByUser,
     acceptedAt: acceptedTime
   })
 
-  foundOPs = foundOPs.map((op: OrderProduct) => {
-    return { ...op, status: opStatus }
-  })
-  await tx.getRepository(OrderProduct).save(foundOPs)
+  let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({where: { id: foundArrivalNotice.id }})
+
+  await tx.getRepository(OrderProduct).createQueryBuilder()
+  .update(OrderProduct)
+  .set({ status: opStatus })
+  .whereInIds(foundOPs.map(op => op.id))
+  .execute();
 
   // 2. Update order vas status if it exists.
   if (foundOVs && foundOVs.length) {
@@ -660,7 +672,6 @@ export async function confirmArrivalNoticeFunction(
         return 'ur.roles_id IN ' + subQuery
       })
       .getRawMany()
-
     // send notification to Office Admin Users
     if (users?.length && context.header?.referer) {
       const receivers: any[] = users.map(user => user.id)
@@ -670,7 +681,6 @@ export async function confirmArrivalNoticeFunction(
         url: context.header.referer,
         data: { url: context.header.referer }
       }
-
       /**
        * @notes Temporary off sendNotification due to suspect of causing wms down
        */
@@ -683,6 +693,9 @@ export async function confirmArrivalNoticeFunction(
   }
 
   return arrivalNotice
+  } catch (e) {
+    console.log(e)
+  }
 }
 
 export async function receiveArrivalNoticeFunction(_: any, name: String, context: any): Promise<ArrivalNotice> {
@@ -953,8 +966,8 @@ export async function rejectArrivalNotice(
     }
 
     /**
-     * @notes Temporary off sendNotification due to suspect of causing wms down
-     */
+ * @notes Temporary off sendNotification due to suspect of causing wms down
+ */
 
     // await sendNotification({
     //   receivers,
@@ -972,8 +985,6 @@ export async function addArrivalNoticeProducts(
   user: User,
   tx?: EntityManager
 ): Promise<void> {
-  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
-  const productDetailRepo: Repository<ProductDetail> = tx?.getRepository(ProductDetail) || getRepository(ProductDetail)
   const orderProductRepo: Repository<OrderProduct> = tx?.getRepository(OrderProduct) || getRepository(OrderProduct)
 
   if (!arrivalNotice?.bizplace || !arrivalNotice?.orderProducts?.length) {
@@ -983,23 +994,44 @@ export async function addArrivalNoticeProducts(
     })
   }
 
-  const createdOrderProducts: OrderProduct[] = await Promise.all(
-    newOrderProducts.map(async (op: OrderProduct) => {
-      return {
-        ...op,
-        domain,
-        bizplace: arrivalNotice.bizplace,
-        name: OrderNoGenerator.orderProduct(),
-        product: await productRepo.findOne(op.product.id),
-        productDetail: await productDetailRepo.findOne(op.productDetail.id),
-        arrivalNotice,
-        creator: user
-      }
+  let createdOrderProducts: any[] = []
+
+  for (let index = 0; index < newOrderProducts.length; index++) {
+    const op = newOrderProducts[index];
+
+    createdOrderProducts.push({
+      name: OrderNoGenerator.orderProduct(),
+      product_id: op.product.id,
+      product_detail_id: op.productDetail.id,
+      batch_id: op.batchId,
+      batch_id_ref: op.batchIdRef,
+      packing_type: op.packingType,
+      packing_size: op.packingSize,
+      uom: op.uom,
+      uom_value: op.uomValue,
+      pack_qty: op.packQty,
+      total_uom_value: op.totalUomValue,
+      unit_price: op.unitPrice,
+      remark: op.remark,
+      manufacture_date: op.manufactureDate,
+      status: op.status,
+      domain_id: domain.id,
+      bizplace_id: arrivalNotice.bizplace,
+      arrival_notice_id: arrivalNotice.id,
+      creator_id: user.id,
+      updater_id: user.id
+
     })
-  )
+  }
 
-  debug('gan-created-order-products', createdOrderProducts)
-  await orderProductRepo.save(createdOrderProducts)
+  await orderProductRepo.query(
+    `
+    INSERT INTO order_products ("name", "product_detail_id", "product_id", "batch_id", "batch_id_ref", "packing_type", "packing_size", "uom", "uom_value", "pack_qty", "total_uom_value", "unit_price", "remark", "manufacture_date", "status", "domain_id", "bizplace_id", "arrival_notice_id", "creator_id", "updater_id")
+    SELECT "name", "product_detail_id", "product_id", "batch_id", "batch_id_ref", "packing_type", "packing_size", "uom", "uom_value", "pack_qty", "total_uom_value", "unit_price", "remark", "manufacture_date", "status", "domain_id", "bizplace_id", "arrival_notice_id", "creator_id", "updater_id"
+    FROM JSON_POPULATE_RECORDSET(NULL::order_products, $1) op
+  `,
+    [JSON.stringify(createdOrderProducts)]
+  )
 }
 
 export async function editArrivalNoticeProducts(

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

@@ -49,12 +49,16 @@ export class ArrivalNoticeQuery {
 
     //separate query to improve typeorm mapping performance. Search for Related Order Product
     let orderProducts = await getRepository(OrderProduct).find({ where: { arrivalNotice: foundGAN }, relations: ['product', 'productDetail'] })
-    foundGAN.orderProducts = orderProducts
-
+    foundGAN.orderProducts = await Promise.all(orderProducts.map(async (orderProduct) => {
+      orderProduct.unitPrice = orderProduct?.unitPrice ? parseFloat(orderProduct.unitPrice.toFixed(2)) : null;
+      orderProduct.adjustedUnitPrice = orderProduct?.adjustedUnitPrice ? parseFloat(orderProduct.adjustedUnitPrice.toFixed(2)) : null;
+      return orderProduct;
+    }))
+    
     //separate query to improve typeorm mapping performance. Search for Related Order Inventory
     let orderInventories = await getRepository(OrderInventory).find({ where: { arrivalNotice: foundGAN }, relations: ['inventory', 'inventory.product', 'inventory.location'] })
     foundGAN.orderInventories = orderInventories
-
+    
     if (name && !foundGAN) throw new Error(`Failed to find arrival notice with ${name}`)
 
     if (foundGAN) {
@@ -75,41 +79,6 @@ export class ArrivalNoticeQuery {
           }
         })
         : []
-
-      // add productDetails data to orderProduct.product
-      foundGAN.orderProducts = await Promise.all(
-        foundGAN.orderProducts.map(async (orderProduct: OrderProduct) => {
-          orderProduct.product['productDetails'] = await getRepository(ProductDetail).find({
-            where: {
-              product: orderProduct.product.id,
-              packingType: orderProduct.packingType,
-              packingSize: orderProduct.packingSize
-            }
-          })
-          orderProduct.unitPrice = orderProduct?.unitPrice ? parseFloat(orderProduct.unitPrice.toFixed(2)) : null
-          orderProduct.adjustedUnitPrice = orderProduct?.adjustedUnitPrice
-            ? parseFloat(orderProduct.adjustedUnitPrice.toFixed(2))
-            : null
-          return orderProduct
-        })
-      )
-
-      // add productDetails data to orderInventory.inventory.product if orderInventory is exist
-      if (foundGAN.orderInventories && foundGAN.orderInventories.length) {
-        foundGAN.orderInventories = await Promise.all(
-          foundGAN.orderInventories.map(async (orderInventory: OrderInventory) => {
-            orderInventory.inventory.product['productDetails'] = await getRepository(ProductDetail).find({
-              where: {
-                product: orderInventory.inventory.product.id,
-                packingType: orderInventory.inventory.packingType,
-                packingSize: orderInventory.inventory.packingSize
-              }
-            })
-            return orderInventory
-          })
-        )
-      }
-
       return {
         ...foundGAN,
         attachment: [...foundPOAttachments, ...foundAttachments]

package/server/service/draft-release-good/draft-release-good-query.ts

@@ -354,7 +354,7 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
         remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0,
         status: foundProductInv?.transferQty
           ? DRAFT_RELEASE_ORDER_STATUS.TRANSFER
-          : foundProductInv?.remainQty || 0 < itm.releaseQty
+          : (foundProductInv?.remainQty || 0) < itm.releaseQty
           ? DRAFT_RELEASE_ORDER_STATUS.INSUFFICIENT
           : DRAFT_RELEASE_ORDER_STATUS.DRAFT
       }

package/server/service/order-inventory/order-inventory.ts

@@ -66,6 +66,11 @@ import { Replenishment } from '../replenishment/replenishment'
   orderInventory.uom
 ])
 @Index('ix_order-inventory_5', (orderInventory: OrderInventory) => [orderInventory.releaseGood])
+
+
+@Index('ix_order-inventory_6', (orderInventory: OrderInventory) => [orderInventory.id], {
+  unique: true
+})
 @ObjectType()
 export class OrderInventory {
   @PrimaryGeneratedColumn('uuid')

package/server/service/others/other-query.ts

@@ -212,11 +212,11 @@ export class OtherQuery {
         productDetail: availableItem ? { id: availableItem.productDetailId } : null,
         inventory: availableItem
           ? {
-              ...availableItem,
-              remainQty: availableItem ? availableItem.remainQty : null,
-              remainUomValue: availableItem ? availableItem.remainUomValue : null,
-              remainUomValueWithUom: availableItem ? availableItem.remainUomValueWithUom : ''
-            }
+            ...availableItem,
+            remainQty: availableItem ? availableItem.remainQty : null,
+            remainUomValue: availableItem ? availableItem.remainUomValue : null,
+            remainUomValueWithUom: availableItem ? availableItem.remainUomValueWithUom : ''
+          }
           : null,
         productId: availableItem ? availableItem.productId : null,
         productDetailID: availableItem ? availableItem.productDetailId : null,
@@ -299,8 +299,6 @@ export class OtherQuery {
       const { domain, user, tx, bizplace }: { domain: Domain; user: User; tx: EntityManager; bizplace: Bizplace } =
         context.state
 
-      const productDetailRepo = tx.getRepository(ProductDetail)
-
       let permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
       let foundPermittedBizplace: Bizplace
       let companyBizplace: Bizplace
@@ -336,90 +334,118 @@ export class OtherQuery {
 
       if (partnerStrictProductSelectionSetting) strictProduct = partnerStrictProductSelectionSetting.value
 
-      let newOrderProducts: any[] = []
-
-      for (var i = 0; i < orderProducts.length; i++) {
-        const orderProduct = orderProducts[i]
-        const productSKU: string = orderProduct.productSKU
-        const foundProduct: Product = await tx.getRepository(Product).findOne({
-          where: {
-            sku: productSKU,
-            bizplace: companyBizplace
+      const json_op = JSON.stringify(
+        orderProducts.map(orderProduct => {
+          return {
+            sku: orderProduct.productSKU,
+            packing_type: orderProduct.packingType,
+            pack_qty: orderProduct.packQty,
+            pallet_qty: orderProduct.palletQty,
+            unit_price: orderProduct.unitPrice,
+            batch_id: orderProduct.batchId,
+            uom: orderProduct.uom,
+            uom_value: orderProduct.uomValue
           }
         })
+      )
 
-        let newOrderProduct: any
-
-        if (foundProduct) {
-          let productDetail: ProductDetail
-          const hasConditions: boolean = Boolean(
-            (orderProduct?.packingType && orderProduct?.packingType.trim() != '') ||
-              (orderProduct?.uom && orderProduct?.uom.trim() != '') ||
-              orderProduct?.uomValue
-          )
-          let productDetailCondition: any = { product: foundProduct }
-
-          if (hasConditions && strictProduct == 'true') {
-            if (orderProduct?.packingType && orderProduct.packingType.trim() != '')
-              productDetailCondition.packingType = orderProduct.packingType.trim()
-
-            if (orderProduct?.uom && orderProduct.uom.trim() != '') productDetailCondition.uom = orderProduct.uom.trim()
-
-            if (orderProduct?.uomValue) productDetailCondition.uomValue = orderProduct.uomValue
-          } else {
-            productDetailCondition.isDefault = true
-          }
-
-          productDetail = await productDetailRepo.findOne({
-            where: productDetailCondition
-          })
-
-          //check if is strict product selection for uom value, uom, packing type
-          const uomValue: number =
-            strictProduct == 'true' && productDetail ? productDetail.uomValue : orderProduct.uomValue
-
-          const uom = strictProduct == 'true' && productDetail ? productDetail.uom : orderProduct.uom
-
-          const packingType =
-            strictProduct == 'true' && productDetail ? productDetail.packingType : orderProduct.packingType
-
-          newOrderProduct = {
-            ...orderProduct,
-            packingType,
-            packingSize: productDetail ? productDetail.packingSize : orderProduct.packingSize,
-            uom,
-            uomValue,
-            productName: `${foundProduct.name}(${foundProduct.description}(${foundProduct.sku}))`,
-            productBrand: foundProduct?.brand ? foundProduct.brand : null,
-            product: {
-              id: foundProduct.id,
-              name: foundProduct.name,
-              sku: foundProduct.sku,
-              type: foundProduct.type,
-              brand: foundProduct.brand,
-              primaryUnit: productDetail ? productDetail.uom : null,
-              primaryValue: productDetail ? productDetail.uomValue : null,
-              costPrice: foundProduct.costPrice
-            },
-            productDetail,
-            totalUomValue:
-              orderProduct.packQty > 0
-                ? uomValue
-                  ? `${(orderProduct.packQty * uomValue).toFixed(2)} ${uom}`
-                  : null
-                : null,
-            isError: productDetail ? false : true
-          }
-        } else {
-          newOrderProduct = {
-            ...orderProduct,
-            productName: orderProduct.productSKU,
-            isError: true
+      // create temp table to hold the input data
+      await tx.query(`
+          CREATE TEMP TABLE raw_order_products(
+            sku VARCHAR(150),
+            packing_type VARCHAR(50),
+            pack_qty FLOAT,
+            pallet_qty FLOAT,
+            unit_price FLOAT,
+            batch_id VARCHAR(50),
+            uom VARCHAR(10),
+            uom_value FLOAT
+          );
+      `)
+
+      // insert input data into temp table
+      await tx.query(`
+          INSERT INTO raw_order_products
+          SELECT * FROM JSON_POPULATE_RECORDSET(NULL::raw_order_products, $1) js
+      `, [json_op])
+
+      // find closest matching product details from input data
+      await tx.query(`
+        create temp table matching_product_details as (
+          select row_number() over(partition by rop.sku order by is_default desc) as rn,
+          rop.sku as "rop_sku", rop.packing_type as "rop_packing_type", rop.uom as "rop_uom", rop.uom_value as "rop_uom_value", pd.*
+          from product_details pd
+          inner join products p on p.id = pd.product_id AND p.bizplace_id = $1
+          inner join raw_order_products rop ON LOWER(rop.sku) = LOWER(p.sku)
+          where 
+          pd.packing_type = coalesce(rop.packing_type, pd.packing_type) 
+          and	pd.uom = coalesce(rop.uom, pd.uom)
+          and pd.uom_value = coalesce(rop.uom_value, pd.uom_value)
+      )`, [companyBizplace.id])
+
+      // massage data into defined structure
+      let results = await tx.query(`
+        select *,
+        case when "packQty" > 0 and "uomValue" is not null then "packQty" * "uomValue" else null end as "totalUomValue"
+        from (
+          SELECT 
+          js.sku,
+          js.pack_qty as "packQty",
+          js.pallet_qty as "palletQty",
+          js.unit_price as "unitPrice",
+          js.batch_id as "batchId",
+          p.id AS "productId",
+          p.name as "productName",
+          p.brand as "productBrand",
+          p.type as "productType",
+          coalesce(mpd.uom, pdd.uom) as "productPrimaryUnit",
+          coalesce(mpd.uom_value, pdd.uom_value) as "productPrimaryValue",
+          coalesce(mpd.packing_size, pdd.packing_size) as "packingSize",
+          ${strictProduct.toLowerCase() === 'false' ? `
+            coalesce(js.packing_type, mpd.packing_type, pdd.packing_type) as "packingType",
+            coalesce(js.uom, mpd.uom, js.uom) as "uom",
+            coalesce(js.uom_value, mpd.uom_value, js.uom_value) as "uomValue",
+          ` : `
+            coalesce(mpd.packing_type, pdd.packing_type) as "packingType",
+            coalesce(mpd.uom, js.uom) as "uom",
+            coalesce(mpd.uom_value, js.uom_value) as "uomValue",
+          `}          
+          coalesce(mpd.id, pdd.id) AS "productDetailId",
+          coalesce(mpd.cost_price, pdd.cost_price) AS "productDetailCostPrice",
+          CASE WHEN p.id is null then js.sku else concat(p.name,' (',p.description,' (',js.sku,'))') end as "productName",
+          CASE WHEN p.id is null or coalesce(mpd.id, pdd.id) is null then true else false end as "isError"
+          FROM raw_order_products js
+          LEFT JOIN products p ON LOWER(js.sku) = LOWER(p.sku) AND p.bizplace_id = $1
+          left join matching_product_details mpd on mpd.rn = 1 and mpd.rop_sku = js.sku and mpd.rop_packing_type = js.packing_type and mpd.rop_uom = js.uom
+          left join product_details pdd on p.id = pdd.product_id and pdd.is_default = true
+        ) dt
+      `, [companyBizplace.id])
+
+      // remove all temp table
+      await tx.query(`DROP TABLE matching_product_details`)
+      await tx.query(`DROP TABLE raw_order_products`)
+
+      // build output structure
+      const newOrderProducts: any[] = results.map(result => {
+        return {
+          ...result,
+          product: {
+            id: result.productId,
+            name: result.productName,
+            sku: result.productSku,
+            description: result.productDescription,
+            type: result.productType,
+            brand: result.productBrand,
+            primaryUnit: result.productPrimaryUnit,
+            primaryValue: result.productPrimaryValue,
+            costPrice: result.productDetailCostPrice,
+          },
+          productDetail: {
+            id: result.productDetailId,
+            costPrice: result.productDetailCostPrice,
           }
         }
-
-        newOrderProducts.push(newOrderProduct)
-      }
+      })
 
       return newOrderProducts
     } catch (e) {
@@ -494,7 +520,7 @@ export class OtherQuery {
           let productDetail: ProductDetail
           const hasConditions: boolean = Boolean(
             (orderProduct?.packingType && orderProduct?.packingType.trim() != '') ||
-              (orderProduct?.uom && orderProduct?.uom.trim() != '')
+            (orderProduct?.uom && orderProduct?.uom.trim() != '')
           )
           let productDetailCondition: any = { product: foundProduct }
 
@@ -519,8 +545,8 @@ export class OtherQuery {
                 ? productDetail.uomValue
                 : null
               : orderProduct?.uomValue
-              ? orderProduct.uomValue
-              : productDetail.uomValue
+                ? orderProduct.uomValue
+                : productDetail.uomValue
 
           newOrderProduct = {
             ...orderProduct,