fleetmap-reports 1.0.261 → 1.0.265

package/src/speeding-report.js

@@ -16,109 +16,135 @@ let traccarInstance
 let userData
 
 const fileName = 'SpeedingReport'
+const eventTypes = ['deviceOverspeed']
 
 async function createSpeedingReport(from, to, reportUserData, traccar) {
+  console.log('Create SpeedingReport')
   traccarInstance = traccar
   userData = reportUserData
-  console.log('createSpeedingReport', from, to, userData, traccar)
   const reportData = []
 
-  if(userData.byDriver){
+  if (userData.byDriver) {
+    console.log("ByDriver")
     const allData = await createSpeedingReportByDriver(from, to)
     reportData.push(allData)
   }
-  else if(userData.byGroup){
+  else if (userData.byGroup) {
     console.log("ByGroup")
-    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,
-          xpert: devices.filter(d => d.attributes.xpert).length > 0
-        }
+    const allData = await createSpeedingReportByGroup(from, to)
+    reportData.push(...allData)
+  } else {
+    console.log("ByDevice")
+    const allData = await createSpeedingReportByDevice(from, to, userData.devices)
+    reportData.push(allData)
+  }
 
-        const eventTypes = ['deviceOverspeed']
-        const events = await traccar.getEvents(traccarInstance, from, to, devices, eventTypes)
-        const routes = userData.useVehicleSpeedLimit ? [] : await traccar.getRoute(traccarInstance, from, to, devices)
+  return reportData
+}
 
-        devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+async function createSpeedingReportByGroup(from, to){
+  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,
+        xpert: devices.filter(d => d.attributes.xpert).length > 0
+      }
 
-        if (events.length > 0) {
-          groupData.devices = await processDevices(from, to, devices, events, routes)
-          reportData.push(groupData)
-        }
+      const events = await traccar.getEvents(traccarInstance, from, to, devices, eventTypes)
+      const routes = await traccar.getRoute(traccarInstance, from, to, devices)
+
+      devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
+
+      if (events.length > 0) {
+        groupData.devices = await processDevices(from, to, devices, events, routes)
+        reportData.push(groupData)
       }
     }
-
-    const withoutGroupData = await createSpeedingReportByDevice(from, to)
-    reportData.push(withoutGroupData)
-  } else {
-    const allData = await createSpeedingReportByDevice(from, to)
-    reportData.push(allData)
   }
 
+  const groupIds = userData.groups.map(g => g.id)
+  const withoutGroupDevices = userData.devices.filter(d => !groupIds.includes(d.groupId))
+
+  const withoutGroupData = await createSpeedingReportByDevice(from, to, withoutGroupDevices)
+  reportData.push(withoutGroupData)
+
   return reportData
 }
 
