monkey-front-core 0.0.235 → 0.0.238

package/src/lib/core/decorators/monkeyecx-charts-decorators.ts

@@ -0,0 +1,46 @@
+/* eslint-disable space-before-function-paren */
+/* eslint-disable func-names */
+export function MonkeyEcxCoreCharts(render = true) {
+  return (
+    target: Object,
+    propertyName: string,
+    propertyDescriptor: PropertyDescriptor
+  ): PropertyDescriptor => {
+    const method = propertyDescriptor.value;
+
+    propertyDescriptor.value = function(...args: any[]) {
+      const context = this;
+      if (render) {
+        const scriptsLoaded = Array.from(document.scripts);
+        scriptsLoaded.forEach((script: any) => {
+          const { src } = script;
+          if (src.search('www.gstatic.com/charts') > 0) {
+            document.getElementsByTagName('head')[0].removeChild(script);
+          }
+        });
+
+        const node = document.createElement('script');
+        node.src = 'https://www.gstatic.com/charts/loader.js';
+        node.type = 'text/javascript';
+        node.async = true;
+        node.id = 'monkeyecx-charts-settings';
+        node.onload = () => {
+          method.apply(context, args);
+        };
+        document.getElementsByTagName('head')[0].appendChild(node);
+      } else {
+        const scriptsLoaded = Array.from(document.scripts);
+        scriptsLoaded.forEach((script: any) => {
+          const { src } = script;
+          if (src.search('www.gstatic.com/charts') > 0) {
+            document.getElementsByTagName('head')[0].removeChild(script);
+          }
+        });
+
+        method.apply(context, args);
+      }
+    };
+
+    return propertyDescriptor;
+  };
+}

package/src/lib/core/decorators/monkeyecx-decorators.ts

