fleetmap-reports 1.0.424 → 1.0.427

package/package.json

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

package/src/index.test.js

@@ -52,6 +52,21 @@ describe('Test_Reports', function () {
     assert.equal(device.trips[1].endPOIName, undefined)
     assert.equal(device.totalDistance, 339204.53999999166) // Total Kms
   }, 20000)
+  // eslint-disable-next-line no-undef
+  it('Trip by driver', async () => {
+    const report = await getReports()
+    const userData = await report.getUserData()
+    userData.byDriver = true
+    const data = await report.tripReport(new Date(2022, 1, 1, 0, 0, 0, 0),
+      new Date(2022, 1, 10, 23, 59, 59, 0),
+      userData)
+    assert.equal(data.length, 1)
+    console.log(data[0].drivers)
+    const driver = data[0].drivers.find(d => d.driver.id === 14020)
+    assert.equal(driver.trips.length, 9) // Total Trips
+    assert.equal(driver.totalDuration, 6274000)
+    assert.equal(driver.maxSpeed, 70.1944)
+  }, 20000)
   it('Trip without addresses', async () => {
     const report = await getReports()
     const userData = await report.getUserData()

package/src/speeding-report.js

@@ -1,6 +1,6 @@
 const messages = require('../lang')
 const jsPDF = require('jspdf')
-const { convertMS, convertToLocaleString } = require('./util/utils')
+const { convertMS, convertToLocaleString, convertToFeature, convertPositionToFeature } = require('./util/utils')
 const { headerFromUser, AmiriRegular } = require('./util/pdfDocument')
 require('jspdf-autotable')
 const { getStyle } = require('./reportStyle')
@@ -12,6 +12,8 @@ const { devicesToProcess } = require('./util/device')
 const { point } = require('@turf/helpers')
 const distance = require('@turf/distance')
 const { insideGeofence } = require('./util/geofence')
+const booleanPointInPolygon = require('@turf/boolean-point-in-polygon')
+const automaticReports = require('./automaticReports')
 
 const fileName = 'SpeedingReport'
 const eventTypes = ['deviceOverspeed']
@@ -69,29 +71,24 @@ async function createSpeedingReportByGroup (from, to, userData, traccarInstance)
 async function createSpeedingReportByDevice (from, to, userData, traccarInstance) {
   const devices = devicesToProcess(userData)
 
-  const allInOne = await traccarHelper.getAllInOne(traccarInstance, from, to, devices, true, false, false, false)
-  const routes = allInOne.route
-  const events = []
-
-  if (userData.roadSpeedLimits) {
-    events.push(...await getHereEvents(devices, routes, userData.maxSpeedThreshold))
-  } else {
-    if (!userData.useVehicleSpeedLimit && userData.customSpeed) {
-      events.push(...await getCustomSpeedLimitEvents(devices, routes, userData.customSpeed))
-    } else {
-      events.push(...await traccarHelper.getEvents(traccarInstance, from, to, devices, eventTypes))
-    }
+  const allData = {
+    devices: [],
+    xpert: devices.filter(d => d && d.attributes && d.attributes.xpert).length > 0
   }
 
-  if (!events.length) {
-    // empty report
-    return { devices: [] }
-  }
+  const sliced = automaticReports.sliceArray(devices, 5)
 
-  return {
-    devices: await processDevices(from, to, devices, events, routes, userData),
-    xpert: devices.filter(d => d && d.attributes && d.attributes.xpert).length > 0
+  let deviceCount = 0
+  for (const slice of sliced) {
+    const { routes, events } = await getEvents(traccarInstance, from, to, slice, userData, deviceCount, devices.length)
+    if (events.length > 0) {
+      const devicesProcessed = await processDevices(from, to, slice, events, routes, userData)
+      allData.devices.push(...devicesProcessed)
+    }
+    deviceCount = deviceCount + slice.length
   }
+
+  return allData
 }
 
 async function createSpeedingReportByDriver (from, to, userData, traccarInstance) {
@@ -103,26 +100,73 @@ async function createSpeedingReportByDriver (from, to, userData, traccarInstance
     return { drivers: [] }
   }
 
-  const allInOne = await traccarHelper.getAllInOne(traccarInstance, from, to, devices, true, false, false, false)
+  const { routes, events } = await getEvents(traccarInstance, from, to, devices, userData)
+
+  if (!events.length) {
+    // empty report
+    return { drivers: [] }
+  }
+
+  return { drivers: await processDrivers(from, to, events, routes, userData) }
+}
+
+async function getEvents (traccarInstance, from, to, devices, userData, deviceCount, totalDevices) {
+  const geofencesFeatures = userData.geofences.filter(g => g.area.startsWith('POLYGON') &&
+      g.attributes.speedLimit).map(g => convertToFeature(g))
+
+  const allInOne = await traccarHelper.getAllInOne(traccarInstance, from, to, devices, true, false, false, false, deviceCount, totalDevices)
   const routes = allInOne.route
 
   const events = []
   if (!userData.useVehicleSpeedLimit && userData.customSpeed) {
     events.push(...await getCustomSpeedLimitEvents(devices, routes, userData.customSpeed))
   } else {
-    events.push(...await traccarHelper.getEvents(traccarInstance, from, to, devices, eventTypes))
+    const traccarEvents = await traccarHelper.getEvents(traccarInstance, from, to, devices, eventTypes)
+    if (geofencesFeatures.length) {
+      events.push(...getGeofenceSpeedLimitEvents(geofencesFeatures, routes, devices))
+      events.push(...traccarEvents.filter(e => !(e.geofenceId)))
+    } else {
+      events.push(...traccarEvents)
+    }
   }
 
   if (userData.roadSpeedLimits) {
     events.push(...await getHereEvents(devices, routes, userData.maxSpeedThreshold))
   }
+  return { routes, events }
+}
 
-  if (!events.length) {
-    // empty report
-    return { drivers: [] }
-  }
+function getGeofenceSpeedLimitEvents (geofencesFeatures, routes, devices) {
+  const events = []
 
-  return { drivers: await processDrivers(from, to, events, routes, userData) }
+  devices.forEach(d => {
+    const deviceRoute = routes.filter(p => p.deviceId === d.id)
+    const routePoints = deviceRoute.map(p => convertPositionToFeature(p))
+    geofencesFeatures.forEach(g => {
+      let eventIsActive = false
+      routePoints.forEach(p => {
+        if (booleanPointInPolygon.default(p, g) && p.properties.position.speed > g.properties.geofence.attributes.speedLimit) {
+          if (!eventIsActive) {
+            const event = {
+              positionId: p.properties.position.id,
+              deviceId: d.id,
+              geofenceId: g.properties.geofence.id,
+              attributes: {
+                speedLimit: g.properties.geofence.attributes.speedLimit,
+                speed: p.properties.position.speed
+              }
+            }
+            events.push(event)
+          }
+          eventIsActive = true
+        } else {
+          eventIsActive = false
+        }
+      })
+    })
+  })
+
+  return events
 }
 
 async function processDrivers (from, to, events, routes, userData) {

package/src/trip-report.js

@@ -114,11 +114,40 @@ async function createTripReportByDriver (from, to, userData, traccar) {
     return { drivers: [] }
   }
 
-  const allInOne = await traccarHelper.getAllInOne(traccar, from, to, devices, true, true, false, false)
-  const tripsData = allInOne.trips
-  const routeData = allInOne.route
+  const allData = {
+    drivers: []
+  }
+
+  const sliced = automaticReports.sliceArray(devices, 5)
+
+  let deviceCount = 0
+  for (const slice of sliced) {
+    const allInOne = await traccarHelper.getAllInOne(traccar, from, to, slice, true, true, false, false, deviceCount, devices.length)
+    const tripsData = allInOne.trips
+    const routeData = allInOne.route
 
-  return { drivers: processDrivers(from, to, userData, { trips: tripsData, route: routeData }) }
+    const results = processDrivers(from, to, userData, { trips: tripsData, route: routeData })
+
+    results.forEach(result => {
+      const driver = allData.drivers.find(d => d.driver.id === result.driver.id)
+      if (driver) {
+        driver.trips.push(...result.trips)
+      } else {
+        allData.drivers.push(result)
+      }
+    })
+
+    deviceCount = deviceCount + slice.length
+  }
+
+  allData.drivers.forEach(d => {
+    d.totalDuration = d.trips.reduce((a, b) => a + b.duration, 0)
+    d.totalDistance = d.trips.reduce((a, b) => a + b.distance, 0)
+    d.maxSpeed = d.trips.reduce((a, b) => { return a > b.maxSpeed ? a : b.maxSpeed }, 0)
+    d.trips = d.trips.sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime())
+  })
+
+  return allData
 }
 
 function processDevices (from, to, devices, data, userData, traccar) {
@@ -195,8 +224,6 @@ function processDrivers (from, to, userData, data) {
     const trips = data.trips.filter(t => t.driverUniqueId === d.uniqueId &&
             (userData.allWeek || !userData.weekDays || isInsideTimetable(t, userData) || isPartialInsideTimetable(t, userData, route)))
 
-    trips.sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime())
-
     const idleEvents = getIdleEvents(data.route, d)
 
     trips.forEach(function (trip, i) {
@@ -211,15 +238,11 @@ function processDrivers (from, to, userData, data) {
         driver: d,
         from,
         to,
-        totalDuration: trips.reduce((a, b) => a + b.duration, 0),
-        totalDistance: trips.reduce((a, b) => a + b.distance, 0),
-        maxSpeed: trips.reduce((a, b) => { return a > b.maxSpeed ? a : b.maxSpeed }, 0),
         trips
       }
       driversResult.push(driverData)
     }
   })
-  console.log(driversResult)
 
   return driversResult
 }