monkey-front-core 0.0.237 → 0.0.238

package/src/lib/core/services/error/monkeyecx-error-handling.service.ts

@@ -0,0 +1,33 @@
+import {
+  Injectable, Injector, ErrorHandler
+} from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { MonkeyEcxHttpErrorHandlingService } from './monkeyecx-http-error-handling.service';
+import { MonkeyEcxHandlingService } from '../monkeyecx-handling.service';
+import { MonkeyEcxOthersErrorsHandlingService } from './monkeyecx-others-errors-handling.service';
+import { MonkeyEcxUtils } from '../../utils/utils';
+import { MonkeyEcxServiceCredentials } from '../../interfaces';
+
+@Injectable({ providedIn: 'root' })
+export class MonkeyEcxErrorHandlingService implements ErrorHandler {
+  constructor(private injector: Injector) {
+    // not to do
+  }
+
+  handleError(error: any, type?: string) {
+    const { injector } = this;
+    const handlingService = injector.get(MonkeyEcxHandlingService);
+    const httpErrorHandlingService = injector.get(MonkeyEcxHttpErrorHandlingService);
+    const othersErrorsHandlingService = injector.get(MonkeyEcxOthersErrorsHandlingService);
+
+    if (error instanceof HttpErrorResponse) {
+      const sCredentials: MonkeyEcxServiceCredentials =
+        handlingService?.getMonkeyEcxServiceCredentials() || {};
+      if (MonkeyEcxUtils.persistNullEmptyUndefined(type) && type === 'refresh_token') {
+        httpErrorHandlingService.handleErrorRefreshToken(error, sCredentials);
+      } else httpErrorHandlingService.handleError(error, sCredentials);
+    } else {
+      othersErrorsHandlingService.handleError(error);
+    }
+  }
+}

package/src/lib/core/services/error/monkeyecx-http-error-handling.service.ts

