@things-factory/operato-pms 4.3.595 → 4.3.609

package/server/graphql/resolvers/daily-loading/generate-daily-loading.ts

@@ -1,5 +1,4 @@
 import { EntityManager, getRepository, Repository } from 'typeorm'
-
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 
@@ -11,40 +10,36 @@ export const generateDailyLoading = {
   async generateDailyLoading(_: any, { dailyLoading }, context: any) {
     const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
-    let dailyLoadingDetails: DailyLoadingDetail[] = dailyLoading.dailyLoadingDetails
-
-    const totalWeight: number = dailyLoadingDetails.reduce(function (prev, cur) {
-      return prev + cur.totalBunchWeight
-    }, 0)
+    try {
+      const dailyLoadingDetails: DailyLoadingDetail[] = dailyLoading.dailyLoadingDetails
 
-    const totalBunch: number = dailyLoadingDetails.reduce(function (prev, cur) {
-      return prev + cur.totalBunchLoaded
-    }, 0)
+      // Calculate total weight and total bunch
+      const totalWeight = parseFloat(
+        dailyLoadingDetails.reduce((prev, cur) => prev + cur.totalBunchWeight, 0).toFixed(4)
+      )
+      const totalBunch = parseFloat(
+        dailyLoadingDetails.reduce((prev, cur) => prev + cur.totalBunchLoaded, 0).toFixed(4)
+      )
 
-    // 1. Create daily loading
-    let newDailyLoading: DailyLoading = new DailyLoading()
-    newDailyLoading.name = NoGenerator.dailyLoading()
-    newDailyLoading.domain = domain
-    newDailyLoading.loadingDate = dailyLoading.loadingDate
-    newDailyLoading.totalBunch = totalBunch
-    newDailyLoading.totalWeight = totalWeight
-    newDailyLoading.status = RECORD_STATUS.STORED
-    newDailyLoading.creator = user
+      // 1. Create daily loading
+      const newDailyLoading = await tx.getRepository(DailyLoading).save({
+        name: NoGenerator.dailyLoading(),
+        domain,
+        loadingDate: dailyLoading.loadingDate,
+        totalBunch,
+        totalWeight,
+        status: RECORD_STATUS.STORED,
+        creator: user
+      })
 
-    newDailyLoading = await tx.getRepository(DailyLoading).save(newDailyLoading)
+      // 2. Create daily loading details and update inventory
+      await addDailyLoadingDetail(domain, newDailyLoading, dailyLoadingDetails, user, tx)
 
-    // 2. Create daily loading detail
-    dailyLoadingDetails = await addDailyLoadingDetail(
-      domain,
-      newDailyLoading,
-      dailyLoadingDetails.map((record: DailyLoadingDetail) => {
-        return { ...record }
-      }),
-      user,
-      tx
-    )
-
-    return newDailyLoading
+      return newDailyLoading
+    } catch (error) {
+      console.error('Error generating daily loading:', error)
+      throw new Error('Failed to generate daily loading.')
+    }
   }
 }
 
