@sunbird-cb/utils-v2 0.0.0-watch

package/esm2022/lib/services/auth-keycloak.service.mjs

@@ -0,0 +1,124 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./configurations.service";
+import * as i3 from "./auth-microsoft.service";
+const storage = localStorage;
+const storageKey = 'kc';
+export class AuthKeycloakService {
+    constructor(http, configSvc, msAuthSvc, environment) {
+        this.http = http;
+        this.configSvc = configSvc;
+        this.msAuthSvc = msAuthSvc;
+        this.loginChangeSubject = new ReplaySubject(1);
+        this.loginChangeSubject.subscribe((isLoggedIn) => {
+            this.configSvc.isAuthenticated = isLoggedIn;
+            if (isLoggedIn &&
+                this.configSvc.instanceConfig &&
+                Boolean(this.configSvc.instanceConfig.disablePidCheck)) {
+                this.configSvc.userProfile = {
+                    email: '',
+                    userName: '',
+                    userId: '',
+                };
+            }
+        });
+        this.environment = environment;
+    }
+    get isLoggedIn$() {
+        return this.loginChangeSubject.asObservable();
+    }
+    async initAuth() {
+        if (!this.configSvc.instanceConfig) {
+            return false;
+        }
+        const instanceConfig = this.configSvc.instanceConfig;
+        if (instanceConfig.microsoft.isConfigured) {
+            this.msAuthSvc.init({ microsoft: instanceConfig.microsoft });
+        }
+        try {
+            this.setupGlobalAuthResponder();
+            this.addKeycloakEventListener();
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    loginV2(_idpHint = 'E', redirectUrl = this.defaultRedirectUrl) {
+        if (this.configSvc.instanceConfig) {
+            window.location.href = this.configSvc.instanceConfig.keycloak.url + redirectUrl;
+            return Promise.resolve();
+        }
+        return Promise.reject();
+    }
+    async logout(redirectUrl = this.defaultRedirectUrl) {
+        if (storage.getItem('telemetrySessionId')) {
+            storage.removeItem('telemetrySessionId');
+        }
+        try {
+            sessionStorage.clear();
+            localStorage.clear();
+        }
+        catch {
+        }
+        storage.removeItem(storageKey);
+        window.location.href = `${redirectUrl}apis/reset`;
+    }
+    async force_logout() {
+        if (storage.getItem('telemetrySessionId')) {
+            storage.removeItem('telemetrySessionId');
+        }
+        else {
+            storage.removeItem(storageKey);
+            window.location.href = `https://${this.environment.sitePath}/apis/reset`;
+            await this.http.get('https://admin-test.ecornell.com/saml/logout.do').toPromise();
+        }
+        try {
+            sessionStorage.clear();
+            localStorage.clear();
+        }
+        catch {
+        }
+        storage.removeItem(storageKey);
+        window.location.href = `https://${this.environment.sitePath}/apis/reset`;
+        await this.http.get('https://admin-test.ecornell.com/saml/logout.do').toPromise();
+    }
+    openInvisibleIframe(url) {
+        const iframe = document.createElement('iframe');
+        iframe.src = url;
+        iframe.style.position = 'absolute';
+        iframe.style.width = '0';
+        iframe.style.height = '0';
+        iframe.style.border = 'none';
+        iframe.style.visibility = 'hidden';
+        iframe.style.opacity = '0';
+        document.body.appendChild(iframe);
+    }
+    addKeycloakEventListener() {
+    }
+    setupGlobalAuthResponder() {
+    }
+    get defaultRedirectUrl() {
+        try {
+            const baseUrl = document.baseURI;
+            return baseUrl || location.origin;
+        }
+        catch (error) {
+            return location.origin;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthKeycloakService, deps: [{ token: i1.HttpClient }, { token: i2.ConfigurationsService }, { token: i3.AuthMicrosoftService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthKeycloakService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthKeycloakService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigurationsService }, { type: i3.AuthMicrosoftService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-keycloak.service.js","sourceRoot":"","sources":["../../../../../../library/sunbird-cb/utils-v2/src/lib/services/auth-keycloak.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http'\r\nimport { Inject, Injectable } from '@angular/core'\r\n// import { KeycloakEvent, KeycloakEventType, KeycloakInitOptions, KeycloakService } from 'keycloak-angular'\r\nimport { ReplaySubject } from 'rxjs'\r\n// import { filter } from 'rxjs/operators'\r\nimport { AuthMicrosoftService } from './auth-microsoft.service'\r\nimport { ConfigurationsService } from './configurations.service'\r\n\r\n// interface IParsedToken {\r\n//   email?: string\r\n//   encEmail?: string\r\n//   name?: string\r\n//   preferred_username?: string\r\n// }\r\n\r\nconst storage = localStorage\r\nconst storageKey = 'kc'\r\n// const logoutRedirectUrl = ''\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class AuthKeycloakService {\r\n  environment: any\r\n  private loginChangeSubject = new ReplaySubject<boolean>(1)\r\n  constructor(\r\n    private http: HttpClient,\r\n    private configSvc: ConfigurationsService,\r\n    // private keycloakSvc: KeycloakService,\r\n    private msAuthSvc: AuthMicrosoftService,\r\n    @Inject('environment') environment: any,\r\n  ) {\r\n    this.loginChangeSubject.subscribe((isLoggedIn: boolean) => {\r\n      this.configSvc.isAuthenticated = isLoggedIn\r\n      if (\r\n        isLoggedIn &&\r\n        this.configSvc.instanceConfig &&\r\n        Boolean(this.configSvc.instanceConfig.disablePidCheck)\r\n      ) {\r\n        this.configSvc.userProfile = {\r\n          email: '',\r\n          userName: '',\r\n          userId: '',\r\n        }\r\n      }\r\n    })\r\n    this.environment = environment\r\n  }\r\n\r\n  // Getters\r\n  get isLoggedIn$() {\r\n    return this.loginChangeSubject.asObservable()\r\n  }\r\n  // get isLoggedIn(): Promise<boolean> {\r\n  //   return this.keycloakSvc.isLoggedIn()\r\n  // }\r\n  // get isAuthenticated(): boolean | undefined {\r\n  //   return this.keycloakSvc.getKeycloakInstance().authenticated\r\n  // }\r\n  // get token(): string | undefined {\r\n  //   return this.keycloakSvc.getKeycloakInstance().token\r\n  // }\r\n  // get sessionId(): string | undefined {\r\n  //   return this.keycloakSvc.getKeycloakInstance().sessionId\r\n  // }\r\n  // get userId(): string | undefined {\r\n  //   const kc = this.keycloakSvc.getKeycloakInstance()\r\n  //   if (!kc) {\r\n  //     return\r\n  //   }\r\n  //   return (kc.tokenParsed && kc.tokenParsed.sub) || (kc.idTokenParsed && kc.idTokenParsed.sub)\r\n  // }\r\n\r\n  // get userEmail(): string | undefined {\r\n  //   const kc = this.keycloakSvc.getKeycloakInstance()\r\n\r\n  //   const tokenParsed = kc.tokenParsed as IParsedToken\r\n  //   const idTokenParsed = kc.idTokenParsed as IParsedToken\r\n  //   return (\r\n  //     (tokenParsed && tokenParsed.email) ||\r\n  //     (idTokenParsed && idTokenParsed.email) ||\r\n  //     (idTokenParsed && idTokenParsed.encEmail) ||\r\n  //     (tokenParsed && tokenParsed.preferred_username) ||\r\n  //     (idTokenParsed && idTokenParsed.preferred_username)\r\n  //   )\r\n  // }\r\n\r\n  // get userName(): string | undefined {\r\n  //   const kc = this.keycloakSvc.getKeycloakInstance()\r\n  //   return (\r\n  //     (kc.tokenParsed && (kc.tokenParsed as IParsedToken).name) ||\r\n  //     (kc.idTokenParsed && (kc.idTokenParsed as IParsedToken).name)\r\n  //   )\r\n  // }\r\n\r\n  async initAuth(): Promise<boolean> {\r\n    if (!this.configSvc.instanceConfig) {\r\n      return false\r\n    }\r\n    const instanceConfig = this.configSvc.instanceConfig\r\n    if (instanceConfig.microsoft.isConfigured) {\r\n      this.msAuthSvc.init({ microsoft: instanceConfig.microsoft })\r\n    }\r\n    try {\r\n      this.setupGlobalAuthResponder()\r\n      this.addKeycloakEventListener()\r\n      // return await this.keycloakSvc.init({\r\n      //   config: {\r\n      //     url: instanceConfig.keycloak.url,\r\n      //     realm: instanceConfig.keycloak.realm,\r\n      //     clientId: instanceConfig.keycloak.clientId,\r\n      //   },\r\n      //   initOptions: {\r\n      //     ...this.getSavedKcConfig(),\r\n      //     onLoad: instanceConfig.keycloak.onLoad || 'check-sso',\r\n      //     checkLoginIframe: false,\r\n      //   },\r\n      //   enableBearerInterceptor: true,\r\n      //   loadUserProfileAtStartUp: false,\r\n      //   bearerExcludedUrls: instanceConfig.keycloak.bearerExcludedUrls,\r\n      // })\r\n      return true\r\n    } catch (err) {\r\n      return false\r\n    }\r\n  }\r\n\r\n  // login(\r\n  //   idpHint: 'E' | 'N' | 'S' = 'E',\r\n  //   redirectUrl: string = this.defaultRedirectUrl,\r\n  // ): Promise<void> {\r\n  //   return this.keycloakSvc.login({\r\n  //     idpHint,\r\n  //     redirectUri: redirectUrl,\r\n  //   })\r\n  // }\r\n  loginV2(\r\n    _idpHint: 'E' | 'N' | 'S' = 'E',\r\n    redirectUrl: string = this.defaultRedirectUrl,\r\n  ): Promise<void> {\r\n    if (this.configSvc.instanceConfig) {\r\n      window.location.href = this.configSvc.instanceConfig.keycloak.url + redirectUrl\r\n      return Promise.resolve()\r\n    }\r\n    return Promise.reject()\r\n  }\r\n  // register(\r\n  //   redirectUrl: string = this.defaultRedirectUrl,\r\n  // ): Promise<void> {\r\n  //   return this.keycloakSvc.register({\r\n  //     redirectUri: redirectUrl,\r\n  //   })\r\n  // }\r\n  /**\r\n   * @deprecated this will be depricated\r\n   */\r\n  async logout(redirectUrl = this.defaultRedirectUrl) {\r\n    if (storage.getItem('telemetrySessionId')) {\r\n      storage.removeItem('telemetrySessionId')\r\n    }\r\n    try {\r\n      sessionStorage.clear()\r\n      localStorage.clear()\r\n    } catch {\r\n\r\n    }\r\n    storage.removeItem(storageKey)\r\n    // alert(`${redirectUrl}apis/reset`)\r\n    window.location.href = `${redirectUrl}apis/reset`\r\n\r\n    // window.location.href = 'http://localhost:3003/reset'\r\n    //  await this.http.get('/apis/reset').toPromise()\r\n    // setTimeout(window.location.href = `${redirectUrl}apis/reset`, 13000)\r\n    // logoutRedirectUrl = redirectUrl\r\n    // if (this.msAuthSvc.isLogoutRequired) {\r\n    //   this.keycloakSvc.logout(this.msAuthSvc.logoutUrl(redirectUrl))\r\n    // } else {\r\n    // this.keycloakSvc.logout(redirectUrl)\r\n    // }\r\n  }\r\n  async force_logout() {\r\n    if (storage.getItem('telemetrySessionId')) {\r\n      storage.removeItem('telemetrySessionId')\r\n    } else {\r\n      // window.location.href = '/public/home'\r\n      storage.removeItem(storageKey)\r\n      // window.location.href = `${this.environment.staticHomePageUrl}`\r\n      // await this.http.get(`https://${this.environment.sitePath}/apis/reset`).toPromise()\r\n      // this.openInvisibleIframe(`https://${this.environment.sitePath}/apis/reset`)\r\n      window.location.href = `https://${this.environment.sitePath}/apis/reset`\r\n      await this.http.get('https://admin-test.ecornell.com/saml/logout.do').toPromise()\r\n\r\n\r\n    }\r\n    try {\r\n      sessionStorage.clear()\r\n      localStorage.clear()\r\n    } catch {\r\n\r\n    }\r\n    storage.removeItem(storageKey)\r\n    // window.location.href = `${this.environment.staticHomePageUrl}`\r\n    //await this.http.get(`https://${this.environment.sitePath}/apis/reset`).toPromise()\r\n    window.location.href = `https://${this.environment.sitePath}/apis/reset`\r\n    // this.openInvisibleIframe(`https://${this.environment.sitePath}/apis/reset`)\r\n    // window.location.href = `${this.environment.staticHomePageUrl}`\r\n    await this.http.get('https://admin-test.ecornell.com/saml/logout.do').toPromise()\r\n\r\n\r\n  }\r\n\r\n  openInvisibleIframe(url: string): void {\r\n    // Create an iframe element\r\n    const iframe = document.createElement('iframe')\r\n\r\n    // Set iframe attributes and make it invisible\r\n    iframe.src = url // The URL you want to load\r\n    iframe.style.position = 'absolute'\r\n    iframe.style.width = '0'\r\n    iframe.style.height = '0'\r\n    iframe.style.border = 'none'\r\n    iframe.style.visibility = 'hidden' // Alternatively, use display: none\r\n    iframe.style.opacity = '0' // Make it invisible, while still loading content\r\n\r\n    // Append the iframe to the body or any specific container element\r\n    document.body.appendChild(iframe)\r\n  }\r\n\r\n  private addKeycloakEventListener() {\r\n    // this.keycloakSvc.keycloakEvents$.subscribe((event: KeycloakEvent) => {\r\n    //   switch (event.type) {\r\n    //     case KeycloakEventType.OnAuthError:\r\n    //       this.loginChangeSubject.next(false)\r\n    //       break\r\n    //     case KeycloakEventType.OnAuthLogout:\r\n    //       this.loginChangeSubject.next(false)\r\n    //       storage.removeItem(storageKey)\r\n    //       break\r\n    //     case KeycloakEventType.OnAuthRefreshError:\r\n    //       break\r\n    //     case KeycloakEventType.OnAuthRefreshSuccess:\r\n    //       break\r\n    //     case KeycloakEventType.OnAuthSuccess:\r\n    //       break\r\n    //     case KeycloakEventType.OnReady:\r\n    //       this.loginChangeSubject.next(event.args)\r\n    //       if (event.args) {\r\n    //         this.saveKeycloakConfig()\r\n    //       }\r\n    //       break\r\n    //     case KeycloakEventType.OnTokenExpired:\r\n    //       this.keycloakSvc.updateToken(60)\r\n    //       break\r\n    //   }\r\n    // })\r\n  }\r\n\r\n  private setupGlobalAuthResponder() {\r\n    // fromEvent<MessageEvent>(window, 'message')\r\n    //   .pipe(\r\n    //     filter(\r\n    //       (event: MessageEvent) =>\r\n    //         Boolean(event) &&\r\n    //         Boolean(event.data) &&\r\n    //         event.data.type === 'AUTH_REQUEST' &&\r\n    //         Boolean(event.source && typeof event.source.postMessage === 'function'),\r\n    //     ),\r\n    //   )\r\n    //   .subscribe(async (event: MessageEvent) => {\r\n    //     const contentWindow = event.source as Window\r\n    //     const token = await this.keycloakSvc.getToken()\r\n    //     const response = {\r\n    //       app: 'WEB_PORTAL',\r\n    //       type: 'AUTH_RESPONSE',\r\n    //       state: 'NONE',\r\n    //       plugin: 'NONE',\r\n    //       data: {\r\n    //         token,\r\n    //         id: event.data && event.data.data && event.data.data.id,\r\n    //       },\r\n    //     }\r\n    //     contentWindow.postMessage(response, '*')\r\n    //   })\r\n  }\r\n\r\n  // Utility Methods\r\n  // private saveKeycloakConfig() {\r\n  //   // const kc = this.keycloakSvc.getKeycloakInstance()\r\n  //   // const kcInitOptions: KeycloakInitOptions = {\r\n  //   //   idToken: kc.idToken,\r\n  //   //   refreshToken: kc.refreshToken,\r\n  //   //   timeSkew: kc.timeSkew,\r\n  //   //   token: kc.token,\r\n  //   // }\r\n  //   // storage.setItem(storageKey, JSON.stringify(kcInitOptions))\r\n  // }\r\n  // private getSavedKcConfig(): KeycloakInitOptions {\r\n  //   try {\r\n  //     // const lastSaved = KEYCLOAK_STORAGE.getItem(key);\r\n  //     const lastSaved = storage.getItem(storageKey)\r\n  //     if (lastSaved) {\r\n  //       const processed = JSON.parse(lastSaved)\r\n  //       if (\r\n  //         'idToken' in processed &&\r\n  //         'refreshToken' in processed &&\r\n  //         'timeSkew' in processed &&\r\n  //         'token' in processed\r\n  //       ) {\r\n  //         return processed\r\n  //       }\r\n  //     }\r\n  //   } catch (e) { }\r\n  //   return {}\r\n  // }\r\n\r\n  private get defaultRedirectUrl(): string {\r\n    try {\r\n      const baseUrl = document.baseURI\r\n      return baseUrl || location.origin\r\n    } catch (error) {\r\n      return location.origin\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/services/auth-microsoft.service.mjs

@@ -0,0 +1,173 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./logger.service";
+import * as i2 from "@angular/common/http";
+const msTokenExpiryDuration = 600;
+const storageKey = 'msLoginRequested';
+const storage = localStorage;
+const API_ENDPOINTS = {
+    sharePointToken: '/apis/protected/v8/user/token',
+};
+export class AuthMicrosoftService {
+    constructor(loggerSvc, http) {
+        this.loggerSvc = loggerSvc;
+        this.http = http;
+        this.msConfig = {
+            clientId: '',
+            tenant: '',
+            defaultEmailId: '',
+            validEmailExtensions: [],
+            isConfigured: false,
+        };
+        this.emailUsed = null;
+        this.code = null;
+        this.msToken = {
+            accessToken: '',
+            expiresOn: '',
+            resource: '',
+            tokenType: '',
+        };
+    }
+    get isLogoutRequired() {
+        return Boolean(this.msConfig.isConfigured && this.msConfig.clientId && this.emailUsed);
+    }
+    get loginUrl() {
+        if (this.msConfig.isConfigured && this.msConfig.clientId) {
+            const base = 'https://login.windows.net/common/oauth2/authorize';
+            const searchParam = new URLSearchParams({
+                response_type: 'code',
+                client_id: this.msConfig.clientId,
+                redirect_uri: window.location.href,
+            });
+            const fragment = location.search.substring(1);
+            if (fragment) {
+                return `${base}?${searchParam.toString()}#${fragment}`;
+            }
+            return `${base}?${searchParam.toString()}`;
+        }
+        return null;
+    }
+    logoutUrl(redirectUrl) {
+        if (this.isValidEmail(this.emailUsed || '')) {
+            return `https://login.microsoftonline.com/common/oauth2/logout?post_logout_redirect_uri=${redirectUrl}`;
+        }
+        return redirectUrl;
+    }
+    async init(config) {
+        if (!config || !config.microsoft || !config.microsoft.isConfigured) {
+            this.loggerSvc.warn('Empty/No Configuration passed, ignoring Microsoft Authentication');
+        }
+        this.msConfig = config.microsoft;
+        const queryParams = new URLSearchParams(location.search);
+        if (queryParams.has('code') && queryParams.has('session_state')) {
+            this.code = queryParams.get('code');
+            if (!this.code) {
+                return;
+            }
+            let url = location.origin + location.pathname;
+            await this.exchangeTokenForCode(this.code, url);
+            if (location.hash) {
+                url += location.hash.substring(1);
+            }
+            history.replaceState(null, '', url);
+        }
+    }
+    async login(email) {
+        if (!this.isValidEmail(email)) {
+            this.loggerSvc.warn(`Microsoft Login is not allowed for your emailId (${email})`);
+            return;
+        }
+        const loginUrl = this.loginUrl;
+        if (loginUrl) {
+            location.assign(loginUrl);
+        }
+        else {
+            this.loggerSvc.warn('Unable to identify Office Login URL, Ignoring login request');
+        }
+    }
+    async getToken(email) {
+        if (this.msToken &&
+            this.isValid(this.msToken.accessToken, this.msToken.expiresOn) &&
+            this.msToken.accessToken) {
+            return this.msToken.accessToken;
+        }
+        if (this.isValidEmail(email)) {
+            try {
+                this.msToken = await this.getTokenForEmail(email);
+                if (this.msToken.accessToken) {
+                    this.emailUsed = email;
+                    return this.msToken.accessToken;
+                }
+            }
+            catch (error) {
+                if (!this.code) {
+                    this.login(email);
+                }
+            }
+        }
+        if (this.msConfig.defaultEmailId && this.isValidEmail(this.msConfig.defaultEmailId)) {
+            try {
+                this.msToken = await this.getTokenForEmail(this.msConfig.defaultEmailId);
+                if (this.msToken.accessToken) {
+                    this.emailUsed = this.msConfig.defaultEmailId;
+                    return this.msToken.accessToken;
+                }
+            }
+            catch (error) { }
+        }
+        throw new Error('UNABLE TO FETCH MS AUTH TOKEN');
+    }
+    loginForSSOEnabledEmbed(email) {
+        if (!this.isValidEmail(email)) {
+            this.loggerSvc.warn('SSO Login request Ignored. Invalid Email Id for SSO Enabled Content');
+        }
+        let msPrevTS = 0;
+        try {
+            msPrevTS = parseInt(storage.getItem(storageKey) || '0', 10);
+        }
+        catch (error) { }
+        if (!msPrevTS || (msPrevTS && (Date.now() - msPrevTS) / 1000 > msTokenExpiryDuration)) {
+            this.loggerSvc.info(`last login exceeded ${msTokenExpiryDuration} duration. Redirecting to O365 login`);
+            storage.setItem(storageKey, Date.now().toString());
+            this.login(email);
+        }
+    }
+    isValidEmail(email) {
+        return this.msConfig.validEmailExtensions.some(ext => email.endsWith(ext));
+    }
+    isValid(accessToken, expiresOn) {
+        if (accessToken && expiresOn) {
+            return true;
+        }
+        return false;
+    }
+    async exchangeTokenForCode(code, redirectUrl) {
+        const response = await this.http
+            .get(`${API_ENDPOINTS}?code=${code}&redirectUrl=${redirectUrl}`)
+            .toPromise();
+        return this.getInstanceFromResponse(response);
+    }
+    async getTokenForEmail(email) {
+        const response = await this.http
+            .get(`${API_ENDPOINTS.sharePointToken}?email=${email}`)
+            .toPromise();
+        return this.getInstanceFromResponse(response);
+    }
+    getInstanceFromResponse(token) {
+        return {
+            accessToken: token.accessToken,
+            expiresOn: token.expiresOn,
+            resource: token.resource,
+            tokenType: token.tokenType,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthMicrosoftService, deps: [{ token: i1.LoggerService }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthMicrosoftService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthMicrosoftService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LoggerService }, { type: i2.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-microsoft.service.js","sourceRoot":"","sources":["../../../../../../library/sunbird-cb/utils-v2/src/lib/services/auth-microsoft.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;;;;AAO1C,MAAM,qBAAqB,GAAG,GAAG,CAAA;AACjC,MAAM,UAAU,GAAG,kBAAkB,CAAA;AACrC,MAAM,OAAO,GAAG,YAAY,CAAA;AAE5B,MAAM,aAAa,GAAG;IACpB,eAAe,EAAE,+BAA+B;CACjD,CAAA;AAID,MAAM,OAAO,oBAAoB;IAiB/B,YAAoB,SAAwB,EAAU,IAAgB;QAAlD,cAAS,GAAT,SAAS,CAAe;QAAU,SAAI,GAAJ,IAAI,CAAY;QAhB9D,aAAQ,GAAgC;YAC9C,QAAQ,EAAE,EAAE;YACZ,MAAM,EAAE,EAAE;YACV,cAAc,EAAE,EAAE;YAClB,oBAAoB,EAAE,EAAE;YACxB,YAAY,EAAE,KAAK;SACpB,CAAA;QACO,cAAS,GAAkB,IAAI,CAAA;QAC/B,SAAI,GAAkB,IAAI,CAAA;QAC1B,YAAO,GAA4B;YACzC,WAAW,EAAE,EAAE;YACf,SAAS,EAAE,EAAE;YACb,QAAQ,EAAE,EAAE;YACZ,SAAS,EAAE,EAAE;SACd,CAAA;IAEyE,CAAC;IAE3E,IAAI,gBAAgB;QAClB,OAAO,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC,CAAA;IACxF,CAAC;IACD,IAAI,QAAQ;QACV,IAAI,IAAI,CAAC,QAAQ,CAAC,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE;YACxD,MAAM,IAAI,GAAG,mDAAmD,CAAA;YAChE,MAAM,WAAW,GAAG,IAAI,eAAe,CAAC;gBACtC,aAAa,EAAE,MAAM;gBACrB,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ;gBACjC,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI;aACnC,CAAC,CAAA;YACF,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;YAC7C,IAAI,QAAQ,EAAE;gBACZ,OAAO,GAAG,IAAI,IAAI,WAAW,CAAC,QAAQ,EAAE,IAAI,QAAQ,EAAE,CAAA;aACvD;YACD,OAAO,GAAG,IAAI,IAAI,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAA;SAC3C;QACD,OAAO,IAAI,CAAA;IACb,CAAC;IACD,SAAS,CAAC,WAAmB;QAC3B,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC,EAAE;YAC3C,OAAO,mFAAmF,WAAW,EAAE,CAAA;SACxG;QACD,OAAO,WAAW,CAAA;IACpB,CAAC;IAID,KAAK,CAAC,IAAI,CAAC,MAAmD;QAC5D,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,YAAY,EAAE;YAClE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,kEAAkE,CAAC,CAAA;SACxF;QACD,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,SAAS,CAAA;QAChC,MAAM,WAAW,GAAG,IAAI,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;QACxD,IAAI,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,WAAW,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE;YAC/D,IAAI,CAAC,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;YACnC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;gBACd,OAAM;aACP;YACD,IAAI,GAAG,GAAG,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAA;YAC7C,MAAM,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;YAC/C,IAAI,QAAQ,CAAC,IAAI,EAAE;gBACjB,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;aAClC;YACD,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,CAAC,CAAA;SACpC;IACH,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,KAAa;QACvB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;YAC7B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,oDAAoD,KAAK,GAAG,CAAC,CAAA;YACjF,OAAM;SACP;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAA;QAC9B,IAAI,QAAQ,EAAE;YACZ,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;SAC1B;aAAM;YACL,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,6DAA6D,CAAC,CAAA;SACnF;IACH,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,KAAa;QAC1B,IACE,IAAI,CAAC,OAAO;YACZ,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;YAC9D,IAAI,CAAC,OAAO,CAAC,WAAW,EACxB;YACA,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAA;SAChC;QACD,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;YAC5B,IAAI;gBACF,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAA;gBACjD,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;oBAC5B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAA;oBACtB,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAA;iBAChC;aACF;YAAC,OAAO,KAAK,EAAE;gBACd,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;oBACd,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;iBAClB;aACF;SACF;QACD,IAAI,IAAI,CAAC,QAAQ,CAAC,cAAc,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE;YACnF,IAAI;gBACF,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAA;gBACxE,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;oBAC5B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAA;oBAC7C,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAA;iBAChC;aACF;YAAC,OAAO,KAAK,EAAE,GAAG;SACpB;QACD,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAA;IAClD,CAAC;IAED,uBAAuB,CAAC,KAAa;QACnC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;YAC7B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,qEAAqE,CAAC,CAAA;SAC3F;QACD,IAAI,QAAQ,GAAG,CAAC,CAAA;QAChB,IAAI;YACF,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,GAAG,EAAE,EAAE,CAAC,CAAA;SAC5D;QAAC,OAAO,KAAK,EAAE,GAAG;QACnB,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,GAAG,IAAI,GAAG,qBAAqB,CAAC,EAAE;YACrF,IAAI,CAAC,SAAS,CAAC,IAAI,CACjB,uBAAuB,qBAAqB,sCAAsC,CACnF,CAAA;YACD,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAA;YAClD,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;SAClB;IACH,CAAC;IAED,YAAY,CAAC,KAAa;QACxB,OAAO,IAAI,CAAC,QAAQ,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAA;IAC5E,CAAC;IAED,OAAO,CAAC,WAA+B,EAAE,SAA6B;QACpE,IAAI,WAAW,IAAI,SAAS,EAAE;YAE5B,OAAO,IAAI,CAAA;SACZ;QACD,OAAO,KAAK,CAAA;IACd,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,IAAY,EAAE,WAAmB;QAC1D,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI;aAC7B,GAAG,CAA0B,GAAG,aAAa,SAAS,IAAI,gBAAgB,WAAW,EAAE,CAAC;aACxF,SAAS,EAAE,CAAA;QACd,OAAO,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAA;IAC/C,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,KAAa;QAClC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI;aAC7B,GAAG,CAA0B,GAAG,aAAa,CAAC,eAAe,UAAU,KAAK,EAAE,CAAC;aAC/E,SAAS,EAAE,CAAA;QACd,OAAO,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAA;IAC/C,CAAC;IAED,uBAAuB,CAAC,KAA8B;QACpD,OAAO;YACL,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,SAAS,EAAE,KAAK,CAAC,SAAS;SAC3B,CAAA;IACH,CAAC;+GAnKU,oBAAoB;mHAApB,oBAAoB,cAFnB,MAAM;;4FAEP,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core'\r\nimport { LoggerService } from './logger.service'\r\nimport { NsInstanceConfig } from './configurations.model'\r\nimport { HttpClient } from '@angular/common/http'\r\nimport { IWsMsTokenModelResponse } from './ms-office.model'\r\n// TODO: Use a url-search-polyfill if the site didnot work in IE 11\r\n\r\nconst msTokenExpiryDuration = 600\r\nconst storageKey = 'msLoginRequested'\r\nconst storage = localStorage\r\n\r\nconst API_ENDPOINTS = {\r\n  sharePointToken: '/apis/protected/v8/user/token',\r\n}\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class AuthMicrosoftService {\r\n  private msConfig: NsInstanceConfig.IMicrosoft = {\r\n    clientId: '',\r\n    tenant: '',\r\n    defaultEmailId: '',\r\n    validEmailExtensions: [],\r\n    isConfigured: false,\r\n  }\r\n  private emailUsed: string | null = null\r\n  private code: string | null = null\r\n  private msToken: IWsMsTokenModelResponse = {\r\n    accessToken: '',\r\n    expiresOn: '',\r\n    resource: '',\r\n    tokenType: '',\r\n  }\r\n\r\n  constructor(private loggerSvc: LoggerService, private http: HttpClient) { }\r\n\r\n  get isLogoutRequired(): boolean {\r\n    return Boolean(this.msConfig.isConfigured && this.msConfig.clientId && this.emailUsed)\r\n  }\r\n  get loginUrl(): string | null {\r\n    if (this.msConfig.isConfigured && this.msConfig.clientId) {\r\n      const base = 'https://login.windows.net/common/oauth2/authorize'\r\n      const searchParam = new URLSearchParams({\r\n        response_type: 'code',\r\n        client_id: this.msConfig.clientId,\r\n        redirect_uri: window.location.href,\r\n      })\r\n      const fragment = location.search.substring(1)\r\n      if (fragment) {\r\n        return `${base}?${searchParam.toString()}#${fragment}`\r\n      }\r\n      return `${base}?${searchParam.toString()}`\r\n    }\r\n    return null\r\n  }\r\n  logoutUrl(redirectUrl: string) {\r\n    if (this.isValidEmail(this.emailUsed || '')) {\r\n      return `https://login.microsoftonline.com/common/oauth2/logout?post_logout_redirect_uri=${redirectUrl}`\r\n    }\r\n    return redirectUrl\r\n  }\r\n\r\n  // Behavior Methods\r\n\r\n  async init(config: Pick<NsInstanceConfig.IConfig, 'microsoft'>) {\r\n    if (!config || !config.microsoft || !config.microsoft.isConfigured) {\r\n      this.loggerSvc.warn('Empty/No Configuration passed, ignoring Microsoft Authentication')\r\n    }\r\n    this.msConfig = config.microsoft\r\n    const queryParams = new URLSearchParams(location.search)\r\n    if (queryParams.has('code') && queryParams.has('session_state')) {\r\n      this.code = queryParams.get('code')\r\n      if (!this.code) {\r\n        return\r\n      }\r\n      let url = location.origin + location.pathname\r\n      await this.exchangeTokenForCode(this.code, url)\r\n      if (location.hash) {\r\n        url += location.hash.substring(1)\r\n      }\r\n      history.replaceState(null, '', url)\r\n    }\r\n  }\r\n\r\n  async login(email: string) {\r\n    if (!this.isValidEmail(email)) {\r\n      this.loggerSvc.warn(`Microsoft Login is not allowed for your emailId (${email})`)\r\n      return\r\n    }\r\n    const loginUrl = this.loginUrl\r\n    if (loginUrl) {\r\n      location.assign(loginUrl)\r\n    } else {\r\n      this.loggerSvc.warn('Unable to identify Office Login URL, Ignoring login request')\r\n    }\r\n  }\r\n\r\n  async getToken(email: string): Promise<string> {\r\n    if (\r\n      this.msToken &&\r\n      this.isValid(this.msToken.accessToken, this.msToken.expiresOn) &&\r\n      this.msToken.accessToken\r\n    ) {\r\n      return this.msToken.accessToken\r\n    }\r\n    if (this.isValidEmail(email)) {\r\n      try {\r\n        this.msToken = await this.getTokenForEmail(email)\r\n        if (this.msToken.accessToken) {\r\n          this.emailUsed = email\r\n          return this.msToken.accessToken\r\n        }\r\n      } catch (error) {\r\n        if (!this.code) {\r\n          this.login(email)\r\n        }\r\n      }\r\n    }\r\n    if (this.msConfig.defaultEmailId && this.isValidEmail(this.msConfig.defaultEmailId)) {\r\n      try {\r\n        this.msToken = await this.getTokenForEmail(this.msConfig.defaultEmailId)\r\n        if (this.msToken.accessToken) {\r\n          this.emailUsed = this.msConfig.defaultEmailId\r\n          return this.msToken.accessToken\r\n        }\r\n      } catch (error) { }\r\n    }\r\n    throw new Error('UNABLE TO FETCH MS AUTH TOKEN')\r\n  }\r\n\r\n  loginForSSOEnabledEmbed(email: string) {\r\n    if (!this.isValidEmail(email)) {\r\n      this.loggerSvc.warn('SSO Login request Ignored. Invalid Email Id for SSO Enabled Content')\r\n    }\r\n    let msPrevTS = 0\r\n    try {\r\n      msPrevTS = parseInt(storage.getItem(storageKey) || '0', 10)\r\n    } catch (error) { }\r\n    if (!msPrevTS || (msPrevTS && (Date.now() - msPrevTS) / 1000 > msTokenExpiryDuration)) {\r\n      this.loggerSvc.info(\r\n        `last login exceeded ${msTokenExpiryDuration} duration. Redirecting to O365 login`,\r\n      )\r\n      storage.setItem(storageKey, Date.now().toString())\r\n      this.login(email)\r\n    }\r\n  }\r\n\r\n  isValidEmail(email: string) {\r\n    return this.msConfig.validEmailExtensions.some(ext => email.endsWith(ext))\r\n  }\r\n\r\n  isValid(accessToken: string | undefined, expiresOn: string | undefined): boolean {\r\n    if (accessToken && expiresOn) {\r\n      // TODO: Implement expiredOn and Date comparison based validity\r\n      return true\r\n    }\r\n    return false\r\n  }\r\n\r\n  async exchangeTokenForCode(code: string, redirectUrl: string): Promise<any> {\r\n    const response = await this.http\r\n      .get<IWsMsTokenModelResponse>(`${API_ENDPOINTS}?code=${code}&redirectUrl=${redirectUrl}`)\r\n      .toPromise()\r\n    return this.getInstanceFromResponse(response)\r\n  }\r\n\r\n  async getTokenForEmail(email: string): Promise<any> {\r\n    const response = await this.http\r\n      .get<IWsMsTokenModelResponse>(`${API_ENDPOINTS.sharePointToken}?email=${email}`)\r\n      .toPromise()\r\n    return this.getInstanceFromResponse(response)\r\n  }\r\n\r\n  getInstanceFromResponse(token: IWsMsTokenModelResponse) {\r\n    return {\r\n      accessToken: token.accessToken,\r\n      expiresOn: token.expiresOn,\r\n      resource: token.resource,\r\n      tokenType: token.tokenType,\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/services/card-content.model.mjs

@@ -0,0 +1,11 @@
+export var NsCardContent;
+(function (NsCardContent) {
+    let EContentStatus;
+    (function (EContentStatus) {
+        EContentStatus["LIVE"] = "Live";
+        EContentStatus["EXPIRED"] = "Expired";
+        EContentStatus["DELETED"] = "Deleted";
+        EContentStatus["MARK_FOR_DELETION"] = "MarkedForDeletion";
+    })(EContentStatus = NsCardContent.EContentStatus || (NsCardContent.EContentStatus = {}));
+})(NsCardContent || (NsCardContent = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FyZC1jb250ZW50Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicmFyeS9zdW5iaXJkLWNiL3V0aWxzLXYyL3NyYy9saWIvc2VydmljZXMvY2FyZC1jb250ZW50Lm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sS0FBVyxhQUFhLENBbUM3QjtBQW5DRCxXQUFpQixhQUFhO0lBNkI1QixJQUFZLGNBS1g7SUFMRCxXQUFZLGNBQWM7UUFDeEIsK0JBQWEsQ0FBQTtRQUNiLHFDQUFtQixDQUFBO1FBQ25CLHFDQUFtQixDQUFBO1FBQ25CLHlEQUF1QyxDQUFBO0lBQ3pDLENBQUMsRUFMVyxjQUFjLEdBQWQsNEJBQWMsS0FBZCw0QkFBYyxRQUt6QjtBQUNILENBQUMsRUFuQ2dCLGFBQWEsS0FBYixhQUFhLFFBbUM3QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5zQ29udGVudCB9IGZyb20gJy4uL3NlcnZpY2VzL3dpZGdldC1jb250ZW50Lm1vZGVsJ1xyXG5cclxuZXhwb3J0IG5hbWVzcGFjZSBOc0NhcmRDb250ZW50IHtcclxuICBleHBvcnQgaW50ZXJmYWNlIElDYXJkIHtcclxuICAgIGNvbnRlbnQ6IE5zQ29udGVudC5JQ29udGVudFxyXG4gICAgY2FyZFN1YlR5cGU6IFRDYXJkU3ViVHlwZVxyXG4gICAgY29udGV4dDogeyBwYWdlU2VjdGlvbjogc3RyaW5nOyBwb3NpdGlvbj86IG51bWJlciB9XHJcbiAgICBpbnRyYW5ldE1vZGU/OiAnZ3JleU91dCcgfCAnaGlkZSdcclxuICAgIGRlbGV0ZWRNb2RlPzogJ2dyZXlPdXQnIHwgJ2hpZGUnXHJcbiAgICBsaWtlcz86IG51bWJlclxyXG4gICAgY29udGVudFRhZ3M/OiBJQ29udGVudFRhZ3NcclxuICB9XHJcblxyXG4gIGV4cG9ydCBpbnRlcmZhY2UgSUNvbnRlbnRUYWdzIHtcclxuICAgIGRheXNTcGFuPzogbnVtYmVyXHJcbiAgICBleGNsdWRlQ29udGVudFR5cGU/OiBOc0NvbnRlbnQuRUNvbnRlbnRUeXBlc1tdXHJcbiAgICBleGNsdWRlTWltZVR5cGU/OiBzdHJpbmdbXVxyXG4gICAgdGFnOiBzdHJpbmdcclxuICAgIGNyaXRlcmlhRmllbGQ/OiBzdHJpbmdcclxuICB9XHJcblxyXG4gIGV4cG9ydCB0eXBlIFRDYXJkU3ViVHlwZSA9XHJcbiAgICB8ICdzdGFuZGFyZCdcclxuICAgIHwgJ21pbmltYWwnXHJcbiAgICB8ICdzcGFjZS1zYXZpbmcnXHJcbiAgICB8ICdjYXJkLXVzZXItZGV0YWlscydcclxuICAgIHwgJ2Jhc2ljLWluZm8nXHJcbiAgICB8ICdiYXNpYy1kZXRhaWxzJ1xyXG4gICAgfCAnY2FyZC1kZXNjcmlwdGlvbi1iYWNrJ1xyXG4gICAgfCAnbmV0d29yay1jYXJkJ1xyXG5cclxuICBleHBvcnQgZW51bSBFQ29udGVudFN0YXR1cyB7XHJcbiAgICBMSVZFID0gJ0xpdmUnLFxyXG4gICAgRVhQSVJFRCA9ICdFeHBpcmVkJyxcclxuICAgIERFTEVURUQgPSAnRGVsZXRlZCcsXHJcbiAgICBNQVJLX0ZPUl9ERUxFVElPTiA9ICdNYXJrZWRGb3JEZWxldGlvbicsXHJcbiAgfVxyXG59XHJcbiJdfQ==

package/esm2022/lib/services/configurations.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configurations.model.js","sourceRoot":"","sources":["../../../../../../library/sunbird-cb/utils-v2/src/lib/services/configurations.model.ts"],"names":[],"mappings":"","sourcesContent":["import { NsPage } from '../resolvers/page.model'\nimport { NsWidgetResolver } from './widget-resolver.model'\nexport namespace NsInstanceConfig {\n  export interface IConfig {\n    authoring: {\n      doUniqueCheck: boolean\n      isMultiStepFlow: boolean\n      allowExpiry: boolean\n      allowRestore: boolean\n      allowReview: boolean\n      allowPublish: boolean\n      allowRedo: boolean\n      newDesign: boolean\n      allowedContentType: string[]\n      urlPatternMatching: {\n        allowReplace: boolean\n        source: string\n        pattern: string\n        allowIframe: boolean\n      }[]\n    }\n    appSetup: boolean\n    chatBotUrl: string\n    defaultFontsize: string\n    defaultThemeClass: string\n    defaultLocale: string\n    disablePidCheck?: boolean\n    isMultilingualEnabled?: boolean\n    fontSizes: IFontSize[]\n    isContentDownloadAvailable: boolean\n    indexHtmlMeta: IIndexHtmlMeta\n    keycloak: IKeycloak\n    locals: ILocalsConfig[]\n    microsoft: IMicrosoft\n    telemetryConfig: ITelemetryConfig\n    themes: ITheme[]\n    logos: ILogos\n    sources?: ISourceLogo[]\n    mailIds: IMailIds\n    details: IDetails\n    validMailIdExtensionsForMailMe: string[]\n    overrideThemeChanges: IOverrideThemeChanges\n    defaultFeatureConfigs: {\n      error: string\n    }\n    backgrounds: {\n      primaryNavBar: NsPage.INavBackground\n      pageNavBar: NsPage.INavBackground\n    }\n    featuredApps: string[]\n    primaryNavBarConfig: IPrimaryNavbarConfig\n    org: string[]\n    rootOrg: string\n    intranetIframeUrls?: string[]\n    showNavBarInSetup?: boolean\n    intranetUrlToCheck?: string\n    introVideo: IPath\n    tourVideo: IPath\n    isDownloadableSource?: IPath\n    isDownloadableIosResource?: IPath\n    isDownloadableAndroidResource?: IPath\n    sourceFieldsUserAutocomplete?: string[]\n    forgotPasswordConfig?: IForgotPassword\n    hubs: IHubs[]\n    courseContentPath?: string\n    portalUrls: IPortalUrls | undefined\n    positions: any\n    websitelanguages: any[]\n    profileTimelyNudges: any,\n    npsCategory?: string\n    compentency?: any\n  }\n  export interface IPortalUrls {\n    igot: string,\n    spv: string,\n    mdo: string,\n    cbc: string,\n    cbp: string,\n    frac: string\n  }\n  export interface IForgotPassword {\n    local?: string\n    enterprise?: string\n    social?: string\n  }\n  export interface ISourceLogo {\n    sourceName?: string\n    sourceId?: string\n    logo?: string\n  }\n  export interface IPath {\n    [key: string]: string\n  }\n  export interface IHubs {\n    active: boolean\n    desc: string\n    hubname: string\n    icon: string\n    path: string,\n    order: number\n  }\n  export interface IIndexHtmlMeta {\n    description?: string\n    openSearchUrl?: string\n    webmanifest: string\n    xIcon?: string\n    pngIcon?: string\n  }\n  export interface IFontSize {\n    baseFontSize: string\n    fontClass: string\n    scale: number\n  }\n  export interface IKeycloak {\n    defaultidpHint: 'E' | 'N' | 'S'\n    isLoginHidden: boolean\n    bearerExcludedUrls: string[]\n    clientId: string\n    key: string\n    realm: string\n    url: string\n    changePasswordUrl?: string\n    onLoad?: 'check-sso' | 'login-required'\n  }\n  export interface ILocalsConfig {\n    isAvailable: boolean\n    isEnabled: boolean\n    locals: string[]\n    path: string\n    isRTL: boolean\n  }\n  export interface IMicrosoft {\n    clientId: string\n    defaultEmailId: string\n    tenant: string\n    validEmailExtensions: string[]\n    isConfigured: boolean\n  }\n  export interface ITheme {\n    color: IThemeColor\n    themeFile: string\n    themeClass: string\n    themeName: string\n  }\n\n  export interface IThemeColor {\n    accent: string\n    primary: string\n    warn: string\n  }\n  export interface IOverrideThemeChanges {\n    isEnabled: boolean\n    desktop: IDesktop\n    mWeb: IMWeb\n  }\n  export interface IDesktop {\n    animationDuration: number\n    logoUrl: string\n    logoText: string\n    logoDisplayTime: number\n    backgroundTheme: string\n  }\n  export interface IMWeb {\n    logoUrl: string\n    logoText: string\n  }\n  export interface ILogos {\n    app: string\n    appTransparent: string\n    appSecondary: string\n    aboutFooter: string\n    aboutHeader: string\n    appBottomNav?: string\n    company: string\n    developedBy: string\n    poweredBy: string\n    defaultContent?: string\n    defaultSourceLogo?: string\n    landingLogo: string\n    navbarLogo?: string\n    playListLogo?: string\n    thumpsUp?: string\n\n  }\n  export interface IMailIds {\n    contactUs: string\n    default: string\n    support: string\n  }\n  export interface IDetails {\n    appName: string\n  }\n  export interface IPrimaryNavbarConfig {\n    mediumScreen: IPrimaryNavBarScreen\n    smallScreen: IPrimaryNavBarScreen\n  }\n  interface IPrimaryNavBarScreen {\n    left: IPrimaryNavBarSide[]\n    right: IPrimaryNavBarSide[]\n  }\n  interface IPrimaryNavBarSide {\n    type: 'widgetButton' | 'featureButton'\n    config: NsWidgetResolver.IRenderConfigWithAnyData | NsPage.INavLink\n  }\n\n  export interface ITelemetryConfig {\n    pdata: {\n      id: string\n      ver: string\n      pid: string\n    }\n    object: {\n      ver: string\n      id: string | undefined\n    }\n    uid: string | null\n    authtoken?: string\n    env: string\n    channel: string\n    batchsize: number\n    host: string\n    endpoint: string\n    apislug: string\n    sid: string\n    publicEndpoint: string\n    protectedEndpoint: string\n  }\n}\n\nexport namespace NsAppsConfig {\n  export type TIconType = 'mat-icon' | 'url'\n\n  export interface IAppsConfig {\n    groups: IGroup[]\n    features: { [id: string]: IFeature }\n    tourGuide?: string[][]\n  }\n\n  export interface IGroup {\n    id: string\n    iconType: string\n    icon: string\n    keywords: string[]\n    name: string\n    toolTip: string\n    featureIds: string[]\n    stripBackground?: string\n    hasRole: string[]\n  }\n\n  // export interface IGroupWithFeatures extends IGroup {\n  //   features: IFeature[]\n  // }\n  export interface IFeature {\n    name: string\n    id: string\n    url: string\n    permission: string | string[] | { all: string[]; some: string[]; none: string[] }\n    iconType: TIconType\n    icon: string\n    keywords: string[]\n    toolTip: string\n    accessKey: string\n    status?: 'earlyAccess' | 'live' | 'alpha' | 'beta'\n    shortName: string\n    description?: string\n    badgeEndpoint?: string\n    mobileAppFunction?: string\n    color?: string\n    target?: string\n  }\n}\n\nexport namespace NsUser {\n  export interface IUserProfile {\n    userId: string\n    email?: string\n    departmentName?: string\n    userName?: string\n    firstName?: string\n    surName?: string\n    middleName?: string\n    lastName?: string\n    rootOrgId?: string\n    rootOrgName?: string\n    profileImage?: string\n    givenName?: string\n    country?: null | string\n    unit?: string | null\n    source_profile_picture?: null | string\n    dealerCode?: null | string\n    isManager?: boolean\n    competencies?: any\n    systemTopics?: any\n    desiredTopics?: any\n    desiredCompetencies?: any\n    userRoles?: any\n    profileUpdateCompletion?: number\n    profileImageUrl?: string\n    professionalDetails?: any\n    webPortalLang?: any,\n    departmentImg?: any\n  }\n\n  export interface INodebbUserProfile {\n    username: string\n    email: string\n  }\n\n  export interface IUserPidProfile {\n    kid_updated: boolean\n    user: IUser\n  }\n\n  export interface IUserPidProfileV2 {\n    kid_updated: boolean\n    result: {\n      response: IUserV2\n    }\n  }\n\n  export interface IUserPidProfileVer2 {\n    result: {\n      UserProfile: IUserVer2\n    }\n  }\n  interface ISourceData {\n    GID: string\n    SNAMPRE: string\n    SNAMADD: string\n    LASTNAME: string\n    SN: string\n    GIVENNAME: string\n    NICKNAME: string\n    PREFERREDSN: string\n    PERSONALTITLE: string\n    MOBILE: string\n    MAIL: string\n    DEPARTMENTTEXT: string\n    COSTLOCATIONUNIT: string\n    COSTLOCATION: string\n    ORGID: string\n    MGMTRESP: string\n    UTC: string\n    CNAMEENG: string\n    LNAMEINT: string\n    USERTYPE: string\n    STATUS: string\n    CONTRACTSTATUS: string\n  }\n\n  interface IUser {\n    wid: string\n    root_org: string\n    org: string\n    is_active?: any\n    account_expiry_date?: any\n    kid: string\n    imported_source_name: string\n    source_id: string\n    username?: any\n    first_name: string\n    last_name: string\n    middle_name?: any\n    known_as: string\n    salutation?: any\n    email: string\n    gender?: any\n    dob?: any\n    languages_known?: any\n    preferred_language?: any\n    source_profile_picture?: any\n    residence_country: string\n    residence_state?: any\n    residence_city: string\n    contact_phone_number_office?: any\n    contact_phone_number_home?: any\n    contact_phone_number_personal: string\n    employement_status?: any\n    contract_type?: any\n    job_title?: any\n    job_role?: any\n    department_name: string\n    unit_name?: any\n    organization_location_country?: any\n    organization_location_state?: any\n    organization_location_city?: any\n    time_inserted: Date\n    time_updated: Date\n    json_unmapped_fields?: any\n    source_data: ISourceData\n  }\n  interface IRootOrg {\n    dateTime: string\n    preferredLanguage: string\n    keys: {}\n    channel: string\n    approvedBy: string\n    description: string\n    updatedDate: string\n    addressId: string\n    orgType: string\n    provider: string\n    orgCode: string\n    locationId: string\n    theme: string\n    id: string\n    isApproved: boolean\n    communityId: string\n    slug: string\n    email: string\n    isSSOEnabled: boolean\n    thumbnail: string\n    updatedBy: string\n    orgName: string\n    locationIds: []\n    externalId: string\n    isRootOrg: boolean\n    rootOrgId: string\n    imgUrl: string\n    approvedDate: string\n    orgTypeId: string\n    homeUrl: string\n    isDefault: boolean\n    createdDate: string\n    contactDetail: string\n    parentOrgId: string\n    createdBy: string\n    hashTagId: string\n    noOfMembers: string\n    status: number\n  }\n  interface IOrg {\n    updatedBy: string\n    organisationId: string\n    orgName: string\n    addedByName: string\n    addedBy: string\n    roles: string[]\n    approvedBy: string\n    updatedDate: string\n    userId: string\n    approvaldate: string\n    isDeleted: boolean\n    parentOrgId: string\n    hashTagId: string\n    isRejected: boolean\n    position: string\n    id: string\n    orgjoindate: string\n    isApproved: boolean\n    orgLeftDate: string\n  }\n  interface IUserV2 {\n    surName: any\n    maskedPhone: string\n    rootOrgName: string\n    subject: []\n    channel: string\n    language: []\n    updatedDate: string\n    managedBy: string\n    flagsValue: number\n    id: string\n    recoveryEmail: string\n    identifier: string\n    thumbnail: string\n    profileVisibility: []\n    updatedBy: string\n    accesscode: string\n    locationIds: []\n    externalIds: []\n    registryId: string\n    rootOrgId: string\n    prevUsedEmail: string\n    firstName: string\n    tncAcceptedOn: string\n    phone: string\n    dob: string\n    grade: []\n    currentLoginTime: string\n    userType: string\n    status: number\n    lastName: string\n    gender: string\n    roles: string[]\n    prevUsedPhone: string\n    stateValidated: boolean\n    isDeleted: boolean\n    organisations: IOrg[]\n    countryCode: string\n    maskedEmail: string\n    tempPassword: string\n    email: string\n    rootOrg: IRootOrg\n    profileSummary: string\n    phoneVerified: boolean\n    recoveryPhone: string\n    userName: string\n    userId: string\n    lastLoginTime: string\n    emailVerified: true\n    framework: {}\n    createdDate: string\n    createdBy: string\n    location: string\n    tncAcceptedVersion: string\n  }\n\n  interface IUserVer2 {\n    'firstname': string,\n    'motherTongue': string,\n    'secondaryEmail': string,\n    'gender': string,\n    '@type': string,\n    'mobile': number,\n    'middlename': string,\n    'telephone': number,\n    'osid': string,\n    'primaryEmailType': string,\n    'knownLanguages': ILanguages[],\n    'wid': string,\n    'nationality': string,\n    'surname': string,\n    'dob': string,\n    'category': string,\n    'primaryEmail': string,\n    'maritalStatus': string,\n    'residenceAddress': string,\n    'result': any\n  }\n  export interface ILanguages {\n    name: string\n  }\n}\n"]}

package/esm2022/lib/services/configurations.service.mjs

@@ -0,0 +1,83 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ConfigurationsService {
+    constructor() {
+        this.appSetup = true;
+        this.userUrl = '';
+        this.baseUrl = `assets/configurations`;
+        this.sitePath = `assets/configurations`;
+        this.hostPath = (window.location.host).replace(':', '_');
+        this.userRoles = null;
+        this.userGroups = null;
+        this.restrictedFeatures = null;
+        this.restrictedWidgets = null;
+        this.instanceConfig = null;
+        this.appsConfig = null;
+        this.rootOrg = null;
+        this.org = null;
+        this.activeOrg = '';
+        this.isProduction = false;
+        this.hasAcceptedTnc = false;
+        this.profileDetailsStatus = false;
+        this.isActive = true;
+        this.userPreference = null;
+        this.userProfile = null;
+        this.userProfileV2 = null;
+        this.nodebbUserProfile = null;
+        this.isAuthenticated = false;
+        this.isNewUser = false;
+        this.pinnedApps = new BehaviorSubject(new Set());
+        this.prefChangeNotifier = new ReplaySubject(1);
+        this.tourGuideNotifier = new ReplaySubject();
+        this.authChangeNotifier = new ReplaySubject(1);
+        this.updateProfile = new BehaviorSubject(false);
+        this.updateProfileObservable = this.updateProfile.asObservable();
+        this.updateTourGuide = new BehaviorSubject(true);
+        this.updateTourGuideObservable = this.updateTourGuide.asObservable();
+        this.updatePlatformRating = new BehaviorSubject({ bottom: '120px' });
+        this.updatePlatformRatingObservable$ = this.updatePlatformRating.asObservable();
+        this.languageTranslationFlag = new Subject();
+        this.activeThemeObject = null;
+        this.activeFontObject = null;
+        this.isDarkMode = false;
+        this.isIntranetAllowed = false;
+        this.isRTL = false;
+        this.activeLocale = null;
+        this.activeLocaleGroup = '';
+        this.completedActivity = null;
+        this.completedTour = false;
+        this.profileSettings = ['profilePicture', 'learningTime', 'learningPoints'];
+        this.primaryNavBar = {
+            color: 'primary',
+        };
+        this.pageNavBar = {
+            color: 'primary',
+        };
+        this.primaryNavBarConfig = null;
+        this.welcomeTabs = null;
+        this.compentency = null;
+        this.cstoken = '';
+        this.netcoreConfig = {};
+        this.changeNavBarFullView = new Subject();
+        this.openExploreMenuForMWeb = new Subject();
+    }
+    updateGlobalProfile(state) {
+        this.updateProfile.next(state);
+    }
+    updateTourGuideMethod(state) {
+        this.updateTourGuide.next(state);
+    }
+    updatePlatformRatingMethod(state) {
+        this.updatePlatformRating.next(state);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConfigurationsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConfigurationsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConfigurationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configurations.service.js","sourceRoot":"","sources":["../../../../../../library/sunbird-cb/utils-v2/src/lib/services/configurations.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport { NSProfileDataV3 } from '../models/profile-v3.models'\nimport { BehaviorSubject, ReplaySubject, Subject } from 'rxjs'\n// import { environment } from '../../../../../../src/environments/environment'\nimport { NsPage } from '../resolvers/page.model'\nimport { NsAppsConfig, NsInstanceConfig, NsUser } from './configurations.model'\nimport { IPortalUrls, IUserPreference } from './user-preference.model'\n\n// const instanceConfigPath: string | null = window.location.host\n// const locationHost: string | null = window.location.host\n\n// if (!environment.production && Boolean(environment.sitePath)) {\n//   locationHost = environment.sitePath\n//   instanceConfigPath = environment.sitePath\n// }\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConfigurationsService {\n  // update as the single source of truth\n  constructor() {\n    // @Inject('env') env: any\n    // if (!env.production && Boolean(env.sitePath)) {\n    //   locationHost = env.sitePath\n    //   instanceConfigPath = env.sitePath\n    // }\n  }\n  appSetup = true\n  // The url the user tried to access while landing in the app before accepting tnc\n  userUrl = ''\n  baseUrl = `assets/configurations`\n  sitePath = `assets/configurations`\n  hostPath = (window.location.host).replace(':', '_')\n\n  userRoles: Set<string> | null = null\n  userGroups: Set<string> | null = null\n  restrictedFeatures: Set<string> | null = null\n  restrictedWidgets: Set<string> | null = null\n  instanceConfig: NsInstanceConfig.IConfig | null = null\n  appsConfig: NsAppsConfig.IAppsConfig | null = null\n  rootOrg: string | null = null\n  courseContentPath?: string\n  org: string[] | null = null\n  activeOrg: string | null = ''\n  isProduction = false\n  hasAcceptedTnc = false\n  profileDetailsStatus = false\n  isActive = true\n  userPreference: IUserPreference | null = null\n  userProfile: NsUser.IUserProfile | null = null\n  userProfileV2: NsUser.IUserProfile | null = null\n  nodebbUserProfile: NsUser.INodebbUserProfile | null = null\n  // created to store complete user details sent by pid\n  unMappedUser: any\n  isAuthenticated = false\n  isNewUser = false\n  portalUrls: IPortalUrls | undefined\n  positions: any\n  overrideThemeChanges: any\n  profileTimelyNudges: any\n\n  // pinnedApps\n  pinnedApps = new BehaviorSubject<Set<string>>(new Set())\n\n  // Notifier\n  prefChangeNotifier = new ReplaySubject<Partial<IUserPreference>>(1)\n  tourGuideNotifier = new ReplaySubject<boolean>()\n  authChangeNotifier = new ReplaySubject<boolean>(1)\n\n  private updateProfile = new BehaviorSubject(false)\n  updateProfileObservable = this.updateProfile.asObservable()\n\n  updateTourGuide = new BehaviorSubject(true)\n  updateTourGuideObservable = this.updateTourGuide.asObservable()\n\n  // platform rating\n  updatePlatformRating = new BehaviorSubject({ bottom: '120px' })\n  updatePlatformRatingObservable$ = this.updatePlatformRating.asObservable()\n\n  languageTranslationFlag = new Subject()\n\n  // Preference Related Values\n  activeThemeObject: NsInstanceConfig.ITheme | null = null\n  activeFontObject: NsInstanceConfig.IFontSize | null = null\n  isDarkMode = false\n  isIntranetAllowed = false\n  isRTL = false\n  activeLocale: NsInstanceConfig.ILocalsConfig | null = null\n  activeLocaleGroup = ''\n  completedActivity: string[] | null = null\n  completedTour = false\n  profileSettings = ['profilePicture', 'learningTime', 'learningPoints']\n\n  primaryNavBar: Partial<NsPage.INavBackground> = {\n    color: 'primary',\n  }\n  pageNavBar: Partial<NsPage.INavBackground> = {\n    color: 'primary',\n  }\n  primaryNavBarConfig: NsInstanceConfig.IPrimaryNavbarConfig | null = null\n  /* for temp Fix */\n  // setBaseUrl = (sitePath: string) => `assets/configurations/${(sitePath).replace(':', '_')}`\n  // setSitePath = (sitePath: string) => `assets/configurations/${(sitePath).replace(\n  //   ':',\n  //   '_',\n  // )}`\n  // setHostPath = (sitePath: string) => (sitePath).replace(':', '_')\n  welcomeTabs: NSProfileDataV3.IProfileTab | null = null\n  compentency: any = null\n  iGOTAIConfig: any\n  // variable setting for csJwtToken\n  cstoken = ''\n  netcoreConfig: any = {}\n\n  changeNavBarFullView = new Subject()\n  openExploreMenuForMWeb = new Subject()\n  updateGlobalProfile(state: boolean) {\n    this.updateProfile.next(state)\n  }\n\n  updateTourGuideMethod(state: boolean) {\n    this.updateTourGuide.next(state)\n  }\n\n  updatePlatformRatingMethod(state: any) {\n    this.updatePlatformRating.next(state)\n  }\n\n}\n"]}

package/esm2022/lib/services/content-strip-multiple.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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