fleetmap-reports 1.0.288 → 1.0.292

package/src/refueling-report.js

@@ -109,21 +109,31 @@ 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){
-            const before = (index > 5 ? array.slice(index-6, index-1) : array.slice(0, index-1)).filter(b => b.attributes.ignition && b.attributes.fuel)
+            //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)
             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,3 +1,27 @@
+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]
@@ -6,3 +30,5 @@ exports.pdfBodyTextColor = [30, 30, 30]
 exports.pdfFooterColor = [210, 210, 210]
 exports.pdfFooterTextColor = [30, 30, 30]
 
+
+

package/src/speeding-report.js

@@ -1,119 +1,149 @@
-const automaticReports = require("./automaticReports")
 const messages = require('../lang')
 const jsPDF = require('jspdf')
-const {convertMS} = require("./util/utils")
+const {convertMS, convertToLocaleString} = require("./util/utils")
+const {headerFromUser, AmiriRegular} = require("./util/pdfDocument")
 require('jspdf-autotable')
 const { parse } = require('wkt')
 const turf = require('turf')
-const reportStyle = require("./reportStyle")
+const {getStyle} = 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, userData, traccar, roadSpeedLimits) {
+async function createSpeedingReport(from, to, reportUserData, traccar) {
   traccarInstance = traccar
-  console.log('createSpeedingReport', from, to, userData, traccar, roadSpeedLimits)
+  userData = reportUserData
   const reportData = []
 
-  if(userData.byDriver){
-    const allData = await createSpeedingReportByDriver(from, to, userData, roadSpeedLimits)
+  if (userData.byDriver) {
+    console.log("ByDriver")
+    const allData = await createSpeedingReportByDriver(from, to)
     reportData.push(allData)
   }
-  else if(userData.byGroup){
+  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 allData = await createSpeedingReportByGroup(from, to)
+    reportData.push(...allData)
+  } else {
+    console.log("createSpeedingReportByDevice")
+    const allData = await createSpeedingReportByDevice(from, to, userData.devices)
+    reportData.push(allData)
+  }
 
-        const data = await getReportData(from, to, devices)
+  return reportData
+}
 
-        devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+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
+      }
 
-        if (data.length > 0) {
-          groupData.devices = await processDevices(from, to, devices, userData.geofences, userData.drivers, data, roadSpeedLimits)
-          reportData.push(groupData)
-        }
+      const events = await traccar.getEvents(traccarInstance, from, to, devices, eventTypes)
+      const routes = await traccar.getRoute(traccarInstance, from, to, devices)
+
+      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)
       }
     }
-
-    const withoutGroupData = await createSpeedingReportByDevice(from, to, userData)
-    reportData.push(withoutGroupData)
-  } else {
-    const allData = await createSpeedingReportByDevice(from, to, userData, roadSpeedLimits)
-    reportData.push(allData)
   }
 
+  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)
+
   return reportData
 }
 
-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
-
-  withoutGroupDevices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+async function createSpeedingReportByDevice(from, to, devices) {
+  devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
-  const data = await getReportData(from, to, withoutGroupDevices)
+  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 = { devices: [] }
+  if(userData.roadSpeedLimits){
+    events.push(...await getHereEvents(devices, routes, userData.maxSpeedThreshold))
+  }
 
-  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
+  if(!events.length) {
+    //empty report
+    return { devices: [] }
   }
 
-  return allData
+  return {
+    devices: await processDevices(from, to, devices, events, routes),
+    xpert: devices.filter(d => d && d.attributes && d.attributes.xpert).length > 0
+  }
 }
 
-async function createSpeedingReportByDriver(from, to, userData) {
-  const deviceIds = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
-  console.log(deviceIds.length)
+async function createSpeedingReportByDriver(from, to) {
+  const devices = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
+  console.log('Devices with driver',devices.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)
+  if(!devices.length) {
+    //empty report
+    return { drivers: [] }
   }
 
-  const allData = {
-    drivers: []
+  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))
   }
 