@@ -0,0 +1,159 @@
+/* eslint-disable no-console */
+/* eslint-disable space-before-function-paren */
+/* eslint-disable func-names */
+/* eslint-disable max-len */
+import { MonkeyEcxServiceCredentials } from '../interfaces';
+import { DecoratorsUtils } from '../utils';
+import { MonkeyEcxUtils } from '../utils/utils';
+
+export function MonkeyEcxCoreServiceConstructor() {
+  return (target: any) => {
+    Object.entries(target.prototype).forEach(([key, value]) => {
+      const method = target.prototype[key];
+      if (key !== 'constructor') {
+        target.prototype[key] = function (...args: any[]) {
+          const context = this;
+          if (DecoratorsUtils.hasMonkeyEcxServiceAndHandlingProperties(context)) {
+            context.monkeyecxService.monkeyecxHandlingService.clearAll();
+          }
+          const result = method.apply(context, args);
+          return result;
+        };
+      }
+    });
+    return target;
+  };
+}
+
+export function MonkeyEcxCoreLog(tp: string) {
+  return function (
+    target: Object,
+    propertyName: string,
+    propertyDescriptor: PropertyDescriptor
+  ): PropertyDescriptor {
+    const method = propertyDescriptor.value;
+    propertyDescriptor.value = function (...args: any[]) {
+      const params = args
+        .map((a: any) => {
+          return JSON.stringify(a);
+        })
+        .join();
+      const result = method.apply(this, args);
+      const r = JSON.stringify(result);
+      console.log(`Call: ${propertyName}(${params}) => ${r}`);
+      return result;
+    };
+
+    return propertyDescriptor;
+  };
+}
+
+export function MonkeyEcxCoreClearDecorators() {
+  return function (
+    target: Object,
+    propertyName: string,
+    propertyDescriptor: PropertyDescriptor
+  ): PropertyDescriptor {
+    const method = propertyDescriptor.value;
+
+    propertyDescriptor.value = function (...args: any[]) {
+      const context: any = this;
+      if (DecoratorsUtils.hasMonkeyEcxServiceAndHandlingProperties(context)) {
+        context?.monkeyecxService?.monkeyecxHandlingService?.clearAll();
+      }
+      const result = method.apply(context, args);
+      return result;
+    };
+
+    return propertyDescriptor;
+  };
+}
+
+export function MonkeyEcxCoreService(params: MonkeyEcxServiceCredentials) {
+  return function (
+    target: Object,
+    propertyName: string,
+    propertyDescriptor: PropertyDescriptor
+  ): PropertyDescriptor {
+    const method = propertyDescriptor.value;
+
+    propertyDescriptor.value = function (...args: any[]) {
+      const context: any = this;
+      if (DecoratorsUtils.hasMonkeyEcxServiceAndHandlingProperties(context)) {
+        context?.monkeyecxService?.monkeyecxHandlingService?.clearAll();
+        context?.monkeyecxService?.monkeyecxHandlingService?.setMonkeyEcxServiceCredentials(params);
+      }
+      const result = method.apply(context, args);
+      return result;
+    };
+
+    return propertyDescriptor;
+  };
+}
+
+export function MonkeyEcxCoreServicePaged(params: MonkeyEcxServiceCredentials) {
+  return function (
+    target: Object,
+    propertyName: string,
+    propertyDescriptor: PropertyDescriptor
+  ): PropertyDescriptor {
+    const method = propertyDescriptor.value;
+
+    propertyDescriptor.value = function (...args: any[]) {
+      const context: any = this;
+      if (DecoratorsUtils.hasMonkeyEcxServiceAndHandlingProperties(context)) {
+        const credentials =
+          context?.monkeyecxService?.monkeyecxHandlingService?.getMonkeyEcxServiceCredentials();
+        let requestPaged = null;
+        if (credentials) {
+          requestPaged = credentials.requestPaged;
+        }
+        context?.monkeyecxService?.monkeyecxHandlingService?.clearAll();
+        context?.monkeyecxService?.monkeyecxHandlingService?.setMonkeyEcxServiceCredentials({
+          ...params,
+          ...(requestPaged || {}),
+        });
+      }
+      const result = method.apply(context, args);
+      return result;
+    };
+
+    return propertyDescriptor;
+  };
+}
+
+export function MonkeyEcxCoreServiceQueue(
+  name: string,
+  description?: string,
+  params?: MonkeyEcxServiceCredentials
+) {
+  return function (
+    target: Object,
+    propertyName: string,
+    propertyDescriptor: PropertyDescriptor
+  ): PropertyDescriptor {
+    const method = propertyDescriptor.value;
+
+    propertyDescriptor.value = function (...args: any[]) {
+      const context: any = this;
+      if (DecoratorsUtils.hasMonkeyEcxServiceAndHandlingProperties(context)) {
+        if (MonkeyEcxUtils.persistNullEmptyUndefined(params)) {
+          context?.monkeyecxService?.monkeyecxHandlingService?.clearAll();
+          context?.monkeyecxService?.monkeyecxHandlingService?.setMonkeyEcxServiceCredentials(
+            params
+          );
+        }
+        context?.monkeyecxService.monkeyecxHandlingService.setMonkeyEcxRequestQueue(
+          DecoratorsUtils.buildQueuePropertys({
+            name,
+            description,
+          })
+        );
+      }
+      const result = method.apply(context, args);
+      return result;
+    };
+
+    return propertyDescriptor;
+  };
+}

package/src/lib/core/decorators/monkeyecx-download-decorators.ts

@@ -0,0 +1,39 @@
+/* eslint-disable space-before-function-paren */
+/* eslint-disable func-names */
+/* eslint-disable max-len */
+import { MonkeyUtils } from 'monkey-style-guide';
+import { MonkeyEcxServiceCredentials } from '../interfaces';
+import { DecoratorsUtils } from '../utils';
+
+export function MonkeyEcxServiceDownload(
+  name: string,
+  description?: string,
+  params?: MonkeyEcxServiceCredentials
+) {
+  return function (
+    target: Object,
+    propertyName: string,
+    propertyDescriptor: PropertyDescriptor
+  ): PropertyDescriptor {
+    const method = propertyDescriptor.value;
+
+    propertyDescriptor.value = function (...args: any[]) {
+      const context: any = this;
+      if (DecoratorsUtils.hasMonkeyEcxServiceAndHandlingProperties(context)) {
+        if (MonkeyUtils.persistNullEmptyUndefined(params)) {
+          context?.monkeyecxService?.monkeyecxHandlingService?.clearAll();
+          context?.monkeyecxService?.monkeyecxHandlingService?.setMonkeyEcxServiceCredentials(
+            params
+          );
+        }
+        context?.monkeyecxService?.monkeyecxHandlingService?.setMonkeyEcxRequestDownload({
+          ...DecoratorsUtils.buildDownloadPropertys(name, description),
+        });
+      }
+      const result = method.apply(context, args);
+      return result;
+    };
+
+    return propertyDescriptor;
+  };
+}

