fleetmap-reports 2.0.358 → 2.0.360

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

@@ -1,223 +0,0 @@
-const automaticReports = require('../automaticReports')
-const traccarHelper = require('../util/traccar')
-const {
-  getDates, getTranslations, convertMS, isClientSide, convertToLocaleString, convertToLocaleDateString,
-  convertToLocaleTimeString
-} = require('../util/utils')
-const { getUserPartner } = require('fleetmap-partners')
-const { getDataByDay } = require('../util/trips')
-const jsPDF = require('jspdf')
-const { headerFromUser, addTable } = require('../util/pdfDocument')
-const { getStyle } = require('../reportStyle')
-
-async function createDelayedStartReport (from, to, userData, traccar) {
-  const reportData = {
-    devices: [],
-    from,
-    to
-  }
-
-  const devices = userData.devices
-
-  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, false, false, deviceCount, devices.length)
-
-    for (const d of slice) {
-      const deviceData = await processDeviceData(from, to, allInOne, d, userData, traccar)
-      reportData.devices.push(deviceData)
-    }
-
-    deviceCount = deviceCount + slice.length
-  }
-
-  reportData.devices = reportData.devices.flat()
-
-  return reportData
-}
-
-function getDelayDescription (startTime, activityStart, lowDelay, mediumDelay, highDelay) {
-  const startTimeDate = new Date(startTime)
-  const activityStartDate = new Date(startTime)
-  activityStartDate.setHours(activityStart.substring(0, 2), activityStart.substring(3, 5))
-
-  if (startTimeDate >= activityStartDate) {
-    const delay = startTimeDate.getTime() - activityStartDate.getTime()
-    if (delay < (lowDelay * 60 * 1000)) {
-      return '-'
-    } else if (delay < (mediumDelay * 60 * 1000)) {
-      return convertMS(delay, false) + ' - Low (+' + lowDelay + ')'
-    } else if (delay < (highDelay * 60 * 1000)) {
-      return convertMS(delay, false) + ' - Medium (+' + mediumDelay + ')'
-    } else {
-      return convertMS(delay, false) + ' - High (+' + highDelay + ')'
-    }
-  }
-
-  return ''
-}
-
-async function processDeviceData (from, to, allInOne, d, userData, traccar) {
-  const trips = allInOne.trips.filter(t => t.deviceId === d.id)
-  const route = allInOne.route.filter(t => t.deviceId === d.id)
-
-  const translations = getTranslations(userData)
-
-  const weekDays = [
-    translations.report.sunday,
-    translations.report.monday,
-    translations.report.tuesday,
-    translations.report.wednesday,
-    translations.report.thursday,
-    translations.report.friday,
-    translations.report.saturday
-  ]
-
-  const dates = getDates(from, to, userData.user.attributes.timezone || getUserPartner(userData.user).timezone)
-
-  const days = []
-  for (const date of dates) {
-    const { tripsByDay, routeByDay } = await getDataByDay(d, date, { trips, route }, userData, traccar)
-
-    let startTime
-    let endTime
-    if (userData.useIgnition) {
-      const firstIgnitionOn = routeByDay.find(p => p.attributes.ignition)
-      if (firstIgnitionOn) {
-        startTime = firstIgnitionOn.fixTime
-      }
-    } else {
-      if (tripsByDay.length) {
-        startTime = tripsByDay[0].startTime
-      }
-    }
-
-    if (tripsByDay.length) {
-      endTime = tripsByDay[tripsByDay.length - 1].endTime
-    }
-
-    if (startTime) {
-      const deviceDayData = {
-        device: d.name,
-        groupId: d.groupId,
-        licensePlate: d.attributes.license_plate,
-        driver: '',
-        weekDay: weekDays[new Date(date).getDay()],
-        startTime,
-        delayDescription: getDelayDescription(startTime, userData.activityStart, userData.lowDelay, userData.mediumDelay, userData.highDelay),
-        endTime
-      }
-
-      days.push(deviceDayData)
-    }
-  }
-
-  return days
-}
-
-async function exportDelayedStartReportToPDF (userData, reportData) {
-  console.log('exportDelayedStartReportToPDF')
-
-  const timezone = userData.user.attributes.timezone
-  const translations = getTranslations(userData)
-  const lang = userData.user.attributes.lang || (isClientSide() && navigator.language)
-  const reportDataRows = reportData.devices
-
-  const headers = [
-    translations.report.group,
-    translations.report.vehicle,
-    translations.report.driver,
-    translations.report.day,
-    translations.report.startDate,
-    translations.report.startTime,
-    translations.report.delayDescription,
-    translations.report.endTime
-  ]
-
-  if (reportDataRows) {
-    // eslint-disable-next-line new-cap
-    const doc = new jsPDF.jsPDF('l')
-    await headerFromUser(doc, translations.report.titleDelayedStartReport, userData.user)
-
-    doc.setFontSize(13)
-    doc.text(convertToLocaleString(reportData.from, lang, timezone, userData.user) + ' - ' + convertToLocaleString(reportData.to, lang, timezone, userData.user), 20, 25)
-
-    const data = []
-    reportDataRows.forEach(function (row) {
-      const group = userData.groups.find(g => row.groupId === g.id)
-
-      const temp = [
-        group ? group.name : '',
-        row.device,
-        row.driver,
-        row.weekDay,
-        convertToLocaleDateString(row.startTime, lang, timezone, userData.user),
-        convertToLocaleTimeString(row.startTime, lang, timezone, userData.user),
-        row.delayDescription,
-        convertToLocaleTimeString(row.endTime, lang, timezone, userData.user)
-      ]
-      data.push(temp)
-    })
-    const footValues = []
-
-    const style = getStyle(getUserPartner(userData.user))
-
-    addTable(doc, headers, data, footValues, style, 40)
-    return doc
-  }
-}
-
-const fileName = 'DelayedStartReport'
-async function exportDelayedStartReportToExcel (userData, reportData) {
-  console.log('Export to Excel')
-
-  const translations = getTranslations(userData)
-  const timezone = userData.user.attributes.timezone
-  const lang = userData.user.attributes.lang
-
-  const reportDataRows = reportData.devices
-
-  const settings = {
-    sheetName: translations.report.titleTripReport, // The name of the sheet
-    fileName // The name of the spreadsheet
-  }
-
-  const headers = [
-    { label: translations.report.group, value: 'group' },
-    { label: translations.report.vehicle, value: 'name' },
-    { label: translations.report.driver, value: 'driver' },
-    { label: translations.report.day, value: 'day' },
-    { label: translations.report.startDate, value: 'startDate' },
-    { label: translations.report.startTime, value: 'startTime' },
-    { label: translations.report.delayDescription, value: 'delayDescription' },
-    { label: translations.report.endTime, value: 'endTime' }
-  ]
-
-  let data = []
-  if (reportDataRows) {
-    reportDataRows.forEach(row => {
-      const group = userData.groups.find(g => row.groupId === g.id)
-      data = data.concat({
-        group: group ? group.name : '',
-        name: row.device,
-        driver: row.driver,
-        day: row.weekDay,
-        startDate: convertToLocaleDateString(row.startTime, lang, timezone, userData.user),
-        startTime: convertToLocaleTimeString(row.startTime, lang, timezone, userData.user),
-        delayDescription: row.delayDescription,
-        endTime: convertToLocaleTimeString(row.endTime, lang, timezone, userData.user)
-      })
-    })
-    console.log(data)
-    return {
-      headers,
-      data,
-      settings
-    }
-  }
-}
-
-exports.create = createDelayedStartReport
-exports.exportToPDF = exportDelayedStartReportToPDF
-exports.exportToExcel = exportDelayedStartReportToExcel

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