@@ -58,29 +53,39 @@ export async function addDailyLoadingDetail(
   const truckRepo: Repository<Truck> = tx?.getRepository(Truck) || getRepository(Truck)
   const blockRepo: Repository<Block> = tx?.getRepository(Block) || getRepository(Block)
   const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
-
   const dailyLoadingDetailRepo: Repository<DailyLoadingDetail> =
     tx?.getRepository(DailyLoadingDetail) || getRepository(DailyLoadingDetail)
 
-  dailyLoadingDetails = await Promise.all(
-    dailyLoadingDetails.map(async (record: DailyLoadingDetail) => {
-      return {
-        ...record,
-        domain,
-        name: NoGenerator.dailyLoadingDetail(),
-        truck: await truckRepo.findOne({ id: record.truck.id }),
-        block: await blockRepo.findOne({ id: record.block.id }),
-        ramp: await rampRepo.findOne({ id: record.ramp.id }),
-        dailyLoading: newDailyLoading,
-        creator: user
-      }
-    })
-  )
+  // Fetch all related entities in a single query to reduce database calls
+  const trucks = await truckRepo.findByIds(dailyLoadingDetails.map(d => d.truck.id))
+  const blocks = await blockRepo.findByIds(dailyLoadingDetails.map(d => d.block.id))
+  const ramps = await rampRepo.findByIds(dailyLoadingDetails.map(d => d.ramp.id))
+
+  const detailsToSave = dailyLoadingDetails.map(record => {
+    const truck = trucks.find(t => t.id === record.truck.id)
+    const block = blocks.find(b => b.id === record.block.id)
+    const ramp = ramps.find(r => r.id === record.ramp.id)
+
+    if (!truck || !block || !ramp) {
+      throw new Error(`Truck, Block, or Ramp not found for detail: ${record.name}`)
+    }
+
+    return {
+      ...record,
+      domain,
+      name: NoGenerator.dailyLoadingDetail(),
+      truck,
+      block,
+      ramp,
+      dailyLoading: newDailyLoading,
+      creator: user
+    }
+  })
 
-  dailyLoadingDetails = await dailyLoadingDetailRepo.save(dailyLoadingDetails)
-  await updatePlantationInventory(domain, newDailyLoading, dailyLoadingDetails, user, tx)
+  const savedDetails = await dailyLoadingDetailRepo.save(detailsToSave)
+  await updatePlantationInventory(domain, newDailyLoading, savedDetails, user, tx)
 
-  return dailyLoadingDetails
+  return savedDetails
 }
 
 export async function updatePlantationInventory(
@@ -93,68 +98,60 @@ export async function updatePlantationInventory(
   const plantationInvRepo: Repository<PlantationInventory> =
     tx?.getRepository(PlantationInventory) || getRepository(PlantationInventory)
 
-  for (let dailyLoadingDetail of dailyLoadingDetails) {
-    let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
-      where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp: dailyLoadingDetail.ramp },
-      relations: ['domain', 'block', 'ramp']
-    })
-
-    if (existingRampTonnage) {
-      existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + dailyLoadingDetail.totalBunchWeight
-      existingRampTonnage.updater = user
-      await plantationInvRepo.save(existingRampTonnage)
+  for (const detail of dailyLoadingDetails) {
+    // Use a transaction to ensure atomicity
+    await tx.transaction(async transactionalEntityManager => {
+      let existingRampTonnage = await transactionalEntityManager.findOne(PlantationInventory, {
+        where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp: detail.ramp },
+        relations: ['domain', 'block', 'ramp']
+      })
+
+      if (existingRampTonnage) {
+        existingRampTonnage.totalTonnage = parseFloat(
+          (existingRampTonnage.totalTonnage + detail.totalBunchWeight).toFixed(4)
+        )
+        existingRampTonnage.updater = user
+        await transactionalEntityManager.save(existingRampTonnage)
+      } else {
+        const plantationInventory = transactionalEntityManager.create(PlantationInventory, {
+          domain,
+          name: NoGenerator.rampTonnageName(),
+          block: detail.block,
+          type: INVENTORY_TYPE.RAMP_TONNAGE,
+          totalTonnage: detail.totalBunchWeight,
+          status: INVENTORY_STATUS.STORED,
+          ramp: detail.ramp,
+          creator: user
+        })
+        await transactionalEntityManager.save(plantationInventory)
+      }
 
       await generateTransactionHistory(
-        dailyLoadingDetail.block,
+        detail.block,
         domain,
-        dailyLoadingDetail.ramp,
+        detail.ramp,
         newDailyLoading.id,
         newDailyLoading.name,
         TRANSACTION_TYPE.LOADING,
         newDailyLoading.loadingDate,
-        0,
-        dailyLoadingDetail.totalBunchWeight,
+        detail.totalBunchLoaded,
+        detail.totalBunchWeight,
         user,
-        tx
+        transactionalEntityManager
       )
-    } else {
-      let plantationInventory: PlantationInventory = new PlantationInventory()
-      plantationInventory.domain = domain
-      plantationInventory.name = NoGenerator.rampTonnageName()
-      plantationInventory.block = dailyLoadingDetail.block
-      plantationInventory.type = INVENTORY_TYPE.RAMP_TONNAGE
-      plantationInventory.totalTonnage = dailyLoadingDetail.totalBunchWeight
-      plantationInventory.status = INVENTORY_STATUS.STORED
-      plantationInventory.ramp = dailyLoadingDetail.ramp
-      plantationInventory.creator = user
-      plantationInventory = await plantationInvRepo.save(plantationInventory)
 
-      await generateTransactionHistory(
-        dailyLoadingDetail.block,
+      await generateRampBlockHistories(
+        detail.block,
         domain,
-        dailyLoadingDetail.ramp,
-        newDailyLoading.id,
-        newDailyLoading.name,
-        TRANSACTION_TYPE.LOADING,
+        detail.ramp,
+        'LOADING',
         newDailyLoading.loadingDate,
-        0,
-        dailyLoadingDetail.totalBunchWeight,
+        detail.totalBunchWeight,
         user,
-        tx
+        null,
+        null,
+        transactionalEntityManager
       )
-    }
-
-    await generateRampBlockHistories(
-      dailyLoadingDetail.block,
-      domain,
-      dailyLoadingDetail.ramp,
-      'LOADING',
-      newDailyLoading.loadingDate,
-      dailyLoadingDetail.totalBunchWeight,
-      user,
-      null,
-      null,
-      tx
-    )
+    })
   }
 }

