services/alert-service.js

/**
 * @namespace Services
 * @category Services
 * @module alert-service
 * */

import i18n from '@/i18n'
import {
  fetchAlerts,
  fetchAlertTypes as fetchAlertTypesFromAPI,
  acknowledgeAlert as acknowledgeAlertFromAPI,
} from '@/api/alerts-api.js'
import { splitOperation } from '@/utils/promise.js'

export function getSearchSelectionLimit() {
  return (
    parseFloat(process.env.VUE_APP_ALERT_MODULE_SEARCH_SELECTION_LIMIT) || 100
  )
}

export async function fetchAlertTypes() {
  return fetchAlertTypesFromAPI()
}

export async function acknowledgeAlert(messageId) {
  return acknowledgeAlertFromAPI(messageId)
}

export function shareAlertByEmail(alertItem) {
  const mail = document.createElement('a')
  const title = `${alertItem.title} (${alertItem.type})`
  const formattedBody = `
    ${alertItem.message}
    `
  mail.href = `mailto:?subject=${title}&body=${encodeURIComponent(
    formattedBody
  )}`
  mail.click()
}

export function computeStatusLabel(isAck = false) {
  return isAck
    ? i18n.t('alerts.item.status_ack')
    : i18n.t('alerts.item.status_noack')
}

/**
 * @TODO To be able to stop the search (i.g user stop an automatic search)
 *
 * @param {*} options.vehicleIds []
 * @param {*} options.dateFrom Date
 * @param {*} options.dateTo Date
 * @param {*} options.types [] i.g [48,32]
 * @param {*} options.status [] i.g [0,1]
 * @param {*} options.handleResults (results)=>({}) Each time results are available
 */
export async function fetchAlertsProgressive(options = {}) {
  const isProgresiveSearch = true
  const getFetchOptions = () => ({
    types: options.types,
    status: options.status,
  })
  if (!isProgresiveSearch) {
    options.handleResults(
      await fetchAlerts(
        this.selection.selectedVehiclesIds.join(','),
        options.datefrom,
        options.dateTo,
        getFetchOptions()
      )
    )
  } else {
    return await splitOperation({
      sequential: false,
      //Packages: Max 5 vehicles per request
      generateSubsets() {
        let subsets = []
        let single = {}
        options.vehicleIds.forEach((id) => {
          single.vehicleIds = single.vehicleIds || []
          single.vehicleIds.push(id)
          if (single.vehicleIds.length >= 5) {
            single.dateFrom = options.dateFrom
            single.dateTo = options.dateTo
            subsets.push(single)
            single = {}
          }
        })
        if (single.vehicleIds) {
          single.dateFrom = options.dateFrom
          single.dateTo = options.dateTo
          subsets.push(single)
        }
        return subsets
      },
      async handleSubset(subset) {
        return await fetchAlerts(
          subset.vehicleIds.join(','),
          subset.dateFrom,
          subset.dateTo,
          getFetchOptions()
        )
      },
      withSubsetResult: (results) => {
        options.handleResults(results)
      },
    })
  }
}