fleetmap-reports 1.0.677 → 1.0.679

package/package.json

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

package/src/tests/zones.test.js

@@ -6,7 +6,7 @@ describe('zones', function () {
     const ellca = require('./ellca.json')
     userData.devices = userData.devices.filter(d => ellca.find(e => e === d.name))
     console.log(userData.devices.length)
-    userData.geofences = userData.geofences.filter(g => g.name === 'Geofence Ellca')
+    userData.geofences = userData.geofences.filter(g => g.name === 'Geofence Ellca 2')
     console.log(userData.geofences)
     const result = await report.zoneReport(
       new Date(Date.UTC(2022, 6, 24, 0, 0, 0, 0)),

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')
@@ -18,8 +17,8 @@ const distance = require('@turf/distance')
 const axios = require('axios')
 const { processServerSide } = require('./util')
 const { filterPositions } = require('./util/route')
-const sliceSize = 1
-const deviceChunk = 1
+const sliceSize = 100
+const deviceChunk = 5
 const fileName = 'ZoneReport'
 
 async function createZoneReport (from, to, userData, traccar) {
@@ -96,76 +95,82 @@ 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)
 
-        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 geofencesData = []
+        for (const geofence of userData.geofences) {
+          const filteredByGeofence = zoneInOutData.filter(d => d.geofenceId === geofence.id)
 
-          const zoneInOutDayData = result.filter(z => (!z.inTime || (new Date(z.inTime.fixTime) < toByDay)) &&
-              (!z.outTime || (new Date(z.outTime.fixTime) > fromByDay)))
+          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 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)
+            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)))
 
-          let timeIn = zoneInOutDayData.length ? zoneInOutDayData.reduce((a, b) => a + (b.totalTime || 0), 0) : 0
+            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 distanceIn = zoneInOutDayData.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
-          } else {
-            distanceOut = calculateDistance(deviceRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay))
-          }
+            let timeIn = zoneInOutDayData.length ? zoneInOutDayData.reduce((a, b) => a + (b.totalInTime || 0), 0) : 0
 
-          if (zoneInOutDayData.length) {
-            // Check if the first entry starts only on the day before
-            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)
-              distanceIn = distanceIn - calculateDistance(routeDayBefore)
+            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
             } 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()
-              )
-              distanceOut = distanceOut + calculateDistance(routeOut)
+              distanceOut = calculateDistance(deviceRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay))
             }
 
-            // Check if the last entry ends only on the next day
-            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)
-              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())
-              distanceOut = distanceOut + calculateDistance(routeOut)
+            if (zoneInOutDayData.length) {
+              // Check if the first entry starts only on the day before
+              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)
+                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()
+                )
+                distanceOut = distanceOut + calculateDistance(routeOut)
+              }
+
+              // Check if the last entry ends only on the next day
+              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)
+                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())
+                distanceOut = distanceOut + calculateDistance(routeOut)
+              }
             }
+            dataByDay.push({
+              date,
+              firstIn: firstIn ? firstIn.inTime.fixTime : undefined,
+              lastOut: lastOut ? lastOut.outTime.fixTime : undefined,
+              distanceIn: distanceIn > 0 ? distanceIn : 0,
+              distanceOut,
+              totalInTime: timeIn,
+              totalOutTime: (24 * 60 * 60 * 1000) - timeIn
+            })
           }
 
-          dataByDay.push({
-            date,
-            firstIn: firstIn ? firstIn.inTime.fixTime : undefined,
-            lastOut: lastOut ? lastOut.outTime.fixTime : undefined,
-            distanceIn,
-            distanceOut,
-            timeIn,
-            timeOut: (24 * 60 * 60 * 1000) - timeIn
+          geofencesData.push({
+            geofenceName: geofence.name,
+            days: dataByDay
           })
         }
 
@@ -173,117 +178,24 @@ async function processDevices (from, to, devices, userData, data) {
           device: d,
           from,
           to,
-          days: dataByDay
+          groupByDay: true,
+          geofences: geofencesData
         })
       } else {
-        if (result.length > 0) {
-          devicesResult.push({
-            device: d,
-            from,
-            to,
-            geofences: result
-          })
-        }
-      }
-    }
-  }
-
-  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
+        devicesResult.push({
+          device: d,
+          from,
+          to,
+          geofences: zoneInOutData
         })
-        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
+  return devicesResult
 }
 
-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,9 +264,17 @@ 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
         })
       }
@@ -437,92 +370,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 +446,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 +470,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 +493,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 : '')
 }