-  console.log(eventsData.length)
+  if(userData.roadSpeedLimits){
+    events.push(...await getHereEvents(devices, routes, userData.maxSpeedThreshold))
+  }
 
-  await getEventsPosition(from , to, userData.devices, userData.geofences, userData.drivers, eventsData)
+  if(!events.length) {
+    //empty report
+    return { drivers: [] }
+  }
 
-  allData.drivers = await processDrivers(from, to, userData.drivers, eventsData)
-  console.log(allData.drivers.length)
-  return allData
+  return {drivers: await processDrivers(from, to, events, routes)}
 }
 
-async function processDrivers(from, to, drivers, data) {
-  console.log(data)
+async function processDrivers(from, to, events, routes) {
   const driversResult = []
-  const alertsWithPosition = data.filter(a => a.position)
-
-  drivers.forEach(d => {
-    const alerts = alertsWithPosition.filter(e => e.position.attributes.driverUniqueId === d.uniqueId)
 
-    if (alerts.length > 0) {
+  await findEventsPosition(from, to, userData.devices, events, routes)
 
+  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: alerts,
-        maxSpeed: alerts.reduce((a, b) => {
+        alerts: driverEvents,
+        maxSpeed: driverEvents.reduce((a, b) => {
           return a > b.attributes.maxSpeed ? a : b.attributes.maxSpeed
         }, 0),
       })
@@ -123,40 +153,20 @@ 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)
+  await findEventsPosition(from, to, devices, events, routes)
 
   for (const d of devices) {
-    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)
+    const deviceEvents = events.filter(e => e.deviceId === d.id && e.position)
+    if (deviceEvents.length > 0) {
+      deviceEvents.sort((a, b) => a.positionId - b.positionId)
       devicesResult.push({
         device: d,
         from: from,
         to: to,
-        alerts: alertsWithPosition,
-        maxSpeed: alertsWithPosition.reduce((a, b) => {
+        alerts: deviceEvents,
+        maxSpeed: deviceEvents.reduce((a, b) => {
           return a > (b && b.attributes && b.attributes.maxSpeed) ? a : (b && b.attributes && b.attributes.maxSpeed)
         }, 0),
       })
@@ -166,93 +176,137 @@ async function processDevices(from, to, devices, geofences, drivers, data, roadS
   return devicesResult
 }
 
-async function getEventsPosition(from, to, devices, geofences, drivers, data, roadSpeedLimits){
+async function findEventsPosition(from, to, devices, events, routes){
   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)
 
-    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) {
+      for (const a of deviceEvents) {
         let pIndex = positions.findIndex(p => p.id === a.positionId)
         if (pIndex > 0) {
-          a.position = positions[pIndex]
           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)'
             }
           }
 
-          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
-              }
-            }
-          }
+          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
 
-          if (a.position.attributes.driverUniqueId) {
-            const driver = drivers.find(d => d.uniqueId === a.position.attributes.driverUniqueId)
-            a.driver = driver && driver.name
+  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
           }
+        }
+        events.push(event)
+        eventIsActive = true
+      } else if (position.speed <= maxSpeed) {
+        eventIsActive = false
+      }
+    }
+  }
 
-          a.deviceName = d.name
+  return events
+}
 
-          positions.slice(pIndex)
+async function getHereEvents(devices, routes, threshold){
+  console.log('here speed limit events')
+  const events = []
+  for (const d of devices) {
+    const positions = routes.filter(p => p.deviceId === d.id)
+    if (!positions.length) {
+      console.log('no positions on device', d.name)
+      continue
+    }
+    try {
+      const results = await here.routeMatch(positions)
+      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}
         }
+      })
+      if (!hereAlerts.length) {
+        console.log('empty array after filter on device', d.name)
+        continue
       }
