monkey-front-core 0.0.237 → 0.0.238

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

@@ -1 +1 @@
-export * from './monkeyecx-request-request-paged-handling';
+export * from './monkeyecx-request-request-paged-handling';

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

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

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

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

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

@@ -0,0 +1,125 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { MonkeyEcxRequestProgressQueue, MonkeyEcxRequestQueue } from '../../interfaces';
+import { Statics } from '../../utils';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxRequestQueueHandlingService {
+  private queue: MonkeyEcxRequestQueue[] = [];
+
+  private queues$: BehaviorSubject<MonkeyEcxRequestQueue[] | any>;
+
+  private newQueue = new BehaviorSubject(false);
+
+  constructor() {
+    this.queues$ = new BehaviorSubject([]);
+  }
+
+  private addToQueue(q: MonkeyEcxRequestQueue) {
+    this.queue.push(q);
+    this.queues$.next(this.queue);
+    this.newQueue.next(true);
+  }
+
+  private markQueueItemAsFinish(q: MonkeyEcxRequestQueue, status?: number, action?: Function) {
+    const saved = [...this.queue];
+    this.queue = [
+      ...saved.map((val: any) => {
+        const valSaved = {
+          ...val
+        };
+        if (val.status === Statics.MonkeyEcxQueueEvents.OnGoing) {
+          if (valSaved.item.id === q.item.id) {
+            return {
+              ...valSaved,
+              status: status || Statics.MonkeyEcxQueueEvents.Finished,
+              action
+            };
+          }
+        }
+        return valSaved;
+      })
+    ];
+    this.queues$.next(this.queue);
+  }
+
+  private updateQueue(q: MonkeyEcxRequestQueue, progress: MonkeyEcxRequestProgressQueue) {
+    const saved = [...this.queue];
+    this.queue = [
+      ...saved.map((val: any) => {
+        const valSaved = {
+          ...val
+        };
+        const { total, loaded } = progress;
+        const currentPecentage = Math.floor(((loaded||0) / (total || 0)) * 100);
+        const totalPercentage = 100;
+        if (valSaved.item.id === q.item.id) {
+          return {
+            ...valSaved,
+            progress: {
+              loaded,
+              total,
+              currentPercentage: currentPecentage,
+              totalPercentage
+            }
+          };
+        }
+        return valSaved;
+      })
+    ];
+
+    this.queues$.next(this.queue);
+  }
+
+  private deleteQueue(q: MonkeyEcxRequestQueue) {
+    const saved = [...this.queue];
+    this.queue = [
+      ...saved.map((val: any) => {
+        const valSaved = {
+          ...val
+        };
+        if (valSaved.item.id === q.item.id) {
+          return null;
+        }
+        return valSaved;
+      })
+    ].filter((_: any) => {
+      return _;
+    });
+
+    this.queues$.next(this.queue);
+  }
+
+  public setQueue(q: MonkeyEcxRequestQueue | null) {
+    if (!q) return;
+    this.addToQueue(q);
+  }
+
+  public getQueue(): Observable<MonkeyEcxRequestQueue[]> {
+    return this.queues$.asObservable();
+  }
+
+  public finishQueueItem(q: MonkeyEcxRequestQueue | null, action?: Function, status?: number) {
+    if (!q) return;
+    this.markQueueItemAsFinish(q, status, action);
+  }
+
+  public removeQueueItem(q: MonkeyEcxRequestQueue) {
+    this.deleteQueue(q);
+  }
+
+  public updateQueueItem(q: MonkeyEcxRequestQueue, progress: MonkeyEcxRequestProgressQueue) {
+    this.updateQueue(q, progress);
+  }
+
+  public hasNewQueue(): Observable<boolean> {
+    return this.newQueue.pipe(
+      map((_: any) => {
+        return _;
+      })
+    );
+  }
+}

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

