fleetmap-reports 1.0.661 → 1.0.662

package/lang/enGB.js

@@ -270,7 +270,11 @@ module.exports = {
     minimumMinutes: 'Minimum time',
     maximumSpeed: 'Maximum speed',
     minutes: 'Minutes',
-    zone: 'Zone'
+    zone: 'Zone',
+    firstIn: 'First In',
+    lastOut: 'Last Out',
+    timeIn: 'Time In',
+    timeOut: 'Time Out'
   },
   layout: {
     deviceOnline: 'Device Online',

package/lang/esCL.js

@@ -259,7 +259,11 @@ module.exports = {
     minimumMinutes: 'Tiempo mínimo',
     maximumSpeed: 'Velocidad máxima',
     minutes: 'Minutos',
-    zone: 'Zona'
+    zone: 'Zona',
+    firstIn: 'Primeira Entrada',
+    lastOut: 'Última Saída',
+    timeIn: 'Tempo Adentro',
+    timeOut: 'Tempo Afuera'
   },
   layout: {
     deviceOnline: 'Dispositivo en línea',

package/lang/ptBR.js

@@ -264,7 +264,11 @@ module.exports = {
     minimumMinutes: 'Tempo mínimo',
     maximumSpeed: 'Velocidade máxima',
     minutes: 'Minutos',
-    zone: 'Zona'
+    zone: 'Zona',
+    firstIn: 'Primeira Entrada',
+    lastOut: 'Última Saída',
+    timeIn: 'Tempo Dentro',
+    timeOut: 'Tempo Fora'
   },
   layout: {
     deviceOnline: 'Dispositivo Online',

package/lang/ptPT.js

@@ -273,7 +273,11 @@ module.exports = {
     minimumMinutes: 'Tempo mínimo',
     maximumSpeed: 'Velocidade máxima',
     minutes: 'Minutos',
-    zone: 'Zone'
+    zone: 'Zone',
+    firstIn: 'Primeira Entrada',
+    lastOut: 'Última Saída',
+    timeIn: 'Tempo Dentro',
+    timeOut: 'Tempo Fora'
   },
   layout: {
     test: 'Test Notification',

package/package.json

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

package/src/zone-report.js

@@ -3,7 +3,7 @@ const automaticReports = require('./automaticReports')
 const {
   convertMS, convertToLocaleString, getTranslations, convertToFeature, convertPositionToFeature,
   calculateDistance,
-  sortPositions
+  sortPositions, getDates, convertToLocaleDateString, convertToLocaleTimeString
 } = require('./util/utils')
 const jsPDF = require('jspdf')
 require('jspdf-autotable')
@@ -84,7 +84,7 @@ async function createZoneReport (from, to, userData, traccar) {
 
 function getNextIn (outDate, alerts, geofenceId, deviceRoute) {
   const next = alerts
-    .filter(a => a.type === 'geofenceEnter' && a.geofenceId === geofenceId)
+    .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()
@@ -98,75 +98,80 @@ async function processDevices (from, to, devices, userData, data) {
     const deviceRoute = data.route.filter(p => p.deviceId === d.id)
 
     if (alerts.length > 0) {
-      const zoneInOutData = []
-      const 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 : ''
-          zoneInData[a.geofenceId] = 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 routeAfterOut = deviceRoute.filter(p =>
-            new Date(p.fixTime).getTime() >= outDate &&
-            new Date(p.fixTime).getTime() < getNextIn(outDate, alerts, a.geofenceId, deviceRoute)
-          )
-          const distanceOut = calculateDistance(routeAfterOut)
-          if (zoneInData[a.geofenceId]) {
-            const totalInTime = moment(a.position.fixTime).diff(moment(zoneInData[a.geofenceId].position.fixTime), 'seconds')
-            const inDate = new Date(zoneInData[a.geofenceId].position.fixTime).getTime()
-            const routeIn = deviceRoute.filter(p =>
-              new Date(p.fixTime).getTime() >= inDate &&
-                new Date(p.fixTime).getTime() < outDate
-            )
-            zoneInOutData.push({
-              inTime: zoneInData[a.geofenceId].position,
-              outTime: a.position,
-              totalTime: totalInTime,
-              distanceIn: calculateDistance(routeIn),
-              distanceOut,
-              geofenceName: geofence.name,
-              stopped: routeIn.filter(p => !p.attributes.ignition).length > 0,
-              driverName: zoneInData[a.geofenceId].position.driverName
-            })
-            zoneInData[a.geofenceId] = null
-          } else {
-            zoneInOutData.push({
-              outTime: a.position,
-              geofenceName: geofence.name,
-              driverName: '',
-              distanceOut
-            })
-          }
-        }
-      })
+      const zoneInOutData = userData.groupByDay
+        ? analyseAlertsGroupGeofences(alerts, deviceRoute)
+        : analyseAlerts(alerts, deviceRoute, userData)
 
-      for (const i in zoneInData) {
-        if (zoneInData[i]) {
-          const geofence = userData.geofences.find(g => g.id === zoneInData[i].geofenceId)
-          if (geofence) {
-            zoneInOutData.push({
-              inTime: zoneInData[i].position,
-              geofenceName: geofence.name,
-              driverName: zoneInData[i].position.driverName
-            })
+      const result = userData.onlyWithStop ? zoneInOutData.filter(d => d.stopped) : zoneInOutData
+      const resultSorted = result.sort((a, b) => a.inTime && b.inTime ? new Date(a.inTime.fixTime).getTime() - new Date(b.inTime.fixTime).getTime() : -1)
+
+      if (userData.groupByDay) {
+        const dates = getDates(from, to)
+
+        const dataByDay = []
+        for (const date of dates) {
+          const fromByDay = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0)
+          const toByDay = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59)
+
+          const zoneInOutDayData = resultSorted.filter(z => new Date(z.inTime.fixTime) < toByDay &&
+              new Date(z.outTime.fixTime) > fromByDay)
+          const firstIn = zoneInOutDayData.find(z => new Date(z.inTime.fixTime) > fromByDay)
+          const lastOut = zoneInOutDayData.findLast(z => new Date(z.outTime.fixTime) < toByDay)
+
+          let timeIn = zoneInOutDayData.length ? zoneInOutData.reduce((a, b) => a + (b.totalTime || 0), 0) * 1000 : 0
+          let distanceIn = zoneInOutDayData.length ? zoneInOutData.reduce((a, b) => a + (b.distanceIn || 0), 0) : 0
+          let distanceOut = zoneInOutDayData.length
+            ? zoneInOutData.reduce((a, b) => a + (b.distanceOut || 0), 0)
+            : 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 (new Date(zoneInOutDayData[0].inTime.fixTime) < fromByDay) {
+              timeIn = timeIn - (fromByDay.getTime() - new Date(zoneInOutDayData[0].inTime.fixTime).getTime())
+              const routeDayBefore = deviceRoute.filter(p => 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 (new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) > toByDay) {
+              timeIn = timeIn - (new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime).getTime() - (toByDay.getTime() + 1000))
+              const routeDayAfter = deviceRoute.filter(p => new Date(p.fixTime) < new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) &&
+                  new Date(p.fixTime) > toByDay)
+              distanceIn = distanceIn - calculateDistance(routeDayAfter)
+              distanceOut = distanceOut - zoneInOutDayData[zoneInOutDayData.length - 1].distanceOut
+              const routeOut = deviceRoute.filter(p => new Date(p.fixTime) > new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) &&
+                  new Date(p.fixTime) < toByDay)
+              distanceOut = distanceOut + calculateDistance(routeOut)
+            }
           }
-        }
-      }
 
-      const result = userData.onlyWithStop ? zoneInOutData.filter(d => d.stopped) : zoneInOutData
+          dataByDay.push({
+            date,
+            firstIn: firstIn ? firstIn.inTime.fixTime : undefined,
+            lastOut: lastOut ? lastOut.outTime.fixTime : undefined,
+            distanceIn,
+            distanceOut,
+            timeIn: (timeIn / 1000),
+            timeOut: (24 * 60 * 60) - (timeIn / 1000)
+          })
+        }
 
-      if (result.length > 0) {
         devicesResult.push({
           device: d,
           from,
           to,
-          geofences: result
+          days: dataByDay
         })
+      } else {
+        if (result.length > 0) {
+          devicesResult.push({
+            device: d,
+            from,
+            to,
+            geofences: resultSorted
+          })
+        }
       }
     }
   }
