ngx-techlify-core 11.4.8 → 11.5.2

package/src/lib/core/core.module.ts

@@ -0,0 +1,44 @@
+import { NgModule, Optional, SkipSelf } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HTTP_INTERCEPTORS, HttpClientModule, HttpClient } from '@angular/common/http';
+import { RouteReuseStrategy, RouterModule } from '@angular/router';
+
+import { RouteReusableStrategy } from './route-reusable-strategy';
+import { ApiPrefixInterceptor } from './api-prefix.interceptor';
+import { ErrorHandlerInterceptor } from './error-handler.interceptor';
+import { HttpService } from './http.service';
+import { TokenInterceptor } from './token.interceptor';
+import { CacheInterceptor } from './cache.interceptor';
+import { SnackModule } from './snack/snack.module';
+
+@NgModule({
+  imports: [
+    CommonModule,
+    HttpClientModule,
+    RouterModule,
+    SnackModule
+  ],
+  providers: [
+    {
+      provide: HttpClient,
+      useClass: HttpService
+    },
+    {
+      provide: RouteReuseStrategy,
+      useClass: RouteReusableStrategy
+    }
+  ],
+  exports: [
+    SnackModule
+  ]
+})
+export class CoreModule {
+
+  constructor(@Optional() @SkipSelf() parentModule: CoreModule) {
+    // Import guard
+    if (parentModule) {
+      throw new Error(`${parentModule} has already been loaded. Import Core module in the root module only.`);
+    }
+  }
+
+}

package/src/lib/core/credentials.service.ts

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import { ConfigService } from './config.service';
+
+export interface Credentials {
+  // Customize received credentials here
+  user: any;
+  token: any;
+}
+
+/**
+ * Provides storage for authentication credentials.
+ * The Credentials interface should be replaced with proper implementation.
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class CredentialsService {
+
+  private _credentials: Credentials | null = null;
+
+  constructor(private configService: ConfigService) {
+  }
+
+  /**
+   * Checks is the user is authenticated.
+   * @return True if the user is authenticated.
+   */
+  get isAuthenticated(): boolean {
+    return !!this.credentials;
+  }
+
+  /**
+   * Gets the user credentials.
+   * @return The user credentials or null if the user is not authenticated.
+   */
+  get credentials(): Credentials | null {
+    if (!this._credentials) {
+      this._credentials = JSON.parse(sessionStorage.getItem(this.configService.getCredentialsKey()) || localStorage.getItem(this.configService.getCredentialsKey()));
+    }
+    return this._credentials;
+  }
+
+  /**
+   * Sets the user credentials.
+   * The credentials may be persisted across sessions by setting the `remember` parameter to true.
+   * Otherwise, the credentials are only persisted for the current session.
+   * @param credentials The user credentials.
+   * @param remember True to remember credentials across sessions.
+   */
+  setCredentials(credentials?: Credentials, remember?: boolean) {
+    this._credentials = credentials || null;
+
+    if (credentials) {
+      (remember ? localStorage : sessionStorage).setItem(this.configService.getCredentialsKey(), JSON.stringify(credentials));
+    } else {
+      sessionStorage.clear();
+      localStorage.clear();
+      this._credentials = null;
+    }
+  }
+
+  getAccessToken(): string | null {
+    const expiration = this.credentials?.token?.expires_in || '';
+    const token = this.credentials?.token?.access_token || '';
+
+    if (!token || !expiration) {
+      return null;
+    }
+
+    if (Date.now() > parseInt(expiration)) {
+      this.setCredentials();
+      return null;
+    }
+
+    return token;
+  }
+
+  getExpiration(): string {
+    return this.credentials?.token?.expires_in || '';
+  }
+
+  getRefreshToken(): string {
+    return this.credentials?.token?.refresh_token || '';
+  }
+
+  refresh(): CredentialsService {
+    this._credentials = null;
+    return this;
+  }
+
+}

package/{lib/core/dataManager.service.d.ts → src/lib/core/dataManager.service.ts}

@@ -1,70 +1,124 @@
+import { Injectable } from '@angular/core';
 import { HttpService } from './http.service';
