fleetmap-reports 2.0.356 → 2.0.358

package/.claude/worktrees/eager-stonebraker-c08ac7/src/util/utils.js

@@ -0,0 +1,358 @@
+const turf = require('@turf/helpers')
+const {
+  getUserPartner
+} = require('fleetmap-partners')
+const messages = require('../../lang')
+const axios = require('axios').default
+const distance = require('@turf/distance')
+const { devicesToProcess } = require('./device')
+
+exports.getTranslations = (userData) => {
+  const lang = this.getLanguage(userData)
+  if (!messages[lang]) {
+    console.warn('no lang found for', userData.user, userData.user.attributes.lang)
+  }
+  return messages[lang] ? messages[lang] : messages['en-GB']
+}
+
+exports.getLanguage = (userData) => {
+  const partner = getUserPartner(userData.user)
+  return userData.user.attributes.lang ||
+    ((typeof navigator !== 'undefined') && navigator.language) ||
+    (partner && partner.lang) ||
+    'pt-BR'
+}
+
+function convertMS (duration, withSeconds) {
+  if (!duration || duration < 0) {
+    return withSeconds ? '00:00:00' : '00:00'
+  }
+
+  const ms = duration % 1000
+  let s = (duration - ms) / 1000
+  let seconds = s % 60
+  s = (s - seconds) / 60
+  let minutes = s % 60
+  let hours = (s - minutes) / 60
+
+  hours = (hours < 10) ? '0' + hours : hours
+  minutes = (minutes < 10) ? '0' + minutes : minutes
+  seconds = (seconds < 10) ? '0' + seconds : seconds
+
+  return withSeconds ? hours + ':' + minutes + ':' + seconds : hours + ':' + minutes
+}
+
+exports.formatNumber = function formatNumber (value) {
+  return Number(value.toFixed(1))
+}
+
+function coordsDistance (lon1, lat1, lon2, lat2) {
+  const from = turf.point([lon1, lat1])
+  const to = turf.point([lon2, lat2])
+
+  return distance.default(from, to, { units: 'meters' })
+}
+
+function convertPositionToFeature (position) {
+  const point = turf.point([position.longitude, position.latitude])
+  point.properties.position = position
+  return point
+}
+
+function convertToFeature (geofence) {
+  if (geofence.area.startsWith('POLYGON')) {
+    const feature = {
+      type: 'Feature',
+      properties: {
+        geofence
+      },
+      geometry: {
+        type: 'Polygon',
+        coordinates: [[]]
+      }
+    }
+    const str = geofence.area.substring('POLYGON(('.length, geofence.area.length - 2)
+    const coordList = str.split(',')
+    for (const i in coordList) {
+      const coord = coordList[i].trim().split(' ')
+      feature.geometry.coordinates[0].push([parseFloat(coord[1]), parseFloat(coord[0])])
+    }
+    return feature
+  }
+
+  if (geofence.area.startsWith('CIRCLE')) {
+    const str = geofence.area.substring('CIRCLE ('.length, geofence.area.length - 1)
+    const coordList = str.split(',')
+    const coord = coordList[0].trim().split(' ')
+    const point = turf.point([parseFloat(coord[1]), parseFloat(coord[0])])
+    point.properties.geofence = geofence
+    point.properties.distance = coordList[1].trim()
+    return point
+  }
+
+  if (geofence.area.startsWith('LINESTRING')) {
+    const str = geofence.area.substring('LINESTRING ('.length, geofence.area.length - 1)
+    const coordList = str.split(',')
+    const coordinates = coordList.map(c => {
+      const coord = c.trim().split(' ')
+      return [parseFloat(coord[1]), parseFloat(coord[0])]
+    })
+    return {
+      type: 'Feature',
+      properties: {
+        geofence
+      },
+      geometry: {
+        type: 'LineString',
+        coordinates
+      }
+    }
+  }
+}
+
+function getDates (startDate, endDate, timezone) {
+  const dates = []
+  let currentDate = new Date(startDate.getFullYear(), startDate.getMonth(), startDate.getDate(), 12, 0, 0, 0)
+  let _endDate = new Date(endDate.getFullYear(), endDate.getMonth(), endDate.getDate(), 23, 59, 59, 0)
+
+  timezone = safeTimezone(timezone)
+  if (!isClientSide() && timezone) {
+    const startDateUserTimezone = convertFromUTC(startDate, timezone)
+    currentDate = new Date(startDateUserTimezone.getFullYear(), startDateUserTimezone.getMonth(), startDateUserTimezone.getDate(), 12, 0, 0, 0)
+    const endDateUserTimezone = convertFromUTC(endDate, timezone)
+    _endDate = new Date(endDateUserTimezone.getFullYear(), endDateUserTimezone.getMonth(), endDateUserTimezone.getDate(), 23, 59, 59, 0)
+  }
+  const addDays = function (days) {
+    const date = new Date(this.valueOf())
+    date.setDate(date.getDate() + days)
+    return date
+  }
+  while (currentDate <= _endDate) {
+    dates.push(currentDate)
+    currentDate = addDays.call(currentDate, 1)
+  }
+  return dates
+}
+
+function getImage (url) {
+  return require('axios').default.get(url, { responseType: 'arraybuffer' }).then(d => d.data)
+}
+
+async function getImageBase64 (url) {
+  const response = await getImage(url)
+  return Buffer.from(response, 'binary').toString('base64')
+}
+
+function getLogoUrl (hostname) {
+  const path = `/img/logos/${hostname}.png`
+  return isClientSide() ? path : `https://${hostname}${path}`
+}
+
+async function getImgFromUrl (hostname) {
+  const url = getLogoUrl(hostname)
+  try {
+    const img = new Image()
+    img.src = url
+    return img
+  } catch (e) {
+    return await getImageBase64(url)
+  }
+}
+
+function isClientSide () { return (typeof window !== 'undefined') }
+
+// Guards against corrupt user attributes (e.g. timezone === true) reaching Intl,
+// which throws RangeError: Invalid time zone specified
+function safeTimezone (timezone) {
+  if (typeof timezone !== 'string' || !timezone) return undefined
+  try {
+    Intl.DateTimeFormat(undefined, { timeZone: timezone })
+    return timezone
+  } catch (e) {
+    return undefined
+  }
+}
+
+function convertToLocaleString (value, lang, timezone, user) {
+  if (isClientSide()) {
+    return new Date(value).toLocaleString()
+  }
+  if ((lang && timezone) || user) {
+    return new Date(value).toLocaleString(lang || getUserPartner(user).lang, {
+      timeZone: safeTimezone(timezone) || safeTimezone(user && getUserPartner(user).timezone),
+      hour12: false
+    })
+  }
+  return new Date(value).toISOString()
+}
+
+function convertToLocaleDateString (value, lang, timezone, user) {
+  if (isClientSide()) {
+    return new Date(value).toLocaleDateString()
+  } else {
+    return new Date(value).toLocaleDateString(lang || getUserPartner(user).lang, {
+      timeZone: safeTimezone(timezone) || safeTimezone(user && getUserPartner(user).timezone),
+      hour12: false
+    })
+  }
+}
+
+function convertToLocaleTimeString (value, lang, timezone, user) {
+  if (isClientSide()) {
+    return new Date(value).toLocaleTimeString()
+  } else {
+    return new Date(value).toLocaleTimeString(lang || getUserPartner(user).lang, {
+      timeZone: safeTimezone(timezone) || safeTimezone(user && getUserPartner(user).timezone),
+      hour12: false
+    })
+  }
+}
+
+function getTimezoneOffset (timezone, date = new Date()) {
+  if (isClientSide()) {
+    return date.getTimezoneOffset()
+  } else {
+    timezone = safeTimezone(timezone)
+    if (!timezone) {
+      return 0
+    }
+    const utcDate = new Date(date.toLocaleString('en-US', { timeZone: 'UTC' }))
+    const tzDate = new Date(date.toLocaleString('en-US', { timeZone: timezone }))
+    return (utcDate.getTime() - tzDate.getTime()) / 6e4
+  }
+}
+
+function convertFromUTC (value, timezone) {
+  if (isClientSide()) {
+    return new Date(value)
+  }
+
+  const valueDate = new Date(value)
+  const offset = getTimezoneOffset(timezone, valueDate)
+  valueDate.setTime(valueDate.getTime() - (offset * 60 * 1000))
+  return valueDate
+}
+
+exports.convertFromLocal = (value, timezone) => {
+  const valueDate = new Date(value)
+  const offset = getTimezoneOffset(timezone, valueDate)
+  valueDate.setTime(valueDate.getTime() + (offset * 60 * 1000))
+  return valueDate
+}
+
+function weekDaySelected (date, weekDays) {
+  return !weekDays || ((date.getDay() === 0 && weekDays.sunday) ||
+    (date.getDay() === 1 && weekDays.monday) ||
+    (date.getDay() === 2 && weekDays.tuesday) ||
+    (date.getDay() === 3 && weekDays.wednesday) ||
+    (date.getDay() === 4 && weekDays.thursday) ||
+    (date.getDay() === 5 && weekDays.friday) ||
+    (date.getDay() === 6 && weekDays.saturday))
+}
+
+async function executeServerSide (type, sliced, from, to, userData, totalItems, traccar, maxRequests = 10) {
+  let itemsCount = 0
+  console.log('PROGRESS_PERC:1')
+  const cookie = await axios.get('/pinmeapi/cookie/get', { withCredentials: true }).then(d => d.data)
+  const reportData = []
+  for (let i = 0; i < sliced.length; i += maxRequests) {
+    const _sliced = sliced.slice(i, i + maxRequests)
+    await Promise.all(_sliced.map(async items => {
+      const url = `https://${getServerHost()}/pinmeapi/reports/${type}`
+      try {
+        await axios.post(url, {
+          from,
+          to,
+          userData: userData.byDriver
+            ? {
+                ...userData,
+                drivers: items,
+                geofences: []
+              }
+            : {
+                ...userData,
+                devices: items,
+                geofences: []
+              },
+          cookie
+        }, { withCredentials: true }).then(d => {
+          const result = d.data[0]
+          if (result) {
+            reportData.push(...((userData.byDriver ? result.drivers : result.devices) || []))
+          }
+        })
+        itemsCount = itemsCount + items.length
+      } catch (e) {
+        console.error(e)
+      }
+      console.log(`PROGRESS_PERC:${itemsCount / totalItems * 100}`)
+    }))
+  }
+
+  if (userData.byDriver) {
+    reportData.sort((a, b) => (a.driver.name > b.driver.name) ? 1 : -1)
+  } else {
+    reportData.sort((a, b) => (a.device.name > b.device.name) ? 1 : -1)
+  }
+
+  return reportData
+}
+
+exports.executeServerSide = executeServerSide
+exports.getImgFromUrl = getImgFromUrl
+exports.convertMS = convertMS
+exports.coordsDistance = coordsDistance
+exports.getDates = getDates
+exports.convertToLocaleString = convertToLocaleString
+exports.convertToLocaleDateString = convertToLocaleDateString
+exports.convertToLocaleTimeString = convertToLocaleTimeString
+exports.isClientSide = isClientSide
+exports.getTimezoneOffset = getTimezoneOffset
+exports.convertFromUTC = convertFromUTC
+exports.weekDaySelected = weekDaySelected
+exports.getLogo = (user) => {
+  const host = window ? window.location.hostname : getUserPartner(user).host
+  return getImage(getLogoUrl(host))
+}
+exports.convertToFeature = convertToFeature
+exports.convertPositionToFeature = convertPositionToFeature
+exports.calculateDistance = (positions, ignoreOdometer) => {
+  let distanceValue = 0
+  if (!ignoreOdometer &&
+      positions.length > 1 &&
+      positions[0].attributes &&
+      positions[0].attributes.odometer &&
+      positions[positions.length - 1].attributes &&
+      positions[positions.length - 1].attributes.odometer) {
+    distanceValue = (positions[positions.length - 1].attributes.odometer - positions[0].attributes.odometer) / 1000
+  }
+
+  if (distanceValue > 0) {
+    return distanceValue
+  }
+
+  return positions
+    .sort((a, b) => new Date(a.fixTime).getTime() - new Date(b.fixTime).getTime())
+    .map(p => [p.longitude, p.latitude])
+    .reduce((previousValue, currentValue, currentIndex, array) => {
+      return currentIndex < array.length - 1
+        ? previousValue + distance.default(currentValue, array[currentIndex + 1])
+        : previousValue
+    }, 0) || 0
+}
+
+exports.sortPositions = (a, b) => new Date(a.fixTime).getTime() - new Date(b.fixTime).getTime()
+exports.getLogoUrl = getLogoUrl
+exports.convertFromUTCDate = (value, user) => {
+  return convertFromUTC(value, user.attributes.timezone || getUserPartner(user).timezone)
+}
+
+exports.getCountry = position => position && position.address && position.address.split(',').slice(-1)[0].trim()
+
+exports.processServerSide = (userData) => {
+  const devices = devicesToProcess(userData)
+  return devices.length > 100 && isClientSide()
+}
+
+const getServerHost = () => process.env.SERVER_HOST
+exports.getServerHost = getServerHost

