@annalib/anna-core 0.0.2 → 0.0.3

package/src/lib/anna-core-shared-lib/services/anna-filter.service.ts

@@ -0,0 +1,616 @@
+// Angular import statements
+import { Options } from '@angular-slider/ngx-slider';
+import { Injectable } from "@angular/core";
+
+// Third party import statements
+import { min, max, map, sortBy, uniq, cloneDeep, isEqual } from "lodash-es";
+import moment from "moment";
+
+// User defined import statements 
+import { AllSelectedStatus, tooltipModelForColumnLevelFiltering } from "../models/anna-tooltip.model";
+import { AnnaDateTimeFormatService, NgbDateType } from './anna-date-time-format.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AnnaFilterService {
+
+  tooltipMap = new Map();
+  tooltipSelectedMap = new Map();
+  initialValueMap: Map<string, any>;
+  translateFunc: string;
+  selectedRadio: string;
+  subRadioButton: string;
+
+  calendarSet: Set<string>;
+  sliderSet: Set<string>;
+  timeSet: Set<string>;
+
+  includeMultiTime: boolean;
+  includeZeroTime: boolean;
+  includeTimeRange: boolean;
+
+  appliedFiltersArray: string[] = [];
+  flightDateRange: { minSelectedDate: any, maxSelectedDate: any };
+  sliderData: { min: any, max: any };
+  ngxSliderObj: Options;
+
+  public static bufferSize = 20;
+
+  constructor(private dateTimeFormatService: AnnaDateTimeFormatService) {
+    console.log("AnnaFilterService service created.")
+    const sliderArr = [
+      "rcvPreempt",
+      "osPreempt",
+      "rcvUnderDly",
+      "postedAudPercent",
+      "booked",
+      "spots",
+      "grp",
+      "cpp",
+      "imps",
+      "cpm",
+      "osUnderDly",
+      "totalWeeks",
+      "WeekNumber",
+      "Rate",
+      "OrderedRatingsOrImpressions",
+      "PostedRatingsOrImpressions", ,
+      "postedAudPercent",
+      "postedAdu",
+      "scheduledAdu",
+      "audienceDeficit",
+      "offeredMGs",
+      "outstandingPE",
+      "offeredADUs",
+      "udDeficitValue",
+      "bookedValue",
+      "bookedSpots",
+      "userChanges"
+    ];
+    const calendarArr = ["period", "AirDate", "flightStartDate", "flightEndDate","date", "startDate", "endDate"];
+    const timeArr = ["StartTimeForFilter", "EndTimeForFilter",
+      "start_time_for_filter", "end_time_for_filter", "startEndTimeMulti"];
+    this.sliderSet = new Set(sliderArr);
+    this.calendarSet = new Set(calendarArr);
+    this.timeSet = new Set(timeArr);
+  }
+
+  returnMaxAndMinValue(data: any[], key: string, isMin: boolean) {
+    data = data.filter((obj) => !["", "-", null].includes(obj[key]));
+    const values = data.map((x) => x[key]);
+    let valueToReturn = isMin ? min(values) : max(values);
+    return valueToReturn;
+  }
+
+  returnMinAndMaxDate(data: any[], key: string) {
+    data = data.filter((obj) => !["", "-", null].includes(obj[key]));
+    let DateArr = data.map((obj) => moment(obj[key]));
+    let minDate = moment.min(DateArr);
+    let maxDate = moment.max(DateArr);
+    return [minDate, maxDate];
+  }
+
+  isTooltipActive(header: string[]): boolean {
+    let set: Set<string> = new Set(this.appliedFiltersArray);
+    return (set.has(header[0])) || (set.has(header[1]));
+  }
+
+  clearColumnFilter() {
+    this.tooltipSelectedMap.delete(this.selectedRadio);
+    if (this.tooltipMap.has(this.selectedRadio)) {
+      this.tooltipMap.delete(this.selectedRadio);
+    }
+    if (this.selectedRadio === "postedAdu") {
+      this.subRadioButton = "required";
+      this.tooltipSelectedMap.delete("isAudRequired");
+    }
+    let appliedFilterSet: Set<string> = new Set(this.appliedFiltersArray);
+    appliedFilterSet.delete(this.selectedRadio);
+    this.appliedFiltersArray = [...appliedFilterSet];
+  }
+
+  populateSliderTooltip(completeData: any[], filteredData: any[]) {
+    let minValue;
+    let maxValue;
+    if (
+      this.appliedFiltersArray.length > 0 &&
+      this.appliedFiltersArray[this.appliedFiltersArray.length - 1] === this.selectedRadio
+    ) {
+      let subsetData;
+      let subfilterApplied = false;
+      //applying all filterexcept the current filter
+      if (this.selectedRadio === "postedAdu" && this.tooltipSelectedMap.has("isAudRequired")) {
+        this.tooltipSelectedMap.delete("isAudRequired");
+        subfilterApplied = true;
+      }
+      subsetData = this.filterData(completeData, this.selectedRadio);
+      //need to find min and max value for
+      minValue = this.returnMaxAndMinValue(subsetData, this.selectedRadio, true);
+      maxValue = this.returnMaxAndMinValue(subsetData, this.selectedRadio, false);
+      if (this.selectedRadio === "postedAdu" && subfilterApplied) {
+        this.tooltipSelectedMap.set("isAudRequired", [false]);
+      }
+    } else {
+      minValue = this.returnMaxAndMinValue(filteredData, this.selectedRadio, true);
+      maxValue = this.returnMaxAndMinValue(filteredData, this.selectedRadio, false);
+    }
+    this.ngxSliderObj = this.setOptionValues(minValue, maxValue);
+    if (this.translateFunc === "normal") {
+      this.ngxSliderObj.translate = this.normalTranslateFunction;
+    } else if (this.translateFunc === "percent") {
+      this.ngxSliderObj.translate = this.percentTranslateFunction;
+    } else if (this.translateFunc === "currency") {
+      this.ngxSliderObj.translate = this.currencyTranslateFunction;
+    }
+    return this.ngxSliderObj;
+  }
+
+  setOptionValues(minValue: number, maxValue: number) {
+    return {
+      floor: minValue,
+      ceil: maxValue
+    };
+  }
+
+  percentTranslateFunction = (data: number): string => {
+    const val = data.toFixed(1) + "%";
+    return val;
+  };
+
+  currencyTranslateFunction = (data: number): string => {
+    if (data >= 1000) {
+      const val = (data / 1000).toFixed(1) + "k";
+      return "$" + val;
+    } else if (data != Math.floor(data)) {
+      return data.toFixed(1).toString();
+    }
+    return "$" + data;
+  };
+
+  normalTranslateFunction = (data: number): string => {
+    if (data >= 1000) {
+      const val = (data / 1000).toFixed(1) + "k";
+      return val;
+    } else if (data != Math.floor(data)) {
+      return data.toFixed(1).toString();
+    }
+    return data.toString();
+  };
+
+  populateTooltip(selectedColumnName: string, completeData: any[], filteredData: any[]) {
+    let tooltipData;
+
+    if (this.appliedFiltersArray.length === 0) {
+      tooltipData = this.populateTooltipDataBasedOnSelectedRadio([selectedColumnName], completeData);
+      tooltipData.forEach((item: { isHidden: boolean }) => (item.isHidden = false));
+    } else if (selectedColumnName === this.appliedFiltersArray[this.appliedFiltersArray.length - 1]) {
+      let subsetData = this.filterData(completeData, selectedColumnName); //filter the data without applying the latest filter
+      tooltipData = this.showHideFilterCheckbox(subsetData, selectedColumnName);
+    } else {
+      //if it is not the latest filter
+      //then filtered Data will be used
+      //create the option data
+      if (!this.tooltipMap.has(selectedColumnName)) {
+        this.populateTooltipDataBasedOnSelectedRadio([selectedColumnName], completeData);
+      }
+
+      tooltipData = this.showHideFilterCheckbox(filteredData, selectedColumnName);
+    }
+    return tooltipData;
+  }
+
+  populateTooltipDataBasedOnSelectedRadio(value: string[], originalData: any) {
+    //if the initial tooltip data is already present fetch from the map
+    if (this.tooltipMap.has(value[0])) {
+      return this.tooltipMap.get(value[0]);
+    } else {
+      //get the unique values from the column and save it in the map
+      this.selectedRadio = value[0];
+      const data = sortBy(originalData.map((u: any) => u[this.selectedRadio])).filter(n => n !== null); //sorting the data in alphabetical order
+      const dataSet = new Set(data); //created a set from the data
+      const toolTipdata = [...dataSet].map((x) => new tooltipModelForColumnLevelFiltering(x));
+      this.tooltipMap.set(value[0], toolTipdata); //setting the key value pair in the tooltipMap
+      this.tooltipSelectedMap.set(value[0], map(toolTipdata, "data")); //setting the key value pair in tooltipSelectedMap
+      return toolTipdata;
+    }
+  }
+
+  showHideFilterCheckbox(arr: any[], selectedColumnName: string) {
+    let currentSubsetData = uniq(arr.map((u) => u[selectedColumnName]));
+
+    //get the initial tooltip Data
+    let tooltipData = this.tooltipMap.get(selectedColumnName);
+
+    //show or hide the value
+    tooltipData.forEach((value: { data: string | number; isHidden: boolean; }) => {
+      //if the element is not present then hide the element
+      let elementToFindIndex = currentSubsetData.findIndex((n: string | number) => n === value.data);
+      if (elementToFindIndex === -1) {
+        value.isHidden = true;
+      } else {
+        //show the element
+        value.isHidden = false;
+      }
+    });
+
+    return tooltipData;
+  }
+
+  isAllOptionsSelected() {
+    let allSelected;
+    let totalOptionsCount = this.tooltipMap.get(this.selectedRadio).filter((x: any) => !x.isHidden).length;
+    let selectedOptionsCount = this.tooltipMap.get(this.selectedRadio).filter((x: any) => !x.isHidden && x.isSelected).length;
+    if (selectedOptionsCount === 0) {
+      allSelected = AllSelectedStatus.none;
+    } else if (selectedOptionsCount > 0 && selectedOptionsCount < totalOptionsCount) {
+      allSelected = AllSelectedStatus.fewSelected;
+    } else {
+      allSelected = AllSelectedStatus.allSelected;
+    }
+    return allSelected;
+  }
+
+  populateDatePickerTooltipWithData(completeData: any[], filteredData: any[]) {
+    let enabledDates;
+    //some filter is applied and the latest filter is the date filter
+    if (
+      this.appliedFiltersArray.length > 0 &&
+      this.appliedFiltersArray[this.appliedFiltersArray.length - 1] === this.selectedRadio
+    ) {
+      let subsetData;
+      //applying all filterexcept thec current  filter
+      if (this.selectedRadio === "period") {
+        subsetData = this.filterData(completeData, "period");
+        let minStartDate = this.returnMinAndMaxDate(subsetData, "startDate");
+        let maxEndDate = this.returnMinAndMaxDate(subsetData, "endDate");
+        enabledDates = { minStartDate: minStartDate[0], maxEndDate: maxEndDate[1] };
+      } else if (this.selectedRadio === "AirDate" || this.selectedRadio === "flightStartDate" ||
+        this.selectedRadio === "flightEndDate" || this.selectedRadio == "date") {
+        subsetData = this.filterData(completeData, this.selectedRadio);
+        let minAndMaxDate = this.returnMinAndMaxDate(subsetData, this.selectedRadio);
+        enabledDates = { minStartDate: minAndMaxDate[0], maxEndDate: minAndMaxDate[1] };
+      } else {
+        subsetData = this.filterData(completeData, this.selectedRadio);
+        //need to find min and max date for start and end date
+        //enabledDates is an arr of minDate and maxDate
+        enabledDates = this.returnMinAndMaxDate(subsetData, this.selectedRadio);
+      }
+    } else {
+      if (this.selectedRadio === "period") {
+        let minStartDate = this.returnMinAndMaxDate(filteredData, "startDate");
+        let maxEndDate = this.returnMinAndMaxDate(filteredData, "endDate");
+        enabledDates = { minStartDate: minStartDate[0], maxEndDate: maxEndDate[1] };
+      } else if (this.selectedRadio === "AirDate" || this.selectedRadio === "flightStartDate" ||
+        this.selectedRadio === "flightEndDate" || this.selectedRadio == "date") {
+        let minAndMaxDate = this.returnMinAndMaxDate(filteredData, this.selectedRadio);
+        enabledDates = { minStartDate: minAndMaxDate[0], maxEndDate: minAndMaxDate[1] };
+      } else {
+        //need to find min and max date for start and end date.
+        // enabledDates is an arr of minDate and maxDate
+        enabledDates = this.returnMinAndMaxDate(filteredData, this.selectedRadio);
+      }
+    }
+    return enabledDates;
+  }
+
+  findUniqueDatesWithData(data: any[]) {
+    let uniqueDates = uniq(data.map((u) => u["date"]));
+    let uniqueDatesInNgbDateFormat: NgbDateType[] = [];
+    uniqueDates.forEach((date) => {
+      uniqueDatesInNgbDateFormat.push(
+        this.dateTimeFormatService.convertToNgbDateStandardFormat(moment(date, "MM/DD/YY").format("MM/DD/YYYY"))
+      );
+    });
+    return uniqueDatesInNgbDateFormat;
+  }
+
+  isCheckboxSelected(selectedData: any) {
+    selectedData.isSelected = !selectedData.isSelected;
+    let allSelected = this.isAllOptionsSelected();
+    return allSelected;
+  }
+
+  allOptionsClicked(status: number) {
+    let header = this.selectedRadio;
+    if (status === 1) {
+      this.tooltipMap.get(header).forEach((item: any) => {
+        if (!item.isHidden) {
+          item.isSelected = true;
+        }
+      });
+      this.tooltipSelectedMap.set(
+        header,
+        this.tooltipMap
+          .get(header)
+          .filter((x: any) => x.isSelected)
+          .map((x: any) => x.data)
+      );
+    } else {
+      this.tooltipMap.get(header).forEach((item: any) => {
+        if (!item.isHidden) {
+          item.isSelected = false;
+        }
+      });
+      this.tooltipSelectedMap.delete(header);
+    }
+  }
+
+  reOrderAppliedFiltersArray(isHierarchialUserFiltered: boolean, date?: any) {
+    let isFiltered = true;
+    isFiltered = this.checkIfDataIsFiltered(isFiltered, isHierarchialUserFiltered, date);
+    this.removeOrChangeLatestFilterIndex(isFiltered);
+  }
+
+  checkIfDataIsFiltered(isFiltered: boolean, isHierarchialUserFiltered: boolean, date?: any) {
+    if (this.selectedRadio == "user" && !this.tooltipMap.has("user")) {
+      isFiltered = cloneDeep(isHierarchialUserFiltered);
+    } else if (this.selectedRadio == "StartTimeForFilter" || this.selectedRadio == "EndTimeForFilter"
+      || this.selectedRadio == "start_time_for_filter" || this.selectedRadio == "end_time_for_filter" || this.selectedRadio == "startEndTimeMulti") {
+      isFiltered = !isEqual(
+        this.initialValueMap.get(this.selectedRadio),
+        this.tooltipSelectedMap.get(this.selectedRadio)
+      ) || !this.includeZeroTime || !this.includeMultiTime;
+    }
+    else if (this.selectedRadio == "startEndTime" || this.selectedRadio == "TimeBand") {
+      isFiltered = !isEqual(this.initialValueMap.get(this.selectedRadio), this.tooltipSelectedMap.get(this.selectedRadio)) || !this.includeZeroTime || !this.includeMultiTime;
+    }
+    else if (this.sliderSet.has(this.selectedRadio)) {
+      isFiltered = !isEqual(this.initialValueMap.get(this.selectedRadio), this.tooltipSelectedMap.get(this.selectedRadio)) && !isEqual(this.tooltipSelectedMap.get(this.selectedRadio), this.sliderData);
+      if (this.selectedRadio == "postedAdu" && this.subRadioButton == "notRequired") {
+        isFiltered = true;
+      }
+      if (!isFiltered && this.tooltipSelectedMap.has(this.selectedRadio)) {
+        this.tooltipSelectedMap.delete(this.selectedRadio);
+      }
+    } else if (
+      this.selectedRadio == "startDate" ||
+      this.selectedRadio == "endDate" ||
+      this.selectedRadio == "period" ||
+      this.selectedRadio == "AirDate" ||
+      this.selectedRadio === "flightStartDate" ||
+      this.selectedRadio === "flightEndDate" ||
+      this.selectedRadio == "date"
+    ) {
+      isFiltered =
+        !isEqual(this.initialValueMap.get(this.selectedRadio), this.tooltipSelectedMap.get(this.selectedRadio)) &&
+        !isEqual(this.tooltipSelectedMap.get(this.selectedRadio), this.flightDateRange);
+      if (!isFiltered && this.tooltipSelectedMap.has(this.selectedRadio)) {
+        this.tooltipSelectedMap.delete(this.selectedRadio);
+      }
+    } else {
+      let totalOptionsCount = this.tooltipMap.get(this.selectedRadio).filter((x: any) => !x.isHidden).length;
+      let selectedOptionsCount = this.tooltipMap.get(this.selectedRadio).filter((x: any) => !x.isHidden && x.isSelected).length;
+      isFiltered = selectedOptionsCount > 0 && selectedOptionsCount != totalOptionsCount ? true : false;
+    }
+    return isFiltered;
+  }
+
+  removeOrChangeLatestFilterIndex(isFiltered: boolean) {
+    let set = new Set(this.appliedFiltersArray);
+
+    if (isFiltered && !set.has(this.selectedRadio)) {
+      set.add(this.selectedRadio);
+    } else if (isFiltered && set.has(this.selectedRadio)) {
+      set.delete(this.selectedRadio);
+      set.add(this.selectedRadio);
+    } else {
+      set.delete(this.selectedRadio);
+    }
+    this.appliedFiltersArray = [...set];
+  }
+
+  filterData(originalData: any[], keyToSkip: string) {
+    let filteredData = originalData;
+
+    this.tooltipSelectedMap.forEach((value, key) => {
+      if (key != keyToSkip) {
+        if (this.sliderSet.has(key)) {
+          filteredData = filteredData.filter((obj) => obj[key] >= value.min && obj[key] <= value.max);
+        }
+        else if (key === "startDate" || key === "endDate") {
+          filteredData = filteredData.filter((obj) => this.returnOrdersInTheRange(obj, value, key));
+        } else if (key === "period" || key === "AirDate" || key === "flightStartDate" || key === "flightEndDate" || key == "date") {
+          filteredData = filteredData.filter((obj) => this.getDataInTheDateRange(obj, value, key));
+        }
+        else if (key === "StartTimeForFilter" || key === "EndTimeForFilter"
+          || key === "start_time_for_filter" || key === "end_time_for_filter") {
+          filteredData = filteredData.filter((obj) => this.returnDataForFromAndToTimeRange(obj, value, key));
+        }
+        else if (key === "startEndTimeMulti") {
+          filteredData = filteredData.filter((obj) => this.returnDataForStartAndEndTimeRange(obj, value, key));
+        }
+        else if (key === "startEndTime" || key === "TimeBand") {
+          let filteredMulti = [];
+          let filteredZero = [];
+          let filteredTimeRange = [];
+          if (this.includeTimeRange) {
+            filteredTimeRange = filteredData.filter((obj) => this.returnDataForTimeRange(obj, value));
+          }
+
+          if (this.includeMultiTime) {
+            filteredMulti = filteredData.filter((obj) => obj[key][0] == "<multi>");
+          }
+
+          if (this.includeZeroTime) {
+            filteredZero = filteredData.filter((obj) => obj[key][0] == "0");
+          }
+
+          filteredData = [...filteredMulti, ...filteredZero, ...filteredTimeRange];
+        } else if (value.length > 0) {
+          filteredData = filteredData.filter((u) => value.includes(u[key]));
+        }
+      }
+    });
+    return filteredData;
+  }
+
+  returnOrdersInTheRange(order: any, range: any, key: any) {
+    let isDateBetweenTheSelectedRange = moment(order[key]).isBetween(range.minSelectedDate, range.maxSelectedDate);
+    let isDateSameAsTheMinSelectedDate = moment(order[key]).isSame(range.minSelectedDate);
+    let isDateSameAsTheMaxSelectedDate = moment(order[key]).isSame(range.maxSelectedDate);
+    return isDateBetweenTheSelectedRange || isDateSameAsTheMinSelectedDate || isDateSameAsTheMaxSelectedDate;
+  }
+
+  returnDataForTimeRange(obj: any, selectedData: any) {
+    let format = "HH:mm:ss";
+    let selectedStartDate = moment(selectedData.startTime, format);
+    let selectedEndDate = moment(selectedData.endTime, format);
+    let startTime = moment(obj.startTime, format);
+    let endTime = moment(obj.endTime, format);
+
+    let isStartTimeSameAsSelectedStartTime = startTime.isSame(selectedStartDate);
+    let isStartTimeBetweenSelectedStartAndEndTime = startTime.isBetween(selectedStartDate, selectedEndDate);
+    let isEndTimeSameAsSelectedEndTime = endTime.isSame(selectedEndDate);
+    let isEndTimeBetweenSelectedStartAndEndTime = endTime.isBetween(selectedStartDate, selectedEndDate);
+
+    return (
+      (isStartTimeBetweenSelectedStartAndEndTime && isEndTimeBetweenSelectedStartAndEndTime) ||
+      (isStartTimeSameAsSelectedStartTime && isEndTimeSameAsSelectedEndTime) ||
+      (isStartTimeSameAsSelectedStartTime && isEndTimeBetweenSelectedStartAndEndTime) ||
+      (isStartTimeBetweenSelectedStartAndEndTime && isEndTimeSameAsSelectedEndTime)
+    );
+  }
+
+  returnDataForFromAndToTimeRange(obj: any, selectedData: any, key: any) {
+    let format = "HH:mm:ss";
+    let selectedFromTime = moment(selectedData.fromTime, format);
+    let selectedToTime = moment(selectedData.toTime, format);
+    let objTime = obj[key];
+    if (["", "-", null].includes(objTime)) {
+      return false;
+    }
+    if (this.includeMultiTime && obj[key] == "<multi>") {
+      return true;
+    }
+    if (!this.includeMultiTime && obj[key] == "<multi>") {
+      return false;
+    }
+    if (this.includeZeroTime && obj[key] == "0") {
+      return true;
+    }
+    if (!this.includeZeroTime && obj[key] == "0") {
+      return false;
+    }
+    if (!this.includeTimeRange) {
+      return false;
+    }
+
+    objTime = this.dateTimeFormatService.formatToTwelveHrs(objTime, true);
+
+    objTime = this.dateTimeFormatService.convertTotwentyFourHrsFormat(
+      objTime[0] + ":" + objTime[1] + " " + objTime[2],
+      true
+    );
+    objTime = objTime[0] + ":" + objTime[1] + ":00";
+
+    objTime = moment(objTime, format);
+
+    let isObjTimeSameAsSelectedFromTime = objTime.isSame(selectedFromTime);
+    let isObjTimeSameAsSelectedToTime = objTime.isSame(selectedToTime);
+    let isObjTimeBetweenSelectedFromTimeAndToTime = objTime.isBetween(selectedFromTime, selectedToTime);
+
+    return (
+      isObjTimeSameAsSelectedFromTime ||
+      isObjTimeSameAsSelectedToTime ||
+      isObjTimeBetweenSelectedFromTimeAndToTime
+    );
+  }
+
+  returnDataForStartAndEndTimeRange(obj: any, selectedData: any, key: any) {
+    let format = "HH:mm:ss";
+    let selectedFromTime = moment(selectedData.fromTime, format);
+    let selectedToTime = moment(selectedData.toTime, format);
+    let objTime = obj[key];
+
+    if (this.includeMultiTime && obj[key][0] == "<multi>") {
+      return true;
+    }
+    if (!this.includeMultiTime && obj[key][0] == "<multi>") {
+      return false;
+    }
+    if (this.includeZeroTime && obj[key][0] == "0") {
+      return true;
+    }
+    if (!this.includeZeroTime && obj[key][0] == "0") {
+      return false;
+    }
+    if (!this.includeTimeRange) {
+      return false;
+    }
+
+    let startTime = moment(obj[key][1], format);
+    let endTime = moment(obj[key][2], format);
+
+    let isStartTimeSameAsSelectedStartTime = startTime.isSame(selectedFromTime);
+    let isStartTimeBetweenSelectedStartAndEndTime = startTime.isBetween(selectedFromTime, selectedToTime);
+    let isEndTimeSameAsSelectedEndTime = endTime.isSame(selectedToTime);
+    let isEndTimeBetweenSelectedStartAndEndTime = endTime.isBetween(selectedFromTime, selectedToTime);
+
+    return (
+      (isStartTimeBetweenSelectedStartAndEndTime && isEndTimeBetweenSelectedStartAndEndTime) ||
+      (isStartTimeSameAsSelectedStartTime && isEndTimeSameAsSelectedEndTime) ||
+      (isStartTimeSameAsSelectedStartTime && isEndTimeBetweenSelectedStartAndEndTime) ||
+      (isStartTimeBetweenSelectedStartAndEndTime && isEndTimeSameAsSelectedEndTime)
+    );
+  }
+
+  getDataInTheDateRange(obj: any, value: any, key: any) {
+    let parsingFormat: string;
+    if (key === "period") {
+      parsingFormat = "YYYY-MM-DD";
+      let startDateIsBetweenSelDate = moment(obj.startDate, parsingFormat).isBetween(
+        value.minSelectedDate,
+        value.maxSelectedDate
+      );
+      let endDateIsBetweenSelDate = moment(obj.endDate, parsingFormat).isBetween(
+        value.minSelectedDate,
+        value.maxSelectedDate
+      );
+
+      let startDateIsSameAsSelStartDate = moment(obj.startDate, parsingFormat).isSame(value.minSelectedDate);
+      let endDateIsSameAsSelEndDate = moment(obj.endDate, parsingFormat).isSame(value.maxSelectedDate);
+
+      return (
+        (startDateIsBetweenSelDate || startDateIsSameAsSelStartDate) &&
+        (endDateIsBetweenSelDate || endDateIsSameAsSelEndDate)
+      );
+    } else if (key === "AirDate" || key === "flightStartDate" || key === "flightEndDate") {
+      parsingFormat = "MM/DD/YYYY";
+      let dateIsBetweenSelDate = moment(obj[key], parsingFormat).isBetween(value.minSelectedDate, value.maxSelectedDate);
+
+      let dateIsSameAsSelStartDate = moment(obj[key], parsingFormat).isSame(value.minSelectedDate);
+      let dateIsSameAsSelEndDate = moment(obj[key], parsingFormat).isSame(value.maxSelectedDate);
+
+      return dateIsBetweenSelDate || dateIsSameAsSelStartDate || dateIsSameAsSelEndDate;
+    }
+    else {
+
+    }
+  }
+
+
+  public initializeTimeFilterData(clonedData: any[], key = "startEndTime") {
+    let startTimeArr = map(clonedData, "startTime");
+    let endTimeArr = map(clonedData, "endTime");
+  
+    startTimeArr.sort((a, b) => {
+        return this.dateTimeFormatService.sortByTimeAscending(a, b);
+    });
+  
+    endTimeArr.sort((a, b) => {
+        return this.dateTimeFormatService.sortByTimeDescending(a, b);
+    });
+  
+    let initialStartEndTime = {
+        startTime: startTimeArr[0],
+        endTime: endTimeArr[0],
+    };
+    this.initialValueMap.set(key, initialStartEndTime);
+  } 
+
+  returnColumnFilterStatus(data: any[], headername: string | number) {
+    return uniq(data.map((u) => u[headername])).length > 1 ? false : true;
+  } 
+
+}