+
 /**
  * Service that provides a wrapper for retrieving data from the server
  * @deprecated use HttpService Instead
  * @author Joshua Kissoon
  * @since 20170709
  */
-export declare class DataManager {
-    private http;
-    constructor(http: HttpService);
+@Injectable({
+    providedIn: 'root'
+})
+export class DataManager {
+
+    constructor(private http: HttpService) { }
+
     /**
      * Callback wrapper for the HTTP GET Call
-     *
+     * 
      * @param urlq The query part of the URL to be sent to the server
-     *
+     * 
      * @author Joshua Kissoon
      * @since 20160826
      * @updated 20170711 to add parameters
      */
-    GET(urlq: string, params?: {}): any;
+    GET(urlq: string, params = {}): any {
+        return this.http
+            .get(urlq, { params: params })
+            .toPromise();
+    }
+
     /**
      * Callback wrapper for the HTTP POST Call
-     *
+     * 
      * @param urlq The query part of the URL to be sent to the server
      * @param object The object containing the POST data to be sent
-     *
+     * 
      * @author Joshua Kissoon
      * @since 20160826
      */
-    POST(urlq: string, object: any): any;
+    POST(urlq: string, object: any): any {
+        if (null == object) {
+            object = { "blank": "blank" };
+        }
+
+        return this.http
+            .post(urlq, object)
+            .toPromise();
+    }
+
     /**
      * Callback wrapper for the HTTP POST Call
-     *
+     * 
      * @param urlq The query part of the URL to be sent to the server
      * @param object The object containing the POST data to be sent
-     *
+     * 
      * @author Joshua Kissoon
      * @since 20160826
      */
-    POSTRAW(urlq: string, object: any): any;
+    POSTRAW(urlq: string, object: any): any {
+        if (null == object) {
+            object = { "blank": "blank" };
+        }
+
+        return this.http
+            .skipHeader()
+            .post(urlq, object)
+            .toPromise();
+    }
+
+
     /**
      * Callback wrapper for the HTTP PUT Call
-     *
+     * 
      * @param urlq The query part of the URL to be sent to the server
      * @param object The object containing the PUT data to be sent
-     *
+     * 
      * @author Joshua Kissoon
      * @since 20160826
      */
-    PUT(urlq: string, object: any): any;
+    PUT(urlq: string, object: any): any {
+        if (null == object) {
+            object = { "blank": "blank" };
+        }
+
+        return this.http
+            .put(urlq, object)
+            .toPromise();
+    }
+
     /**
      * Callback wrapper for the HTTP PATCH Call
-     *
+     * 
      * @param urlq The query part of the URL to be sent to the server
      * @param object The object containing the PUT data to be sent
-     *
+     * 
      * @author Joshua Kissoon
      * @since 20161107
      */
-    PATCH(urlq: string, object: any): any;
+    PATCH(urlq: string, object: any): any {
+        if (null == object) {
+            object = { "blank": "blank" };
+        }
+
+        return this.http
+            .patch(urlq, object)
+            .toPromise();
+    }
+
     /**
      * Callback wrapper for the HTTP DELETE Call
-     *
+     * 
      * @param urlq The query part of the URL to be sent to the server
-     *
+     * 
      * @author Joshua Kissoon
      * @since 20160826
      */
-    DELETE(urlq: string): any;
-}
+    DELETE(urlq: string): any {
+        return this.http
+            .delete(urlq)
+            .toPromise();
+    }
+
+}

