monkey-front-core 0.0.238 → 0.0.239

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

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

@@ -1,24 +0,0 @@
-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/src/lib/core/services/logged/monkeyecx-logged-handling.service.ts

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

@@ -1,58 +0,0 @@
-/* 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

@@ -1,116 +0,0 @@
-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/src/lib/core/services/pagination/monkeyecx-pagination.service.ts

@@ -1,27 +0,0 @@
-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/src/lib/core/services/request-download/monkeyecx-request-download-handling.service.ts

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

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

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

@@ -1,58 +0,0 @@
-import { HttpParams } from '@angular/common/http';
-import { MonkeyEcxRequestPaged } from '../../interfaces/monkeyecx-request-paged';
-import { MonkeyEcxResponseLinks } from '../../interfaces/monkeyecx-response-links';
-
-export class MonkeyEcxRequestPagedHandling {
-  private url?: string;
-
-  private pagedParams: MonkeyEcxRequestPaged;
-
-  private links: MonkeyEcxResponseLinks;
-
-  private samePage = false;
-
-  constructor(
-    url?: string,
-    pagedParams?: MonkeyEcxRequestPaged,
-    links?: any,
-    samePage: boolean = false
-  ) {
-    this.url = url;
-    this.pagedParams = pagedParams || {
-      page: {},
-    };
-    this.links = links;
-    this.samePage = samePage;
-  }
-
-  private handlePagedValuesFromApi(url: string = '') {
-    if (url.search('\\?') < 0) return url;
-    const params = url.substring(url.search('\\?') + 1, url.length);
-    url = url.substring(0, url.search('\\?'));
-    return `${url}?${new HttpParams({
-      fromString: params,
-    })
-      .delete('size')
-      .delete('page')
-      .toString()}`;
-  }
-
-  private getUrlParams(url: string): string {
-    const { pagedParams } = this;
-    const { number, size } = pagedParams?.page || {};
-    const hasInitialQueryParams = url.search('\\?') > 0;
-    return `${!hasInitialQueryParams ? '?' : '&'}page=${number || 0}&size=${size || 20}`;
-  }
-
-  public getRequestWithPagedParams(): string {
-    const { url, links, samePage } = this;
-    if (samePage && links.self) {
-      return links.self.href;
-    }
-    if (links && links.next) {
-      return links.next.href;
-    }
-    const handled = this.handlePagedValuesFromApi(url);
-    return `${handled}${this.getUrlParams(handled)}`;
-  }
-}