fleetmap-reports 2.0.356 → 2.0.358

package/lang/enGB.js

@@ -193,7 +193,25 @@ module.exports = {
     titleIdleReport: 'Idle Report',
     titleMachinesReport: 'Machines Report',
     titleStopReport: 'Stop Report',
+    titleDriverRankingReport: 'Driver Ranking Report',
     titleSensorReport: 'Sensor Report',
+    rank: 'Rank',
+    grade: 'Grade',
+    safetyScore: 'Safety',
+    efficiencyScore: 'Efficiency',
+    complianceScore: 'Compliance',
+    score: 'Overall Score',
+    avgFuelConsumption: 'Avg. L/100km',
+    highEngineRPM: 'High RPM',
+    hardBraking: 'Hard Braking',
+    hardAcceleration: 'Hard Acceleration',
+    hardCornering: 'Hard Cornering',
+    overspeedAlarm: 'Speeding',
+    geofenceAlarm: 'Seatbelt',
+    continuesDrivingAlarm: 'Continuous Driving',
+    reverseAlarm: 'Reverse Gear',
+    otherAlarm: 'Other',
+    detailedMetrics: 'Detailed metrics',
     from: 'From',
     to: 'to',
     headerStartAddress: 'Start address',

package/lang/esCL.js

@@ -183,7 +183,25 @@ module.exports = {
     titleIdleReport: 'Informe de Ralenti',
     titleMachinesReport: 'Informe de Maquinas',
     titleStopReport: 'Informe de Paradas',
+    titleDriverRankingReport: 'Informe de Ranking de Conductores',
     titleSensorReport: 'Informe de Sensores',
+    rank: 'Posición',
+    grade: 'Calificación',
+    safetyScore: 'Seguridad',
+    efficiencyScore: 'Eficiencia',
+    complianceScore: 'Cumplimiento',
+    score: 'Puntuación General',
+    avgFuelConsumption: 'Consumo Prom. L/100km',
+    highEngineRPM: 'RPM Alto',
+    hardBraking: 'Frenado Brusco',
+    hardAcceleration: 'Aceleración Brusca',
+    hardCornering: 'Giro Brusco',
+    overspeedAlarm: 'Exceso de Velocidad',
+    geofenceAlarm: 'Cinturón de Seguridad',
+    continuesDrivingAlarm: 'Conducción Continua',
+    reverseAlarm: 'Marcha Atrás',
+    otherAlarm: 'Otros',
+    detailedMetrics: 'Métricas detalladas',
     from: 'De',
     to: 'a',
     headerStartAddress: 'Lugar de início',

package/lang/frFR.json

@@ -297,7 +297,13 @@
     "geofenceAlarm": "Ceinture",
     "continuesDrivingAlarm": "Cond. Continue",
     "reverseAlarm": "Marche Arriere",
-    "otherAlarm": "Other"
+    "otherAlarm": "Other",
+    "rank": "Rang",
+    "grade": "Note",
+    "safetyScore": "Sécurité",
+    "efficiencyScore": "Efficacité",
+    "complianceScore": "Conformité",
+    "detailedMetrics": "Métriques détaillées"
   },
   "layout": {
     "deviceOnline": "Appareil en ligne",

package/lang/ptBR.js

@@ -185,7 +185,25 @@ module.exports = {
     titleIdleReport: 'Relatórios de Ralenti',
     titleMachinesReport: 'Relatório de Máquinas',
     titleStopReport: 'Relatório de Paragens',
+    titleDriverRankingReport: 'Relatório de Ranking de Motoristas',
     titleSensorReport: 'Relatório de Sensores',
+    rank: 'Posição',
+    grade: 'Nota',
+    safetyScore: 'Segurança',
+    efficiencyScore: 'Eficiência',
+    complianceScore: 'Conformidade',
+    score: 'Pontuação Geral',
+    avgFuelConsumption: 'Consumo Médio L/100km',
+    highEngineRPM: 'RPM Alta',
+    hardBraking: 'Frenagem Brusca',
+    hardAcceleration: 'Aceleração Brusca',
+    hardCornering: 'Curva Brusca',
+    overspeedAlarm: 'Excesso de Velocidade',
+    geofenceAlarm: 'Cinto de Segurança',
+    continuesDrivingAlarm: 'Condução Contínua',
+    reverseAlarm: 'Marcha à Ré',
+    otherAlarm: 'Outros',
+    detailedMetrics: 'Métricas detalhadas',
     from: 'De',
     to: 'a',
     headerStartAddress: 'Local de início',

package/lang/ptPT.js

@@ -191,7 +191,25 @@ module.exports = {
     titleIdleReport: 'Relatórios de Ralenti',
     titleMachinesReport: 'Relatório de Máquinas',
     titleStopReport: 'Relatório de Paragens',
+    titleDriverRankingReport: 'Relatório de Ranking de Condutores',
     titleSensorReport: 'Relatório de Sensores',
+    rank: 'Posição',
+    grade: 'Nota',
+    safetyScore: 'Segurança',
+    efficiencyScore: 'Eficiência',
+    complianceScore: 'Conformidade',
+    score: 'Pontuação Geral',
+    avgFuelConsumption: 'Consumo Médio L/100km',
+    highEngineRPM: 'RPM Alto',
+    hardBraking: 'Travagem Brusca',
+    hardAcceleration: 'Aceleração Brusca',
+    hardCornering: 'Curva Brusca',
+    overspeedAlarm: 'Excesso de Velocidade',
+    geofenceAlarm: 'Cinto de Segurança',
+    continuesDrivingAlarm: 'Condução Contínua',
+    reverseAlarm: 'Marcha-atrás',
+    otherAlarm: 'Outros',
+    detailedMetrics: 'Métricas detalhadas',
     from: 'De',
     to: 'a',
     headerStartAddress: 'Local de início',

package/package.json

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

package/src/partnerReports/driverranking-report.js

@@ -24,6 +24,39 @@ const continuesDrivingCoefficient = 0.1
 const reverseCoefficient = 0.1
 const otherCoefficient = 0.1
 
+const grades = [
+  { min: 90, grade: 'A' },
+  { min: 75, grade: 'B' },
+  { min: 60, grade: 'C' },
+  { min: 40, grade: 'D' },
+  { min: -Infinity, grade: 'F' }
+]
+
+// Converts a "the lower the better" metric into a 0-100 score (100 = met target, 0 = twice the target or worse)
+function goodnessScore (actual, target) {
+  if (!target || target <= 0) {
+    return 100
+  }
+  return Math.max(0, Math.min(100, 100 * (1 - (actual / target))))
+}
+
+// Same as goodnessScore, but for metrics where deviating from the target in either direction is bad (e.g. distance)
+function deviationScore (actual, target) {
+  if (!target || target <= 0) {
+    return 100
+  }
+  return Math.max(0, Math.min(100, 100 * (1 - (Math.abs(actual - target) / target))))
+}
+
+function weightedAverage (metrics) {
+  const totalWeight = metrics.reduce((sum, m) => sum + m.weight, 0)
+  return metrics.reduce((sum, m) => sum + (m.value * m.weight), 0) / totalWeight
+}
+
+function toGrade (score) {
+  return grades.find(g => score >= g.min).grade
+}
+
 async function create (from, to, userData, traccar) {
   const reportData = {
     drivers: []
@@ -67,28 +100,37 @@ async function create (from, to, userData, traccar) {
       await processDevice(driversData, device, userData, { route, trips }, deviceAlarmEvents, deviceOverspeedEvents)
       deviceCount++
     }
+
+    console.log('LOADING_MESSAGE:' + slice[0].name)
+    console.log(`PROGRESS_PERC:${deviceCount / devices.length * 100}`)
   }
 
   const allDriversData = (Array.from(driversData.values())).filter(d => d.distance > 0)
   allDriversData.forEach(d => {
-    const distanceScore = (Math.abs(d.distance - userData.distanceTarget) / userData.distanceTarget) * distanceCoefficient
-    const rpmScore = ((d.highEngineRPM / 60000) / userData.rpmTarget) * rpmCoefficient
-    const hardBrakingScore = (d.hardBraking / userData.hardBrakingTarget) * hardBrakingCoefficient
-    const hardAccelerationScore = (d.hardAcceleration / userData.hardAccelerationTarget) * hardAccelerationCoefficient
-    const hardCorneringScore = (d.hardCornering / userData.hardCorneringTarget) * hardCorneringCoefficient
-    const overspeedScore = (d.overspeed / userData.overspeedTarget) * overspeedCoefficient
-    const consumptionScore = (getCanAvgConsumption(d.distance, d.spentFuel).byKms / userData.fuelConsumptionTarget) * consumptionCoefficient
-    const geofenceAlarmScore = (d.geofenceAlarm / userData.geofenceTarget) * geofenceCoefficient
-    const continuesDrivingAlarmScore = (d.continuesDrivingAlarm / userData.continuesDrivingTarget) * continuesDrivingCoefficient
-    const reverseAlarmScore = (d.reverseAlarm / userData.reverseTarget) * reverseCoefficient
-    const otherAlarmScore = (d.otherAlarm / userData.otherTarget) * otherCoefficient
-
     d.avgFuelConsumption = getCanAvgConsumption(d.distance, d.spentFuel).byKms
-    d.score = distanceScore + rpmScore + hardBrakingScore + hardAccelerationScore +
-        hardCorneringScore + consumptionScore + overspeedScore + geofenceAlarmScore +
-        continuesDrivingAlarmScore + reverseAlarmScore + otherAlarmScore
+
+    d.safetyScore = weightedAverage([
+      { value: goodnessScore(d.hardBraking, userData.hardBrakingTarget), weight: hardBrakingCoefficient },
+      { value: goodnessScore(d.hardAcceleration, userData.hardAccelerationTarget), weight: hardAccelerationCoefficient },
+      { value: goodnessScore(d.hardCornering, userData.hardCorneringTarget), weight: hardCorneringCoefficient },
+      { value: goodnessScore(d.overspeed, userData.overspeedTarget), weight: overspeedCoefficient },
+      { value: goodnessScore(d.reverseAlarm, userData.reverseTarget), weight: reverseCoefficient }
+    ])
+    d.efficiencyScore = weightedAverage([
+      { value: deviationScore(d.distance, userData.distanceTarget), weight: distanceCoefficient },
+      { value: goodnessScore(d.avgFuelConsumption, userData.fuelConsumptionTarget), weight: consumptionCoefficient },
+      { value: goodnessScore(d.highEngineRPM / 60000, userData.rpmTarget), weight: rpmCoefficient }
+    ])
+    d.complianceScore = weightedAverage([
+      { value: goodnessScore(d.geofenceAlarm, userData.geofenceTarget), weight: geofenceCoefficient },
+      { value: goodnessScore(d.continuesDrivingAlarm, userData.continuesDrivingTarget), weight: continuesDrivingCoefficient },
+      { value: goodnessScore(d.otherAlarm, userData.otherTarget), weight: otherCoefficient }
+    ])
+    d.overallScore = (d.safetyScore + d.efficiencyScore + d.complianceScore) / 3
+    d.grade = toGrade(d.overallScore)
   })
-  allDriversData.sort((a, b) => (a.score > b.score) ? 1 : -1)
+  allDriversData.sort((a, b) => b.overallScore - a.overallScore)
+  allDriversData.forEach((d, index) => { d.rank = index + 1 })
 
   reportData.drivers.push(...allDriversData)
 
@@ -204,7 +246,13 @@ async function exportToExcel (userData, reportData) {
   }
 
   const headers = [
+    { label: translations.report.rank, value: 'rank' },
     { label: translations.report.driver, value: 'name' },
+    { label: translations.report.grade, value: 'grade' },
+    { label: translations.report.score, value: 'overallScore' },
+    { label: translations.report.safetyScore, value: 'safetyScore' },
+    { label: translations.report.efficiencyScore, value: 'efficiencyScore' },
+    { label: translations.report.complianceScore, value: 'complianceScore' },
     { label: translations.report.distance, value: 'distance' },
     { label: translations.report.avgFuelConsumption, value: 'avgFuelConsumption' },
     { label: translations.report.highEngineRPM, value: 'highEngineRPM' },
@@ -215,16 +263,21 @@ async function exportToExcel (userData, reportData) {
     { label: translations.report.geofenceAlarm, value: 'geofenceAlarm' },
     { label: translations.report.continuesDrivingAlarm, value: 'continuesDrivingAlarm' },
     { label: translations.report.reverseAlarm, value: 'reverseAlarm' },
-    { label: translations.report.otherAlarm, value: 'otherAlarm' },
-    { label: translations.report.score, value: 'score' }
+    { label: translations.report.otherAlarm, value: 'otherAlarm' }
   ]
 
   let data = []
   if (reportDataRows) {
     reportDataRows.forEach(row => {
       data = data.concat({
+        rank: row.rank,
         name: row.name,
-        distance: Number(row.distance.toFixed(1)),
+        grade: row.grade,
+        overallScore: Math.round(row.overallScore),
+        safetyScore: Math.round(row.safetyScore),
+        efficiencyScore: Math.round(row.efficiencyScore),
+        complianceScore: Math.round(row.complianceScore),
+        distance: Number((row.distance / 1000).toFixed(1)),
         avgFuelConsumption: Number(row.avgFuelConsumption.toFixed(2)),
         highEngineRPM: convertMS(row.highEngineRPM, false),
         hardBraking: row.hardBraking,
@@ -234,11 +287,9 @@ async function exportToExcel (userData, reportData) {
         geofenceAlarm: row.geofenceAlarm,
         continuesDrivingAlarm: row.continuesDrivingAlarm,
         reverseAlarm: row.reverseAlarm,
-        otherAlarm: row.otherAlarm,
-        score: Number(row.score.toFixed(2))
+        otherAlarm: row.otherAlarm
       })
     })
-    console.log(data)
     return {
       headers,
       data,
@@ -247,15 +298,33 @@ async function exportToExcel (userData, reportData) {
   }
 }
 
+const gradeColors = {
+  A: { fill: [200, 236, 204], text: [30, 110, 40] },
+  B: { fill: [223, 240, 196], text: [66, 110, 30] },
+  C: { fill: [255, 236, 179], text: [153, 101, 0] },
+  D: { fill: [255, 205, 178], text: [166, 74, 0] },
+  F: { fill: [255, 205, 210], text: [153, 0, 20] }
+}
+
 async function exportToPDF (userData, reportData) {
-  console.log('exportDelayedStartReportToPDF')
+  console.log('exportDriverRankingReportToPDF')
 
   const timezone = userData.user.attributes.timezone
   const translations = getTranslations(userData)
   const lang = userData.user.attributes.lang || (isClientSide() && navigator.language)
   const reportDataRows = reportData.drivers
 
-  const headers = [
+  const scoreboardHeaders = [
+    translations.report.rank,
+    translations.report.driver,
+    translations.report.grade,
+    translations.report.score,
+    translations.report.safetyScore,
+    translations.report.efficiencyScore,
+    translations.report.complianceScore
+  ]
+
+  const detailHeaders = [
     translations.report.driver,
     translations.report.distance,
     translations.report.avgFuelConsumption,
@@ -267,8 +336,7 @@ async function exportToPDF (userData, reportData) {
     translations.report.geofenceAlarm,
     translations.report.continuesDrivingAlarm,
     translations.report.reverseAlarm,
-    translations.report.otherAlarm,
-    translations.report.score
+    translations.report.otherAlarm
   ]
 
   if (reportDataRows) {
@@ -279,30 +347,66 @@ async function exportToPDF (userData, reportData) {
     doc.setFontSize(13)
     doc.text(convertToLocaleString(reportData.from, lang, timezone, userData.user) + ' - ' + convertToLocaleString(reportData.to, lang, timezone, userData.user), 20, 25)
 
-    const data = []
-    reportDataRows.forEach(function (row) {
-      const temp = [
-        row.name,
-        row.distance.toFixed(1),
-        row.avgFuelConsumption.toFixed(2),
-        convertMS(row.highEngineRPM, false),
-        row.hardBraking,
-        row.hardAcceleration,
-        row.hardCornering,
-        row.overspeed,
-        row.geofenceAlarm,
-        row.continuesDrivingAlarm,
-        row.reverseAlarm,
-        row.otherAlarm,
-        row.score.toFixed(2)
-      ]
-      data.push(temp)
-    })
-    const footValues = []
+    const scoreboardData = reportDataRows.map(row => [
+      row.rank,
+      row.name,
+      row.grade,
+      Math.round(row.overallScore),
+      Math.round(row.safetyScore),
+      Math.round(row.efficiencyScore),
+      Math.round(row.complianceScore)
+    ])
 
     const style = getStyle(getUserPartner(userData.user))
 
-    addTable(doc, headers, data, footValues, style, 40, {
+    addTable(doc, scoreboardHeaders, scoreboardData, [], style, 40, {
+      0: { halign: 'center' },
+      2: { halign: 'center' },
+      3: { halign: 'right' },
+      4: { halign: 'right' },
+      5: { halign: 'right' },
+      6: { halign: 'right' }
+    }, (cellData) => {
+      if (cellData.section !== 'body') {
+        return
+      }
+      const row = reportDataRows[cellData.row.index]
+      if (!row) {
+        return
+      }
+      if (cellData.column.index === 0) {
+        cellData.cell.styles.fontStyle = row.rank <= 3 ? 'bold' : 'normal'
+      }
+      if (cellData.column.index === 2 || cellData.column.index === 3) {
+        const colors = gradeColors[row.grade]
+        cellData.cell.styles.fillColor = colors.fill
+        cellData.cell.styles.textColor = colors.text
+        cellData.cell.styles.fontStyle = 'bold'
+      }
+    })
+
+    const detailData = reportDataRows.map(row => [
+      row.name,
+      (row.distance / 1000).toFixed(1),
+      row.avgFuelConsumption.toFixed(2),
+      convertMS(row.highEngineRPM, false),
+      row.hardBraking,
+      row.hardAcceleration,
+      row.hardCornering,
+      row.overspeed,
+      row.geofenceAlarm,
+      row.continuesDrivingAlarm,
+      row.reverseAlarm,
+      row.otherAlarm
+    ])
+
+    const detailStartY = doc.lastAutoTable.finalY + 12
+    doc.setFontSize(10)
+    doc.setFont('helvetica', 'bold')
+    doc.text(translations.report.detailedMetrics, 15, detailStartY - 4)
+    doc.setFont('helvetica', 'normal')
+
+    addTable(doc, detailHeaders, detailData, [], { ...style, bodyFontSize: 7, headerFontSize: 8 }, detailStartY, {
       1: { halign: 'right' },
       2: { halign: 'right' },
       3: { halign: 'right' },
@@ -313,8 +417,7 @@ async function exportToPDF (userData, reportData) {
       8: { halign: 'right' },
       9: { halign: 'right' },
       10: { halign: 'right' },
-      11: { halign: 'right' },
-      12: { halign: 'right' }
+      11: { halign: 'right' }
     })
     return doc
   }

package/src/speeding-report.js

@@ -132,7 +132,17 @@ async function getEvents (traccarInstance, from, to, devices, userData, deviceCo
   if (processServerSide() && !userData.useVehicleSpeedLimit) {
     const cookie = await axios.get('/pinmeapi/cookie/get', { withCredentials: true }).then(d => d.data)
     const url = `https://${getServerHost()}/pinmeapi/reports/speeding-report/getEvents`
-    return axios.post(url, { from, to, devices, userData, deviceCount, totalDevices, sliceSize, cookie }, { withCredentials: true }).then(d => d.data)
+    const maxAttempts = 3
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await axios.post(url, { from, to, devices, userData, deviceCount, totalDevices, sliceSize, cookie }, { withCredentials: true, timeout: 60000 }).then(d => d.data)
+      } catch (e) {
+        console.log(`getEvents failed for devices [${devices.map(d => d.name).join(', ')}] (attempt ${attempt}/${maxAttempts}): ${e.message}`)
+        if (attempt === maxAttempts) {
+          return []
+        }
+      }
+    }
   } else {
     const geofencesFeatures = userData.geofences.filter(g => g.area && g.area.startsWith('POLYGON') &&
       g.attributes.speedLimit).map(g => convertToFeature(g))

package/src/util/pdfDocument.js

@@ -61,7 +61,7 @@ async function headerFromUser (doc, title, user, orientation = 'l') {
   return header(doc, title, partner && partner.host, getStyle(partner), orientation)
 }
 
-function addTable (doc, headers, data, footValues, style, startY, columnStyles = {}) {
+function addTable (doc, headers, data, footValues, style, startY, columnStyles = {}, didParseCell) {
   doc.autoTable({
     head: [headers],
     body: data,
@@ -97,6 +97,7 @@ function addTable (doc, headers, data, footValues, style, startY, columnStyles =
         })
       })
     },
+    ...(didParseCell ? { didParseCell } : {}),
     columnStyles,
     startY
   })