fleetmap-reports 2.0.358 → 2.0.359

package/.claude/worktrees/eager-stonebraker-c08ac7/src/util/driver.js

@@ -1,90 +0,0 @@
-const traccar = require('./traccar')
-const automaticReports = require('../automaticReports')
-const traccarHelper = require('./traccar')
-const { isInsideTimetable, isPartialInsideTimetable } = require('./trips')
-
-// get devices used by each driver between two dates
-async function devicesByDriver (traccarInstance, from, to, drivers, devices) {
-  const eventsData = await traccar.getEvents(traccarInstance, from, to, devices, ['driverChanged'])
-  const driverUniqueIdsToProcess = new Set(eventsData.map(e => e.attributes.driverUniqueId))
-  const driversToProcess = drivers.filter(d => driverUniqueIdsToProcess.has(d.uniqueId))
-
-  const deviceIdsToProcess = new Set(eventsData.map(e => e.deviceId))
-  const devicesToProcess = devices.filter(d => deviceIdsToProcess.has(d.id))
-
-  return { devices: devicesToProcess, drivers: driversToProcess }
-}
-
-async function reportByDriver (devices, traccar, from, to, userData, processor, allInOneData = { route: true, trips: true, stops: true, summary: false }) {
-  const report = { drivers: [] }
-
-  const sliced = automaticReports.sliceArray(devices, 5)
-
-  let deviceCount = 0
-  for (const slice of sliced) {
-    const allInOne = await traccarHelper.getAllInOne(traccar, from, to, slice, allInOneData.route, allInOneData.trips, allInOneData.stops, allInOneData.summary, deviceCount, devices.length)
-    const results = await processor(from, to, userData, { trips: allInOne.trips, route: allInOne.route, stops: allInOne.stops })
-    report.drivers.push(...results)
-    deviceCount = deviceCount + slice.length
-  }
-
-  return report
-}
-
-function getDriverUniqueIdTimeline (driverUniqueIdTimeline, driverUniqueId, date) {
-  if (!driverUniqueIdTimeline) {
-    return undefined
-  }
-
-  return driverUniqueIdTimeline.find(d => d.uniqueId === driverUniqueId &&
-      (!d.startDate || new Date(d.startDate) <= new Date(date)) &&
-      (!d.endDate || new Date(d.endDate) >= new Date(date)))
-}
-
-function getDriverName (driverUniqueId, date, userData) {
-  if (driverUniqueId) {
-    const timeline = getDriverUniqueIdTimeline(userData.driverUniqueIdTimeline, driverUniqueId, date)
-
-    if (timeline) {
-      return timeline.driverName
-    }
-
-    const driver = userData.drivers ? userData.drivers.find(d => !d.uniqueId.localeCompare(driverUniqueId, undefined, { sensitivity: 'base' })) : undefined
-
-    return driver
-      ? driver.name + ' ' + ((driver.attributes && driver.attributes.notes) || '')
-      : driverUniqueId
-  }
-
-  return ''
-}
-
-async function getDriverData (d, data, userData) {
-  const route = data.route ? data.route.filter(p => !d.uniqueId.localeCompare(p.attributes.driverUniqueId, undefined, { sensitivity: 'base' })) : undefined
-  const trips = data.trips ? data.trips.filter(t => !d.uniqueId.localeCompare(t.driverUniqueId, undefined, { sensitivity: 'base' })) : undefined
-  const events = data.events ? data.events.filter(e => e.position && !d.uniqueId.localeCompare(e.position.attributes.driverUniqueId, undefined, { sensitivity: 'base' })) : undefined
-
-  const filteredTrips = []
-  if (trips) {
-    for (const t of trips) {
-      if (userData.allWeek ||
-          !userData.weekDays ||
-          isInsideTimetable(t, userData) ||
-          await isPartialInsideTimetable(undefined, t, userData, route)) {
-        filteredTrips.push(t)
-      }
-    }
-  }
-
-  return {
-    route,
-    trips: filteredTrips,
-    events
-  }
-}
-
-exports.getDriverData = getDriverData
-exports.getDriverName = getDriverName
-exports.getDriverUniqueIdTimeline = getDriverUniqueIdTimeline
-exports.devicesByDriver = devicesByDriver
-exports.reportByDriver = reportByDriver

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

