fleetmap-reports 1.0.679 → 1.0.681

package/package.json

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

package/src/partnerReports/afriquia.js

@@ -1,6 +1,7 @@
 const traccar = require('../util/traccar')
 const { getIdleEvents } = require('../util/route')
-const { insideGeofence, getNearestPOIs } = require('../util/geofence')
+const { getNearestPOIs, checkGeofenceIn } = require('../util/geofence')
+const { convertToFeature, convertPositionToFeature } = require('../util/utils')
 
 function calculateLastStopTime (stopTime, to, time) {
   return stopTime + (to.getTime() - new Date(time).getTime())
@@ -16,10 +17,12 @@ async function createActivityReport (from, to, userData, traccarInstance) {
 
   const notAuthGeofenceIds = (await traccarInstance.geofences.geofencesGet(undefined, undefined, undefined, Number(process.env.AFRIQUIA_NOT_AUTH_GROUP_ID), undefined, undefined).then(r => r.data)).map(g => g.id)
   unauthorizedGeofences.push(...(userData.geofences.filter(g => notAuthGeofenceIds.includes(g.id))))
+  const unauthorizedGeofencesFeatures = unauthorizedGeofences.map(g => convertToFeature(g))
   console.log('unauthorizedGeofences', unauthorizedGeofences)
 
   const authGeofenceIds = (await traccarInstance.geofences.geofencesGet(undefined, undefined, undefined, Number(process.env.AFRIQUIA_AUTH_GROUP_ID), undefined, undefined).then(r => r.data)).map(g => g.id)
   authorizedGeofences.push(...(userData.geofences.filter(g => authGeofenceIds.includes(g.id))))
+  const authorizedGeofencesFeatures = authorizedGeofences.map(g => convertToFeature(g))
   console.log('authorizedGeofences', authorizedGeofences)
 
   const allInOne = await traccar.getAllInOne(traccarInstance, from, to, userData.devices, true, true, true, false)
@@ -37,12 +40,19 @@ async function createActivityReport (from, to, userData, traccarInstance) {
     let authorizedStopsTime = 0
 
     stops.forEach(s => {
-      const unauthorized = unauthorizedGeofences.find(g => insideGeofence({ latitude: s.latitude, longitude: s.longitude }, g))
+      const point = convertPositionToFeature({ latitude: s.latitude, longitude: s.longitude })
+      const unauthorized = unauthorizedGeofencesFeatures.find(g => {
+        const geofenceFeature = unauthorizedGeofencesFeatures.find(gF => gF.properties.geofence.id === g.id)
+        return checkGeofenceIn(point, geofenceFeature)
+      })
 
       if (unauthorized) {
         unauthorizedStops = unauthorizedStops + 1
       } else {
-        const authorized = authorizedGeofences.find(g => insideGeofence({ latitude: s.latitude, longitude: s.longitude }, g))
+        const authorized = authorizedGeofences.find(g => {
+          const geofenceFeature = authorizedGeofencesFeatures.find(gF => gF.properties.geofence.id === g.id)
+          return checkGeofenceIn(point, geofenceFeature)
+        })
 
         if (authorized) {
           authorizedStops = authorizedStops + 1

package/src/util/geofence.js

@@ -1,6 +1,9 @@
 const turf = require('@turf/helpers')
 const inside = require('@turf/boolean-point-in-polygon')
 const { coordsDistance } = require('./utils')
+const booleanPointInPolygon = require('@turf/boolean-point-in-polygon')
+const distance = require('@turf/distance')
+const pointToLineDistance = require('@turf/point-to-line-distance')
 
 exports.insideGeofence = function insideGeofence (position, geofence) {
   const coords = geofence.area.slice(9, geofence.area.length - 2).split(',')
@@ -32,3 +35,14 @@ exports.loadGroupsData = async function loadGroupsData (userData, traccarInstanc
     g.geofenceIds = (await traccarInstance.geofences.geofencesGet(undefined, undefined, undefined, g.id, undefined, undefined).then(r => r.data)).map(g => g.id)
   }
 }
+
+exports.checkGeofenceIn = function checkGeofenceIn (p, g) {
+  switch (g.geometry.type) {
+    case 'Polygon':
+      return booleanPointInPolygon.default(p, g)
+    case 'Point':
+      return distance.default(p, g, { units: 'meters' }) >= g.properties.distance
+    case 'LineString':
+      return pointToLineDistance.default(p, g, { units: 'meters' }) > (g.properties.geofence.attributes.polylineDistance || 25)
+  }
+}

package/src/zone-report.js

@@ -11,12 +11,10 @@ const { headerFromUser, addTable } = require('./util/pdfDocument')
 const { getStyle } = require('./reportStyle')
 const { getUserPartner } = require('fleetmap-partners')
 const { devicesToProcess } = require('./util/device')
-const pointToLineDistance = require('@turf/point-to-line-distance')
-const booleanPointInPolygon = require('@turf/boolean-point-in-polygon')
-const distance = require('@turf/distance')
 const axios = require('axios')
 const { processServerSide } = require('./util')
 const { filterPositions } = require('./util/route')
+const { checkGeofenceIn } = require('./util/geofence')
 const sliceSize = 100
 const deviceChunk = 5
 const fileName = 'ZoneReport'
@@ -97,91 +95,91 @@ async function processDevices (from, to, devices, userData, data) {
 
     const zoneInOutData = analyseAlerts(alerts, deviceRoute, userData, from, to).filter(d => !userData.onlyWithStop || d.stopped)
 
-    if (zoneInOutData.length > 0) {
-      if (userData.groupByDay) {
-        const dates = getDates(from, to)
+    if (userData.groupByDay) {
+      const dates = getDates(from, to)
 
-        const geofencesData = []
-        for (const geofence of userData.geofences) {
-          const filteredByGeofence = zoneInOutData.filter(d => d.geofenceId === geofence.id)
+      const geofencesData = []
+      for (const geofence of userData.geofences) {
+        const filteredByGeofence = zoneInOutData.filter(d => d.geofenceId === geofence.id)
 
-          const dataByDay = []
-          for (const date of dates) {
-            const fromByDay = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0)
-            const toByDay = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59)
+        const dataByDay = []
+        for (const date of dates) {
+          const fromByDay = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0)
+          const toByDay = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59)
 
-            const dayRoute = deviceRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay)
-            const zoneInOutDayData = filteredByGeofence.filter(z => (!z.inTime || (new Date(z.inTime.fixTime) < toByDay)) &&
+          const dayRoute = deviceRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay)
+          const zoneInOutDayData = filteredByGeofence.filter(z => (!z.inTime || (new Date(z.inTime.fixTime) < toByDay)) &&
                 (!z.outTime || (new Date(z.outTime.fixTime) > fromByDay)))
 
-            const firstIn = zoneInOutDayData.find(z => z.inTime && new Date(z.inTime.fixTime) > fromByDay)
-            const lastOut = zoneInOutDayData.slice().reverse().find(z => z.outTime && new Date(z.outTime.fixTime) < toByDay)
+          const firstIn = zoneInOutDayData.find(z => z.inTime && new Date(z.inTime.fixTime) > fromByDay)
+          const lastOut = zoneInOutDayData.slice().reverse().find(z => z.outTime && new Date(z.outTime.fixTime) < toByDay)
 
-            let timeIn = zoneInOutDayData.length ? zoneInOutDayData.reduce((a, b) => a + (b.totalInTime || 0), 0) : 0
+          let timeIn = zoneInOutDayData.length ? zoneInOutDayData.reduce((a, b) => a + (b.totalInTime || 0), 0) : 0
 
-            let distanceIn = zoneInOutDayData.length && dayRoute.length ? zoneInOutDayData.reduce((a, b) => a + (b.distanceIn || 0), 0) : 0
-            let distanceOut = 0
-            if (zoneInOutDayData.length) {
-              distanceOut = zoneInOutDayData.reduce((a, b) => a + (b.distanceOut || 0), 0) - zoneInOutDayData[zoneInOutDayData.length - 1].distanceOut
-            } else {
-              distanceOut = calculateDistance(deviceRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay))
-            }
+          let distanceIn = zoneInOutDayData.length && dayRoute.length ? zoneInOutDayData.reduce((a, b) => a + (b.distanceIn || 0), 0) : 0
+          let distanceOut = 0
+          if (zoneInOutDayData.length) {
+            distanceOut = zoneInOutDayData.reduce((a, b) => a + (b.distanceOut || 0), 0) - zoneInOutDayData[zoneInOutDayData.length - 1].distanceOut
+          } else {
+            distanceOut = calculateDistance(deviceRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay))
+          }
 
-            if (zoneInOutDayData.length) {
-              // Check if the first entry starts only on the day before
-              if (!zoneInOutDayData[0].inTime || new Date(zoneInOutDayData[0].inTime.fixTime) < fromByDay) {
-                const inTime = zoneInOutDayData[0].inTime ? new Date(zoneInOutDayData[0].inTime.fixTime) : from
-                timeIn = timeIn - (fromByDay.getTime() - inTime.getTime())
-                const routeDayBefore = deviceRoute.filter(p => (!zoneInOutDayData[0].inTime || new Date(p.fixTime) >= new Date(zoneInOutDayData[0].inTime.fixTime)) &&
+          if (zoneInOutDayData.length) {
+            // Check if the first entry starts only on the day before
+            if (!zoneInOutDayData[0].inTime || new Date(zoneInOutDayData[0].inTime.fixTime) < fromByDay) {
+              const inTime = zoneInOutDayData[0].inTime ? new Date(zoneInOutDayData[0].inTime.fixTime) : from
+              timeIn = timeIn - (fromByDay.getTime() - inTime.getTime())
+              const routeDayBefore = deviceRoute.filter(p => (!zoneInOutDayData[0].inTime || new Date(p.fixTime) >= new Date(zoneInOutDayData[0].inTime.fixTime)) &&
                     new Date(p.fixTime) < fromByDay)
-                distanceIn = distanceIn - calculateDistance(routeDayBefore)
-              } else {
-                // Add distanceOut before the first entry
-                const routeOut = deviceRoute.filter(p =>
-                  new Date(p.fixTime).getTime() < new Date(zoneInOutDayData[0].inTime.fixTime).getTime() &&
+              distanceIn = distanceIn - calculateDistance(routeDayBefore)
+            } else {
+              // Add distanceOut before the first entry
+              const routeOut = deviceRoute.filter(p =>
+                new Date(p.fixTime).getTime() < new Date(zoneInOutDayData[0].inTime.fixTime).getTime() &&
                     new Date(p.fixTime).getTime() >= fromByDay.getTime()
-                )
-                distanceOut = distanceOut + calculateDistance(routeOut)
-              }
-
-              // Check if the last entry ends only on the next day
-              if (!zoneInOutDayData[zoneInOutDayData.length - 1].outTime || new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) > toByDay) {
-                const outTime = zoneInOutDayData[zoneInOutDayData.length - 1].outTime ? new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) : to
-                timeIn = timeIn - (outTime.getTime() - (toByDay.getTime() + 1000))
-                const routeDayAfter = deviceRoute.filter(p => new Date(p.fixTime) <= outTime && new Date(p.fixTime) > toByDay)
-                distanceIn = distanceIn - calculateDistance(routeDayAfter)
-              } else {
-                const routeOut = deviceRoute.filter(p =>
-                  new Date(p.fixTime) >= new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime).getTime() &&
+              )
+              distanceOut = distanceOut + calculateDistance(routeOut)
+            }
+
+            // Check if the last entry ends only on the next day
+            if (!zoneInOutDayData[zoneInOutDayData.length - 1].outTime || new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) > toByDay) {
+              const outTime = zoneInOutDayData[zoneInOutDayData.length - 1].outTime ? new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) : to
+              timeIn = timeIn - (outTime.getTime() - (toByDay.getTime() + 1000))
+              const routeDayAfter = deviceRoute.filter(p => new Date(p.fixTime) <= outTime && new Date(p.fixTime) > toByDay)
+              distanceIn = distanceIn - calculateDistance(routeDayAfter)
+            } else {
+              const routeOut = deviceRoute.filter(p =>
+                new Date(p.fixTime) >= new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime).getTime() &&
                     new Date(p.fixTime) < toByDay.getTime())
-                distanceOut = distanceOut + calculateDistance(routeOut)
-              }
+              distanceOut = distanceOut + calculateDistance(routeOut)
             }
-            dataByDay.push({
-              date,
-              firstIn: firstIn ? firstIn.inTime.fixTime : undefined,
-              lastOut: lastOut ? lastOut.outTime.fixTime : undefined,
-              distanceIn: distanceIn > 0 ? distanceIn : 0,
-              distanceOut,
-              totalInTime: timeIn,
-              totalOutTime: (24 * 60 * 60 * 1000) - timeIn
-            })
           }
-
-          geofencesData.push({
-            geofenceName: geofence.name,
-            days: dataByDay
+          dataByDay.push({
+            date,
+            firstIn: firstIn ? firstIn.inTime.fixTime : undefined,
+            lastOut: lastOut ? lastOut.outTime.fixTime : undefined,
+            distanceIn: distanceIn > 0 ? distanceIn : 0,
+            distanceOut,
+            totalInTime: timeIn,
+            totalOutTime: (24 * 60 * 60 * 1000) - timeIn
           })
         }
 
-        devicesResult.push({
-          device: d,
-          from,
-          to,
-          groupByDay: true,
-          geofences: geofencesData
+        geofencesData.push({
+          geofenceName: geofence.name,
+          days: dataByDay
         })
-      } else {
+      }
+
+      devicesResult.push({
+        device: d,
+        from,
+        to,
+        groupByDay: true,
+        geofences: geofencesData
+      })
+    } else {
+      if (zoneInOutData.length > 0) {
         devicesResult.push({
           device: d,
           from,
@@ -281,6 +279,15 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to) {
     }
   }
 
+  if (!zoneInOutData.length && userData.groupByDay) {
+    const geofenceIn = alerts.find(a => a.type === 'geofenceIn')
+    zoneInOutData.push({
+      distanceIn: geofenceIn ? calculateDistance(deviceRoute) : 0,
+      distanceOut: !geofenceIn ? calculateDistance(deviceRoute) : 0,
+      totalTime: to.getTime() - from.getTime()
+    })
+  }
+
   return zoneInOutData
 }
 
@@ -292,17 +299,6 @@ function checkGeofenceExit (p1, p2, g) {
   return checkGeofenceEnter(p2, p1, g)
 }
 
-function checkGeofenceIn (p, g) {
-  switch (g.geometry.type) {
-    case 'Polygon':
-      return booleanPointInPolygon.default(p, g)
-    case 'Point':
-      return distance.default(p, g, { units: 'meters' }) >= g.properties.distance
-    case 'LineString':
-      return pointToLineDistance.default(p, g, { units: 'meters' }) > (g.properties.geofence.attributes.polylineDistance || 25)
-  }
-}
-
 function getInAndOutEvents (devices, route, userData) {
   const events = []
   devices.forEach(d => {