fleetmap-reports 2.0.357 → 2.0.358

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

@@ -0,0 +1,128 @@
+const automaticReports = require('./automaticReports')
+const { devicesToProcess } = require('./util/device')
+const { getTranslations } = require('./util/utils')
+const traccarHelper = require('./util/traccar')
+
+function calculateFuelDrop (position, positions) {
+  const index = positions.indexOf(position)
+  if (index > 0) {
+    let backIndex = 1
+    while ((backIndex < 10) && index - backIndex >= 0) {
+      const positionBefore = positions[index - backIndex]
+      const diff = positionBefore.attributes.fuel - position.attributes.fuel
+      if (diff > 0) {
+        return diff
+      }
+      backIndex++
+    }
+  }
+  return 0
+}
+
+async function createFuelDropReport (from, to, userData, traccar) {
+  console.log('Create FuelDropReport')
+
+  const allData = {
+    devices: [],
+    from,
+    to
+  }
+
+  const reportData = []
+  reportData.push(allData)
+
+  const devices = devicesToProcess(userData)
+
+  const arrayOfArrays = automaticReports.sliceArray(devices, 50)
+  let data = []
+
+  const types = ['deviceFuelDrop']
+  for (const a of arrayOfArrays) {
+    const response = await traccar.reports.reportsEventsGet(from, to, a.map(d => d.id), null, types)
+    data = data.concat(response.data)
+  }
+  console.log('FuelDrop Alerts:' + data.length)
+  allData.totalDevices = 0
+  allData.totalFuelDrops = 0
+  allData.totalFuelDropLiters = 0
+
+  for (const d of devices) {
+    const alerts = data.filter(t => t.deviceId === d.id)
+    if (alerts.length > 0) {
+      const allInOne = await traccarHelper.getAllInOne(traccar, from, to, [d], true, false, false, false, 1, devices.length)
+      const route = allInOne.route.filter(t => t.deviceId === d.id)
+
+      for (const a of alerts) {
+        a.fuelDropLiters = 0
+        if (a.positionId > 0) {
+          const position = route.find(p => p.id === a.positionId)
+          if (position) {
+            a.position = position
+            const diff = calculateFuelDrop(position, route)
+            a.fuelDropLiters = Math.round(diff * d.attributes.fuel_tank_capacity / 100)
+          }
+        }
+      }
+
+      // Filter wrong fuel drop values
+      const filteredAlerts = alerts.filter(a => a.fuelDropLiters < d.attributes.fuel_tank_capacity && a.fuelDropLiters > 0)
+
+      if (filteredAlerts.length > 0) {
+        allData.devices.push({
+          device: d,
+          alerts: filteredAlerts
+        })
+      }
+    }
+  }
+
+  return reportData
+}
+
+function exportFuelDropReportToExcel (userData, reportData) {
+  console.log('Export to Excel')
+  const translations = getTranslations(userData)
+
+  const settings = {
+    sheetName: 'FuelDropReport', // The name of the sheet
+    fileName: 'FuelDropReport' // The name of the spreadsheet
+  }
+  const headers = [
+    { label: translations.report.name, value: 'name' },
+    { label: translations.report.driver, value: 'driver' },
+    { label: translations.report.date, value: 'fixTime' },
+    { label: translations.report.address, value: 'address' },
+    { label: translations.report.fueldrop, value: 'fuelDropLiters' }
+  ]
+  let data = []
+  if (reportData.devices) {
+    reportData.devices.forEach(d => {
+      data = data.concat(d.alerts.map(r => {
+        return {
+          driver: r.driverName,
+          fuelDropLiters: r.fuelDropLiters,
+          fixTime: new Date(r.position.fixTime).toLocaleString(),
+          name: d.device.name,
+          address: r.geofenceName || r.position.address
+        }
+      }))
+    })
+  }
+
+  return {
+    headers,
+    data,
+    settings
+  }
+}
+
+function exportFuelDropReportToPDF (userData, reportData) {
+  console.log('Export to PDF')
+}
+
+exports.createFuelDropReport = createFuelDropReport
+exports.exportFuelDropReportToPDF = exportFuelDropReportToPDF
+exports.exportFuelDropReportToExcel = exportFuelDropReportToExcel
+exports.create = createFuelDropReport
+exports.exportToPDF = exportFuelDropReportToPDF
+exports.exportToExcel = exportFuelDropReportToExcel

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