package/server/graphql/resolvers/daily-loading/update-daily-loading.ts

@@ -3,8 +3,8 @@ import { EntityManager, getRepository, Repository } from 'typeorm'
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 
-import { INVENTORY_TYPE, TRANSACTION_TYPE } from '../../../constants'
-import { Block, DailyLoading, DailyLoadingDetail, PlantationInventory, Ramp, Truck } from '../../../entities'
+import { TRANSACTION_TYPE } from '../../../constants'
+import { Block, DailyLoading, DailyLoadingDetail, Ramp, Truck } from '../../../entities'
 import { generateTransactionHistory, NoGenerator } from '../../../utils'
 
 export const updateDailyLoading = {
@@ -31,8 +31,8 @@ export const updateDailyLoading = {
       return prev + cur.totalBunchWeight
     }, 0)
 
-    dailyLoading.totalBunch = totalBunch
-    dailyLoading.totalWeight = totalWeight
+    dailyLoading.totalBunch = parseFloat(totalBunch.toFixed(4))
+    dailyLoading.totalWeight = parseFloat(totalWeight.toFixed(4))
     dailyLoading.loadingDate = dailyLoadingPatch.loadingDate
     dailyLoading.updater = user
     dailyLoading = await dailyLoadingRepo.save(dailyLoading)
@@ -59,12 +59,11 @@ export async function updateDailyLoadingDetail(
 
   let updatedDailyLoadingDetails: any[] = []
   const dailyLoadingDetails: DailyLoadingDetail[] = dailyLoading.dailyLoadingDetails
-  // for existing data row
+
+  // Filter existing and new records
   const existingDailyLoadingDetails: DailyLoadingDetail[] = dailyLoadingDetailPatches.filter(
     detail => detail.name !== null
   )
-
-  // new row added in client side
   const newDailyLoadingDetail: DailyLoadingDetail[] = dailyLoadingDetailPatches.filter(detail => detail.name === null)
 
   if (existingDailyLoadingDetails?.length > 0) {
@@ -74,8 +73,29 @@ export async function updateDailyLoadingDetail(
           detail => detail.name === existingRecord.name
         )
 
-        if (foundDailyLoadingDetailPatch.totalBunchWeight !== existingRecord.totalBunchWeight) {
-          await updatePlantationInventory(domain, dailyLoading, foundDailyLoadingDetailPatch, existingRecord, user, tx)
+        if (foundDailyLoadingDetailPatch) {
+          // Calculate variance for totalBunchLoaded
+          const bunchLoadedVariance =
+            foundDailyLoadingDetailPatch.totalBunchLoaded - foundDailyLoadingDetailPatch.prevTotalBunchLoaded
+          const bunchWeightVariance =
+            foundDailyLoadingDetailPatch.totalBunchWeight - foundDailyLoadingDetailPatch.prevTotalBunchWeight
+
+          // If there is a variance, generate a transaction history
+          if (bunchLoadedVariance !== 0 || bunchWeightVariance !== 0) {
+            await generateTransactionHistory(
+              existingRecord.block,
+              domain,
+              existingRecord.ramp,
+              dailyLoading.id,
+              dailyLoading.name,
+              TRANSACTION_TYPE.LOADING_ADJUSTMENT, // Use appropriate transaction type
+              dailyLoading.loadingDate,
+              bunchLoadedVariance,
+              bunchWeightVariance,
+              user,
+              tx
+            )
+          }
         }
 
         return {
@@ -110,45 +130,22 @@ export async function updateDailyLoadingDetail(
         newDailyLoadingDetail.dailyLoading = dailyLoading
 
         await dailyLoadingDetailRepo.save(newDailyLoadingDetail)
-      })
-    )
-  }
-}
 
