fleetmap-reports 1.0.249 → 1.0.253

package/src/speeding-report.js

@@ -13,16 +13,18 @@ const {getUserPartner} = require("fleetmap-partners");
 const traccar = require("./util/traccar");
 
 let traccarInstance
+let userData
 
 const fileName = 'SpeedingReport'
 
-async function createSpeedingReport(from, to, userData, traccar, roadSpeedLimits) {
+async function createSpeedingReport(from, to, reportUserData, traccar) {
   traccarInstance = traccar
-  console.log('createSpeedingReport', from, to, userData, traccar, roadSpeedLimits)
+  userData = reportUserData
+  console.log('createSpeedingReport', from, to, userData, traccar)
   const reportData = []
 
   if(userData.byDriver){
-    const allData = await createSpeedingReportByDriver(from, to, userData, roadSpeedLimits)
+    const allData = await createSpeedingReportByDriver(from, to)
     reportData.push(allData)
   }
   else if(userData.byGroup){
@@ -37,48 +39,50 @@ async function createSpeedingReport(from, to, userData, traccar, roadSpeedLimits
           xpert: devices.filter(d => d.attributes.xpert).length > 0
         }
 
-        const events = ['deviceOverspeed']
-        const data = await traccar.getEvents(traccarInstance, from, to, devices, events)
+        const eventTypes = ['deviceOverspeed']
+        const events = await traccar.getEvents(traccarInstance, from, to, devices, eventTypes)
+        const routes = userData.useVehicleSpeedLimit ? [] : await traccar.getRoute(traccarInstance, from, to, devices)
 
         devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
-        if (data.length > 0) {
-          groupData.devices = await processDevices(from, to, devices, userData.geofences, userData.drivers, data, roadSpeedLimits)
+        if (events.length > 0) {
+          groupData.devices = await processDevices(from, to, devices, events, routes)
           reportData.push(groupData)
         }
       }
     }
 
-    const withoutGroupData = await createSpeedingReportByDevice(from, to, userData)
+    const withoutGroupData = await createSpeedingReportByDevice(from, to)
     reportData.push(withoutGroupData)
   } else {
-    const allData = await createSpeedingReportByDevice(from, to, userData, roadSpeedLimits)
+    const allData = await createSpeedingReportByDevice(from, to)
     reportData.push(allData)
   }
 
   return reportData
 }
 
