fleetmap-reports 2.0.356 → 2.0.358

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

@@ -0,0 +1,360 @@
+const automaticReports = require('./automaticReports')
+const jsPDF = require('jspdf')
+require('jspdf-autotable')
+const { getStyle } = require('./reportStyle')
+const { headerFromUser } = require('./util/pdfDocument')
+const { getUserPartner } = require('fleetmap-partners')
+const {
+  convertToLocaleString, getTranslations, convertMS,
+  getLanguage
+} = require('./util/utils')
+const { devicesToProcess } = require('./util/device')
+const { isInside } = require('./util/timetable')
+const { getDigitalPortValue } = require('./location-report')
+const { maxParallelRequests } = require('./automaticReports')
+const { getNearestPOI } = require('./util/geofence')
+
+const fileName = 'EventReport'
+
+async function createEventsReport (from, to, userData, traccar) {
+  console.log('Create EventsReport')
+  const reportData = []
+
+  if (userData.byGroup) {
+    console.log('ByGroup')
+    for (const g of userData.groups) {
+      const devices = userData.devices.filter(d => d.groupId === g.id)
+      console.log(g.name + ' devices:' + devices.length)
+      if (devices.length > 0) {
+        const groupData = {
+          devices: [],
+          group: g,
+          xpert: devices.filter(d => d.attributes.xpert).length > 0
+        }
+
+        const data = await getReportData(from, to, devices, userData.eventTypes, traccar)
+
+        devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+
+        if (data.length > 0) {
+          groupData.devices = await processDevices(from, to, devices, data, traccar, userData)
+          reportData.push(groupData)
+        }
+      }
+    }
+  }
+
+  const devices = devicesToProcess(userData)
+
+  const data = await getReportData(from, to, devices, userData.eventTypes || [], traccar)
+
+  if (data.length > 0) {
+    reportData.push({
+      devices: await processDevices(from, to, devices, data, traccar, userData),
+      xpert: devices.filter(d => d.attributes.xpert).length > 0
+    })
+  }
+
+  return reportData
+}
+
+async function getReportData (from, to, devices, types, traccar) {
+  let data = []
+  const arrayOfArrays = automaticReports.sliceArray(devices)
+  const traccarTypes = new Set(types.map(t => t.startsWith('alarm') ? 'alarm' : t))
+  await Promise.all(arrayOfArrays.map(async a => {
+    const response = await traccar.reports.reportsEventsGet(from, to, a.map(d => d.id), null, traccarTypes)
+    data = data.concat(
+      response.data.filter(
+        e => types.find(t => t === e.type) || types.find(t => t.replace('alarm_', '') === e.attributes.alarm)
+      ))
+  }))
+  console.log('Alerts:' + data.length)
+  return data
+}
+
+async function processDevices (from, to, devices, data, traccar, userData) {
+  const devicesResult = []
+  let i = 0
+  for (let j = 0; j < devices.length; j += maxParallelRequests) {
+    await Promise.all(devices.slice(j, j + maxParallelRequests).map(async d => {
+      const deviceAlerts = data.filter(t => t.deviceId === d.id)
+      // events can arrive at bd very late, so we search with a 24 hours delay
+      const dayBefore = new Date(new Date(from).setDate(from.getDate() - 1))
+      const response = await traccar.reports.reportsRouteGet(dayBefore, to, [d.id])
+      const positions = response.data
+
+      for (const a of deviceAlerts) {
+        a.position = positions.find(p => p.id === a.positionId)
+
+        if (a.type === 'alarm' && a.position) {
+          for (const p of positions.filter(p => p.fixTime >= a.position.fixTime)) {
+            if (p.attributes.alarm !== a.position.attributes.alarm) { break }
+            a.endPosition = p
+          }
+        }
+
+        if (!a.geofenceId && a.position) {
+          const poi = getNearestPOI(a.position, userData.geofences)
+          a.geofenceId = poi && poi.p.id
+        }
+        if (a.geofenceId) {
+          const geofence = userData.geofences.find(g => g.id === a.geofenceId)
+          if (geofence) {
+            if (a.type === 'deviceOverspeed') {
+              a.geofenceName = geofence.name + ' (' + Math.round(a.attributes.speedLimit * 1.85200) + ' Km/h)'
+            } else {
+              a.geofenceName = geofence.name
+            }
+          }
+        }
+
+        if (a.position && a.position.attributes.driverUniqueId) {
+          const driver = userData.drivers.find(d => d.uniqueId === a.position.attributes.driverUniqueId)
+          a.driver = driver && driver.name
+        }
+      }
+
+      const alerts = deviceAlerts.filter(a => userData.allWeek || !userData.weekDays || (!a.position || isInside(a.position.fixTime, a.position.fixTime, userData)))
+        .filter(a => a.position).sort((a, b) => a.position.fixTime.localeCompare(b.position.fixTime))
+      console.log('LOADING_MESSAGE:' + d.name)
+      console.log(`PROGRESS_PERC:${++i / devices.length * 100}`)
+
+      if (alerts.length > 0) {
+        devicesResult.push({
+          device: d,
+          from,
+          to,
+          alerts
+        })
+      }
+    }))
+  }
+
+  return devicesResult
+}
+
+async function exportSpeedingReportToPDF (userData, reportData) {
+  console.log('Export to PDF')
+  const lang = getLanguage(userData)
+  const translations = getTranslations(userData)
+  const timezone = userData.user.attributes.timezone
+
+  const headers = [
+    translations.report.eventType,
+    translations.report.start,
+    translations.report.end,
+    translations.report.address,
+    translations.report.duration,
+    translations.report.info
+  ]
+  if (reportData.devices) {
+    let first = true
+    // eslint-disable-next-line new-cap
+    const doc = new jsPDF.jsPDF('l')
+    await headerFromUser(doc, translations.report.titleEventsReport, userData.user)
+
+    reportData.devices.forEach(d => {
+      const data = []
+      const name = deviceName(d.device)
+      const group = deviceGroupName(translations, userData.groups, d.device)
+
+      let space = 0
+      if (!first) {
+        doc.addPage()
+      } else {
+        first = false
+        space = 10
+      }
+      doc.setFontSize(13)
+      doc.text(name, 20, space + 20)
+      doc.setFontSize(11)
+      doc.text(group, 200, space + 20)
+      doc.text(convertToLocaleString(d.from, lang, timezone) + ' - ' + convertToLocaleString(d.to, lang, timezone), 20, space + 25)
+
+      const headerEventTypes = []
+      userData.eventTypes.forEach(e => {
+        const data = e.startsWith('alarm') ? { type: 'alarm', attributes: { alarm: e.slice(6) } } : { type: e }
+        const value = e.startsWith('alarm') ? d.alerts.filter(a => a.attributes.alarm === data.attributes.alarm).length : d.alerts.filter(a => a.type === e).length
+        if (value > 0) {
+          headerEventTypes.push([getEventType(data, translations, d.device), value])
+        }
+      })
+
+      doc.autoTable({
+        head: ['', '', '', '', ''],
+        body: [
+          headerEventTypes.slice(0, 6).map(a => a[0]),
+          headerEventTypes.slice(0, 6).map(a => a[1]),
+          headerEventTypes.slice(7).map(a => a[0]),
+          headerEventTypes.slice(7).map(a => a[1])
+        ],
+        startY: space + 30,
+        showHead: false,
+        bodyStyles: { fillColor: [256, 256, 256], textColor: [30, 30, 30], halign: 'center', valign: 'middle' },
+        alternateRowStyles: { fillColor: [256, 256, 256], valign: 'bottom' }
+      })
+      d.alerts.forEach(a => {
+        const temp = [
+          getEventType(a, translations, d.device, userData),
+          getAlertDate(userData.user, a.position),
+          getAlertDate(userData.user, a.endPosition),
+          a.geofenceName || (a.position ? a.position.address : ''),
+          a.position && a.endPosition ? convertMS(new Date(a.endPosition.fixTime).getTime() - new Date(a.position.fixTime).getTime()) : '',
+          getAlertInfo(userData.drivers, a, d.device, translations)
+        ]
+        data.push(temp)
+      })
+
+      const footValues = [
+        'Total:' + d.alerts.length,
+        '', '', ''
+      ]
+
+      const style = getStyle(getUserPartner(userData.user))
+      doc.autoTable({
+        head: [headers],
+        body: data,
+        foot: [footValues],
+        showFoot: 'lastPage',
+        headStyles: {
+          fillColor: style.pdfHeaderColor,
+          textColor: style.pdfHeaderTextColor,
+          fontSize: 10
+        },
+        bodyStyles: {
+          fillColor: style.pdfBodyColor,
+          textColor: style.pdfBodyTextColor,
+          fontSize: 8
+        },
+        footStyles: {
+          fillColor: style.pdfFooterColor,
+          textColor: style.pdfFooterTextColor,
+          fontSize: 9
+        },
+        startY: space + 65
+      })
+    })
+    return doc
+  }
+}
+
+function getEventType (a, translations, device, userData) {
+  if (a.type === 'alarm') {
+    let sensor
+    if (a.attributes.alarm === 'sensor') { sensor = device.attributes.sensor1 }
+    return sensor || translations.report['event_' + a.attributes.alarm] || a.attributes.alarm
+  } else {
+    const result = translations.report['event_' + a.type] || a.type
+    try {
+      if (userData &&
+          userData.maintenances &&
+          a.type === 'maintenance') {
+        const maintenance = userData.maintenances.find(m => m.id === a.maintenanceId)
+        if (maintenance) { return `${result} ${maintenance.name}` }
+      }
+    } catch (e) {
+      console.error(e)
+    }
+    return result
+  }
+}
+
+function exportSpeedingReportToExcel (userData, reportData) {
+  console.log('exportSpeedingReportToExcel')
+
+  const translations = getTranslations(userData)
+
+  const settings = {
+    sheetName: translations.report.titleEventsReport, // The name of the sheet
+    fileName // The name of the spreadsheet
+  }
+  const headers = [
+    { label: translations.report.vehicle, value: 'name' },
+    { label: translations.report.eventType, value: 'eventType' },
+    { label: translations.report.start, value: 'fixTime' },
+    { label: translations.report.end, value: 'endFixTime' },
+    { label: translations.report.address, value: 'address' },
+    { label: translations.report.duration, value: 'duration' },
+    { label: translations.report.zone, value: 'geofenceName' },
+    { label: translations.report.driver, value: 'driver' },
+    { label: translations.report.info, value: 'info' },
+    { label: '', value: 'alarm' },
+    { label: 'Latitude', value: 'latitude' },
+    { label: 'Longitude', value: 'longitude' }
+  ]
+  let data = []
+  if (reportData.devices) {
+    reportData.devices.forEach(d => {
+      data = data.concat(d.alerts.map(a => {
+        return {
+          name: d.device.name,
+          eventType: getEventType(a, translations, d.device),
+          fixTime: getAlertDate(userData.user, a.position),
+          endFixTime: getAlertDate(userData.user, a.endPosition),
+          address: a.position && a.position.address,
+          duration: a.position && a.endPosition ? convertMS(new Date(a.endPosition.fixTime).getTime() - new Date(a.position.fixTime).getTime()) : '',
+          geofenceName: a.geofenceName,
+          info: getAlertInfo(userData.drivers, a, d.device, translations),
+          driver: a.driver,
+          latitude: a.position && a.position.latitude,
+          longitude: a.position && a.position.longitude,
+          alarm: a.attributes.notifications ? translations.report.alarm : ''
+        }
+      }))
+    })
+    return {
+      headers,
+      data,
+      settings
+    }
+  }
+}
+
+function deviceGroupName (translation, groups, device) {
+  const group = groups.find(g => device.groupId === g.id)
+  if (group) {
+    return translation.report.group + ': ' + group.name
+  }
+  return ''
+}
+
+function deviceName (device) {
+  return device.name + (device.attributes.license_plate ? ', ' + device.attributes.license_plate : '') + (device.model ? ', ' + device.model : '')
+}
+
+function getAlertInfo (drivers, alert, device, translations) {
+  if (alert.type === 'alarm' && alert.attributes.alarm === 'temperature') {
+    return alert.attributes.info
+  }
+  if (alert.type === 'alarm' && alert.attributes.alarm === 'sensor') {
+    return device ? device.attributes.sensor1on : ''
+  }
+  if (alert.attributes.alarm && alert.attributes.alarm.startsWith('hard')) {
+    return ''
+  }
+  if (alert.type === 'alarm' && alert.position) {
+    return getDigitalPortValue(alert.position, 1, translations, device.attributes)
+  }
+  if (alert.type === 'deviceOverspeed') {
+    return Math.round(alert.attributes.speed * 1.85200) + ' Km/h'
+  }
+  if (alert.type === 'driverChanged') {
+    const driver = drivers.find(d => d.uniqueId === alert.attributes.driverUniqueId)
+    return driver ? driver.name : alert.attributes.driverUniqueId
+  }
+  return ''
+}
+
+function getAlertDate (user, position) {
+  if (position) {
+    return convertToLocaleString(position.fixTime, user.attributes.lang, user.attributes.timezone)
+  }
+}
+
+exports.createEventsReport = createEventsReport
+exports.exportSpeedingReportToPDF = exportSpeedingReportToPDF
+exports.exportSpeedingReportToExcel = exportSpeedingReportToExcel
+exports.create = createEventsReport
+exports.exportToPDF = exportSpeedingReportToPDF
+exports.exportToExcel = exportSpeedingReportToExcel

