fleetmap-reports 1.0.649 → 1.0.651

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fleetmap-reports",
-  "version": "1.0.649",
+  "version": "1.0.651",
   "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/zone-report.js

@@ -32,7 +32,6 @@ async function createZoneReport (from, to, userData, traccar) {
   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 +41,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 +70,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 }))
@@ -88,14 +82,8 @@ async function createZoneReport (from, to, userData, traccar) {
 
   return reportData
 }
-function getPreviousOut(inDate, alerts, geofenceId, deviceRoute) {
-  return alerts
-    .filter(a => a.type === 'geofenceExit' && a.geofenceId === geofenceId)
-    .find(a => new Date(a.position.fixTime).getTime() < inDate) ||
-    new Date(deviceRoute[0].fixTime).getTime()
-}
 
-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) ||
@@ -125,9 +113,6 @@ async function processDevices (from, to, devices, userData, data) {
               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 routeBeforeIn = deviceRoute.filter(p =>
-                new Date(p.fixTime).getTime() >= getPreviousOut(inDate, alerts, a.geofenceId, deviceRoute) &&
-                new Date(p.fixTime).getTime() < inDate)
               const routeIn = deviceRoute.filter(p =>
                 new Date(p.fixTime).getTime() >= inDate &&
                 new Date(p.fixTime).getTime() < outDate
@@ -142,7 +127,7 @@ async function processDevices (from, to, devices, userData, data) {
                   outTime: a.position,
                   totalTime: totalInTime,
                   distanceIn: calculateDistance(routeIn),
-                  distanceOut: calculateDistance(routeBeforeIn) + calculateDistance(routeAfterOut),
+                  distanceOut: calculateDistance(routeAfterOut),
                   geofenceName: geofence.name,
                   stopped: routeIn.filter(p => !p.attributes.ignition).length > 0,
                   driverName: zoneInData[a.geofenceId].position.driverName
@@ -191,66 +176,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
 }