-async function createSpeedingReportByDevice(from, to, userData, roadSpeedLimits) {
+async function createSpeedingReportByDevice(from, to) {
   const groupIds = userData.groups.map(g => g.id)
   const withoutGroupDevices = userData.byGroup ? userData.devices.filter(d => !groupIds.includes(d.groupId)) : userData.devices
 
   withoutGroupDevices.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
-  const events = ['deviceOverspeed']
-  const data = await traccar.getEvents(traccarInstance, from, to, withoutGroupDevices, events)
+  const eventTypes = ['deviceOverspeed']
+  const events = await traccar.getEvents(traccarInstance, from, to, withoutGroupDevices, eventTypes)
+  const routes = userData.useVehicleSpeedLimit ? [] : await traccar.getRoute(traccarInstance, from, to, withoutGroupDevices)
 
   const allData = { devices: [] }
 
-  if(data.length > 0 || roadSpeedLimits) {
-    allData.devices = await processDevices(from, to, withoutGroupDevices, userData.geofences, userData.drivers, data, roadSpeedLimits)
+  if(events.length > 0 || userData.roadSpeedLimits) {
+    allData.devices = await processDevices(from, to, withoutGroupDevices, events, routes)
     allData.xpert = withoutGroupDevices.filter(d => d && d.attributes && d.attributes.xpert).length > 0
   }
 
   return allData
 }
 
-async function createSpeedingReportByDriver(from, to, userData) {
+async function createSpeedingReportByDriver(from, to) {
   const deviceIds = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
   console.log('Devices with driver',deviceIds.length)
 
@@ -93,18 +97,18 @@ async function createSpeedingReportByDriver(from, to, userData) {
   }
   console.log(eventsData.length)
 
-  await getEventsPosition(from , to, userData.devices, userData.geofences, userData.drivers, eventsData)
-  allData.drivers = await processDrivers(from, to, userData.drivers, eventsData)
+  await getEventsPosition(from , to, userData.devices, eventsData)
+  allData.drivers = await processDrivers(from, to, eventsData)
   console.log(allData.drivers.length)
   return allData
 }
 
-async function processDrivers(from, to, drivers, data) {
+async function processDrivers(from, to, data) {
   console.log(data)
   const driversResult = []
   const alertsWithPosition = data.filter(a => a.position)
 
-  drivers.forEach(d => {
+  userData.drivers.forEach(d => {
     const alerts = alertsWithPosition.filter(e => e.position.attributes.driverUniqueId === d.uniqueId)
 
     if (alerts.length > 0) {
@@ -124,34 +128,70 @@ async function processDrivers(from, to, drivers, data) {
   return driversResult
 }
 
-async function processDevices(from, to, devices, geofences, drivers, data, roadSpeedLimits) {
+async function processDevices(from, to, devices, events, routes) {
   const devicesResult = []
 
-  await getEventsPosition(from , to, devices, geofences, drivers, data, roadSpeedLimits)
+  if(userData.useVehicleSpeedLimit) {
+    await getEventsPosition(from, to, devices, events)
 
-  console.log(data)
+    console.log(events)
 
-  for (const d of devices) {
-    const alerts = data.filter(t => t.deviceId === d.id)
+    for (const d of devices) {
+      const deviceEvents = events.filter(t => t.deviceId === d.id)
 
-    if (alerts.length > 0) {
-      const alertsWithPosition = alerts.filter(a => a.position).sort((a,b) => a.positionId - b.positionId)
-      devicesResult.push({
-        device: d,
-        from: from,
-        to: to,
-        alerts: alertsWithPosition,
-        maxSpeed: alertsWithPosition.reduce((a, b) => {
-          return a > (b && b.attributes && b.attributes.maxSpeed) ? a : (b && b.attributes && b.attributes.maxSpeed)
-        }, 0),
-      })
+      if (deviceEvents.length > 0) {
+        const alertsWithPosition = deviceEvents.filter(a => a.position).sort((a, b) => a.positionId - b.positionId)
+        devicesResult.push({
+          device: d,
+          from: from,
+          to: to,
+          alerts: alertsWithPosition,
+          maxSpeed: alertsWithPosition.reduce((a, b) => {
+            return a > (b && b.attributes && b.attributes.maxSpeed) ? a : (b && b.attributes && b.attributes.maxSpeed)
+          }, 0),
+        })
+      }
+    }
+  } else {
+    for (const d of devices) {
+      const positions = routes.filter(t => t.deviceId === d.id)
+      const maxSpeed = userData.customSpeed / 1.85200
+
+      const alerts = []
+      for(let pIndex = 0; pIndex < positions.length ; pIndex++){
+        const position = positions[pIndex]
+        if(position.speed > maxSpeed){
+          const alert = {
+            position: position,
+            attributes: {
+              speedLimit: maxSpeed,
+              speed: position.speed
+            }
+          }
+
+          pIndex = calculateEventData(positions, pIndex, alert)
+
+          alerts.push(alert)
+        }
+      }
+      if(alerts.length > 0){
+        devicesResult.push({
+          device: d,
+          from: from,
+          to: to,
+          alerts: alerts,
+          maxSpeed: alerts.reduce((a, b) => {
+            return a > (b && b.attributes && b.attributes.maxSpeed) ? a : (b && b.attributes && b.attributes.maxSpeed)
+          }, 0),
+        })
+      }
     }
   }
 
   return devicesResult
 }
 
-async function getEventsPosition(from, to, devices, geofences, drivers, events, roadSpeedLimits){
+async function getEventsPosition(from, to, devices, events){
 
   const deviceIds = [...new Set(events.map(e => e.deviceId))]
   const routeData = await traccar.getRoute(traccarInstance, from, to, deviceIds.map(id => { return { id: id } } ))
@@ -161,10 +201,10 @@ async function getEventsPosition(from, to, devices, geofences, drivers, events,
   for (const d of devices) {
     let alerts = events.filter(t => t.deviceId === d.id)
 
-    if (alerts.length > 0 || roadSpeedLimits) {
+    if (alerts.length > 0 || userData.roadSpeedLimits) {
       const positions = routeData.filter(p => p.deviceId === d.id)
 
-      if (roadSpeedLimits && positions.length) {
+      if (userData.roadSpeedLimits && positions.length) {
         try {
           const results = await here.routeMatch(positions)
           const hereAlerts = results.map(r => {
@@ -202,7 +242,7 @@ async function getEventsPosition(from, to, devices, geofences, drivers, events,
           let geofence = null
 
           if (a.geofenceId) {
-            geofence = geofences.find(g => g.id === a.geofenceId)
+            geofence = userData.geofences.find(g => g.id === a.geofenceId)
             if (geofence) {
               a.geofenceName = geofence.name + ' (' + Math.round(a.attributes.speedLimit * 1.85200) + ' Km/h)'
             }
@@ -230,7 +270,7 @@ async function getEventsPosition(from, to, devices, geofences, drivers, events,
           }
 
           if (a.position.attributes.driverUniqueId) {
-            const driver = drivers.find(d => d.uniqueId === a.position.attributes.driverUniqueId)
+            const driver = userData.drivers.find(d => d.uniqueId === a.position.attributes.driverUniqueId)
             a.driver = driver && driver.name
           }
 
@@ -243,6 +283,31 @@ async function getEventsPosition(from, to, devices, geofences, drivers, events,
   }
 }
 
+function calculateEventData(positions, pIndex, a, geofence){
+  let endEventPosition = a.position
+  let maxSpeed = a.position.speed
+  let dist = 0
+  while (pIndex + 1 < positions.length) {
+    pIndex++
+
+    dist += distance(point([endEventPosition.longitude, endEventPosition.latitude]),
+        point([positions[pIndex].longitude, positions[pIndex].latitude]))
+    endEventPosition = positions[pIndex]
+    if (endEventPosition.speed <= a.attributes.speedLimit || (geofence && isOutsideGeofence(geofence, endEventPosition))) {
+      a.eventTime = new Date(endEventPosition.fixTime) - new Date(a.position.fixTime)
+      a.attributes.maxSpeed = maxSpeed
+      a.distance = dist
+      break
+    } else {
+      if (maxSpeed < endEventPosition.speed) {
+        maxSpeed = endEventPosition.speed
+      }
+    }
+  }
+
+  return pIndex
+}
+
 function isOutsideGeofence(geofence, endEventPosition) {
   const v = turf.feature(turf.flip(parse(geofence.area)))
   const point = turf.point([endEventPosition.longitude, endEventPosition.latitude])
@@ -266,7 +331,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
     translations.report.duration,
   ]
 
-  if(userData.useRoadSpeedLimits) {
+  if(userData.roadSpeedLimits) {
     headers.splice(2, 0, translations.report.roadSpeedLimit)
   }
 
@@ -301,7 +366,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
         doc.text(group ? translations.report.group + ': ' + group.name : '', 150, space+20 )
         doc.text(new Date(d.from).toLocaleString() + ' - ' + new Date(d.to).toLocaleString(), 20, space+25 )
         if (d.alerts[0] && !userData.byDriver) {
-          doc.text(translations.report.speedLimit + ": " + Math.round(d.alerts[0].attributes.speedLimit * 1.85200) + ' Km/h', 20, space + 30)
+          doc.text(translations.report.speedLimit + ": " + (userData.useVehicleSpeedLimit ? Math.round(d.alerts[0].attributes.speedLimit * 1.85200) : userData.customSpeed) + ' Km/h', 20, space + 30)
         }
         d.alerts.map(a => {
           const temp = [
@@ -314,7 +379,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
             userData.byDriver ? a.deviceName : a.driver
           ]
 
-          if(userData.useRoadSpeedLimits){
+          if(userData.roadSpeedLimits){
             temp.splice(2, 0, a.roadSpeedLimit)
           }
 
@@ -330,7 +395,7 @@ async function exportSpeedingReportToPDF(userData, reportData) {
           convertMS(d.alerts.reduce((a, b) => a + b.eventTime, 0), true)
         ]
 
-        if(userData.useRoadSpeedLimits){
+        if(userData.roadSpeedLimits){
           footValues.splice(2, 0, '')
         }
 
@@ -389,7 +454,7 @@ function exportSpeedingReportToExcel(userData, reportData) {
     userData.byDriver ? {label: translations.report.vehicle, value:'name'} : {label: translations.report.driver, value:'driver'}
   ]
 
-  if (userData.useRoadSpeedLimits){
+  if (userData.roadSpeedLimits){
     headers.splice(3, 0, {label: translations.report.roadSpeedLimit, value:'roadSpeedLimit'})
   }
 

package/src/trip-report.js

@@ -6,40 +6,43 @@ require('jspdf-autotable')
 const {coordsDistance} = require("./util/utils")
 const drivers = require("./util/driver")
 const {getUserPartner} = require("fleetmap-partners")
-const {headerFromUser} = require("./util/pdfDocument")
+const {headerFromUser, addTable} = require("./util/pdfDocument")
 const {getStyle} = require("./reportStyle")
 const traccar = require("./util/traccar")
+const trips = require("./util/trips");
 
 
 let traccarInstance
+let userData
 
 const fileName = 'TripReport'
 
-async function createTripReport(from, to, userData, traccar) {
+async function createTripReport(from, to, reportUserData, traccar) {
     console.log('Create TripReport')
+    userData = reportUserData
     traccarInstance = traccar
     const reportData = []
 
     if(userData.byDriver){
-        const allData = await createTripReportByDriver(from, to, userData)
+        const allData = await createTripReportByDriver(from, to)
         reportData.push(allData)
     }
     else if(userData.byGroup){
         console.log("ByGroup")
-        const allData = await createTripReportByGroup(from, to, userData)
+        const allData = await createTripReportByGroup(from, to)
         reportData.push(...allData)
     }
 
     const groupIds = userData.groups.map(g => g.id)
     const withoutGroupDevices = userData.byGroup ? userData.devices.filter(d => !groupIds.includes(d.groupId)) : userData.devices
 
-    const allData = await createTripReportByDevice(from, to, userData, withoutGroupDevices)
+    const allData = await createTripReportByDevice(from, to, withoutGroupDevices)
     reportData.push(allData)
 
     return reportData
 }
 
-async function createTripReportByDevice(from, to, userData, devices) {
+async function createTripReportByDevice(from, to, devices) {
     const allData = {
         devices: [],
         xpert: devices.filter(d => d.attributes.xpert).length > 0
@@ -54,14 +57,14 @@ async function createTripReportByDevice(from, to, userData, devices) {
     console.log('Trips:' + data.length)
 
     if (data.length > 0) {
-        allData.devices = processDevices(from, to, devices, data, stopsData, userData)
-
+        await trips.checkTripsKms(traccarInstance, from, to,[], data, devices)
+        allData.devices = processDevices(from, to, devices, data, stopsData)
     }
 
     return allData
 }
 
-async function createTripReportByGroup(from, to, userData) {
+async function createTripReportByGroup(from, to) {
     const reportData = []
     for (const g of userData.groups) {
         const devices = userData.devices.filter(d => d.groupId === g.id)
@@ -93,7 +96,7 @@ async function createTripReportByGroup(from, to, userData) {
     return reportData
 }
 
-async function createTripReportByDriver(from, to, userData){
+async function createTripReportByDriver(from, to){
     const deviceIds = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
     console.log(deviceIds.length)
 
@@ -112,11 +115,11 @@ async function createTripReportByDriver(from, to, userData){
     return allData
 }
 
-function processDevices(from, to, devices, data, stopsData, userData) {
+function processDevices(from, to, devices, data, stopsData) {
     const devicesResult = []
 
     devices.forEach(d => {
-        const trips = data.filter(t => t.deviceId === d.id)
+        const trips = data.filter(t => t.deviceId === d.id && (userData.allWeek || isInsideTimetable(t, userData)))
         const stops = stopsData.filter(s => s.deviceId === d.id)
 
         trips.forEach(t => {
@@ -146,8 +149,8 @@ function processDevices(from, to, devices, data, stopsData, userData) {
         })
 
         if (trips.length > 0) {
-            trips.forEach(function(trip, index) {
-                const stop = stops.length+1 > index ? stops[index+1] : null
+            trips.forEach(trip => {
+                const stop = getStop(new Date(trip.startTime), stops)
 
                 if (stop) {
                     trip.stopDuration = (new Date(stop.endTime) - new Date(stop.startTime))
@@ -240,27 +243,38 @@ async function exportTripReportToPDF(userData, reportData) {
     }
 
     if (tripsData) {
-        let first = true
         const doc = new jsPDF.jsPDF('l');
         await headerFromUser(doc, translations.report.titleTripReport, userData.user)
-        for(const d of tripsData){
+
+        tripsData.forEach(function (d, index) {
             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) {
+            let space = index === 0 ? 8 : 0
+            if(index){
                 doc.addPage()
-            } else {
-                first = false
-                space = 8
             }
+
             doc.setFontSize(13)
             doc.text(name, 20, space+20 )
             doc.setFontSize(11)
             doc.text(group ? translations.report.group + ': ' + group.name : '', 200, space+20 )
             doc.text(new Date(d.from).toLocaleString() + ' - ' + new Date(d.to).toLocaleString(), 20, space+25 )
-            doc.text(translations.report.headerStartAddress + ': ' + d.trips[0].startAddress, 20, space+30 )
+            if(!userData.allWeek) {
+                doc.text((userData.weekDays.monday ? ' ' + translations.report.monday + ',' : '')
+                    + (userData.weekDays.tuesday ? ' ' + translations.report.tuesday + ',' : '')
+                    + (userData.weekDays.wednesday ? ' ' + translations.report.wednesday + ',' : '')
+                    + (userData.weekDays.thursday ? ' ' + translations.report.thursday + ',' : '')
+                    + (userData.weekDays.friday ? ' ' + translations.report.friday + ',' : '')
+                    + (userData.weekDays.saturday ? ' ' + translations.report.saturday + ',' : '')
+                    + (userData.weekDays.sunday ? ' ' + translations.report.sunday + ',' : '')
+                    + ' das '
+                    + userData.dayHours.startTime + ' - ' + userData.dayHours.endTime, 20, space + 30)
+                doc.text(translations.report.headerStartAddress + ': ' + d.trips[0].startAddress, 20, space+40 )
+            } else {
+                doc.text(translations.report.headerStartAddress + ': ' + d.trips[0].startAddress, 20, space+35 )
+            }
 
             d.trips.map(a => {
                 const temp = [
@@ -306,28 +320,8 @@ async function exportTripReportToPDF(userData, reportData) {
             }
 
             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
-                },
-                footStyles: {
-                    fillColor: style.pdfFooterColor,
-                    textColor: style.pdfFooterTextColor,
-                    fontSize: 9
-                },
-                startY: space+35 })
-        }
+            addTable(doc, headers, data, footValues, style, space + (userData.allWeek ? 40 : 45))
+        })
         return doc
     }
 }
@@ -451,6 +445,39 @@ function getMaxSpeed(data) {
     return Math.round(max * 1.85200)
 }
 
+function getStop(tripEndDate, stops){
+    const stopList = stops.filter(s => new Date(s.startTime).getTime() >= tripEndDate.getTime())
+    if(stopList.length){
+        return stopList[0]
+    }
+
+    return null
+}
+
+function isInsideTimetable(t, userData){
+    const tripStart  = new Date(t.startTime)
+    const tripEnd  = new Date(t.endTime)
+
+    if((tripStart.getDay() === 0 && userData.weekDays.sunday) ||
+        (tripStart.getDay() === 1 && userData.weekDays.monday) ||
+        (tripStart.getDay() === 2 && userData.weekDays.tuesday) ||
+        (tripStart.getDay() === 3 && userData.weekDays.wednesday)  ||
+        (tripStart.getDay() === 4 && userData.weekDays.thursday) ||
+        (tripStart.getDay() === 5 && userData.weekDays.friday) ||
+        (tripStart.getDay() === 6 && userData.weekDays.saturday)) {
+
+        const startDate = new Date(new Date(tripStart).toISOString().split('T')[0] + ' '+userData.dayHours.startTime)
+        const endDate = new Date(new Date(tripStart).toISOString().split('T')[0] + ' '+userData.dayHours.endTime)
+
+        console.log(tripStart, startDate, endDate)
+
+        //Trips inside time period
+        return tripStart.getTime() > startDate.getTime() && tripEnd.getTime() < endDate.getTime()
+    }
+
+    return false
+}
+
 exports.createTripReport = createTripReport;
 exports.exportTripReportToPDF = exportTripReportToPDF;
 exports.exportTripReportToExcel = exportTripReportToExcel;

package/src/util/traccar.js

@@ -52,7 +52,21 @@ async function getEvents(traccar, from, to, devices, events){
     return result.map(r => r.data).flat()
 }
 
+async function getSummary(traccar, from, to, devices){
+    const devicesToSlice = devices.slice()
+    const arrayOfArrays = automaticReports.sliceArray(devicesToSlice)
+    let requests = []
+    for (const a of arrayOfArrays) {
+        const promise = traccar.reports.reportsSummaryGet(from, to, a.map(d => d.id))
+        requests = requests.concat(promise)
+    }
+
+    const result = await Promise.all(requests)
+    return result.map(r => r.data).flat()
+}
+
 exports.getRoute = getRoute
 exports.getTrips = getTrips
 exports.getStops = getStops
 exports.getEvents = getEvents
+exports.getSummary = getSummary

package/src/util/trips.js

@@ -0,0 +1,18 @@
+const traccar = require("./traccar");
+
+async function checkTripsKms(traccarInstance, from, to, routeData, tripsData, devices) {
+    console.log('checkTripsKms')
+    const trips = tripsData.filter(t => t.distance === 0 && t.averageSpeed > 10)
+    if(trips.length > 0) {
+        //Vehicles with imported positions. calculate trip distance with route positions
+        const route = routeData.length === 0 ? await traccar.getRoute(traccarInstance, from, to, devices) : routeData
+        trips.forEach(t => {
+            const tripRoute = route.filter(p => p.deviceId === t.deviceId
+                && new Date(p.fixTime).getTime() > new Date(t.startTime).getTime()
+                && new Date(p.fixTime).getTime() < new Date(t.endTime).getTime())
+            t.distance = tripRoute.reduce((a, b) => a + b.attributes.distance, 0)
+        })
+    }
+}
+
+exports.checkTripsKms = checkTripsKms

package/src/util/utils.js

@@ -31,7 +31,7 @@ function coordsDistance(lon1, lat1, lon2, lat2) {
 
 function getDates(startDate, endDate) {
     const dates = []
-    let currentDate = startDate
+    let currentDate = new Date(startDate.toISOString().split('T')[0] + ' 12:00 PM')
     const addDays = function (days) {
         const date = new Date(this.valueOf())
         date.setDate(date.getDate() + days)