package/src/lib/core/error-handler.interceptor.ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest, HttpErrorResponse } from '@angular/common/http';
+import { Observable, throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { Logger } from './logger.service';
+import { ConfigService } from './config.service';
+import { ErrorHandlerService } from './error-handler.service';
+
+const log = new Logger('ErrorHandlerInterceptor');
+
+/**
+ * Adds a default error handler to all requests.
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ErrorHandlerInterceptor implements HttpInterceptor {
+
+  constructor(private configService: ConfigService, private errorHandler: ErrorHandlerService) { }
+
+  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    return next.handle(request).pipe(catchError(error => this.handleError(error)));
+  }
+
+  // Customize the default error handler here if needed
+  private handleError(error: HttpErrorResponse): Observable<HttpEvent<any>> {
+    let errorMessage = '';
+    if (error.error instanceof ErrorEvent) {
+      // client-side error
+      errorMessage = `Client Error: ${this.configService?.getProjectKey()}: ${error.error.message}`;
+    } else {
+      // server-side error
+      errorMessage = `Server Error: ${this.configService?.getProjectKey()}`;
+      try {
+        this.errorHandler.handleError(error, 'Unexpected Server Error, try later or contact service team');
+      } catch (e) {
+        console.log("Unable to handle server error", e);
+      }
+    }
+    return throwError(error);
+  }
+
+}

package/src/lib/core/error-handler.service.ts

@@ -0,0 +1,61 @@
+import { TechlifyConfig } from './techlify-config.model';
+import { Injectable } from "@angular/core";
+import { AlertService } from "./alert.service";
+
+
+/**
+ * Service used to handle errors from the request
+ *
+ * @author Joshua Kissoon
+ * @since 20171202
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ErrorHandlerService {
+
+  constructor(private alerter: AlertService,
+    private config: TechlifyConfig,
+  ) {
+  }
+
+  handleError(errorResponse: any, msg: string = '') {
+    // 1 - Create empty array to store errors
+    const errors = [];
+
+    // 2 - check if the error object is present in the response
+    if (errorResponse?.error) {
+
+      // 3 - Check for Laravel form validation error messages object
+      if (errorResponse?.error?.errors) {
+
+        // 4 - For each error property (which is a form field)
+        for (const property in errorResponse.error.errors) {
+
+          if (errorResponse.error.errors?.hasOwnProperty(property)) {
+
+            // 5 - Extract it's array of errors
+            const propertyErrors: Array<string> = errorResponse?.error?.errors[property];
+
+            // 6 - Push all errors in the array to the errors array
+            propertyErrors.forEach(error => errors.push(error));
+          }
+
+        }
+      }
+
+      if (errors.length === 0) {
+        // 7 - Push the main error message to the array of errors if there is no validation error
+        errors.push(errorResponse.error.message ? errorResponse.error.message : errorResponse.error?.error);
+      }
+    }
+    var errMessage = errors.length ? errors[0] : msg;
+    this.alerter.addAlert("Error: " + errMessage, "warning");
+
+    if (errorResponse.status == 403 && this.config.isLogoutWhileApiGetsFailed) {
+      sessionStorage.clear();
+      localStorage.clear();
+      location.reload();
+    }
+  }
+}

package/src/lib/core/filter.service.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class FilterService {
+
+  filters: any;
+
+  constructor(private router: Router) { }
+
+  applyFilterToRoute(url, filter) {
+    this.router.navigate([filter],
+      {
+        relativeTo: url,
+        replaceUrl: true
+      }
+    )
+  }
+
+  getFiltersFromRoute(url, filterFormGroup) {
+    url.params.subscribe(
+      params => {
+        for (var filter in params) {
+          if (params[filter]) {
+
+            for (let [key, value] of Object.entries(filterFormGroup)) {
+              if (key === filter) {
+                filterFormGroup[key] = params[filter];
+              }
+            }
+
+          }
+
+        }
+      }
+    );
+    return filterFormGroup;
+  }
+
+}

package/src/lib/core/form-validator.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class FormValidatorService {
+
+  constructor() { }
+
+  /**Method to evaluate form fields*/
+  isFieldValid(field: string, formGroup: FormGroup | any, firstAttempt?: boolean) {
+    return (!formGroup.get(field).valid && formGroup.get(field).touched) ||
+      (!formGroup.get(field).valid && formGroup.get(field).untouched && firstAttempt);
+  }
+
+  /**Method to find error in form fields*/
+  getErrorMessage(field: string, formGroup: FormGroup | any, errorMessages: any, errorField?: string) {
+    const error = Object.keys(formGroup.get(field).errors);
+    return (error.length > 0) ? (errorMessages[errorField || field][error[0]] ? errorMessages[errorField || field][error[0]] : '') : '';
+  }
+
+}

