@sunbird-cb/consumption 0.0.85 → 0.0.87

package/esm5/lib/_common/strips/content-strip-facet-filter/content-strip-facet-filter.component.js

@@ -0,0 +1,1450 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Component, Input, HostBinding, Inject, EventEmitter, Output } from '@angular/core';
+import { WidgetBaseComponent } from '@sunbird-cb/resolver-v2';
+import { ApiRequestFor } from './content-strip-facet-filter.model';
+// import { HttpClient } from '@angular/common/http'
+import { WidgetContentService } from '../../../_services/widget-content.service';
+import { MultilingualTranslationsService } from '../../../_services/multilingual-translations.service';
+import { LoggerService, EventService, ConfigurationsService, UtilityService, WsEvents, } from '@sunbird-cb/utils-v2';
+import { filter } from 'rxjs/operators';
+import { WidgetUserService } from '../../../_services/widget-user.service';
+// import { environment } from 'src/environments/environment'
+// tslint:disable-next-line
+import * as _ from 'lodash';
+import { TranslateService } from '@ngx-translate/core';
+import { Router } from '@angular/router';
+import { FormBuilder } from '@angular/forms';
+/**
+ * @record
+ */
+function IStripUnitContentData() { }
+if (false) {
+    /** @type {?} */
+    IStripUnitContentData.prototype.key;
+    /** @type {?} */
+    IStripUnitContentData.prototype.canHideStrip;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.mode;
+    /** @type {?} */
+    IStripUnitContentData.prototype.showStrip;
+    /** @type {?} */
+    IStripUnitContentData.prototype.disableTranslate;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.widgets;
+    /** @type {?} */
+    IStripUnitContentData.prototype.stripTitle;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.hideViewMoreUrl;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.stripTitleLink;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.sliderConfig;
+    /** @type {?} */
+    IStripUnitContentData.prototype.stripConfig;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.tabs;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.stripName;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.stripLogo;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.description;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.stripInfo;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.noDataWidget;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.errorWidget;
+    /** @type {?} */
+    IStripUnitContentData.prototype.showOnNoData;
+    /** @type {?} */
+    IStripUnitContentData.prototype.showOnLoader;
+    /** @type {?} */
+    IStripUnitContentData.prototype.showOnError;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.loaderWidgets;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.stripBackground;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.secondaryHeading;
+    /** @type {?} */
+    IStripUnitContentData.prototype.viewMoreUrl;
+    /** @type {?|undefined} */
+    IStripUnitContentData.prototype.request;
+}
+var ContentStripFacetFilterComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(ContentStripFacetFilterComponent, _super);
+    function ContentStripFacetFilterComponent(environment, contentSvc, loggerSvc, eventSvc, configSvc, utilitySvc, router, userSvc, translate, langtranslations, _fb) {
+        var _this = _super.call(this) || this;
+        _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._fb = _fb;
+        _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');
+            /** @type {?} */
+            var lang = JSON.stringify(localStorage.getItem('websiteLanguage'));
+            lang = lang.replace(/\"/g, '');
+            _this.translate.use(lang);
+        }
+        _this.environment = environment;
+        return _this;
+    }
+    /**
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+    };
+    /**
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        this.initData();
+        this.contentSvc.telemetryData$.subscribe((/**
+         * @param {?} data
+         * @return {?}
+         */
+        function (data) {
+            _this.telemtryResponse.emit(data);
+        }));
+        this.facetForm = this._fb.group({
+            org: ['0']
+        });
+    };
+    /**
+     * @private
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.initData = /**
+     * @private
+     * @return {?}
+     */
+    function () {
+        var e_1, _a;
+        var _this = this;
+        this.stripsKeyOrder = this.widgetData && this.widgetData.strips && this.widgetData.strips.map((/**
+         * @param {?} strip
+         * @return {?}
+         */
+        function (strip) { return strip.key; })) || [];
+        if (this.widgetData.loader && this.widgetData.strips.length) {
+            this.showParentLoader = true;
+        }
+        try {
+            // Fetch the data
+            for (var _b = tslib_1.__values(this.widgetData.strips), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var strip = _c.value;
+                if (this.checkForEmptyWidget(strip)) {
+                    this.fetchStripFromRequestData(strip, false);
+                }
+                else {
+                    this.processStrip(strip, [], 'done', true, null);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        // Subscription for changes
+        /** @type {?} */
+        var keyAndEvent = this.widgetData.strips
+            .map((/**
+         * @param {?} strip
+         * @return {?}
+         */
+        function (strip) { return ({
+            key: strip.key,
+            type: (strip.refreshEvent && strip.refreshEvent.eventType) || '',
+            from: (strip.refreshEvent && strip.refreshEvent.from.toString()) || '',
+        }); }))
+            .filter((/**
+         * @param {?} __0
+         * @return {?}
+         */
+        function (_a) {
+            var key = _a.key, type = _a.type, from = _a.from;
+            return key && type && from;
+        }));
+        /** @type {?} */
+        var eventTypeSet = new Set(keyAndEvent.map((/**
+         * @param {?} e
+         * @return {?}
+         */
+        function (e) { return e.type; })));
+        this.changeEventSubscription = this.eventSvc.events$
+            .pipe(filter((/**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) { return eventTypeSet.has(event.eventType); })))
+            .subscribe((/**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) {
+            keyAndEvent
+                .filter((/**
+             * @param {?} e
+             * @return {?}
+             */
+            function (e) { return e.type === event.eventType && e.from === event.from; }))
+                .map((/**
+             * @param {?} e
+             * @return {?}
+             */
+            function (e) { return e.key; }))
+                .forEach((/**
+             * @param {?} k
+             * @return {?}
+             */
+            function (k) { return _this.fetchStripFromKey(k, false); }));
+        }));
+    };
+    /**
+     * @private
+     * @param {?} key
+     * @param {?=} calculateParentStatus
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.fetchStripFromKey = /**
+     * @private
+     * @param {?} key
+     * @param {?=} calculateParentStatus
+     * @return {?}
+     */
+    function (key, calculateParentStatus) {
+        if (calculateParentStatus === void 0) { calculateParentStatus = true; }
+        /** @type {?} */
+        var stripData = this.widgetData.strips.find((/**
+         * @param {?} strip
+         * @return {?}
+         */
+        function (strip) { return strip.key === key; }));
+        if (stripData) {
+            this.fetchStripFromRequestData(stripData, calculateParentStatus);
+        }
+    };
+    /**
+     * @private
+     * @param {?} strip
+     * @param {?=} calculateParentStatus
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.fetchStripFromRequestData = /**
+     * @private
+     * @param {?} strip
+     * @param {?=} calculateParentStatus
+     * @return {?}
+     */
+    function (strip, calculateParentStatus) {
+        if (calculateParentStatus === void 0) { calculateParentStatus = true; }
+        // setting initial values
+        strip.loaderWidgets = this.transformSkeletonToWidgets(strip);
+        this.processStrip(strip, [], 'fetching', false, null);
+        if (strip && strip.stripRequestFor === ApiRequestFor.SEARCH && !strip.onTabClickRequest) {
+            this.fetchFromSearch(strip, calculateParentStatus);
+        }
+    };
+    /**
+     * @private
+     * @param {?} strip
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.transformSkeletonToWidgets = /**
+     * @private
+     * @param {?} strip
+     * @return {?}
+     */
+    function (strip) {
+        return [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10].map((/**
+         * @param {?} _content
+         * @return {?}
+         */
+        function (_content) { return ({
+            widgetType: 'cardLib',
+            widgetSubType: 'cardContentLib',
+            widgetHostClass: 'mb-2',
+            widgetData: {
+                cardSubType: strip.loaderConfig && strip.loaderConfig.cardSubType || 'card-standard-skeleton',
+                cardCustomeClass: strip.customeClass ? strip.customeClass : '',
+            },
+        }); }));
+    };
+    /**
+     * @private
+     * @param {?} strip
+     * @param {?=} results
+     * @param {?=} fetchStatus
+     * @param {?=} calculateParentStatus
+     * @param {?=} _viewMoreUrl
+     * @param {?=} tabsResults
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.processStrip = /**
+     * @private
+     * @param {?} strip
+     * @param {?=} results
+     * @param {?=} fetchStatus
+     * @param {?=} calculateParentStatus
+     * @param {?=} _viewMoreUrl
+     * @param {?=} tabsResults
+     * @return {?}
+     */
+    function (strip, results, fetchStatus, calculateParentStatus, _viewMoreUrl, tabsResults) {
+        if (results === void 0) { results = []; }
+        if (calculateParentStatus === void 0) { calculateParentStatus = true; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var stripData;
+            var _a;
+            return tslib_1.__generator(this, function (_b) {
+                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,
+                    stripName: strip.name,
+                    mode: strip.mode,
+                    stripConfig: strip.stripConfig,
+                    stripBackground: strip.stripBackground,
+                    secondaryHeading: strip.secondaryHeading,
+                    loaderWidgets: strip.loaderWidgets || [],
+                    hideViewMoreUrl: strip.hideViewMoreUrl || false,
+                    widgets: fetchStatus === 'done'
+                        ? tslib_1.__spread((strip.preWidgets || []).map((/**
+                         * @param {?} w
+                         * @return {?}
+                         */
+                        function (w) { return (tslib_1.__assign({}, w, { widgetHostClass: "mb-2 " + w.widgetHostClass })); })), results, (strip.postWidgets || []).map((/**
+                         * @param {?} w
+                         * @return {?}
+                         */
+                        function (w) { return (tslib_1.__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 = tslib_1.__assign({}, this.stripsResultDataMap, (_a = {}, _a[strip.key] = stripData, _a));
+                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;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * @private
+     * @param {?} fetchStatus
+     * @param {?} stripWidgetsCount
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.checkParentStatus = /**
+     * @private
+     * @param {?} fetchStatus
+     * @param {?} stripWidgetsCount
+     * @return {?}
+     */
+    function (fetchStatus, stripWidgetsCount) {
+        if (fetchStatus === 'done' && !stripWidgetsCount) {
+            this.noDataCount += 1;
+        }
+        else if (fetchStatus === 'done' && stripWidgetsCount) {
+            this.successDataCount += 1;
+        }
+        else if (fetchStatus === 'error') {
+            this.errorDataCount += 1;
+        }
+        /** @type {?} */
+        var settledCount = this.noDataCount + this.successDataCount + this.errorDataCount;
+        /** @type {?} */
+        var 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;
+    };
+    /**
+     * @param {?} strip
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.checkForEmptyWidget = /**
+     * @param {?} strip
+     * @return {?}
+     */
+    function (strip) {
+        if (strip.request &&
+            ((strip.request.requestBody && Object.keys(strip.request.requestBody).length))) {
+            return true;
+        }
+        return false;
+    };
+    // strip settings
+    // strip settings
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.toggleInfo = 
+    // strip settings
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    function (data) {
+        /** @type {?} */
+        var 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 = tslib_1.__assign({}, stripInfo, { visibilityMode: stripInfo.visibilityMode === 'hidden' ? 'visible' : 'hidden' });
+            }
+        }
+    };
+    /**
+     * @param {?} stripData
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.raiseTelemetry = /**
+     * @param {?} stripData
+     * @return {?}
+     */
+    function (stripData) {
+        this.telemtryResponse.emit(stripData);
+    };
+    /**
+     * @param {?} key
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.setHiddenForStrip = /**
+     * @param {?} key
+     * @return {?}
+     */
+    function (key) {
+        this.stripsResultDataMap[key].showStrip = false;
+        sessionStorage.setItem("cstrip_" + key, '1');
+    };
+    // selected pills data
+    // selected pills data
+    /**
+     * @param {?} tabdata
+     * @param {?} tabIndex
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.getSelectedPillIndex = 
+    // selected pills data
+    /**
+     * @param {?} tabdata
+     * @param {?} tabIndex
+     * @return {?}
+     */
+    function (tabdata, tabIndex) {
+        if (tabdata.pillsData && tabdata.pillsData.length) {
+            /** @type {?} */
+            var index = tabdata.pillsData.findIndex((/**
+             * @param {?} pill
+             * @return {?}
+             */
+            function (pill) {
+                return pill.selected;
+            }));
+            return index;
+        }
+        return 0;
+    };
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.getdata = /**
+     * @param {?} data
+     * @return {?}
+     */
+    function (data) {
+        if (data.stripInfo) {
+            return data.stripInfo.widget;
+        }
+        return {};
+    };
+    /**
+     * @param {?} tabEvent
+     * @param {?} pillIndex
+     * @param {?} stripMap
+     * @param {?} stripKey
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.tabClicked = /**
+     * @param {?} tabEvent
+     * @param {?} pillIndex
+     * @param {?} stripMap
+     * @param {?} stripKey
+     * @return {?}
+     */
+    function (tabEvent, pillIndex, stripMap, stripKey) {
+        var _this = this;
+        if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {
+            stripMap.tabs[tabEvent.index].pillsData[pillIndex].fetchTabStatus = 'inprogress';
+            stripMap.tabs[tabEvent.index].pillsData[pillIndex].tabLoading = true;
+            stripMap.showOnLoader = true;
+        }
+        /** @type {?} */
+        var 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,
+        });
+        /** @type {?} */
+        var currentTabFromMap = stripMap.tabs && stripMap.tabs[tabEvent.index];
+        /** @type {?} */
+        var currentPillFromMap = stripMap.tabs && stripMap.tabs[tabEvent.index].pillsData[pillIndex];
+        /** @type {?} */
+        var currentStrip = this.widgetData.strips.find((/**
+         * @param {?} s
+         * @return {?}
+         */
+        function (s) { return s.key === stripKey; }));
+        if (this.stripsResultDataMap[stripKey] && currentTabFromMap) {
+            this.stripsResultDataMap[stripKey].viewMoreUrl.queryParams = tslib_1.__assign({}, this.stripsResultDataMap[stripKey].viewMoreUrl.queryParams, { tabSelected: currentTabFromMap.value, pillSelected: currentPillFromMap.value });
+        }
+        if (currentStrip && currentTabFromMap && !currentTabFromMap.computeDataOnClick && currentPillFromMap) {
+            if (currentPillFromMap.requestRequired && currentPillFromMap.request) {
+                if (currentPillFromMap.request.searchV6) {
+                    // this.getTabDataByNewReqSearchV6(currentStrip, tabEvent.index, currentTabFromMap, true);
+                }
+                stripMap.tabs[tabEvent.index].pillsData[pillIndex].tabLoading = false;
+            }
+            else {
+                this.getTabDataByfilter(currentStrip, currentTabFromMap, true);
+                if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {
+                    stripMap.tabs[tabEvent.index].pillsData[pillIndex].fetchTabStatus = 'inprogress';
+                    stripMap.tabs[tabEvent.index].pillsData[pillIndex].tabLoading = false;
+                    stripMap.showOnLoader = true;
+                    this.resetFilter(stripMap, tabEvent.index, pillIndex);
+                }
+                setTimeout((/**
+                 * @return {?}
+                 */
+                function () {
+                    if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {
+                        stripMap.tabs[tabEvent.index].pillsData[pillIndex].fetchTabStatus = 'done';
+                        stripMap.tabs[tabEvent.index].pillsData[pillIndex].tabLoading = false;
+                        stripMap.showOnLoader = false;
+                        _this.resetSelectedPill(stripMap.tabs[tabEvent.index].pillsData);
+                        stripMap.tabs[tabEvent.index].pillsData[pillIndex]['selected'] = true;
+                    }
+                }), 200);
+            }
+        }
+    };
+    /**
+     * @param {?} event
+     * @param {?} stripMap
+     * @param {?} stripKey
+     * @param {?} pillIndex
+     * @param {?} tabIndex
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.pillClicked = /**
+     * @param {?} event
+     * @param {?} stripMap
+     * @param {?} stripKey
+     * @param {?} pillIndex
+     * @param {?} tabIndex
+     * @return {?}
+     */
+    function (event, stripMap, stripKey, pillIndex, tabIndex) {
+        var _this = this;
+        if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {
+            stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'inprogress';
+            stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = true;
+            stripMap.showOnLoader = true;
+        }
+        /** @type {?} */
+        var currentTabFromMap = stripMap.tabs && stripMap.tabs[tabIndex];
+        /** @type {?} */
+        var currentPillFromMap = stripMap.tabs && stripMap.tabs[tabIndex].pillsData[pillIndex];
+        /** @type {?} */
+        var currentStrip = this.widgetData.strips.find((/**
+         * @param {?} s
+         * @return {?}
+         */
+        function (s) { return s.key === stripKey; }));
+        if (this.stripsResultDataMap[stripKey] && currentTabFromMap) {
+            this.stripsResultDataMap[stripKey].viewMoreUrl.queryParams = tslib_1.__assign({}, this.stripsResultDataMap[stripKey].viewMoreUrl.queryParams, { tabSelected: currentTabFromMap.value, pillSelected: currentPillFromMap.value });
+        }
+        if (currentStrip && currentTabFromMap && !currentTabFromMap.computeDataOnClick && currentPillFromMap) {
+            if (currentPillFromMap.requestRequired && currentPillFromMap.request) {
+                // call API to get tab data and process
+                // this.processStrip(currentStrip, [], 'fetching', true, null)
+                if (currentPillFromMap.request.searchV6) {
+                    // this.getTabDataByNewReqSearchV6(currentStrip, tabIndex, pillIndex, currentPillFromMap, true);
+                }
+                else if (currentPillFromMap.request.trendingSearch) {
+                    // this.getTabDataByNewReqTrending(currentStrip, tabIndex, pillIndex, currentPillFromMap, true);
+                }
+                // if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {
+                //   stripMap.tabs[tabEvent.index].tabLoading = false;
+                // }
+                stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;
+            }
+            else {
+                this.getTabDataByfilter(currentStrip, currentTabFromMap, true);
+                if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {
+                    stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'inprogress';
+                    stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;
+                    stripMap.showOnLoader = true;
+                    this.resetFilter(stripMap, tabIndex, pillIndex);
+                }
+                setTimeout((/**
+                 * @return {?}
+                 */
+                function () {
+                    if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {
+                        stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'done';
+                        stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;
+                        stripMap.showOnLoader = false;
+                        _this.resetSelectedPill(stripMap.tabs[tabIndex].pillsData);
+                        stripMap.tabs[tabIndex].pillsData[pillIndex]['selected'] = true;
+                    }
+                }), 200);
+            }
+        }
+    };
+    /**
+     * @param {?} pillData
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.resetSelectedPill = /**
+     * @param {?} pillData
+     * @return {?}
+     */
+    function (pillData) {
+        if (pillData && pillData.length) {
+            pillData.forEach((/**
+             * @param {?} pill
+             * @return {?}
+             */
+            function (pill) {
+                pill['selected'] = false;
+            }));
+        }
+    };
+    /**
+     * @param {?} strip
+     * @param {?} currentTab
+     * @param {?} calculateParentStatus
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.getTabDataByfilter = /**
+     * @param {?} strip
+     * @param {?} currentTab
+     * @param {?} calculateParentStatus
+     * @return {?}
+     */
+    function (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
+    };
+    /**
+     * @private
+     * @param {?} key
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.getIfStripHidden = /**
+     * @private
+     * @param {?} key
+     * @return {?}
+     */
+    function (key) {
+        /** @type {?} */
+        var storageItem = sessionStorage.getItem("cstrip_" + key);
+        return Boolean(storageItem !== '1');
+    };
+    // translate labes
+    // translate labes
+    /**
+     * @param {?} label
+     * @param {?} type
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.translateLabels = 
+    // translate labes
+    /**
+     * @param {?} label
+     * @param {?} type
+     * @return {?}
+     */
+    function (label, type) {
+        return this.langtranslations.translateLabel(label, type, '');
+    };
+    /**
+     * @param {?} stripData
+     * @param {?} path
+     * @param {?} queryParamsData
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.redirectViewAll = /**
+     * @param {?} stripData
+     * @param {?} path
+     * @param {?} queryParamsData
+     * @return {?}
+     */
+    function (stripData, path, queryParamsData) {
+        if (this.emitViewAll) {
+            this.viewAllResponse.emit(stripData);
+        }
+        else {
+            this.router.navigate([path], { queryParams: queryParamsData });
+        }
+    };
+    /**
+     * @param {?} index
+     * @param {?} item
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.identify = /**
+     * @param {?} index
+     * @param {?} item
+     * @return {?}
+     */
+    function (index, item) {
+        if (index >= 0) { }
+        return item;
+    };
+    /**
+     * @param {?} index
+     * @param {?} item
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.tracker = /**
+     * @param {?} index
+     * @param {?} item
+     * @return {?}
+     */
+    function (index, item) {
+        if (index >= 0) { }
+        return _.get(item, 'widgetData.content.identifier');
+    };
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.getContineuLearningLenth = /**
+     * @param {?} data
+     * @return {?}
+     */
+    function (data) {
+        return data.widgets ? data.widgets.length : 0;
+    };
+    /**
+     * @param {?} key
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.showAccordion = /**
+     * @param {?} key
+     * @return {?}
+     */
+    function (key) {
+        if (this.utilitySvc.isMobile && this.stripsResultDataMap[key].mode === 'accordion') {
+            return this.showAccordionData;
+        }
+        return true;
+    };
+    /**
+     * @param {?} wData
+     * @param {?} data
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.checkCondition = /**
+     * @param {?} wData
+     * @param {?} data
+     * @return {?}
+     */
+    function (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;
+    };
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.checkVisible = /**
+     * @param {?} data
+     * @return {?}
+     */
+    function (data) {
+        return data.stripInfo && data.stripInfo.visibilityMode === 'visible';
+    };
+    /**
+     * @param {?} stripsResultDataMap
+     * @param {?} key
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.getSelectedIndex = /**
+     * @param {?} stripsResultDataMap
+     * @param {?} key
+     * @return {?}
+     */
+    function (stripsResultDataMap, key) {
+        /** @type {?} */
+        var returnValue = 0;
+        return returnValue;
+    };
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.getLength = /**
+     * @param {?} data
+     * @return {?}
+     */
+    function (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
+            /** @type {?} */
+            var tabWithMaxWidgets_1 = {};
+            data.tabs.forEach((/**
+             * @param {?} tab
+             * @return {?}
+             */
+            function (tab) {
+                if (tab.pillsData && tab.pillsData.length) {
+                    tabWithMaxWidgets_1 = tab.pillsData.reduce((/**
+                     * @param {?} prev
+                     * @param {?} current
+                     * @return {?}
+                     */
+                    function (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_1.widgets ? tabWithMaxWidgets_1.widgets.length : 0;
+        }
+    };
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.isStripShowing = /**
+     * @param {?} data
+     * @return {?}
+     */
+    function (data) {
+        var _this = this;
+        /** @type {?} */
+        var 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((/**
+             * @param {?} key
+             * @return {?}
+             */
+            function (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;
+    };
+    Object.defineProperty(ContentStripFacetFilterComponent.prototype, "isMobile", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.utilitySvc.isMobile || false;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    // search api with facets
+    // search api with facets
+    /**
+     * @param {?} strip
+     * @param {?} request
+     * @param {?} apiUrl
+     * @param {?} calculateParentStatus
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.postRequestMethod = 
+    // search api with facets
+    /**
+     * @param {?} strip
+     * @param {?} request
+     * @param {?} apiUrl
+     * @param {?} calculateParentStatus
+     * @return {?}
+     */
+    function (strip, request, apiUrl, calculateParentStatus) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, new Promise((/**
+                     * @param {?} resolve
+                     * @param {?} reject
+                     * @return {?}
+                     */
+                    function (resolve, reject) {
+                        if (request && request) {
+                            _this.contentSvc.postApiMethod(apiUrl, request).subscribe((/**
+                             * @param {?} results
+                             * @return {?}
+                             */
+                            function (results) {
+                                if (results.result && results.result.content) {
+                                    /** @type {?} */
+                                    var showViewMore = Boolean(results.result.content && results.result.content.length > 5 && strip.stripConfig && strip.stripConfig.postCardForSearch);
+                                    /** @type {?} */
+                                    var viewMoreUrl = showViewMore
+                                        ? {
+                                            path: strip.viewMoreUrl && strip.viewMoreUrl.path || '',
+                                            queryParams: {
+                                                tab: 'Learn',
+                                                q: strip.viewMoreUrl && strip.viewMoreUrl.queryParams,
+                                                f: {},
+                                            },
+                                        }
+                                        : null;
+                                    resolve({ results: results, viewMoreUrl: viewMoreUrl });
+                                }
+                            }), (/**
+                             * @param {?} error
+                             * @return {?}
+                             */
+                            function (error) {
+                                _this.processStrip(strip, [], 'error', calculateParentStatus, null);
+                                reject(error);
+                            }));
+                        }
+                    }))];
+            });
+        });
+    };
+    /**
+     * @param {?} strip
+     * @param {?=} calculateParentStatus
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.fetchFromSearch = /**
+     * @param {?} strip
+     * @param {?=} calculateParentStatus
+     * @return {?}
+     */
+    function (strip, calculateParentStatus) {
+        if (calculateParentStatus === void 0) { calculateParentStatus = true; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var response, tabIndex, pillIndex, widgets, tabResults, error_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(strip.request && Object.keys(strip.request.requestBody).length)) return [3 /*break*/, 4];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.postRequestMethod(strip, strip.request.requestBody, strip.request.apiUrl, calculateParentStatus)];
+                    case 2:
+                        response = _a.sent();
+                        tabIndex = 0;
+                        pillIndex = 0;
+                        if (response.results && response.results.result) {
+                            this.mapAllDataWithFacets(strip, response.results.result.content, response.results.result.facets, calculateParentStatus);
+                            widgets = this.transformContentsToWidgets(response.results.result.content, strip);
+                            tabResults = [];
+                            // if (this.stripsResultDataMap[strip.key] && this.stripsResultDataMap[strip.key].tabs) {
+                            //   const allTabs = this.stripsResultDataMap[strip.key].tabs;
+                            //   const allPills = this.stripsResultDataMap[strip.key].tabs[tabIndex].pillsData;
+                            //   this.resetSelectedPill(allPills)
+                            //   if (allTabs && allTabs.length && allTabs[tabIndex]) {
+                            //     if(allPills && allPills.length && allPills[pillIndex]){
+                            //       allPills[pillIndex] = {
+                            //         ...allPills[pillIndex],
+                            //         widgets,
+                            //         fetchTabStatus: 'done',
+                            //         selected: true
+                            //       };
+                            //     }
+                            //     allTabs[tabIndex] = {
+                            //       ...allTabs[tabIndex],
+                            //       widgets,
+                            //       fetchTabStatus: 'done',
+                            //     };
+                            //     tabResults = allTabs;
+                            //   }
+                            // }
+                            // this.processStrip(
+                            //   strip,
+                            //   widgets,
+                            //   'done',
+                            //   calculateParentStatus,
+                            //   response.viewMoreUrl,
+                            //   tabResults // tabResults as widgets
+                            // );
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * @param {?} strip
+     * @param {?} content
+     * @param {?} facets
+     * @param {?} calculateParentStatus
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.mapAllDataWithFacets = /**
+     * @param {?} strip
+     * @param {?} content
+     * @param {?} facets
+     * @param {?} calculateParentStatus
+     * @return {?}
+     */
+    function (strip, content, facets, calculateParentStatus) {
+        var _this = this;
+        console.log(strip, content);
+        /** @type {?} */
+        var allTabs = this.stripsResultDataMap[strip.key].tabs;
+        /** @type {?} */
+        var facet = [];
+        allTabs.forEach((/**
+         * @param {?} ele
+         * @return {?}
+         */
+        function (ele) {
+            ele['fetchTabStatus'] = 'done';
+            /** @type {?} */
+            var filteredData = content.filter((/**
+             * @param {?} contEle
+             * @return {?}
+             */
+            function (contEle) { return contEle.nlwUserExp.includes(ele.value); }))
+            // filteredData.forEach(element => {
+            //   facet =  [...facet,..._.difference(element.nlwOrgs ,facet)];
+            // });
+            ;
+            // filteredData.forEach(element => {
+            //   facet =  [...facet,..._.difference(element.nlwOrgs ,facet)];
+            // });
+            ele['widgets'] = filteredData;
+            ele.pillsData.forEach((/**
+             * @param {?} pill
+             * @return {?}
+             */
+            function (pill) {
+                if (pill.value === 'all') {
+                    pill['widgets'] = _this.transformContentsToWidgets(filteredData, strip);
+                    pill['fetchTabStatus'] = 'done';
+                }
+                else if (pill.value === 'course') {
+                    /** @type {?} */
+                    var contentFilteredData = filteredData.filter((/**
+                     * @param {?} contEle
+                     * @return {?}
+                     */
+                    function (contEle) { return contEle.courseCategory.toLowerCase() === pill.value; }));
+                    pill['widgets'] = _this.transformContentsToWidgets(contentFilteredData, strip);
+                    pill['fetchTabStatus'] = 'done';
+                }
+                else {
+                    /** @type {?} */
+                    var contentFilteredData = filteredData.filter((/**
+                     * @param {?} contEle
+                     * @return {?}
+                     */
+                    function (contEle) { return contEle.courseCategory.toLowerCase() !== 'course'; }));
+                    pill['widgets'] = _this.transformContentsToWidgets(contentFilteredData, strip);
+                    pill['fetchTabStatus'] = 'done';
+                }
+            }));
+            // ele['facets'] = [{
+            //   name:'nlwOrgs',
+            //   values: facet
+            // }]
+            ele['facets'] = facets;
+        }));
+        strip.tabs[0].pillsData[0].fetchTabStatus = 'done';
+        strip.tabs[0].pillsData[0].tabLoading = false;
+        strip.showOnLoader = false;
+        this.resetSelectedPill(strip.tabs[0].pillsData);
+        strip.tabs[0].pillsData[0]['selected'] = true;
+        this.processStrip(strip, [], 'done', calculateParentStatus, strip.viewMoreUrl, allTabs // tabResults as widgets
+        );
+    };
+    /**
+     * @private
+     * @param {?} contents
+     * @param {?} strip
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.transformContentsToWidgets = /**
+     * @private
+     * @param {?} contents
+     * @param {?} strip
+     * @return {?}
+     */
+    function (contents, strip) {
+        return (contents || []).map((/**
+         * @param {?} content
+         * @param {?} idx
+         * @return {?}
+         */
+        function (content, idx) { return (content ? {
+            widgetType: 'cardLib',
+            widgetSubType: 'cardContentLib',
+            widgetHostClass: 'mb-2',
+            widgetData: tslib_1.__assign({ content: 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: {},
+        }); }));
+    };
+    /**
+     * @param {?} eventData
+     * @param {?} stripMap
+     * @param {?} tabIndex
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.getorgData = /**
+     * @param {?} eventData
+     * @param {?} stripMap
+     * @param {?} tabIndex
+     * @return {?}
+     */
+    function (eventData, stripMap, tabIndex) {
+        var _this = this;
+        console.log(eventData);
+        /** @type {?} */
+        var selectedValue = eventData.target.value;
+        /** @type {?} */
+        var pillIndex = this.getSelectedPillIndex(stripMap.tabs[tabIndex], tabIndex);
+        if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {
+            stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'inprogress';
+            stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;
+            stripMap.showOnLoader = true;
+            /** @type {?} */
+            var returnedValues = stripMap.tabs[tabIndex].widgets.filter((/**
+             * @param {?} ele
+             * @return {?}
+             */
+            function (ele) {
+                /** @type {?} */
+                var words = ele.nlwOrgs.map((/**
+                 * @param {?} v
+                 * @return {?}
+                 */
+                function (v) { return v.toLowerCase(); }));
+                return words.includes(selectedValue);
+            }));
+            stripMap.tabs[tabIndex].pillsData[pillIndex]['widgets'] = this.transformContentsToWidgets(returnedValues, stripMap);
+        }
+        setTimeout((/**
+         * @return {?}
+         */
+        function () {
+            if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {
+                stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'done';
+                stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;
+                stripMap.showOnLoader = false;
+                _this.resetSelectedPill(stripMap.tabs[tabIndex].pillsData);
+                stripMap.tabs[tabIndex].pillsData[pillIndex]['selected'] = true;
+            }
+        }), 200);
+    };
+    /**
+     * @param {?} stripMap
+     * @param {?} tabIndex
+     * @param {?} pillIndex
+     * @return {?}
+     */
+    ContentStripFacetFilterComponent.prototype.resetFilter = /**
+     * @param {?} stripMap
+     * @param {?} tabIndex
+     * @param {?} pillIndex
+     * @return {?}
+     */
+    function (stripMap, tabIndex, pillIndex) {
+        var _this = this;
+        // let selectedValue = eventData.target.value
+        if (pillIndex) {
+            pillIndex = this.getSelectedPillIndex(stripMap.tabs[tabIndex], tabIndex);
+        }
+        this.facetForm.reset({
+            org: 0
+        });
+        if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {
+            stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'inprogress';
+            stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;
+            stripMap.showOnLoader = true;
+            // let returnedValues = stripMap.tabs[tabIndex].widgets.filter((ele: any) => {
+            //   var words = ele.nlwOrgs.map(v => v.toLowerCase());
+            //   return words.includes(selectedValue)
+            // })
+            /** @type {?} */
+            var contentData = stripMap.tabs[tabIndex].widgets || [];
+            stripMap.tabs[tabIndex].pillsData[pillIndex]['widgets'] = this.transformContentsToWidgets(contentData, stripMap);
+        }
+        setTimeout((/**
+         * @return {?}
+         */
+        function () {
+            if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {
+                stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'done';
+                stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;
+                stripMap.showOnLoader = false;
+                _this.resetSelectedPill(stripMap.tabs[tabIndex].pillsData);
+                stripMap.tabs[tabIndex].pillsData[pillIndex]['selected'] = true;
+            }
+        }), 200);
+    };
+    ContentStripFacetFilterComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'sb-uic-content-strip-facet-filter',
+                    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 \" [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])\" class=\"block md:hidden\">\n                  <div \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                </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            <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                  (selectedTabChange)=\"tabClicked($event, 0, stripsResultDataMap[key], key)\">\n                  <mat-tab label=\"{{tab?.label}}\" *ngFor=\"let tab of stripsResultDataMap[key].tabs; let last = last;let tabIndex = index\">\n                    <ng-template mat-tab-label>\n                      <span><span *ngIf=\"!tab?.disableTranslate\">{{ translateLabels(tab?.label, 'home') }}</span>\n                      <span *ngIf=\"tab?.disableTranslate\">{{tab?.label}}</span> &nbsp;</span>\n                      <span *ngIf=\"tab?.showTabDataCount && tab?.widgets?.length\">({{tab?.widgets?.length}})</span>\n                    </ng-template>\n\n                    <div class=\"wfull\" *ngIf=\"tab?.pillsData && tab?.pillsData?.length\">\n                      <div class=\"flex justify-between item-center flex-wrap gap-4\">\n                        <div class=\"\">\n                          <ng-container *ngFor=\"let facet of tab?.facets\">\n                            <form [formGroup]=\"facetForm\">\n                            <div class=\"facets-select\">\n                              <select formControlName=\"org\" (change)=\"getorgData($event,  stripsResultDataMap[key], tabIndex)\">\n                                <option value=\"0\" selected disabled>Choose by organisation</option>\n                                <option value=\"{{d.name}}\" *ngFor=\"let d of facet.values\" >{{d.name}}</option>\n                              </select>\n                            </div>\n                          </form>\n                          </ng-container>\n                        </div>\n                        <div>\n                          <ng-container >\n                            <mat-chip-list  class=\"content-pill-data\" aria-label=\"Fish selection\">\n                                <ng-container *ngFor=\"let pill of tab?.pillsData;let p = index\">\n                                    <mat-chip [selected]=\"pill?.selected\" (click)=\"pillClicked($event, stripsResultDataMap[key], key, p, tabIndex)\">\n                                      <span class=\"pill-name\">{{pill?.label}}</span></mat-chip>\n                                </ng-container>\n                            </mat-chip-list>\n                          </ng-container>\n                        </div>\n                         <!-- viewAll start-->\n                          <div *ngIf=\"!stripsResultDataMap[key]?.hideViewMoreUrl && checkCondition(widgetData , stripsResultDataMap[key])\" class=\" hidden md:block\">\n                            <div  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                          </div>\n                            \n                          <!-- viewAll end-->\n                      </div>\n                      <div *ngIf=\"stripsResultDataMap && stripsResultDataMap[key]?.showOnLoader ||\n                      !tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.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                     <ng-container *ngIf=\"tab?.pillsData && tab?.pillsData.length && tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]\">\n                      <div *ngIf=\"((tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.fetchTabStatus && tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.fetchTabStatus === 'done') &&\n                      (!tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.widgets || !tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.widgets?.length))\">\n                      <ng-container *ngIf=\"tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.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?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.nodataMsg, 'home') }}</div>\n                        </div>\n                      </ng-template>\n                      </div>\n                     </ng-container>\n                      <ng-container *ngIf=\"(tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.fetchTabStatus === 'done' || tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.widgets?.length)\">\n                        <ng-container  *ngIf=\"!tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.tabLoading\">\n                          <sb-uic-horizontal-scroller-v2 [id]=\"key+'-scroller'\" [sliderConfig]=\"stripsResultDataMap[key]?.sliderConfig\" [widgetsLength]=\"tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.widgets?.length\"\n                            [loadStatus]=\"'done'\" [defaultMaxWidgets]=\"tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.maxWidgets ||\n                            stripsResultDataMap[key]?.sliderConfig?.maxWidgets || defaultMaxWidgets\" [stripConfig]=\"stripsResultDataMap[key]?.stripConfig\">\n                            <ng-container *ngFor=\"let widget of tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.widgets| slice:0:(tab?.pillsData[getSelectedPillIndex(tab ,tabIndex)]?.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>\n          </div>\n        </div>\n      </a>\n\n    </ng-container>\n  </ng-container>\n</ng-template>",
+                    styles: ["@charset \"UTF-8\";.facets-select{position:relative;display:inline-block;width:250px}.facets-select select{appearance:none;-webkit-appearance:none;-moz-appearance:none;background-color:#fff;border:1px solid #ccc;border-radius:25px;padding:10px 30px 10px 10px;font-size:16px;font-family:Arial,sans-serif;width:100%;height:100%;cursor:pointer}.facets-select:after{content:\"\u25BC\";position:absolute;top:50%;right:10px;transform:translateY(-50%);pointer-events:none;font-size:14px;color:#555}::ng-deep mat-chip-list.content-pill-data .mat-chip-selected{background-color:#1b4ca1!important}::ng-deep mat-chip-list.content-pill-data .mat-chip-selected .pill-name{color:#fff!important}::ng-deep mat-chip-list.content-pill-data .mat-chip-list-wrapper .mat-chip{cursor:pointer!important}::ng-deep mat-chip-list.content-pill-data .mat-chip-list-wrapper .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background:#1b4ca1!important;color:#fff!important}::ng-deep mat-chip-list.content-pill-data .mat-chip-list-wrapper .mat-chip.mat-standard-chip{background:#fff!important;border:1px solid rgba(0,0,0,.0784313725)!important}"]
+                }] }
+    ];
+    /** @nocollapse */
+    ContentStripFacetFilterComponent.ctorParameters = function () { return [
+        { type: undefined, decorators: [{ type: Inject, args: ['environment',] }] },
+        { type: WidgetContentService },
+        { type: LoggerService },
+        { type: EventService },
+        { type: ConfigurationsService },
+        { type: UtilityService },
+        { type: Router },
+        { type: WidgetUserService },
+        { type: TranslateService },
+        { type: MultilingualTranslationsService },
+        { type: FormBuilder }
+    ]; };
+    ContentStripFacetFilterComponent.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',] }]
+    };
+    return ContentStripFacetFilterComponent;
+}(WidgetBaseComponent));
+export { ContentStripFacetFilterComponent };
+if (false) {
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.widgetData;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.emptyResponse;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.viewAllResponse;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.telemtryResponse;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.providerId;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.emitViewAll;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.channnelName;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.id;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.stripsResultDataMap;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.stripsKeyOrder;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.showAccordionData;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.showParentLoader;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.showParentError;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.showParentNoData;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.errorDataCount;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.noDataCount;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.successDataCount;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.contentAvailable;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.baseUrl;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.veifiedKarmayogi;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.environment;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.changeEventSubscription;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.defaultMaxWidgets;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.enrollInterval;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.todaysEvents;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.enrollmentMapData;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.facetForm;
+    /**
+     * @type {?}
+     * @private
+     */
+    ContentStripFacetFilterComponent.prototype.contentSvc;
+    /**
+     * @type {?}
+     * @private
+     */
+    ContentStripFacetFilterComponent.prototype.loggerSvc;
+    /**
+     * @type {?}
+     * @private
+     */
+    ContentStripFacetFilterComponent.prototype.eventSvc;
+    /**
+     * @type {?}
+     * @private
+     */
+    ContentStripFacetFilterComponent.prototype.configSvc;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.utilitySvc;
+    /** @type {?} */
+    ContentStripFacetFilterComponent.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    ContentStripFacetFilterComponent.prototype.userSvc;
+    /**
+     * @type {?}
+     * @private
+     */
+    ContentStripFacetFilterComponent.prototype.translate;
+    /**
+     * @type {?}
+     * @private
+     */
+    ContentStripFacetFilterComponent.prototype.langtranslations;
+    /**
+     * @type {?}
+     * @private
+     */
+    ContentStripFacetFilterComponent.prototype._fb;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-strip-facet-filter.component.js","sourceRoot":"ng://@sunbird-cb/consumption/","sources":["lib/_common/strips/content-strip-facet-filter/content-strip-facet-filter.component.ts"],"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 { NsContentStripWithFacets, ApiRequestFor } from './content-strip-facet-filter.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';\nimport { NsCardContent } from '../../../_models/card-content-v2.model';\nimport { ITodayEvents } from '../../../_models/event';\nimport { TranslateService } from '@ngx-translate/core';\nimport { Router } from '@angular/router';\nimport { FormBuilder } from '@angular/forms';\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  hideViewMoreUrl?: boolean;\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  tabs?: NsContentStripWithFacets.IContentStripTab[] | undefined;\n  stripName?: string;\n  stripLogo?: string;\n  description?: string;\n  stripInfo?: NsContentStripWithFacets.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\n@Component({\n  selector: 'sb-uic-content-strip-facet-filter',\n  templateUrl: './content-strip-facet-filter.component.html',\n  styleUrls: ['./content-strip-facet-filter.component.scss']\n})\nexport class ContentStripFacetFilterComponent extends WidgetBaseComponent\nimplements\nOnInit,\nOnDestroy,\nNsWidgetResolver.IWidgetData<NsContentStripWithFacets.IContentStripMultiple> {\n  @Input() widgetData!: NsContentStripWithFacets.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  facetForm: any\n  constructor(\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    public router: Router,\n    private userSvc: WidgetUserService,\n    private translate: TranslateService,\n    private langtranslations: MultilingualTranslationsService,\n    private _fb: FormBuilder\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  ngOnDestroy(): void {\n   \n  }\n\n  ngOnInit() {\n    this.initData();\n    this.contentSvc.telemetryData$.subscribe((data: any) => {\n      this.telemtryResponse.emit(data)\n    })\n    this.facetForm = this._fb.group({\n      org: ['0']\n    })\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  private fetchStripFromRequestData(\n    strip: NsContentStripWithFacets.IContentStripUnit,\n    calculateParentStatus = true,\n  ) {\n    // setting initial values\n    strip.loaderWidgets = this.transformSkeletonToWidgets(strip);\n    this.processStrip(strip, [], 'fetching', false, null);\n    if(strip && strip.stripRequestFor ===  ApiRequestFor.SEARCH && !strip.onTabClickRequest) {\n      this.fetchFromSearch(strip, calculateParentStatus);\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: NsContentStripWithFacets.IContentStripUnit,\n    results: NsWidgetResolver.IRenderConfigWithAnyData[] = [],\n    fetchStatus: TFetchStatus,\n    calculateParentStatus = true,\n    _viewMoreUrl: any,\n    tabsResults?: NsContentStripWithFacets.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      stripName: strip.name,\n      mode: strip.mode,\n      stripConfig: strip.stripConfig,\n      stripBackground: strip.stripBackground,\n      secondaryHeading: strip.secondaryHeading,\n      loaderWidgets: strip.loaderWidgets || [],\n      hideViewMoreUrl:strip.hideViewMoreUrl || false,\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\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: NsContentStripWithFacets.IContentStripUnit): boolean {\n    if (\n      strip.request &&\n      ((strip.request.requestBody && Object.keys(strip.request.requestBody).length))\n    ) {\n      return true;\n    }\n    return false;\n  }\n  // strip settings\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  raiseTelemetry(stripData: any){\n    this.telemtryResponse.emit(stripData)\n  }\n  setHiddenForStrip(key: string) {\n    this.stripsResultDataMap[key].showStrip = false;\n    sessionStorage.setItem(`cstrip_${key}`, '1');\n  }\n  // selected pills data\n  getSelectedPillIndex(tabdata: any, tabIndex: any) {\n    if(tabdata.pillsData && tabdata.pillsData.length) {\n      let index = tabdata.pillsData.findIndex((pill: any) => {\n          return pill.selected\n      });\n      return index\n    }\n    return 0\n  }\n\n  getdata(data: IStripUnitContentData) {\n    if (data.stripInfo) {\n      return data.stripInfo.widget;\n    }\n    return {};\n\n  }\n\n  public tabClicked(tabEvent: MatTabChangeEvent, pillIndex: any, stripMap: IStripUnitContentData, stripKey: string) {\n    if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {\n      stripMap.tabs[tabEvent.index].pillsData[pillIndex].fetchTabStatus = 'inprogress';\n      stripMap.tabs[tabEvent.index].pillsData[pillIndex].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\n    const currentTabFromMap: any = stripMap.tabs && stripMap.tabs[tabEvent.index];\n    const currentPillFromMap: any = stripMap.tabs && stripMap.tabs[tabEvent.index].pillsData[pillIndex];\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.value,\n        pillSelected: currentPillFromMap.value,\n      };\n    }\n\n    if (currentStrip && currentTabFromMap && !currentTabFromMap.computeDataOnClick && currentPillFromMap) {\n      if (currentPillFromMap.requestRequired && currentPillFromMap.request) {\n        if (currentPillFromMap.request.searchV6) {\n          // this.getTabDataByNewReqSearchV6(currentStrip, tabEvent.index, currentTabFromMap, true);\n        }\n      stripMap.tabs[tabEvent.index].pillsData[pillIndex].tabLoading = false;\n      } else {\n        this.getTabDataByfilter(currentStrip, currentTabFromMap, true);\n        if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {\n          stripMap.tabs[tabEvent.index].pillsData[pillIndex].fetchTabStatus = 'inprogress';\n          stripMap.tabs[tabEvent.index].pillsData[pillIndex].tabLoading = false;\n          stripMap.showOnLoader = true;\n          this.resetFilter(stripMap, tabEvent.index ,pillIndex)\n        }\n        setTimeout(() => {\n          if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {\n            stripMap.tabs[tabEvent.index].pillsData[pillIndex].fetchTabStatus = 'done';\n            stripMap.tabs[tabEvent.index].pillsData[pillIndex].tabLoading = false;\n            stripMap.showOnLoader = false;\n            this.resetSelectedPill(stripMap.tabs[tabEvent.index].pillsData)\n            stripMap.tabs[tabEvent.index].pillsData[pillIndex]['selected']=true\n          }\n        },         200);\n      }\n    }\n  }\n\n  pillClicked(event: any, stripMap: IStripUnitContentData, stripKey: any, pillIndex: any, tabIndex: any) {\n    if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {\n      stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'inprogress';\n      stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = true;\n      stripMap.showOnLoader = true;\n    }\n    const currentTabFromMap: any = stripMap.tabs && stripMap.tabs[tabIndex];\n    const currentPillFromMap: any = stripMap.tabs && stripMap.tabs[tabIndex].pillsData[pillIndex];\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.value,\n        pillSelected: currentPillFromMap.value,\n      };\n    }\n    if (currentStrip && currentTabFromMap && !currentTabFromMap.computeDataOnClick && currentPillFromMap) {\n      if (currentPillFromMap.requestRequired && currentPillFromMap.request) {\n        // call API to get tab data and process\n        // this.processStrip(currentStrip, [], 'fetching', true, null)\n        if (currentPillFromMap.request.searchV6) {\n          // this.getTabDataByNewReqSearchV6(currentStrip, tabIndex, pillIndex, currentPillFromMap, true);\n        } else if (currentPillFromMap.request.trendingSearch) {\n          // this.getTabDataByNewReqTrending(currentStrip, tabIndex, pillIndex, currentPillFromMap, true);\n        }\n        // if (stripMap && stripMap.tabs && stripMap.tabs[tabEvent.index]) {\n        //   stripMap.tabs[tabEvent.index].tabLoading = false;\n        // }\n\n      stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;\n      } else {\n        this.getTabDataByfilter(currentStrip, currentTabFromMap, true);\n        if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {\n          stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'inprogress';\n          stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;\n          stripMap.showOnLoader = true;\n          this.resetFilter(stripMap, tabIndex ,pillIndex)\n        }\n        setTimeout(() => {\n          if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {\n            stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'done';\n            stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;\n            stripMap.showOnLoader = false;\n            this.resetSelectedPill(stripMap.tabs[tabIndex].pillsData)\n            stripMap.tabs[tabIndex].pillsData[pillIndex]['selected']=true\n          }\n        },         200);\n      }\n    }\n  }\n\n  resetSelectedPill(pillData: any){\n    if(pillData && pillData.length){\n      pillData.forEach((pill: any) => {\n        pill['selected'] = false\n      });\n    }\n  }\n\n  getTabDataByfilter(\n    strip: NsContentStripWithFacets.IContentStripUnit,\n    currentTab: NsContentStripWithFacets.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  private getIfStripHidden(key: string): boolean {\n    const storageItem = sessionStorage.getItem(`cstrip_${key}`);\n    return Boolean(storageItem !== '1');\n  }\n\n  // translate labes\n  translateLabels(label: string, type: any) {\n    return this.langtranslations.translateLabel(label, type, '');\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  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  getContineuLearningLenth(data: IStripUnitContentData) {\n    return data.widgets ? data.widgets.length : 0;\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  checkCondition(wData: NsContentStripWithFacets.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  getSelectedIndex(stripsResultDataMap: any, key: any): number {\n    let returnValue = 0;\n    return returnValue;\n  }\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      let tabWithMaxWidgets: any = {}\n      data.tabs.forEach((tab: any)=>{\n        if(tab.pillsData && tab.pillsData.length){\n          tabWithMaxWidgets = tab.pillsData.reduce(\n            (prev: any, current: any) => {\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\n        }\n      })\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  isStripShowing(data: any) {\n    let count = 0;\n    \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  get isMobile() {\n    return this.utilitySvc.isMobile || false;\n  }\n\n\n\n  // search api with facets\n  async postRequestMethod(strip: NsContentStripWithFacets.IContentStripUnit,\n    request: NsContentStripWithFacets.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          }\n        }, (error: any) => {\n          this.processStrip(strip, [], 'error', calculateParentStatus, null);\n          reject(error);\n        },\n        );\n      }\n    });\n  }\n\n  async fetchFromSearch(strip: NsContentStripWithFacets.IContentStripUnit, calculateParentStatus = true) {\n    if (strip.request && Object.keys(strip.request.requestBody).length) {\n        try {\n          const response = await this.postRequestMethod(strip, strip.request.requestBody, strip.request.apiUrl, calculateParentStatus);\n          let tabIndex=0\n          let pillIndex= 0\n          if (response.results && response.results.result) {\n            this.mapAllDataWithFacets(strip, response.results.result.content, response.results.result.facets, calculateParentStatus)\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            //   const allPills = this.stripsResultDataMap[strip.key].tabs[tabIndex].pillsData;\n            //   this.resetSelectedPill(allPills)\n            //   if (allTabs && allTabs.length && allTabs[tabIndex]) {\n            //     if(allPills && allPills.length && allPills[pillIndex]){\n            //       allPills[pillIndex] = {\n            //         ...allPills[pillIndex],\n            //         widgets,\n            //         fetchTabStatus: 'done',\n            //         selected: true\n            //       };\n            //     }\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          }\n        } catch (error) {\n          // Handle errors\n          // console.error('Error:', error);\n        }\n      \n    }\n  }\n\n  mapAllDataWithFacets(strip :any, content : any, facets:any, calculateParentStatus: any) {\n    console.log(strip, content)\n    const allTabs = this.stripsResultDataMap[strip.key].tabs;\n    let facet: any = []\n    allTabs.forEach((ele: any)=> {\n      ele['fetchTabStatus']= 'done'\n      let filteredData =  content.filter((contEle: any) => contEle.nlwUserExp.includes(ele.value))\n      // filteredData.forEach(element => {\n      //   facet =  [...facet,..._.difference(element.nlwOrgs ,facet)];\n      // });\n      ele['widgets'] = filteredData\n      ele.pillsData.forEach((pill: any) => {\n        if(pill.value === 'all') {\n          pill['widgets'] = this.transformContentsToWidgets(filteredData, strip);\n          pill['fetchTabStatus']= 'done'\n        } else if(pill.value === 'course') {\n          let contentFilteredData =  filteredData.filter((contEle: any) => contEle.courseCategory.toLowerCase() === pill.value)\n          pill['widgets'] = this.transformContentsToWidgets(contentFilteredData, strip);\n          pill['fetchTabStatus']= 'done'\n        } else {\n          let contentFilteredData =  filteredData.filter((contEle: any) => contEle.courseCategory.toLowerCase() !== 'course')\n          pill['widgets'] = this.transformContentsToWidgets(contentFilteredData, strip);\n          pill['fetchTabStatus']= 'done'\n        }\n      })\n\n      // ele['facets'] = [{\n      //   name:'nlwOrgs',\n      //   values: facet\n      // }]\n      ele['facets'] = facets\n    })\n    strip.tabs[0].pillsData[0].fetchTabStatus = 'done';\n    strip.tabs[0].pillsData[0].tabLoading = false;\n    strip.showOnLoader = false;\n    this.resetSelectedPill(strip.tabs[0].pillsData)\n    strip.tabs[0].pillsData[0]['selected']=true\n    this.processStrip(\n              strip,\n              [],\n              'done',\n              calculateParentStatus,\n              strip.viewMoreUrl,\n              allTabs // tabResults as widgets\n            );\n  }\n\n  private transformContentsToWidgets(\n    contents: NsContent.IContent[],\n    strip: NsContentStripWithFacets.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  getorgData(eventData: any, stripMap: any, tabIndex: any) {\n    console.log(eventData)\n    let selectedValue = eventData.target.value\n    let pillIndex: any = this.getSelectedPillIndex(stripMap.tabs[tabIndex], tabIndex)\n    if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {\n      stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'inprogress';\n      stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;\n      stripMap.showOnLoader = true;\n      let returnedValues = stripMap.tabs[tabIndex].widgets.filter((ele: any) => {\n        var words = ele.nlwOrgs.map(v => v.toLowerCase());\n        return words.includes(selectedValue)\n      })\n      stripMap.tabs[tabIndex].pillsData[pillIndex]['widgets'] = this.transformContentsToWidgets(returnedValues, stripMap);\n    }\n    setTimeout(() => {\n      if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {\n        stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'done';\n        stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;\n        stripMap.showOnLoader = false;\n        this.resetSelectedPill(stripMap.tabs[tabIndex].pillsData)\n        stripMap.tabs[tabIndex].pillsData[pillIndex]['selected']=true\n      }\n    },         200);\n  }\n\n  resetFilter(stripMap: any,  tabIndex: any, pillIndex: any) {\n    // let selectedValue = eventData.target.value\n    if(pillIndex) {\n     pillIndex = this.getSelectedPillIndex(stripMap.tabs[tabIndex], tabIndex)\n    }\n    this.facetForm.reset({\n      org: 0\n     });\n    if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {\n      stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'inprogress';\n      stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;\n      stripMap.showOnLoader = true;\n      // let returnedValues = stripMap.tabs[tabIndex].widgets.filter((ele: any) => {\n      //   var words = ele.nlwOrgs.map(v => v.toLowerCase());\n      //   return words.includes(selectedValue)\n      // })\n      let contentData: any = stripMap.tabs[tabIndex].widgets || []\n      stripMap.tabs[tabIndex].pillsData[pillIndex]['widgets'] = this.transformContentsToWidgets(contentData, stripMap);\n    }\n    setTimeout(() => {\n      if (stripMap && stripMap.tabs && stripMap.tabs[tabIndex]) {\n        stripMap.tabs[tabIndex].pillsData[pillIndex].fetchTabStatus = 'done';\n        stripMap.tabs[tabIndex].pillsData[pillIndex].tabLoading = false;\n        stripMap.showOnLoader = false;\n        this.resetSelectedPill(stripMap.tabs[tabIndex].pillsData)\n        stripMap.tabs[tabIndex].pillsData[pillIndex]['selected']=true\n      }\n    },         200);\n  }\n}\n"]}