@sabstravtech/obtservices 0.0.0 → 0.0.1

package/projects/obtservices/base/src/lib/vendor/services/enterprise-basket.service.ts

@@ -1,1150 +0,0 @@
-import moment from 'moment';
-import Ajv from 'ajv';
-import { BehaviorSubject, Observable, Observer, Subject } from 'rxjs';
-import { switchMap, take, tap, map } from 'rxjs/operators';
-
-import {
-  AddItemToBasket,
-  Basket,
-  BasketItem,
-  BasketStatus,
-  ManagementInfo,
-  PassengerType,
-  PaymentMethod,
-  Service,
-  ServiceType,
-  SetBasketItemMiValue,
-  SupplementaryBookingInfo
-} from '../types/graphql.types';
-import {
-  GetMiAutoSugestionArray,
-  GetUserBasketItemResult,
-  GetUserBasketResult,
-  MenuSlideEnum,
-  UserBasketResult
-} from '../types/types';
-import { ManagementInfoAndIsValid } from '../classes/management-info-and-valid';
-import { ModalTypes } from '../classes/modal-types.enum';
-import { SupplementaryBookingInfoImpl } from '../classes/supplementary-booking-info-impl';
-import { BasketInfoMiDetailsImpl } from '../classes/basket-info-mi-details.impl';
-import { BaseHelperRoutines } from '../classes/helpers';
-import { BaseModalOpenerService } from './modal-opener.service';
-import {
-  BaseGetUserFetcher,
-  SearchGetUserFetcherType
-} from '../fetchers/user-fetcher';
-import {
-  AcceptNewPriceFetcherType,
-  BaseAcceptNewPriceUpdater
-} from '../updaters/accept-new-price.updater';
-import {
-  BaseGetBasketFetcher,
-  GetBasketFetcherType
-} from '../fetchers/basket-fetcher';
-import {
-  BaseGetUserBasketsFetcher,
-  GetUserBasketsFetcherType
-} from '../fetchers/get-users-baskets-fetcher';
-import {
-  BaseGetMiAutoSugestionFetcher,
-  MiAutoSuggestFetcherType
-} from '../fetchers/getMiAutoSugestions.fetcher';
-import {
-  AddItemToBasketFetcherType,
-  BaseAddItemToBasketUpdater
-} from '../updaters/add-item-to-basket.updater';
-import {
-  AddUserBasketFetcherType,
-  BaseAddUserToBasketItemUpdater
-} from '../updaters/addUserToBasketItem';
-import {
-  SetBasketItemLeadPassengerFetcherType,
-  BaseSetBasketItemLeadPassengerUpdater
-} from '../updaters/set-basket-item-lead-passenger.updater';
-import {
-  BaseBookBasketUpdater,
-  BookBasketFetcherType
-} from '../updaters/book-basket-updater';
-import {
-  BaseCreateBasketUpdater,
-  CreateBasketFetcherType
-} from '../updaters/create-basket-updater';
-import {
-  BaseDeleteBasketUpdater,
-  DeleteBasketFetcherType
-} from '../updaters/remove-basket-updater';
-import {
-  BaseRemoveItemFromBasketUpdater,
-  DeleteBasketItemFetcherType
-} from '../updaters/remove-item-from-basket.updater';
-import {
-  BaseRevalidateBasketUpdater,
-  RevalidateBasketFetcherType
-} from '../updaters/revalidate-basket-updater';
-import {
-  BaseSendBasketForApprovalUpdater,
-  SendBasketApprovalFetcherType
-} from '../updaters/send-basket-for-approval.updater';
-import {
-  BaseSetBasketItemMiGroupUpdater,
-  SetBasketItMiGroupFetcherType
-} from '../updaters/set-basket-item-mi-group';
-import { Traveller } from '../models/traveller.object';
-import { SearchObject } from '../interfaces/search-objects.interface';
-import {
-  BaseSetBasketItemMiValueUpdater,
-  SetBasketItMiFetcherType
-} from '../updaters/set-basket-item-mi-value-updater';
-import {
-  BaseValidateMiFreeValueTester,
-  ValidateMiFetcherType
-} from '../testers/validate-mi-free-value.tester';
-import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
-import {
-  FullUserDetails,
-  UserServiceInterface
-} from '../interfaces/Iuser.service';
-import {
-  EnterpriseBasketServiceInterface,
-  InternalBasketInterface
-} from '../interfaces/Ienterprise-basket.service';
-import { SupplementaryBookingInfoInterface } from '../interfaces/Isupplementary-booking-info-impl';
-import {
-  BasemoveBasketItemToBasket,
-  MoveItemToADifferentBasketType
-} from '../updaters/move-basket-item-to-basket';
-import {
-  BaseUpdateBasketNotesType,
-  BaseUpdateBasketNoteUpdater
-} from '../updaters/update-basket-notes-updater';
-import {
-  BaseUpdateBasketTitleType,
-  BaseUpdateBasketTitleUpdater
-} from '../updaters/update-basket-title-updater';
-import {
-  BaseSetPaymentOptionUpdater,
-  SetBasketItemPaymentMethodType
-} from '../updaters/set-basket-item-paymenr-option.updater';
-const TEMPID = 'TEMPID_';
-
-export interface BasketAndItem {
-  basketId: string;
-  item: BasketItem;
-}
-export interface MiGroupDetail {
-  type: ServiceType;
-  options: string[];
-  basketItem: BasketItem;
-  value: string;
-}
-export interface BasketItemManagementInfo {
-  miPerItem: ManagementInfoAndIsValid[];
-  miPerUser: {
-    [key: string]: {
-      managementInfo: ManagementInfoAndIsValid[];
-      supplementaryBookingInfo?: SupplementaryBookingInfoInterface;
-    };
-  };
-  users: string[];
-  basketItem: BasketItem;
-}
-
-export interface BasketInformation {
-  prices: { [key: string]: number };
-  mixedCurrency: boolean;
-  count: number;
-  miGroups: MiGroupDetail[];
-  basketInfoMiDetails: BasketInfoMiDetailsImpl[];
-  suppInfo: SupplementaryBookingInfoInterface[];
-}
-
-export interface BasketPricesList {
-  type: ServiceType;
-  price: number;
-  currency?: string;
-  text: string;
-}
-
-export interface BasketPrices {
-  total: number;
-  currency?: string;
-  list: BasketPricesList[];
-}
-
-export type BasketDetails = UserBasketResult & BasketInformation;
-export class InternalBasket<Q extends SearchGetUserFetcherType>
-  implements BasketInformation, InternalBasketInterface
-{
-  subject: BehaviorSubject<BasketDetails>;
-  id?: string;
-  tempid?: string;
-  title: string;
-  prices: { [key: string]: number };
-  mixedCurrency: boolean;
-  count: number;
-  miGroups: MiGroupDetail[];
-  basketInfoMiDetails: BasketInfoMiDetailsImpl[];
-  suppInfo: SupplementaryBookingInfoInterface[];
-  grandTotal: { [key: string]: number };
-  constructor(
-    basket: UserBasketResult,
-    private helpers: BaseHelperRoutines,
-    private basketService: EnterpriseBasketServiceInterface,
-    private getUserFetcher: BaseGetUserFetcher<Q>
-  ) {
-    Object.assign(this, {
-      subject: new BehaviorSubject<BasketDetails>({
-        ...basket,
-        prices: {},
-        mixedCurrency: false,
-        count: 0,
-        miGroups: [],
-        basketInfoMiDetails: [],
-        suppInfo: []
-      }),
-      tempid: basket.id,
-      id: basket.id,
-      title: basket.title,
-      prices: {},
-      mixedCurrency: false,
-      count: 0,
-      miGroups: [],
-      basketInfoMiDetails: [],
-      suppInfo: []
-    });
-    this.next(basket);
-  }
-
-  destructor() {
-    this.subject.complete();
-  }
-
-  next(basket: UserBasketResult) {
-    basket = this.helpers.clone(basket);
-    if (
-      basket.status === BasketStatus.Approved &&
-      basket.basketItems[0].perItemPhoneNumber === undefined
-    ) {
-      // We're in approved state so we need to make sure we have the supplement stuff
-      this.basketService
-        .getBasket({ id: basket.id, withSupplemental: true })
-        .subscribe((newBasket: UserBasketResult) => {
-          this.next(newBasket);
-        });
-      return;
-    }
-    this.id = basket.id;
-    this.title = basket.title;
-    const toSend: BasketDetails = {
-      ...basket,
-      ...(basket.basketItems || []).reduce(
-        (accum: BasketInformation, item: BasketItem, index: number) => {
-          if (!accum.prices[item.currency]) {
-            accum.prices[item.currency] = 0;
-          }
-          accum.prices[item.currency] += item.price;
-
-          accum.suppInfo.push(
-            new SupplementaryBookingInfoImpl(
-              item,
-              this.helpers,
-              this.getUserFetcher
-            )
-          );
-          if (item.miGroupsAvailable && item.miGroupsAvailable.length > 0) {
-            accum.miGroups.push({
-              type: item.service.type,
-              options: item.miGroupsAvailable,
-              basketItem: item,
-              value: item.miGroupSelected || ''
-            });
-          }
-          if (item.managementInfo?.length > 0 && item.users?.length > 0) {
-            accum.basketInfoMiDetails.push(
-              new BasketInfoMiDetailsImpl(
-                item,
-                this.basketService,
-                this.helpers
-              )
-            );
-          }
-          return accum;
-        },
-        {
-          prices: {},
-          mixedCurrency: false,
-          count: basket.basketItems?.length || 0,
-          miGroups: [],
-          basketInfoMiDetails: [],
-          suppInfo: []
-        }
-      )
-    };
-    toSend.mixedCurrency = Object.keys(toSend.prices).length > 1;
-    this.subject.next(toSend);
-  }
-}
-
-export abstract class BaseEnterpriseBasketService<
-  ANPU_Q extends AcceptNewPriceFetcherType,
-  AITB_Q extends AddItemToBasketFetcherType,
-  AUTB_Q extends AddUserBasketFetcherType,
-  CB_Q extends CreateBasketFetcherType,
-  GB_Q extends GetBasketFetcherType,
-  BB_Q extends BookBasketFetcherType,
-  DB_Q extends DeleteBasketFetcherType,
-  GAS_Q extends MiAutoSuggestFetcherType,
-  RIB_Q extends DeleteBasketItemFetcherType,
-  RVB_Q extends RevalidateBasketFetcherType,
-  SBMI_Q extends SetBasketItMiGroupFetcherType,
-  SVMI_Q extends SetBasketItMiFetcherType,
-  VMI_Q extends ValidateMiFetcherType,
-  SBA_Q extends SendBasketApprovalFetcherType,
-  GU_Q extends SearchGetUserFetcherType,
-  GUB_Q extends GetUserBasketsFetcherType,
-  SBLP_Q extends SetBasketItemLeadPassengerFetcherType,
-  MITDB_Q extends MoveItemToADifferentBasketType,
-  UBN_Q extends BaseUpdateBasketNotesType,
-  UBT_Q extends BaseUpdateBasketTitleType,
-  SBM_Q extends SetBasketItemPaymentMethodType
-> implements EnterpriseBasketServiceInterface
-{
-  private currentBaskets: InternalBasket<GU_Q>[] = [];
-
-  highlightBasketItemsEmitter: Subject<GetUserBasketItemResult[]> = new Subject<
-    GetUserBasketItemResult[]
-  >();
-
-  basketChangeEmitter: BehaviorSubject<string> = new BehaviorSubject<string>(
-    ''
-  );
-
-  private get currentBasketID(): string {
-    return this.basketChangeEmitter.value;
-  }
-
-  private set currentBasketID(value: string) {
-    if (value !== this.currentBasketID) {
-      // this prevents the emitter getting stuck in a loop  - casuing browser overloads
-      this.basketChangeEmitter.next(value);
-    }
-  }
-
-  baskets = new BehaviorSubject<InternalBasket<GU_Q>[]>([]);
-
-  basketList: BasketPricesList[] = [
-    {
-      type: ServiceType.Flight,
-      text: 'FLIGHTS',
-      price: 0
-    },
-    {
-      type: ServiceType.Rail,
-      text: 'RAIL',
-      price: 0
-    },
-    {
-      type: ServiceType.Hotel,
-      text: 'HOTELS',
-      price: 0
-    },
-    {
-      type: ServiceType.Cab,
-      text: 'TAXIS',
-      price: 0
-    },
-    {
-      type: ServiceType.Car,
-      text: 'CARS',
-      price: 0
-    },
-    {
-      type: ServiceType.InternationalRail,
-      text: 'EUROSTAR',
-      price: 0
-    },
-    {
-      type: ServiceType.Parking,
-      text: 'PARKING',
-      price: 0
-    },
-    {
-      type: ServiceType.Lounge,
-      text: 'LOUNGES',
-      price: 0
-    },
-    {
-      type: ServiceType.Coach,
-      text: 'COACH',
-      price: 0
-    },
-    {
-      type: ServiceType.FastTrack,
-      text: 'FAST_TRACK',
-      price: 0
-    }
-  ];
-
-  basketPrices: BehaviorSubject<BasketPrices> =
-    new BehaviorSubject<BasketPrices>({ total: null, list: this.basketList });
-
-  menuState = MenuSlideEnum.OUT;
-
-  constructor(
-    private acceptNewPriceUpdater: BaseAcceptNewPriceUpdater<ANPU_Q>,
-    private addItemToBasketUpdater: BaseAddItemToBasketUpdater<AITB_Q>,
-    private addUserToBasketItem: BaseAddUserToBasketItemUpdater<AUTB_Q>,
-    private basketCreator: BaseCreateBasketUpdater<CB_Q>,
-    public basketFetcher: BaseGetBasketFetcher<GB_Q>,
-    private bookBasketUpdater: BaseBookBasketUpdater<BB_Q>,
-    private deleteBasketUpdater: BaseDeleteBasketUpdater<DB_Q>,
-    private getMiAutoSugestionFetcher: BaseGetMiAutoSugestionFetcher<GAS_Q>,
-    private helpers: BaseHelperRoutines,
-    private removeItemFromBasketUpdater: BaseRemoveItemFromBasketUpdater<RIB_Q>,
-    private revalidateBasketUpdater: BaseRevalidateBasketUpdater<RVB_Q>,
-    private setBasketItemMiGroupUpdater: BaseSetBasketItemMiGroupUpdater<SBMI_Q>,
-    private setBasketItemMiValueUpdater: BaseSetBasketItemMiValueUpdater<SVMI_Q>,
-    private validateMiFreeValue: BaseValidateMiFreeValueTester<VMI_Q>,
-    private sendBasketForApprovalUpdater: BaseSendBasketForApprovalUpdater<SBA_Q>,
-    private getUserFetcher: BaseGetUserFetcher<GU_Q>,
-    private getUserBasketsFetcher: BaseGetUserBasketsFetcher<GUB_Q>,
-    private SetBasketItemLeadPassenger: BaseSetBasketItemLeadPassengerUpdater<SBLP_Q>,
-    private moveItemToADifferentBasket: BasemoveBasketItemToBasket<MITDB_Q>,
-    private updateBasketNotesUpdater: BaseUpdateBasketNoteUpdater<UBN_Q>,
-    private updateBasketTitleUpdater: BaseUpdateBasketTitleUpdater<UBT_Q>,
-    private setPaymentMethodUpdater: BaseSetPaymentOptionUpdater<SBM_Q>,
-    private userService: UserServiceInterface,
-    private modalService: BaseModalOpenerService
-  ) {
-    this.userService.changeUser.subscribe({
-      next: (userDetails: FullUserDetails) => {
-        this.reset();
-      }
-    });
-  }
-
-  public reset() {
-    if (this.userService.getfullUserDetails(false).userData.value) {
-      this.getUserBasketsFetcher
-        .fetchList({
-          basketStatus: BasketStatus.Open,
-          user: this.userService
-            .getfullUserDetails(true)
-            .userData.value.user_id.toString()
-        })
-        .pipe(take(1))
-        .subscribe(
-          (baskets: UserBasketResult[]) => {
-            this.currentBaskets = baskets.map((basket: UserBasketResult) => {
-              if (basket) {
-                let intBasket = this.findBasket(basket.id);
-                if (!intBasket) {
-                  intBasket = new InternalBasket(
-                    basket,
-                    this.helpers,
-                    this,
-                    this.getUserFetcher
-                  );
-
-                  this.currentBaskets.push(intBasket);
-                }
-                return intBasket;
-              }
-            });
-
-            this.baskets.next(this.currentBaskets);
-
-            if (this.currentBaskets.length > 0) {
-              this.currentBasketID = this.currentBaskets[0].id;
-            } else {
-              this.currentBasketID = null;
-            }
-
-            this.basketChangeEmitter.next(this.currentBasketID);
-          },
-          (error: any) => {
-            console.error(error);
-          }
-        );
-    } else {
-      this.currentBaskets.forEach((basket: InternalBasketInterface) =>
-        basket.subject.unsubscribe()
-      );
-      this.currentBaskets = [];
-      this.currentBasketID = null;
-      this.baskets.next(this.currentBaskets);
-      this.basketChangeEmitter.next(this.currentBasketID);
-    }
-  }
-
-  public async getAllOpenBaskets(user_id: string): Promise<UserBasketResult[]> {
-    // let intBasket = this.findBasket(user_id)
-    return this.getUserBasketsFetcher
-      .fetchList({ basketStatus: BasketStatus.Open, user: user_id })
-      .pipe(
-        take(1),
-        map((results: UserBasketResult[]) => {
-          if (results.length) {
-            results.forEach((result: UserBasketResult) => {
-              if (!this.findBasket(result.id)) {
-                const intBasket = new InternalBasket(
-                  result,
-                  this.helpers,
-                  this,
-                  this.getUserFetcher
-                );
-                this.currentBaskets.push(intBasket);
-              }
-            });
-          } else {
-            const intBasket = new InternalBasket(
-              {
-                id: user_id,
-                basketItems: []
-              } as BasketDetails,
-              this.helpers,
-              this,
-              this.getUserFetcher
-            );
-            this.currentBaskets.push(intBasket);
-          }
-
-          return results;
-        })
-      )
-      .toPromise();
-  }
-
-  public async addToBasket(
-    item: AddItemToBasket.Variables,
-    intBasket: InternalBasket<GU_Q>,
-    searchService: EnterpriseSearchServiceInterface,
-    travellers: Traveller[] = []
-  ): Promise<boolean> {
-    if (travellers?.length > 0) {
-      item.users = this.helpers.makeUsers(travellers);
-      item.leadPassenger = item.users[0].id;
-    }
-    item = this.checkDetails(item);
-    if (item && intBasket) {
-      this.addItemToBasketUpdater
-        .updateOne(item)
-        .pipe(take(1))
-        .subscribe(
-          (newBasket: Partial<UserBasketResult>) => {
-            intBasket.next({
-              ...intBasket.subject.value,
-              ...newBasket
-            });
-            const service = this.userService.findService(item.service).type;
-            searchService.search_objects[service].booking_chosen = true;
-            searchService.search_objects[service].chosen = false;
-            const bi: GetUserBasketItemResult[] = newBasket.basketItems;
-            this.highlightBasketItemsEmitter.next(bi);
-            this.basketChangeEmitter.next(this.currentBasketID);
-          },
-          (error: any) => {
-            console.error(error);
-            intBasket.subject.next(intBasket.subject.value);
-          }
-        );
-    }
-    return false;
-  }
-
-  loadBasket(id: string): void {
-    let intBasket = this.findBasket(id);
-    if (!intBasket) {
-      intBasket = new InternalBasket(
-        {
-          id,
-          basketItems: []
-        } as BasketDetails,
-        this.helpers,
-        this,
-        this.getUserFetcher
-      );
-      this.currentBaskets.push(intBasket);
-    }
-    this.basketFetcher
-      .fetchOne({ id })
-      .subscribe((newBasket: UserBasketResult) => {
-        intBasket.next(newBasket);
-      });
-  }
-
-  subsribeToBasket(id: string, observer: Observer<BasketDetails>): void {
-    const intBasket = this.findBasket(id);
-    if (intBasket) {
-      intBasket.subject.subscribe(observer);
-    }
-  }
-
-  removeExpiredItems(id: string): void {
-    const intBasket = this.findBasket(id);
-    intBasket.subject.value.basketItems
-      .filter((basketItem: BasketItem): boolean => {
-        return (
-          basketItem.latestValidationPriceDifference !== 0 || basketItem.expired
-        );
-      })
-      .forEach((basketItem: BasketItem) => {
-        this.removeBasketItem(id, basketItem);
-      });
-  }
-
-  removeBasketItem(basketId: string, item: BasketItem): void {
-    const intBasket: InternalBasket<GU_Q> = this.findBasket(basketId);
-    this.removeItemFromBasketUpdater
-      .updateOne({ basketItem: item.id })
-      .subscribe((newBasket: Basket) => {
-        intBasket.next({
-          ...intBasket.subject.value,
-          ...newBasket
-        });
-        this.basketChangeEmitter.next(basketId);
-      });
-  }
-
-  public async getDefaultBasket(
-    getBookedBasket: boolean = false
-  ): Promise<InternalBasket<GU_Q>> {
-    const internalBasket: InternalBasket<GU_Q> = null;
-    // console.log(this.currentBasketID);
-    return await this.findOrCreateBasket(
-      this.currentBasketID,
-      getBookedBasket
-    ).then((data) => {
-      return data;
-    });
-  }
-
-  private findBasket(id: string): InternalBasket<GU_Q> {
-    return this.currentBaskets.find((basket: InternalBasket<GU_Q>) => {
-      return basket.id === id || basket.tempid === id;
-    });
-  }
-
-  private async findOrCreateBasket(
-    id?: string,
-    getBookedBasket: boolean = false
-  ): Promise<InternalBasket<GU_Q>> {
-    let basket: InternalBasket<GU_Q> = null;
-    if (!id) {
-      const allOpenBaskets = await this.getAllOpenBaskets(
-        this.userService
-          .getfullUserDetails(true)
-          .userData.value.user_id.toString()
-      );
-
-      // find the last updated basket
-      if (!allOpenBaskets?.length) {
-        basket = await this.createBasket();
-        this.currentBaskets.push(basket);
-        this.baskets.next(this.currentBaskets);
-      } else {
-        // baskets are already sorted by last updated - return the last updated basket
-        basket = this.findBasket(allOpenBaskets[0].id);
-
-        if (basket.subject.value.status === 'BOOKED' && !getBookedBasket) {
-          console.warn(
-            '+++ Retrieved basket is in booked status - creating a new one +++'
-          );
-          basket = await this.createBasket();
-          this.currentBaskets.push(basket);
-        }
-        this.baskets.next(this.currentBaskets);
-      }
-    } else {
-      basket = this.findBasket(id);
-      // console.log('+++ Found Basket: ', basket, ' +++');
-    }
-
-    return basket;
-  }
-
-  public async createBasket(): Promise<InternalBasket<GU_Q>> {
-    const basket: UserBasketResult = {
-      id: TEMPID + moment().unix().toString(),
-      owner: null,
-      reference: null,
-      title: null,
-      notes: null,
-      createdAt: null,
-      updatedAt: null,
-      basketItems: [],
-      status: null,
-      validated: false
-    };
-
-    const intBasket = new InternalBasket<GU_Q>(
-      basket,
-      this.helpers,
-      this,
-      this.getUserFetcher
-    );
-    // { subject: new BehaviorSubject<Basket>(basket), tempid: basket.id, id: basket.id, title: basket.id };
-
-    const toReturn = await this.createBasketOnDB(intBasket);
-    this.currentBaskets.push(toReturn);
-    this.baskets.next(this.currentBaskets);
-    this.basketChangeEmitter.next(toReturn.id);
-    return toReturn;
-  }
-
-  private createBasketOnDB(
-    intBasket: InternalBasket<GU_Q>
-  ): Promise<InternalBasket<GU_Q>> {
-    return new Promise((resolve, reject) => {
-      this.basketCreator
-        .updateOne({})
-        .pipe(take(1))
-        .subscribe(
-          (basket: UserBasketResult) => {
-            intBasket.id = basket.id;
-            intBasket.next(basket);
-            resolve(intBasket);
-          },
-          (error: any) => {
-            reject(error);
-          },
-          () => {}
-        );
-    });
-  }
-
-  toggleMenu(): void {
-    if (
-      this.menuState === MenuSlideEnum.IN ||
-      this.menuState === MenuSlideEnum.FLAT
-    ) {
-      this.menuState = MenuSlideEnum.OUT;
-    } else {
-      this.menuState = MenuSlideEnum.IN;
-    }
-  }
-
-  closeMenu(): void {
-    this.menuState = MenuSlideEnum.IN;
-  }
-
-  getLatestBasketItemForTypes(
-    basketItems: BasketItem[]
-  ): Record<ServiceType, BasketItem> {
-    return (basketItems || []).reduce(
-      (
-        latestItems: Record<ServiceType, BasketItem>,
-        basketItem: BasketItem
-      ) => {
-        latestItems[basketItem.service.type] = basketItem;
-        return latestItems;
-      },
-      {} as Record<ServiceType, BasketItem>
-    );
-  }
-
-  private checkDetails(
-    item: AddItemToBasket.Variables
-  ): AddItemToBasket.Variables {
-    const serviceToCheck: Service = this.userService.findService(item.service);
-    if (!serviceToCheck) {
-      console.error('Unable to find service for basket item : ' + item.service);
-      return null;
-    }
-
-    // check the item.detail object against the relevant service detailSchema using Ajv
-    const ajv = new Ajv();
-    const validateDetailSchema = ajv.compile(serviceToCheck.detailSchema);
-    const validateSearchSchema = ajv.compile(serviceToCheck.searchQuerySchema);
-
-    // if there are any moment date objects in the searchQuery object convert these to date-time strings
-    item.searchQuery = this.helpers.sanitizeMomentDates(item.searchQuery);
-
-    if (!validateSearchSchema(item.searchQuery)) {
-      const error = `Item searchQuery is not valid for ${serviceToCheck.name} search schema.`;
-      console.warn('searchSchema', serviceToCheck.searchQuerySchema);
-      console.warn('item.searchQuery', item.searchQuery);
-      console.log(validateSearchSchema.errors);
-      this.modalService.open(ModalTypes.ModalErrorComponent, {}, { error });
-      return null;
-    }
-
-    if (!validateDetailSchema(item.detail)) {
-      const error = `Item detail is not valid for ${serviceToCheck.name} detail schema.`;
-      console.warn('detailSchema', serviceToCheck.detailSchema);
-      console.warn('item.detail', item.detail);
-      console.log('Schema errors', validateDetailSchema.errors);
-      this.modalService.open(ModalTypes.ModalErrorComponent, {}, { error });
-      return null;
-    }
-    return item;
-  }
-
-  getNumberItemsForBasket(basket: InternalBasket<GU_Q> = null): number {
-    basket = basket || this.findBasket(this.currentBasketID);
-    return basket?.subject.value.basketItems.length || 0;
-  }
-
-  async removeBasket(basketid: string) {
-    if (basketid) {
-      await this.deleteBasketUpdater
-        .updateOne({ id: basketid })
-        .pipe(
-          take(1),
-          switchMap((data: any): any => {
-            this.findBasket(basketid)?.destructor();
-            this.currentBaskets = this.currentBaskets.filter((intBa) => {
-              return intBa.id !== basketid;
-            });
-            this.baskets.next(this.currentBaskets);
-            if (basketid === this.currentBasketID) {
-              this.currentBasketID = this.currentBaskets[0]?.id || null;
-              this.basketChangeEmitter.next(this.currentBasketID);
-            }
-            return data;
-          })
-        )
-        .toPromise();
-    }
-  }
-
-  continueSearchAndBook(
-    basketItems: any[],
-    itiniaryUrl: string[],
-    searchService: EnterpriseSearchServiceInterface
-  ): string[] {
-    const latestBasketItems = this.getLatestBasketItemForTypes(basketItems);
-    const nextSearch: SearchObject =
-      searchService.getHighestSearchPriorityObject(latestBasketItems);
-    if (nextSearch) {
-      (searchService.searches as any)[
-        nextSearch.type
-      ].updateFromPreviousSearches(latestBasketItems);
-      return [nextSearch.searchUrl];
-    } else {
-      return itiniaryUrl;
-    }
-  }
-
-  addTravellers(
-    basketid: string,
-    basketItem: BasketItem,
-    travellers: Traveller[],
-    index: number = 0
-  ): void {
-    const basket = this.findBasket(basketid);
-    if (index < travellers.length) {
-      const traveller = travellers[index];
-      const passengerType: PassengerType = traveller.isChild
-        ? PassengerType.Child
-        : traveller.isInfant
-        ? PassengerType.Infant
-        : PassengerType.Adult;
-
-      this.addUserToBasketItem
-        .updateOne({
-          basketItem: basketItem.id,
-          users: [
-            {
-              id: traveller.id,
-              passengerType
-            }
-          ],
-          withSupplemental: false
-        })
-        .subscribe(
-          () => {},
-          () => {},
-          () => {
-            this.addTravellers(basket.id, basketItem, travellers, index + 1);
-          }
-        );
-    } else {
-      this.basketFetcher.fetchOne({ id: basket.id }).subscribe(
-        (basket1: GetUserBasketResult) => {
-          basket.subject.next({ ...basket.subject.value, ...basket1 });
-        },
-        (_) => {},
-        () => {
-          basket.next(basket.subject.value);
-        }
-      );
-    }
-  }
-
-  setLeadPassenger(
-    basketid: string,
-    basketItem: BasketItem,
-    travellers: Traveller,
-    index: number = 0
-  ): void {
-    const basket = this.findBasket(basketid);
-    if (index < 1) {
-      this.SetBasketItemLeadPassenger.updateOne({
-        id: basketItem.id,
-        user: travellers.id,
-        withSupplemental: false
-      }).subscribe(
-        () => {},
-        () => {},
-        () => {
-          this.setLeadPassenger(basket.id, basketItem, travellers, index + 1);
-        }
-      );
-    } else {
-      this.basketFetcher.fetchOne({ id: basket.id }).subscribe(
-        (basket1: GetUserBasketResult) => {
-          basket.subject.next({ ...basket.subject.value, ...basket1 });
-        },
-        (_) => {},
-        () => {
-          basket.next(basket.subject.value);
-        }
-      );
-    }
-  }
-
-  updateBasket(
-    basketid: string,
-    obs: Observable<BasketDetails>
-  ): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      obs.pipe(take(1)).subscribe(
-        (basket: BasketDetails) => {
-          const intBasket = this.findBasket(basketid);
-          intBasket.next(basket);
-          resolve();
-        },
-        (error: any) => {
-          console.error(error);
-          const intBasket = this.findBasket(basketid);
-          intBasket.next(intBasket.subject.value);
-          reject(error);
-        },
-        () => {}
-      );
-    });
-  }
-
-  revalidate(basketid: string): void {
-    this.updateBasket(
-      basketid,
-      this.revalidateBasketUpdater.updateOne({ id: basketid })
-    );
-  }
-
-  setBasketItemMiGroup(
-    basketid: string,
-    basketItemid: string,
-    group: string
-  ): void {
-    this.updateBasket(
-      basketid,
-      this.setBasketItemMiGroupUpdater.updateOne({
-        basketItem: basketItemid,
-        group
-      })
-    );
-  }
-
-  acceptNewPrice(basketid: string, item: BasketItem): void {
-    this.updateBasket(
-      basketid,
-      this.acceptNewPriceUpdater.updateOne({ id: item.id })
-    );
-  }
-
-  validateFreeValeMi(
-    miItem: ManagementInfo,
-    freeValue: string
-  ): Promise<boolean> {
-    return new Promise((resolve, reject) => {
-      this.validateMiFreeValue
-        .test({ mi: miItem.id, freeValue })
-        .subscribe(resolve, reject);
-    });
-  }
-
-  setMiFreeValue(
-    basketid: string,
-    miItem: ManagementInfo,
-    freeValue: string,
-    userId: string = null
-  ) {
-    const intBasket = this.findBasket(basketid);
-    const args: SetBasketItemMiValue.Variables = {
-      mi: miItem.id,
-      miFreeValue: freeValue
-    };
-    if (!!userId) {
-      args.user = userId;
-    }
-    this.setBasketItemMiValueUpdater
-      .updateOne(args)
-      .pipe(take(1))
-      .subscribe(
-        (basket: BasketDetails) => {
-          intBasket.next(basket);
-        },
-        (_) => {},
-        () => {
-          intBasket.next(intBasket.subject.value);
-        }
-      );
-  }
-
-  setMiSelectedValue(
-    basketid: string,
-    miItem: ManagementInfo,
-    selectedValue: string,
-    userId: string = null
-  ) {
-    const args: SetBasketItemMiValue.Variables = {
-      mi: miItem.id,
-      miValue: selectedValue
-    };
-    if (!!userId) {
-      args.user = userId;
-    }
-    this.updateBasket(
-      basketid,
-      this.setBasketItemMiValueUpdater.updateOne(args)
-    );
-  }
-
-  getMiAutoSugestions(
-    miId: string,
-    partialLabel: string,
-    isLoading: BehaviorSubject<boolean>
-  ): Observable<GetMiAutoSugestionArray> {
-    isLoading?.next(true);
-
-    return this.getMiAutoSugestionFetcher
-      .fetchList({ mi: miId, partialLabel })
-      .pipe(
-        tap((_) => {
-          isLoading?.next(false);
-        })
-      );
-  }
-
-  saveMiData(basketId: string, bmiArray: BasketItemManagementInfo[]) {
-    bmiArray.forEach((bmi: BasketItemManagementInfo) => {
-      bmi.miPerItem.forEach((item: ManagementInfoAndIsValid) => {
-        item.save(basketId, null);
-      });
-      bmi.users.forEach((user: string) => {
-        bmi.miPerUser[user].managementInfo.forEach(
-          (item: ManagementInfoAndIsValid) => {
-            item.save(basketId, user);
-          }
-        );
-      });
-    });
-  }
-
-  sendBasketForApproval(basketid: string) {
-    this.updateBasket(
-      basketid,
-      this.sendBasketForApprovalUpdater
-        .updateOne({ basket: basketid })
-        .pipe(take(1))
-    );
-  }
-
-  setBasketItemPaymentOption(
-    basket: BasketDetails,
-    basketItem: BasketItem,
-    paymentMethod: string
-  ): Promise<void> {
-    return this.updateBasket(
-      basket.id,
-      this.setPaymentMethodUpdater.updateOne({
-        basketItem: basketItem.id,
-        paymentMethod
-      })
-    );
-  }
-
-  bookBasket(basketid: string, supplementaryInfo: SupplementaryBookingInfo[]) {
-    this.updateBasket(
-      basketid,
-      this.bookBasketUpdater.updateOne({ id: basketid, supplementaryInfo })
-    );
-  }
-
-  moveBasketItem(
-    originalBasketId: string,
-    basketItem: BasketItem,
-    basketIdToMoveTo: string
-  ): void {
-    this.moveItemToADifferentBasket
-      .updateOne({
-        basketItem: basketItem.id,
-        newBasket: basketIdToMoveTo
-      })
-      .subscribe(() => {
-        this.loadBasket(originalBasketId);
-        this.loadBasket(basketIdToMoveTo);
-      });
-  }
-
-  updateBasketNotes(basketId: string, notes: string): void {
-    this.updateBasket(
-      basketId,
-      this.updateBasketNotesUpdater.updateOne({ id: basketId, notes })
-    );
-  }
-
-  updateBasketTitle(basketId: string, title: string): void {
-    this.updateBasket(
-      basketId,
-      this.updateBasketTitleUpdater.updateOne({ id: basketId, newTitle: title })
-    );
-  }
-  getBasket(query: {
-    id: string;
-    withSupplemental: true;
-  }): Observable<GetUserBasketResult> {
-    return this.basketFetcher.fetchOne(query);
-  }
-
-  atLeastOneSearchChosen(): boolean {
-    const intBasket: InternalBasketInterface = this.findBasket(
-      this.currentBasketID
-    );
-    return intBasket?.subject.value.basketItems.length > 0;
-  }
-
-  public getBasketStats(index: number): BehaviorSubject<BasketPrices> {
-    const basketPricesObj =
-      this.baskets.value[index]?.subject?.value?.prices || {};
-    const basketPricesKey = Object.keys(basketPricesObj)[0];
-    if (basketPricesKey) {
-      this.basketPrices.value.currency = basketPricesKey;
-      this.basketPrices.value.total =
-        this.baskets.value[index].subject.value.prices[basketPricesKey];
-    } else {
-      this.basketPrices.value.total = 0;
-    }
-
-    this.basketPrices.value.list.forEach((keys) => {
-      keys.price = this.baskets.value[index]?.subject?.value?.basketItems
-        .filter((item) => item.service.type === keys.type)
-        .reduce((sum, current) => sum + current.price, 0);
-    });
-    return this.basketPrices;
-  }
-}
-
-interface DetailSchemaProperties {
-  type?: 'string' | 'number' | 'integer' | 'array';
-  $ref?: string;
-  format?: string;
-}
-interface DetailSchema {
-  $defs?: { [key: string]: DetailSchema };
-  additionalProperties: boolean;
-  properties: { [key: string]: DetailSchemaProperties };
-  required: string[];
-}