@ksremp/ngx-ksremp-app-lib 1.0.0

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

@@ -0,0 +1,159 @@
+import { Injectable } from '@angular/core';
+import { DEFAULT_INTERRUPTSOURCES } from '@ng-idle/core';
+import { BehaviorSubject, interval, timer } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { LibConstants } from '../../models/LibConstants';
+import * as i0 from "@angular/core";
+import * as i1 from "../logger/logger.service";
+import * as i2 from "@ng-idle/core";
+import * as i3 from "../login/login.service";
+import * as i4 from "@ionic/angular";
+import * as i5 from "@ng-idle/keepalive";
+/**
+ * This service will automatically extend user's session by refreshing access_token if the validity of access token is less than 120s and
+ * user is not idle on the screen.
+ *
+ * @author Prerak Tiwari
+ */
+export class IdleService {
+    constructor(logger, idle, ls, nav, keepalive) {
+        this.logger = logger;
+        this.idle = idle;
+        this.ls = ls;
+        this.nav = nav;
+        this.keepalive = keepalive;
+        this.timerInterval = interval(1000); //1s
+        this.timer = timer(120000); //30s 
+        this.time = 120;
+        this.countDown = this.timerInterval.pipe(take(this.time));
+        this.counter = new BehaviorSubject(0);
+        this.lastPing = null;
+        this.showSessionTimeoutWarning = new BehaviorSubject(false);
+        this.logger.log('[IdleService] IdleService Initialized');
+    }
+    setupIdalTimeout() {
+        // sets an idle timeout of 180 seconds
+        this.idle.setIdle(LibConstants.idleTime);
+        // sets a timeout period of 120 seconds. after 300 seconds of inactivity, the user will be considered timed out.
+        this.idle.setTimeout(LibConstants.timeOutPeriod);
+        // sets the default interrupts, in this case, things like clicks, scrolls, touches to the document
+        this.idle.setInterrupts(DEFAULT_INTERRUPTSOURCES);
+        this.idle.onIdleStart.subscribe(() => {
+            this.unsubscribe();
+            this.showSessionTimeoutWarning.next(true);
+            this.counterSubscription = this.countDown.subscribe(val => {
+                this.counter.next(this.time - val);
+            });
+            this.counterEndSubscription = this.timer.subscribe(val => {
+                this.logout();
+            });
+        });
+        // sets the ping interval to 15 seconds
+        this.keepalive.interval(15);
+        this.keepalive.onPing.subscribe(() => this.lastPing = new Date());
+        this.ls.getUserBs().subscribe(user => {
+            if (user) {
+                this.logger.log('IdleService watching');
+                this.sessionValidityTill = this.addSeconds(new Date(), user.expires_in);
+                this.idle.watch();
+            }
+            else {
+                this.idle.stop();
+                this.logger.log('IdleService stopped');
+            }
+        });
+    }
+    reset() {
+        this.idle.watch();
+        this.showSessionTimeoutWarning.next(false);
+        if (this.counterSubscription) {
+            this.counterSubscription.unsubscribe();
+        }
+        if (this.counterEndSubscription) {
+            this.counterEndSubscription.unsubscribe();
+        }
+        this.setupSessionObserver();
+        this.checkSessionValidity();
+    }
+    stay() {
+        //this.childModal.hide();
+        this.reset();
+    }
+    setupSessionTimeoutObserver() {
+        this.ls.getUserBs().subscribe(user => {
+            if (user) {
+                this.logger.log('[IdleService] Subscribing Session Observer');
+                this.sessionValidityTill = this.addSeconds(new Date(), user.expires_in);
+                this.setupSessionObserver();
+            }
+            else {
+                this.logger.log('[IdleService] Unsubscribing Session Observer');
+                this.unsubscribe();
+            }
+        });
+    }
+    setupSessionObserver() {
+        this.unsubscribe();
+        const source = interval(15000);
+        this.sessionValiditysubscription = source.subscribe(val => this.checkSessionValidity());
+    }
+    unsubscribe() {
+        if (this.sessionValiditysubscription) {
+            this.sessionValiditysubscription.unsubscribe();
+        }
+    }
+    checkSessionValidity() {
+        let isIdle = this.idle.isIdling();
+        if (!isIdle) {
+            let tokenExpTime = this.sessionValidityTill;
+            let now = new Date();
+            let diffInSec = Math.ceil((tokenExpTime.getTime() - now.getTime()) / 1000);
+            this.logger.log('[IdleService] diffInSec', diffInSec);
+            if (diffInSec < 120) {
+                this.unsubscribe();
+                this.logger.log('[IdleService] Initiating Refresh Token as session is active and user is active');
+                this.ls
+                    .refreshToken(this.ls.getUser().refresh_token)
+                    .then(async (res) => {
+                    await this.ls.setUser(res).then(res => res);
+                    return true;
+                })
+                    .catch(err => {
+                    this.logger.error('[IdleService] error while refreshing token', err);
+                    return false;
+                });
+            }
+            else {
+                this.logger.log('[IdleService] NOT Initiating Refresh Token as session is active');
+            }
+        }
+        else {
+            this.logger.log('[IdleService] NOT Initiating Refresh Token as session is idle and it will be timeout automatically.');
+        }
+    }
+    logout() {
+        //this.childModal.hide();
+        this.ls.logout();
+        this.nav.navigateRoot('/login');
+        this.showSessionTimeoutWarning.next(false);
+        if (this.counterSubscription) {
+            this.counterSubscription.unsubscribe();
+        }
+        if (this.counterEndSubscription) {
+            this.counterEndSubscription.unsubscribe();
+        }
+    }
+    addSeconds(date, secToAdd) {
+        date.setSeconds(date.getSeconds() + secToAdd);
+        return date;
+    }
+    static { this.ɵfac = function IdleService_Factory(t) { return new (t || IdleService)(i0.ɵɵinject(i1.LoggerService), i0.ɵɵinject(i2.Idle), i0.ɵɵinject(i3.LoginService), i0.ɵɵinject(i4.NavController), i0.ɵɵinject(i5.Keepalive)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: IdleService, factory: IdleService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IdleService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.LoggerService }, { type: i2.Idle }, { type: i3.LoginService }, { type: i4.NavController }, { type: i5.Keepalive }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"idle.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-reusa-app-lib/src/lib/services/idle/idle.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { NavController } from '@ionic/angular';\nimport { DEFAULT_INTERRUPTSOURCES, Idle } from '@ng-idle/core';\nimport { Keepalive } from '@ng-idle/keepalive';\nimport { BehaviorSubject, interval, Subscription, timer } from 'rxjs';\nimport { take } from 'rxjs/operators';\nimport { LibConstants } from '../../models/LibConstants';\nimport { LoggerService } from '../logger/logger.service';\nimport { LoginService } from '../login/login.service';\n\n/**\n * This service will automatically extend user's session by refreshing access_token if the validity of access token is less than 120s and \n * user is not idle on the screen.\n * \n * @author Prerak Tiwari\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class IdleService {\n  private sessionValidityTill : Date;\n  public timerInterval = interval(1000); //1s\n  public timer = timer(120000); //30s \n  time = 120;\n  public countDown = this.timerInterval.pipe(take(this.time));\n  public counter : BehaviorSubject<number> = new BehaviorSubject(0);\n  lastPing?: Date = null;\n\n  counterSubscription : Subscription;\n  counterEndSubscription : Subscription;\n  sessionValiditysubscription: Subscription;\n\n  public showSessionTimeoutWarning : BehaviorSubject<Boolean> = new BehaviorSubject(false);\n\n  constructor( private logger: LoggerService ,public idle: Idle, private ls : LoginService, private nav: NavController, private keepalive: Keepalive) { \n    this.logger.log('[IdleService] IdleService Initialized');\n  }\n\n  setupIdalTimeout(){\n    // sets an idle timeout of 180 seconds\n    this.idle.setIdle(LibConstants.idleTime);\n    // sets a timeout period of 120 seconds. after 300 seconds of inactivity, the user will be considered timed out.\n    this.idle.setTimeout(LibConstants.timeOutPeriod);\n    // sets the default interrupts, in this case, things like clicks, scrolls, touches to the document\n    this.idle.setInterrupts(DEFAULT_INTERRUPTSOURCES);\n\n    this.idle.onIdleStart.subscribe(() => {\n        this.unsubscribe();\n        this.showSessionTimeoutWarning.next(true);\n        this.counterSubscription = this.countDown.subscribe(val =>{\n          this.counter.next(this.time - val);\n        });\n\n        this.counterEndSubscription = this.timer.subscribe(val => {\n          this.logout();\n        });\n    });\n\n    // sets the ping interval to 15 seconds\n    this.keepalive.interval(15);\n\n    this.keepalive.onPing.subscribe(() => this.lastPing = new Date());\n\n    this.ls.getUserBs().subscribe(user => {\n      if(user){\n        this.logger.log('IdleService watching');\n        this.sessionValidityTill = this.addSeconds(new Date(), user.expires_in);\n        this.idle.watch()\n      }else {\n        this.idle.stop();\n        this.logger.log('IdleService stopped');\n      }\n    });\n  }\n\n  reset() {\n    this.idle.watch();\n    this.showSessionTimeoutWarning.next(false);\n    if(this.counterSubscription){\n      this.counterSubscription.unsubscribe();\n    }\n    if(this.counterEndSubscription){\n      this.counterEndSubscription.unsubscribe();\n    }\n    this.setupSessionObserver();\n    this.checkSessionValidity();\n  }\n\n  stay() {\n    //this.childModal.hide();\n    this.reset();\n  }\n  \n\n  setupSessionTimeoutObserver(){\n    this.ls.getUserBs().subscribe(user => {\n      if(user){\n        this.logger.log('[IdleService] Subscribing Session Observer');\n        this.sessionValidityTill = this.addSeconds(new Date(), user.expires_in);\n        this.setupSessionObserver();\n      }else {\n        this.logger.log('[IdleService] Unsubscribing Session Observer');\n        this.unsubscribe();\n      }\n    });\n  }\n\n  setupSessionObserver(){\n    this.unsubscribe();\n    const source = interval(15000);\n    this.sessionValiditysubscription = source.subscribe(val => this.checkSessionValidity());\n  }\n\n  private unsubscribe() {\n    if (this.sessionValiditysubscription) {\n      this.sessionValiditysubscription.unsubscribe();\n    }\n  }\n\n  checkSessionValidity(){\n    let isIdle = this.idle.isIdling();\n    if(!isIdle){\n      let tokenExpTime = this.sessionValidityTill;\n      let now = new Date();\n      let diffInSec = Math.ceil((tokenExpTime.getTime() - now.getTime())/1000);\n      this.logger.log('[IdleService] diffInSec', diffInSec);\n      if(diffInSec < 120){\n        this.unsubscribe();\n        this.logger.log('[IdleService] Initiating Refresh Token as session is active and user is active');\n        this.ls\n            .refreshToken(this.ls.getUser().refresh_token)\n            .then(async res => {\n                await this.ls.setUser(res).then(res => res);\n                return true;\n            })\n            .catch(err => {\n                this.logger.error('[IdleService] error while refreshing token', err);\n                return false;\n            });\n      }else{\n        this.logger.log('[IdleService] NOT Initiating Refresh Token as session is active');\n      }\n    }else {\n      this.logger.log('[IdleService] NOT Initiating Refresh Token as session is idle and it will be timeout automatically.');\n    }\n  }\n\n  logout() {\n    //this.childModal.hide();\n    this.ls.logout();\n    this.nav.navigateRoot('/login');\n    this.showSessionTimeoutWarning.next(false);\n    if(this.counterSubscription){\n      this.counterSubscription.unsubscribe();\n    }\n    if(this.counterEndSubscription){\n      this.counterEndSubscription.unsubscribe();\n    }\n  }\n\n  addSeconds(date :  Date, secToAdd : number){\n    date.setSeconds(date.getSeconds() + secToAdd);\n    return date;\n  }\n}\n"]}

package/esm2022/lib/services/lexis-nexis/lexis.nexis.service.mjs

@@ -0,0 +1,60 @@
+import { Injectable } from '@angular/core';
+import { LibConstants } from '../../models/LibConstants';
+import { BaseService } from '../base-service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class LexisNexisService extends BaseService {
+    constructor(http) {
+        super(http);
+        this.http = http;
+    }
+    setServiceContext() {
+        this.serviceContext = LibConstants.claims_service.context;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.claims_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.claims_service.protocol;
+    }
+    setServiceHost() {
+        this.host = LibConstants.claims_service.host;
+    }
+    isLexisNexisIdProofingEnabled(ssn) {
+        return this.post(`ln/enabled`, ssn);
+    }
+    isLexisNexisIdProofingEnabledWithUserId(userId) {
+        return this.get(`ln/enabled/${userId}`);
+    }
+    isLexisNexisProofedWithin24Hours(userId) {
+        return this.get(`ln/proofed-today/${userId}`);
+    }
+    getLnQueryApiResponse(userName, customerEventType) {
+        const sessionId = window['sessionId'];
+        if (!sessionId) {
+            console.error('Session ID not found in window object.');
+            return; // handle accordingly
+        }
+        const query = {
+            sessionId: sessionId,
+            userId: userName,
+            customerEventType: customerEventType
+        };
+        return this.post(`ln/query-api/`, query);
+    }
+    getLnQueryApiPIResponse(accountCreationData) {
+        return this.post(`ln/query-api-pi/`, accountCreationData);
+    }
+    lnAuthenticationQA(authSelection) {
+        return this.post(`ln/authenticate/`, authSelection);
+    }
+    static { this.ɵfac = function LexisNexisService_Factory(t) { return new (t || LexisNexisService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LexisNexisService, factory: LexisNexisService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LexisNexisService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-logger";
+/**
+ * Logger services responsible for logging various messages in browser's console. Developers are advised to use this class for
+ * any loggin related activity instead of console.log. This service will also send any errors to remote loggin server for debugging
+ * purpose.
+ *
+ * @see https://www.npmjs.com/package/ngx-logger for more details about the configurations.
+ *
+ * @author Prerak Tiwari
+ * */
+export class LoggerService {
+    constructor(logger) {
+        this.logger = logger;
+        logger.info('LoggerService initialized Successfully.');
+    }
+    trace(message, ...additional) {
+        this.logger.trace(message, additional);
+    }
+    debug(message, ...additional) {
+        this.logger.debug(message, additional);
+    }
+    info(message, ...additional) {
+        this.logger.info(message, additional);
+    }
+    log(message, ...additional) {
+        let msg = message;
+        this.logger.log(msg, additional);
+    }
+    warn(message, ...additional) {
+        this.logger.warn(message, additional);
+    }
+    error(message, ...additional) {
+        this.logger.error(message, additional);
+    }
+    fatal(message, ...additional) {
+        this.logger.fatal(message, additional);
+    }
+    setCustomHttpHeaders(headers) {
+        this.logger.setCustomHttpHeaders(headers);
+    }
+    setCustomParams(params) {
+        this.logger.setCustomParams(params);
+    }
+    setWithCredentialsOptionValue(withCredentials) {
+        this.logger.setWithCredentialsOptionValue(withCredentials);
+    }
+    registerMonitor(monitor) {
+        this.logger.registerMonitor(monitor);
+    }
+    updateConfig(config) {
+        this.logger.updateConfig(config);
+    }
+    getConfigSnapshot() {
+        return this.logger.getConfigSnapshot();
+    }
+    static { this.ɵfac = function LoggerService_Factory(t) { return new (t || LoggerService)(i0.ɵɵinject(i1.NGXLogger)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LoggerService, factory: LoggerService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LoggerService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.NGXLogger }], null); })();
+//# sourceMappingURL=data:application/json;base64,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