package/.claude/worktrees/eager-stonebraker-c08ac7/src/util/worker.js

@@ -0,0 +1,14 @@
+const path = require('path')
+console.log(`worker ${process.pid} is running`, process.cwd())
+process.on('message', async (message) => {
+  try {
+    const { report, method, args } = message
+    console.log(`worker ${process.pid} is running`, process.cwd(), report, method)
+    const _report = require(path.resolve(__dirname, `../${report}`))
+    process.send({ result: await _report[method](...args) })
+  } catch (error) {
+    console.error(`worker ${process.pid} error:`, error)
+    process.send({ error: error.message, stack: error.stack })
+    process.exit(1)
+  }
+})

package/.claude/worktrees/eager-stonebraker-c08ac7/src/util/xpert.js

@@ -0,0 +1,58 @@
+function parseEndTripMessage (xpertMessage) {
+  const data = xpertMessage.split(',')
+
+  return {
+    date: data[1],
+    totalDistanceTravelled: Number(data[2]),
+    totalDistanceTravelledWithCruiseControl: Number(data[3]),
+    totalFuelConsumption: Number(data[4]),
+    totalFuelConsumptionInPTO: Number(data[5]),
+    totalFuelConsumptionInIdle: Number(data[6]),
+    totalFuelConsumptionDriving: Number(data[7]),
+    totalFuelConsumptionWithCruiseControl: Number(data[8]),
+    totalTimeWithCruiseControl: Number(data[9]),
+    totalTimeInPTO: Number(data[10]),
+    totalTimeInIdle: Number(data[11]),
+    totalTimeDriving: Number(data[12]),
+    totalTimeWithIgnitionKeyOnly: Number(data[13]),
+    totalEngineHours: Number(data[14])
+  }
+}
+
+function parseCanDriverStyleMessage (xpertMessage) {
+  const data = xpertMessage.split(',')
+
+  return {
+    date: data[1],
+    totalFuelConsumptionInEcoRange: Number(data[2]),
+    totalTimeInEcoRange: Number(data[3]),
+    totalDistanceInEcoRange: Number(data[4]),
+    totalFuelConsumptionWithClutchPressed2: Number(data[5]),
+    totalTimeWithClutchPressed2: Number(data[6]),
+    totalDistanceWithClutchPressed2: Number(data[7]),
+    totalFuelConsumptionWithCruiseControlAndAccelerator2: Number(data[8]),
+    totalTimeWithCruiseControlAndAccelerator2: Number(data[9]),
+    totalDistanceWithCruiseControlAndAccelerator2: Number(data[10]),
+    totalNumberOfBrakes: Number(data[11]),
+    totalNumberOfHarshBrakes: Number(data[12]),
+    totalNumberOfHarshAccelerations: Number(data[13]),
+    totalTimeWithHighRpmAndTorque: Number(data[14]),
+    totalTimeWithHighTorque: Number(data[15]),
+    totalTimeWithHighEngineTemperature: Number(data[16]),
+    totalFuelConsumptionWithHighRpmAndTorque: Number(data[17]),
+    totalDistanceWithHighRpmAndTorque: Number(data[18])
+  }
+}
+
+function getEndTripMessages (xpertMessages) {
+  return xpertMessages.map(xpert => (Array.isArray(xpert) ? xpert.split(';').find(m => m.startsWith('3')) : (xpert.startsWith('3') ? xpert : undefined))).flat().filter(a => a)
+}
+
+function getCanDriverStyleMessages (xpertMessages) {
+  return xpertMessages.map(xpert => Array.isArray(xpert) ? xpert.split(';').find(m => m.startsWith('4')) : (xpert.startsWith('4') ? xpert : undefined)).flat().filter(a => a)
+}
+
+exports.parseEndTripMessage = parseEndTripMessage
+exports.getEndTripMessages = getEndTripMessages
+exports.parseCanDriverStyleMessage = parseCanDriverStyleMessage
+exports.getCanDriverStyleMessages = getCanDriverStyleMessages

