fleetmap-reports 2.0.357 → 2.0.358

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

@@ -0,0 +1,359 @@
+const automaticReports = require('../automaticReports')
+const traccarHelper = require('../util/traccar')
+const { getUncompletedTrip } = require('../util/trips')
+const { getEndTripMessages, getCanDriverStyleMessages, parseEndTripMessage, parseCanDriverStyleMessage } = require('../util/xpert')
+const { calculateDistance, getTranslations, convertMS } = require('../util/utils')
+const { addTable, headerFromUser } = require('../util/pdfDocument')
+const jsPDF = require('jspdf')
+const { getStyle } = require('../reportStyle')
+const { getUserPartner } = require('fleetmap-partners')
+const { calculateConsumption } = require('../util/fuel')
+
+async function createPerformanceReportSingle (from, to, userData, traccar) {
+  const reportData = []
+
+  const allInOne = await traccarHelper.getAllInOne(traccar, from, to, userData.devices.slice(0, 1), true, true, true, true)
+
+  const device = userData.devices[0]
+
+  if (!device) { return [] }
+
+  const {
+    drivingTime, idleTime, cruiseControlTime, economicTime, highEngineRPM, hardBraking, hardAcceleration, hardCornering,
+    drivingConsumption, idleConsumption, cruiseControlConsumption, economicConsumption, drivingDistance, cruiseControlDistance,
+    economicDistance
+  } = getDeviceData(allInOne, device)
+
+  const totalTime = drivingTime + idleTime
+  const totalConsumption = drivingConsumption + idleConsumption
+
+  const totalIndicator = (drivingDistance > 0 ? totalConsumption * 100 / drivingDistance : 0).toFixed(1) + ' L/100'
+  const drivingIndicator = (drivingDistance > 0 ? drivingConsumption * 100 / drivingDistance : 0).toFixed(1) + ' L/100'
+  const idleIndicator = (totalConsumption > 0 ? idleConsumption * 100 / totalConsumption : 0).toFixed(1) + ' %'
+  const economicIndicator = (totalTime > 0 ? economicTime * 100 / totalTime : 0).toFixed(1) + ' %'
+  const cruiseControlIndicator = (totalTime > 0 ? cruiseControlTime * 100 / totalTime : 0).toFixed(1) + ' %'
+  const highEngineRPMIndicator = (totalTime > 0 ? highEngineRPM * 100 / totalTime : 0).toFixed(1) + ' %'
+  const hardBrakingIndicator = (drivingDistance > 0 ? hardBraking * 100 / drivingDistance : 0).toFixed(0) + ' Freinage/100 Km'
+  const hardAccelerationIndicator = (drivingDistance > 0 ? hardAcceleration * 100 / drivingDistance : 0).toFixed(0) + ' Accélération/100 Km'
+  const hardCorneringIndicator = (drivingDistance > 0 ? hardCornering * 100 / drivingDistance : 0).toFixed(0) + ' Virages/100 Km'
+
+  const drivingUse = Math.round(totalTime > 0 ? drivingTime * 100 / totalTime : 0)
+  const idleUse = Math.round(totalTime > 0 ? idleTime * 100 / totalTime : 0)
+
+  const engineEconomicRPM = Math.round(totalTime > 0 ? economicTime * 100 / totalTime : 0)
+  const engineHighRPM = Math.round(totalTime > 0 ? highEngineRPM * 100 / totalTime : 0)
+  const engineOtherRPM = 100 - (engineEconomicRPM + engineHighRPM)
+
+  const cruiseControlOn = Math.round(totalTime > 0 ? cruiseControlTime * 100 / totalTime : 0)
+  const cruiseControlOff = 100 - cruiseControlOn
+
+  const totalData = getRowData(1, device, 'Totale', totalTime, totalConsumption, drivingDistance, totalIndicator, 0, 0, 0)
+  const drivingData = getRowData(2, device, 'Conduite', drivingTime, drivingConsumption, drivingDistance, drivingIndicator, drivingUse, engineOtherRPM, cruiseControlOff)
+  const idleData = getRowData(3, device, 'Ralenti', idleTime, idleConsumption, '', idleIndicator, idleUse, 0, 0)
+  const economicData = getRowData(4, device, 'Économique', economicTime, economicConsumption, economicDistance, economicIndicator, 0, engineEconomicRPM, 0)
+  const cruiseControlData = getRowData(5, device, 'Cruise Control', cruiseControlTime, cruiseControlConsumption, cruiseControlDistance, cruiseControlIndicator, 0, 0, cruiseControlOn)
+  const highEngineRPMData = getRowData(6, device, 'Tour moteur élevé', highEngineRPM, '', '', highEngineRPMIndicator, 0, engineHighRPM, 0)
+  const hardBrakingData = getRowData(7, device, 'Freinage brusque', hardBraking, '', '', hardBrakingIndicator, 0, 0, 0)
+  const hardAccelerationData = getRowData(8, device, 'Accéleration brusque', hardAcceleration, '', '', hardAccelerationIndicator, 0, 0, 0)
+  const hardCorneringData = getRowData(9, device, 'Virages brusque', hardCornering, '', '', hardCorneringIndicator, 0, 0, 0)
+
+  reportData.push(totalData)
+  reportData.push(drivingData)
+  reportData.push(idleData)
+  reportData.push(economicData)
+  reportData.push(cruiseControlData)
+  reportData.push(highEngineRPMData)
+  reportData.push(hardBrakingData)
+  reportData.push(hardAccelerationData)
+  reportData.push(hardCorneringData)
+  return reportData
+}
+async function createPerformanceReport (from, to, userData, traccar) {
+  const reportData = []
+
+  const devices = userData.devices
+
+  const sliced = automaticReports.sliceArray(devices, 5)
+  let deviceCount = 0
+  for (const slice of sliced) {
+    const allInOne = await traccarHelper.getAllInOne(traccar, from, to, slice, true, true, true, true, deviceCount, devices.length)
+
+    slice.forEach(d => {
+      const deviceData = getDeviceData(allInOne, d)
+      deviceData.device = d.name
+      reportData.push(deviceData)
+    })
+
+    deviceCount = deviceCount + slice.length
+  }
+  return reportData
+}
+
+function getDeviceData (allInOne, d) {
+  const deviceRoute = allInOne.route.filter(t => t.deviceId === d.id)
+  const deviceTrips = allInOne.trips.filter(t => t.deviceId === d.id)
+
+  const uncompletedTrip = getUncompletedTrip(d, deviceRoute, deviceTrips)
+  if (uncompletedTrip) {
+    deviceTrips.push(uncompletedTrip)
+  }
+
+  if (deviceRoute.find(p => p.attributes.rawXpert)) {
+    // Inofleet unit with xpert data
+    const xpertMessages = deviceRoute.map(p => p.attributes.rawXpert).filter(a => a)
+    const endTripData = getEndTripMessages(xpertMessages).map(m => parseEndTripMessage(m.xpertString || m)).sort((a, b) => a.date.localeCompare(b.date))
+    const canDriverStyle = getCanDriverStyleMessages(xpertMessages).map(m => parseCanDriverStyleMessage(m.xpertString || m)).sort((a, b) => a.date.localeCompare(b.date))
+
+    const drivingTime = endTripData.length > 1 ? endTripData[endTripData.length - 1].totalTimeDriving - endTripData[0].totalTimeDriving : 0
+    const idleTime = endTripData.length > 1 ? (endTripData[endTripData.length - 1].totalTimeInIdle || 0) - (endTripData[0].totalTimeInIdle || 0) : 0
+    const cruiseControlTime = endTripData.length > 1 ? endTripData[endTripData.length - 1].totalTimeWithCruiseControl - endTripData[0].totalTimeWithCruiseControl : 0
+    const economicTime = canDriverStyle.length > 1 ? canDriverStyle[canDriverStyle.length - 1].totalTimeInEcoRange - canDriverStyle[0].totalTimeInEcoRange : 0
+    const highEngineRPM = canDriverStyle.length > 1 ? canDriverStyle[canDriverStyle.length - 1].totalTimeWithHighRpmAndTorque - canDriverStyle[0].totalTimeWithHighRpmAndTorque : 0
+    const hardBraking = canDriverStyle.length > 1 ? canDriverStyle[canDriverStyle.length - 1].totalNumberOfHarshBrakes - canDriverStyle[0].totalNumberOfHarshBrakes : 0
+    const hardAcceleration = canDriverStyle.length > 1 ? canDriverStyle[canDriverStyle.length - 1].totalNumberOfHarshAccelerations - canDriverStyle[0].totalNumberOfHarshAccelerations : 0
+    const hardCornering = 0
+
+    const drivingConsumption = endTripData.length > 1 ? (endTripData[endTripData.length - 1].totalFuelConsumptionDriving - endTripData[0].totalFuelConsumptionDriving) * 0.1 : 0
+    const idleConsumption = endTripData.length > 1 ? (endTripData[endTripData.length - 1].totalFuelConsumptionInIdle - endTripData[0].totalFuelConsumptionInIdle) * 0.1 : 0
+    const cruiseControlConsumption = endTripData.length > 1 ? (endTripData[endTripData.length - 1].totalFuelConsumptionWithCruiseControl - endTripData[0].totalFuelConsumptionWithCruiseControl) * 0.1 : 0
+    const economicConsumption = canDriverStyle.length > 1 ? (canDriverStyle[canDriverStyle.length - 1].totalFuelConsumptionInEcoRange - canDriverStyle[0].totalFuelConsumptionInEcoRange) * 0.1 : 0
+
+    const drivingDistance = endTripData.length > 1 ? endTripData[endTripData.length - 1].totalDistanceTravelled - endTripData[0].totalDistanceTravelled : 0
+    const cruiseControlDistance = endTripData.length > 1 ? endTripData[endTripData.length - 1].totalDistanceTravelledWithCruiseControl - endTripData[0].totalDistanceTravelledWithCruiseControl : 0
+    const economicDistance = canDriverStyle.length > 1 ? canDriverStyle[canDriverStyle.length - 1].totalDistanceInEcoRange - canDriverStyle[0].totalDistanceInEcoRange : 0
+
+    return {
+      drivingTime,
+      idleTime,
+      cruiseControlTime,
+      economicTime,
+      highEngineRPM,
+      hardBraking,
+      hardAcceleration,
+      hardCornering,
+      drivingConsumption,
+      idleConsumption,
+      cruiseControlConsumption,
+      economicConsumption,
+      drivingDistance,
+      cruiseControlDistance,
+      economicDistance
+    }
+  } else {
+    const deviceSummary = allInOne.summary.filter(t => t.deviceId === d.id)[0]
+    const deviceStops = allInOne.stops.filter(t => t.deviceId === d.id)
+
+    const drivingTime = deviceTrips.reduce((a, b) => a + b.duration, 0)
+    const drivingConsumption = calculateConsumption(d, { trips: deviceTrips, stops: [], route: deviceRoute, summary: deviceSummary })
+    const drivingDistance = deviceSummary ? deviceSummary.distance / 1000 : 0
+    const idleTime = deviceTrips.reduce((a, b) => a + (b.idleTime ? b.idleTime : 0), 0) + deviceStops.reduce((a, b) => a + b.engineHours, 0)
+    const idleConsumption = deviceSummary && deviceSummary.spentFuel > drivingConsumption ? deviceSummary.spentFuel - drivingConsumption : 0
+
+    const highEngineRPMSections = calculateRPMSections(deviceRoute, d.attributes.highRPM || 1300)
+    const highEngineRPM = highEngineRPMSections.map(a => a.length > 1
+      ? a.map((p, index) => index === 0 ? 0 : new Date(p.fixTime).getTime() - new Date(a[index - 1].fixTime).getTime()).reduce((a, b) => a + b, 0)
+      : 0).reduce((a, b) => a + b, 0)
+
+    const economicRPMSections = calculateRPMSections(deviceRoute, d.attributes.minEconomicRPM || 1000, d.attributes.maxEconomicRPM || 1250)
+    const economicTime = economicRPMSections.map(a => a.length > 1
+      ? a.map((p, index) => index === 0 ? 0 : new Date(p.fixTime).getTime() - new Date(a[index - 1].fixTime).getTime()).reduce((a, b) => a + b, 0)
+      : 0).reduce((a, b) => a + b, 0)
+    const economicDistance = economicRPMSections.map(a => a.length > 1
+      ? calculateDistance(a, d.attributes['report.ignoreOdometer'])
+      : 0).reduce((a, b) => a + b, 0)
+    const economicConsumption = economicRPMSections.map(a => a.length > 1
+      ? a[a.length - 1].attributes.fuelUsed - a[0].attributes.fuelUsed
+      : 0).reduce((a, b) => a + (b || 0), 0)
+
+    const hardBraking = deviceRoute.filter(p => p.attributes.alarm === 'hardBraking').length
+    const hardAcceleration = deviceRoute.filter(p => p.attributes.alarm === 'hardAcceleration').length
+    const hardCornering = deviceRoute.filter(p => p.attributes.alarm === 'hardCornering').length
+
+    return {
+      drivingTime: drivingTime / 1000,
+      idleTime: idleTime / 1000,
+      cruiseControlTime: 0,
+      economicTime: economicTime / 1000,
+      highEngineRPM: highEngineRPM / 1000,
+      hardBraking,
+      hardAcceleration,
+      hardCornering,
+      drivingConsumption,
+      idleConsumption,
+      cruiseControlConsumption: 0,
+      economicConsumption,
+      drivingDistance,
+      cruiseControlDistance: 0,
+      economicDistance
+    }
+  }
+}
+
+function getRowData (index, device, description, time, consumption, distance, indicator, use, rpm, cruiseControl) {
+  return {
+    index,
+    device: device.name,
+    description,
+    time,
+    consumption,
+    distance,
+    indicator,
+    use,
+    rpm,
+    cruiseControl
+  }
+}
+
+function calculateRPMSections (route, min, max) {
+  const sections = []
+  let newSection = true
+  route.forEach(p => {
+    const rpm = p.attributes.rpm
+    if ((!min || rpm > min) && (!max || rpm < max)) {
+      if (newSection) {
+        sections.push([p])
+      } else {
+        sections[sections.length - 1].push(p)
+      }
+      newSection = false
+    } else {
+      newSection = true
+    }
+  })
+
+  return sections
+}
+
+async 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')
+  await headerFromUser(doc, 'Rapport de Performance', userData.user)
+
+  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: Number(d.drivingDistance.toFixed(2)),
+      economicTime: convertMS(d.economicTime * 1000),
+      economicConsumption: Number(d.economicConsumption.toFixed(1)),
+      economicDistance: Number(d.economicDistance.toFixed(2)),
+      cruiseControlTime: convertMS(d.cruiseControlTime * 1000),
+      cruiseControlConsumption: Number(d.cruiseControlConsumption.toFixed(1)),
+      cruiseControlDistance: Number(d.cruiseControlDistance.toFixed(2)),
+      highEngineRPM: d.highEngineRPM,
+      hardAcceleration: d.hardAcceleration,
+      hardBraking: d.hardBraking,
+      hardCornering: d.hardCornering
+    }
+  }))
+
+  return {
+    headers,
+    data,
+    settings
+  }
+}
+
+exports.calculateRPMSections = calculateRPMSections
+exports.createPerformanceReport = createPerformanceReport
+exports.createPerformanceReportSingle = createPerformanceReportSingle
+exports.exportPerformanceReportToPDF = exportPerformanceReportToPDF
+exports.exportPerformanceReportToExcel = exportPerformanceReportToExcel