fleetmap-reports 1.0.247 → 1.0.251

package/src/speeding-report.js

@@ -1,4 +1,3 @@
-const automaticReports = require("./automaticReports")
 const messages = require('../lang')
 const jsPDF = require('jspdf')
 const {convertMS} = require("./util/utils")
@@ -14,16 +13,18 @@ const {getUserPartner} = require("fleetmap-partners");
 const traccar = require("./util/traccar");
 
 let traccarInstance
+let userData
 
 const fileName = 'SpeedingReport'
 
-async function createSpeedingReport(from, to, userData, traccar, roadSpeedLimits) {
+async function createSpeedingReport(from, to, reportUserData, traccar) {
   traccarInstance = traccar
-  console.log('createSpeedingReport', from, to, userData, traccar, roadSpeedLimits)
+  userData = reportUserData
+  console.log('createSpeedingReport', from, to, userData, traccar)
   const reportData = []
 
   if(userData.byDriver){
-    const allData = await createSpeedingReportByDriver(from, to, userData, roadSpeedLimits)
+    const allData = await createSpeedingReportByDriver(from, to)
     reportData.push(allData)
   }
   else if(userData.byGroup){
@@ -38,76 +39,76 @@ async function createSpeedingReport(from, to, userData, traccar, roadSpeedLimits
           xpert: devices.filter(d => d.attributes.xpert).length > 0
         }
 
-        const data = await getReportData(from, to, devices)
+        const eventTypes = ['deviceOverspeed']
+        const events = await traccar.getEvents(traccarInstance, from, to, devices, eventTypes)
+        const routes = userData.useVehicleSpeedLimit ? [] : await traccar.getRoute(traccarInstance, from, to, devices)
 
         devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
-        if (data.length > 0) {
-          groupData.devices = await processDevices(from, to, devices, userData.geofences, userData.drivers, data, roadSpeedLimits)
+        if (events.length > 0) {
+          groupData.devices = await processDevices(from, to, devices, events, routes)
           reportData.push(groupData)
         }
       }
     }
 
-    const withoutGroupData = await createSpeedingReportByDevice(from, to, userData)
+    const withoutGroupData = await createSpeedingReportByDevice(from, to)
     reportData.push(withoutGroupData)
   } else {
-    const allData = await createSpeedingReportByDevice(from, to, userData, roadSpeedLimits)
+    const allData = await createSpeedingReportByDevice(from, to)
     reportData.push(allData)
   }
 
   return reportData
 }
 
