@qite/tide-booking-component 1.1.3 → 1.2.0

package/src/booking-wizard/features/flight-options/flight-utils.ts

@@ -0,0 +1,401 @@
+import { BookingPackageFlight, BookingPackageFlightMetaDataLine } from "@qite/tide-client/build/types";
+import { differenceInMinutes, isEqual, parseISO } from "date-fns";
+import { FlightDirectionFilter, FlightFilterOption, FlightFilterOptions, GroupedFlightDetails, GroupedFlights } from "../../types";
+
+/*interface FlightGroup {
+  code: string;
+  startDate: Date,
+  endDate: Date;
+  options: BookingPackageFlight[];
+}*/
+
+export const buildGroupedFlights = (outwardFlights: BookingPackageFlight[] | undefined, returnFlights: BookingPackageFlight[] | undefined) => {
+  if (!outwardFlights || !returnFlights) return [] as GroupedFlights[];
+
+  // let outwardGroups = groupFlights(outwardFlights);
+  // let returnGroups = groupFlights(returnFlights);
+
+  const pairs: { outward: BookingPackageFlight, return: BookingPackageFlight }[] = [];
+  outwardFlights.forEach(outwardFlight => {
+    if (outwardFlight.externalGuid) {
+      const returnFlight = returnFlights.find(x => x.externalGuid === outwardFlight.externalGuid)!;
+      pairs.push({ outward: outwardFlight, return: returnFlight });
+    } else {
+      const outwardCode = outwardFlight.code.substring(0, 7);
+      const returnCode = outwardCode.split(" ").reduce((a, b) => `${b} ${a}`);
+
+      returnFlights.filter(x => x.code.startsWith(returnCode)).forEach(returnFlight => {
+        pairs.push({ outward: outwardFlight, return: returnFlight });
+      });
+    }
+  });
+
+  const results = pairs.map(x => {
+    const outwardFlightDetails = getFlightDetails(x.outward);
+    const returnFlightDetails = getFlightDetails(x.return);
+
+    return {
+      isSelected: x.outward.isSelected && x.return.isSelected,
+      price: x.outward.price + x.return.price,
+      outward: outwardFlightDetails,
+      return: returnFlightDetails,
+      selectedOutward: x.outward,
+      selectedReturn: x.return
+    } as GroupedFlights;
+  });
+
+  return results;
+}
+
+export const buildFilterOptions = (
+  outwardFlights: BookingPackageFlight[] | undefined,
+  returnFlights: BookingPackageFlight[] | undefined,
+  translations: any
+) => {
+  if (!outwardFlights || !returnFlights) return undefined;
+
+  const airports: FlightFilterOption[] = [];
+  const airlines: FlightFilterOption[] = [];
+  const numberOfStops: FlightFilterOption[] = [];
+  const outwardDeparturePeriods: FlightFilterOption[] = [];
+  const returnDeparturePeriods: FlightFilterOption[] = [];
+
+  let lowestDepartureTravelDuration = 9999;
+  let highestDepartureTravelDuration = 0
+  let lowestDepartureChangeDuration = 9999;
+  let highestDepartureChangeDuration = 0;
+
+  outwardFlights.forEach(flight => {
+    const airlineCode = flight.code.split('/')[1];
+
+    if (flight.flightMetaData.flightLines?.length) {
+      const firstLine = flight.flightMetaData.flightLines[0];
+
+      if (!airports.some(x => x.value === firstLine.departureAirport)) {
+        airports.push({
+          value: firstLine?.departureAirport,
+          label: firstLine.departureAirportDescription,
+          count: 0,
+          isSelected: false
+        });
+      }
+    }
+
+    if (!airlines.some(x => x.value === airlineCode)) {
+      airlines.push({
+        value: airlineCode,
+        label: flight.airlineDescription,
+        count: 0,
+        isSelected: false
+      });
+    }
+
+    const stopCount = flight.flightMetaData.flightLines.length - 1;
+    if (!numberOfStops.some(x => x.value === (stopCount + ''))) {
+      numberOfStops.push({
+        value: (stopCount + ''),
+        label: stopCount === 0
+          ? translations.FLIGHTS_FORM.DIRECT_FLIGHT
+          : stopCount == 1
+            ? `${stopCount} ${translations.FLIGHTS_FORM.STOP}`
+            : `${stopCount} ${translations.FLIGHTS_FORM.STOPS}`,
+        count: 0,
+        isSelected: false
+      });
+    }
+
+    const departureTime = flight.flightMetaData.flightLines[0].departureTime;
+    const timeBracket = determineTimeBracket(departureTime);
+    if (!outwardDeparturePeriods.some(x => x.value === timeBracket)) {
+      outwardDeparturePeriods.push({
+        value: timeBracket,
+        label: getBracketTranslation(timeBracket, translations),
+        count: 0,
+        isSelected: false
+      });
+    }
+
+    const travelDurationInMinutes = minutesFromTicks(flight.flightMetaData.durationInTicks);
+    if (travelDurationInMinutes > highestDepartureTravelDuration) highestDepartureTravelDuration = travelDurationInMinutes;
+    if (travelDurationInMinutes < lowestDepartureTravelDuration) lowestDepartureTravelDuration = travelDurationInMinutes;
+
+    const changeDurationInMinutes = getTotalChangeDuration(flight);
+    if (changeDurationInMinutes > highestDepartureChangeDuration) highestDepartureChangeDuration = changeDurationInMinutes;
+    if (changeDurationInMinutes < lowestDepartureChangeDuration) lowestDepartureChangeDuration = changeDurationInMinutes;
+  });
+
+  let lowestReturnTravelDuration = 9999;
+  let highestReturnTravelDuration = 0
+  let lowestReturnChangeDuration = 9999;
+  let highestReturnChangeDuration = 0;
+
+  returnFlights.forEach(flight => {
+    const durationInMinutes = minutesFromTicks(flight.flightMetaData.durationInTicks);
+    if (durationInMinutes > highestReturnTravelDuration) highestReturnTravelDuration = durationInMinutes;
+    if (durationInMinutes < lowestReturnTravelDuration) lowestReturnTravelDuration = durationInMinutes;
+
+    const changeDurationInMinutes = getTotalChangeDuration(flight);
+    if (changeDurationInMinutes > highestReturnChangeDuration) highestReturnChangeDuration = changeDurationInMinutes;
+    if (changeDurationInMinutes < lowestReturnChangeDuration) lowestReturnChangeDuration = changeDurationInMinutes;
+
+    const departureTime = flight.flightMetaData.flightLines[0].departureTime;
+    const timeBracket = determineTimeBracket(departureTime);
+    if (!returnDeparturePeriods.some(x => x.value === timeBracket)) {
+      returnDeparturePeriods.push({
+        value: timeBracket,
+        label: getBracketTranslation(timeBracket, translations),
+        count: 0,
+        isSelected: false
+      });
+    }
+  })
+
+  return {
+    airports: airports,
+    airlines: airlines,
+    numberOfStops: numberOfStops,
+    outward: {
+      departurePeriod: outwardDeparturePeriods,
+      travelDuration: {
+        min: lowestDepartureTravelDuration,
+        max: highestDepartureTravelDuration,
+        selectedMin: lowestDepartureTravelDuration,
+        selectedMax: highestDepartureTravelDuration
+      },
+      changeDuration: {
+        min: lowestDepartureChangeDuration,
+        max: highestDepartureChangeDuration,
+        selectedMin: lowestDepartureChangeDuration,
+        selectedMax: highestDepartureChangeDuration
+      }
+    },
+    return: {
+      departurePeriod: returnDeparturePeriods,
+      travelDuration: {
+        min: lowestReturnTravelDuration,
+        max: highestReturnTravelDuration,
+        selectedMin: lowestReturnTravelDuration,
+        selectedMax: highestReturnTravelDuration
+      },
+      changeDuration: {
+        min: lowestReturnChangeDuration,
+        max: highestReturnChangeDuration,
+        selectedMin: lowestReturnChangeDuration,
+        selectedMax: highestReturnChangeDuration
+      }
+    }
+  } as FlightFilterOptions;
+}
+
+export const filterGroupedFlights = (groups: GroupedFlights[], filterOptions: FlightFilterOptions | undefined) => {
+  if (!groups.length || !filterOptions) return [];
+
+  let filteredGroups = groups;
+  if (filterOptions.airlines.some(x => x.isSelected)) {
+    const selectedAirlineCodes = filterOptions.airlines.filter(x => x.isSelected);
+    filteredGroups = filteredGroups.filter(x => selectedAirlineCodes.some(y => y.value === x.outward.airlineCode));
+  }
+
+  if (filterOptions.airports.some(x => x.isSelected)) {
+    const selectedAirlineCodes = filterOptions.airports.filter(x => x.isSelected);
+    filteredGroups = filteredGroups.filter(x => selectedAirlineCodes.some(y => y.value === x.outward.departureAirportCode));
+  }
+
+  if (filterOptions.numberOfStops.some(x => x.isSelected)) {
+    const selectedNumberOfStops = filterOptions.airlines.filter(x => x.isSelected);
+    filteredGroups = filteredGroups.filter(x => selectedNumberOfStops.some(y => parseInt(y.value) === (x.outward.flightLines.length - 1)));
+  }
+
+  filteredGroups = filterGroupedFlightByDirection(filteredGroups, true, filterOptions.outward);
+  filteredGroups = filterGroupedFlightByDirection(filteredGroups, false, filterOptions.return);
+
+  return filteredGroups;
+}
+
+const filterGroupedFlightByDirection = (groups: GroupedFlights[], isOutward: boolean, directionFilter: FlightDirectionFilter) => {
+  let filteredGroups = groups;
+
+  if (directionFilter.departurePeriod.some(x => x.isSelected)) {
+    const selectedDeparturePeriods = directionFilter.departurePeriod.filter(x => x.isSelected);
+    filteredGroups = filteredGroups.filter(x => selectedDeparturePeriods.some(y => y.value === determineTimeBracket((isOutward ? x.outward : x.return).departureTime)));
+  }
+
+  filteredGroups = filteredGroups.filter(x => directionFilter.travelDuration.selectedMin <= (isOutward ? x.outward : x.return).travelDurationMinutes && (isOutward ? x.outward : x.return).travelDurationMinutes <= directionFilter.travelDuration.selectedMax);
+  return filteredGroups.filter(x => directionFilter.changeDuration.selectedMin <= (isOutward ? x.outward : x.return).changeDurationMinutes && (isOutward ? x.outward : x.return).changeDurationMinutes <= directionFilter.changeDuration.selectedMax);
+}
+
+export const formatMinutes = (minutes: number) => {
+  var hh = Math.floor(minutes / 60);
+  var mm = Math.floor(minutes % 60);
+  return pad(hh, 2) + ":" + pad(mm, 2);
+}
+
+const getFlightDetails = (flight: BookingPackageFlight) => {
+  const firstLine = flight.flightMetaData.flightLines[0];
+  const lastLine = flight.flightMetaData.flightLines[flight.flightMetaData.flightLines.length - 1];
+
+  const airlineCode = flight.code.split('/')[1];
+  const waitDurations = getWaitDurations(flight.flightMetaData.flightLines);
+
+  return {
+    airline: flight.airlineDescription,
+    airlineCode: airlineCode,
+    departureDate: firstLine.departureDate,
+    departureTime: firstLine.departureTime,
+    departureAirportCode: firstLine.departureAirport,
+    departureAirport: firstLine.departureAirportDescription,
+    arrivalDate: lastLine.arrivalDate,
+    arrivalTime: lastLine.arrivalTime,
+    arrivalAirport: lastLine.arrivalAirportDescription,
+    travelDuration: formatDuration(flight.flightMetaData.durationInTicks),
+    travelDurationMinutes: minutesFromTicks(flight.flightMetaData.durationInTicks),
+    changeDurationMinutes: getTotalChangeDuration(flight),
+    numberOfStops: flight.flightMetaData.flightLines.length - 1,
+    isNextDay: isNextDay(firstLine.departureDate, lastLine.arrivalDate),
+    travelClass: firstLine.travelClass,
+    flightLines: flight.flightMetaData.flightLines.map((x, i) => ({
+      airline: x.operatingAirlineDescription,
+      departureDate: x.departureDate,
+      departureTime: x.departureTime,
+      departureAirport: x.departureAirportDescription,
+      arrivalDate: x.arrivalDate,
+      arrivalTime: x.arrivalTime,
+      arrivalAirport: x.arrivalAirportDescription,
+      number: `${x.airlineCode} ${x.number}`,
+      travelDuration: formatDuration(x.durationInTicks),
+      waitDuration: waitDurations.length - 1 <= i ? waitDurations[i] : undefined,
+    }))
+  } as GroupedFlightDetails;
+}
+
+const isNextDay = (startDateString: string, endDateString: string) => {
+  const startDate = parseISO(startDateString);
+  const endDate = parseISO(endDateString);
+
+  return !isEqual(startDate, endDate);
+}
+
+const getWaitDurations = (lines: BookingPackageFlightMetaDataLine[]) => {
+  if (lines.length <= 1) return [];
+  let arrivalDate = lines[0].arrivalDate;
+  let arrivalTime = lines[0].arrivalTime;
+
+  const waitDurations: string[] = [];
+  for (var i = 1; i < lines.length; i++) {
+    const line = lines[i];
+
+    const waitDuration = getWaitDuration(arrivalDate, arrivalTime, line.departureDate, line.departureTime);
+    waitDurations.push(waitDuration);
+
+    arrivalDate = line.arrivalDate;
+    arrivalTime = line.arrivalTime;
+  }
+
+  return waitDurations;
+}
+
+const getWaitDuration = (arrivalDateString: string, arrivalTime: string, departureDateString: string, departureTime: string) => {
+  const minutes = getWaitDurationInMinutes(arrivalDateString, arrivalTime, departureDateString, departureTime);
+
+  var hh = Math.floor(minutes / 60);
+  var mm = Math.floor(minutes % 60);
+  return pad(hh, 2) + ":" + pad(mm, 2);
+}
+
+const getWaitDurationInMinutes = (arrivalDateString: string, arrivalTime: string, departureDateString: string, departureTime: string) => {
+  const arrivalDate = parseISO(arrivalDateString);
+  const arrivalTimeParts = arrivalTime.split(':');
+
+  arrivalDate.setHours(parseInt(arrivalTimeParts[0]));
+  arrivalDate.setMinutes(parseInt(arrivalTimeParts[1]));
+
+  const departureDate = parseISO(departureDateString);
+  const departureTimeParts = departureTime.split(':');
+
+  departureDate.setHours(parseInt(departureTimeParts[0]));
+  departureDate.setMinutes(parseInt(departureTimeParts[1]));
+
+  return differenceInMinutes(departureDate, arrivalDate);
+}
+
+/*const groupFlights = (flights: BookingPackageFlight[]) => {
+  let flightsPool = [...flights];
+  let groups = [] as FlightGroup[];
+  for (var i = 0; i < flightsPool.length; i++) {
+    const flight = flightsPool[i];
+
+    const relatedFlights = flightsPool.filter(x => x != flight
+      && x.code === flight.code
+      && isDateEqual(x.startDateTime, flight.startDateTime)
+      && isDateEqual(x.endDateTime, flight.endDateTime)
+    );
+
+    flightsPool = flightsPool.filter(x => x != flight
+      && relatedFlights.some(y => y != x));
+
+    groups.push({
+      code: flight.code,
+      startDate: parseISO(flight.startDateTime),
+      endDate: parseISO(flight.endDateTime),
+      options: [flight, ...relatedFlights]
+    });
+  }
+}
+
+const isDateEqual = (first: string, second: string) => {
+  const firstDate = parseISO(first);
+  const secondDate = parseISO(second);
+
+  return isEqual(firstDate, secondDate);
+}*/
+
+const minutesFromTicks = (ticks: number) => {
+  const totalSeconds = ticks / 10_000_000;
+  return Math.floor(totalSeconds / 60);
+}
+
+const formatDuration = (ticks: number) => {
+  if (!ticks) return '';
+
+  const totalSeconds = ticks / 10_000_000;
+  var hh = Math.floor(totalSeconds / 3600);
+  var mm = Math.floor((totalSeconds % 3600) / 60);
+  return pad(hh, 2) + ":" + pad(mm, 2);
+}
+
+const pad = (input: number, width: number) => {
+  const n = input + '';
+  return n.length >= width ? n : new Array(width - n.length + 1).join('0') + n;
+}
+
+const determineTimeBracket = (input: string) => {
+  const time = parseInt(input.replace(':', ''));
+  if (time <= 500) return '0000-0500';
+  if (time > 500 && time <= 1200) return '0500-1200';
+  if (time > 1200 && time <= 1800) return '1201-1800';
+  return '1800-2400';
+}
+
+const getBracketTranslation = (input: string, translations: any) => {
+  if (input === '0000-0500') return translations.FLIGHTS_FORM.NIGHT_DEPARTURE;
+  if (input === '0500-1200') return translations.FLIGHTS_FORM.MORNING_DEPARTURE;
+  if (input === '1200-1800') return translations.FLIGHTS_FORM.AFTERNOON_DEPARTURE;
+  return translations.FLIGHTS_FORM.EVENING_DEPARTURE;
+}
+
+const getTotalChangeDuration = (flight: BookingPackageFlight) => {
+  const lines = flight.flightMetaData.flightLines;
+
+  if (lines.length <= 1) return 0;
+  let arrivalDate = lines[0].arrivalDate;
+  let arrivalTime = lines[0].arrivalTime;
+
+  let waitDuration = 0;
+  for (var i = 1; i < lines.length; i++) {
+    const line = lines[i];
+
+    waitDuration += getWaitDurationInMinutes(arrivalDate, arrivalTime, line.departureDate, line.departureTime);
+  }
+
+  return waitDuration;
+}