fleetmap-reports 1.0.288 → 1.0.292

package/src/activity-report.js

@@ -1,38 +1,45 @@
 const automaticReports = require("./automaticReports")
 const messages = require('../lang')
-const {convertMS} = require("./util/utils")
+const {convertMS, getDates} = require("./util/utils")
 const jsPDF = require('jspdf')
-const autotable =  require('jspdf-autotable')
-const reportStyle = require("./reportStyle")
-const drivers = require("./util/driver");
+require('jspdf-autotable')
+const drivers = require("./util/driver")
+const {headerFromUser, addTable} = require("./util/pdfDocument")
+const {getStyle} = require("./reportStyle")
+const {getUserPartner} = require("fleetmap-partners")
+const traccar = require("./util/traccar")
+const {createKmsReport} = require("./kms-report");
+const {isInsideTimetable} = require("./util/trips");
 
 let traccarInstance
+let userData
 
 const fileName = 'ActivityReport'
 
-async function createActivityReport(from, to, userData, traccar) {
+async function createActivityReport(from, to, reportUserData, traccar) {
     console.log('Create ActivityReport')
     traccarInstance = traccar
+    userData = reportUserData
     const reportData = []
 
     if(userData.byDriver){
-        const allData = await createActivityReportByDriver(from, to, userData)
+        const allData = await createActivityReportByDriver(from, to)
         reportData.push(allData)
     }
     else if(userData.byGroup){
-        const allGroupsData = await createActivityReportByGroup(from, to, userData)
+        const allGroupsData = await createActivityReportByGroup(from, to)
         allGroupsData.forEach(data => reportData.push(data))
-        const withoutGroupDevices = await createActivityReportByDevice(from, to, userData)
+        const withoutGroupDevices = await createActivityReportByDevice(from, to)
         reportData.push(withoutGroupDevices)
     } else {
-        const allData = await createActivityReportByDevice(from, to, userData)
+        const allData = await createActivityReportByDevice(from, to)
         reportData.push(allData)
     }
 
     return reportData
 }
 
-async function createActivityReportByGroup(from, to, userData){
+async function createActivityReportByGroup(from, to){
     console.log("ByGroup")
     const reportData = []
     for (const g of userData.groups) {
@@ -67,49 +74,98 @@ async function createActivityReportByGroup(from, to, userData){
     return reportData
 }
 
-async function createActivityReportByDevice(from, to, userData){
+async function createActivityReportByDevice(from, to){
     const groupIds = userData.groups.map(g => g.id)
-    const withoutGroupDevices = userData.byGroup ? userData.devices.filter(d => !groupIds.includes(d.groupId)) : userData.devices
+    const devicesToProcess = userData.byGroup ? userData.devices.filter(d => !groupIds.includes(d.groupId)) : userData.devices
 
     const allData = {
         devices: [],
-        xpert: withoutGroupDevices.filter(d => d.attributes.xpert).length > 0,
+        xpert: devicesToProcess.filter(d => d.attributes.xpert).length > 0,
         from: from,
         to: to
     }
 
-    withoutGroupDevices.sort((a, b) => (a.name > b.name) ? 1 : -1)
-    const devicesToSlice = withoutGroupDevices.slice()
+    //Get report data from traccar
+    devicesToProcess.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
-    const arrayOfArrays = automaticReports.sliceArray(devicesToSlice)
-    let data = []
-    let trips = []
-    for (const a of arrayOfArrays) {
-        const responseData = await traccarInstance.reports.reportsSummaryGet(from, to, a.map(d => d.id))
-        data = data.concat(responseData.data)
+    // use the km report to calculate kms
+    const kmsReport = await createKmsReport(from, to, userData, traccarInstance)
 
-        const responseTrips = await traccarInstance.reports.reportsTripsGet(from, to, a.map(d => d.id))
-        trips = trips.concat(responseTrips.data)
+    let data = []
+    if(userData.groupByDay) {
+        const dates = getDates(from, to)
+        for(const date of dates){
+            if(userData.allWeek || !userData.weekDays){
+                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 summary = await traccar.getSummary(traccarInstance, fromByDay, toByDay, devicesToProcess)
+                summary.forEach(s => s.date = date)
+                data = data.concat(summary)
+            } else {
+                if((date.getDay() === 0 && userData.weekDays.sunday) ||
+                    (date.getDay() === 1 && userData.weekDays.monday) ||
+                    (date.getDay() === 2 && userData.weekDays.tuesday) ||
+                    (date.getDay() === 3 && userData.weekDays.wednesday)  ||
+                    (date.getDay() === 4 && userData.weekDays.thursday) ||
+                    (date.getDay() === 5 && userData.weekDays.friday) ||
+                    (date.getDay() === 6 && userData.weekDays.saturday)) {
+
+                    const fromByDay = new Date(new Date(date).toISOString().split('T')[0] + ' ' + userData.dayHours.startTime)
+                    const toByDay = new Date(new Date(date).toISOString().split('T')[0] + ' ' + userData.dayHours.endTime)
+
+                    if(fromByDay.getTime() < toByDay.getTime()) {
+                        const summary = await traccar.getSummary(traccarInstance, new Date(fromByDay.toUTCString()), new Date(toByDay.toUTCString()), devicesToProcess)
+                        summary.forEach(s => s.date = date)
+                        data = data.concat(summary)
+                    } else {
+                        const dayStart = new Date(new Date(date).toISOString().split('T')[0] + ' 00:00:00')
+                        const dayEnd = new Date(new Date(date).toISOString().split('T')[0] + ' 23:59:59')
+
+                        const summaryStart = await traccar.getSummary(traccarInstance, new Date(dayStart.toUTCString()), new Date(toByDay.toUTCString()), devicesToProcess)
+                        const summaryEnd = await traccar.getSummary(traccarInstance, new Date(fromByDay.toUTCString()), new Date(dayEnd.toUTCString()), devicesToProcess)
+
+                        const summary = []
+                        summaryStart.forEach(s => {
+                            const sEnd = summaryEnd.find(a => s.deviceId === a.deviceId)
+                            summary.push({
+                                date: date,
+                                deviceId: s.deviceId,
+                                averageSpeed: (s.averageSpeed + sEnd.averageSpeed) / 2,
+                                distance: s.distance + sEnd.distance,
+                                engineHours: s.engineHours + sEnd.engineHours,
+                                maxSpeed: s.maxSpeed > sEnd.maxSpeed ? s.maxSpeed : sEnd.maxSpeed,
+                                endOdometer: 0,
+                                startOdometer: 0
+                            })
+                        })
+                        data = data.concat(summary)
+                    }
+                }else {
+                    data = data.concat({date: date})
+                }
+            }
+        }
+    } else {
+        data = await traccar.getSummary(traccarInstance, from, to, devicesToProcess)
     }
 
     console.log('Summary:' + data.length)
 
-    if (data.length === 0) {
-        return allData
+    //Process report data
+    if (data.length > 0) {
+        allData.devices = processDevices(devicesToProcess, data, kmsReport)
     }
 
-    allData.devices = processDevices(withoutGroupDevices, data, trips)
-
     return allData
 }
 
-async function createActivityReportByDriver(from, to, userData){
-    const deviceIds = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
-    console.log(deviceIds)
+async function createActivityReportByDriver(from, to){
+    const devices = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
+
     let tripsData = []
-    if(deviceIds.length > 0) {
-        const response = await traccarInstance.reports.reportsTripsGet(from, to, deviceIds)
-        tripsData = response.data
+    if(devices.length > 0) {
+        tripsData = await traccar.getTrips(traccarInstance, from, to, devices)
     }
 
     const allData = {
@@ -118,24 +174,26 @@ async function createActivityReportByDriver(from, to, userData){
         to: to
     }
 
-    allData.drivers = processDrivers(userData.drivers, tripsData)
+    allData.drivers = processDrivers(from, to, userData.drivers, tripsData)
 
     return allData
 }
 
 
-function processDevices(devices, data, trips) {
+function processDevices(devices, data, kmsReport) {
     const devicesResult = []
 
     devices.forEach(d => {
         const summary = data.filter(s => s.deviceId === d.id)
-        const deviceTrips = trips.filter(t => t.deviceId === d.id)
         if (summary) {
-            summary[0].convertedSpentFuel = automaticReports.calculateSpentFuel(summary[0].spentFuel, d)
-            summary[0].distance = deviceTrips.filter(t => t.distance > 0).reduce((a, b) => a + b.distance, 0)
+            summary.forEach(s => {
+                const deviceKms = kmsReport[0].devices.filter(r => r.device.id === d.id)
+                s.convertedSpentFuel = automaticReports.calculateSpentFuel(s.spentFuel, d)
+                s.distance = deviceKms.length ? (userData.groupByDay ? deviceKms[0].days.find(d => d.date.getTime() === s.date.getTime()).kms : deviceKms[0].summary.distance) : 0
+            })
             const deviceData = {
                 device: d,
-                summary: summary[0],
+                summary: summary,
             }
             devicesResult.push(deviceData)
         }
@@ -144,7 +202,7 @@ function processDevices(devices, data, trips) {
     return devicesResult
 }
 
-function processDrivers(drivers, data) {
+function processDrivers(from, to, drivers, data) {
     console.log(data)
     const driversResult = []
     drivers.forEach(d => {
@@ -152,12 +210,32 @@ function processDrivers(drivers, data) {
         if (trips.length > 0) {
             const driverData = {
                 driver: d,
-                summary: {
+                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)))
+
+                    driverData.summary.push({
+                        date: 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 > 0 ? Math.round(tripsByDay.reduce((a, b) => a + b.averageSpeed, 0) / tripsByDay.length) : 0,
+                    })
+                }
+            } 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),
-                },
+                })
             }
             driversResult.push(driverData)
         }
@@ -166,202 +244,456 @@ function processDrivers(drivers, data) {
     return driversResult
 }
 
-function exportActivityReportToPDF(userData, reportData) {
+async function exportActivityReportToPDF(userData, reportData) {
     console.log('Export to PDF')
-
     const lang = userData.user.attributes.lang
     const translations = messages[lang] ? messages[lang] : messages['en-GB']
 
-    const headers = []
-    if(userData.byDriver) {
-        headers.push(translations.report.driver,
-            translations.report.distance,
-            translations.report.speed + ' ' + translations.report.avgSpeed + ' (Km/h)',
-            translations.report.speed + ' ' + translations.report.maxSpeed + ' (Km/h)',
-            translations.report.driverHours)
-    } else {
-        headers.push(translations.report.name,
-            translations.report.group,
-            translations.report.distance,
-            translations.report.start + ' ' + translations.report.odometer,
-            translations.report.end + ' ' + translations.report.odometer,
-            translations.report.speed + ' ' + translations.report.avgSpeed + ' (Km/h)',
-            translations.report.speed + ' ' + translations.report.maxSpeed + ' (Km/h)',
-            translations.report.engineHours,
-            translations.report.spentFuel)
-    }
     if (reportData.devices || reportData.drivers) {
-        const doc = new jsPDF.jsPDF('l');
-        doc.setFontSize(14)
-        doc.text(translations.report.titleActivityReport, 15, 15 )
-
-        let data = []
-        doc.setFontSize(10)
-        doc.text(new Date(reportData.from).toLocaleString() + ' - ' + new Date(reportData.to).toLocaleString(), 20, 30 )
-        if(userData.byDriver) {
-            reportData.drivers.forEach(d => {
-                const temp = [
-                    d.driver.name,
-                    Number((d.summary.distance / 1000).toFixed(2)),
-                    Math.round(d.summary.averageSpeed * 1.85200),
-                    Math.round(d.summary.maxSpeed * 1.85200),
-                    convertMS(d.summary.engineHours)
-                ]
-                data.push(temp)
-            })
+        const doc = new jsPDF.jsPDF('l')
+        await headerFromUser(doc, translations.report.titleActivityReport, userData.user)
+
+        if(userData.groupByDay && userData.byDriver) {
+            exportActivityReportToPDF_Driver_GroupByDay(doc, translations, reportData)
+        } else if(userData.groupByDay) {
+            exportActivityReportToPDF_Vehicle_GroupByDay(doc, translations, reportData)
+        } else if(userData.byDriver) {
+            exportActivityReportToPDF_Driver(doc, translations, reportData)
         } else {
-            reportData.devices.forEach(d => {
-                const group = userData.groups.find(g => d.device.groupId === g.id)
-
-                const temp = [
-                    d.summary.deviceName,
-                    group ? group.name : '',
-                    Number((d.summary.distance / 1000).toFixed(2)),
-                    Number((d.summary.startOdometer / 1000).toFixed(2)),
-                    Number((d.summary.endOdometer / 1000).toFixed(2)),
-                    Math.round(d.summary.averageSpeed * 1.85200),
-                    Math.round(d.summary.maxSpeed * 1.85200),
-                    convertMS(d.summary.engineHours),
-                    d.summary.convertedSpentFuel >= 0 ? d.summary.convertedSpentFuel : 0,
-                ]
-                data.push(temp)
-            })
+            exportActivityReportToPDF_Vehicle(doc, translations, reportData)
         }
 
-        const footValues = []
-        if(userData.byDriver) {
-            footValues.push(
-                'Total:' + reportData.drivers.length,
-                (reportData.drivers.reduce((a, b) => a + b.summary.distance, 0)/1000).toFixed(0),
-                getSumAvgSpeed(reportData.drivers),
-                getSumMaxSpeed(reportData.drivers),
-                convertMS(reportData.drivers.reduce((a, b) => a + b.summary.engineHours, 0)),
-            )
-        } else {
-            footValues.push(
-                'Total:' + reportData.devices.length,
-                '',
-                (reportData.devices.reduce((a, b) => a + b.summary.distance, 0)/1000).toFixed(0),
-                '','',
-                getSumAvgSpeed(reportData.devices),
-                getSumMaxSpeed(reportData.devices),
-                convertMS(reportData.devices.reduce((a, b) => a + b.summary.engineHours, 0)),
-                getSumSpentFuel(reportData.devices)
-            )
+        return doc
+    }
+}
+
+function exportActivityReportToPDF_Driver(doc, translations, reportData) {
+    const headers = [translations.report.driver,
+        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(new Date(reportData.from).toLocaleString() + ' - ' + new Date(reportData.to).toLocaleString(), 20, 30)
+
+    const data = []
+    reportData.drivers.forEach(d => {
+        const temp = [
+            d.driver.name,
+            Number((d.summary[0].distance / 1000).toFixed(2)),
+            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),
+        getSumMaxSpeed(reportData.drivers),
+        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 exportActivityReportToPDF_Vehicle(doc, translations, reportData) {
+    const headers = [translations.report.vehicle,
+        translations.report.group,
+        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(new Date(reportData.from).toLocaleString() + ' - ' + new Date(reportData.to).toLocaleString(), 20, 30)
+
+    const data = []
+    reportData.devices.forEach(d => {
+        const group = userData.groups.find(g => d.device.groupId === g.id)
+
+        const temp = [
+            d.summary[0].deviceName,
+            group ? group.name : '',
+            Number((d.summary[0].distance / 1000).toFixed(2)),
+            Number((d.summary[0].startOdometer / 1000).toFixed(2)),
+            Number((d.summary[0].endOdometer / 1000).toFixed(2)),
+            Math.round(d.summary[0].averageSpeed * 1.85200),
+            Math.round(d.summary[0].maxSpeed * 1.85200),
+            convertMS(d.summary[0].engineHours),
+            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),
+        getSumMaxSpeed(reportData.devices),
+        convertMS(reportData.devices.reduce((a, b) => a + b.summary[0].engineHours, 0)),
+        getSumSpentFuel(reportData.devices)]
+
+    const style = getStyle(getUserPartner(userData.user))
+    addTable(doc, headers, data, footValues, style, 35)
+}
+
+function exportActivityReportToPDF_Vehicle_GroupByDay(doc, translations, reportData) {
+    const headers = [translations.report.date,
+        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) {
+        const name = userData.byDriver ? d.driver.name : d.device.name
+        const group = userData.byDriver ? userData.groups.find(g => g.drivers.includes(d.id)) : userData.groups.find(g => d.device.groupId === g.id)
+
+        let space = index === 0 ? 8 : 0
+        if(index){
+            doc.addPage()
         }
 
-        doc.autoTable({
-            head: [headers],
-            body: data,
-            foot: [footValues],
-            showFoot: 'lastPage',
-            headStyles: {
-                fillColor: reportStyle.pdfHeaderColor,
-                textColor: reportStyle.pdfHeaderTextColor
-            },
-            bodyStyles: {
-                fillColor: reportStyle.pdfBodyColor,
-                textColor: reportStyle.pdfBodyTextColor
-            },
-            footStyles: {
-                fillColor: reportStyle.pdfFooterColor,
-                textColor: reportStyle.pdfFooterTextColor
-            },
-            startY: 35 });
+        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)
+        }
 
-        return doc
+        const data = []
+        d.summary.forEach(s => {
+            const temp = [
+                new Date(s.date).toLocaleDateString() + ' - ' + weekDays[s.date.getDay()],
+                Number((s.distance / 1000).toFixed(2)),
+                Number((s.startOdometer / 1000).toFixed(2)),
+                Number((s.endOdometer / 1000).toFixed(2)),
+                Math.round(s.averageSpeed * 1.85200),
+                Math.round(s.maxSpeed * 1.85200),
+                convertMS(s.engineHours),
+                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),
+            getSumMaxSpeed(d.summary),
+            convertMS(d.summary.reduce((a, b) => a + b.engineHours, 0)),
+            getSumSpentFuel(d.summary)]
+
+        const style = getStyle(getUserPartner(userData.user))
+        addTable(doc, headers, data, footValues, style, 40)
+    })
+}
+
+function exportActivityReportToExcel_Vehicle_GroupByDay(settings, translations, reportData) {
+    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.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: s.deviceName,
+                    group: group ? group.name : '',
+                    date: new Date(s.date).toLocaleDateString(),
+                    weekday: weekDays[s.date.getDay()],
+                    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: s.convertedSpentFuel >= 0 ? s.convertedSpentFuel : 0
+                }
+            }))
+        })
+        console.log(data)
+        return {
+            headers,
+            data,
+            settings
+        }
     }
 }
 
-function exportActivityReportToExcel(userData, reportData) {
-    console.log('Export to Excel')
+function exportActivityReportToPDF_Driver_GroupByDay(doc, translations, reportData) {
+    const headers = [translations.report.date,
+        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))
+
+        let space = index === 0 ? 8 : 0
+        if(index){
+            doc.addPage()
+        }
 
-    const lang = userData.user.attributes.lang
-    const translations = messages[lang] ? messages[lang] : messages['en-GB']
+        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 settings = {
-        sheetName: translations.report.titleActivityReport, // The name of the sheet
-        fileName: fileName // The name of the spreadsheet
-    }
+        const data = []
+        d.summary.forEach(s => {
+            const temp = [
+                new Date(s.date).toLocaleDateString() + ' - ' + weekDays[s.date.getDay()],
+                Number((s.distance / 1000).toFixed(2)),
+                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),
+            getSumMaxSpeed(d.summary),
+            convertMS(d.summary.reduce((a, b) => a + b.engineHours, 0))]
+
+        const style = getStyle(getUserPartner(userData.user))
+        addTable(doc, headers, data, footValues, style, 40)
+    })
+}
 
-    const headers = []
+function exportActivityReportToExcel_Driver_GroupByDay(settings, translations, reportData) {
+    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.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
+    ]
 
-    if(userData.byDriver) {
-        headers.push(
-            {label: translations.report.driver, value: 'driver'},
-            {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'})
-    } else {
-        headers.push(
-            {label: translations.report.vehicle, value: 'name'},
-            {label: translations.report.group, value: 'group'},
-            {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'})
+    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[s.date.getDay()],
+                    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)
+                }
+            }))
+        })
+        console.log(data)
+        return {
+            headers,
+            data,
+            settings
+        }
     }
+}
+
+function exportActivityReportToExcel_Driver(settings, translations, reportData) {
+    const headers = [{label: translations.report.driver, value: 'driver'},
+        {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(userData.byDriver){
-        if (reportData.drivers) {
-            reportData.drivers.forEach(d => {
-                data = data.concat([{
-                    driver: d.driver.name,
-                    distance: Number((d.summary.distance / 1000).toFixed(0)),
-                    avgSpeed: Math.round(d.summary.averageSpeed * 1.85200),
-                    maxSpeed: Math.round(d.summary.maxSpeed * 1.85200),
-                    engineHours: convertMS(d.summary.engineHours)
-                }])
-            })
-            console.log(data)
-            return {
-                headers,
-                data,
-                settings
-            }
+    if (reportData.drivers) {
+        reportData.drivers.forEach(d => {
+            data = data.concat([{
+                driver: d.driver.name,
+                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)
+            }])
+        })
+        console.log(data)
+        return {
+            headers,
+            data,
+            settings
         }
-    } else {
-        if (reportData.devices) {
-            reportData.devices.forEach(d => {
-                const group = userData.groups.find(g => d.device.groupId === g.id)
+    }
+}
 
-                data = data.concat([{
-                    name: d.summary.deviceName,
-                    group: group ? group.name : '',
-                    distance: Number((d.summary.distance / 1000).toFixed(0)),
-                    startOdometer: Number((d.summary.startOdometer / 1000).toFixed(0)),
-                    endOdometer: Number((d.summary.endOdometer / 1000).toFixed(0)),
-                    avgSpeed: Math.round(d.summary.averageSpeed * 1.85200),
-                    maxSpeed: Math.round(d.summary.maxSpeed * 1.85200),
-                    engineHours: convertMS(d.summary.engineHours),
-                    spentFuel: d.summary.convertedSpentFuel >= 0 ? d.summary.convertedSpentFuel : 0,
-                }])
-            })
-            console.log(data)
-            return {
-                headers,
-                data,
-                settings
-            }
+function exportActivityReportToExcel_Vehicle(settings, translations, reportData) {
+    const headers = [{label: translations.report.vehicle, value: 'name'},
+        {label: translations.report.group, value: 'group'},
+        {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)
+
+            data = data.concat([{
+                name: d.summary[0].deviceName,
+                group: group ? group.name : '',
+                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: d.summary[0].convertedSpentFuel >= 0 ? d.summary[0].convertedSpentFuel : 0,
+            }])
+        })
+        console.log(data)
+        return {
+            headers,
+            data,
+            settings
         }
     }
 }
 
+function exportActivityReportToExcel(reportUserData, reportData) {
+    console.log('Export to Excel')
+    userData = reportUserData
+    const lang = userData.user.attributes.lang
+    const translations = messages[lang] ? messages[lang] : messages['en-GB']
+
+    const settings = {
+        sheetName: translations.report.titleActivityReport, // The name of the sheet
+        fileName: fileName // The name of the spreadsheet
+    }
+
+    if(userData.groupByDay && userData.byDriver){
+        return exportActivityReportToExcel_Driver_GroupByDay(settings, translations, reportData)
+    } else if(userData.groupByDay){
+        return exportActivityReportToExcel_Vehicle_GroupByDay(settings, translations, reportData)
+    } else if(userData.byDriver){
+        return exportActivityReportToExcel_Driver(settings, translations, reportData)
+    } else {
+        return exportActivityReportToExcel_Vehicle(settings, translations, reportData)
+    }
+}
+
 function getSumAvgSpeed(data){
     const values = data.map(item => {
-        return Math.round(item.summary.averageSpeed * 1.85200)
-    })
-    return Math.round((values.reduce((a, b) => a + b, 0)) / data.length)
+        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){
     const values = data.map(item => {
-        return item.summary.maxSpeed
+        if(userData.groupByDay){
+            return item.maxSpeed
+        } else {
+            return item.summary[0].maxSpeed
+        }
     })
     const max = values.reduce(function (a, b) {
         return Math.max(a, b);
@@ -371,7 +703,11 @@ function getSumMaxSpeed(data){
 
 function getSumSpentFuel(data){
     const values = data.map(item => {
-        return item.summary.convertedSpentFuel >= 0 ? item.summary.convertedSpentFuel : 0
+        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)
 }