fleetmap-reports 1.0.957 → 1.0.959

package/package.json

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

package/src/index.js

@@ -182,5 +182,15 @@ function Reports (config, axios, cookieJar) {
   this.stopReportToExcel = (userData, reportData) => {
     return require('./stop-report').exportStopReportToExcel(userData, reportData)
   }
+
+  this.performanceReport = (from, to, userData) => {
+    return require('./partnerReports/performance-report').createPerformanceReport(from, to, userData, this.traccar)
+  }
+  this.performanceReportToPDF = (userData, reportData) => {
+    return require('./partnerReports/performance-report').exportPerformanceReportToPDF(userData, reportData)
+  }
+  this.performanceReportToExcel = (userData, reportData) => {
+    return require('./partnerReports/performance-report').exportPerformanceReportToExcel(userData, reportData)
+  }
 }
 module.exports = Reports

package/src/partnerReports/performance-report.js

@@ -2,7 +2,11 @@ const automaticReports = require('../automaticReports')
 const traccarHelper = require('../util/traccar')
 const { getUncompletedTrip } = require('../util/trips')
 const { getEndTripMessages, getCanDriverStyleMessages, parseEndTripMessage, parseCanDriverStyleMessage } = require('../util/xpert')
-const { calculateDistance } = require('../util/utils')
+const { calculateDistance, getTranslations, convertMS } = require('../util/utils')
+const { addTable } = require('../util/pdfDocument')
+const jsPDF = require('jspdf')
+const { getStyle } = require('../reportStyle')
+const { getUserPartner } = require('fleetmap-partners')
 
 async function createPerformanceReport (from, to, userData, traccar) {
   const reportData = []
@@ -214,4 +218,134 @@ function calculateRPMSections (route, min, max) {
   return sections
 }
 
+function exportPerformanceReportToPDF (userData, reportData) {
+  const translations = getTranslations(userData)
+
+  const headers = [
+    translations.report.vehicle,
+    'Utilisation',
+    'Conduite',
+    'Ralenti',
+    'Totale (L)',
+    'Conduite (L)',
+    'Ralenti (L)',
+    'Conduite (Km)',
+    'Économique',
+    'Économique (L)',
+    'Économique (Km)',
+    'Cruise Control',
+    'Cruise Control (L)',
+    'Cruise Control (Km)',
+    'Tour moteur élevé',
+    'Accéleration brusque (Sum)',
+    'Freinage brusque (Sum)',
+    'Virages brusque'
+  ]
+
+  const data = []
+  reportData.forEach(d => {
+    const row = [
+      d.device,
+      convertMS((d.drivingTime + d.idleTime) * 1000),
+      convertMS(d.drivingTime * 1000),
+      convertMS(d.idleTime * 1000),
+      d.drivingConsumption + d.idleConsumption,
+      d.drivingConsumption,
+      d.idleConsumption,
+      d.drivingDistance.toFixed(2),
+      convertMS(d.economicTime * 1000),
+      d.economicConsumption.toFixed(1),
+      d.economicDistance.toFixed(2),
+      convertMS(d.cruiseControlTime * 1000),
+      d.cruiseControlConsumption.toFixed(1),
+      d.cruiseControlDistance.toFixed(2),
+      convertMS(d.highEngineRPM * 1000),
+      d.hardAcceleration,
+      d.hardBraking,
+      d.hardCornering
+    ]
+    data.push(row)
+  })
+
+  const doc = new jsPDF.jsPDF('l')
+  const style = getStyle(getUserPartner(userData.user))
+
+  const footValues = []
+
+  doc.setFontSize(11)
+  doc.text(new Date(userData.from).toLocaleString() + ' - ' + new Date(userData.to).toLocaleString(), 20, 33)
+
+  style.headerFontSize = 8
+  style.bodyFontSize = 7
+  const columnStyles = {}
+  for (let i = 1; i < 18; i++) {
+    columnStyles[i] = { halign: 'right' }
+  }
+  addTable(doc, headers, data, footValues, style, 40, columnStyles)
+  return doc
+}
+
+function exportPerformanceReportToExcel (userData, reportData) {
+  const translations = getTranslations(userData)
+
+  const settings = {
+    sheetName: 'Rapport de Performance', // The name of the sheet
+    fileName: 'RapportPerformance' // The name of the spreadsheet
+  }
+
+  const headers = [{ label: translations.report.vehicle, value: 'name' },
+    { label: 'Totale Utilisation', value: 'totalUse' },
+    { label: 'Conduite', value: 'drivingTime' },
+    { label: 'Ralenti', value: 'idleTime' },
+    { label: 'Totale (L)', value: 'totalConsumption' },
+    { label: 'Conduite (L)', value: 'drivingConsumption' },
+    { label: 'Ralenti (L)', value: 'idleConsumption' },
+    { label: 'Conduite (Km)', value: 'drivingDistance' },
+    { label: 'Économique', value: 'economicTime' },
+    { label: 'Économique (L)', value: 'economicConsumption' },
+    { label: 'Économique (Km)', value: 'economicDistance' },
+    { label: 'Cruise Control', value: 'cruiseControlTime' },
+    { label: 'Cruise Control (L)', value: 'cruiseControlConsumption' },
+    { label: 'Cruise Control (Km)', value: 'cruiseControlDistance' },
+    { label: 'Tour moteur élevé', value: 'highEngineRPM' },
+    { label: 'Accéleration brusque (Sum)', value: 'hardAcceleration' },
+    { label: 'Freinage brusque (Sum)', value: 'hardBraking' },
+    { label: 'Virages brusque', value: 'hardCornering' }]
+
+  let data = []
+  data = data.concat([{}])
+  /*data = data.concat(reportData.map(d => {
+    return {
+      name: d.device,
+      totalUse: convertMS((d.drivingTime + d.idleTime) * 1000),
+      drivingTime: convertMS(d.drivingTime * 1000),
+      idleTime: convertMS(d.idleTime * 1000),
+      totalConsumption: d.drivingConsumption + d.idleConsumption,
+      drivingConsumption: d.drivingConsumption,
+      idleConsumption: d.idleConsumption,
+      drivingDistance: d.drivingDistance,
+      economicTime: convertMS(d.economicTime * 1000),
+      economicConsumption: d.economicConsumption,
+      economicDistance: d.economicDistance,
+      cruiseControlTime: convertMS(d.cruiseControlTime * 1000),
+      cruiseControlConsumption: d.cruiseControlConsumption,
+      cruiseControlDistance: d.cruiseControlDistance,
+      highEngineRPM: d.highEngineRPM,
+      hardAcceleration: d.hardAcceleration,
+      hardBraking: d.hardBraking,
+      hardCornering: d.hardCornering
+    }
+  }))*/
+
+  console.log(data)
+
+  return {
+    headers,
+    data,
+    settings
+  }
+}
+
 exports.createPerformanceReport = createPerformanceReport
+exports.exportPerformanceReportToPDF = exportPerformanceReportToPDF
+exports.exportPerformanceReportToExcel = exportPerformanceReportToExcel

package/src/tests/gpsjump.test.js

@@ -0,0 +1,23 @@
+const { getReports } = require('./index')
+const assert = require('assert')
+const { convertMS } = require('../util/utils')
+const { createGPSJumpReport } = require('../partnerReports/gpsjump-report')
+
+// eslint-disable-next-line no-undef
+describe('gpsjump', function () {
+  // eslint-disable-next-line no-undef
+  it('gpsjump report', async () => {
+    const report = await getReports()
+    const userData = await report.getUserData()
+    userData.devices = userData.devices.filter(d => d.id === 22326)
+    const data = await createGPSJumpReport(
+      new Date(Date.UTC(2023, 6, 1, 0, 0, 0, 0)),
+      new Date(Date.UTC(2023, 6, 17, 23, 59, 59, 0)),
+      userData,
+      report.traccar)
+    console.log(data)
+    assert.equal(data[0].consumption, 19.799999999999997)
+    assert.equal(data[0].distance, 326.7657)
+    assert.equal(convertMS(data[1].time * 1000, false), '08:19')
+  }, 8000000)
+})

package/src/tests/zones.test.js

@@ -61,4 +61,21 @@ describe('zones', function () {
     assert.equal(first.days[0].distanceOut, 0)
     assert.equal(first.days[2].distanceOut, 0)
   }, 4000000)
+
+  it('works with casais zones in columns 2', async () => {
+    const report = await getReports()
+    const userData = await report.getUserData()
+    userData.zonesByColumn = true
+    userData.devices = userData.devices.filter(d => d.id === 81201)
+    userData.geofences = userData.geofences.filter(g => g.name === 'baliza 1 - raio verde ' ||
+        g.name === 'baliza 2 - raio amarelo')
+    userData.onlyWithKmsOut = false
+    const result = await report.zoneReport(
+      new Date(Date.UTC(2023, 7, 7, 0, 0, 0, 0)),
+      new Date(Date.UTC(2023, 7, 7, 23, 59, 59, 0)),
+      userData)
+    const first = result[0].devices[0]
+    console.log(first)
+    assert.equal(first.days[0].distanceOut, 554.6037095121401)
+  }, 4000000)
 })

