@annalib/anna-core 2.0.0 → 2.1.0

package/src/lib/anna-core-shared-lib/services/anna-date-time-format.service.ts

@@ -0,0 +1,197 @@
+// Angular import statements
+import { Injectable } from '@angular/core';
+import { NgbDate } from '@ng-bootstrap/ng-bootstrap';
+
+// Third party import statements
+import moment from "moment";
+
+// User defined import statements 
+export type NgbDateType = { year: number, month: number, day: number };
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AnnaDateTimeFormatService {
+
+  constructor() {
+    console.log("AnnaDateTimeFormatService service created.")
+  }
+
+  convertToNgbDateStandardFormat(date: any): NgbDateType | NgbDate {
+    return {
+      year: parseInt(moment(date, "MM/DD/YYYY").format("YYYY")),
+      month: parseInt(moment(date, "MM/DD/YYYY").format("M")),
+      day: parseInt(moment(date, "MM/DD/YYYY").format("D")),
+    };
+  }
+
+  convertToNgbDate(date: any, parseFormat: any): NgbDateType | NgbDate {
+    return {
+      year: parseInt(moment(date, parseFormat).format("YYYY")),
+      month: parseInt(moment(date, parseFormat).format("M")),
+      day: parseInt(moment(date, parseFormat).format("D")),
+    };
+  }
+
+  formatToTwelveHrs(time: any, callRemoveZero: boolean) {
+    if (time.endsWith('A') || time.endsWith('P')) {
+      time = time.substring(0, time.length - 1);
+    }
+    let tmp = time.split(":");
+    let formattedTime = [];
+    if (+tmp[0] > 12) {
+      formattedTime[0] = (+tmp[0] - 12).toString();
+      if (+tmp[0] == 24) formattedTime[2] = "AM";
+      else formattedTime[2] = "PM";
+    } else if (tmp[0] == "12") {
+      formattedTime[0] = tmp[0];
+      formattedTime[2] = "PM";
+    } else if (tmp[0] == "00") {
+      formattedTime[0] = "12"
+      formattedTime[2] = "AM";
+    } else {
+      formattedTime[0] = tmp[0];
+      formattedTime[2] = "AM";
+    }
+    formattedTime[1] = tmp[1];
+    if (callRemoveZero) formattedTime = this.removeZero(formattedTime);
+    return formattedTime;
+  }
+
+  convertTotwentyFourHrsFormat(time: any, callAddZero: any) {
+    let tmp = time.split(/[ :]+/);
+    let formattedTime = [];
+    if (tmp[0] != "12" && tmp[2] == "PM") {
+      formattedTime[0] = (+tmp[0] + 12).toString();
+    } else if (tmp[0] == "12" && tmp[2] == "AM") {
+      formattedTime[0] = "00";
+    } else formattedTime[0] = tmp[0].toString();
+    formattedTime[1] = tmp[1].toString();
+    if (callAddZero) formattedTime = this.addZero(formattedTime);
+    return formattedTime;
+  }
+
+  removeZero(time: any) {
+    let removedZero;
+    let formattedTime = time;
+    if (
+      time[0] == "01" ||
+      time[0] == "02" ||
+      time[0] == "03" ||
+      time[0] == "04" ||
+      time[0] == "05" ||
+      time[0] == "06" ||
+      time[0] == "07" ||
+      time[0] == "08" ||
+      time[0] == "09"
+    ) {
+      removedZero = time[0].toString();
+      formattedTime[0] = removedZero.charAt(1);
+      formattedTime[1] = time[1];
+      formattedTime[2] = time[2];
+    }
+    return formattedTime;
+  }
+
+  addZero(time: any) {
+    let addedZero;
+    let formattedTime = time;
+    if (time[1] == "0") time[1] = "0" + time[1];
+    if (
+      time[0] == "0" ||
+      time[0] == "1" ||
+      time[0] == "2" ||
+      time[0] == "3" ||
+      time[0] == "4" ||
+      time[0] == "5" ||
+      time[0] == "6" ||
+      time[0] == "7" ||
+      time[0] == "8" ||
+      time[0] == "9"
+    ) {
+      addedZero = "0" + time[0];
+      formattedTime[0] = addedZero;
+      formattedTime[1] = time[1];
+    }
+    return formattedTime;
+  }
+
+  sortByTimeAscending(a: any, b: any) {
+    let format = "HH:mm:ss";
+    a = moment(a, format);
+    b = moment(b, format);
+
+    let results;
+
+    results = a.hours() > b.hours() ? 1 : a.hours() < b.hours() ? -1 : 0;
+
+    if (results === 0) results = a.minutes() > b.minutes() ? 1 : a.minutes() < b.minutes() ? -1 : 0;
+
+    if (results === 0) results = a.seconds() > b.seconds() ? 1 : a.seconds() < b.seconds() ? -1 : 0;
+
+    return results;
+  }
+
+  sortByTimeDescending(a: any, b: any) {
+    let format = "HH:mm:ss";
+    a = moment(a, format);
+    b = moment(b, format);
+
+    let results;
+
+    results = a.hours() < b.hours() ? 1 : a.hours() > b.hours() ? -1 : 0;
+
+    if (results === 0) results = a.minutes() < b.minutes() ? 1 : a.minutes() > b.minutes() ? -1 : 0;
+
+    if (results === 0) results = a.seconds() < b.seconds() ? 1 : a.seconds() > b.seconds() ? -1 : 0;
+    return results;
+  }
+
+  convertNgbDateToMoment(ngbDate: NgbDate | NgbDateType): string {
+    let converted = moment();
+    converted.month(ngbDate.month - 1);
+    converted.date(ngbDate.day);
+    converted.year(ngbDate.year);
+    return converted.format("MM/DD/YYYY");
+  }
+
+  compareDate(a: string, b: string, isAsc: boolean) {
+    return isAsc ? moment(a).diff(b) : moment(b).diff(a);
+  }
+
+  formatDateAndHHMMATimeToStandardFormat(dateAndTime: any) {
+    let standardFormat, date, time;
+    if (dateAndTime.includes("|")) {
+      date = dateAndTime.slice(0, dateAndTime.indexOf("|"));
+      time = dateAndTime.slice(dateAndTime.indexOf('|') + 1, dateAndTime.length).trim();
+
+      time = time.slice(0, 2) + ":" + time.slice(2, 4) + " " + time.slice(4, 5);
+      time = time + "M";
+      standardFormat = date + time;
+    }
+    else {
+      standardFormat = dateAndTime + " 00:00 AM"
+    }
+    return moment(standardFormat).format("MM/DD/YYYY hh:mm A");
+  }
+
+  compare(a: number | string, b: number | string, isAsc: boolean) {
+    return (a < b ? -1 : 1) * (isAsc ? 1 : -1);
+  }
+
+  sortDataByBroadcastTimeAsc(firstParamTime: string, secondParamTime: string, broadcastTime: string) {
+    let format = "HH:mm:ss";
+
+    let a = moment(firstParamTime, format);
+    let b = moment(secondParamTime, format);
+
+    let broadcastMomentDateTime = moment(broadcastTime, "HH:mm:ss");
+
+    a = a.isBefore(broadcastMomentDateTime) ? a.add(1, "d") : a;
+    b = b.isBefore(broadcastMomentDateTime) ? b.add(1, "d") : b;
+
+    let result = a.isBefore(b) ? -1 : a.isAfter(b) ? 1 : 0;
+    return result;
+  }
+  
+}

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