@@ -0,0 +1,160 @@
+import { Injectable, NgZone } from '@angular/core';
+import { Router } from '@angular/router';
+import { HttpErrorResponse } from '@angular/common/http';
+import { TranslateService } from '@ngx-translate/core';
+import { MonkeyStyleGuideSnackbarService } from 'monkey-style-guide';
+import { MonkeyEcxAuthenticationService } from '../auth';
+import { MonkeyEcxService } from '../monkeyecx-service.service';
+import { MonkeyEcxTokenStorageService } from '../storage';
+import { MonkeyEcxCommonsService } from '../commons';
+import { MonkeyEcxServiceCredentials } from '../../interfaces';
+import { MonkeyEcxUtils } from '../../utils/utils';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxHttpErrorHandlingService extends MonkeyEcxCommonsService {
+  constructor(
+    monkeyecxService: MonkeyEcxService,
+    tokenStorage: MonkeyEcxTokenStorageService,
+    private monkeyecxAuthenticationService: MonkeyEcxAuthenticationService,
+    private router: Router,
+    private snackbarService: MonkeyStyleGuideSnackbarService,
+    private translateService: TranslateService
+  ) {
+    super(monkeyecxService, tokenStorage);
+
+    super.resolve(null, null);
+
+    this.geti18n(this.translateService, 'SERVICES.WARNING');
+  }
+
+  private isHttpCodeIgnoreMessage(tp: MonkeyEcxServiceCredentials, httpCode: number): boolean {
+    if (!MonkeyEcxUtils.persistNullEmptyUndefined(tp) && !tp?.httpResponse) {
+      return false;
+    }
+
+    const found = (tp?.httpResponse?.httpCodeIgnore || [])?.indexOf(httpCode) > -1;
+
+    return found;
+  }
+
+  private isHttpCodeIgnoreRedirect(
+    tp: MonkeyEcxServiceCredentials,
+    httpCode: number
+  ): boolean {
+    if (!MonkeyEcxUtils.persistNullEmptyUndefined(tp) && !tp?.httpResponse) {
+      return false;
+    }
+
+    const found = (tp?.httpResponse?.httpCodeIgnoreRedirect || [])?.indexOf(httpCode) > -1;
+
+    return found;
+  }
+
+  private getMessageType(status: number): 'theme' | 'warning' | 'success' | 'error' | 'question' {
+    if (status === 409 || status === 400) {
+      return 'warning';
+    }
+
+    return 'error';
+  }
+
+  private showMessage(
+    message: string,
+    error: HttpErrorResponse,
+    mkc: MonkeyEcxServiceCredentials
+  ) {
+    const { snackbarService } = this;
+    if (!this.isHttpCodeIgnoreMessage(mkc, error.status)) {
+      snackbarService.show({
+        title: this.__i18n?.TITLE,
+        message,
+        type: this.getMessageType(error.status),
+        duration: 4000,
+        horizontalPosition: 'center',
+        verticalPosition: 'top'
+      });
+    }
+  }
+
+  private handleMessage(error: HttpErrorResponse, mkc: MonkeyEcxServiceCredentials) {
+    // eslint-disable-next-line camelcase
+    const { notifications, error_description, message } = error.error;
+    let customMessage = '';
+
+    if (message) {
+      customMessage = message;
+    }
+
+    // eslint-disable-next-line camelcase
+    if (error_description) {
+      // eslint-disable-next-line camelcase
+      customMessage = error_description;
+    }
+
+    if (notifications) {
+      customMessage = notifications;
+    }
+
+    if (!customMessage) {
+      if (error.error instanceof Blob) {
+        const blob = new Blob([error.error], {
+          type: 'application/json'
+        });
+        const reader = new FileReader();
+        reader.addEventListener('loadend', (e) => {
+          const text = e?.target?.result;
+          const jsonResp = JSON.parse(text as string);
+          customMessage = jsonResp.notifications;
+          this.showMessage(customMessage, error, mkc);
+        });
+        reader.readAsText(blob);
+      } else {
+        this.showMessage(this.__i18n['ERROR-HANDLING']?.ERROR, error, mkc);
+      }
+    } else {
+      this.showMessage(customMessage, error, mkc);
+    }
+  }
+
+  public handleError(error: HttpErrorResponse, mkc: MonkeyEcxServiceCredentials) {
+    const { router, tokenStorage } = this;
+    const { status } = error;
+    const { companyType } = tokenStorage?.getToken() || { companyType: '' };
+
+    const routes: any = {
+      403: 'forbidden',
+      500: 'service-problems',
+      503: 'service-problems'
+    };
+
+    let route = '/app';
+    if (companyType) {
+      route = `${route}/${companyType}/pages`;
+    } else {
+      route = `${route}/pages`;
+    }
+
+    const found = routes[status];
+    let timeout = 0;
+
+    if (found && !this.isHttpCodeIgnoreRedirect(mkc, error?.status)) {
+      route = `${route}/${found}`.toLowerCase();
+      timeout = 800;
+      router.navigate([route]);
+    }
+
+    setTimeout(() => {
+      this.handleMessage(error, mkc);
+    }, timeout);
+  }
+
+  public handleErrorRefreshToken(error: HttpErrorResponse, mkc: MonkeyEcxServiceCredentials) {
+    if (error.status === 401 || error.status === 400) {
+      NgZone.call(this.monkeyecxAuthenticationService.redirectLoginWelcomeBack(), {});
+    } else if (!this.isHttpCodeIgnoreMessage(mkc, error.status)) {
+      this.handleMessage(error, mkc);
+    }
+  }
+}

package/src/lib/core/services/error/monkeyecx-others-errors-handling.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { MonkeyStyleGuideModalService } from 'monkey-style-guide';
+import { VersionChangedComponent } from '../../../components/version-changed';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxOthersErrorsHandlingService {
+  constructor(private modalService: MonkeyStyleGuideModalService) {
+    // not to do
+  }
+
+  public handleError(error: any) {
+    const { modalService } = this;
+    const { message } = error;
+
+    if (new RegExp(/Loading chunk [\d]+ failed/).test(message)) {
+      modalService.open(VersionChangedComponent, {
+        color: 'theme',
+        size: 'md'
+      });
+    }
+  }
+}

