fleetmap-reports 2.0.356 → 2.0.358

package/.claude/worktrees/eager-stonebraker-c08ac7/src/zone-report.js

@@ -0,0 +1,904 @@
+const automaticReports = require('./automaticReports')
+const {
+  convertMS, convertToLocaleString, getTranslations, convertToFeature, convertPositionToFeature,
+  calculateDistance,
+  sortPositions, getDates, convertToLocaleDateString, convertToLocaleTimeString,
+  isClientSide,
+  getLanguage, convertFromUTC, convertFromLocal
+} = require('./util/utils')
+const jsPDF = require('jspdf')
+require('jspdf-autotable')
+const traccarHelper = require('./util/traccar')
+const { headerFromUser, addTable } = require('./util/pdfDocument')
+const { getStyle } = require('./reportStyle')
+const {
+  getUserPartner
+} = require('fleetmap-partners')
+const { devicesToProcess } = require('./util/device')
+const {
+  cleanPositions
+} = require('./util/route')
+const { checkGeofenceIn } = require('./util/geofence')
+const { parallel } = require('./util/parallel')
+const { getDataByDay } = require('./util/trips')
+const axios = require('axios').default
+const sliceSize = 1
+const deviceChunk = 5
+const fileName = 'ZoneReport'
+
+function simpleLimit (concurrency) {
+  const queue = []
+  let activeCount = 0
+
+  const next = () => {
+    if (queue.length === 0 || activeCount >= concurrency) return
+    activeCount++
+    const { fn, resolve, reject } = queue.shift()
+    fn().then(resolve).catch(reject).finally(() => {
+      activeCount--
+      next()
+    })
+  }
+
+  return fn => {
+    return new Promise((resolve, reject) => {
+      queue.push({ fn, resolve, reject })
+      next()
+    })
+  }
+}
+
+exports.process = async (traccar, from, to, slice, deviceCount, devices, reportRangeDays, userData) => {
+  const data = await traccarHelper.getAllInOne(
+    traccar, from, to, slice, true, false, false, false,
+    deviceCount, devices.length, sliceSize, reportRangeDays > 29 ? 1 : deviceChunk, undefined, false, true)
+
+  const route = data.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)))
+  }
+  return await processDevices(from, to, slice, userData, { alerts, route, summary: data.summary })
+}
+
+async function createZoneReport (from, to, userData, traccar) {
+  console.log('createZoneReport', from, to)
+  const reportData = []
+  const devices = devicesToProcess(userData)
+  const allData = {
+    devices: [],
+    xpert: devices.filter(d => d.attributes.xpert).length > 0
+  }
+
+  if (isClientSide()) {
+    const cookie = await axios.get('/pinmeapi/cookie/get', { withCredentials: true }).then(d => d.data)
+    const url = `https://${process.env.SERVER_HOST}/pinmeapi/reports/zone-report`
+    return axios.post(url, { from, to, userData, cookie }).then(d => d.data)
+  }
+  const types = ['geofenceEnter', 'geofenceExit']
+
+  if (userData.byGroup) {
+    for (const g of userData.groups) {
+      const devices = userData.devices.filter(d => d.groupId === g.id)
+      console.log(g.name + ' devices:' + devices.length)
+      if (devices.length > 0) {
+        const groupData = {
+          devices: [],
+          group: g,
+          xpert: devices.filter(d => d.attributes.xpert).length > 0
+        }
+        const response = await traccar.reports.reportsEventsGet(from, to, null, [g.id], types)
+        const data = response.data
+
+        devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+
+        if (data.length > 0) {
+          groupData.devices = await processDevices(from, to, devices, userData, { alerts: data })
+          reportData.push(groupData)
+        }
+      }
+    }
+  }
+
+  const reportRangeDays = (new Date(to).getTime() - new Date(from).getTime()) / (1000 * 60 * 60 * 24)
+  const sliced = automaticReports.sliceArray(devices, sliceSize)
+
+  const url = 'https://rntba7aqifqx3iywrenb7pq6km0liwsr.lambda-url.us-east-1.on.aws/pinmeapi/process-report/zone-report-processing'
+
+  const limit = simpleLimit(1000)
+  const promises = sliced.map((slice, i) => limit(async () => {
+    const now = new Date()
+    return traccar.axios.post(url, {
+      from,
+      to,
+      userData,
+      slice,
+      deviceCount: i,
+      devices,
+      reportRangeDays
+    }, { timeout: 900000 })
+      .catch(e => {
+        console.error(url, (e.response && e.response.data) || e, 'try again')
+        return traccar.axios.post(url, {
+          from,
+          to,
+          userData,
+          slice,
+          deviceCount: i,
+          devices,
+          reportRangeDays
+        }, { timeout: 900000 })
+      }).then(response => {
+        console.log('processed devices', slice.map(d => d.id), 'in', new Date() - now, 'ms')
+        return response.data
+      })
+  })
+  )
+  const results = await Promise.all(promises)
+  results.forEach(processed => {
+    if (processed && processed.length) {
+      allData.devices.push(...processed)
+    }
+  })
+
+  reportData.push(allData)
+
+  return reportData
+}
+
+async function processDevices (from, to, devices, userData, data) {
+  const devicesResult = []
+  console.log('processDevices', from, to, devices.length)
+  for (const d of devices) {
+    const alerts = data.alerts.filter(t => t && t.deviceId === d.id)
+    const deviceRoute = data.route.filter(p => p.deviceId === d.id)
+    let zoneInOutData = analyseAlerts(alerts, deviceRoute, userData, from, to, d).filter(d => !userData.onlyWithStop || d.stopped)
+
+    if (userData.groupByDay || userData.zonesByColumn) {
+      const dates = getDates(from, to, userData.user.attributes.timezone)
+
+      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 startDateLocal = new Date(convertFromUTC(date, userData.user.attributes.timezone).toISOString().split('T')[0] + ' ' + userData.dayHours.startTime)
+          const endDateLocal = new Date(convertFromUTC(date, userData.user.attributes.timezone).toISOString().split('T')[0] + ' ' + userData.dayHours.endTime)
+          const startDate = isClientSide() ? startDateLocal : convertFromLocal(startDateLocal, userData.user.attributes.timezone)
+          const endDate = isClientSide() ? endDateLocal : convertFromLocal(endDateLocal, userData.user.attributes.timezone)
+
+          const { routeByDay, zoneInOutDayData } = await getDataByDay(d, date, { route: deviceRoute, zoneInOutData: filteredByGeofence }, userData)
+
+          const firstIn = zoneInOutDayData.find(z => z.inTime && new Date(z.inTime.fixTime) > startDate)
+          const lastOut = zoneInOutDayData.slice().reverse().find(z => z.outTime && new Date(z.outTime.fixTime) < endDate)
+
+          const timeIn = calculateTimeIn(zoneInOutDayData, startDate, from, endDate, to)
+          const distanceIn = calculateDistanceIn(zoneInOutDayData, deviceRoute, routeByDay, startDate, endDate, to, d)
+          const distanceOut = calculateDistanceOut(zoneInOutDayData, routeByDay, startDate, endDate, 'distanceOut', d)
+
+          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
+          })
+        }
+
+        geofencesData.push({
+          geofenceId: geofence.id,
+          geofenceName: geofence.name,
+          days: filterResult(dataByDay, userData)
+        })
+      }
+
+      if (userData.zonesByColumn) {
+        const groupByDay = []
+        for (const date of dates) {
+          const startDateLocal = new Date(convertFromUTC(date, userData.user.attributes.timezone).toISOString().split('T')[0] + ' ' + userData.dayHours.startTime)
+          const endDateLocal = new Date(convertFromUTC(date, userData.user.attributes.timezone).toISOString().split('T')[0] + ' ' + userData.dayHours.endTime)
+          const startDate = isClientSide() ? startDateLocal : convertFromLocal(startDateLocal, userData.user.attributes.timezone)
+          const endDate = isClientSide() ? endDateLocal : convertFromLocal(endDateLocal, userData.user.attributes.timezone)
+
+          const { routeByDay, zoneInOutDayData } = await getDataByDay(d, date, { route: deviceRoute, zoneInOutData }, userData)
+
+          const distanceOut = calculateDistanceOut(zoneInOutDayData, routeByDay, startDate, endDate, 'distanceOutAny', d)
+
+          const geofences = geofencesData.map(g => {
+            const day = g.days.find(day => day.date === date)
+            return {
+              geofenceId: g.geofenceId,
+              geofenceName: g.geofenceName,
+              distanceIn: day && day.distanceIn
+            }
+          })
+
+          if (distanceOut > 0.01 || geofences.filter(g => g.distanceIn > 0.01).length) {
+            if (!userData.onlyWithKmsOut || distanceOut) {
+              groupByDay.push({
+                date,
+                geofences,
+                distanceOut
+              })
+            }
+          }
+        }
+
+        if (groupByDay.length) {
+          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) {
+        if (userData.tripsBetweenZones) {
+          const tripsBetweenZones = []
+          zoneInOutData = zoneInOutData.sort((a, b) => a.inTime && b.inTime && new Date(a.inTime.fixTime).getTime() - new Date(b.inTime.fixTime).getTime())
+          let outGeofence
+          let inGeofence
+          for (let i = 0; i < zoneInOutData.length - 1; i++) {
+            if (!outGeofence) {
+              outGeofence = zoneInOutData[i]
+            }
+            inGeofence = zoneInOutData[i + 1]
+
+            if (outGeofence.outTime &&
+                inGeofence.inTime &&
+                new Date(outGeofence.outTime.fixTime).getTime() < new Date(inGeofence.inTime.fixTime).getTime()) {
+              tripsBetweenZones.push({
+                outTime: outGeofence.outTime,
+                outGeofenceName: outGeofence.geofenceName,
+                inTime: inGeofence.inTime,
+                inGeofenceName: inGeofence.geofenceName,
+                distanceOut: outGeofence.distanceOutAny,
+                totalOutTime: new Date(inGeofence.inTime.fixTime).getTime() - new Date(outGeofence.outTime.fixTime).getTime()
+              })
+              outGeofence = undefined
+            } else {
+              if (outGeofence.outTime &&
+                  inGeofence.outTime &&
+                  new Date(outGeofence.outTime.fixTime).getTime() <= new Date(inGeofence.outTime.fixTime).getTime()) {
+                outGeofence = undefined
+              }
+            }
+          }
+          if (tripsBetweenZones.length > 0) {
+            devicesResult.push({
+              device: d,
+              from,
+              to,
+              tripsBetweenZones: true,
+              geofences: filterResult(tripsBetweenZones, userData)
+            })
+          }
+        } else {
+          devicesResult.push({
+            device: d,
+            from,
+            to,
+            geofences: filterResult(zoneInOutData, userData)
+          })
+        }
+      }
+    }
+  }
+
+  return devicesResult
+}
+
+function filterResult (result, userData) {
+  result = userData.onlyWithKmsOut ? result.filter(a => a.distanceOut >= 0.5) : result
+  return userData.onlyWithKmsIn ? result.filter(a => a.distanceIn === undefined || a.distanceIn >= 0.5) : result
+}
+
+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)
+
+  if (next && !alerts.filter(a => a.type === 'geofenceExit' &&
+      new Date(a.position.fixTime).getTime() > outDate &&
+      new Date(a.position.fixTime).getTime() < new Date(next.position.fixTime).getTime()).length) {
+    return (next && next.position && new Date(next.position.fixTime).getTime()) ||
+        new Date(deviceRoute.slice(-1)[0].fixTime).getTime()
+  }
+}
+
+function getAnyLastExit (inDate, alerts, deviceRoute) {
+  const next = alerts
+    .filter(a => a.type === 'geofenceExit')
+    .find(a => new Date(a.position.fixTime).getTime() < inDate)
+
+  if (next && !alerts.filter(a => a.type === 'geofenceEnter' &&
+      new Date(a.position.fixTime).getTime() < inDate &&
+      new Date(a.position.fixTime).getTime() > new Date(next.position.fixTime).getTime()).length) {
+    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, device) {
+  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, device.attributes['report.ignoreOdometer'])
+    }
+
+    // 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, device.attributes['report.ignoreOdometer'])
+    }
+  }
+
+  return distanceIn
+}
+
+function calculateDistanceOut (zoneInOutDayData, dayRoute, fromByDay, toByDay, field, device) {
+  if (zoneInOutDayData.length) {
+    zoneInOutDayData.sort((a, b) => (a.inTime ? new Date(a.inTime.fixTime).getTime() : 0) - (b.inTime ? new Date(b.inTime.fixTime).getTime() : 0))
+    const dataInsideDay = zoneInOutDayData.filter(z => z.outTime && new Date(z.outTime.fixTime) < toByDay)
+    let distanceOut = dataInsideDay.reduce((a, b) => a + (b[field] || 0), 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, device.attributes['report.ignoreOdometer'])
+    }
+
+    zoneInOutDayData.sort((a, b) => (a.outTime ? new Date(a.outTime.fixTime).getTime() : 0) - (b.outTime ? new Date(b.outTime.fixTime).getTime() : 0))
+    if (zoneInOutDayData[zoneInOutDayData.length - 1].outTime && new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) < toByDay) {
+      // Add distanceOut after last exit
+      distanceOut = distanceOut - zoneInOutDayData[zoneInOutDayData.length - 1][field]
+      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, device.attributes['report.ignoreOdometer'])
+    }
+
+    return distanceOut
+  }
+
+  return calculateDistance(dayRoute.filter(p => new Date(p.fixTime) >= fromByDay && new Date(p.fixTime) < toByDay), device.attributes['report.ignoreOdometer'])
+}
+
+function analyseAlerts (alerts, deviceRoute, userData, from, to, device) {
+  const zoneInOutData = []
+  let zoneInData = []
+
+  alerts.forEach(a => {
+    if (!a.position) {
+      return
+    }
+    if (a.type === 'geofenceEnter') {
+      const driver = userData.drivers.find(d => a.position.attributes && d.uniqueId === a.position.attributes.driverUniqueId)
+      a.position.driverName = driver ? driver.name : ''
+      if (zoneInData.length === 0) {
+        const anyLastExist = getAnyLastExit(new Date(a.position.fixTime).getTime(), alerts, deviceRoute)
+        a.anyLastExit = anyLastExist || from
+      }
+
+      zoneInData.push(a)
+    } else if (a.type === 'geofenceExit') {
+      const geofence = userData.geofences.find(g => g.id === a.geofenceId)
+      if (!geofence) {
+        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() < nextIn
+      )
+      const totalOutTime = nextIn - outDate
+      const distanceOut = calculateDistance(routeAfterOut, device.attributes['report.ignoreOdometer'])
+
+      let anyNextIn
+      let distanceOutAny = 0
+      if (zoneInData.length < 2) {
+        anyNextIn = getAnyNextIn(outDate, alerts, deviceRoute) || to
+        const routeAfterOutAndBeforeAnyNextIn = deviceRoute.filter(p =>
+          new Date(p.fixTime).getTime() >= outDate &&
+            new Date(p.fixTime).getTime() <= anyNextIn
+        )
+        distanceOutAny = Math.round(calculateDistance(routeAfterOutAndBeforeAnyNextIn, device.attributes['report.ignoreOdometer']))
+      }
+
+      const inData = zoneInData.find(z => z.geofenceId === a.geofenceId)
+      if (inData) {
+        const totalInTime = new Date(a.position.fixTime).getTime() - new Date(inData.position.fixTime).getTime()
+        const inDate = new Date(inData.position.fixTime).getTime()
+        const routeIn = deviceRoute.filter(p =>
+          new Date(p.fixTime).getTime() >= inDate &&
+          new Date(p.fixTime).getTime() < outDate
+        )
+        zoneInOutData.push({
+          inTime: inData.position,
+          outTime: a.position,
+          totalInTime,
+          totalOutTime,
+          distanceIn: calculateDistance(routeIn, device.attributes['report.ignoreOdometer']),
+          distanceOut,
+          distanceOutAny,
+          anyNextIn,
+          anyLastExit: a.anyLastExit,
+          geofenceName: geofence.name,
+          geofenceId: geofence.id,
+          stopped: routeIn.filter(p => !(p.attributes && p.attributes.ignition)).length > 0,
+          driverName: inData.position.driverName
+        })
+        zoneInData = zoneInData.filter(z => z.geofenceId !== a.geofenceId)
+      } 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, device.attributes['report.ignoreOdometer']),
+          driverName: '',
+          distanceOut,
+          distanceOutAny,
+          anyNextIn,
+          anyLastExit: a.anyLastExit
+        })
+      }
+    }
+  })
+
+  for (const inData of zoneInData) {
+    const geofence = userData.geofences.find(g => g.id === inData.geofenceId)
+    if (geofence) {
+      const totalInTime = to.getTime() - new Date(inData.position.fixTime).getTime()
+      const routeIn = deviceRoute.filter(p =>
+        new Date(p.fixTime).getTime() >= new Date(inData.position.fixTime).getTime() &&
+          new Date(p.fixTime).getTime() < to.getTime()
+      )
+      zoneInOutData.push({
+        inTime: inData.position,
+        totalInTime,
+        distanceIn: calculateDistance(routeIn, device.attributes['report.ignoreOdometer']),
+        geofenceName: geofence.name,
+        geofenceId: geofence.id,
+        driverName: inData.position.driverName,
+        anyLastExit: inData.anyLastExit
+      })
+    }
+  }
+
+  if (!zoneInOutData.length && userData.groupByDay) {
+    const geofenceIn = alerts.find(a => a.type === 'geofenceEnter')
+    zoneInOutData.push({
+      distanceIn: geofenceIn ? calculateDistance(deviceRoute, device.attributes['report.ignoreOdometer']) : 0,
+      distanceOut: !geofenceIn ? calculateDistance(deviceRoute, device.attributes['report.ignoreOdometer']) : 0,
+      totalTime: to.getTime() - from.getTime()
+    })
+  }
+
+  return zoneInOutData
+}
+
+async function getInAndOutEvents (devices, route, userData) {
+  const events = []
+  const geofencesFeatures = userData.geofences.filter(g => g.area).map(g => convertToFeature(g))
+  devices.forEach(d => {
+    const deviceRoute = route.filter(p => p.deviceId === d.id)
+    const routePoints = deviceRoute.sort(sortPositions).map(p => convertPositionToFeature(p))
+    console.log('getInAndOutEvents', d.id, deviceRoute.length, routePoints.length)
+    routePoints.filter(p => p.properties.position.valid).forEach((p, i, array) => {
+      p.inside = {}
+      if (!i) {
+        geofencesFeatures.forEach((g, id) => {
+          if (checkGeofenceIn(p, g)) {
+            p.inside[id] = true
+            events.push(createEvent('geofenceEnter', d.id, p, g))
+          }
+        })
+        return
+      }
+      const previous = array[i - 1]
+      geofencesFeatures.forEach((g, id) => {
+        if (previous.inside[id]) {
+          if (!checkGeofenceIn(p, g)) {
+            events.push(createEvent('geofenceExit', d.id, p, g))
+          } else {
+            p.inside[id] = true
+          }
+        } else {
+          if (checkGeofenceIn(p, g)) {
+            p.inside[id] = true
+            events.push(createEvent('geofenceEnter', d.id, p, g))
+          }
+        }
+      })
+    })
+  })
+  return events
+}
+
+function createEvent (type, deviceId, p, g) {
+  return {
+    type,
+    position: p.properties.position,
+    geofenceId: g.properties.geofence.id,
+    deviceId
+  }
+}
+
+async function exportZoneReportToPDF (userData, reportData) {
+  console.log('Export to PDF')
+
+  const timezone = userData.user.attributes.timezone
+  const translations = getTranslations(userData)
+  const lang = getLanguage(userData)
+
+  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 if (userData.tripsBetweenZones) {
+    headers.push(...[
+      translations.report.date_start,
+      translations.report.geofenceOut || 'Zone OUT',
+      translations.report.date_end,
+      translations.report.geofenceIn || 'Zone IN',
+      translations.report.duration,
+      translations.report.distance
+    ])
+  } 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')
+    await headerFromUser(doc, translations.report.titleZoneReport, userData.user)
+    const style = getStyle(getUserPartner(userData.user))
+    let space = 0
+
+    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 })
+          ]
+          addTable(doc, headers, data, footer, style, space + 40, {
+            0: { halign: 'right' },
+            1: { halign: 'right' },
+            2: { halign: 'right' },
+            3: { halign: 'right' },
+            4: { halign: 'right' },
+            5: { halign: 'right' },
+            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(() => {
+          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)
+        if (userData.tripsBetweenZones) {
+          d.geofences.forEach(a => {
+            const temp = [
+              geofenceExit(userData.user, a),
+              a.outGeofenceName,
+              geofenceEnter(userData.user, a),
+              a.inGeofenceName,
+              convertMS(a.totalOutTime, true),
+              a.distanceOut ? a.distanceOut.toLocaleString(lang, { maximumFractionDigits: 2 }) : 0
+            ]
+            data.push(temp)
+          })
+          const footer = ['Total:' + d.geofences.length]
+          addTable(doc, headers, data, footer, style, space + 35, {
+            4: { halign: 'right' },
+            5: { halign: 'right' }
+          })
+        } else {
+          d.geofences.forEach(a => {
+            const temp = [
+              geofenceEnter(userData.user, a),
+              geofenceExit(userData.user, a),
+              a.stopped ? translations.report.yes : translations.report.no,
+              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 footer = ['Total:' + d.geofences.length]
+          addTable(doc, headers, data, footer, style, space + 35, {
+            3: { halign: 'right' },
+            4: { halign: 'right' },
+            5: { halign: 'right' }
+          })
+        }
+      }
+    })
+    return doc
+  }
+}
+
+function exportZoneReportToExcel (userData, reportData) {
+  console.log('Export to Excel')
+
+  const translations = getTranslations(userData)
+
+  const settings = {
+    sheetName: translations.report.titleActivityReport, // The name of the sheet
+    fileName // The name of the spreadsheet
+  }
+  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 || 'First In', value: 'firstIn' },
+      { label: translations.report.lastOut || 'Last Out', value: 'lastOut' },
+      { label: translations.report.distanceIn || 'Kms Adentro', value: 'distanceIn', format: '0' },
+      { label: translations.report.timeIn || 'Total In Time', value: 'totalInTime' },
+      { label: translations.report.distanceOut || 'Kms Afuera', value: 'distanceOut', format: '0' },
+      { label: translations.report.timeOut || 'Total Out Time', value: 'totalOutTime' }
+    ])
+  } else if (userData.zonesByColumn) {
+    headers.push(...[
+      { label: translations.report.vehicle, value: 'name' },
+      { label: translations.report.date, value: 'date' }
+    ])
+    if (reportData.devices.length) {
+      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', format: '0' })
+  } else if (userData.tripsBetweenZones) {
+    headers.push(...[
+      { label: translations.report.vehicle, value: 'name' },
+      { label: translations.report.date_start, value: 'exit' },
+      { label: translations.report.geofenceOut || 'Zone OUT', value: 'zoneOut' },
+      { label: translations.report.date_end, value: 'enter' },
+      { label: translations.report.geofenceIn || 'Zone IN', value: 'zoneIn' },
+      { label: translations.report.duration, value: 'totalOutTime' },
+      { label: translations.report.distance, value: 'distanceOut', format: '0' }
+    ])
+  } 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', format: '0' },
+      { label: translations.report.distanceOut || 'Kms Afuera', value: 'distanceOut', format: '0' },
+      { label: translations.report.geofence, value: 'zone' },
+      { label: translations.report.driver, value: 'driver' }
+    ])
+  }
+
+  let data = []
+  if (reportData.devices) {
+    reportData.devices.forEach(d => {
+      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 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)
+        }))
+        data = data.concat([{}])
+      }
+    })
+    return {
+      headers,
+      data,
+      settings
+    }
+  }
+}
+
+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, excel) {
+  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: excel
+      ? data.distanceIn || 0
+      : (data.distanceIn && data.distanceIn.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 2 })) || 0,
+    distanceOut: excel
+      ? data.distanceOut || 0
+      : (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,
+    zoneOut: data.outGeofenceName,
+    zoneIn: data.inGeofenceName,
+    driver: data.driverName
+  }
+}
+
+function deviceName (device) {
+  return device.name + (device.attributes.license_plate ? ', ' + device.attributes.license_plate : '') + (device.model ? ', ' + device.model : '')
+}
+
+function geofenceEnter (user, row) {
+  return row.inTime ? convertToLocaleString(row.inTime.fixTime, user.attributes.lang, user.attributes.timezone) : ''
+}
+function geofenceExit (user, row) {
+  return row.outTime ? convertToLocaleString(row.outTime.fixTime, user.attributes.lang, user.attributes.timezone) : ''
+}
+
+exports.createZoneReport = createZoneReport
+exports.exportZoneReportToPDF = exportZoneReportToPDF
+exports.exportZoneReportToExcel = exportZoneReportToExcel
+exports.create = createZoneReport
+exports.exportToPDF = exportZoneReportToPDF
+exports.exportToExcel = exportZoneReportToExcel
+exports.getInAndOutEvents = getInAndOutEvents