@@ -0,0 +1,172 @@
+const axios = require('axios')
+
+const appId = 'apiKey=' + process.env.HERE_API_KEY
+
+const calcRoute = 'https://fleet.ls.hereapi.com/2/calculateroute.json?&detailedTollCosts=1&' +
+  appId +
+  '&routeMatch=1&filetype=CSV&mode=car&tollVehicleType=1&rollups=none,country;tollsys&' +
+  'attributes=SPEED_LIMITS_FCn(*),ROAD_NAME_FCn(*),ROAD_ADMIN_FCn(*),DISTANCE_MARKERS_FCn(*)' +
+  ',ROAD_GEOM_FCn(*),TOLL_LINK_FCn(*),TOLL_BOOTH_FCn(*),TRUCK_SPEED_LIMITS_FCn(*),TRUCK_RESTR_FCn(*)'
+
+const util = require('util')
+
+function mpsToKmh (mps) {
+  return mps * 3.6
+}
+
+function getSpeedLimit (li) {
+  if (li && li.attributes && li.attributes.SPEED_LIMITS_FCN) {
+    const from = li.attributes.SPEED_LIMITS_FCN[0].FROM_REF_SPEED_LIMIT
+    const to = li.attributes.SPEED_LIMITS_FCN[0].TO_REF_SPEED_LIMIT
+    if (from > to) {
+      return from
+    }
+    return to
+  }
+  return 999
+}
+
+function getRoadName (li) {
+  if (li.attributes.ROAD_GEOM_FCN) {
+    const result = li.attributes.ROAD_GEOM_FCN[0].NAME
+    if (result && result.length > 0) { return result }
+  }
+  return ''
+}
+
+function getTruckSpeedLimits (li) {
+  if (li.attributes.TRUCK_SPEED_LIMITS_FCN) {
+    return li.attributes.TRUCK_SPEED_LIMITS_FCN
+  }
+  return null
+}
+
+function getDistanceMarkers (li) {
+  if (li.attributes.DISTANCE_MARKERS_FCN) {
+    const dMarkers = li.attributes.DISTANCE_MARKERS_FCN
+    return util.format('km %d', dMarkers[0].DISTANCE_VALUE)
+  }
+  return ''
+}
+
+function generateCSV (rows) {
+  const route = []
+  route.push('latitude, longitude, speed_kmh, heading, timestamp')
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i]
+    route.push(r.latitude + ',' + r.longitude + ',' + r.speed * 1.852 + ',' + r.course + ',' + r.fixTime)
+  }
+  return route.join('\n')
+}
+/*
+function generateCoordsCSV(rows) {
+  const route = []
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i]
+    route.push('id=' + i + '&prox=' + r.latMatched + ',' + r.lonMatched + ',20')
+  }
+  return route.join('\n')
+}
+
+function fillGeocoding(rows) {
+  return new Promise((resolve) => {
+    const csv = generateCoordsCSV(rows.slice(0, 300))
+    const body = {
+      report: 'reverseGeocode',
+      rows: csv
+    }
+    axios.post(rServerUrl,
+      body,
+      {
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 60000 // Maximum timeour for the Lambda API Gateway
+      }
+    ).then((response) => {
+      if (response.data) {
+        const hereData = response.data
+        for (let i = 0; i < hereData.Response.Item.length; i++) {
+          rows[i].geocoding = hereData.Response.Item[i].Result[0].Location.Address.Label
+        }
+        resolve(rows)
+      }
+    }).catch((e) => {
+      console.error(e)
+    })
+  })
+} */
+
+exports.routeMatch = async (rows) => {
+  const csv = generateCSV(rows)
+  const response = await axios.post(calcRoute, csv, { headers: { 'Content-Type': 'application/binary' } })
+  const hereData = response.data
+  const route = hereData.response.route[0]
+  const results = []
+  const wayPoints = route.waypoint
+  const links = route.leg[0].link
+  if (wayPoints && wayPoints.length > 0) {
+    for (let i = 0; i < wayPoints.length; i++) {
+      const tp = wayPoints[i]
+      const li = links[tp.routeLinkSeqNrMatched]
+      results.push({
+        linkId: tp.routeLinkSeqNrMatched,
+        timestamp: tp.timestamp,
+        currentSpeedKmh: mpsToKmh(tp.speedMps),
+        latitude: tp.originalPosition.latitude,
+        longitude: tp.originalPosition.longitude,
+        latMatched: tp.mappedPosition.latitude,
+        lonMatched: tp.mappedPosition.longitude,
+        heading: tp.headingDegreeNorthClockwise,
+        headingMatched: tp.headingMatched,
+        speedLimit: getSpeedLimit(li),
+        roadName: getRoadName(li),
+        truckSpeedLimits: getTruckSpeedLimits(li),
+        distanceMarkers: getDistanceMarkers(li),
+        geocoding: ''
+      })
+    }
+  }
+  return results
+}
+
+exports.tollsMatch = async (rows, result) => {
+  const csv = generateCSV(rows)
+  axios.post(calcRoute, csv, { headers: { 'Content-Type': 'application/binary' } }).then((response) => {
+    const hereData = response.data
+    const results = []
+    const tollData = hereData.response.route[0].tollCost.routeTollItems
+    if (tollData) {
+      let it = 0
+      const wayPoints = hereData.response.route[0].waypoint
+      const links = hereData.response.route[0].leg[0].link
+      for (let ti = 0; ti < tollData.length; ti++) {
+        const i = tollData[ti]
+        if (i.tollCostAlternatives) {
+          for (let il = 0; il < links.length; il++) {
+            if (parseInt(links[il].linkId) === parseInt(i.tollStructures[0].linkIds[0])) {
+              for (; it < wayPoints.length; it++) {
+                if (wayPoints[it].routeLinkSeqNrMatched >= il) {
+                  const li = wayPoints[it]
+                  results.push({
+                    country: i.country,
+                    road: i.tollSystem[0].name,
+                    amount: i.tollCostAlternatives[0].amount,
+                    currency: i.tollCostAlternatives[0].currency,
+                    toll: i.tollStructures[0].name,
+                    timestamp: li ? li.timestamp : '',
+                    speed: li ? mpsToKmh(li.speedMps) : ''
+                  })
+                  break
+                }
+              }
+              break
+            }
+          }
+        }
+      }
+      result(results)
+    } else { result([]) }
+  }).catch(e => {
+    console.error(e)
+    result([])
+  })
+}

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

