fleetmap-reports 1.0.678 → 1.0.680

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fleetmap-reports",
-  "version": "1.0.678",
+  "version": "1.0.680",
   "description": "",
   "main": "src/index.js",
   "scripts": {

package/src/zone-report.js

@@ -1,4 +1,3 @@
-const moment = require('moment')
 const automaticReports = require('./automaticReports')
 const {
   convertMS, convertToLocaleString, getTranslations, convertToFeature, convertPositionToFeature,
@@ -8,7 +7,7 @@ const {
 const jsPDF = require('jspdf')
 require('jspdf-autotable')
 const traccarHelper = require('./util/traccar')
-const { headerFromUser } = require('./util/pdfDocument')
+const { headerFromUser, addTable } = require('./util/pdfDocument')
 const { getStyle } = require('./reportStyle')
 const { getUserPartner } = require('fleetmap-partners')
 const { devicesToProcess } = require('./util/device')
@@ -96,30 +95,30 @@ async function processDevices (from, to, devices, userData, data) {
     const alerts = data.alerts.filter(t => t.deviceId === d.id)
     const deviceRoute = data.route.filter(p => p.deviceId === d.id)
 
-    const zoneInOutData = userData.groupByDay
-      ? analyseAlertsGroupGeofences(alerts, deviceRoute, from, to)
-      : analyseAlerts(alerts, deviceRoute, userData)
+    const zoneInOutData = analyseAlerts(alerts, deviceRoute, userData, from, to).filter(d => !userData.onlyWithStop || d.stopped)
 
-    if (zoneInOutData.length > 0) {
-      const result = userData.onlyWithStop ? zoneInOutData.filter(d => d.stopped) : zoneInOutData
+    if (userData.groupByDay) {
+      const dates = getDates(from, to)
 
-      if (userData.groupByDay) {
-        const dates = getDates(from, to)
+      const geofencesData = []
+      for (const geofence of userData.geofences) {
+        const filteredByGeofence = zoneInOutData.filter(d => d.geofenceId === geofence.id)
 
         const dataByDay = []
         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 zoneInOutDayData = result.filter(z => (!z.inTime || (new Date(z.inTime.fixTime) < toByDay)) &&
-              (!z.outTime || (new Date(z.outTime.fixTime) > fromByDay)))
+          const dayRoute = deviceRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay)
+          const zoneInOutDayData = filteredByGeofence.filter(z => (!z.inTime || (new Date(z.inTime.fixTime) < toByDay)) &&
+                (!z.outTime || (new Date(z.outTime.fixTime) > fromByDay)))
 
           const firstIn = zoneInOutDayData.find(z => z.inTime && new Date(z.inTime.fixTime) > fromByDay)
           const lastOut = zoneInOutDayData.slice().reverse().find(z => z.outTime && new Date(z.outTime.fixTime) < toByDay)
 
-          let timeIn = zoneInOutDayData.length ? zoneInOutDayData.reduce((a, b) => a + (b.totalTime || 0), 0) : 0
+          let timeIn = zoneInOutDayData.length ? zoneInOutDayData.reduce((a, b) => a + (b.totalInTime || 0), 0) : 0
 
-          let distanceIn = zoneInOutDayData.length ? zoneInOutDayData.reduce((a, b) => a + (b.distanceIn || 0), 0) : 0
+          let distanceIn = zoneInOutDayData.length && dayRoute.length ? zoneInOutDayData.reduce((a, b) => a + (b.distanceIn || 0), 0) : 0
           let distanceOut = 0
           if (zoneInOutDayData.length) {
             distanceOut = zoneInOutDayData.reduce((a, b) => a + (b.distanceOut || 0), 0) - zoneInOutDayData[zoneInOutDayData.length - 1].distanceOut
@@ -132,14 +131,14 @@ async function processDevices (from, to, devices, userData, data) {
             if (!zoneInOutDayData[0].inTime || new Date(zoneInOutDayData[0].inTime.fixTime) < fromByDay) {
               const inTime = zoneInOutDayData[0].inTime ? new Date(zoneInOutDayData[0].inTime.fixTime) : from
               timeIn = timeIn - (fromByDay.getTime() - inTime.getTime())
-              const routeDayBefore = deviceRoute.filter(p => (!zoneInOutDayData[0].inTime || new Date(p.fixTime) > new Date(zoneInOutDayData[0].inTime.fixTime)) &&
-                  new Date(p.fixTime) < fromByDay)
+              const routeDayBefore = deviceRoute.filter(p => (!zoneInOutDayData[0].inTime || new Date(p.fixTime) >= new Date(zoneInOutDayData[0].inTime.fixTime)) &&
+                    new Date(p.fixTime) < fromByDay)
               distanceIn = distanceIn - calculateDistance(routeDayBefore)
             } else {
               // Add distanceOut before the first entry
               const routeOut = deviceRoute.filter(p =>
                 new Date(p.fixTime).getTime() < new Date(zoneInOutDayData[0].inTime.fixTime).getTime() &&
-                  new Date(p.fixTime).getTime() >= fromByDay.getTime()
+                    new Date(p.fixTime).getTime() >= fromByDay.getTime()
               )
               distanceOut = distanceOut + calculateDistance(routeOut)
             }
@@ -148,42 +147,47 @@ async function processDevices (from, to, devices, userData, data) {
             if (!zoneInOutDayData[zoneInOutDayData.length - 1].outTime || new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) > toByDay) {
               const outTime = zoneInOutDayData[zoneInOutDayData.length - 1].outTime ? new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) : to
               timeIn = timeIn - (outTime.getTime() - (toByDay.getTime() + 1000))
-              const routeDayAfter = deviceRoute.filter(p => new Date(p.fixTime) < outTime && new Date(p.fixTime) > toByDay)
+              const routeDayAfter = deviceRoute.filter(p => new Date(p.fixTime) <= outTime && new Date(p.fixTime) > toByDay)
               distanceIn = distanceIn - calculateDistance(routeDayAfter)
             } else {
               const routeOut = deviceRoute.filter(p =>
-                new Date(p.fixTime) > new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime).getTime() &&
-                  new Date(p.fixTime) < toByDay.getTime())
+                new Date(p.fixTime) >= new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime).getTime() &&
+                    new Date(p.fixTime) < toByDay.getTime())
               distanceOut = distanceOut + calculateDistance(routeOut)
             }
           }
-
           dataByDay.push({
             date,
             firstIn: firstIn ? firstIn.inTime.fixTime : undefined,
             lastOut: lastOut ? lastOut.outTime.fixTime : undefined,
-            distanceIn,
+            distanceIn: distanceIn > 0 ? distanceIn : 0,
             distanceOut,
-            timeIn,
-            timeOut: (24 * 60 * 60 * 1000) - timeIn
+            totalInTime: timeIn,
+            totalOutTime: (24 * 60 * 60 * 1000) - timeIn
           })
         }
 
+        geofencesData.push({
+          geofenceName: geofence.name,
+          days: dataByDay
+        })
+      }
+
+      devicesResult.push({
+        device: d,
+        from,
+        to,
+        groupByDay: true,
+        geofences: geofencesData
+      })
+    } else {
+      if (zoneInOutData.length > 0) {
         devicesResult.push({
           device: d,
           from,
           to,
-          days: dataByDay
+          geofences: zoneInOutData
         })
-      } else {
-        if (result.length > 0) {
-          devicesResult.push({
-            device: d,
-            from,
-            to,
-            geofences: result
-          })
-        }
       }
     }
   }