@@ -1,102 +0,0 @@
-function calculateFuelDiff (a, b) {
-  return b - a
-}
-
-function getRefuelingLiters (d, position, diff) {
-  if (position.protocol === 'teltonika' && !position.attributes.io89) {
-    return diff
-  }
-  return Math.round(diff * d.attributes.fuel_tank_capacity / 100)
-}
-
-function calculateTotalFuelFromSensor(trips, stops, positions, device, firstStopIndex) {
-  const lastStopIndex = firstStopIndex + trips.length - 1
-  const lastStop = stops.length > lastStopIndex ? stops[lastStopIndex] : null
-  const firstTripStart = new Date(trips[0].startTime).getTime()
-  const lastEndTime = lastStop ? new Date(lastStop.endTime).getTime() : new Date(trips[trips.length - 1].endTime).getTime()
-
-  const rangePositions = positions.filter(p => {
-    const t = new Date(p.fixTime).getTime()
-    return t >= firstTripStart && t <= lastEndTime && p.attributes.fuel != null
-  })
-
-  if (rangePositions.length < 2) return 0
-
-  const invertedSensor = device.attributes.fuel_low_threshold > device.attributes.fuel_high_threshold
-  const sensorRange = Math.abs(device.attributes.fuel_high_threshold - device.attributes.fuel_low_threshold)
-  const refuelThreshold = sensorRange * 0.2
-
-  let totalRawConsumption = 0
-  let segmentStartFuel = rangePositions[0].attributes.fuel
-
-  for (let i = 1; i < rangePositions.length; i++) {
-    const prev = rangePositions[i - 1]
-    const curr = rangePositions[i]
-    // refuel = significant increase for normal sensor, significant decrease for inverted
-    const fuelChange = invertedSensor
-        ? prev.attributes.fuel - curr.attributes.fuel
-        : curr.attributes.fuel - prev.attributes.fuel
-
-    if (fuelChange > refuelThreshold) {
-      const segmentRawDiff = invertedSensor
-          ? prev.attributes.fuel - segmentStartFuel
-          : segmentStartFuel - prev.attributes.fuel
-      if (segmentRawDiff > 0) totalRawConsumption += segmentRawDiff
-      segmentStartFuel = curr.attributes.fuel
-    }
-  }
-
-  const lastFuel = rangePositions[rangePositions.length - 1].attributes.fuel
-  const lastSegmentRawDiff = invertedSensor
-      ? lastFuel - segmentStartFuel
-      : segmentStartFuel - lastFuel
-  if (lastSegmentRawDiff > 0) totalRawConsumption += lastSegmentRawDiff
-
-  if (totalRawConsumption <= 0) return 0
-  return (totalRawConsumption / sensorRange) * device.attributes.fuel_tank_capacity
-}
-
-
-function calculateConsumption (d, data) {
-  let fuelConsumption = 0
-  const withFuelUsed = data.route && data.route.find(p => p.attributes.fuelUsed)
-  if (data.summary && withFuelUsed) {
-    fuelConsumption = calculateSpentFuel(data.summary.spentFuel, d, withFuelUsed)
-  } else if (data.trips && data.stops) {
-    fuelConsumption = data.trips.reduce((a, b) => a + calculateSpentFuel(b.spentFuel, d, withFuelUsed), 0) + data.stops.reduce((a, b) => a + calculateSpentFuel(b.spentFuel, d, withFuelUsed), 0)
-  } else if (data.route && data.route.length > 1 && data.route[0].attributes.fuelUsed) {
-    fuelConsumption = data.route[data.route.length - 1].attributes.fuelUsed - data.route[0].attributes.fuelUsed
-  } else if (data.summary) {
-    fuelConsumption = data.summary.spentFuel
-  }
-  return fuelConsumption > 0 ? fuelConsumption : 0
-}
-
-function calculateSpentFuel (value, device, withFuelUsed) {
-  if (!value) { return value }
-
-  if (device.attributes.xpert) {
-    return withFuelUsed ? value : (value * device.attributes.fuel_tank_capacity) / 100
-  }
-
-  const { fuel_low_threshold, fuel_high_threshold, fuel_tank_capacity } = device.attributes
-  if (fuel_low_threshold != null && fuel_high_threshold != null && fuel_tank_capacity) {
-    const sensorRange = Math.abs(fuel_high_threshold - fuel_low_threshold)
-    const rawFuel = fuel_low_threshold > fuel_high_threshold
-        ? (value < 0 ? Math.abs(value) : 0)
-        : value
-    return rawFuel > 0 ? (rawFuel / sensorRange) * fuel_tank_capacity : 0
-  }
-
-  return value > 0 ? value : 0
-}
-
-function useOdooFuelData (d, route) {
-  return route && route.length && !route[0].attributes.fuel && d.attributes.odooId
-}
-
-exports.calculateFuelDiff = calculateFuelDiff
-exports.getRefuelingLiters = getRefuelingLiters
-exports.calculateConsumption = calculateConsumption
-exports.useOdooFuelData = useOdooFuelData
-exports.calculateTotalFuelFromSensor = calculateTotalFuelFromSensor

package/.claude/worktrees/eager-stonebraker-c08ac7/src/util/geofence.js