-export async function updatePlantationInventory(
-  domain: Domain,
-  dailyLoading: DailyLoading,
-  foundDailyLoadingDetailPatch: any,
-  existingRecord: DailyLoadingDetail,
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const plantationInvRepo: Repository<PlantationInventory> =
-    tx?.getRepository(PlantationInventory) || getRepository(PlantationInventory)
-
-  let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
-    where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp: existingRecord.ramp },
-    relations: ['domain', 'block', 'ramp']
-  })
-
-  if (existingRampTonnage) {
-    const tonnageChanges: number = foundDailyLoadingDetailPatch.totalBunchWeight - existingRecord.totalBunchWeight
-    existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + tonnageChanges
-    existingRampTonnage.updater = user
-    await plantationInvRepo.save(existingRampTonnage)
-
-    await generateTransactionHistory(
-      existingRampTonnage.block,
-      domain,
-      existingRampTonnage.ramp,
-      dailyLoading.id,
-      dailyLoading.name,
-      TRANSACTION_TYPE.LOADING_ADJUSTMENT,
-      dailyLoading.loadingDate,
-      0,
-      tonnageChanges,
-      user,
-      tx
+        // Generate transaction history for new records
+        await generateTransactionHistory(
+          newDailyLoadingDetail.block,
+          domain,
+          newDailyLoadingDetail.ramp,
+          dailyLoading.id,
+          dailyLoading.name,
+          TRANSACTION_TYPE.LOADING, // Use appropriate transaction type
+          dailyLoading.loadingDate,
+          newDailyLoadingDetail.totalBunchLoaded,
+          newDailyLoadingDetail.totalBunchWeight,
+          user,
+          tx
+        )
+      })
     )
   }
 }

package/server/graphql/resolvers/report/daily-ffb-dispatch-production-reports.ts

@@ -6,7 +6,7 @@ import { Block, Organization, Ramp } from '../../../entities'
 export const dailyFfbDispatchProductionReports = {
   async dailyFfbDispatchProductionReports(_: any, params: ListParam, context: any) {
     try {
-      const { domain, tx }: { domain: Domain, tx: EntityManager } = context.state
+      const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
 
       let year = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[0])
       let month = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[1])
@@ -36,14 +36,16 @@ export const dailyFfbDispatchProductionReports = {
         where: { domain: domain.id, deletedAt: IsNull() }
       })
 
-      let blocks = await tx.getRepository(Block).query(`
+      let blocks = await tx.getRepository(Block).query(
+        `
         SELECT b.id, b.name FROM ramps r
         INNER JOIN blocks b ON b.id = r.block_id 
         WHERE b.deleted_at IS NULL
         AND r.domain_id = $1
         GROUP BY b.id, b.name         
-      `, [domain.id])
-
+      `,
+        [domain.id]
+      )
 
       // --  WHERE dd.dispatch_at::timestamp between $1::timestamp and $2::timestamp
       // [fromDateString, toDateString]
