fleetmap-reports 1.0.248 → 1.0.252

package/src/index.js

@@ -19,8 +19,8 @@ function Reports(config, axios) {
             byGroup: false
         }
     }
-    this.speedingReport = (from, to, userData, roadSpeedLimits) => {
-        return require('./speeding-report').createSpeedingReport(from, to, userData, this.traccar, roadSpeedLimits)
+    this.speedingReport = (from, to, userData) => {
+        return require('./speeding-report').createSpeedingReport(from, to, userData, this.traccar)
     }
 
     this.speedingReportToPDF = (userData, reportData) => {

package/src/kms-report.js

@@ -1,4 +1,3 @@
-const {createActivityReport} = require("./activity-report");
 const messages = require('../lang')
 const jsPDF = require('jspdf')
 require('jspdf-autotable')
@@ -6,6 +5,7 @@ const {getStyle} = require("./reportStyle");
 const {headerFromUser,addTable} = require("./util/pdfDocument");
 const {getUserPartner} = require("fleetmap-partners");
 const traccar = require("./util/traccar");
+const {getDates} = require("./util/utils");
 
 
 let traccarInstance
@@ -51,73 +51,102 @@ function processDevices(from, to, devices, route, trips) {
         const deviceTrips = trips.filter(t => t.deviceId === d.id)
 
          if (deviceTrips.length > 0) {
-            deviceTrips.forEach(t => t.tripDay = new Date(t.startTime).toISOString().split('T')[0] + ' 12:00 PM')
-            const groupedTrips = deviceTrips.reduce(
-                (entryMap, e) => entryMap.set(e.tripDay, [...entryMap.get(e.tripDay)||[], e]),
-                new Map()
-            )
-
-            const days = []
-            const keys = Array.from(groupedTrips.keys())
-            keys.forEach(key => {
-                const currentDate = new Date(key)
-                let dayTrips = groupedTrips.get(key)
-                const day = {
-                    date: currentDate,
-                    kms: 0
-                }
-
-                if(userData.allWeek){
-                    day.kms = dayTrips.reduce((a, b) => a + b.distance, 0) || 0
-                } else {
-                    if((currentDate.getDay() === 0 && userData.weekDays.sunday) ||
-                        (currentDate.getDay() === 1 && userData.weekDays.monday) ||
-                        (currentDate.getDay() === 2 && userData.weekDays.tuesday) ||
-                        (currentDate.getDay() === 3 && userData.weekDays.wednesday)  ||
-                        (currentDate.getDay() === 4 && userData.weekDays.thursday) ||
-                        (currentDate.getDay() === 5 && userData.weekDays.friday) ||
-                        (currentDate.getDay() === 6 && userData.weekDays.saturday)) {
-
-                        const startDate = new Date(new Date(key).toISOString().split('T')[0] + ' '+userData.dayHours.startTime)
-                        const endDate = new Date(new Date(key).toISOString().split('T')[0] + ' '+userData.dayHours.endTime)
-
-                        console.log(key, startDate, endDate)
-
-                        //Trips inside time period
-                        const filteredTrips = dayTrips.filter(t => new Date(t.startTime).getTime() > startDate.getTime()
-                                && new Date(t.endTime).getTime() < endDate.getTime())
+            if(userData.groupByDay) {
+                deviceTrips.forEach(t => t.tripDay = new Date(t.startTime).toISOString().split('T')[0] + ' 12:00 PM')
+                const groupedTrips = deviceTrips.reduce(
+                    (entryMap, e) => entryMap.set(e.tripDay, [...entryMap.get(e.tripDay)||[], e]),
+                    new Map()
+                )
 
-                        //Trip starts outside time period and ends inside time period
-                        const startIncompleteTrip = dayTrips.filter(t => new Date(t.startTime).getTime() < startDate.getTime()
-                            && new Date(t.endTime).getTime() > startDate.getTime())
+                const allDates = getDates(from, to)
+
+                const days = []
+                let keys = Array.from(groupedTrips.keys())
+                 allDates.forEach(d => {
+                     const day = d.toISOString().split('T')[0] + ' 12:00 PM'
+                     if(!keys.includes(day)){
+                         groupedTrips.set(day, [])
+                     }
+                 })
+
+                 keys = Array.from(groupedTrips.keys())
+                 keys.sort((a,b)=>new Date(a).getTime()-new Date(b).getTime());
+                 keys.forEach(key => {
+                    const currentDate = new Date(key)
+                    let dayTrips = groupedTrips.get(key)
+                    const day = {
+                        date: currentDate,
+                        kms: 0
+                    }
 
-                        //Trip starts inside time period and ends outside time period
-                        const endIncompleteTrip = dayTrips.filter(t => new Date(t.startTime).getTime() < endDate.getTime()
+                    if(userData.allWeek){
+                        day.kms = dayTrips.reduce((a, b) => a + b.distance, 0) || 0
+                    } else {
+                        if((currentDate.getDay() === 0 && userData.weekDays.sunday) ||
+                            (currentDate.getDay() === 1 && userData.weekDays.monday) ||
+                            (currentDate.getDay() === 2 && userData.weekDays.tuesday) ||
+                            (currentDate.getDay() === 3 && userData.weekDays.wednesday)  ||
+                            (currentDate.getDay() === 4 && userData.weekDays.thursday) ||
+                            (currentDate.getDay() === 5 && userData.weekDays.friday) ||
+                            (currentDate.getDay() === 6 && userData.weekDays.saturday)) {
+
+                            const startDate = new Date(new Date(key).toISOString().split('T')[0] + ' '+userData.dayHours.startTime)
+                            const endDate = new Date(new Date(key).toISOString().split('T')[0] + ' '+userData.dayHours.endTime)
+
+                            console.log(key, startDate, endDate)
+
+                            if(startDate.getTime() < endDate.getTime()) {
+                                //Trips inside time period
+                                const filteredTrips = dayTrips.filter(t => new Date(t.startTime).getTime() > startDate.getTime()
+                                    && new Date(t.endTime).getTime() < endDate.getTime())
+
+                                day.kms = filteredTrips.reduce((a, b) => a + b.distance, 0) || 0
+                                console.log('Inside trips:' + day.kms)
+                            } else {
+                                //Trips inside time period
+                                const filteredTrips = dayTrips.filter(t => new Date(t.startTime).getTime() > startDate.getTime()
+                                    || new Date(t.endTime).getTime() < endDate.getTime())
+
+                                day.kms = filteredTrips.reduce((a, b) => a + b.distance, 0) || 0
+                                console.log('Inside trips:' + day.kms)
+                            }
+
+                            //Trip starts outside time period and ends inside time period
+                            const startIncompleteTrip = dayTrips.filter(t => new Date(t.startTime).getTime() < startDate.getTime()
+                                && new Date(t.endTime).getTime() > startDate.getTime())
+
+                            //Trip starts inside time period and ends outside time period
+                            const endIncompleteTrip = dayTrips.filter(t => new Date(t.startTime).getTime() < endDate.getTime()
                                 && new Date(t.endTime).getTime() > endDate.getTime())
 
-                        day.kms = filteredTrips.reduce((a, b) => a + b.distance, 0) || 0
-                        console.log('Inside trips:'+day.kms)
-
-                        if(startIncompleteTrip.length){
-                            const routeInside = route.filter(p => new Date(p.fixTime).getTime() > startDate.getTime() && new Date(p.fixTime).getTime() < new Date(startIncompleteTrip[0].endTime).getTime())
-                            day.kms = day.kms + (routeInside.reduce((a, b) => a + b.distance, 0) || 0)
-                            console.log('startIncompleteTrip:'+day.kms)
-                        }
-
-                        if(endIncompleteTrip.length){
-                            const routeInside = route.filter(p => new Date(p.fixTime).getTime() < endDate.getTime() && new Date(p.fixTime).getTime() > new Date(endIncompleteTrip[0].startTime).getTime())
-                            day.kms = day.kms + (routeInside.reduce((a, b) => a + b.distance, 0) || 0)
-                            console.log('endIncompleteTrip:'+day.kms)
+                            if (startIncompleteTrip.length) {
+                                const routeInside = route.filter(p => new Date(p.fixTime).getTime() > startDate.getTime() && new Date(p.fixTime).getTime() < new Date(startIncompleteTrip[0].endTime).getTime())
+                                day.kms = day.kms + (routeInside.reduce((a, b) => a + b.distance, 0) || 0)
+                                console.log('startIncompleteTrip:' + day.kms)
+                            }
+
+                            if (endIncompleteTrip.length) {
+                                const routeInside = route.filter(p => new Date(p.fixTime).getTime() < endDate.getTime() && new Date(p.fixTime).getTime() > new Date(endIncompleteTrip[0].startTime).getTime())
+                                day.kms = day.kms + (routeInside.reduce((a, b) => a + b.distance, 0) || 0)
+                                console.log('endIncompleteTrip:' + day.kms)
+                            }
                         }
                     }
-                }
 
-                days.push(day)
-            })
-            devicesResult.push({
-             device: d,
-             days: days
-            })
+                    days.push(day)
+                })
+                devicesResult.push({
+                 device: d,
+                 days: days
+                })
+            } else {
+                devicesResult.push({
+                    device: d,
+                    summary: {
+                        distance: deviceTrips.filter(t => t.distance > 0).reduce((a, b) => a + b.distance, 0),
+                    }
+                })
+            }
         }
     }
 
@@ -130,27 +159,22 @@ async function createKmsReport(from, to, reportUserData, traccar) {
     console.log(from, to)
     traccarInstance = traccar
     userData = reportUserData
-    if(userData.groupByDay){
-        const reportData = []
-
-        if(userData.byDriver){
-            const allData = await createKmsReportByDriver(from, to)
-            reportData.push(allData)
-        }
-        else if(userData.byGroup){
-            const allGroupsData = await createKmsReportByGroup(from, to)
-            allGroupsData.forEach(data => reportData.push(data))
-            const withoutGroupDevices = await createKmsReportByDevice(from, to)
-            reportData.push(withoutGroupDevices)
-        } else {
-            const allData = await createKmsReportByDevice(from, to)
-            reportData.push(allData)
-        }
-
-        return reportData
+    const reportData = []
+    if(userData.byDriver){
+        const allData = await createKmsReportByDriver(from, to)
+        reportData.push(allData)
+    }
+    else if(userData.byGroup){
+        const allGroupsData = await createKmsReportByGroup(from, to)
+        allGroupsData.forEach(data => reportData.push(data))
+        const withoutGroupDevices = await createKmsReportByDevice(from, to)
+        reportData.push(withoutGroupDevices)
     } else {
-        return await createActivityReport(from, to, userData, traccar)
+        const allData = await createKmsReportByDevice(from, to)
+        reportData.push(allData)
     }
+
+    return reportData
 }
 
 async function exportKmsReportToPDF(userData, reportData) {
@@ -158,6 +182,16 @@ async function exportKmsReportToPDF(userData, reportData) {
     const translations = messages[lang] ? messages[lang] : messages['en-GB']
     const kmsData = userData.byDriver ? reportData.drivers : reportData.devices
 
+    const weekDays = [
+        translations.report.sunday,
+        translations.report.monday,
+        translations.report.tuesday,
+        translations.report.wednesday,
+        translations.report.thursday,
+        translations.report.friday,
+        translations.report.saturday
+    ]
+
     const headers = []
     if(userData.groupByDay) {
         headers.push(translations.report.date,
@@ -174,32 +208,42 @@ async function exportKmsReportToPDF(userData, reportData) {
             translations.report.distance)
     }
     if (kmsData) {
-        let first = true
-        const doc = userData.groupByDay ? new jsPDF.jsPDF('p') : new jsPDF.jsPDF('l')
-        await headerFromUser(doc, translations.report.titleKmsReport, userData.user, 'p')
+        const orientation = userData.groupByDay ? 'p' : 'l'
+        const doc = new jsPDF.jsPDF(orientation)
+        await headerFromUser(doc, translations.report.titleKmsReport, userData.user, orientation)
 
         if (userData.groupByDay) {
-            for (const d of kmsData) {
+            kmsData.forEach(function (d, index) {
                 const name = userData.byDriver ? d.driver.name : d.device.name
                 const group = userData.byDriver ? userData.groups.find(g => g.drivers.includes(d.id)) : userData.groups.find(g => d.device.groupId === g.id)
 
-                let space = 0
-                if (!first) {
+                let space = index === 0 ? 8 : 0
+                if(index){
                     doc.addPage()
-                } else {
-                    first = false
-                    space = 8
                 }
+
                 doc.setFontSize(13)
                 doc.text(name, 20, space + 20)
                 doc.setFontSize(11)
                 doc.text(group ? translations.report.group + ': ' + group.name : '', 150, space + 20)
                 doc.text(new Date(reportData.from).toLocaleString() + ' - ' + new Date(reportData.to).toLocaleString(), 20, space + 25)
 
+                if(!userData.allWeek) {
+                    doc.text((userData.weekDays.monday ? ' ' + translations.report.monday + ',' : '')
+                        + (userData.weekDays.tuesday ? ' ' + translations.report.tuesday + ',' : '')
+                        + (userData.weekDays.wednesday ? ' ' + translations.report.wednesday + ',' : '')
+                        + (userData.weekDays.thursday ? ' ' + translations.report.thursday + ',' : '')
+                        + (userData.weekDays.friday ? ' ' + translations.report.friday + ',' : '')
+                        + (userData.weekDays.saturday ? ' ' + translations.report.saturday + ',' : '')
+                        + (userData.weekDays.sunday ? ' ' + translations.report.sunday + ',' : '')
+                        + ' das '
+                        + userData.dayHours.startTime + ' - ' + userData.dayHours.endTime, 20, space + 30)
+                }
+
                 const data = []
                 d.days.forEach(day => {
                     const temp = [
-                        new Date(day.date).toLocaleDateString(),
+                        new Date(day.date).toLocaleDateString() + ' - ' + weekDays[day.date.getDay()],
                         (day.kms/1000).toFixed(0)
                     ]
 
@@ -213,9 +257,8 @@ async function exportKmsReportToPDF(userData, reportData) {
                 )
 
                 const style = getStyle(getUserPartner(userData.user))
-
-                addTable(doc, headers, data, footValues, style, 35)
-            }
+                addTable(doc, headers, data, footValues, style, 40)
+            })
         } else {
             const data = []
             if (userData.byDriver) {
@@ -234,7 +277,7 @@ async function exportKmsReportToPDF(userData, reportData) {
                     const group = userData.groups.find(g => d.device.groupId === g.id)
 
                     const temp = [
-                        d.summary.deviceName,
+                        d.device.name,
                         d.device.model,
                         group ? group.name : '',
                         Number((d.summary.distance / 1000).toFixed(0))
@@ -273,6 +316,16 @@ function exportKmsReportToExcel(userData, reportData) {
     const lang = userData.user.attributes.lang || (navigator && navigator.language)
     const translations = messages[lang] ? messages[lang] : messages['en-GB']
 
+    const weekDays = [
+        translations.report.sunday,
+        translations.report.monday,
+        translations.report.tuesday,
+        translations.report.wednesday,
+        translations.report.thursday,
+        translations.report.friday,
+        translations.report.saturday
+    ]
+
     const settings = {
         sheetName: translations.report.titleKmsReport, // The name of the sheet
         fileName: fileName // The name of the spreadsheet
@@ -286,6 +339,7 @@ function exportKmsReportToExcel(userData, reportData) {
             {label: translations.report.licensePlate, value: 'licenseplate'},
             {label: translations.report.group, value: 'group'},
             {label: translations.report.date, value: 'date'},
+            {label: translations.report.weekDay, value: 'weekday'},
             {label: translations.report.distance, value: 'distance'})
     } else if(userData.byDriver) {
         headers.push(
@@ -314,12 +368,13 @@ function exportKmsReportToExcel(userData, reportData) {
                     group: group ? group.name : '',
                     licenseplate: d.device.attributes.license_plate,
                     date: a.date,
+                    weekday: weekDays[a.date.getDay()],
                     distance: Number((a.kms / 1000).toFixed(0))
                 }
             }))
         } else {
             data = data.concat([{
-                name: userData.byDriver ? d.driver.name : d.summary.deviceName,
+                name: userData.byDriver ? d.driver.name : d.device.name,
                 group: group ? group.name : '',
                 licenseplate: userData.byDriver ? '' : d.device.attributes.license_plate,
                 distance: Number((d.summary.distance / 1000).toFixed(0))

package/src/speeding-report.js

@@ -13,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){
@@ -37,48 +39,50 @@ async function createSpeedingReport(from, to, userData, traccar, roadSpeedLimits
           xpert: devices.filter(d => d.attributes.xpert).length > 0
         }
 
-        const events = ['deviceOverspeed']
-        const data = await traccar.getEvents(traccarInstance, from, to, devices, events)
+        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('Devices with driver',deviceIds.length)
 
@@ -93,18 +97,18 @@ async function createSpeedingReportByDriver(from, to, userData) {
   }
   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) {
@@ -124,34 +128,70 @@ async function processDrivers(from, to, drivers, data) {
   return driversResult
 }
 
-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 } } ))
@@ -161,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 => {
@@ -202,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)'
             }
@@ -230,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
           }
 
@@ -243,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])
@@ -266,7 +331,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
     translations.report.duration,
   ]
 
-  if(userData.useRoadSpeedLimits) {
+  if(userData.roadSpeedLimits) {
     headers.splice(2, 0, translations.report.roadSpeedLimit)
   }
 
@@ -301,7 +366,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
         doc.text(group ? translations.report.group + ': ' + group.name : '', 150, space+20 )
         doc.text(new Date(d.from).toLocaleString() + ' - ' + new Date(d.to).toLocaleString(), 20, space+25 )
         if (d.alerts[0] && !userData.byDriver) {
-          doc.text(translations.report.speedLimit + ": " + Math.round(d.alerts[0].attributes.speedLimit * 1.85200) + ' Km/h', 20, space + 30)
+          doc.text(translations.report.speedLimit + ": " + (userData.useVehicleSpeedLimit ? Math.round(d.alerts[0].attributes.speedLimit * 1.85200) : userData.customSpeed) + ' Km/h', 20, space + 30)
         }
         d.alerts.map(a => {
           const temp = [
@@ -314,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)
           }
 
@@ -330,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, '')
         }
 
@@ -389,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'})
   }