@@ -0,0 +1,507 @@
+// 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";
+import { SortType } from '../models/anna-sort.model';
+
+// User defined import statements 
+import { AnnaDateTimeFormatService, NgbDateType } from './anna-date-time-format.service';
+import { AnnaSortService } from './anna-sort.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;
+  sliderCurrencySet = new Set(["booked","cpp","cpm","rcvPreempt","osPreempt","postedAdu","scheduledAdu","audienceDeficit","Rate"]);
+
+  public static bufferSize = 20;
+  isFilterSortActive: any = null;
+
+  constructor(private dateTimeFormatService: AnnaDateTimeFormatService, private annaSortService: AnnaSortService) {
+    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", "startEndTime"];
+    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[], sortMap: Map<string, SortType>): boolean {
+    let set: Set<string> = new Set(this.appliedFiltersArray);
+    if(header.length == 1){
+      return ( (sortMap.size > 0 && sortMap.get(header[0]) != "DEFAULT") || set.has(header[0]));
+    }
+    return ( (sortMap.size > 0 && sortMap.get(header[0]) != "DEFAULT") || (sortMap.size > 0 && sortMap.get(header[1]) != "DEFAULT") || set.has(header[0]) || set.has(header[1])); 
+
+  }
+
+  clearColumnFilter() {
+    if(this.tooltipSelectedMap.has(this.selectedRadio)){
+      this.tooltipSelectedMap.delete(this.selectedRadio);
+      let appliedFilterSet: Set<string> = new Set(this.appliedFiltersArray);
+      appliedFilterSet.delete(this.selectedRadio);
+      this.appliedFiltersArray = [...appliedFilterSet];  
+    }
+
+    if(this.annaSortService.columnSortState.has(this.selectedRadio)){
+      this.annaSortService.columnSortState.set(this.selectedRadio,"DEFAULT");
+    }
+
+  }
+
+  setOptionValues(minValue: number, maxValue: number) {
+    return {
+      floor: minValue,
+      ceil: maxValue,
+      disabled: true,
+      translate: this.normalTranslateFunction
+    };
+  }
+
+  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();
+  };
+
+  findUniqueDatesWithData(data: any[]) {
+    let uniqueDates = uniq(data.map((u) => u["date"]));
+    let uniqueDatesInNgbDateFormat: NgbDateType[] = [];
+    uniqueDates.forEach((date: any) => {
+      uniqueDatesInNgbDateFormat.push(
+        this.dateTimeFormatService.convertToNgbDateStandardFormat(moment(date, "MM/DD/YY").format("MM/DD/YYYY"))
+      );
+    });
+    return uniqueDatesInNgbDateFormat;
+  }
+
+  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" || key === "AirDate" || key === "flightStartDate" || key === "flightEndDate" || key == "date") {
+          filteredData = filteredData.filter((obj) => this.isObjectInTheRange(obj, value, key));
+        } else if (key === "period" ) {
+          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" || key == "startEndTime" || key === "TimeBand") {
+          filteredData = filteredData.filter((obj) => this.returnDataForStartAndEndTimeRange(obj, value, key));
+        }
+        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 (selectedData.includeMulti && obj[key] == "<multi>") {
+      return true;
+    }
+    if (!selectedData.includeMulti && obj[key] == "<multi>") {
+      return false;
+    }
+    if (selectedData.includeZero && obj[key] == "0") {
+      return true;
+    }
+    if (!selectedData.includeZero && obj[key] == "0") {
+      return false;
+    }
+    if (!selectedData.includeTimeRange) {
+      return false;
+    }
+
+
+    let momentTime = moment(objTime,format);
+    
+    let isObjTimeSameAsSelectedFromTime = momentTime.isSame(selectedFromTime);
+    let isObjTimeSameAsSelectedToTime = momentTime.isSame(selectedToTime);
+    let isObjTimeBetweenSelectedFromTimeAndToTime = momentTime.isBetween(selectedFromTime, selectedToTime);
+
+    return (
+      isObjTimeSameAsSelectedFromTime ||
+      isObjTimeSameAsSelectedToTime ||
+      isObjTimeBetweenSelectedFromTimeAndToTime
+    );
+  }
+
+  returnDataForStartAndEndTimeRange(obj: any, selectedData:any, key: string) {
+    let format = "HH:mm:ss";
+    let selectedFromTime = moment(selectedData.fromTime, format);
+    let selectedToTime = moment(selectedData.toTime, format);
+    
+    if(selectedData.includeMulti && obj[key][0] == "<multi>") {
+        return true;
+    }
+    
+    if(!selectedData.includeMulti && obj[key][0] == "<multi>") {
+        return false;
+    }
+
+    if(selectedData.includeZero && obj[key][0] == "0") {
+        return true;
+    }
+
+    if(!selectedData.includeZero && obj[key][0] == "0") {
+        return false;
+    }
+
+    if(!selectedData.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 momentStartDate = moment(obj.startDate);
+      let momentEndDate = moment(obj.endDate);
+      
+      let startDateIsBetweenSelDate = momentStartDate.isBetween(
+        value.fromDate,
+        value.toDate
+      );
+      let endDateIsBetweenSelDate = momentEndDate.isBetween(
+        value.fromDate,
+        value.toDate
+      );
+      
+      
+      let startDateIsSameAsSelStartDate = value.fromDate.isSame(momentStartDate);
+      let endDateIsSameAsSelEndDate = value.toDate.isSame(momentEndDate);
+
+      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;
+    }
+  }
+
+
+  public initializeTimeFilterData(clonedData: any[], key = "startEndTime") {
+    let startTimeArr = map(clonedData, "startTime");
+    let endTimeArr = map(clonedData, "endTime");
+  
+    startTimeArr.sort((a: any, b: any) => {
+        return this.dateTimeFormatService.sortByTimeAscending(a, b);
+    });
+  
+    endTimeArr.sort((a: any, b: any) => {
+        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) {
+
+    if(headerName == "startEndTime"){
+      let time = data.map(u => u[headerName][0]);
+      let uniqTime = uniq(time);
+      return uniqTime.length == 0;
+    }
+
+    return uniq(data.map((u) => u[headerName])).length > 1 ? false : true;
+  }
+  
+  getFilterOptionsData(data: any[], clonedData: any[]){
+    let appliedFilterSet = new Set(this.appliedFiltersArray);
+    if(appliedFilterSet.has(this.selectedRadio)){
+      return this.filterData(clonedData, this.selectedRadio);
+    }
+    else{
+      return data;
+    }
+  }
+
+  reOrderAppliedFiltersState(clonedData: any[], value: any){
+    let isFiltered = true;
+    isFiltered = this.checkIfFilterIsApplied(clonedData,value);
+    this.removeOrChangeLatestFilterIndex(isFiltered);
+    return isFiltered;
+  }
+
+  checkIfFilterIsApplied(clonedData: any[],value: any){
+    let initialValueOfColumn = sortBy(clonedData.map(item => item[this.selectedRadio]));
+    let currentValueOfColumn = sortBy(this.applyFilter(clonedData,value).map(item => item[this.selectedRadio]));
+    return !isEqual(initialValueOfColumn, currentValueOfColumn);
+  }
+
+  applyFilter(data: any[],value: any){
+    let filteredData = data;
+    let key = this.selectedRadio;
+      if (this.sliderSet.has(key)) {
+        filteredData = filteredData.filter((obj) => obj[key] >= value.min && obj[key] <= value.max);
+      }
+      else if (key === "startDate" || key === "endDate" || key === "AirDate" || key === "flightStartDate" || key === "flightEndDate" || key == "date") {
+        filteredData = filteredData.filter((obj) => this.isObjectInTheRange(obj, value, key));
+      } else if (key === "period" ) {
+        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" || key == "startEndTime" || key === "TimeBand") {
+        filteredData = filteredData.filter((obj) => this.returnDataForStartAndEndTimeRange(obj, value, key));
+      }
+      else if (value.length > 0) {
+        filteredData = filteredData.filter((u) => value.includes(u[key]));
+      }
+      return filteredData;  
+  }
+
+  isObjectInTheRange(obj: any, value: {fromDate: moment.Moment, toDate: moment.Moment},key:string){
+    let objVal = obj[key];
+    let momentDate = moment(objVal);
+    let isDateSameAsStartOfTheRange = value.fromDate.isSame(objVal);
+    let isDateSameAsEndOfTheRange = value.toDate.isSame(objVal);
+    let isDateBetweenTheStartAndEndOfRange = momentDate.isBetween(value.fromDate,value.toDate);
+    return isDateSameAsStartOfTheRange || isDateSameAsEndOfTheRange || isDateBetweenTheStartAndEndOfRange;
+  }
+
+  updateStateOfTheCurrentFilterTab(sortMap: Map<string, SortType>){
+    let activeKey = this.selectedRadio;
+    let keyArr: string[] = [];
+    Object.keys(this.isFilterSortActive).forEach(key => {
+      if(key.includes(activeKey)){
+        keyArr = key.split(",");
+        this.isFilterSortActive[key] =  this.isTooltipActive(keyArr, sortMap);
+      }
+    });
+
+  }
+
+  updateStateOfAllTheKeys(sortMap: Map<string, SortType>){
+     Object.keys(this.isFilterSortActive).forEach(key => {
+       let keyArr = key.split(",");
+       this.isFilterSortActive[key] = this.isTooltipActive(keyArr,sortMap);
+     })     
+  }
+    
+}