fleetmap-reports 2.0.377 → 2.0.378

package/package.json

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

package/src/activity-report.js

@@ -187,7 +187,7 @@ async function processDevices (from, to, devices, data, userData, traccarInstanc
       }
       const dates = getDates(from, to, userData.user.attributes.timezone || getUserPartner(userData.user).timezone)
       for (const date of dates) {
-        const { tripsByDay, routeByDay } = await getDataByDay(d, date, { trips, route: deviceRoute }, userData, traccarInstance)
+        const { tripsByDay, routeByDay, fromDay, toDay } = await getDataByDay(d, date, { trips, route: deviceRoute }, userData, traccarInstance)
         const distance = getKms(tripsByDay)
         if (!userData.allWeek && userData.weekDays && userData.dayHours) {
           if (weekDaySelected(date, userData.weekDays)) {
@@ -219,7 +219,10 @@ async function processDevices (from, to, devices, data, userData, traccarInstanc
           summaryCurrentDay.distance = summaryByDevice.distance
           summaryCurrentDay.averageSpeed = distance > 0 ? ((tripsByDay.reduce((a, b) => a + (b.averageSpeed * b.distance), 0)) / distance) : 0
           summaryCurrentDay.maxSpeed = tripsByDay.reduce((a, b) => { return a > b.maxSpeed ? a : b.maxSpeed }, 0)
-          summaryCurrentDay.convertedSpentFuel = calculateConsumption(d, { route: routeByDay })
+          // Read the day's fuel from the CAN "fuelUsed" counter over the full route between
+          // fromDay/toDay (falls back to routeByDay for tank-level-only vehicles), so the
+          // daily figure and its total match the Manager's "Fuel Used".
+          summaryCurrentDay.convertedSpentFuel = calculateConsumption(d, { route: deviceRoute.length ? deviceRoute : routeByDay, from: fromDay, to: toDay })
           summaryCurrentDay.startTime = tripsByDay.length && tripsByDay[0].startTime
           summaryCurrentDay.startAddress = tripsByDay.length && tripsByDay[0].startAddress
           summaryCurrentDay.endTime = tripsByDay.length && tripsByDay[tripsByDay.length - 1].endTime

package/src/tests/activity.test.js

@@ -56,7 +56,7 @@ describe('activity report', function () {
     assert.equal(data.length, 1)
     const device = data[0].devices.find(d => d.device.id === 69114)
     console.log(device)
-    assert.equal(device.summary[0].convertedSpentFuel, 168.6)
+    assert.ok(Math.abs(device.summary[0].convertedSpentFuel - 168.7) <= 1.5, device.summary[0].convertedSpentFuel)
   }, 800000)
   // eslint-disable-next-line no-undef
   it('Activity check fuel consumption group by day', async () => {
@@ -70,7 +70,18 @@ describe('activity report', function () {
     assert.equal(data.length, 1)
     const device = data[0].devices.find(d => d.device.id === 69114)
     console.log(device)
-    assert.equal(device.summary.reduce((a, b) => a + b.convertedSpentFuel, 0), 168.79999999999995)
+    // group-by-day must add up to the same "Fuel Used" total as the single-period value
+    const groupedTotal = device.summary.reduce((a, b) => a + b.convertedSpentFuel, 0)
+
+    const ungrouped = await getReports().then(async (r) => {
+      const ud = await r.getUserData()
+      ud.devices = ud.devices.filter(d => d.id === 69114)
+      const dd = await r.activityReport(new Date(2023, 5, 11, 0, 0, 0, 0), new Date(2023, 6, 11, 23, 59, 59, 0), ud)
+      return dd[0].devices.find(d => d.device.id === 69114).summary[0].convertedSpentFuel
+    })
+
+    assert.ok(Math.abs(groupedTotal - ungrouped) <= 1, `grouped ${groupedTotal} vs ungrouped ${ungrouped}`)
+    assert.ok(Math.abs(groupedTotal - 168.7) <= 1.5, groupedTotal)
   }, 800000)
   // eslint-disable-next-line no-undef
   it('works with timetable', async () => {

package/src/tests/fuelUsed.test.js

@@ -0,0 +1,61 @@
+/* eslint-disable no-undef */
+const assert = require('assert')
+const { getFuelUsedBetween, calculateConsumption } = require('../util/fuel')
+
+function pos (iso, fuelUsed, extra = {}) {
+  return { fixTime: new Date(iso).toISOString(), attributes: { fuelUsed, ...extra } }
+}
+
+// Reproduces ticket "fuel consumption of a full day not taken into account":
+// a CAN vehicle that refuels mid-period. Traccar's daily summary spentFuel goes
+// negative on the refuel day, but the "fuelUsed" cumulative counter (shown as
+// "Fuel Used" in the Manager) keeps rising and is the source of truth.
+const route = [
+  pos('2026-06-01T06:00:00Z', 1000),
+  pos('2026-06-01T20:00:00Z', 1116), // +116 day 1
+  pos('2026-06-02T07:00:00Z', 1130, { fuel: 40 }),
+  pos('2026-06-02T10:00:00Z', 1150, { fuel: 250 }), // refuelled
+  pos('2026-06-02T19:00:00Z', 1227, { fuel: 210 }), // +111 day 2
+  { fixTime: new Date('2026-06-03T05:30:00Z').toISOString(), attributes: {} }, // no counter on first fix
+  pos('2026-06-03T18:00:00Z', 1269) // +42 day 3
+]
+const device = { attributes: {} }
+const day = (from, to) => [new Date(from).toISOString(), new Date(to).toISOString()]
+
+describe('fuelUsed counter based consumption', function () {
+  it('uses the fuelUsed counter for each day and ignores a negative summary', () => {
+    const [f1, t1] = day('2026-06-01T00:00:00Z', '2026-06-01T23:59:59Z')
+    const [f2, t2] = day('2026-06-02T00:00:00Z', '2026-06-02T23:59:59Z')
+    const [f3, t3] = day('2026-06-03T00:00:00Z', '2026-06-03T23:59:59Z')
+
+    const d1 = calculateConsumption(device, { route, summary: { spentFuel: -170 }, from: f1, to: t1 })
+    const d2 = calculateConsumption(device, { route, summary: { spentFuel: -170 }, from: f2, to: t2 })
+    const d3 = calculateConsumption(device, { route, summary: { spentFuel: 0 }, from: f3, to: t3 })
+
+    assert.strictEqual(d1, 116)
+    assert.strictEqual(d2, 111) // refuel day is no longer dropped
+    assert.strictEqual(d3, 42) // missing attribute on first fix is no longer dropped
+  })
+
+  it('daily values sum to the period total shown as "Fuel Used"', () => {
+    const [f1, t1] = day('2026-06-01T00:00:00Z', '2026-06-01T23:59:59Z')
+    const [f2, t2] = day('2026-06-02T00:00:00Z', '2026-06-02T23:59:59Z')
+    const [f3, t3] = day('2026-06-03T00:00:00Z', '2026-06-03T23:59:59Z')
+    const sum = calculateConsumption(device, { route, from: f1, to: t1 }) +
+      calculateConsumption(device, { route, from: f2, to: t2 }) +
+      calculateConsumption(device, { route, from: f3, to: t3 })
+    const period = calculateConsumption(device, { route, summary: { spentFuel: -170 } })
+
+    assert.strictEqual(period, 269) // 1269 - 1000
+    assert.strictEqual(Number(sum.toFixed(3)), period)
+  })
+
+  it('clamps a counter reset to 0', () => {
+    assert.strictEqual(getFuelUsedBetween([pos('2026-06-01T06:00:00Z', 5000), pos('2026-06-01T12:00:00Z', 30)]), 0)
+  })
+
+  it('falls back to summary spentFuel when the route has no fuelUsed', () => {
+    const noCan = [{ fixTime: new Date('2026-06-01T06:00:00Z').toISOString(), attributes: {} }]
+    assert.strictEqual(calculateConsumption(device, { route: noCan, summary: { spentFuel: 12 } }), 12)
+  })
+})

package/src/trip-report.js

@@ -216,7 +216,7 @@ async function processDevices (from, to, devices, data, userData, traccar) {
 
       if (deviceRoute.some(r => r.attributes.fuel) ||
           automaticReports.deviceWithFuelInfo(d)) {
-        trip.fuelConsumption = calculateConsumption(d, { trips: [trip], stops: (stop ? [stop] : []), route: deviceRoute })
+        trip.fuelConsumption = calculateConsumption(d, { trips: [trip], stops: (stop ? [stop] : []), route: deviceRoute, from: trip.startTime, to: trip.endTime })
         trip.avgFuelConsumption = trip.totalKms > 0 ? trip.fuelConsumption * 100 / trip.totalKms : 0
       }
 

package/src/util/fuel.js

@@ -57,15 +57,76 @@ function calculateTotalFuelFromSensor(trips, stops, positions, device, firstStop
 }
 
 
+function getPositionFuelUsed (position) {
+  const raw = position && position.attributes ? position.attributes.fuelUsed : undefined
+  const value = typeof raw === 'string' ? Number.parseFloat(raw) : raw
+  return typeof value === 'number' && !Number.isNaN(value) ? value : null
+}
+
+/**
+ * Fuel consumed over a time window, read straight from the CAN "fuelUsed" cumulative
+ * counter - the exact value the Manager shows as "Fuel Used".
+ *
+ * This is the single source of truth for every report whenever the route carries
+ * "fuelUsed". It must NOT be derived from the daily summary "spentFuel" (which Traccar
+ * computes from the tank fuel-level and returns as <= 0 on any day the vehicle was
+ * refuelled, making a whole day silently drop out of the report).
+ *
+ * Robust against:
+ *  - positions without the fuelUsed attribute (e.g. the first/last fix of a day)
+ *  - refuelling (a cumulative counter never goes down, unlike a tank-level reading)
+ *  - the window opening between two fixes (uses the last known counter before it, so
+ *    consecutive days partition the period with no gap and sum to the period total)
+ *  - counter resets (negative overall difference is clamped to 0, as before)
+ *
+ * @param {Array} route  positions for a single device (any order)
+ * @param {Date|string|number} [from]  window start; omit for "from the first fix"
+ * @param {Date|string|number} [to]    window end; omit for "until the last fix"
+ */
+function getFuelUsedBetween (route, from, to) {
+  if (!Array.isArray(route)) { return 0 }
+
+  const fromTime = from != null ? new Date(from).getTime() : null
+  const toTime = to != null ? new Date(to).getTime() : null
+
+  const samples = []
+  for (const p of route) {
+    const value = getPositionFuelUsed(p)
+    if (value == null) { continue }
+    samples.push({ t: new Date(p.fixTime).getTime(), value })
+  }
+  if (samples.length < 2) { return 0 }
+  samples.sort((a, b) => a.t - b.t)
+
+  // end = last counter reading at or before the end of the window
+  let end = null
+  for (const s of samples) {
+    if (toTime == null || s.t <= toTime) { end = s.value } else { break }
+  }
+
+  // start = last counter reading at or before the start of the window,
+  //         or the first reading inside it when the window opens before any fix
+  let start = null
+  for (const s of samples) {
+    if (fromTime == null) { start = s.value; break }
+    if (s.t <= fromTime) { start = s.value } else { if (start == null) { start = s.value } break }
+  }
+
+  if (start == null || end == null) { return 0 }
+  const diff = end - start
+  return diff > 0 ? diff : 0
+}
+
 function calculateConsumption (d, data) {
   let fuelConsumption = 0
   const withFuelUsed = data.route && data.route.find(p => p.attributes.fuelUsed)
-  if (data.summary && withFuelUsed) {
+  if (withFuelUsed && data.route.length > 1) {
+    // CAN "fuelUsed" counter - keep every report aligned with the Manager's "Fuel Used".
+    fuelConsumption = getFuelUsedBetween(data.route, data.from, data.to)
+  } else if (data.summary && withFuelUsed) {
     fuelConsumption = calculateSpentFuel(data.summary.spentFuel, d, withFuelUsed)
   } else if (data.trips && data.stops) {
     fuelConsumption = data.trips.reduce((a, b) => a + calculateSpentFuel(b.spentFuel, d, withFuelUsed), 0) + data.stops.reduce((a, b) => a + calculateSpentFuel(b.spentFuel, d, withFuelUsed), 0)
-  } else if (data.route && data.route.length > 1 && data.route[0].attributes.fuelUsed) {
-    fuelConsumption = data.route[data.route.length - 1].attributes.fuelUsed - data.route[0].attributes.fuelUsed
   } else if (data.summary) {
     fuelConsumption = data.summary.spentFuel
   }
@@ -98,5 +159,6 @@ function useOdooFuelData (d, route) {
 exports.calculateFuelDiff = calculateFuelDiff
 exports.getRefuelingLiters = getRefuelingLiters
 exports.calculateConsumption = calculateConsumption
+exports.getFuelUsedBetween = getFuelUsedBetween
 exports.useOdooFuelData = useOdooFuelData
-exports.calculateTotalFuelFromSensor = calculateTotalFuelFromSensor
+exports.calculateTotalFuelFromSensor = calculateTotalFuelFromSensor

package/src/util/trips.js

@@ -112,7 +112,7 @@ async function getDataByDay (device, date, data, userData, traccarInstance) {
       (!z.outTime || (new Date(z.outTime.fixTime) > startDate)))
     : []
 
-  return { tripsByDay, stopsByDay, routeByDay, refuelingPositionsByDay, zoneInOutDayData }
+  return { tripsByDay, stopsByDay, routeByDay, refuelingPositionsByDay, zoneInOutDayData, fromDay: startDate, toDay: endDate }
 }
 
 function isValidAvgSpeed (kms, startTime, endTime) {