@@ -174,6 +179,125 @@ async function processDevices (from, to, devices, userData, data) {
   return devicesResult
 }
 
+function analyseAlertsGroupGeofences (alerts, deviceRoute) {
+  const zoneInOutData = []
+  const zoneInData = {}
+
+  alerts.forEach(a => {
+    if (!a.position) {
+      return
+    }
+    if (a.type === 'geofenceEnter') {
+      if (zoneInData.inTime) {
+        zoneInData.inCount++
+      } else {
+        zoneInData.inTime = a
+        zoneInData.inCount = 1
+      }
+      return
+    }
+    if (a.type === 'geofenceExit') {
+      zoneInData.inCount--
+      if (zoneInData.inCount === 0) {
+        const totalInTime = moment(a.position.fixTime).diff(moment(zoneInData.inTime.position.fixTime), 'seconds')
+        const inDate = new Date(zoneInData.inTime.position.fixTime).getTime()
+        const outDate = new Date(a.position.fixTime).getTime()
+        const routeAfterOut = deviceRoute.filter(p =>
+          new Date(p.fixTime).getTime() >= outDate &&
+            new Date(p.fixTime).getTime() < getNextIn(outDate, alerts, undefined, deviceRoute)
+        )
+        const distanceOut = calculateDistance(routeAfterOut)
+        const routeIn = deviceRoute.filter(p =>
+          new Date(p.fixTime).getTime() >= inDate &&
+            new Date(p.fixTime).getTime() < outDate
+        )
+        zoneInOutData.push({
+          inTime: zoneInData.inTime.position,
+          outTime: a.position,
+          totalTime: totalInTime,
+          distanceIn: calculateDistance(routeIn),
+          distanceOut,
+          stopped: routeIn.filter(p => !p.attributes.ignition).length > 0
+        })
+        zoneInData.inTime = undefined
+      }
+    }
+  })
+
+  if (zoneInData.inTime) {
+    zoneInOutData.push({ ...zoneInData })
+  }
+  return zoneInOutData
+}
+
+function analyseAlerts (alerts, deviceRoute, userData) {
+  const zoneInOutData = []
+  const 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 : ''
+      zoneInData[a.geofenceId] = 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 routeAfterOut = deviceRoute.filter(p =>
+        new Date(p.fixTime).getTime() >= outDate &&
+          new Date(p.fixTime).getTime() < getNextIn(outDate, alerts, a.geofenceId, deviceRoute)
+      )
+      const distanceOut = calculateDistance(routeAfterOut)
+      if (zoneInData[a.geofenceId]) {
+        const totalInTime = moment(a.position.fixTime).diff(moment(zoneInData[a.geofenceId].position.fixTime), 'seconds')
+        const inDate = new Date(zoneInData[a.geofenceId].position.fixTime).getTime()
+        const routeIn = deviceRoute.filter(p =>
+          new Date(p.fixTime).getTime() >= inDate &&
+            new Date(p.fixTime).getTime() < outDate
+        )
+        zoneInOutData.push({
+          inTime: zoneInData[a.geofenceId].position,
+          outTime: a.position,
+          totalTime: totalInTime,
+          distanceIn: calculateDistance(routeIn),
+          distanceOut,
+          geofenceName: geofence.name,
+          stopped: routeIn.filter(p => !p.attributes.ignition).length > 0,
+          driverName: zoneInData[a.geofenceId].position.driverName
+        })
+        zoneInData[a.geofenceId] = null
+      } else {
+        zoneInOutData.push({
+          outTime: a.position,
+          geofenceName: geofence.name,
+          driverName: '',
+          distanceOut
+        })
+      }
+    }
+  })
+
+  for (const i in zoneInData) {
+    if (zoneInData[i]) {
+      const geofence = userData.geofences.find(g => g.id === zoneInData[i].geofenceId)
+      if (geofence) {
+        zoneInOutData.push({
+          inTime: zoneInData[i].position,
+          geofenceName: geofence.name,
+          driverName: zoneInData[i].position.driverName
+        })
+      }
+    }
+  }
+
+  return zoneInOutData
+}
+
 function checkGeofenceEnter (p1, p2, g) {
   switch (g.geometry.type) {
     case 'Polygon':
@@ -229,16 +353,26 @@ async function exportZoneReportToPDF (userData, reportData) {
   const translations = getTranslations(userData)
   const lang = userData.user.attributes.lang || (navigator && navigator.language)
 
-  const headers = [
-    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 = 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
+      ]
   if (reportData.devices) {
     let first = true
     // eslint-disable-next-line new-cap
@@ -262,23 +396,44 @@ async function exportZoneReportToPDF (userData, reportData) {
       doc.setFontSize(11)
       doc.text(group ? translations.report.group + ': ' + group.name : '', 200, space + 20)
       doc.text(convertToLocaleString(d.from, lang, timezone) + ' - ' + convertToLocaleString(d.to, lang, timezone), 20, space + 25)
-      d.geofences.forEach(a => {
-        const temp = [
-          geofenceEnter(userData.user, a),
-          geofenceExit(userData.user, a),
-          a.stopped ? translations.report.yes : translations.report.no,
-          a.totalTime ? convertMS(a.totalTime * 1000, true) : '',
-          a.distanceIn && a.distanceIn.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 1 }),
-          a.distanceOut && a.distanceOut.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 1 }),
-          a.geofenceName,
-          a.driverName
-        ]
-        data.push(temp)
-      })
+      userData.groupByDay
+        ? d.days.forEach(a => {
+          const temp = [
+            convertToLocaleDateString(a.date, userData.user.attributes.lang, userData.user.attributes.timezone),
+            a.firstIn ? convertToLocaleTimeString(a.firstIn, userData.user.attributes.lang, userData.user.attributes.timezone) : '-',
+            a.lastOut ? convertToLocaleTimeString(a.lastOut, userData.user.attributes.lang, userData.user.attributes.timezone) : '-',
+            a.distanceIn.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 1 }),
+            a.timeIn ? convertMS(a.timeIn * 1000, false) : '',
+            a.distanceOut.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 1 }),
+            a.timeOut ? convertMS(a.timeOut * 1000, false) : ''
+          ]
+          data.push(temp)
+        })
+        : d.geofences.forEach(a => {
+          const temp = [
+            geofenceEnter(userData.user, a),
+            geofenceExit(userData.user, a),
+            a.stopped ? translations.report.yes : translations.report.no,
+            a.totalTime ? convertMS(a.totalTime * 1000, true) : '',
+            a.distanceIn && a.distanceIn.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 1 }),
+            a.distanceOut && a.distanceOut.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 1 }),
+            a.geofenceName,
+            a.driverName
+          ]
+          data.push(temp)
+        })
 