package/.claude/worktrees/eager-stonebraker-c08ac7/src/fuel-consumption-report.js

@@ -0,0 +1,296 @@
+const refuelingReport = require('./refueling-report')
+const traccarHelper = require('./util/traccar')
+const odoo = require('./util/odoo')
+const automaticReports = require('./automaticReports')
+const { devicesToProcess } = require('./util/device')
+const { getTranslations, convertToLocaleString, getLanguage, convertMS, formatNumber, getDates, isClientSide, executeServerSide } = require('./util/utils')
+const { getStyle } = require('./reportStyle')
+const { getUserPartner } = require('fleetmap-partners')
+const { addTable, headerFromUser } = require('./util/pdfDocument')
+const jsPDF = require('jspdf')
+const { calculateConsumption, calculateTotalFuelFromSensor} = require('./util/fuel')
+const { getSummaryByDay } = require('./util/traccar')
+const { getDataByDay } = require('./util/trips')
+
+async function createFuelConsumptionReport (from, to, userData, traccar) {
+  console.log('Create FuelConsumption Report')
+
+  const reportData = []
+
+  const allData = {
+    devices: [],
+    from,
+    to
+  }
+
+  const devices = devicesToProcess(userData)
+
+  allData.totalDevices = 0
+
+  if (isClientSide() && (devices.length > 50 || ((new Date(to).getTime() - new Date(from).getTime()) > (1000 * 60 * 60 * 24 * 15)))) {
+    const sliced = automaticReports.sliceArray(devices, 1)
+    allData.devices = await executeServerSide('fuel-consumption-report', sliced, from, to, userData, devices.length, traccar, 5)
+    allData.totalDevices = allData.devices.length
+    reportData.push(allData)
+    return reportData
+  }
+
+  const allInOne = await traccarHelper.getAllInOne(traccar, from, to, devices, true, true, true, false)
+  const dates = getDates(from, to, userData.user.attributes.timezone || getUserPartner(userData.user).timezone)
+  const summary = await getSummaryByDay(dates, userData, traccar, devices, true, from, to)
+
+  const fuelServicesData = []
+  if (devices.some(d => d.attributes.odooId)) {
+    fuelServicesData.push(...(await odoo.getOdooFuelServices(traccar, from, to)))
+  }
+
+  if (allInOne.trips.length === 0) {
+    return reportData
+  }
+
+  for (const d of devices) {
+    const stops = allInOne.stops.filter(t => t.deviceId === d.id)
+    const trips = allInOne.trips.filter(t => t.deviceId === d.id)
+    const route = allInOne.route.filter(r => r.deviceId === d.id)
+    const deviceFuelServices = fuelServicesData.filter(f => Number.parseInt(d.attributes.odooId) === f.vehicle_id[0])
+
+    if (trips.length > 0) {
+      const refuelingPositions = await refuelingReport.calculateRefuelingPositions(userData, d, { route, trips, fuelServices: deviceFuelServices })
+      const days = []
+      for (const date of dates) {
+        const { tripsByDay, stopsByDay, routeByDay, refuelingPositionsByDay } = await getDataByDay(d, date, { trips, stops, route, refuelingPositions }, userData, traccar)
+        const summaryByDay = summary.find(a => a.date === date).summary
+        const summaryByDevice = summaryByDay.find(a => a.deviceId === d.id)
+
+        const firstStopIndex = !stopsByDay.length || !tripsByDay.length ? 0 : (new Date(tripsByDay[0].startTime) < new Date(stopsByDay[0].startTime) ? 0 : 1)
+        const distance = summaryByDevice.distance
+
+        const hasFuelSensor = 'fuel_low_threshold' in d.attributes &&
+            'fuel_high_threshold' in d.attributes &&
+            d.attributes.fuel_tank_capacity
+
+        const spentFuel = hasFuelSensor ?
+            tripsByDay.length > 0 ? calculateTotalFuelFromSensor(tripsByDay, stopsByDay, route, d, firstStopIndex) : 0
+            : calculateConsumption(d, { trips: tripsByDay, stops: stopsByDay, route: routeByDay, summary: summaryByDevice })
+
+        const dataRow = {
+          date,
+          distance,
+          spentFuel,
+          avgConsumption: getCanAvgConsumption(distance, spentFuel),
+          startOdometer: summaryByDevice.startOdometer,
+          endOdometer: summaryByDevice.endOdometer,
+          duration: tripsByDay.reduce((a, b) => a + b.duration, 0),
+          refueling: (refuelingPositionsByDay && refuelingPositionsByDay.length > 0) ? refuelingPositionsByDay.reduce((a, b) => a + b.diff, 0) : 0
+        }
+
+        days.push(dataRow)
+      }
+
+      if (days.length > 0) {
+        allData.devices.push({
+          device: d,
+          days
+        })
+        allData.totalDevices = allData.totalDevices + 1
+      }
+    }
+  }
+
+  reportData.push(allData)
+
+  return reportData
+}
+
+function getOdooAvgConsumption (day, allRefuelingPositions, trips) {
+  const refuelingData = allRefuelingPositions.filter(r => new Date(r.date).getTime() > new Date(day).getTime())
+  let odooFuel
+  let kms
+  if (!refuelingData.length) {
+    odooFuel = allRefuelingPositions.reduce((a, b) => a + b.diff, 0)
+    kms = trips.reduce((a, b) => a + b.distance, 0)
+  } else {
+    odooFuel = allRefuelingPositions.filter(r => new Date(r.date).getTime() <= new Date(refuelingData[0].date).getTime()).reduce((a, b) => a + b.diff, 0)
+    kms = trips.filter(t => new Date(t.startDate).getTime() < new Date(refuelingData[0].date).getTime()).reduce((a, b) => a + b.distance, 0)
+  }
+
+  if (kms === 0 || odooFuel === 0) { return { byKms: 0, byLiters: 0 } }
+
+  return calculateAvgConsumption(odooFuel, kms)
+}
+
+function getCanAvgConsumption (distance, spentFuel) {
+  if (distance === 0 || spentFuel === 0) { return { byKms: 0, byLiters: 0 } }
+
+  return calculateAvgConsumption(spentFuel, distance)
+}
+
+function calculateAvgConsumption (fuel, distance) {
+  return { byKms: fuel * 100 / (distance / 1000), byLiters: (distance / 1000) / fuel }
+}
+
+function exportFuelConsumptionReportToExcel (userData, reportData) {
+  const translations = getTranslations(userData)
+  const lang = getLanguage(userData)
+
+  const settings = {
+    sheetName: 'FuelConsumptionReport', // The name of the sheet
+    fileName: 'FuelConsumptionReport' // The name of the spreadsheet
+  }
+  const headers = [
+    { label: translations.report.vehicle, value: 'name' },
+    { label: translations.report.date, value: 'date' },
+    { label: translations.report.distance, value: 'kms' },
+    { label: translations.report.consumption, value: 'consumption' },
+    { label: (lang === 'pt-BR' ? translations.report.avg_consumption_by_liters : translations.report.avg_consumption), value: 'avg_consumption' },
+    { label: translations.report.duration, value: 'duration' },
+    { label: translations.report.odometer, value: 'accumulated_kms' },
+    { label: translations.report.refueling, value: 'refueling' }
+  ]
+  let data = []
+  if (reportData.devices) {
+    reportData.devices.forEach((d) => {
+      data = data.concat(d.days.map((r) => {
+        return {
+          name: d.device.name,
+          date: new Date(r.date).toLocaleDateString(),
+          kms: formatNumber(r.distance / 1000),
+          consumption: r.spentFuel > 0 ? formatNumber(r.spentFuel) : 0,
+          avg_consumption: formatNumber(lang === 'pt-BR' ? r.avgConsumption.byLiters : r.avgConsumption.byKms),
+          duration: convertMS(r.duration),
+          accumulated_kms: formatNumber((r.endOdometer / 1000)),
+          refueling: formatNumber(r.refueling)
+        }
+      }))
+      // Totals
+      data = data.concat([{
+        date: 'Total:' + d.days.length,
+        kms: getTotalKms(userData.user, d.days),
+        consumption: getTotalConsumption(userData.user, d.days),
+        avg_consumption: getTotalAvgConsumption(userData.user, d.days),
+        duration: getTotalDuration(userData.user, d.days),
+        refueling: getTotalRefueling(userData.user, d.days)
+      }])
+      data = data.concat([{}])
+    })
+    return {
+      headers,
+      data,
+      settings
+    }
+  }
+}
+
+async function exportFuelConsumptionReportToPDF (userData, reportData) {
+  console.log('Export to PDF')
+  const timezone = userData.user.attributes.timezone
+  const translations = getTranslations(userData)
+  const lang = getLanguage(userData)
+
+  // eslint-disable-next-line new-cap
+  const doc = new jsPDF.jsPDF('l')
+  await headerFromUser(doc, translations.report.titleFuelConsumptionReport, userData.user)
+
+  const headers = [
+    translations.report.date,
+    translations.report.distance,
+    translations.report.consumption,
+    (lang === 'pt-BR' ? translations.report.avg_consumption_by_liters : translations.report.avg_consumption),
+    translations.report.duration,
+    translations.report.odometer,
+    translations.report.refueling
+  ]
+
+  if (reportData.devices) {
+    reportData.devices.forEach((d, index) => {
+      const data = []
+      const name = deviceName(d.device)
+      const group = userData.groups.find(g => d.device.groupId === g.id)
+
+      const space = index === 0 ? 8 : 0
+      if (index) {
+        doc.addPage()
+      }
+
+      doc.setFontSize(13)
+      doc.text(name, 20, space + 20)
+      doc.setFontSize(11)
+      doc.text(group ? translations.report.group + ': ' + group.name : '', 200, space + 20)
+      doc.text(convertToLocaleString(reportData.from, lang, timezone) + ' - ' + convertToLocaleString(reportData.to, lang, timezone), 20, space + 25)
+
+      d.days.forEach(r =>
+        data.push([
+          new Date(r.date).toLocaleDateString(),
+          formatNumber(r.distance / 1000),
+          r.spentFuel > 0 ? formatNumber(r.spentFuel) : 0,
+          formatNumber(lang === 'pt-BR' ? r.avgConsumption.byLiters : r.avgConsumption.byKms),
+          convertMS(r.duration),
+          formatNumber((r.endOdometer / 1000)),
+          formatNumber(r.refueling)
+        ]))
+
+      const footValues = [
+        'Total:' + d.days.length,
+        getTotalKms(userData.user, d.days),
+        getTotalConsumption(userData.user, d.days),
+        getTotalAvgConsumption(userData.user, d.days),
+        getTotalDuration(userData.user, d.days),
+        '',
+        getTotalRefueling(userData.user, d.days)
+      ]
+
+      const style = getStyle(getUserPartner(userData.user))
+      addTable(doc, headers, data, footValues, style, space + (userData.allWeek ? 40 : 45),
+        {
+          1: { halign: 'right' },
+          2: { halign: 'right' },
+          3: { halign: 'right' },
+          4: { halign: 'right' },
+          5: { halign: 'right' },
+          6: { halign: 'right' }
+        })
+    })
+
+    return doc
+  }
+}
+
+function deviceName (device) {
+  return device.name + (device.attributes.license_plate ? ', ' + device.attributes.license_plate : '') + (device.model ? ', ' + device.model : '')
+}
+
+function getTotalKms (user, data) {
+  const totalKms = data.reduce((a, b) => a + b.distance, 0)
+  return formatNumber(totalKms / 1000, user.attributes.lang)
+}
+
+function getTotalConsumption (user, data) {
+  const totalConsumption = data.reduce((a, b) => a + (b.spentFuel > 0 ? b.spentFuel : 0), 0)
+  return formatNumber(totalConsumption, user.attributes.lang)
+}
+
+function getTotalDuration (user, data) {
+  const totalDuration = data.reduce((a, b) => a + b.duration, 0)
+  return convertMS(totalDuration)
+}
+
+function getTotalRefueling (user, data) {
+  const totalRefueling = data.reduce((a, b) => a + b.refueling, 0)
+  return formatNumber(totalRefueling, user.attributes.lang)
+}
+
+function getTotalAvgConsumption (user, data) {
+  const values = data.map(a => a.distance * (user.attributes.lang === 'pt-BR' ? a.avgConsumption.byLiters : a.avgConsumption.byKms)).reduce((a, b) => a + b, 0)
+  const totalKms = data.reduce((a, b) => a + b.distance, 0)
+
+  const totalAvgConsumption = values / totalKms
+  return formatNumber(totalAvgConsumption, user.attributes.lang)
+}
+
+exports.createFuelConsumptionReport = createFuelConsumptionReport
+exports.exportFuelConsumptionReportToPDF = exportFuelConsumptionReportToPDF
+exports.exportFuelConsumptionReportToExcel = exportFuelConsumptionReportToExcel
+exports.create = createFuelConsumptionReport
+exports.exportToPDF = exportFuelConsumptionReportToPDF
+exports.exportToExcel = exportFuelConsumptionReportToExcel
+exports.getCanAvgConsumption = getCanAvgConsumption