@sunbird-cb/consumption 0.0.0-watch

package/esm2015/lib/_common/content-strip-with-tabs-lib/content-strip-with-tabs-lib.component.js

@@ -0,0 +1,1661 @@
+import { __awaiter } from "tslib";
+import { Component, Input, HostBinding, Inject, EventEmitter, Output } from '@angular/core';
+import { WidgetBaseComponent } from '@sunbird-cb/resolver-v2';
+import { WsEvents, } from '@sunbird-cb/utils-v2';
+import { filter } from 'rxjs/operators';
+// import { environment } from 'src/environments/environment'
+// tslint:disable-next-line
+import * as _ from 'lodash';
+import { NsCardContent } from '../../_models/card-content-v2.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../_services/widget-content.service";
+import * as i2 from "@sunbird-cb/utils-v2";
+import * as i3 from "@angular/router";
+import * as i4 from "../../_services/widget-user.service";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "../../_services/multilingual-translations.service";
+import * as i7 from "@angular/material/button";
+import * as i8 from "@angular/material/icon";
+import * as i9 from "@angular/material/tabs";
+import * as i10 from "../horizontal-scroller-v2/horizontal-scroller-v2.component";
+import * as i11 from "@angular/common";
+import * as i12 from "@sunbird-cb/resolver-v2";
+import * as i13 from "@angular/material/tooltip";
+export class ContentStripWithTabsLibComponent extends WidgetBaseComponent {
+    constructor(
+    // private contentStripSvc: ContentStripNewMultipleService,
+    environment, contentSvc, loggerSvc, eventSvc, configSvc, utilitySvc, 
+    // private http: HttpClient,
+    // private searchServSvc: SearchServService,
+    router, userSvc, translate, langtranslations) {
+        super();
+        this.contentSvc = contentSvc;
+        this.loggerSvc = loggerSvc;
+        this.eventSvc = eventSvc;
+        this.configSvc = configSvc;
+        this.utilitySvc = utilitySvc;
+        this.router = router;
+        this.userSvc = userSvc;
+        this.translate = translate;
+        this.langtranslations = langtranslations;
+        this.emptyResponse = new EventEmitter();
+        this.viewAllResponse = new EventEmitter();
+        this.telemtryResponse = new EventEmitter();
+        this.providerId = '';
+        this.emitViewAll = false;
+        this.channnelName = '';
+        this.id = `ws-strip-miltiple_${Math.random()}`;
+        this.stripsResultDataMap = {};
+        this.stripsKeyOrder = [];
+        this.showAccordionData = true;
+        this.showParentLoader = false;
+        this.showParentError = false;
+        this.showParentNoData = false;
+        this.errorDataCount = 0;
+        this.noDataCount = 0;
+        this.successDataCount = 0;
+        this.contentAvailable = true;
+        this.baseUrl = this.configSvc.sitePath || '';
+        this.veifiedKarmayogi = false;
+        this.changeEventSubscription = null;
+        this.defaultMaxWidgets = 12;
+        this.todaysEvents = [];
+        if (localStorage.getItem('websiteLanguage')) {
+            this.translate.setDefaultLang('en');
+            let lang = JSON.stringify(localStorage.getItem('websiteLanguage'));
+            lang = lang.replace(/\"/g, '');
+            this.translate.use(lang);
+        }
+        this.environment = environment;
+    }
+    ngOnInit() {
+        // const url = window.location.href
+        this.initData();
+        this.contentSvc.telemetryData$.subscribe((data) => {
+            this.telemtryResponse.emit(data);
+        });
+    }
+    ngOnDestroy() {
+        if (this.changeEventSubscription) {
+            this.changeEventSubscription.unsubscribe();
+        }
+    }
+    showAccordion(key) {
+        if (this.utilitySvc.isMobile && this.stripsResultDataMap[key].mode === 'accordion') {
+            return this.showAccordionData;
+        }
+        return true;
+    }
+    setHiddenForStrip(key) {
+        this.stripsResultDataMap[key].showStrip = false;
+        sessionStorage.setItem(`cstrip_${key}`, '1');
+    }
+    getIfStripHidden(key) {
+        const storageItem = sessionStorage.getItem(`cstrip_${key}`);
+        return Boolean(storageItem !== '1');
+    }
+    initData() {
+        this.stripsKeyOrder = this.widgetData && this.widgetData.strips && this.widgetData.strips.map(strip => strip.key) || [];
+        if (this.widgetData.loader && this.widgetData.strips.length) {
+            this.showParentLoader = true;
+        }
+        // Fetch the data
+        for (const strip of this.widgetData.strips) {
+            if (this.checkForEmptyWidget(strip)) {
+                this.fetchStripFromRequestData(strip, false);
+            }
+            else {
+                this.processStrip(strip, [], 'done', true, null);
+            }
+        }
+        // Subscription for changes
+        const keyAndEvent = this.widgetData.strips
+            .map(strip => ({
+            key: strip.key,
+            type: (strip.refreshEvent && strip.refreshEvent.eventType) || '',
+            from: (strip.refreshEvent && strip.refreshEvent.from.toString()) || '',
+        }))
+            .filter(({ key, type, from }) => key && type && from);
+        const eventTypeSet = new Set(keyAndEvent.map(e => e.type));
+        this.changeEventSubscription = this.eventSvc.events$
+            .pipe(filter(event => eventTypeSet.has(event.eventType)))
+            .subscribe(event => {
+            keyAndEvent
+                .filter(e => e.type === event.eventType && e.from === event.from)
+                .map(e => e.key)
+                .forEach(k => this.fetchStripFromKey(k, false));
+        });
+    }
+    fetchStripFromKey(key, calculateParentStatus = true) {
+        const stripData = this.widgetData.strips.find(strip => strip.key === key);
+        if (stripData) {
+            this.fetchStripFromRequestData(stripData, calculateParentStatus);
+        }
+    }
+    isStripShowing(data) {
+        let count = 0;
+        if (data && data.key === this.environment.programStripKey && (!data.tabs || !data.tabs.length) &&
+            data.stripTitle === this.environment.programStripName && data.widgets.length > 0) {
+            data.widgets.forEach((key) => {
+                if (key && key.widgetData.content.primaryCategory === this.environment.programStripPrimaryCategory) {
+                    count = count + 1;
+                }
+            });
+            if (count > 0) {
+                data.showStrip = true;
+            }
+            else {
+                data.showStrip = false;
+            }
+        }
+        // console.log('data.key', data, data.key, data.widgets);
+        return data.showStrip;
+    }
+    get isMobile() {
+        return this.utilitySvc.isMobile || false;
+    }
+    getdata(data) {
+        if (data.stripInfo) {
+            return data.stripInfo.widget;
+        }
+        return {};
+    }
+    checkCondition(wData, data) {
+        if (wData.strips[0].stripConfig && wData.strips[0].stripConfig.hideShowAll) {
+            return !wData.strips[0].stripConfig.hideShowAll;
+        }
+        return wData.strips[0].viewMoreUrl && data.widgets && data.widgets.length >= 4;
+    }
+    checkVisible(data) {
+        return data.stripInfo && data.stripInfo.visibilityMode === 'visible';
+    }
+    getContineuLearningLenth(data) {
+        return data.widgets ? data.widgets.length : 0;
+    }
+    getLength(data) {
+        if (!data.tabs || !data.tabs.length) {
+            return data.widgets ? data.widgets.length : 0;
+        }
+        {
+            // if tabs are there check if each tab has widgets and get the tab with max widgets
+            const tabWithMaxWidgets = data.tabs.reduce((prev, current) => {
+                if (!prev.widgets && !current.widgets) {
+                    return current;
+                }
+                if (prev.widgets && current.widgets) {
+                    return (prev.widgets.length > current.widgets.length) ? prev : current;
+                }
+                if (current.widgets && !prev.widgets) {
+                    return current;
+                }
+                if (!current.widgets && prev.widgets) {
+                    return prev;
+                }
+                return current;
+                // return (prev.widgets && current.widgets && (prev.widgets.length > current.widgets.length) ) ? prev : current
+                // tslint:disable-next-line: align
+            }, data.tabs[0]);
+            // if tabs has atleast 1 widgets then strip will show or else not
+            return tabWithMaxWidgets.widgets ? tabWithMaxWidgets.widgets.length : 0;
+        }
+    }
+    getFiltersFromArray(v6filters) {
+        const filters = {};
+        if (v6filters.constructor === Array) {
+            v6filters.forEach(((f) => {
+                Object.keys(f).forEach(key => {
+                    filters[key] = f[key];
+                });
+            }));
+            return filters;
+        }
+        return v6filters;
+    }
+    transformSearchV6FiltersV2(v6filters) {
+        const filters = {};
+        if (v6filters.constructor === Array) {
+            v6filters.forEach(((f) => {
+                Object.keys(f).forEach(key => {
+                    filters[key] = f[key];
+                });
+            }));
+            return filters;
+        }
+        return v6filters;
+    }
+    checkForDateFilters(filters) {
+        let userData;
+        if (this.configSvc.userProfile) {
+            userData = this.configSvc.userProfile;
+        }
+        if (filters && filters.hasOwnProperty('batches.endDate')) {
+            // tslint:disable-next-line
+            filters['batches.endDate']['>='] = eval(filters['batches.endDate']['>=']);
+        }
+        else if (filters && filters.hasOwnProperty('batches.enrollmentEndDate')) {
+            // tslint:disable-next-line
+            filters['batches.enrollmentEndDate']['>='] = eval(filters['batches.enrollmentEndDate']['>=']);
+        }
+        else if (filters.organisation &&
+            filters.organisation.indexOf('<orgID>') >= 0) {
+            if (this.providerId) {
+                filters.organisation = this.providerId;
+            }
+            else {
+                filters.organisation = userData && userData.rootOrgId;
+                if (filters && filters.hasOwnProperty('designation')) {
+                    filters.designation = userData.professionalDetails.length > 0 ?
+                        userData.professionalDetails[0].designation : '';
+                }
+            }
+        }
+        return filters;
+    }
+    fetchStripFromRequestData(strip, calculateParentStatus = true) {
+        // setting initial values
+        strip.loaderWidgets = this.transformSkeletonToWidgets(strip);
+        this.processStrip(strip, [], 'fetching', false, null);
+        this.fetchFromEnrollmentList(strip, calculateParentStatus);
+        this.fetchFromSearchV6(strip, calculateParentStatus);
+        this.fetchFromTrendingContent(strip, calculateParentStatus);
+        this.fetchAllCbpPlans(strip, calculateParentStatus);
+        this.fetchAllTopContent(strip, calculateParentStatus);
+        this.fetchAllFeaturedContent(strip, calculateParentStatus);
+        this.fetchAllBookMarkData(strip, calculateParentStatus);
+        this.fetchAllPlaylistSearch(strip, calculateParentStatus);
+        this.fetchPlaylistReadData(strip, calculateParentStatus);
+        this.fetchCiosContentData(strip, calculateParentStatus);
+        // this.enrollInterval = setInterval(() => {
+        //   this.fetchAllCbpPlans(strip, calculateParentStatus)
+        // },                                1000)
+    }
+    fetchFromEnrollmentList(strip, calculateParentStatus = true) {
+        if (strip.request && strip.request.enrollmentList && Object.keys(strip.request.enrollmentList).length) {
+            let userId = '';
+            let content;
+            let contentNew;
+            let tabResults = [];
+            const queryParams = _.get(strip.request.enrollmentList, 'queryParams');
+            // if (queryParams && queryParams.batchDetails) {
+            //   if (!queryParams.batchDetails.includes('&retiredCoursesEnabled=true')) {
+            //     queryParams.batchDetails += '&retiredCoursesEnabled=true'
+            //   }
+            // }
+            if (this.configSvc.userProfile) {
+                userId = this.configSvc.userProfile.userId;
+            }
+            // this.userSvc.resetTime('enrollmentService')
+            // tslint:disable-next-line: deprecation
+            this.userSvc.fetchUserBatchList(userId, queryParams).subscribe((result) => {
+                const courses = result && result.courses;
+                const showViewMore = Boolean(courses.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch);
+                const viewMoreUrl = showViewMore
+                    ? {
+                        path: (strip.viewMoreUrl && strip.viewMoreUrl.path) || '',
+                        queryParams: {
+                            q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,
+                            f: strip.request && strip.request.searchV6 && strip.request.searchV6.filters
+                                ? JSON.stringify(
+                                // this.searchServSvc.transformSearchV6Filters(
+                                strip.request.searchV6.filters
+                                // ),
+                                )
+                                : {},
+                        },
+                    }
+                    : null;
+                if (courses && courses.length) {
+                    content = courses.map((c) => {
+                        const contentTemp = c.content;
+                        contentTemp.completionPercentage = c.completionPercentage || c.progress || 0;
+                        contentTemp.completionStatus = c.completionStatus || c.status || 0;
+                        contentTemp.enrolledDate = c.enrolledDate || '';
+                        contentTemp.lastContentAccessTime = c.lastContentAccessTime || '';
+                        contentTemp.lastReadContentStatus = c.lastReadContentStatus || '';
+                        contentTemp.lastReadContentId = c.lastReadContentId || '';
+                        contentTemp.lrcProgressDetails = c.lrcProgressDetails || '';
+                        contentTemp.issuedCertificates = c.issuedCertificates || [];
+                        contentTemp.batchId = c.batchId || '';
+                        return contentTemp;
+                    });
+                }
+                // To filter content with completionPercentage > 0,
+                // so that only those content will show in home page
+                // continue learing strip
+                // if (content && content.length) {
+                //   contentNew = content.filter((c: any) => {
+                //     /** commented as both are 0 after enrolll */
+                //     if (c.completionPercentage && c.completionPercentage > 0) {
+                //       return c
+                //     }
+                //   })
+                // }
+                // To sort in descending order of the enrolled date
+                contentNew = (content || []).sort((a, b) => {
+                    const dateA = new Date(a.lastContentAccessTime || 0);
+                    const dateB = new Date(b.lastContentAccessTime || 0);
+                    return dateB - dateA;
+                });
+                if (strip.tabs && strip.tabs.length) {
+                    tabResults = this.splitEnrollmentTabsData(contentNew, strip);
+                    this.processStrip(strip, this.transformContentsToWidgets(contentNew, strip), 'done', calculateParentStatus, viewMoreUrl, tabResults);
+                }
+                else {
+                    this.processStrip(strip, this.transformContentsToWidgets(contentNew, strip), 'done', calculateParentStatus, viewMoreUrl);
+                }
+            }, () => {
+                this.processStrip(strip, [], 'error', calculateParentStatus, null);
+            });
+        }
+    }
+    splitEnrollmentTabsData(contentNew, strip) {
+        const tabResults = [];
+        const splitData = this.getInprogressAndCompleted(contentNew, (e) => e.completionStatus === 1 || e.completionPercentage < 100, strip);
+        if (strip.tabs && strip.tabs.length) {
+            for (let i = 0; i < strip.tabs.length; i += 1) {
+                if (strip.tabs[i]) {
+                    tabResults.push(Object.assign(Object.assign(Object.assign({}, strip.tabs[i]), { fetchTabStatus: 'done' }), (splitData.find(itmInner => {
+                        if (strip.tabs && strip.tabs[i] && itmInner.value === strip.tabs[i].value) {
+                            return itmInner;
+                        }
+                        return undefined;
+                    }))));
+                }
+            }
+        }
+        return tabResults;
+    }
+    getInprogressAndCompleted(array, customFilter, strip) {
+        const inprogress = [];
+        const completed = [];
+        // array.forEach((e: any, idx: number, arr: any[]) => (customFilter(e, idx, arr) ? inprogress : completed).push(e))
+        array.forEach((e, idx, arr) => {
+            const status = e.status ? e.status.toLowerCase() : '';
+            const statusRetired = status === 'retired';
+            if (customFilter(e, idx, arr)) {
+                if (!statusRetired) {
+                    inprogress.push(e);
+                }
+            }
+            else {
+                completed.push(e);
+            }
+        });
+        // Sort the completed array with 'Live' status first and 'Retired' status second
+        completed.sort((a, b) => {
+            const statusA = a.status ? a.status.toLowerCase() : '';
+            const statusB = b.status ? b.status.toLowerCase() : '';
+            if (statusA === 'live' && statusB !== 'live') {
+                return -1;
+            }
+            if (statusA !== 'live' && statusB === 'live') {
+                return 1;
+            }
+            if (statusA === 'retired' && statusB !== 'retired') {
+                return 1;
+            }
+            if (statusA !== 'retired' && statusB === 'retired') {
+                return -1;
+            }
+            return 0;
+        });
+        return [
+            { value: 'inprogress', widgets: this.transformContentsToWidgets(inprogress, strip) },
+            { value: 'completed', widgets: this.transformContentsToWidgets(completed, strip) }
+        ];
+    }
+    fetchFromSearchV6(strip, calculateParentStatus = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (strip.request && strip.request.searchV6 && Object.keys(strip.request.searchV6).length) {
+                // if (!(strip.request.searchV6.locale && strip.request.searchV6.locale.length > 0)) {
+                //   if (this.configSvc.activeLocale) {
+                //     strip.request.searchV6.locale = [this.configSvc.activeLocale.locals[0]]
+                //   } else {
+                //     strip.request.searchV6.locale = ['en']
+                //   }
+                // }
+                let originalFilters = [];
+                // tslint:disable:no-console
+                console.log(originalFilters);
+                if (strip.request &&
+                    strip.request.searchV6 &&
+                    strip.request.searchV6.request &&
+                    strip.request.searchV6.request.filters) {
+                    originalFilters = strip.request.searchV6.request.filters;
+                    strip.request.searchV6.request.filters = this.checkForDateFilters(strip.request.searchV6.request.filters);
+                    strip.request.searchV6.request.filters = this.getFiltersFromArray(strip.request.searchV6.request.filters);
+                }
+                if (strip.tabs && strip.tabs.length) {
+                    // TODO: Have to extract requestRequired to outer level of tabs config
+                    const firstTab = strip.tabs[0];
+                    if (firstTab.requestRequired) {
+                        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                            const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]);
+                            this.getTabDataByNewReqSearchV6(strip, 0, currentTabFromMap, calculateParentStatus);
+                        }
+                    }
+                }
+                else {
+                    try {
+                        const response = yield this.searchV6Request(strip, strip.request, calculateParentStatus);
+                        // console.log('calling  after - response, ', response)
+                        if (response && response.results) {
+                            // console.log('calling  after-- ')
+                            if (response.results.result.content) {
+                                if (strip.key === 'scheduledAssessment') {
+                                    this.enrollInterval = setInterval(() => {
+                                        this.checkInvitOnlyAssessments(response.results.result.content, strip, calculateParentStatus, response.viewMoreUrl);
+                                        // tslint:disable-next-line
+                                    }, 1000);
+                                }
+                                else {
+                                    this.processStrip(strip, this.transformContentsToWidgets(response.results.result.content, strip), 'done', calculateParentStatus, response.viewMoreUrl);
+                                }
+                            }
+                            else if (response.results.result.Event) {
+                                this.processStrip(strip, this.transformEventsToWidgets(response.results.result.Event, strip), 'done', calculateParentStatus, response.viewMoreUrl);
+                            }
+                            else {
+                                this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                            }
+                        }
+                        else {
+                            this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                        }
+                    }
+                    catch (error) {
+                        // Handle errors
+                        // console.error('Error:', error);
+                    }
+                }
+            }
+        });
+    }
+    checkInvitOnlyAssessments(content, strip, calculateParentStatus, viewMoreUrl) {
+        if (localStorage.getItem('enrollmentMapData')) {
+            this.enrollmentMapData = JSON.parse(localStorage.getItem('enrollmentMapData') || '{}');
+            let filteredArray = [];
+            let now = new Date().getTime();
+            content.forEach((data) => {
+                if (this.enrollmentMapData[data.identifier]) {
+                    if (this.enrollmentMapData[data.identifier].status !== 2 && this.enrollmentMapData[data.identifier].batch) {
+                        const enrollData = this.enrollmentMapData[data.identifier].batch;
+                        let endDate = new Date(enrollData.endDate).getTime();
+                        // let endDate:any = '2024-07-7T00:00:00.000Z'
+                        let timeDuration = endDate - now;
+                        if (timeDuration > 0) {
+                            data['batch'] = this.enrollmentMapData[data.identifier].batch;
+                            data['completionPercentage'] = this.enrollmentMapData[data.identifier].completionPercentage;
+                            filteredArray.push(data);
+                        }
+                    }
+                }
+            });
+            filteredArray = filteredArray.sort((a, b) => {
+                const dateA = new Date(a.batch.startDate || 0);
+                const dateB = new Date(b.batch.startDate || 0);
+                return dateA - dateB;
+            });
+            this.processStrip(strip, this.transformContentsToWidgets(filteredArray, strip), 'done', calculateParentStatus, viewMoreUrl);
+            clearInterval(this.enrollInterval);
+        }
+    }
+    searchV6Request(strip, request, calculateParentStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const originalFilters = [];
+            return new Promise((resolve, reject) => {
+                if (request && request.searchV6) {
+                    this.contentSvc.searchV6(request.searchV6).subscribe(results => {
+                        const showViewMore = Boolean(results.result.content && results.result.content.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch);
+                        const viewMoreUrl = showViewMore
+                            ? {
+                                path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',
+                                queryParams: {
+                                    tab: 'Learn',
+                                    q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,
+                                    f: request &&
+                                        request.searchV6 &&
+                                        request.searchV6.request &&
+                                        request.searchV6.request.filters
+                                        ? JSON.stringify(this.transformSearchV6FiltersV2(originalFilters))
+                                        : {},
+                                },
+                            }
+                            : null;
+                        // if (viewMoreUrl && viewMoreUrl.queryParams) {
+                        //   viewMoreUrl.queryParams = viewMoreUrl.queryParams
+                        // }
+                        resolve({ results, viewMoreUrl });
+                    }, (error) => {
+                        this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                        reject(error);
+                    });
+                }
+            });
+        });
+    }
+    fetchFromTrendingContent(strip, calculateParentStatus = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (strip.request && strip.request.trendingSearch && Object.keys(strip.request.trendingSearch).length) {
+                // if (!(strip.request.searchV6.locale && strip.request.searchV6.locale.length > 0)) {
+                //   if (this.configSvc.activeLocale) {
+                //     strip.request.searchV6.locale = [this.configSvc.activeLocale.locals[0]]
+                //   } else {
+                //     strip.request.searchV6.locale = ['en']
+                //   }
+                // }
+                let originalFilters = [];
+                // tslint:disable:no-console
+                console.log(originalFilters);
+                if (strip.request &&
+                    strip.request.trendingSearch &&
+                    strip.request.trendingSearch.request &&
+                    strip.request.trendingSearch.request.filters) {
+                    originalFilters = strip.request.trendingSearch.request.filters;
+                    strip.request.trendingSearch.request.filters = this.checkForDateFilters(strip.request.trendingSearch.request.filters);
+                    strip.request.trendingSearch.request.filters = this.getFiltersFromArray(strip.request.trendingSearch.request.filters);
+                }
+                if (strip.tabs && strip.tabs.length) {
+                    // TODO: Have to extract requestRequired to outer level of tabs config
+                    const firstTab = strip.tabs[0];
+                    if (firstTab.requestRequired) {
+                        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                            const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]);
+                            this.getTabDataByNewReqTrending(strip, 0, currentTabFromMap, calculateParentStatus);
+                        }
+                    }
+                }
+                else {
+                    try {
+                        const response = yield this.trendingSearchRequest(strip, strip.request, calculateParentStatus);
+                        if (response && response.results && response.results.response) {
+                            const content = response.results.response[strip.request.trendingSearch.responseKey] || [];
+                            this.processStrip(strip, this.transformContentsToWidgets(content, strip), 'done', calculateParentStatus, response.viewMoreUrl || '');
+                            if (!content.length) {
+                                this.emptyResponse.emit(true);
+                            }
+                        }
+                        else {
+                            this.emptyResponse.emit(true);
+                            this.processStrip(strip, [], 'done', calculateParentStatus, null);
+                        }
+                    }
+                    catch (error) {
+                        // Handle errors
+                        this.emptyResponse.emit(true);
+                        this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                    }
+                }
+            }
+        });
+    }
+    trendingSearchRequest(strip, request, calculateParentStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const originalFilters = [];
+            return new Promise((resolve, reject) => {
+                if (request && request.trendingSearch) {
+                    // check for the request if it has dynamic values]
+                    if (request.trendingSearch.request.filters.organisation &&
+                        request.trendingSearch.request.filters.organisation.indexOf('<orgID>') >= 0) {
+                        let userRootOrgId;
+                        if (this.configSvc.userProfile) {
+                            userRootOrgId = this.configSvc.userProfile.rootOrgId;
+                        }
+                        request.trendingSearch.request.filters.organisation = userRootOrgId;
+                    }
+                    this.contentSvc.trendingContentSearch(request.trendingSearch).subscribe(results => {
+                        const showViewMore = Boolean(results.result &&
+                            strip.request &&
+                            results.result[strip.request.trendingSearch.responseKey] &&
+                            results.result[strip.request.trendingSearch.responseKey].length > 5 &&
+                            strip.stripConfig && strip.stripConfig.postCardForSearch);
+                        const viewMoreUrl = showViewMore
+                            ? {
+                                path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',
+                                queryParams: {
+                                    tab: 'Learn',
+                                    q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,
+                                    f: request &&
+                                        request.trendingSearch &&
+                                        request.trendingSearch.request &&
+                                        request.trendingSearch.request.filters
+                                        ? JSON.stringify(this.transformSearchV6FiltersV2(originalFilters))
+                                        : {},
+                                },
+                            }
+                            : null;
+                        let proccesedResult = [];
+                        if (results && results.response && results.response.certifications) {
+                            results.response.certifications.map((result) => {
+                                if (result.source === this.channnelName) {
+                                    proccesedResult.push(result);
+                                }
+                            });
+                        }
+                        results = { response: { certifications: proccesedResult } };
+                        resolve({ results, viewMoreUrl });
+                    }, (error) => {
+                        if (error.error && error.error.status === 400) {
+                            this.processStrip(strip, [], 'done', calculateParentStatus, null);
+                        }
+                        // this.processStrip(strip, [], 'done', calculateParentStatus, null)
+                        reject(error);
+                    });
+                }
+            });
+        });
+    }
+    toggleInfo(data) {
+        const stripInfo = this.stripsResultDataMap[data.key].stripInfo;
+        if (stripInfo) {
+            if (stripInfo.mode !== 'below') {
+                this.loggerSvc.warn(`strip info mode: ${stripInfo.mode} not implemented yet`);
+                stripInfo.mode = 'below';
+            }
+            if (stripInfo.mode === 'below') {
+                this.stripsResultDataMap[data.key].stripInfo = Object.assign(Object.assign({}, stripInfo), { visibilityMode: stripInfo.visibilityMode === 'hidden' ? 'visible' : 'hidden' });
+            }
+        }
+    }
+    transformContentsToWidgets(contents, strip) {
+        return (contents || []).map((content, idx) => (content ? {
+            widgetType: 'cardLib',
+            widgetSubType: 'cardContentLib',
+            widgetHostClass: 'mb-2',
+            widgetData: Object.assign(Object.assign({ content }, (content.batch && { batch: content.batch })), { cardSubType: strip.stripConfig && strip.stripConfig.cardSubType, cardCustomeClass: strip.customeClass ? strip.customeClass : '', context: { pageSection: strip.key, position: idx }, intranetMode: strip.stripConfig && strip.stripConfig.intranetMode, deletedMode: strip.stripConfig && strip.stripConfig.deletedMode, contentTags: strip.stripConfig && strip.stripConfig.contentTags }),
+        } : {
+            widgetType: 'card',
+            widgetSubType: 'cardContent',
+            widgetHostClass: 'mb-2',
+            widgetData: {},
+        }));
+    }
+    transformEventsToWidgets(contents, strip) {
+        this.eventSvc.setEventListData(contents);
+        return (this.eventSvc.todaysEvents || []).map((content, idx) => (content ? {
+            widgetType: 'card',
+            widgetSubType: 'eventHubCard',
+            widgetHostClass: 'mb-2',
+            widgetData: {
+                content,
+                cardSubType: strip.stripConfig && strip.stripConfig.cardSubType,
+                cardCustomeClass: strip.customeClass ? strip.customeClass : '',
+                context: { pageSection: strip.key, position: idx },
+                intranetMode: strip.stripConfig && strip.stripConfig.intranetMode,
+                deletedMode: strip.stripConfig && strip.stripConfig.deletedMode,
+                contentTags: strip.stripConfig && strip.stripConfig.contentTags,
+            },
+        } : {
+            widgetType: 'card',
+            widgetSubType: 'eventHubCard',
+            widgetHostClass: 'mb-2',
+            widgetData: {},
+        }));
+    }
+    transformSkeletonToWidgets(strip) {
+        return [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10].map(_content => ({
+            widgetType: 'cardLib',
+            widgetSubType: 'cardContentLib',
+            widgetHostClass: 'mb-2',
+            widgetData: {
+                cardSubType: strip.loaderConfig && strip.loaderConfig.cardSubType || 'card-standard-skeleton',
+                cardCustomeClass: strip.customeClass ? strip.customeClass : '',
+            },
+        }));
+    }
+    processStrip(strip, results = [], fetchStatus, calculateParentStatus = true, _viewMoreUrl, tabsResults) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stripData = {
+                viewMoreUrl: strip.viewMoreUrl,
+                key: strip.key,
+                canHideStrip: Boolean(strip.canHideStrip),
+                showStrip: this.getIfStripHidden(strip.key),
+                noDataWidget: strip.noDataWidget,
+                errorWidget: strip.errorWidget,
+                stripInfo: strip.info,
+                stripTitle: strip.title,
+                stripTitleLink: strip.stripTitleLink,
+                disableTranslate: strip.disableTranslate,
+                sliderConfig: strip.sliderConfig,
+                tabs: tabsResults ? tabsResults : strip.tabs,
+                tabsType: strip.tabsType ? strip.tabsType : '',
+                stripName: strip.name,
+                mode: strip.mode,
+                stripConfig: strip.stripConfig,
+                stripBackground: strip.stripBackground,
+                secondaryHeading: strip.secondaryHeading,
+                loaderWidgets: strip.loaderWidgets || [],
+                widgets: fetchStatus === 'done'
+                    ? [
+                        ...(strip.preWidgets || []).map(w => (Object.assign(Object.assign({}, w), { widgetHostClass: `mb-2 ${w.widgetHostClass}` }))),
+                        ...results,
+                        ...(strip.postWidgets || []).map(w => (Object.assign(Object.assign({}, w), { widgetHostClass: `mb-2 ${w.widgetHostClass}` }))),
+                    ]
+                    : [],
+                showOnNoData: Boolean(strip.noDataWidget &&
+                    !((strip.preWidgets || []).length + results.length + (strip.postWidgets || []).length) &&
+                    fetchStatus === 'done'),
+                showOnLoader: Boolean(strip.loader && fetchStatus === 'fetching'),
+                showOnError: Boolean(strip.errorWidget && fetchStatus === 'error'),
+            };
+            // const stripData = this.stripsResultDataMap[strip.key]
+            this.stripsResultDataMap = Object.assign(Object.assign({}, this.stripsResultDataMap), { [strip.key]: stripData });
+            if (!tabsResults) {
+                if (calculateParentStatus &&
+                    (fetchStatus === 'done' || fetchStatus === 'error') &&
+                    stripData.widgets) {
+                    this.checkParentStatus(fetchStatus, stripData.widgets.length);
+                }
+                if (calculateParentStatus && !(results && results.length > 0)) {
+                    this.contentAvailable = false;
+                }
+                else if (results && results.length > 0) {
+                    this.contentAvailable = true;
+                }
+            }
+            else {
+                this.contentAvailable = true;
+            }
+        });
+    }
+    checkParentStatus(fetchStatus, stripWidgetsCount) {
+        if (fetchStatus === 'done' && !stripWidgetsCount) {
+            this.noDataCount += 1;
+        }
+        else if (fetchStatus === 'done' && stripWidgetsCount) {
+            this.successDataCount += 1;
+        }
+        else if (fetchStatus === 'error') {
+            this.errorDataCount += 1;
+        }
+        const settledCount = this.noDataCount + this.successDataCount + this.errorDataCount;
+        const totalCount = this.widgetData.strips.length;
+        if (this.successDataCount > 0 && settledCount < totalCount) {
+            return;
+        }
+        this.showParentLoader = settledCount !== totalCount;
+        this.showParentNoData =
+            this.noDataCount > 0 && this.noDataCount + this.errorDataCount === totalCount;
+        this.showParentError = this.errorDataCount === totalCount;
+    }
+    checkForEmptyWidget(strip) {
+        if (strip.request &&
+            ((strip.request.api && Object.keys(strip.request.api).length) ||
+                (strip.request.search && Object.keys(strip.request.search).length) ||
+                (strip.request.searchRegionRecommendation &&
+                    Object.keys(strip.request.searchRegionRecommendation).length) ||
+                (strip.request.searchV6 && Object.keys(strip.request.searchV6).length) ||
+                (strip.request.enrollmentList && Object.keys(strip.request.enrollmentList).length) ||
+                (strip.request.cbpList && Object.keys(strip.request.cbpList).length) ||
+                (strip.request.trendingSearch && Object.keys(strip.request.trendingSearch).length) ||
+                (strip.request.topContent && Object.keys(strip.request.topContent).length) ||
+                (strip.request.featureContent && Object.keys(strip.request.featureContent).length) ||
+                (strip.request.bookmarkRead && Object.keys(strip.request.bookmarkRead).length) ||
+                (strip.request.playlistSearch && Object.keys(strip.request.playlistSearch).length) ||
+                (strip.request.playlistRead && Object.keys(strip.request.playlistRead).length) ||
+                (strip.request.ciosContent && Object.keys(strip.request.ciosContent).length))) {
+            return true;
+        }
+        return false;
+    }
+    tabClicked(tabEvent, stripMap, stripKey) {
+        if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {
+            stripMap.tabs[tabEvent.index].fetchTabStatus = 'inprogress';
+            stripMap.tabs[tabEvent.index].tabLoading = true;
+            stripMap.showOnLoader = true;
+        }
+        const data = {
+            label: `${tabEvent.tab.textLabel}`,
+            index: tabEvent.index,
+        };
+        this.eventSvc.raiseInteractTelemetry({
+            type: WsEvents.EnumInteractTypes.CLICK,
+            subType: WsEvents.EnumInteractSubTypes.HOME_PAGE_STRIP_TABS,
+            id: `${_.camelCase(data.label)}-tab`,
+        }, {}, {
+            module: WsEvents.EnumTelemetrymodules.HOME,
+        });
+        const currentTabFromMap = stripMap.tabs && stripMap.tabs[tabEvent.index];
+        const currentStrip = this.widgetData.strips.find(s => s.key === stripKey);
+        if (this.stripsResultDataMap[stripKey] && currentTabFromMap) {
+            this.stripsResultDataMap[stripKey].viewMoreUrl.queryParams = Object.assign(Object.assign({}, this.stripsResultDataMap[stripKey].viewMoreUrl.queryParams), { tabSelected: currentTabFromMap.label });
+        }
+        if (currentStrip && currentTabFromMap && !currentTabFromMap.computeDataOnClick) {
+            if (currentTabFromMap.requestRequired && currentTabFromMap.request) {
+                // call API to get tab data and process
+                // this.processStrip(currentStrip, [], 'fetching', true, null)
+                if (currentTabFromMap.request.searchV6) {
+                    this.getTabDataByNewReqSearchV6(currentStrip, tabEvent.index, currentTabFromMap, true);
+                }
+                else if (currentTabFromMap.request.trendingSearch) {
+                    this.getTabDataByNewReqTrending(currentStrip, tabEvent.index, currentTabFromMap, true);
+                }
+                else if (currentTabFromMap.request.topContent) {
+                    this.getTabDataByNewReqTopContent(currentStrip, tabEvent.index, currentTabFromMap, true);
+                }
+                else if (currentTabFromMap.request.playlistRead) {
+                    this.getTabDataByNewReqPlaylistReadContent(currentStrip, tabEvent.index, currentTabFromMap, true);
+                }
+                else if (currentTabFromMap.request.ciosContent) {
+                    this.getTabDataByCiosSearch(currentStrip, tabEvent.index, currentTabFromMap, true);
+                }
+                if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {
+                    stripMap.tabs[tabEvent.index].tabLoading = false;
+                }
+            }
+            else {
+                this.getTabDataByfilter(currentStrip, currentTabFromMap, true);
+                setTimeout(() => {
+                    if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {
+                        stripMap.tabs[tabEvent.index].tabLoading = false;
+                        stripMap.tabs[tabEvent.index].fetchTabStatus = 'done';
+                        stripMap.showOnLoader = false;
+                    }
+                }, 200);
+            }
+        }
+    }
+    getTabDataByNewReqSearchV6(strip, tabIndex, currentTab, calculateParentStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.searchV6Request(strip, currentTab.request, calculateParentStatus);
+                if (response && response.results) {
+                    const widgets = this.transformContentsToWidgets(response.results.result.content, strip);
+                    let tabResults = [];
+                    if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                        const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                        if (allTabs && allTabs.length && allTabs[tabIndex]) {
+                            allTabs[tabIndex] = Object.assign(Object.assign({}, allTabs[tabIndex]), { widgets, fetchTabStatus: 'done' });
+                            tabResults = allTabs;
+                        }
+                    }
+                    this.processStrip(strip, widgets, 'done', calculateParentStatus, response.viewMoreUrl, tabResults // tabResults as widgets
+                    );
+                }
+                else {
+                    this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                }
+            }
+            catch (error) {
+                // Handle errors
+                // console.error('Error:', error);
+            }
+        });
+    }
+    getTabDataByNewReqTrending(strip, tabIndex, currentTab, calculateParentStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.trendingSearchRequest(strip, currentTab.request, calculateParentStatus);
+                if (response && response.results && response.results.response) {
+                    const content = response.results.response[currentTab.value] || [];
+                    const widgets = this.transformContentsToWidgets(content, strip);
+                    // console.log('currentTab --- widgets', widgets)
+                    let tabResults = [];
+                    if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                        const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                        if (allTabs && allTabs.length && allTabs[tabIndex]) {
+                            allTabs[tabIndex] = Object.assign(Object.assign({}, allTabs[tabIndex]), { widgets, fetchTabStatus: 'done' });
+                            tabResults = allTabs;
+                        }
+                    }
+                    // console.log('tabResults -++++***--', tabResults)
+                    // console.log('calling  after-- ')
+                    this.processStrip(strip, widgets, 'done', calculateParentStatus, response.viewMoreUrl, tabResults // tabResults as widgets
+                    );
+                }
+                else {
+                    this.processStrip(strip, [], 'done', calculateParentStatus, null);
+                }
+            }
+            catch (error) {
+                // Handle errors
+                this.processStrip(strip, [], 'error', calculateParentStatus, null);
+            }
+        });
+    }
+    getTabDataByfilter(strip, currentTab, calculateParentStatus) {
+        // tslint:disable:no-console
+        console.log('strip -- ', strip);
+        // tslint:disable:no-console
+        console.log('currentTab -- ', currentTab);
+        // tslint:disable:no-console
+        console.log('calculateParentStatus-- ', calculateParentStatus);
+        // TODO: Write logic for individual filter if passed in config
+        // add switch case based on config key passed
+    }
+    fetchAllCbpPlans(strip, calculateParentStatus = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (strip.request && strip.request.cbpList && Object.keys(strip.request.cbpList).length) {
+                let courses;
+                let tabResults = [];
+                const response = yield this.userSvc.fetchCbpPlanList().toPromise();
+                if (response) {
+                    courses = response;
+                    if (strip.tabs && strip.tabs.length) {
+                        tabResults = this.splitCbpTabsData(courses, strip);
+                        yield this.processStrip(strip, this.transformContentsToWidgets(courses, strip), 'done', calculateParentStatus, '', tabResults);
+                    }
+                    else {
+                        this.processStrip(strip, this.transformContentsToWidgets(courses, strip), 'done', calculateParentStatus, 'viewMoreUrl');
+                    }
+                }
+                // this.userSvc.fetchCbpPlanList().subscribe( async  (res: any) => {
+                //   if (res) {
+                //     console.log(res,'===============================>')
+                //     courses = res
+                //     if (strip.tabs && strip.tabs.length) {
+                //       tabResults = this.splitCbpTabsData(courses, strip)
+                //       await this.processStrip(
+                //         strip,
+                //         this.transformContentsToWidgets(courses, strip),
+                //         'done',
+                //         calculateParentStatus,
+                //         '',
+                //         tabResults
+                //       )
+                //     } else {
+                //       this.processStrip(
+                //         strip,
+                //         this.transformContentsToWidgets(courses, strip),
+                //         'done',
+                //         calculateParentStatus,
+                //         'viewMoreUrl',
+                //       )
+                //     }
+                //   }
+                // },                                        (_err: any) => {
+                // })
+                clearInterval(this.enrollInterval);
+            }
+        });
+    }
+    splitCbpTabsData(contentNew, strip) {
+        const tabResults = [];
+        const splitData = this.getTabsList(contentNew, strip);
+        if (strip.tabs && strip.tabs.length) {
+            for (let i = 0; i < strip.tabs.length; i += 1) {
+                if (strip.tabs[i]) {
+                    tabResults.push(Object.assign(Object.assign(Object.assign({}, strip.tabs[i]), { fetchTabStatus: 'done' }), (splitData.find(itmInner => {
+                        if (strip.tabs && strip.tabs[i] && itmInner.value === strip.tabs[i].value) {
+                            return itmInner;
+                        }
+                        return undefined;
+                    }))));
+                }
+            }
+        }
+        return tabResults;
+    }
+    getTabsList(array, strip) {
+        let all = [];
+        let upcoming = [];
+        let overdue = [];
+        array.forEach((e) => {
+            all.push(e);
+            if (e.planDuration === NsCardContent.ACBPConst.OVERDUE) {
+                overdue.push(e);
+            }
+            else if (e.planDuration === NsCardContent.ACBPConst.UPCOMING) {
+                upcoming.push(e);
+            }
+        });
+        const allCompleted = all.filter((allData) => allData.contentStatus === 2);
+        let allInCompleted = all.filter((allData) => allData.contentStatus < 2);
+        let allCompletedOverDue = allCompleted.filter((allData) => allData.planDuration === NsCardContent.ACBPConst.OVERDUE);
+        const allCompletedAll = allCompleted.filter((allData) => allData.planDuration !== NsCardContent.ACBPConst.OVERDUE);
+        allCompletedOverDue = allCompletedOverDue.sort((a, b) => {
+            if (a.planDuration === NsCardContent.ACBPConst.OVERDUE && b.planDuration === NsCardContent.ACBPConst.OVERDUE) {
+                const firstDate = new Date(a.endDate);
+                const secondDate = new Date(b.endDate);
+                return firstDate > secondDate ? -1 : 1;
+            }
+        });
+        allInCompleted = allInCompleted.sort((a, b) => {
+            if (a.planDuration === NsCardContent.ACBPConst.OVERDUE && b.planDuration === NsCardContent.ACBPConst.OVERDUE) {
+                const firstDate = new Date(a.endDate);
+                const secondDate = new Date(b.endDate);
+                return firstDate > secondDate ? -1 : 1;
+            }
+        });
+        all = [...allInCompleted, ...allCompletedAll, ...allCompletedOverDue];
+        overdue = overdue.filter((data) => {
+            return data.contentStatus < 2;
+        });
+        overdue = overdue.sort((a, b) => {
+            const firstDate = new Date(a.endDate);
+            const secondDate = new Date(b.endDate);
+            return firstDate > secondDate ? -1 : 1;
+        });
+        upcoming = upcoming.filter((data) => {
+            return data.contentStatus < 2;
+        });
+        // this.getSelectedIndex(1)
+        return [
+            { value: 'all', widgets: this.transformContentsToWidgets(all, strip) },
+            { value: 'upcoming', widgets: this.transformContentsToWidgets(upcoming, strip) },
+            { value: 'overdue', widgets: this.transformContentsToWidgets(overdue, strip) }
+        ];
+    }
+    getSelectedIndex(stripsResultDataMap, key) {
+        let returnValue = 0;
+        if (key === 'cbpPlan') {
+            if (stripsResultDataMap.tabs.length) {
+                const data = stripsResultDataMap.tabs.filter((ele) => ele.value === 'upcoming');
+                returnValue = data[0].widgets && data[0].widgets.length > 0 ? 1 : 0;
+            }
+        }
+        return returnValue;
+    }
+    translateLabels(label, type) {
+        return this.langtranslations.translateLabel(label, type, '');
+    }
+    identify(index, item) {
+        if (index >= 0) { }
+        return item;
+    }
+    tracker(index, item) {
+        if (index >= 0) { }
+        return _.get(item, 'widgetData.content.identifier');
+    }
+    fetchAllTopContent(strip, calculateParentStatus = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (strip.request && strip.request.topContent && Object.keys(strip.request.topContent).length) {
+                let originalFilters = [];
+                if (strip.request &&
+                    strip.request.topContent &&
+                    strip.request.topContent.request &&
+                    strip.request.topContent.request.filters) {
+                    originalFilters = strip.request.topContent.request.filters;
+                    strip.request.topContent.request.filters = this.postMethodFilters(strip.request.topContent.request.filters);
+                }
+                if (strip.tabs && strip.tabs.length) {
+                    // TODO: Have to extract requestRequired to outer level of tabs config
+                    const firstTab = strip.tabs[0];
+                    if (firstTab.requestRequired) {
+                        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                            const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]);
+                            this.getTabDataByNewReqTopContent(strip, 0, currentTabFromMap, calculateParentStatus);
+                        }
+                    }
+                }
+                else {
+                    try {
+                        const response = yield this.postRequestMethod(strip, strip.request.topContent, strip.request.apiUrl, calculateParentStatus);
+                        // console.log('calling  after - response, ', response)
+                        if (response && response.results) {
+                            // console.log('calling  after-- ')
+                            if (response.results.result.content && response.results.result.content.length) {
+                                this.processStrip(strip, this.transformContentsToWidgets(response.results.result.content, strip), 'done', calculateParentStatus, response.viewMoreUrl);
+                            }
+                            else {
+                                this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                                this.emptyResponse.emit(true);
+                            }
+                        }
+                        else {
+                            this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                            this.emptyResponse.emit(true);
+                        }
+                    }
+                    catch (error) {
+                        // Handle errors
+                        // console.error('Error:', error);
+                    }
+                }
+            }
+        });
+    }
+    fetchAllFeaturedContent(strip, calculateParentStatus = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (strip.request && strip.request.featureContent && Object.keys(strip.request.featureContent).length) {
+                let originalFilters = [];
+                if (strip.request &&
+                    strip.request.featureContent &&
+                    strip.request.featureContent.request &&
+                    strip.request.featureContent.request.filters) {
+                    originalFilters = strip.request.featureContent.request.filters;
+                    strip.request.featureContent.request.filters = this.postMethodFilters(strip.request.featureContent.request.filters);
+                }
+                try {
+                    const response = yield this.postRequestMethod(strip, strip.request.featureContent, strip.request.apiUrl, calculateParentStatus);
+                    // console.log('calling  after - response, ', response)
+                    if (response && response.results) {
+                        // console.log('calling  after-- ')
+                        if (response.results.result.content && response.results.result.content.length) {
+                            this.processStrip(strip, this.transformContentsToWidgets(response.results.result.content, strip), 'done', calculateParentStatus, response.viewMoreUrl);
+                        }
+                        else {
+                            this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                            this.emptyResponse.emit(true);
+                        }
+                    }
+                    else {
+                        this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                        this.emptyResponse.emit(true);
+                    }
+                }
+                catch (error) {
+                    this.emptyResponse.emit(true);
+                    // Handle errors
+                    // console.error('Error:', error);
+                }
+            }
+        });
+    }
+    getTabDataByNewReqTopContent(strip, tabIndex, currentTab, calculateParentStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (currentTab.request &&
+                currentTab.request.topContent &&
+                currentTab.request.topContent.request &&
+                currentTab.request.topContent.request.filters) {
+                currentTab.request.topContent.request.filters = this.postMethodFilters(currentTab.request.topContent.request.filters);
+            }
+            try {
+                // const response = await this.searchV6Request(strip, currentTab.request, calculateParentStatus);
+                const response = yield this.postRequestMethod(strip, currentTab.request.topContent, currentTab.request.apiUrl, calculateParentStatus);
+                if (response.results && response.results.result) {
+                    const widgets = this.transformContentsToWidgets(response.results.result.content, strip);
+                    let tabResults = [];
+                    if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                        const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                        if (allTabs && allTabs.length && allTabs[tabIndex]) {
+                            allTabs[tabIndex] = Object.assign(Object.assign({}, allTabs[tabIndex]), { widgets, fetchTabStatus: 'done' });
+                            tabResults = allTabs;
+                        }
+                    }
+                    this.processStrip(strip, widgets, 'done', calculateParentStatus, response.viewMoreUrl, tabResults // tabResults as widgets
+                    );
+                }
+                else {
+                    this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                }
+            }
+            catch (error) {
+                // Handle errors
+                // console.error('Error:', error);
+            }
+        });
+    }
+    raiseTelemetry(stripData) {
+        this.telemtryResponse.emit(stripData);
+    }
+    postRequestMethod(strip, request, apiUrl, calculateParentStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                if (request && request) {
+                    this.contentSvc.postApiMethod(apiUrl, request).subscribe(results => {
+                        if (results.result && results.result.content) {
+                            const showViewMore = Boolean(results.result.content && results.result.content.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch);
+                            const viewMoreUrl = showViewMore
+                                ? {
+                                    path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',
+                                    queryParams: {
+                                        tab: 'Learn',
+                                        q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,
+                                        f: {},
+                                    },
+                                }
+                                : null;
+                            resolve({ results, viewMoreUrl });
+                        }
+                        else if (results && results.data) {
+                            const showViewMore = Boolean(results.data && results.data.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch);
+                            const viewMoreUrl = showViewMore ? {
+                                path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',
+                                queryParams: {
+                                    tab: 'Learn',
+                                    q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,
+                                    f: {},
+                                },
+                            }
+                                : null;
+                            resolve({ results, viewMoreUrl });
+                        }
+                        else if (results.result && results.result.data) {
+                            const showViewMore = Boolean(results.data && results.result.data && results.result.data.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch);
+                            const viewMoreUrl = showViewMore ? {
+                                path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',
+                                queryParams: {
+                                    tab: 'Learn',
+                                    q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,
+                                    f: {},
+                                },
+                            }
+                                : null;
+                            resolve({ results, viewMoreUrl });
+                        }
+                    }, (error) => {
+                        this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                        reject(error);
+                    });
+                }
+            });
+        });
+    }
+    getRequestMethod(strip, request, apiUrl, calculateParentStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const originalFilters = [];
+            return new Promise((resolve, reject) => {
+                if (request && request) {
+                    this.contentSvc.getApiMethod(apiUrl).subscribe(results => {
+                        let showViewMore;
+                        if (results.result.data) {
+                            showViewMore = Boolean(results.result.data && results.result.data.orgList.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch);
+                        }
+                        else if (results.result.content) {
+                            let featuredProvider = JSON.parse(results.result.content.featuredProviders || '[]');
+                            showViewMore = Boolean(featuredProvider && featuredProvider.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch);
+                        }
+                        const viewMoreUrl = showViewMore
+                            ? {
+                                path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',
+                            }
+                            : null;
+                        resolve({ results, viewMoreUrl });
+                    }, (error) => {
+                        this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                        reject(error);
+                    });
+                }
+            });
+        });
+    }
+    postMethodFilters(filters) {
+        if (filters.organisation &&
+            filters.organisation.indexOf('<orgID>') >= 0) {
+            filters.organisation = filters.organisation.replace('<orgID>', this.providerId);
+        }
+        return filters;
+    }
+    getFullUrl(apiUrl, id) {
+        let formedUrl = apiUrl;
+        if (apiUrl.indexOf('<bookmarkId>') >= 0) {
+            formedUrl = apiUrl.replace('<bookmarkId>', this.environment.mdoChannelsBookmarkId);
+        }
+        else if (apiUrl.indexOf('<playlistKey>') >= 0 && apiUrl.indexOf('<orgID>') >= 0) {
+            formedUrl = apiUrl.replace('<playlistKey>', this.providerId + id);
+            formedUrl = formedUrl.replace('<orgID>', this.providerId);
+        }
+        else if (apiUrl.indexOf('<doId>') >= 0) {
+            formedUrl = apiUrl.replace('<doId>', this.environment.providerDataKey);
+        }
+        return formedUrl;
+    }
+    redirectViewAll(stripData, path, queryParamsData) {
+        if (this.emitViewAll) {
+            this.viewAllResponse.emit(stripData);
+        }
+        else {
+            this.router.navigate([path], { queryParams: queryParamsData });
+        }
+    }
+    fetchAllBookMarkData(strip, calculateParentStatus = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (strip.request && strip.request.bookmarkRead && Object.keys(strip.request.bookmarkRead).length) {
+                let originalFilters = [];
+                if (strip.request &&
+                    strip.request.bookmarkRead &&
+                    strip.request.bookmarkRead.bookmarkId) {
+                    strip.request.apiUrl = this.getFullUrl(strip.request.apiUrl, strip.request.bookmarkRead.bookmarkId);
+                }
+                try {
+                    const response = yield this.getRequestMethod(strip, strip.request.bookmarkRead, strip.request.apiUrl, calculateParentStatus);
+                    let content = response.results.result.data.orgList;
+                    if (response) {
+                        this.processStrip(strip, this.transformAllContentsToWidgets(content, strip), 'done', calculateParentStatus, response);
+                    }
+                    else {
+                        this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                        this.emptyResponse.emit(true);
+                    }
+                }
+                catch (error) {
+                    this.emptyResponse.emit(true);
+                    // Handle errors
+                    // console.error('Error:', error);
+                }
+            }
+        });
+    }
+    transformAllContentsToWidgets(contents, strip) {
+        return (contents || []).map((content, idx) => (content ? {
+            widgetType: 'cardLib',
+            widgetSubType: 'cardContentLib',
+            widgetHostClass: 'mb-2',
+            widgetData: Object.assign(Object.assign({ content }, (content.batch && { batch: content.batch })), { cardSubType: strip.stripConfig && strip.stripConfig.cardSubType, cardCustomeClass: strip.customeClass ? strip.customeClass : '', context: { pageSection: strip.key, position: idx }, intranetMode: strip.stripConfig && strip.stripConfig.intranetMode, deletedMode: strip.stripConfig && strip.stripConfig.deletedMode, contentTags: strip.stripConfig && strip.stripConfig.contentTags }),
+        } : {
+            widgetType: 'card',
+            widgetSubType: 'cardContent',
+            widgetHostClass: 'mb-2',
+            widgetData: {},
+        }));
+    }
+    transformAllTabContentsToWidgets(contents, currentTab) {
+        return (contents || []).map((content, idx) => (content ? {
+            widgetType: 'cardLib',
+            widgetSubType: 'cardContentLib',
+            widgetHostClass: 'mb-2',
+            widgetData: Object.assign(Object.assign({ content }, (content.batch && { batch: content.batch })), { cardSubType: currentTab.stripConfig && currentTab.stripConfig.cardSubType, cardCustomeClass: currentTab.customeClass ? currentTab.customeClass : '', context: { pageSection: currentTab.value, position: idx }, intranetMode: currentTab.stripConfig && currentTab.stripConfig.intranetMode, deletedMode: currentTab.stripConfig && currentTab.stripConfig.deletedMode, contentTags: currentTab.stripConfig && currentTab.stripConfig.contentTags }),
+        } : {
+            widgetType: 'card',
+            widgetSubType: 'cardContent',
+            widgetHostClass: 'mb-2',
+            widgetData: {},
+        }));
+    }
+    fetchAllPlaylistSearch(strip, calculateParentStatus = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (strip.request && strip.request.playlistSearch && Object.keys(strip.request.playlistSearch).length) {
+                let originalFilters = [];
+                if (strip.request &&
+                    strip.request.playlistSearch &&
+                    strip.request.playlistSearch.request &&
+                    strip.request.playlistSearch.request.filters) {
+                    originalFilters = strip.request.playlistSearch.request.filters;
+                    strip.request.playlistSearch.request.filters = this.postMethodFilters(strip.request.playlistSearch.request.filters);
+                }
+                try {
+                    const response = yield this.postRequestMethod(strip, strip.request.playlistSearch.request, strip.request.apiUrl, calculateParentStatus);
+                    // console.log('calling  after - response, ', response)
+                    if (response && response.results) {
+                        // console.log('calling  after-- ')
+                        if (response.results.result.data && response.results.result.data.length) {
+                            let finalPlaylistData = [];
+                            let programData = response.results.result.data;
+                            programData.forEach((prgData) => {
+                                if (prgData.children && prgData.children.length) {
+                                    finalPlaylistData.push(prgData);
+                                }
+                            });
+                            if (finalPlaylistData.length) {
+                                this.processStrip(strip, this.transformContentsToWidgets(finalPlaylistData, strip), 'done', calculateParentStatus, response.viewMoreUrl);
+                            }
+                            else {
+                                this.emptyResponse.emit(true);
+                            }
+                        }
+                        else {
+                            this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                            this.emptyResponse.emit(true);
+                        }
+                    }
+                    else {
+                        this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                        this.emptyResponse.emit(true);
+                    }
+                }
+                catch (error) {
+                    this.emptyResponse.emit(true);
+                    // Handle errors
+                    // console.error('Error:', error);
+                }
+            }
+        });
+    }
+    fetchPlaylistReadData(strip, calculateParentStatus = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (strip.request && strip.request.playlistRead && Object.keys(strip.request.playlistRead).length) {
+                let originalFilters = [];
+                if (strip.request &&
+                    strip.request.playlistRead &&
+                    strip.request.playlistRead.type) {
+                    strip.request.apiUrl = this.getFullUrl(strip.request.apiUrl, strip.request.playlistRead.type);
+                }
+                if (strip.tabs && strip.tabs.length) {
+                    // TODO: Have to extract requestRequired to outer level of tabs config
+                    const firstTab = strip.tabs[0];
+                    if (firstTab.requestRequired) {
+                        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                            const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]);
+                            this.getTabDataByNewReqPlaylistReadContent(strip, 0, currentTabFromMap, calculateParentStatus);
+                        }
+                    }
+                }
+                else {
+                    try {
+                        const response = yield this.getRequestMethod(strip, strip.request.playlistRead, strip.request.apiUrl, calculateParentStatus);
+                        if (response && response.results.result.content) {
+                            let content = response.results.result.content;
+                            if (strip.key === 'providers') {
+                                let featuredProviders = JSON.parse(content.featuredProviders || '[]');
+                                this.processStrip(strip, this.transformAllContentsToWidgets(featuredProviders, strip), 'done', calculateParentStatus, response);
+                            }
+                            else {
+                                this.processStrip(strip, this.transformAllContentsToWidgets(content, strip), 'done', calculateParentStatus, response);
+                            }
+                        }
+                        else {
+                            this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                            this.emptyResponse.emit(true);
+                        }
+                    }
+                    catch (error) {
+                        this.emptyResponse.emit(true);
+                        // Handle errors
+                        // console.error('Error:', error);
+                    }
+                }
+            }
+        });
+    }
+    getTabDataByNewReqPlaylistReadContent(strip, tabIndex, currentTab, calculateParentStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (currentTab.request &&
+                currentTab.request.playlistRead &&
+                currentTab.request.playlistRead.type) {
+                currentTab.request.apiUrl = this.getFullUrl(currentTab.request.apiUrl, currentTab.request.playlistRead.type);
+            }
+            try {
+                const response = yield this.getRequestMethod(strip, currentTab.request.playlistRead, currentTab.request.apiUrl, calculateParentStatus);
+                // if (response && response.results.result.content) {  
+                //   let content  = response.results.result.content
+                //   if(strip.key === 'providers'){
+                //     let featuredProviders : any = JSON.parse(content.featuredProviders|| '[]')
+                //     this.processStrip(
+                //       strip,
+                //       this.transformAllContentsToWidgets(featuredProviders, strip),
+                //       'done',
+                //       calculateParentStatus,
+                //       response,
+                //     );
+                //   } else {
+                //     this.processStrip(
+                //       strip,
+                //       this.transformAllContentsToWidgets(content, strip),
+                //       'done',
+                //       calculateParentStatus,
+                //       response,
+                //     );
+                //   }
+                // } else {
+                //   this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                //   this.emptyResponse.emit(true)
+                // }
+                if (response.results && response.results.result) {
+                    let content = response.results.result.content;
+                    let widgets = [];
+                    if (currentTab.value === 'providers') {
+                        let featuredProviders = JSON.parse(content.featuredProviders || '[]');
+                        widgets = this.transformAllTabContentsToWidgets(featuredProviders, currentTab);
+                    }
+                    else {
+                        widgets = this.transformAllTabContentsToWidgets(content, currentTab);
+                    }
+                    let tabResults = [];
+                    if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                        const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                        if (allTabs && allTabs.length && allTabs[tabIndex]) {
+                            allTabs[tabIndex] = Object.assign(Object.assign({}, allTabs[tabIndex]), { widgets, fetchTabStatus: 'done' });
+                            tabResults = allTabs;
+                        }
+                    }
+                    this.processStrip(strip, widgets, 'done', calculateParentStatus, response.viewMoreUrl, tabResults // tabResults as widgets
+                    );
+                }
+                else {
+                    let tabResults = [];
+                    if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                        const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                        if (allTabs && allTabs.length && allTabs[tabIndex]) {
+                            allTabs[tabIndex] = Object.assign(Object.assign({}, allTabs[tabIndex]), { fetchTabStatus: 'done' });
+                            tabResults = allTabs;
+                        }
+                    }
+                    this.processStrip(strip, [], 'error', calculateParentStatus, null, tabResults);
+                }
+            }
+            catch (error) {
+                console.error('Error:', error);
+                let tabResults = [];
+                if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs && this.stripsResultDataMap[strip.key].tabs.length) {
+                    const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                    if (allTabs && allTabs.length && allTabs[tabIndex]) {
+                        allTabs[tabIndex] = Object.assign(Object.assign({}, allTabs[tabIndex]), { fetchTabStatus: 'done' });
+                        tabResults = allTabs;
+                    }
+                    this.processStrip(strip, [], 'error', calculateParentStatus, null, tabResults);
+                }
+                else {
+                    this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                }
+            }
+        });
+    }
+    fetchCiosContentData(strip, calculateParentStatus = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (strip && strip.request.ciosContent && Object.keys(strip.request.ciosContent).length) {
+                if (strip.tabs && strip.tabs.length) {
+                    // TODO: Have to extract requestRequired to outer level of tabs config
+                    const firstTab = strip.tabs[0];
+                    if (firstTab.requestRequired && firstTab.value === 'extCourse') {
+                        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                            const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]);
+                            this.getTabDataByCiosSearch(strip, 0, currentTabFromMap, calculateParentStatus);
+                        }
+                    }
+                    if (firstTab.requestRequired && firstTab.value === 'providers') {
+                        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                            const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]);
+                            this.getTabDataByNewReqPlaylistReadContent(strip, 0, currentTabFromMap, calculateParentStatus);
+                        }
+                    }
+                }
+                else {
+                    try {
+                        const response = yield this.postRequestMethod(strip, strip.request.ciosContent, strip.request.apiUrl, calculateParentStatus);
+                        // console.log('calling  after - response, ', response)
+                        if (response && response.results) {
+                            // console.log('calling  after-- ')
+                            if (response.results.data && response.results.data.length) {
+                                let extContentData = response.results.data;
+                                if (extContentData.length) {
+                                    this.processStrip(strip, this.transformContentsToWidgets(extContentData, strip), 'done', calculateParentStatus, response.viewMoreUrl);
+                                }
+                                else {
+                                    this.emptyResponse.emit(true);
+                                }
+                            }
+                            else {
+                                this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                                this.emptyResponse.emit(true);
+                            }
+                        }
+                        else {
+                            this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                            this.emptyResponse.emit(true);
+                        }
+                    }
+                    catch (error) {
+                        this.emptyResponse.emit(true);
+                        // Handle errors
+                        // console.error('Error:', error);
+                    }
+                }
+            }
+        });
+    }
+    getTabDataByCiosSearch(strip, tabIndex, _currentTab, calculateParentStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.contentSvc.postApiMethod(strip.request.apiUrl, strip.request.ciosContent).toPromise();
+                ;
+                if (response && response.data && response.data.length) {
+                    const widgets = this.transformContentsToWidgets(response.data, strip);
+                    let tabResults = [];
+                    if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                        const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                        if (allTabs && allTabs.length && allTabs[tabIndex]) {
+                            allTabs[tabIndex] = Object.assign(Object.assign({}, allTabs[tabIndex]), { widgets, fetchTabStatus: 'done' });
+                            tabResults = allTabs;
+                        }
+                    }
+                    this.processStrip(strip, widgets, 'done', calculateParentStatus, response.viewMoreUrl, tabResults // tabResults as widgets
+                    );
+                }
+                else {
+                    let tabResults = [];
+                    if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                        const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                        if (allTabs && allTabs.length && allTabs[tabIndex]) {
+                            allTabs[tabIndex] = Object.assign(Object.assign({}, allTabs[tabIndex]), { fetchTabStatus: 'done' });
+                            tabResults = allTabs;
+                        }
+                    }
+                    this.processStrip(strip, [], 'error', calculateParentStatus, null, tabResults);
+                }
+            }
+            catch (error) {
+                console.error('Error:', error);
+                let tabResults = [];
+                if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs && this.stripsResultDataMap[strip.key].tabs.length) {
+                    const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                    if (allTabs && allTabs.length && allTabs[tabIndex]) {
+                        allTabs[tabIndex] = Object.assign(Object.assign({}, allTabs[tabIndex]), { fetchTabStatus: 'done' });
+                        tabResults = allTabs;
+                    }
+                    this.processStrip(strip, [], 'error', calculateParentStatus, null, tabResults);
+                }
+                else {
+                    this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                }
+            }
+        });
+    }
+}
+ContentStripWithTabsLibComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ContentStripWithTabsLibComponent, deps: [{ token: 'environment' }, { token: i1.WidgetContentService }, { token: i2.LoggerService }, { token: i2.EventService }, { token: i2.ConfigurationsService }, { token: i2.UtilityService }, { token: i3.Router }, { token: i4.WidgetUserService }, { token: i5.TranslateService }, { token: i6.MultilingualTranslationsService }], target: i0.ɵɵFactoryTarget.Component });
+ContentStripWithTabsLibComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ContentStripWithTabsLibComponent, selector: "sb-uic-content-strip-with-tabs", inputs: { widgetData: "widgetData", providerId: "providerId", emitViewAll: "emitViewAll", channnelName: "channnelName" }, outputs: { emptyResponse: "emptyResponse", viewAllResponse: "viewAllResponse", telemtryResponse: "telemtryResponse" }, host: { properties: { "id": "this.id" } }, usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"!contentAvailable; else otherTemplate\"></ng-container>\n<ng-template #otherTemplate>\n  <!-- <div *ngIf=\"showParentLoader\" class=\"text-center my-2\">\n    <mat-spinner class=\"inline-block\"></mat-spinner>\n  </div> -->\n  <ng-container *ngIf=\"showParentError\" [sbUiResolverWidget]=\"widgetData.errorWidget\"></ng-container>\n  <ng-container *ngIf=\"showParentNoData\" [sbUiResolverWidget]=\"widgetData.noDataWidget\"></ng-container>\n  <ng-container *ngFor=\"let key of stripsKeyOrder; let i = index; trackBy: identify\">\n    <ng-container *ngIf=\"isStripShowing(stripsResultDataMap[key])\">\n      <a name=\"{{stripsResultDataMap[key]?.stripTitle}}\" [class]=\"key\">\n        <div *ngIf=\"stripsResultDataMap && (getLength(stripsResultDataMap[key]) ||\n                    stripsResultDataMap[key]?.showOnNoData ||\n                    stripsResultDataMap[key]?.showOnLoader ||\n                    stripsResultDataMap[key]?.showOnError)\n                  \" [ngClass]=\"\n                    !widgetData?.isChannelStrip ? 'xs:px-8 sx:px-10ss' : i > 0 ? 'mt-12' : ''\n                  \" [id]=\"key\" [ngClass]=\"!widgetData?.isChannelStrip ? 'margin-bottom-custom' : 'margin-bottom-xs'\">\n          <div [ngClass]=\"{ pad: stripsResultDataMap[key]?.stripBackground }\"\n            [ngStyle]=\"{ 'background-color': stripsResultDataMap[key]?.stripBackground }\">\n            <div class=\"flex flex-col pl-4 pr-4 md:pr-0 md:pl-0 min-height-40 \" [ngClass]=\"\n                        !widgetData?.isChannelStrip\n                          ? ''\n                          : stripsResultDataMap[key]?.stripTitle\n                          ? 'mb-8'\n                          : ''\n                      \">\n              <div class=\"flex flex-1 items-center\">\n                <p class=\"mat-subheading-1 margin-remove inline-block \" *ngIf=\"stripsResultDataMap[key]?.stripTitle\">\n                  <span class=\"capitalize\" *ngIf=\"stripsResultDataMap[key]?.disableTranslate\">\n                    {{stripsResultDataMap[key]?.stripTitle}}\n                  </span>\n                  <span *ngIf=\"!stripsResultDataMap[key]?.disableTranslate\">\n                    {{ translateLabels(stripsResultDataMap[key]?.stripTitle, 'home') }}\n                  </span>\n                </p>\n\n                <button *ngIf=\"stripsResultDataMap[key]?.stripInfo?.icon\" type=\"button\" mat-icon-button\n                  (click)=\"toggleInfo(stripsResultDataMap[key])\" i18n-matTooltip matTooltip=\"info\"\n                  class=\"margin-left-xs\">\n                  <mat-icon>{{ stripsResultDataMap[key]?.stripInfo?.icon.icon }}</mat-icon>\n                </button>\n                <a *ngIf=\"stripsResultDataMap[key]?.stripTitleLink?.link\"\n                  [routerLink]=\"stripsResultDataMap[key]?.stripTitleLink?.link\"\n                  [queryParams]=\"stripsResultDataMap[key]?.stripTitleLink?.link?.queryParams\">\n                  <mat-icon class=\"ws-mat-primary-primary-text ws-mat-default-text\" [color]=\"'accent'\">{{\n                    stripsResultDataMap[key]?.stripTitleLink?.icon }}</mat-icon>\n                </a>\n                <span class=\"spacer\"></span>\n                <!-- viewAll start-->\n                <div *ngIf=\"checkCondition(widgetData , stripsResultDataMap[key])\"\n                  class=\"ml-4 pl-2 view-more ws-mat-default-text\">\n                  <a class=\"flex ws-mat-default-text items-center justify-center mat-body-1 cursor-pointer\" \n                    (click)=\"raiseTelemetry(stripsResultDataMap[key]);redirectViewAll(stripsResultDataMap[key], stripsResultDataMap[key]?.viewMoreUrl?.path, stripsResultDataMap[key]?.viewMoreUrl?.queryParams )\">\n                    <span i18n class=\"ws-mat-default-text\">{{translateLabels(widgetData.strips[0].viewMoreUrl.viewMoreText,'home')  || 'See all'}}</span>\n                    <mat-icon class=\"ws-mat-default-text mat-icon notranslate material-icons mat-icon-no-color\" color=\"accent\">navigate_next</mat-icon>\n                  </a>\n                </div>\n                <!-- viewAll end-->\n              </div>\n              <button mat-icon-button (click)=\"setHiddenForStrip(key)\" *ngIf=\"stripsResultDataMap[key]?.canHideStrip\">\n                <mat-icon>close</mat-icon>\n              </button>\n              <mat-icon class=\"cursor-pointer\" *ngIf=\"stripsResultDataMap[key]?.mode === 'accordion' && isMobile\"\n                (click)=\"showAccordionData = !showAccordionData\">{{ showAccordionData ? 'expand_less' : 'expand_more' }}\n              </mat-icon>\n            </div>\n\n            <div class=\"mb-4\" *ngIf=\"checkVisible(stripsResultDataMap[key])\">\n              <ng-container [sbUiResolverWidget]=\"getdata(stripsResultDataMap[key])\">\n              </ng-container>\n            </div>\n\n            <ng-container *ngIf=\"stripsResultDataMap[key]?.showOnNoData\"\n              [sbUiResolverWidget]=\"stripsResultDataMap[key]?.noDataWidget\"></ng-container>\n            <ng-container *ngIf=\"stripsResultDataMap[key]?.showOnError\"\n              [sbUiResolverWidget]=\"stripsResultDataMap[key]?.errorWidget\"></ng-container>\n            <!-- IF no errors then proceed to show tabs or non tabs strip -->\n            <ng-container *ngIf=\"!stripsResultDataMap[key]?.showOnNoData && !stripsResultDataMap[key]?.showOnError\">\n              <ng-container *ngIf=\"stripsResultDataMap[key].tabs && stripsResultDataMap[key].tabs.length\">\n                <mat-tab-group  animationDuration=\"0ms\" [selectedIndex]=\"getSelectedIndex(stripsResultDataMap[key], key)\"\n                class=\"mat-tab-labels w-full strips-tabgroup  \" dynamicHeight\n                [ngClass]=\"stripsResultDataMap[key]?.tabsType ? stripsResultDataMap[key]?.tabsType : ''\"\n                  (selectedTabChange)=\"tabClicked($event, stripsResultDataMap[key], key)\">\n                  <mat-tab label=\"{{tab?.label}}\" *ngFor=\"let tab of stripsResultDataMap[key].tabs; let last = last;\">\n                    <ng-template mat-tab-label>\n                      <span>{{ translateLabels(tab?.label, 'home') }} &nbsp;</span>\n                      <span *ngIf=\"tab?.showTabDataCount && tab?.widgets?.length\">({{tab?.widgets?.length}})</span>\n                    </ng-template>\n                    <div>\n                      <!-- <ng-container [ngTemplateOutlet]=\"loader\" *ngIf=\"stripsResultDataMap[key]?.showOnLoader\">\n                      </ng-container> -->\n                      <div *ngIf=\"stripsResultDataMap && stripsResultDataMap[key]?.showOnLoader ||\n                      !tab.fetchTabStatus\"\n                      class=\"text-center my-2\">\n                            <sb-uic-horizontal-scroller-v2 [sliderConfig]=\"stripsResultDataMap[key]?.sliderConfig\" [id]=\"key+'-scroller'\"\n                                    [loadStatus]=\"'fetching'\" [stripConfig]=\"stripsResultDataMap[key]?.stripConfig\">\n                              <ng-container *ngFor=\"let widget of stripsResultDataMap[key]?.loaderWidgets; trackBy: tracker\">\n                                <ng-container [sbUiResolverWidget]=\"widget\"></ng-container>\n                              </ng-container>\n                            </sb-uic-horizontal-scroller-v2>\n                      </div>\n                      <div *ngIf=\"((tab?.fetchTabStatus && tab?.fetchTabStatus === 'done') &&\n                      (!tab?.widgets || !tab?.widgets?.length))\">\n                      <ng-container *ngIf=\"tab?.value === 'inprogress'; else msgTemp\">\n                        <div class=\"w-full flex flex-col items-center justify-center\">\n                          <img alt=\"\" class=\"mt-4 mb-4\" src=\"assets/icons/home/nodataDefault.svg\">\n                          <div class=\"mat-subheading-1 text-center info-content\">{{ 'contentstripmultiple.getReadyForLearningAdventure' | translate }} -\n                            <a class=\"click-here\" [routerLink]=\"'/page/learn'\">{{ 'contentstripmultiple.clickHere' | translate }}</a> {{ 'contentstripmultiple.toEnrollNextCourse' | translate }}</div>\n                        </div>\n                      </ng-container>\n                      <ng-template #msgTemp>\n                        <div class=\"w-full flex flex-col items-center justify-center\">\n                          <img alt=\"\" class=\"mt-4 mb-4\" src=\"assets/icons/home/nodataDefault.png\">\n                          <div class=\"mat-subheading-1 text-center\">{{ translateLabels(tab.nodataMsg, 'home') }}</div>\n                        </div>\n                      </ng-template>\n                      </div>\n                      <ng-container *ngIf=\"(tab?.fetchTabStatus === 'done' || tab?.widgets?.length)\">\n                        <ng-container  *ngIf=\"!tab?.tabLoading\">\n\n                          <sb-uic-horizontal-scroller-v2 [id]=\"key+'-scroller'\" [sliderConfig]=\"stripsResultDataMap[key]?.sliderConfig\" [widgetsLength]=\"tab?.widgets?.length\"\n                            *ngIf=\"getContineuLearningLenth(stripsResultDataMap[key]) && showAccordion(key)\"\n                            [loadStatus]=\"'done'\" [defaultMaxWidgets]=\"tab?.maxWidgets ||\n                            stripsResultDataMap[key]?.sliderConfig?.maxWidgets || defaultMaxWidgets\" [stripConfig]=\"stripsResultDataMap[key]?.stripConfig\">\n                            <ng-container *ngFor=\"let widget of tab?.widgets| slice:0:(tab?.maxWidgets ||\n                            stripsResultDataMap[key]?.sliderConfig?.maxWidgets || defaultMaxWidgets); trackBy: tracker\">\n                                <ng-container [sbUiResolverWidget]=\"widget\"></ng-container>\n                            </ng-container>\n                          </sb-uic-horizontal-scroller-v2>\n                        </ng-container>\n                      </ng-container>\n                    </div>\n                  </mat-tab>\n                </mat-tab-group>\n              </ng-container>\n              <ng-container *ngIf=\"!stripsResultDataMap[key].tabs || !stripsResultDataMap[key].tabs.length\">\n                <div *ngIf=\"stripsResultDataMap && stripsResultDataMap[key]?.showOnLoader\" class=\"text-center my-2\">\n                      <sb-uic-horizontal-scroller-v2 [id]=\"key+'-scroller'\" [sliderConfig]=\"stripsResultDataMap[key]?.sliderConfig\"\n                              [loadStatus]=\"'fetching'\" [stripConfig]=\"stripsResultDataMap[key]?.stripConfig\">\n                        <ng-container *ngFor=\"let widget of stripsResultDataMap[key]?.loaderWidgets; trackBy: tracker\">\n                          <ng-container [sbUiResolverWidget]=\"widget\"></ng-container>\n                        </ng-container>\n                      </sb-uic-horizontal-scroller-v2>\n                </div>\n                <div class=\"\">\n                    <sb-uic-horizontal-scroller-v2 [id]=\"key+'-scroller'\" [sliderConfig]=\"stripsResultDataMap[key]?.sliderConfig\"\n                    *ngIf=\"getContineuLearningLenth(stripsResultDataMap[key]) && showAccordion(key)\" [widgetsLength]=\"stripsResultDataMap[key]?.widgets?.length\" [loadStatus]=\"'done'\" [defaultMaxWidgets]=\"stripsResultDataMap[key].sliderConfig?.maxWidgets || defaultMaxWidgets\" [stripConfig]=\"stripsResultDataMap[key]?.stripConfig\">\n                      <ng-container *ngFor=\"let widget of stripsResultDataMap[key]?.widgets| slice:0:(stripsResultDataMap[key].sliderConfig?.maxWidgets || defaultMaxWidgets); trackBy: tracker\">\n                      <!-- <ng-container *ngIf=\"widget.widgetData.context.pageSection === 'continueLearning' \"> -->\n                      <!-- <ng-container *ngIf=\"widget.widgetData.content.completionPercentage !== 100\"\n                        [sbUiResolverWidget]=\"widget\"></ng-container> -->\n                        <ng-container [sbUiResolverWidget]=\"widget\"></ng-container>\n                      <!-- </ng-container> -->\n                      </ng-container>\n                  </sb-uic-horizontal-scroller-v2>\n                </div>\n              </ng-container>\n            </ng-container>\n          </div>\n        </div>\n      </a>\n\n    </ng-container>\n  </ng-container>\n</ng-template>", styles: [".view-more{display:flex;align-items:center;text-align:center;height:40px;justify-content:center}.view-more .icon{font-size:24px;width:24px;height:24px;border:1px solid;border-radius:50%;padding:8px;margin-bottom:8px}.margin-bottom-custom{margin-bottom:60px}.view-more:hover{background-color:#dcdfe5}::ng-deep .strips-tabgroup .mat-tab-header{border-bottom:2px solid rgba(0,0,0,.12)}::ng-deep .strips-tabgroup .mat-tab-body{padding:20px 0!important;box-sizing:border-box;overflow-y:initial!important}::ng-deep .strips-tabgroup .mat-tab-body-wrapper{overflow:inherit!important}::ng-deep .strips-tabgroup .mat-tab-label{border-bottom:0px solid rgba(0,0,0,.1);margin-right:0;opacity:1}::ng-deep .strips-tabgroup .mat-tab-label .mat-tab-label-content{text-transform:inherit;font:400 14px/20px Lato}::ng-deep .strips-tabgroup .mat-tab-label-active .mat-tab-label-content{font-weight:700!important}.click-here{color:#1b4ca1}.info-content{opacity:1;color:#000000de;font:700 14px/20px Lato-Bold;text-align:center}::ng-deep .pills-tab .mat-tab-header{border-bottom:unset!important}::ng-deep .pills-tab .mat-tab-label{border:1px solid rgba(0,0,0,.2392156863)!important;padding:2px 8px;margin-right:8px!important;min-width:unset!important;border-radius:12px;height:unset!important}::ng-deep .pills-tab .mat-ink-bar{background-color:transparent!important;visibility:hidden!important}::ng-deep .pills-tab .mat-tab-label-active{color:#fff!important;background-color:#1b4ca1!important}::ng-deep .pills-tab .mat-tab-body{padding:0!important}.min-height-40{min-height:40px}\n"], components: [{ type: i7.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i9.MatTabGroup, selector: "mat-tab-group", inputs: ["color", "disableRipple"], exportAs: ["matTabGroup"] }, { type: i9.MatTab, selector: "mat-tab", inputs: ["disabled", "label", "aria-label", "aria-labelledby"], exportAs: ["matTab"] }, { type: i10.HorizontalScrollerV2Component, selector: "sb-uic-horizontal-scroller-v2", inputs: ["loadStatus", "id", "onHover", "sliderConfig", "widgetsLength", "defaultMaxWidgets", "stripConfig"], outputs: ["loadNext"] }], directives: [{ type: i11.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i12.SbUiResolverDirective, selector: "[sbUiResolverWidget]", inputs: ["sbUiResolverWidget"] }, { type: i11.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i11.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i11.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i13.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { type: i3.RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: ["routerLink", "target", "queryParams", "fragment", "queryParamsHandling", "preserveFragment", "skipLocationChange", "replaceUrl", "state", "relativeTo"] }, { type: i9.MatTabLabel, selector: "[mat-tab-label], [matTabLabel]" }], pipes: { "translate": i5.TranslatePipe, "slice": i11.SlicePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ContentStripWithTabsLibComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'sb-uic-content-strip-with-tabs',
+                    templateUrl: './content-strip-with-tabs-lib.component.html',
+                    styleUrls: ['./content-strip-with-tabs-lib.component.scss'],
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i1.WidgetContentService }, { type: i2.LoggerService }, { type: i2.EventService }, { type: i2.ConfigurationsService }, { type: i2.UtilityService }, { type: i3.Router }, { type: i4.WidgetUserService }, { type: i5.TranslateService }, { type: i6.MultilingualTranslationsService }]; }, propDecorators: { widgetData: [{
+                type: Input
+            }], emptyResponse: [{
+                type: Output
+            }], viewAllResponse: [{
+                type: Output
+            }], telemtryResponse: [{
+                type: Output
+            }], providerId: [{
+                type: Input
+            }], emitViewAll: [{
+                type: Input
+            }], channnelName: [{
+                type: Input
+            }], id: [{
+                type: HostBinding,
+                args: ['id']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-strip-with-tabs-lib.component.js","sourceRoot":"","sources":["../../../../../../../library/sunbird-cb/consumption/src/lib/_common/content-strip-with-tabs-lib/content-strip-with-tabs-lib.component.ts","../../../../../../../library/sunbird-cb/consumption/src/lib/_common/content-strip-with-tabs-lib/content-strip-with-tabs-lib.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input, OnDestroy, HostBinding, Inject, EventEmitter, Output } from '@angular/core';\nimport { NsWidgetResolver, WidgetBaseComponent } from '@sunbird-cb/resolver-v2';\nimport { NsContentStripWithTabs } from './content-strip-with-tabs-lib.model';\n// import { HttpClient } from '@angular/common/http'\nimport { WidgetContentService } from '../../_services/widget-content.service';\nimport { NsContent } from '../../_models/widget-content.model';\nimport { MultilingualTranslationsService } from '../../_services/multilingual-translations.service';\nimport {\n  TFetchStatus,\n  LoggerService,\n  EventService,\n  ConfigurationsService,\n  UtilityService,\n  WsEvents,\n} from '@sunbird-cb/utils-v2';\nimport { Subscription } from 'rxjs';\nimport { filter } from 'rxjs/operators';\nimport { WidgetUserService } from '../../_services/widget-user.service';\n// import { environment } from 'src/environments/environment'\n// tslint:disable-next-line\nimport * as _ from 'lodash'\nimport { MatTabChangeEvent } from '@angular/material/tabs';\nimport { NsCardContent } from '../../_models/card-content-v2.model';\nimport { ITodayEvents } from '../../_models/event';\nimport { TranslateService } from '@ngx-translate/core';\nimport { Router } from '@angular/router';\n\ninterface IStripUnitContentData {\n  key: string;\n  canHideStrip: boolean;\n  mode?: string;\n  showStrip: boolean;\n  disableTranslate: boolean;\n  widgets?: NsWidgetResolver.IRenderConfigWithAnyData[];\n  stripTitle: string;\n  stripTitleLink?: {\n    link: {\n      queryParams: string\n    },\n    icon: string,\n    queryParams: string\n  };\n  sliderConfig?: {\n    showNavs: boolean,\n    showDots: boolean,\n    maxWidgets?: number\n    cerificateCardMargin?: boolean\n  };\n  stripConfig: any;\n  tabsType?: string;\n  tabs?: NsContentStripWithTabs.IContentStripTab[] | undefined;\n  stripName?: string;\n  stripLogo?: string;\n  description?: string;\n  stripInfo?: NsContentStripWithTabs.IStripInfo;\n  noDataWidget?: NsWidgetResolver.IRenderConfigWithAnyData;\n  errorWidget?: NsWidgetResolver.IRenderConfigWithAnyData;\n  showOnNoData: boolean;\n  showOnLoader: boolean;\n  showOnError: boolean;\n  loaderWidgets?: any;\n  stripBackground?: string;\n  secondaryHeading?: any;\n  viewMoreUrl: any;\n  request?: any\n\n}\n\n@Component({\n  selector: 'sb-uic-content-strip-with-tabs',\n  templateUrl: './content-strip-with-tabs-lib.component.html',\n  styleUrls: ['./content-strip-with-tabs-lib.component.scss'],\n})\nexport class ContentStripWithTabsLibComponent extends WidgetBaseComponent\n  implements\n  OnInit,\n  OnDestroy,\n  NsWidgetResolver.IWidgetData<NsContentStripWithTabs.IContentStripMultiple> {\n  @Input() widgetData!: NsContentStripWithTabs.IContentStripMultiple;\n  @Output() emptyResponse = new EventEmitter<any>()\n  @Output() viewAllResponse = new EventEmitter<any>()\n  @Output() telemtryResponse = new EventEmitter<any>()\n  @Input() providerId: any = ''\n  @Input() emitViewAll: boolean = false\n  @Input() channnelName: any = ''\n  @HostBinding('id')\n  public id = `ws-strip-miltiple_${Math.random()}`;\n  stripsResultDataMap: { [key: string]: IStripUnitContentData } = {};\n  stripsKeyOrder: string[] = [];\n  showAccordionData = true;\n  showParentLoader = false;\n  showParentError = false;\n  showParentNoData = false;\n  errorDataCount = 0;\n  noDataCount = 0;\n  successDataCount = 0;\n  contentAvailable = true;\n  baseUrl = this.configSvc.sitePath || '';\n  veifiedKarmayogi = false;\n  environment!: any;\n  changeEventSubscription: Subscription | null = null;\n  defaultMaxWidgets = 12;\n  enrollInterval: any;\n  todaysEvents: any = [];\n  enrollmentMapData: any\n\n  constructor(\n    // private contentStripSvc: ContentStripNewMultipleService,\n    @Inject('environment') environment: any,\n    private contentSvc: WidgetContentService,\n    private loggerSvc: LoggerService,\n    private eventSvc: EventService,\n    private configSvc: ConfigurationsService,\n    public utilitySvc: UtilityService,\n    // private http: HttpClient,\n    // private searchServSvc: SearchServService,\n    public router: Router,\n    private userSvc: WidgetUserService,\n    private translate: TranslateService,\n    private langtranslations: MultilingualTranslationsService\n  ) {\n    super();\n    if (localStorage.getItem('websiteLanguage')) {\n      this.translate.setDefaultLang('en');\n      let lang = JSON.stringify(localStorage.getItem('websiteLanguage'));\n      lang = lang.replace(/\\\"/g, '');\n      this.translate.use(lang);\n    }\n    this.environment = environment\n  }\n\n  ngOnInit() {\n    // const url = window.location.href\n    this.initData();\n    this.contentSvc.telemetryData$.subscribe((data: any) => {\n      this.telemtryResponse.emit(data)\n    })\n\n\n  }\n\n  ngOnDestroy() {\n    if (this.changeEventSubscription) {\n      this.changeEventSubscription.unsubscribe();\n    }\n  }\n\n  showAccordion(key: string) {\n    if (this.utilitySvc.isMobile && this.stripsResultDataMap[key].mode === 'accordion') {\n      return this.showAccordionData;\n    }\n    return true;\n  }\n\n  setHiddenForStrip(key: string) {\n    this.stripsResultDataMap[key].showStrip = false;\n    sessionStorage.setItem(`cstrip_${key}`, '1');\n  }\n  private getIfStripHidden(key: string): boolean {\n    const storageItem = sessionStorage.getItem(`cstrip_${key}`);\n    return Boolean(storageItem !== '1');\n  }\n\n  private initData() {\n    this.stripsKeyOrder = this.widgetData && this.widgetData.strips && this.widgetData.strips.map(strip => strip.key) || [];\n    if (this.widgetData.loader && this.widgetData.strips.length) {\n      this.showParentLoader = true;\n    }\n    // Fetch the data\n    for (const strip of this.widgetData.strips) {\n      if (this.checkForEmptyWidget(strip)) {\n        this.fetchStripFromRequestData(strip, false);\n      } else {\n        this.processStrip(strip, [], 'done', true, null);\n      }\n    }\n    // Subscription for changes\n    const keyAndEvent: { key: string; type: string; from: string }[] = this.widgetData.strips\n      .map(strip => ({\n        key: strip.key,\n        type: (strip.refreshEvent && strip.refreshEvent.eventType) || '',\n        from: (strip.refreshEvent && strip.refreshEvent.from.toString()) || '',\n      }))\n      .filter(({ key, type, from }) => key && type && from);\n    const eventTypeSet = new Set(keyAndEvent.map(e => e.type));\n    this.changeEventSubscription = this.eventSvc.events$\n      .pipe(filter(event => eventTypeSet.has(event.eventType)))\n      .subscribe(event => {\n        keyAndEvent\n          .filter(e => e.type === event.eventType && e.from === event.from)\n          .map(e => e.key)\n          .forEach(k => this.fetchStripFromKey(k, false));\n      });\n  }\n\n  private fetchStripFromKey(key: string, calculateParentStatus = true) {\n    const stripData = this.widgetData.strips.find(strip => strip.key === key);\n    if (stripData) {\n      this.fetchStripFromRequestData(stripData, calculateParentStatus);\n    }\n  }\n\n  isStripShowing(data: any) {\n    let count = 0;\n    if (data && data.key === this.environment.programStripKey && (!data.tabs || !data.tabs.length) &&\n      data.stripTitle === this.environment.programStripName && data.widgets.length > 0) {\n      data.widgets.forEach((key: any) => {\n        if (key && key.widgetData.content.primaryCategory === this.environment.programStripPrimaryCategory) {\n          count = count + 1;\n        }\n      });\n      if (count > 0) {\n        data.showStrip = true;\n      } else {\n        data.showStrip = false;\n      }\n    }\n    // console.log('data.key', data, data.key, data.widgets);\n    return data.showStrip;\n  }\n\n  get isMobile() {\n    return this.utilitySvc.isMobile || false;\n  }\n\n  getdata(data: IStripUnitContentData) {\n    if (data.stripInfo) {\n      return data.stripInfo.widget;\n    }\n    return {};\n\n  }\n  checkCondition(wData: NsContentStripWithTabs.IContentStripMultiple, data: IStripUnitContentData) {\n    if (wData.strips[0].stripConfig && wData.strips[0].stripConfig.hideShowAll) {\n      return !wData.strips[0].stripConfig.hideShowAll;\n    }\n    return wData.strips[0].viewMoreUrl && data.widgets && data.widgets.length >= 4;\n  }\n  checkVisible(data: IStripUnitContentData) {\n    return data.stripInfo && data.stripInfo.visibilityMode === 'visible';\n  }\n\n  getContineuLearningLenth(data: IStripUnitContentData) {\n    return data.widgets ? data.widgets.length : 0;\n  }\n  getLength(data: IStripUnitContentData) {\n    if (!data.tabs || !data.tabs.length) {\n      return data.widgets ? data.widgets.length : 0;\n    } {\n      // if tabs are there check if each tab has widgets and get the tab with max widgets\n      const tabWithMaxWidgets = data.tabs.reduce(\n        (prev, current) => {\n          if (!prev.widgets && !current.widgets) {\n            return current;\n          }\n          if (prev.widgets && current.widgets) {\n            return (prev.widgets.length > current.widgets.length) ? prev : current;\n          }\n          if (current.widgets && !prev.widgets) {\n            return current;\n          }\n          if (!current.widgets && prev.widgets) {\n            return prev;\n          }\n          return current;\n          // return (prev.widgets && current.widgets && (prev.widgets.length > current.widgets.length) ) ? prev : current\n          // tslint:disable-next-line: align\n        }, data.tabs[0]);\n      // if tabs has atleast 1 widgets then strip will show or else not\n      return tabWithMaxWidgets.widgets ? tabWithMaxWidgets.widgets.length : 0;\n    }\n  }\n\n  private getFiltersFromArray(v6filters: any) {\n    const filters: any = {};\n    if (v6filters.constructor === Array) {\n      v6filters.forEach(((f: any) => {\n        Object.keys(f).forEach(key => {\n          filters[key] = f[key];\n        });\n      }));\n      return filters;\n    }\n    return v6filters;\n  }\n\n  private transformSearchV6FiltersV2(v6filters: any) {\n    const filters: any = {};\n    if (v6filters.constructor === Array) {\n      v6filters.forEach(((f: any) => {\n        Object.keys(f).forEach(key => {\n          filters[key] = f[key];\n        });\n      }));\n      return filters;\n    }\n    return v6filters;\n  }\n\n  checkForDateFilters(filters: any) {\n    let userData: any;\n    if (this.configSvc.userProfile) {\n      userData = this.configSvc.userProfile;\n    }\n\n    if (filters && filters.hasOwnProperty('batches.endDate')) {\n      // tslint:disable-next-line\n      filters['batches.endDate']['>='] = eval(filters['batches.endDate']['>='])\n    } else if (filters && filters.hasOwnProperty('batches.enrollmentEndDate')) {\n      // tslint:disable-next-line\n      filters['batches.enrollmentEndDate']['>='] = eval(filters['batches.enrollmentEndDate']['>='])\n    } else if (filters.organisation &&\n      filters.organisation.indexOf('<orgID>') >= 0\n    ) {\n      if (this.providerId) {\n        filters.organisation = this.providerId;\n      } else {\n        filters.organisation = userData && userData.rootOrgId;\n\n        if (filters && filters.hasOwnProperty('designation')) {\n          filters.designation = userData.professionalDetails.length > 0 ?\n            userData.professionalDetails[0].designation : '';\n        }\n      }\n\n    }\n    return filters;\n  }\n\n  private fetchStripFromRequestData(\n    strip: NsContentStripWithTabs.IContentStripUnit,\n    calculateParentStatus = true,\n  ) {\n    // setting initial values\n    strip.loaderWidgets = this.transformSkeletonToWidgets(strip);\n    this.processStrip(strip, [], 'fetching', false, null);\n    this.fetchFromEnrollmentList(strip, calculateParentStatus);\n    this.fetchFromSearchV6(strip, calculateParentStatus);\n    this.fetchFromTrendingContent(strip, calculateParentStatus);\n    this.fetchAllCbpPlans(strip, calculateParentStatus);\n    this.fetchAllTopContent(strip, calculateParentStatus);\n    this.fetchAllFeaturedContent(strip, calculateParentStatus);\n    this.fetchAllBookMarkData(strip, calculateParentStatus);\n    this.fetchAllPlaylistSearch(strip, calculateParentStatus);\n    this.fetchPlaylistReadData(strip, calculateParentStatus);\n    this.fetchCiosContentData(strip, calculateParentStatus);\n\n    // this.enrollInterval = setInterval(() => {\n    //   this.fetchAllCbpPlans(strip, calculateParentStatus)\n    // },                                1000)\n  }\n\n  fetchFromEnrollmentList(strip: NsContentStripWithTabs.IContentStripUnit, calculateParentStatus = true) {\n    if (strip.request && strip.request.enrollmentList && Object.keys(strip.request.enrollmentList).length) {\n      let userId = '';\n      let content: NsContent.IContent[];\n      let contentNew: NsContent.IContent[];\n      let tabResults: any[] = [];\n      const queryParams = _.get(strip.request.enrollmentList, 'queryParams');\n      // if (queryParams && queryParams.batchDetails) {\n      //   if (!queryParams.batchDetails.includes('&retiredCoursesEnabled=true')) {\n      //     queryParams.batchDetails += '&retiredCoursesEnabled=true'\n      //   }\n      // }\n      if (this.configSvc.userProfile) {\n        userId = this.configSvc.userProfile.userId;\n      }\n      // this.userSvc.resetTime('enrollmentService')\n      // tslint:disable-next-line: deprecation\n      this.userSvc.fetchUserBatchList(userId, queryParams).subscribe(\n        (result: any) => {\n          const courses = result && result.courses;\n          const showViewMore = Boolean(\n            courses.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch,\n          );\n          const viewMoreUrl = showViewMore\n            ? {\n              path: (strip.viewMoreUrl && strip.viewMoreUrl.path) || '',\n              queryParams: {\n                q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,\n                f:\n                  strip.request && strip.request.searchV6 && strip.request.searchV6.filters\n                    ? JSON.stringify(\n                      // this.searchServSvc.transformSearchV6Filters(\n                      strip.request.searchV6.filters\n                      // ),\n                    )\n                    : {},\n              },\n            }\n            : null;\n          if (courses && courses.length) {\n            content = courses.map((c: any) => {\n              const contentTemp: NsContent.IContent = c.content;\n              contentTemp.completionPercentage = c.completionPercentage || c.progress || 0;\n              contentTemp.completionStatus = c.completionStatus || c.status || 0;\n              contentTemp.enrolledDate = c.enrolledDate || '';\n              contentTemp.lastContentAccessTime = c.lastContentAccessTime || '';\n              contentTemp.lastReadContentStatus = c.lastReadContentStatus || '';\n              contentTemp.lastReadContentId = c.lastReadContentId || '';\n              contentTemp.lrcProgressDetails = c.lrcProgressDetails || '';\n              contentTemp.issuedCertificates = c.issuedCertificates || [];\n              contentTemp.batchId = c.batchId || '';\n              return contentTemp;\n            });\n          }\n          // To filter content with completionPercentage > 0,\n          // so that only those content will show in home page\n          // continue learing strip\n          // if (content && content.length) {\n          //   contentNew = content.filter((c: any) => {\n          //     /** commented as both are 0 after enrolll */\n          //     if (c.completionPercentage && c.completionPercentage > 0) {\n          //       return c\n          //     }\n          //   })\n          // }\n\n          // To sort in descending order of the enrolled date\n          contentNew = (content || []).sort((a: any, b: any) => {\n            const dateA: any = new Date(a.lastContentAccessTime || 0);\n            const dateB: any = new Date(b.lastContentAccessTime || 0);\n            return dateB - dateA;\n          });\n\n          if (strip.tabs && strip.tabs.length) {\n            tabResults = this.splitEnrollmentTabsData(contentNew, strip);\n            this.processStrip(\n              strip,\n              this.transformContentsToWidgets(contentNew, strip),\n              'done',\n              calculateParentStatus,\n              viewMoreUrl,\n              tabResults\n            );\n          } else {\n            this.processStrip(\n              strip,\n              this.transformContentsToWidgets(contentNew, strip),\n              'done',\n              calculateParentStatus,\n              viewMoreUrl,\n            );\n          }\n        },\n        () => {\n          this.processStrip(strip, [], 'error', calculateParentStatus, null);\n        }\n      );\n    }\n  }\n\n  splitEnrollmentTabsData(contentNew: NsContent.IContent[], strip: NsContentStripWithTabs.IContentStripUnit) {\n    const tabResults: any[] = [];\n    const splitData = this.getInprogressAndCompleted(\n      contentNew,\n      (e: any) => e.completionStatus === 1 || e.completionPercentage < 100,\n      strip,\n    );\n\n    if (strip.tabs && strip.tabs.length) {\n      for (let i = 0; i < strip.tabs.length; i += 1) {\n        if (strip.tabs[i]) {\n          tabResults.push(\n            {\n              ...strip.tabs[i],\n              fetchTabStatus: 'done',\n              ...(splitData.find(itmInner => {\n                if (strip.tabs && strip.tabs[i] && itmInner.value === strip.tabs[i].value) {\n                  return itmInner;\n                }\n                return undefined;\n              })),\n            }\n          );\n        }\n      }\n    }\n    return tabResults;\n  }\n\n  getInprogressAndCompleted(array: NsContent.IContent[],\n                            customFilter: any,\n                            strip: NsContentStripWithTabs.IContentStripUnit) {\n                              const inprogress: any[] = []\n    const completed: any[] = []\n    // array.forEach((e: any, idx: number, arr: any[]) => (customFilter(e, idx, arr) ? inprogress : completed).push(e))\n    array.forEach((e, idx, arr) => {\n    const status = e.status ? (e.status as string).toLowerCase() : ''\n    const statusRetired = status === 'retired'\n    if (customFilter(e, idx, arr)) {\n    if (!statusRetired) {\n      inprogress.push(e)\n    }\n   } else {\n    completed.push(e)\n   }\n    })\n    // Sort the completed array with 'Live' status first and 'Retired' status second\n    completed.sort((a: any, b: any) => {\n      const statusA = a.status ? a.status.toLowerCase() : ''\n      const statusB = b.status ? b.status.toLowerCase() : ''\n      if (statusA === 'live' && statusB !== 'live') {\n        return -1\n      }\n      if (statusA !== 'live' && statusB === 'live') {\n        return 1\n      }\n      if (statusA === 'retired' && statusB !== 'retired') {\n        return 1\n      }\n      if (statusA !== 'retired' && statusB === 'retired') {\n        return -1\n      }\n      return 0\n    })\n    return [\n      { value: 'inprogress', widgets: this.transformContentsToWidgets(inprogress, strip) },\n      { value: 'completed', widgets: this.transformContentsToWidgets(completed, strip) }];\n  }\n\n  async fetchFromSearchV6(strip: NsContentStripWithTabs.IContentStripUnit, calculateParentStatus = true) {\n    if (strip.request && strip.request.searchV6 && Object.keys(strip.request.searchV6).length) {\n      // if (!(strip.request.searchV6.locale && strip.request.searchV6.locale.length > 0)) {\n      //   if (this.configSvc.activeLocale) {\n      //     strip.request.searchV6.locale = [this.configSvc.activeLocale.locals[0]]\n      //   } else {\n      //     strip.request.searchV6.locale = ['en']\n      //   }\n      // }\n      let originalFilters: any = [];\n      // tslint:disable:no-console\n      console.log(originalFilters);\n      if (strip.request &&\n        strip.request.searchV6 &&\n        strip.request.searchV6.request &&\n        strip.request.searchV6.request.filters) {\n        originalFilters = strip.request.searchV6.request.filters;\n        strip.request.searchV6.request.filters = this.checkForDateFilters(strip.request.searchV6.request.filters);\n        strip.request.searchV6.request.filters = this.getFiltersFromArray(\n          strip.request.searchV6.request.filters,\n        );\n      }\n      if (strip.tabs && strip.tabs.length) {\n        // TODO: Have to extract requestRequired to outer level of tabs config\n        const firstTab = strip.tabs[0];\n        if (firstTab.requestRequired) {\n          if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n            const allTabs = this.stripsResultDataMap[strip.key].tabs;\n            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]) as NsContentStripWithTabs.IContentStripTab;\n\n            this.getTabDataByNewReqSearchV6(strip, 0, currentTabFromMap, calculateParentStatus);\n          }\n        }\n\n      } else {\n        try {\n          const response = await this.searchV6Request(strip, strip.request, calculateParentStatus);\n          // console.log('calling  after - response, ', response)\n          if (response && response.results) {\n            // console.log('calling  after-- ')\n            if (response.results.result.content) {\n              if (strip.key === 'scheduledAssessment') {\n                this.enrollInterval = setInterval(() => {\n                  this.checkInvitOnlyAssessments(response.results.result.content, strip, calculateParentStatus, response.viewMoreUrl)\n\n                  // tslint:disable-next-line\n                }, 1000)\n\n\n              } else {\n                this.processStrip(\n                  strip,\n                  this.transformContentsToWidgets(response.results.result.content, strip),\n                  'done',\n                  calculateParentStatus,\n                  response.viewMoreUrl,\n                );\n              }\n\n            } else if (response.results.result.Event) {\n              this.processStrip(\n                strip,\n                this.transformEventsToWidgets(response.results.result.Event, strip),\n                'done',\n                calculateParentStatus,\n                response.viewMoreUrl,\n              );\n            } else {\n              this.processStrip(strip, [], 'error', calculateParentStatus, null);\n            }\n\n          } else {\n            this.processStrip(strip, [], 'error', calculateParentStatus, null);\n          }\n        } catch (error) {\n          // Handle errors\n          // console.error('Error:', error);\n        }\n      }\n    }\n  }\n\n  checkInvitOnlyAssessments(content: any, strip: any, calculateParentStatus: any, viewMoreUrl: any) {\n    if (localStorage.getItem('enrollmentMapData')) {\n      this.enrollmentMapData = JSON.parse(localStorage.getItem('enrollmentMapData') || '{}')\n      let filteredArray: any = []\n      let now = new Date().getTime()\n      content.forEach((data: any) => {\n        if (this.enrollmentMapData[data.identifier]) {\n          if(this.enrollmentMapData[data.identifier].status !== 2 && this.enrollmentMapData[data.identifier].batch) {\n            const enrollData = this.enrollmentMapData[data.identifier].batch\n            let endDate:any = new Date(enrollData.endDate).getTime()\n            // let endDate:any = '2024-07-7T00:00:00.000Z'\n            let timeDuration = endDate - now\n            if(timeDuration > 0 ) {\n              data['batch'] = this.enrollmentMapData[data.identifier].batch\n              data['completionPercentage'] = this.enrollmentMapData[data.identifier].completionPercentage\n              filteredArray.push(data)\n            }\n          }\n          \n        }\n      })\n      filteredArray = filteredArray.sort((a: any, b: any) => {\n        const dateA: any = new Date(a.batch.startDate || 0)\n        const dateB: any = new Date(b.batch.startDate || 0)\n        return dateA - dateB\n      })\n      this.processStrip(\n        strip,\n        this.transformContentsToWidgets(filteredArray, strip),\n        'done',\n        calculateParentStatus,\n        viewMoreUrl,\n      );\n      clearInterval(this.enrollInterval)\n    }\n  }\n\n  async searchV6Request(strip: NsContentStripWithTabs.IContentStripUnit,\n    request: NsContentStripWithTabs.IContentStripUnit['request'],\n    calculateParentStatus: boolean\n  ): Promise<any> {\n    const originalFilters: any = [];\n    return new Promise<any>((resolve, reject) => {\n      if (request && request.searchV6) {\n        this.contentSvc.searchV6(request.searchV6).subscribe(results => {\n          const showViewMore = Boolean(\n            results.result.content && results.result.content.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch,\n          );\n          const viewMoreUrl = showViewMore\n            ? {\n              path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',\n              queryParams: {\n                tab: 'Learn',\n                q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,\n                f:\n                  request &&\n                    request.searchV6 &&\n                    request.searchV6.request &&\n                    request.searchV6.request.filters\n                    ? JSON.stringify(\n                      this.transformSearchV6FiltersV2(\n                        originalFilters,\n                      )\n                    )\n                    : {},\n              },\n            }\n            : null;\n          // if (viewMoreUrl && viewMoreUrl.queryParams) {\n          //   viewMoreUrl.queryParams = viewMoreUrl.queryParams\n          // }\n          resolve({ results, viewMoreUrl });\n        }, (error: any) => {\n          this.processStrip(strip, [], 'error', calculateParentStatus, null);\n          reject(error);\n        },\n        );\n      }\n    });\n  }\n\n  async fetchFromTrendingContent(strip: NsContentStripWithTabs.IContentStripUnit, calculateParentStatus = true) {\n    if (strip.request && strip.request.trendingSearch && Object.keys(strip.request.trendingSearch).length) {\n      // if (!(strip.request.searchV6.locale && strip.request.searchV6.locale.length > 0)) {\n      //   if (this.configSvc.activeLocale) {\n      //     strip.request.searchV6.locale = [this.configSvc.activeLocale.locals[0]]\n      //   } else {\n      //     strip.request.searchV6.locale = ['en']\n      //   }\n      // }\n      let originalFilters: any = [];\n      // tslint:disable:no-console\n      console.log(originalFilters);\n      if (strip.request &&\n        strip.request.trendingSearch &&\n        strip.request.trendingSearch.request &&\n        strip.request.trendingSearch.request.filters) {\n        originalFilters = strip.request.trendingSearch.request.filters;\n        strip.request.trendingSearch.request.filters = this.checkForDateFilters(strip.request.trendingSearch.request.filters);\n        strip.request.trendingSearch.request.filters = this.getFiltersFromArray(\n          strip.request.trendingSearch.request.filters,\n        );\n      }\n      if (strip.tabs && strip.tabs.length) {\n        // TODO: Have to extract requestRequired to outer level of tabs config\n        const firstTab = strip.tabs[0];\n        if (firstTab.requestRequired) {\n          if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n            const allTabs = this.stripsResultDataMap[strip.key].tabs;\n            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]) as NsContentStripWithTabs.IContentStripTab;\n\n            this.getTabDataByNewReqTrending(strip, 0, currentTabFromMap, calculateParentStatus);\n          }\n        }\n\n      } else {\n        try {\n          const response = await this.trendingSearchRequest(strip, strip.request, calculateParentStatus);\n          if (response && response.results && response.results.response) {\n            const content = response.results.response[strip.request.trendingSearch.responseKey] || [];\n            this.processStrip(\n              strip,\n              this.transformContentsToWidgets(content, strip),\n              'done',\n              calculateParentStatus,\n              response.viewMoreUrl || '',\n            );\n            if (!content.length) {\n              this.emptyResponse.emit(true)\n            }\n          } else {\n            this.emptyResponse.emit(true)\n            this.processStrip(strip, [], 'done', calculateParentStatus, null);\n          }\n        } catch (error) {\n          // Handle errors\n          this.emptyResponse.emit(true)\n          this.processStrip(strip, [], 'error', calculateParentStatus, null);\n        }\n      }\n    }\n  }\n\n  async trendingSearchRequest(strip: NsContentStripWithTabs.IContentStripUnit,\n    request: NsContentStripWithTabs.IContentStripUnit['request'],\n    calculateParentStatus: boolean\n  ): Promise<any> {\n    const originalFilters: any = [];\n    return new Promise<any>((resolve, reject) => {\n      if (request && request.trendingSearch) {\n        // check for the request if it has dynamic values]\n        if (request.trendingSearch.request.filters.organisation &&\n          request.trendingSearch.request.filters.organisation.indexOf('<orgID>') >= 0\n        ) {\n          let userRootOrgId;\n          if (this.configSvc.userProfile) {\n            userRootOrgId = this.configSvc.userProfile.rootOrgId;\n          }\n          request.trendingSearch.request.filters.organisation = userRootOrgId;\n        }\n        this.contentSvc.trendingContentSearch(request.trendingSearch).subscribe(results => {\n          const showViewMore = Boolean(\n            results.result &&\n            strip.request &&\n            results.result[strip.request.trendingSearch.responseKey] &&\n            results.result[strip.request.trendingSearch.responseKey].length > 5 &&\n            strip.stripConfig && strip.stripConfig.postCardForSearch,\n          );\n          const viewMoreUrl = showViewMore\n            ? {\n              path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',\n              queryParams: {\n                tab: 'Learn',\n                q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,\n                f:\n                  request &&\n                    request.trendingSearch &&\n                    request.trendingSearch.request &&\n                    request.trendingSearch.request.filters\n                    ? JSON.stringify(\n                      this.transformSearchV6FiltersV2(\n                        originalFilters,\n                      )\n                    )\n                    : {},\n              },\n            }\n            : null;\n          let proccesedResult: any = []\n          if (results && results.response && results.response.certifications) {\n            results.response.certifications.map((result: any) => {\n              if (result.source === this.channnelName) {\n                proccesedResult.push(result)\n              }\n            })\n          }\n          results = { response: { certifications: proccesedResult } }\n          resolve({ results, viewMoreUrl });\n        }, (error: any) => {\n          if (error.error && error.error.status === 400) {\n            this.processStrip(strip, [], 'done', calculateParentStatus, null);\n          }\n          // this.processStrip(strip, [], 'done', calculateParentStatus, null)\n          reject(error);\n        },\n        );\n      }\n    });\n  }\n\n  toggleInfo(data: IStripUnitContentData) {\n    const stripInfo = this.stripsResultDataMap[data.key].stripInfo;\n    if (stripInfo) {\n      if (stripInfo.mode !== 'below') {\n        this.loggerSvc.warn(`strip info mode: ${stripInfo.mode} not implemented yet`);\n        stripInfo.mode = 'below';\n      }\n      if (stripInfo.mode === 'below') {\n        this.stripsResultDataMap[data.key].stripInfo = {\n          ...stripInfo,\n          visibilityMode: stripInfo.visibilityMode === 'hidden' ? 'visible' : 'hidden',\n        };\n      }\n    }\n  }\n\n  private transformContentsToWidgets(\n    contents: NsContent.IContent[],\n    strip: NsContentStripWithTabs.IContentStripUnit,\n  ) {\n    return (contents || []).map((content, idx) => (\n      content ? {\n        widgetType: 'cardLib',\n        widgetSubType: 'cardContentLib',\n        widgetHostClass: 'mb-2',\n        widgetData: {\n          content,\n          ...(content.batch && { batch: content.batch }),\n          cardSubType: strip.stripConfig && strip.stripConfig.cardSubType,\n          cardCustomeClass: strip.customeClass ? strip.customeClass : '',\n          context: { pageSection: strip.key, position: idx },\n          intranetMode: strip.stripConfig && strip.stripConfig.intranetMode,\n          deletedMode: strip.stripConfig && strip.stripConfig.deletedMode,\n          contentTags: strip.stripConfig && strip.stripConfig.contentTags,\n        },\n      } : {\n        widgetType: 'card',\n        widgetSubType: 'cardContent',\n        widgetHostClass: 'mb-2',\n        widgetData: {},\n      }\n    ));\n  }\n\n  private transformEventsToWidgets(\n    contents: ITodayEvents[],\n    strip: NsContentStripWithTabs.IContentStripUnit,\n  ) {\n    this.eventSvc.setEventListData(contents);\n    return (this.eventSvc.todaysEvents || []).map((content: any, idx: any) => (content ? {\n      widgetType: 'card',\n      widgetSubType: 'eventHubCard',\n      widgetHostClass: 'mb-2',\n      widgetData: {\n        content,\n        cardSubType: strip.stripConfig && strip.stripConfig.cardSubType,\n        cardCustomeClass: strip.customeClass ? strip.customeClass : '',\n        context: { pageSection: strip.key, position: idx },\n        intranetMode: strip.stripConfig && strip.stripConfig.intranetMode,\n        deletedMode: strip.stripConfig && strip.stripConfig.deletedMode,\n        contentTags: strip.stripConfig && strip.stripConfig.contentTags,\n      },\n    } : {\n      widgetType: 'card',\n      widgetSubType: 'eventHubCard',\n      widgetHostClass: 'mb-2',\n      widgetData: {},\n    }\n    ));\n  }\n  private transformSkeletonToWidgets(\n    strip: any\n  ) {\n    return [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10].map(_content => ({\n      widgetType: 'cardLib',\n      widgetSubType: 'cardContentLib',\n      widgetHostClass: 'mb-2',\n      widgetData: {\n        cardSubType: strip.loaderConfig && strip.loaderConfig.cardSubType || 'card-standard-skeleton',\n        cardCustomeClass: strip.customeClass ? strip.customeClass : '',\n      },\n    }));\n  }\n\n  private async processStrip(\n    strip: NsContentStripWithTabs.IContentStripUnit,\n    results: NsWidgetResolver.IRenderConfigWithAnyData[] = [],\n    fetchStatus: TFetchStatus,\n    calculateParentStatus = true,\n    _viewMoreUrl: any,\n    tabsResults?: NsContentStripWithTabs.IContentStripTab[] | undefined,\n    // calculateParentStatus is used so that parents' status is not re-calculated if the API is called again coz of filters, etc.\n  ) {\n    const stripData = {\n      viewMoreUrl: strip.viewMoreUrl,\n      key: strip.key,\n      canHideStrip: Boolean(strip.canHideStrip),\n      showStrip: this.getIfStripHidden(strip.key),\n      noDataWidget: strip.noDataWidget,\n      errorWidget: strip.errorWidget,\n      stripInfo: strip.info,\n      stripTitle: strip.title,\n      stripTitleLink: strip.stripTitleLink,\n      disableTranslate: strip.disableTranslate,\n      sliderConfig: strip.sliderConfig,\n      tabs: tabsResults ? tabsResults : strip.tabs,\n      tabsType: strip.tabsType ? strip.tabsType : '',\n      stripName: strip.name,\n      mode: strip.mode,\n      stripConfig: strip.stripConfig,\n      stripBackground: strip.stripBackground,\n      secondaryHeading: strip.secondaryHeading,\n      loaderWidgets: strip.loaderWidgets || [],\n      widgets:\n        fetchStatus === 'done'\n          ? [\n            ...(strip.preWidgets || []).map(w => ({\n              ...w,\n              widgetHostClass: `mb-2 ${w.widgetHostClass}`,\n            })),\n            ...results,\n            ...(strip.postWidgets || []).map(w => ({\n              ...w,\n              widgetHostClass: `mb-2 ${w.widgetHostClass}`,\n            })),\n          ]\n          : [],\n      showOnNoData: Boolean(\n        strip.noDataWidget &&\n        !((strip.preWidgets || []).length + results.length + (strip.postWidgets || []).length) &&\n        fetchStatus === 'done',\n      ),\n      showOnLoader: Boolean(strip.loader && fetchStatus === 'fetching'),\n      showOnError: Boolean(strip.errorWidget && fetchStatus === 'error'),\n    };\n    // const stripData = this.stripsResultDataMap[strip.key]\n    this.stripsResultDataMap = {\n      ...this.stripsResultDataMap,\n      [strip.key]: stripData,\n    };\n    if (!tabsResults) {\n      if (\n        calculateParentStatus &&\n        (fetchStatus === 'done' || fetchStatus === 'error') &&\n        stripData.widgets\n      ) {\n        this.checkParentStatus(fetchStatus, stripData.widgets.length);\n      }\n      if (calculateParentStatus && !(results && results.length > 0)) {\n        this.contentAvailable = false;\n      } else if (results && results.length > 0) {\n        this.contentAvailable = true;\n      }\n    } else {\n      this.contentAvailable = true;\n    }\n  }\n  private checkParentStatus(fetchStatus: TFetchStatus, stripWidgetsCount: number): void {\n    if (fetchStatus === 'done' && !stripWidgetsCount) {\n      this.noDataCount += 1;\n    } else if (fetchStatus === 'done' && stripWidgetsCount) {\n      this.successDataCount += 1;\n    } else if (fetchStatus === 'error') {\n      this.errorDataCount += 1;\n    }\n    const settledCount = this.noDataCount + this.successDataCount + this.errorDataCount;\n    const totalCount = this.widgetData.strips.length;\n    if (this.successDataCount > 0 && settledCount < totalCount) {\n      return;\n    }\n    this.showParentLoader = settledCount !== totalCount;\n    this.showParentNoData =\n      this.noDataCount > 0 && this.noDataCount + this.errorDataCount === totalCount;\n    this.showParentError = this.errorDataCount === totalCount;\n  }\n  checkForEmptyWidget(strip: NsContentStripWithTabs.IContentStripUnit): boolean {\n    if (\n      strip.request &&\n      ((strip.request.api && Object.keys(strip.request.api).length) ||\n        (strip.request.search && Object.keys(strip.request.search).length) ||\n        (strip.request.searchRegionRecommendation &&\n          Object.keys(strip.request.searchRegionRecommendation).length) ||\n        (strip.request.searchV6 && Object.keys(strip.request.searchV6).length) ||\n        (strip.request.enrollmentList && Object.keys(strip.request.enrollmentList).length) ||\n        (strip.request.cbpList && Object.keys(strip.request.cbpList).length) ||\n        (strip.request.trendingSearch && Object.keys(strip.request.trendingSearch).length) ||\n        (strip.request.topContent && Object.keys(strip.request.topContent).length) ||\n        (strip.request.featureContent && Object.keys(strip.request.featureContent).length) ||\n        (strip.request.bookmarkRead && Object.keys(strip.request.bookmarkRead).length) ||\n        (strip.request.playlistSearch && Object.keys(strip.request.playlistSearch).length) ||\n        (strip.request.playlistRead && Object.keys(strip.request.playlistRead).length) ||\n        (strip.request.ciosContent && Object.keys(strip.request.ciosContent).length)\n      )\n    ) {\n      return true;\n    }\n    return false;\n  }\n\n  public tabClicked(tabEvent: MatTabChangeEvent, stripMap: IStripUnitContentData, stripKey: string) {\n    if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {\n      stripMap.tabs[tabEvent.index].fetchTabStatus = 'inprogress';\n      stripMap.tabs[tabEvent.index].tabLoading = true;\n      stripMap.showOnLoader = true;\n    }\n    const data: WsEvents.ITelemetryTabData = {\n      label: `${tabEvent.tab.textLabel}`,\n      index: tabEvent.index,\n    };\n    this.eventSvc.raiseInteractTelemetry(\n      {\n        type: WsEvents.EnumInteractTypes.CLICK,\n        subType: WsEvents.EnumInteractSubTypes.HOME_PAGE_STRIP_TABS,\n        id: `${_.camelCase(data.label)}-tab`,\n      },\n      {},\n      {\n        module: WsEvents.EnumTelemetrymodules.HOME,\n      }\n    );\n    const currentTabFromMap: any = stripMap.tabs && stripMap.tabs[tabEvent.index];\n    const currentStrip = this.widgetData.strips.find(s => s.key === stripKey);\n    if (this.stripsResultDataMap[stripKey] && currentTabFromMap) {\n      this.stripsResultDataMap[stripKey].viewMoreUrl.queryParams = {\n        ...this.stripsResultDataMap[stripKey].viewMoreUrl.queryParams,\n        tabSelected: currentTabFromMap.label,\n      };\n    }\n    if (currentStrip && currentTabFromMap && !currentTabFromMap.computeDataOnClick) {\n      if (currentTabFromMap.requestRequired && currentTabFromMap.request) {\n        // call API to get tab data and process\n        // this.processStrip(currentStrip, [], 'fetching', true, null)\n        if (currentTabFromMap.request.searchV6) {\n          this.getTabDataByNewReqSearchV6(currentStrip, tabEvent.index, currentTabFromMap, true);\n        } else if (currentTabFromMap.request.trendingSearch) {\n          this.getTabDataByNewReqTrending(currentStrip, tabEvent.index, currentTabFromMap, true);\n        } else if (currentTabFromMap.request.topContent) {\n          this.getTabDataByNewReqTopContent(currentStrip, tabEvent.index, currentTabFromMap, true);\n        } else if (currentTabFromMap.request.playlistRead) {\n          this.getTabDataByNewReqPlaylistReadContent(currentStrip, tabEvent.index, currentTabFromMap, true);\n        } else if (currentTabFromMap.request.ciosContent) {\n          this.getTabDataByCiosSearch(currentStrip, tabEvent.index, currentTabFromMap, true)\n        }\n        if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {\n          stripMap.tabs[tabEvent.index].tabLoading = false;\n        }\n      } else {\n        this.getTabDataByfilter(currentStrip, currentTabFromMap, true);\n        setTimeout(() => {\n          if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {\n            stripMap.tabs[tabEvent.index].tabLoading = false;\n            stripMap.tabs[tabEvent.index].fetchTabStatus = 'done';\n            stripMap.showOnLoader = false;\n          }\n        }, 200);\n      }\n    }\n  }\n\n\n  async getTabDataByNewReqSearchV6(\n    strip: NsContentStripWithTabs.IContentStripUnit,\n    tabIndex: number,\n    currentTab: NsContentStripWithTabs.IContentStripTab,\n    calculateParentStatus: boolean\n  ) {\n    try {\n      const response = await this.searchV6Request(strip, currentTab.request, calculateParentStatus);\n      if (response && response.results) {\n        const widgets = this.transformContentsToWidgets(response.results.result.content, strip);\n        let tabResults: any[] = [];\n        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n          const allTabs = this.stripsResultDataMap[strip.key].tabs;\n          if (allTabs && allTabs.length && allTabs[tabIndex]) {\n            allTabs[tabIndex] = {\n              ...allTabs[tabIndex],\n              widgets,\n              fetchTabStatus: 'done',\n            };\n            tabResults = allTabs;\n          }\n        }\n        this.processStrip(\n          strip,\n          widgets,\n          'done',\n          calculateParentStatus,\n          response.viewMoreUrl,\n          tabResults // tabResults as widgets\n        );\n      } else {\n        this.processStrip(strip, [], 'error', calculateParentStatus, null);\n      }\n    } catch (error) {\n      // Handle errors\n      // console.error('Error:', error);\n    }\n  }\n\n  async getTabDataByNewReqTrending(\n    strip: NsContentStripWithTabs.IContentStripUnit,\n    tabIndex: number,\n    currentTab: NsContentStripWithTabs.IContentStripTab,\n    calculateParentStatus: boolean\n  ) {\n    try {\n      const response = await this.trendingSearchRequest(strip, currentTab.request, calculateParentStatus);\n      if (response && response.results && response.results.response) {\n        const content = response.results.response[currentTab.value] || [];\n        const widgets = this.transformContentsToWidgets(content, strip);\n        // console.log('currentTab --- widgets', widgets)\n        let tabResults: any[] = [];\n        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n          const allTabs = this.stripsResultDataMap[strip.key].tabs;\n          if (allTabs && allTabs.length && allTabs[tabIndex]) {\n            allTabs[tabIndex] = {\n              ...allTabs[tabIndex],\n              widgets,\n              fetchTabStatus: 'done',\n            };\n            tabResults = allTabs;\n          }\n        }\n        // console.log('tabResults -++++***--', tabResults)\n        // console.log('calling  after-- ')\n        this.processStrip(\n          strip,\n          widgets,\n          'done',\n          calculateParentStatus,\n          response.viewMoreUrl,\n          tabResults // tabResults as widgets\n        );\n      } else {\n        this.processStrip(strip, [], 'done', calculateParentStatus, null);\n      }\n    } catch (error) {\n      // Handle errors\n      this.processStrip(strip, [], 'error', calculateParentStatus, null);\n    }\n  }\n\n  getTabDataByfilter(\n    strip: NsContentStripWithTabs.IContentStripUnit,\n    currentTab: NsContentStripWithTabs.IContentStripTab,\n    calculateParentStatus: boolean\n  ) {\n    // tslint:disable:no-console\n    console.log('strip -- ', strip);\n    // tslint:disable:no-console\n    console.log('currentTab -- ', currentTab);\n    // tslint:disable:no-console\n    console.log('calculateParentStatus-- ', calculateParentStatus);\n    // TODO: Write logic for individual filter if passed in config\n    // add switch case based on config key passed\n  }\n\n  async fetchAllCbpPlans(strip: any, calculateParentStatus = true) {\n\n    if (strip.request && strip.request.cbpList && Object.keys(strip.request.cbpList).length) {\n\n      let courses: NsContent.IContent[];\n      let tabResults: any[] = [];\n      const response = await this.userSvc.fetchCbpPlanList().toPromise();\n      if (response) {\n        courses = response;\n        if (strip.tabs && strip.tabs.length) {\n          tabResults = this.splitCbpTabsData(courses, strip);\n          await this.processStrip(\n            strip,\n            this.transformContentsToWidgets(courses, strip),\n            'done',\n            calculateParentStatus,\n            '',\n            tabResults\n          );\n        } else {\n          this.processStrip(\n            strip,\n            this.transformContentsToWidgets(courses, strip),\n            'done',\n            calculateParentStatus,\n            'viewMoreUrl',\n          );\n        }\n      }\n      // this.userSvc.fetchCbpPlanList().subscribe( async  (res: any) => {\n      //   if (res) {\n      //     console.log(res,'===============================>')\n      //     courses = res\n      //     if (strip.tabs && strip.tabs.length) {\n      //       tabResults = this.splitCbpTabsData(courses, strip)\n      //       await this.processStrip(\n      //         strip,\n      //         this.transformContentsToWidgets(courses, strip),\n      //         'done',\n      //         calculateParentStatus,\n      //         '',\n      //         tabResults\n      //       )\n      //     } else {\n      //       this.processStrip(\n      //         strip,\n      //         this.transformContentsToWidgets(courses, strip),\n      //         'done',\n      //         calculateParentStatus,\n      //         'viewMoreUrl',\n      //       )\n      //     }\n      //   }\n      // },                                        (_err: any) => {\n\n      // })\n\n      clearInterval(this.enrollInterval);\n    }\n  }\n  splitCbpTabsData(contentNew: NsContent.IContent[], strip: NsContentStripWithTabs.IContentStripUnit) {\n    const tabResults: any[] = [];\n    const splitData = this.getTabsList(\n      contentNew,\n      strip,\n    );\n    if (strip.tabs && strip.tabs.length) {\n      for (let i = 0; i < strip.tabs.length; i += 1) {\n        if (strip.tabs[i]) {\n          tabResults.push(\n            {\n              ...strip.tabs[i],\n              fetchTabStatus: 'done',\n              ...(splitData.find(itmInner => {\n                if (strip.tabs && strip.tabs[i] && itmInner.value === strip.tabs[i].value) {\n                  return itmInner;\n                }\n                return undefined;\n              })),\n            }\n          );\n        }\n      }\n    }\n    return tabResults;\n  }\n\n  getTabsList(array: NsContent.IContent[],\n    strip: NsContentStripWithTabs.IContentStripUnit) {\n    let all: any[] = [];\n    let upcoming: any[] = [];\n    let overdue: any[] = [];\n    array.forEach((e: any) => {\n      all.push(e);\n      if (e.planDuration === NsCardContent.ACBPConst.OVERDUE) {\n        overdue.push(e);\n      } else if (e.planDuration === NsCardContent.ACBPConst.UPCOMING) {\n        upcoming.push(e);\n      }\n    });\n    const allCompleted = all.filter((allData: any) => allData.contentStatus === 2);\n    let allInCompleted = all.filter((allData: any) => allData.contentStatus < 2);\n\n    let allCompletedOverDue = allCompleted.filter((allData: any) => allData.planDuration === NsCardContent.ACBPConst.OVERDUE);\n    const allCompletedAll = allCompleted.filter((allData: any) => allData.planDuration !== NsCardContent.ACBPConst.OVERDUE);\n\n    allCompletedOverDue = allCompletedOverDue.sort((a: any, b: any): any => {\n      if (a.planDuration === NsCardContent.ACBPConst.OVERDUE && b.planDuration === NsCardContent.ACBPConst.OVERDUE) {\n        const firstDate: any = new Date(a.endDate);\n        const secondDate: any = new Date(b.endDate);\n        return firstDate > secondDate ? -1 : 1;\n      }\n    });\n\n    allInCompleted = allInCompleted.sort((a: any, b: any): any => {\n      if (a.planDuration === NsCardContent.ACBPConst.OVERDUE && b.planDuration === NsCardContent.ACBPConst.OVERDUE) {\n        const firstDate: any = new Date(a.endDate);\n        const secondDate: any = new Date(b.endDate);\n        return firstDate > secondDate ? -1 : 1;\n      }\n    });\n\n    all = [...allInCompleted, ...allCompletedAll, ...allCompletedOverDue];\n\n    overdue = overdue.filter((data: any): any => {\n      return data.contentStatus < 2;\n    });\n\n    overdue = overdue.sort((a: any, b: any): any => {\n      const firstDate: any = new Date(a.endDate);\n      const secondDate: any = new Date(b.endDate);\n      return firstDate > secondDate ? -1 : 1;\n    });\n\n    upcoming = upcoming.filter((data: any): any => {\n      return data.contentStatus < 2;\n    });\n    // this.getSelectedIndex(1)\n    return [\n      { value: 'all', widgets: this.transformContentsToWidgets(all, strip) },\n      { value: 'upcoming', widgets: this.transformContentsToWidgets(upcoming, strip) },\n      { value: 'overdue', widgets: this.transformContentsToWidgets(overdue, strip) }];\n  }\n\n  getSelectedIndex(stripsResultDataMap: any, key: any): number {\n    let returnValue = 0;\n    if (key === 'cbpPlan') {\n      if (stripsResultDataMap.tabs.length) {\n        const data = stripsResultDataMap.tabs.filter((ele: any) => ele.value === 'upcoming');\n        returnValue = data[0].widgets && data[0].widgets.length > 0 ? 1 : 0;\n      }\n    }\n    return returnValue;\n  }\n\n  translateLabels(label: string, type: any) {\n    return this.langtranslations.translateLabel(label, type, '');\n  }\n\n  identify(index: number, item: any) {\n    if (index >= 0) { }\n    return item;\n  }\n  tracker(index: number, item: any) {\n    if (index >= 0) { }\n    return _.get(item, 'widgetData.content.identifier')\n  }\n\n  async fetchAllTopContent(strip: NsContentStripWithTabs.IContentStripUnit, calculateParentStatus = true) {\n    if (strip.request && strip.request.topContent && Object.keys(strip.request.topContent).length) {\n      let originalFilters: any = [];\n      if (strip.request &&\n        strip.request.topContent &&\n        strip.request.topContent.request &&\n        strip.request.topContent.request.filters) {\n        originalFilters = strip.request.topContent.request.filters;\n        strip.request.topContent.request.filters = this.postMethodFilters(strip.request.topContent.request.filters);\n      }\n      if (strip.tabs && strip.tabs.length) {\n        // TODO: Have to extract requestRequired to outer level of tabs config\n        const firstTab = strip.tabs[0];\n        if (firstTab.requestRequired) {\n          if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n            const allTabs = this.stripsResultDataMap[strip.key].tabs;\n            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]) as NsContentStripWithTabs.IContentStripTab;\n\n            this.getTabDataByNewReqTopContent(strip, 0, currentTabFromMap, calculateParentStatus);\n          }\n        }\n\n      } else {\n        try {\n          const response = await this.postRequestMethod(strip, strip.request.topContent, strip.request.apiUrl, calculateParentStatus);\n          // console.log('calling  after - response, ', response)\n          if (response && response.results) {\n            // console.log('calling  after-- ')\n            if (response.results.result.content && response.results.result.content.length) {\n              this.processStrip(\n                strip,\n                this.transformContentsToWidgets(response.results.result.content, strip),\n                'done',\n                calculateParentStatus,\n                response.viewMoreUrl,\n              );\n            } else {\n              this.processStrip(strip, [], 'error', calculateParentStatus, null);\n              this.emptyResponse.emit(true)\n            }\n\n          } else {\n            this.processStrip(strip, [], 'error', calculateParentStatus, null);\n            this.emptyResponse.emit(true)\n          }\n        } catch (error) {\n          // Handle errors\n          // console.error('Error:', error);\n        }\n      }\n    }\n  }\n\n  async fetchAllFeaturedContent(strip: NsContentStripWithTabs.IContentStripUnit, calculateParentStatus = true) {\n    if (strip.request && strip.request.featureContent && Object.keys(strip.request.featureContent).length) {\n      let originalFilters: any = [];\n      if (strip.request &&\n        strip.request.featureContent &&\n        strip.request.featureContent.request &&\n        strip.request.featureContent.request.filters) {\n        originalFilters = strip.request.featureContent.request.filters;\n        strip.request.featureContent.request.filters = this.postMethodFilters(strip.request.featureContent.request.filters);\n      }\n      try {\n        const response = await this.postRequestMethod(strip, strip.request.featureContent, strip.request.apiUrl, calculateParentStatus);\n        // console.log('calling  after - response, ', response)\n        if (response && response.results) {\n          // console.log('calling  after-- ')\n          if (response.results.result.content && response.results.result.content.length) {\n            this.processStrip(\n              strip,\n              this.transformContentsToWidgets(response.results.result.content, strip),\n              'done',\n              calculateParentStatus,\n              response.viewMoreUrl,\n            );\n          } else {\n            this.processStrip(strip, [], 'error', calculateParentStatus, null);\n            this.emptyResponse.emit(true)\n          }\n\n        } else {\n          this.processStrip(strip, [], 'error', calculateParentStatus, null);\n          this.emptyResponse.emit(true)\n        }\n      } catch (error) {\n        this.emptyResponse.emit(true)\n        // Handle errors\n        // console.error('Error:', error);\n      }\n    }\n  }\n\n\n  async getTabDataByNewReqTopContent(\n    strip: NsContentStripWithTabs.IContentStripUnit,\n    tabIndex: number,\n    currentTab: NsContentStripWithTabs.IContentStripTab,\n    calculateParentStatus: boolean\n  ) {\n    if (currentTab.request &&\n      currentTab.request.topContent &&\n      currentTab.request.topContent.request &&\n      currentTab.request.topContent.request.filters) {\n        currentTab.request.topContent.request.filters = this.postMethodFilters(currentTab.request.topContent.request.filters);\n    }\n    try {\n      // const response = await this.searchV6Request(strip, currentTab.request, calculateParentStatus);\n      const response = await this.postRequestMethod(strip, currentTab.request.topContent, currentTab.request.apiUrl, calculateParentStatus);\n      if (response.results && response.results.result) {\n        const widgets = this.transformContentsToWidgets(response.results.result.content, strip);\n        let tabResults: any[] = [];\n        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n          const allTabs = this.stripsResultDataMap[strip.key].tabs;\n          if (allTabs && allTabs.length && allTabs[tabIndex]) {\n            allTabs[tabIndex] = {\n              ...allTabs[tabIndex],\n              widgets,\n              fetchTabStatus: 'done',\n            };\n            tabResults = allTabs;\n          }\n        }\n        this.processStrip(\n          strip,\n          widgets,\n          'done',\n          calculateParentStatus,\n          response.viewMoreUrl,\n          tabResults // tabResults as widgets\n        );\n      } else {\n        this.processStrip(strip, [], 'error', calculateParentStatus, null);\n      }\n    } catch (error) {\n      // Handle errors\n      // console.error('Error:', error);\n    }\n  }\n\n  raiseTelemetry(stripData: any) {\n    this.telemtryResponse.emit(stripData)\n  }\n\n  async postRequestMethod(strip: NsContentStripWithTabs.IContentStripUnit,\n    request: NsContentStripWithTabs.IContentStripUnit['request'],\n    apiUrl: string,\n    calculateParentStatus: boolean\n  ): Promise<any> {\n    return new Promise<any>((resolve, reject) => {\n      if (request && request) {\n        this.contentSvc.postApiMethod(apiUrl, request).subscribe(results => {\n          if (results.result && results.result.content) {\n            const showViewMore = Boolean(\n              results.result.content && results.result.content.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch,\n            );\n            const viewMoreUrl = showViewMore\n              ? {\n                path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',\n                queryParams: {\n                  tab: 'Learn',\n                  q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,\n                  f: {},\n                },\n              }\n              : null;\n            resolve({ results, viewMoreUrl });\n          } else if (results && results.data) {\n            const showViewMore = Boolean(\n              results.data && results.data.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch,\n            );\n            const viewMoreUrl = showViewMore ? {\n              path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',\n              queryParams: {\n                tab: 'Learn',\n                q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,\n                f: {},\n              },\n            }\n              : null;\n            resolve({ results, viewMoreUrl });\n          } else if (results.result && results.result.data) {\n            const showViewMore = Boolean(\n              results.data && results.result.data && results.result.data.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch,\n            );\n            const viewMoreUrl = showViewMore ? {\n              path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',\n              queryParams: {\n                tab: 'Learn',\n                q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,\n                f: {},\n              },\n            }\n              : null;\n            resolve({ results, viewMoreUrl });\n          }\n\n        }, (error: any) => {\n          this.processStrip(strip, [], 'error', calculateParentStatus, null);\n          reject(error);\n        },\n        );\n      }\n    });\n  }\n\n  async getRequestMethod(strip: NsContentStripWithTabs.IContentStripUnit,\n    request: NsContentStripWithTabs.IContentStripUnit['request'],\n    apiUrl: string,\n    calculateParentStatus: boolean\n  ): Promise<any> {\n    const originalFilters: any = [];\n    return new Promise<any>((resolve, reject) => {\n      if (request && request) {\n        this.contentSvc.getApiMethod(apiUrl).subscribe(results => {\n        let showViewMore: any\n        if(results.result.data){\n            showViewMore = Boolean(\n              results.result.data && results.result.data.orgList.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch,\n              );\n        } else if(results.result.content){\n          let featuredProvider = JSON.parse(results.result.content.featuredProviders || '[]')\n          showViewMore = Boolean(\n            featuredProvider && featuredProvider.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch,\n            );\n        }\n        const viewMoreUrl = showViewMore\n        ? {\n        path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',\n        }\n        : null;\n        resolve({ results, viewMoreUrl });\n        },                                                   (error: any) => {\n        this.processStrip(strip, [], 'error', calculateParentStatus, null);\n        reject(error);\n        },\n        );\n      }\n    });\n  }\n\n  postMethodFilters(filters: any) {\n    if (filters.organisation &&\n      filters.organisation.indexOf('<orgID>') >= 0\n    ) {\n      filters.organisation = filters.organisation.replace('<orgID>', this.providerId)\n    }\n    return filters\n  }\n  getFullUrl(apiUrl: any, id: string) {\n    let formedUrl: string = apiUrl\n    if (apiUrl.indexOf('<bookmarkId>') >= 0) {\n      formedUrl = apiUrl.replace('<bookmarkId>', this.environment.mdoChannelsBookmarkId)\n    } else if (apiUrl.indexOf('<playlistKey>') >= 0 && apiUrl.indexOf('<orgID>') >= 0) {\n      formedUrl = apiUrl.replace('<playlistKey>', this.providerId + id) \n      formedUrl = formedUrl.replace('<orgID>', this.providerId) \n    } else if(apiUrl.indexOf('<doId>') >= 0) {\n      formedUrl = apiUrl.replace('<doId>', this.environment.providerDataKey) \n    } \n    return formedUrl\n  }\n\n  redirectViewAll(stripData: any, path: string, queryParamsData: any) {\n    if (this.emitViewAll) {\n      this.viewAllResponse.emit(stripData)\n    } else {\n      this.router.navigate([path], { queryParams: queryParamsData })\n    }\n  }\n\n  async fetchAllBookMarkData(strip: NsContentStripWithTabs.IContentStripUnit, calculateParentStatus = true) {\n    if (strip.request && strip.request.bookmarkRead && Object.keys(strip.request.bookmarkRead).length) {\n      let originalFilters: any = [];\n      if (strip.request &&\n        strip.request.bookmarkRead &&\n        strip.request.bookmarkRead.bookmarkId) {\n        strip.request.apiUrl = this.getFullUrl(strip.request.apiUrl, strip.request.bookmarkRead.bookmarkId);\n      }\n      try {\n        const response = await this.getRequestMethod(strip, strip.request.bookmarkRead, strip.request.apiUrl, calculateParentStatus);\n        let content = response.results.result.data.orgList\n        if (response) {\n          this.processStrip(\n            strip,\n            this.transformAllContentsToWidgets(content, strip),\n            'done',\n            calculateParentStatus,\n            response,\n          );\n\n        } else {\n          this.processStrip(strip, [], 'error', calculateParentStatus, null);\n          this.emptyResponse.emit(true)\n        }\n      } catch (error) {\n        this.emptyResponse.emit(true)\n        // Handle errors\n        // console.error('Error:', error);\n      }\n    }\n  }\n\n  private transformAllContentsToWidgets(\n    contents: any,\n    strip: NsContentStripWithTabs.IContentStripUnit,\n  ) {\n    return (contents || []).map((content, idx) => (\n      content ? {\n        widgetType: 'cardLib',\n        widgetSubType: 'cardContentLib',\n        widgetHostClass: 'mb-2',\n        widgetData: {\n          content,\n          ...(content.batch && { batch: content.batch }),\n          cardSubType: strip.stripConfig && strip.stripConfig.cardSubType,\n          cardCustomeClass: strip.customeClass ? strip.customeClass : '',\n          context: { pageSection: strip.key, position: idx },\n          intranetMode: strip.stripConfig && strip.stripConfig.intranetMode,\n          deletedMode: strip.stripConfig && strip.stripConfig.deletedMode,\n          contentTags: strip.stripConfig && strip.stripConfig.contentTags,\n        },\n      } : {\n        widgetType: 'card',\n        widgetSubType: 'cardContent',\n        widgetHostClass: 'mb-2',\n        widgetData: {},\n      }\n    ));\n  }\n\n  private transformAllTabContentsToWidgets(\n    contents: any,\n    currentTab: NsContentStripWithTabs.IContentStripTab,\n  ) {\n    return (contents || []).map((content, idx) => (\n      content ? {\n        widgetType: 'cardLib',\n        widgetSubType: 'cardContentLib',\n        widgetHostClass: 'mb-2',\n        widgetData: {\n          content,\n          ...(content.batch && { batch: content.batch }),\n          cardSubType: currentTab.stripConfig && currentTab.stripConfig.cardSubType,\n          cardCustomeClass: currentTab.customeClass ? currentTab.customeClass : '',\n          context: { pageSection: currentTab.value, position: idx },\n          intranetMode: currentTab.stripConfig && currentTab.stripConfig.intranetMode,\n          deletedMode: currentTab.stripConfig && currentTab.stripConfig.deletedMode,\n          contentTags: currentTab.stripConfig && currentTab.stripConfig.contentTags,\n        },\n      } : {\n        widgetType: 'card',\n        widgetSubType: 'cardContent',\n        widgetHostClass: 'mb-2',\n        widgetData: {},\n      }\n    ));\n  }\n\n  async fetchAllPlaylistSearch(strip: NsContentStripWithTabs.IContentStripUnit, calculateParentStatus = true) {\n    if (strip.request && strip.request.playlistSearch && Object.keys(strip.request.playlistSearch).length) {\n      let originalFilters: any = [];\n      if (strip.request &&\n        strip.request.playlistSearch &&\n        strip.request.playlistSearch.request &&\n        strip.request.playlistSearch.request.filters) {\n        originalFilters = strip.request.playlistSearch.request.filters;\n        strip.request.playlistSearch.request.filters = this.postMethodFilters(strip.request.playlistSearch.request.filters);\n      }\n      try {\n        const response = await this.postRequestMethod(strip, strip.request.playlistSearch.request, strip.request.apiUrl, calculateParentStatus);\n        // console.log('calling  after - response, ', response)\n        if (response && response.results) {\n          // console.log('calling  after-- ')\n          if (response.results.result.data && response.results.result.data.length) {\n            let finalPlaylistData: any = []\n            let programData: any = response.results.result.data\n            programData.forEach((prgData: any) => {\n              if (prgData.children && prgData.children.length) {\n                finalPlaylistData.push(prgData)\n              }\n            })\n            if (finalPlaylistData.length) {\n              this.processStrip(\n                strip,\n                this.transformContentsToWidgets(finalPlaylistData, strip),\n                'done',\n                calculateParentStatus,\n                response.viewMoreUrl,\n              );\n            } else {\n              this.emptyResponse.emit(true)\n            }\n          } else {\n            this.processStrip(strip, [], 'error', calculateParentStatus, null);\n            this.emptyResponse.emit(true)\n          }\n\n        } else {\n          this.processStrip(strip, [], 'error', calculateParentStatus, null);\n          this.emptyResponse.emit(true)\n        }\n      } catch (error) {\n        this.emptyResponse.emit(true)\n        // Handle errors\n        // console.error('Error:', error);\n      }\n    }\n  }\n\n  async fetchPlaylistReadData(strip: NsContentStripWithTabs.IContentStripUnit, calculateParentStatus = true) {\n    if (strip.request && strip.request.playlistRead && Object.keys(strip.request.playlistRead).length) {\n      let originalFilters: any = [];\n      if (strip.request &&\n        strip.request.playlistRead &&\n        strip.request.playlistRead.type) {\n        strip.request.apiUrl = this.getFullUrl(strip.request.apiUrl, strip.request.playlistRead.type);\n      }\n      if (strip.tabs && strip.tabs.length) {\n        // TODO: Have to extract requestRequired to outer level of tabs config\n        const firstTab = strip.tabs[0];\n        if (firstTab.requestRequired) {\n          if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n            const allTabs = this.stripsResultDataMap[strip.key].tabs;\n            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]) as NsContentStripWithTabs.IContentStripTab;\n\n            this.getTabDataByNewReqPlaylistReadContent(strip, 0, currentTabFromMap, calculateParentStatus);\n          }\n        }\n\n      } else {\n        try {\n          const response = await this.getRequestMethod(strip, strip.request.playlistRead, strip.request.apiUrl, calculateParentStatus);\n        \n          if (response && response.results.result.content) {  \n            let content  = response.results.result.content\n            if(strip.key === 'providers'){\n              let featuredProviders : any = JSON.parse(content.featuredProviders|| '[]')\n              this.processStrip(\n                strip,\n                this.transformAllContentsToWidgets(featuredProviders, strip),\n                'done',\n                calculateParentStatus,\n                response,\n              );\n            } else {\n              this.processStrip(\n                strip,\n                this.transformAllContentsToWidgets(content, strip),\n                'done',\n                calculateParentStatus,\n                response,\n              );\n            }\n          } else {\n            this.processStrip(strip, [], 'error', calculateParentStatus, null);\n            this.emptyResponse.emit(true)\n          }\n        } catch (error) {\n          this.emptyResponse.emit(true)\n          // Handle errors\n          // console.error('Error:', error);\n        }\n      }\n    }\n  }\n  async getTabDataByNewReqPlaylistReadContent(\n    strip: NsContentStripWithTabs.IContentStripUnit,\n    tabIndex: number,\n    currentTab: NsContentStripWithTabs.IContentStripTab,\n    calculateParentStatus: boolean\n  ) {\n    if (currentTab.request &&\n      currentTab.request.playlistRead &&\n      currentTab.request.playlistRead.type) {\n        currentTab.request.apiUrl = this.getFullUrl(currentTab.request.apiUrl, currentTab.request.playlistRead.type);\n    }\n    try {\n      const response = await this.getRequestMethod(strip, currentTab.request.playlistRead, currentTab.request.apiUrl, calculateParentStatus);\n      // if (response && response.results.result.content) {  \n      //   let content  = response.results.result.content\n      //   if(strip.key === 'providers'){\n      //     let featuredProviders : any = JSON.parse(content.featuredProviders|| '[]')\n      //     this.processStrip(\n      //       strip,\n      //       this.transformAllContentsToWidgets(featuredProviders, strip),\n      //       'done',\n      //       calculateParentStatus,\n      //       response,\n      //     );\n      //   } else {\n      //     this.processStrip(\n      //       strip,\n      //       this.transformAllContentsToWidgets(content, strip),\n      //       'done',\n      //       calculateParentStatus,\n      //       response,\n      //     );\n      //   }\n      // } else {\n      //   this.processStrip(strip, [], 'error', calculateParentStatus, null);\n      //   this.emptyResponse.emit(true)\n      // }\n      if (response.results && response.results.result) {\n        let content  = response.results.result.content\n        let widgets = []\n        if(currentTab.value === 'providers'){\n          let featuredProviders : any = JSON.parse(content.featuredProviders|| '[]')\n          widgets = this.transformAllTabContentsToWidgets(featuredProviders, currentTab)\n        } else {\n          widgets = this.transformAllTabContentsToWidgets(content, currentTab)\n        }\n        let tabResults: any[] = [];\n        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n          const allTabs = this.stripsResultDataMap[strip.key].tabs;\n          if (allTabs && allTabs.length && allTabs[tabIndex]) {\n            allTabs[tabIndex] = {\n              ...allTabs[tabIndex],\n              widgets,\n              fetchTabStatus: 'done',\n            };\n            tabResults = allTabs;\n          }\n        }\n        this.processStrip(\n          strip,\n          widgets,\n          'done',\n          calculateParentStatus,\n          response.viewMoreUrl,\n          tabResults // tabResults as widgets\n        );\n      } else {\n        let tabResults: any[] = [];\n        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n          const allTabs = this.stripsResultDataMap[strip.key].tabs;\n          if (allTabs && allTabs.length && allTabs[tabIndex]) {\n            allTabs[tabIndex] = {\n              ...allTabs[tabIndex],\n              fetchTabStatus: 'done',\n            };\n            tabResults = allTabs;\n          }\n        }\n        this.processStrip(strip, [], 'error', calculateParentStatus, null, tabResults);\n      }\n    } catch (error) {\n      console.error('Error:', error)\n      let tabResults: any[] = [];\n        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs && this.stripsResultDataMap[strip.key].tabs.length) {\n          const allTabs = this.stripsResultDataMap[strip.key].tabs;\n          if (allTabs && allTabs.length && allTabs[tabIndex]) {\n            allTabs[tabIndex] = {\n              ...allTabs[tabIndex],\n              fetchTabStatus: 'done',\n            };\n            tabResults = allTabs;\n          }\n          this.processStrip(strip, [], 'error', calculateParentStatus, null, tabResults)\n        } else {\n          this.processStrip(strip, [], 'error', calculateParentStatus, null);\n        }\n    }\n  }\n\n  async fetchCiosContentData(strip: NsContentStripWithTabs.IContentStripUnit, calculateParentStatus = true) {\n    if (strip && strip.request.ciosContent && Object.keys(strip.request.ciosContent).length) {\n      if (strip.tabs && strip.tabs.length) {\n        // TODO: Have to extract requestRequired to outer level of tabs config\n        const firstTab = strip.tabs[0];\n        if (firstTab.requestRequired && firstTab.value === 'extCourse') {\n          if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n            const allTabs = this.stripsResultDataMap[strip.key].tabs;\n            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]) as NsContentStripWithTabs.IContentStripTab;\n            this.getTabDataByCiosSearch(strip, 0, currentTabFromMap, calculateParentStatus);\n          }\n        }\n        if (firstTab.requestRequired && firstTab.value === 'providers') {\n          if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n            const allTabs = this.stripsResultDataMap[strip.key].tabs;\n            const currentTabFromMap = (allTabs && allTabs.length && allTabs[0]) as NsContentStripWithTabs.IContentStripTab;\n            this.getTabDataByNewReqPlaylistReadContent(strip, 0, currentTabFromMap, calculateParentStatus);\n          }\n        }\n      } else {\n        try {\n          const response = await this.postRequestMethod(strip, strip.request.ciosContent, strip.request.apiUrl, calculateParentStatus);\n          // console.log('calling  after - response, ', response)\n          if (response && response.results) {\n            // console.log('calling  after-- ')\n            if (response.results.data && response.results.data.length) {\n              let extContentData: any = response.results.data\n              if (extContentData.length) {\n                this.processStrip(\n                  strip,\n                  this.transformContentsToWidgets(extContentData, strip),\n                  'done',\n                  calculateParentStatus,\n                  response.viewMoreUrl,\n                );\n              } else {\n                this.emptyResponse.emit(true)\n              }\n            } else {\n              this.processStrip(strip, [], 'error', calculateParentStatus, null);\n              this.emptyResponse.emit(true)\n            }\n  \n          } else {\n            this.processStrip(strip, [], 'error', calculateParentStatus, null);\n            this.emptyResponse.emit(true)\n          }\n        } catch (error) {\n          this.emptyResponse.emit(true)\n          // Handle errors\n          // console.error('Error:', error);\n        }\n      }\n    }\n  }\n\n  async getTabDataByCiosSearch(\n    strip: NsContentStripWithTabs.IContentStripUnit,\n    tabIndex: number,\n    _currentTab: NsContentStripWithTabs.IContentStripTab,\n    calculateParentStatus: boolean\n  ) {\n    try {\n      const response = await this.contentSvc.postApiMethod(strip.request.apiUrl,strip.request.ciosContent).toPromise();;\n      if (response && response.data && response.data.length) {\n        const widgets = this.transformContentsToWidgets(response.data, strip);\n        let tabResults: any[] = [];\n        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n          const allTabs = this.stripsResultDataMap[strip.key].tabs;\n          if (allTabs && allTabs.length && allTabs[tabIndex]) {\n            allTabs[tabIndex] = {\n              ...allTabs[tabIndex],\n              widgets,\n              fetchTabStatus: 'done',\n            };\n            tabResults = allTabs;\n          }\n        }\n        this.processStrip(\n          strip,\n          widgets,\n          'done',\n          calculateParentStatus,\n          response.viewMoreUrl,\n          tabResults // tabResults as widgets\n        );\n      } else {\n        let tabResults: any[] = [];\n        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {\n          const allTabs = this.stripsResultDataMap[strip.key].tabs;\n          if (allTabs && allTabs.length && allTabs[tabIndex]) {\n            allTabs[tabIndex] = {\n              ...allTabs[tabIndex],\n              fetchTabStatus: 'done',\n            };\n            tabResults = allTabs;\n          }\n        }\n        this.processStrip(strip, [], 'error', calculateParentStatus, null, tabResults);\n      }\n    } catch (error) {\n      console.error('Error:', error)\n      let tabResults: any[] = [];\n        if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs && this.stripsResultDataMap[strip.key].tabs.length) {\n          const allTabs = this.stripsResultDataMap[strip.key].tabs;\n          if (allTabs && allTabs.length && allTabs[tabIndex]) {\n            allTabs[tabIndex] = {\n              ...allTabs[tabIndex],\n              fetchTabStatus: 'done',\n            };\n            tabResults = allTabs;\n          }\n          this.processStrip(strip, [], 'error', calculateParentStatus, null, tabResults)\n        } else {\n          this.processStrip(strip, [], 'error', calculateParentStatus, null);\n        }\n    }\n  }\n\n}\n","<ng-container *ngIf=\"!contentAvailable; else otherTemplate\"></ng-container>\n<ng-template #otherTemplate>\n  <!-- <div *ngIf=\"showParentLoader\" class=\"text-center my-2\">\n    <mat-spinner class=\"inline-block\"></mat-spinner>\n  </div> -->\n  <ng-container *ngIf=\"showParentError\" [sbUiResolverWidget]=\"widgetData.errorWidget\"></ng-container>\n  <ng-container *ngIf=\"showParentNoData\" [sbUiResolverWidget]=\"widgetData.noDataWidget\"></ng-container>\n  <ng-container *ngFor=\"let key of stripsKeyOrder; let i = index; trackBy: identify\">\n    <ng-container *ngIf=\"isStripShowing(stripsResultDataMap[key])\">\n      <a name=\"{{stripsResultDataMap[key]?.stripTitle}}\" [class]=\"key\">\n        <div *ngIf=\"stripsResultDataMap && (getLength(stripsResultDataMap[key]) ||\n                    stripsResultDataMap[key]?.showOnNoData ||\n                    stripsResultDataMap[key]?.showOnLoader ||\n                    stripsResultDataMap[key]?.showOnError)\n                  \" [ngClass]=\"\n                    !widgetData?.isChannelStrip ? 'xs:px-8 sx:px-10ss' : i > 0 ? 'mt-12' : ''\n                  \" [id]=\"key\" [ngClass]=\"!widgetData?.isChannelStrip ? 'margin-bottom-custom' : 'margin-bottom-xs'\">\n          <div [ngClass]=\"{ pad: stripsResultDataMap[key]?.stripBackground }\"\n            [ngStyle]=\"{ 'background-color': stripsResultDataMap[key]?.stripBackground }\">\n            <div class=\"flex flex-col pl-4 pr-4 md:pr-0 md:pl-0 min-height-40 \" [ngClass]=\"\n                        !widgetData?.isChannelStrip\n                          ? ''\n                          : stripsResultDataMap[key]?.stripTitle\n                          ? 'mb-8'\n                          : ''\n                      \">\n              <div class=\"flex flex-1 items-center\">\n                <p class=\"mat-subheading-1 margin-remove inline-block \" *ngIf=\"stripsResultDataMap[key]?.stripTitle\">\n                  <span class=\"capitalize\" *ngIf=\"stripsResultDataMap[key]?.disableTranslate\">\n                    {{stripsResultDataMap[key]?.stripTitle}}\n                  </span>\n                  <span *ngIf=\"!stripsResultDataMap[key]?.disableTranslate\">\n                    {{ translateLabels(stripsResultDataMap[key]?.stripTitle, 'home') }}\n                  </span>\n                </p>\n\n                <button *ngIf=\"stripsResultDataMap[key]?.stripInfo?.icon\" type=\"button\" mat-icon-button\n                  (click)=\"toggleInfo(stripsResultDataMap[key])\" i18n-matTooltip matTooltip=\"info\"\n                  class=\"margin-left-xs\">\n                  <mat-icon>{{ stripsResultDataMap[key]?.stripInfo?.icon.icon }}</mat-icon>\n                </button>\n                <a *ngIf=\"stripsResultDataMap[key]?.stripTitleLink?.link\"\n                  [routerLink]=\"stripsResultDataMap[key]?.stripTitleLink?.link\"\n                  [queryParams]=\"stripsResultDataMap[key]?.stripTitleLink?.link?.queryParams\">\n                  <mat-icon class=\"ws-mat-primary-primary-text ws-mat-default-text\" [color]=\"'accent'\">{{\n                    stripsResultDataMap[key]?.stripTitleLink?.icon }}</mat-icon>\n                </a>\n                <span class=\"spacer\"></span>\n                <!-- viewAll start-->\n                <div *ngIf=\"checkCondition(widgetData , stripsResultDataMap[key])\"\n                  class=\"ml-4 pl-2 view-more ws-mat-default-text\">\n                  <a class=\"flex ws-mat-default-text items-center justify-center mat-body-1 cursor-pointer\" \n                    (click)=\"raiseTelemetry(stripsResultDataMap[key]);redirectViewAll(stripsResultDataMap[key], stripsResultDataMap[key]?.viewMoreUrl?.path, stripsResultDataMap[key]?.viewMoreUrl?.queryParams )\">\n                    <span i18n class=\"ws-mat-default-text\">{{translateLabels(widgetData.strips[0].viewMoreUrl.viewMoreText,'home')  || 'See all'}}</span>\n                    <mat-icon class=\"ws-mat-default-text mat-icon notranslate material-icons mat-icon-no-color\" color=\"accent\">navigate_next</mat-icon>\n                  </a>\n                </div>\n                <!-- viewAll end-->\n              </div>\n              <button mat-icon-button (click)=\"setHiddenForStrip(key)\" *ngIf=\"stripsResultDataMap[key]?.canHideStrip\">\n                <mat-icon>close</mat-icon>\n              </button>\n              <mat-icon class=\"cursor-pointer\" *ngIf=\"stripsResultDataMap[key]?.mode === 'accordion' && isMobile\"\n                (click)=\"showAccordionData = !showAccordionData\">{{ showAccordionData ? 'expand_less' : 'expand_more' }}\n              </mat-icon>\n            </div>\n\n            <div class=\"mb-4\" *ngIf=\"checkVisible(stripsResultDataMap[key])\">\n              <ng-container [sbUiResolverWidget]=\"getdata(stripsResultDataMap[key])\">\n              </ng-container>\n            </div>\n\n            <ng-container *ngIf=\"stripsResultDataMap[key]?.showOnNoData\"\n              [sbUiResolverWidget]=\"stripsResultDataMap[key]?.noDataWidget\"></ng-container>\n            <ng-container *ngIf=\"stripsResultDataMap[key]?.showOnError\"\n              [sbUiResolverWidget]=\"stripsResultDataMap[key]?.errorWidget\"></ng-container>\n            <!-- IF no errors then proceed to show tabs or non tabs strip -->\n            <ng-container *ngIf=\"!stripsResultDataMap[key]?.showOnNoData && !stripsResultDataMap[key]?.showOnError\">\n              <ng-container *ngIf=\"stripsResultDataMap[key].tabs && stripsResultDataMap[key].tabs.length\">\n                <mat-tab-group  animationDuration=\"0ms\" [selectedIndex]=\"getSelectedIndex(stripsResultDataMap[key], key)\"\n                class=\"mat-tab-labels w-full strips-tabgroup  \" dynamicHeight\n                [ngClass]=\"stripsResultDataMap[key]?.tabsType ? stripsResultDataMap[key]?.tabsType : ''\"\n                  (selectedTabChange)=\"tabClicked($event, stripsResultDataMap[key], key)\">\n                  <mat-tab label=\"{{tab?.label}}\" *ngFor=\"let tab of stripsResultDataMap[key].tabs; let last = last;\">\n                    <ng-template mat-tab-label>\n                      <span>{{ translateLabels(tab?.label, 'home') }} &nbsp;</span>\n                      <span *ngIf=\"tab?.showTabDataCount && tab?.widgets?.length\">({{tab?.widgets?.length}})</span>\n                    </ng-template>\n                    <div>\n                      <!-- <ng-container [ngTemplateOutlet]=\"loader\" *ngIf=\"stripsResultDataMap[key]?.showOnLoader\">\n                      </ng-container> -->\n                      <div *ngIf=\"stripsResultDataMap && stripsResultDataMap[key]?.showOnLoader ||\n                      !tab.fetchTabStatus\"\n                      class=\"text-center my-2\">\n                            <sb-uic-horizontal-scroller-v2 [sliderConfig]=\"stripsResultDataMap[key]?.sliderConfig\" [id]=\"key+'-scroller'\"\n                                    [loadStatus]=\"'fetching'\" [stripConfig]=\"stripsResultDataMap[key]?.stripConfig\">\n                              <ng-container *ngFor=\"let widget of stripsResultDataMap[key]?.loaderWidgets; trackBy: tracker\">\n                                <ng-container [sbUiResolverWidget]=\"widget\"></ng-container>\n                              </ng-container>\n                            </sb-uic-horizontal-scroller-v2>\n                      </div>\n                      <div *ngIf=\"((tab?.fetchTabStatus && tab?.fetchTabStatus === 'done') &&\n                      (!tab?.widgets || !tab?.widgets?.length))\">\n                      <ng-container *ngIf=\"tab?.value === 'inprogress'; else msgTemp\">\n                        <div class=\"w-full flex flex-col items-center justify-center\">\n                          <img alt=\"\" class=\"mt-4 mb-4\" src=\"assets/icons/home/nodataDefault.svg\">\n                          <div class=\"mat-subheading-1 text-center info-content\">{{ 'contentstripmultiple.getReadyForLearningAdventure' | translate }} -\n                            <a class=\"click-here\" [routerLink]=\"'/page/learn'\">{{ 'contentstripmultiple.clickHere' | translate }}</a> {{ 'contentstripmultiple.toEnrollNextCourse' | translate }}</div>\n                        </div>\n                      </ng-container>\n                      <ng-template #msgTemp>\n                        <div class=\"w-full flex flex-col items-center justify-center\">\n                          <img alt=\"\" class=\"mt-4 mb-4\" src=\"assets/icons/home/nodataDefault.png\">\n                          <div class=\"mat-subheading-1 text-center\">{{ translateLabels(tab.nodataMsg, 'home') }}</div>\n                        </div>\n                      </ng-template>\n                      </div>\n                      <ng-container *ngIf=\"(tab?.fetchTabStatus === 'done' || tab?.widgets?.length)\">\n                        <ng-container  *ngIf=\"!tab?.tabLoading\">\n\n                          <sb-uic-horizontal-scroller-v2 [id]=\"key+'-scroller'\" [sliderConfig]=\"stripsResultDataMap[key]?.sliderConfig\" [widgetsLength]=\"tab?.widgets?.length\"\n                            *ngIf=\"getContineuLearningLenth(stripsResultDataMap[key]) && showAccordion(key)\"\n                            [loadStatus]=\"'done'\" [defaultMaxWidgets]=\"tab?.maxWidgets ||\n                            stripsResultDataMap[key]?.sliderConfig?.maxWidgets || defaultMaxWidgets\" [stripConfig]=\"stripsResultDataMap[key]?.stripConfig\">\n                            <ng-container *ngFor=\"let widget of tab?.widgets| slice:0:(tab?.maxWidgets ||\n                            stripsResultDataMap[key]?.sliderConfig?.maxWidgets || defaultMaxWidgets); trackBy: tracker\">\n                                <ng-container [sbUiResolverWidget]=\"widget\"></ng-container>\n                            </ng-container>\n                          </sb-uic-horizontal-scroller-v2>\n                        </ng-container>\n                      </ng-container>\n                    </div>\n                  </mat-tab>\n                </mat-tab-group>\n              </ng-container>\n              <ng-container *ngIf=\"!stripsResultDataMap[key].tabs || !stripsResultDataMap[key].tabs.length\">\n                <div *ngIf=\"stripsResultDataMap && stripsResultDataMap[key]?.showOnLoader\" class=\"text-center my-2\">\n                      <sb-uic-horizontal-scroller-v2 [id]=\"key+'-scroller'\" [sliderConfig]=\"stripsResultDataMap[key]?.sliderConfig\"\n                              [loadStatus]=\"'fetching'\" [stripConfig]=\"stripsResultDataMap[key]?.stripConfig\">\n                        <ng-container *ngFor=\"let widget of stripsResultDataMap[key]?.loaderWidgets; trackBy: tracker\">\n                          <ng-container [sbUiResolverWidget]=\"widget\"></ng-container>\n                        </ng-container>\n                      </sb-uic-horizontal-scroller-v2>\n                </div>\n                <div class=\"\">\n                    <sb-uic-horizontal-scroller-v2 [id]=\"key+'-scroller'\" [sliderConfig]=\"stripsResultDataMap[key]?.sliderConfig\"\n                    *ngIf=\"getContineuLearningLenth(stripsResultDataMap[key]) && showAccordion(key)\" [widgetsLength]=\"stripsResultDataMap[key]?.widgets?.length\" [loadStatus]=\"'done'\" [defaultMaxWidgets]=\"stripsResultDataMap[key].sliderConfig?.maxWidgets || defaultMaxWidgets\" [stripConfig]=\"stripsResultDataMap[key]?.stripConfig\">\n                      <ng-container *ngFor=\"let widget of stripsResultDataMap[key]?.widgets| slice:0:(stripsResultDataMap[key].sliderConfig?.maxWidgets || defaultMaxWidgets); trackBy: tracker\">\n                      <!-- <ng-container *ngIf=\"widget.widgetData.context.pageSection === 'continueLearning' \"> -->\n                      <!-- <ng-container *ngIf=\"widget.widgetData.content.completionPercentage !== 100\"\n                        [sbUiResolverWidget]=\"widget\"></ng-container> -->\n                        <ng-container [sbUiResolverWidget]=\"widget\"></ng-container>\n                      <!-- </ng-container> -->\n                      </ng-container>\n                  </sb-uic-horizontal-scroller-v2>\n                </div>\n              </ng-container>\n            </ng-container>\n          </div>\n        </div>\n      </a>\n\n    </ng-container>\n  </ng-container>\n</ng-template>"]}