fleetmap-reports 2.0.315 → 2.0.317

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fleetmap-reports",
-  "version": "2.0.315",
+  "version": "2.0.317",
   "description": "",
   "main": "src/index.js",
   "scripts": {

package/src/partnerReports/dailyuse-report.js

@@ -1,7 +1,11 @@
 const traccarHelper = require('../util/traccar')
 const { isInsideTimetable } = require('../util/trips')
-const { convertFromUTCDate } = require('../util/utils')
+const { convertFromUTCDate, getTranslations, convertMS, convertToLocaleTimeString, isClientSide } = require('../util/utils')
 const automaticReports = require('../automaticReports')
+const jsPDF = require('jspdf')
+const { getStyle } = require('../reportStyle')
+const { getUserPartner } = require('fleetmap-partners')
+const { addTable, headerFromUser } = require('../util/pdfDocument')
 
 async function createDailyUseReport (from, to, userData, traccar) {
   const reportData = []
@@ -77,4 +81,72 @@ function processDeviceData (allInOne, d, userData) {
   }
 }
 
+async function exportDailyUseReportToPDF (userData, reportData) {
+  const translations = getTranslations(userData)
+  const timezone = userData.user.attributes.timezone
+  const lang = userData.user.attributes.lang || (isClientSide() && navigator.language)
+
+  const headers = [
+    translations.report.vehicle,
+    'Immatriculation',
+    'Groupe',
+    'Matin départ',
+    'Matin arrêt',
+    'Matin temps',
+    'Déjeuner',
+    'Après-midi départ',
+    'Après-midi arrêt',
+    'Après-midi temps',
+    'Total temps',
+    'Total conduit',
+    'Total arrêts',
+    'Total kms'
+  ]
+
+  const data = []
+  reportData.forEach(d => {
+    const row = [
+      d.device,
+      d.licensePlate,
+      d.group,
+      convertToLocaleTimeString(d.morningStart, lang, timezone, userData.user),
+      convertToLocaleTimeString(d.morningEnd, lang, timezone, userData.user),
+      convertMS(d.morningTime),
+      convertMS(d.lunch),
+      convertToLocaleTimeString(d.afternoonStart, lang, timezone, userData.user),
+      convertToLocaleTimeString(d.afternoonEnd, lang, timezone, userData.user),
+      convertMS(d.afternoonTime),
+      convertMS(d.totalTime),
+      convertMS(d.totalDrivingTime),
+      d.totalStops,
+      (d.totalDistance / 100).toFixed(1)
+    ]
+    data.push(row)
+  })
+
+  const doc = new jsPDF.jsPDF('l')
+  await headerFromUser(doc, 'Rapport de Performance', userData.user)
+  const style = getStyle(getUserPartner(userData.user))
+
+  const footValues = []
+
+  doc.setFontSize(11)
+  doc.text(new Date(userData.from).toLocaleString() + ' - ' + new Date(userData.to).toLocaleString(), 20, 33)
+
+  style.headerFontSize = 8
+  style.bodyFontSize = 7
+  const columnStyles = {}
+  for (let i = 3; i < 14; i++) {
+    columnStyles[i] = { halign: 'right' }
+  }
+  addTable(doc, headers, data, footValues, style, 40, columnStyles)
+  return doc
+}
+
+function exportDailyUseReportToExcel (userData, reportData) {
+
+}
+
 exports.createDailyUseReport = createDailyUseReport
+exports.exportDailyUseReportToPDF = exportDailyUseReportToPDF
+exports.exportDailyUseReportToExcel = exportDailyUseReportToExcel

package/src/partnerReports/passenger-report.js

@@ -0,0 +1,46 @@
+async function createPassengerReport (from, to, userData, traccar) {
+  //const allDevices = await traccar.axios.get('/devices').then(d => d.data)
+  const devices = userData.devices
+  const drivers = await traccar.axios.get('/drivers').then(d => d.data)
+  const groups = await traccar.axios.get('/groups').then(d => d.data)
+  await Promise.all(groups.map(async g => {
+    const driversByGroup = await traccar.axios.get(`/drivers?groupId=${g.id}`).then(d => d.data)
+    driversByGroup.forEach(d => {
+      const _driver = drivers.find(a => a.id === d.id)
+      if (_driver) {
+        _driver.groupName = g.name
+      }
+    })
+  }))
+  const eventsUrl = `/reports/events?${devices.map(d => 'deviceId=' + d.id).join('&')
+}&from=${from.toISOString()
+}&to=${to.toISOString()
+}`
+  const positionsUrl = `/reports/route?${devices.map(d => 'deviceId=' + d.id).join('&')
+}&from=${from.toISOString()
+}&to=${to.toISOString()
+}`
+  const events = await traccar.axios.get(eventsUrl).then(d => d.data)
+  const positions = await traccar.axios.get(positionsUrl).then(d => d.data)
+  events.forEach(e => {
+    delete e.attributes
+    const driver = getDriver(e, positions, drivers)
+    const position = positions.find(p => p.id === e.positionId)
+    e.deviceName = devices.find(d => d.id === e.deviceId).name
+    e.groupName = driver.groupName || ''
+    e.fixtime = position && new Date(position.fixTime)
+    e.notes = driver && driver.attributes.notes
+    e.driverName = (driver && driver.name) || (position && position.attributes.driverUniqueId)
+  })
+  return events
+}
+
+function getDriver (event, positions, drivers) {
+  const p = positions.find(p => p.id === event.positionId)
+  if (!p) { return '' }
+  const d = drivers.find(d => d.uniqueId === p.attributes.driverUniqueId)
+  if (!d) { return '' }
+  return d
+}
+
+exports.createPassengerReport = createPassengerReport

package/src/sensor-report.js

@@ -10,60 +10,13 @@ const { headerFromUser, addTable } = require('./util/pdfDocument')
 const { getStyle } = require('./reportStyle')
 const { getUserPartner } = require('fleetmap-partners')
 
-function minimumDuration (status, userData) {
-  if (status) {
-    return (userData.minimumMinutesOn * 60 * 1000)
-  }
-
-  return (userData.minimumMinutesOff * 60 * 1000)
-}
-
-function addSensorPeriod (statusPeriodBySensor, s, currentStatus, d, duration, currentPosition, previousPosition) {
-  statusPeriodBySensor[s.sensor].push({
-    startTime: currentStatus[s.sensor].startTime,
-    endTime: previousPosition.fixTime,
-    endAddress: previousPosition.address,
-    value: currentStatus[s.sensor].value,
-    valueDescription: currentStatus[s.sensor].value ? d.attributes[s.sensor + 'on'] : d.attributes[s.sensor + 'off'],
-    name: s.name,
-    duration
-  })
-  currentStatus[s.sensor] = { value: currentPosition.attributes[s.id], startTime: currentPosition.fixTime }
-}
-
 function processDevices (from, to, devices, data, userData) {
   const result = []
 
   for (const d of devices) {
     const positions = data.route.filter(t => t.deviceId === d.id)
 
-    const statusPeriodBySensor = {}
-    const currentStatus = {}
-    positions.forEach((p, index) => {
-      userData.sensors.forEach(s => {
-        if (!statusPeriodBySensor[s.sensor]) {
-          statusPeriodBySensor[s.sensor] = []
-        }
-        if (currentStatus[s.sensor] !== undefined) {
-          if (currentStatus[s.sensor].value !== p.attributes[s.id]) {
-            const duration = new Date(positions[index - 1].fixTime).getTime() - new Date(currentStatus[s.sensor].startTime).getTime()
-            if ((duration >= minimumDuration(currentStatus[s.sensor].value, userData)) || statusPeriodBySensor[s.sensor].length === 0) {
-              addSensorPeriod(statusPeriodBySensor, s, currentStatus, d, duration, p, positions[index - 1])
-            } else {
-              const element = statusPeriodBySensor[s.sensor].pop()
-              currentStatus[s.sensor] = { value: p.attributes[s.id], startTime: element.startTime }
-            }
-          } else {
-            const distanceBetweenPositions = new Date(p.fixTime).getTime() - new Date(positions[index - 1].fixTime).getTime()
-            if (distanceBetweenPositions > 30 * 60 * 1000 && currentStatus[s.sensor].value === true) {
-              currentStatus[s.sensor] = { value: p.attributes[s.id], startTime: p.fixTime }
-            }
-          }
-        } else {
-          currentStatus[s.sensor] = { value: p.attributes[s.id], startTime: p.fixTime }
-        }
-      })
-    })
+    const statusPeriodBySensor = computeSensorPeriods(positions, userData.sensors, d, userData)
 
     const rows = Object.values(statusPeriodBySensor).flat()
     rows.sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime())
@@ -92,6 +45,129 @@ function processDevices (from, to, devices, data, userData) {
   return result
 }
 
+function computeSensorPeriods (positions, sensors, d, userData) {
+  if (!positions || positions.length === 0) return {}
+
+  const result = {}
+  const minOn = (userData.minimumMinutesOn || 0) * 60 * 1000
+  const minOff = (userData.minimumMinutesOff || 0) * 60 * 1000
+  const maxDistanceBetweenPositions = 20 * 60 * 1000
+
+  const minThreshold = (value) => (value ? minOn : minOff)
+
+  function pushPeriod (sensorKey, s, value, startTime, endTime, endPos) {
+    const duration = endTime - startTime
+    const period = {
+      value,
+      startTime,
+      endTime,
+      duration,
+      name: s.name,
+      endAddress: endPos.address,
+      valueDescription: value
+        ? d.attributes[s.sensor + 'on']
+        : d.attributes[s.sensor + 'off']
+    }
+    console.debug(period)
+    result[sensorKey].push(period)
+  }
+
+  for (const s of sensors) result[s.sensor] = []
+
+  // Track current period per sensor
+  const current = {}
+  const firstPos = positions[0]
+  for (const s of sensors) {
+    current[s.sensor] = {
+      value: firstPos.attributes[s.id],
+      startTime: new Date(firstPos.fixTime)
+    }
+  }
+
+  for (let i = 1; i < positions.length; i++) {
+    const prevPos = positions[i - 1]
+    const currPos = positions[i]
+    const changeTime = new Date(currPos.fixTime)
+
+    for (const s of sensors) {
+      const key = s.sensor
+      const prevValue = current[key].value
+      const newValue = currPos.attributes[s.id]
+
+      if (prevValue === newValue) continue
+
+      const oldStartTime = current[key].startTime
+      const prevEndTime = changeTime
+      const duration = prevEndTime - oldStartTime
+      const threshold = minThreshold(prevValue)
+      let newPeriodStartTime = changeTime
+
+      // Check distance between positions
+      if (prevValue === false && newValue === true && maxDistanceBetweenPositions > 0) {
+        const nextPos = positions[i + 1]
+        if (nextPos && nextPos.attributes && nextPos.attributes[s.id] === true) {
+          const nextTime = new Date(nextPos.fixTime)
+          if (nextTime - oldStartTime > maxDistanceBetweenPositions) {
+            newPeriodStartTime = nextTime
+          }
+        }
+      }
+
+      if (duration >= threshold) {
+        pushPeriod(key, s, prevValue, oldStartTime, prevEndTime, prevPos)
+      } else {
+        // merging logic for previous ignored period
+        const list = result[key]
+        if (list.length > 0) {
+          const last = list[list.length - 1]
+          if (last.value === newValue) {
+            list.pop()
+            newPeriodStartTime = new Date(last.startTime)
+          }
+        }
+      }
+
+      current[key] = {
+        value: newValue,
+        startTime: newPeriodStartTime
+      }
+    }
+  }
+
+  // Close final periods
+  const lastPos = positions[positions.length - 1]
+  const lastTime = new Date(lastPos.fixTime)
+
+  for (const s of sensors) {
+    const key = s.sensor
+    const st = current[key]
+    const startTime = st.startTime
+    const endTime = lastTime
+    const value = st.value
+    const duration = endTime - startTime
+    const threshold = minThreshold(value)
+
+    if (duration >= threshold) {
+      pushPeriod(key, s, value, startTime, endTime, lastPos)
+    } else {
+      // try to merge tiny final period into previous pushed period if same value
+      const list = result[key]
+      if (list.length > 0 && list[list.length - 1].value === value) {
+        const last = list[list.length - 1]
+        last.endTime = endTime
+        last.duration = last.endTime - last.startTime
+        last.endAddress = lastPos.address
+        last.valueDescription = value
+          ? d.attributes[s.sensor + 'on']
+          : d.attributes[s.sensor + 'off']
+      }
+      // otherwise drop final tiny period
+    }
+  }
+
+  return result
+}
+
 async function create (from, to, userData, traccar) {
   const devices = devicesToProcess(userData)
   const sliced = automaticReports.sliceArray(devices, 5)

package/src/tests/dailyuse.test.js

@@ -0,0 +1,19 @@
+const { getReports } = require('./index')
+const assert = require('assert')
+const { createDailyUseReport } = require('../partnerReports/dailyuse-report')
+
+describe('dailyuse', function () {
+  // eslint-disable-next-line no-undef
+  it('dailyuse report', async () => {
+    const report = await getReports()
+    const userData = await report.getUserData()
+
+    const data = await createDailyUseReport(
+      new Date(Date.UTC(2023, 10, 1, 0, 0, 0, 0)),
+      new Date(Date.UTC(2023, 10, 6, 23, 59, 59, 0)),
+      userData,
+      report.traccar)
+    console.log(data)
+    assert.equal(data[0].consumption, 19.799999999999997)
+  }, 8000000)
+})

package/src/tests/gpsjump.test.js

@@ -0,0 +1,23 @@
+const { getReports } = require('./index')
+const assert = require('assert')
+const { convertMS } = require('../util/utils')
+const { createGPSJumpReport } = require('../partnerReports/gpsjump-report')
+
+// eslint-disable-next-line no-undef
+describe('gpsjump', function () {
+  // eslint-disable-next-line no-undef
+  it('gpsjump report', async () => {
+    const report = await getReports()
+    const userData = await report.getUserData()
+    userData.devices = userData.devices.filter(d => d.id === 22326)
+    const data = await createGPSJumpReport(
+      new Date(Date.UTC(2023, 6, 1, 0, 0, 0, 0)),
+      new Date(Date.UTC(2023, 6, 17, 23, 59, 59, 0)),
+      userData,
+      report.traccar)
+    console.log(data)
+    assert.equal(data[0].consumption, 19.799999999999997)
+    assert.equal(data[0].distance, 326.7657)
+    assert.equal(convertMS(data[1].time * 1000, false), '08:19')
+  }, 8000000)
+})

package/src/tests/kms.test.js

@@ -65,10 +65,11 @@ describe('Kms_Reports', function () {
   it('KmsReport by timezone marrocos', async () => {
     const reports = await getReports(process.env.email, process.env.password)
     const userData = await reports.getUserData()
+    userData.groupByDay = true
     userData.devices = userData.devices.filter(d => d.id === 93497)
     const data = await reports.kmsReport(convertFromLocal(new Date(2024, 2, 18, 0, 0, 0), userData.user.attributes.timezone), convertFromLocal(new Date(2024, 2, 18, 23, 59, 59), userData.user.attributes.timezone),
       userData)
     const device = data[0].devices.find(d => d.device.id === 93497)
-    assert.equal(device, 1)
+    assert.equal(device.days.length, 1)
   }, 3000000)
 })

package/src/tests/zones.test.js

@@ -159,4 +159,21 @@ describe('zones', function () {
     console.log(first)
     assert.equal(first.days[6].distanceOut, 867.0554430738234)
   }, 4000000)
+
+  it('works with casais zones in columns 7', async () => {
+    const report = await getReports()
+    const userData = await report.getUserData()
+    userData.zonesByColumn = true
+    userData.devices = userData.devices.filter(d => d.id === 81166)
+    userData.geofences = userData.geofences.filter(g => g.name === 'baliza 1 - raio verde ' ||
+        g.name === 'baliza 2 - raio amarelo')
+    userData.onlyWithKmsOut = false
+    const result = await report.zoneReport(
+        new Date(Date.UTC(2023, 9, 9, 0, 0, 0, 0)),
+        new Date(Date.UTC(2023, 9, 31, 23, 59, 59, 0)),
+        userData)
+    const first = result[0].devices[0]
+    console.log(first)
+    assert.equal(first.days[17].distanceOut, 720.7985320478997)
+  }, 4000000)
 })

package/src/util/parallel.js

@@ -25,12 +25,6 @@ exports.parallel = (report, method, toSlice, ...args) => {
         try {
           console.log('forking worker', workerCount++, report, method, slice.length)
           const worker = cluster.fork()
-          worker.send({
-            report,
-            method,
-            args: [slice, ...args]
-          })
-          console.log('sent to worker', worker.process.pid)
           worker.on('message', ({ result }) => {
             console.log('received result from worker', worker.process.pid)
             _result.push(result)
@@ -48,6 +42,12 @@ exports.parallel = (report, method, toSlice, ...args) => {
               reject(new Error(`Worker ${worker.process.pid} exited with code ${code} and signal ${signal}`))
             }
           })
+          worker.send({
+            report,
+            method,
+            args: [slice, ...args]
+          })
+          console.log('sent to worker', worker.process.pid)
         } catch (e) {
           console.error(report, method, 'worker', workerCount, 'numCPUs', numCPUs)
           reject(e)

package/src/zone-report.js

@@ -538,7 +538,7 @@ function analyseAlerts (alerts, deviceRoute, userData, from, to, device) {
 
 async function getInAndOutEvents (devices, route, userData) {
   const events = []
-  const geofencesFeatures = userData.geofences.map(g => convertToFeature(g))
+  const geofencesFeatures = userData.geofences.filter(g => g.area).map(g => convertToFeature(g))
   devices.forEach(d => {
     const deviceRoute = route.filter(p => p.deviceId === d.id)
     const routePoints = deviceRoute.sort(sortPositions).map(p => convertPositionToFeature(p))