-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)
+async function createSpeedingReportByDevice(from, to, devices) {
+  devices.sort((a, b) => (a.name > b.name) ? 1 : -1)
 
-  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 routes = await traccar.getRoute(traccarInstance, from, to, devices)
+  const events = []
+  if(!userData.useVehicleSpeedLimit && userData.customSpeed){
+    events.push(...await getCustomSpeedLimitEvents(devices, routes))
+  } else {
+    events.push(...await traccar.getEvents(traccarInstance, from, to, devices, eventTypes))
+  }
 
-  const allData = { devices: [] }
+  if(userData.roadSpeedLimits){
+    events.push(...await getHereEvents(devices, routes))
+  }
 
-  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
+  if(!events.length) {
+    //empty report
+    return { devices: [] }
   }
 
-  return allData
+  return {
+    devices: await processDevices(from, to, devices, events, routes),
+    xpert: devices.filter(d => d && d.attributes && d.attributes.xpert).length > 0
+  }
 }
 
 async function createSpeedingReportByDriver(from, to) {
-  const deviceIds = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
-  console.log('Devices with driver',deviceIds.length)
+  const devices = await drivers.devicesByDriver(traccarInstance, from, to, userData.drivers, userData.devices)
+  console.log('Devices with driver',devices.length)
+
+  if(!devices.length) {
+    //empty report
+    return { drivers: [] }
+  }
 
-  let eventsData = []
-  if(deviceIds.length > 0) {
-    const devices = userData.devices.filter(d => deviceIds.includes(d.id))
-    eventsData = await traccar.getEvents(traccarInstance, from, to, devices,['deviceOverspeed'])
+  const routes = await traccar.getRoute(traccarInstance, from, to, devices)
+  const events = []
+  if(!userData.useVehicleSpeedLimit && userData.customSpeed){
+    events.push(...await getCustomSpeedLimitEvents(devices, routes))
+  } else {
+    events.push(...await traccar.getEvents(traccarInstance, from, to, devices, eventTypes))
   }
 
-  const allData = {
-    drivers: []
+  if(userData.roadSpeedLimits){
+    events.push(...await getHereEvents(devices, routes))
   }
-  console.log(eventsData.length)
 
-  await getEventsPosition(from , to, userData.devices, eventsData)
-  allData.drivers = await processDrivers(from, to, eventsData)
-  console.log(allData.drivers.length)
-  return allData
+  if(!events.length) {
+    //empty report
+    return { drivers: [] }
+  }
+
+  return {drivers: await processDrivers(from, to, events, routes)}
 }
 
-async function processDrivers(from, to, data) {
-  console.log(data)
+async function processDrivers(from, to, events, routes) {
   const driversResult = []
-  const alertsWithPosition = data.filter(a => a.position)
-
-  userData.drivers.forEach(d => {
-    const alerts = alertsWithPosition.filter(e => e.position.attributes.driverUniqueId === d.uniqueId)
 
-    if (alerts.length > 0) {
+  await findEventsPosition(from, to, userData.devices, events, routes)
 
+  userData.drivers.forEach(d => {
+    const driverEvents = events.filter(e => e.position && e.position.attributes.driverUniqueId === d.uniqueId)
+    if (driverEvents.length > 0) {
+      driverEvents.sort((a, b) => a.positionId - b.positionId)
       driversResult.push({
         driver: d,
         from: from,
         to: to,
-        alerts: alerts,
-        maxSpeed: alerts.reduce((a, b) => {
+        alerts: driverEvents,
+        maxSpeed: driverEvents.reduce((a, b) => {
           return a > b.attributes.maxSpeed ? a : b.attributes.maxSpeed
         }, 0),
       })
@@ -130,117 +156,38 @@ async function processDrivers(from, to, data) {
 
 async function processDevices(from, to, devices, events, routes) {
   const devicesResult = []
+  await findEventsPosition(from, to, devices, events, routes)
 
-  if(userData.useVehicleSpeedLimit) {
-    await getEventsPosition(from, to, devices, events)
-
-    console.log(events)
-
-    for (const d of devices) {
-      const deviceEvents = events.filter(t => t.deviceId === d.id)
-
-      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),
-        })
-      }
+  for (const d of devices) {
+    const deviceEvents = events.filter(e => e.deviceId === d.id && e.position)
+    if (deviceEvents.length > 0) {
+      deviceEvents.sort((a, b) => a.positionId - b.positionId)
+      devicesResult.push({
+        device: d,
+        from: from,
+        to: to,
+        alerts: deviceEvents,
+        maxSpeed: deviceEvents.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, events){
-
-  const deviceIds = [...new Set(events.map(e => e.deviceId))]
-  const routeData = await traccar.getRoute(traccarInstance, from, to, deviceIds.map(id => { return { id: id } } ))
-
-  console.log(events)
-
+async function findEventsPosition(from, to, devices, events, routes){
   for (const d of devices) {
-    let alerts = events.filter(t => t.deviceId === d.id)
-
-    if (alerts.length > 0 || userData.roadSpeedLimits) {
-      const positions = routeData.filter(p => p.deviceId === d.id)
-
-      if (userData.roadSpeedLimits && positions.length) {
-        try {
-          const results = await here.routeMatch(positions)
-          const hereAlerts = results.map(r => {
-            const position = positions.find(p => new Date(p.fixTime).getTime() === r.timestamp)
-            return {
-              ...r,
-              roadSpeedLimit: r.speedLimit,
-              deviceId: d.id,
-              position,
-              positionId: position && position.id,
-              attributes: {speedLimit: r.speedLimit, speed: r.currentSpeedKmh / 1.85200}
-            }
-          })
-          console.log('hereAlerts', hereAlerts)
-          const reduced = hereAlerts.reduce((acc, cur, idx, src) => {
-            if (idx === 1) {
-              return [cur]
-            }
-            if (cur.timestamp - src[idx - 1].timestamp > 300000 || cur.roadSpeedLimit !== src[idx - 1].roadSpeedLimit) {
-              return acc.concat(cur)
-            }
-            return acc
-          })
-          events.push(...reduced)
-          alerts = events.filter(t => t.deviceId === d.id)
-        } catch (e) {
-          console.error(e)
-        }
-      }
+    let deviceEvents = events.filter(e => e.deviceId === d.id && e.positionId)
+    if (deviceEvents.length > 0) {
+      deviceEvents.sort((a,b) => a.positionId-b.positionId )
+      const positions = routes.filter(p => p.deviceId === d.id)
 
-      for (const a of alerts) {
+      for (const a of deviceEvents) {
         let pIndex = positions.findIndex(p => p.id === a.positionId)
         if (pIndex > 0) {
-          a.position = positions[pIndex]
           let geofence = null
-
           if (a.geofenceId) {
             geofence = userData.geofences.find(g => g.id === a.geofenceId)
             if (geofence) {
@@ -248,44 +195,87 @@ async function getEventsPosition(from, to, devices, events){
             }
           }
 
-          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
-              }
-            }
-          }
+          if(!a.position) {
+            a.position = positions[pIndex]
+            pIndex = calculateEventData(positions, pIndex, a, d, geofence)
 
-          if (a.position.attributes.driverUniqueId) {
-            const driver = userData.drivers.find(d => d.uniqueId === a.position.attributes.driverUniqueId)
-            a.driver = driver && driver.name
+            positions.slice(pIndex)
           }
+        }
+      }
+    }
+  }
+}
 
-          a.deviceName = d.name
+async function getCustomSpeedLimitEvents(devices, routes){
+  console.log('calculate custom speed limit events')
+  const events = []
+  const maxSpeed = userData.customSpeed / 1.85200
 
-          positions.slice(pIndex)
+  for (const d of devices) {
+    const positions = routes.filter(p => p.deviceId === d.id)
+    let eventIsActive = false
+
+    for (const position of positions) {
+      if(position.speed > maxSpeed && !eventIsActive){
+        const event = {
+          positionId: position && position.id,
+          deviceId: d.id,
+          attributes: {
+            speedLimit: maxSpeed,
+            speed: position.speed
+          }
         }
+        events.push(event)
+        eventIsActive = true
+      } else if (position.speed <= maxSpeed) {
+        eventIsActive = false
       }
     }
   }
+
+  return events
 }
 
-function calculateEventData(positions, pIndex, a, geofence){
-  let endEventPosition = a.position
-  let maxSpeed = a.position.speed
+async function getHereEvents(devices, routes){
+  console.log('calculate custom speed limit events')
+  const events = []
+  for (const d of devices) {
+    const positions = routes.filter(p => p.deviceId === d.id)
+    try {
+      const results = await here.routeMatch(positions)
+      const hereAlerts = results.map(r => {
+        const position = positions.find(p => new Date(p.fixTime).getTime() === r.timestamp)
+        return {
+          ...r,
+          roadSpeedLimit: r.speedLimit,
+          deviceId: d.id,
+          position,
+          positionId: position && position.id,
+          attributes: {speedLimit: r.speedLimit, speed: r.currentSpeedKmh / 1.85200}
+        }
+      })
+      console.log('hereAlerts', hereAlerts)
+      const reduced = hereAlerts.reduce((acc, cur, idx, src) => {
+        if (idx === 1) {
+          return [cur]
+        }
+        if (cur.timestamp - src[idx - 1].timestamp > 300000 || cur.roadSpeedLimit !== src[idx - 1].roadSpeedLimit) {
+          return acc.concat(cur)
+        }
+        return acc
+      })
+      events.push(...reduced)
+    } catch (e) {
+      //console.error(e)
+    }
+  }
+  return events
+}
+
+function calculateEventData(positions, pIndex, alert, device, geofence){
+  let endEventPosition = alert.position
+  let maxSpeed = alert.position.speed
   let dist = 0
   while (pIndex + 1 < positions.length) {
     pIndex++
@@ -293,10 +283,10 @@ function calculateEventData(positions, pIndex, a, geofence){
     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
+    if (endEventPosition.speed <= alert.attributes.speedLimit || (geofence && isOutsideGeofence(geofence, endEventPosition))) {
+      alert.eventTime = new Date(endEventPosition.fixTime) - new Date(alert.position.fixTime)
+      alert.attributes.maxSpeed = maxSpeed
+      alert.distance = dist
       break
     } else {
       if (maxSpeed < endEventPosition.speed) {
@@ -305,6 +295,14 @@ function calculateEventData(positions, pIndex, a, geofence){
     }
   }
 
+
+  if (alert.position.attributes.driverUniqueId) {
+    const driver = userData.drivers.find(d => d.uniqueId === alert.position.attributes.driverUniqueId)
+    alert.driver = driver && driver.name
+  }
+
+  alert.deviceName = device.name
+
   return pIndex
 }