fleetmap-reports 1.0.284 → 1.0.288

package/src/refueling-report.js

@@ -109,31 +109,21 @@ function calculateRefuelingPositions(d, positions) {
     let refuelingActivated = false
     let currentValue = null
     let positionsChecked = 0
-    let lastRefuelingIndex = 0
     positions.forEach(function(element, index, array){
         if(!element.attributes.ignition && refuelingActivated && !currentValue){
-            //Ignition is off and Refueling is Active and there is no current value
-
-            //Get 5 position before the ignition off to calculate the current value of the fuel tank level
-            //lastRefuelingIndex is used to avoid re-analyzing positions prior to a refueling
-            const before = (index > 5 ? array.slice((index-6 < lastRefuelingIndex ? lastRefuelingIndex : index-6), index-1) : array.slice(0, index-1)).filter(b => b.attributes.ignition && b.attributes.fuel)
+            const before = (index > 5 ? array.slice(index-6, index-1) : array.slice(0, index-1)).filter(b => b.attributes.ignition && b.attributes.fuel)
             currentValue = Math.round(before.reduce((a, b) => a + b.attributes.fuel, 0) / before.length )
-
             positionsChecked = 0
         }
 
         if(element.attributes.ignition && refuelingActivated && currentValue) {
-            //Ignition is on and Refueling is Active and there is a current value
-            //Calculate the value of the fuel tank level after turning the ignition back on
             const after = (array.length > index + 5 ? array.slice(index, index+1) : array.slice(index)).filter(b => b.attributes.ignition && b.attributes.fuel)
             const newValue = Math.round(after.reduce((a, b) => a + b.attributes.fuel, 0) / after.length )
 
             const diff = automaticReports.calculateFuelDiff(currentValue, newValue, d)
             if (diff > 20) {
-                //New refueling detected
                 const value = Math.round(diff * d.attributes.fuel_tank_capacity / 100)
                 refuelingPositions.push({position: element, diff: value})
-                lastRefuelingIndex = index
                 positionsChecked = 6 // to reset values
             }
 

package/src/reportStyle.js

@@ -1,27 +1,3 @@
-function getStyle(partnerData) {
-    const reportStyleData = {
-        pdfHeaderColor: [105, 105, 105],
-        pdfHeaderTextColor: [256, 256, 256],
-        pdfBodyColor: [256, 256, 256],
-        pdfBodyTextColor: [30, 30, 30],
-        pdfFooterColor: [210, 210, 210],
-        pdfFooterTextColor: [30, 30, 30],
-        imgHeight: 0,
-        imgWidth: 0,
-    }
-
-    if(partnerData && partnerData.reports){
-        reportStyleData.pdfHeaderColor = partnerData.reports.mainColor || [105, 105, 105]
-        reportStyleData.pdfFooterColor = partnerData.reports.mainColor || [210, 210, 210]
-        reportStyleData.pdfFooterTextColor = partnerData.reports.mainColor ? [256, 256, 256] : [30, 30, 30]
-        reportStyleData.imgHeight = partnerData.reports.logoHeight || 0
-        reportStyleData.imgWidth = partnerData.reports.logoWidth || 0
-    }
-
-    return reportStyleData
-}
-
-exports.getStyle = getStyle
 
 exports.pdfHeaderColor = [105, 105, 105]
 exports.pdfHeaderTextColor = [256, 256, 256]
@@ -30,5 +6,3 @@ exports.pdfBodyTextColor = [30, 30, 30]
 exports.pdfFooterColor = [210, 210, 210]
 exports.pdfFooterTextColor = [30, 30, 30]
 
-
-

package/src/speeding-report.js

@@ -1,150 +1,119 @@
+const automaticReports = require("./automaticReports")
 const messages = require('../lang')
 const jsPDF = require('jspdf')
-const {convertMS, convertToLocaleString} = require("./util/utils")
-const {headerFromUser, AmiriRegular} = require("./util/pdfDocument")
+const {convertMS} = require("./util/utils")
 require('jspdf-autotable')
 const { parse } = require('wkt')
 const turf = require('turf')
-const {getStyle} = require("./reportStyle")
+const reportStyle = require("./reportStyle")
 const drivers = require("./util/driver")
 const {distance, point} = require('turf')
 const here = require('./here')
-const {getUserPartner} = require("fleetmap-partners");
-const traccar = require("./util/traccar");
 
 let traccarInstance
-let userData
 
 const fileName = 'SpeedingReport'
-const eventTypes = ['deviceOverspeed']
 
-async function createSpeedingReport(from, to, reportUserData, traccar) {
-  console.log('Create SpeedingReport')
+async function createSpeedingReport(from, to, userData, traccar, roadSpeedLimits) {
   traccarInstance = traccar
-  userData = reportUserData
+  console.log('createSpeedingReport', from, to, userData, traccar, roadSpeedLimits)
   const reportData = []
 
-  if (userData.byDriver) {
-    console.log("ByDriver")
-    const allData = await createSpeedingReportByDriver(from, to)
+  if(userData.byDriver){
+    const allData = await createSpeedingReportByDriver(from, to, userData, roadSpeedLimits)
     reportData.push(allData)
   }
-  else if (userData.byGroup) {
+  else if(userData.byGroup){
     console.log("ByGroup")
-    const allData = await createSpeedingReportByGroup(from, to)
-    reportData.push(...allData)
-  } else {
-    console.log("ByDevice")
-    const allData = await createSpeedingReportByDevice(from, to, userData.devices)
-    reportData.push(allData)
-  }
-
-  return reportData
-}
-
-async function createSpeedingReportByGroup(from, to){
-  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
-      }
+    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 events = await traccar.getEvents(traccarInstance, from, to, devices, eventTypes)
-      const routes = await traccar.getRoute(traccarInstance, from, to, devices)
+        const data = await getReportData(from, to, devices)
 
-      devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+        devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
-      if (events.length > 0) {
-        groupData.devices = await processDevices(from, to, devices, events, routes)
-        reportData.push(groupData)
+        if (data.length > 0) {
+          groupData.devices = await processDevices(from, to, devices, userData.geofences, userData.drivers, data, roadSpeedLimits)
+          reportData.push(groupData)
+        }
       }
     }
-  }
-
-  const groupIds = userData.groups.map(g => g.id)
-  const withoutGroupDevices = userData.devices.filter(d => !groupIds.includes(d.groupId))
 
-  const withoutGroupData = await createSpeedingReportByDevice(from, to, withoutGroupDevices)
-  reportData.push(withoutGroupData)
+    const withoutGroupData = await createSpeedingReportByDevice(from, to, userData)
+    reportData.push(withoutGroupData)
+  } else {
+    const allData = await createSpeedingReportByDevice(from, to, userData, roadSpeedLimits)
+    reportData.push(allData)
+  }
 
   return reportData
 }
 
-async function createSpeedingReportByDevice(from, to, devices) {
-  devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+async function createSpeedingReportByDevice(from, to, userData, roadSpeedLimits) {
+  const groupIds = userData.groups.map(g => g.id)
+  const withoutGroupDevices = userData.byGroup ? userData.devices.filter(d => !groupIds.includes(d.groupId)) : userData.devices
 
-  const routes = await traccar.getRoute(traccarInstance, from, to, devices)
-  const events = []
-  if(!userData.useVehicleSpeedLimit && userData.customSpeed){
-    events.push(...await getCustomSpeedLimitEvents(devices, routes))
-  } else {
-    events.push(...await traccar.getEvents(traccarInstance, from, to, devices, eventTypes))
-  }
+  withoutGroupDevices.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
-  if(userData.roadSpeedLimits){
-    events.push(...await getHereEvents(devices, routes, userData.maxSpeedThreshold))
-  }
+  const data = await getReportData(from, to, withoutGroupDevices)
 
-  if(!events.length) {
-    //empty report
-    return { devices: [] }
-  }
+  const allData = { devices: [] }
 
-  return {
-    devices: await processDevices(from, to, devices, events, routes),
-    xpert: devices.filter(d => d && d.attributes && d.attributes.xpert).length > 0
+  if(data.length > 0 || roadSpeedLimits) {
+    allData.devices = await processDevices(from, to, withoutGroupDevices, userData.geofences, userData.drivers, data, roadSpeedLimits)
+    allData.xpert = withoutGroupDevices.filter(d => d && d.attributes && d.attributes.xpert).length > 0
   }
+
+  return allData
 }
 
-async function createSpeedingReportByDriver(from, to) {
-  const devices = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
-  console.log('Devices with driver',devices.length)
+async function createSpeedingReportByDriver(from, to, userData) {
+  const deviceIds = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
+  console.log(deviceIds.length)
 
-  if(!devices.length) {
-    //empty report
-    return { drivers: [] }
+  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)
   }
 
-  const routes = await traccar.getRoute(traccarInstance, from, to, devices)
-  const events = []
-  if(!userData.useVehicleSpeedLimit && userData.customSpeed){
-    events.push(...await getCustomSpeedLimitEvents(devices, routes))
-  } else {
-    events.push(...await traccar.getEvents(traccarInstance, from, to, devices, eventTypes))
+  const allData = {
+    drivers: []
   }
 
-  if(userData.roadSpeedLimits){
-    events.push(...await getHereEvents(devices, routes, userData.maxSpeedThreshold))
-  }
+  console.log(eventsData.length)
 
-  if(!events.length) {
-    //empty report
-    return { drivers: [] }
-  }
+  await getEventsPosition(from , to, userData.devices, userData.geofences, userData.drivers, eventsData)
 
-  return {drivers: await processDrivers(from, to, events, routes)}
+  allData.drivers = await processDrivers(from, to, userData.drivers, eventsData)
+  console.log(allData.drivers.length)
+  return allData
 }
 
-async function processDrivers(from, to, events, routes) {
+async function processDrivers(from, to, drivers, data) {
+  console.log(data)
   const driversResult = []
+  const alertsWithPosition = data.filter(a => a.position)
+
+  drivers.forEach(d => {
+    const alerts = alertsWithPosition.filter(e => e.position.attributes.driverUniqueId === d.uniqueId)
 
-  await findEventsPosition(from, to, userData.devices, events, routes)
+    if (alerts.length > 0) {
 
-  userData.drivers.forEach(d => {
-    const driverEvents = events.filter(e => e.position && e.position.attributes.driverUniqueId === d.uniqueId)
-    if (driverEvents.length > 0) {
-      driverEvents.sort((a, b) => a.positionId - b.positionId)
       driversResult.push({
         driver: d,
         from: from,
         to: to,
-        alerts: driverEvents,
-        maxSpeed: driverEvents.reduce((a, b) => {
+        alerts: alerts,
+        maxSpeed: alerts.reduce((a, b) => {
           return a > b.attributes.maxSpeed ? a : b.attributes.maxSpeed
         }, 0),
       })
@@ -154,20 +123,40 @@ async function processDrivers(from, to, events, routes) {
   return driversResult
 }
 
-async function processDevices(from, to, devices, events, routes) {
+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) {
   const devicesResult = []
-  await findEventsPosition(from, to, devices, events, routes)
+
+  await getEventsPosition(from , to, devices, geofences, drivers, data, roadSpeedLimits)
 
   for (const d of devices) {
-    const deviceEvents = events.filter(e => e.deviceId === d.id && e.position)
-    if (deviceEvents.length > 0) {
-      deviceEvents.sort((a, b) => a.positionId - b.positionId)
+    const alerts = data.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: deviceEvents,
-        maxSpeed: deviceEvents.reduce((a, b) => {
+        alerts: alertsWithPosition,
+        maxSpeed: alertsWithPosition.reduce((a, b) => {
           return a > (b && b.attributes && b.attributes.maxSpeed) ? a : (b && b.attributes && b.attributes.maxSpeed)
         }, 0),
       })
@@ -177,136 +166,93 @@ async function processDevices(from, to, devices, events, routes) {
   return devicesResult
 }
 
-async function findEventsPosition(from, to, devices, events, routes){
+async function getEventsPosition(from, to, devices, geofences, drivers, data, roadSpeedLimits){
   for (const d of devices) {
-    let deviceEvents = events.filter(e => e.deviceId === d.id && e.positionId)
-    if (deviceEvents.length > 0) {
-      deviceEvents.sort((a,b) => a.positionId-b.positionId )
-      const positions = routes.filter(p => p.deviceId === d.id)
 
-      for (const a of deviceEvents) {
+    let alerts = data.filter(t => t.deviceId === d.id)
+
+    if (alerts.length > 0 || roadSpeedLimits) {
+      const response = await traccarInstance.reports.reportsRouteGet(from, to, [d.id])
+      const positions = response.data
+
+      if (roadSpeedLimits && positions.length) {
+        try {
+          await new Promise(res => setTimeout(res, 1000))
+          const results = await here.routeMatch(positions)
+          const hereAlerts = results.map(r => {
+            const position = positions.find(p => new Date(p.fixTime).getTime() === r.timestamp)
+            return {
+              ...r,
+              roadSpeedLimit: r.speedLimit,
+              deviceId: d.id,
+              position,
+              positionId: position && position.id,
+              attributes: {speedLimit: r.speedLimit, speed: r.currentSpeedKmh / 1.85200}
+            }
+          })
+          console.log('hereAlerts', hereAlerts)
+          const reduced = hereAlerts.reduce((acc, cur, idx, src) => {
+            if (idx === 1) {
+              return [cur]
+            }
+            if (cur.timestamp - src[idx - 1].timestamp > 300000 || cur.roadSpeedLimit !== src[idx - 1].roadSpeedLimit) {
+              return acc.concat(cur)
+            }
+            return acc
+          })
+          data.push(...reduced)
+          alerts = data.filter(t => t.deviceId === d.id)
+        } catch (e) {
+          console.error(e)
+        }
+      }
+
+      for (const a of alerts) {
         let pIndex = positions.findIndex(p => p.id === a.positionId)
         if (pIndex > 0) {
+          a.position = positions[pIndex]
           let geofence = null
+
           if (a.geofenceId) {
-            geofence = userData.geofences.find(g => g.id === a.geofenceId)
+            geofence = geofences.find(g => g.id === a.geofenceId)
             if (geofence) {
               a.geofenceName = geofence.name + ' (' + Math.round(a.attributes.speedLimit * 1.85200) + ' Km/h)'
             }
           }
 
-          a.position = positions[pIndex]
-          pIndex = calculateEventData(positions, pIndex, a, d, geofence)
-          positions.slice(pIndex)
-        }
-      }
-    }
-  }
-}
-
-async function getCustomSpeedLimitEvents(devices, routes){
-  console.log('custom speed limit events')
-  const events = []
-  const maxSpeed = userData.customSpeed / 1.85200
-
-  for (const d of devices) {
-    const positions = routes.filter(p => p.deviceId === d.id)
-    let eventIsActive = false
-
-    for (const position of positions) {
-      if(position.speed > maxSpeed && !eventIsActive){
-        const event = {
-          positionId: position && position.id,
-          deviceId: d.id,
-          attributes: {
-            speedLimit: maxSpeed,
-            speed: position.speed
+          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
+              }
+            }
           }
-        }
-        events.push(event)
-        eventIsActive = true
-      } else if (position.speed <= maxSpeed) {
-        eventIsActive = false
-      }
-    }
-  }
 
-  return events
-}
+          if (a.position.attributes.driverUniqueId) {
+            const driver = drivers.find(d => d.uniqueId === a.position.attributes.driverUniqueId)
+            a.driver = driver && driver.name
+          }
 
-async function getHereEvents(devices, routes, threshold){
-  console.log('here speed limit events')
-  const events = []
-  let i,j, temporary, chunk = 1;
-  for (i = 0,j = devices.length; i < j; i += chunk) {
-    temporary = devices.slice(i, i + chunk);
-    await Promise.all(temporary.map(d =>
-        here.routeMatch(routes.filter(p => p.deviceId === d.id)).then(r => d.results = r)
-    ))
-  }
+          a.deviceName = d.name
 
-  for (const d of devices) {
-    try {
-      const results = d.results
-      const hereAlerts = results.filter(r => r.currentSpeedKmh > (parseInt(r.speedLimit) + threshold)).map(r => {
-        const position = positions.find(p => new Date(p.fixTime).getTime() === r.timestamp)
-        return {
-          ...r,
-          roadSpeedLimit: r.speedLimit,
-          deviceId: d.id,
-          position,
-          positionId: position && position.id,
-          attributes: {speedLimit: r.speedLimit, speed: r.currentSpeedKmh / 1.85200}
-        }
-      })
-      const reduced = hereAlerts.reduce((acc, cur, idx, src) => {
-        if (idx === 1) {
-          return [cur]
-        }
-        if (cur.timestamp - src[idx - 1].timestamp > 300000 || cur.roadSpeedLimit !== src[idx - 1].roadSpeedLimit) {
-          return acc.concat(cur)
+          positions.slice(pIndex)
         }
-        return acc
-      })
-      events.push(...reduced)
-    } catch (e) {
-      console.error(e)
-    }
-  }
-  return events
-}
-
-function calculateEventData(positions, pIndex, alert, device, geofence){
-  let endEventPosition = alert.position
-  let maxSpeed = alert.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 <= alert.attributes.speedLimit || (geofence && isOutsideGeofence(geofence, endEventPosition))) {
-      alert.eventTime = new Date(endEventPosition.fixTime) - new Date(alert.position.fixTime)
-      alert.attributes.maxSpeed = maxSpeed
-      alert.distance = dist
-      break
-    } else {
-      if (maxSpeed < endEventPosition.speed) {
-        maxSpeed = endEventPosition.speed
       }
     }
   }
-
-
-  if (alert.position.attributes.driverUniqueId) {
-    const driver = userData.drivers.find(d => d.uniqueId === alert.position.attributes.driverUniqueId)
-    alert.driver = driver && driver.name
-  }
-
-  alert.deviceName = device.name
-
-  return pIndex
 }
 
 function isOutsideGeofence(geofence, endEventPosition) {
@@ -315,11 +261,10 @@ function isOutsideGeofence(geofence, endEventPosition) {
   return turf.inside(point, v)
 }
 
-async function exportSpeedingReportToPDF(userData, reportData) {
+function exportSpeedingReportToPDF(userData, reportData) {
   console.log('Export to PDF')
 
   const lang = userData.user.attributes.lang
-  const timezone = userData.user.attributes.timezone
   const translations = messages[lang] ? messages[lang] : messages['en-GB']
 
   const overspeedData = userData.byDriver ? reportData.drivers : reportData.devices
@@ -333,7 +278,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
     translations.report.duration,
   ]
 
-  if(userData.roadSpeedLimits) {
+  if(userData.useRoadSpeedLimits) {
     headers.splice(2, 0, translations.report.roadSpeedLimit)
   }
 
@@ -346,7 +291,8 @@ async function exportSpeedingReportToPDF(userData, reportData) {
   if (overspeedData) {
     let first = true
     const doc = new jsPDF.jsPDF('l');
-    await headerFromUser(doc, translations.report.titleSpeedingReport, userData.user)
+    doc.setFontSize(14)
+    doc.text(translations.report.titleSpeedingReport, 15, 15 )
 
     overspeedData.forEach(d => {
       try {
@@ -362,13 +308,13 @@ async function exportSpeedingReportToPDF(userData, reportData) {
           first = false
           space = 10
         }
-        doc.setFontSize(13)
+        doc.setFontSize(12)
         doc.text(name, 20, space+20 )
-        doc.setFontSize(11)
+        doc.setFontSize(10)
         doc.text(group ? translations.report.group + ': ' + group.name : '', 150, space+20 )
-        doc.text(convertToLocaleString(d.from, lang, timezone) + ' - ' + convertToLocaleString(d.to, lang, timezone), 20, space+25 )
+        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 + ": " + ((userData.useVehicleSpeedLimit || !userData.customSpeed) ? Math.round(d.alerts[0].attributes.speedLimit * 1.85200) : userData.customSpeed) + ' Km/h', 20, space + 30)
+          doc.text(translations.report.speedLimit + ": " + Math.round(d.alerts[0].attributes.speedLimit * 1.85200) + ' Km/h', 20, space + 30)
         }
         d.alerts.map(a => {
           const temp = [
@@ -381,7 +327,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
             userData.byDriver ? a.deviceName : a.driver
           ]
 
-          if(userData.roadSpeedLimits){
+          if(userData.useRoadSpeedLimits){
             temp.splice(2, 0, a.roadSpeedLimit)
           }
 
@@ -397,34 +343,26 @@ async function exportSpeedingReportToPDF(userData, reportData) {
           convertMS(d.alerts.reduce((a, b) => a + b.eventTime, 0), true)
         ]
 
-        if(userData.roadSpeedLimits){
+        if(userData.useRoadSpeedLimits){
           footValues.splice(2, 0, '')
         }
 
-        doc.addFileToVFS("Amiri-Regular.ttf", AmiriRegular());
-        doc.addFont("Amiri-Regular.ttf", "Amiri", "normal");
-
-        const style = getStyle(getUserPartner(userData.user))
         doc.autoTable({
           head: [headers],
           body: data,
           foot: [footValues],
           showFoot: 'lastPage',
           headStyles: {
-            fillColor: style.pdfHeaderColor,
-            textColor: style.pdfHeaderTextColor,
-            fontSize: 10
+            fillColor: reportStyle.pdfHeaderColor,
+            textColor: reportStyle.pdfHeaderTextColor
           },
           bodyStyles: {
-            fillColor: style.pdfBodyColor,
-            textColor: style.pdfBodyTextColor,
-            fontSize: 8,
-            font: timezone === 'Asia/Qatar' ? "Amiri" : ''
+            fillColor: reportStyle.pdfBodyColor,
+            textColor: reportStyle.pdfBodyTextColor
           },
           footStyles: {
-            fillColor: style.pdfFooterColor,
-            textColor: style.pdfFooterTextColor,
-            fontSize: 9
+            fillColor: reportStyle.pdfFooterColor,
+            textColor: reportStyle.pdfFooterTextColor
           },
           startY: space+35 });
     } catch (e) {
@@ -460,7 +398,7 @@ function exportSpeedingReportToExcel(userData, reportData) {
     userData.byDriver ? {label: translations.report.vehicle, value:'name'} : {label: translations.report.driver, value:'driver'}
   ]
 
-  if (userData.roadSpeedLimits){
+  if (userData.useRoadSpeedLimits){
     headers.splice(3, 0, {label: translations.report.roadSpeedLimit, value:'roadSpeedLimit'})
   }
 
@@ -496,7 +434,10 @@ function deviceName(device){
 }
 
 function getAlertDate(row, user) {
-  return convertToLocaleString(row.position.fixTime, user.attributes.lang, user.attributes.timezone)
+  return new Date(row.position.fixTime).toLocaleString(user.attributes.lang, {
+    timeZone: user.attributes.timezone,
+    hour12: false
+  })
 }
 
 function getMaxSpeed(data) {