@uiapplib/ngx-ui-web-lib 0.0.1

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

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/storage-angular";
+export class HelpService {
+    constructor(storage) {
+        this.storage = storage;
+        this.showing = false;
+        this.showHelpButton = new BehaviorSubject(false);
+    }
+    setupDefaultHelpBehaviour(preferences) {
+        this.helpPreferences = preferences;
+        this.setupPreferenceInStorageIfNotPresent();
+    }
+    setupPreferenceInStorageIfNotPresent() {
+        this.helpPreferences
+            .forEach(async (preference) => {
+            let pref = await this.storage.get(preference.name);
+            if (pref == null || pref == undefined) {
+                this.storage.set(preference.name, preference.showOnLoad);
+            }
+        });
+    }
+    show() {
+        this.showing = true;
+    }
+    hide() {
+        this.showing = false;
+    }
+    isShowing() {
+        return this.showing;
+    }
+    setHelpAvailability(isAvailable) {
+        if (!isAvailable) {
+            this.hide();
+        }
+        this.showHelpButton.next(isAvailable);
+    }
+    shouldDisplayHelpButton() {
+        return this.showHelpButton;
+    }
+    setPreference(name, value) {
+        this.storage.set(name, value);
+    }
+    getPreference(name) {
+        return this.storage.get(name);
+    }
+    async showDialogIfPreferenceAllow(name) {
+        let pref = await this.getPreference(name);
+        if (pref) {
+            this.show();
+        }
+    }
+    static { this.ɵfac = function HelpService_Factory(t) { return new (t || HelpService)(i0.ɵɵinject(i1.Storage)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: HelpService, factory: HelpService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HelpService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.Storage }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

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/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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