fleetmap-reports 2.0.358 → 2.0.360

package/.claude/worktrees/eager-stonebraker-c08ac7/src/speeding-report.js

@@ -1,663 +0,0 @@
-const jsPDF = require('jspdf')
-const {
-  convertMS, convertToLocaleString, convertToFeature, convertPositionToFeature, getTranslations, getLanguage,
-  getCountry,
-  getServerHost
-} = require('./util/utils')
-const { headerFromUser, AmiriRegular } = require('./util/pdfDocument')
-require('jspdf-autotable')
-const { getStyle } = require('./reportStyle')
-const drivers = require('./util/driver')
-const {
-  getUserPartner
-} = require('fleetmap-partners')
-const traccarHelper = require('./util/traccar')
-const { devicesToProcess } = require('./util/device')
-const { point } = require('@turf/helpers')
-const distance = require('@turf/distance')
-const { insideGeofence } = require('./util/geofence')
-const booleanPointInPolygon = require('@turf/boolean-point-in-polygon')
-const automaticReports = require('./automaticReports')
-const { default: axios } = require('axios')
-const { getDriverName, getDriverData } = require('./util/driver')
-
-const fileName = 'SpeedingReport'
-const eventTypes = ['deviceOverspeed']
-
-async function createSpeedingReport (from, to, userData, traccarInstance) {
-  const reportData = []
-
-  if (userData.byDriver) {
-    console.log('ByDriver')
-    const allData = await createSpeedingReportByDriver(from, to, userData, traccarInstance)
-    reportData.push(allData)
-  } else if (userData.byGroup) {
-    console.log('ByGroup')
-    const allData = await createSpeedingReportByGroup(from, to, userData, traccarInstance)
-    reportData.push(...allData)
-  } else {
-    console.log('createSpeedingReportByDevice')
-    const allData = await createSpeedingReportByDevice(from, to, userData, traccarInstance)
-    reportData.push(allData)
-  }
-
-  return reportData
-}
-
-async function createSpeedingReportByGroup (from, to, userData, traccarInstance) {
-  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 events = await traccarHelper.getEvents(traccarInstance, from, to, devices, eventTypes)
-      const routes = await traccarHelper.getRoute(traccarInstance, from, to, devices)
-
-      devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
-
-      if (events.length > 0) {
-        groupData.devices = processDevices(from, to, devices, events, routes, userData)
-        reportData.push(groupData)
-      }
-    }
-  }
-
-  const withoutGroupData = await createSpeedingReportByDevice(from, to, userData, traccarInstance)
-  reportData.push(withoutGroupData)
-
-  return reportData
-}
-
-function processServerSide () {
-  return (process.env.PROCESS_HERE_EVENTS && process.env.PROCESS_HERE_EVENTS === 'server')
-}
-
-async function getOverspeedEvents (from, to, userData, devices, allData, traccarInstance) {
-  const _sliced = automaticReports.sliceArray(automaticReports.sliceArray(devices, 5), 5)
-  let deviceCount = 0
-  const overspeedEvents = []
-  for (const sliced of _sliced) {
-    await Promise.all(sliced.map(async slice => {
-      overspeedEvents.push(...await getEvents(traccarInstance, from, to, slice, userData, deviceCount, devices.length, slice.length))
-      deviceCount = deviceCount + slice.length
-      if (processServerSide()) {
-        console.log('LOADING_MESSAGE:' + slice[0].name)
-        console.log(`PROGRESS_PERC:${deviceCount / devices.length * 100}`)
-      }
-    }))
-  }
-  return overspeedEvents
-}
-
-async function createSpeedingReportByDevice (from, to, userData, traccarInstance) {
-  const devices = devicesToProcess(userData)
-
-  const allData = {
-    devices: [],
-    xpert: devices.filter(d => d && d.attributes && d.attributes.xpert).length > 0
-  }
-
-  allData.devices = await getOverspeedEvents(from, to, userData, devices, allData, traccarInstance)
-
-  return allData
-}
-
-async function createSpeedingReportByDriver (from, to, userData, traccarInstance) {
-  const { devices } = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
-  console.log('Devices with driver', devices.length)
-  const _drivers = []
-  const sliced = automaticReports.sliceArray(devices, 5)
-  let deviceCount = 0
-  for (const slice of sliced) {
-    const eventsByDevice = await getEvents(traccarInstance, from, to, slice, userData, deviceCount, devices.length, slice.length)
-    if (processServerSide()) {
-      console.log('LOADING_MESSAGE:' + slice[0].name)
-      console.log(`PROGRESS_PERC:${deviceCount / devices.length * 100}`)
-    }
-    if (eventsByDevice && eventsByDevice.length > 0) {
-      _drivers.push(...(await processDrivers(from, to, eventsByDevice, userData)))
-    }
-    deviceCount = deviceCount + slice.length
-  }
-  return { drivers: _drivers }
-}
-
-async function getEvents (traccarInstance, from, to, devices, userData, deviceCount, totalDevices, sliceSize) {
-  if (processServerSide() && !userData.useVehicleSpeedLimit) {
-    const cookie = await axios.get('/pinmeapi/cookie/get', { withCredentials: true }).then(d => d.data)
-    const url = `https://${getServerHost()}/pinmeapi/reports/speeding-report/getEvents`
-    const maxAttempts = 3
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        return await axios.post(url, { from, to, devices, userData, deviceCount, totalDevices, sliceSize, cookie }, { withCredentials: true, timeout: 60000 }).then(d => d.data)
-      } catch (e) {
-        console.log(`getEvents failed for devices [${devices.map(d => d.name).join(', ')}] (attempt ${attempt}/${maxAttempts}): ${e.message}`)
-        if (attempt === maxAttempts) {
-          return []
-        }
-      }
-    }
-  } else {
-    const geofencesFeatures = userData.geofences.filter(g => g.area && g.area.startsWith('POLYGON') &&
-      g.attributes.speedLimit).map(g => convertToFeature(g))
-
-    const allInOne = await traccarHelper.getAllInOne(traccarInstance, from, to, devices, true, false,
-      false, false, deviceCount, totalDevices, sliceSize)
-    const routes = allInOne.route
-
-    const events = []
-    if (userData.roadSpeedLimits) {
-      const hereResults = await getRoadSpeedLimits(devices, routes, userData.maxSpeedThreshold, userData.minimumIdleMinutes)
-      console.log('got', hereResults.length, 'from here')
-      events.push(...hereResults)
-    } else if (!userData.useVehicleSpeedLimit && userData.customSpeed) {
-      events.push(...await getCustomSpeedLimitEvents(devices, routes, userData.customSpeed))
-    } else {
-      const traccarEvents = await traccarHelper.getEvents(traccarInstance, from, to, devices, eventTypes)
-      if (geofencesFeatures.length) {
-        events.push(...getGeofenceSpeedLimitEvents(geofencesFeatures, routes, devices))
-        events.push(...traccarEvents.filter(e => !(e.geofenceId)))
-      } else {
-        events.push(...traccarEvents)
-      }
-    }
-    if (events.length > 0) {
-      return processDevices(from, to, devices, events, routes, userData)
-    }
-    return []
-  }
-}
-
-function getGeofenceSpeedLimitEvents (geofencesFeatures, routes, devices) {
-  const events = []
-
-  devices.forEach(d => {
-    const deviceRoute = routes.filter(p => p.deviceId === d.id)
-    const routePoints = deviceRoute.map(p => convertPositionToFeature(p))
-    geofencesFeatures.forEach(g => {
-      let eventIsActive = false
-      routePoints.forEach(p => {
-        if (booleanPointInPolygon.default(p, g) && p.properties.position.speed > g.properties.geofence.attributes.speedLimit) {
-          if (!eventIsActive) {
-            const event = {
-              positionId: p.properties.position.id,
-              deviceId: d.id,
-              geofenceId: g.properties.geofence.id,
-              attributes: {
-                speedLimit: g.properties.geofence.attributes.speedLimit,
-                speed: p.properties.position.speed
-              }
-            }
-            events.push(event)
-          }
-          eventIsActive = true
-        } else {
-          eventIsActive = false
-        }
-      })
-    })
-  })
-
-  return events
-}
-
-async function processDrivers (from, to, eventsByDevice, userData) {
-  const driversResult = []
-
-  for (const d of userData.drivers) {
-    const driverEvents = (await getDriverData(d, { events: eventsByDevice.map(d => d.alerts).flat() }, userData)).events
-    if (driverEvents.length > 0) {
-      driverEvents.sort((a, b) => a.positionId - b.positionId)
-      driversResult.push({
-        driver: d,
-        from,
-        to,
-        alerts: driverEvents,
-        maxSpeed: driverEvents.reduce((a, b) => {
-          return a > b.attributes.maxSpeed ? a : b.attributes.maxSpeed
-        }, 0)
-      })
-    }
-  }
-
-  return driversResult
-}
-const MAX_DEVICE_SPEED = 160
-
-function processDevices (from, to, devices, events, routes, userData) {
-  const devicesResult = []
-  findEventsPosition(from, to, devices, events, routes, userData)
-
-  for (const d of devices) {
-    const deviceEvents = events.filter(e => e.deviceId === d.id && e.position).filter(e => e.position.speed < MAX_DEVICE_SPEED)
-    if (deviceEvents.length > 0) {
-      deviceEvents.sort((a, b) => a.positionId - b.positionId)
-      devicesResult.push({
-        device: d,
-        from,
-        to,
-        alerts: deviceEvents,
-        maxSpeed: deviceEvents.reduce((a, b) => {
-          return a > (b && b.attributes && b.attributes.maxSpeed) ? a : (b && b.attributes && b.attributes.maxSpeed)
-        }, 0)
-      })
-    }
-  }
-
-  return devicesResult
-}
-
-function findEventsPosition (from, to, devices, events, routes, userData) {
-  for (const d of devices) {
-    const deviceEvents = events.filter(e => e.deviceId === d.id && e.positionId)
-    if (deviceEvents.length > 0) {
-      const positions = routes.filter(p => p.deviceId === d.id)
-      for (const a of deviceEvents) {
-        const pIndex = positions.findIndex(p => p.id === a.positionId)
-        if (pIndex >= 0) {
-          let geofence = null
-          if (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)'
-            }
-          }
-
-          if (!userData.roadSpeedLimits) {
-            a.position = positions[pIndex]
-            calculateEventData(positions, pIndex, a, d, geofence, userData)
-          }
-          if (a.position.attributes.driverUniqueId) {
-            a.driver = getDriverName(a.position.attributes.driverUniqueId, a.position.fixTime, userData)
-          }
-          a.deviceName = d.name
-        } else {
-          console.warn('cant find position for event', a)
-        }
-      }
-    }
-  }
-}
-
-async function getCustomSpeedLimitEvents (devices, routes, customSpeed) {
-  console.log('custom speed limit events')
-  const events = []
-  const maxSpeed = 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,
-          position,
-          deviceId: d.id,
-          attributes: {
-            speedLimit: maxSpeed,
-            speed: position.speed
-          }
-        }
-        events.push(event)
-        eventIsActive = true
-      } else if (position.speed <= maxSpeed) {
-        eventIsActive = false
-      }
-    }
-  }
-
-  return events
-}
-
-async function getRoadSpeedLimits (devices, routes, threshold, minimumMinutes = 0) {
-  const position = routes.find(p => getCountry(p))
-  const country = position && getCountry(position)
-  return getOSMSpeedingEvents(devices, routes, threshold, minimumMinutes, country)
-}
-
-exports.getRoadSpeedLimits = getRoadSpeedLimits
-
-let countSuccess = 0
-let countError = 0
-let lastSuccessDuration
-async function invokeValhalla (route, i, chunk, country, threshold, results, retry = 3) {
-  const slice = route.slice(i, i + chunk)
-  const url = `http://valhalla-${country}.pinme.io:8002/trace_attributes`
-  try {
-    const now = new Date()
-    const {
-      // eslint-disable-next-line camelcase
-      matched_points,
-      edges
-    } = await axios.post(url,
-      {
-        costing: 'auto',
-        shape_match: 'map_snap',
-        filters: {
-          attributes: [
-            'admin.country_code',
-            'admin.country_text',
-            'admin.state_code',
-            'admin.state_text',
-            'edge.names',
-            'edge.way_id',
-            'edge.speed_limit',
-            'matched.point',
-            'matched.type',
-            'matched.edge_index'
-          ],
-          action: 'include'
-        },
-        shape: slice.map(p => ({
-          lon: p.longitude,
-          lat: p.latitude
-        }))
-      }, { timeout: 50000 })
-      .then(r => r.data)
-    countSuccess++
-    lastSuccessDuration = new Date() - now
-    // eslint-disable-next-line camelcase
-    matched_points.forEach((mp, mIndex) => {
-      const edge = edges[mp.edge_index]
-      const position = route[mIndex + i]
-      if (edge && (edge.speed_limit + (threshold || 0)) < position.speed * 1.852) {
-        results.push({ ...mp, ...edge, ...position, position })
-      }
-    })
-  } catch (e) {
-    countError++
-    if (e.response && e.response.data && e.response.data.error_code === 444) {
-      console.warn(e.response.data.error)
-      return
-    }
-    if (--retry) {
-      console.warn('retry', retry, e.message, (e.response && e.response.data) || url, 'deviceId',
-        slice[0] && slice[0].deviceId, slice[0] && slice[0].address, slice[0] && slice[0].fixTime, country, 'chunk', chunk,
-        'success', countSuccess, 'error', countError, lastSuccessDuration)
-      return invokeValhalla(route, i, chunk, country, threshold, results, retry)
-    } else {
-      console.error(e.message, (e.response && e.response.data) || url, 'deviceId',
-        slice[0] && slice[0].deviceId, slice[0] && slice[0].address, slice[0] && slice[0].fixTime, country, 'chunk', chunk, 'success', countSuccess, 'error', countError, lastSuccessDuration)
-    }
-  }
-}
-
-async function getOSMSpeedingEvents (devices, routes, threshold, minimumMinutes = 0, country) {
-  const chunk = 100
-  const events = []
-  for (const d of devices) {
-    const route = routes.filter(r => r.deviceId === d.id)
-    const results = []
-    const promises = []
-    for (let i = 0; i < route.length; i += chunk) {
-      promises.push(invokeValhalla(route, i, chunk, country, threshold, results))
-    }
-    await Promise.all(promises)
-    const reduced = results.reduce((acc, cur, idx, src) => {
-      const last = acc.length && acc.slice(-1)[0]
-      if (last && new Date(cur.fixTime) - new Date(src[idx - 1].fixTime) < 1000 * 60 * 2) {
-        last.eventTime = new Date(cur.fixTime) - new Date(last.fixTime)
-        last.attributes.maxSpeed = Math.max(last.attributes.maxSpeed, cur.speed)
-        last.distance += distance.default(point([cur.longitude, cur.latitude]), point([src[idx - 1].longitude, src[idx - 1].latitude]))
-      } else {
-        cur.positionId = cur && cur.id
-        cur.roadSpeedLimit = cur.speed_limit
-        cur.deviceId = d.id
-        cur.attributes = { speedLimit: cur.speed_limit, speed: cur.speed, maxSpeed: cur.speed }
-        cur.eventTime = 0
-        cur.distance = 0
-        acc.push(cur)
-      }
-      return acc
-    }, [])
-    events.push(...reduced)
-  }
-  return events.filter(e => e.eventTime >= minimumMinutes * 60 * 1000)
-}
-
-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.default(point([endEventPosition.longitude, endEventPosition.latitude]),
-      point([positions[pIndex].longitude, positions[pIndex].latitude]))
-    endEventPosition = positions[pIndex]
-    if (endEventPosition.speed <= alert.attributes.speedLimit || (geofence && !insideGeofence(endEventPosition, geofence))) {
-      alert.eventTime = new Date(endEventPosition.fixTime) - new Date(alert.position.fixTime) + (device.attributes.overspeedMinimalDuration || 0) * 1000
-      alert.attributes.maxSpeed = maxSpeed
-      alert.distance = dist
-      break
-    } else {
-      if (maxSpeed < endEventPosition.speed) {
-        maxSpeed = endEventPosition.speed
-      }
-    }
-  }
-}
-
-async function exportSpeedingReportToPDF (userData, reportData) {
-  console.log('Export to PDF')
-  const lang = getLanguage(userData)
-
-  const timezone = userData.user.attributes.timezone
-  const translations = getTranslations(userData)
-
-  const overspeedData = userData.byDriver ? reportData.drivers : reportData.devices
-
-  const headers = [
-    translations.report.date,
-    translations.report.address,
-    translations.report.overspeed,
-    translations.report.distance,
-    translations.report.maxSpeed,
-    translations.report.duration
-  ]
-
-  if (userData.roadSpeedLimits) {
-    headers.splice(2, 0, translations.report.roadSpeedLimit)
-  }
-
-  if (userData.byDriver) {
-    headers.push(translations.report.vehicle)
-  } else {
-    headers.push(translations.report.driver)
-  }
-
-  if (overspeedData) {
-    let first = true
-    // eslint-disable-next-line new-cap
-    const doc = new jsPDF.jsPDF('l', undefined, undefined, true)
-    await headerFromUser(doc, translations.report.titleSpeedingReport, userData.user)
-
-    overspeedData.forEach(d => {
-      try {
-        const data = []
-
-        const name = userData.byDriver ? d.driver.name : deviceName(d.device)
-        const group = userData.byDriver ? userData.groups.find(g => g.drivers && g.drivers.includes(d.id)) : userData.groups.find(g => d.device.groupId === g.id)
-
-        let space = 0
-        if (!first) {
-          doc.addPage()
-        } else {
-          first = false
-          space = 10
-        }
-        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(convertToLocaleString(d.from, lang, timezone, userData.user) + ' - ' + convertToLocaleString(d.to, lang, timezone, userData.user), 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) + ' Km/h' : (userData.roadSpeedLimits ? translations.report.roadSpeedLimit : userData.customSpeed + ' Km/h')), 20, space + 30)
-        }
-        d.alerts.forEach(a => {
-          const temp = [
-            getAlertDate(a, userData.user),
-            a.position.address + (a.geofenceName ? ' - ' + a.geofenceName : ''),
-            Math.round(a.attributes.speed * 1.85200),
-            a.distance && new Intl.NumberFormat(userData.user.attributes.lang, { maximumSignificantDigits: 1 }).format(a.distance),
-            a.attributes.maxSpeed ? Math.round(a.attributes.maxSpeed * 1.85200) : Math.round(a.attributes.speed * 1.85200),
-            convertMS(a.eventTime, true),
-            userData.byDriver ? a.deviceName : a.driver
-          ]
-
-          if (userData.roadSpeedLimits) {
-            temp.splice(2, 0, a.roadSpeedLimit)
-          }
-
-          data.push(temp)
-        })
-
-        const footValues = [
-          'Total:' + d.alerts.length,
-          '',
-          '',
-          '',
-          getMaxSpeed(d.alerts),
-          convertMS(d.alerts.reduce((a, b) => a + b.eventTime, 0), true)
-        ]
-
-        if (userData.roadSpeedLimits) {
-          footValues.splice(2, 0, '')
-        }
-
-        if (timezone === 'Asia/Qatar') {
-          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
-          },
-          bodyStyles: {
-            fillColor: style.pdfBodyColor,
-            textColor: style.pdfBodyTextColor,
-            fontSize: 8,
-            font: timezone === 'Asia/Qatar' ? 'Amiri' : ''
-          },
-          footStyles: {
-            fillColor: style.pdfFooterColor,
-            textColor: style.pdfFooterTextColor,
-            fontSize: 9
-          },
-          startY: space + 35
-        })
-      } catch (e) {
-        console.error(e, 'moving on...')
-      }
-    })
-
-    return doc
-  }
-}
-
-function exportSpeedingReportToExcel (userData, reportData) {
-  console.log('Export to Excel')
-
-  const lang = getLanguage(userData)
-  const translations = getTranslations(userData)
-  const overspeedData = userData.byDriver ? reportData.drivers : reportData.devices
-
-
-    const settings = {
-    sheetName: translations.report.titleSpeedingReport.substring(0, 31), // The name of the sheet
-    fileName // The name of the spreadsheet
-  }
-  const headers = [
-    userData.byDriver ? { label: translations.report.driver, value: 'driver' } : { label: translations.report.vehicle, value: 'name' },
-    userData.byDriver ? { label: translations.report.group, value: 'groupName' } : { label: translations.report.group, value: 'groupName' },
-    { label: translations.report.date, value: 'fixTime' },
-    { label: translations.report.address, value: 'address' },
-    {
-      label: userData.roadSpeedLimits ? translations.report.roadSpeedLimit : translations.report.speedLimit,
-      value: 'speedLimit'
-    },
-    { label: translations.report.overspeed, value: 'speed' },
-    { label: translations.report.distance, value: 'distance' },
-    { label: translations.report.maxSpeed, value: 'maxSpeed' },
-    { label: translations.report.duration, value: 'duration' },
-    userData.byDriver ? { label: translations.report.vehicle, value: 'name' } : { label: translations.report.driver, value: 'driver' },
-    { label: 'link', value: 'link', format: 'hyperlink' }
-  ]
-
-  if (userData.roadSpeedLimits) {
-    headers.push({ label: translations.report.info, value: 'info' })
-  }
-
-  let data = []
-  if (overspeedData) {
-    overspeedData.forEach(d => {
-      data = data.concat([{}])
-      data = data.concat(d.alerts.map(a => {
-        const group = userData.groups.find(g => g.id === d.device.groupId)
-        return {
-          groupName: group ? group.name : '',
-          driver: userData.byDriver ? d.driver.name : a.driver,
-          speed: Math.round(a.attributes.speed * 1.85200),
-          distance: a.distance && new Intl.NumberFormat(lang, { maximumSignificantDigits: 1 }).format(a.distance),
-          maxSpeed: a.attributes.maxSpeed ? Math.round(a.attributes.maxSpeed * 1.85200) : Math.round(a.attributes.speed * 1.85200),
-          duration: convertMS(a.eventTime, true),
-          fixTime: getAlertDate(a, userData.user),
-          name: userData.byDriver ? a.deviceName : d.device.name,
-          address: a.position.address + (a.geofenceName ? ' - ' + a.geofenceName : ''),
-          speedLimit: userData.roadSpeedLimits
-            ? a.roadSpeedLimit
-            : userData.useVehicleSpeedLimit
-              ? Math.round(a.attributes.speedLimit * 1.85200)
-              : userData.customSpeed,
-          ...(userData.roadSpeedLimits ? { info: `https://openstreetmap.org/way/${a.way_id}` } : {}),
-          link: `https://${getUserPartner(userData.user).host}/#/map?vehicleName=${userData.byDriver ? a.deviceName : d.device.name}&date=${new Date(a.position.fixTime).toISOString()}`
-        }
-      }))
-    })
-    return {
-      headers,
-      data,
-      settings
-    }
-  }
-}
-
-function deviceName (device) {
-  return device.name + (device.attributes.license_plate ? ', ' + device.attributes.license_plate : '') + (device.model ? ', ' + device.model : '')
-}
-
-function getAlertDate (row, user) {
-  return convertToLocaleString(row.position.fixTime, user.attributes.lang, user.attributes.timezone, user)
-}
-
-function getMaxSpeed (data) {
-  const values = data.map(item => {
-    return item.attributes.maxSpeed
-  })
-  const max = values.reduce(function (a, b) {
-    return Math.max(a, b)
-  })
-  return Math.round(max * 1.85200)
-}
-
-exports.createSpeedingReport = createSpeedingReport
-exports.exportSpeedingReportToPDF = exportSpeedingReportToPDF
-exports.exportSpeedingReportToExcel = exportSpeedingReportToExcel
-exports.create = createSpeedingReport
-exports.exportToPDF = exportSpeedingReportToPDF
-exports.exportToExcel = exportSpeedingReportToExcel
-exports.getOverspeedEvents = getOverspeedEvents