From 18b966bfa3eb9cc128b5e498bd27c9453a4474a8 Mon Sep 17 00:00:00 2001
From: Felix <23635466+its-felix@users.noreply.github.com>
Date: Sat, 14 Dec 2024 02:15:08 +0100
Subject: [PATCH] update m&m quick search for the new v3 api

---
 ui/src/lib/milesandmore/client.ts      |  74 +++---
 ui/src/pages/tools/mm-quick-search.tsx | 334 +++++++++++++++++++------
 2 files changed, 295 insertions(+), 113 deletions(-)

diff --git a/ui/src/lib/milesandmore/client.ts b/ui/src/lib/milesandmore/client.ts
index 822b59c..b967b03 100644
--- a/ui/src/lib/milesandmore/client.ts
+++ b/ui/src/lib/milesandmore/client.ts
@@ -9,11 +9,7 @@ export enum FareFamily {
 }
 
 export enum CorporateCode {
-  LH = '223293',
-}
-
-export enum CompanyCode {
-  LH = 'LH',
+  LH = 223293,
 }
 
 export enum PassengerCode {
@@ -29,47 +25,32 @@ export enum Mode {
   BEST_BY_DAY = 'bestByDay',
 }
 
-export interface FrequentFlyer {
-  companyCode: CompanyCode;
-  priorityCode: number;
-}
-
 export interface Itinerary {
-  departureDateTime?: string;
+  departureDateTime: string;
   originLocationCode: string;
   destinationLocationCode: string;
 }
 
-export interface SearchPreferences {
-  mode: Mode;
-  showMilesPrice: boolean;
-}
-
-export interface Traveler {
-  passengerTypeCode: PassengerCode;
-}
-
 export interface TripDetails {
-  tripDuration: number;
+  tripDuration?: number;
   rangeOfDeparture: number;
 }
 
 export interface BestByRequest {
   commercialFareFamilies: ReadonlyArray<FareFamily>;
   corporateCodes: ReadonlyArray<CorporateCode>;
+  countryOfCommencement: 'DE',
   currencyCode: CurrencyCode;
-  frequentFlyer: FrequentFlyer;
   itineraries: ReadonlyArray<Itinerary>;
-  searchPreferences: SearchPreferences;
-  travelers: ReadonlyArray<Traveler>;
-  tripDetails?: TripDetails;
+  tripDetails: TripDetails;
 }
 
 export interface MMRequest {
   mode: Mode;
   fareFamily: FareFamily;
   travelers: ReadonlyArray<PassengerCode>;
-  departureDateTime: DateTime<true>;
+  minDepartureDateTime: DateTime<true>;
+  maxDepartureDateTime: DateTime<true>;
   origin: string;
   destination: string;
 }
@@ -96,15 +77,12 @@ export interface Flight {
 
 export interface Bound {
   fareFamilyCode: string;
-  originLocationCode: string;
-  destinationLocationCode: string;
-  flights: ReadonlyArray<Flight>;
+  flights: ReadonlyArray<{}>;
 }
 
 export interface MilesConversion {
   convertedMiles: {
     base: number;
-    total: number;
   };
 }
 
@@ -122,13 +100,19 @@ export interface ResponseDataEntry {
   departureDate: string;
   fareFamilyCode: string;
   bounds: ReadonlyArray<Bound>;
-  fareInfos: ReadonlyArray<unknown>;
+  fareInfos: ReadonlyArray<{}>;
   prices: Prices;
 }
 
+export interface Currency {
+  name: string;
+  decimalPlaces: number;
+}
+
 export interface ResponseDataDictionaries {
   aircraft: Record<string, string>;
   airline: Record<string, string>;
+  currency: Record<string, Currency>;
   flight: Record<string, FlightLookup>;
 }
 
@@ -151,38 +135,43 @@ export class MilesAndMoreClient {
   }
 
   async getBestBy(req: MMRequest): Promise<MMResponse> {
+    const today = DateTime.now();
+    let minDepartureDateTime = req.minDepartureDateTime;
+    if (today > minDepartureDateTime) {
+      minDepartureDateTime = today;
+    }
+
     const request = {
       commercialFareFamilies: [req.fareFamily],
       corporateCodes: [CorporateCode.LH],
+      countryOfCommencement: 'DE',
       currencyCode: CurrencyCode.EUR,
-      frequentFlyer: {
-        companyCode: CompanyCode.LH,
-        priorityCode: 0,
-      },
       itineraries: [
         {
-          departureDateTime: req.departureDateTime.toISODate() + 'T00:00:00',
+          departureDateTime: minDepartureDateTime.toISODate() + 'T00:00:00',
           originLocationCode: req.origin,
           destinationLocationCode: req.destination,
         },
       ],
-      searchPreferences: {
-        mode: req.mode,
-        showMilesPrice: true,
+      tripDetails: {
+        rangeOfDeparture: Math.ceil(minDepartureDateTime.until(req.maxDepartureDateTime).length('days')),
       },
-      travelers: req.travelers.map((v) => ({ passengerTypeCode: v })),
     } satisfies BestByRequest;
 
     const errs: Array<string> = [];
 
-    for (let i = 0; i < 3; i++) {
+    const maxAttempts = 1;
+    for (let i = 0; i < maxAttempts; i++) {
       const resp = await this.httpClient.fetch(
-        `http://127.0.0.1:8090/milesandmore/flights/v1/${req.mode === Mode.BEST_BY_MONTH ? 'bestbymonth' : 'bestbyday'}`,
+        `http://127.0.0.1:8090/milesandmore/flights/v3/${req.mode === Mode.BEST_BY_MONTH ? 'bestbymonth' : 'bestbyday'}`,
         {
           method: 'POST',
           body: JSON.stringify(request),
           headers: {
+            'Accept': 'application/json, text/plain, */*',
+            'Content-Type': 'application/json',
             'X-Api-Key': 'agGBZmuTGwFXWzVDg8ckGKGBytemE1nS',
+            'Rtw': 'true',
           },
         },
       );
@@ -195,6 +184,7 @@ export class MilesAndMoreClient {
           dictionaries: {
             aircraft: {},
             airline: {},
+            currency: {},
             flight: {},
           },
         };
diff --git a/ui/src/pages/tools/mm-quick-search.tsx b/ui/src/pages/tools/mm-quick-search.tsx
index 1788635..b8fcdf2 100644
--- a/ui/src/pages/tools/mm-quick-search.tsx
+++ b/ui/src/pages/tools/mm-quick-search.tsx
@@ -2,16 +2,14 @@ import React, { useCallback, useMemo, useState } from 'react';
 import { useHttpClient } from '../../components/util/context/http-client';
 import {
   ArrivalDeparture,
-  Bound,
-  FareFamily,
+  FareFamily, FlightLookup,
   MilesAndMoreClient,
   MMResponse,
   Mode,
   PassengerCode,
-  ResponseDataDictionaries, ResponseDataEntry
 } from '../../lib/milesandmore/client';
 import {
-  Alert,
+  Alert, Box,
   Button,
   ColumnLayout,
   Container,
@@ -20,16 +18,54 @@ import {
   Form,
   FormField,
   Grid,
-  Header, Link, Table
+  Header, Link, Select, SelectProps, Table
 } from '@cloudscape-design/components';
 import { AirportMultiselect } from '../../components/select/airport-multiselect';
-import { DateTime, Duration } from 'luxon';
+import { DateTime } from 'luxon';
 import { catchNotify, useAppControls } from '../../components/util/context/app-controls';
 import { useCollection } from '@cloudscape-design/collection-hooks';
 import { useInterval } from '../../components/util/state/common';
 import { useAirports } from '../../components/util/state/data';
 import { FlightLink } from '../../components/common/flight-link';
 import { withDepartureAirportFilter, withDepartureDateFilter } from '../flight';
+import { BulletSeperator, Join } from '../../components/common/join';
+
+const CABIN_OPTIONS = [
+  {
+    label: 'Economy',
+    description: FareFamily.ECO,
+    value: FareFamily.ECO,
+  },
+  {
+    label: 'Premium Economy',
+    description: FareFamily.PRECO,
+    value: FareFamily.PRECO,
+  },
+  {
+    label: 'Business',
+    description: FareFamily.BUSINESS,
+    value: FareFamily.BUSINESS,
+  },
+  {
+    label: 'First',
+    description: FareFamily.FIRST,
+    value: FareFamily.FIRST,
+  },
+] satisfies ReadonlyArray<SelectProps.Option>;
+
+interface MmSearchMatch {
+  legs: ReadonlyArray<MmSearchMatchLeg>;
+  miles: number;
+  cash: ReadonlyArray<[string, string]>;
+}
+
+interface MmSearchMatchLeg {
+  departureTime: DateTime<true>;
+  departureAirport: string;
+  arrivalTime: DateTime<true>;
+  arrivalAirport: string;
+  flight: FlightLookup;
+}
 
 export function MmQuickSearch() {
   const { httpClient } = useHttpClient();
@@ -39,41 +75,39 @@ export function MmQuickSearch() {
   const airportsQuery = useAirports();
 
   const [isLoading, setLoading] = useState(false);
+  const [cabin, setCabin] = useState<SelectProps.Option>(CABIN_OPTIONS[2]);
   const [origins, setOrigins] = useState<ReadonlyArray<string>>([]);
   const [destinations, setDestinations] = useState<ReadonlyArray<string>>([]);
   const [minDeparture, setMinDeparture] = useState<DateTime<true>>(DateTime.now().startOf('day'));
-  const [maxDeparture, setMaxDeparture] = useState<DateTime<true>>(DateTime.now().endOf('day'));
+  const [maxDeparture, setMaxDeparture] = useState<DateTime<true>>(minDeparture.endOf('month'));
 
-  const [items, setItems] = useState<ReadonlyArray<Entry>>([]);
+  const [items, setItems] = useState<ReadonlyArray<MmSearchMatch>>([]);
 
   function onSearch() {
     setLoading(true);
     (async () => {
-      const promises: Array<Promise<MMResponse>> = [];
-      const start = minDeparture.startOf('month');
-      const end = maxDeparture.startOf('month');
+      const promises: Array<[string, string, Promise<MMResponse>]> = [];
+      const fareFamily = cabin.value as FareFamily;
 
       for (const origin of origins) {
         for (const destination of destinations) {
-          let curr = start;
-          do {
-            const promise = mmClient.getBestBy({
-              mode: Mode.BEST_BY_DAY,
-              fareFamily: FareFamily.BUSINESS,
-              travelers: [PassengerCode.ADULT],
-              departureDateTime: curr,
-              origin: origin,
-              destination: destination,
-            });
-
-            promises.push(promise);
-
-            curr = curr.plus(Duration.fromMillis(1000 * 60 * 60 * 24 * 32)).startOf('month');
-          } while (end.diff(curr).toMillis() > 0);
+          const promise = mmClient.getBestBy({
+            mode: Mode.BEST_BY_DAY,
+            fareFamily: fareFamily,
+            travelers: [PassengerCode.ADULT],
+            minDepartureDateTime: minDeparture,
+            maxDepartureDateTime: maxDeparture,
+            origin: origin,
+            destination: destination,
+          });
+
+          promises.push([origin, destination, promise]);
         }
       }
 
-      for (const promise of promises) {
+      const allErrors: Array<string> = [];
+
+      for (const [origin, destination, promise] of promises) {
         let res: MMResponse;
         try {
           res = await promise;
@@ -82,24 +116,23 @@ export function MmQuickSearch() {
           continue;
         }
 
-        for (let d of res.data) {
-          const filteredBounds: Array<Bound> = [];
-          for (const bound of d.bounds) {
-            if (bound.flights.length >= 1) {
-              const flight = res.dictionaries.flight[bound.flights[0].id];
-              const departure = DateTime.fromISO(flight.departure.dateTime, { setZone: true });
+        const [entries, errors] = mmResponseToEntries(origin, destination, res);
+        allErrors.push(...errors);
 
-              if (departure.isValid && departure >= minDeparture && departure <= maxDeparture) {
-                filteredBounds.push(bound);
-              }
-            }
-          }
+        setItems((prev) => [...prev, ...entries]);
+      }
 
-          if (filteredBounds.length >= 1) {
-            d = { ...d, bounds: filteredBounds };
-            setItems((prev) => [...prev, { entry: d, dictionaries: res.dictionaries }]);
-          }
-        }
+      if (allErrors.length > 0) {
+        notification.addOnce({
+          type: 'warning',
+          header: 'Could not display all matches',
+          content: (
+            <ColumnLayout columns={1}>
+              {...allErrors.map((v) => <Box>{v}</Box>)}
+            </ColumnLayout>
+          ),
+          dismissible: true,
+        });
       }
     })()
       .catch(catchNotify(notification))
@@ -117,9 +150,19 @@ export function MmQuickSearch() {
               gridDefinition={[
                 { colspan: { default: 12, xs: 6, m: 3 } },
                 { colspan: { default: 12, xs: 6, m: 3 } },
-                { colspan: { default: 12, xs: 12, m: 6 } },
+                { colspan: { default: 12, xs: 6, m: 3 } },
+                { colspan: { default: 12, xs: 12, m: 3 } },
               ]}
             >
+              <FormField label={'Cabin'}>
+                <Select
+                  selectedOption={cabin}
+                  options={CABIN_OPTIONS}
+                  onChange={(e) => setCabin(e.detail.selectedOption)}
+                  disabled={isLoading}
+                />
+              </FormField>
+
               <FormField label={'Origin'}>
                 <AirportMultiselect
                   airports={airportsQuery.data}
@@ -211,17 +254,9 @@ function ProxyConnectionAlert({ client }: { client: MilesAndMoreClient }) {
   )
 }
 
-interface Entry {
-  entry: ResponseDataEntry;
-  dictionaries: ResponseDataDictionaries;
-}
-
-function AvailabilityTable({ items: rawItems, onClear }: { items: ReadonlyArray<Entry>, onClear: () => void }) {
+function AvailabilityTable({ items: rawItems, onClear }: { items: ReadonlyArray<MmSearchMatch>, onClear: () => void }) {
   const { items, collectionProps } = useCollection(rawItems, { sorting: {} });
 
-  const sortByDepartureDate = useCallback((a: Entry, b: Entry) => a.entry.departureDate.localeCompare(b.entry.departureDate), []);
-  const sortByMilesPrice = useCallback((a: Entry, b: Entry) => a.entry.prices.milesConversion.convertedMiles.base - b.entry.prices.milesConversion.convertedMiles.base, []);
-
   return (
     <Table
       {...collectionProps}
@@ -230,48 +265,88 @@ function AvailabilityTable({ items: rawItems, onClear }: { items: ReadonlyArray<
       items={items}
       columnDefinitions={[
         {
-          id: 'departure_date',
-          header: 'Departure Date',
-          cell: (v) => v.entry.departureDate,
-          sortingComparator: sortByDepartureDate,
+          id: 'departure_time',
+          header: 'Departure Time',
+          cell: (v) => v.legs[0].departureTime.toISO(),
+          sortingComparator: useCallback((a: MmSearchMatch, b: MmSearchMatch) => {
+            return compareDateTime(a.legs[0].departureTime, b.legs[0].departureTime);
+          }, []),
+        },
+        {
+          id: 'departure_airport',
+          header: 'Departure Airport',
+          cell: (v) => v.legs[0].departureAirport,
+          sortingComparator: useCallback((a: MmSearchMatch, b: MmSearchMatch) => {
+            return a.legs[0].departureAirport.localeCompare(b.legs[0].departureAirport);
+          }, []),
+        },
+        {
+          id: 'arrival_time',
+          header: 'Arrival Time',
+          cell: (v) => v.legs[v.legs.length - 1].arrivalTime.toISO(),
+          sortingComparator: useCallback((a: MmSearchMatch, b: MmSearchMatch) => {
+            return compareDateTime(a.legs[a.legs.length - 1].arrivalTime, b.legs[b.legs.length - 1].arrivalTime);
+          }, []),
+        },
+        {
+          id: 'arrival_airport',
+          header: 'Arrival Airport',
+          cell: (v) => v.legs[v.legs.length - 1].arrivalAirport,
+          sortingComparator: useCallback((a: MmSearchMatch, b: MmSearchMatch) => {
+            return a.legs[a.legs.length - 1].arrivalAirport.localeCompare(b.legs[b.legs.length - 1].arrivalAirport);
+          }, []),
+        },
+        {
+          id: 'duration',
+          header: 'Duration',
+          cell: (v) => {
+            const start = v.legs[0].departureTime;
+            const end = v.legs[v.legs.length - 1].arrivalTime;
+            const duration = end.diff(start);
+
+            return duration.rescale().toHuman();
+          },
         },
         {
           id: 'route',
           header: 'Route',
           cell: (v) => {
-            return v.entry.bounds
-              .map((v) => `${v.originLocationCode} - ${v.destinationLocationCode}`)
-              .join(' • ');
+            const route = [v.legs[0].departureAirport];
+
+            for (const leg of v.legs) {
+              route.push(leg.arrivalAirport);
+            }
+
+            return <Join seperator={BulletSeperator} items={route} />;
           },
         },
         {
           id: 'flight_numbers',
           header: 'Flight Numbers',
           cell: (v) => {
-            const elements = v.entry.bounds
-              .flatMap((v) => v.flights)
-              .map((v) => v.id)
-              .map((id) => v.dictionaries.flight[id])
-              .map((v) => (<FlightNumber flightNumber={`${v.marketingAirlineCode}${v.marketingFlightNumber}`} departure={v.departure} />));
+            const elements = v.legs
+              .map((v) => v.flight)
+              .map((v) => (<FlightNumber flightNumber={`${v.operatingAirlineCode}${v.marketingFlightNumber}`} departure={v.departure} />));
 
-            return <ColumnLayout columns={elements.length} variant={'text-grid'}>{...elements}</ColumnLayout>
+            return <Join seperator={BulletSeperator} items={elements} />;
           },
         },
         {
           id: 'miles_price',
           header: 'Miles',
           cell: (v) => {
-            return v.entry.prices.milesConversion.convertedMiles.base;
+            return v.miles;
           },
-          sortingComparator: sortByMilesPrice,
+          sortingField: 'miles',
         },
         {
           id: 'cash',
           header: 'Cash',
           cell: (v) => {
-            return v.entry.prices.totalPrices
-              .map((v) => `${(v.totalTaxes / 100.0).toFixed(2)} ${v.currencyCode}`)
-              .join(', ');
+            const elements = v.cash
+              .map((v) => `${v[0]} ${v[1]}`)
+
+            return <Join seperator={BulletSeperator} items={elements} />;
           },
         }
       ]}
@@ -289,4 +364,121 @@ function FlightNumber({ flightNumber, departure }: { flightNumber: string, depar
   }
 
   return <FlightLink flightNumber={flightNumber} query={query} />;
+}
+
+function mmResponseToEntries(departureAirport: string, arrivalAirport: string, resp: MMResponse): [ReadonlyArray<MmSearchMatch>, ReadonlyArray<string>] {
+  const allFlights: Array<MmSearchMatchLeg> = [];
+  const errors: Array<string> = [];
+
+  for (const [key, flight] of Object.entries(resp.dictionaries.flight)) {
+    const departureTime = DateTime.fromISO(flight.departure.dateTime, { setZone: true });
+    const arrivalTime = DateTime.fromISO(flight.arrival.dateTime, { setZone: true });
+
+    if (departureTime.isValid && arrivalTime.isValid) {
+      allFlights.push({
+        departureTime: departureTime,
+        departureAirport: flight.departure.locationCode,
+        arrivalTime: arrivalTime,
+        arrivalAirport: flight.arrival.locationCode,
+        flight: flight,
+      });
+    } else {
+      errors.push(`could not parse departure/arrival time for flight ${key}`);
+    }
+  }
+
+  const result: Array<MmSearchMatch> = [];
+
+  for (const entry of resp.data) {
+    let numFlights = 0;
+    for (const bound of entry.bounds) {
+      numFlights += bound.flights.length;
+    }
+
+    if (numFlights < 1) {
+      errors.push(`found match for ${departureAirport}-${arrivalAirport} on ${entry.departureDate}, but match does not have any flights`);
+      continue
+    }
+
+    const legs = findMatchingLegs(allFlights, departureAirport, entry.departureDate, arrivalAirport, numFlights);
+    if (!legs) {
+      errors.push(`found match for ${departureAirport}-${arrivalAirport} on ${entry.departureDate}, but no flights could be matched from the response`);
+      continue
+    }
+
+    result.push({
+      legs: legs.toSorted((a, b) => compareDateTime(a.departureTime, b.departureTime)),
+      miles: entry.prices.milesConversion.convertedMiles.base,
+      cash: entry.prices.totalPrices
+        .map((v) => {
+          const currency = resp.dictionaries.currency[v.currencyCode] ?? { name: v.currencyCode, decimalPlaces: 0 };
+          const decimals = currency.decimalPlaces;
+
+          return [
+            (v.totalTaxes / Math.pow(10, decimals)).toFixed(decimals),
+            v.currencyCode,
+          ];
+        }),
+    });
+  }
+
+  return [result, errors];
+}
+
+function findMatchingLegs(allFlights: ReadonlyArray<MmSearchMatchLeg>, departureAirport: string, departureDate: string, arrivalAirport: string, numFlights: number): ReadonlyArray<MmSearchMatchLeg> | null {
+  const potentialResults: Array<ReadonlyArray<MmSearchMatchLeg>> = [];
+
+  for (const flight of allFlights) {
+    if (flight.departureAirport === departureAirport && flight.departureTime.toISODate() === departureDate) {
+      const following = findFollowingLegs(allFlights, flight.arrivalAirport, arrivalAirport, numFlights - 1, flight.arrivalTime);
+      if (following) {
+        potentialResults.push([flight, ...following]);
+      }
+    }
+  }
+
+  if (potentialResults.length !== 1) {
+    return null;
+  }
+
+  return potentialResults[0];
+}
+
+function findFollowingLegs(allFlights: ReadonlyArray<MmSearchMatchLeg>, departureAirport: string, arrivalAirport: string, numFlights: number, offset: DateTime<true>): ReadonlyArray<MmSearchMatchLeg> | null {
+  if (numFlights < 1) {
+    return [];
+  }
+
+  const potentialResults: Array<ReadonlyArray<MmSearchMatchLeg>> = [];
+
+  for (const flight of allFlights) {
+    if (flight.departureAirport === departureAirport && flight.departureTime >= offset) {
+      if (numFlights > 1 && flight.arrivalAirport !== arrivalAirport) {
+        const following = findFollowingLegs(allFlights, flight.arrivalAirport, arrivalAirport, numFlights - 1, flight.arrivalTime);
+        if (following) {
+          potentialResults.push([flight, ...following]);
+        }
+      } else if (numFlights === 1 && flight.arrivalAirport === arrivalAirport) {
+        potentialResults.push([flight]);
+      }
+    }
+  }
+
+  if (potentialResults.length < 1) {
+    return null;
+  }
+
+  potentialResults.sort((a, b) => compareDateTime(a[0].departureTime, b[0].departureTime));
+
+  return potentialResults[0];
+}
+
+function compareDateTime(a: DateTime<boolean>, b: DateTime<boolean>): number {
+  if (a > b) {
+    return 1;
+  } else if (a < b) {
+    return -1;
+  }
+
+  return 0;
 }
\ No newline at end of file