+      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
+      })
+      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) {
@@ -261,10 +315,11 @@ function isOutsideGeofence(geofence, endEventPosition) {
   return turf.inside(point, v)
 }
 
-function exportSpeedingReportToPDF(userData, reportData) {
+async 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
@@ -278,7 +333,7 @@ function exportSpeedingReportToPDF(userData, reportData) {
     translations.report.duration,
   ]
 
-  if(userData.useRoadSpeedLimits) {
+  if(userData.roadSpeedLimits) {
     headers.splice(2, 0, translations.report.roadSpeedLimit)
   }
 
@@ -291,8 +346,7 @@ function exportSpeedingReportToPDF(userData, reportData) {
   if (overspeedData) {
     let first = true
     const doc = new jsPDF.jsPDF('l');
-    doc.setFontSize(14)
-    doc.text(translations.report.titleSpeedingReport, 15, 15 )
+    await headerFromUser(doc, translations.report.titleSpeedingReport, userData.user)
 
     overspeedData.forEach(d => {
       try {
@@ -308,13 +362,13 @@ function exportSpeedingReportToPDF(userData, reportData) {
           first = false
           space = 10
         }
-        doc.setFontSize(12)
+        doc.setFontSize(13)
         doc.text(name, 20, space+20 )
-        doc.setFontSize(10)
+        doc.setFontSize(11)
         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 )
+        doc.text(convertToLocaleString(d.from, lang, timezone) + ' - ' + convertToLocaleString(d.to, lang, timezone), 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 || !userData.customSpeed) ? Math.round(d.alerts[0].attributes.speedLimit * 1.85200) : userData.customSpeed) + ' Km/h', 20, space + 30)
         }
         d.alerts.map(a => {
           const temp = [
@@ -327,7 +381,7 @@ function exportSpeedingReportToPDF(userData, reportData) {
             userData.byDriver ? a.deviceName : a.driver
           ]
 
-          if(userData.useRoadSpeedLimits){
+          if(userData.roadSpeedLimits){
             temp.splice(2, 0, a.roadSpeedLimit)
           }
 
@@ -343,26 +397,34 @@ 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, '')
         }
 
+        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: reportStyle.pdfHeaderColor,
-            textColor: reportStyle.pdfHeaderTextColor
+            fillColor: style.pdfHeaderColor,
+            textColor: style.pdfHeaderTextColor,
+            fontSize: 10
           },
           bodyStyles: {
-            fillColor: reportStyle.pdfBodyColor,
-            textColor: reportStyle.pdfBodyTextColor
+            fillColor: style.pdfBodyColor,
+            textColor: style.pdfBodyTextColor,
+            fontSize: 8,
+            font: timezone === 'Asia/Qatar' ? "Amiri" : ''
           },
           footStyles: {
-            fillColor: reportStyle.pdfFooterColor,
-            textColor: reportStyle.pdfFooterTextColor
+            fillColor: style.pdfFooterColor,
+            textColor: style.pdfFooterTextColor,
+            fontSize: 9
           },
           startY: space+35 });
     } catch (e) {
@@ -398,7 +460,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'})
   }
 
@@ -434,10 +496,7 @@ function deviceName(device){
 }
 
 function getAlertDate(row, user) {
-  return new Date(row.position.fixTime).toLocaleString(user.attributes.lang, {
-    timeZone: user.attributes.timezone,
-    hour12: false
-  })
+  return convertToLocaleString(row.position.fixTime, user.attributes.lang, user.attributes.timezone)
 }
 
 function getMaxSpeed(data) {

package/src/tests/index.js

@@ -0,0 +1,22 @@
+const {SessionApi} = require("traccar-api");
+const axios = require('axios')
+const axiosCookieJarSupport = require('axios-cookiejar-support').default;
+const tough = require('tough-cookie');
+const Index = require('../index');
+const cookieJar = new tough.CookieJar();
+const traccarConfig = {
+    basePath: 'https://api.pinme.io/api',
+    baseOptions: {
+        withCredentials: true,
+        jar: cookieJar
+    }
+}
+
+axiosCookieJarSupport(axios)
+
+exports.getReports = async() => {
+    await new SessionApi(traccarConfig, null, axios).sessionPost(process.env.email, process.env.password)
+    return new Index(traccarConfig, axios)
+}
+
+