fleetmap-reports 1.0.473 → 1.0.474

package/package.json

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

package/src/here.js

@@ -10,11 +10,11 @@ const calcRoute = 'https://fleet.ls.hereapi.com/2/calculateroute.json?&detailedT
 
 const util = require('util')
 
-function mpsToKmh(mps) {
+function mpsToKmh (mps) {
   return mps * 3.6
 }
 
-function getSpeedLimit(li) {
+function getSpeedLimit (li) {
   if (li && li.attributes && li.attributes.SPEED_LIMITS_FCN) {
     const from = li.attributes.SPEED_LIMITS_FCN[0].FROM_REF_SPEED_LIMIT
     const to = li.attributes.SPEED_LIMITS_FCN[0].TO_REF_SPEED_LIMIT
@@ -26,7 +26,7 @@ function getSpeedLimit(li) {
   return 999
 }
 
-function getRoadName(li) {
+function getRoadName (li) {
   if (li.attributes.ROAD_GEOM_FCN) {
     const result = li.attributes.ROAD_GEOM_FCN[0].NAME
     if (result && result.length > 0) { return result }
@@ -34,14 +34,14 @@ function getRoadName(li) {
   return ''
 }
 
-function getTruckSpeedLimits(li) {
+function getTruckSpeedLimits (li) {
   if (li.attributes.TRUCK_SPEED_LIMITS_FCN) {
     return li.attributes.TRUCK_SPEED_LIMITS_FCN
   }
   return null
 }
 
-function getDistanceMarkers(li) {
+function getDistanceMarkers (li) {
   if (li.attributes.DISTANCE_MARKERS_FCN) {
     const dMarkers = li.attributes.DISTANCE_MARKERS_FCN
     return util.format('km %d', dMarkers[0].DISTANCE_VALUE)
@@ -49,7 +49,7 @@ function getDistanceMarkers(li) {
   return ''
 }
 
-function generateCSV(rows) {
+function generateCSV (rows) {
   const route = []
   route.push('latitude, longitude, speed_kmh, heading, timestamp')
   for (let i = 0; i < rows.length; i++) {
@@ -68,7 +68,6 @@ function generateCoordsCSV(rows) {
   return route.join('\n')
 }
 
-
 function fillGeocoding(rows) {
   return new Promise((resolve) => {
     const csv = generateCoordsCSV(rows.slice(0, 300))
@@ -94,12 +93,12 @@ function fillGeocoding(rows) {
       console.error(e)
     })
   })
-}*/
+} */
 
 exports.routeMatch = async (rows) => {
   console.log('here sending', rows.length)
   const csv = generateCSV(rows)
-  const response = await axios.post(calcRoute, csv, { headers: { 'Content-Type': 'application/binary' }})
+  const response = await axios.post(calcRoute, csv, { headers: { 'Content-Type': 'application/binary' } })
   const hereData = response.data
   const route = hereData.response.route[0]
   const results = []
@@ -109,32 +108,30 @@ exports.routeMatch = async (rows) => {
     for (let i = 0; i < wayPoints.length; i++) {
       const tp = wayPoints[i]
       const li = links[tp.routeLinkSeqNrMatched]
-      if (mpsToKmh(tp.speedMps) > getSpeedLimit(li)) {
-        results.push({
-          linkId: tp.routeLinkSeqNrMatched,
-          timestamp: tp.timestamp,
-          currentSpeedKmh: mpsToKmh(tp.speedMps),
-          latitude: tp.originalPosition.latitude,
-          longitude: tp.originalPosition.longitude,
-          latMatched: tp.mappedPosition.latitude,
-          lonMatched: tp.mappedPosition.longitude,
-          heading: tp.headingDegreeNorthClockwise,
-          headingMatched: tp.headingMatched,
-          speedLimit: getSpeedLimit(li),
-          roadName: getRoadName(li),
-          truckSpeedLimits: getTruckSpeedLimits(li),
-          distanceMarkers: getDistanceMarkers(li),
-          geocoding: ''
-        })
-      }
+      results.push({
+        linkId: tp.routeLinkSeqNrMatched,
+        timestamp: tp.timestamp,
+        currentSpeedKmh: mpsToKmh(tp.speedMps),
+        latitude: tp.originalPosition.latitude,
+        longitude: tp.originalPosition.longitude,
+        latMatched: tp.mappedPosition.latitude,
+        lonMatched: tp.mappedPosition.longitude,
+        heading: tp.headingDegreeNorthClockwise,
+        headingMatched: tp.headingMatched,
+        speedLimit: getSpeedLimit(li),
+        roadName: getRoadName(li),
+        truckSpeedLimits: getTruckSpeedLimits(li),
+        distanceMarkers: getDistanceMarkers(li),
+        geocoding: ''
+      })
     }
   }
   return results
 }
 
-exports.tollsMatch = async(rows, result) => {
+exports.tollsMatch = async (rows, result) => {
   const csv = generateCSV(rows)
-  axios.post(calcRoute, csv, { headers: { 'Content-Type': 'application/binary' }}).then((response) => {
+  axios.post(calcRoute, csv, { headers: { 'Content-Type': 'application/binary' } }).then((response) => {
     const hereData = response.data
     const results = []
     const tollData = hereData.response.route[0].tollCost.routeTollItems

package/src/index.test.js

@@ -3,11 +3,11 @@ const assert = require('assert')
 
 async function getSpeedingReport (report, userData) {
   const data = await report.speedingReport(
-    new Date(Date.UTC(2021, 11, 6, 0, 0, 0, 0)),
-    new Date(Date.UTC(2021, 11, 8, 23, 59, 59, 0)),
+    new Date(Date.UTC(2022, 7, 15, 0, 0, 0, 0)),
+    new Date(Date.UTC(2022, 7, 15, 23, 59, 59, 0)),
     userData)
   assert.equal(data.length, 1)
-  const device = data[0].devices.find(d => d.device.id === 22326)
+  const device = data[0].devices[0]
   const totalDistance = device.alerts.reduce((a, b) => a + b.distance, 0)
   const totalEventTime = device.alerts.reduce((a, b) => a + b.eventTime, 0)
   return { device, totalDistance, totalEventTime }
@@ -19,14 +19,14 @@ describe('Test_Reports', function () {
   it('Speeding by device', async () => {
     const report = await getReports()
     const userData = await report.getUserData()
-    userData.roadSpeedLimit = true
+    userData.roadSpeedLimits = true
     const { device, totalDistance, totalEventTime } = await getSpeedingReport(report, userData)
     assert.equal(device.alerts.length, 15) // Total Alerts
     assert.equal(totalDistance, 19.59984677533689) // Total Kms
     assert.equal(totalEventTime, 562000) // Total Duration
   }, 200000)
   // eslint-disable-next-line no-undef
-  it('Speeding by device with custom speed', async () => {
+  it('Speeding with custom speed', async () => {
     const report = await getReports()
     const userData = await report.getUserData()
 

package/src/speeding-report.js

@@ -280,34 +280,29 @@ async function getHereEvents (devices, routes, threshold) {
       console.log('no positions on device', d.name)
       resolve()
     }
-    let hereAlerts = null
     here.routeMatch(positions).then(results => {
-      hereAlerts = results.filter(r => r.currentSpeedKmh > (parseInt(r.speedLimit) + threshold)).map(r => {
-        const position = positions.find(p => new Date(p.fixTime).getTime() === r.timestamp)
-        return {
-          ...r,
-          roadSpeedLimit: r.speedLimit,
-          deviceId: d.id,
-          position,
-          positionId: position && position.id,
-          attributes: { speedLimit: r.speedLimit, speed: r.currentSpeedKmh / 1.85200 }
+      const reduced = results.reduce((acc, cur, idx, src) => {
+        const previous = acc.length && acc.slice(-1)[0]
+        if (cur.currentSpeedKmh > parseInt(cur.speedLimit) + (threshold || 0)) {
+          cur.position = positions.find(p => new Date(p.fixTime).getTime() === cur.timestamp)
+          if (previous && previous.speedLimit === cur.speedLimit) {
+            previous.eventTime += cur.timestamp - previous.timestamp
+            previous.attributes.maxSpeed = Math.max(previous.attributes.maxSpeed, cur.currentSpeedKmh)
+            previous.distance += distance.default(point([cur.position.longitude, cur.position.latitude]), point([previous.position.longitude, previous.position.latitude]))
+          } else {
+            cur.positionId = cur.position && cur.position.id
+            cur.roadSpeedLimit = cur.speedLimit
+            cur.deviceId = d.id
+            cur.attributes = { speedLimit: cur.speedLimit, speed: cur.currentSpeedKmh / 1.85200 }
+            return acc.concat(cur)
+          }
         }
-      })
-      if (!hereAlerts.length) {
+        return acc
+      }, [])
+      if (!reduced.length) {
         console.log('empty array after filter on device', d.name)
         resolve()
       }
-      const reduced = hereAlerts.length < 2
-        ? hereAlerts
-        : hereAlerts.reduce((acc, cur, idx, src) => {
-          if (idx === 1) {
-            return [acc]
-          }
-          if (cur.timestamp - src[idx - 1].timestamp > 300000 || cur.roadSpeedLimit !== src[idx - 1].roadSpeedLimit) {
-            return acc.concat(cur)
-          }
-          return acc
-        })
       events.push(...reduced)
       resolve()
     }).catch(e => {
@@ -323,6 +318,7 @@ function calculateEventData (positions, pIndex, alert, device, geofence, userDat
   let endEventPosition = alert.position
   let maxSpeed = alert.position.speed
   let dist = 0
+  if (alert.eventTime) { return -1 }
   while (pIndex + 1 < positions.length) {
     pIndex++
     dist += distance.default(point([endEventPosition.longitude, endEventPosition.latitude]),