@@ -1,328 +0,0 @@
-const traccarHelper = require('../util/traccar')
-const { getDriverData, devicesByDriver } = require('../util/driver')
-const { getCanDriverStyleMessages, parseCanDriverStyleMessage } = require('../util/xpert')
-const { calculateRPMSections } = require('./performance-report')
-const { getTranslations, isClientSide, convertToLocaleString, convertMS } = require('../util/utils')
-const jsPDF = require('jspdf')
-const { headerFromUser, addTable } = require('../util/pdfDocument')
-const { getStyle } = require('../reportStyle')
-const { getUserPartner } = require('fleetmap-partners')
-const { getOverspeedEvents } = require('../speeding-report')
-const { calculateConsumption } = require('../util/fuel')
-const { getCanAvgConsumption } = require('../fuel-consumption-report')
-const automaticReports = require('../automaticReports')
-
-const distanceCoefficient = 0.5
-const consumptionCoefficient = 0.7
-const rpmCoefficient = 0.8
-const hardBrakingCoefficient = 0.10
-const hardAccelerationCoefficient = 0.10
-const hardCorneringCoefficient = 0.10
-const overspeedCoefficient = 0.15
-const geofenceCoefficient = 0.15
-const continuesDrivingCoefficient = 0.1
-const reverseCoefficient = 0.1
-const otherCoefficient = 0.1
-
-async function create (from, to, userData, traccar) {
-  const reportData = {
-    drivers: []
-  }
-
-  userData.geofences = []
-  userData.roadSpeedLimits = true
-
-  const { devices, drivers } = await devicesByDriver(traccar, from, to, userData.drivers, userData.devices)
-  userData.drivers = drivers
-
-  let deviceCount = 0
-  const driversData = new Map()
-  const overspeedEvents = await getOverspeedEvents(from, to, userData, devices, userData, traccar)
-
-  const sliced = automaticReports.sliceArray(devices, 5)
-
-  for (const slice of sliced) {
-    const allInOne = await traccarHelper.getAllInOne(traccar, from, to, slice, true, true, false, false, deviceCount, devices.length)
-
-    const result = []
-    const requests = []
-    for (const _chunk of automaticReports.sliceArray(slice.map(d => d.id), 1)) {
-      requests.push(traccar.reports.reportsEventsGet(from, to, _chunk, null, ['alarm']))
-    }
-
-    try {
-      result.push(...(await Promise.all(requests)))
-    } catch (e) {
-      console.log(e)
-    }
-    const alarmEvents = result.flatMap(d => d.data)
-
-    for (const device of slice) {
-      const route = allInOne.route.filter(t => t.deviceId === device.id)
-      const trips = allInOne.trips.filter(t => t.deviceId === device.id)
-
-      const deviceOverspeedEvents = overspeedEvents.find(e => e.device.id === device.id)
-      const deviceAlarmEvents = alarmEvents.filter(e => e.deviceId === device.id)
-
-      await processDevice(driversData, device, userData, { route, trips }, deviceAlarmEvents, deviceOverspeedEvents)
-      deviceCount++
-    }
-
-    console.log('LOADING_MESSAGE:' + slice[0].name)
-    console.log(`PROGRESS_PERC:${deviceCount / devices.length * 100}`)
-  }
-
-  const allDriversData = (Array.from(driversData.values())).filter(d => d.distance > 0)
-  allDriversData.forEach(d => {
-    const distanceScore = (Math.abs(d.distance - userData.distanceTarget) / userData.distanceTarget) * distanceCoefficient
-    const rpmScore = ((d.highEngineRPM / 60000) / userData.rpmTarget) * rpmCoefficient
-    const hardBrakingScore = (d.hardBraking / userData.hardBrakingTarget) * hardBrakingCoefficient
-    const hardAccelerationScore = (d.hardAcceleration / userData.hardAccelerationTarget) * hardAccelerationCoefficient
-    const hardCorneringScore = (d.hardCornering / userData.hardCorneringTarget) * hardCorneringCoefficient
-    const overspeedScore = (d.overspeed / userData.overspeedTarget) * overspeedCoefficient
-    const consumptionScore = (getCanAvgConsumption(d.distance, d.spentFuel).byKms / userData.fuelConsumptionTarget) * consumptionCoefficient
-    const geofenceAlarmScore = (d.geofenceAlarm / userData.geofenceTarget) * geofenceCoefficient
-    const continuesDrivingAlarmScore = (d.continuesDrivingAlarm / userData.continuesDrivingTarget) * continuesDrivingCoefficient
-    const reverseAlarmScore = (d.reverseAlarm / userData.reverseTarget) * reverseCoefficient
-    const otherAlarmScore = (d.otherAlarm / userData.otherTarget) * otherCoefficient
-
-    d.avgFuelConsumption = getCanAvgConsumption(d.distance, d.spentFuel).byKms
-    d.score = distanceScore + rpmScore + hardBrakingScore + hardAccelerationScore +
-        hardCorneringScore + consumptionScore + overspeedScore + geofenceAlarmScore +
-        continuesDrivingAlarmScore + reverseAlarmScore + otherAlarmScore
-  })
-  allDriversData.sort((a, b) => (a.score > b.score) ? 1 : -1)
-
-  reportData.drivers.push(...allDriversData)
-
-  reportData.target = {
-    distanceTarget: userData.distanceTarget,
-    rpmTarget: userData.rpmTarget,
-    hardBrakingTarget: userData.hardBrakingTarget,
-    hardAccelerationTarget: userData.hardAccelerationTarget,
-    hardCorneringTarget: userData.hardCorneringTarget,
-    fuelConsumptionTarget: userData.fuelConsumptionTarget,
-    overspeedTarget: userData.overspeedTarget,
-    geofenceTarget: userData.geofenceTarget,
-    continuesDrivingTarget: userData.continuesDrivingTarget,
-    reverseTarget: userData.reverseTarget,
-    otherTarget: userData.otherTarget
-  }
-
-  reportData.coefficient = {
-    distanceCoefficient,
-    rpmCoefficient,
-    hardBrakingCoefficient,
-    hardAccelerationCoefficient,
-    hardCorneringCoefficient,
-    consumptionCoefficient,
-    overspeedCoefficient,
-    geofenceCoefficient,
-    continuesDrivingCoefficient,
-    reverseCoefficient,
-    otherCoefficient
-  }
-
-  return reportData
-}
-
-async function processDevice (driversData, device, userData, allInOne, alarmEvents, overspeedEvents) {
-  for (const d of userData.drivers) {
-    const { trips, route } = await getDriverData(d, allInOne, userData)
-    const positionsIds = route.map(p => p.id)
-    const events = alarmEvents.filter(e => positionsIds.includes(e.positionId))
-    const driverOverSpeedEvents = overspeedEvents ? overspeedEvents.alerts.filter(e => positionsIds.includes(e.position.id)) : []
-    const spentFuel = calculateConsumption(device, { trips, route })
-
-    const geofenceAlarm = events.filter(e => e.attributes.alarm === 'la ceinture').length
-    const continuesDrivingAlarm = events.filter(e => e.attributes.alarm === 'Conduite continue').length
-    const reverseAlarm = events.filter(e => e.attributes.alarm === 'MARCHE ARIERRE').length
-    const otherAlarm = events.length - (geofenceAlarm + continuesDrivingAlarm + reverseAlarm)
-
-    let driverData = driversData.get(d.id)
-    if (!driverData) {
-      driverData = {
-        name: d.name,
-        distance: 0,
-        highEngineRPM: 0,
-        hardBraking: 0,
-        hardAcceleration: 0,
-        hardCornering: 0,
-        overspeed: 0,
-        spentFuel: 0,
-        geofenceAlarm: 0,
-        continuesDrivingAlarm: 0,
-        reverseAlarm: 0,
-        otherAlarm: 0
-      }
-      driversData.set(d.id, driverData)
-    }
-
-    let highEngineRPM = 0
-    let hardBraking = 0
-    let hardAcceleration = 0
-    let hardCornering = 0
-    if (route.find(p => p.attributes.rawXpert)) {
-      const xpertMessages = route.map(p => p.attributes.rawXpert).filter(a => a)
-      const canDriverStyle = getCanDriverStyleMessages(xpertMessages).map(m => parseCanDriverStyleMessage(m))
-      highEngineRPM = canDriverStyle.reduce((a, b) => a + b.totalTimeWithHighRpmAndTorque, 0)
-      hardBraking = canDriverStyle.reduce((a, b) => a + b.totalNumberOfHarshBrakes, 0)
-      hardAcceleration = canDriverStyle.reduce((a, b) => a + b.totalNumberOfHarshAccelerations, 0)
-    } else {
-      const highEngineRPMSections = calculateRPMSections(route, d.attributes.highRPM || 1500)
-      highEngineRPM = highEngineRPMSections.map(a => a.length > 1
-        ? a.map((p, index) => index === 0 ? 0 : new Date(p.fixTime).getTime() - new Date(a[index - 1].fixTime).getTime()).reduce((a, b) => a + b, 0)
-        : 0).reduce((a, b) => a + b, 0)
-
-      hardBraking = route.filter(p => p.attributes.alarm === 'hardBraking').length
-      hardAcceleration = route.filter(p => p.attributes.alarm === 'hardAcceleration').length
-      hardCornering = route.filter(p => p.attributes.alarm === 'hardCornering').length
-    }
-
-    driverData.distance = driverData.distance + trips.filter(t => t.distance > 0).reduce((a, b) => a + b.distance, 0)
-    driverData.highEngineRPM = driverData.highEngineRPM + highEngineRPM
-    driverData.hardBraking = driverData.hardBraking + hardBraking
-    driverData.hardAcceleration = driverData.hardAcceleration + hardAcceleration
-    driverData.hardCornering = driverData.hardCornering + hardCornering
-    driverData.overspeed = driverData.overspeed + driverOverSpeedEvents.length
-    driverData.spentFuel = driverData.spentFuel + spentFuel
-    driverData.geofenceAlarm = driverData.geofenceAlarm + geofenceAlarm
-    driverData.continuesDrivingAlarm = driverData.continuesDrivingAlarm + continuesDrivingAlarm
-    driverData.reverseAlarm = driverData.reverseAlarm + reverseAlarm
-    driverData.otherAlarm = driverData.otherAlarm + otherAlarm
-  }
-}
-
-const fileName = 'DriverRankingReport'
-async function exportToExcel (userData, reportData) {
-  console.log('Export to Excel')
-
-  const translations = getTranslations(userData)
-
-  const reportDataRows = reportData.drivers
-
-  const settings = {
-    sheetName: translations.report.titleDriverRankingReport, // The name of the sheet
-    fileName // The name of the spreadsheet
-  }
-
-  const headers = [
-    { label: translations.report.driver, value: 'name' },
-    { label: translations.report.distance, value: 'distance' },
-    { label: translations.report.avgFuelConsumption, value: 'avgFuelConsumption' },
-    { label: translations.report.highEngineRPM, value: 'highEngineRPM' },
-    { label: translations.report.hardBraking, value: 'hardBraking' },
-    { label: translations.report.hardAcceleration, value: 'hardAcceleration' },
-    { label: translations.report.hardCornering, value: 'hardCornering' },
-    { label: translations.report.overspeedAlarm, value: 'overspeed' },
-    { label: translations.report.geofenceAlarm, value: 'geofenceAlarm' },
-    { label: translations.report.continuesDrivingAlarm, value: 'continuesDrivingAlarm' },
-    { label: translations.report.reverseAlarm, value: 'reverseAlarm' },
-    { label: translations.report.otherAlarm, value: 'otherAlarm' },
-    { label: translations.report.score, value: 'score' }
-  ]
-
-  let data = []
-  if (reportDataRows) {
-    reportDataRows.forEach(row => {
-      data = data.concat({
-        name: row.name,
-        distance: Number(row.distance.toFixed(1)),
-        avgFuelConsumption: Number(row.avgFuelConsumption.toFixed(2)),
-        highEngineRPM: convertMS(row.highEngineRPM, false),
-        hardBraking: row.hardBraking,
-        hardAcceleration: row.hardAcceleration,
-        hardCornering: row.hardCornering,
-        overspeed: row.overspeed,
-        geofenceAlarm: row.geofenceAlarm,
-        continuesDrivingAlarm: row.continuesDrivingAlarm,
-        reverseAlarm: row.reverseAlarm,
-        otherAlarm: row.otherAlarm,
-        score: Number(row.score.toFixed(2))
-      })
-    })
-    console.log(data)
-    return {
-      headers,
-      data,
-      settings
-    }
-  }
-}
-
-async function exportToPDF (userData, reportData) {
-  console.log('exportDelayedStartReportToPDF')
-
-  const timezone = userData.user.attributes.timezone
-  const translations = getTranslations(userData)
-  const lang = userData.user.attributes.lang || (isClientSide() && navigator.language)
-  const reportDataRows = reportData.drivers
-
-  const headers = [
-    translations.report.driver,
-    translations.report.distance,
-    translations.report.avgFuelConsumption,
-    translations.report.highEngineRPM,
-    translations.report.hardBraking,
-    translations.report.hardAcceleration,
-    translations.report.hardCornering,
-    translations.report.overspeedAlarm,
-    translations.report.geofenceAlarm,
-    translations.report.continuesDrivingAlarm,
-    translations.report.reverseAlarm,
-    translations.report.otherAlarm,
-    translations.report.score
-  ]
-
-  if (reportDataRows) {
-    // eslint-disable-next-line new-cap
-    const doc = new jsPDF.jsPDF('l')
-    await headerFromUser(doc, translations.report.titleDriverRankingReport, userData.user)
-
-    doc.setFontSize(13)
-    doc.text(convertToLocaleString(reportData.from, lang, timezone, userData.user) + ' - ' + convertToLocaleString(reportData.to, lang, timezone, userData.user), 20, 25)
-
-    const data = []
-    reportDataRows.forEach(function (row) {
-      const temp = [
-        row.name,
-        row.distance.toFixed(1),
-        row.avgFuelConsumption.toFixed(2),
-        convertMS(row.highEngineRPM, false),
-        row.hardBraking,
-        row.hardAcceleration,
-        row.hardCornering,
-        row.overspeed,
-        row.geofenceAlarm,
-        row.continuesDrivingAlarm,
-        row.reverseAlarm,
-        row.otherAlarm,
-        row.score.toFixed(2)
-      ]
-      data.push(temp)
-    })
-    const footValues = []
-
-    const style = getStyle(getUserPartner(userData.user))
-
-    addTable(doc, headers, data, footValues, style, 40, {
-      1: { halign: 'right' },
-      2: { halign: 'right' },
-      3: { halign: 'right' },
-      4: { halign: 'right' },
-      5: { halign: 'right' },
-      6: { halign: 'right' },
-      7: { halign: 'right' },
-      8: { halign: 'right' },
-      9: { halign: 'right' },
-      10: { halign: 'right' },
-      11: { halign: 'right' },
-      12: { halign: 'right' }
-    })
-    return doc
-  }
-}
-
-exports.create = create
-exports.exportToPDF = exportToPDF
-exports.exportToExcel = exportToExcel

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

