fleetmap-reports 1.0.758 → 1.0.759

package/package.json

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

package/src/tests/performance.test.js

@@ -2,14 +2,15 @@ const { getReports } = require('./index')
 const { createPerformanceReport } = require('../partnerReports/performance-report')
 // eslint-disable-next-line no-undef
 describe('performance', function () {
+  this.timeout(500000)
   // eslint-disable-next-line no-undef
   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

@@ -2,6 +2,7 @@ const { getReports } = require('./index')
 const assert = require('assert')
 // eslint-disable-next-line no-undef
 describe('zones', function () {
+  this.timeout(500000)
   // eslint-disable-next-line no-undef
   it('works with ellca', async () => {
     const report = await getReports()
@@ -47,4 +48,41 @@ describe('zones', function () {
     assert.equal(first.inTime.fixTime, '2023-01-03T21:23:24.000+0000')
     assert.equal(first.outTime.fixTime, '2023-01-07T12:22:53.000+0000')
   }, 4000000)
+
+  // eslint-disable-next-line no-undef
+  it('works with casais 2', async () => {
+    const report = await getReports('mario.andre.moreira@casais.gi', 'Casais.23')
+    const userData = await report.getUserData()
+    userData.groupByDay = true
+    userData.devices = userData.devices.filter(d => d.name === 'G-2542-F Fiat Tipo')
+    userData.geofences = userData.geofences.filter(g => g.name === 'baliza raio verde ')
+    assert.equal(userData.geofences.length > 0, true)
+    assert.equal(userData.devices.length > 0, true)
+    const result = await report.zoneReport(
+      new Date(2023, 1, 27, 0, 0, 0, 0),
+      new Date(2023, 1, 27, 23, 59, 59, 0),
+      userData)
+    assert.equal(result[0].devices[0].geofences.length, 1)
+    assert.equal(result[0].devices[0].geofences[0].days.length, 1)
+    const first = result[0].devices[0].geofences[0].days[0]
+    assert.equal(first.firstIn, '2023-02-27T21:53:16.000+0000')
+    assert.equal(first.distanceIn, 93.03917199839687)
+    assert.equal(first.distanceOut, 819.6685737216337)
+  }, 4000000)
+
+  it('works with casais 3', async () => {
+    const report = await getReports(process.env.USER_CASAIS, process.env.PASS_CASAIS)
+    const userData = await report.getUserData()
+    userData.zonesByColumn = true
+    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, 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]
+    console.log(first)
+    assert.equal(first.name, 'baliza raio verde ')
+    assert.equal(first.distanceIn, '1069.343491503579')
+  }, 4000000)
 })

package/src/zone-report.js

@@ -70,8 +70,13 @@ async function createZoneReport (from, to, userData, traccar) {
       deviceCount, devices.length, sliceSize, deviceChunk, undefined)
 
     const route = filterPositions(data.route)
-    const alerts = await parallel('zone-report', 'getInAndOutEvents', slice, cleanPositions(route), userData)
-    allData.devices.push(...await processDevices(from, to, devices, userData, { alerts, route }))
+    const alerts = []
+    if (isClientSide()) {
+      alerts.push(...(await getInAndOutEvents(slice, cleanPositions(route), userData)))
+    } else {
+      alerts.push(...(await parallel('zone-report', 'getInAndOutEvents', slice, cleanPositions(route), userData)))
+    }
+    allData.devices.push(...await processDevices(from, to, devices, userData, { alerts, route, summary: data.summary }))
 
     deviceCount = deviceCount + slice.length
   }
@@ -81,24 +86,15 @@ 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) {
+    if (userData.groupByDay || userData.zonesByColumn) {
       const dates = getDates(from, to, userData.user.attributes.timezone)
 
       const geofencesData = []
@@ -117,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
+          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')
 
-          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)
-            }
-
-            // 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,
@@ -170,18 +129,54 @@ async function processDevices (from, to, devices, userData, data) {
         }
 
         geofencesData.push({
+          geofenceId: geofence.id,
           geofenceName: geofence.name,
           days: dataByDay
         })
       }
 
-      devicesResult.push({
-        device: d,
-        from,
-        to,
-        groupByDay: true,
-        geofences: geofencesData
-      })
+      if (userData.zonesByColumn) {
+        const groupByDay = []
+        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 = 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
+            }
+          })
+
+          groupByDay.push({
+            date,
+            geofences,
+            distanceOut
+          })
+        }
+
+        devicesResult.push({
+          device: d,
+          from,
+          to,
+          zonesByColumn: true,
+          days: groupByDay
+        })
+      } else {
+        devicesResult.push({
+          device: d,
+          from,
+          to,
+          groupByDay: true,
+          geofences: geofencesData
+        })
+      }
     } else {
       if (zoneInOutData.length > 0) {
         devicesResult.push({
@@ -197,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 = {}
@@ -222,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()
@@ -236,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,
@@ -256,7 +344,8 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to) {
           totalOutTime,
           distanceIn: calculateDistance(routeIn),
           driverName: '',
-          distanceOut
+          distanceOut,
+          distanceOutAny
         })
       }
     }
@@ -349,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')
@@ -410,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)
@@ -447,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 => {
@@ -481,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)