fleetmap-reports 2.0.358 → 2.0.360

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

@@ -1,822 +0,0 @@
-const automaticReports = require('./automaticReports')
-const {
-  convertMS, getDates, getTranslations, weekDaySelected, convertToLocaleString, isClientSide,
-  getLanguage, executeServerSide
-} = require('./util/utils')
-const jsPDF = require('jspdf')
-require('jspdf-autotable')
-const {
-  headerFromUser, addTable,
-  pdfPageByDay
-} = require('./util/pdfDocument')
-const { getStyle } = require('./reportStyle')
-const { getUserPartner } = require('fleetmap-partners')
-const traccar = require('./util/traccar')
-const { isInsideTimetable, isPartialInsideTimetable, calculateTrip, getDataByDay, getKms, calculateMultiDayTrips } = require('./util/trips')
-const { devicesToProcess } = require('./util/device')
-const { getDriverData } = require('./util/driver')
-const { calculateConsumption } = require('./util/fuel')
-const { getSummaryByDay } = require('./util/traccar')
-
-const fileName = 'ActivityReport'
-
-async function createActivityReport (from, to, userData, traccarInstance) {
-  console.log('Create ActivityReport')
-  const reportData = []
-
-  if (userData.byDriver) {
-    const allData = await createActivityReportByDriver(from, to, userData, traccarInstance)
-    reportData.push(allData)
-  } else if (userData.byGroup) {
-    const allData = await createActivityReportByGroup(from, to, userData, traccarInstance)
-    reportData.push(...allData)
-  } else {
-    const allData = await createActivityReportByDevice(from, to, userData, traccarInstance)
-    reportData.push(allData)
-  }
-
-  return reportData
-}
-
-async function createActivityReportByGroup (from, to, userData, traccarInstance) {
-  console.log('ByGroup')
-  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,
-        from,
-        to
-      }
-
-      const response = await traccarInstance.reports.reportsSummaryGet(from, to, null, [g.id])
-      const summary = response.data
-
-      const responseTrips = await traccarInstance.reports.reportsTripsGet(from, to, null, [g.id])
-      const trips = responseTrips.data
-
-      devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
-
-      if (summary.length > 0) {
-        groupData.devices = await processDevices(from, to, devices, { summary, trips }, userData, traccarInstance)
-
-        reportData.push(groupData)
-      }
-    }
-  }
-
-  const withoutGroupDevices = await createActivityReportByDevice(from, to, userData, traccarInstance)
-  reportData.push(withoutGroupDevices)
-
-  return reportData
-}
-
-async function createActivityReportByDevice (from, to, userData, traccarInstance) {
-  console.log('createActivityReportByDevice')
-  const allDevices = devicesToProcess(userData)
-
-  const allData = {
-    devices: [],
-    xpert: allDevices.filter(d => d.attributes.xpert).length > 0,
-    from,
-    to
-  }
-
-  if (isClientSide() && allDevices.length > 20) {
-    const sliced = automaticReports.sliceArray(allDevices, 10)
-    await executeServerSide('activity-report', sliced, from, to, userData, allDevices.length, traccarInstance, 5).then(devices => {
-      allData.devices = devices
-    })
-  } else {
-    let summaryByDay = []
-    if (userData.allWeek && userData.groupByDay) {
-      const dates = getDates(from, to, userData.user.attributes.timezone || getUserPartner(userData.user).timezone)
-      summaryByDay = await getSummaryByDay(dates, userData, traccarInstance, allDevices, true, from, to)
-    }
-
-    let deviceCount = 0
-    const sliced = automaticReports.sliceArray(allDevices, 20)
-    for (const devices of sliced) {
-      const needRoute = userData.groupByDay || !userData.allWeek
-      const {
-        trips,
-        route,
-        summary
-      } = await traccar.getAllInOne(traccarInstance, from, to, devices, needRoute, true, false, !userData.groupByDay, deviceCount, allDevices.length, 10)
-
-      // Process report data
-      if (summary.length || trips.length) {
-        allData.devices = allData.devices.concat(await processDevices(from, to, devices, { summaryByDay, summary, trips, route }, userData, traccarInstance))
-      }
-      deviceCount += devices.length
-    }
-  }
-
-  return allData
-}
-
-async function createActivityReportByDriver (from, to, userData, traccarInstance) {
-  console.log('createActivityReportByDriver')
-  const allDevices = await traccarInstance.devices.devicesGet().then(d => d.data)
-
-  const allData = {
-    drivers: [],
-    from,
-    to
-  }
-  const driversData = new Map()
-
-  let deviceCount = 0
-  const sliced = automaticReports.sliceArray(allDevices, 10)
-  for (const devices of sliced) {
-    const data = await traccar.getAllInOne(traccarInstance, from, to, devices, true, true, false, false, deviceCount, allDevices.length)
-
-    for (const d of userData.drivers) {
-      const { trips, route } = await getDriverData(d, data, userData)
-      let driverData = driversData.get(d.id)
-      if (!driverData) {
-        driverData = { trips: [], route: [] }
-        driversData.set(d.id, driverData)
-      }
-      driverData.trips = driverData.trips.concat(...(trips || []))
-      driverData.route = driverData.route.concat(...(route || []))
-    }
-
-    deviceCount += devices.length
-  }
-
-  allData.drivers = processDrivers(from, to, userData.drivers, driversData, userData)
-
-  return allData
-}
-
-async function processDevices (from, to, devices, data, userData, traccarInstance) {
-  const devicesResult = []
-
-  for (const d of devices) {
-    const deviceTrips = data.trips.filter(t => t.deviceId === d.id)
-    const deviceRoute = data.route.filter(t => t.deviceId === d.id)
-
-    let uncompletedTripRoute = []
-    if (deviceRoute.length && deviceTrips.length && deviceRoute[deviceRoute.length - 1].attributes.ignition) {
-      uncompletedTripRoute = deviceRoute.filter(p => p.attributes.ignition && new Date(p.fixTime).getTime() > new Date(deviceTrips[deviceTrips.length - 1].endTime).getTime())
-      if (uncompletedTripRoute.length) {
-        deviceTrips.push(calculateTrip(d, uncompletedTripRoute))
-      }
-    }
-
-    const summary = []
-    if (userData.groupByDay) {
-      const trips = []
-      for (const t of deviceTrips) {
-        if (userData.allWeek || !userData.weekDays) {
-          trips.push(t)
-          continue
-        }
-        if (isInsideTimetable(t, userData)) {
-          trips.push(t)
-          continue
-        }
-        if (await isPartialInsideTimetable(d, t, userData, deviceRoute)) {
-          trips.push(t)
-        }
-      }
-      const dates = getDates(from, to, userData.user.attributes.timezone || getUserPartner(userData.user).timezone)
-      for (const date of dates) {
-        const { tripsByDay, routeByDay } = await getDataByDay(d, date, { trips, route: deviceRoute }, userData, traccarInstance)
-        const distance = getKms(tripsByDay)
-        if (!userData.allWeek && userData.weekDays && userData.dayHours) {
-          if (weekDaySelected(date, userData.weekDays)) {
-            summary.push({
-              date,
-              deviceId: d.id,
-              averageSpeed: distance > 0 ? ((tripsByDay.reduce((a, b) => a + (b.averageSpeed * b.distance), 0)) / distance) : 0,
-              distance,
-              engineHours: tripsByDay.reduce((a, b) => a + b.duration, 0),
-              maxSpeed: tripsByDay.reduce((a, b) => {
-                return a > b.maxSpeed ? a : b.maxSpeed
-              }, 0),
-              endOdometer: 0,
-              startOdometer: 0,
-              startTime: tripsByDay.length && tripsByDay[0].startTime,
-              startAddress: tripsByDay.length && tripsByDay[0].startAddress,
-              endTime: tripsByDay.length && tripsByDay[tripsByDay.length - 1].endTime,
-              endAddress: tripsByDay.length && tripsByDay[tripsByDay.length - 1].endAddress,
-              startTimeIsOut: tripsByDay.some(t => t.startTimeIsOut),
-              endTimeIsOut: tripsByDay.some(t => t.endTimeIsOut)
-            })
-          }
-        } else {
-          const summaryByDay = data.summaryByDay.find(a => a.date.getTime() === date.getTime())
-          const summaryByDevice = summaryByDay.summary.find(a => a.deviceId === d.id)
-
-          const summaryCurrentDay = { date, deviceId: d.id }
-          summaryCurrentDay.engineHours = tripsByDay.reduce((a, b) => a + b.duration, 0)
-          summaryCurrentDay.distance = summaryByDevice.distance
-          summaryCurrentDay.averageSpeed = distance > 0 ? ((tripsByDay.reduce((a, b) => a + (b.averageSpeed * b.distance), 0)) / distance) : 0
-          summaryCurrentDay.maxSpeed = tripsByDay.reduce((a, b) => { return a > b.maxSpeed ? a : b.maxSpeed }, 0)
-          summaryCurrentDay.convertedSpentFuel = calculateConsumption(d, { route: routeByDay })
-          summaryCurrentDay.startTime = tripsByDay.length && tripsByDay[0].startTime
-          summaryCurrentDay.startAddress = tripsByDay.length && tripsByDay[0].startAddress
-          summaryCurrentDay.endTime = tripsByDay.length && tripsByDay[tripsByDay.length - 1].endTime
-          summaryCurrentDay.endAddress = tripsByDay.length && tripsByDay[tripsByDay.length - 1].endAddress
-          summaryCurrentDay.startOdometer = summaryByDevice.startOdometer
-          summaryCurrentDay.endOdometer = summaryByDevice.endOdometer
-          summaryCurrentDay.startTimeIsOut = tripsByDay.some(t => t.startTimeIsOut)
-          summaryCurrentDay.endTimeIsOut = tripsByDay.some(t => t.endTimeIsOut)
-          summary.push(summaryCurrentDay)
-        }
-      }
-    } else {
-      if (!userData.allWeek && userData.weekDays && userData.dayHours) {
-        const trips = deviceTrips.filter(t => userData.allWeek || !userData.weekDays || isInsideTimetable(t, userData) || isPartialInsideTimetable(d, t, userData, deviceRoute))
-        const distance = getKms(trips)
-        summary.push({
-          deviceId: d.id,
-          averageSpeed: distance > 0 ? ((trips.reduce((a, b) => a + (b.averageSpeed * b.distance), 0)) / distance) : 0,
-          distance,
-          engineHours: trips.reduce((a, b) => a + b.duration, 0),
-          maxSpeed: trips.reduce((a, b) => {
-            return a > b.maxSpeed ? a : b.maxSpeed
-          }, 0),
-          startOdometer: trips.length ? trips[0].startOdometer : 0,
-          endOdometer: trips.length ? trips[trips.length - 1].endOdometer : 0,
-          startTime: trips.length && trips[0].startTime,
-          startAddress: trips.length && trips[0].startAddress,
-          endTime: trips.length && trips[trips.length - 1].endTime,
-          endAddress: trips.length && trips[trips.length - 1].endAddress
-        })
-      } else {
-        summary.push(...data.summary.filter(s => s.deviceId === d.id))
-
-        if (summary.length) {
-          summary.forEach(s => {
-            s.engineHours = deviceTrips.reduce((a, b) => a + b.duration, 0)
-            s.convertedSpentFuel = calculateConsumption(d, { route: deviceRoute, summary: s })
-            s.startTime = deviceTrips.length && deviceTrips[0].startTime
-            s.startAddress = deviceTrips.length && deviceTrips[0].startAddress
-            s.endTime = deviceTrips.length && deviceTrips[deviceTrips.length - 1].endTime
-            s.endAddress = deviceTrips.length && deviceTrips[deviceTrips.length - 1].endAddress
-          })
-        }
-      }
-    }
-
-    const deviceData = {
-      device: d,
-      summary
-    }
-
-    if ((deviceData.summary.length && deviceData.summary.some(s => s.startTime)) || !userData.onlyWithActivity) {
-      devicesResult.push(deviceData)
-    }
-  }
-
-  return devicesResult
-}
-
-function processDrivers (from, to, drivers, driversData, userData) {
-  const driversResult = []
-  drivers.forEach(d => {
-    const { trips, route } = driversData.get(d.id)
-    trips.sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime())
-    if (trips.length > 0) {
-      const driverData = {
-        driver: d,
-        summary: []
-      }
-      if (userData.groupByDay) {
-        const dates = getDates(from, to)
-        for (const date of dates) {
-          const fromByDay = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0)
-          const toByDay = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59)
-
-          const tripsByDay = trips.filter(t => (new Date(t.startTime) > fromByDay && new Date(t.endTime) < toByDay) &&
-                    (userData.allWeek || !userData.weekDays || isInsideTimetable(t, userData) || isPartialInsideTimetable(undefined, t, userData, route)))
-
-          calculateMultiDayTrips(trips, route, tripsByDay, fromByDay, toByDay, userData.devices)
-
-          driverData.summary.push({
-            date,
-            distance: tripsByDay.filter(t => t.distance > 0).reduce((a, b) => a + b.distance, 0),
-            engineHours: tripsByDay.reduce((a, b) => a + b.duration, 0),
-            maxSpeed: tripsByDay.reduce((a, b) => Math.max(a, b.maxSpeed), 0),
-            averageSpeed: tripsByDay.length ? Math.round(tripsByDay.reduce((a, b) => a + b.averageSpeed, 0) / tripsByDay.length) : 0,
-            startTime: tripsByDay.length && tripsByDay[0].startTime,
-            startAddress: tripsByDay.length && tripsByDay[0].startAddress,
-            endTime: tripsByDay.length && tripsByDay[tripsByDay.length - 1].endTime,
-            endAddress: tripsByDay.length && tripsByDay[tripsByDay.length - 1].endAddress
-          })
-        }
-      } else {
-        driverData.summary.push({
-          distance: trips.filter(t => t.distance > 0).reduce((a, b) => a + b.distance, 0),
-          engineHours: trips.reduce((a, b) => a + b.duration, 0),
-          maxSpeed: trips.reduce((a, b) => Math.max(a, b.maxSpeed), 0),
-          averageSpeed: Math.round(trips.reduce((a, b) => a + b.averageSpeed, 0) / trips.length),
-          startTime: trips.length && trips[0].startTime,
-          startAddress: trips.length && trips[0].startAddress,
-          endTime: trips.length && trips[trips.length - 1].endTime,
-          endAddress: trips.length && trips[trips.length - 1].endAddress
-        })
-      }
-      driversResult.push(driverData)
-    }
-  })
-
-  return driversResult
-}
-
-async function exportActivityReportToPDF (userData, reportData) {
-  console.log('Export to PDF')
-  const translations = getTranslations(userData)
-
-  if (reportData.devices || reportData.drivers) {
-    // eslint-disable-next-line new-cap
-    const doc = new jsPDF.jsPDF('l')
-    await headerFromUser(doc, translations.report.titleActivityReport, userData.user)
-
-    if (userData.groupByDay && userData.byDriver) {
-      exportActivityReportToPDFDriverGroupByDay(doc, translations, reportData, userData)
-    } else if (userData.groupByDay) {
-      exportActivityReportToPDFVehicleGroupByDay(doc, translations, reportData, userData)
-    } else if (userData.byDriver) {
-      exportActivityReportToPDFDriver(doc, translations, reportData, userData)
-    } else {
-      exportActivityReportToPDFVehicle(doc, translations, reportData, userData)
-    }
-
-    return doc
-  }
-}
-
-function exportActivityReportToPDFDriver (doc, translations, reportData, userData) {
-  const timezone = userData.user.attributes.timezone
-  const lang = getLanguage(userData)
-
-  const headers = [translations.report.driver,
-    translations.report.start,
-    translations.report.end,
-    translations.report.distance,
-    translations.report.speed + ' ' + translations.report.avgSpeed + ' (Km/h)',
-    translations.report.speed + ' ' + translations.report.maxSpeed + ' (Km/h)',
-    translations.report.driverHours]
-
-  doc.setFontSize(10)
-  doc.text(convertToLocaleString(reportData.from, lang, timezone) + ' - ' + convertToLocaleString(reportData.to, lang, timezone), 20, 30)
-
-  const data = []
-  reportData.drivers.forEach(d => {
-    const temp = [
-      d.driver.name,
-      d.summary[0].startTime ? new Date(d.summary[0].startTime).toLocaleString() : '',
-      d.summary[0].endTime ? new Date(d.summary[0].endTime).toLocaleString() : '',
-      Number((d.summary[0].distance / 1000).toFixed(1)),
-      Math.round(d.summary[0].averageSpeed * 1.85200),
-      Math.round(d.summary[0].maxSpeed * 1.85200),
-      convertMS(d.summary[0].engineHours)
-    ]
-    data.push(temp)
-  })
-
-  const footValues = ['Total:' + reportData.drivers.length,
-    '', '',
-    (reportData.drivers.reduce((a, b) => a + b.summary[0].distance, 0) / 1000).toFixed(0),
-    getSumAvgSpeed(reportData.drivers, userData),
-    getSumMaxSpeed(reportData.drivers, userData),
-    convertMS(reportData.drivers.reduce((a, b) => a + b.summary[0].engineHours, 0))]
-
-  const style = getStyle(getUserPartner(userData.user))
-  addTable(doc, headers, data, footValues, style, 35)
-}
-
-function exportActivityReportToPDFVehicle (doc, translations, reportData, userData) {
-  const timezone = userData.user.attributes.timezone
-  const lang = getLanguage(userData)
-
-  const headers = [translations.report.vehicle,
-    translations.report.group,
-    translations.report.start,
-    translations.report.end,
-    translations.report.distance,
-    translations.report.start + ' ' + translations.report.odometer,
-    translations.report.end + ' ' + translations.report.odometer,
-    translations.report.avgSpeed + ' (Km/h)',
-    translations.report.maxSpeed + ' (Km/h)',
-    translations.report.engineHours,
-    translations.report.spentFuel]
-
-  doc.setFontSize(10)
-  doc.text(convertToLocaleString(reportData.from, lang, timezone, userData.user) + ' - ' + convertToLocaleString(reportData.to, lang, timezone, userData.user), 20, 30)
-
-  const data = []
-  reportData.devices.forEach(d => {
-    const group = userData.groups.find(g => d.device.groupId === g.id)
-
-    if (d.summary) {
-      const temp = [
-        d.device.name,
-        group ? group.name : '',
-        d.summary[0].startTime ? new Date(d.summary[0].startTime).toLocaleString() : '',
-        d.summary[0].endTime ? new Date(d.summary[0].endTime).toLocaleString() : '',
-        Number((d.summary[0].distance / 1000).toFixed(1)),
-        Number((d.summary[0].startOdometer / 1000).toFixed(1)),
-        Number((d.summary[0].endOdometer / 1000).toFixed(1)),
-        Math.round(d.summary[0].averageSpeed * 1.85200),
-        Math.round(d.summary[0].maxSpeed * 1.85200),
-        convertMS(d.summary[0].engineHours),
-        Math.round(d.summary[0].convertedSpentFuel >= 0 ? d.summary[0].convertedSpentFuel : 0)
-      ]
-      data.push(temp)
-    }
-  })
-
-  const footValues = ['Total:' + reportData.devices.length,
-    '', '', '',
-    (reportData.devices.reduce((a, b) => a + b.summary[0].distance, 0) / 1000).toFixed(0),
-    '', '',
-    getSumAvgSpeed(reportData.devices, userData),
-    getSumMaxSpeed(reportData.devices, userData),
-    convertMS(reportData.devices.reduce((a, b) => a + b.summary[0].engineHours, 0)),
-    Math.round(getSumSpentFuel(reportData.devices, userData))]
-
-  const style = getStyle(getUserPartner(userData.user))
-  addTable(doc, headers, data, footValues, style, 35)
-}
-
-function exportActivityReportToPDFVehicleGroupByDay (doc, translations, reportData, userData) {
-  const headers = [translations.report.date,
-    translations.report.start,
-    translations.report.end,
-    translations.report.distance,
-    translations.report.start + ' ' + translations.report.odometer,
-    translations.report.end + ' ' + translations.report.odometer,
-    translations.report.avgSpeed + ' (Km/h)',
-    translations.report.maxSpeed + ' (Km/h)',
-    translations.report.engineHours,
-    translations.report.spentFuel]
-
-  const weekDays = [
-    translations.report.sunday,
-    translations.report.monday,
-    translations.report.tuesday,
-    translations.report.wednesday,
-    translations.report.thursday,
-    translations.report.friday,
-    translations.report.saturday
-  ]
-
-  reportData.devices.forEach(function (d, index) {
-    pdfPageByDay(userData, d, index, doc, translations, reportData)
-
-    const data = []
-    d.summary.forEach(s => {
-      const temp = [
-        new Date(s.date).toLocaleDateString() + ' - ' + weekDays[new Date(s.date).getDay()],
-        s.startTime ? new Date(s.startTime).toLocaleTimeString() : '',
-        s.endTime ? new Date(s.endTime).toLocaleTimeString() : '',
-        Number((s.distance / 1000).toFixed(1)),
-        Number((s.startOdometer / 1000).toFixed(1)),
-        Number((s.endOdometer / 1000).toFixed(1)),
-        Math.round(s.averageSpeed * 1.85200),
-        Math.round(s.maxSpeed * 1.85200),
-        convertMS(s.engineHours),
-        Math.round(s.convertedSpentFuel >= 0 ? s.convertedSpentFuel : 0)
-      ]
-
-      data.push(temp)
-    })
-
-    const footValues = ['Total:' + d.summary.length,
-      '', '',
-      (d.summary.reduce((a, b) => a + b.distance, 0) / 1000).toFixed(0),
-      '', '',
-      getSumAvgSpeed(d.summary, userData),
-      getSumMaxSpeed(d.summary, userData),
-      convertMS(d.summary.reduce((a, b) => a + b.engineHours, 0)),
-      Math.round(getSumSpentFuel(d.summary, userData))]
-
-    const style = getStyle(getUserPartner(userData.user))
-    addTable(doc, headers, data, footValues, style, 40)
-  })
-}
-
-function exportActivityReportToExcelVehicleGroupByDay (settings, translations, reportData, userData) {
-  const headers = [{ label: translations.report.vehicle, value: 'name' },
-    { label: translations.report.group, value: 'group' },
-    { label: translations.report.date, value: 'date' },
-    { label: translations.report.weekDay, value: 'weekday' },
-    { label: translations.report.start, value: 'start' },
-    { label: translations.report.end, value: 'end' },
-    { label: translations.report.distance, value: 'distance' },
-    { label: translations.report.start + ' ' + translations.report.odometer, value: 'startOdometer' },
-    { label: translations.report.end + ' ' + translations.report.odometer, value: 'endOdometer' },
-    { label: translations.report.speed + ' ' + translations.report.avgSpeed + ' (Km/h)', value: 'avgSpeed' },
-    { label: translations.report.speed + ' ' + translations.report.maxSpeed + ' (Km/h)', value: 'maxSpeed' },
-    { label: translations.report.engineHours, value: 'engineHours' },
-    { label: translations.report.spentFuel, value: 'spentFuel' }]
-
-  const weekDays = [
-    translations.report.sunday,
-    translations.report.monday,
-    translations.report.tuesday,
-    translations.report.wednesday,
-    translations.report.thursday,
-    translations.report.friday,
-    translations.report.saturday
-  ]
-
-  let data = []
-  if (reportData.devices) {
-    reportData.devices.forEach(d => {
-      const group = userData.groups.find(g => d.device.groupId === g.id)
-
-      data = data.concat([{}])
-      data = data.concat(d.summary.map(s => {
-        return {
-          name: d.device.name,
-          group: group ? group.name : '',
-          date: new Date(s.date).toLocaleDateString(),
-          weekday: weekDays[new Date(s.date).getDay()],
-          start: s.startTime ? new Date(s.startTime).toLocaleTimeString() : '',
-          end: s.endTime ? new Date(s.endTime).toLocaleTimeString() : '',
-          distance: Number((s.distance / 1000).toFixed(0)),
-          startOdometer: Number((s.startOdometer / 1000).toFixed(0)),
-          endOdometer: Number((s.endOdometer / 1000).toFixed(0)),
-          avgSpeed: Math.round(s.averageSpeed * 1.85200),
-          maxSpeed: Math.round(s.maxSpeed * 1.85200),
-          engineHours: convertMS(s.engineHours),
-          spentFuel: Math.round(s.convertedSpentFuel >= 0 ? s.convertedSpentFuel : 0)
-        }
-      }))
-    })
-    return {
-      headers,
-      data,
-      settings
-    }
-  }
-}
-
-function exportActivityReportToPDFDriverGroupByDay (doc, translations, reportData, userData) {
-  const headers = [translations.report.date,
-    translations.report.start,
-    translations.report.end,
-    translations.report.distance,
-    translations.report.avgSpeed + ' (Km/h)',
-    translations.report.maxSpeed + ' (Km/h)',
-    translations.report.engineHours]
-
-  const weekDays = [
-    translations.report.sunday,
-    translations.report.monday,
-    translations.report.tuesday,
-    translations.report.wednesday,
-    translations.report.thursday,
-    translations.report.friday,
-    translations.report.saturday
-  ]
-
-  reportData.drivers.forEach(function (d, index) {
-    const name = d.driver.name
-    const group = userData.groups.find(g => g.drivers.includes(d.id))
-
-    const space = index === 0 ? 8 : 0
-    if (index) {
-      doc.addPage()
-    }
-
-    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 && userData.weekDays) {
-      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.summary.forEach(s => {
-      const temp = [
-        new Date(s.date).toLocaleDateString() + ' - ' + weekDays[new Date(s.date).getDay()],
-        s.startTime ? new Date(s.startTime).toLocaleTimeString() : '',
-        s.endTime ? new Date(s.endTime).toLocaleTimeString() : '',
-        Number((s.distance / 1000).toFixed(1)),
-        Math.round(s.averageSpeed * 1.85200),
-        Math.round(s.maxSpeed * 1.85200),
-        convertMS(s.engineHours)
-      ]
-
-      data.push(temp)
-    })
-
-    const footValues = ['Total:' + d.summary.length,
-      '', '',
-      (d.summary.reduce((a, b) => a + b.distance, 0) / 1000).toFixed(0),
-      getSumAvgSpeed(d.summary, userData),
-      getSumMaxSpeed(d.summary, userData),
-      convertMS(d.summary.reduce((a, b) => a + b.engineHours, 0))]
-
-    const style = getStyle(getUserPartner(userData.user))
-    addTable(doc, headers, data, footValues, style, 40)
-  })
-}
-
-function exportActivityReportToExcelDriverGroupByDay (settings, translations, reportData, userData) {
-  const headers = [{ label: translations.report.driver, value: 'name' },
-    { label: translations.report.group, value: 'group' },
-    { label: translations.report.date, value: 'date' },
-    { label: translations.report.weekDay, value: 'weekday' },
-    { label: translations.report.start, value: 'start' },
-    { label: translations.report.end, value: 'end' },
-    { label: translations.report.distance, value: 'distance' },
-    { label: translations.report.speed + ' ' + translations.report.avgSpeed + ' (Km/h)', value: 'avgSpeed' },
-    { label: translations.report.speed + ' ' + translations.report.maxSpeed + ' (Km/h)', value: 'maxSpeed' },
-    { label: translations.report.engineHours, value: 'engineHours' }]
-
-  const weekDays = [
-    translations.report.sunday,
-    translations.report.monday,
-    translations.report.tuesday,
-    translations.report.wednesday,
-    translations.report.thursday,
-    translations.report.friday,
-    translations.report.saturday
-  ]
-
-  let data = []
-  if (reportData.drivers) {
-    reportData.drivers.forEach(d => {
-      const group = userData.groups.find(g => g.drivers.includes(d.id))
-
-      data = data.concat([{}])
-      data = data.concat(d.summary.map(s => {
-        return {
-          name: d.driver.name,
-          group: group ? group.name : '',
-          date: new Date(s.date).toLocaleDateString(),
-          weekday: weekDays[new Date(s.date).getDay()],
-          start: s.startTime ? new Date(s.startTime).toLocaleTimeString() : '',
-          end: s.endTime ? new Date(s.endTime).toLocaleTimeString() : '',
-          distance: Number((s.distance / 1000).toFixed(0)),
-          avgSpeed: Math.round(s.averageSpeed * 1.85200),
-          maxSpeed: Math.round(s.maxSpeed * 1.85200),
-          engineHours: convertMS(s.engineHours)
-        }
-      }))
-    })
-    return {
-      headers,
-      data,
-      settings
-    }
-  }
-}
-
-function exportActivityReportToExcelDriver (settings, translations, reportData) {
-  const headers = [{ label: translations.report.driver, value: 'driver' },
-    { label: translations.report.start, value: 'start' },
-    { label: translations.report.end, value: 'end' },
-    { label: translations.report.distance, value: 'distance' },
-    { label: translations.report.speed + ' ' + translations.report.avgSpeed + ' (Km/h)', value: 'avgSpeed' },
-    { label: translations.report.speed + ' ' + translations.report.maxSpeed + ' (Km/h)', value: 'maxSpeed' },
-    { label: translations.report.driverHours, value: 'engineHours' }]
-
-  let data = []
-  if (reportData.drivers) {
-    reportData.drivers.forEach(d => {
-      data = data.concat([{
-        driver: d.driver.name,
-        start: d.summary[0].startTime ? new Date(d.summary[0].startTime).toLocaleString() : '',
-        end: d.summary[0].endTime ? new Date(d.summary[0].endTime).toLocaleString() : '',
-        distance: Number((d.summary[0].distance / 1000).toFixed(0)),
-        avgSpeed: Math.round(d.summary[0].averageSpeed * 1.85200),
-        maxSpeed: Math.round(d.summary[0].maxSpeed * 1.85200),
-        engineHours: convertMS(d.summary[0].engineHours)
-      }])
-    })
-    return {
-      headers,
-      data,
-      settings
-    }
-  }
-}
-
-function exportActivityReportToExcelVehicle (settings, translations, reportData, userData) {
-  const headers = [{ label: translations.report.vehicle, value: 'name' },
-    { label: translations.report.group, value: 'group' },
-    { label: translations.report.start, value: 'start' },
-    { label: translations.report.end, value: 'end' },
-    { label: translations.report.distance, value: 'distance' },
-    { label: translations.report.start + ' ' + translations.report.odometer, value: 'startOdometer' },
-    { label: translations.report.end + ' ' + translations.report.odometer, value: 'endOdometer' },
-    { label: translations.report.speed + ' ' + translations.report.avgSpeed + ' (Km/h)', value: 'avgSpeed' },
-    { label: translations.report.speed + ' ' + translations.report.maxSpeed + ' (Km/h)', value: 'maxSpeed' },
-    { label: translations.report.engineHours, value: 'engineHours' },
-    { label: translations.report.spentFuel, value: 'spentFuel' }]
-
-  if (reportData.devices) {
-    let data = []
-    reportData.devices.forEach(d => {
-      const group = userData.groups.find(g => d.device.groupId === g.id)
-
-      if (d.summary) {
-        data = data.concat([{
-          name: d.device.name,
-          group: group ? group.name : '',
-          start: d.summary[0].startTime ? new Date(d.summary[0].startTime).toLocaleString() : '',
-          end: d.summary[0].endTime ? new Date(d.summary[0].endTime).toLocaleString() : '',
-          distance: Number((d.summary[0].distance / 1000).toFixed(0)),
-          startOdometer: Number((d.summary[0].startOdometer / 1000).toFixed(0)),
-          endOdometer: Number((d.summary[0].endOdometer / 1000).toFixed(0)),
-          avgSpeed: Math.round(d.summary[0].averageSpeed * 1.85200),
-          maxSpeed: Math.round(d.summary[0].maxSpeed * 1.85200),
-          engineHours: convertMS(d.summary[0].engineHours),
-          spentFuel: Math.round(d.summary[0].convertedSpentFuel >= 0 ? d.summary[0].convertedSpentFuel : 0)
-        }])
-      }
-    })
-    return {
-      headers,
-      data,
-      settings
-    }
-  }
-}
-
-function exportActivityReportToExcel (userData, reportData) {
-  console.log('Export to Excel')
-  const translations = getTranslations(userData)
-
-  const settings = {
-    sheetName: translations.report.titleActivityReport, // The name of the sheet
-    fileName // The name of the spreadsheet
-  }
-
-  if (userData.groupByDay && userData.byDriver) {
-    return exportActivityReportToExcelDriverGroupByDay(settings, translations, reportData, userData)
-  } else if (userData.groupByDay) {
-    return exportActivityReportToExcelVehicleGroupByDay(settings, translations, reportData, userData)
-  } else if (userData.byDriver) {
-    return exportActivityReportToExcelDriver(settings, translations, reportData, userData)
-  } else {
-    return exportActivityReportToExcelVehicle(settings, translations, reportData, userData)
-  }
-}
-
-function getSumAvgSpeed (data, userData) {
-  const values = data.map(item => {
-    if (userData.groupByDay) {
-      return Math.round(item.averageSpeed * 1.85200)
-    } else {
-      return Math.round(item.summary[0].averageSpeed * 1.85200)
-    }
-  }).filter(v => v !== 0)
-  return Math.round((values.reduce((a, b) => a + b, 0)) / values.length)
-}
-
-function getSumMaxSpeed (data, userData) {
-  const values = data.map(item => {
-    if (userData.groupByDay) {
-      return item.maxSpeed
-    } else {
-      return item.summary[0].maxSpeed
-    }
-  })
-  const max = values.reduce(function (a, b) {
-    return Math.max(a, b)
-  })
-  return Math.round(max * 1.85200)
-}
-
-function getSumSpentFuel (data, userData) {
-  const values = data.map(item => {
-    if (userData.groupByDay) {
-      return item.convertedSpentFuel >= 0 ? item.convertedSpentFuel : 0
-    } else {
-      return item.summary[0].convertedSpentFuel >= 0 ? item.summary[0].convertedSpentFuel : 0
-    }
-  })
-  return values.reduce((a, b) => a + b, 0)
-}
-
-exports.createActivityReport = createActivityReport
-exports.exportActivityReportToPDF = exportActivityReportToPDF
-exports.exportActivityReportToExcel = exportActivityReportToExcel
-exports.create = createActivityReport
-exports.exportToPDF = exportActivityReportToPDF
-exports.exportToExcel = exportActivityReportToExcel