services/circuit-reference-service.js

import APIUrls from '@/config/simpliciti-apis.js'
import api, { getAPIV3Pooling } from '@/api'
import normalizeCircuitVersion from '@/services/entities/circuit-reference-item.js'
import normalizeCircuitVersionSection from '@/services/entities/circuit-version-section.js'
import normalizeCircuitStepLastExecutionItem from '@/services/entities/last-circuit-execution-step-item.js'

export async function fetchCircuitActivities(circuitIds) {
  return await getAPIV3Pooling({
    uri: `${APIUrls.APIV3_GEORED_ROUND_ACTIVITIES}?page=1&itemsPerPage=500`,
    payload: {
      roundId: circuitIds,
    },
    transform: normalizeCircuitActivityItem,
  })
}

/**
 *
 * @param {*} circuitId
 * @param {*} versionId
 * @param {Array} circuitActivities Circuit activities: Used during normalization
 * @returns
 */
export async function fetchCircuitVersionSections(
  circuitId,
  versionId,
  circuitActivities = []
) {
  if (!circuitId && !versionId) {
    throw new Error(
      'fetchCircuitVersionSections requires circuitId and versionId'
    )
  }

  let fetchPromise = getAPIV3Pooling({
    uri: `${APIUrls.APIV3_GEORED_ROUND_VERSIONS_SECTIONS}?page=1&itemsPerPage=500&round.id=${circuitId}&version=${versionId}`,
    transform(response) {
      return {
        sections: response.sections
          .map((v) =>
            normalizeCircuitVersionSection(v, {
              circuitActivities,
            })
          )
          .sort((a, b) => {
            return a.number > b.number ? -1 : 1
          }),
      }
    },
    /* payload: {
      properties: ['sections'], //Unsupported by API for now
      'properties[sections]': [
        'id',
        'activityId',
        'linestring',
        'maneuver',
        'startStreet',
        'startCity',
        'activityName',
        'kmTheoretical',
        'kmCalculation',
        'alert',
      ],
    },*/
  })

  let fetchResponse = (await fetchPromise)[0] || {}

  return {
    circuitId,
    versionId,
    visible: true,
    sections: fetchResponse.sections || [],
  }
}

export async function fetchCircuitVersionDetailsByCircuitId(circuitIds) {
  return await getAPIV3Pooling({
    uri: `${APIUrls.APIV3_GEORED_ROUND_VERSIONS}?page=1&itemsPerPage=500`,
    payload: {
      'round.id': circuitIds,
    },
    transform: normalizeCircuitVersion,
  })
}

/**
 * @todo unused
 * @param {*} circuitVersionsIds
 * @returns
 
export async function fetchCircuitVersionsDetailsByIds(
  circuitVersionsIds = []
) {
  if (circuitVersionsIds.length === 0) {
    console.warn('expect circuitVersionsIds length greather than zero')
    return null
  }
  return await Promise.all(
    circuitVersionsIds.map((id) => {
      return (async () => {
        let res = await api.v3.get(
          `${APIUrls.APIV3_GEORED_ROUND_VERSIONS}/${id}`
        )
        return normalizeCircuitVersion(res.data)
      })()
    })
  )
}
*/

/**
 * @warn unused
 
export async function fetchCircuitVersions() {
  return await getAPIV3Pooling({
    uri: `${APIUrls.APIV3_GEORED_ROUND_VERSIONS}?page=1&itemsPerPage=500`,
    transform: normalizeCircuitVersion,
    payload: {
      properties: ['id', 'versionId', 'round'],
      'properties[round]': ['id', 'shortName'],
    },
    forcePayload: true,
  })
}
*/

function normalizeCircuitActivityItem(rawItem) {
  return {
    id: rawItem.id,
    code: rawItem.activityId, //This should be renamed as activityCode in the API (To cleary distinguish between auto-increment id and unique identifier)
    name: rawItem.name,
    color: rawItem.hexaColor || 'black',
  }
}

/**
 * Retrieve the last five circuit execution steps given a circuit, version and step id
 * @warn Attention to pagination!
 * @param {*} circuitId
 * @param {*} versionId
 * @param {*} sectionId
 */
export async function fetchCircuitVersionStepLastExecutions(
  circuitId,
  versionId,
  sectionId,
  options = {}
) {
  let res =
    options.mockResponse ||
    (
      await api.v3.get(
        APIUrls.APIV3_GEORED_ROUND_SERVICE_LAST_ROUND_EXECUTION_SECTIONS,
        {
          roundId: circuitId,
          version: versionId,
          sectionId: sectionId,
          nb: 5,
        }
      )
    ).data
  return res.map(normalizeCircuitStepLastExecutionItem)
}

export async function fetchGPSManeuvers() {
  const maneuversTable = {
    go_straight: 'straight',
    half_turn: 'u_turn_left',
    turn_left: 'left',
    turn_right: 'right',
  }
  return await getAPIV3Pooling({
    uri: `${APIUrls.APIV3_GEORED_ROUND_MANEUVERS}?page=1&itemsPerPage=500`,
    transform(rawItem) {
      return {
        id: rawItem.id,
        code: rawItem.code,
        label: rawItem.label,
        svgName: (
          maneuversTable[rawItem.label.toLowerCase()] || rawItem.label
        ).toUpperCase(),
      }
    },
  })
}