store/location_module/helpers.js

import moment from 'moment'
import createLocationMainSearchItemEntity from '@/services/entities/location-main-search-item.js'
import { getNestedValue } from '@/utils/object.js'
const R = require('ramda')

/**
 * Parses APIV2 response (by_vehicule_dates) into flat array.
 *
 * @example
 *  Input: apiv2_response.data.items
 *  Output: Array of histories (vehicle)
 * @param {Object} responseData
 * @returns
 */
export function getItemsFromHistoryVehicleDriverAPIV2Response(responseData) {
  return Object.keys(responseData).reduce((array, dateString) => {
    array = array.concat(responseData[dateString] || [])
    return array
  }, [])
}

/**
 * Parses APIV2 response (by_chauffeur_dates) into flat array.
 *
 * @example
 *  Input: apiv2_response.data.items
 *  Output: Array of histories (driver)
 * @param {Object} responseData
 * @returns
 */
export function getItemsFromHistoryDriverAPIV2Response(responseData) {
  let result = []
  Object.keys(responseData).forEach((dateString) => {
    Object.keys(responseData[dateString]).forEach((driverId) => {
      const driver = responseData[dateString][driverId]
      driver.historique.forEach((historyDetails) => {
        result.push({
          driverName: driver.nom_chauffeur,
          driverId,
          ...historyDetails,
        })
      })
    })
  })
  return result
}

/**
 * Parses APIV2 response (by_circuit_dates) into flat array.
 *
 * Note: Response can contain multiple "historique" (circuit executions) for a single date/circuit_id
 *
 * @example
 *  Input: apiv2_response.data.items
 *  Output: Array of histories (circuit)
 * @param {Object} responseData
 * @returns
 */
export function getItemsFromHistoryCircuitAPIV2Response(responseData) {
  //Reduce executions from different dates into single array
  return Object.keys(responseData).reduce((array, dateString) => {
    let circuitExecutions = []

    //Loop circuits
    Object.keys(responseData[dateString]).forEach((circuitId) => {
      let historiesArray = responseData[dateString][circuitId].historique || {}
      //Loop executions
      Object.keys(historiesArray).forEach((executionId) => {
        circuitExecutions.push({
          //Headers
          ...R.omit(['historique'], responseData[dateString][circuitId]),
          //Execution data
          ...(historiesArray[executionId] || {}),
        })
      })
    })

    array = array.concat(circuitExecutions)
    return array
  }, [])
}

/**
 *
 * Parses Location module item from main search
 * Item comes from API (temp reel / historique)
 *
 * @TODO Refactor/Move into services/entities/location-main-search-entity
 *
 * @param {*} item
 * @param {*} options
 * @param {*} rootGetters
 * @returns
 */
export function parseLocationItem(item, options, rootGetters) {
  const vehicleId = getNestedValue(item, ['vehicule.id', 'vehicule_id'])
  const vehicleCategory = getVehicleCategoryObject(vehicleId, rootGetters)
  return createLocationMainSearchItemEntity(item, {
    ...options,
    vehicleCategory,
  })
}

/**
 * @TODO Refactor/Improve
 *
 * Get vehicle category object from search module loaded dataset
 *
 * @param {*} vehicleId
 * @param {*} rootGetters
 * @returns
 */
function getVehicleCategoryObject(vehicleId, rootGetters) {
  const vehicle = rootGetters['search_module/getVehicles'].find(
    (v) => v.id.toString() == vehicleId.toString()
  )

  if (!vehicle) {
    //Vue.$log.warn("Can't find vehicle object", vehicleId);
    return null
  }

  let categoryObject = rootGetters['search_module/getVehicleCategories'].find(
    (c) => {
      return c.id.toString() == vehicle.categoryId
    }
  )

  if (!categoryObject) {
    return null
  }

  return {
    ...categoryObject,
    parent: categoryObject.parent || categoryObject.parent_id,
  }
}

/**
 *
 * Helper to compute querystring date parameters (v2 historique APIs) from Array of date ranges.
 *
 * @param {[]} selectedDateRanges Array of date ranges from search_module
 * @param isFirstAndLastDay, Boolean that indicate if the search is for the first and last day
 * @returns
 */
export function getHistoryAPIQueryStringDatePart(
  selectedDateRanges = [],
  isFirstAndLastDay
) {
  let querystring = ''
  let dates = selectedDateRanges.map((range) => {
    return range[0]
  })
  if (dates.length > 0) {
    let timeFrom = moment(
      selectedDateRanges[selectedDateRanges.length - 1][0]
    ).format('HH:mm')
    let timeTo = moment(
      selectedDateRanges[selectedDateRanges.length - 1][1]
    ).format('HH:mm')
    dates = dates.map((d) => moment(d).format(`YYYY-MM-DD`))
    dates = dates.filter((d, i) => dates.indexOf(d) === i) //Remove duplicates
    querystring += `&dates=${dates.join(',')}`
    querystring += `&heure_debut=${window.encodeURI(timeFrom)}`
    querystring += `&heure_fin=${window.encodeURI(timeTo)}`
    querystring += `&premier_dernier_jour=${isFirstAndLastDay}`
  }
  return querystring
}