@@ -1,61 +0,0 @@
-const automaticReports = require('../automaticReports')
-const traccarHelper = require('../util/traccar')
-const distance = require('@turf/distance')
-
-async function createGPSJumpReport (from, to, userData, traccar, minDistance) {
-  let reportData = []
-
-  const devices = userData.devices
-
-  const sliced = automaticReports.sliceArray(devices, 10)
-  let deviceCount = 0
-  for (const slice of sliced) {
-    const allInOne = await traccarHelper.getAllInOne(traccar, from, to, slice, true, false, false, false, deviceCount, devices.length)
-
-    slice.forEach(d => {
-      const deviceData = getDeviceData(allInOne, d, userData.user, minDistance || userData.minDistance)
-      reportData = reportData.concat(deviceData)
-    })
-
-    deviceCount = deviceCount + slice.length
-  }
-
-  return reportData
-}
-
-function getDeviceData (allInOne, d, user, minDistance) {
-  const deviceRoute = allInOne.route.filter(t => t.deviceId === d.id)
-
-  return deviceRoute.map((pA, index) => {
-    if (index < deviceRoute.length - 1) {
-      const pB = deviceRoute[index + 1]
-      const distanceValue = distance.default([pA.longitude, pA.latitude], [pB.longitude, pB.latitude], { units: 'meters' })
-      if ((minDistance * 1000) < distanceValue) {
-        return {
-          device: d.name,
-          dateA: pA.fixTime,
-          addressA: pA.address,
-          dateB: pB.fixTime,
-          addressB: pB.address,
-          distance: distanceValue
-        }
-      }
-    }
-    return undefined
-  }).filter(a => a).sort((a, b) => (a.device > b.device) ? 1 : -1)
-}
-
-async function exportGPSJumpReportToPDF (userData, reportData) {
-
-}
-
-async function exportGPSJumpReportToExcel (userData, reportData) {
-
-}
-
-exports.createGPSJumpReport = createGPSJumpReport
-exports.exportGPSJumpReportToPDF = exportGPSJumpReportToPDF
-exports.exportGPSJumpReportToExcel = exportGPSJumpReportToExcel
-exports.create = createGPSJumpReport
-exports.exportToPDF = exportGPSJumpReportToPDF
-exports.exportToExcel = exportGPSJumpReportToExcel