@sabstravtech/obtservices 0.0.0

package/projects/obtservices/base/src/lib/vendor/services/my-bookings.service.ts

@@ -0,0 +1,184 @@
+import { BehaviorSubject, Observable, of } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+import { EnterpriseMyBookingsServiceInterface } from '../interfaces/Imybookings.service';
+import {
+  BaseSearchUsersCanBookForFetcher,
+  SearchUserCanBookForFetcherType
+} from '../fetchers/search-users-can-book-for-fetcher';
+import {
+  BaseGetUserBasketsFetcher,
+  GetUserBasketsFetcherType
+} from '../fetchers/get-users-baskets-fetcher';
+import { UserBasketResult } from '../types/types';
+import {
+  BasketItem,
+  BasketItemStatus,
+  BasketStatus,
+  QueryGetUserBasketsArgs,
+  ServiceType,
+  User
+} from '../types/graphql.types';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+
+export class BaseEnterpriseMyBookingsService<
+  GUB_Q extends GetUserBasketsFetcherType,
+  SUCBF_Q extends SearchUserCanBookForFetcherType
+> implements EnterpriseMyBookingsServiceInterface
+{
+  public baskets: BehaviorSubject<UserBasketResult[]> = new BehaviorSubject<
+    UserBasketResult[]
+  >([]);
+
+  private _basketStatusIconClasses: Record<BasketStatus, string> = {
+    [BasketStatus.Approved]: 'ico-tick',
+    [BasketStatus.AwaitingApproval]: 'ico-clock',
+    [BasketStatus.BookingFailed]: 'ico-deny',
+    [BasketStatus.Disapproved]: 'ico-deny',
+    [BasketStatus.Open]: 'ico-calendar',
+    [BasketStatus.PartiallyBooked]: 'ico-deny',
+    [BasketStatus.Booked]: 'ico-deny'
+  };
+
+  private _serviceTypeIconClasses: Record<ServiceType, string> = {
+    [ServiceType.Cab]: 'ico-m-taxi',
+    [ServiceType.Car]: 'ico-car',
+    [ServiceType.Coach]: 'ico-bus',
+    [ServiceType.Flight]: 'ico-flight',
+    [ServiceType.Hotel]: 'ico-bed',
+    [ServiceType.FastTrack]: '',
+    [ServiceType.InternationalRail]: 'ico-rail',
+    [ServiceType.Lounge]: 'ico-material ico-lounge',
+    [ServiceType.Parking]: 'ico-material ico-parking',
+    [ServiceType.Rail]: 'ico-rail',
+    [ServiceType.Eurostar]: 'ico-rail'
+  };
+
+  constructor(
+    private getUserBasketsFetcher: BaseGetUserBasketsFetcher<GUB_Q>,
+    private searchUserCanBookFor: BaseSearchUsersCanBookForFetcher<SUCBF_Q>
+  ) {}
+
+  getUserBaskets(
+    query: QueryGetUserBasketsArgs,
+    isLoading: BehaviorSubject<boolean>
+  ): void {
+    isLoading.next(true);
+    this.getUserBasketsFetcher
+      .fetchList(query)
+      .pipe(take(1))
+      .subscribe(
+        (baskets: UserBasketResult[]) => {
+          this.baskets.next(baskets);
+          isLoading.next(false);
+        },
+        (error: any) => {
+          console.error(error);
+          isLoading.next(false);
+        }
+      );
+  }
+
+  getSearchUserCanBookFor(
+    search: string,
+    isLoading: BehaviorSubject<boolean>
+  ): Observable<User[]> {
+    if (search.length > 2) {
+      isLoading.next(true);
+      return this.searchUserCanBookFor
+        .fetchList({
+          email: search
+        })
+        .pipe(
+          take(1),
+          map((results: User[]) => {
+            isLoading.next(false);
+            return results;
+          })
+        );
+    }
+    return of([]);
+  }
+
+  getServiceTypeFilters(
+    searchService: EnterpriseSearchServiceInterface
+  ): string[] {
+    const serviceTypeFilters: string[] = [];
+    for (const [key] of Object.entries(searchService.search_objects)) {
+      serviceTypeFilters.push(key);
+    }
+    return serviceTypeFilters;
+  }
+
+  getBasketStatusFilters(): string[] {
+    const basketStatusFilters: string[] = [];
+    Object.values(BasketStatus).forEach((basketStatus) =>
+      basketStatusFilters.push(basketStatus)
+    );
+    return basketStatusFilters;
+  }
+
+  getServiceTypeFilterVanityName(serviceType: ServiceType): string {
+    switch (serviceType) {
+      case ServiceType.Cab:
+        return 'Taxi';
+      case ServiceType.InternationalRail:
+        return 'European Rail';
+      default:
+        return serviceType;
+    }
+  }
+
+  getBasketStatusIconClass(status: BasketStatus): string {
+    return this._basketStatusIconClasses[status] || 'ico-exclamation';
+  }
+
+  getServiceTypeIconClass(basketItem: BasketItem): string {
+    return (
+      this._serviceTypeIconClasses[basketItem.service.type] || 'ico-exclamation'
+    );
+  }
+
+  getTotalPriceForBasketItems(basketItems: BasketItem[]): number {
+    return basketItems.reduce((total, basketItem) => {
+      return total + basketItem.price;
+    }, 0);
+  }
+
+  getTravellerNamesFromBasketItems(basketItems: BasketItem[]): string[] {
+    let travellerNames: string[] = [];
+    basketItems.map((basketItem) =>
+      basketItem.users.map((user) =>
+        travellerNames.push(`${user.forename} ${user.surname}`)
+      )
+    );
+    travellerNames = [...new Set(travellerNames)]; // remove any duplicate traveller names
+    return travellerNames;
+  }
+
+  allBasketItemsMatchStatus(
+    basketItems: BasketItem[],
+    basketItemStatus: BasketItemStatus
+  ): boolean {
+    return basketItems.every(
+      (basketItem) => basketItem.status === basketItemStatus
+    );
+  }
+
+  getHotelAddress(hotelAddress: { [key: string]: string }): string {
+    const { county, postcode, streetName, town } = hotelAddress;
+    const hotelAddressArr = [];
+    if (streetName) hotelAddressArr.push(streetName);
+    if (town) hotelAddressArr.push(town);
+    if (county) hotelAddressArr.push(county);
+    if (postcode) hotelAddressArr.push(postcode);
+    return hotelAddressArr.join(', ');
+  }
+
+  getHotelLocation(hotelAddress: { [key: string]: string }): string {
+    const { county, town } = hotelAddress;
+    const hotelAddressArr = [];
+    if (town) hotelAddressArr.push(town);
+    if (county) hotelAddressArr.push(county);
+    return hotelAddressArr.join(', ');
+  }
+}