package/{lib/core/services/index.d.ts → src/lib/core/services/index.ts}

@@ -1,22 +1,22 @@
-export * from './auth';
-export * from './commons/monkeyecx-commons.service';
-export * from './config/monkeyecx-config.module';
-export * from './config/monkeyecx-config.service';
-export * from './config/monkeyecx-error-config.service';
-export * from './config/monkeyecx-feature-toggle.service';
-export * from './config/monkeyecx-i18n-config.service';
-export * from './config/monkeyecx-logs-config.service';
-export * from './config/monkeyecx-maintenance-config.service';
-export * from './config/monkeyecx-security-console-config.service';
-export * from './config/monkeyecx-service-worker-config.service';
-export * from './error';
-export * from './logged';
-export * from './pagination';
-export * from './monkeyecx-service.service';
-export * from './monkeyecx-handling.service';
-export * from './request-download';
-export * from './request-paged';
-export * from './request-queue';
-export * from './routes';
-export * from './schedules';
-export * from './storage';
+export * from './auth';
+export * from './commons/monkeyecx-commons.service';
+export * from './config/monkeyecx-config.module';
+export * from './config/monkeyecx-config.service';
+export * from './config/monkeyecx-error-config.service';
+export * from './config/monkeyecx-feature-toggle.service';
+export * from './config/monkeyecx-i18n-config.service';
+export * from './config/monkeyecx-logs-config.service';
+export * from './config/monkeyecx-maintenance-config.service';
+export * from './config/monkeyecx-security-console-config.service';
+export * from './config/monkeyecx-service-worker-config.service';
+export * from './error';
+export * from './logged';
+export * from './pagination';
+export * from './monkeyecx-service.service';
+export * from './monkeyecx-handling.service';
+export * from './request-download';
+export * from './request-paged';
+export * from './request-queue';
+export * from './routes';
+export * from './schedules';
+export * from './storage';

package/{lib/core/services/logged/index.d.ts → src/lib/core/services/logged/index.ts}

@@ -1 +1 @@
-export * from './monkeyecx-logged-handling.service';
+export * from './monkeyecx-logged-handling.service';

package/src/lib/core/services/logged/monkeyecx-logged-handling.service.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { MonkeyEcxRequestSchedule } from '../../interfaces';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxLoggedHandlingService {
+  private schedules: MonkeyEcxRequestSchedule[] = [];
+
+  private genericSchedules: MonkeyEcxRequestSchedule[] = [];
+
+  constructor() {
+    // not to do
+  }
+
+  private destroySchedule() {
+    this.schedules.forEach((sch: MonkeyEcxRequestSchedule) => {
+      clearInterval(sch.interval);
+    });
+    this.schedules = [];
+  }
+
+  private destroyGenericSchedule() {
+    this.genericSchedules.forEach((sch: MonkeyEcxRequestSchedule) => {
+      clearInterval(sch.interval);
+    });
+    this.genericSchedules = [];
+  }
+
+  public addSchedule(sch: MonkeyEcxRequestSchedule[]) {
+    this.schedules = sch;
+  }
+
+  public addGenericSchedule(sch: MonkeyEcxRequestSchedule[]) {
+    this.genericSchedules = sch;
+  }
+
+  public destroy() {
+    this.destroySchedule();
+    this.destroyGenericSchedule();
+  }
+}

package/src/lib/core/services/monkeyecx-handling.service.ts

