fleetmap-reports 2.0.364 → 2.0.366

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fleetmap-reports",
-  "version": "2.0.364",
+  "version": "2.0.366",
   "description": "",
   "main": "src/index.js",
   "scripts": {

package/src/partnerReports/driverranking-report.js

@@ -1,8 +1,9 @@
+const axios = require('axios').default
 const traccarHelper = require('../util/traccar')
 const { getDriverData, devicesByDriver } = require('../util/driver')
 const { getCanDriverStyleMessages, parseCanDriverStyleMessage } = require('../util/xpert')
 const { calculateRPMSections } = require('./performance-report')
-const { getTranslations, isClientSide, convertToLocaleString, convertMS, executeServerSide } = require('../util/utils')
+const { getTranslations, isClientSide, convertToLocaleString, convertMS, getServerHost } = require('../util/utils')
 const jsPDF = require('jspdf')
 const { headerFromUser, addTable } = require('../util/pdfDocument')
 const { getStyle } = require('../reportStyle')
@@ -87,25 +88,8 @@ async function create (from, to, userData, traccar) {
   }
 
   if (isClientSide() && (userData.drivers.length > 50 || ((new Date(to).getTime() - new Date(from).getTime()) > (1000 * 60 * 60 * 24 * 15)))) {
-    const sliced = automaticReports.sliceArray(userData.drivers, 5)
-    userData.requestToRunServerSide = true
-    userData.byDriver = true
-    // Narrow the devices sent per-slice to just the ones those drivers actually used, so a single
-    // server invocation doesn't have to hold the whole fleet's route data in memory at once (was
-    // causing Runtime.OutOfMemory on large fleets).
-    const allDriversData = await executeServerSide('driverranking-report', sliced, from, to, userData, userData.drivers.length, traccar, 5, (driversSlice) => {
-      const deviceIds = new Set()
-      driversSlice.forEach(d => {
-        const ids = deviceIdsByDriver.get(d.uniqueId)
-        if (ids) {
-          ids.forEach(id => deviceIds.add(id))
-        }
-      })
-      return { devices: userData.devices.filter(device => deviceIds.has(device.id)) }
-    })
-
-    allDriversData.sort((a, b) => b.overallScore - a.overallScore)
-    allDriversData.forEach((d, index) => { d.rank = index + 1 })
+    const rawRows = await runServerSideGrid(from, to, userData, deviceIdsByDriver, traccar)
+    const allDriversData = scoreAndRankDrivers(mergeRawRows(rawRows), userData)
 
     reportData.drivers = allDriversData
     reportData.target = buildTargets(userData)
@@ -159,7 +143,25 @@ async function create (from, to, userData, traccar) {
     }
   }
 
-  const allDriversData = (Array.from(driversData.values())).filter(d => d.distance > 0)
+  const rawRows = Array.from(driversData.values())
+
+  // When invoked as one cell of the client's (driverSlice x dateChunk) grid, return the raw
+  // accumulated totals for just this chunk - the client sums them across chunks for the same
+  // driver before computing scores, since scores are relative to the whole requested period.
+  if (userData.rawMode) {
+    reportData.drivers = rawRows
+    return reportData
+  }
+
+  reportData.drivers = scoreAndRankDrivers(rawRows, userData)
+  reportData.target = buildTargets(userData)
+  reportData.coefficient = buildCoefficients()
+
+  return reportData
+}
+
+function scoreAndRankDrivers (rawRows, userData) {
+  const allDriversData = rawRows.filter(d => d.distance > 0)
   allDriversData.forEach(d => {
     d.avgFuelConsumption = getCanAvgConsumption(d.distance, d.spentFuel).byKms
 
@@ -185,12 +187,86 @@ async function create (from, to, userData, traccar) {
   })
   allDriversData.sort((a, b) => b.overallScore - a.overallScore)
   allDriversData.forEach((d, index) => { d.rank = index + 1 })
+  return allDriversData
+}
 
-  reportData.drivers.push(...allDriversData)
-  reportData.target = buildTargets(userData)
-  reportData.coefficient = buildCoefficients()
+const mergedFields = ['distance', 'highEngineRPM', 'hardBraking', 'hardAcceleration', 'hardCornering',
+  'overspeed', 'spentFuel', 'geofenceAlarm', 'continuesDrivingAlarm', 'reverseAlarm', 'otherAlarm']
+
+// Sums each driver's raw totals across every (driverSlice x dateChunk) grid cell they appeared in
+function mergeRawRows (rawRows) {
+  const merged = new Map()
+  rawRows.forEach(row => {
+    let acc = merged.get(row.driverId)
+    if (!acc) {
+      acc = { driverId: row.driverId, name: row.name }
+      mergedFields.forEach(field => { acc[field] = 0 })
+      merged.set(row.driverId, acc)
+    }
+    mergedFields.forEach(field => { acc[field] += row[field] || 0 })
+  })
+  return Array.from(merged.values())
+}
 
-  return reportData
+// Fans the report out across a grid of (driverSlice x dateChunk) requests to the backend, so no
+// single Lambda invocation has to hold more than a handful of drivers' worth of one week of route
+// data in memory at once, and progress feedback arrives once per grid cell rather than once per
+// driver-slice (which could take minutes on its own with a long date range).
+async function runServerSideGrid (from, to, userData, deviceIdsByDriver, traccar) {
+  const driverSlices = automaticReports.sliceArray(userData.drivers, 5)
+  const dateChunks = splitDateRange(from, to, 7)
+
+  const cells = []
+  driverSlices.forEach(driverSlice => {
+    dateChunks.forEach(dateChunk => cells.push({ driverSlice, dateChunk }))
+  })
+
+  const cookie = await axios.get('/pinmeapi/cookie/get', { withCredentials: true }).then(d => d.data)
+  const url = `https://${getServerHost()}/pinmeapi/reports/driverranking-report`
+  const rawRows = []
+  let completed = 0
+  const maxConcurrent = 10
+
+  for (let i = 0; i < cells.length; i += maxConcurrent) {
+    const batch = cells.slice(i, i + maxConcurrent)
+    await Promise.all(batch.map(async ({ driverSlice, dateChunk }) => {
+      const deviceIds = new Set()
+      driverSlice.forEach(d => {
+        const ids = deviceIdsByDriver.get(d.uniqueId)
+        if (ids) {
+          ids.forEach(id => deviceIds.add(id))
+        }
+      })
+      const slicedDevices = userData.devices.filter(device => deviceIds.has(device.id))
+
+      try {
+        const response = await axios.post(url, {
+          from: dateChunk.from,
+          to: dateChunk.to,
+          userData: {
+            ...userData,
+            drivers: driverSlice,
+            devices: slicedDevices,
+            geofences: [],
+            requestToRunServerSide: true,
+            rawMode: true
+          },
+          cookie
+        }, { withCredentials: true })
+        const result = response.data[0]
+        if (result) {
+          rawRows.push(...(result.drivers || []))
+        }
+      } catch (e) {
+        console.error(e)
+      }
+      completed++
+      console.log('LOADING_MESSAGE:' + driverSlice[0].name)
+      console.log(`PROGRESS_PERC:${(completed / cells.length) * 100}`)
+    }))
+  }
+
+  return rawRows
 }
 
 function buildTargets (userData) {
@@ -241,6 +317,7 @@ async function processDevice (driversData, device, userData, allInOne, alarmEven
     let driverData = driversData.get(d.id)
     if (!driverData) {
       driverData = {
+        driverId: d.id,
         name: d.name,
         distance: 0,
         highEngineRPM: 0,