package/projects/obtservices/base/src/lib/vendor/services/routehappy.service.ts

@@ -0,0 +1,275 @@
+import { BehaviorSubject } from 'rxjs';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { Memorise } from '../classes/limited-cache.class';
+import { UPA, Amenities } from '../classes/routehappy-request';
+import { Included } from '../classes/routehappy-response';
+import { AbstractHttpCallService } from './http-call.service';
+
+export interface RouteHappyBandsUpas {
+  brands: Brand[];
+  upas: Upas[];
+}
+
+export interface RouteHappyAmenities {
+  seat: Amenities.Seat;
+  wifi: Amenities.Wifi;
+  power: Amenities.Power;
+  entertainment: Amenities.Entertainment;
+  fresh_food: Amenities.FreshFood;
+  beverage: Amenities.Beverage;
+  layout: Amenities.Layout;
+  aircraft: Amenities.Aircraft;
+}
+interface Brand {
+  brand_name: string;
+  brand_codes: string[];
+}
+interface Upa {
+  headline: string;
+  description: string;
+  small_icon_url: string;
+  large_icon_url: string;
+  cta_text: string;
+  cta_url: string;
+  categories: string[];
+  fees: any[];
+}
+
+interface Upas {
+  [key: string]: Upa;
+}
+
+export class BaseRouteHappyService {
+  constructor(
+    private httpService: AbstractHttpCallService,
+    private helpers: BaseHelperRoutines
+  ) {}
+
+  @Memorise()
+  public getAmenitiesForFlight(
+    flight: any
+  ): BehaviorSubject<RouteHappyAmenities[]> {
+    const value = new BehaviorSubject<RouteHappyAmenities[]>([]);
+
+    // const ids = flight.LegDetails
+    //   .map((leg: any) => {
+    //     return [
+    //       leg.depPoint,
+    //       leg.arrPoint,
+    //       leg.touropID,
+    //       leg.transNo.substr(leg.touropID.length), // Remove the touropId fdrom the beginning of the flight number
+    //       Helpers.formatIsoDateNoHyphans(Helpers.yymmddToMoment(leg.dateDep)),
+    //       this.convertClassString(leg.seatClassBasic.toUpperCase())
+    //     ].join('-');
+    //   })
+    //   .join(',');
+
+    // this.httpService
+    //   .post(URLS.routeHappy, {
+    //     type: 'flight-get',
+    //     parameters:
+    //       'include=' +
+    //       [
+    //         'segments.aircraft',
+    //         'segments.entertainment',
+    //         'segments.fresh_food',
+    //         'segments.layout',
+    //         'segments.power',
+    //         'segments.seat',
+    //         'segments.wifi',
+    //         'segments.beverage'
+    //       ].join(',') +
+    //       '&ids=' +
+    //       ids,
+    //     url: 'api-legs'
+    //   })
+    //   .pipe(take(1))
+    //   .subscribe((response: Amenities.AmenitiesResponse) => {
+    //     value.next(this.parseAmenities(response));
+    //   });
+
+    return value;
+  }
+
+  parseAmenities(response: Amenities.AmenitiesResponse): RouteHappyAmenities[] {
+    const linked = response.linked;
+
+    const findId = (id: string, data: any[]) => {
+      return data.find((item) => item.id == id);
+    };
+    return response.data.map((datum: Amenities.Datum) => {
+      const currentSegment: Amenities.Segment = findId(
+        datum.links.segments[0],
+        linked.segments
+      );
+      return {
+        seat: findId(currentSegment.links.seat.toString(), linked.seats),
+        wifi: findId(currentSegment.links.wifi.toString(), linked.wifis),
+        power: findId(
+          currentSegment.links.power.toString(),
+          linked.entertainments
+        ),
+        entertainment: findId(
+          currentSegment.links.entertainment.toString(),
+          linked.entertainments
+        ),
+        fresh_food: findId(
+          currentSegment.links.fresh_food.toString(),
+          linked.fresh_foods
+        ),
+        beverage: findId(
+          currentSegment.links.beverage.toString(),
+          linked.beverages
+        ),
+        layout: findId(currentSegment.links.layout.toString(), linked.layouts),
+        aircraft: findId(
+          currentSegment.links.aircraft.toString(),
+          linked.aircrafts
+        )
+      };
+    });
+  }
+
+  convertClassString(seatClass: string): string {
+    switch (seatClass) {
+      case 'ECONOMY':
+        return 'ECON';
+      case 'PREMIUM ECONOMY':
+        return 'PREMECON';
+      case 'BUSINESS':
+        return 'BUSINESS';
+      case 'FIRST':
+        return 'FIRST';
+      default:
+        return 'ECON';
+    }
+  }
+
+  @Memorise()
+  public getUpasForFlight(flight: any): BehaviorSubject<RouteHappyBandsUpas[]> {
+    const value = new BehaviorSubject<RouteHappyBandsUpas[]>([]);
+
+    const data: UPA.UPARequest = {
+      data: {
+        type: 'legs_search',
+        attributes: {
+          fare_source: '1S',
+          categories: ['brand', 'promotion'],
+          legs: [
+            {
+              segments: []
+            }
+          ]
+        }
+      }
+    };
+    data.data.attributes.legs = flight.LegDetails.map((leg: any) => {
+      return {
+        segments: [
+          {
+            dep: leg.depPoint,
+            arr: leg.arrPoint,
+            carrier: leg.touropID,
+            flt_no: leg.transNo.substr(leg.touropID.length), // Remove the touropId fdrom the beginning of the flight number
+            dep_date: this.helpers.formatIsoDate(
+              this.helpers.yymmddToMoment(leg.dateDep)
+            ),
+            cabin_id: this.convertClass(leg.seatClassBasic.toUpperCase())
+          }
+        ]
+      };
+    });
+
+    // this.httpService
+    //   .post(URLS.routeHappy, {
+    //     type: 'flight',
+    //     payload: data,
+    //     parameters: 'include=legs.leg_fares.fare,legs.leg_fares.leg_fare_segments.upas',
+    //     url: 'hub-api-legssearch'
+    //   })
+    //   .pipe(take(1))
+    //   .subscribe((response: RouteHappyBandsUpas[]) => {
+    //     value.next(this.parseResponse(response));
+    //   });
+
+    return value;
+  }
+  convertClass(seatClass: string): number {
+    switch (seatClass) {
+      case 'ECONOMY':
+        return 1;
+      case 'PREMIUM ECONOMY':
+        return 2;
+      case 'BUSINESS':
+        return 3;
+      case 'FIRST':
+        return 4;
+      default:
+        return 1;
+    }
+  }
+
+  private parseResponse(response: any): RouteHappyBandsUpas[] {
+    const makeKey = (...args: string[]) => {
+      return args.join('_');
+    };
+
+    const makeKeyFromData = (data: { type: string; id: string }) => {
+      return makeKey(data.type, data.id);
+    };
+
+    const getAttributes = (data: { type: string; attributes: string }) => {
+      return data.attributes;
+    };
+
+    const relationships = response.included.reduce(
+      (details: { [key: string]: Included }, included: Included) => {
+        details[makeKey(included.type, included.id)] = included;
+        return details;
+      },
+      {}
+    );
+
+    const getRelationship = (data: { type: string; id: string }): any => {
+      return relationships[makeKeyFromData(data)];
+    };
+
+    const toReturn = response.data.relationships.legs.data.map(
+      (leg: { type: string; id: string }) => {
+        const currentLeg = getRelationship(leg);
+        const legFares = currentLeg.relationships.leg_fares.data
+          .map(getRelationship)
+          .filter((legFare: any) => !!legFare.relationships.fare.data);
+
+        const brands = legFares
+          .map((legFare: any) =>
+            getRelationship(legFare.relationships.fare.data)
+          )
+          .map(getAttributes);
+        const upas = legFares
+          .map((legFare: any) =>
+            legFare.relationships.leg_fare_segments.data.map(getRelationship)
+          )
+          .map((legFareSegment: any): any[] => {
+            return legFareSegment.map((obj: any) =>
+              obj.relationships.upas.data
+                .map(getRelationship)
+                .map((upa: any) => {
+                  return {
+                    id: upa.id,
+                    details: getAttributes(upa)
+                  };
+                })
+                .reduce((current: Upas, next: any): Upas => {
+                  current[next.id] = next.details;
+                  return current;
+                }, {})
+            );
+          });
+
+        return { brands, upas };
+      }
+    );
+    return toReturn;
+  }
+}