fleetmap-reports 2.0.357 → 2.0.358

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

@@ -0,0 +1,345 @@
+const helpers = require('@turf/helpers')
+const automaticReports = require('./automaticReports')
+const { devicesToProcess } = require('./util/device')
+const distance = require('@turf/distance')
+const { getTranslations, getLanguage, convertToLocaleString } = require('./util/utils')
+const odoo = require('./util/odoo')
+const traccarHelper = require('./util/traccar')
+const { calculateFuelDiff, getRefuelingLiters } = require('./util/fuel')
+const jsPDF = require('jspdf')
+const { headerFromUser, addTable } = require('./util/pdfDocument')
+const { getStyle } = require('./reportStyle')
+const { getUserPartner } = require('fleetmap-partners')
+
+// const positionsToCheck = 15
+
+async function createRefuelingReport (from, to, userData, traccar) {
+  console.log('Create RefuelingReport')
+
+  const reportData = []
+
+  const allData = {
+    devices: [],
+    from,
+    to
+  }
+
+  const devices = devicesToProcess(userData).filter(d => automaticReports.deviceWithFuelInfo(d))
+
+  console.log('Devices:' + devices.length)
+
+  const slices = automaticReports.sliceArray(devices, 5)
+
+  allData.totalDevices = 0
+  allData.totalRefueling = 0
+  allData.totalRefuelingLiters = 0
+  let deviceCount = 0
+  for (const slice of slices) {
+    const allInOne = await traccarHelper.getAllInOne(traccar, from, to, slice, true, false, false, false, deviceCount, devices.length)
+    const route = allInOne.route
+
+    const fuelServicesData = []
+    if (devices.some(d => d.attributes.odooId)) {
+      fuelServicesData.push(...(await odoo.getOdooFuelServices(traccar, from, to)))
+    }
+
+    allData.devices.push(...await processDevices(from, to, slice, route, userData, fuelServicesData))
+    deviceCount = deviceCount + slice.length
+  }
+  const refuelingPositions = allData.devices.map(d => d.refuelings).flat()
+  allData.totalDevices = allData.totalDevices + 1
+  allData.totalRefueling = allData.totalRefueling + refuelingPositions.length
+  allData.totalRefuelingLiters = allData.totalRefuelingLiters + refuelingPositions.reduce((a, b) => a + b.diff, 0)
+
+  reportData.push(allData)
+
+  return reportData
+}
+
+async function processDevices (from, to, devices, data, userData, fuelServicesData) {
+  const devicesResult = []
+
+  for (const d of devices) {
+    const positions = data.filter(t => t.deviceId === d.id)
+    const deviceFuelServices = fuelServicesData.filter(f => Number.parseInt(d.attributes.odooId) === f.vehicle_id[0])
+
+    if (positions.length > 0) {
+      const refuelingPositions = await calculateRefuelingPositions(userData, d, {
+        route: positions,
+        fuelServices: deviceFuelServices
+      })
+
+      if (userData.drivers.length > 0) {
+        refuelingPositions.forEach(r => {
+          if (r.position) {
+            const geofence = findNearestPOI(r.position, userData.geofences)
+            if (geofence) {
+              r.position.geofenceName = geofence.name
+            }
+            const driver = userData.drivers.find(d => d.uniqueId === r.position.attributes.driverUniqueId)
+            if (driver) {
+              r.position.driverName = driver.name
+            }
+          }
+        })
+      }
+
+      if (refuelingPositions.length > 0) {
+        devicesResult.push({
+          device: d,
+          refuelings: refuelingPositions
+        })
+      }
+    }
+  }
+
+  return devicesResult
+}
+
+function findNearestPOI (position, geofences) {
+  if (geofences.length === 0) { return null }
+
+  if (!position) { return null }
+
+  const a = geofences.map(g => {
+    if (g.area && g.area.startsWith('CIRCLE (')) {
+      console.log('->' + g.area)
+      const str = g.area.substring('CIRCLE ('.length, g.area.indexOf(','))
+
+      const coord = str.trim().split(' ')
+      return {
+        id: g.id,
+        distance: Math.round(coordsDistance(parseFloat(coord[1]), parseFloat(coord[0]), position.longitude, position.latitude))
+      }
+    }
+    return {
+      id: g.id,
+      distance: Number.MAX_SAFE_INTEGER
+    }
+  }).filter(a => a.distance < 100).sort((a, b) => (a.distance > b.distance) ? 1 : -1)
+
+  if (a.length > 0) {
+    return a[0]
+  }
+
+  return null
+}
+
+function coordsDistance (lon1, lat1, lon2, lat2) {
+  const from = helpers.point([lon1, lat1])
+  const to = helpers.point([lon2, lat2])
+
+  return distance.default(from, to) * 1000
+}
+
+/* function isStoped (position) {
+  return !position.attributes.ignition || position.attributes.rpm === 0
+} */
+
+/* function analyseRouteRefuelingOnStops (data, d, refuelingPositions) {
+  let refuelingActivated = false
+  let currentValue = null
+  let positionsChecked = 0
+  let lastRefuelingIndex = 0
+  data.route.forEach(function (element, index, array) {
+    if (isStoped(element) && refuelingActivated && !currentValue) {
+      // Ignition is off and Refueling is Active and there is no current value
+
+      // Get 5 position before the ignition off to calculate the current value of the fuel tank level
+      // lastRefuelingIndex is used to avoid re-analyzing positions prior to a refueling
+      const before = (index > 5 ? array.slice((index - 6 < lastRefuelingIndex ? lastRefuelingIndex : index - 6), index - 1) : array.slice(0, index - 1)).filter(b => b.attributes.ignition && b.attributes.fuel)
+      currentValue = Math.round(before.reduce((a, b) => a + b.attributes.fuel, 0) / before.length)
+
+      positionsChecked = 0
+    }
+
+    if (element.attributes.ignition && refuelingActivated && currentValue) {
+      // Ignition is on and Refueling is Active and there is a current value
+      // Calculate the value of the fuel tank level after turning the ignition back on
+      const after = (array.length > index + 5 ? array.slice(index, index + 1) : array.slice(index)).filter(b => b.attributes.ignition && b.attributes.fuel)
+      const newValue = Math.round(after.reduce((a, b) => a + b.attributes.fuel, 0) / after.length)
+
+      const diff = calculateFuelDiff(currentValue, newValue, d, element)
+      if (diff > 20) {
+        // New refueling detected
+        const value = getRefuelingLiters(d, element, diff)
+        refuelingPositions.push({position: element, date: element.fixTime, diff: value})
+        lastRefuelingIndex = index
+        positionsChecked = positionsToCheck + 1 // to reset values
+      }
+
+      if (positionsChecked > positionsToCheck) {
+        refuelingActivated = false
+        currentValue = null
+        positionsChecked = 0
+      } else {
+        positionsChecked++
+      }
+    }
+
+    if (element.attributes.ignition && !refuelingActivated) {
+      refuelingActivated = true
+    }
+  })
+} */
+
+function analyseRouteRefueling (data, d, refuelingPositions) {
+  let startValue = 0
+  let currentValue = 0
+  let refuelingActivated = false
+  data.route.forEach(function (element, index, array) {
+    if (!refuelingActivated) {
+      startValue = element.attributes.fuel
+    }
+
+    const endValue = array.length > index + 2 ? array[index + 2].attributes.fuel : undefined
+    const diff = calculateFuelDiff(startValue, endValue, d, element)
+
+    if (diff > 5 && !refuelingActivated) {
+      refuelingActivated = true
+      currentValue = diff
+    } else if (refuelingActivated && currentValue < diff) {
+      currentValue = diff
+    } else {
+      if (currentValue > 20) {
+        // New refueling detected
+        const value = getRefuelingLiters(d, element, currentValue)
+        refuelingPositions.push({ position: element, date: element.fixTime, diff: value })
+        currentValue = 0
+      }
+      refuelingActivated = false
+    }
+  })
+}
+
+async function calculateRefuelingPositions (userData, d, data) {
+  const refuelingPositions = []
+
+  if (d.attributes.odooId && !data.route[0].attributes.fuel) {
+    console.log(data.fuelServices)
+    data.fuelServices.forEach(s => {
+      const serviceDate = new Date(s.date)
+      serviceDate.setHours(23, 59, 59, 59)
+
+      const routeBeforeService = data.route.filter(r => new Date(r.fixTime).getTime() < serviceDate.getTime())
+
+      const quantity = s.liter
+
+      if (routeBeforeService.length) {
+        refuelingPositions.push({ position: routeBeforeService.slice(-1)[0], date: s.date, diff: Number.parseFloat(quantity), cost: s.amount })
+      }
+    })
+  } else {
+    // analyseRouteRefuelingOnStops(data, d, refuelingPositions)
+    analyseRouteRefueling(data, d, refuelingPositions)
+  }
+  return refuelingPositions
+}
+
+function exportRefuelingReportToExcel (userData, reportData) {
+  console.log('Export to Excel')
+  const translations = getTranslations(userData)
+
+  const settings = {
+    sheetName: 'RefuelingReport', // The name of the sheet
+    fileName: 'RefuelingReport' // The name of the spreadsheet
+  }
+  const headers = [
+    { label: translations.report.vehicle, value: 'name' },
+    { label: translations.report.date, value: 'fixTime' },
+    { label: translations.report.address, value: 'address' },
+    { label: translations.report.refueling, value: 'diff' },
+    { label: translations.report.driver, value: 'driver' }
+  ]
+  let data = []
+  if (reportData.devices) {
+    reportData.devices.forEach(d => {
+      data = data.concat(d.refuelings.map(r => {
+        return {
+          driver: r.driverName,
+          diff: r.diff,
+          fixTime: new Date(r.position.fixTime).toLocaleString(),
+          name: d.device.name,
+          address: r.geofenceName || r.position.address
+        }
+      }))
+    })
+  }
+
+  return {
+    headers,
+    data,
+    settings
+  }
+}
+
+async function exportRefuelingReportToPDF (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.titleRefuelingReport, userData.user)
+
+  const headers = [
+    translations.report.date,
+    translations.report.address,
+    translations.report.refueling,
+    translations.report.driver
+  ]
+
+  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.refuelings.forEach(r =>
+      data.push([
+        new Date(r.position.fixTime).toLocaleString(),
+        r.geofenceName || r.position.address,
+        r.diff,
+        r.driverName
+      ])
+    )
+
+    const footValues = [
+      'Total:' + d.refuelings.length,
+      '',
+      d.refuelings.reduce((a, b) => a + b.diff, 0),
+      ''
+    ]
+
+    const style = getStyle(getUserPartner(userData.user))
+    addTable(doc, headers, data, footValues, style, space + 40,
+      {
+        2: { halign: 'right' }
+      })
+  })
+
+  return doc
+}
+
+function deviceName (device) {
+  return device.name + (device.attributes.license_plate ? ', ' + device.attributes.license_plate : '') + (device.model ? ', ' + device.model : '')
+}
+
+exports.createRefuelingReport = createRefuelingReport
+exports.calculateRefuelingPositions = calculateRefuelingPositions
+exports.exportRefuelingReportToPDF = exportRefuelingReportToPDF
+exports.exportRefuelingReportToExcel = exportRefuelingReportToExcel
+exports.create = createRefuelingReport
+exports.exportToPDF = exportRefuelingReportToPDF
+exports.exportToExcel = exportRefuelingReportToExcel

