fleetmap-reports 1.0.956 → 1.0.958

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fleetmap-reports",
-  "version": "1.0.956",
+  "version": "1.0.958",
   "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/util/geofence.js

@@ -22,13 +22,15 @@ function getNearestPOIs (long, lat, geofences) {
     .filter(g => g && g.area.startsWith('CIRCLE'))
     .map(g => {
       const str = g.area.substring('CIRCLE ('.length, g.area.indexOf(','))
+      const radius = g.area.substring(g.area.indexOf(',') + 1, g.area.indexOf(')'))
       const coord = str.trim().split(' ')
       return {
         p: g,
-        distance: Math.round(coordsDistance(parseFloat(coord[1]), parseFloat(coord[0]), long, lat))
+        distance: Math.round(coordsDistance(parseFloat(coord[1]), parseFloat(coord[0]), long, lat)),
+        r: parseFloat(radius)
       }
     })
-  return distance.filter(a => a.distance < 100).sort((a, b) => (a.distance > b.distance) ? 1 : -1)
+  return distance.filter(a => a.distance < a.r).sort((a, b) => (a.distance > b.distance) ? 1 : -1)
 }
 exports.getNearestPOIs = getNearestPOIs
 

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 === 'geofenceExit' &&
+      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() &&
@@ -331,6 +345,10 @@ 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 : ''
+      if (Object.keys(zoneInData).length === 0) {
+        a.anyLastExit = getAnyLastExit(new Date(a.position.fixTime).getTime(), alerts, deviceRoute)
+      }
+
       zoneInData[a.geofenceId] = a
     } else if (a.type === 'geofenceExit') {
       const geofence = userData.geofences.find(g => g.id === a.geofenceId)
@@ -368,6 +386,8 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to, device) {
           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,
@@ -389,7 +409,9 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to, device) {
           distanceIn: calculateDistance(routeIn, device.attributes['report.ignoreOdometer']),
           driverName: '',
           distanceOut,
-          distanceOutAny
+          distanceOutAny,
+          anyNextIn,
+          anyLastExit: a.anyLastExit
         })
       }
     }
@@ -417,7 +439,7 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to, device) {
   }
 
   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,