@@ -0,0 +1,403 @@
+const jsPDF = require('jspdf')
+const { headerFromUser, AmiriRegular } = require('./util/pdfDocument')
+const {
+  convertToLocaleString, convertMS, getTranslations, getLanguage, convertToLocaleDateString, convertToLocaleTimeString,
+  convertPositionToFeature,
+  convertToFeature
+} = require('./util/utils')
+const { getStyle } = require('./reportStyle')
+const { getUserPartner } = require('fleetmap-partners')
+const { devicesToProcess } = require('./util/device')
+const automaticReports = require('./automaticReports')
+const traccarHelper = require('./util/traccar')
+const { getIdleEvents } = require('./util/route')
+const { reportByDriver, getDriverData } = require('./util/driver')
+const { getNearestPOIs, checkGeofenceIn, loadGroupsData } = require('./util/geofence')
+
+const fileName = 'IdleReport'
+
+function getDriver (idleEvent, drivers) {
+  if (idleEvent && idleEvent.position && idleEvent.position.attributes.driverUniqueId) {
+    const driver = drivers.find(d => d.uniqueId === idleEvent.position.attributes.driverUniqueId)
+    return driver ? driver.name : idleEvent.position.attributes.driverUniqueId
+  }
+  return ''
+}
+
+async function createIdleReport (from, to, userData, traccarInstance) {
+  console.log('Create IdleReport')
+  const reportData = []
+
+  if (userData.byDriver) {
+    console.log('ByDriver')
+    const report = await createIdleReportByDriver(from, to, userData, traccarInstance)
+    reportData.push(report)
+  } else if (userData.byGroup) {
+    console.log('ByGroup')
+    const allData = await createIdleReportByGroup(from, to, userData, traccarInstance)
+    reportData.push(...allData)
+  } else {
+    console.log('ByDevice')
+    const report = await createIdleReportByDevice(from, to, userData, traccarInstance)
+    reportData.push(report)
+  }
+
+  return reportData
+}
+
+async function createIdleReportByDriver (from, to, userData, traccar) {
+  const devices = await traccar.devices.devicesGet().then(d => d.data)
+
+  if (!devices.length) {
+    // Empty report
+    return { drivers: [] }
+  }
+
+  await loadGroupsData(userData, traccar)
+
+  const results = await reportByDriver(devices, traccar, from, to, userData, processDrivers)
+
+  const report = {
+    drivers: [],
+    from,
+    to
+  }
+
+  results.drivers.forEach(result => {
+    const driver = report.drivers.find(d => d.driver.id === result.driver.id)
+    if (driver) {
+      driver.idleEvents.push(...result.idleEvents)
+    } else {
+      report.drivers.push(result)
+    }
+  })
+
+  report.drivers.forEach(d => {
+    d.idleEvents = d.idleEvents.sort((a, b) => (new Date(a.position.fixTime) > new Date(b.position.fixTime)) ? 1 : -1)
+  })
+
+  return report
+}
+
+async function createIdleReportByGroup (from, to, userData, traccarInstance) {
+  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,
+        from,
+        to
+      }
+
+      const response = await traccarInstance.reports.reportsRouteGet(from, to, null, [g.id])
+      const routes = response.data
+
+      devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+
+      if (routes.length > 0) {
+        console.log('Routes:' + routes.length)
+        groupData.devices = processDevices(from, to, devices, routes, userData)
+
+        reportData.push(groupData)
+      }
+    }
+  }
+
+  const groupIds = userData.groups.map(g => g.id)
+  const withoutGroupDevices = userData.devices.filter(d => !groupIds.includes(d.groupId))
+
+  const allData = await createIdleReportByDevice(from, to, withoutGroupDevices, userData, traccarInstance)
+  reportData.push(allData)
+
+  return reportData
+}
+
+async function createIdleReportByDevice (from, to, userData, traccarInstance) {
+  const allData = {
+    devices: [],
+    from,
+    to
+  }
+
+  await loadGroupsData(userData, traccarInstance)
+
+  const devices = devicesToProcess(userData)
+  const sliced = automaticReports.sliceArray(devices, 5)
+
+  let deviceCount = 0
+  for (const slice of sliced) {
+    const { route } = await traccarHelper.getAllInOne(traccarInstance, from, to, slice, true, false, false, false, deviceCount, devices.length)
+
+    if (route.length > 0) {
+      allData.devices.push(...await processDevices(from, to, slice, route, userData))
+    }
+
+    deviceCount = deviceCount + slice.length
+  }
+
+  return allData
+}
+
+async function processDrivers (from, to, userData, data) {
+  const driversResult = []
+  for (const d of userData.drivers) {
+    const { route } = await getDriverData(d, data, userData)
+
+    if (route.length > 0) {
+      const idleEvents = getIdleEvents(data.route, d, userData.idleSpeedThreshold / 1.85200)
+      const filteredEvents = idleEvents.filter(e => userData.minimumIdleMinutes ? e.idleTime > userData.minimumIdleMinutes * 60 * 1000 : true)
+
+      if (filteredEvents.length) {
+        filteredEvents.forEach(e => {
+          findPOIData(e, userData)
+          findGeofenceData(e, userData)
+          const device = userData.devices.find(d => d.id === e.position.deviceId)
+          e.deviceName = device ? device.name : ''
+        })
+
+        const driverData = {
+          driver: d,
+          idleEvents: filteredEvents
+        }
+        driversResult.push(driverData)
+      }
+    }
+  }
+
+  return driversResult
+}
+
+async function processDevices (from, to, devices, routes, userData) {
+  const devicesResult = []
+  for (const d of devices) {
+    const route = routes.filter(p => p.deviceId === d.id)
+
+    const idleEvents = getIdleEvents(route, undefined, userData.idleSpeedThreshold / 1.85200)
+    const filteredEvents = idleEvents.filter(e => e.idleTime > (userData.minimumIdleMinutes ? userData.minimumIdleMinutes * 60 * 1000 : 0))
+
+    if (filteredEvents.length) {
+      for (const e of filteredEvents) {
+        findPOIData(e, userData)
+        findGeofenceData(e, userData)
+
+        const driver = userData.drivers.find(d => d.id === e.position.attributes.driverUniqueId)
+        e.driver = driver ? driver.name : ''
+      }
+
+      const deviceData = {
+        device: d,
+        idleEvents: filteredEvents
+      }
+      devicesResult.push(deviceData)
+    }
+  }
+
+  return devicesResult
+}
+
+function findPOIData (event, userData) {
+  const nearestPOIs = getNearestPOIs(event.position.longitude, event.position.latitude, userData.geofences)
+  if (nearestPOIs.length > 0) {
+    event.endPOIName = nearestPOIs[0].p.name
+  }
+}
+
+function findGeofenceData (event, userData) {
+  const geofence = userData.geofences.filter(g => !g.area.startsWith('CIRCLE')).find(g =>
+    checkGeofenceIn(convertPositionToFeature(event.position), convertToFeature(g)))
+  if (geofence) {
+    const group = userData.groups.find(g => g.geofenceIds && g.geofenceIds.includes(geofence.id))
+    event.geofenceName = geofence.name
+    event.geofenceGroup = (group && group.name) || ''
+  }
+}
+
+async function exportIdleReportToPDF (userData, reportData) {
+  console.log('Export to PDF')
+
+  const timezone = userData.user.attributes.timezone
+  const lang = getLanguage(userData)
+  const translations = getTranslations(userData)
+
+  const idleData = userData.byDriver ? reportData.drivers : reportData.devices
+
+  const headers = [
+    translations.report.date,
+    translations.report.start,
+    translations.report.end,
+    translations.report.address,
+    translations.report.duration,
+    translations.report.zone
+  ]
+
+  if (userData.byDriver) {
+    headers.push(translations.report.vehicle)
+  } else {
+    headers.push(translations.report.driver)
+  }
+
+  if (idleData) {
+    let first = true
+    // eslint-disable-next-line new-cap
+    const doc = new jsPDF.jsPDF('l')
+    await headerFromUser(doc, translations.report.titleIdleReport, userData.user)
+
+    idleData.forEach(d => {
+      try {
+        const data = []
+
+        const name = userData.byDriver ? d.driver.name : deviceName(d.device)
+        const group = userData.byDriver ? userData.groups.find(g => g.drivers.includes(d.id)) : userData.groups.find(g => d.device.groupId === g.id)
+
+        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 ? translations.report.group + ': ' + group.name : '', 150, space + 20)
+        doc.text(convertToLocaleString(reportData.from, lang, timezone) + ' - ' + convertToLocaleString(reportData.to, lang, timezone), 20, space + 25)
+        doc.text(translations.report.minimumMinutes + ': ' + userData.minimumIdleMinutes + ' ' + translations.report.minutes, 20, space + 35)
+        doc.text(translations.report.maximumSpeed + ': ' + userData.idleSpeedThreshold + ' Km/h', 100, space + 35)
+
+        d.idleEvents.forEach(a => {
+          const temp = [
+            getIdleEventDate(a.position, userData.user),
+            getIdleEventTime(a.position, userData.user),
+            getIdleEventTime(a.lastPosition, userData.user),
+            a.endPOIName || a.position.address,
+            convertMS(a.idleTime, true),
+            (a.geofenceName || '') + (a.geofenceGroup ? ' (' + a.geofenceGroup + ')' : ''),
+            userData.byDriver ? a.deviceName : getDriver(a, userData.drivers)
+          ]
+          data.push(temp)
+        })
+
+        const footValues = [
+          'Total:' + d.idleEvents.length,
+          '', '', '',
+          convertMS(d.idleEvents.reduce((a, b) => a + b.idleTime, 0), true)
+        ]
+
+        if (userData.roadSpeedLimits) {
+          footValues.splice(2, 0, '')
+        }
+
+        if (timezone === 'Asia/Qatar') {
+          doc.addFileToVFS('Amiri-Regular.ttf', AmiriRegular())
+          doc.addFont('Amiri-Regular.ttf', 'Amiri', 'normal')
+        }
+
+        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,
+            font: timezone === 'Asia/Qatar' ? 'Amiri' : ''
+
+          },
+          footStyles: {
+            fillColor: style.pdfFooterColor,
+            textColor: style.pdfFooterTextColor,
+            fontSize: 9
+          },
+          startY: space + 45
+        })
+      } catch (e) {
+        console.error(e, 'moving on...')
+      }
+    })
+
+    return doc
+  }
+}
+
+function exportIdleReportToExcel (userData, reportData) {
+  console.log('Export to Excel')
+
+  const translations = getTranslations(userData)
+
+  const idleData = userData.byDriver ? reportData.drivers : reportData.devices
+
+  const settings = {
+    sheetName: translations.report.titleIdleReport.substring(0, 31), // The name of the sheet
+    fileName // The name of the spreadsheet
+  }
+  const headers = [
+    { label: userData.byDriver ? translations.report.driver : translations.report.vehicle, value: 'name' },
+    { label: translations.report.date, value: 'date' },
+    { label: translations.report.start, value: 'start' },
+    { label: translations.report.end, value: 'end' },
+    { label: translations.report.address, value: 'address' },
+    { label: translations.report.duration, value: 'duration' },
+    { label: translations.report.zone, value: 'zone' },
+    { label: userData.byDriver ? translations.report.vehicle : translations.report.driver, value: 'subname' }
+  ]
+
+  let data = []
+  if (idleData) {
+    idleData.forEach(d => {
+      data = data.concat([{}])
+      data = data.concat(d.idleEvents.map(a => {
+        return {
+          name: userData.byDriver ? d.driver.name : d.device.name,
+          duration: convertMS(a.idleTime, true),
+          date: getIdleEventDate(a.position, userData.user),
+          start: getIdleEventTime(a.position, userData.user),
+          end: getIdleEventTime(a.lastPosition, userData.user),
+          subname: userData.byDriver ? a.deviceName : getDriver(a, userData.drivers),
+          address: a.endPOIName || a.position.address,
+          zone: (a.geofenceName || '') + (a.geofenceGroup ? ' (' + a.geofenceGroup + ')' : '')
+        }
+      }))
+      // Totals
+      data = data.concat([{
+        name: d.idleEvents.length,
+        duration: convertMS(d.idleEvents.reduce((a, b) => a + b.idleTime, 0), true)
+      }])
+      data = data.concat([{}])
+    })
+    console.log(data)
+    return {
+      headers,
+      data,
+      settings
+    }
+  }
+}
+
+function deviceName (device) {
+  return device.name + (device.attributes.license_plate ? ', ' + device.attributes.license_plate : '') + (device.model ? ', ' + device.model : '')
+}
+
+function getIdleEventDate (position, user) {
+  return convertToLocaleDateString(position.fixTime, user.attributes.lang, user.attributes.timezone)
+}
+
+function getIdleEventTime (position, user) {
+  return convertToLocaleTimeString(position.fixTime, user.attributes.lang, user.attributes.timezone)
+}
+
+exports.createIdleReport = createIdleReport
+exports.exportIdleReportToPDF = exportIdleReportToPDF
+exports.exportIdleReportToExcel = exportIdleReportToExcel
+exports.create = createIdleReport
+exports.exportToPDF = exportIdleReportToPDF
+exports.exportToExcel = exportIdleReportToExcel