package/.claude/worktrees/eager-stonebraker-c08ac7/src/reportStyle.js

@@ -0,0 +1,34 @@
+function getStyle(partnerData) {
+    const reportStyleData = {
+        pdfHeaderColor: [105, 105, 105],
+        pdfHeaderTextColor: [256, 256, 256],
+        pdfBodyColor: [256, 256, 256],
+        pdfBodyTextColor: [30, 30, 30],
+        pdfFooterColor: [210, 210, 210],
+        pdfFooterTextColor: [30, 30, 30],
+        imgHeight: 0,
+        imgWidth: 0,
+    }
+
+    if(partnerData && partnerData.reports){
+        reportStyleData.pdfHeaderColor = partnerData.reports.mainColor || [105, 105, 105]
+        reportStyleData.pdfFooterColor = partnerData.reports.mainColor || [210, 210, 210]
+        reportStyleData.pdfFooterTextColor = partnerData.reports.mainColor ? [256, 256, 256] : [30, 30, 30]
+        reportStyleData.imgHeight = partnerData.reports.logoHeight || 0
+        reportStyleData.imgWidth = partnerData.reports.logoWidth || 0
+    }
+
+    return reportStyleData
+}
+
+exports.getStyle = getStyle
+
+exports.pdfHeaderColor = [105, 105, 105]
+exports.pdfHeaderTextColor = [256, 256, 256]
+exports.pdfBodyColor = [256, 256, 256]
+exports.pdfBodyTextColor = [30, 30, 30]
+exports.pdfFooterColor = [210, 210, 210]
+exports.pdfFooterTextColor = [30, 30, 30]
+
+
+