@@ -0,0 +1,136 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { MonkeyEcxRequestProgressQueue, MonkeyEcxRequestQueue } from '../../interfaces';
+import { Statics } from '../../utils';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxRequestQueueModalHandlingService {
+  private queue: MonkeyEcxRequestQueue[] = [];
+
+  private queues$: BehaviorSubject<MonkeyEcxRequestQueue[] | any>;
+
+  private newQueue$ = new BehaviorSubject(false);
+
+  private allQueueFinished$ = new BehaviorSubject(false);
+
+  constructor() {
+    this.queues$ = new BehaviorSubject([]);
+  }
+
+  private addToQueue(q: MonkeyEcxRequestQueue) {
+    this.queue.push(q);
+    this.queues$.next(this.queue);
+    this.newQueue$.next(true);
+  }
+
+  private markQueueItemAsFinish(q: MonkeyEcxRequestQueue, status?: number, action?: Function) {
+    const saved = [...this.queue];
+    this.queue = [
+      ...saved.map((val: any) => {
+        const valSaved = {
+          ...val
+        };
+        if (val.status === Statics.MonkeyEcxQueueEvents.OnGoing) {
+          if (valSaved.item.id === q.item.id) {
+            return {
+              ...valSaved,
+              status: status || Statics.MonkeyEcxQueueEvents.Finished,
+              action
+            };
+          }
+        }
+        return valSaved;
+      })
+    ];
+    this.queues$.next(this.queue);
+  }
+
+  private updateQueue(q: MonkeyEcxRequestQueue, progress: MonkeyEcxRequestProgressQueue) {
+    const saved = [...this.queue];
+    this.queue = [
+      ...saved.map((val: any) => {
+        const valSaved = {
+          ...val
+        };
+        const { total, loaded } = progress;
+        const currentPecentage = Math.floor(((loaded||0) / (total||0)) * 100);
+        const totalPercentage = 100;
+        if (valSaved.item.id === q.item.id) {
+          return {
+            ...valSaved,
+            progress: {
+              loaded,
+              total,
+              currentPercentage: currentPecentage,
+              totalPercentage
+            }
+          };
+        }
+        return valSaved;
+      })
+    ];
+
+    this.queues$.next(this.queue);
+  }
+
+  private deleteQueue(q: MonkeyEcxRequestQueue) {
+    const saved = [...this.queue];
+    this.queue = [
+      ...saved.map((val: any) => {
+        const valSaved = {
+          ...val
+        };
+        if (valSaved.item.id === q.item.id) {
+          return null;
+        }
+        return valSaved;
+      })
+    ].filter((_: any) => {
+      return _;
+    });
+
+    this.queues$.next(this.queue);
+    if (this.queue.length <= 0) {
+      this.allQueueFinished$.next(true);
+    }
+  }
+
+  public setQueue(q: MonkeyEcxRequestQueue) {
+    this.addToQueue(q);
+  }
+
+  public getQueue(): Observable<MonkeyEcxRequestQueue[]> {
+    return this.queues$.asObservable();
+  }
+
+  public finishQueueItem(q: MonkeyEcxRequestQueue, action?: Function, status?: number) {
+    this.markQueueItemAsFinish(q, status, action);
+  }
+
+  public removeQueueItem(q: MonkeyEcxRequestQueue) {
+    this.deleteQueue(q);
+  }
+
+  public updateQueueItem(q: MonkeyEcxRequestQueue, progress: MonkeyEcxRequestProgressQueue) {
+    this.updateQueue(q, progress);
+  }
+
+  public hasNewQueue(): Observable<boolean> {
+    return this.newQueue$.pipe(
+      map((_: any) => {
+        return _;
+      })
+    );
+  }
+
+  public hasAllQueueFinished(): Observable<boolean> {
+    return this.allQueueFinished$.pipe(
+      map((_: any) => {
+        return _;
+      })
+    );
+  }
+}

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

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

