fleetmap-reports 1.0.489 → 1.0.491

package/package.json

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

package/src/index.test.js

@@ -3,15 +3,13 @@ const assert = require('assert')
 
 async function getSpeedingReport (report, userData) {
   const data = await report.speedingReport(
-    new Date(Date.UTC(2022, 7, 15, 0, 0, 0, 0)),
-    new Date(Date.UTC(2022, 7, 15, 23, 59, 59, 0)),
+    new Date(Date.UTC(2022, 1, 17, 0, 0, 0, 0)),
+    new Date(Date.UTC(2022, 1, 17, 23, 59, 59, 0)),
     userData)
   assert.equal(data.length, 1)
-  const device = data[0].devices[0]
-  console.log(device)
+  const device = data[0].devices.find(d => d.device.id === 22326)
   const totalDistance = device.alerts.reduce((a, b) => a + b.distance, 0)
   const totalEventTime = device.alerts.reduce((a, b) => a + b.eventTime, 0)
-  console.log(device.alerts)
   return { device, totalDistance, totalEventTime }
 }
 
@@ -23,10 +21,9 @@ describe('Test_Reports', function () {
     const userData = await report.getUserData()
     userData.roadSpeedLimits = true
     const { device, totalDistance, totalEventTime } = await getSpeedingReport(report, userData)
-    assert.equal(device.alerts.length, 16) // Total Alerts
-    console.log(device.alerts)
-    assert.equal(totalDistance, 74.71054403083238) // Total Kms
-    assert.equal(totalEventTime, 3009000) // Total Duration
+    assert.equal(device.alerts.length, 104) // Total Alerts
+    assert.equal(totalDistance, 36.6525856031222) // Total Kms
+    assert.equal(totalEventTime, 1524000) // Total Duration
   }, 200000)
   // eslint-disable-next-line no-undef
   it('Speeding with custom speed', async () => {
@@ -36,9 +33,9 @@ describe('Test_Reports', function () {
     userData.useVehicleSpeedLimit = false
     userData.customSpeed = 100
     const { device, totalDistance, totalEventTime } = await getSpeedingReport(report, userData)
-    assert.equal(device.alerts.length, 24) // Total Alerts
-    assert.equal(totalDistance, 49.481065231791064) // Total Kms
-    assert.equal(totalEventTime, 1523000) // Total Duration
+    assert.equal(device.alerts.length, 13) // Total Alerts
+    assert.equal(totalDistance, 46.64576895855739) // Total Kms
+    assert.equal(totalEventTime, 1402000) // Total Duration
   }, 20000)
   // eslint-disable-next-line no-undef
   it('Trip by device', async () => {
@@ -261,7 +258,7 @@ describe('Test_Reports', function () {
     assert.equal(data.length, 1)
     const device = data[0].devices.find(d => d.device.id === 22326)
     assert.equal(device.summary[0].startOdometer, 122502742.59)
-    assert.equal(device.summary[0].distance, 1404204.4299999028)
+    assert.equal(device.summary[0].distance, 1427444.4699999243)
     assert.equal(device.summary[0].startTime, '2022-01-01T13:35:47.000+0000')
     assert.equal(device.summary[0].endTime, '2022-01-31T17:36:27.000+0000')
   }, 40000)
@@ -289,7 +286,7 @@ describe('Test_Reports', function () {
     assert.equal(data.length, 1)
     const device = data[0].devices.find(d => d.device.id === 22326)
     assert.equal(device.summary[5].startOdometer, 122923290.95)
-    assert.equal(device.summary[5].distance, 77021.6400000006)
+    assert.equal(device.summary[5].distance, 77033.18999999762)
     assert.equal(device.summary[5].startTime, '2022-01-06T18:35:36.000+0000')
     assert.equal(device.summary[5].endTime, '2022-01-06T19:54:27.000+0000')
   }, 90000)

package/src/speeding-report.js

@@ -68,6 +68,10 @@ async function createSpeedingReportByGroup (from, to, userData, traccarInstance)
   return reportData
 }
 
+function processServerSide () {
+  return (process.env.PROCESS_HERE_EVENTS && process.env.PROCESS_HERE_EVENTS === 'server')
+}
+
 async function createSpeedingReportByDevice (from, to, userData, traccarInstance) {
   const devices = devicesToProcess(userData)
 
@@ -81,6 +85,10 @@ async function createSpeedingReportByDevice (from, to, userData, traccarInstance
   let deviceCount = 0
   for (const slice of sliced) {
     const { routes, events } = await getEvents(traccarInstance, from, to, slice, userData, deviceCount, devices.length, slice.length)
+    if (processServerSide()) {
+      console.log('LOADING_MESSAGE:' + slice[0].name)
+      console.log(`PROGRESS_PERC:${deviceCount / devices.length * 100}`)
+    }
     if (events.length > 0) {
       const devicesProcessed = await processDevices(from, to, slice, events, routes, userData)
       allData.devices.push(...devicesProcessed)
@@ -111,8 +119,8 @@ async function createSpeedingReportByDriver (from, to, userData, traccarInstance
 }
 
 async function getEvents (traccarInstance, from, to, devices, userData, deviceCount, totalDevices, sliceSize) {
-  if (process.env.PROCESS_HERE_EVENTS && process.env.PROCESS_HERE_EVENTS === 'server') {
-    const url = `${process.env.REPORTS_SERVER || ''}/reports/speeding-report/getEvents`
+  if (processServerSide()) {
+    const url = `https://${process.env.SERVER_HOST}/reports/speeding-report/getEvents`
     return axios.post(url, { from, to, devices, userData, deviceCount, totalDevices, sliceSize }, { withCredentials: true }).then(d => d.data)
   } else {
     const geofencesFeatures = userData.geofences.filter(g => g.area.startsWith('POLYGON') &&
@@ -225,10 +233,9 @@ async function processDevices (from, to, devices, events, routes, userData) {
 async function findEventsPosition (from, to, devices, events, routes, userData) {
   for (const d of devices) {
     const deviceEvents = events.filter(e => e.deviceId === d.id && e.positionId)
+    console.log(d.name, deviceEvents.length)
     if (deviceEvents.length > 0) {
-      deviceEvents.sort((a, b) => new Date(a.position.fixTime) - new Date(b.position.fixTime))
       const positions = routes.filter(p => p.deviceId === d.id)
-
       for (const a of deviceEvents) {
         const pIndex = positions.findIndex(p => p.id === a.positionId)
         if (pIndex > 0) {
@@ -250,10 +257,9 @@ async function findEventsPosition (from, to, devices, events, routes, userData)
             a.driver = (driver && driver.name) || a.position.attributes.driverUniqueId
           }
           a.deviceName = d.name
-
-          return pIndex
         }
       }
+      deviceEvents.sort((a, b) => new Date(a.position.fixTime) - new Date(b.position.fixTime))
     }
   }
 }
@@ -271,6 +277,7 @@ async function getCustomSpeedLimitEvents (devices, routes, customSpeed) {
       if (position.speed > maxSpeed && !eventIsActive) {
         const event = {
           positionId: position && position.id,
+          position,
           deviceId: d.id,
           attributes: {
             speedLimit: maxSpeed,
@@ -291,52 +298,47 @@ async function getCustomSpeedLimitEvents (devices, routes, customSpeed) {
 async function getHereEvents (devices, routes, threshold) {
   try {
     console.log('env', process.env.PROCESS_HERE_EVENTS)
-    if (process.env.PROCESS_HERE_EVENTS && process.env.PROCESS_HERE_EVENTS === 'server') {
-      const url = `${process.env.REPORTS_SERVER}/reports/here`
-      return axios.post(url, { devices, routes, threshold }).then(d => d.data)
-    } else {
-      console.log('here speed limit events')
-      const events = []
-      const promises = devices.map(d => new Promise((resolve) => {
-        const positions = routes.filter(p => p.deviceId === d.id)
-        if (!positions.length) {
-          console.log('no positions on device', d.name)
-          resolve()
-        }
-        here.routeMatch(positions).then(results => {
-          const reduced = results.reduce((acc, cur, idx, src) => {
-            cur.overSpeeding = cur.currentSpeedKmh > parseInt(cur.speedLimit) + (threshold || 0)
-            const last = acc.length && acc.slice(-1)[0]
-            cur.position = positions.find(p => new Date(p.fixTime).getTime() === cur.timestamp)
-            if (cur.overSpeeding && last && src[idx - 1].overSpeeding && last.speedLimit === cur.speedLimit) {
-              last.eventTime = cur.timestamp - last.timestamp
-              last.attributes.maxSpeed = Math.max(last.attributes.maxSpeed, cur.position.speed)
-              last.distance = distance.default(point([cur.position.longitude, cur.position.latitude]), point([last.position.longitude, last.position.latitude]))
-            } else if (cur.overSpeeding) {
-              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, maxSpeed: cur.position.speed }
-              cur.eventTime = 0
-              cur.distance = 0
-              acc.push(cur)
-            }
-            return acc
-          }, [])
-          if (!reduced.length) {
-            console.log('empty array after filter on device', d.name)
-            resolve()
+    console.log('here speed limit events')
+    const events = []
+    const promises = devices.map(d => new Promise((resolve) => {
+      const positions = routes.filter(p => p.deviceId === d.id)
+      if (!positions.length) {
+        console.log('no positions on device', d.name)
+        resolve()
+      }
+      here.routeMatch(positions).then(results => {
+        const reduced = results.reduce((acc, cur, idx, src) => {
+          cur.overSpeeding = cur.currentSpeedKmh > parseInt(cur.speedLimit) + (threshold || 0)
+          const last = acc.length && acc.slice(-1)[0]
+          cur.position = positions.find(p => new Date(p.fixTime).getTime() === cur.timestamp)
+          if (cur.overSpeeding && last && src[idx - 1].overSpeeding && last.speedLimit === cur.speedLimit) {
+            last.eventTime = cur.timestamp - last.timestamp
+            last.attributes.maxSpeed = Math.max(last.attributes.maxSpeed, cur.position.speed)
+            last.distance = distance.default(point([cur.position.longitude, cur.position.latitude]), point([last.position.longitude, last.position.latitude]))
+          } else if (cur.overSpeeding) {
+            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, maxSpeed: cur.position.speed }
+            cur.eventTime = 0
+            cur.distance = 0
+            acc.push(cur)
           }
-          events.push(...reduced)
-          resolve()
-        }).catch(e => {
-          console.error('error on route match, moving on', e)
+          return acc
+        }, [])
+        if (!reduced.length) {
+          console.log('empty array after filter on device', d.name)
           resolve()
-        })
-      }))
-      await Promise.all(promises)
-      return events
-    }
+        }
+        events.push(...reduced)
+        resolve()
+      }).catch(e => {
+        console.error('error on route match, moving on', e)
+        resolve()
+      })
+    }))
+    await Promise.all(promises)
+    return events
   } catch (e) {
     console.error(e)
   }
@@ -348,6 +350,7 @@ function calculateEventData (positions, pIndex, alert, device, geofence, userDat
   let dist = 0
   while (pIndex + 1 < positions.length) {
     pIndex++
+    console.log(pIndex)
     dist += distance.default(point([endEventPosition.longitude, endEventPosition.latitude]),
       point([positions[pIndex].longitude, positions[pIndex].latitude]))
     endEventPosition = positions[pIndex]
@@ -355,6 +358,7 @@ function calculateEventData (positions, pIndex, alert, device, geofence, userDat
       alert.eventTime = new Date(endEventPosition.fixTime) - new Date(alert.position.fixTime)
       alert.attributes.maxSpeed = maxSpeed
       alert.distance = dist
+      console.log(alert)
       break
     } else {
       if (maxSpeed < endEventPosition.speed) {