monkey-front-core 0.0.235 → 0.0.238

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

@@ -0,0 +1,557 @@
+import {
+  ActivatedRouteSnapshot,
+  NavigationStart,
+  Router,
+  RouterStateSnapshot
+} from '@angular/router';
+import { HttpErrorResponse } from '@angular/common/http';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject, Observable, throwError } from 'rxjs';
+import { filter, take, takeWhile } from 'rxjs/operators';
+import {
+  MonkeyEcxErrorResponse,
+  MonkeyEcxHandledErrorResponse,
+  MonkeyEcxRequestPaged,
+  MonkeyEcxRequestSchedule,
+  MonkeyEcxResponsePaged,
+  MonkeyEcxResponseLinks,
+  MonkeyEcxTokenCredentials,
+  MonkeyEcxTranslateOptions,
+  MonkeyEcxCompanyPendenciesValidated,
+  MonkeyEcxCountrySecurity,
+  MonkeyEcxSavedState,
+  MonkeyEcxConfig
+} from '../../interfaces';
+import { MonkeyEcxTokenStorageService } from '../storage/monkeyecx-token-storage.service';
+import { MonkeyEcxRequestScheduleService } from '../schedules/monkeyecx-request-schedule.service';
+import { MonkeyEcxRequestQueueHandlingService } from '../request-queue/monkeyecx-request-queue-handling.service';
+import { MonkeyEcxRequestPagedHandling } from '../request-paged/monkeyecx-request-request-paged-handling';
+import { MonkeyEcxFeatureToggleService } from '../config/monkeyecx-feature-toggle.service';
+import { MonkeyEcxUtils } from '../../utils/utils';
+import { MonkeyEcxCoreService } from '../../decorators/monkeyecx-decorators';
+import { MonkeyEcxService } from '../monkeyecx-service.service';
+import { MonkeyEcxPaginationService } from '../pagination';
+import { MonkeyEcxModel } from '../../model';
+
+class LinksModel extends MonkeyEcxModel {
+  constructor(data?: any) {
+    super();
+    this._links = data?._links;
+  }
+}
+
+export class MonkeyEcxCommonsService {
+  private flagValidator = true;
+
+  __data$: Observable<any> | null = null;
+
+  __pagination$: Observable<any> | null = null;
+
+  __control$: Observable<any> | null = null;
+
+  __data: any | any[];
+
+  __savedState: MonkeyEcxSavedState | null = null;
+
+  __params: any | any[];
+
+  __error: MonkeyEcxErrorResponse | null = null;
+
+  __handledError: MonkeyEcxHandledErrorResponse | null = null;
+
+  __page: MonkeyEcxResponsePaged | null = null;
+
+  __links: MonkeyEcxResponseLinks | null = null;
+
+  __search: any;
+
+  __requestPaged: MonkeyEcxRequestPaged | null = null;
+
+  __onSearchChanged$: BehaviorSubject<any> = new BehaviorSubject(null);
+
+  __onDataChanged$: BehaviorSubject<any> = new BehaviorSubject(null);
+
+  __onLoadingInProgress$: BehaviorSubject<any> = new BehaviorSubject(false);
+
+  __onUploadInProgress$: BehaviorSubject<any> = new BehaviorSubject(false);
+
+  __onDataDeleted$: BehaviorSubject<any> = new BehaviorSubject(null);
+
+  __onErrorChanged$: BehaviorSubject<any> = new BehaviorSubject(null);
+
+  __onGovernmentIdDataChanged$: BehaviorSubject<any> = new BehaviorSubject(null);
+
+  __onZipCodeDataChanged$: BehaviorSubject<any> = new BehaviorSubject(null);
+
+  __oni18nDataChanged$: BehaviorSubject<any> = new BehaviorSubject(null);
+
+  __onDoSearch$: BehaviorSubject<MonkeyEcxRequestPaged> = new BehaviorSubject({});
+
+  __tokenCredentials: MonkeyEcxTokenCredentials | null = null;
+
+  __schedule: MonkeyEcxRequestSchedule | null = null;
+
+  __i18n: any;
+
+  __callbackPagination: Function = () => {
+    // eslint-disable-next-line no-console
+    return console.error('Method callbackPagination needs to be declared');
+  };
+
+  __paginationOptions: {
+    service: MonkeyEcxPaginationService;
+    callback: Function;
+    name?: string;
+  } | undefined;
+
+  __isAbleToDoPagination = {};
+
+  constructor(
+    public monkeyecxService?: MonkeyEcxService,
+    public tokenStorage?: MonkeyEcxTokenStorageService,
+    public otherArgs?: {
+      router?: Router;
+      schedule?: {
+        service: MonkeyEcxRequestScheduleService;
+        options?: {
+          clearOnChangeRoute?: boolean;
+        };
+      };
+      queue?: {
+        service: MonkeyEcxRequestQueueHandlingService;
+      };
+    }
+  ) {
+    this.handleInit();
+  }
+
+  private handleInit() {
+    if (this.tokenStorage) {
+      this.__tokenCredentials = this.tokenStorage.getToken();
+    }
+
+    if (this.otherArgs?.router) {
+      const { clearOnChangeRoute } = this.otherArgs?.schedule?.options || {
+        clearOnChangeRoute: false
+      };
+      this.otherArgs.router.events
+        .pipe(
+          filter((event: any) => {
+            return event instanceof NavigationStart;
+          }),
+          take(1)
+        )
+        .subscribe(() => {
+          if (this.__schedule && clearOnChangeRoute) {
+            this.otherArgs?.schedule?.service?.removeSchedule(this.__schedule);
+            this.__schedule = null;
+          }
+        });
+    }
+  }
+
+  private navigateToPendencyPage(arg: MonkeyEcxCompanyPendenciesValidated, router?: Router) {
+    const { companyType } = this.__tokenCredentials || {
+      companyType: ''
+    };
+    let route = '/app';
+
+    if (companyType) {
+      route = `${route}/${companyType}/pages`;
+    } else {
+      route = `${route}/user/profile/pages`;
+    }
+
+    if (!router) {
+      // eslint-disable-next-line no-console
+      console.error('Router must be declared');
+    } else {
+      router.navigate([`${route}/company-pendency`.toLowerCase()], {
+        state: {
+          pendencyData: arg
+        }
+      });
+    }
+  }
+
+  private getRole(): string {
+    const { __tokenCredentials } = this;
+
+    if (!__tokenCredentials) return '';
+
+    if (__tokenCredentials?.programAdmin === 'true') {
+      return 'PROGRAM_ADMIN';
+    }
+
+    return __tokenCredentials?.role || '';
+  }
+
+  private allowedSecurityAccessByPendency(args: any): MonkeyEcxCompanyPendenciesValidated {
+    if (!args) {
+      return {
+        hasPendencies: false
+      };
+    }
+    const { service, type } = args;
+    return service.hasPendencies(type);
+  }
+
+  private allowedSecurityAccessByFeature(args: any): boolean {
+    if (!args) {
+      return true;
+    }
+    const { config, feature } = args;
+    try {
+      if (!MonkeyEcxUtils.persistNullEmptyUndefined(feature) ||
+        !MonkeyEcxUtils.persistNullEmptyUndefined(config?.program?.settings)) {
+        return true;
+      }
+      return !config?.program?.settings?.[feature];
+    } catch (e) {
+      // not to do
+    }
+    return true;
+  }
+
+  private allowedSecurityAccessByCountry(arg?: MonkeyEcxCountrySecurity): boolean {
+    if (!arg) return true;
+    return arg.country === arg.envCountry;
+  }
+
+  private allowedSecurityAccess(args: any): boolean {
+    if (!args) return true;
+    const roles = args?.roles;
+    const byExclusion = args?.byExclusion;
+    const found = roles?.indexOf(this.getRole());
+    let ret = false;
+    if (byExclusion) {
+      ret = true;
+      if (found > -1) {
+        ret = false;
+      }
+    } else {
+      ret = false;
+      if (found > -1) {
+        ret = true;
+      }
+    }
+    if (!roles || roles.length === 0 || this.getRole() === 'PROGRAM_ADMIN') {
+      ret = true;
+    }
+    return ret;
+  }
+
+  private navigateToErrorPage(statusCode: number, router?: Router) {
+    const routes: any = {
+      403: 'forbidden',
+      404: 'not-found',
+      500: 'service-problems',
+      503: 'service-problems'
+    };
+
+    if (!router) {
+      console.error('Router must be declared');
+    } else {
+      router?.navigate([`/app/pages/${routes[statusCode]}`.toLowerCase()]);
+    }
+  }
+
+  private handlePaginationOptions() {
+    const { __paginationOptions } = this;
+    if (__paginationOptions) {
+      const { service, callback, name } = __paginationOptions;
+      service?.setCallback((type: string) => {
+        this.doPaginationv2(type, callback);
+      }, name || 'main');
+    }
+  }
+
+  setPage(requestPaged: MonkeyEcxRequestPaged) {
+    this.__requestPaged = {
+      ...this.__requestPaged,
+      ...requestPaged
+    };
+    return this;
+  }
+
+  nextPage(): boolean {
+    if (this.__links) {
+      return !!this.__links?.next;
+    }
+    if (!this.__requestPaged) return false;
+    const { page } = this.__requestPaged as any;
+    const { number, totalPages } = page;
+    if (number < totalPages) {
+      this.__requestPaged = {
+        ...this.__requestPaged,
+        page: {
+          ...page,
+          number: number + 1
+        }
+      };
+      return true;
+    }
+    return false;
+  }
+
+  getEmbeddedData(data: any, field: string): any[] | any {
+    const { _embedded } = data;
+    return _embedded ? _embedded[field] : null;
+  }
+
+  getNormalizedUrl(url: string, samePage = false): string {
+    const { __requestPaged, __links } = this;
+    return new MonkeyEcxRequestPagedHandling(
+      url,
+      __requestPaged || {},
+      __links,
+      samePage
+    ).getRequestWithPagedParams();
+  }
+
+  clear(clearData: boolean) {
+    if (clearData) {
+      this.__data = null;
+      this.__requestPaged = null;
+      this.__params = null;
+      this.__page = null;
+      this.__links = null;
+
+      if (this.__schedule) {
+        const { queue } = this.__schedule;
+        if (queue) {
+          this.otherArgs?.queue?.service?.removeQueueItem(queue);
+        }
+        this.otherArgs?.schedule?.service?.removeSchedule(this.__schedule);
+        this.__schedule = null;
+      }
+    }
+    this.__error = null;
+    this.__handledError = null;
+    this.flagValidator = false;
+  }
+
+  resolve(
+    route: ActivatedRouteSnapshot | null,
+    state: RouterStateSnapshot | null,
+    otherArgs?: {
+      callbackMain: Function;
+      router?: Router;
+      security?: {
+        roles: string[];
+        byExclusion?: boolean;
+      };
+      callbackPagination?: Function;
+      translateOptions?: MonkeyEcxTranslateOptions;
+      feature?: {
+        service: MonkeyEcxFeatureToggleService;
+        flag: string;
+      };
+      featureByProgram?: {
+        config: MonkeyEcxConfig;
+        feature: string;
+      };
+      countrySecurity?: MonkeyEcxCountrySecurity;
+      pendency?: {
+        service: {
+          hasPendencies: Function;
+        };
+        type: string;
+      };
+      paginationOptions?: {
+        service: MonkeyEcxPaginationService,
+        callback: Function,
+        name?: string
+      }
+    }
+  ) {
+    if (JSON.stringify(route?.queryParams) === '{}') {
+      this.__data = null;
+      this.__page = null;
+    }
+
+    this.__requestPaged = null;
+    this.flagValidator = true;
+
+    if (this.tokenStorage) {
+      this.__tokenCredentials = this.tokenStorage.getToken();
+    }
+
+    const pend = this.allowedSecurityAccessByPendency(otherArgs?.pendency);
+    const allowedByProgram = this.allowedSecurityAccessByFeature(otherArgs?.featureByProgram);
+
+    if (
+      this.allowedSecurityAccess(otherArgs?.security) &&
+      this.allowedSecurityAccessByCountry(otherArgs?.countrySecurity) &&
+      !pend.hasPendencies &&
+      allowedByProgram
+    ) {
+      if (this.__schedule) {
+        this.otherArgs?.schedule?.service?.removeSchedule(this.__schedule);
+        this.__schedule = null;
+      }
+
+      const { __requestPaged } = this;
+      if (!__requestPaged) {
+        this.setPage({
+          page: {
+            number: 0,
+            size: 10
+          }
+        });
+      }
+
+      if (otherArgs?.translateOptions) {
+        const { service, keys } = otherArgs?.translateOptions;
+        this.geti18n(service, keys || '');
+      }
+
+      if (otherArgs?.callbackPagination) {
+        this.__callbackPagination = otherArgs.callbackPagination;
+      }
+
+      if (otherArgs?.paginationOptions) {
+        this.__paginationOptions = otherArgs?.paginationOptions;
+        this.handlePaginationOptions();
+      }
+
+      if (otherArgs?.feature) {
+        const { flag, service } = otherArgs.feature;
+
+        service.onFlags
+          .pipe(
+            takeWhile(() => {
+              return this.flagValidator;
+            })
+          )
+          .subscribe((val: boolean) => {
+            if (val) {
+              const hasFlag = service.getFlag(flag);
+
+              if (MonkeyEcxUtils.persistNullEmptyUndefined(hasFlag)) {
+                if (!hasFlag) {
+                  this.navigateToErrorPage(404, otherArgs?.router);
+                  return;
+                }
+              }
+              otherArgs?.callbackMain();
+            }
+          });
+      } else {
+        otherArgs?.callbackMain();
+      }
+    } else if (!allowedByProgram) {
+      this.navigateToErrorPage(404, otherArgs?.router);
+    } else if (pend.hasPendencies) {
+      this.navigateToPendencyPage(pend, otherArgs?.router);
+    } else {
+      this.navigateToErrorPage(403, otherArgs?.router);
+    }
+  }
+
+  getHTTPHeaderApplicationPDF(): Object {
+    return {
+      observe: 'response',
+      responseType: 'blob'
+    };
+  }
+
+  @MonkeyEcxCoreService({
+    requestInProgress: {
+      showProgress: true
+    }
+  })
+  genericMethod(link: any, data?: any, callback?: Function) {
+    const { href, type = 'get' } = link;
+
+    this.monkeyecxService?.[type.toLowerCase()](`${href}`, data)?.subscribe(
+      (resp: any) => {
+        if (callback) callback(resp);
+      },
+      (err: HttpErrorResponse) => {
+        if (callback) callback();
+        throwError(err);
+      }
+    );
+  }
+
+  @MonkeyEcxCoreService({
+    requestInProgress: {
+      showProgress: true
+    }
+  })
+  async getGenericData(data: any, action: string) {
+    const { monkeyecxService } = this;
+    if (!monkeyecxService) return null;
+    const { href, type } = new LinksModel(data)?.getAction(action) || {
+      href: '', type: 'get'
+    };
+
+    return monkeyecxService[type.toLowerCase()]<any>(href)
+      .pipe(take(1)).toPromise();
+  }
+
+  geti18n(translateService: TranslateService, keys: string | string[]) {
+    translateService.onDefaultLangChange.subscribe(() => {
+      this.__i18n = translateService.instant(keys);
+      this.__oni18nDataChanged$.next(null);
+    });
+    translateService.getStreamOnTranslationChange(keys).subscribe(() => {
+      this.__i18n = translateService.instant(keys);
+      this.__oni18nDataChanged$.next(null);
+    });
+  }
+
+  doPagination() {
+    if (!this.__onLoadingInProgress$.value) {
+      const hasMorePages = this.setPage({
+        page: {
+          ...this.__page
+        }
+      }).nextPage();
+
+      if (hasMorePages && this.__callbackPagination) {
+        this.__callbackPagination();
+      }
+    }
+  }
+
+  doPaginationv2(type: string, callback: Function) {
+    if (!this.__onLoadingInProgress$.value) {
+      if (callback) {
+        callback(type);
+      }
+    }
+  }
+
+  setLinks(links: any) {
+    this.__isAbleToDoPagination = {
+      first: !!links?.first,
+      next: !!links?.next
+    };
+    this.__links = links;
+  }
+
+  setSearchByUrl(router: Router, url: string, search: any, extras?: any) {
+    this.__data = null;
+    this.__page = null;
+    this.__onDataChanged$.next(null);
+    this.__onLoadingInProgress$.next(false);
+
+    router.navigate([url], {
+      queryParams: {
+        ...search,
+        r: MonkeyEcxUtils.getRandomString(30)
+      },
+      queryParamsHandling: 'merge',
+      ...extras
+    });
+  }
+
+  saveState(state: MonkeyEcxSavedState) {
+    this.__savedState = {
+      page: this.__page,
+      ...state
+    };
+  }
+}

