fleetmap-reports 2.0.358 → 2.0.359

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

@@ -1,904 +0,0 @@
-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