package/src/lib/anna-core-shared-lib/services/anna-generic-table.service.ts

@@ -0,0 +1,50 @@
+// Angular import statements
+import { Injectable } from "@angular/core";
+
+// Third party import statements
+import { Subject } from "rxjs";
+
+//sub-entries of anna lib import statement
+import { AnnaSortService } from './anna-sort.service';
+import { AnnaFilterService } from "./anna-filter.service";
+
+@Injectable({
+  providedIn: "root",
+})
+export class AnnaGenericTableService {
+
+  virtualScrollSubject = new Subject();
+  constructor(private annaFilterService: AnnaFilterService, 
+    private annaSortService: AnnaSortService){}
+
+  calculateNumberOfSkeletonColumnsForTable(tableHeaders: any[]): number[][] {
+    let numberOfSkeletonColumns: any[][] = [];
+    var headersInEachColumn = 0;
+    tableHeaders.forEach((column) => {
+        if (column.visible) {
+            headersInEachColumn = 0;
+            column.headerInfo.forEach(() => {
+            headersInEachColumn++;
+            })
+            numberOfSkeletonColumns.push(Array(headersInEachColumn).fill(0));
+        }
+    })
+    return numberOfSkeletonColumns;
+  }
+
+  initColumnFilterAndSorting() {
+    this.annaFilterService.tooltipMap = new Map();
+    this.annaFilterService.tooltipSelectedMap = new Map();
+    this.annaFilterService.selectedRadio = null;
+    this.annaFilterService.appliedFiltersArray = [];
+    this.annaFilterService.initialValueMap = new Map();
+
+    this.annaSortService.tooltip = null;
+    this.annaSortService.sortByAsc = new Map();
+    this.annaSortService.sortByDesc = new Map();
+    this.annaSortService.keySorted = null;
+    this.annaSortService.isAsc = false;
+  }
+
+
+}