package/src/lib/core/decorators/monkeyecx-upload-decorators.ts

@@ -0,0 +1,39 @@
+/* eslint-disable space-before-function-paren */
+/* eslint-disable func-names */
+/* eslint-disable max-len */
+import { MonkeyUtils } from 'monkey-style-guide';
+import { MonkeyEcxServiceCredentials } from '../interfaces';
+import { DecoratorsUtils } from '../utils';
+
+export function MonkeyEcxServiceUpload(
+  name: string,
+  description?: string,
+  params?: MonkeyEcxServiceCredentials
+) {
+  return function (
+    target: Object,
+    propertyName: string,
+    propertyDescriptor: PropertyDescriptor
+  ): PropertyDescriptor {
+    const method = propertyDescriptor.value;
+
+    propertyDescriptor.value = function (...args: any[]) {
+      const context: any = this;
+      if (DecoratorsUtils.hasMonkeyEcxServiceAndHandlingProperties(context)) {
+        if (MonkeyUtils.persistNullEmptyUndefined(params)) {
+          context?.monkeyecxService?.monkeyecxHandlingService?.clearAll();
+          context?.monkeyecxService?.monkeyecxHandlingService?.setMonkeyEcxServiceCredentials(
+            params
+          );
+        }
+        context?.monkeyecxService?.monkeyecxHandlingService?.setMonkeyEcxRequestUpload({
+          ...DecoratorsUtils.buildUploadPropertys(name, description),
+        });
+      }
+      const result = method.apply(context, args);
+      return result;
+    };
+
+    return propertyDescriptor;
+  };
+}

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

@@ -1,12 +1,12 @@
-export * from './monkeyecx-drag-drop';
-export * from './monkeyecx-format-currency';
-export * from './monkeyecx-format-upper';
-export * from './monkeyecx-only-alpha-numeric-directive';
-export * from './monkeyecx-only-number-directive';
-export * from './monkeyecx-popover-options.directive';
-export * from './monkeyecx-popover.directive';
-export * from './monkeyecx-security-directive';
-export * from './monkeyecx-tooltip-directive';
-export * from './monkeyecx-directives-module';
-export * from './monkeyecx-feature-directive';
-export * from './monkeyecx-feature-by-program-directive';
+export * from './monkeyecx-drag-drop';
+export * from './monkeyecx-format-currency';
+export * from './monkeyecx-format-upper';
+export * from './monkeyecx-only-alpha-numeric-directive';
+export * from './monkeyecx-only-number-directive';
+export * from './monkeyecx-popover-options.directive';
+export * from './monkeyecx-popover.directive';
+export * from './monkeyecx-security-directive';
+export * from './monkeyecx-tooltip-directive';
+export * from './monkeyecx-directives-module';
+export * from './monkeyecx-feature-directive';
+export * from './monkeyecx-feature-by-program-directive';

package/src/lib/core/directives/monkeyecx-directives-module.ts