package/src/zone-report.js

@@ -270,6 +270,19 @@ function getAnyNextIn (outDate, alerts, deviceRoute) {
   }
 }
 
+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
 
@@ -297,7 +310,7 @@ function calculateDistanceOut (zoneInOutDayData, dayRoute, fromByDay, toByDay, f
     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) {
+    if (zoneInOutDayData[0].inTime && new Date(zoneInOutDayData[0].inTime.fixTime) > fromByDay && (field !== 'distanceOutAny' || zoneInOutDayData[0].anyLastExit)) {
       // Add distanceOut before the first entry
       const routeOut = dayRoute.filter(p =>
         new Date(p.fixTime).getTime() < new Date(zoneInOutDayData[0].inTime.fixTime).getTime() &&
@@ -306,7 +319,8 @@ function calculateDistanceOut (zoneInOutDayData, dayRoute, fromByDay, toByDay, f
       distanceOut = distanceOut + calculateDistance(routeOut, device.attributes['report.ignoreOdometer'])
     }
 
-    if (zoneInOutDayData[zoneInOutDayData.length - 1].outTime && new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) < toByDay) {
+    if (zoneInOutDayData[zoneInOutDayData.length - 1].outTime && new Date(zoneInOutDayData[zoneInOutDayData.length - 1].outTime.fixTime) < toByDay && (field !== 'distanceOutAny' || zoneInOutDayData[zoneInOutDayData.length - 1].anyNextIn)) {
+      // 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() &&
@@ -322,7 +336,7 @@ function calculateDistanceOut (zoneInOutDayData, dayRoute, fromByDay, toByDay, f
 
 function analyseAlerts (alerts, deviceRoute, userData, from, to, device) {
   const zoneInOutData = []
-  const zoneInData = {}
+  let zoneInData = []
 
   alerts.forEach(a => {
     if (!a.position) {
@@ -331,7 +345,12 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to, device) {
     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
+      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) {
@@ -346,34 +365,41 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to, device) {
       const totalOutTime = nextIn - outDate
       const distanceOut = calculateDistance(routeAfterOut, device.attributes['report.ignoreOdometer'])
 
-      const anyNextIn = getAnyNextIn(outDate, alerts, deviceRoute)
-      const routeAfterOutAndBeforeAnyNextIn = deviceRoute.filter(p =>
-        new Date(p.fixTime).getTime() >= outDate &&
-          new Date(p.fixTime).getTime() <= anyNextIn
-      )
-      const distanceOutAny = Object.keys(zoneInData).length < 2 ? Math.round(calculateDistance(routeAfterOutAndBeforeAnyNextIn, device.attributes['report.ignoreOdometer'])) : 0
+      let anyNextIn
+      let distanceOutAny = 0
+      if (zoneInData.length < 2) {
+        anyNextIn = getAnyNextIn(outDate, alerts, deviceRoute)
+        const routeAfterOutAndBeforeAnyNextIn = deviceRoute.filter(p =>
+          new Date(p.fixTime).getTime() >= outDate &&
+            new Date(p.fixTime).getTime() <= anyNextIn
+        )
+        distanceOutAny = zoneInData.length < 2 ? Math.round(calculateDistance(routeAfterOutAndBeforeAnyNextIn, device.attributes['report.ignoreOdometer'])) : 0
+      }
 
-      if (zoneInData[a.geofenceId]) {
-        const totalInTime = new Date(a.position.fixTime).getTime() - new Date(zoneInData[a.geofenceId].position.fixTime).getTime()
-        const inDate = new Date(zoneInData[a.geofenceId].position.fixTime).getTime()
+      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: zoneInData[a.geofenceId].position,
+          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.ignition).length > 0,
-          driverName: zoneInData[a.geofenceId].position.driverName
+          driverName: inData.position.driverName
         })
-        delete zoneInData[a.geofenceId]
+        zoneInData = zoneInData.filter(z => z.geofenceId === a.geofenceId)
       } else {
         const totalInTime = new Date(a.position.fixTime).getTime() - from.getTime()
         const routeIn = deviceRoute.filter(p =>
@@ -389,35 +415,36 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to, device) {
           distanceIn: calculateDistance(routeIn, device.attributes['report.ignoreOdometer']),
           driverName: '',
           distanceOut,
-          distanceOutAny
+          distanceOutAny,
+          anyNextIn,
+          anyLastExit: a.anyLastExit
         })
       }
     }
   })
 
-  for (const i in zoneInData) {
-    if (zoneInData[i]) {
-      const geofence = userData.geofences.find(g => g.id === zoneInData[i].geofenceId)
-      if (geofence) {
-        const totalInTime = to.getTime() - new Date(zoneInData[i].position.fixTime).getTime()
-        const routeIn = deviceRoute.filter(p =>
-          new Date(p.fixTime).getTime() >= new Date(zoneInData[i].position.fixTime).getTime() &&
+  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: zoneInData[i].position,
-          totalInTime,
-          distanceIn: calculateDistance(routeIn, device.attributes['report.ignoreOdometer']),
-          geofenceName: geofence.name,
-          geofenceId: geofence.id,
-          driverName: zoneInData[i].position.driverName
-        })
-      }
+      )
+      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 === 'geofenceIn')
+    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,