fleetmap-reports 1.0.757 → 1.0.759

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fleetmap-reports",
-  "version": "1.0.757",
+  "version": "1.0.759",
   "description": "",
   "main": "src/index.js",
   "scripts": {
@@ -34,8 +34,7 @@
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6.0.0",
-    "jest": "^27.5.0",
-    "mocha": "^10.2.0",
+    "jest": "^29.6.1",
     "webpack": "^5.51.0",
     "webpack-cli": "^4.5.0"
   },

package/src/activity-report.js

@@ -264,7 +264,6 @@ function processDevices (from, to, devices, data, userData) {
 }
 
 function processDrivers (from, to, drivers, data, userData) {
-  console.log(data)
   const driversResult = []
   drivers.forEach(d => {
     const { route, trips } = getDriverData(d, data)
@@ -351,7 +350,6 @@ function exportActivityReportToPDFDriver (doc, translations, reportData, userDat
 
   doc.setFontSize(10)
   doc.text(convertToLocaleString(reportData.from, lang, timezone) + ' - ' + convertToLocaleString(reportData.to, lang, timezone), 20, 30)
-  doc.text()
 
   const data = []
   reportData.drivers.forEach(d => {

package/src/tests/activity.test.js

@@ -0,0 +1,48 @@
+// eslint-disable-next-line no-undef
+const { getReports } = require('./index')
+const assert = require('assert')
+// eslint-disable-next-line no-undef
+describe('activity report', function () {
+  // eslint-disable-next-line no-undef
+  it('Activity by device', async () => {
+    const report = await getReports()
+    const userData = await report.getUserData()
+
+    const data = await report.activityReport(new Date(2022, 0, 1, 0, 0, 0, 0),
+      new Date(2022, 0, 31, 23, 59, 59, 0),
+      userData)
+    assert.equal(data.length, 1)
+    const device = data[0].devices.find(d => d.device.id === 22326)
+    assert.equal(device.summary[0].startOdometer, 0)
+    assert.equal(device.summary[0].distance, 0)
+    assert.equal(device.summary[0].startTime, 0)
+    assert.equal(device.summary[0].endTime, 0)
+  }, 80000)
+
+  // eslint-disable-next-line no-undef
+  it('Activity by driver', async () => {
+    const report = await getReports('felipe@codepa.com.br', process.env.password)
+    const userData = await report.getUserData()
+    userData.byDriver = true
+    const data = await report.activityReport(new Date(2023, 0, 1, 0, 0, 0, 0),
+      new Date(2023, 0, 1, 23, 59, 59, 0),
+      userData)
+    assert.equal(data.length, 1)
+    await report.activityReportToPDF(userData, data[0])
+  }, 800000)
+  // eslint-disable-next-line no-undef
+  it('Activity byDevice groupByDay', async () => {
+    const report = await getReports()
+    const userData = await report.getUserData()
+    userData.groupByDay = true
+    const data = await report.activityReport(new Date(2022, 0, 1, 0, 0, 0, 0),
+      new Date(2022, 0, 20, 23, 59, 59, 0),
+      userData)
+    assert.equal(data.length, 1)
+    const device = data[0].devices.find(d => d.device.id === 22326)
+    assert.equal(device.summary[5].startOdometer, 0)
+    assert.equal(device.summary[5].distance, 0)
+    assert.equal(device.summary[5].startTime, 0)
+    assert.equal(device.summary[5].endTime, 0)
+  }, 90000)
+})

package/src/tests/index.js

@@ -16,6 +16,7 @@ axiosCookieJarSupport(axios)
 
 const getReports = async (email, password) => {
   try {
+    console.log('email / pass', process.env.email, process.env.password)
     await new SessionApi(traccarConfig, null, axios).sessionPost(email || process.env.email, password || process.env.password)
     return new Index(traccarConfig, axios, cookieJar)
   } catch (e) {

package/src/tests/index.test.js

@@ -192,36 +192,6 @@ describe('Test_Reports', function () {
     assert.equal(totalIdleTime, 16000) // Total Duration
   }, 20000)
   // eslint-disable-next-line no-undef
-  it('Activity by device', async () => {
-    const report = await getReports()
-    const userData = await report.getUserData()
-
-    const data = await report.activityReport(new Date(2022, 0, 1, 0, 0, 0, 0),
-      new Date(2022, 0, 31, 23, 59, 59, 0),
-      userData)
-    assert.equal(data.length, 1)
-    const device = data[0].devices.find(d => d.device.id === 22326)
-    assert.equal(device.summary[0].startOdometer, 122502742.59)
-    assert.equal(device.summary[0].distance, 1425532.6071218813)
-    assert.equal(device.summary[0].startTime, '2022-01-01T13:35:47.000+0000')
-    assert.equal(device.summary[0].endTime, '2022-01-31T17:36:27.000+0000')
-  }, 80000)
-  // eslint-disable-next-line no-undef
-  it('Activity byDevice groupByDay', async () => {
-    const report = await getReports()
-    const userData = await report.getUserData()
-    userData.groupByDay = true
-    const data = await report.activityReport(new Date(2022, 0, 1, 0, 0, 0, 0),
-      new Date(2022, 0, 20, 23, 59, 59, 0),
-      userData)
-    assert.equal(data.length, 1)
-    const device = data[0].devices.find(d => d.device.id === 22326)
-    assert.equal(device.summary[5].startOdometer, 122923290.95)
-    assert.equal(device.summary[5].distance, 77033.18999999762)
-    assert.equal(device.summary[5].startTime, '2022-01-06T18:35:36.000+0000')
-    assert.equal(device.summary[5].endTime, '2022-01-06T19:54:27.000+0000')
-  }, 90000)
-  // eslint-disable-next-line no-undef
   it('test allinone', async () => {
     console.log('Start')
     const reports = await getReports()

package/src/tests/performance.test.js

@@ -7,10 +7,10 @@ describe('performance', function () {
   it('performance report', async () => {
     const report = await getReports()
     const userData = await report.getUserData()
-    userData.devices = userData.devices.filter(d => d.attributes.xpert)
+    userData.devices = userData.devices.filter(d => d.id === 128270)
     const data = await createPerformanceReport(
-      new Date(Date.UTC(2023, 5, 10, 0, 0, 0, 0)),
-      new Date(Date.UTC(2023, 5, 20, 23, 59, 59, 0)),
+      new Date(Date.UTC(2023, 5, 29, 0, 0, 0, 0)),
+      new Date(Date.UTC(2023, 5, 30, 23, 59, 59, 0)),
       userData,
       report.traccar)
     console.log(data)

package/src/tests/zones.test.js

@@ -77,7 +77,7 @@ describe('zones', function () {
     userData.devices = userData.devices.filter(d => d.name === 'G-1101-E Clio')
     userData.geofences = userData.geofences.filter(g => g.name === 'baliza raio verde ' || g.name === 'baliza raio amarelo ')
     const result = await report.zoneReport(
-        new Date(Date.UTC(2023, 0, 1, 0, 0, 0, 0)),
+        new Date(Date.UTC(2023, 0, 29, 0, 0, 0, 0)),
         new Date(Date.UTC(2023, 0, 31, 23, 59, 59, 0)),
         userData)
     const first = result[0].devices[0].geofences[0]

package/src/zone-report.js

@@ -86,21 +86,12 @@ async function createZoneReport (from, to, userData, traccar) {
   return reportData
 }
 
-function getNextIn (outDate, alerts, geofenceId, deviceRoute) {
-  const next = alerts
-    .filter(a => a.type === 'geofenceEnter' && (a.geofenceId === geofenceId || !geofenceId))
-    .find(a => new Date(a.position.fixTime).getTime() > outDate)
-  return (next && next.position && new Date(next.position.fixTime).getTime()) ||
-    new Date(deviceRoute.slice(-1)[0].fixTime).getTime()
-}
-
 async function processDevices (from, to, devices, userData, data) {
   const devicesResult = []
 
   for (const d of devices) {
     const alerts = data.alerts.filter(t => t.deviceId === d.id)
     const deviceRoute = data.route.filter(p => p.deviceId === d.id)
-
     const zoneInOutData = analyseAlerts(alerts, deviceRoute, userData, from, to).filter(d => !userData.onlyWithStop || d.stopped)
 
     if (userData.groupByDay || userData.zonesByColumn) {
@@ -122,47 +113,10 @@ async function processDevices (from, to, devices, userData, data) {
           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.totalInTime || 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 || 0)
-          } else {
-            distanceOut = calculateDistance(deviceRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay))
-          }
-
-          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)
-            }
+          const timeIn = calculateTimeIn(zoneInOutDayData, fromByDay, from, toByDay, to)
+          const distanceIn = calculateDistanceIn(zoneInOutDayData, deviceRoute, dayRoute, fromByDay, toByDay, to)
+          const distanceOut = calculateDistanceOut(zoneInOutDayData, dayRoute, fromByDay, toByDay, 'distanceOut')
 
-            // 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,
@@ -175,6 +129,7 @@ async function processDevices (from, to, devices, userData, data) {
         }
 
         geofencesData.push({
+          geofenceId: geofence.id,
           geofenceName: geofence.name,
           days: dataByDay
         })
@@ -186,11 +141,14 @@ async function processDevices (from, to, devices, userData, data) {
           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 dayRoute = deviceRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay)
-          const totalDistance = calculateDistance(dayRoute)
+          const zoneInOutDayData = zoneInOutData.filter(z => (!z.inTime || (new Date(z.inTime.fixTime) < toByDay)) &&
+              (!z.outTime || (new Date(z.outTime.fixTime) > fromByDay)))
+
+          const distanceOut = calculateDistanceOut(zoneInOutDayData, deviceRoute, fromByDay, toByDay, 'distanceOutAny')
 
           const geofences = geofencesData.map(g => {
             return {
+              geofenceId: g.geofenceId,
               geofenceName: g.geofenceName,
               distanceIn: g.days.find(day => day.date === date).distanceIn
             }
@@ -199,7 +157,7 @@ async function processDevices (from, to, devices, userData, data) {
           groupByDay.push({
             date,
             geofences,
-            distanceOut: totalDistance - geofences.reduce((a, b) => a + (b.distanceIn || 0), 0)
+            distanceOut
           })
         }
 
@@ -234,6 +192,90 @@ async function processDevices (from, to, devices, userData, data) {
   return devicesResult
 }
 
+function calculateTimeIn (zoneInOutDayData, fromByDay, from, toByDay, to) {
+  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())
+    }
+
+    // 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))
+    }
+  }
+  return timeIn
+}
+
+function getNextIn (outDate, alerts, geofenceId, deviceRoute) {
+  const next = alerts
+    .filter(a => a.type === 'geofenceEnter' && (a.geofenceId === geofenceId || !geofenceId))
+    .find(a => new Date(a.position.fixTime).getTime() > outDate)
+  return (next && next.position && new Date(next.position.fixTime).getTime()) ||
+      new Date(deviceRoute.slice(-1)[0].fixTime).getTime()
+}
+
+function getAnyNextIn (outDate, alerts, deviceRoute) {
+  const next = alerts
+    .filter(a => a.type === 'geofenceEnter')
+    .find(a => new Date(a.position.fixTime).getTime() > outDate)
+  return (next && next.position && new Date(next.position.fixTime).getTime()) ||
+      new Date(deviceRoute.slice(-1)[0].fixTime).getTime()
+}
+
+function calculateDistanceIn (zoneInOutDayData, deviceRoute, dayRoute, fromByDay, toByDay, to) {
+  let distanceIn = zoneInOutDayData.length && dayRoute.length ? zoneInOutDayData.reduce((a, b) => a + (b.distanceIn || 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 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)
+    }
+
+    // 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
+      const routeDayAfter = deviceRoute.filter(p => new Date(p.fixTime) <= outTime && new Date(p.fixTime) > toByDay)
+      distanceIn = distanceIn - calculateDistance(routeDayAfter)
+    }
+  }
+
+  return distanceIn
+}
+
+function calculateDistanceOut (zoneInOutDayData, dayRoute, fromByDay, toByDay, field) {
+  if (zoneInOutDayData.length) {
+    let distanceOut = zoneInOutDayData.reduce((a, b) => a + (b[field] || 0), 0) -
+        (zoneInOutDayData[zoneInOutDayData.length - 1][field] || 0)
+
+    if (zoneInOutDayData[0].inTime && new Date(zoneInOutDayData[0].inTime.fixTime) > fromByDay) {
+      // Add distanceOut before the first entry
+      const routeOut = dayRoute.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)
+    }
+
+    if (zoneInOutDayData[zoneInOutDayData.length - 1].outTime && new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) < toByDay) {
+      const routeOut = dayRoute.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)
+    }
+
+    return distanceOut
+  }
+
+  return calculateDistance(dayRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay))
+}
+
 function analyseAlerts (alerts, deviceRoute, userData, from, to) {
   const zoneInOutData = []
   const zoneInData = {}
@@ -259,6 +301,14 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to) {
       )
       const totalOutTime = nextIn - outDate
       const distanceOut = calculateDistance(routeAfterOut)
+
+      const anyNextIn = getAnyNextIn(outDate, alerts, deviceRoute)
+      const routeAfterOutAndBeforeAnyNextIn = deviceRoute.filter(p =>
+        new Date(p.fixTime).getTime() >= outDate &&
+          new Date(p.fixTime).getTime() < anyNextIn
+      )
+      const distanceOutAny = zoneInData.length < 2 ? calculateDistance(routeAfterOutAndBeforeAnyNextIn) : 0
+
       if (zoneInData[a.geofenceId]) {
         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()
@@ -273,6 +323,7 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to) {
           totalOutTime,
           distanceIn: calculateDistance(routeIn),
           distanceOut,
+          distanceOutAny,
           geofenceName: geofence.name,
           geofenceId: geofence.id,
           stopped: routeIn.filter(p => !p.attributes.ignition).length > 0,
@@ -293,7 +344,8 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to) {
           totalOutTime,
           distanceIn: calculateDistance(routeIn),
           driverName: '',
-          distanceOut
+          distanceOut,
+          distanceOutAny
         })
       }
     }
@@ -386,26 +438,35 @@ async function exportZoneReportToPDF (userData, reportData) {
   const translations = getTranslations(userData)
   const lang = userData.user.attributes.lang || (navigator && navigator.language)
 
-  const headers = userData.groupByDay
-    ? [
-        translations.report.date,
-        translations.report.firstIn,
-        translations.report.lastOut,
-        translations.report.distanceIn || 'Kms Adentro',
-        translations.report.timeIn,
-        translations.report.distanceOut || 'Kms Afuera',
-        translations.report.timeOut
-      ]
-    : [
-        translations.report.enter,
-        translations.report.exit,
-        translations.report.stopped,
-        translations.report.duration,
-        translations.report.distanceIn || 'Kms Adentro',
-        translations.report.distanceOut || 'Kms Afuera',
-        translations.report.geofence,
-        translations.report.driver
-      ]
+  const headers = []
+
+  if (userData.groupByDay) {
+    headers.push(...[
+      translations.report.date,
+      translations.report.firstIn,
+      translations.report.lastOut,
+      translations.report.distanceIn || 'Kms Adentro',
+      translations.report.timeIn,
+      translations.report.distanceOut || 'Kms Afuera',
+      translations.report.timeOut
+    ])
+  } else if (userData.zonesByColumn) {
+    headers.push(translations.report.date)
+    reportData.devices[0].days[0].geofences.forEach(g => headers.push(g.geofenceName))
+    headers.push(translations.report.distanceOut || 'Kms Afuera')
+  } else {
+    headers.push(...[
+      translations.report.enter,
+      translations.report.exit,
+      translations.report.stopped,
+      translations.report.duration,
+      translations.report.distanceIn || 'Kms Adentro',
+      translations.report.distanceOut || 'Kms Afuera',
+      translations.report.geofence,
+      translations.report.driver
+    ])
+  }
+
   if (reportData.devices) {
     // eslint-disable-next-line new-cap
     const doc = new jsPDF.jsPDF('l')
@@ -447,6 +508,31 @@ async function exportZoneReportToPDF (userData, reportData) {
             6: { halign: 'right' }
           })
         })
+      } else if (userData.zonesByColumn) {
+        const data = []
+        space = reportHeader(index === 0, doc, translations, d, lang, timezone, userData)
+        d.days.forEach(day => {
+          const temp = [convertToLocaleDateString(day.date, lang, timezone)]
+          day.geofences.forEach(a => {
+            temp.push(a.distanceIn ? a.distanceIn.toLocaleString(lang, { maximumFractionDigits: 2 }) : 0)
+          })
+          temp.push(day.distanceOut ? day.distanceOut.toLocaleString(lang, { maximumFractionDigits: 2 }) : 0)
+          data.push(temp)
+        })
+        const footer = ['Total:' + d.days.length]
+        reportData.devices[0].days[0].geofences.forEach(gColumn => {
+          footer.push(d.days.reduce((a, b) => a + (b.geofences.find(g => g.geofenceId === gColumn.geofenceId).distanceIn), 0).toLocaleString(lang, { maximumFractionDigits: 2 }))
+        })
+        footer.push(d.days.reduce((a, b) => a + (b.distanceOut ? b.distanceOut : 0), 0).toLocaleString(lang, { maximumFractionDigits: 2 }))
+
+        let columnIndex = 1
+        const columnStyles = { }
+        reportData.devices[0].days[0].geofences.forEach(a => {
+          columnStyles[columnIndex] = { halign: 'right' }
+          columnIndex++
+        })
+        columnStyles[columnIndex] = { halign: 'right' }
+        addTable(doc, headers, data, footer, style, space + 40, columnStyles)
       } else {
         const data = []
         space = reportHeader(index === 0, doc, translations, d, lang, timezone, userData)
@@ -484,29 +570,42 @@ function exportZoneReportToExcel (userData, reportData) {
     sheetName: translations.report.titleActivityReport, // The name of the sheet
     fileName // The name of the spreadsheet
   }
-  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: 'totalInTime' },
-        { label: translations.report.distanceOut || 'Kms Afuera', value: 'distanceOut' },
-        { 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: 'totalInTime' },
-        { label: translations.report.distanceIn || 'Kms Adentro', value: 'distanceIn' },
-        { label: translations.report.distanceOut || 'Kms Afuera', value: 'distanceOut' },
-        { label: translations.report.geofence, value: 'zone' },
-        { label: translations.report.driver, value: 'driver' }
-      ]
+  const headers = []
+  if (userData.groupByDay) {
+    headers.push([
+      { 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: 'totalInTime' },
+      { label: translations.report.distanceOut || 'Kms Afuera', value: 'distanceOut' },
+      { label: translations.report.timeOut, value: 'totalOutTime' }
+    ])
+  } else if (userData.zonesByColumn) {
+    headers.push(...[
+      { label: translations.report.vehicle, value: 'name' },
+      { label: translations.report.date, value: 'date' }
+    ])
+    reportData.devices[0].days[0].geofences.forEach(g =>
+      headers.push({ label: g.geofenceName, value: g.geofenceId })
+    )
+    headers.push({ label: translations.report.distanceOut || 'Kms Afuera', value: 'distanceOut' })
+  } else {
+    headers.push(...[
+      { 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: 'totalInTime' },
+      { label: translations.report.distanceIn || 'Kms Adentro', value: 'distanceIn' },
+      { label: translations.report.distanceOut || 'Kms Afuera', value: 'distanceOut' },
+      { label: translations.report.geofence, value: 'zone' },
+      { label: translations.report.driver, value: 'driver' }
+    ])
+  }
+
   let data = []
   if (reportData.devices) {
     reportData.devices.forEach(d => {
@@ -518,6 +617,20 @@ function exportZoneReportToExcel (userData, reportData) {
           }))
           data = data.concat([{}])
         })
+      } else if (userData.zonesByColumn) {
+        const lang = userData.user.attributes.lang
+        d.days.forEach(day => {
+          const row = {
+            name: d.device.name,
+            date: convertToLocaleDateString(day.date, lang, userData.user.attributes.timezone),
+            distanceOut: day.distanceOut ? parseFloat(day.distanceOut.toFixed(2)) : 0
+          }
+          day.geofences.forEach(g => {
+            row[g.geofenceId] = g.distanceIn ? parseFloat(g.distanceIn.toFixed(2)) : 0
+          })
+          data.push(row)
+        })
+        data = data.concat([{}])
       } else {
         data = data.concat(d.geofences.map(a => {
           return getColumns(d, a, userData, translations, true)