@sunbird-cb/utils-v2 0.0.1

package/esm2015/lib/services/event.service.js

@@ -0,0 +1,211 @@
+import { Inject, Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { WsEvents } from './event.model';
+import { UtilityService } from './utility.service';
+import _ from 'lodash';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "./utility.service";
+export class EventService {
+    constructor(environment, utilitySvc) {
+        this.utilitySvc = utilitySvc;
+        this.todaysEvents = [];
+        this.eventsSubject = new Subject();
+        this.events$ = this.eventsSubject.asObservable();
+        this.eventsChatbotSubject = new Subject();
+        this.chatbotEvents$ = this.eventsChatbotSubject.asObservable();
+        this.eventsGetStartSubject = new Subject();
+        this.getStartEvents$ = this.eventsGetStartSubject.asObservable();
+        this.eventsPRSubject = new Subject();
+        this.getPREvents$ = this.eventsPRSubject.asObservable();
+        this.environment = environment;
+    }
+    dispatchEvent(event) {
+        event.pageContext = this.getContext(event.pageContext);
+        this.eventsSubject.next(event);
+    }
+    dispatchChatbotEvent(event) {
+        this.eventsChatbotSubject.next(event);
+    }
+    dispatchGetStartedEvent(event) {
+        this.eventsGetStartSubject.next(event);
+    }
+    dispatchPlatformRatingEvent(event) {
+        this.eventsPRSubject.next(event);
+    }
+    raiseInteractTelemetry(edata, object, pageContext) {
+        this.dispatchEvent({
+            eventType: WsEvents.WsEventType.Telemetry,
+            eventLogLevel: WsEvents.WsEventLogLevel.Info,
+            data: {
+                edata,
+                object,
+                pageContext: this.getContext(pageContext),
+                eventSubType: WsEvents.EnumTelemetrySubType.Interact,
+            },
+            from: '',
+            to: 'Telemetry',
+        });
+    }
+    raiseFeedbackTelemetry(edata, object, from) {
+        this.dispatchEvent({
+            eventType: WsEvents.WsEventType.Telemetry,
+            eventLogLevel: WsEvents.WsEventLogLevel.Info,
+            data: {
+                edata,
+                object,
+                eventSubType: WsEvents.EnumTelemetrySubType.Feedback,
+            },
+            from: from || '',
+            to: 'Telemetry',
+        });
+    }
+    raiseCustomImpression(object, pageContext) {
+        this.dispatchEvent({
+            eventType: WsEvents.WsEventType.Telemetry,
+            eventLogLevel: WsEvents.WsEventLogLevel.Info,
+            data: {
+                object,
+                pageContext: this.getContext(pageContext),
+                eventSubType: WsEvents.EnumTelemetrySubType.Impression,
+            },
+            from: '',
+            to: 'Telemetry',
+        });
+    }
+    getContext(pageContext) {
+        const routeDataContext = this.utilitySvc.routeData;
+        const finalContext = {
+            pageId: routeDataContext.pageId,
+            module: routeDataContext.module,
+        };
+        if (pageContext) {
+            if (pageContext.pageIdExt) {
+                finalContext.pageId = `${routeDataContext.pageId}_${pageContext.pageIdExt}`;
+            }
+            else if (pageContext.pageId) {
+                finalContext.pageId = pageContext.pageId;
+            }
+            if (pageContext.module) {
+                finalContext.module = pageContext.module;
+            }
+        }
+        return finalContext;
+    }
+    handleTabTelemetry(subType, data, object) {
+        this.raiseInteractTelemetry({
+            subType,
+            type: WsEvents.EnumInteractTypes.CLICK,
+            id: `${_.camelCase(data.label)}-tab`,
+        }, Object.assign({}, object), {
+            pageIdExt: `${_.camelCase(data.label)}-tab`,
+        });
+        this.raiseCustomImpression(Object.assign({ context: {
+                position: data.index,
+            } }, object), {
+            pageIdExt: `${_.camelCase(data.label)}-tab`,
+        });
+    }
+    getPublicUrl(url) {
+        const mainUrl = url.split('/content').pop() || '';
+        return `${this.environment.contentHost}/${this.environment.contentBucket}/content${mainUrl}`;
+    }
+    allEventDateFormat(datetime) {
+        const date = new Date(datetime).getDate();
+        const year = new Date(datetime).getFullYear();
+        const month = new Date(datetime).getMonth();
+        const hours = new Date(datetime).getHours();
+        const minutes = new Date(datetime).getMinutes();
+        const seconds = new Date(datetime).getSeconds();
+        const formatedDate = new Date(year, month, date, hours, minutes, seconds, 0);
+        const format = 'YYYY-MM-DD';
+        const readableDateMonth = moment(formatedDate).format(format);
+        const finalDateTimeValue = `${readableDateMonth}`;
+        return finalDateTimeValue;
+    }
+    compareDate(startDate) {
+        const now = new Date();
+        const day = ('0' + (new Date().getDate())).slice(-2);
+        const year = new Date().getFullYear();
+        const month = ('0' + (now.getMonth() + 1)).slice(-2);
+        const todaysdate = `${year}-${month}-${day}`;
+        if (startDate === todaysdate) {
+            return true;
+        }
+        return false;
+    }
+    customDateFormat(date, time) {
+        const stime = time.split('+')[0];
+        const hour = stime.substr(0, 2);
+        const min = stime.substr(2, 3);
+        return `${date} ${hour}${min}`;
+    }
+    setEventListData(eventObj) {
+        if (eventObj !== undefined) {
+            this.todaysEvents = [];
+            const data = eventObj;
+            Object.keys(data).forEach(((index) => {
+                const obj = data[index];
+                const floor = Math.floor;
+                const hours = floor(obj.duration / 60);
+                const minutes = obj.duration % 60;
+                const duration = (hours === 0) ? ((minutes === 0) ? '---' : `${minutes} minutes`) : (minutes === 0) ? (hours === 1) ?
+                    `${hours} hour` : `${hours} hours` : (hours === 1) ? `${hours} hour ${minutes} minutes` :
+                    `${hours} hours ${minutes} minutes`;
+                const creatordata = obj.creatorDetails !== undefined ? obj.creatorDetails : [];
+                const str = creatordata && creatordata.length > 0 ? creatordata.replace(/\\/g, '') : [];
+                const creatorDetails = str && str.length > 0 ? JSON.parse(str) : creatordata;
+                const stime = obj.startTime.split('+')[0];
+                const hour = stime.substr(0, 2);
+                const min = stime.substr(2, 3);
+                const starttime = `${hour}${min}`;
+                const etime = obj.endTime.split('+')[0];
+                const ehour = etime.substr(0, 2);
+                const emin = etime.substr(2, 3);
+                const endtime = `${ehour}${emin}`;
+                const eventDataObj = {
+                    event: obj,
+                    eventName: obj.name,
+                    eventStartTime: starttime,
+                    eventEndTime: endtime,
+                    eventStartDate: obj.startDate,
+                    eventCreatedOn: this.allEventDateFormat(obj.createdOn),
+                    eventDuration: duration,
+                    eventjoined: creatorDetails.length,
+                    eventThumbnail: obj.appIcon && (obj.appIcon !== null || obj.appIcon !== undefined) ?
+                        this.getPublicUrl(obj.appIcon) :
+                        '/assets/icons/Events_default.png',
+                    pastevent: false,
+                };
+                const isToday = this.compareDate(obj.startDate);
+                if (isToday) {
+                    this.todaysEvents.push(eventDataObj);
+                }
+            }));
+        }
+    }
+}
+EventService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+EventService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: ['environment',] }] },
+    { type: UtilityService }
+];
+/** @nocollapse */ EventService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function EventService_Factory() { return new EventService(i0.ɵɵinject("environment"), i0.ɵɵinject(i1.UtilityService)); }, token: EventService, providedIn: "root" });
+if (false) {
+    EventService.prototype.todaysEvents;
+    EventService.prototype.eventsSubject;
+    EventService.prototype.events$;
+    EventService.prototype.eventsChatbotSubject;
+    EventService.prototype.chatbotEvents$;
+    EventService.prototype.eventsGetStartSubject;
+    EventService.prototype.getStartEvents$;
+    EventService.prototype.eventsPRSubject;
+    EventService.prototype.getPREvents$;
+    EventService.prototype.environment;
+    EventService.prototype.utilitySvc;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event.service.js","sourceRoot":"ng://@sunbird-cb/utils-v2/","sources":["lib/services/event.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Subject } from 'rxjs'\r\nimport { WsEvents } from './event.model'\r\nimport { UtilityService } from './utility.service'\r\n/* tslint:disable*/\r\nimport _ from 'lodash'\r\nimport moment from 'moment'\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class EventService {\r\n  todaysEvents: any = []\r\n  \r\n  private eventsSubject = new Subject<WsEvents.IWsEvents<any>>()\r\n  public events$ = this.eventsSubject.asObservable()\r\n\r\n  private eventsChatbotSubject = new Subject<WsEvents.IWsEvents<any>>()\r\n  public chatbotEvents$ = this.eventsChatbotSubject.asObservable()\r\n\r\n  private eventsGetStartSubject = new Subject<WsEvents.IWsEvents<any>>()\r\n  public getStartEvents$ = this.eventsGetStartSubject.asObservable()\r\n\r\n  private eventsPRSubject = new Subject<WsEvents.IWsEvents<any>>()\r\n  public getPREvents$ = this.eventsPRSubject.asObservable()\r\n\r\n  environment: any\r\n  constructor(\r\n    @Inject('environment') environment: any,\r\n    private utilitySvc: UtilityService,\r\n  ) {\r\n    this.environment = environment\r\n    // this.focusChangeEventListener()\r\n  }\r\n\r\n  dispatchEvent<T>(event: WsEvents.IWsEvents<T>) {\r\n    event.pageContext = this.getContext(event.pageContext)\r\n    this.eventsSubject.next(event)\r\n  }\r\n\r\n  dispatchChatbotEvent<T>(event: WsEvents.IWsEvents<T>) {\r\n    this.eventsChatbotSubject.next(event)\r\n  }\r\n\r\n  dispatchGetStartedEvent<T>(event: WsEvents.IWsEvents<T>) {\r\n    this.eventsGetStartSubject.next(event)\r\n  }\r\n\r\n  dispatchPlatformRatingEvent<T>(event: WsEvents.IWsEvents<T>) {\r\n    this.eventsPRSubject.next(event)\r\n  }\r\n\r\n\r\n  // helper functions\r\n  raiseInteractTelemetry(edata: WsEvents.ITelemetryEdata, object: any, pageContext?: WsEvents.ITelemetryPageContext) {\r\n    this.dispatchEvent<WsEvents.IWsEventTelemetryInteract>({\r\n      eventType: WsEvents.WsEventType.Telemetry,\r\n      eventLogLevel: WsEvents.WsEventLogLevel.Info,\r\n      data: {\r\n        edata,\r\n        object,\r\n        pageContext: this.getContext(pageContext),\r\n        eventSubType: WsEvents.EnumTelemetrySubType.Interact,\r\n      },\r\n      from: '',\r\n      to: 'Telemetry',\r\n    })\r\n  }\r\n\r\n  raiseFeedbackTelemetry(edata: WsEvents.ITelemetryEdata, object: any, from?: string) {\r\n    this.dispatchEvent<WsEvents.IWsEventTelemetryInteract>({\r\n      eventType: WsEvents.WsEventType.Telemetry,\r\n      eventLogLevel: WsEvents.WsEventLogLevel.Info,\r\n      data: {\r\n        edata,\r\n        object,\r\n        eventSubType: WsEvents.EnumTelemetrySubType.Feedback,\r\n      },\r\n      from: from || '',\r\n      to: 'Telemetry',\r\n    })\r\n  }\r\n\r\n  // Raise custom impression events eg:on tab change\r\n  raiseCustomImpression(object: any, pageContext?: WsEvents.ITelemetryPageContext) {\r\n    this.dispatchEvent<WsEvents.IWsEventTelemetryImpression>({\r\n      eventType: WsEvents.WsEventType.Telemetry,\r\n      eventLogLevel: WsEvents.WsEventLogLevel.Info,\r\n      data: {\r\n        object,\r\n        pageContext: this.getContext(pageContext),\r\n        eventSubType: WsEvents.EnumTelemetrySubType.Impression,\r\n      },\r\n      from: '',\r\n      to: 'Telemetry',\r\n    })\r\n  }\r\n\r\n  // private focusChangeEventListener() {\r\n  //   fromEvent(window, 'focus').subscribe(() => {\r\n  //     this.raiseInteractTelemetry('focus', 'gained', {})\r\n  //   })\r\n  //   fromEvent(window, 'blur').subscribe(() => {\r\n  //     this.raiseInteractTelemetry('focus', 'lost', {})\r\n  //   })\r\n  // }\r\n\r\n  // Method to get the context information about the telemetry interact event\r\n  private getContext(pageContext: WsEvents.ITelemetryPageContext | undefined): WsEvents.ITelemetryPageContext {\r\n    const routeDataContext = this.utilitySvc.routeData\r\n    // initialize with the route data configuration - current route's pageID & module\r\n    const finalContext: WsEvents.ITelemetryPageContext = {\r\n      pageId: routeDataContext.pageId,\r\n      module: routeDataContext.module,\r\n    }\r\n    if (pageContext) {\r\n      // if context has pageIdExt, append it to the route's pageId\r\n      if (pageContext.pageIdExt) {\r\n        finalContext.pageId = `${routeDataContext.pageId}_${pageContext.pageIdExt}`\r\n      } else if (pageContext.pageId) {\r\n        // else context has pageId, override it to the final pageID\r\n        finalContext.pageId = pageContext.pageId\r\n      }\r\n      // if context has module, override it to the final module\r\n      if (pageContext.module) {\r\n        finalContext.module = pageContext.module\r\n      }\r\n    }\r\n\r\n    return finalContext\r\n  }\r\n\r\n  public handleTabTelemetry(subType: string, data: WsEvents.ITelemetryTabData, object?:any) {\r\n    // raise a tab click interact event\r\n    this.raiseInteractTelemetry(\r\n      {\r\n        subType,\r\n        type: WsEvents.EnumInteractTypes.CLICK,\r\n        id: `${_.camelCase(data.label)}-tab`,\r\n      },\r\n      {\r\n        // context: {\r\n        //   position: data.index,\r\n        // },\r\n        ...object\r\n      },\r\n      {\r\n      pageIdExt: `${_.camelCase(data.label)}-tab`,\r\n    })\r\n\r\n    // raise a tab click impression event\r\n    this.raiseCustomImpression({\r\n      context: {\r\n            position: data.index,\r\n          },\r\n          ...object\r\n      },{\r\n      pageIdExt: `${_.camelCase(data.label)}-tab`,\r\n    })\r\n  }\r\n\r\n  getPublicUrl(url: string): string {\r\n    const mainUrl = url.split('/content').pop() || ''\r\n    return `${this.environment.contentHost}/${this.environment.contentBucket}/content${mainUrl}`\r\n  }\r\n\r\n  allEventDateFormat(datetime: any) {\r\n    const date = new Date(datetime).getDate()\r\n    const year = new Date(datetime).getFullYear()\r\n    const month = new Date(datetime).getMonth()\r\n    const hours = new Date(datetime).getHours()\r\n    const minutes = new Date(datetime).getMinutes()\r\n    const seconds = new Date(datetime).getSeconds()\r\n    const formatedDate = new Date(year, month, date, hours, minutes, seconds, 0)\r\n    // let format = 'YYYY-MM-DD hh:mm a'\r\n    // if (!timeAllow) {\r\n    const format = 'YYYY-MM-DD'\r\n    // }\r\n    const readableDateMonth = moment(formatedDate).format(format)\r\n    const finalDateTimeValue = `${readableDateMonth}`\r\n    return finalDateTimeValue\r\n  }\r\n\r\n  compareDate(startDate: any) {\r\n    const now = new Date()\r\n\r\n    // tslint:disable-next-line:prefer-template\r\n    const day =  ('0' + (new Date().getDate())).slice(-2)\r\n    const year = new Date().getFullYear()\r\n    // tslint:disable-next-line:prefer-template\r\n    const month = ('0' + (now.getMonth() + 1)).slice(-2)\r\n    const todaysdate = `${year}-${month}-${day}`\r\n    if (startDate === todaysdate)  {\r\n      return true\r\n    }\r\n    return false\r\n  }\r\n\r\n  customDateFormat(date: any, time: any) {\r\n    const stime = time.split('+')[0]\r\n    const hour = stime.substr(0, 2)\r\n    const min = stime.substr(2, 3)\r\n    return `${date} ${hour}${min}`\r\n }\r\n\r\n\r\n setEventListData(eventObj: any) {\r\n  if (eventObj !== undefined) {\r\n    this.todaysEvents = []\r\n    const data = eventObj\r\n   // console.log('strip comp', data)\r\n    Object.keys(data).forEach((index: any) => {\r\n      const obj = data[index]\r\n      const floor = Math.floor\r\n      const hours = floor(obj.duration / 60)\r\n      const minutes = obj.duration % 60\r\n      const duration = (hours === 0) ? ((minutes === 0) ? '---' : `${minutes} minutes`) : (minutes === 0) ? (hours === 1) ?\r\n        `${hours} hour` : `${hours} hours` : (hours === 1) ? `${hours} hour ${minutes} minutes` :\r\n        `${hours} hours ${minutes} minutes`\r\n      const creatordata = obj.creatorDetails !== undefined ? obj.creatorDetails : []\r\n      const str = creatordata && creatordata.length > 0 ? creatordata.replace(/\\\\/g, '') : []\r\n      const creatorDetails = str && str.length > 0 ? JSON.parse(str) : creatordata\r\n\r\n      const stime = obj.startTime.split('+')[0]\r\n      const hour = stime.substr(0, 2)\r\n      const min = stime.substr(2, 3)\r\n      const starttime = `${hour}${min}`\r\n\r\n      const etime = obj.endTime.split('+')[0]\r\n      const ehour = etime.substr(0, 2)\r\n      const emin = etime.substr(2, 3)\r\n      const endtime = `${ehour}${emin}`\r\n\r\n      const eventDataObj = {\r\n        event: obj,\r\n        eventName: obj.name,\r\n        eventStartTime: starttime,\r\n        eventEndTime: endtime,\r\n        eventStartDate: obj.startDate,\r\n        eventCreatedOn: this.allEventDateFormat(obj.createdOn),\r\n        eventDuration: duration,\r\n        eventjoined: creatorDetails.length,\r\n        eventThumbnail: obj.appIcon && (obj.appIcon !== null || obj.appIcon !== undefined) ?\r\n          this.getPublicUrl(obj.appIcon) :\r\n          '/assets/icons/Events_default.png',\r\n        pastevent: false,\r\n      }\r\n      const isToday = this.compareDate(obj.startDate)\r\n      if (isToday) {\r\n        this.todaysEvents.push(eventDataObj)\r\n      }\r\n    })\r\n  }\r\n}\r\n}\r\n"]}

package/esm2015/lib/services/logger.service.js

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import { ConfigurationsService } from './configurations.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./configurations.service";
+export class LoggerService {
+    constructor(configSvc) {
+        this.configSvc = configSvc;
+        this.consoleError = console.error;
+        this.consoleInfo = console.info;
+        this.consoleLog = console.log;
+        this.consoleWarn = console.warn;
+        this.noConsole = (() => { });
+    }
+    get error() {
+        return this.consoleError;
+    }
+    get info() {
+        return this.configSvc.isProduction ? this.noConsole : this.consoleInfo;
+    }
+    get log() {
+        return this.configSvc.isProduction ? this.noConsole : this.consoleLog;
+    }
+    get warn() {
+        return this.configSvc.isProduction ? this.noConsole : this.consoleWarn;
+    }
+    removeConsoleAccess() {
+        if (this.configSvc.isProduction) {
+            return;
+        }
+        const noConsoleWithError = (() => {
+            throw new Error('Console Functions Usage Are Not Allowed.');
+        });
+        console.warn = noConsoleWithError;
+        console.info = noConsoleWithError;
+        console.error = noConsoleWithError;
+    }
+}
+LoggerService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+LoggerService.ctorParameters = () => [
+    { type: ConfigurationsService }
+];
+/** @nocollapse */ LoggerService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function LoggerService_Factory() { return new LoggerService(i0.ɵɵinject(i1.ConfigurationsService)); }, token: LoggerService, providedIn: "root" });
+if (false) {
+    LoggerService.prototype.consoleError;
+    LoggerService.prototype.consoleInfo;
+    LoggerService.prototype.consoleLog;
+    LoggerService.prototype.consoleWarn;
+    LoggerService.prototype.noConsole;
+    LoggerService.prototype.configSvc;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/ms-office.model.js

@@ -0,0 +1,8 @@
+export function IWsMsTokenModelResponse() { }
+if (false) {
+    IWsMsTokenModelResponse.prototype.accessToken;
+    IWsMsTokenModelResponse.prototype.expiresOn;
+    IWsMsTokenModelResponse.prototype.resource;
+    IWsMsTokenModelResponse.prototype.tokenType;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXMtb2ZmaWNlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHN1bmJpcmQtY2IvdXRpbHMtdjIvIiwic291cmNlcyI6WyJsaWIvc2VydmljZXMvbXMtb2ZmaWNlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDZDQUtDOztJQUpDLDhDQUFvQjtJQUNwQiw0Q0FBa0I7SUFDbEIsMkNBQWlCO0lBQ2pCLDRDQUFrQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgSVdzTXNUb2tlbk1vZGVsUmVzcG9uc2Uge1xyXG4gIGFjY2Vzc1Rva2VuPzogc3RyaW5nXHJcbiAgZXhwaXJlc09uPzogc3RyaW5nXHJcbiAgcmVzb3VyY2U/OiBzdHJpbmdcclxuICB0b2tlblR5cGU/OiBzdHJpbmdcclxufVxyXG4iXX0=

package/esm2015/lib/services/multilingual-translations.service.js

@@ -0,0 +1,136 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject } from 'rxjs';
+import { ConfigurationsService } from './configurations.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@angular/common/http";
+import * as i3 from "./configurations.service";
+export class MultilingualTranslationsService {
+    constructor(translate, http, configSvc) {
+        this.translate = translate;
+        this.http = http;
+        this.configSvc = configSvc;
+        this.selectedLang = '';
+        this.languageSelected = new BehaviorSubject(true);
+        this.languageSelectedObservable = this.languageSelected.asObservable();
+        this.editProfileDetails = '/apis/proxies/v8/user/v1/extPatch';
+    }
+    getLanguage() {
+        if (this.configSvc.unMappedUser) {
+            if (this.configSvc.unMappedUser.profileDetails &&
+                this.configSvc.unMappedUser.profileDetails.additionalProperties &&
+                this.configSvc.unMappedUser.profileDetails.additionalProperties.webPortalLang) {
+                const lang = this.configSvc.unMappedUser.profileDetails.additionalProperties.webPortalLang;
+                this.translate.use(lang);
+                localStorage.setItem('websiteLanguage', lang);
+            }
+            else {
+                if (localStorage.getItem('websiteLanguage')) {
+                    let lang = JSON.stringify(localStorage.getItem('websiteLanguage'));
+                    lang = lang.replace(/\"/g, '');
+                    this.translate.use(lang);
+                }
+                else {
+                    this.translate.setDefaultLang('en');
+                    localStorage.setItem('websiteLanguage', 'en');
+                }
+            }
+        }
+        else {
+            if (localStorage.getItem('websiteLanguage')) {
+                let lang = JSON.stringify(localStorage.getItem('websiteLanguage'));
+                lang = lang.replace(/\"/g, '');
+                this.translate.use(lang);
+            }
+        }
+    }
+    translateLabelWithoutspace(label, type, subtype) {
+        let nlabel = label;
+        nlabel = nlabel && nlabel.replace(/\s/g, '');
+        if (subtype) {
+            const translationKey = type + '.' + nlabel + subtype;
+            return this.translate.instant(translationKey);
+        }
+        const translationKeyn = type + '.' + nlabel;
+        return this.translate.instant(translationKeyn);
+    }
+    translateLabel(label, type, subtype) {
+        let nlabel = label;
+        nlabel = nlabel.toLowerCase();
+        const sl = nlabel.split(' ');
+        sl.forEach(((w, index) => {
+            if (index !== 0) {
+                sl[index] = w[0].toUpperCase() + w.slice(1);
+            }
+        }));
+        nlabel = sl.join('');
+        nlabel = nlabel.replace(/\s/g, '');
+        if (subtype) {
+            const translationKey = type + '.' + nlabel + subtype;
+            return this.translate.instant(translationKey);
+        }
+        const translationKeyn = type + '.' + nlabel;
+        return this.translate.instant(translationKeyn);
+    }
+    translateActualLabel(label, type, subtype) {
+        let nlabel = label;
+        const sl = nlabel.split(' ');
+        sl.forEach(((w, index) => {
+            if (index !== 0) {
+                sl[index] = w[0].toUpperCase() + w.slice(1);
+            }
+        }));
+        nlabel = sl.join('');
+        nlabel = nlabel.replace(/\s/g, '');
+        if (subtype) {
+            const translationKey = type + '.' + nlabel + subtype;
+            return this.translate.instant(translationKey);
+        }
+        const translationKeyn = type + '.' + nlabel;
+        return this.translate.instant(translationKeyn);
+    }
+    editProfileDetailsAPI(data) {
+        return this.http.post(this.editProfileDetails, data);
+    }
+    updatelanguageSelected(state, lang, userid) {
+        this.languageSelected.next(state);
+        this.translate.use(lang);
+        this.selectedLang = lang;
+        if (userid) {
+            const reqUpdates = {
+                request: {
+                    userId: userid,
+                    profileDetails: {
+                        additionalProperties: {
+                            webPortalLang: this.selectedLang,
+                        },
+                    },
+                },
+            };
+            this.editProfileDetailsAPI(reqUpdates).subscribe();
+        }
+    }
+}
+MultilingualTranslationsService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+MultilingualTranslationsService.ctorParameters = () => [
+    { type: TranslateService },
+    { type: HttpClient },
+    { type: ConfigurationsService }
+];
+/** @nocollapse */ MultilingualTranslationsService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function MultilingualTranslationsService_Factory() { return new MultilingualTranslationsService(i0.ɵɵinject(i1.TranslateService), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.ConfigurationsService)); }, token: MultilingualTranslationsService, providedIn: "root" });
+if (false) {
+    MultilingualTranslationsService.prototype.selectedLang;
+    MultilingualTranslationsService.prototype.languageSelected;
+    MultilingualTranslationsService.prototype.languageSelectedObservable;
+    MultilingualTranslationsService.prototype.editProfileDetails;
+    MultilingualTranslationsService.prototype.translate;
+    MultilingualTranslationsService.prototype.http;
+    MultilingualTranslationsService.prototype.configSvc;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multilingual-translations.service.js","sourceRoot":"ng://@sunbird-cb/utils-v2/","sources":["lib/services/multilingual-translations.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http'\nimport { Injectable } from '@angular/core'\nimport { TranslateService } from '@ngx-translate/core'\nimport { BehaviorSubject } from 'rxjs'\nimport { ConfigurationsService } from './configurations.service'\n\n@Injectable({\n    providedIn: 'root',\n})\n\nexport class MultilingualTranslationsService {\n    selectedLang = ''\n    // website lang change\n    languageSelected = new BehaviorSubject(true)\n    languageSelectedObservable = this.languageSelected.asObservable()\n    editProfileDetails = '/apis/proxies/v8/user/v1/extPatch'\n\n    constructor(private translate: TranslateService, private http: HttpClient, private configSvc: ConfigurationsService) {\n    //    this.getLanguage()\n    }\n\n    getLanguage() {\n        if (this.configSvc.unMappedUser) {\n            if (this.configSvc.unMappedUser.profileDetails &&\n                this.configSvc.unMappedUser.profileDetails.additionalProperties &&\n                this.configSvc.unMappedUser.profileDetails.additionalProperties.webPortalLang) {\n              const lang = this.configSvc.unMappedUser.profileDetails.additionalProperties.webPortalLang\n              this.translate.use(lang)\n              localStorage.setItem('websiteLanguage', lang)\n            } else {\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              } else {\n                this.translate.setDefaultLang('en')\n                localStorage.setItem('websiteLanguage', 'en')\n              }\n            }\n        } else {\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        }\n    }\n\n    translateLabelWithoutspace(label: string, type: any, subtype: any) {\n        let nlabel = label\n        nlabel = nlabel && nlabel.replace(/\\s/g, '')\n        if (subtype) {\n            // tslint:disable-next-line: prefer-template\n            const translationKey = type + '.' +  nlabel + subtype\n            return this.translate.instant(translationKey)\n        }\n        // tslint:disable-next-line: prefer-template\n        const translationKeyn = type + '.' +  nlabel\n        return this.translate.instant(translationKeyn)\n    }\n\n    translateLabel(label: string, type: any, subtype: any) {\n        let nlabel = label\n        nlabel = nlabel.toLowerCase()\n        const sl = nlabel.split(' ')\n        sl.forEach((w: any, index: any) => {\n            if (index !== 0) {\n                sl[index] = w[0].toUpperCase() + w.slice(1)\n            }\n        })\n        nlabel = sl.join('')\n        nlabel = nlabel.replace(/\\s/g, '')\n        if (subtype) {\n            // tslint:disable-next-line: prefer-template\n          const translationKey = type + '.' +  nlabel + subtype\n          return this.translate.instant(translationKey)\n        }\n        // tslint:disable-next-line: prefer-template\n        const translationKeyn = type + '.' +  nlabel\n        return this.translate.instant(translationKeyn)\n    }\n\n    translateActualLabel(label: string, type: any, subtype: any) {\n        let nlabel = label\n        const sl = nlabel.split(' ')\n        sl.forEach((w: any, index: any) => {\n            if (index !== 0) {\n                sl[index] = w[0].toUpperCase() + w.slice(1)\n            }\n        })\n        nlabel = sl.join('')\n        nlabel = nlabel.replace(/\\s/g, '')\n        if (subtype) {\n            // tslint:disable-next-line: prefer-template\n          const translationKey = type + '.' +  nlabel + subtype\n          return this.translate.instant(translationKey)\n        }\n        // tslint:disable-next-line: prefer-template\n        const translationKeyn = type + '.' +  nlabel\n        return this.translate.instant(translationKeyn)\n    }\n\n    editProfileDetailsAPI(data: any) {\n        return this.http.post<any>(this.editProfileDetails, data)\n    }\n\n    updatelanguageSelected(state: any, lang: any, userid: any) {\n        this.languageSelected.next(state)\n        this.translate.use(lang)\n        this.selectedLang = lang\n\n       if (userid) {\n        const reqUpdates = {\n            request: {\n              userId: userid,\n              profileDetails: {\n                additionalProperties: {\n                    webPortalLang: this.selectedLang,\n                },\n              },\n            },\n        }\n        this.editProfileDetailsAPI(reqUpdates).subscribe()\n       }\n    }\n}\n"]}

package/esm2015/lib/services/nps-grid.service.js

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+const ɵ0 = (id) => `/apis/proxies/v8/user/v1/feed/${id}`, ɵ1 = (id) => `/apis/proxies/v8/forms/getFormById?id=${id}`;
+const API_END_POINTS = {
+    readFeed: (ɵ0),
+    getFormID: (ɵ1),
+    submitForm: `/apis/proxies/v8/forms/v1/saveFormSubmit`,
+    deleteFeed: `/apis/proxies/v8/user/feed/v1/delete`,
+};
+export class NPSGridService {
+    constructor(http) {
+        this.http = http;
+        this.telemetryEvents = new BehaviorSubject(false);
+        this.updateTelemetryDataObservable = this.telemetryEvents.asObservable();
+    }
+    updateTelemetryData(state) {
+        this.telemetryEvents.next(state);
+    }
+    getFeedStatus(id) {
+        return this.http.get(API_END_POINTS.readFeed(id));
+    }
+    getFormData(formid) {
+        return this.http.get(API_END_POINTS.getFormID(formid));
+    }
+    submitPlatformRating(req) {
+        return this.http.post(API_END_POINTS.submitForm, req);
+    }
+    deleteFeed(req) {
+        return this.http.post(API_END_POINTS.deleteFeed, req);
+    }
+}
+NPSGridService.decorators = [
+    { type: Injectable }
+];
+NPSGridService.ctorParameters = () => [
+    { type: HttpClient }
+];
+if (false) {
+    NPSGridService.prototype.telemetryEvents;
+    NPSGridService.prototype.updateTelemetryDataObservable;
+    NPSGridService.prototype.http;
+}
+export { ɵ0, ɵ1 };
+//# sourceMappingURL=data:application/json;base64,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