fleetmap-reports 2.0.356 → 2.0.358

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

@@ -0,0 +1,641 @@
+const automaticReports = require('./automaticReports')
+const jsPDF = require('jspdf')
+const {
+  convertMS, convertToLocaleString, convertToLocaleDateString, convertToLocaleTimeString, getTranslations,
+  isClientSide, formatNumber
+} = require('./util/utils')
+require('jspdf-autotable')
+const { getUserPartner } = require('fleetmap-partners')
+const { headerFromUser, addTable } = require('./util/pdfDocument')
+const { getStyle } = require('./reportStyle')
+const traccarHelper = require('./util/traccar')
+const {
+  isInsideTimetable, isPartialInsideTimetable, getTripIdleTime, calculateStopDuration,
+  getUncompletedTrip, getTripTotalKms
+} = require('./util/trips')
+const { devicesToProcess, deviceName } = require('./util/device')
+const { getIdleEvents } = require('./util/route')
+const { reportByDriver, getDriverName, getDriverData } = require('./util/driver')
+const { getNearestPOIs } = require('./util/geofence')
+const { parallel } = require('./util/parallel')
+const { calculateConsumption } = require('./util/fuel')
+
+const fileName = 'TripReport'
+
+async function createTripReport (from, to, userData, traccar) {
+  console.log('createTripReport', from, to, userData.byDriver ? 'by driver' : userData.byGroup ? 'by group' : 'by device')
+  const reportData = []
+
+  if (userData.byDriver) {
+    const report = await createTripReportByDriver(from, to, userData, traccar)
+    reportData.push(report)
+  } else if (userData.byGroup) {
+    const allData = await createTripReportByGroup(from, to, userData, traccar)
+    reportData.push(...allData)
+  } else {
+    const report = await createTripReportByDevice(from, to, userData, traccar)
+    reportData.push(report)
+  }
+
+  return reportData
+}
+
+async function createTripReportByDevice (from, to, userData, traccar) {
+  const devices = devicesToProcess(userData)
+
+  const allData = {
+    devices: [],
+    xpert: devices.filter(d => d.attributes.xpert).length > 0
+  }
+
+  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, false, deviceCount, devices.length)
+    const tripsData = allInOne.trips
+    const stopsData = allInOne.stops
+    const routeData = allInOne.route
+
+    console.log('Trips:' + tripsData.length)
+
+    if (tripsData.length > 0) {
+      allData.devices.push(...await processDevices(from, to, slice, {
+        trips: tripsData,
+        stops: stopsData,
+        route: routeData
+      }, userData, traccar))
+    }
+    deviceCount = deviceCount + slice.length
+  }
+
+  return allData
+}
+
+async function createTripReportByGroup (from, to, userData, traccar) {
+  const reportData = []
+  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 response = await traccar.reports.reportsTripsGet(from, to, null, [g.id])
+      const tripsData = response.data
+
+      const stopsResponse = await traccar.reports.reportsStopsGet(from, to, null, [g.id])
+      const stopsData = stopsResponse.data
+
+      const routeResponse = await traccar.reports.reportsRouteGet(from, to, null, [g.id])
+      const routeData = routeResponse.data
+
+      devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+
+      if (tripsData.length > 0) {
+        console.log('Trips:' + tripsData.length)
+        groupData.devices = await processDevices(from, to, devices, { trips: tripsData, stops: stopsData, route: routeData }, userData)
+
+        reportData.push(groupData)
+      }
+    }
+  }
+
+  const allData = await createTripReportByDevice(from, to, userData, traccar)
+  reportData.push(allData)
+
+  return reportData
+}
+
+async function createTripReportByDriver (from, to, userData, traccar) {
+  const devices = await traccar.devices.devicesGet().then(d => d.data)
+  console.log(devices.length, 'devices')
+  console.log('drivers', userData.drivers)
+
+  if (!devices.length) {
+    // Empty report
+    return { drivers: [] }
+  }
+
+  const results = await reportByDriver(devices, traccar, from, to, userData, processDrivers)
+
+  const report = { drivers: [] }
+
+  results.drivers.forEach(result => {
+    const driver = report.drivers.find(d => d.driver.id === result.driver.id)
+    if (driver) {
+      driver.trips.push(...result.trips)
+    } else {
+      report.drivers.push(result)
+    }
+  })
+
+  report.drivers.forEach(d => {
+    d.totalDuration = d.trips.reduce((a, b) => a + b.duration, 0)
+    d.totalDistance = d.trips.reduce((a, b) => a + b.distance, 0)
+    d.maxSpeed = d.trips.reduce((a, b) => { return a > b.maxSpeed ? a : b.maxSpeed }, 0)
+    d.trips = d.trips.sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime())
+
+    d.trips.forEach((trip, i) => {
+      trip.stopDuration = (i !== d.trips.length - 1 ? (new Date(d.trips[i + 1].startTime) - new Date(trip.endTime)) : (to - new Date(trip.endTime))) - trip.stopEngineHours
+    })
+  })
+
+  return report
+}
+
+async function processDevices (from, to, devices, data, userData, traccar) {
+  const devicesResult = []
+
+  for (const d of devices) {
+    const deviceRoute = data.route.filter(t => t.deviceId === d.id)
+    const deviceTrips = data.trips.filter(t => t.deviceId === d.id)
+
+    const uncompletedTrip = getUncompletedTrip(d, deviceRoute, deviceTrips)
+    if (uncompletedTrip) {
+      deviceTrips.push(uncompletedTrip)
+    }
+
+    const trips = []
+
+    for (const t of deviceTrips) {
+      if (userData.allWeek ||
+        !userData.weekDays ||
+        isInsideTimetable(t, userData) ||
+        await isPartialInsideTimetable(d, t, userData, deviceRoute)) {
+        trips.push(t)
+      }
+    }
+
+    const stops = data.stops.filter(s => s.deviceId === d.id)
+
+    trips.forEach(trip => {
+      trip.model = d.model
+      const stop = getStop(new Date(trip.startTime), stops)
+
+      trip.totalKms = getTripTotalKms(trip, stop, deviceRoute)
+
+      const nearestPOIs = getNearestPOIs(trip.endLon, trip.endLat, userData.geofences)
+      if (nearestPOIs.length > 0) {
+        trip.endPOIName = nearestPOIs[0].p.name
+      }
+
+      if (userData.includeTemperature) {
+        const tripRoute = deviceRoute.filter(p => trip.startTime <= p.fixTime && trip.endTime >= p.fixTime)
+
+        const temperatureValues = tripRoute.map(p => {
+          for (let i = 1; i <= 3; i++) {
+            const temp = 'temp' + i
+            if (p.attributes[temp] && parseFloat(p.attributes[temp]) !== 175) {
+              return parseFloat(p.attributes[temp])
+            }
+          }
+
+          return undefined
+        }).filter(a => a !== undefined)
+
+        trip.maxTemp = temperatureValues.length > 0
+          ? temperatureValues.reduce((a, b) => {
+            return a > b ? a : b
+          })
+          : 0
+        trip.minTemp = temperatureValues.length > 0
+          ? temperatureValues.reduce((a, b) => {
+            return a < b ? a : b
+          })
+          : 0
+        trip.avgTemp = temperatureValues.length > 0
+          ? (temperatureValues.reduce((a, b) => {
+              return a + b
+            }, 0)) / temperatureValues.length
+          : 0
+      }
+
+      if (deviceRoute.some(r => r.attributes.fuel) ||
+          automaticReports.deviceWithFuelInfo(d)) {
+        trip.fuelConsumption = calculateConsumption(d, { trips: [trip], stops: (stop ? [stop] : []), route: deviceRoute })
+        trip.avgFuelConsumption = trip.totalKms > 0 ? trip.fuelConsumption * 100 / trip.totalKms : 0
+      }
+
+      if (stop && !trip.endTimeIsOut) {
+        trip.stopDuration = calculateStopDuration(stop)
+        trip.stopEngineHours = trip.idleTime + stop.idleTime
+      } else {
+        trip.stopDuration = 0
+        trip.stopEngineHours = 0
+      }
+      if (trip.endAddress === null) {
+        traccar.axios.get(`/server/geocode?latitude=${trip.endLat}&longitude=${trip.endLon}`)
+          .then(d => { trip.endAddress = d.data }).catch(e => console.warn(e.message, trip.endLat, trip.endLon))
+      }
+    })
+
+    if (trips.length > 0) {
+      const deviceData = {
+        device: d,
+        from,
+        to,
+        totalDuration: trips.reduce((a, b) => a + b.duration, 0),
+        totalDistance: trips.reduce((a, b) => a + b.distance, 0),
+        maxSpeed: trips.reduce((a, b) => {
+          return a > b.maxSpeed ? a : b.maxSpeed
+        }, 0),
+        trips
+      }
+
+      if (trips[0].fuelConsumption !== undefined) {
+        deviceData.totalFuelConsumption = trips.reduce((a, b) => a + b.fuelConsumption, 0)
+        deviceData.avgFuelConsumption = deviceData.totalDistance > 0 ? (deviceData.totalFuelConsumption * 100) / (deviceData.totalDistance / 1000) : 0
+      }
+
+      devicesResult.push(deviceData)
+    }
+  }
+
+  return devicesResult
+}
+
+function calculateIdleEvents (drivers, route) {
+  const idleEvents = []
+  drivers.forEach(d => {
+    idleEvents.push(...getIdleEvents(route, d))
+  })
+  return idleEvents
+}
+
+async function processDrivers (from, to, userData, data) {
+  const driversResult = []
+
+  const idleEvents = []
+  if (isClientSide()) {
+    idleEvents.push(...(calculateIdleEvents(userData.drivers, data.route)))
+  } else {
+    if (data.route.length && userData.drivers.length) {
+      idleEvents.push(...(await parallel('trip-report', 'calculateIdleEvents', userData.drivers, data.route)))
+    }
+  }
+
+  for (const d of userData.drivers) {
+    const { trips, route } = await getDriverData(d, data, userData)
+
+    if (trips) {
+      trips.forEach(trip => {
+        const stop = data.stops.find(s => s.deviceId === trip.deviceId && (new Date(s.startTime).getTime() === new Date(trip.endTime).getTime()))
+
+        trip.totalKms = getTripTotalKms(trip, stop, route)
+
+        const nearestPOIs = getNearestPOIs(trip.endLon, trip.endLat, userData.geofences)
+        if (nearestPOIs.length > 0) {
+          trip.endPOIName = nearestPOIs[0].p.name
+        }
+
+        trip.stopEngineHours = getTripIdleTime(trip, idleEvents) + (stop ? stop.idleTime : 0)
+      })
+
+      if (trips.length > 0) {
+        const driverData = {
+          driver: d,
+          from,
+          to,
+          trips
+        }
+        driversResult.push(driverData)
+      }
+    }
+  }
+
+  return driversResult
+}
+
+async function exportTripReportToPDF (userData, reportData) {
+  console.log('exportTripReportToPDF')
+
+  const timezone = userData.user.attributes.timezone
+  const translations = getTranslations(userData)
+  const lang = userData.user.attributes.lang || (isClientSide() && navigator.language)
+  const tripsData = userData.byDriver ? reportData.drivers : reportData.devices
+
+  const headers = [
+    translations.report.date,
+    translations.report.start,
+    translations.report.end,
+    translations.report.endAddress,
+    translations.report.tripTime,
+    translations.report.idleTime,
+    translations.report.stopTime,
+    translations.report.distance,
+    translations.report.avgSpeed,
+    translations.report.maxSpeed
+  ]
+
+  if (userData.includeTemperature) {
+    headers.push(translations.report.maxTemp)
+    headers.push(translations.report.minTemp)
+    headers.push(translations.report.avgTemp)
+  }
+
+  if (tripsData) {
+    const withFuelData = tripsData.find(t => t.totalFuelConsumption !== undefined)
+
+    if (withFuelData) {
+      headers.push(translations.report.consumption,
+        translations.report.avg_consumption)
+    }
+
+    if (userData.byDriver) {
+      headers.push(translations.report.name)
+    } else {
+      headers.push(translations.report.driver)
+    }
+
+    // eslint-disable-next-line new-cap
+    const doc = new jsPDF.jsPDF('l')
+    await headerFromUser(doc, translations.report.titleTripReport, userData.user)
+
+    tripsData.forEach(function (d, index) {
+      const data = []
+      const name = userData.byDriver
+        ? d.driver.name + ' ' + ((d.driver.attributes && d.driver.attributes.notes) || '')
+        : deviceName(d.device)
+      const group = userData.byDriver ? userData.groups.find(g => g.drivers && g.drivers.includes(d.id)) : 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(d.from, lang, timezone, userData.user) + ' - ' + convertToLocaleString(d.to, lang, timezone, userData.user), 20, space + 25)
+      if (!userData.allWeek && userData.weekDays) {
+        doc.text((userData.weekDays.monday ? ' ' + translations.report.monday + ',' : '') +
+                    (userData.weekDays.tuesday ? ' ' + translations.report.tuesday + ',' : '') +
+                    (userData.weekDays.wednesday ? ' ' + translations.report.wednesday + ',' : '') +
+                    (userData.weekDays.thursday ? ' ' + translations.report.thursday + ',' : '') +
+                    (userData.weekDays.friday ? ' ' + translations.report.friday + ',' : '') +
+                    (userData.weekDays.saturday ? ' ' + translations.report.saturday + ',' : '') +
+                    (userData.weekDays.sunday ? ' ' + translations.report.sunday + ',' : '') +
+                    ' das ' +
+                    userData.dayHours.startTime + ' - ' + userData.dayHours.endTime, 20, space + 30)
+        doc.text(translations.report.headerStartAddress + ': ' + d.trips[0].startAddress, 20, space + 40)
+      } else {
+        doc.text(translations.report.headerStartAddress + ': ' + d.trips[0].startAddress, 20, space + 35)
+      }
+
+      d.trips.forEach(a => {
+        const temp = [
+          getTripDate(userData.user, a),
+          getTripStart(userData.user, a),
+          getTripEnd(userData.user, a),
+          a.endPOIName || a.endAddress,
+          convertMS(a.duration)
+        ]
+
+        temp.push(convertMS(a.stopEngineHours),
+          convertMS(a.stopDuration),
+          Intl.NumberFormat(userData.user.attributes.lang, { maximumFractionDigits: 1 }).format(a.totalKms),
+          Math.round(a.averageSpeed * 1.85200),
+          Math.round(a.maxSpeed * 1.85200))
+
+        if (userData.includeTemperature) {
+          temp.push(a.maxTemp)
+          temp.push(a.minTemp)
+          temp.push(a.avgTemp && a.avgTemp.toFixed(1))
+        }
+
+        if (withFuelData) {
+          temp.push(a.fuelConsumption && a.fuelConsumption.toFixed(1),
+            a.avgFuelConsumption && a.avgFuelConsumption.toFixed(1))
+        }
+
+        if (userData.byDriver) {
+          temp.push(a.deviceName)
+        } else {
+          temp.push(getDriverName(a.driverUniqueId, a.startTime, userData))
+        }
+
+        data.push(temp)
+      })
+      const footValues = [
+        'Total:' + d.trips.length,
+        '', '', '',
+        convertMS(d.trips.reduce((a, b) => a + b.duration, 0))
+      ]
+
+      footValues.push(convertMS(d.trips.reduce((a, b) => a + b.stopEngineHours, 0)),
+        convertMS(d.trips.reduce((a, b) => a + b.stopDuration, 0)),
+        getSumTotalKms(userData.user, d.trips),
+        getSumAvgSpeed(d.trips),
+        getMaxSpeed(d.trips))
+
+      if (userData.includeTemperature) {
+        footValues.push(...['', '', ''])
+      }
+
+      if (withFuelData) {
+        footValues.push(
+          d.totalFuelConsumption && parseFloat(d.totalFuelConsumption).toFixed(1),
+          d.avgFuelConsumption && parseFloat(d.avgFuelConsumption).toFixed(1))
+      }
+
+      const style = getStyle(getUserPartner(userData.user))
+      if (userData.includeTemperature && withFuelData) {
+        style.headerFontSize = 8
+        style.bodyFontSize = 6
+        style.footerFontSize = 7
+      }
+
+      addTable(doc,
+        headers, data, footValues, style,
+        space + (userData.allWeek ? 40 : 45),
+        {
+          4: { halign: 'right' },
+          5: { halign: 'right' },
+          6: { halign: 'right' },
+          7: { halign: 'right' },
+          8: { halign: 'right' },
+          9: { halign: 'right' },
+          ...(userData.includeTemperature
+            ? {
+                10: { halign: 'right' },
+                11: { halign: 'right' },
+                12: { halign: 'right' }
+              }
+            : {}),
+          ...(withFuelData && userData.includeTemperature
+            ? {
+                13: { halign: 'right' },
+                14: { halign: 'right' }
+              }
+            : withFuelData
+              ? {
+                  10: { halign: 'right' },
+                  11: { halign: 'right' }
+                }
+              : {})
+        })
+    })
+    return doc
+  }
+}
+
+function exportTripReportToExcel (userData, reportData) {
+  console.log('Export to Excel')
+
+  const translations = getTranslations(userData)
+
+  const tripsData = userData.byDriver ? reportData.drivers : reportData.devices
+
+  const settings = {
+    sheetName: translations.report.titleTripReport, // The name of the sheet
+    fileName // The name of the spreadsheet
+  }
+
+  const headers = [
+    { label: translations.report.date, value: 'date' },
+    { label: translations.report.start, value: 'start' },
+    { label: translations.report.end, value: 'end' },
+    { label: translations.report.endAddress, value: 'endAddress' },
+    { label: translations.report.tripTime, value: 'tripTime' },
+    { label: translations.report.idleTime, value: 'idleTime' },
+    { label: translations.report.stopTime, value: 'stopTime' },
+    { label: translations.report.distance, value: 'distance' },
+    { label: translations.report.avgSpeed, value: 'averageSpeed' },
+    { label: translations.report.maxSpeed, value: 'maxSpeed' }
+  ]
+
+  if (userData.includeTemperature) {
+    headers.push({ label: translations.report.maxTemp, value: 'maxTemp' })
+    headers.push({ label: translations.report.minTemp, value: 'minTemp' })
+    headers.push({ label: translations.report.avgTemp, value: 'avgTemp' })
+  }
+
+  let data = []
+  if (tripsData) {
+    const withFuelData = tripsData.find(b => b.totalFuelConsumption !== undefined)
+
+    if (withFuelData) {
+      headers.push({ label: translations.report.consumption, value: 'consumption' },
+        { label: translations.report.avg_consumption, value: 'avgConsumption' })
+    }
+
+    if (userData.byDriver) {
+      headers.unshift({ label: translations.report.driver, value: 'name' })
+      headers.push({ label: translations.report.vehicle, value: 'subname' })
+    } else {
+      headers.unshift({ label: translations.settings.vehicle_model, value: 'model' })
+      headers.unshift({ label: translations.report.group, value: 'group' })
+      headers.unshift({ label: translations.report.driver, value: 'subname' })
+      headers.unshift({ label: translations.report.vehicle, value: 'name' })
+    }
+
+    tripsData.forEach(d => {
+      const group = userData.byDriver
+        ? userData.groups.find(g => g.drivers && g.drivers.includes(d.id))
+        : userData.groups.find(g => g.id === d.device.groupId)
+      data = data.concat([{}])
+      data = data.concat(d.trips.map(a => {
+        return {
+          name: userData.byDriver ? d.driver.name : a.deviceName,
+          date: getTripDate(userData.user, a),
+          start: getTripStart(userData.user, a),
+          end: getTripEnd(userData.user, a),
+          endAddress: a.endPOIName || a.endAddress,
+          tripTime: convertMS(a.duration),
+          idleTime: convertMS(a.stopEngineHours),
+          stopTime: convertMS(a.stopDuration),
+          distance: Number(a.totalKms.toFixed(1)),
+          averageSpeed: Math.round(a.averageSpeed * 1.85200),
+          maxSpeed: Math.round(a.maxSpeed * 1.85200),
+          consumption: a.fuelConsumption && Number(a.fuelConsumption.toFixed(1)),
+          avgConsumption: a.avgFuelConsumption && Number(a.avgFuelConsumption.toFixed(1)),
+          subname: userData.byDriver ? a.deviceName : getDriverName(a.driverUniqueId, a.startTime, userData),
+          maxTemp: a.maxTemp,
+          minTemp: a.minTemp,
+          avgTemp: a.avgTemp && Number(a.avgTemp.toFixed(1)),
+          model: d.device && d.device.model,
+          group: group && group.name
+        }
+      }))
+      // Totals
+      data = data.concat([{
+        name: d.trips.length,
+        tripTime: convertMS(d.trips.reduce((a, b) => a + b.duration, 0)),
+        idleTime: convertMS(d.trips.reduce((a, b) => a + b.stopEngineHours, 0)),
+        stopTime: convertMS(d.trips.reduce((a, b) => a + b.stopDuration, 0)),
+        distance: getSumTotalKms(userData.user, d.trips),
+        averageSpeed: getSumAvgSpeed(d.trips),
+        maxSpeed: getMaxSpeed(d.trips),
+        consumption: d.totalFuelConsumption && Number(parseFloat(d.totalFuelConsumption).toFixed(1)),
+        avgConsumption: d.avgFuelConsumption && Number(parseFloat(d.avgFuelConsumption).toFixed(1))
+      }])
+      data = data.concat([{}])
+    })
+    console.log(data)
+    return {
+      headers,
+      data,
+      settings
+    }
+  }
+}
+
+function getTripDate (user, trip) {
+  return convertToLocaleDateString(trip.startTime, user.attributes.lang, user.attributes.timezone, user)
+}
+
+function getTripStart (user, trip) {
+  return convertToLocaleTimeString(trip.startTime, user.attributes.lang, user.attributes.timezone, user)
+}
+
+function getTripEnd (user, trip) {
+  return convertToLocaleTimeString(trip.endTime, user.attributes.lang, user.attributes.timezone, user)
+}
+
+function getSumTotalKms (user, data) {
+  const values = data.map(item => {
+    return item.totalKms ? parseFloat(item.totalKms) : 0
+  })
+  return formatNumber(values.reduce((a, b) => a + b, 0))
+}
+
+function getSumAvgSpeed (data) {
+  const values = data.map(item => {
+    return Math.round(item.averageSpeed * 1.85200) * item.totalKms
+  })
+  const totalKms = data.reduce((a, b) => a + b.totalKms, 0)
+  return totalKms > 0 ? Math.round((values.reduce((a, b) => a + b, 0)) / totalKms) : 0
+}
+
+function getMaxSpeed (data) {
+  const values = data.map(item => {
+    return item.maxSpeed
+  })
+  const max = values.reduce(function (a, b) {
+    return Math.max(a, b)
+  })
+  return Math.round(max * 1.85200)
+}
+
+function getStop (tripEndDate, stops) {
+  const stopList = stops.filter(s => new Date(s.startTime).getTime() >= tripEndDate.getTime())
+  if (stopList.length) {
+    return stopList[0]
+  }
+
+  return null
+}
+
+exports.getStop = getStop
+exports.createTripReport = createTripReport
+exports.exportTripReportToPDF = exportTripReportToPDF
+exports.exportTripReportToExcel = exportTripReportToExcel
+exports.create = createTripReport
+exports.exportToPDF = exportTripReportToPDF
+exports.exportToExcel = exportTripReportToExcel
+exports.calculateIdleEvents = calculateIdleEvents

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

@@ -0,0 +1,13 @@
+function devicesToProcess (userData) {
+  const groupIds = userData.groups.map(g => g.id)
+  const devices = userData.byGroup ? userData.devices.filter(d => !groupIds.includes(d.groupId)) : userData.devices
+  devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+  console.log('LOADING_MESSAGE:' + devices.map(d => d.name).join(', '))
+  return devices
+}
+
+exports.deviceName = function deviceName (device) {
+  return device.name + (device.attributes.license_plate ? ', ' + device.attributes.license_plate : '') + (device.model ? ', ' + device.model : '')
+}
+
+exports.devicesToProcess = devicesToProcess