-async function createSpeedingReportByDevice(from, to, userData, roadSpeedLimits) {
+async function createSpeedingReportByDevice(from, to) {
   const groupIds = userData.groups.map(g => g.id)
   const withoutGroupDevices = userData.byGroup ? userData.devices.filter(d => !groupIds.includes(d.groupId)) : userData.devices
 
   withoutGroupDevices.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
-  const events = ['deviceOverspeed']
-  const data = await traccar.getEvents(traccarInstance, from, to, withoutGroupDevices, events)
+  const eventTypes = ['deviceOverspeed']
+  const events = await traccar.getEvents(traccarInstance, from, to, withoutGroupDevices, eventTypes)
+  const routes = userData.useVehicleSpeedLimit ? [] : await traccar.getRoute(traccarInstance, from, to, withoutGroupDevices)
 
   const allData = { devices: [] }
 
-  if(data.length > 0 || roadSpeedLimits) {
-    allData.devices = await processDevices(from, to, withoutGroupDevices, userData.geofences, userData.drivers, data, roadSpeedLimits)
+  if(events.length > 0 || userData.roadSpeedLimits) {
+    allData.devices = await processDevices(from, to, withoutGroupDevices, events, routes)
     allData.xpert = withoutGroupDevices.filter(d => d && d.attributes && d.attributes.xpert).length > 0
   }
 
   return allData
 }
 
-async function createSpeedingReportByDriver(from, to, userData) {
+async function createSpeedingReportByDriver(from, to) {
   const deviceIds = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
-  console.log(deviceIds.length)
+  console.log('Devices with driver',deviceIds.length)
 
   let eventsData = []
   if(deviceIds.length > 0) {
-    console.log('getReportData', deviceIds.length)
     const devices = userData.devices.filter(d => deviceIds.includes(d.id))
-    eventsData = await getReportData(from, to, devices)
+    eventsData = await traccar.getEvents(traccarInstance, from, to, devices,['deviceOverspeed'])
   }
 
   const allData = {
     drivers: []
   }
-
   console.log(eventsData.length)
 
-  await getEventsPosition(from , to, userData.devices, userData.geofences, userData.drivers, eventsData)
-
-  allData.drivers = await processDrivers(from, to, userData.drivers, eventsData)
+  await getEventsPosition(from , to, userData.devices, eventsData)
+  allData.drivers = await processDrivers(from, to, eventsData)
   console.log(allData.drivers.length)
   return allData
 }
 
-async function processDrivers(from, to, drivers, data) {
+async function processDrivers(from, to, data) {
   console.log(data)
   const driversResult = []
   const alertsWithPosition = data.filter(a => a.position)
 
-  drivers.forEach(d => {
+  userData.drivers.forEach(d => {
     const alerts = alertsWithPosition.filter(e => e.position.attributes.driverUniqueId === d.uniqueId)
 
     if (alerts.length > 0) {
@@ -127,52 +128,70 @@ async function processDrivers(from, to, drivers, data) {
   return driversResult
 }
 
-async function getReportData(from, to, devices) {
-  const types = ['deviceOverspeed']
-  let data = []
-  const arrayOfArrays = automaticReports.sliceArray(devices)
-  for (const a of arrayOfArrays) {
-    try {
-      const devices = a.map(d => d.id)
-      console.log('reportsEventsGet', from, to, devices, null, types)
-      const response = await traccarInstance.reports.reportsEventsGet(from, to, devices, null, types)
-      data = data.concat(response.data)
-    } catch (e) {
-      console.error(e)
-    }
-  }
-  console.log('Alerts:', data.length)
-  return data
-}
-
-async function processDevices(from, to, devices, geofences, drivers, data, roadSpeedLimits) {
+async function processDevices(from, to, devices, events, routes) {
   const devicesResult = []
 
-  await getEventsPosition(from , to, devices, geofences, drivers, data, roadSpeedLimits)
+  if(userData.useVehicleSpeedLimit) {
+    await getEventsPosition(from, to, devices, events)
 
-  console.log(data)
+    console.log(events)
 
-  for (const d of devices) {
-    const alerts = data.filter(t => t.deviceId === d.id)
+    for (const d of devices) {
+      const deviceEvents = events.filter(t => t.deviceId === d.id)
 
-    if (alerts.length > 0) {
-      const alertsWithPosition = alerts.filter(a => a.position).sort((a,b) => a.positionId - b.positionId)
-      devicesResult.push({
-        device: d,
-        from: from,
-        to: to,
-        alerts: alertsWithPosition,
-        maxSpeed: alertsWithPosition.reduce((a, b) => {
-          return a > (b && b.attributes && b.attributes.maxSpeed) ? a : (b && b.attributes && b.attributes.maxSpeed)
-        }, 0),
-      })
+      if (deviceEvents.length > 0) {
+        const alertsWithPosition = deviceEvents.filter(a => a.position).sort((a, b) => a.positionId - b.positionId)
+        devicesResult.push({
+          device: d,
+          from: from,
+          to: to,
+          alerts: alertsWithPosition,
+          maxSpeed: alertsWithPosition.reduce((a, b) => {
+            return a > (b && b.attributes && b.attributes.maxSpeed) ? a : (b && b.attributes && b.attributes.maxSpeed)
+          }, 0),
+        })
+      }
+    }
+  } else {
+    for (const d of devices) {
+      const positions = routes.filter(t => t.deviceId === d.id)
+      const maxSpeed = userData.customSpeed / 1.85200
+
+      const alerts = []
+      for(let pIndex = 0; pIndex < positions.length ; pIndex++){
+        const position = positions[pIndex]
+        if(position.speed > maxSpeed){
+          const alert = {
+            position: position,
+            attributes: {
+              speedLimit: maxSpeed,
+              speed: position.speed
+            }
+          }
+
+          pIndex = calculateEventData(positions, pIndex, alert)
+
+          alerts.push(alert)
+        }
+      }
+      if(alerts.length > 0){
+        devicesResult.push({
+          device: d,
+          from: from,
+          to: to,
+          alerts: alerts,
+          maxSpeed: alerts.reduce((a, b) => {
+            return a > (b && b.attributes && b.attributes.maxSpeed) ? a : (b && b.attributes && b.attributes.maxSpeed)
+          }, 0),
+        })
+      }
     }
   }
 
   return devicesResult
 }
 
-async function getEventsPosition(from, to, devices, geofences, drivers, events, roadSpeedLimits){
+async function getEventsPosition(from, to, devices, events){
 
   const deviceIds = [...new Set(events.map(e => e.deviceId))]
   const routeData = await traccar.getRoute(traccarInstance, from, to, deviceIds.map(id => { return { id: id } } ))
@@ -182,10 +201,10 @@ async function getEventsPosition(from, to, devices, geofences, drivers, events,
   for (const d of devices) {
     let alerts = events.filter(t => t.deviceId === d.id)
 
-    if (alerts.length > 0 || roadSpeedLimits) {
+    if (alerts.length > 0 || userData.roadSpeedLimits) {
       const positions = routeData.filter(p => p.deviceId === d.id)
 
-      if (roadSpeedLimits && positions.length) {
+      if (userData.roadSpeedLimits && positions.length) {
         try {
           const results = await here.routeMatch(positions)
           const hereAlerts = results.map(r => {
@@ -223,7 +242,7 @@ async function getEventsPosition(from, to, devices, geofences, drivers, events,
           let geofence = null
 
           if (a.geofenceId) {
-            geofence = geofences.find(g => g.id === a.geofenceId)
+            geofence = userData.geofences.find(g => g.id === a.geofenceId)
             if (geofence) {
               a.geofenceName = geofence.name + ' (' + Math.round(a.attributes.speedLimit * 1.85200) + ' Km/h)'
             }
@@ -251,7 +270,7 @@ async function getEventsPosition(from, to, devices, geofences, drivers, events,
           }
 
           if (a.position.attributes.driverUniqueId) {
-            const driver = drivers.find(d => d.uniqueId === a.position.attributes.driverUniqueId)
+            const driver = userData.drivers.find(d => d.uniqueId === a.position.attributes.driverUniqueId)
             a.driver = driver && driver.name
           }
 
@@ -264,6 +283,31 @@ async function getEventsPosition(from, to, devices, geofences, drivers, events,
   }
 }
 
+function calculateEventData(positions, pIndex, a, geofence){
+  let endEventPosition = a.position
+  let maxSpeed = a.position.speed
+  let dist = 0
+  while (pIndex + 1 < positions.length) {
+    pIndex++
+
+    dist += distance(point([endEventPosition.longitude, endEventPosition.latitude]),
+        point([positions[pIndex].longitude, positions[pIndex].latitude]))
+    endEventPosition = positions[pIndex]
+    if (endEventPosition.speed <= a.attributes.speedLimit || (geofence && isOutsideGeofence(geofence, endEventPosition))) {
+      a.eventTime = new Date(endEventPosition.fixTime) - new Date(a.position.fixTime)
+      a.attributes.maxSpeed = maxSpeed
+      a.distance = dist
+      break
+    } else {
+      if (maxSpeed < endEventPosition.speed) {
+        maxSpeed = endEventPosition.speed
+      }
+    }
+  }
+
+  return pIndex
+}
+
 function isOutsideGeofence(geofence, endEventPosition) {
   const v = turf.feature(turf.flip(parse(geofence.area)))
   const point = turf.point([endEventPosition.longitude, endEventPosition.latitude])
@@ -287,7 +331,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
     translations.report.duration,
   ]
 
-  if(userData.useRoadSpeedLimits) {
+  if(userData.roadSpeedLimits) {
     headers.splice(2, 0, translations.report.roadSpeedLimit)
   }
 
@@ -335,7 +379,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
             userData.byDriver ? a.deviceName : a.driver
           ]
 
-          if(userData.useRoadSpeedLimits){
+          if(userData.roadSpeedLimits){
             temp.splice(2, 0, a.roadSpeedLimit)
           }
 
@@ -351,7 +395,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
           convertMS(d.alerts.reduce((a, b) => a + b.eventTime, 0), true)
         ]
 
-        if(userData.useRoadSpeedLimits){
+        if(userData.roadSpeedLimits){
           footValues.splice(2, 0, '')
         }
 
@@ -410,7 +454,7 @@ function exportSpeedingReportToExcel(userData, reportData) {
     userData.byDriver ? {label: translations.report.vehicle, value:'name'} : {label: translations.report.driver, value:'driver'}
   ]
 
-  if (userData.useRoadSpeedLimits){
+  if (userData.roadSpeedLimits){
     headers.splice(3, 0, {label: translations.report.roadSpeedLimit, value:'roadSpeedLimit'})
   }
 

package/src/trip-report.js

@@ -5,9 +5,10 @@ const {convertMS} = require("./util/utils")
 require('jspdf-autotable')
 const {coordsDistance} = require("./util/utils")
 const drivers = require("./util/driver")
-const {getUserPartner} = require("fleetmap-partners");
+const {getUserPartner} = require("fleetmap-partners")
 const {headerFromUser} = require("./util/pdfDocument")
 const {getStyle} = require("./reportStyle")
+const traccar = require("./util/traccar")
 
 
 let traccarInstance
@@ -16,7 +17,6 @@ const fileName = 'TripReport'
 
 async function createTripReport(from, to, userData, traccar) {
     console.log('Create TripReport')
-
     traccarInstance = traccar
     const reportData = []
 
@@ -26,72 +26,74 @@ async function createTripReport(from, to, userData, traccar) {
     }
     else 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)
-            if(devices.length > 0) {
-                const groupData = {
-                    devices: [],
-                    group: g,
-                    xpert: devices.filter(d => d.attributes.xpert).length > 0
-                }
-
-                const response = await traccarInstance.reports.reportsTripsGet(from, to, null, [g.id])
-                const data = response.data
-
-                const stopsResponse = await traccarInstance.reports.reportsStopsGet(from, to, null, [g.id])
-                const stopsData = stopsResponse.data
-
-                devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
-
-                if (data.length > 0) {
-
-                    console.log('Trips:' + data.length)
-                    groupData.devices = processDevices(from, to, devices, data, stopsData)
-
-                    reportData.push(groupData)
-                }
-            }
-        }
+        const allData = await createTripReportByGroup(from, to, userData)
+        reportData.push(...allData)
     }
 
     const groupIds = userData.groups.map(g => g.id)
     const withoutGroupDevices = userData.byGroup ? userData.devices.filter(d => !groupIds.includes(d.groupId)) : userData.devices
 
+    const allData = await createTripReportByDevice(from, to, userData, withoutGroupDevices)
+    reportData.push(allData)
+
+    return reportData
+}
+
+async function createTripReportByDevice(from, to, userData, devices) {
     const allData = {
         devices: [],
-        xpert: withoutGroupDevices.filter(d => d.attributes.xpert).length > 0
+        xpert: devices.filter(d => d.attributes.xpert).length > 0
     }
 
-    withoutGroupDevices.sort((a, b) => (a.name > b.name) ? 1 : -1)
-    const devicesToSlice = withoutGroupDevices.slice()
-
-    const arrayOfArrays = automaticReports.sliceArray(devicesToSlice)
-    let data = []
-    let stopsData = []
-    for (const a of arrayOfArrays) {
-        const response = await traccarInstance.reports.reportsTripsGet(from, to, a.map(d => d.id))
-        data = data.concat(response.data)
+    devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
-        const stopsResponse = await traccarInstance.reports.reportsStopsGet(from, to, a.map(d => d.id))
-        stopsData = stopsResponse.data
-    }
+    const devicesToSlice = devices.slice()
+    const data = await traccar.getTrips(traccarInstance, from, to, devicesToSlice)
+    const stopsData = await traccar.getStops(traccarInstance, from, to, devicesToSlice)
 
     console.log('Trips:' + data.length)
 
-    if (data.length === 0) {
-        return reportData
+    if (data.length > 0) {
+        allData.devices = processDevices(from, to, devices, data, stopsData, userData)
+
     }
 
-    allData.devices = processDevices(from, to, withoutGroupDevices, data, stopsData, userData)
+    return allData
+}
 
-    reportData.push(allData)
+async function createTripReportByGroup(from, to, userData) {
+    const reportData = []
+    for (const g of userData.groups) {
+        const devices = userData.devices.filter(d => d.groupId === g.id)
+        console.log(g.name + ' devices:' + devices.length)
+        if(devices.length > 0) {
+            const groupData = {
+                devices: [],
+                group: g,
+                xpert: devices.filter(d => d.attributes.xpert).length > 0
+            }
+
+            const response = await traccarInstance.reports.reportsTripsGet(from, to, null, [g.id])
+            const data = response.data
 
+            const stopsResponse = await traccarInstance.reports.reportsStopsGet(from, to, null, [g.id])
+            const stopsData = stopsResponse.data
+
+            devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+
+            if (data.length > 0) {
+
+                console.log('Trips:' + data.length)
+                groupData.devices = processDevices(from, to, devices, data, stopsData, userData)
+
+                reportData.push(groupData)
+            }
+        }
+    }
     return reportData
 }
 
 async function createTripReportByDriver(from, to, userData){
-
     const deviceIds = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
     console.log(deviceIds.length)
 

package/src/util/driver.js

@@ -1,14 +1,8 @@
-const automaticReports = require("../automaticReports")
+const traccar = require("./traccar");
 
 //get devices used by each driver between two dates
-async function devicesByDriver(traccar, from, to, drivers, devices){
-    let eventsData = []
-    let tripsData = []
-    const arrayOfArrays = automaticReports.sliceArray(devices)
-    for (const a of arrayOfArrays) {
-        const response = await traccar.reports.reportsEventsGet(from, to, a.map(d => d.id), null, ['driverChanged'])
-        eventsData = eventsData.concat(response.data)
-    }
+async function devicesByDriver(traccarInstance, from, to, drivers, devices){
+    const eventsData = traccar.getEvents(traccarInstance, from, to , devices, ['driverChanged'])
 
     const deviceIds = []
     for(const d of drivers) {

package/src/util/traccar.js

@@ -27,6 +27,19 @@ async function getTrips(traccar, from, to, devices){
     return result.map(r => r.data).flat()
 }
 
+async function getStops(traccar, from, to, devices){
+    const devicesToSlice = devices.slice()
+    const arrayOfArrays = automaticReports.sliceArray(devicesToSlice)
+    let requests = []
+    for (const a of arrayOfArrays) {
+        const promise = traccar.reports.reportsStopsGet(from, to, a.map(d => d.id))
+        requests = requests.concat(promise)
+    }
+
+    const result = await Promise.all(requests)
+    return result.map(r => r.data).flat()
+}
+
 async function getEvents(traccar, from, to, devices, events){
     const devicesToSlice = devices.slice()
     const arrayOfArrays = automaticReports.sliceArray(devicesToSlice)
@@ -41,4 +54,5 @@ async function getEvents(traccar, from, to, devices, events){
 
 exports.getRoute = getRoute
 exports.getTrips = getTrips
+exports.getStops = getStops
 exports.getEvents = getEvents

package/src/util/utils.js

@@ -29,6 +29,21 @@ function coordsDistance(lon1, lat1, lon2, lat2) {
     return (turf.distance(from, to, 'meters'))
 }
 
+function getDates(startDate, endDate) {
+    const dates = []
+    let currentDate = startDate
+    const addDays = function (days) {
+        const date = new Date(this.valueOf())
+        date.setDate(date.getDate() + days)
+        return date
+    }
+    while (currentDate <= endDate) {
+        dates.push(currentDate)
+        currentDate = addDays.call(currentDate, 1)
+    }
+    return dates
+}
+
 async function getImgFromUrl(hostname) {
     try {
         const img = new Image()
@@ -43,4 +58,5 @@ async function getImgFromUrl(hostname) {
 exports.getImgFromUrl = getImgFromUrl
 exports.convertMS = convertMS
 exports.coordsDistance = coordsDistance
+exports.getDates = getDates