@@ -0,0 +1,58 @@
+/* eslint-disable max-len */
+import { Injectable } from '@angular/core';
+import { MonkeyEcxRequestDownload } from '../interfaces/request-download/monkeyecx-request-download';
+import { MonkeyEcxRequestQueue } from '../interfaces/request-queue/monkeyecx-request-queue';
+import { MonkeyEcxRequestUpload } from '../interfaces/request-upload/monkeyecx-request-upload';
+import { MonkeyEcxServiceCredentials } from '../interfaces/monkeyecx-service-credentials';
+
+@Injectable({
+  providedIn: 'root'
+})
+export abstract class MonkeyEcxHandlingService {
+  private monkeyecxServiceCredentials: MonkeyEcxServiceCredentials | null = null;
+
+  private monkeyecxRequestQueue: MonkeyEcxRequestQueue | null = null;
+
+  private monkeyecxRequestDownload: MonkeyEcxRequestDownload | null = null;
+
+  private monkeyecxRequestUpload: MonkeyEcxRequestUpload | null = null;
+
+  public clearAll() {
+    this.monkeyecxServiceCredentials = null;
+    this.monkeyecxRequestQueue = null;
+    this.monkeyecxRequestDownload = null;
+    this.monkeyecxRequestUpload = null;
+  }
+
+  public setMonkeyEcxServiceCredentials(param: MonkeyEcxServiceCredentials) {
+    this.monkeyecxServiceCredentials = param;
+  }
+
+  public getMonkeyEcxServiceCredentials(): MonkeyEcxServiceCredentials | null {
+    return this.monkeyecxServiceCredentials;
+  }
+
+  public setMonkeyEcxRequestQueue(queue: MonkeyEcxRequestQueue) {
+    this.monkeyecxRequestQueue = queue;
+  }
+
+  public getMonkeyEcxRequestQueue(): MonkeyEcxRequestQueue | null {
+    return this.monkeyecxRequestQueue;
+  }
+
+  public setMonkeyEcxRequestDownload(download: MonkeyEcxRequestDownload) {
+    this.monkeyecxRequestDownload = download;
+  }
+
+  public getMonkeyEcxRequestDownload(): MonkeyEcxRequestDownload | null {
+    return this.monkeyecxRequestDownload;
+  }
+
+  public setMonkeyEcxRequestUpload(upload: MonkeyEcxRequestUpload) {
+    this.monkeyecxRequestUpload = upload;
+  }
+
+  public getMonkeyEcxRequestUpload(): MonkeyEcxRequestUpload | null {
+    return this.monkeyecxRequestUpload;
+  }
+}

package/src/lib/core/services/monkeyecx-service.service.ts

