@things-factory/sales-base 4.3.82 → 4.3.83

package/server/utils/inventory-util.ts

@@ -2,7 +2,7 @@ import { EntityManager, Equal, getRepository, In, Not, Raw, Repository, SelectQu
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { Product, ProductBundle, ProductDetail } from '@things-factory/product-base'
+import { Product, ProductBundle } from '@things-factory/product-base'
 import { Domain, ListParam } from '@things-factory/shell'
 import {
   Inventory,
@@ -12,8 +12,7 @@ import {
   Location,
   LOCATION_STATUS,
   LOCATION_TYPE,
-  Pallet,
-  generateInventoryHistory
+  Pallet
 } from '@things-factory/warehouse-base'
 
 import { ORDER_TYPES } from '../constants'
@@ -103,7 +102,6 @@ export const InventoryUtil = {
               coalesce(p.sku, '') AS "productSKU",
               coalesce(p.brand, '') AS "productBrand",
               p.id AS "productId",
-              pd.id AS "productDetailId",
               COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)),0) AS "remainQty",
               COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)),0) AS "remainUomValue",
               concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', pd.uom) AS "remainUomValueWithUom",
@@ -116,7 +114,10 @@ export const InventoryUtil = {
               WHERE l2.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')
               AND i.domain_id = $1 AND i.status = 'STORED'
               ${inventoryBizplaceFilter ? `AND i.bizplace_id = '${inventoryBizplaceFilter.value}'` : ``}
-            ) i ON i.product_detail_id = pd.id
+            ) i ON i.product_id = pd.product_id
+            AND i.packing_type = pd.packing_type 
+            and i.packing_size = pd.packing_size 
+            and i.uom = pd.uom 
             LEFT JOIN oi ON i.batch_id = oi.batch_id AND p.name = oi.product_name AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
             LEFT JOIN (
               SELECT pbs.product_id, SUM(pbs.bundle_qty * src.release_qty) AS bundle_product_release_qty, SUM(pbs.bundle_qty * src.release_uom_value) AS bundle_product_release_uom_value 
@@ -126,24 +127,22 @@ export const InventoryUtil = {
             ) bp on i.product_id = bp.product_id
             WHERE p.bizplace_id IN (${bizplaceIds})
               ${productDetailWhereClause}
-              ${
-                productFilter
-                  ? `AND (
+              ${productFilter
+          ? `AND (
                 lower(p.sku) ilike '${productFilter.value}'
                 OR lower(p.name) ilike '${productFilter.value}'
                 OR lower(p.description) ilike '${productFilter.value}'
               )
             `
-                  : ``
-              }
+          : ``
+        }
             GROUP BY
               p.id,
-              pd.id,
               pd.packing_type,
               pd.packing_size,
               pd.uom
             UNION 
-            SELECT packing_type, packing_size,'UNIT' AS "uom", name AS "productName", sku AS "productSKU", '-' AS "productBrand", id AS "productId", pbs.product_detail_id AS "productDetailId",
+            SELECT packing_type, packing_size,'UNIT' AS "uom", name AS "productName", sku AS "productSKU", '-' AS "productBrand", id AS "productId",
             COALESCE(MIN(FLOOR(pbs."availableQty")),0) AS "remainQty", 
             COALESCE(MIN(FLOOR(pbs."availableUomValue")),0) AS "remainUomValue", 
             CONCAT(COALESCE(MIN(FLOOR(pbs."availableUomValue")),0),' UNIT') AS "remainUomValueWithUom", 
@@ -152,8 +151,7 @@ export const InventoryUtil = {
             LEFT JOIN (
               SELECT pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
               (SUM(COALESCE(i2.qty, 0)) - SUM(COALESCE(i2.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
-              (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue",
-              pbs.product_detail_id
+              (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue"
               FROM product_bundle_settings pbs 
               LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id AND i2.domain_id = $1 AND i2.status = 'STORED'
               INNER JOIN locations l2 ON i2.location_id = l2.id                
@@ -162,28 +160,25 @@ export const InventoryUtil = {
               ${inventoryBizplaceFilter ? `AND i2.bizplace_id = '${inventoryBizplaceFilter.value}'` : ``}
               GROUP BY 
                 pbs.product_id, 
-                pbs.product_bundle_id,
-                pbs.product_detail_id
+                pbs.product_bundle_id
             ) pbs ON pbs.product_bundle_id = pb.id
             ${bundleWhereClause}
             AND pb.bizplace_id IN (${bizplaceIds}) 
-            ${
-              productFilter
-                ? `AND (
+            ${productFilter
+          ? `AND (
               lower(pb.sku) ilike '${productFilter.value}'
               OR lower(pb.name) ilike '${productFilter.value}'
               OR lower(pb.description) ilike '${productFilter.value}'
               )
             `
-                : ``
-            }
+          : ``
+        }
             GROUP BY 
               pb.packing_type, 
               pb.packing_size, 
               pb.name, 
               pb.sku, 
-              pb.id,
-              pbs.product_detail_id
+              pb.id
           )
           AS inv_prod_grp 
           ${whereClause}
@@ -278,7 +273,6 @@ export const InventoryUtil = {
               coalesce(p.sku, '') AS "productSKU",
               coalesce(p.brand, '') AS "productBrand",
               p.id AS "productId",
-              i.product_detail_id AS "productDetailId",
               SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)) AS "remainQty",
               SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) AS "remainUomValue",
               concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', i.uom) AS "remainUomValueWithUom",
