@sabstravtech/obtservices 0.0.0

package/projects/obtservices/base/src/lib/vendor/classes/helpers.ts

@@ -0,0 +1,1233 @@
+import moment from 'moment';
+import _ from 'lodash';
+
+import { Traveller } from '../models/traveller.object';
+
+import {
+  BasketDetails,
+  BasketItemManagementInfo
+} from '../services/enterprise-basket.service';
+import { ManagementInfoAndIsValid } from './management-info-and-valid';
+import { UserServices } from '../interfaces/Iuser.service';
+import {
+  FlightDirectionEnum,
+  MinMax,
+  NgbDateStruct,
+  Schema
+} from '../types/types';
+import {
+  Airport,
+  BasketItem,
+  FareConditions,
+  FlightItinerary,
+  FlightJourney,
+  PassengerType,
+  Service,
+  ServiceType,
+  UserPassengerTypeInput
+} from '../types/graphql.types';
+import { SupplementaryBookingInfoInterface } from '../interfaces/Isupplementary-booking-info-impl';
+import { Memorise } from './limited-cache.class';
+
+declare var hex_hmac_md5: any;
+
+const FLIGHT_MAX_CHILD_AGE_YEARS = 16;
+const RAIL_MAX_CHILD_AGE_YEARS = 12;
+const EUROSTAR_MAX_CHILD_AGE_YEARS = 12;
+const COACH_MAX_CHILD_AGE_YEARS = 15;
+const LOUNGES_MAX_CHILD_AGE_YEARS = 12;
+const FLIGHT_MAX_INFANT_AGE_YEARS = 0;
+const RAIL_MAX_INFANT_AGE_YEARS = 0;
+const COACH_MAX_INFANT_AGE_YEARS = 0;
+const LOUNGES_MAX_INFANT_AGE_YEARS = 0;
+
+const months = [
+  'Jan',
+  'Feb',
+  'Mar',
+  'Apr',
+  'May',
+  'Jun',
+  'Jul',
+  'Aug',
+  'Sep',
+  'Oct',
+  'Nov',
+  'Dec'
+];
+
+const full_months = [
+  'January',
+  'February',
+  'March',
+  'April',
+  'May',
+  'June',
+  'July',
+  'August',
+  'September',
+  'October',
+  'November',
+  'December'
+];
+
+const weekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+
+const full_weekdays = [
+  'Sunday',
+  'Monday',
+  'Tuesday',
+  'Wednesday',
+  'Thursday',
+  'Friday',
+  'Saturday'
+];
+
+export class BaseHelperRoutines {
+  static READ_DATE_FORMAT = 'dd, D MMM YYYY';
+  static READ_TIME_FORMAT = 'HH:mm';
+  static DATE_FORMAT = 'YYMMDD';
+  static ISO_DATA_FORMAT = 'YYYY-MM-DD';
+  static ISO_DATA_FORMAT_TIME = 'YYYY-MM-DD HH:mm';
+  static ISO_DATA_FORMAT_NO_HYPHANS = 'YYYYMMDD';
+  static TIME_FORMAT = 'HHmm';
+  static TIME_FORMAT_COLON = 'HH:mm';
+  static MMDDYY_DATE = 'DDMMYYYY';
+
+  minToHour(dur: number) {
+    return `${Math.floor(dur / 60)}h ${dur % 60}m`;
+  }
+
+  makeColonTime(time: string) {
+    return time.substring(0, 2) + ':' + time.substring(2, 4);
+  }
+
+  nonNullMin(key: string, ...args: any[]) {
+    return args.reduce(
+      (current, item) => {
+        if (item && item[key]) {
+          if (current.min > Number(item[key])) {
+            return { item, min: Number(item[key]) };
+          }
+        }
+        return current;
+      },
+      { min: Number.MAX_SAFE_INTEGER, item: null }
+    ).item;
+  }
+
+  joinByComma(...attributes: any[]): string {
+    return attributes
+      .reduce((acc, attr) => {
+        if (_.isEmpty(attr)) {
+          acc += attr + ',';
+        }
+        return acc;
+      }, '')
+      .slice(0, -1);
+  }
+
+  mutuallyInclude(a: string, b: string): boolean {
+    try {
+      return a.includes(b) || b.includes(a);
+    } catch (e) {
+      console.warn('Trying to mutually compare undefined variable.');
+      return false;
+    }
+  }
+
+  findByKey(array: any[], key: string, value: string): any {
+    return array
+      .filter((item) => {
+        return item[key] === value;
+      })
+      .pop();
+  }
+
+  dateToNgDate(date: Date): NgbDateStruct {
+    return {
+      year: date.getFullYear(),
+      month: date.getMonth() + 1,
+      day: date.getDate()
+    };
+  }
+
+  convertToYYMMDD(date: string) {
+    if (date.length > 6) {
+      return this.formatDate(this.yyyymmddTimeToMoment(date));
+    }
+    return date;
+  }
+
+  formatDateToMMDDYYY(date: Date): string {
+    return moment(date).format(BaseHelperRoutines.MMDDYY_DATE);
+  }
+
+  formatDate(date: moment.Moment): string {
+    date = moment(date);
+    return date.format(BaseHelperRoutines.DATE_FORMAT);
+  }
+
+  formatTime(date: moment.Moment): string {
+    try {
+      return date.format(BaseHelperRoutines.TIME_FORMAT);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  formatTimeColon(date: moment.Moment): string {
+    date = moment(date);
+    return date.format(BaseHelperRoutines.TIME_FORMAT_COLON);
+  }
+
+  formatIsoDate(date: moment.Moment): string {
+    date = moment(date);
+    return date.format(BaseHelperRoutines.ISO_DATA_FORMAT);
+  }
+
+  formatIsoDateTime(date: moment.Moment): string {
+    date = moment(date);
+    return date.format(BaseHelperRoutines.ISO_DATA_FORMAT_TIME);
+  }
+
+  formatIsoDateNoHyphans(date: moment.Moment): string {
+    date = moment(date);
+    return date.format(BaseHelperRoutines.ISO_DATA_FORMAT_NO_HYPHANS);
+  }
+
+  generateTimesList(from = 0, to = 24, step = 15): string[] {
+    const dateTimeArray: string[] = [];
+    for (let hour = 0; hour < to - from; hour++) {
+      for (let minute = 0; minute < 60; minute += step) {
+        dateTimeArray.push(moment({ hour, minute }).format('HH:mm'));
+      }
+    }
+    return dateTimeArray;
+  }
+
+  momentToNgDate(date: moment.Moment): NgbDateStruct {
+    date = moment(date);
+    return this.dateToNgDate(date.toDate());
+  }
+
+  ngDateToDate(date: NgbDateStruct): Date {
+    return new Date(date.year, date.month - 1, date.day);
+  }
+
+  ngDateToMoment(date: NgbDateStruct, time?: string): moment.Moment {
+    const mom = moment(this.ngDateToDate(date));
+    if (time) {
+      const times = time.split(':');
+      if (times.length === 2) {
+        mom.set('hours', Number(times[0])).set('minutes', Number(times[1]));
+      } else {
+        mom
+          .set('hours', Number(time.substr(0, 2)))
+          .set('minutes', Number(time.substr(2, 2)));
+      }
+    }
+    return mom;
+  }
+
+  todayToNgbDateStruct(): NgbDateStruct {
+    const today = moment();
+    return { year: today.year(), month: today.month() + 1, day: today.date() };
+  }
+
+  objectToArray(object: Record<string, any>): Array<any> {
+    return Object.keys(object).map((i) => object[i]);
+  }
+
+  yyyymmddToDate(value: string): Date {
+    return new Date(
+      Number(value.substring(0, 4)),
+      Number(value.substring(4, 6)) - 1,
+      Number(value.substring(6, 8))
+    );
+  }
+
+  yyyymmddToMoment(value: string): moment.Moment {
+    return moment(this.yyyymmddToDate(value));
+  }
+
+  yymmddToMoment(value: string): moment.Moment {
+    return moment(value, 'YYMMDD');
+  }
+
+  yymmddToNgbDate(value: string): NgbDateStruct {
+    return this.momentToNgDate(this.yymmddToMoment(value));
+  }
+
+  yymmdd_hhmmToMoment(date: string, time: string): moment.Moment {
+    return moment(`${date} ${time}`, 'YYMMDD HHmm');
+  }
+
+  yyyymmdd_hhmmToMoment(date: string, time: string): moment.Moment {
+    return moment(`${date} ${time}`, 'YYYYMMDD HHmm');
+  }
+
+  yyyymmddToNgDate(value: string): NgbDateStruct {
+    return this.dateToNgDate(this.yyyymmddToDate(value));
+  }
+
+  yyyymmddTimeToNgDate(date: string, time: string): NgbDateStruct {
+    const dt = this.yyyymmddToMoment(date)
+      .add(Number(time.substring(0, 2)), 'hours')
+      .add(Number(time.substring(2, 4)), 'minutes');
+    return this.momentToNgDate(dt);
+  }
+
+  yyyymmddTimeToMoment(date: string): moment.Moment {
+    if (date.length === 6) {
+      return moment(`${date}`, 'YYMMDD');
+    }
+    return moment(`${date}`, 'YYYYMMDD');
+  }
+
+  hhmmToTime(value: string): string {
+    return `${value.substring(0, 2)}:${value.substring(2, 4)}`;
+  }
+
+  dateStringToyyyymmdd(d: string): string | null {
+    if (typeof d !== 'string') {
+      return null;
+    }
+    const m = /(\d{4})[-\/]?(\d{2})[-\/]?(\d{2})/.exec(d);
+    return m ? `${m[1]}${m[2]}${m[3]}` : null;
+  }
+
+  timeStringTohh_mm(t: string): string | null {
+    if (typeof t !== 'string') {
+      return null;
+    }
+    const m = /(\d{2})[:-]?(\d{2})/.exec(t);
+    return m ? `${m[1]}:${m[2]}` : null;
+  }
+
+  stringToBool(s: string): boolean {
+    return s && s !== 'false' && s !== '0' && s !== 'no' && s !== 'n';
+  }
+
+  clone<T = any>(toClone: T): T {
+    return _.cloneDeep(toClone) as T;
+  }
+
+  replaceKeysInText(
+    text: string,
+    replacements: Record<string, string>
+  ): string {
+    return Object.keys(replacements).reduce((current, key) => {
+      return current.replace('%' + key, replacements[key]);
+    }, text);
+  }
+
+  getNextMinuets(date: moment.Moment = moment(), minutesToRound = 15) {
+    date.minute(Math.ceil(date.minute() / minutesToRound) * minutesToRound);
+    return date.format('HH:mm');
+  }
+  /********************************************************************************************
+   * Below are functions needed for generating the hashed number once token, taken as required	*
+   * Don't Mess with these																		*
+   ********************************************************************************************/
+  getNumberOnceValue(token: string): string {
+    const random_value = this.guid();
+    return random_value + '_' + hex_hmac_md5(token, random_value);
+  }
+
+  guid(): any {
+    let random_hex = '';
+
+    for (let i = 0; i < 32; i++) {
+      random_hex += this.s4();
+    }
+
+    return random_hex;
+  }
+
+  s4(): any {
+    return Math.floor((1 + Math.random()) * 0x10000)
+      .toString(16)
+      .substring(1);
+  }
+
+  capitaliseFirstLetter(word: string): string {
+    if (word.length > 0) {
+      return word[0].toUpperCase() + word.slice(1).toLowerCase();
+    } else {
+      return '';
+    }
+  }
+
+  fromObject(...args: any[]): any {
+    let data = args.shift();
+    for (let index = 0; data && index < args.length; index += 1) {
+      data = data[args[index]];
+    }
+    return data;
+  }
+
+  momentRoundMinutes(time: moment.Moment, round: number): moment.Moment {
+    time = moment(time).startOf('minutes');
+    let diff = time.minutes() % round;
+    if (diff !== 0) {
+      diff = round - diff;
+    }
+    return time.add(diff, 'minute');
+  }
+
+  round(date: any, duration: any) {
+    return moment(Math.ceil(+date / +duration) * +duration);
+  }
+
+  icsFold(body: string): string {
+    const lines = body.split(/\r\n/g);
+    return lines
+      .map((line) => {
+        let res = '';
+        const n = 72;
+        line = line.trim();
+        while (line.length > n) {
+          res += `${line.slice(0, n)}\r\n`;
+          line = ` ${line.slice(n).trim()}`;
+        }
+        if (line.trim()) {
+          res += line;
+        }
+        return res;
+      })
+      .join('\r\n');
+  }
+
+  splitAddressLine(
+    line: string,
+    len: number
+  ): { line: string; residue: string } {
+    const res = {
+      line: line.replace(/\s+/g, ' ').trim(),
+      residue: ''
+    };
+    if (res.line.length > len) {
+      let i = res.line.slice(0, len).lastIndexOf(',');
+      if (i > 0) {
+        res.residue = res.line.slice(i + 1).trim();
+        res.line = res.line.slice(0, i).trim();
+      } else {
+        i = res.line.slice(0, len).lastIndexOf(' ');
+        if (i > 0) {
+          res.residue = res.line.slice(i + 1).trim();
+          res.line = res.line.slice(0, i);
+        } else {
+          res.residue = res.line.slice(len);
+          res.line = res.line.slice(0, len);
+        }
+      }
+    }
+    return res;
+  }
+
+  daysBetween(start: moment.Moment, end: moment.Moment): number {
+    return end.diff(start, 'days');
+  }
+
+  mapPromise<T = any, R = any>(
+    a: T[],
+    f: (val: T, index: number) => R | Promise<R>,
+    max?: number
+  ): Promise<R[]> {
+    const it = a[Symbol.iterator]();
+    const result: R[] = [];
+    const buffer: Promise<R>[] = [];
+    let i = 0;
+    const nextf = (): Promise<R> => {
+      const next = it.next();
+      if (next.done) {
+        return;
+      }
+      const index = i++;
+      return Promise.resolve(f(next.value, index)).then((val) => {
+        result[index] = val;
+        return nextf();
+      });
+    };
+    while (!max || buffer.length <= max) {
+      const n = nextf();
+      if (n) {
+        buffer.push(n);
+      } else {
+        break;
+      }
+    }
+    return Promise.all(buffer).then(() => {
+      return result;
+    });
+  }
+
+  mapSeriesPromise<T = any, R = any>(
+    a: T[],
+    f: (val: T, index: number) => R | Promise<R>
+  ): Promise<R[]> {
+    return this.mapPromise(a, f, 1);
+  }
+
+  obj2queryString(obj: any): string {
+    return _.reduce(
+      obj,
+      (a, v, k) => {
+        if (a !== '') {
+          a += '&';
+        }
+        return `${a}${encodeURIComponent(k)}=${encodeURIComponent(v)}`;
+      },
+      ''
+    );
+  }
+
+  stripPunctuation(s: string): string {
+    return s.replace(/[^a-zA-Z0-9\s]/g, '');
+  }
+
+  replaceAll(haystack: string, needle: string, replacement: string): string {
+    return haystack
+      ? haystack.replace(new RegExp(needle, 'g'), replacement)
+      : null;
+  }
+
+  dateTime(sabsDate: string, sabsTime: string): any {
+    const tempDate = sabsDate.match(/.{1,2}/g); // splits every 2 characters
+    const tempTime = sabsTime.match(/.{1,2}/g);
+
+    const newStr =
+      '20' +
+      tempDate[0] +
+      '-' +
+      tempDate[1] +
+      '-' +
+      tempDate[2] +
+      'T' +
+      tempTime[0] +
+      ':' +
+      tempTime[1] +
+      ':00';
+    return newStr;
+  }
+
+  alternateJSONStringify(jsonObject: any): string {
+    let jsonString = JSON.stringify(jsonObject);
+    jsonString = jsonString.replace(/"/g, '`');
+    return jsonString;
+  }
+
+  // Convert object to array
+  ConvertObjectToArray(object: object): any[] {
+    let array = _.values(object);
+    array = _.flatten(array);
+    return array;
+  }
+
+  addDay(dateStruct: NgbDateStruct): any {
+    const date = new Date(
+      dateStruct.year,
+      dateStruct.month - 1,
+      dateStruct.day + 1
+    );
+    const retDate = {
+      year: date.getFullYear(),
+      month: date.getMonth() + 1,
+      day: date.getDate()
+    };
+    //// console.log(retDate);
+    //// console.log(date);
+    return retDate;
+  }
+
+  hashCode(toCode: string): string {
+    let hash = 0;
+
+    for (let i = 0; i < toCode.length; i += 1) {
+      const char = toCode.charCodeAt(i);
+      // tslint:disable-next-line: no-bitwise
+      hash = (hash << 5) - hash + char;
+      // tslint:disable-next-line: no-bitwise
+      hash = hash & hash;
+    }
+    return hash.toString();
+  }
+
+  MMddyyToNgb(date: string): NgbDateStruct {
+    return this.momentToNgDate(moment(date, BaseHelperRoutines.MMDDYY_DATE));
+  }
+
+  selectedChildrenTravellers(
+    selectedTravellers: Traveller[],
+    type: ServiceType
+  ) {
+    switch (type) {
+      // These types do not have a difference between adults and children. so always mark as adults.
+      case ServiceType.Hotel:
+      case ServiceType.Cab:
+        return [];
+    }
+    return selectedTravellers.filter(
+      (traveller: Traveller) => traveller.isChild
+    );
+  }
+
+  selectedTravellers(travellers: Traveller[], type: ServiceType) {
+    switch (type) {
+      // These types do not have a difference between adults and children. so always mark as adults.
+      case ServiceType.Hotel:
+      case ServiceType.Cab:
+        return { adults: travellers, children: [], infants: [] };
+      default:
+        return travellers.reduce(
+          (
+            accum: {
+              adults: Traveller[];
+              children: Traveller[];
+              infants: Traveller[];
+            },
+            traveller: Traveller
+          ) => {
+            if (traveller.isChild) {
+              if (traveller.isInfant) {
+                accum.infants.push(traveller);
+              } else {
+                accum.children.push(traveller);
+              }
+            } else {
+              accum.adults.push(traveller);
+            }
+            return accum;
+          },
+          {
+            adults: [],
+            children: [],
+            infants: []
+          }
+        );
+    }
+  }
+  selectedAdultTravellers(selectedTravellers: Traveller[], type: ServiceType) {
+    switch (type) {
+      // These types do not have a difference between adults and children. so always mark as adults.
+      case ServiceType.Hotel:
+      case ServiceType.Cab:
+        return selectedTravellers;
+    }
+    return selectedTravellers.filter(
+      (traveller: Traveller) => !traveller.isChild && !traveller.isInfant
+    );
+  }
+
+  private _isChild(traveller: Traveller | Date, maxAge: number): boolean {
+    if (traveller instanceof Date) {
+      const adultDate = moment().add(-maxAge, 'years');
+      return adultDate.isBefore(
+        moment(traveller, BaseHelperRoutines.ISO_DATA_FORMAT),
+        'day'
+      );
+    } else {
+      return traveller.isChild;
+    }
+  }
+
+  isChildFlight(traveller: Traveller): boolean {
+    return this._isChild(traveller, FLIGHT_MAX_CHILD_AGE_YEARS);
+  }
+
+  isChildRail(traveller: Traveller): boolean {
+    return this._isChild(traveller, RAIL_MAX_CHILD_AGE_YEARS);
+  }
+
+  isChildEurostar(traveller: Traveller): boolean {
+    return this._isChild(traveller, EUROSTAR_MAX_CHILD_AGE_YEARS);
+  }
+
+  uniqBy(array: any[], value: string) {
+    return _.uniqBy(array, value);
+  }
+
+  isChild(traveller: Traveller | Date, travelType: ServiceType) {
+    switch (travelType) {
+      case ServiceType.Flight:
+        return this._isChild(traveller, FLIGHT_MAX_CHILD_AGE_YEARS);
+      case ServiceType.Rail:
+        return this._isChild(traveller, RAIL_MAX_CHILD_AGE_YEARS);
+      // case ServiceType.Eurostar:
+      //  return this._isChild(traveller, EUROSTAR_MAX_CHILD_AGE_YEARS);
+      case ServiceType.Coach:
+        return this._isChild(traveller, COACH_MAX_CHILD_AGE_YEARS);
+      case ServiceType.Lounge:
+        return this._isChild(traveller, LOUNGES_MAX_CHILD_AGE_YEARS);
+      case ServiceType.Hotel:
+      case ServiceType.Cab:
+        return false;
+      default:
+        return false;
+    }
+  }
+
+  isInfant(traveller: Traveller | Date, travelType: ServiceType) {
+    switch (travelType) {
+      case ServiceType.Flight:
+        return this._isChild(traveller, FLIGHT_MAX_INFANT_AGE_YEARS);
+      case ServiceType.Rail:
+        return this._isChild(traveller, RAIL_MAX_INFANT_AGE_YEARS);
+      // case ServiceType.Eurostar:
+      //  return this._isChild(traveller, EUROSTAR_MAX_CHILD_AGE_YEARS);
+      case ServiceType.Coach:
+        return this._isChild(traveller, COACH_MAX_INFANT_AGE_YEARS);
+      case ServiceType.Lounge:
+        return this._isChild(traveller, LOUNGES_MAX_INFANT_AGE_YEARS);
+      case ServiceType.Hotel:
+      case ServiceType.Cab:
+        return false;
+      default:
+        return false;
+    }
+  }
+
+  getAgeType(traveller: Traveller, travelType: ServiceType): any {
+    return this.isChild(traveller, travelType) ? 'C' : 'A';
+  }
+
+  getMaxChildAge(type: ServiceType): string {
+    switch (type) {
+      case ServiceType.Flight:
+        return moment()
+          .add(-FLIGHT_MAX_CHILD_AGE_YEARS + 1, 'years')
+          .format(BaseHelperRoutines.MMDDYY_DATE);
+      case ServiceType.Rail:
+        return moment()
+          .add(-RAIL_MAX_CHILD_AGE_YEARS + 1, 'years')
+          .format(BaseHelperRoutines.MMDDYY_DATE);
+      // case ServiceType.EUROSTAR:
+      //  return moment().add(-EUROSTAR_MAX_CHILD_AGE_YEARS + 1, 'years').format(Helpers.MMDDYY_DATE);
+      case ServiceType.Coach:
+        return moment()
+          .add(-COACH_MAX_CHILD_AGE_YEARS + 1, 'years')
+          .format(BaseHelperRoutines.MMDDYY_DATE);
+      case ServiceType.Lounge:
+        return moment()
+          .add(-LOUNGES_MAX_CHILD_AGE_YEARS + 1, 'years')
+          .format(BaseHelperRoutines.MMDDYY_DATE);
+    }
+  }
+
+  getDefaultAdultAge(type: ServiceType): string {
+    switch (type) {
+      case ServiceType.Flight:
+        return moment()
+          .add(-FLIGHT_MAX_CHILD_AGE_YEARS - 10, 'years')
+          .format(BaseHelperRoutines.MMDDYY_DATE);
+      case ServiceType.Rail:
+        return moment()
+          .add(-RAIL_MAX_CHILD_AGE_YEARS - 10, 'years')
+          .format(BaseHelperRoutines.MMDDYY_DATE);
+      // case ServiceType.Eurostar:
+      //  return moment().add(-EUROSTAR_MAX_CHILD_AGE_YEARS - 10, 'years').format(Helpers.MMDDYY_DATE);
+      case ServiceType.Coach:
+        return moment()
+          .add(-COACH_MAX_CHILD_AGE_YEARS - 10, 'years')
+          .format(BaseHelperRoutines.MMDDYY_DATE);
+      case ServiceType.Lounge:
+        return moment()
+          .add(-LOUNGES_MAX_CHILD_AGE_YEARS - 10, 'years')
+          .format(BaseHelperRoutines.MMDDYY_DATE);
+      case ServiceType.Hotel:
+      case ServiceType.Cab:
+        // These types do not have child places so
+        return moment()
+          .add(-18, 'years')
+          .format(BaseHelperRoutines.MMDDYY_DATE);
+    }
+    return moment().add(-18, 'years').format(BaseHelperRoutines.MMDDYY_DATE);
+  }
+
+  transform(
+    array: any[],
+    callback: _.MemoVoidArrayIterator<any, any[]>,
+    acc: any
+  ): any[] {
+    return _.transform(array, callback, acc);
+  }
+
+  arrayToObject<T extends { [key: string]: any }>(
+    array: T[],
+    field: string
+  ): { [key: string]: T } {
+    return array
+      .filter((data: T) => !!data)
+      .reduce((configs: { [key: string]: T }, configItem: T) => {
+        if (configItem && configItem[field]) {
+          configs[configItem[field]] = configItem;
+          return configs;
+        }
+      }, {});
+  }
+
+  arrayToObjectArray<T extends { [key: string]: any }>(
+    array: T[],
+    field: string
+  ): { [key: string]: T[] } {
+    return array
+      .filter((data: T) => !!data)
+      .reduce((configs: { [key: string]: T[] }, configItem: T) => {
+        if (configItem && configItem[field]) {
+          configs[configItem[field]] = configs[configItem[field]] || [];
+          configs[configItem[field]].push(configItem);
+          return configs;
+        }
+      }, {});
+  }
+
+  getTerminals(airport: Airport): string[] {
+    return airport.terminals;
+  }
+
+  fieldFromObject(obj: object, field: string): string {
+    return (field || '')
+      .split('.')
+      .reduce((current: Record<string, any>, field1: string) => {
+        if (current && current[field1]) {
+          return current[field1];
+        }
+        return '';
+      }, obj);
+  }
+
+  mapFieldFromObject<K extends string | number | symbol, T>(field: K) {
+    return (obj: Record<K, any>): T => {
+      return obj[field];
+    };
+  }
+
+  removeNulls<T>(query: T): T {
+    return Object.keys(query).reduce((accum: T, key: string) => {
+      const value = (query as Record<string, any>)[key];
+      const data = Array.isArray(value)
+        ? value.filter((item: any) => !!item) || null
+        : value;
+      if (
+        (data !== null && data !== undefined && data !== 'null') ||
+        (Array.isArray(data) && data.length > 0)
+      ) {
+        (accum as Record<string, any>)[key] = data;
+      }
+      return accum;
+    }, {} as T);
+  }
+
+  getTravellersId(travellers: Traveller[]): string[] {
+    if (travellers) {
+      return travellers.reduce(
+        (previousValue: string[], currentValue: Traveller, idx: number) => {
+        return idx === 0 ? [currentValue.id] : [...previousValue, currentValue.id];
+      }, []);
+    }
+  }
+
+  /**
+   * loop over the query object param and convert any moment date objects to date-time strings
+   * @param query
+   * @param debug
+   */
+  sanitizeMomentDates(query: any, debug = false): any {
+    const sanitizedQuery = { ...query };
+    for (const [key, value] of Object.entries(sanitizedQuery)) {
+      if (moment.isMoment(value)) {
+        sanitizedQuery[key] = sanitizedQuery[key].toISOString();
+      }
+    }
+    if (debug) {
+      console.log('-- sanitizeMomentDates() called --');
+      console.log('original query: ', query);
+      console.log('sanitized query: ', sanitizedQuery);
+    }
+    return sanitizedQuery;
+  }
+
+  toStrings<T>(toFormat: T, schema: Schema): T {
+    return Object.entries(schema.properties || {}).reduce(
+      (currentValue: T, [key, value]: [string, Schema]): T => {
+        const newValue = this._formatValue(
+          toFormat[key as keyof T],
+          value,
+          (schema.required || []).includes(key)
+        );
+
+        if (newValue !== null) {
+          currentValue[key as keyof T] = newValue;
+        }
+        return currentValue;
+      },
+      {} as T
+    );
+  }
+
+  private _formatValue(value: any, schema: Schema, isRequired: boolean): any {
+    switch (schema.type) {
+      case 'integer':
+        const tmp = Number.parseInt(value, 10);
+        return Number.isNaN(tmp) ? (isRequired ? 0 : null) : tmp;
+      case 'string':
+        const tmp1 = value ? value.toString() : null;
+        return tmp1 && tmp1.length > 0 ? tmp1 : isRequired ? '' : null;
+      case 'object':
+        return value ? this.toStrings(value, schema) : isRequired ? {} : null;
+      case 'array':
+        return value; // TODO write array translation
+      default:
+        return value;
+    }
+  }
+
+  makeTimeWindow(dateTime: moment.Moment, start: number, end: number): string {
+    const startTime = dateTime.clone().add(start, 'hour');
+    const endTime = dateTime.clone().add(end, 'hour');
+
+    return this.formatTime(startTime) + '-' + this.formatTime(endTime);
+  }
+
+  inRange(tocheck: number, range: MinMax): boolean {
+    return tocheck >= range.min && tocheck <= range.max;
+  }
+
+  makeUsers(travellers: Traveller[]): UserPassengerTypeInput[] {
+    return travellers.map((traveller: Traveller): UserPassengerTypeInput => {
+      return {
+        id: traveller.id,
+        passengerType: traveller.isChild
+          ? PassengerType.Child
+          : traveller.isInfant
+          ? PassengerType.Infant
+          : PassengerType.Adult
+      };
+    });
+  }
+
+  makeMomentDayTime(addDay?: number, hh?: number, m?: number) {
+    const dt = moment();
+
+    if (addDay !== undefined) {
+      dt.add(addDay, 'day');
+    }
+
+    if (hh !== undefined) {
+      dt.set('hours', hh);
+    }
+
+    if (m !== undefined) {
+      dt.set('minutes', m);
+    }
+
+    return dt;
+  }
+
+  sanatizeReturns<T>(
+    defaults: T,
+    suppliedData: Partial<T>,
+    momentFields?: (keyof T)[]
+  ): T {
+    const combined: T = Object.assign({}, defaults, suppliedData);
+    return (momentFields || []).reduce((current: T, next: keyof T) => {
+      const value = (current as any)[next];
+      (current as any)[next] = !value
+        ? moment()
+        : typeof value === 'string'
+        ? moment(value)
+        : value;
+      return current;
+    }, combined);
+  }
+
+  miIsValid(toCheck: ManagementInfoAndIsValid[]) {
+    return (
+      toCheck.length === 0 ||
+      !!toCheck.find((miItem: ManagementInfoAndIsValid) => {
+        return miItem.isValid();
+      })
+    );
+  }
+
+  isMiValid(
+    miPerItem: ManagementInfoAndIsValid[],
+    miPerUser: {
+      [key: string]: {
+        managementInfo: ManagementInfoAndIsValid[];
+      };
+    }
+  ): boolean {
+    const userMis = Object.values(miPerUser || {});
+    return (
+      this.miIsValid(miPerItem) &&
+      (userMis.length === 0 ||
+        !!userMis.find(
+          (userMis1: { managementInfo: ManagementInfoAndIsValid[] }) => {
+            return this.miIsValid(userMis1.managementInfo);
+          }
+        ))
+    );
+  }
+
+  needsMi(basket: BasketDetails, needsToViewMi: boolean): boolean {
+    return (
+      basket.basketInfoMiDetails.length > 0 &&
+      (needsToViewMi ||
+        !basket.basketInfoMiDetails.find(
+          (miDetail: BasketItemManagementInfo): boolean => {
+            return this.isMiValid(miDetail.miPerItem, miDetail.miPerUser);
+          }
+        ))
+    );
+  }
+
+  findService(services: UserServices, id: string): Service {
+    return Object.values(services).reduce(
+      (current: Service, service1: Service[]): Service => {
+        return (
+          current ||
+          service1.find((service2: Service): boolean => {
+            return service2.id === id;
+          })
+        );
+      },
+      null as Service
+    );
+  }
+
+  allTrue(
+    suppInfo: SupplementaryBookingInfoInterface[],
+    filter: (suppInfo: SupplementaryBookingInfoInterface) => boolean
+  ): boolean {
+    return suppInfo.filter(filter).length === suppInfo.length;
+  }
+
+  joinFromAttribute<T>(
+    joinCharacter: string,
+    attribute: keyof T,
+    array: T[]
+  ): string {
+    return array.map((item: T) => item[attribute]).join(joinCharacter);
+  }
+
+  /**
+   * @description - split up an array into equal parts
+   * @param array - the array to split up
+   * @param size - the size of the constituant parts
+   * @param includeRemainder - wether or not to include any remaing results - default true
+   */
+  splitUpArray(
+    array: any[],
+    size: number,
+    includeRemainder: boolean = true
+  ): any[] {
+    const arrayCopy = _.cloneDeep(array); // lodash clone deep
+    let newArray = [];
+
+    if (arrayCopy.length > size) {
+      while (arrayCopy.length >= size) {
+        newArray.push(arrayCopy.splice(0, size));
+      }
+
+      // add any remaining
+      if (arrayCopy.length && includeRemainder) {
+        newArray.push(arrayCopy);
+      }
+    } else {
+      newArray = arrayCopy;
+    }
+
+    return newArray;
+  }
+
+  @Memorise()
+  getTimeDifference(depDateTime: string, arrDateTime: string): number {
+    return moment(depDateTime).diff(moment(arrDateTime), 'minutes');
+  }
+
+  @Memorise()
+  dayDifference(dept: string, arr: string): string {
+    const diff = moment(arr)
+      .startOf('day')
+      .diff(moment(dept).startOf('day'), 'day');
+    return diff > 0 ? diff.toString() : '';
+  }
+
+  @Memorise()
+  makeFareRules(flight: FlightItinerary, direction: FlightDirectionEnum) {
+    const flights =
+      direction === FlightDirectionEnum.Outbound
+        ? flight.outboundFlights
+        : flight.inboundFlights;
+    const rules = flights.reduce(
+      (current: FareConditions, next: FlightJourney) => {
+        current.cancellation = current.cancellation.concat(
+          next.fareConditions?.cancellation || []
+        );
+        current.change = current.change.concat(
+          next.fareConditions?.change || []
+        );
+        current.noShow = current.noShow.concat(
+          next.fareConditions?.noShow || []
+        );
+        current.upgrade = current.upgrade.concat(
+          next.fareConditions?.upgrade || []
+        );
+        current.other = current.other.concat(next.fareConditions?.other || []);
+        return current;
+      },
+      {
+        cancellation: [],
+        change: [],
+        noShow: [],
+        upgrade: [],
+        other: []
+      }
+    );
+    return { rules, flights };
+  }
+
+  /**
+   * @desc - generates ics file content
+   */
+  generateIcsFileContents(basketItems: BasketItem[]): string {
+    const icsBodyContent = this.generateIcsFileBodyContent(basketItems);
+    return [
+      'BEGIN:VCALENDAR\r\n',
+      'PRODID:-//Micros Travel//SABS Corporate - MMXIII//EN\r\n',
+      'VERSION:2.0\r\n',
+      'METHOD:REQUEST\r\n',
+      icsBodyContent,
+      'END:VCALENDAR\r\n'
+    ].join('');
+  }
+
+  /**
+   * @desc - generates ics file body content based on the provided basketItems param
+   */
+  generateIcsFileBodyContent(basketItems: BasketItem[]): string {
+    // TODO: currently only basket items with ServiceType.Lounge are handled. See below to TODOs for remaining tasks
+    const bodyContent: string[] = [];
+
+    // generate calendar data for each basket item
+    basketItems.map((basketItem, index) => {
+      const data = {
+        dStart: '',
+        dEnd: '',
+        locationFrom: '',
+        locationTo: '',
+        basketId: '',
+        description: '',
+        serviceType: '',
+        summary: ''
+      };
+
+      const { type } = basketItem.service;
+
+      // populate data object depending on the service type in the basket
+      switch (type) {
+        case ServiceType.Lounge:
+          const {
+            adults,
+            children,
+            bookingThirdPartyReference,
+            detail,
+            service
+          } = basketItem;
+          data.basketId = basketItem.id;
+          data.dStart = detail?.arrivalDatetime;
+          data.dEnd = '';
+          data.summary = `Airport Lounge - ${detail.name}`;
+          data.serviceType = service.type.toLowerCase();
+          data.description = [
+            `Lounge: ${detail.name}\r\n`,
+            `Starts: ${detail.arrivalDatetime}\r\n`,
+            `Adults: ${adults}\r\n`,
+            `Children: ${children}\r\n`,
+            `Booking Ref: ${bookingThirdPartyReference}`
+          ].join('');
+          break;
+        case ServiceType.Cab:
+        // TODO: handle this case
+        // hint: see logic in icalendar.component.ts  file on lighting current version
+        case ServiceType.Car:
+        // TODO: handle this case
+        case ServiceType.Coach:
+        // TODO: handle this case
+        case ServiceType.FastTrack:
+        // TODO: handle this case
+        case ServiceType.Flight:
+        // TODO: handle this case
+        case ServiceType.Hotel:
+        // TODO: handle this case
+        case ServiceType.InternationalRail:
+        // TODO: handle this case
+        case ServiceType.Parking:
+        // TODO: handle this case
+        case ServiceType.Rail:
+        // TODO: handle this case
+      }
+
+      bodyContent.push(
+        [
+          'BEGIN:VEVENT\r\n',
+          data.dStart
+            ? `DTSTART:${moment(data.dStart).format('YYYYMMDDTHHmmss')}\r\n`
+            : '',
+          data.dEnd
+            ? `DTEND:${moment(data.dEnd).format('YYYYMMDDTHHmmss')}\r\n`
+            : '',
+          'ORGANIZER;CN="Do not reply to this email":mailto:do_not_reply@sabscorp.com\r\n',
+          data.locationTo && data.locationFrom
+            ? `LOCATION: ${data.locationTo} to ${data.locationFrom} \r\n`
+            : '',
+          'TRANSP:OPAQUE\r\n',
+          'SEQUENCE:0\r\n',
+          `UID:${data.serviceType}_${index}_${data.basketId}@sabscorp.com\r\n`,
+          `DTSTAMP:${moment().format('YYYYMMDDTHHmmss')}\r\n`,
+          `DESCRIPTION:${data.description}\r\n`,
+          `SUMMARY:${data.summary}\r\n`,
+          'END:VEVENT\r\n'
+        ].join('')
+      );
+    });
+
+    return bodyContent.join('');
+  }
+
+  /**
+   * @desc - creates an element in memory and triggers click event to download ics file
+   */
+  downloadIcs(filename: string, text: string) {
+    const element = document.createElement('a');
+    element.setAttribute(
+      'href',
+      'data:text/plain;charset=utf-8,' + encodeURIComponent(text)
+    );
+    element.setAttribute('download', filename);
+    element.setAttribute('target', '_blank');
+    element.style.display = 'none';
+    element.click();
+  }
+
+  /**
+   * @description - split a string on capitals
+   * @param rawString - the string we want to split
+   * @param join - whether or not to joing the split into one string, seperated by a space
+   * @returns string/string[]
+   */
+  splitStringOnCapitals(
+    rawString: string,
+    join: boolean = false
+  ): string | string[] {
+    const splitString = rawString.split(/(?=[A-Z])/);
+
+    if (join) {
+      return splitString.join(' ');
+    }
+
+    return splitString;
+  }
+}