fleetmap-reports 2.0.356 → 2.0.358

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

@@ -0,0 +1,447 @@
+const automaticReports = require('./automaticReports')
+const traccarHelper = require('./util/traccar')
+const { devicesToProcess, deviceName } = require('./util/device')
+const {
+  getTranslations, isClientSide, convertToLocaleString, convertMS, getDates, convertToLocaleDateString,
+  convertToLocaleTimeString
+} = require('./util/utils')
+const jsPDF = require('jspdf')
+const { headerFromUser, addTable } = require('./util/pdfDocument')
+const { getStyle } = require('./reportStyle')
+const { getUserPartner } = require('fleetmap-partners')
+
+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 = 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())
+
+    if (userData.groupByDay) {
+      const dates = getDates(from, to, userData.user.attributes.timezone)
+
+      const data = userData.groupBySensor ? groupByDayAndSensor(rows, dates) : groupByDay(rows, dates)
+
+      result.push({
+        device: d,
+        from,
+        to,
+        rows: data
+      })
+    } else {
+      result.push({
+        device: d,
+        from,
+        to,
+        rows
+      })
+    }
+  }
+
+  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 = 30 * 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)
+    const endTime = new Date(prevPos.fixTime)
+
+    for (const s of sensors) {
+      const key = s.sensor
+      const prevValue = current[key].value
+      const newValue = currPos.attributes[s.id]
+
+      const oldStartTime = current[key].startTime
+      const gap = changeTime - new Date(prevPos.fixTime)
+      if (gap > maxDistanceBetweenPositions) {
+        const prevEndTime = prevValue ? new Date(prevPos.fixTime) : changeTime
+        const duration = prevEndTime - oldStartTime
+        const threshold = minThreshold(prevValue)
+
+        if (duration >= threshold) {
+          pushPeriod(key, s, prevValue, oldStartTime, prevEndTime, prevPos)
+        }
+
+        current[key] = { value: newValue, startTime: changeTime }
+
+        continue
+      }
+
+      if (prevValue === newValue) continue
+
+      const prevEndTime = endTime
+      const duration = prevEndTime - oldStartTime
+      const threshold = minThreshold(prevValue)
+      let newPeriodStartTime = changeTime
+
+      // Check distance between positions
+      if (prevValue === false && newValue === true) {
+        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)
+  const result = []
+
+  let deviceCount = 0
+  for (const slice of sliced) {
+    const allInOne = await traccarHelper.getAllInOne(traccar, from, to, slice, true, false, false, false, deviceCount, devices.length)
+    const routeData = allInOne.route
+
+    if (routeData.length > 0) {
+      result.push(...processDevices(from, to, slice, { route: routeData }, userData))
+    }
+    deviceCount = deviceCount + slice.length
+  }
+
+  return [{ devices: result }]
+}
+
+function groupByDay (rows, dates) {
+  const groupedByDay = {}
+
+  dates.forEach(dateStr => {
+    const dayStart = new Date(dateStr)
+    dayStart.setHours(0, 0, 0, 0)
+    const dayEnd = new Date(dayStart.getTime() + 86400000 - 1) // 23:59:59
+
+    rows.forEach(row => {
+      if (row.value) {
+        const rowStart = new Date(row.startTime)
+        const rowEnd = new Date(row.endTime)
+
+        if (rowStart <= dayEnd && rowEnd >= dayStart) {
+          if (!groupedByDay[dateStr]) {
+            groupedByDay[dateStr] = {}
+          }
+
+          if (!groupedByDay[dateStr][row.name]) {
+            groupedByDay[dateStr][row.name] = {
+              firstActivation: null,
+              lastActivation: null,
+              totalDuration: 0
+            }
+          }
+
+          const periodStart = Math.max(rowStart.getTime(), dayStart.getTime())
+          const periodEnd = Math.min(rowEnd.getTime(), dayEnd.getTime())
+
+          const sensorData = groupedByDay[dateStr][row.name]
+
+          if (!sensorData.firstActivation || periodStart < sensorData.firstActivation) {
+            sensorData.firstActivation = periodStart
+          }
+
+          if (!sensorData.lastActivation || periodEnd > sensorData.lastActivation) {
+            sensorData.lastActivation = periodEnd
+          }
+
+          sensorData.totalDuration += periodEnd - periodStart
+        }
+      }
+    })
+  })
+
+  // 🖨️ Exibir os dados processados
+  Object.entries(groupedByDay).forEach(([date, sensors]) => {
+    Object.entries(sensors).forEach(([sensor, data]) => {
+      console.log(`Data: ${date}, Sensor: ${sensor}`)
+      console.log(`  Primeira ativação: ${data.firstActivation ? new Date(data.firstActivation).toLocaleTimeString() : '00:00'}`)
+      console.log(`  Última ativação: ${data.lastActivation ? new Date(data.lastActivation).toLocaleTimeString() : '23:59'}`)
+      console.log(`  Duração total: ${(data.totalDuration / 1000 / 60).toFixed(2)} minutos`)
+    })
+  })
+
+  return Object.entries(groupedByDay)
+}
+
+function groupByDayAndSensor (rows, dates) {
+  const groupedData = {}
+
+  dates.forEach(dateStr => {
+    const dayStart = new Date(dateStr)
+    dayStart.setHours(0, 0, 0, 0)
+    const dayEnd = new Date(dayStart.getTime() + 86400000 - 1) // 23:59:59
+
+    if (!groupedData[dateStr]) {
+      groupedData[dateStr] = {
+        firstActivation: null,
+        lastActivation: null,
+        totalDuration: 0
+      }
+    }
+
+    const activePeriods = []
+
+    rows.forEach(row => {
+      if (row.value) {
+        const rowStart = new Date(row.startTime).getTime()
+        const rowEnd = new Date(row.endTime).getTime()
+
+        if (rowStart <= dayEnd.getTime() && rowEnd >= dayStart.getTime()) {
+          const periodStart = Math.max(rowStart, dayStart.getTime())
+          const periodEnd = Math.min(rowEnd, dayEnd.getTime())
+
+          activePeriods.push([periodStart, periodEnd]) // Store activation period
+        }
+      }
+    })
+
+    // Merge overlapping activation periods
+    activePeriods.sort((a, b) => a[0] - b[0]) // Sort by start time
+    const mergedPeriods = []
+    let currentPeriod = null
+
+    activePeriods.forEach(([start, end]) => {
+      if (!currentPeriod) {
+        currentPeriod = [start, end]
+      } else if (start <= currentPeriod[1]) {
+        // Extend the current period if overlapping
+        currentPeriod[1] = Math.max(currentPeriod[1], end)
+      } else {
+        // Store the finished period and start a new one
+        mergedPeriods.push(currentPeriod)
+        currentPeriod = [start, end]
+      }
+    })
+    if (currentPeriod) {
+      mergedPeriods.push(currentPeriod)
+    }
+
+    const totalDuration = mergedPeriods.reduce((sum, [start, end]) => sum + (end - start), 0)
+
+    if (mergedPeriods.length > 0) {
+      groupedData[dateStr].firstActivation = mergedPeriods[0][0]
+      groupedData[dateStr].lastActivation = mergedPeriods[mergedPeriods.length - 1][1]
+      groupedData[dateStr].totalDuration = totalDuration
+    }
+  })
+
+  return Object.entries(groupedData)
+}
+async function exportToPDF (userData, reportData) {
+  console.log('exportSensorReportToPDF')
+
+  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 = userData.groupByDay && userData.groupBySensor
+    ? [
+        translations.report.date,
+        translations.report.start,
+        translations.report.end,
+        translations.report.duration
+      ]
+    : (userData.groupByDay
+        ? [
+            translations.report.date,
+            'Sensor',
+            translations.report.start,
+            translations.report.end,
+            translations.report.duration
+          ]
+        : [
+            'Sensor',
+            translations.report.start,
+            translations.report.end,
+            'Estado',
+            translations.report.duration,
+            translations.report.endAddress
+          ])
+
+  if (reportDataRows) {
+    // eslint-disable-next-line new-cap
+    const doc = new jsPDF.jsPDF('l')
+    await headerFromUser(doc, 'Relatório de Sensores', userData.user)
+
+    let index = 0
+    reportDataRows.forEach(function (d) {
+      if (d.rows.length) {
+        const data = []
+        const name = deviceName(d.device)
+        const group = userData.groups.find(g => d.device.groupId === g.id)
+
+        const space = index === 0 ? 8 : 0
+        if (index) {
+          doc.addPage()
+        }
+
+        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(convertToLocaleString(d.from, lang, timezone, userData.user) + ' - ' + convertToLocaleString(d.to, lang, timezone, userData.user), 20, space + 25)
+
+        if (userData.groupByDay && userData.groupBySensor) {
+          d.rows.forEach(day => {
+            const temp = [
+              convertToLocaleDateString(day[0], lang, timezone, userData.user),
+              day[1].firstActivation ? convertToLocaleTimeString(day[1].firstActivation, lang, timezone, userData.user) : '-',
+              day[1].lastActivation ? convertToLocaleTimeString(day[1].lastActivation, lang, timezone, userData.user) : '-',
+              convertMS(day[1].totalDuration)
+            ]
+            data.push(temp)
+          })
+        } else if (userData.groupByDay) {
+          d.rows.forEach(day => {
+            const sensors = Object.entries(day[1])
+            sensors.forEach(sensor => {
+              const temp = [
+                convertToLocaleDateString(day[0], lang, timezone, userData.user),
+                sensor[0],
+                sensor[1].firstActivation ? convertToLocaleTimeString(sensor[1].firstActivation, lang, timezone, userData.user) : '-',
+                sensor[1].lastActivation ? convertToLocaleTimeString(sensor[1].lastActivation, lang, timezone, userData.user) : '-',
+                convertMS(sensor[1].totalDuration)
+              ]
+              data.push(temp)
+            })
+          })
+        } else {
+          d.rows.forEach(row => {
+            const temp = [
+              row.name,
+              convertToLocaleString(row.startTime, lang, timezone, userData.user),
+              convertToLocaleString(row.endTime, lang, timezone, userData.user),
+              row.valueDescription,
+              convertMS(row.duration),
+              row.endAddress
+            ]
+            data.push(temp)
+          })
+        }
+
+        const totalDuration = (userData.groupByDay && userData.groupBySensor) ? getTotalDuration(d.rows) : 0
+
+        const footValues = (userData.groupByDay && userData.groupBySensor) ? ['', '', '', totalDuration] : []
+
+        const style = getStyle(getUserPartner(userData.user))
+
+        addTable(doc, headers, data, footValues, style, 40,
+          (userData.groupByDay && userData.groupBySensor ? { 3: { halign: 'right' } } : { 4: { halign: 'right' } }))
+
+        index++
+      }
+    })
+    return doc
+  }
+}
+
+function getTotalDuration (rows) {
+  return convertMS(rows.reduce((a, b) => a + b[1].totalDuration, 0), false)
+}
+
+function exportToExcel (userData, reportData) {
+
+}
+
+exports.exportToPDF = exportToPDF
+exports.exportToExcel = exportToExcel
+exports.create = create