@@ -0,0 +1,116 @@
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { Observable, throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { MonkeyEcxHandlingService } from './monkeyecx-handling.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class MonkeyEcxService {
+  constructor(
+    protected http: HttpClient,
+    public monkeyecxHandlingService: MonkeyEcxHandlingService
+  ) {
+    // not to do
+  }
+
+  private handlelize(params: any): any {
+    if (!params) {
+      return params;
+    }
+
+    // eslint-disable-next-line no-restricted-syntax
+    for (const field of [
+      'createdAt',
+      'createUserId',
+      'updatedAt',
+      'lastUserId',
+      '_links',
+      'governmentIdType',
+      'governmentIdMask',
+      'screenType',
+      'screenTab',
+    ]) {
+      delete params[field];
+    }
+    return params;
+  }
+
+  public get<T>(url: string, options?: T): Observable<T> {
+    return this.http.get<T>(url, options);
+  }
+
+  public post<T>(url: string, params: T, options?: T): Observable<T> {
+    return this.http.post<T>(url, params, options);
+  }
+
+  public put<T>(url: string, params: T): Observable<T> {
+    return this.http.put<T>(
+      url,
+      this.handlelize({
+        ...params,
+      })
+    );
+  }
+
+  public delete<T>(url: string, params?: T): Observable<T> {
+    return this.http.delete<T>(url, params);
+  }
+
+  public download<T>(url: string, options?: T, filename?: string) {
+    this.http.get<T>(url, options).subscribe(
+      (resp: any) => {
+        const { headers, body } = resp;
+        const contentType = headers.get('Content-Type');
+        const contentDisposition = headers.get('Content-Disposition');
+        if (contentDisposition) {
+          filename = contentDisposition
+            .split(';')[1]
+            .split('filename')[1]
+            .split('=')[1]
+            .trim()
+            .replace(new RegExp(/"/g), '');
+        }
+        const blob = new Blob([body], {
+          type: `${contentType}`,
+        });
+        return {
+          filename,
+          blob,
+        };
+      },
+      (err: HttpErrorResponse) => {
+        throwError(err);
+      }
+    );
+  }
+
+  public downloadOb<T>(url: string, options?: T, filename?: string): Observable<any> {
+    return this.http.get<any>(url, options).pipe(
+      map((resp: any) => {
+        const { headers, body } = resp;
+        const contentType = headers.get('Content-Type');
+        const contentDisposition = headers.get('Content-Disposition');
+        if (contentDisposition) {
+          filename = contentDisposition
+            .split(';')[1]
+            .split('filename')[1]
+            .split('=')[1]
+            .trim()
+            .replace(new RegExp(/"/g), '');
+        }
+        const blob = new Blob([body], {
+          type: `${contentType}`,
+        });
+        return {
+          filename,
+          blob,
+        };
+      }),
+      catchError((err: any) => {
+        return throwError(err);
+      })
+    );
+  }
+}

package/{lib/core/services/pagination/index.d.ts → src/lib/core/services/pagination/index.ts}

@@ -1 +1 @@
-export * from './monkeyecx-pagination.service';
+export * from './monkeyecx-pagination.service';

package/src/lib/core/services/pagination/monkeyecx-pagination.service.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxPaginationService {
+  private callbacks: {
+    [key: string]: Function;
+  } = {};
+
+  constructor() {
+    // not to do
+  }
+
+  public setCallback(callback: Function, name: string = 'main') {
+    this.callbacks = {
+      ...this.callbacks,
+      [name]: callback
+    };
+  }
+
+  public execute(type: string, name: string = 'main') {
+    const { callbacks } = this;
+    const callback = callbacks?.[name];
+    if (callback) callback(type);
+  }
+}

package/{lib/core/services/request-download/index.d.ts → src/lib/core/services/request-download/index.ts}

@@ -1,2 +1,2 @@
-export * from './monkeyecx-request-download-handling.service';
-export * from './monkeyecx-request-downloaded-handling.service';
+export * from './monkeyecx-request-download-handling.service';
+export * from './monkeyecx-request-downloaded-handling.service';

package/src/lib/core/services/request-download/monkeyecx-request-download-handling.service.ts

@@ -0,0 +1,100 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { MonkeyEcxUtils } from '../../utils/utils';
+import { MonkeyEcxRequestDownload } from '../../interfaces';
+import { MonkeyEcxDownloadEvents } from '../../utils/statics';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxRequestDownloadHandlingService {
+  private download: MonkeyEcxRequestDownload[] = [];
+
+  private download$: BehaviorSubject<MonkeyEcxRequestDownload[] | any>;
+
+  constructor() {
+    this.download$ = new BehaviorSubject([]);
+  }
+
+  private addTo(q: MonkeyEcxRequestDownload) {
+    this.download.push(q);
+    this.download$.next(this.download);
+  }
+
+  private markItemAsFinish(q: MonkeyEcxRequestDownload, status?: number) {
+    const saved = [...this.download];
+    this.download = [
+      ...saved
+        .map((val: any) => {
+          if (val.status === MonkeyEcxDownloadEvents.OnGoing) {
+            const valSaved = {
+              ...val
+            };
+            if (valSaved.item.id === q.item.id) {
+              return {
+                ...valSaved,
+                status: status || MonkeyEcxDownloadEvents.Finished
+              };
+            }
+            return valSaved;
+          }
+          return null;
+        })
+        .filter((_: any) => {
+          return _;
+        })
+    ];
+
+    this.download = this.download.filter((_: any) => {
+      return _.status === MonkeyEcxDownloadEvents.OnGoing;
+    });
+    this.download$.next(this.download);
+  }
+
+  private updateItem(q: MonkeyEcxRequestDownload, loaded?: number, total?: number) {
+    const saved = [...this.download];
+    this.download = [
+      ...saved.map((val: any) => {
+        const valSaved = {
+          ...val
+        };
+        const currentPecentage = Math.floor(((loaded || 0) / (total || 0)) * 100);
+        const totalPercentage = 100;
+        if (valSaved.item.id === q.item.id) {
+          return {
+            ...valSaved,
+            loaded,
+            total,
+            currentPercentage: currentPecentage,
+            totalPercentage
+          };
+        }
+        return valSaved;
+      })
+    ];
+    this.download$.next(this.download);
+  }
+
+  public set(q: MonkeyEcxRequestDownload) {
+    this.addTo(q);
+  }
+
+  public get(): Observable<MonkeyEcxRequestDownload[]> {
+    return this.download$.asObservable();
+  }
+
+  public update(q: MonkeyEcxRequestDownload, loaded?: number, total?: number) {
+    this.updateItem(q, loaded, total);
+  }
+
+  public finishItem(q: MonkeyEcxRequestDownload, status?: number) {
+    this.markItemAsFinish(q, status);
+  }
+
+  public hasDownloadOnGoing(): boolean {
+    const found = this.download.find((_: any) => {
+      return _.status === MonkeyEcxDownloadEvents.OnGoing;
+    });
+    return MonkeyEcxUtils.persistNullEmptyUndefined(found);
+  }
+}

package/src/lib/core/services/request-download/monkeyecx-request-downloaded-handling.service.ts

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { MonkeyEcxUtils } from '../../utils/utils';
+import { Statics } from '../../utils';
+import { MonkeyEcxRequestDownloaded } from '../../interfaces';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxRequestDownloadedHandlingService {
+  private downloaded: MonkeyEcxRequestDownloaded[] = [];
+
+  private downloaded$: BehaviorSubject<MonkeyEcxRequestDownloaded[] | any>;
+
+  constructor() {
+    this.downloaded$ = new BehaviorSubject([]);
+  }
+
+  private addTo(q: MonkeyEcxRequestDownloaded) {
+    this.downloaded.push(q);
+    this.downloaded$.next(this.downloaded);
+  }
+
+  private markItemAsFinish(q: MonkeyEcxRequestDownloaded, status?: number) {
+    const saved = [...this.downloaded];
+    this.downloaded = [
+      ...saved.map((val: any) => {
+        if (val.status === Statics.MonkeyEcxDownloadEvents.OnGoing) {
+          const valSaved = {
+            ...val
+          };
+          if (valSaved.item.id === q.item.id) {
+            return {
+              ...valSaved,
+              status: status || Statics.MonkeyEcxDownloadEvents.Finished,
+              action: q.action
+            };
+          }
+          return valSaved;
+        }
+        return val;
+      })
+    ];
+    this.downloaded$.next(this.downloaded);
+  }
+
+  public set(q: MonkeyEcxRequestDownloaded) {
+    this.addTo(q);
+  }
+
+  public get(): Observable<MonkeyEcxRequestDownloaded[]> {
+    return this.downloaded$.asObservable();
+  }
+
+  public finishItem(q: MonkeyEcxRequestDownloaded, status?: number) {
+    this.markItemAsFinish(q, status);
+  }
+
+  public hasDownloadOnGoing(): boolean {
+    const found = this.downloaded.find((_: any) => {
+      return _.status === Statics.MonkeyEcxDownloadEvents.OnGoing;
+    });
+    return MonkeyEcxUtils.persistNullEmptyUndefined(found);
+  }
+}