fleetmap-reports 2.0.356 → 2.0.358

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

@@ -0,0 +1,822 @@
+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