package/src/lib/core/services/config/index.ts

@@ -0,0 +1,9 @@
+export * from './monkeyecx-alerts-config.service';
+export * from './monkeyecx-config.module';
+export * from './monkeyecx-config.service';
+export * from './monkeyecx-feature-toggle.service';
+export * from './monkeyecx-i18n-config.service';
+export * from './monkeyecx-logs-config.service';
+export * from './monkeyecx-maintenance-config.service';
+export * from './monkeyecx-security-console-config.service';
+export * from './monkeyecx-service-worker-config.service';

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

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { MonkeyStyleGuideModalFixedService } from 'monkey-style-guide';
+import * as moment_ from 'moment';
+import { MonkeyEcxConfig } from '../../interfaces';
+import { AlertsComponent } from '../../../components';
+
+const moment: any = moment_;
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MonkeyEcxAlertsConfigService {
+  constructor(private modalService: MonkeyStyleGuideModalFixedService) {
+    // not to do
+  }
+
+  private handleValidation(config: MonkeyEcxConfig) {
+    if (config.alert) {
+      const { img, title, message, endDate } = config.alert;
+      if (moment.default().isSameOrBefore(moment.default(endDate))) {
+        this.modalService.open(AlertsComponent, {
+          color: 'theme',
+          size: 'md',
+          data: {
+            img,
+            title,
+            message
+          }
+        });
+      }
+    }
+  }
+
+  public apply(config: MonkeyEcxConfig) {
+    this.handleValidation(config);
+  }
+}

package/src/lib/core/services/config/monkeyecx-config.module.ts

@@ -0,0 +1,23 @@
+/* eslint-disable indent */
+import { ModuleWithProviders, NgModule, Optional, SkipSelf } from '@angular/core';
+import { MonkeyEcxConfigService } from './monkeyecx-config.service';
+
+@NgModule()
+export class MonkeyEcxConfigModule {
+  constructor(
+    @Optional()
+    @SkipSelf()
+    parentModule: MonkeyEcxConfigModule
+  ) {
+    if (parentModule) {
+      throw new Error('MonkeyEcxConfigModule is already loaded. Import it in the AppModule only!');
+    }
+  }
+
+  static forRoot(): ModuleWithProviders<MonkeyEcxConfigModule> {
+    return {
+      ngModule: MonkeyEcxConfigModule,
+      providers: [MonkeyEcxConfigService]
+    };
+  }
+}