services/identification-service.js

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

import {
  fetchLeveesSynthesis as fetchLeveesSynthesisFromAPI,
  fetchLeveesDetails as fetchLeveesDetailsFromAPI,
} from '@/api/identification-api'
import { splitOperation } from '@/utils/promise.js'
import moment from 'moment'
import { formatDate } from '@/utils/dates.js'
import { getNestedValue } from '@/utils/object.js'

export {
  normalizeLeveeDetailsItem,
  normalizeLeveesSynthesisItem,
} from '@/api/identification-api'

export async function fetchLeveesDetails(
  date,
  vehicleId,
  circuitId,
  options = {}
) {
  return fetchLeveesDetailsFromAPI(date, vehicleId, circuitId, options)
}

/**
 * @TODO To be able to stop the search (i.g user stop an automatic search)
 *
 * @param {*} options.elementIds []
 * @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 fetchLeveesSynthesis(options = {}) {
  const getFetchOptions = () => ({
    elementType: options.elementType,
    filters: options.filters || {},
  })
  return await splitOperation({
    sequential: false,
    //Packages: Max 5 vehicles per request
    generateSubsets() {
      let subsets = []
      let single = {}
      options.elementIds.forEach((id) => {
        single.elementIds = single.elementIds || []
        single.elementIds.push(id)
        if (single.elementIds.length >= 1) {
          single.dates = options.dates
          subsets.push(single)
          single = {}
        }
      })
      if (single.elementIds) {
        single.dates = options.dates
        subsets.push(single)
      }
      return subsets
    },
    async handleSubset(subset) {
      //Split by date (API supports 1 date at time)
      await splitOperation({
        sequential: true,
        generateSubsets() {
          return subset.dates.map((date) => {
            return {
              ...subset,
              dates: [date],
            }
          })
        },
        async handleSubset(subset) {
          return await fetchLeveesSynthesisFromAPI(
            subset.elementIds.join(','),
            subset.dates,
            getFetchOptions()
          )
        },
        withSubsetResult: (results) => {
          options.handleResults(results)
        },
      })
    },
  })
}

export function createContainerHelpersMixin() {
  return {
    data() {
      return {
        //Necessary to compute table header text
        dateFromFormatted: '',
        dateToFormatted: '',
        //detailedItemsBy (external)
        //detailedItemsByDateValue (external)
        //detailedItemsByVehicleIdValue (external)
      }
    },
    computed: {
      tableHeaderText() {
        if (this.detailedItemsBy === 'total') {
          return this.$t('identification.table.header_text.total', {
            fromDate: this.dateFromFormatted,
            toDate: this.dateToFormatted,
          })
          //return `Résultats du ${this.dateFromFormatted} au ${this.dateToFormatted}`;
        }
        if (this.detailedItemsBy === 'date') {
          return this.$t('identification.table.header_text.date', {
            date: this.detailedItemsByDateValue,
          })
          //return `Résultats du ${this.detailedItemsByDateValue}`;
        }
        if (this.detailedItemsBy === 'vehicle') {
          return this.$t('identification.table.header_text.vehicle', {
            vehicleName: this.getVehicleName(
              this.detailedItemsByVehicleIdValue
            ),
            date: this.detailedItemsByDateValue,
          })
          //return `Résultats du véhicule ${this.getVehicleName(this.detailedItemsByVehicleIdValue)} du ${this.detailedItemsByDateValue}`;
        }
        if (this.detailedItemsBy === 'circuit') {
          return this.$t('identification.table.header_text.circuit', {
            vehicleName: this.getVehicleName(
              this.detailedItemsByVehicleIdValue
            ),
            circuitName: this.getCircuitName(
              this.detailedItemsByVehicleIdValue,
              this.detailedItemsByCircuitIdValue
            ),
            date: this.detailedItemsByDateValue,
          })
          //return `Résultats du véhicule ${this.getVehicleName(this.detailedItemsByVehicleIdValue)}, circuit ${this.getCircuitName(this.detailedItemsByVehicleIdValue,this.detailedItemsByCircuitIdValue)} du ${this.detailedItemsByDateValue}`;
        }
        return ''
      },
    },
    methods: {
      /**
       * Uses this.items (external)
       */
      getVehicleName(id) {
        return (
          ((this.items || []).find((i) => i.vehicleId == id) || {})
            .vehicleName || ''
        )
      },
      getCircuitName(vehicleId, circuitId) {
        let synthesisVehicleItem =
          (this.items || []).find((i) => i.vehicleId == vehicleId) || {}
        let circuitSynthesis =
          (
            synthesisVehicleItem.circuits ||
            synthesisVehicleItem.synthesis ||
            []
          ).find((s) => s.circuitId == circuitId) || {}
        return circuitSynthesis.circuitName || ''
      },
    },
  }
}

/**
 * Used by Location - Identification (Popup details, triggered from table)
 * Used by Identification (Popup details, triggered from table)
 * @param {Object} data API Response
 * @returns
 */
export function normalizeIdentificationBacDetailsResponse(data) {
  if (!data || (data instanceof Array && data.length === 0)) {
    return {}
  }

  return {
    id: data['levee_id'],
    startDate: data['dateheure'],
    prohibition: formatProhibition(data),
    behavior: formatBehavior(data),
    export: formatExport(data),
  }

  function formatObjectValue(item, key, defaultValue, options = {}) {
    return getNestedValue(item, key, defaultValue, options)
  }

  function formatProhibition(item) {
    let prohibition = {}

    if (item && item.hasOwnProperty('blacklist')) {
      prohibition = {
        id: formatObjectValue(item['blacklist'], 'blacklist_id'),
        isBlacklisted: formatObjectValue(item, 'blackliste'),
        filename: formatObjectValue(item['blacklist'], 'fichier'),
        versionDate: formatObjectValue(item['blacklist'], 'dateheure_version'),
      }

      if (prohibition.isBlacklisted) {
        prohibition['issue'] = formatObjectValue(item['blacklist'], 'motif')
      }
    }

    return prohibition
  }

  function formatBehavior(item) {
    let behavior = {}

    if (item && item.hasOwnProperty('comportement_lc')) {
      behavior = {
        name: formatObjectValue(item['comportement_lc'], 'nom'),
        endValidity: formatObjectValue(item['comportement_lc'], 'fin_validite'),
        blockedAccess: formatObjectValue(
          item['comportement_lc'],
          'acces_blocage_lc'
        ),
        driverChoice: formatObjectValue(
          item['comportement_lc'],
          'choix_chauffeur_blocage_lc',
          ''
        ),
      }
    }

    return behavior
  }

  function formatExport(item) {
    let exportData = {}

    if (
      item &&
      item.hasOwnProperty('levees_exports') &&
      item.levees_exports instanceof Array &&
      item.levees_exports.length >= 1
    ) {
      let lastFile = item.levees_exports[0]
      item.levees_exports.forEach((currItem) => {
        if (
          moment(currItem.export_dateheure).isAfter(
            moment(lastFile.export_dateheure)
          )
        ) {
          lastFile = currItem
        }
      })

      exportData = {
        lastExportDate: Vue.$date.formatDatetime(lastFile.export_dateheure),
        fileExport: lastFile.export_fichier,
      }
    }

    return exportData
  }
}