fleetmap-reports 1.0.856 → 1.0.858

package/lang/frFR.json

@@ -169,6 +169,7 @@
     "digital_ports1": "Ports numériques 1",
     "digital_ports2": "Portes numériques 2",
     "temperature": "Température",
+    "temperature2": "Température 2",
     "select_vehicles": "sélectionner des véhicules",
     "select_vehicles_placeholder": "Véhicules",
     "select_geofences": "sélectionner les balises",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fleetmap-reports",
-  "version": "1.0.856",
+  "version": "1.0.858",
   "description": "",
   "main": "src/index.js",
   "scripts": {
@@ -16,6 +16,7 @@
     "@turf/point-to-line-distance": "^6.5.0",
     "axios": "^0.22.0",
     "axios-cookiejar-support": "^1.0.1",
+    "country-reverse-geocoding": "^0.2.2",
     "docx": "^7.3.0",
     "file-saver": "^2.0.5",
     "fleetmap-partners": "^1.0.126",

package/src/location-report.js

@@ -203,6 +203,7 @@ async function exportLocationReportToPDF (userData, reportData) {
 
   if (userData.includeTemperature) {
     headers.push(translations.report.temperature)
+    headers.push(translations.report.temperature2 || 'Temperature 2')
   }
 
   if (positionsData) {
@@ -254,7 +255,8 @@ async function exportLocationReportToPDF (userData, reportData) {
         ]
 
         if (userData.includeTemperature) {
-          temp.push(getTempValue(a))
+          temp.push(getTempValue(a, 'temp1'))
+          temp.push(getTempValue(a, 'temp2'))
         }
 
         if (userData.includeDigitalPorts) {
@@ -300,11 +302,8 @@ async function exportLocationReportToPDF (userData, reportData) {
   }
 }
 
-function getTempValue (row) {
-  return (row.attributes && (
-    (row.attributes.temp1 !== 175 && row.attributes.temp1) ||
-      (row.attributes.temp2 !== 175 && row.attributes.temp2)
-  )) || ''
+function getTempValue (row, sensor) {
+  return (row.attributes[sensor] !== 175 && row.attributes[sensor]) || ''
 }
 
 function getDigitalPort1Label (row, translations, dAttributes) {
@@ -397,7 +396,8 @@ function exportLocationReportToExcel (userData, reportData) {
           speed: Math.round(a.speed * 1.85200),
           ignition: a.attributes.ignition ? translations.report.ignitionOn : translations.report.ignitionOff,
           driver: userData.byDriver ? d.driver.name : getDriverName(a.attributes.driverUniqueId, a.fixTime, userData),
-          temperature: getTempValue(a),
+          temperature: getTempValue(a, 'temp1'),
+          temperature2: getTempValue(a, 'temp2'),
           digitalport1: getDigitalPortValue(a, 1, translations, d.device.attributes),
           digitalport2: getDigitalPortValue(a, 2, translations, d.device.attributes),
           latitude: a.latitude,

package/src/speeding-report.js

@@ -15,6 +15,7 @@ const booleanPointInPolygon = require('@turf/boolean-point-in-polygon')
 const automaticReports = require('./automaticReports')
 const { default: axios } = require('axios')
 const { getDriverName, getDriverData } = require('./util/driver')
+const crg = require('country-reverse-geocoding').country_reverse_geocoding()
 
 const fileName = 'SpeedingReport'
 const eventTypes = ['deviceOverspeed']
@@ -136,7 +137,7 @@ async function getEvents (traccarInstance, from, to, devices, userData, deviceCo
 
     const events = []
     if (userData.roadSpeedLimits) {
-      const hereResults = await getHereEvents(devices, routes, userData.maxSpeedThreshold, userData.minimumIdleMinutes)
+      const hereResults = await getRoadSpeedLimits(devices, routes, userData.maxSpeedThreshold, userData.minimumIdleMinutes)
       console.log('got', hereResults.length, 'from here')
       events.push(...hereResults)
     } else if (!userData.useVehicleSpeedLimit && userData.customSpeed) {
@@ -298,6 +299,76 @@ async function getCustomSpeedLimitEvents (devices, routes, customSpeed) {
   return events
 }
 
+async function getRoadSpeedLimits(devices, routes, threshold, minimumMinutes = 0) {
+  const position = routes[0]
+  const country = crg.get_country(position.latitude, position.longitude)
+  const config = {
+    CHL: getOSMSpeedingEvents
+  }
+  const method = config[country && country.code] || getHereEvents
+  return method(devices, routes, threshold, minimumMinutes)
+}
+
+async function getOSMSpeedingEvents(devices, routes, threshold, minimumMinutes = 0) {
+  const chunk = 1000
+  const events = []
+  for (const d of devices) {
+    const route = routes.filter(r => r.deviceId === d.id)
+    const results = []
+    for (let i = 0; i < route.length; i += chunk) {
+      const apiKey = process.env.geoapifyKey
+      const slice = route.slice(i, i + chunk)
+      const { features } = await axios.post(`https://api.geoapify.com/v1/mapmatching?apiKey=${apiKey}`, {
+        mode: 'drive',
+        waypoints: slice.map(p => ({
+          timestamp: p.fixTime,
+          bearing: p.bearing,
+          location: [p.longitude, p.latitude]
+        }))
+      }).then(r => r.data)
+
+      const { properties } = features[0]
+      for (const wp of properties.waypoints) {
+        const leg = properties.legs[wp.leg_index]
+        if (!leg) {
+          console.log('ignoring legs (count):', properties.legs.count, wp.leg_index)
+          continue
+        }
+        const step = leg.steps[wp.step_index]
+        const position = route[wp.original_index + i]
+        if (!step) {
+          console.log('ignoring', wp.step_index, wp.leg_index, properties.legs[0].steps[wp.step_index], properties.legs[0].steps.length)
+          continue
+        }
+        if (wp.match_type !== 'unmatched' && step.speed_limit < position.speed * 1.852) {
+          results.push({ ...wp, ...step, ...position })
+        }
+      }
+    }
+    const reduced = results.reduce((acc, cur, idx, src) => {
+      cur.overSpeeding = cur.speed * 1.852 > cur.speed_limit + (threshold || 0)
+      const last = acc.length && acc.slice(-1)[0]
+      if (cur.overSpeeding && last && src[idx - 1].overSpeeding && last.speed_limit === cur.speed_limit) {
+        last.eventTime = new Date(cur.fixTime) - new Date(last.fixTime)
+        last.attributes.maxSpeed = Math.max(last.attributes.maxSpeed, cur.speed)
+        last.distance = distance.default(point([cur.longitude, cur.latitude]), point([last.longitude, last.latitude]))
+      } else if (cur.overSpeeding) {
+        cur.positionId = cur && cur.id
+        cur.roadSpeedLimit = cur.speed_limit
+        cur.deviceId = d.id
+        cur.attributes = { speedLimit: cur.speed_limit, speed: cur.speed, maxSpeed: cur.speed }
+        cur.eventTime = 0
+        cur.distance = 0
+        cur.position = {...cur}
+        acc.push(cur)
+      }
+      return acc
+    }, [])
+    events.push(...reduced)
+  }
+  return events.filter(e => e.eventTime >= minimumMinutes * 60 * 1000)
+}
+
 async function getHereEvents (devices, routes, threshold, minimumMinutes = 0) {
   try {
     console.log('PROCESS_HERE_EVENTS', process.env.PROCESS_HERE_EVENTS)

package/src/tests/speeding.test.js

@@ -3,11 +3,11 @@ const assert = require('assert')
 
 async function getSpeedingReport (report, userData) {
   const data = await report.speedingReport(
-    new Date(Date.UTC(2022, 1, 17, 0, 0, 0, 0)),
-    new Date(Date.UTC(2022, 1, 17, 23, 59, 59, 0)),
+    new Date(Date.UTC(2023, 9, 4, 0, 0, 0, 0)),
+    new Date(Date.UTC(2023, 9, 4, 23, 59, 59, 0)),
     userData)
 
-  const device = data[0].devices.find(d => d.device.id === 22326)
+  const device = data[0].devices[0]
   const totalDistance = device && device.alerts.reduce((a, b) => a + b.distance, 0)
   const totalEventTime = device && device.alerts.reduce((a, b) => a + b.eventTime, 0)
   return { device, totalDistance, totalEventTime }
@@ -20,7 +20,7 @@ describe('speeding tests', function () {
     const userData = await report.getUserData()
     userData.roadSpeedLimits = true
     const { device } = await getSpeedingReport(report, userData)
-    assert.equal(device.alerts.length, 104) // Total Alerts
+    assert.equal(device.alerts.length, 9) // Total Alerts
     console.log(device.alerts)
 
     userData.minimumIdleMinutes = 1