package/src/lib/core/services/routes/monkeyecx-dicovery-params.service.ts

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import { Router, ActivatedRouteSnapshot } from '@angular/router';
+import { MonkeyEcxUtils } from '../../utils/utils';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxDiscoveryParamsService {
+  constructor(private router: Router) {
+    // not to do
+  }
+
+  private getLastChild(route: ActivatedRouteSnapshot): ActivatedRouteSnapshot {
+    if (route.firstChild) {
+      return this.getLastChild(route.firstChild);
+    }
+
+    return route;
+  }
+
+  public setData(field: string, value: any): any {
+    const { root } = this.router.routerState.snapshot;
+    const route: ActivatedRouteSnapshot = this.getLastChild(root);
+    route.data[field] = value;
+  }
+
+  public getData(field: string): any {
+    const { root } = this.router.routerState.snapshot;
+    const route: ActivatedRouteSnapshot = this.getLastChild(root);
+
+    const found: any = MonkeyEcxUtils.persistNullEmptyUndefined(route) ? route.data[field] : null;
+    return found;
+  }
+
+  public getDataFromCurrentNavigation(field: string): any {
+    const navigation = this.router.getCurrentNavigation();
+    let state: any = null;
+    if (MonkeyEcxUtils.persistNullEmptyUndefined(navigation)) {
+      state = navigation?.extras.state;
+    }
+
+    return state ? state[field] : null;
+  }
+
+  public getParam(param: string): string | null {
+    const { root } = this.router.routerState.snapshot;
+    const route: ActivatedRouteSnapshot = this.getLastChild(root);
+    let found: string = MonkeyEcxUtils.persistNullEmptyUndefined(route)
+      ? route?.paramMap?.get(param) || ''
+      : '';
+    if (!MonkeyEcxUtils.persistNullEmptyUndefined(found)) found = this.getData(param);
+    return found;
+  }
+}

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

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

package/src/lib/core/services/schedules/monkeyecx-request-schedule.service.ts

