fleetmap-reports 1.0.392 → 1.0.399

package/src/refueling-report.js

@@ -1,177 +1,179 @@
-const helpers = require("turf")
-const automaticReports = require("./automaticReports")
-const {devicesToProcess} = require("./util/device");
+const helpers = require('@turf/helpers')
+const automaticReports = require('./automaticReports')
+const { devicesToProcess } = require('./util/device')
+const distance = require('@turf/distance')
 
 const positionsToCheck = 15
 
-async function createRefuelingReport(from, to, userData, traccar) {
-    console.log('Create RefuelingReport')
+async function createRefuelingReport (from, to, userData, traccar) {
+  console.log('Create RefuelingReport')
 
-    const reportData = []
+  const reportData = []
 
-    const allData = {
-        devices: [],
-        from: from,
-        to: to
-    }
+  const allData = {
+    devices: [],
+    from,
+    to
+  }
 
-    const devices = devicesToProcess(userData).filter(d => automaticReports.deviceWithFuelInfo(d))
+  const devices = devicesToProcess(userData).filter(d => automaticReports.deviceWithFuelInfo(d))
 
-    console.log('Devices:'+devices.length)
+  console.log('Devices:' + devices.length)
 
-    const arrayOfArrays = automaticReports.sliceArray(devices)
-    let data = []
-    for (const a of arrayOfArrays) {
-        const response = await traccar.reports.reportsRouteGet(from, to, a.map(d => d.id))
-        data = data.concat(response.data)
-    }
+  const arrayOfArrays = automaticReports.sliceArray(devices)
+  let data = []
+  for (const a of arrayOfArrays) {
+    const response = await traccar.reports.reportsRouteGet(from, to, a.map(d => d.id))
+    data = data.concat(response.data)
+  }
 
-    console.log('Locations:'+data.length)
+  console.log('Locations:' + data.length)
 
-    if(data.length === 0) {
-        return reportData
-    }
+  if (data.length === 0) {
+    return reportData
+  }
+
+  allData.totalDevices = 0
+  allData.totalRefueling = 0
+  allData.totalRefuelingLiters = 0
+
+  for (const d of devices) {
+    const positions = data.filter(t => t.deviceId === d.id)
+
+    if (positions.length > 0) {
+      const refuelingPositions = await this.calculateRefuelingPositions(userData, d, { route: positions })
+
+      if (userData.drivers.length > 0) {
+        refuelingPositions.forEach(p => {
+          const geofence = findNearestPOI(p.position, userData.geofences)
+          if (geofence) {
+            p.position.geofenceName = geofence.name
+          }
+          const driver = userData.drivers.find(d => d.uniqueId === p.position.attributes.driverUniqueId)
+          if (driver) {
+            p.position.driverName = driver.name
+          }
+        })
+      }
 
-    allData.totalDevices = 0
-    allData.totalRefueling = 0
-    allData.totalRefuelingLiters = 0
-
-    for (const d of devices) {
-        const positions = data.filter(t => t.deviceId===d.id)
-
-        if(positions.length > 0) {
-            const refuelingPositions = await this.calculateRefuelingPositions(userData, d, {route: positions})
-
-            if (userData.drivers.length > 0) {
-                refuelingPositions.forEach(p => {
-                    const geofence = findNearestPOI(p.position, userData.geofences)
-                    if(geofence) {
-                        p.position.geofenceName = geofence.name
-                    }
-                    const driver = userData.drivers.find(d => d.uniqueId === p.position.attributes.driverUniqueId)
-                    if (driver) {
-                        p.position.driverName = driver.name
-                    }
-                })
-            }
-
-            if (refuelingPositions.length > 0) {
-                allData.devices.push({
-                    device: d,
-                    refuelings: refuelingPositions,
-                })
-                allData.totalDevices = allData.totalDevices+1
-                allData.totalRefueling = allData.totalRefueling + refuelingPositions.length
-                allData.totalRefuelingLiters = allData.totalRefuelingLiters + refuelingPositions.reduce((a, b) => a + b.diff, 0)
-            }
-        }
+      if (refuelingPositions.length > 0) {
+        allData.devices.push({
+          device: d,
+          refuelings: refuelingPositions
+        })
+        allData.totalDevices = allData.totalDevices + 1
+        allData.totalRefueling = allData.totalRefueling + refuelingPositions.length
+        allData.totalRefuelingLiters = allData.totalRefuelingLiters + refuelingPositions.reduce((a, b) => a + b.diff, 0)
+      }
     }
+  }
 
-    reportData.push(allData)
+  reportData.push(allData)
 
-    return reportData
+  return reportData
 }
 
-function findNearestPOI(position, geofences) {
-    if (geofences.length === 0) { return null }
+function findNearestPOI (position, geofences) {
+  if (geofences.length === 0) { return null }
 
-    if (!position) { return null }
+  if (!position) { return null }
 
-    const a = geofences.map(g => {
-        if (g.area) {
-            const str = g.area.substring('CIRCLE ('.length, g.area.indexOf(','))
-            const coord = str.trim().split(' ')
-            return {
-                id: g.id,
-                distance: Math.round(coordsDistance(parseFloat(coord[1]), parseFloat(coord[0]), position.longitude, position.latitude))
-            }
-        }
-        return {
-            id: g.id,
-            distance: Number.MAX_SAFE_INTEGER
-        }
-    }).filter(a => a.distance < 100).sort((a, b) => (a.distance > b.distance) ? 1 : -1)
+  const a = geofences.map(g => {
+    if (g.area && g.area.startsWith('CIRCLE (')) {
+      console.log('->' + g.area)
+      const str = g.area.substring('CIRCLE ('.length, g.area.indexOf(','))
 
-    if (a.length > 0) {
-        return a[0]
+      const coord = str.trim().split(' ')
+      return {
+        id: g.id,
+        distance: Math.round(coordsDistance(parseFloat(coord[1]), parseFloat(coord[0]), position.longitude, position.latitude))
+      }
     }
+    return {
+      id: g.id,
+      distance: Number.MAX_SAFE_INTEGER
+    }
+  }).filter(a => a.distance < 100).sort((a, b) => (a.distance > b.distance) ? 1 : -1)
 
-    return null
-}
-
-function coordsDistance(lon1, lat1, lon2, lat2) {
-    const from = helpers.point([lon1, lat1])
-    const to = helpers.point([lon2, lat2])
+  if (a.length > 0) {
+    return a[0]
+  }
 
-    return (helpers.distance(from, to) * 1000)
+  return null
 }
 
-async function calculateRefuelingPositions(userData, d, data) {
-    const refuelingPositions = []
-
-    if(userData.withOdooServices && d.attributes.odooId) {
-        console.log(data.fuelServices)
-        data.fuelServices.forEach(s => {
-            const serviceDate = new Date(s.date)
-            serviceDate.setHours(23, 59, 59, 59)
+function coordsDistance (lon1, lat1, lon2, lat2) {
+  const from = helpers.point([lon1, lat1])
+  const to = helpers.point([lon2, lat2])
 
-            const routeBeforeService = data.route.filter(r => new Date(r.fixTime).getTime() < serviceDate.getTime())
+  return distance.default(from, to) * 1000
+}
 
-            const quantity = s.notes.split(':')[1].replace(',', '.') || 0
+async function calculateRefuelingPositions (userData, d, data) {
+  const refuelingPositions = []
+
+  if (userData.withOdooServices && d.attributes.odooId) {
+    console.log(data.fuelServices)
+    data.fuelServices.forEach(s => {
+      const serviceDate = new Date(s.date)
+      serviceDate.setHours(23, 59, 59, 59)
+
+      const routeBeforeService = data.route.filter(r => new Date(r.fixTime).getTime() < serviceDate.getTime())
+
+      const quantity = s.notes.split(':')[1].replace(',', '.') || 0
+
+      if (routeBeforeService.length) {
+        refuelingPositions.push({ date: s.date, diff: Number.parseFloat(quantity), cost: s.amount })
+      }
+    })
+  } else {
+    let refuelingActivated = false
+    let currentValue = null
+    let positionsChecked = 0
+    let lastRefuelingIndex = 0
+    data.route.forEach(function (element, index, array) {
+      if (!element.attributes.ignition && refuelingActivated && !currentValue) {
+        // Ignition is off and Refueling is Active and there is no current value
+
+        // Get 5 position before the ignition off to calculate the current value of the fuel tank level
+        // lastRefuelingIndex is used to avoid re-analyzing positions prior to a refueling
+        const before = (index > 5 ? array.slice((index - 6 < lastRefuelingIndex ? lastRefuelingIndex : index - 6), index - 1) : array.slice(0, index - 1)).filter(b => b.attributes.ignition && b.attributes.fuel)
+        currentValue = Math.round(before.reduce((a, b) => a + b.attributes.fuel, 0) / before.length)
+
+        positionsChecked = 0
+      }
+
+      if (element.attributes.ignition && refuelingActivated && currentValue) {
+        // Ignition is on and Refueling is Active and there is a current value
+        // Calculate the value of the fuel tank level after turning the ignition back on
+        const after = (array.length > index + 5 ? array.slice(index, index + 1) : array.slice(index)).filter(b => b.attributes.ignition && b.attributes.fuel)
+        const newValue = Math.round(after.reduce((a, b) => a + b.attributes.fuel, 0) / after.length)
+
+        const diff = automaticReports.calculateFuelDiff(currentValue, newValue, d)
+        if (diff > 20) {
+          // New refueling detected
+          const value = Math.round(diff * d.attributes.fuel_tank_capacity / 100)
+          refuelingPositions.push({ position: element, date: element.fixTime, diff: value })
+          lastRefuelingIndex = index
+          positionsChecked = positionsToCheck + 1 // to reset values
+        }
 
-            if (routeBeforeService.length) {
-                refuelingPositions.push({date: s.date, diff: Number.parseFloat(quantity), cost: s.amount})
-            }
-        })
-    } else {
-        let refuelingActivated = false
-        let currentValue = null
-        let positionsChecked = 0
-        let lastRefuelingIndex = 0
-        data.route.forEach(function (element, index, array) {
-            if (!element.attributes.ignition && refuelingActivated && !currentValue) {
-                //Ignition is off and Refueling is Active and there is no current value
-
-                //Get 5 position before the ignition off to calculate the current value of the fuel tank level
-                //lastRefuelingIndex is used to avoid re-analyzing positions prior to a refueling
-                const before = (index > 5 ? array.slice((index - 6 < lastRefuelingIndex ? lastRefuelingIndex : index - 6), index - 1) : array.slice(0, index - 1)).filter(b => b.attributes.ignition && b.attributes.fuel)
-                currentValue = Math.round(before.reduce((a, b) => a + b.attributes.fuel, 0) / before.length)
-
-                positionsChecked = 0
-            }
-
-            if (element.attributes.ignition && refuelingActivated && currentValue) {
-                //Ignition is on and Refueling is Active and there is a current value
-                //Calculate the value of the fuel tank level after turning the ignition back on
-                const after = (array.length > index + 5 ? array.slice(index, index + 1) : array.slice(index)).filter(b => b.attributes.ignition && b.attributes.fuel)
-                const newValue = Math.round(after.reduce((a, b) => a + b.attributes.fuel, 0) / after.length)
-
-                const diff = automaticReports.calculateFuelDiff(currentValue, newValue, d)
-                if (diff > 20) {
-                    //New refueling detected
-                    const value = Math.round(diff * d.attributes.fuel_tank_capacity / 100)
-                    refuelingPositions.push({position: element, date: element.fixTime, diff: value})
-                    lastRefuelingIndex = index
-                    positionsChecked = positionsToCheck + 1 // to reset values
-                }
-
-                if (positionsChecked > positionsToCheck) {
-                    refuelingActivated = false
-                    currentValue = null
-                    positionsChecked = 0
-                } else {
-                    positionsChecked++
-                }
-            }
-
-            if (element.attributes.ignition && !refuelingActivated) {
-                refuelingActivated = true
-            }
-        })
-    }
-    return refuelingPositions
+        if (positionsChecked > positionsToCheck) {
+          refuelingActivated = false
+          currentValue = null
+          positionsChecked = 0
+        } else {
+          positionsChecked++
+        }
+      }
+
+      if (element.attributes.ignition && !refuelingActivated) {
+        refuelingActivated = true
+      }
+    })
+  }
+  return refuelingPositions
 }
 
-
-exports.createRefuelingReport = createRefuelingReport;
+exports.createRefuelingReport = createRefuelingReport
 exports.calculateRefuelingPositions = calculateRefuelingPositions