package/src/lib/core/header.interceptor.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+
+/**
+ * Prefixes all requests not starting with `http[s]` with `environment.serverUrl`.
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class HeaderInterceptor implements HttpInterceptor {
+
+  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    request = request.clone({
+      setHeaders: {
+        'Content-Type': request.headers.get('Content-Type') || 'application/json',
+      }
+    });
+    return next.handle(request);
+  }
+}

package/src/lib/core/http-cache.service.ts

@@ -0,0 +1,122 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { ConfigService } from './config.service';
+import { Logger } from './logger.service';
+
+const log = new Logger('HttpCacheService');
+
+
+export interface HttpCacheEntry {
+  lastUpdated: Date;
+  data: HttpResponse<any>;
+}
+
+/**
+ * Provides a cache facility for HTTP requests with configurable persistence policy.
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class HttpCacheService {
+
+  private cachedData: { [key: string]: HttpCacheEntry; } = {};
+  private storage: Storage | any | null;
+  private cachePersistenceKey: String | any;
+
+  constructor(private configService: ConfigService) {
+    this.storage = this.configService.getStorage();
+    this.cachePersistenceKey = this.configService.getProjectKey() + '_HTTP_CACHE';
+    this.loadCacheData();
+  }
+
+  /**
+   * Sets the cache data for the specified request.
+   * @param {!string} url The request URL.
+   * @param {ResponseOptions} data The received data.
+   * @param {Date=} lastUpdated The cache last update, current date is used if not specified.
+   */
+  setCacheData(url: string, data: HttpResponse<any>, lastUpdated?: Date) {
+    this.cachedData[url] = {
+      lastUpdated: lastUpdated || new Date(),
+      data: data
+    };
+    log.debug(`Cache set for key: "${url}"`);
+    this.saveCacheData();
+  }
+
+  /**
+   * Gets the cached data for the specified request.
+   * @param {!string} url The request URL.
+   * @return {?ResponseOptions} The cached data or null if no cached data exists for this request.
+   */
+  getCacheData(url: string): HttpResponse<any> | null {
+    const cacheEntry = this.cachedData[url];
+
+    if (cacheEntry) {
+      log.debug(`Cache hit for key: "${url}"`);
+      return cacheEntry.data;
+    }
+
+    return null;
+  }
+
+  /**
+   * Gets the cached entry for the specified request.
+   * @param {!string} url The request URL.
+   * @return {?HttpCacheEntry} The cache entry or null if no cache entry exists for this request.
+   */
+  getHttpCacheEntry(url: string): HttpCacheEntry | null {
+    return this.cachedData[url] || null;
+  }
+
+  /**
+   * Clears the cached entry (if exists) for the specified request.
+   * @param {!string} url The request URL.
+   */
+  clearCache(url: string): void {
+    delete this.cachedData[url];
+    log.debug(`Cache cleared for key: "${url}"`);
+    this.saveCacheData();
+  }
+
+  /**
+   * Cleans cache entries older than the specified date.
+   * @param {date=} expirationDate The cache expiration date. If no date is specified, all cache is cleared.
+   */
+  cleanCache(expirationDate?: Date) {
+    if (expirationDate) {
+      Object(this.cachedData).keys.forEach((key: string) => {
+        if (expirationDate >= this.cachedData[key]?.lastUpdated) {
+          delete this.cachedData[key];
+        }
+      });
+    } else {
+      this.cachedData = {};
+    }
+    this.saveCacheData();
+  }
+
+  /**
+   * Sets the cache persistence policy.
+   * Note that changing the cache persistence will also clear the cache from its previous storage.
+   * @param {'local'|'session'=} persistence How the cache should be persisted, it can be either local or session
+   *   storage, or if no value is provided it will be only in-memory (default).
+   */
+  setPersistence(persistence?: 'local' | 'session') {
+    this.cleanCache();
+    this.storage = persistence === 'local' ? localStorage : persistence === 'session' ? sessionStorage : null;
+    this.loadCacheData();
+  }
+
+  private saveCacheData() {
+    if (this.storage) {
+      this.storage[this.cachePersistenceKey] = JSON.stringify(this.cachedData);
+    }
+  }
+
+  private loadCacheData() {
+    const data = this.storage ? this.storage[this.cachePersistenceKey] : null;
+    this.cachedData = data ? JSON.parse(data) : {};
+  }
+
+}