fleetmap-reports 2.0.386 → 2.0.388

package/package.json

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

package/src/kms-report.js

@@ -11,16 +11,18 @@ const { getDates, getTranslations, isClientSide, executeServerSide } = require('
 const driversUtil = require('./util/driver')
 const {
   isInsideTimetable, isPartialInsideTimetable, calculateTrip, getDataByDay, getKms,
-  getTripTotalKms, calculateMultiDayTrips
+  getTripTotalKms, calculateMultiDayTrips, getUncompletedTrip
 } = require('./util/trips')
 const { devicesToProcess } = require('./util/device')
 const { getDriverData, reportByDriver } = require('./util/driver')
 const automaticReports = require('./automaticReports')
-const { getSummaryByDay } = require('./util/traccar')
 const { getStop } = require('./trip-report')
 
 const fileName = 'KmsReport'
 
+// dates from getDates are at noon: 12h back/forward to the day boundary plus a 24h buffer
+const CHUNK_BOUNDARY_BUFFER_MS = 36 * 60 * 60 * 1000
+
 async function createKmsReport (from, to, userData, traccarInstance) {
   console.log('Create KmsReport', from, to, userData.byDriver ? 'by driver' : (userData.byGroup ? 'by group' : 'by device'))
   const reportData = []
@@ -47,52 +49,31 @@ async function createKmsReportByDevice (from, to, userData, traccarInstance) {
     to
   }
 
-  if (isClientSide() && (allDevices.length > 50 || ((new Date(to).getTime() - new Date(from).getTime()) > (1000 * 60 * 60 * 24 * 15))) && userData.groupByDay) {
+  if (isClientSide() && allDevices.length > 20) {
     const sliced = automaticReports.sliceArray(allDevices, 1)
     await executeServerSide('kms-report', sliced, from, to, userData, allDevices.length, traccarInstance).then(devices => {
       allData.devices = devices
     })
   } else {
-    if (userData.allWeek && userData.groupByDay) {
-      const dates = getDates(from, to, userData.user.attributes.timezone || getUserPartner(userData.user).timezone)
-      const summary = await getSummaryByDay(dates, userData, traccarInstance, allDevices, false, from, to)
-      for (const device of allDevices) {
-        const days = []
-        dates.forEach(date => {
-          const summaryByDay = summary.find(a => a.date === date).summary
-          const summaryByDevice = summaryByDay.find(a => a.deviceId === device.id)
-          if (summaryByDevice) {
-            days.push({
-              date,
-              kms: summaryByDevice.distance,
-              startOdometer: summaryByDevice.startOdometer,
-              endOdometer: summaryByDevice.endOdometer
-            })
-          }
-        })
-        const daysWithOdometer = days.filter(a => a.startOdometer > 0)
-        allData.devices.push({
-          device,
-          startOdometer: daysWithOdometer.length > 0 ? daysWithOdometer[0].startOdometer : 0,
-          endOdometer: daysWithOdometer.length > 0 ? daysWithOdometer[daysWithOdometer.length - 1].endOdometer : 0,
-          days
-        })
-      }
+    if (userData.groupByDay) {
+      allData.devices = await createKmsReportByDeviceByDay(from, to, allDevices, userData, traccarInstance)
     } else {
       let deviceCount = 0
       const sliced = automaticReports.sliceArray(allDevices,
         20)
       for (const devices of sliced) {
-        const needRoute = userData.groupByDay || !userData.allWeek
+        // without groupByDay the distance is the sum of getTripTotalKms, which needs route and stops
         const {
           trips,
           route,
+          stops,
           summary
-        } = await traccar.getAllInOne(traccarInstance, from, to, devices, needRoute, true, false, !userData.groupByDay, deviceCount, allDevices.length, 10, 1)
+        } = await traccar.getAllInOne(traccarInstance, from, to, devices, true, true, !userData.groupByDay, !userData.groupByDay, deviceCount, allDevices.length, 10, 1)
 
         allData.devices = allData.devices.concat(await processDevices(from, to, devices, {
           trips,
           route,
+          stops,
           summary
         }, userData, traccarInstance))
 
@@ -104,6 +85,63 @@ async function createKmsReportByDevice (from, to, userData, traccarInstance) {
   return allData
 }
 
+// Same distance as the trip report (sum of getTripTotalKms), split by day.
+// The period is fetched in blocks of 7 days and 20 devices so long periods and large fleets
+// aren't loaded all at once (same approach as the fuel consumption report).
+async function createKmsReportByDeviceByDay (from, to, allDevices, userData, traccarInstance) {
+  const dates = getDates(from, to, userData.user.attributes.timezone || getUserPartner(userData.user).timezone)
+  const dateGroups = automaticReports.sliceArray(dates, 7)
+  const slicedDevices = automaticReports.sliceArray(allDevices, 20)
+  const totalDevices = allDevices.length * dateGroups.length
+  const results = new Map(allDevices.map(d => [d.id, { device: d, startOdometer: 0, endOdometer: 0, days: [], hasTrips: false }]))
+
+  let deviceCount = 0
+  for (const [index, chunkDates] of dateGroups.entries()) {
+    // internal boundaries are widened so a trip crossing them is fetched whole and then clipped by getDataByDay
+    const chunkFrom = index === 0 ? from : new Date(chunkDates[0].getTime() - CHUNK_BOUNDARY_BUFFER_MS)
+    const chunkTo = index === dateGroups.length - 1 ? to : new Date(chunkDates[chunkDates.length - 1].getTime() + CHUNK_BOUNDARY_BUFFER_MS)
+
+    for (const devices of slicedDevices) {
+      const data = await traccar.getAllInOne(traccarInstance, chunkFrom, chunkTo, devices, true, true, true, false, deviceCount, totalDevices, 10, 1)
+
+      for (const d of devices) {
+        const result = results.get(d.id)
+        const route = data.route.filter(p => p.deviceId === d.id)
+        const stops = data.stops.filter(s => s.deviceId === d.id)
+        const deviceTrips = data.trips.filter(t => t.deviceId === d.id)
+        const uncompletedTrip = getUncompletedTrip(d, route, deviceTrips)
+        if (uncompletedTrip) {
+          deviceTrips.push(uncompletedTrip)
+        }
+        const trips = deviceTrips.filter(t => userData.allWeek || !userData.weekDays || isInsideTimetable(t, userData) || isPartialInsideTimetable(d, t, userData, route))
+
+        for (const date of chunkDates) {
+          const { tripsByDay, stopsByDay } = await getDataByDay(d, date, { trips, stops, route }, userData, traccarInstance)
+          if (tripsByDay.length) {
+            if (!result.hasTrips) {
+              result.startOdometer = tripsByDay[0].startOdometer
+            }
+            result.endOdometer = tripsByDay[tripsByDay.length - 1].endOdometer
+            result.hasTrips = true
+          }
+          result.days.push({
+            date,
+            kms: tripsByDay.reduce((a, b) =>
+              a + getTripTotalKms(b, getStop(new Date(b.endTime), stopsByDay), route), 0
+            ) * 1000
+          })
+        }
+      }
+      deviceCount += devices.length
+    }
+  }
+
+  // with a timetable, devices without trips were already left out of the report
+  return [...results.values()]
+    .filter(r => userData.allWeek || r.hasTrips)
+    .map(({ hasTrips, ...r }) => r)
+}
+
 async function createKmsReportByDriver (from, to, userData, traccarInstance) {
   const report = { drivers: [] }
 
@@ -257,7 +295,17 @@ async function processDevices (from, to, devices, data, userData, traccarInstanc
         })
       }
     } else {
-      const summary = data.summary.find(s => s.deviceId === d.id)
+      let summary = data.summary.find(s => s.deviceId === d.id)
+      if (trips.length > 0) {
+        // same calculation as the trip report and the kms report by driver, so all of them give the same distance
+        const deviceStops = (data.stops || []).filter(s => s.deviceId === d.id)
+        summary = {
+          ...summary,
+          distance: trips.reduce((a, b) =>
+            a + getTripTotalKms(b, getStop(new Date(b.endTime), deviceStops), deviceRoute), 0
+          ) * 1000
+        }
+      }
       devicesResult.push({
         device: d,
         summary

package/src/partnerReports/performance-report.js

@@ -209,7 +209,7 @@ function calculateRPMSections (route, min, max) {
   let newSection = true
   route.forEach(p => {
     const rpm = p.attributes.rpm
-    if ((!min || rpm > min) && (!max || rpm < max)) {
+    if ((min === undefined || rpm > min) && (!max || rpm < max)) {
       if (newSection) {
         sections.push([p])
       } else {

package/src/rpm-report.js

@@ -10,7 +10,7 @@ const automaticReports = require('./automaticReports')
 const { calculateRPMSections } = require('./partnerReports/performance-report')
 
 const fileName = 'RPMReport'
-const defaultThreshold = 2500
+const defaultThreshold = 0
 
 async function createRPMReport (from, to, userData, traccarInstance) {
   console.log('Create RPMReport', from, to)
@@ -23,6 +23,7 @@ async function createRPMReport (from, to, userData, traccarInstance) {
   }
 
   const dates = getDates(from, to, userData.user.attributes.timezone || getUserPartner(userData.user).timezone)
+  const threshold = getThreshold(userData)
 
   let deviceCount = 0
   const sliced = automaticReports.sliceArray(allDevices, 20)
@@ -31,7 +32,7 @@ async function createRPMReport (from, to, userData, traccarInstance) {
     for (const d of devices) {
       const deviceRoute = route.filter(p => p.deviceId === d.id && p.attributes.rpm !== undefined)
       if (deviceRoute.length) {
-        allData.devices.push(processDevice(d, deviceRoute, dates))
+        allData.devices.push(processDevice(d, deviceRoute, dates, threshold))
       }
     }
     deviceCount += devices.length
@@ -40,8 +41,10 @@ async function createRPMReport (from, to, userData, traccarInstance) {
   return [allData]
 }
 
-function getThreshold (device) {
-  return Number(device.attributes.highRPM) || defaultThreshold
+// the report's own threshold (userData.rpmThreshold), independent of the device highRPM attribute used by other reports
+function getThreshold (userData) {
+  const threshold = Number(userData.rpmThreshold)
+  return userData.rpmThreshold !== undefined && userData.rpmThreshold !== '' && Number.isFinite(threshold) ? threshold : defaultThreshold
 }
 
 function dayKey (date) {
@@ -49,8 +52,7 @@ function dayKey (date) {
 }
 
 // time between consecutive positions that are both above the threshold, attributed to the day of the first one
-function processDevice (device, deviceRoute, dates) {
-  const threshold = getThreshold(device)
+function processDevice (device, deviceRoute, dates, threshold = defaultThreshold) {
   const days = dates.map(date => ({ date, time: 0 }))
   calculateRPMSections(deviceRoute, threshold).forEach(section => {
     for (let i = 1; i < section.length; i++) {

package/src/tests/rpm.test.js

@@ -17,17 +17,28 @@ describe('RPM_Report', function () {
     position(new Date(2026, 9, 2, 9, 0), 2600),
     position(new Date(2026, 9, 2, 9, 0, 30), 2600)
   ]
-  it('sums time above the default threshold per day', () => {
-    const result = processDevice({ id: 1, attributes: {} }, route, dates)
+  it('sums time above the threshold per day', () => {
+    const result = processDevice({ id: 1, attributes: {} }, route, dates, 2500)
     assert.equal(result.threshold, 2500)
     assert.equal(result.days[0].time, 3 * 60 * 1000)
     assert.equal(result.days[1].time, 30 * 1000)
     assert.equal(result.time, 3 * 60 * 1000 + 30 * 1000)
   })
-  it('uses the device highRPM attribute as threshold', () => {
-    const result = processDevice({ id: 1, attributes: { highRPM: 2650 } }, route, dates)
-    assert.equal(result.threshold, 2650)
-    assert.equal(result.days[0].time, 2 * 60 * 1000)
-    assert.equal(result.days[1].time, 0)
+  it('ignores the device highRPM attribute', () => {
+    const result = processDevice({ id: 1, attributes: { highRPM: 2650 } }, route, dates, 2500)
+    assert.equal(result.threshold, 2500)
+    assert.equal(result.days[0].time, 3 * 60 * 1000)
+  })
+  it('defaults to rpm > 0 (engine running time)', () => {
+    const idleRoute = [
+      position(new Date(2026, 9, 1, 8, 0), 0),
+      position(new Date(2026, 9, 1, 8, 10), 800),
+      position(new Date(2026, 9, 1, 8, 20), 2000),
+      position(new Date(2026, 9, 1, 8, 30), 0),
+      position(new Date(2026, 9, 1, 8, 40), 0)
+    ]
+    const result = processDevice({ id: 1, attributes: {} }, idleRoute, dates)
+    assert.equal(result.threshold, 0)
+    assert.equal(result.days[0].time, 10 * 60 * 1000)
   })
 })