package/.claude/worktrees/eager-stonebraker-c08ac7/src/word/index.js

@@ -0,0 +1,95 @@
+const {
+  Document, Paragraph, Packer, TableRow, TableCell, Table, WidthType, ImageRun, Header, TextRun, HeadingLevel,
+  AlignmentType, Footer
+} = require('docx')
+const { saveAs } = require('file-saver')
+const utils = require('../util/utils')
+const { getUserPartner } = require('fleetmap-partners')
+const colWidth = 2000
+
+function formatCellValue (value) {
+  return value.toLocaleDateString ? value.toLocaleDateString() : value + ''
+}
+
+exports.reportToWord = async (userData, dateRange, excel, title) => {
+  console.log('excel', excel)
+  const partnerData = getUserPartner(userData.user)
+
+  if (!excel.data.length && utils.isClientSide()) {
+    alert('Não há dados')
+    return
+  }
+  const logo = await utils.getLogo(userData.user)
+  console.log('logo', logo)
+  const table = new Table({
+    columnWidths: excel.headers.map(() => colWidth),
+    rows: [
+      new TableRow({
+        children: excel.headers.map(r => new TableCell({
+          children: [new Paragraph(r.label)],
+          width: {
+            size: colWidth,
+            type: WidthType.DXA
+          }
+        }))
+      }),
+      ...excel.data.filter(r => Object.keys(r).length).map(r => new TableRow({
+        children: Object.keys(r).map(k =>
+          new TableCell({
+            children: [new Paragraph(formatCellValue(r[k]))],
+            width: {
+              size: colWidth,
+              type: WidthType.DXA
+            }
+          }))
+      }))
+    ]
+  })
+  const doc = new Document({
+    sections: [{
+      headers: {
+        default: new Header({
+          children: [
+            new Paragraph({
+              children: [
+                new ImageRun({
+                  data: logo,
+                  transformation: {
+                    width: (partnerData.reports && partnerData.reports.logoWidth * 2) || 200,
+                    height: (partnerData.reports && partnerData.reports.logoHeight * 2) || 50
+                  }
+                })
+              ]
+            })
+          ]
+        })
+      },
+      footers: {
+        default: new Footer({
+          children: [
+            new Paragraph({
+              children: [
+                new TextRun('Relatório gerado a ' + new Date().toLocaleString())
+              ]
+            })
+          ]
+        })
+      },
+      properties: {},
+      children: [
+        new Paragraph({
+          children: [new TextRun(title)],
+          heading: HeadingLevel.HEADING_1,
+          alignment: AlignmentType.CENTER
+        }),
+        new Paragraph({}),
+        new Paragraph(new Date(dateRange[0]).toLocaleString() + ' - ' + new Date(dateRange[1]).toLocaleString()),
+        new Paragraph({}),
+        table
+      ]
+    }]
+  })
+  Packer.toBlob(doc).then(blob => {
+    saveAs(blob, 'report.docx')
+  })
+}