-      const footValues = [
-        'Total:' + d.geofences.length
-      ]
+      const footValues = userData.groupByDay
+        ? [
+            'Total:' + d.days.length,
+            '', '',
+            d.days.reduce((a, b) => a + b.distanceIn, 0).toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 1 }),
+            '',
+            d.days.reduce((a, b) => a + b.distanceOut, 0).toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 1 })
+          ]
+        : [
+            'Total:' + d.geofences.length
+          ]
 
       const style = getStyle(getUserPartner(userData.user))
       doc.autoTable({
@@ -318,32 +473,54 @@ function exportZoneReportToExcel (userData, reportData) {
     sheetName: translations.report.titleActivityReport, // The name of the sheet
     fileName // The name of the spreadsheet
   }
-  const headers = [
-    { label: translations.report.vehicle, value: 'name' },
-    { label: translations.report.enter, value: 'enter' },
-    { label: translations.report.exit, value: 'exit' },
-    { label: translations.report.stopped, value: 'stopped' },
-    { label: translations.report.duration, value: 'duration' },
-    { label: translations.report.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 = userData.groupByDay
+    ? [
+        { label: translations.report.date, value: 'date' },
+        { label: translations.report.firstIn, value: 'firstIn' },
+        { label: translations.report.lastOut, value: 'lastOut' },
+        { label: translations.report.distanceIn || 'Kms Adentro', value: 'distanceIn' },
+        { label: translations.report.timeIn, value: 'timeIn' },
+        { label: translations.report.distanceOut || 'Kms Afuera', value: 'distanceOut' },
+        { label: translations.report.timeOut, value: 'timeOut' }
+      ]
+    : [
+        { label: translations.report.vehicle, value: 'name' },
+        { label: translations.report.enter, value: 'enter' },
+        { label: translations.report.exit, value: 'exit' },
+        { label: translations.report.stopped, value: 'stopped' },
+        { label: translations.report.duration, value: 'duration' },
+        { label: translations.report.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 => {
-      data = data.concat(d.geofences.map(a => {
-        return {
-          ...a,
-          name: d.device.name,
-          enter: geofenceEnter(userData.user, a),
-          exit: geofenceExit(userData.user, a),
-          stopped: a.stopped ? translations.report.yes : translations.report.no,
-          duration: a.totalTime ? convertMS(a.totalTime * 1000, true) : '',
-          zone: a.geofenceName,
-          driver: a.driverName
-        }
-      }))
+      data = userData.groupByDay
+        ? data.concat(d.days.map(a => {
+          return {
+            date: convertToLocaleDateString(a.date, userData.user.attributes.lang, userData.user.attributes.timezone),
+            firstIn: a.firstIn ? convertToLocaleTimeString(a.firstIn, userData.user.attributes.lang, userData.user.attributes.timezone) : '-',
+            lastOut: a.lastOut ? convertToLocaleTimeString(a.lastOut, userData.user.attributes.lang, userData.user.attributes.timezone) : '-',
+            distanceIn: a.distanceIn && a.distanceIn.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 1 }),
+            distanceOut: a.distanceOut && a.distanceOut.toLocaleString(userData.user.attributes.lang, { maximumFractionDigits: 1 }),
+            timeIn: convertMS(a.timeIn * 1000),
+            timeOut: convertMS(a.timeOut * 1000)
+          }
+        }))
+        : data.concat(d.geofences.map(a => {
+          return {
+            ...a,
+            name: d.device.name,
+            enter: geofenceEnter(userData.user, a),
+            exit: geofenceExit(userData.user, a),
+            stopped: a.stopped ? translations.report.yes : translations.report.no,
+            duration: a.totalTime ? convertMS(a.totalTime * 1000, true) : '',
+            zone: a.geofenceName,
+            driver: a.driverName
+          }
+        }))
     })
     return {
       headers,