@@ -0,0 +1,45 @@
+import { OverlayModule } from '@angular/cdk/overlay';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MonkeyEcxDragDropDirective } from './monkeyecx-drag-drop';
+import { MonkeyEcxFeatureByProgramDirective } from './monkeyecx-feature-by-program-directive';
+import { MonkeyEcxFeatureDirective } from './monkeyecx-feature-directive';
+import { MonkeyEcxFormatCurrency } from './monkeyecx-format-currency';
+import { MonkeyEcxFormatUpper } from './monkeyecx-format-upper';
+import { MonkeyEcxOnlyAlphaNumericDirective } from './monkeyecx-only-alpha-numeric-directive';
+import { MonkeyEcxOnlyNumbersDirective } from './monkeyecx-only-number-directive';
+import { MonkeyEcxPopoverOptionsDirective } from './monkeyecx-popover-options.directive';
+import { MonkeyEcxPopoverDirective } from './monkeyecx-popover.directive';
+import { MonkeyEcxSecurityDirective } from './monkeyecx-security-directive';
+import { MonkeyEcxTooltipDirective } from './monkeyecx-tooltip-directive';
+
+@NgModule({
+  declarations: [
+    MonkeyEcxDragDropDirective,
+    MonkeyEcxFormatCurrency,
+    MonkeyEcxFeatureDirective,
+    MonkeyEcxFeatureByProgramDirective,
+    MonkeyEcxFormatUpper,
+    MonkeyEcxOnlyAlphaNumericDirective,
+    MonkeyEcxOnlyNumbersDirective,
+    MonkeyEcxSecurityDirective,
+    MonkeyEcxTooltipDirective,
+    MonkeyEcxPopoverDirective,
+    MonkeyEcxPopoverOptionsDirective
+  ],
+  imports: [CommonModule, OverlayModule],
+  exports: [
+    MonkeyEcxDragDropDirective,
+    MonkeyEcxFormatCurrency,
+    MonkeyEcxFeatureDirective,
+    MonkeyEcxFeatureByProgramDirective,
+    MonkeyEcxFormatUpper,
+    MonkeyEcxOnlyAlphaNumericDirective,
+    MonkeyEcxOnlyNumbersDirective,
+    MonkeyEcxSecurityDirective,
+    MonkeyEcxTooltipDirective,
+    MonkeyEcxPopoverDirective,
+    MonkeyEcxPopoverOptionsDirective
+  ]
+})
+export class MonkeyEcxDirectivesModule {}

package/src/lib/core/directives/monkeyecx-drag-drop.ts

@@ -0,0 +1,40 @@
+import { Directive, HostListener, Output, HostBinding, EventEmitter } from '@angular/core';
+
+@Directive({
+  selector: '[monkeyecxDragDrop]',
+})
+export class MonkeyEcxDragDropDirective {
+  @Output() onFileDropped: EventEmitter<any> = new EventEmitter<any>();
+
+  @HostBinding('style.background-color') private background = '#f5fcff';
+
+  @HostBinding('style.opacity') private opacity = '1';
+
+  @HostListener('dragover', ['$event'])
+  onDragOver(evt: any) {
+    evt?.preventDefault();
+    evt?.stopPropagation();
+    this.background = '#9ecbec';
+    this.opacity = '0.8';
+  }
+
+  @HostListener('dragleave', ['$event'])
+  public onDragLeave(evt: any) {
+    evt?.preventDefault();
+    evt?.stopPropagation();
+    this.background = '#f5fcff';
+    this.opacity = '1';
+  }
+
+  @HostListener('drop', ['$event'])
+  public ondrop(evt: any) {
+    evt?.preventDefault();
+    evt?.stopPropagation();
+    this.background = '#f5fcff';
+    this.opacity = '1';
+    const { files } = evt?.dataTransfer;
+    if (files.length > 0) {
+      this.onFileDropped.emit(files);
+    }
+  }
+}

package/src/lib/core/directives/monkeyecx-feature-by-program-directive.ts

@@ -0,0 +1,53 @@
+import { ChangeDetectorRef, Directive, ElementRef, Input, OnInit } from '@angular/core';
+import { MonkeyEcxConfig } from '../interfaces';
+import { MonkeyEcxConfigService } from '../services';
+import { MonkeyEcxUtils } from '../utils/utils';
+
+@Directive({
+  selector: '[monkeyecxFeatureByProgram]'
+})
+export class MonkeyEcxFeatureByProgramDirective implements OnInit {
+  @Input('feature') feature: string = '';
+
+  private config?: MonkeyEcxConfig;
+
+  constructor(
+    private cdr: ChangeDetectorRef,
+    private elementRef: ElementRef,
+    private monkeyConfigService: MonkeyEcxConfigService
+  ) {
+    this.monkeyConfigService.config().subscribe((_: MonkeyEcxConfig) => {
+      this.config = _;
+    });
+  }
+
+  private handleDisplay(): void {
+    const { feature, config } = this;
+    let display = 'none';
+
+    if (!MonkeyEcxUtils.persistNullEmptyUndefined(feature) ||
+    !MonkeyEcxUtils.persistNullEmptyUndefined(config?.program?.settings)) {
+      return;
+    }
+
+    const disabled = config?.program?.settings?.[feature];
+
+    if (!disabled) {
+      display = 'block';
+    }
+
+    this.elementRef.nativeElement.style.display = display;
+
+    if (display === 'none') {
+      this.elementRef.nativeElement.remove();
+    }
+
+    this.cdr.detectChanges();
+  }
+
+  ngOnInit() {
+    if (!this.feature) return;
+    this.cdr.detectChanges();
+    this.handleDisplay();
+  }
+}

