fleetmap-reports 2.0.387 → 2.0.388

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fleetmap-reports",
-  "version": "2.0.387",
+  "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