@sunbird-cb/consumption 0.0.11 → 0.0.13

package/esm5/lib/_common/calender/calender.component.js

@@ -0,0 +1,335 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { DatePipe } from '@angular/common';
+import { Component, Input, } from '@angular/core';
+import { InsiteDataService } from '../../_services/insite-data.service';
+var CalenderComponent = /** @class */ (function () {
+    function CalenderComponent(datePipe, insightSvc) {
+        this.datePipe = datePipe;
+        this.insightSvc = insightSvc;
+        this.fetchDataFromApi = false;
+        this.showHeader = false;
+        this.defaultDays = 3;
+        this.fullCalendor = false;
+        this.days = [];
+        this.trainings = {};
+        this.isDataLoading = false;
+        this.currentDate = new Date();
+        this.allMonths = ["January", "February", "March",
+            "April", "May", "June", "July",
+            "August", "September", "October",
+            "November", "December"
+        ];
+        this.monthsDropdown = [];
+    }
+    /**
+     * @return {?}
+     */
+    CalenderComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        this.currentMonthAndYear = this.datePipe.transform(this.currentDate, 'MMMM y');
+        this.selectedMonth = this.datePipe.transform(this.currentDate, 'LLLL yyyy');
+        if (this.fullCalendor) {
+            console.log("this.currentDate ", this.currentDate);
+            this.days = this.getDaysInMonth(this.currentDate.getFullYear(), this.currentDate.getMonth());
+            this.getMonthsDropdownData();
+        }
+        if (!this.fullCalendor) {
+            this.days = this.getDays(this.currentDate, +this.defaultDays);
+        }
+        this.startDate = this.days[0];
+        this.endDate = this.days[this.days.length - 1];
+        if (this.fetchDataFromApi) {
+            this.isDataLoading = true;
+            this.getInsiteData();
+        }
+    };
+    /**
+     * @return {?}
+     */
+    CalenderComponent.prototype.getInsiteData = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        /** @type {?} */
+        var request = {
+            "locale": [
+                "en"
+            ],
+            "query": "",
+            "request": {
+                "query": "",
+                "filters": {
+                    "category": [
+                        "Calendar"
+                    ],
+                    "status": [
+                        "Live",
+                        "Retired"
+                    ],
+                    "contentType": "Event",
+                    "startDate": {
+                        ">=": this.startDate,
+                        "<=": this.endDate
+                        // ">=": "2024-01-15",
+                        // "<": "2024-05-31"
+                    },
+                    "channel": [this.providerId]
+                },
+                "sort_by": {
+                    "lastUpdatedOn": "desc"
+                }
+            }
+        };
+        this.insightSvc.fetchTrainingDetails(request).subscribe((/**
+         * @param {?} res
+         * @return {?}
+         */
+        function (res) {
+            if (res && res.result && res.result.Event) {
+                res.result.Event.forEach((/**
+                 * @param {?} resp
+                 * @return {?}
+                 */
+                function (resp) {
+                    if (_this.trainings[resp.startDate]) {
+                        /** @type {?} */
+                        var prevData = _this.trainings[resp.startDate];
+                        /** @type {?} */
+                        var location_1 = resp.eventType;
+                        if (resp.venue && location_1 !== "Online") {
+                            /** @type {?} */
+                            var jsonResp = JSON.parse(resp.venue);
+                            location_1 = jsonResp['address'];
+                        }
+                        /** @type {?} */
+                        var formatObject = {
+                            location: location_1,
+                            startTime: _this.convertTo12HourFormat(resp.startTime),
+                            endTime: _this.convertTo12HourFormat(resp.endTime),
+                            title: resp.name,
+                            startDate: _this.formatDate(resp.startDate),
+                            endDate: _this.formatDate(resp.endDate),
+                            registrationLink: resp.registrationLink,
+                        };
+                        prevData.push(formatObject);
+                        _this.trainings[resp.startDate] = prevData;
+                    }
+                }));
+            }
+            _this.isDataLoading = false;
+        }));
+    };
+    /**
+     * @param {?} obj
+     * @return {?}
+     */
+    CalenderComponent.prototype.getKeys = /**
+     * @param {?} obj
+     * @return {?}
+     */
+    function (obj) {
+        return Object.keys(obj);
+    };
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    CalenderComponent.prototype.formatDate = /**
+     * @param {?} date
+     * @return {?}
+     */
+    function (date) {
+        /** @type {?} */
+        var formatDate = new Date(date);
+        return this.datePipe.transform(formatDate, 'E, dd LLL');
+    };
+    /**
+     * @param {?} timeString
+     * @return {?}
+     */
+    CalenderComponent.prototype.convertTo12HourFormat = /**
+     * @param {?} timeString
+     * @return {?}
+     */
+    function (timeString) {
+        /** @type {?} */
+        var time = timeString.split(":");
+        /** @type {?} */
+        var hours = +time[0];
+        /** @type {?} */
+        var minutes = +time[1];
+        /** @type {?} */
+        var ampm = hours >= 12 ? 'PM' : 'AM';
+        hours = hours % 12;
+        hours = hours ? hours : 12;
+        /** @type {?} */
+        var strHours = hours < 10 ? '0' + hours : hours.toString();
+        /** @type {?} */
+        var strMinutes = minutes < 10 ? '0' + minutes : minutes.toString();
+        return strHours + ":" + strMinutes + ": " + ampm;
+    };
+    /**
+     * @param {?} cDate
+     * @param {?} counter
+     * @return {?}
+     */
+    CalenderComponent.prototype.getDays = /**
+     * @param {?} cDate
+     * @param {?} counter
+     * @return {?}
+     */
+    function (cDate, counter) {
+        /** @type {?} */
+        var days = [];
+        /** @type {?} */
+        var initDate = new Date(cDate);
+        initDate = this.datePipe.transform(initDate, 'y-MM-dd');
+        days.push(initDate);
+        this.trainings[initDate] = [];
+        while (counter > 0) {
+            /** @type {?} */
+            var myDate = new Date(cDate);
+            myDate = myDate.setDate(myDate.getDate() + 1);
+            cDate = myDate;
+            myDate = this.datePipe.transform(myDate, 'y-MM-dd');
+            days.push(myDate);
+            this.trainings[myDate] = [];
+            counter = counter - 1;
+        }
+        return days;
+    };
+    /**
+     * @param {?} year
+     * @param {?} month
+     * @return {?}
+     */
+    CalenderComponent.prototype.getDaysInMonth = /**
+     * @param {?} year
+     * @param {?} month
+     * @return {?}
+     */
+    function (year, month) {
+        /** @type {?} */
+        var date = new Date(year, month, 1);
+        /** @type {?} */
+        var days = [];
+        this.trainings = {};
+        while (date.getMonth() === month) {
+            /** @type {?} */
+            var myDate = new Date(date);
+            myDate = this.datePipe.transform(myDate, 'y-MM-dd');
+            days.push(myDate);
+            this.trainings[myDate] = [];
+            date.setDate(date.getDate() + 1);
+        }
+        return days;
+    };
+    /**
+     * @return {?}
+     */
+    CalenderComponent.prototype.getMonthsDropdownData = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        this.allMonths.forEach((/**
+         * @param {?} month
+         * @return {?}
+         */
+        function (month) {
+            _this.monthsDropdown.push(month + " " + _this.currentDate.getFullYear());
+        }));
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    CalenderComponent.prototype.selectMonth = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        /** @type {?} */
+        var selectedMonth = new Date(event);
+        this.currentDate = selectedMonth;
+        this.days = [];
+        this.days = this.getDaysInMonth(this.currentDate.getFullYear(), this.currentDate.getMonth());
+        this.startDate = this.days[0];
+        this.endDate = this.days[this.days.length - 1];
+        this.isDataLoading = true;
+        this.getInsiteData();
+    };
+    CalenderComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'sb-uic-calender',
+                    template: "<div class=\"calendar-header flex flex-row c-padding center gap-2\" *ngIf=\"showHeader\">\n    <div class=\"pt-3\">{{ objectData?.title }}:</div>\n    <div class=\"choose-month\">\n        <mat-form-field class=\"custom-month\">\n            <mat-select matNativeControl panelClass=\"custom-select\" [ngModel]=\"selectedMonth\" (ngModelChange)=\"selectMonth($event)\" class=\"month-select\">\n                <span *ngFor=\"let month of monthsDropdown\">\n                    <mat-option [value]=\"month\">{{month}}</mat-option>\n                </span>\n            </mat-select>\n        </mat-form-field>\n    </div>\n</div>\n<div *ngIf=\"layoutType==='grid'\">\n    <div *ngFor=\"let obj of getKeys(trainings);  let i = index\">\n        <sb-uic-calender-day [day]=\"trainings[obj]\"\n            [layoutType]=\"layoutType\"\n            [objectData]=\"objectData\"\n            [dataLoading]=\"isDataLoading\"\n            [eventDate]=\"obj\"\n            [rowId]=\"i\">\n        </sb-uic-calender-day>\n    </div>    \n</div>\n<div *ngIf=\"layoutType==='row'\">\n    <div *ngFor=\"let obj of getKeys(trainings); let j = index\">\n        <sb-uic-calender-day [day]=\"trainings[obj]\"\n            [layoutType]=\"layoutType\"\n            [objectData]=\"objectData\"\n            [dataLoading]=\"isDataLoading\"\n            [eventDate]=\"obj\"\n            [rowId]=\"j\">\n        </sb-uic-calender-day>\n    </div>\n</div>",
+                    styles: [".calendar-header{font-family:Montserrat;font-size:16px;font-weight:600;line-height:19.5px;text-align:left}.c-padding{padding:0}.center{align-items:center}::ng-deep .custom-month .mat-form-field-wrapper{padding-bottom:0!important;width:110px}::ng-deep .custom-month .mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#000!important}::ng-deep .custom-month .mat-select-value{width:89%}::ng-deep .custom-month .mat-select-value-text{font-weight:600}@media screen and (max-width:768px){.c-padding{padding:0 1.25rem 1rem}.calendar-header{font-size:15px}}"]
+                }] }
+    ];
+    /** @nocollapse */
+    CalenderComponent.ctorParameters = function () { return [
+        { type: DatePipe },
+        { type: InsiteDataService }
+    ]; };
+    CalenderComponent.propDecorators = {
+        objectData: [{ type: Input }],
+        layoutType: [{ type: Input }],
+        fetchDataFromApi: [{ type: Input }],
+        showHeader: [{ type: Input }],
+        defaultDays: [{ type: Input }],
+        providerId: [{ type: Input }],
+        fullCalendor: [{ type: Input }]
+    };
+    return CalenderComponent;
+}());
+export { CalenderComponent };
+if (false) {
+    /** @type {?} */
+    CalenderComponent.prototype.objectData;
+    /** @type {?} */
+    CalenderComponent.prototype.layoutType;
+    /** @type {?} */
+    CalenderComponent.prototype.fetchDataFromApi;
+    /** @type {?} */
+    CalenderComponent.prototype.showHeader;
+    /** @type {?} */
+    CalenderComponent.prototype.defaultDays;
+    /** @type {?} */
+    CalenderComponent.prototype.providerId;
+    /** @type {?} */
+    CalenderComponent.prototype.fullCalendor;
+    /** @type {?} */
+    CalenderComponent.prototype.days;
+    /** @type {?} */
+    CalenderComponent.prototype.trainings;
+    /** @type {?} */
+    CalenderComponent.prototype.currentMonthAndYear;
+    /** @type {?} */
+    CalenderComponent.prototype.isDataLoading;
+    /** @type {?} */
+    CalenderComponent.prototype.currentDate;
+    /** @type {?} */
+    CalenderComponent.prototype.endDate;
+    /** @type {?} */
+    CalenderComponent.prototype.startDate;
+    /** @type {?} */
+    CalenderComponent.prototype.allMonths;
+    /** @type {?} */
+    CalenderComponent.prototype.monthsDropdown;
+    /** @type {?} */
+    CalenderComponent.prototype.selectedMonth;
+    /**
+     * @type {?}
+     * @private
+     */
+    CalenderComponent.prototype.datePipe;
+    /** @type {?} */
+    CalenderComponent.prototype.insightSvc;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calender.component.js","sourceRoot":"ng://@sunbird-cb/consumption/","sources":["lib/_common/calender/calender.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatePipe } from '@angular/common';\nimport {\n  Component,\n  Input,\n  OnInit,\n  \n} from '@angular/core';\nimport { InsiteDataService } from '../../_services/insite-data.service';\n\n@Component({\n  selector: 'sb-uic-calender',\n  templateUrl: './calender.component.html',\n  styleUrls: ['./calender.component.scss']\n})\nexport class CalenderComponent implements OnInit {\n\n  @Input() objectData: any\n  @Input() layoutType: any\n  @Input() fetchDataFromApi: boolean = false\n  @Input() showHeader: boolean = false\n  @Input() defaultDays: number = 3\n  @Input() providerId: any\n  @Input() fullCalendor: boolean = false\n  days = []\n  trainings: any = {}\n  currentMonthAndYear: any\n  isDataLoading: boolean = false\n  currentDate: any = new Date()\n  endDate: any\n  startDate: any\n  allMonths = [\"January\", \"February\", \"March\",\n    \"April\", \"May\", \"June\", \"July\",\n    \"August\", \"September\", \"October\",\n    \"November\", \"December\"\n  ]\n  monthsDropdown: any = []\n  selectedMonth: any\n  constructor(private datePipe: DatePipe, public insightSvc: InsiteDataService) { }\n\n  ngOnInit() {\n    this.currentMonthAndYear = this.datePipe.transform(this.currentDate, 'MMMM y')\n    this.selectedMonth = this.datePipe.transform(this.currentDate, 'LLLL yyyy')\n    if (this.fullCalendor) {\n      console.log(\"this.currentDate \", this.currentDate)\n      this.days = this.getDaysInMonth(this.currentDate.getFullYear(), this.currentDate.getMonth())\n      this.getMonthsDropdownData()\n    }\n    if (!this.fullCalendor) {\n      this.days = this.getDays(this.currentDate, +this.defaultDays)\n    }\n    this.startDate = this.days[0]\n    this.endDate = this.days[this.days.length - 1]\n    if(this.fetchDataFromApi) {\n      this.isDataLoading = true\n      this.getInsiteData()\n    }\n  }\n  getInsiteData() {\n    let request = {\n      \"locale\": [\n          \"en\"\n      ],\n      \"query\": \"\",\n      \"request\": {\n          \"query\": \"\",\n          \"filters\": {\n              \"category\": [\n                  \"Calendar\"\n              ],\n              \"status\": [\n                  \"Live\",\n                  \"Retired\"\n              ],\n              \"contentType\": \"Event\",\n              \"startDate\": {\n                \">=\": this.startDate,\n                \"<=\": this.endDate\n                // \">=\": \"2024-01-15\",\n                // \"<\": \"2024-05-31\"\n              },\n              \"channel\": [this.providerId]\n          },\n          \"sort_by\": {\n              \"lastUpdatedOn\": \"desc\"\n          }\n      }\n    }\n    this.insightSvc.fetchTrainingDetails(request).subscribe((res: any)=> {\n      if (res && res.result && res.result.Event) {\n        res.result.Event.forEach((resp: any) => {\n          if (this.trainings[resp.startDate]) {\n            let prevData = this.trainings[resp.startDate]\n            let location = resp.eventType\n            if (resp.venue && location !== \"Online\") {\n              const jsonResp = JSON.parse(resp.venue)\n              location = jsonResp['address']\n            }\n            const formatObject = {\n              location: location,\n              startTime: this.convertTo12HourFormat(resp.startTime),\n              endTime: this.convertTo12HourFormat(resp.endTime),\n              title: resp.name,\n              startDate: this.formatDate(resp.startDate),\n              endDate: this.formatDate(resp.endDate),\n              registrationLink: resp.registrationLink,\n            }\n            prevData.push(formatObject)\n            this.trainings[resp.startDate] = prevData\n          }\n        })\n      }\n      this.isDataLoading = false\n    })\n  }\n\n  getKeys(obj: any): string[] {\n    return Object.keys(obj);\n  }\n\n  formatDate(date: any) {\n    let formatDate = new Date(date)\n    return this.datePipe.transform(formatDate, 'E, dd LLL')\n  }\n\n  convertTo12HourFormat(timeString: string): string {\n    const time = timeString.split(\":\")\n    let hours = +time[0]\n    const minutes = +time[1]\n    const ampm = hours >= 12 ? 'PM' : 'AM'\n    hours = hours % 12\n    hours = hours ? hours : 12\n    const strHours = hours < 10 ? '0' + hours : hours.toString()\n    const strMinutes = minutes < 10 ? '0' + minutes : minutes.toString()\n    return `${strHours}:${strMinutes}: ${ampm}`\n  }\n\n  getDays(cDate: any, counter: number) {\n    const days: any = []\n    let initDate: any = new Date(cDate)\n    initDate = this.datePipe.transform(initDate, 'y-MM-dd')\n    days.push(initDate)\n    this.trainings[initDate] = []\n    while (counter > 0) {\n      let myDate: any = new Date(cDate)\n      myDate = myDate.setDate(myDate.getDate() + 1)\n      cDate = myDate\n      myDate = this.datePipe.transform(myDate, 'y-MM-dd')\n      days.push(myDate)\n      this.trainings[myDate] = []\n      counter = counter - 1\n    }\n    return days\n  }\n\n  getDaysInMonth(year: number, month: number): Date[] {\n    const date = new Date(year, month, 1)\n    const days: any = []\n    this.trainings = {}\n    while (date.getMonth() === month) {\n      let myDate: any = new Date(date)\n      myDate = this.datePipe.transform(myDate, 'y-MM-dd')\n      days.push(myDate)\n      this.trainings[myDate] = []\n      date.setDate(date.getDate() + 1)\n    }\n    return days\n  }\n\n  getMonthsDropdownData() {\n    this.allMonths.forEach((month: any) => {\n      this.monthsDropdown.push(`${month} ${this.currentDate.getFullYear()}`)\n    })\n  }\n\n  selectMonth(event: any) {\n    const selectedMonth: any = new Date(event)\n    this.currentDate = selectedMonth\n    this.days = []\n    this.days = this.getDaysInMonth(this.currentDate.getFullYear(), this.currentDate.getMonth())\n    this.startDate = this.days[0]\n    this.endDate = this.days[this.days.length - 1]\n    this.isDataLoading = true\n    this.getInsiteData()\n  }\n}\n"]}

package/esm5/lib/_common/calender/calender.module.js

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from '@angular/core';
+import { CommonModule, DatePipe } from '@angular/common';
+import { CalenderComponent } from './calender.component';
+import { MatIconModule, MatSelectModule } from '@angular/material';
+import { SkeletonLoaderLibModule } from '../skeleton-loader-lib/skeleton-loader-lib.module';
+import { CalenderDayComponent } from './calender-day/calender-day.component';
+import { InsiteDataService } from '../../_services/insite-data.service';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+var CalenderModule = /** @class */ (function () {
+    function CalenderModule() {
+    }
+    CalenderModule.decorators = [
+        { type: NgModule, args: [{
+                    imports: [
+                        CommonModule,
+                        MatIconModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MatSelectModule,
+                        SkeletonLoaderLibModule
+                    ],
+                    declarations: [CalenderComponent, CalenderDayComponent],
+                    exports: [CalenderComponent],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    providers: [DatePipe, InsiteDataService],
+                },] }
+    ];
+    return CalenderModule;
+}());
+export { CalenderModule };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/_common/cards/card-portrait/card-portrait.component.js

@@ -49,6 +49,10 @@ var CardPortraitComponent = /** @class */ (function () {
             this.sourceLogos = instanceConfig.sources;
             this.defaultSLogo = instanceConfig.logos.defaultSourceLogo || '';
         }
+        else {
+            this.defaultThumbnail = '/assets/instances/eagle/app_logos/default.png';
+            this.defaultSLogo = '/assets/instances/eagle/app_logos/KarmayogiBharat_Logo.svg';
+        }
     };
     /**
      * @return {?}
@@ -179,4 +183,4 @@ if (false) {
      */
     CardPortraitComponent.prototype.configSvc;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"card-portrait.component.js","sourceRoot":"ng://@sunbird-cb/consumption/","sources":["lib/_common/cards/card-portrait/card-portrait.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { NsCardContent } from '../../../_models/card-content.model';\nimport { MatSnackBar } from '@angular/material';\nimport { ConfigurationsService, EventService } from '@sunbird-cb/utils-v2';\nimport * as _ from \"lodash\";\nimport { TranslateService } from '@ngx-translate/core';\nimport { MultilingualTranslationsService } from '../../../_services/multilingual-translations.service';\n\n@Component({\n  selector: 'sb-uic-card-portrait',\n  templateUrl: './card-portrait.component.html',\n  styleUrls: ['./card-portrait.component.scss']\n})\nexport class CardPortraitComponent implements OnInit {\n  @Input() widgetData!: NsCardContent.ICard;\n  @Input() isLiveOrMarkForDeletion: any\n  @Input() showIntranetContent: any\n  @Input() isIntranetAllowedSettings: any\n  @Input() isCardLoading: boolean = false\n  @Output() contentData = new EventEmitter<any>()\n  isCardFlipped:boolean = false\n  defaultThumbnail: any\n  sourceLogos: any\n  defaultSLogo: any\n  showFlip = false\n  widgetType: any = 'df'\n  widgetSubType: any ='sdf'\n  constructor(\n    private snackBar: MatSnackBar,\n    private events: EventService,\n    private translate: TranslateService,\n    private langtranslations: MultilingualTranslationsService,\n    private configSvc: ConfigurationsService,) { \n      this.langtranslations.languageSelectedObservable.subscribe(() => {\n        if (localStorage.getItem('websiteLanguage')) {\n          this.translate.setDefaultLang('en')\n          const lang = localStorage.getItem('websiteLanguage')!\n          this.translate.use(lang)\n        }\n      })\n    }\n\n  ngOnInit() {\n    const instanceConfig = this.configSvc.instanceConfig\n    if (instanceConfig) {\n      this.defaultThumbnail = instanceConfig.logos.defaultContent || ''\n      this.sourceLogos = instanceConfig.sources\n      this.defaultSLogo = instanceConfig.logos.defaultSourceLogo || ''\n    }\n  }\n\n  showSnackbar() {\n    if (this.showIntranetContent) {\n      this.snackBar.open('Content is only available in intranet', 'X', { duration: 2000 })\n    } else if (!this.isLiveOrMarkForDeletion) {\n      this.snackBar.open('Content may be expired or deleted', 'X', { duration: 2000 })\n    }\n  }\n  getRedirectUrlData(contentData: any){\n    this.contentData.emit(contentData)\n  }\n  raiseTelemetry() {\n    // if(this.forPreview){\n    //   return\n    // }\n    this.events.raiseInteractTelemetry(\n      {\n        type: 'click',\n        subType: `${this.widgetType}-${this.widgetSubType}`,\n        id: `${_.camelCase(this.widgetData.content.primaryCategory)}-card`,\n      },\n      {\n        id: this.widgetData.content.identifier,\n        type: this.widgetData.content.primaryCategory,\n        //context: this.widgetData.context,\n        rollup: {},\n        ver: `${this.widgetData.content.version}${''}`,\n      },\n      {\n        pageIdExt: `${_.camelCase(this.widgetData.content.primaryCategory)}-card`,\n        module: _.camelCase(this.widgetData.content.primaryCategory),\n      })\n  }\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"card-portrait.component.js","sourceRoot":"ng://@sunbird-cb/consumption/","sources":["lib/_common/cards/card-portrait/card-portrait.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { NsCardContent } from '../../../_models/card-content.model';\nimport { MatSnackBar } from '@angular/material';\nimport { ConfigurationsService, EventService } from '@sunbird-cb/utils-v2';\nimport * as _ from \"lodash\";\nimport { TranslateService } from '@ngx-translate/core';\nimport { MultilingualTranslationsService } from '../../../_services/multilingual-translations.service';\n\n@Component({\n  selector: 'sb-uic-card-portrait',\n  templateUrl: './card-portrait.component.html',\n  styleUrls: ['./card-portrait.component.scss']\n})\nexport class CardPortraitComponent implements OnInit {\n  @Input() widgetData!: NsCardContent.ICard;\n  @Input() isLiveOrMarkForDeletion: any\n  @Input() showIntranetContent: any\n  @Input() isIntranetAllowedSettings: any\n  @Input() isCardLoading: boolean = false\n  @Output() contentData = new EventEmitter<any>()\n  isCardFlipped:boolean = false\n  defaultThumbnail: any\n  sourceLogos: any\n  defaultSLogo: any\n  showFlip = false\n  widgetType: any = 'df'\n  widgetSubType: any ='sdf'\n  constructor(\n    private snackBar: MatSnackBar,\n    private events: EventService,\n    private translate: TranslateService,\n    private langtranslations: MultilingualTranslationsService,\n    private configSvc: ConfigurationsService,) { \n      this.langtranslations.languageSelectedObservable.subscribe(() => {\n        if (localStorage.getItem('websiteLanguage')) {\n          this.translate.setDefaultLang('en')\n          const lang = localStorage.getItem('websiteLanguage')!\n          this.translate.use(lang)\n        }\n      })\n    }\n\n  ngOnInit() {\n    const instanceConfig = this.configSvc.instanceConfig\n    if (instanceConfig) {\n      this.defaultThumbnail = instanceConfig.logos.defaultContent || ''\n      this.sourceLogos = instanceConfig.sources\n      this.defaultSLogo = instanceConfig.logos.defaultSourceLogo || ''\n    } else {\n      this.defaultThumbnail = '/assets/instances/eagle/app_logos/default.png'\n      this.defaultSLogo =  '/assets/instances/eagle/app_logos/KarmayogiBharat_Logo.svg'\n    }\n  }\n\n  showSnackbar() {\n    if (this.showIntranetContent) {\n      this.snackBar.open('Content is only available in intranet', 'X', { duration: 2000 })\n    } else if (!this.isLiveOrMarkForDeletion) {\n      this.snackBar.open('Content may be expired or deleted', 'X', { duration: 2000 })\n    }\n  }\n  getRedirectUrlData(contentData: any){\n    this.contentData.emit(contentData)\n  }\n  raiseTelemetry() {\n    // if(this.forPreview){\n    //   return\n    // }\n    this.events.raiseInteractTelemetry(\n      {\n        type: 'click',\n        subType: `${this.widgetType}-${this.widgetSubType}`,\n        id: `${_.camelCase(this.widgetData.content.primaryCategory)}-card`,\n      },\n      {\n        id: this.widgetData.content.identifier,\n        type: this.widgetData.content.primaryCategory,\n        //context: this.widgetData.context,\n        rollup: {},\n        ver: `${this.widgetData.content.version}${''}`,\n      },\n      {\n        pageIdExt: `${_.camelCase(this.widgetData.content.primaryCategory)}-card`,\n        module: _.camelCase(this.widgetData.content.primaryCategory),\n      })\n  }\n\n}\n"]}

package/esm5/lib/_common/cards/card-user/card-user.component.js

@@ -70,9 +70,9 @@ var CardUserComponent = /** @class */ (function () {
         this.events.raiseInteractTelemetry({
             type: 'click',
             subType: this.widgetType + "-" + this.widgetSubType,
-            id: _.camelCase(this.widgetData.user.userId) + "-card",
+            id: _.camelCase(this.widgetData.content.userId) + "-card",
         }, {
-            id: this.widgetData.user.userId,
+            id: this.widgetData.content.userId,
             // type: this.widgetData.user.primaryCategory,
             //context: this.widgetData.context,
             rollup: {},
@@ -84,8 +84,8 @@ var CardUserComponent = /** @class */ (function () {
     CardUserComponent.decorators = [
         { type: Component, args: [{
                     selector: 'sb-uic-card-user',
-                    template: "<mat-card class=\"card-users-container mr-5 padding-remove cursor-pointer\">\n    <div class=\"display-contents\">\n        <ng-container *ngIf=\"widgetData.user\">\n            <a (click)=\"raiseTelemetry();$event.stopPropagation()\" role=\"link\"\n                i18n-aria-label>\n                <ng-container>\n                    <mat-card-content class=\"min-top\">\n                        <div style=\"position: relative; z-index: 1;\">\n                            <ng-container *ngIf=\"widgetData.user.profileImage\">\n                                <img mat-card-image [src]=\"widgetData.user.profileImage\"\n                                    loading=\"lazy\" class=\"card-img ws-mat-primary-lite-background margin-remove\"\n                                    [wsUtilsDefaultThumbnail]=\"defaultThumbnail\" [alt]=\"widgetData.user.firstName\" />\n                            </ng-container>\n                            <ng-container *ngIf=\"!widgetData.user.profileImage\">\n                                <ng-template #defaultImg>\n                                    <img mat-card-image [src]=\"defaultThumbnail\" loading=\"lazy\"\n                                        class=\"card-img ws-mat-primary-lite-background margin-remove\"\n                                        [alt]=\"widgetData.user.firstName\" />\n                                </ng-template>\n                            </ng-container>\n                        </div>\n                        <div class=\"padding-m\">\n                            <div class=\"user_widget flex margin-remove\">\n                            </div>\n                            <div [id]=\"'m-c-'+ widgetData.user?.userId\"\n                                class=\"mat-subheading-1 title-text ws-mat-text-block-fade-gradient\">\n                                {{ widgetData?.user?.firstName }}\n                            </div>\n                            <div class=\"flex w-full flex-wrap flex-middle\">\n                                <p>\n                                    {{ widgetData?.user?.description }}\n                                </p>\n                            </div>\n                        </div>\n                    </mat-card-content>\n                </ng-container>\n            </a>\n        </ng-container>\n    </div>\n</mat-card>",
-                    styles: [".card-users-container{position:relative;width:268px;min-height:346px;border-radius:8px;box-sizing:border-box;box-shadow:0 10px 30px rgba(153,153,153,.2);overflow:hidden;height:346px;margin:20px 8px}.card-users-container .progress-bar{width:101%;margin-left:-15px;display:flex;margin-top:0;background:bisque;position:absolute;bottom:0}.card-users-container ::ng-deep .mat-progress-bar{height:8px!important}.card-users-container .icon_text{font-size:12px;line-height:16px;text-transform:uppercase}.card-users-container .course_logo_box{width:38px;height:38px;background:#fff;border-radius:8px;box-sizing:border-box;box-shadow:0 2px 1px -1px rgba(0,0,0,.2),0 1px 1px 0 rgba(0,0,0,.14),0 1px 3px 0 rgba(0,0,0,.12)}.card-users-container .course_logo_box img{height:28px;width:28px;padding:5px;display:inline-block}.card-users-container .course_logo_box p{display:inline-block;vertical-align:top}.card-users-container .org-text{font-size:12px;font-weight:400;width:75%;padding-left:10px;word-break:break-all;white-space:initial;overflow:hidden;text-overflow:ellipsis;display:-webkit-box;-webkit-line-clamp:1;-webkit-box-orient:vertical}.card-users-container .source-div{position:relative;top:100px;background:#fff;z-index:3;border:1px solid #dedfe0;min-width:72px;min-height:72px;max-width:72px;max-height:72px;display:flex;border-radius:8px}.card-users-container .source-div .source-icon{border-radius:8px;display:block;margin:auto;max-width:58px;max-height:-webkit-fill-available}.card-users-container mat-card-content{background:#fff}.card-users-container .card-img{min-width:245px;max-height:140px;min-height:140px;display:block;-o-object-fit:fill;object-fit:fill;border-top-left-radius:8px;border-top-right-radius:8px;width:100%}.card-users-container .mat-subheading-1{font:600 14px/24px Montserrat}.card-users-container .complexity{padding-top:70px;display:flex;font-size:14px;line-height:21px;padding-bottom:10px}.card-users-container .complexity .mode-tag{border-radius:5px;order:2;margin-left:auto;color:#fff;font-size:10px}.card-users-container .complexity .duration{display:flex;margin-left:auto;order:3;font-weight:700}.card-users-container .complexity .time-text{margin:0 5px 0 6px;font-weight:700}.card-users-container .basic{margin:auto 0}.card-users-container .title-text{word-break:break-all;white-space:initial;margin:8px 0;position:relative;overflow:hidden;text-overflow:ellipsis;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;min-height:48px}.card-users-container .description-text{position:relative;overflow:hidden;height:42px;white-space:normal;text-overflow:ellipsis}.duration-box{background:#000;position:absolute;border:none;display:flex;align-items:center;padding:4px;border-radius:4px}.duration-box.right-corner{right:4px;bottom:4px}.duration-box .mat-icon{vertical-align:middle;color:#fff!important;height:14px!important;width:14px!important;font-size:14px}.duration-box .duration{font:700 12px/16px Lato;display:inline-block;margin:0;padding:0}"]
+                    template: "<mat-card class=\"user-card card-users-container mr-5 padding-remove cursor-pointer\">\n    <div class=\"display-contents\">\n        <ng-container *ngIf=\"widgetData.content\">\n            <a (click)=\"raiseTelemetry();$event.stopPropagation()\" role=\"link\"\n                i18n-aria-label>\n                <ng-container>\n                    <mat-card-content class=\"min-top\">\n                        <div style=\"position: relative; z-index: 1;\">\n                            <ng-container *ngIf=\"widgetData.content.image\">\n                                <img mat-card-image [src]=\"widgetData.content.image\"\n                                    loading=\"lazy\" class=\"card-img ws-mat-primary-lite-background margin-remove\"\n                                    [wsUtilsDefaultThumbnail]=\"defaultThumbnail\" [alt]=\"widgetData.content.name\" />\n                            </ng-container>\n                            <ng-container *ngIf=\"!widgetData.content.image\">\n                                <ng-template #defaultImg>\n                                    <img mat-card-image [src]=\"defaultThumbnail\" loading=\"lazy\"\n                                        class=\"card-img ws-mat-primary-lite-background margin-remove\"\n                                        [alt]=\"widgetData.content.name\" />\n                                </ng-template>\n                            </ng-container>\n                        </div>\n                        <div class=\"padding-m\">\n                            <div class=\"user_widget flex margin-remove\">\n                            </div>\n                            <div [id]=\"'m-c-'+ widgetData.content?.userId\"\n                                class=\"mat-subheading-1 title-text ws-mat-text-block-fade-gradient\">\n                                {{ widgetData?.content?.name }}\n                            </div>\n                            <div class=\"flex w-full flex-wrap flex-middle\">\n                                <p class=\"whitespace-normal description-text\">\n                                    {{ widgetData?.content?.description }}\n                                </p>\n                            </div>\n                        </div>\n                    </mat-card-content>\n                </ng-container>\n            </a>\n        </ng-container>\n    </div>\n</mat-card>",
+                    styles: [".card-users-container{position:relative;width:282px;min-height:281px;border-radius:8px;box-sizing:border-box;box-shadow:0 10px 30px rgba(153,153,153,.2);overflow:hidden;height:281px;margin:16px 8px}.card-users-container .course_logo_box{width:38px;height:38px;background:#fff;border-radius:8px;box-sizing:border-box;box-shadow:0 2px 1px -1px rgba(0,0,0,.2),0 1px 1px 0 rgba(0,0,0,.14),0 1px 3px 0 rgba(0,0,0,.12)}.card-users-container .course_logo_box img{height:28px;width:28px;padding:5px;display:inline-block}.card-users-container .course_logo_box p{display:inline-block;vertical-align:top}.card-users-container .org-text{font-size:12px;font-weight:400;width:75%;padding-left:10px;word-break:break-all;white-space:initial;overflow:hidden;text-overflow:ellipsis;display:-webkit-box;-webkit-line-clamp:1;-webkit-box-orient:vertical}.card-users-container mat-card-content{background:#fff}.card-users-container .card-img{min-width:245px;max-height:140px;min-height:140px;display:block;-o-object-fit:fill;object-fit:fill;border-top-left-radius:8px;border-top-right-radius:8px;width:100%}.card-users-container .mat-subheading-1{font:600 14px/24px Montserrat}.card-users-container .complexity{padding-top:70px;display:flex;font-size:14px;line-height:21px;padding-bottom:10px}.card-users-container .complexity .mode-tag{border-radius:5px;order:2;margin-left:auto;color:#fff;font-size:10px}.card-users-container .complexity .duration{display:flex;margin-left:auto;order:3;font-weight:700}.card-users-container .complexity .time-text{margin:0 5px 0 6px;font-weight:700}.card-users-container .basic{margin:auto 0}.card-users-container .title-text{word-break:break-all;white-space:initial;margin:8px 0;position:relative;overflow:hidden;text-overflow:ellipsis;display:-webkit-box;-webkit-line-clamp:1;-webkit-box-orient:vertical;min-height:24px}.card-users-container .description-text{position:relative;overflow:hidden;height:63px;white-space:normal;text-overflow:ellipsis}.duration-box{background:#000;position:absolute;border:none;display:flex;align-items:center;padding:4px;border-radius:4px}.duration-box.right-corner{right:4px;bottom:4px}.duration-box .mat-icon{vertical-align:middle;color:#fff!important;height:14px!important;width:14px!important;font-size:14px}.duration-box .duration{font:700 12px/16px Lato;display:inline-block;margin:0;padding:0}"]
                 }] }
     ];
     /** @nocollapse */
@@ -144,4 +144,4 @@ if (false) {
      */
     CardUserComponent.prototype.configSvc;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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