fleetmap-reports 2.0.316 → 2.0.318

package/package.json

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

package/src/index.js

@@ -12,7 +12,7 @@ function Reports (config, axios) {
   }
   this.getUserData = async () => {
     return {
-      user: await this.traccar.session.sessionGet(process.env.TOKEN).then(d => d.data),
+      user: await this.traccar.session.sessionGet().then(d => d.data),
       devices: await this.traccar.devices.devicesGet().then(d => d.data),
       groups: await this.traccar.groups.groupsGet().then(d => d.data),
       drivers: await this.traccar.drivers.driversGet().then(d => d.data),

package/src/sensor-report.js

@@ -10,60 +10,13 @@ const { headerFromUser, addTable } = require('./util/pdfDocument')
 const { getStyle } = require('./reportStyle')
 const { getUserPartner } = require('fleetmap-partners')
 
-function minimumDuration (status, userData) {
-  if (status) {
-    return (userData.minimumMinutesOn * 60 * 1000)
-  }
-
-  return (userData.minimumMinutesOff * 60 * 1000)
-}
-
-function addSensorPeriod (statusPeriodBySensor, s, currentStatus, d, duration, currentPosition, previousPosition) {
-  statusPeriodBySensor[s.sensor].push({
-    startTime: currentStatus[s.sensor].startTime,
-    endTime: previousPosition.fixTime,
-    endAddress: previousPosition.address,
-    value: currentStatus[s.sensor].value,
-    valueDescription: currentStatus[s.sensor].value ? d.attributes[s.sensor + 'on'] : d.attributes[s.sensor + 'off'],
-    name: s.name,
-    duration
-  })
-  currentStatus[s.sensor] = { value: currentPosition.attributes[s.id], startTime: currentPosition.fixTime }
-}
-
 function processDevices (from, to, devices, data, userData) {
   const result = []
 
   for (const d of devices) {
-    const positions = data.route.filter(t => t.deviceId === d.id)
-
-    const statusPeriodBySensor = {}
-    const currentStatus = {}
-    positions.forEach((p, index) => {
-      userData.sensors.forEach(s => {
-        if (!statusPeriodBySensor[s.sensor]) {
-          statusPeriodBySensor[s.sensor] = []
-        }
-        if (currentStatus[s.sensor] !== undefined) {
-          if (currentStatus[s.sensor].value !== p.attributes[s.id]) {
-            const duration = new Date(positions[index - 1].fixTime).getTime() - new Date(currentStatus[s.sensor].startTime).getTime()
-            if ((duration >= minimumDuration(currentStatus[s.sensor].value, userData)) || statusPeriodBySensor[s.sensor].length === 0) {
-              addSensorPeriod(statusPeriodBySensor, s, currentStatus, d, duration, p, positions[index - 1])
-            } else {
-              const element = statusPeriodBySensor[s.sensor].pop()
-              currentStatus[s.sensor] = { value: p.attributes[s.id], startTime: element.startTime }
-            }
-          } else {
-            const distanceBetweenPositions = new Date(p.fixTime).getTime() - new Date(positions[index - 1].fixTime).getTime()
-            if (distanceBetweenPositions > 30 * 60 * 1000 && currentStatus[s.sensor].value === true) {
-              currentStatus[s.sensor] = { value: p.attributes[s.id], startTime: p.fixTime }
-            }
-          }
-        } else {
-          currentStatus[s.sensor] = { value: p.attributes[s.id], startTime: p.fixTime }
-        }
-      })
-    })
+    const positions = data.route.filter(t => t.deviceId === d.id).filter(t => t.attributes.motion)
+
+    const statusPeriodBySensor = computeSensorPeriods(positions, userData.sensors, d, userData)
 
     const rows = Object.values(statusPeriodBySensor).flat()
     rows.sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime())
@@ -92,6 +45,129 @@ function processDevices (from, to, devices, data, userData) {
   return result
 }
 
+function computeSensorPeriods (positions, sensors, d, userData) {
+  if (!positions || positions.length === 0) return {}
+
+  const result = {}
+  const minOn = (userData.minimumMinutesOn || 0) * 60 * 1000
+  const minOff = (userData.minimumMinutesOff || 0) * 60 * 1000
+  const maxDistanceBetweenPositions = 20 * 60 * 1000
+
+  const minThreshold = (value) => (value ? minOn : minOff)
+
+  function pushPeriod (sensorKey, s, value, startTime, endTime, endPos) {
+    const duration = endTime - startTime
+    const period = {
+      value,
+      startTime,
+      endTime,
+      duration,
+      name: s.name,
+      endAddress: endPos.address,
+      valueDescription: value
+        ? d.attributes[s.sensor + 'on']
+        : d.attributes[s.sensor + 'off']
+    }
+    console.debug(period)
+    result[sensorKey].push(period)
+  }
+
+  for (const s of sensors) result[s.sensor] = []
+
+  // Track current period per sensor
+  const current = {}
+  const firstPos = positions[0]
+  for (const s of sensors) {
+    current[s.sensor] = {
+      value: firstPos.attributes[s.id],
+      startTime: new Date(firstPos.fixTime)
+    }
+  }
+
+  for (let i = 1; i < positions.length; i++) {
+    const prevPos = positions[i - 1]
+    const currPos = positions[i]
+    const changeTime = new Date(currPos.fixTime)
+
+    for (const s of sensors) {
+      const key = s.sensor
+      const prevValue = current[key].value
+      const newValue = currPos.attributes[s.id]
+
+      if (prevValue === newValue) continue
+
+      const oldStartTime = current[key].startTime
+      const prevEndTime = changeTime
+      const duration = prevEndTime - oldStartTime
+      const threshold = minThreshold(prevValue)
+      let newPeriodStartTime = changeTime
+
+      // Check distance between positions
+      if (prevValue === false && newValue === true && maxDistanceBetweenPositions > 0) {
+        const nextPos = positions[i + 1]
+        if (nextPos && nextPos.attributes && nextPos.attributes[s.id] === true) {
+          const nextTime = new Date(nextPos.fixTime)
+          if (nextTime - oldStartTime > maxDistanceBetweenPositions) {
+            newPeriodStartTime = nextTime
+          }
+        }
+      }
+
+      if (duration >= threshold) {
+        pushPeriod(key, s, prevValue, oldStartTime, prevEndTime, prevPos)
+      } else {
+        // merging logic for previous ignored period
+        const list = result[key]
+        if (list.length > 0) {
+          const last = list[list.length - 1]
+          if (last.value === newValue) {
+            list.pop()
+            newPeriodStartTime = new Date(last.startTime)
+          }
+        }
+      }
+
+      current[key] = {
+        value: newValue,
+        startTime: newPeriodStartTime
+      }
+    }
+  }
+
+  // Close final periods
+  const lastPos = positions[positions.length - 1]
+  const lastTime = new Date(lastPos.fixTime)
+
+  for (const s of sensors) {
+    const key = s.sensor
+    const st = current[key]
+    const startTime = st.startTime
+    const endTime = lastTime
+    const value = st.value
+    const duration = endTime - startTime
+    const threshold = minThreshold(value)
+
+    if (duration >= threshold) {
+      pushPeriod(key, s, value, startTime, endTime, lastPos)
+    } else {
+      // try to merge tiny final period into previous pushed period if same value
+      const list = result[key]
+      if (list.length > 0 && list[list.length - 1].value === value) {
+        const last = list[list.length - 1]
+        last.endTime = endTime
+        last.duration = last.endTime - last.startTime
+        last.endAddress = lastPos.address
+        last.valueDescription = value
+          ? d.attributes[s.sensor + 'on']
+          : d.attributes[s.sensor + 'off']
+      }
+      // otherwise drop final tiny period
+    }
+  }
+
+  return result
+}
+
 async function create (from, to, userData, traccar) {
   const devices = devicesToProcess(userData)
   const sliced = automaticReports.sliceArray(devices, 5)

package/src/util/route.js

@@ -51,7 +51,10 @@ function cleanPosition (p) {
     deviceId: p.deviceId,
     speed: p.speed,
     valid: p.valid,
-    attributes: { driverUniqueId: p.attributes.driverUniqueId }
+    attributes: {
+      ignition: p.attributes.ignition,
+      driverUniqueId: p.attributes.driverUniqueId
+    }
   }
 }
 

package/src/zone-report.js

@@ -150,6 +150,7 @@ async function createZoneReport (from, to, userData, traccar) {
 
 async function processDevices (from, to, devices, userData, data) {
   const devicesResult = []
+  console.log('processDevices', from, to, devices.length)
   for (const d of devices) {
     const alerts = data.alerts.filter(t => t && t.deviceId === d.id)
     const deviceRoute = data.route.filter(p => p.deviceId === d.id)