@@ -52,44 +54,67 @@ export const dailyFfbDispatchProductionReports = {
       await tx.query(
         `
           CREATE TEMP TABLE raw_block_dispatch ON COMMIT DROP AS (
-            SELECT "name", "dispatch_at", sum(weight) AS weight	FROM(
+            SELECT 
+              "name", 
+              "dispatch_at", 
+              SUM(weight::numeric) AS weight 
+            FROM (
               SELECT * FROM (
-                SELECT dd.id,COALESCE(b.name, 'unknown') AS name, 1 AS "rank", dd.dispatch_at::date AS dispatch_at,
-                COALESCE(ddd.adjusted_weight, ddd.collected_ramp_weight, 0) AS weight
-                FROM daily_dispatches dd 
-                INNER JOIN daily_dispatch_details ddd ON ddd.daily_dispatch_id = dd.id
-                INNER JOIN ramps r ON r.id = ddd.ramp_id 
-                INNER JOIN blocks b ON b.id = r.block_id
-                WHERE dd.dispatch_at::date between $1 and $2
-                AND b.deleted_at is null
+                SELECT 
+                  rbh.id, 
+                  COALESCE(b.name, 'unknown') AS name, 
+                  1 AS "rank", 
+                  rbh.transaction_date::date AS dispatch_at,
+                  CASE
+                    WHEN rbh.transaction_type = 'DISPATCH' AND rbh.weight < 0 THEN ABS(rbh.weight)
+                    WHEN rbh.transaction_type IN ('REVERSE_DISPATCH', 'TONNAGE_VARIANCE') THEN ABS(rbh.weight)
+                    ELSE 0
+                  END AS weight
+                FROM ramp_block_histories rbh
+                INNER JOIN blocks b ON b.id = rbh.block_id 
+                WHERE rbh.transaction_type IN ('DISPATCH', 'REVERSE_DISPATCH', 'TONNAGE_VARIANCE')
+                  AND rbh.transaction_date::date BETWEEN $1 AND $2
+                  AND b.deleted_at IS NULL
                 UNION
-                SELECT dd.id, COALESCE(c.name, 'unknown') AS name, CASE WHEN c.name IS NULL THEN 3 ELSE 2 END AS "rank", dd.dispatch_at::date AS dispatch_at,
-                COALESCE((SELECT SUM(COALESCE(ddd.adjusted_weight, ddd.collected_ramp_weight, 0)) FROM daily_dispatch_details ddd WHERE ddd.daily_dispatch_id = dd.id),0) AS weight	
+                SELECT 
+                  dd.id, 
+                  COALESCE(c.name, 'unknown') AS name, 
+                  CASE WHEN c.name IS NULL THEN 3 ELSE 2 END AS "rank", 
+                  dd.dispatch_at::date AS dispatch_at,
+                  COALESCE(
+                    (SELECT SUM(COALESCE(ddd.adjusted_weight, ddd.collected_ramp_weight, 0)) 
+                    FROM daily_dispatch_details ddd 
+                    WHERE ddd.daily_dispatch_id = dd.id), 0
+                  ) AS weight	
                 FROM daily_dispatches dd 
                 LEFT JOIN organizations c ON c.id = dd.dispatch_to_id
-                WHERE dd.dispatch_at::date between $1 and $2
+                WHERE dd.dispatch_at::date BETWEEN $1 AND $2
+                  AND dd.deleted_at IS NULL
               ) foo 
               ORDER BY "rank", "name", "dispatch_at"
             ) foo
             GROUP BY "name", "dispatch_at"
             ORDER BY name, "dispatch_at"
-          )          
+          );        
         `,
         [fromDateString, toDateString]
       )
 
-      await tx.query(`
+      await tx.query(
+        `
         create temp table cross_column ON COMMIT DROP as (
-          SELECT b.name FROM ramps r 
-          INNER JOIN blocks b ON b.id = r.block_id 
-          WHERE r.deleted_at IS NULL AND r.domain_id = $1
+          SELECT b.name FROM blocks b
+          WHERE 1=1  
+          AND b.domain_id = $1
           AND b.deleted_at is null
           GROUP BY b.id, b.name
           UNION
           SELECT c.name FROM organizations c
           where c.deleted_at is null
         )
-      `, [domain.id])
+      `,
+        [domain.id]
+      )
 
       let definedCrossColumn = await tx.query(`
         select string_agg(concat('"', name, '"'),',') as columns from cross_column
@@ -108,7 +133,12 @@ export const dailyFfbDispatchProductionReports = {
               $$
                 SELECT name from cross_column
               $$
-            ) AS (dispatch_at date, ${definedCrossColumn[0].columns.split(',').map(itm => { return itm + ' varchar' }).join(',')} )
+            ) AS (dispatch_at date, ${definedCrossColumn[0].columns
+              .split(',')
+              .map(itm => {
+                return itm + ' varchar'
+              })
+              .join(',')} )
           );
         `
       )
@@ -117,7 +147,12 @@ export const dailyFfbDispatchProductionReports = {
         `
           CREATE TEMP TABLE temp_monthly_production_data ON COMMIT DROP AS (
             SELECT TO_CHAR(md.dateDay:: DATE, 'dd/mm/yyyy') as "date"
-            , row_to_json((SELECT d FROM (SELECT ${definedCrossColumn[0].columns.split(',').map(itm => { return 'pbd.' + itm }).join(',')}) d))::varchar as "blockData"
+            , row_to_json((SELECT d FROM (SELECT ${definedCrossColumn[0].columns
+              .split(',')
+              .map(itm => {
+                return 'pbd.' + itm
+              })
+              .join(',')}) d))::varchar as "blockData"
             , (SELECT sum(weight) FROM raw_block_dispatch rbd WHERE rbd.dispatch_at = pbd.dispatch_at) AS "today"
             FROM (select generate_series((date '${fromDateString}')::timestamp, (date '${toDateString}')::timestamp, interval '1 day')::date as dateDay) as md 
             LEFT JOIN pivot_block_dispatch pbd on pbd.dispatch_at::date = md.dateDay
@@ -138,13 +173,13 @@ export const dailyFfbDispatchProductionReports = {
         `
       )
 
-
       return {
         items: result.map(itm => {
           return {
             ...itm
           }
-        }), total: total[0].count
+        }),
+        total: total[0].count
       }
     } catch (error) {
       throw error