fleetmap-reports 2.0.358 → 2.0.359

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

@@ -1,128 +0,0 @@
-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

@@ -1,172 +0,0 @@
-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

@@ -1,403 +0,0 @@
-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