@sabstravtech/obtservices 0.0.0

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

@@ -0,0 +1,1150 @@
+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[];
+}