@@ -191,99 +195,7 @@ async function processDevices (from, to, devices, userData, data) {
   return devicesResult
 }
 
-function analyseAlertsGroupGeofences (alerts, deviceRoute, from, to) {
-  const zoneInOutData = []
-  const zoneInData = { inCount: 0 }
-
-  alerts.forEach(a => {
-    if (!a.position) {
-      return
-    }
-    if (a.type === 'geofenceEnter') {
-      if (zoneInData.inTime) {
-        zoneInData.inCount++
-      } else {
-        zoneInData.inTime = a
-        zoneInData.inCount = 1
-      }
-      return
-    }
-    if (a.type === 'geofenceExit') {
-      if (zoneInData.inCount === 0) {
-        zoneInOutData.splice(0, zoneInOutData.length)
-        const totalInTime = new Date(a.position.fixTime).getTime() - from.getTime()
-        const outDate = new Date(a.position.fixTime).getTime()
-        const routeIn = deviceRoute.filter(p =>
-          new Date(p.fixTime).getTime() >= from &&
-            new Date(p.fixTime).getTime() < outDate
-        )
-        const routeAfterOut = deviceRoute.filter(p =>
-          new Date(p.fixTime).getTime() >= outDate &&
-            new Date(p.fixTime).getTime() < getNextIn(outDate, alerts, undefined, deviceRoute)
-        )
-        const distanceOut = calculateDistance(routeAfterOut)
-        zoneInOutData.push({
-          outTime: a.position,
-          totalTime: totalInTime,
-          distanceIn: calculateDistance(routeIn),
-          distanceOut
-        })
-        return
-      }
-
-      zoneInData.inCount--
-      if (zoneInData.inCount === 0) {
-        const totalInTime = new Date(a.position.fixTime).getTime() - new Date(zoneInData.inTime.position.fixTime).getTime()
-        const inDate = new Date(zoneInData.inTime.position.fixTime).getTime()
-        const outDate = new Date(a.position.fixTime).getTime()
-        const routeAfterOut = deviceRoute.filter(p =>
-          new Date(p.fixTime).getTime() >= outDate &&
-            new Date(p.fixTime).getTime() < getNextIn(outDate, alerts, undefined, deviceRoute)
-        )
-        const distanceOut = calculateDistance(routeAfterOut)
-        const routeIn = deviceRoute.filter(p =>
-          new Date(p.fixTime).getTime() >= inDate &&
-            new Date(p.fixTime).getTime() < outDate
-        )
-        zoneInOutData.push({
-          inTime: zoneInData.inTime.position,
-          outTime: a.position,
-          totalTime: totalInTime,
-          distanceIn: calculateDistance(routeIn),
-          distanceOut
-        })
-        zoneInData.inTime = undefined
-      }
-    }
-  })
-
-  if (zoneInData.inTime) {
-    const totalInTime = to.getTime() - new Date(zoneInData.inTime.position.fixTime).getTime()
-    const routeIn = deviceRoute.filter(p =>
-      new Date(p.fixTime).getTime() >= new Date(zoneInData.inTime.position.fixTime).getTime() &&
-        new Date(p.fixTime).getTime() < to.getTime()
-    )
-    zoneInOutData.push({
-      inTime: zoneInData.inTime.position,
-      distanceIn: calculateDistance(routeIn),
-      distanceOut: 0,
-      totalTime: totalInTime
-    })
-  }
-
-  if (!zoneInOutData.length) {
-    const geofenceIn = alerts.find(a => a.type === 'geofenceIn')
-    zoneInOutData.push({
-      distanceIn: geofenceIn ? calculateDistance(deviceRoute) : 0,
-      distanceOut: !geofenceIn ? calculateDistance(deviceRoute) : 0,
-      totalTime: to.getTime() - from.getTime()
-    })
-  }
-
-  return zoneInOutData
-}
-
-function analyseAlerts (alerts, deviceRoute, userData) {
+function analyseAlerts (alerts, deviceRoute, userData, from, to) {
   const zoneInOutData = []
   const zoneInData = {}
 
@@ -301,13 +213,15 @@ function analyseAlerts (alerts, deviceRoute, userData) {
         return
       }
       const outDate = new Date(a.position.fixTime).getTime()
+      const nextIn = getNextIn(outDate, alerts, a.geofenceId, deviceRoute)
       const routeAfterOut = deviceRoute.filter(p =>
         new Date(p.fixTime).getTime() >= outDate &&
-          new Date(p.fixTime).getTime() < getNextIn(outDate, alerts, a.geofenceId, deviceRoute)
+          new Date(p.fixTime).getTime() < nextIn
       )
+      const totalOutTime = nextIn - outDate
       const distanceOut = calculateDistance(routeAfterOut)
       if (zoneInData[a.geofenceId]) {
-        const totalInTime = moment(a.position.fixTime).diff(moment(zoneInData[a.geofenceId].position.fixTime), 'seconds')
+        const totalInTime = new Date(a.position.fixTime).getTime() - new Date(zoneInData[a.geofenceId].position.fixTime).getTime()
         const inDate = new Date(zoneInData[a.geofenceId].position.fixTime).getTime()
         const routeIn = deviceRoute.filter(p =>
           new Date(p.fixTime).getTime() >= inDate &&
@@ -316,18 +230,29 @@ function analyseAlerts (alerts, deviceRoute, userData) {
         zoneInOutData.push({
           inTime: zoneInData[a.geofenceId].position,
           outTime: a.position,
-          totalTime: totalInTime,
+          totalInTime,
+          totalOutTime,
           distanceIn: calculateDistance(routeIn),
           distanceOut,
           geofenceName: geofence.name,
+          geofenceId: geofence.id,
           stopped: routeIn.filter(p => !p.attributes.ignition).length > 0,
           driverName: zoneInData[a.geofenceId].position.driverName
         })
         zoneInData[a.geofenceId] = null
       } else {
+        const totalInTime = new Date(a.position.fixTime).getTime() - from.getTime()
+        const routeIn = deviceRoute.filter(p =>
+          new Date(p.fixTime).getTime() >= from.getTime() &&
+            new Date(p.fixTime).getTime() < outDate
+        )
         zoneInOutData.push({
           outTime: a.position,
           geofenceName: geofence.name,
+          geofenceId: geofence.id,
+          totalInTime,
+          totalOutTime,
+          distanceIn: calculateDistance(routeIn),
           driverName: '',
           distanceOut
         })
@@ -339,15 +264,32 @@ function analyseAlerts (alerts, deviceRoute, userData) {
     if (zoneInData[i]) {
       const geofence = userData.geofences.find(g => g.id === zoneInData[i].geofenceId)
       if (geofence) {
+        const totalInTime = to.getTime() - new Date(zoneInData[i].position.fixTime).getTime()
+        const routeIn = deviceRoute.filter(p =>
+          new Date(p.fixTime).getTime() >= new Date(zoneInData[i].position.fixTime).getTime() &&
+            new Date(p.fixTime).getTime() < to.getTime()
+        )
         zoneInOutData.push({
           inTime: zoneInData[i].position,
+          totalInTime,
+          distanceIn: calculateDistance(routeIn),
           geofenceName: geofence.name,
+          geofenceId: geofence.id,
           driverName: zoneInData[i].position.driverName
         })
       }
     }
   }
 
+  if (!zoneInOutData.length && userData.groupByDay) {
+    const geofenceIn = alerts.find(a => a.type === 'geofenceIn')
+    zoneInOutData.push({
+      distanceIn: geofenceIn ? calculateDistance(deviceRoute) : 0,
+      distanceOut: !geofenceIn ? calculateDistance(deviceRoute) : 0,
+      totalTime: to.getTime() - from.getTime()
+    })
+  }
+
   return zoneInOutData
 }
 
@@ -437,92 +379,67 @@ async function exportZoneReportToPDF (userData, reportData) {
         translations.report.driver
       ]
   if (reportData.devices) {
-    let first = true
     // eslint-disable-next-line new-cap
     const doc = new jsPDF.jsPDF('l')
     await headerFromUser(doc, translations.report.titleZoneReport, userData.user)
+    const style = getStyle(getUserPartner(userData.user))
+    let space = 0
 
-    reportData.devices.forEach(d => {
-      const data = []
-      const name = deviceName(d.device)
-      const group = userData.groups.find(g => d.device.groupId === g.id)
-
-      let space = 0
-      if (!first) {
-        doc.addPage()
-      } else {
-        first = false
-        space = 10
-      }
-      doc.setFontSize(13)
-      doc.text(name, 20, space + 20)
-      doc.setFontSize(11)
-      doc.text(group ? translations.report.group + ': ' + group.name : '', 200, space + 20)
-      doc.text(convertToLocaleString(d.from, lang, timezone) + ' - ' + convertToLocaleString(d.to, lang, timezone), 20, space + 25)
-      userData.groupByDay
-        ? d.days.forEach(a => {
-          const temp = [
-            convertToLocaleDateString(a.date, userData.user.attributes.lang, userData.user.attributes.timezone),
-            a.firstIn ? convertToLocaleTimeString(a.firstIn, userData.user.attributes.lang, userData.user.attributes.timezone) : '-',
-            a.lastOut ? convertToLocaleTimeString(a.lastOut, userData.user.attributes.lang, userData.user.attributes.timezone) : '-',
-            a.distanceIn && a.distanceIn.toLocaleString(this.user.attributes.lang, { maximumFractionDigits: 2 }),
-            convertMS(a.timeIn, false),
-            a.distanceOut && a.distanceOut.toLocaleString(this.user.attributes.lang, { maximumFractionDigits: 2 }),
-            convertMS(a.timeOut, false)
+    reportData.devices.forEach((d, index) => {
+      if (userData.groupByDay) {
+        d.geofences.forEach((g, i) => {
+          const data = []
+          space = reportHeader(index === 0 && i === 0, doc, translations, d, lang, timezone, userData, g)
+          g.days.forEach(a => {
+            const temp = [
+              convertToLocaleDateString(a.date, lang, timezone),
+              a.firstIn ? convertToLocaleTimeString(a.firstIn, lang, timezone) : '-',
+              a.lastOut ? convertToLocaleTimeString(a.lastOut, lang, timezone) : '-',
+              a.distanceIn ? a.distanceIn.toLocaleString(lang, { maximumFractionDigits: 2 }) : 0,
+              convertMS(a.totalInTime, false),
+              a.distanceOut ? a.distanceOut.toLocaleString(lang, { maximumFractionDigits: 2 }) : 0,
+              convertMS(a.totalOutTime, false)
+            ]
+            data.push(temp)
+          })
+          const footer = [
+            'Total:' + g.days.length,
+            '', '',
+            g.days.reduce((a, b) => a + (b.distanceIn ? b.distanceIn : 0), 0).toLocaleString(lang, { maximumFractionDigits: 2 }),
+            '',
+            g.days.reduce((a, b) => a + (b.distanceOut ? b.distanceOut : 0), 0).toLocaleString(lang, { maximumFractionDigits: 2 })
           ]
-          data.push(temp)
+          addTable(doc, headers, data, footer, style, space + 40, {
+            3: { halign: 'right' },
+            4: { halign: 'right' },
+            5: { halign: 'right' },
+            6: { halign: 'right' }
+          })
         })
-        : d.geofences.forEach(a => {
+      } else {
+        const data = []
+        space = reportHeader(index === 0, doc, translations, d, lang, timezone, userData)
+        d.geofences.forEach(a => {
           const temp = [
             geofenceEnter(userData.user, a),
             geofenceExit(userData.user, a),
             a.stopped ? translations.report.yes : translations.report.no,
-            a.totalTime ? convertMS(a.totalTime * 1000, true) : '',
-            a.distanceIn && a.distanceIn.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 2 }),
-            a.distanceOut && a.distanceOut.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 2 }),
+            convertMS(a.totalInTime, true),
+            a.distanceIn ? a.distanceIn.toLocaleString(lang, { maximumFractionDigits: 2 }) : 0,
+            a.distanceOut ? a.distanceOut.toLocaleString(lang, { maximumFractionDigits: 2 }) : 0,
             a.geofenceName,
             a.driverName
           ]
           data.push(temp)
         })
-
-      const footValues = userData.groupByDay
-        ? [
-            'Total:' + d.days.length,
-            '', '',
-            d.days.reduce((a, b) => a + b.distanceIn, 0).toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 2 }),
-            '',
-            d.days.reduce((a, b) => a + b.distanceOut, 0).toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 2 })
-          ]
-        : [
-            'Total:' + d.geofences.length
-          ]
-
-      const style = getStyle(getUserPartner(userData.user))
-      doc.autoTable({
-        head: [headers],
-        body: data,
-        foot: [footValues],
-        showFoot: 'lastPage',
-        headStyles: {
-          fillColor: style.pdfHeaderColor,
-          textColor: style.pdfHeaderTextColor,
-          fontSize: 10
-        },
-        bodyStyles: {
-          fillColor: style.pdfBodyColor,
-          textColor: style.pdfBodyTextColor,
-          fontSize: 8
-        },
-        footStyles: {
-          fillColor: style.pdfFooterColor,
-          textColor: style.pdfFooterTextColor,
-          fontSize: 9
-        },
-        startY: space + 35
-      })
+        const footer = ['Total:' + d.geofences.length]
+        addTable(doc, headers, data, footer, style, space + 35, {
+          3: { halign: 'right' },
+          4: { halign: 'right' },
+          5: { halign: 'right' }
+        })
+      }
     })
-
     return doc
   }
 }
@@ -538,21 +455,22 @@ function exportZoneReportToExcel (userData, reportData) {
   }
   const headers = userData.groupByDay
     ? [
+        { label: translations.report.geofence, value: 'zone' },
         { label: translations.report.vehicle, value: 'name' },
         { label: translations.report.date, value: 'date' },
         { label: translations.report.firstIn, value: 'firstIn' },
         { label: translations.report.lastOut, value: 'lastOut' },
         { label: translations.report.distanceIn || 'Kms Adentro', value: 'distanceIn' },
-        { label: translations.report.timeIn, value: 'timeIn' },
+        { label: translations.report.timeIn, value: 'totalInTime' },
         { label: translations.report.distanceOut || 'Kms Afuera', value: 'distanceOut' },
-        { label: translations.report.timeOut, value: 'timeOut' }
+        { label: translations.report.timeOut, value: 'totalOutTime' }
       ]
     : [
         { label: translations.report.vehicle, value: 'name' },
         { label: translations.report.enter, value: 'enter' },
         { label: translations.report.exit, value: 'exit' },
         { label: translations.report.stopped, value: 'stopped' },
-        { label: translations.report.duration, value: 'duration' },
+        { label: translations.report.duration, value: 'totalInTime' },
         { label: translations.report.distanceIn || 'Kms Adentro', value: 'distanceIn' },
         { label: translations.report.distanceOut || 'Kms Afuera', value: 'distanceOut' },
         { label: translations.report.geofence, value: 'zone' },
@@ -561,33 +479,20 @@ function exportZoneReportToExcel (userData, reportData) {
   let data = []
   if (reportData.devices) {
     reportData.devices.forEach(d => {
-      data = userData.groupByDay
-        ? data.concat(d.days.map(a => {
-          return {
-            name: d.device.name,
-            date: convertToLocaleDateString(a.date, userData.user.attributes.lang, userData.user.attributes.timezone),
-            firstIn: a.firstIn ? convertToLocaleTimeString(a.firstIn, userData.user.attributes.lang, userData.user.attributes.timezone) : '-',
-            lastOut: a.lastOut ? convertToLocaleTimeString(a.lastOut, userData.user.attributes.lang, userData.user.attributes.timezone) : '-',
-            distanceIn: a.distanceIn && a.distanceIn.toLocaleString(this.user.attributes.lang, { maximumFractionDigits: 2 }),
-            distanceOut: a.distanceOut && a.distanceOut.toLocaleString(this.user.attributes.lang, { maximumFractionDigits: 2 }),
-            timeIn: convertMS(a.timeIn),
-            timeOut: convertMS(a.timeOut)
-          }
-        }))
-        : data.concat(d.geofences.map(a => {
-          return {
-            ...a,
-            name: d.device.name,
-            enter: geofenceEnter(userData.user, a),
-            exit: geofenceExit(userData.user, a),
-            stopped: a.stopped ? translations.report.yes : translations.report.no,
-            duration: a.totalTime ? convertMS(a.totalTime * 1000, true) : '',
-            distanceIn: a.distanceIn && a.distanceIn.toLocaleString(this.user.attributes.lang, { maximumFractionDigits: 2 }),
-            distanceOut: a.distanceOut && a.distanceOut.toLocaleString(this.user.attributes.lang, { maximumFractionDigits: 2 }),
-            zone: a.geofenceName,
-            driver: a.driverName
-          }
+      if (userData.groupByDay) {
+        d.geofences.forEach(g => {
+          data = data.concat([{ zone: g.geofenceName }])
+          data = data.concat(g.days.map(a => {
+            return getColumns(d, a, userData, translations)
+          }))
+          data = data.concat([{}])
+        })
+      } else {
+        data = data.concat(d.geofences.map(a => {
+          return getColumns(d, a, userData, translations)
         }))
+        data = data.concat([{}])
+      }
     })
     return {
       headers,
@@ -597,6 +502,46 @@ function exportZoneReportToExcel (userData, reportData) {
   }
 }
 
+function reportHeader (first, doc, translations, device, lang, timezone, userData, geofence) {
+  const name = deviceName(device.device)
+  const group = userData.groups.find(g => device.device.groupId === g.id)
+
+  const space = first ? 8 : 0
+  if (!first) {
+    doc.addPage()
+  }
+
+  doc.setFontSize(13)
+  doc.text(name, 20, space + 20)
+  doc.setFontSize(11)
+  doc.text(group ? translations.report.group + ': ' + group.name : '', 200, space + 20)
+  doc.text(convertToLocaleString(device.from, lang, timezone) + ' - ' + convertToLocaleString(device.to, lang, timezone), 20, space + 25)
+  if (userData.groupByDay) {
+    doc.text(translations.report.geofence + ': ' + geofence.geofenceName, 20, space + 30)
+  }
+
+  return space
+}
+
+function getColumns (device, data, userData, translations) {
+  return {
+    ...data,
+    name: device.device.name,
+    enter: geofenceEnter(userData.user, data),
+    exit: geofenceExit(userData.user, data),
+    stopped: data.stopped ? translations.report.yes : translations.report.no,
+    date: convertToLocaleDateString(data.date, userData.user.attributes.lang, userData.user.attributes.timezone),
+    firstIn: data.firstIn ? convertToLocaleTimeString(data.firstIn, userData.user.attributes.lang, userData.user.attributes.timezone) : '-',
+    lastOut: data.lastOut ? convertToLocaleTimeString(data.lastOut, userData.user.attributes.lang, userData.user.attributes.timezone) : '-',
+    distanceIn: data.distanceIn ? data.distanceIn.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 2 }) : 0,
+    distanceOut: data.distanceOut ? data.distanceOut.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 2 }) : 0,
+    totalInTime: convertMS(data.totalInTime, !userData.groupByDay),
+    totalOutTime: convertMS(data.totalOutTime, !userData.groupByDay),
+    zone: data.geofenceName,
+    driver: data.driverName
+  }
+}
+
 function deviceName (device) {
   return device.name + (device.attributes.license_plate ? ', ' + device.attributes.license_plate : '') + (device.model ? ', ' + device.model : '')
 }