fleetmap-reports 2.0.356 → 2.0.358

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

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

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

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