zek 17.3.88 → 17.3.97

package/fesm2022/zek.mjs

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { Injectable, inject, InjectionToken, Inject, Directive, EventEmitter, Input, Output, ViewChild, Pipe, Component, forwardRef, NgModule, HostListener, ViewEncapsulation, ChangeDetectionStrategy, Optional } from '@angular/core';
 import * as i1 from '@angular/router';
 import { Router, NavigationStart, ActivatedRoute, RouterModule } from '@angular/router';
-import { BehaviorSubject, Subject, of, tap, catchError, firstValueFrom, interval, timer } from 'rxjs';
+import { Subject, of, tap, catchError, firstValueFrom, interval, BehaviorSubject, timer } from 'rxjs';
 import * as i2 from '@ngx-translate/core';
 import { TranslateService, TranslateModule } from '@ngx-translate/core';
 import * as i1$1 from '@angular/common/http';
@@ -1434,50 +1434,68 @@ class ValidationHelper {
 }
 
 class AuthService {
+    static { this.USER_KEY = 'user'; }
+    static { this.REFRESH_TOKEN_INTERVAL = 15 * 60 * 1000; }
     constructor() {
-        this._isInitialized = false;
-        this._oldValue = false;
+        this._auth = false;
         this._user = null;
+        const user = StorageHelper.get(AuthService.USER_KEY);
+        if (user) {
+            this._init(user);
+        }
+    }
+    get _isAuthenticated() {
+        const expired = this.getExpired();
+        return new Date() < expired;
     }
-    static { this.USER_KEY = 'user'; }
-    // access_token
     get user() {
-        if (!this._isInitialized) {
-            const user = StorageHelper.get(AuthService.USER_KEY);
-            if (user) {
-                user.id = ObjectHelper.isDefined(user.id) ? Convert.parseNumber(user.id) : user.id;
-                user.expired = ObjectHelper.isDefined(user.expired) ? DateHelper.parseDate(user.expired) : user.expired;
-                user.refreshTokenTime = ObjectHelper.isDefined(user.refreshTokenTime) ? DateHelper.parseDate(user.refreshTokenTime) : user.refreshTokenTime;
-                if (Array.isArray(user.roles)) {
-                    user.roles = user.roles.map(function (e) { return e ? e.toUpperCase() : e; });
-                }
-            }
-            this._user = user;
-            this._isInitialized = true;
-            this._starRefreshTokenTimer();
-        }
         return this._user;
     }
-    _starRefreshTokenTimer() {
-        this._stopRefreshTokenTimer();
-        const user = this._user;
-        if (user && user.refreshTokenTime) {
-            let timeout = user.refreshTokenTime.getTime() - Date.now(); // - (60 * 1000);
-            if (timeout < 0) {
+    get isAuthenticated() {
+        return this._auth;
+    }
+    _starTimer() {
+        this._stopTimer();
+        let interval = this.getExpired().getTime() - new Date().getTime();
+        if (interval < 1000)
+            interval = 1000;
+        if (interval > 0 && this._user) {
+            this._refreshTimerId = setInterval(() => {
                 this.emitOnRefreshToken();
+            }, interval);
+            if (this._user) {
+                this._timerId = setInterval(() => {
+                    this._onTick();
+                }, 1000);
             }
-            const minRefreshTime = 60000; //1 min;
-            if (timeout < minRefreshTime) {
-                timeout = minRefreshTime;
+        }
+    }
+    _stopTimer() {
+        if (typeof this._timerId === 'number') {
+            clearInterval(this._timerId);
+        }
+    }
+    _onTick() {
+        const newValue = this._isAuthenticated;
+        if (this._auth !== newValue) {
+            this._auth = newValue;
+            if (!newValue) {
+                this.logout();
             }
-            this._timerId = setInterval(() => {
+        }
+    }
+    _starRefreshTokenTimer() {
+        this._stopRefreshTokenTimer();
+        const interval = AuthService.REFRESH_TOKEN_INTERVAL;
+        if (interval > 0 && this._user) {
+            this._refreshTimerId = setInterval(() => {
                 this.emitOnRefreshToken();
-            }, timeout);
+            }, interval);
         }
     }
     _stopRefreshTokenTimer() {
-        if (typeof this._timerId === 'number') {
-            clearInterval(this._timerId);
+        if (typeof this._refreshTimerId === 'number') {
+            clearInterval(this._refreshTimerId);
         }
     }
     emitOnRefreshToken() {
@@ -1485,28 +1503,14 @@ class AuthService {
             this._onRefreshTokenSubject.next();
         }
     }
-    isAuthenticated() {
-        const expired = this.getExpired() || new Date(0); // if getExpired is null return min JS date
-        const newValue = new Date() < expired;
-        if (this._oldValue !== newValue) {
-            this._oldValue = newValue;
-            this.emitOnSignedIn();
-            //if user is signed in and expired we need to logout (remove from localStorage)
-            if (!newValue) {
-                this.logout();
-            }
-            return newValue;
-        }
-        return newValue;
-    }
     emitOnSignedIn() {
         if (this._onSignedInSubject) {
-            this._onSignedInSubject.next(this._oldValue);
+            this._onSignedInSubject.next(this._auth);
         }
     }
     get onSignedIn() {
         if (!this._onSignedInSubject) {
-            this._onSignedInSubject = new BehaviorSubject(false);
+            this._onSignedInSubject = new Subject(); //(this.isAuthenticated);
             this._onSignedInObservable = this._onSignedInSubject.asObservable();
         }
         if (!this._onSignedInObservable)
@@ -1524,39 +1528,42 @@ class AuthService {
     }
     login(user) {
         StorageHelper.set(AuthService.USER_KEY, user);
-        this._user = null;
-        this._isInitialized = false; //user get method will init user
-        this.isAuthenticated(); //this method need to execute subject.next();        
+        this._init(user);
     }
-    logout() {
-        this.login(null);
-    }
-    getExpired() {
-        const user = this.user;
+    _init(user) {
         if (user) {
-            return user.expired;
+            //convert string to local date/time
+            user.expired = ObjectHelper.isDefined(user.expired) ? DateHelper.parseDate(user.expired) : user.expired;
+            if (Array.isArray(user.roles)) {
+                user.roles = user.roles.map(function (e) { return e ? e.toUpperCase() : e; });
+            }
         }
-        return null;
+        this._user = user;
+        //if old value was false and we set true then we need to emit
+        if (!this._auth) {
+            this._auth = true;
+            this.emitOnSignedIn();
+        }
+        this._starTimer();
+        this._starRefreshTokenTimer();
     }
-    getRefreshTokenExpired() {
-        const user = this.user;
-        if (user) {
-            return user.refreshTokenTime;
+    logout() {
+        StorageHelper.set(AuthService.USER_KEY, null);
+        this._user = null;
+        if (this._auth) {
+            this._auth = false;
+            this.emitOnSignedIn();
         }
-        return null;
+        this._stopTimer();
+        this._stopRefreshTokenTimer();
+    }
+    /**
+     *
+     * @returns user expiry date. if user is null returns min JS date
+     */
+    getExpired() {
+        return this.user?.expired ?? new Date(0);
     }
-    // isInRole(allowedRoles: string[]): boolean {
-    //     if (!allowedRoles || allowedRoles.length === 0) {
-    //         return true;
-    //     }
-    //     const tmp = this.getUser();
-    //     const roles = tmp ? tmp.roles : null;
-    //     if (!roles || roles.length === 0) {
-    //         return false;
-    //     }
-    //     let isInRole = allowedRoles.some(role => roles.indexOf(role) !== -1);
-    //     return isInRole;
-    // }
     hasPermission(permission) {
         if (!permission) {
             return true;
@@ -1619,12 +1626,12 @@ class AuthService {
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: AuthService, decorators: [{
             type: Injectable
-        }] });
+        }], ctorParameters: () => [] });
 
 const zekAuthGuard = (route, state) => {
     const auth = inject(AuthService);
     const router = inject(Router);
-    if (!auth.isAuthenticated()) {
+    if (!auth.isAuthenticated) {
         router.navigate(['/login'], { queryParams: { returnUrl: state.url } });
         return false;
     }
@@ -1934,7 +1941,8 @@ class WebApiClient {
         this.baseUrl = baseUrl;
     }
     get(url, params) {
-        return this.http.get(this.baseUrl + url, { headers: this.getHeaders(), params: this.toHttpParams(params) });
+        const combinedUrl = UrlHelper.combine(this.baseUrl, url);
+        return this.http.get(combinedUrl, { headers: this.getHeaders(), params: this.toHttpParams(params) });
         /*.catch(catchError(this.handleError(url)))
         .do((res: Response) => {
             // Handle success, maybe display notification
@@ -1947,16 +1955,20 @@ class WebApiClient {
     */
     }
     getString(url, params) {
-        return this.http.get(this.baseUrl + url, { headers: this.getHeaders(), responseType: 'text', params: this.toHttpParams(params) });
+        const combinedUrl = UrlHelper.combine(this.baseUrl, url);
+        return this.http.get(combinedUrl, { headers: this.getHeaders(), responseType: 'text', params: this.toHttpParams(params) });
     }
     getBytes(url, params) {
-        return this.http.get(this.baseUrl + url, { headers: this.getHeaders(), responseType: 'arraybuffer', params: this.toHttpParams(params) });
+        const combinedUrl = UrlHelper.combine(this.baseUrl, url);
+        return this.http.get(combinedUrl, { headers: this.getHeaders(), responseType: 'arraybuffer', params: this.toHttpParams(params) });
     }
     getBlob(url, params) {
-        return this.http.get(this.baseUrl + url, { headers: this.getHeaders(), responseType: 'blob', params: this.toHttpParams(params) });
+        const combinedUrl = UrlHelper.combine(this.baseUrl, url);
+        return this.http.get(combinedUrl, { headers: this.getHeaders(), responseType: 'blob', params: this.toHttpParams(params) });
     }
     postBlob(url, body) {
-        return this.http.post(this.baseUrl + url, body, { headers: this.getHeaders(), responseType: 'blob' });
+        const combinedUrl = UrlHelper.combine(this.baseUrl, url);
+        return this.http.post(combinedUrl, body, { headers: this.getHeaders(), responseType: 'blob' });
     }
     toHttpParams(obj) {
         if (!obj)
@@ -1999,26 +2011,26 @@ class WebApiClient {
     //    return undefined;
     //}
     post(url, body) {
-        return this.http.post(this.baseUrl + url, body, { headers: this.getHeaders(body) });
+        return this.http.post(UrlHelper.combine(this.baseUrl, url), body, { headers: this.getHeaders(body) });
         //.pipe(
         //catchError(this.handleError(url))
         //);
     }
     put(url, body) {
-        return this.http.put(this.baseUrl + url, body, { headers: this.getHeaders(body) });
+        return this.http.put(UrlHelper.combine(this.baseUrl, url), body, { headers: this.getHeaders(body) });
         //.pipe(
         //catchError(this.handleError(url))
         //);
     }
     delete(url, body) {
-        return this.http.request('delete', this.baseUrl + url, { body, headers: this.getHeaders(body) });
+        return this.http.request('delete', UrlHelper.combine(this.baseUrl, url), { body, headers: this.getHeaders(body) });
         //return this.http.delete(environment.url + url, { headers: this.getHeaders() });
         //.pipe(
         //catchError(this.handleError(url))
         //);
     }
     patch(url, body) {
-        return this.http.patch(this.baseUrl + url, body, { headers: this.getHeaders(body) });
+        return this.http.patch(UrlHelper.combine(this.baseUrl, url), body, { headers: this.getHeaders(body) });
     }
     getHeaders(body) {
         let httpHeaders = new HttpHeaders();