@@ -0,0 +1,224 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { MonkeyEcxCoreService } from '../../decorators/monkeyecx-decorators';
+import { MonkeyEcxUtils } from '../../utils/utils';
+import { MonkeyEcxRequestSchedule } from '../../interfaces';
+import { MonkeyEcxService } from '../monkeyecx-service.service';
+import { MonkeyEcxLoggedHandlingService } from '../logged';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxRequestScheduleService {
+  private schedule: MonkeyEcxRequestSchedule[] | any[] = [];
+
+  private genericSchedule: MonkeyEcxRequestSchedule[] | any[] = [];
+
+  constructor(
+    public monkeyecxService: MonkeyEcxService,
+    private monkeyLoggedHandlingService: MonkeyEcxLoggedHandlingService
+  ) {
+    // not to do
+  }
+
+  private addToSchedule(q: MonkeyEcxRequestSchedule) {
+    this.schedule.push(q);
+    this.monkeyLoggedHandlingService.addSchedule(this.schedule);
+  }
+
+  private addToGenericSchedule(q: MonkeyEcxRequestSchedule) {
+    this.genericSchedule.push(q);
+    this.monkeyLoggedHandlingService.addGenericSchedule(this.genericSchedule);
+  }
+
+  private removeFromSchedule(q: MonkeyEcxRequestSchedule) {
+    clearInterval(q.interval);
+    const saved = [...this.schedule];
+    this.schedule = [
+      ...saved.map((sch: MonkeyEcxRequestSchedule) => {
+        const savedLocal = {
+          ...sch
+        };
+        if (sch.id === q.id) {
+          return null;
+        }
+        return savedLocal;
+      })
+    ].filter((_: any) => {
+      return _;
+    });
+    this.monkeyLoggedHandlingService.addSchedule(this.schedule);
+  }
+
+  private removeFromGenericSchedule(q: MonkeyEcxRequestSchedule) {
+    clearInterval(q.interval);
+    const saved = [...this.genericSchedule];
+    this.genericSchedule = [
+      ...saved.map((sch: MonkeyEcxRequestSchedule) => {
+        const savedLocal = {
+          ...sch
+        };
+        if (sch.id === q.id) {
+          return null;
+        }
+        return savedLocal;
+      })
+    ].filter((_: any) => {
+      return _;
+    });
+    this.monkeyLoggedHandlingService.addGenericSchedule(this.genericSchedule);
+  }
+
+  private removeFromScheduleById(id: string) {
+    const q = this.getScheduleById(id);
+    clearInterval(q?.interval);
+    const saved = [...this.schedule];
+    this.schedule = [
+      ...saved.map((sch: MonkeyEcxRequestSchedule) => {
+        const savedLocal = {
+          ...sch
+        };
+        if (sch.id === q?.id) {
+          return null;
+        }
+        return savedLocal;
+      })
+    ].filter((_: any) => {
+      return _;
+    });
+    this.monkeyLoggedHandlingService.addSchedule(this.schedule);
+  }
+
+  @MonkeyEcxCoreService({
+    httpResponse: {
+      httpCodeIgnore: [400, 403, 404, 500, 503]
+    },
+    requestInProgress: {
+      showProgress: false
+    }
+  })
+  private doCall(sch: MonkeyEcxRequestSchedule) {
+    const { url, method, params, data, action, errorAction } = sch;
+
+    const errAction = errorAction || ((...args) => {});
+
+    this.monkeyecxService[method.toLowerCase()]<any>(`${url}`, params).subscribe(
+      (resp: any) => {
+        action(
+          {
+            ...data,
+            ...resp
+          },
+          sch
+        );
+      },
+      (err: HttpErrorResponse) => {
+        this.removeFromSchedule(sch);
+        errAction(
+          {
+            ...data
+          },
+          sch,
+          err
+        );
+      }
+    );
+  }
+
+  @MonkeyEcxCoreService({
+    httpResponse: {
+      httpCodeIgnore: [400, 401, 403, 404, 500, 503],
+      httpCodeIgnoreRedirect: [503]
+    },
+    requestInProgress: {
+      showProgress: false
+    }
+  })
+  private doGenericCall(sch: MonkeyEcxRequestSchedule) {
+    const { url, method, params, data, action, errorAction } = sch;
+
+    const errAction = errorAction || ((...args) => {});
+
+    this.monkeyecxService[method.toLowerCase()]<any>(`${url}`, params).subscribe(
+      (resp: any) => {
+        action(
+          {
+            ...data,
+            ...resp
+          },
+          sch
+        );
+      },
+      (err: HttpErrorResponse) => {
+        this.removeFromGenericSchedule(sch);
+        errAction(
+          {
+            ...data
+          },
+          sch,
+          err
+        );
+      }
+    );
+  }
+
+  public setSchedule(q: MonkeyEcxRequestSchedule, delay: number = 3000) {
+    const id = q?.id || `${MonkeyEcxUtils.getRandomString(40)}`;
+    const obj = {
+      ...q,
+      id
+    };
+
+    const interval = setInterval(() => {
+      this.doCall({
+        ...obj,
+        interval
+      });
+    }, delay);
+
+    const sch = {
+      ...obj,
+      interval
+    };
+
+    this.addToSchedule(sch);
+    return sch;
+  }
+
+  public setGenericSchedule(q: MonkeyEcxRequestSchedule, delay: number = 3000) {
+    const interval = setInterval(() => {
+      this.doGenericCall({
+        ...q,
+        interval
+      });
+    }, delay);
+
+    const sch = {
+      ...q,
+      id: `${MonkeyEcxUtils.getRandomString(40)}`,
+      interval
+    };
+
+    this.addToGenericSchedule(sch);
+    return sch;
+  }
+
+  public removeSchedule(q: MonkeyEcxRequestSchedule) {
+    this.removeFromSchedule(q);
+  }
+
+  public removeGenericSchedule(q: MonkeyEcxRequestSchedule) {
+    this.removeFromGenericSchedule(q);
+  }
+
+  public removeScheduleById(id: string) {
+    this.removeFromScheduleById(id);
+  }
+
+  public getScheduleById(id: string) {
+    const q = this.schedule.find((sch: MonkeyEcxRequestSchedule) => {
+      return sch.id === id;
+    });
+    return q;
+  }
+}

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

@@ -1,2 +1,2 @@
-export * from './monkeyecx-token-storage.service';
-export * from './monkeyecx-cookie-storage.service';
+export * from './monkeyecx-token-storage.service';
+export * from './monkeyecx-cookie-storage.service';

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

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { CookieService } from 'ngx-cookie-service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxCookieStorageService {
+  constructor(private cookieService: CookieService) {
+    // not to do
+  }
+
+  public setCookie(name: string, value: any, environment: any) {
+    this.removeCookie(name, environment);
+    const { urlDomain } = environment;
+    const handledDomain = urlDomain ? `.${urlDomain}` : '';
+    this.cookieService.set(name, value, undefined, '/', handledDomain, true, 'None');
+  }
+
+  public getCookie(name: string) {
+    return this.cookieService.get(name);
+  }
+
+  public removeCookie(name: string, environment: any) {
+    const { urlDomain } = environment;
+    const handledDomain = urlDomain ? `.${urlDomain}` : '';
+    this.cookieService.delete(name, '/', handledDomain, true, 'None');
+  }
+}