package/src/lib/core/directives/monkeyecx-feature-directive.ts

@@ -0,0 +1,72 @@
+import { ChangeDetectorRef, Directive, ElementRef, Input, OnDestroy, OnInit } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { MonkeyEcxUtils } from '../utils/utils';
+import { MonkeyEcxFeatureToggleService } from '../services/config/monkeyecx-feature-toggle.service';
+
+@Directive({
+  selector: '[monkeyecxFeature]'
+})
+export class MonkeyEcxFeatureDirective implements OnDestroy, OnInit {
+  @Input('featureName') feature?: string;
+
+  private unsubscribeAll = new Subject();
+
+  constructor(
+    private cdr: ChangeDetectorRef,
+    private elementRef: ElementRef,
+    private monkeyecxFeatureToggleService: MonkeyEcxFeatureToggleService
+  ) {
+    // not to do
+  }
+
+  private getFeature(feature: string): boolean {
+    const { monkeyecxFeatureToggleService } = this;
+
+    if (!monkeyecxFeatureToggleService) {
+      return false;
+    }
+
+    return monkeyecxFeatureToggleService?.getFlag(feature) || false;
+  }
+
+  private handleDisplay(): void {
+    if (!this.feature) return;
+    const flag = this.getFeature(this.feature);
+    let display = 'none';
+
+    if (!MonkeyEcxUtils.persistNullEmptyUndefined(flag)) {
+      return;
+    }
+
+    if (flag) {
+      display = 'block';
+    }
+
+    if (display === 'none') {
+      this.elementRef.nativeElement.remove();
+    }
+
+    this.elementRef.nativeElement.style.display = display;
+    this.cdr.detectChanges();
+  }
+
+  ngOnDestroy() {
+    this.unsubscribeAll.next();
+    this.unsubscribeAll.complete();
+  }
+
+  ngOnInit() {
+    if (!this.feature) return;
+    this.elementRef.nativeElement.style.display = 'none';
+    this.cdr.detectChanges();
+
+    this.monkeyecxFeatureToggleService.onFlags
+      .pipe(takeUntil(this.unsubscribeAll))
+      .subscribe((val: boolean) => {
+        if (val) {
+          this.handleDisplay();
+        }
+      });
+  }
+}

package/src/lib/core/directives/monkeyecx-format-currency.ts

@@ -0,0 +1,44 @@
+import { Directive, ElementRef, HostListener, OnInit, Injector } from '@angular/core';
+import { CurrencyPipe } from '@angular/common';
+import { TranslateService } from '@ngx-translate/core';
+import { MonkeyEcxUtils } from '../utils/utils';
+
+@Directive({
+  selector: '[monkeyecxFormatCurrency]',
+  providers: [CurrencyPipe]
+})
+export class MonkeyEcxFormatCurrency implements OnInit {
+  private el: HTMLInputElement;
+
+  private currency: any;
+
+  private currencyCode: string = 'BRL';
+
+  private currentLocale: string = 'pt-BR';
+
+  constructor(private elementRef: ElementRef, private injector: Injector) {
+    this.el = this.elementRef.nativeElement;
+    this.currency = this.injector.get(CurrencyPipe);
+
+    const translateService = this.injector.get(TranslateService);
+    translateService.get('MONKEY-CURRENCY-CODE').subscribe((_: any) => {
+      this.currencyCode = _;
+      this.currentLocale = translateService.getDefaultLang();
+    });
+  }
+
+  private handle(value: any): string {
+    const { currencyCode, currentLocale } = this;
+    const newValue = MonkeyEcxUtils.handleOnlyNumbers(value);
+    return this.currency.transform(newValue / 100, currencyCode, 'symbol', '', currentLocale);
+  }
+
+  ngOnInit() {
+    this.el.value = this.handle(this.el.value);
+  }
+
+  @HostListener('input', ['$event.target.value'])
+  onInput(value: any) {
+    this.el.value = this.handle(value);
+  }
+}