@@ -298,7 +292,6 @@ export const InventoryUtil = {
             AND l2.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')
             ${productWhereClause}
             GROUP BY
-            i.product_detail_id,
             i.batch_id,
             i.batch_id_ref,
             p.id,
@@ -306,7 +299,7 @@ export const InventoryUtil = {
             i.packing_size,
             i.uom
             UNION 
-            SELECT 'BUNDLE' AS "batchId", null as "batchIdRef", packing_type, packing_size,'UNIT' AS "uom", name AS "productName", sku AS "productSKU", 'brand' AS "productBrand", id AS "productId", pbs.product_detail_id AS "productDetailId",
+            SELECT 'BUNDLE' AS "batchId", null as "batchIdRef", packing_type, packing_size,'UNIT' AS "uom", name AS "productName", sku AS "productSKU", 'brand' AS "productBrand", id AS "productId",
             MIN(FLOOR(pbs."availableQty")) AS "remainQty", 
             MIN(FLOOR(pbs."availableUomValue")) AS "remainUomValue", 
             CONCAT(MIN(FLOOR(pbs."availableUomValue")),' UNIT') AS "remainUomValueWithUom", 
@@ -315,17 +308,16 @@ export const InventoryUtil = {
             INNER JOIN (
               SELECT pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
               (SUM(COALESCE(i2.qty, 0)) - SUM(COALESCE(i2.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
-              (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue",
-              pbs.product_detail_id
+              (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue"
               FROM product_bundle_settings pbs 
               LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id AND i2.domain_id = $1
               AND i2.bizplace_id IN (${bizplaceIds})
               AND i2.status = 'STORED'
               LEFT JOIN oi ON oi.product_id = i2.product_id
-              GROUP BY pbs.product_id, pbs.product_bundle_id, pbs.product_detail_id
+              GROUP BY pbs.product_id, pbs.product_bundle_id
             ) pbs ON pbs.product_bundle_id = pb.id
             ${bundleWhereClause}
-            GROUP BY pb.packing_type, pb.packing_size, pb.name, pb.sku, pb.id, pbs.product_detail_id
+            GROUP BY pb.packing_type, pb.packing_size, pb.name, pb.sku, pb.id
           )
           AS inv_prod_grp
           ${whereClause}
@@ -365,15 +357,13 @@ export const InventoryUtil = {
 
       if (params?.pagination) {
         items = await trxMgr.query(
-          `select * from temp_inventory_product_group  ${filterGroupTypeQuery ? filterGroupTypeQuery : ''} ${
-            sortingArr.length > 0 ? ' Order by ' + sortedBy.toString() : ''
+          `select * from temp_inventory_product_group  ${filterGroupTypeQuery ? filterGroupTypeQuery : ''} ${sortingArr.length > 0 ? ' Order by ' + sortedBy.toString() : ''
           } OFFSET $1 LIMIT $2`,
           [(params.pagination.page - 1) * params.pagination.limit, params.pagination.limit]
         )
       } else {
         items = await trxMgr.query(
-          `select * from temp_inventory_product_group ${filterGroupTypeQuery ? filterGroupTypeQuery : ''} ${
-            sortingArr.length > 0 ? ' Order by ' + sortedBy.toString() : ''
+          `select * from temp_inventory_product_group ${filterGroupTypeQuery ? filterGroupTypeQuery : ''} ${sortingArr.length > 0 ? ' Order by ' + sortedBy.toString() : ''
           }`
         )
       }
@@ -496,8 +486,9 @@ export const InventoryUtil = {
     let json_oi = JSON.stringify(
       orderInventories.map(x => {
         return {
-          product_detail_id: x.productDetail.id,
+          product_id: x.product.id,
           batch_id: x.batchId,
+          packing_type: x.packingType,
           release_qty: x.releaseQty,
           uom: x.uom
         }
@@ -506,14 +497,15 @@ export const InventoryUtil = {
 
     let resultQb = await trxMgr.query(
       `
-      select joi.product_detail_id as "productDetailId", joi.batch_id as "batchId", joi.uom as "uom", joi.release_qty as "releaseQty",
+      select joi.product_id as "productId", joi.batch_id as "batchId", joi.packing_type as "packingType", joi.uom as "uom", joi.release_qty as "releaseQty",
       sum(i.qty - coalesce(i.locked_qty,0)) - coalesce(
       (
         select sum(oi.release_qty) from order_inventories oi 
         where (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
         and oi.inventory_id IS null
-        and oi.product_detail_id = joi.product_detail_id
+        and oi.product_id = joi.product_id
         and oi.batch_id = joi.batch_id
+        and oi.packing_type = joi.packing_type
         and oi.uom = joi.uom
         and oi.domain_id = $1
         and oi.bizplace_id = $2
@@ -523,20 +515,21 @@ export const InventoryUtil = {
         select sum(oi.release_uom_value) from order_inventories oi 
         where (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
         and oi.inventory_id IS null
-        and oi.product_detail_id = joi.product_detail_id
+        and oi.product_id = joi.product_id
         and oi.batch_id = joi.batch_id
+        and oi.packing_type = joi.packing_type
         and oi.uom = joi.uom
         and oi.domain_id = $1
         and oi.bizplace_id = $2
       ),0) as "availableUomValue"
       from json_populate_recordset(NULL::order_inventories,'${json_oi}') joi
-      left join inventories i on joi.product_detail_id = i.product_detail_id 
+      left join inventories i on joi.product_id = i.product_id 
       and joi.batch_id = i.batch_id
-      and i.status ='STORED'
+      and joi.packing_type = i.packing_type and i.status ='STORED'
       and joi.uom = i.uom
       and i.domain_id = $1
       and i.bizplace_id = $2
-      group by joi.product_detail_id, joi.batch_id, joi.packing_type, joi.release_qty, joi.uom
+      group by joi.product_id, joi.batch_id, joi.packing_type, joi.release_qty, joi.uom
     `,
       [warehouseDomain.id, partnerBizplace.id]
     )
@@ -582,9 +575,9 @@ export const InventoryUtil = {
    * @returns orderInventories
    */
   async autoAssignInventoryForRelease(
-    orderInventory: OrderInventory,
     product: Product,
-    productDetail: ProductDetail,
+    orderInventory: OrderInventory,
+    packingType: string,
     locationSortingRules: any = [],
     customerBizplace: Bizplace,
     domain: Domain,
@@ -595,14 +588,16 @@ export const InventoryUtil = {
     qb.leftJoinAndSelect('iv.location', 'loc')
       .andWhere('"iv"."domain_id" = :domainId')
       .andWhere('"iv"."bizplace_id" = :bizplaceId')
-      .andWhere('"iv"."product_detail_id" = :productDetailId')
+      .andWhere('"iv"."packing_type" = :packingType')
+      .andWhere('"iv"."product_id" = :productId')
       .andWhere('"iv"."status" = :status')
       .andWhere('"iv"."qty" - COALESCE("iv"."locked_qty", 0) > 0')
       .andWhere('"loc"."type" NOT IN (:...locationTypes)')
       .setParameters({
         domainId: domain.id,
         bizplaceId: customerBizplace.id,
-        productDetailId: productDetail.id,
+        packingType: packingType,
+        productId: product.id,
         status: INVENTORY_STATUS.STORED,
         locationTypes: [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
       })
@@ -664,7 +659,7 @@ export const InventoryUtil = {
       }
     })
 
-    return _composeTargetInventories(productDetail, orderInventory, inventories)
+    return _composeTargetInventories(product, orderInventory, inventories)
   },
 
   /**
@@ -856,32 +851,31 @@ async function getConditions(
           case 'batch_product':
             productWhereClause += `
               AND (i.batch_id, p.id, i.packing_type, i.packing_size) ${operator === 'in' ? 'IN' : 'NOT IN'} (${value
-              .map(
-                (v: { batchId: string; productId: string; packingType: string; packingSize: string }) =>
-                  `('${v.batchId}', '${v.productId}', '${v.packingType}', '${v.packingSize}')`
-              )
-              .join()})
+                .map(
+                  (v: { batchId: string; productId: string; packingType: string; packingSize: string }) =>
+                    `('${v.batchId}', '${v.productId}', '${v.packingType}', '${v.packingSize}')`
+                )
+                .join()})
             `
             break
 
           case 'batch_bundle':
             bundleWhereClause += `
               ${bundleWhereClause == '' ? 'WHERE' : 'AND'} pb.id ${operator === 'in' ? 'IN' : 'NOT IN'} (${value
-              .map((v: { productId: string }) => `('${v.productId}')`)
-              .join()})
+                .map((v: { productId: string }) => `('${v.productId}')`)
+                .join()})
             `
             break
 
           case 'product':
             productDetailWhereClause += `
-              AND (pd.product_id, pd.packing_type, pd.packing_size, pd.uom) ${
-                operator === 'in' ? 'IN' : 'NOT IN'
+              AND (pd.product_id, pd.packing_type, pd.packing_size, pd.uom) ${operator === 'in' ? 'IN' : 'NOT IN'
               } (${value
-              .map(
-                (v: { productId: string; packingType: string; packingSize: string; uom: string }) =>
-                  `('${v.productId}', '${v.packingType}', '${v.packingSize}', '${v.uom}')`
-              )
-              .join()})
+                .map(
+                  (v: { productId: string; packingType: string; packingSize: string; uom: string }) =>
+                    `('${v.productId}', '${v.packingType}', '${v.packingSize}', '${v.uom}')`
+                )
+                .join()})
             `
             break
         }
@@ -933,6 +927,98 @@ async function updateInventory(
   return await trxMgr.getRepository(Inventory).save(inventory)
 }
 
+async function generateInventoryHistory(
+  inventory: Inventory,
+  refOrder: any,
+  transactionType: string,
+  qty: number,
+  uomValue: number,
+  user: User,
+  trxMgr?: EntityManager
+): Promise<InventoryHistory> {
+  const invHistoryRepo: Repository<InventoryHistory> =
+    trxMgr?.getRepository(InventoryHistory) || getRepository(InventoryHistory)
+  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
+
+  if (!inventory?.id) throw new Error(`Can't find out ID of inventory.`)
+  if (!refOrder?.id || !refOrder.name) throw new Error(`Can't find out ID or Name of Reference Order`)
+  if (
+    !inventory?.domain ||
+    !inventory?.bizplace ||
+    !inventory?.product?.id ||
+    !inventory?.warehouse?.id ||
+    !inventory?.location?.id
+  ) {
+    inventory = await invRepo.findOne({
+      where: { id: inventory.id },
+      relations: ['domain', 'bizplace', 'product', 'warehouse', 'location']
+    })
+  }
+
+  const domain: Domain = inventory.domain
+  const location: Location = inventory.location
+
+  const seq: number = await invHistoryRepo.count({ domain: inventory.domain, palletId: inventory.palletId })
+  let openingQty: number = 0
+  let openingUomValue: number = 0
+
+  if (seq) {
+    const lastInvHistory: InventoryHistory = await invHistoryRepo.findOne({
+      domain: inventory.domain,
+      palletId: inventory.palletId,
+      seq: seq - 1
+    })
+    openingQty = lastInvHistory.openingQty + lastInvHistory.qty
+    openingUomValue = lastInvHistory.openingUomValue + lastInvHistory.uomValue
+  }
+
+  let inventoryHistory: InventoryHistory = new InventoryHistory()
+  inventoryHistory.name = InventoryNoGenerator.inventoryHistoryName()
+  inventoryHistory.description = inventory.description
+  inventoryHistory.seq = seq
+  inventoryHistory.palletId = inventory.palletId
+  inventoryHistory.cartonId = inventory.cartonId
+  inventoryHistory.batchId = inventory.batchId
+  inventoryHistory.batchIdRef = inventory.batchIdRef
+  inventoryHistory.status = inventory.status
+  inventoryHistory.transactionType = transactionType
+  inventoryHistory.refOrderId = refOrder?.id || null
+  inventoryHistory.orderNo = refOrder?.name || null
+  inventoryHistory.orderRefNo = refOrder?.refNo || null
+  inventoryHistory.inventory = inventory
+  inventoryHistory.product = inventory.product
+  inventoryHistory.reusablePallet = inventory.reusablePallet
+  inventoryHistory.zone = inventory.zone
+  inventoryHistory.warehouse = inventory.warehouse
+  inventoryHistory.location = inventory.location
+  inventoryHistory.expirationDate = inventory.expirationDate
+  inventoryHistory.packingType = inventory.packingType
+  inventoryHistory.packingSize = inventory.packingSize
+  inventoryHistory.uom = inventory.uom
+  inventoryHistory.qty = qty
+  inventoryHistory.openingQty = openingQty
+  inventoryHistory.uomValue = uomValue
+  inventoryHistory.openingUomValue = openingUomValue
+  inventoryHistory.unitCost = inventory.unitCost
+  inventoryHistory.domain = inventory.domain
+  inventoryHistory.bizplace = inventory.bizplace
+  inventoryHistory.creator = user
+  inventoryHistory.updater = user
+
+  inventoryHistory = await invHistoryRepo.save(inventoryHistory)
+
+  if (inventory.lastSeq !== seq) {
+    await invRepo.save({
+      ...inventory,
+      lastSeq: inventoryHistory.seq,
+      updater: user
+    })
+  }
+
+  await switchLocationStatus(domain, location, user, trxMgr)
+  return inventoryHistory
+}
+
 /**
  * @description: Check location emptiness and update status of location
  * @param domain
@@ -971,17 +1057,12 @@ export async function switchLocationStatus(
   return location
 }
 
-export function _composeTargetInventories(
-  productDetail: ProductDetail,
-  record: any,
-  inventories: Inventory[]
-): OrderInventory[] {
+export function _composeTargetInventories(product: Product, record: any, inventories: Inventory[]): OrderInventory[] {
   let leftReleaseQty: number = record.releaseQty
   let leftReleaseUomValue: number = record.releaseUomValue
   let compReleaseQty: number = 0
   let compReleaseUomValue: number = 0
   let totalInventoryQty: number = inventories.reduce((total, inventory) => total + inventory.remainQty, 0)
-  let product = productDetail.product
 
   if (totalInventoryQty < record.releaseQty) {
     throw new Error(`invalid release qty for ${product?.sku}`)
@@ -1034,7 +1115,6 @@ export function _composeTargetInventories(
       batchIdRef,
       uom,
       product,
-      productDetail,
       type: ORDER_TYPES.RELEASE_OF_GOODS
     })