fleetmap-reports 1.0.650 → 1.0.652

package/package.json

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

package/src/tests/index.test.js

@@ -354,15 +354,18 @@ describe('Test_Reports', function () {
     const userData = await report.getUserData()
     const data = await report.zoneReport(new Date(2022, 3, 25, 0, 0, 0, 0),
       new Date(2022, 3, 28, 23, 59, 59, 0),
-      userData)
+      { ...userData, devices: userData.devices.filter(d => d.id === 22326) })
 
     assert.equal(data.length, 1)
     const device = data[0].devices.find(d => d.device.id === 22326)
     assert.equal(device.geofences.length, 19)
+    console.log(device.geofences[0])
     assert.equal(device.geofences[0].inTime.fixTime, '2022-04-25T23:47:58.000+0000')
     assert.equal(device.geofences[0].outTime.fixTime, '2022-04-26T07:47:35.000+0000')
     assert.equal(device.geofences[0].totalTime, '28777')
     assert.equal(device.geofences[0].geofenceName, 'Casa João')
+    assert.equal(device.geofences[0].distanceIn, 0.38569639521207727)
+    // expect(device.geofences[0].distanceOut).toBeGreaterThan(0)
   }, 990000)
   // eslint-disable-next-line no-undef
   it('Zone Report With Stops', async () => {

package/src/util/device.js

@@ -2,7 +2,6 @@ function devicesToProcess (userData) {
   const groupIds = userData.groups.map(g => g.id)
   const devices = userData.byGroup ? userData.devices.filter(d => !groupIds.includes(d.groupId)) : userData.devices
   devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
-
   console.log('LOADING_MESSAGE:' + devices.map(d => d.name).join(', '))
   return devices
 }

package/src/zone-report.js

@@ -27,12 +27,10 @@ async function createZoneReport (from, to, userData, traccar) {
     const url = `https://${process.env.SERVER_HOST}/reports/zone-report`
     return axios.post(url, { from, to, userData }, { withCredentials: true }).then(d => d.data)
   }
-  console.log('Create ZoneReport')
   const reportData = []
   const types = ['geofenceEnter', 'geofenceExit']
 
   if (userData.byGroup) {
-    console.log('ByGroup')
     for (const g of userData.groups) {
       const devices = userData.devices.filter(d => d.groupId === g.id)
       console.log(g.name + ' devices:' + devices.length)
@@ -42,12 +40,9 @@ async function createZoneReport (from, to, userData, traccar) {
           group: g,
           xpert: devices.filter(d => d.attributes.xpert).length > 0
         }
-        console.log('LOADING_MESSAGE:' + 'Eventos...')
         const response = await traccar.reports.reportsEventsGet(from, to, null, [g.id], types)
         const data = response.data
 
-        console.log('Geofence Enter/Exit Alerts:' + data.length)
-
         devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
         if (data.length > 0) {
@@ -74,9 +69,7 @@ async function createZoneReport (from, to, userData, traccar) {
       deviceCount, devices.length, sliceSize, deviceChunk, undefined)
 
     const route = filterPositions(data.route)
-
     const alerts = getInAndOutEvents(slice, route, userData)
-    console.log('Geofence Enter/Exit Alerts:' + alerts.length)
 
     if (alerts.length) {
       allData.devices.push(...await processDevices(from, to, devices, userData, { alerts, route }))
@@ -89,7 +82,7 @@ async function createZoneReport (from, to, userData, traccar) {
   return reportData
 }
 
-function getNextIn(outDate, alerts, geofenceId, deviceRoute) {
+function getNextIn (outDate, alerts, geofenceId, deviceRoute) {
   return alerts
     .filter(a => a.type === 'geofenceEnter' && a.geofenceId === geofenceId)
     .find(a => new Date(a.position.fixTime).getTime() > outDate) ||
@@ -115,39 +108,37 @@ async function processDevices (from, to, devices, userData, data) {
             zoneInData[a.geofenceId] = a
           } else if (a.type === 'geofenceExit') {
             const geofence = userData.geofences.find(g => g.id === a.geofenceId)
+            if (!geofence) { return }
+            const outDate = new Date(a.position.fixTime).getTime()
+            const routeAfterOut = deviceRoute.filter(p =>
+              new Date(p.fixTime).getTime() >= outDate &&
+              new Date(p.fixTime).getTime() < getNextIn(outDate, alerts, a.geofenceId, deviceRoute)
+            )
             if (zoneInData[a.geofenceId]) {
               const totalInTime = moment(a.position.fixTime).diff(moment(zoneInData[a.geofenceId].position.fixTime), 'seconds')
               const inDate = new Date(zoneInData[a.geofenceId].position.fixTime).getTime()
-              const outDate = new Date(a.position.fixTime).getTime()
               const routeIn = deviceRoute.filter(p =>
                 new Date(p.fixTime).getTime() >= inDate &&
                 new Date(p.fixTime).getTime() < outDate
               )
-              const routeAfterOut = deviceRoute.filter(p =>
-                new Date(p.fixTime).getTime() >= outDate &&
-                new Date(p.fixTime).getTime() < getNextIn(outDate, alerts, a.geofenceId, deviceRoute)
-              )
-              if (geofence) {
-                zoneInOutData.push({
-                  inTime: zoneInData[a.geofenceId].position,
-                  outTime: a.position,
-                  totalTime: totalInTime,
-                  distanceIn: calculateDistance(routeIn),
-                  distanceOut: calculateDistance(routeAfterOut),
-                  geofenceName: geofence.name,
-                  stopped: routeIn.filter(p => !p.attributes.ignition).length > 0,
-                  driverName: zoneInData[a.geofenceId].position.driverName
-                })
-              }
+              zoneInOutData.push({
+                inTime: zoneInData[a.geofenceId].position,
+                outTime: a.position,
+                totalTime: totalInTime,
+                distanceIn: calculateDistance(routeIn),
+                distanceOut: calculateDistance(routeAfterOut),
+                geofenceName: geofence.name,
+                stopped: routeIn.filter(p => !p.attributes.ignition).length > 0,
+                driverName: zoneInData[a.geofenceId].position.driverName
+              })
               zoneInData[a.geofenceId] = null
             } else {
-              if (geofence) {
-                zoneInOutData.push({
-                  outTime: a.position,
-                  geofenceName: geofence.name,
-                  driverName: ''
-                })
-              }
+              zoneInOutData.push({
+                outTime: a.position,
+                geofenceName: geofence.name,
+                driverName: '',
+                distanceOut: calculateDistance(routeAfterOut)
+              })
             }
           }
         }
@@ -182,66 +173,42 @@ async function processDevices (from, to, devices, userData, data) {
   return devicesResult
 }
 
+function checkGeofenceEnter (p1, p2, g) {
+  switch (g.geometry.type) {
+    case 'Polygon':
+      return !booleanPointInPolygon.default(p1, g) && booleanPointInPolygon.default(p2, g)
+    case 'Point':
+      return distance.default(p1, g, { units: 'meters' }) >= g.properties.distance &&
+        distance.default(p2, g, { units: 'meters' }) < g.properties.distance
+    case 'LineString':
+      return pointToLineDistance.default(p1, g, { units: 'meters' }) > (g.properties.geofence.attributes.polylineDistance || 25) &&
+        pointToLineDistance.default(p2, g, { units: 'meters' }) <= (g.properties.geofence.attributes.polylineDistance || 25)
+  }
+}
+
+function checkGeofenceExit (p1, p2, g) {
+  return checkGeofenceEnter(p2, p1, g)
+}
+
 function getInAndOutEvents (devices, route, userData) {
   const events = []
   devices.forEach(d => {
     const deviceRoute = route.filter(p => p.deviceId === d.id)
-
     const routePoints = deviceRoute.sort(sortPositions).map(p => convertPositionToFeature(p))
     const geofencesFeatures = userData.geofences.map(g => convertToFeature(g))
 
-    const entryMap = []
-    routePoints.forEach(p => {
-      if (!p.properties.position.valid) {
-        return
-      }
-      geofencesFeatures.forEach(g => {
-        if (g.geometry.type === 'Polygon') {
-          if (booleanPointInPolygon.default(p, g)) {
-            if (!entryMap.includes(g)) {
-              events.push(createEvent('geofenceEnter', d.id, p, g))
-              entryMap.push(g)
-            }
-          } else {
-            if (entryMap.includes(g)) {
-              events.push(createEvent('geofenceExit', d.id, p, g))
-              const index = entryMap.indexOf(g)
-              entryMap.splice(index, 1)
-            }
-          }
-        }
-        if (g.geometry.type === 'Point') {
-          if (distance.default(p, g, { units: 'meters' }) < g.properties.distance) {
-            if (!entryMap.includes(g)) {
-              events.push(createEvent('geofenceEnter', d.id, p, g))
-              entryMap.push(g)
-            }
-          } else {
-            if (entryMap.includes(g)) {
-              events.push(createEvent('geofenceExit', d.id, p, g))
-              const index = entryMap.indexOf(g)
-              entryMap.splice(index, 1)
-            }
-          }
-        }
-        if (g.geometry.type === 'LineString') {
-          if (pointToLineDistance.default(p, g, { units: 'meters' }) < (g.properties.geofence.attributes.polylineDistance || 25)) {
-            if (!entryMap.includes(g)) {
-              events.push(createEvent('geofenceEnter', d.id, p, g))
-              entryMap.push(g)
-            }
-          } else {
-            if (entryMap.includes(g)) {
-              events.push(createEvent('geofenceExit', d.id, p, g))
-              const index = entryMap.indexOf(g)
-              entryMap.splice(index, 1)
-            }
-          }
+    routePoints.filter(p => p.properties.position.valid).forEach((p, i, array) => {
+      if (!i) { return }
+      const previous = array[i - 1]
+      for (const g of geofencesFeatures) {
+        if (checkGeofenceEnter(previous, p, g)) {
+          events.push(createEvent('geofenceEnter', d.id, p, g))
+        } else if (checkGeofenceExit(previous, p, g)) {
+          events.push(createEvent('geofenceExit', d.id, p, g))
         }
-      })
+      }
     })
   })
-
   return events
 }