ngx-techlify-core 11.5.2 → 14.2.1

package/src/lib/core/api-prefix.interceptor.ts

@@ -1,22 +0,0 @@
-import { Injectable } from '@angular/core';
-import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from '@angular/common/http';
-import { Observable } from 'rxjs';
-import { ConfigService } from './config.service';
-
-/**
- * Prefixes all requests not starting with `http[s]` with `environment.serverUrl`.
- */
-@Injectable({
-  providedIn: 'root'
-})
-export class ApiPrefixInterceptor implements HttpInterceptor {
-
-  constructor(private configService: ConfigService) { }
-
-  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
-    if (!/^(http|https):/i.test(request.url)) {
-      request = request.clone({ url: this.configService.getApiUrl() + request.url });
-    }
-    return next.handle(request);
-  }
-}

package/src/lib/core/authentication.guard.ts

@@ -1,34 +0,0 @@
-import { Injectable } from '@angular/core';
-import { Router, CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
-import { CredentialsService } from './credentials.service';
-import { Logger } from './logger.service';
-
-const log = new Logger('AuthenticationGuard');
-
-@Injectable({
-  providedIn: 'root'
-})
-export class AuthenticationGuard implements CanActivate {
-
-  constructor(private router: Router,
-    private credentialsService: CredentialsService) { }
-
-  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean {
-    return this.isUserAuthenticated(route, state);
-  }
-
-  canLoad(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean {
-    return this.isUserAuthenticated(route, state);
-  }
-
-  isUserAuthenticated(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean {
-    if (this.credentialsService.isAuthenticated) {
-      return true;
-    }
-
-    log.debug('Not authenticated, redirecting and adding redirect url...');
-    this.router.navigate(['/login'], { queryParams: { redirect: state.url }, replaceUrl: true });
-    return false;
-  }
-
-}

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

@@ -1,53 +0,0 @@
-
-import { Injectable } from '@angular/core';
-import { Observable, of } from 'rxjs';
-import { concatMap, map } from 'rxjs/operators';
-import { Credentials, CredentialsService } from './credentials.service';
-import { HttpService } from './http.service';
-
-/**
- * Provides a base for authentication workflow.
- * The login/logout methods should be replaced with proper implementation.
- */
-@Injectable({
-  providedIn: 'root'
-})
-export class AuthenticationService {
-
-  constructor(private credentialsService: CredentialsService, private http: HttpService) { }
-
-  /**
-   * Authenticates the user.
-   * @param context The login parameters.
-   * @return The user credentials.
-   */
-  login(context: any): Observable<Credentials> {
-    const data = <Credentials>{};
-    return this.http
-      .skipToken()
-      .post('oauth/token', context)
-      .pipe(
-        concatMap(async (tokenInfo: any) => {
-          tokenInfo.expires_in = Date.now() + (tokenInfo.expires_in * 1000);
-          data.token = tokenInfo;
-          data.user = {};
-          this.credentialsService.setCredentials(data, context.remember);
-          const userInfo: any = await this.http.get('api/user/current').toPromise();
-          data.user = userInfo?.user;
-          this.credentialsService.setCredentials(data, context.remember);
-          return data;
-        })
-      )
-  }
-
-  /**
-   * Logs out the user and clear credentials.
-   * @return True if the user was logged out successfully.
-   */
-  logout(): Observable<boolean> {
-
-    this.credentialsService.setCredentials();
-    return of(true);
-  }
-
-}

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

@@ -1,59 +0,0 @@
-import { Injectable } from '@angular/core';
-import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest, HttpResponse } from '@angular/common/http';
-import { HttpCacheService } from './http-cache.service';
-import { Observable, Subscriber } from 'rxjs';
-
-/**
- * Caches HTTP requests.
- * Use ExtendedHttpClient fluent API to configure caching for each request.
- */
-@Injectable({
-  providedIn: 'root'
-})
-export class CacheInterceptor implements HttpInterceptor {
-
-  private forceUpdate = false;
-
-  constructor(private httpCacheService: HttpCacheService) { }
-
-  /**
-   * Configures interceptor options
-   * @param {{update: boolean}} options If update option is enabled, forces request to be made and updates cache entry.
-   * @return {CacheInterceptor} The configured instance.
-   */
-  configure(options?: { update?: boolean } | null): CacheInterceptor {
-    const instance = new CacheInterceptor(this.httpCacheService);
-    if (options && options.update) {
-      instance.forceUpdate = true;
-    }
-    return instance;
-  }
-
-  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
-    if (request.method !== 'GET') {
-      return next.handle(request);
-    }
-
-    return new Observable((subscriber: Subscriber<HttpEvent<any>>) => {
-      const cachedData = this.forceUpdate ? null : this.httpCacheService.getCacheData(request.urlWithParams);
-      if (cachedData !== null) {
-        // Create new response to avoid side-effects
-        subscriber.next(new HttpResponse(cachedData as Object));
-        subscriber.complete();
-      } else {
-        next.handle(request)
-          .subscribe(
-            event => {
-              if (event instanceof HttpResponse) {
-                this.httpCacheService.setCacheData(request.urlWithParams, event);
-              }
-              subscriber.next(event);
-            },
-            error => subscriber.error(error),
-            () => subscriber.complete()
-          );
-      }
-    });
-  }
-
-}

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

@@ -1,52 +0,0 @@
-import { Injectable } from '@angular/core';
-
-import { TechlifyConfig } from "./techlify-config.model";
-
-/**
- * Service that provides settings for all other services
- *
- * @author Joshua Kissoon
- * @since 20170709
- */
-@Injectable({
-  providedIn: 'root'
-})
-export class ConfigService {
-
-  public static BASE_CREDENTIALS = "credentials";
-
-  private config: TechlifyConfig;
-
-  constructor(config: TechlifyConfig) {
-    this.config = config;
-  }
-
-  getConfigsRaw() {
-    return this.config.rawConfigs;
-  }
-
-  getProjectKey() {
-    return this.config.projectKey;
-  }
-
-  getApiUrl() {
-    return this.config.apiUrl;
-  }
-
-  getAuthClientSecret() {
-    return this.config.authClientSecret;
-  }
-
-  getStorage() {
-    return this.config.storage ? this.config.storage : localStorage;
-  }
-
-  getAuthGrantType() {
-    return this.config.authGrantType;
-  }
-
-  getCredentialsKey() {
-    return this.config.projectKey + "_" + ConfigService.BASE_CREDENTIALS;
-  }
-
-}

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

@@ -1,44 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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/src/lib/core/error-handler.interceptor.ts

@@ -1,43 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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) : {};
-  }
-
-}