@@ -1,52 +0,0 @@
-const turf = require('@turf/helpers')
-const inside = require('@turf/boolean-point-in-polygon')
-const { coordsDistance } = require('./utils')
-const booleanPointInPolygon = require('@turf/boolean-point-in-polygon')
-const distance = require('@turf/distance')
-const pointToLineDistance = require('@turf/point-to-line-distance')
-
-exports.insideGeofence = function insideGeofence (position, geofence) {
-  const coords = geofence.area.slice(9, geofence.area.length - 2).split(',')
-  const coords2 = coords.map(c => {
-    return c.trim().split(' ').map(a => parseFloat(a))
-  })
-  const pt = turf.point([parseFloat(position.latitude), parseFloat(position.longitude)])
-  const poly = turf.polygon([coords2])
-
-  return inside.default(pt, poly)
-}
-
-exports.getNearestPOI = (position, geofences) => getNearestPOIs(position.longitude, position.latitude, geofences)[0]
-function getNearestPOIs (long, lat, geofences) {
-  const distance = geofences
-    .filter(g => g && g.area && 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)),
-        r: parseFloat(radius)
-      }
-    })
-  return distance.filter(a => a.distance < a.r).sort((a, b) => (a.distance > b.distance) ? 1 : -1)
-}
-exports.getNearestPOIs = getNearestPOIs
-
-exports.loadGroupsData = async function loadGroupsData (userData, traccarInstance) {
-  for (const g of userData.groups) {
-    g.geofenceIds = (await traccarInstance.geofences.geofencesGet(undefined, undefined, undefined, g.id, undefined, undefined).then(r => r.data)).map(g => g.id)
-  }
-}
-
-exports.checkGeofenceIn = function checkGeofenceIn (p, g) {
-  switch (g.geometry.type) {
-    case 'Polygon':
-      return booleanPointInPolygon.default(p, g)
-    case 'Point':
-      return distance.default(p, g, { units: 'meters' }) <= g.properties.distance
-    case 'LineString':
-      return pointToLineDistance.default(p, g, { units: 'meters' }) < (g.properties.geofence.attributes.polylineDistance || 25)
-  }
-}

package/.claude/worktrees/eager-stonebraker-c08ac7/src/util/odoo.js

@@ -1,18 +0,0 @@
-
-async function getOdooFuelServices (traccar, from, to) {
-  const url = `/odoo/reports/refuelingServices?startDate=${from.toDateString()}&endDate=${to.toDateString()}`
-
-  try {
-    const { data } = await traccar.axios.get(url, {
-      jar: traccar.cookieJar,
-      withCredentials: true
-    })
-
-    return data
-  } catch (e) {
-    console.log(e)
-    return []
-  }
-}
-
-exports.getOdooFuelServices = getOdooFuelServices

package/.claude/worktrees/eager-stonebraker-c08ac7/src/util/parallel.js

@@ -1,64 +0,0 @@
-const { sliceArray } = require('../automaticReports')
-const path = require('path')
-
-exports.parallel = (report, method, toSlice, ...args) => {
-  const cluster = require('cluster')
-  const numCPUs = require('os').cpus().length
-  return new Promise((resolve, reject) => {
-    if (cluster.isPrimary) {
-      console.log('parallel with', numCPUs, 'cpus', 'toSlice len', toSlice.length)
-      cluster.setupPrimary({ exec: path.resolve(__dirname, 'worker.js') })
-      const sliced = toSlice.length > (numCPUs - 1) ? sliceArray(toSlice, toSlice.length / (numCPUs - 1)) : [toSlice]
-      console.log('sliced in', sliced.length)
-      const _result = []
-      let done = 0
-      let workerCount = 0
-      if (!sliced.length) {
-        console.error(report, method, 'got sliced length', sliced.length, toSlice)
-        reject(new Error('0 to process'))
-      }
-      sliced.forEach((slice) => {
-        if (!slice.length) {
-          console.error(report, method, 'got empty slice', slice)
-          reject(new Error('got empty slice'))
-        }
-        try {
-          console.log('forking worker', workerCount++, report, method, slice.length)
-          const worker = cluster.fork()
-          worker.on('message', ({ result }) => {
-            console.log('received result from worker', worker.process.pid)
-            _result.push(result)
-            if (++done === sliced.length) {
-              resolve(_result.flat())
-            }
-          })
-          worker.on('error', (e) => {
-            console.error(e)
-            reject(new Error(`Worker ${worker.process.pid} error ${e.message}`))
-            reject(e)
-          })
-          worker.on('exit', (code, signal) => {
-            if (code !== 0) {
-              reject(new Error(`Worker ${worker.process.pid} exited with code ${code} and signal ${signal}`))
-            }
-          })
-          worker.send({
-            report,
-            method,
-            args: [slice, ...args]
-          })
-          console.log('sent to worker', worker.process.pid)
-        } catch (e) {
-          console.error(report, method, 'worker', workerCount, 'numCPUs', numCPUs)
-          reject(e)
-        }
-      })
-      cluster.on('exit', (worker, code, signal) => {
-        console.log('worker died', worker.process.pid, code, signal)
-        if (signal === 'SIGKILL') {
-          reject(new Error(`Worker died ${worker.process.pid}, code ${code} signal ${signal}`))
-        }
-      })
-    }
-  })
-}