package/src/lib/core/directives/monkeyecx-format-upper.ts

@@ -0,0 +1,54 @@
+import { Directive, ElementRef, forwardRef, HostListener, Renderer2, Self } from '@angular/core';
+import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';
+
+@Directive({
+  selector: '[monkeyecxFormatUpper]',
+  providers: [
+    {
+      provide: NG_VALUE_ACCESSOR,
+      useExisting: forwardRef(() => {
+        // eslint-disable-next-line no-use-before-define
+        return MonkeyEcxFormatUpper;
+      }),
+      multi: true,
+    },
+  ],
+})
+export class MonkeyEcxFormatUpper implements ControlValueAccessor {
+  _onChange?: (_: any) => void;
+
+  _touched?: () => void;
+
+  constructor(@Self() private _el: ElementRef, private _renderer: Renderer2) {
+    // not to do
+  }
+
+  @HostListener('keyup', ['$event'])
+  onKeyDown(evt: KeyboardEvent) {
+    const value = this._el.nativeElement.value.toUpperCase();
+    this._renderer.setProperty(this._el.nativeElement, 'value', value);
+    this._onChange?.(value);
+    evt.preventDefault();
+  }
+
+  @HostListener('blur', ['$event'])
+  onBlur() {
+    this._touched?.();
+  }
+
+  writeValue(value: any): void {
+    this._renderer.setProperty(this._el.nativeElement, 'value', value);
+  }
+
+  registerOnChange(fn: (_: any) => void): void {
+    this._onChange = fn;
+  }
+
+  registerOnTouched(fn: () => void): void {
+    this._touched = fn;
+  }
+
+  setDisabledState(isDisabled: boolean): void {
+    this._renderer.setProperty(this._el.nativeElement, 'disabled', isDisabled);
+  }
+}

package/src/lib/core/directives/monkeyecx-only-alpha-numeric-directive.ts

@@ -0,0 +1,21 @@
+import { Directive, ElementRef, HostListener } from '@angular/core';
+import { MonkeyEcxUtils } from '../utils/utils';
+
+@Directive({
+  selector: '[monkeyecxOnlyAlphaNumeric]'
+})
+export class MonkeyEcxOnlyAlphaNumericDirective {
+  constructor(private elementRef: ElementRef) {
+    // not to do
+  }
+
+  @HostListener('input', ['$event'])
+  onInputChange(event: Event) {
+    const initalValue = this.elementRef.nativeElement.value;
+
+    this.elementRef.nativeElement.value = MonkeyEcxUtils.handleOnlyAlphaNumeric(initalValue);
+    if (initalValue !== this.elementRef.nativeElement.value) {
+      event.stopPropagation();
+    }
+  }
+}

package/src/lib/core/directives/monkeyecx-only-number-directive.ts

@@ -0,0 +1,21 @@
+import { Directive, ElementRef, HostListener } from '@angular/core';
+import { MonkeyEcxUtils } from '../utils/utils';
+
+@Directive({
+  selector: '[monkeyecxOnlyNumbers]'
+})
+export class MonkeyEcxOnlyNumbersDirective {
+  constructor(private elementRef: ElementRef) {
+    // not to do
+  }
+
+  @HostListener('input', ['$event'])
+  onInputChange(event: Event) {
+    const initalValue = this.elementRef.nativeElement.value;
+
+    this.elementRef.nativeElement.value = MonkeyEcxUtils.handleOnlyNumbers(initalValue);
+    if (initalValue !== this.elementRef.nativeElement.value) {
+      event.stopPropagation();
+    }
+  }
+}