monkey-front-core 0.0.235 → 0.0.238

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

@@ -0,0 +1,151 @@
+import { Injectable } from '@angular/core';
+import { Observable, of, BehaviorSubject } from 'rxjs';
+import { MonkeyEcxConfigService } from '../config/monkeyecx-config.service';
+import { MonkeyEcxUtils } from '../../utils/utils';
+import {
+  MonkeyEcxConfig,
+  MonkeyEcxMeCredentials,
+  MonkeyEcxTokenCredentials,
+} from '../../interfaces';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class MonkeyEcxTokenStorageService {
+  private token: MonkeyEcxTokenCredentials | null;
+
+  private token$: BehaviorSubject<MonkeyEcxTokenCredentials | any>;
+
+  private me$: BehaviorSubject<MonkeyEcxMeCredentials | any>;
+
+  private config: MonkeyEcxConfig | null = null;
+
+  constructor(private monkeyecxConfigService: MonkeyEcxConfigService) {
+    this.token = {
+      username: '',
+      program: '',
+      accessToken: '',
+      refreshToken: '',
+      companyId: '',
+      governmentId: '',
+      companyTypeUrl: '',
+      companyType: '',
+      programAdmin: false,
+      programType: '',
+      accessType: '',
+      role: '',
+      ownerGovernmentId: '',
+      _clearIgnore: {
+        ignore: ['username', 'program', 'accessType'],
+      },
+    };
+    this.token$ = new BehaviorSubject(null);
+    this.me$ = new BehaviorSubject(null);
+
+    this.monkeyecxConfigService.config().subscribe((_: MonkeyEcxConfig) => {
+      this.config = _;
+    });
+  }
+
+  private setAllTokens(token: MonkeyEcxTokenCredentials) {
+    const { token$ } = this;
+    Object.entries(token).forEach(([key, value]) => {
+      if (MonkeyEcxUtils.persistNullEmptyUndefined(value)) {
+        localStorage.setItem(key, value);
+      }
+    });
+    token$.next(token);
+  }
+
+  private getAllTokens(): MonkeyEcxTokenCredentials {
+    const { token, config } = this;
+    const handledToken: any = {
+      ...token,
+    };
+    Object.entries(token || {}).forEach(([key, value]) => {
+      handledToken[key] = localStorage.getItem(key);
+    });
+
+    if (!handledToken?.program && config?.program) {
+      handledToken.program = config?.program?.token;
+    }
+
+    return handledToken;
+  }
+
+  private setAllMe(me: MonkeyEcxMeCredentials) {
+    const { me$ } = this;
+    let previousMe = JSON.parse(localStorage?.getItem('me') || '{}');
+    Object.entries(me).forEach(([key, value]) => {
+      if (MonkeyEcxUtils.persistNullEmptyUndefined(value)) {
+        previousMe = {
+          ...previousMe,
+          [key]: value,
+        };
+      }
+    });
+
+    localStorage.setItem('me', JSON.stringify(previousMe));
+    me$.next(previousMe);
+  }
+
+  private getAllMe(): MonkeyEcxMeCredentials {
+    const me = localStorage.getItem('me');
+    return JSON.parse(me || '{}') as MonkeyEcxMeCredentials;
+  }
+
+  public tokenHasChanged(): Observable<MonkeyEcxTokenCredentials> {
+    return this.token$.asObservable();
+  }
+
+  public meHasChanged(): Observable<MonkeyEcxMeCredentials> {
+    return this.me$.asObservable() || null;
+  }
+
+  public getToken(): MonkeyEcxTokenCredentials {
+    return this.getAllTokens();
+  }
+
+  public getMe(): MonkeyEcxMeCredentials {
+    return this.getAllMe();
+  }
+
+  public setToken(token: MonkeyEcxTokenCredentials) {
+    this.setAllTokens(token);
+  }
+
+  public setMe(me: MonkeyEcxMeCredentials) {
+    this.setAllMe(me);
+  }
+
+  public clear(force?: boolean): Observable<boolean> {
+    const { token } = this;
+    try {
+      Object.entries(token || {}).forEach(([key, value]) => {
+        if (
+          (token?._clearIgnore?.ignore || []).filter((val: any) => {
+            return val === key;
+          }).length <= 0 ||
+          force === true
+        ) {
+          localStorage.removeItem(key);
+        }
+      });
+      localStorage.removeItem('me');
+    } catch (error) {
+      return of(false);
+    }
+    return of(true);
+  }
+
+  /**
+   * @param fields (the name of fields you want to clear. ie: ['companyId', 'role', ...])
+   */
+  public clearCredentials(
+    fields = ['companyId', 'governmentId', 'companyType', 'programAdmin', 'role']
+  ) {
+    fields?.forEach((key: string) => {
+      localStorage.removeItem(key);
+    });
+  }
+}

package/{lib/core/specification-search/index.d.ts → src/lib/core/specification-search/index.ts}

@@ -1 +1 @@
-export * from './monkeyecx-specification-search';
+export * from './monkeyecx-specification-search';

package/src/lib/core/specification-search/monkeyecx-specification-search.ts

@@ -0,0 +1,111 @@
+/* eslint-disable no-unused-vars */
+import { MonkeyEcxUtils } from '../utils/utils';
+
+export enum OpSearch {
+  LIKE = ':*:value*',
+  BETWEEN = ':first AND :last',
+  OR = 'OR',
+  AND = 'AND',
+  GT = '>:value',
+  LT = '<:value',
+  EQUAL = '::value',
+  IN = ' IN :value',
+  NOT = ' !:value'
+}
+
+export class MonkeyEcxSpecificationSearch {
+  constructor() {
+    // not to do
+  }
+
+  private handleValue(value: any) {
+    return Object.entries(value).map(([key, value1]) => {
+      if (!MonkeyEcxUtils.persistNullEmptyUndefined(value1)) {
+        return null;
+      }
+      if (Array.isArray(value1)) {
+        if (key === OpSearch.BETWEEN) {
+          return `${key}`.replace(':first', value1[0]).replace(':last', value1[1]);
+        }
+      }
+      return `${key}`.replace(':value', `${value1}`);
+    })[0];
+  }
+
+  private queryVisitor(value: any): any {
+    const okay = Object.entries(value).map(([key1, value1]) => {
+      if (key1 === OpSearch.OR || key1 === OpSearch.AND) {
+        const join = (value1 as any[])
+          .map((_: any) => {
+            return Object.entries(_).map(([key2, value2]) => {
+              if (value2 instanceof Object) {
+                value2 = this.handleValue(value2);
+              }
+              return this.criteriaParser(key2, value2);
+            })[0];
+          })
+          .filter((_: any) => {
+            return _;
+          })
+          .join(` ${key1} `);
+        return `${join ? `(${join})` : ''}`;
+      }
+      if (value1 instanceof Object) {
+        value1 = this.handleValue(value1);
+      }
+      return this.criteriaParser(key1, value1);
+    });
+    return okay
+      .filter((_: any) => {
+        return _;
+      })
+      .join(' AND ');
+  }
+
+  private criteriaParser(key: string, value: any | any[]) {
+    if (!MonkeyEcxUtils.persistNullEmptyUndefined(value)) {
+      return '';
+    }
+    if (value instanceof Object) {
+      return this.queryVisitor(value);
+    }
+    return `${key}${value}`;
+  }
+
+  public build(spec: any): string {
+    try {
+      return this.queryVisitor(spec);
+    } catch (e) {
+      throw new Error(`MonkeyEcxSpecificationSearch Error ${e}`);
+    }
+  }
+
+  public buildMoreThanOne(field: string, op = OpSearch.EQUAL, addSingleQuotes = false) {
+    const self: any = this;
+    try {
+      if (!self[field]) return [];
+
+      const filters = self[field]?.split(',')?.map((filter: string) => {
+        if (!filter) return null;
+        return {
+          [field]: {
+            [op]: addSingleQuotes ? `'${filter}'` : `${filter}`
+          }
+        };
+      }).filter((val: any) => { return val; });
+      return filters || [];
+    } catch (e) {
+      throw new Error(`MonkeyEcxSpecificationSearch Error ${e}`);
+    }
+  }
+
+  public handleFieldSeparatedBy(field: string, signal = ',', op = OpSearch.EQUAL) {
+    return this[field]?.split(signal)?.map((_) => {
+      return {
+        [field]: {
+          [op]: _
+        }
+      };
+    });
+  }
+}

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

@@ -0,0 +1,56 @@
+import {
+  MonkeyEcxRequestDownload,
+  MonkeyEcxRequestItemQueue,
+  MonkeyEcxRequestQueue,
+  MonkeyEcxRequestUpload
+} from '../interfaces';
+import * as Statics from './statics';
+import { MonkeyEcxUtils } from './utils';
+
+export function buildQueuePropertys(queue: MonkeyEcxRequestItemQueue): MonkeyEcxRequestQueue {
+  const params: MonkeyEcxRequestQueue = {
+    item: {
+      ...queue,
+      id: MonkeyEcxUtils.getRandomString(40)
+    },
+    status: Statics.MonkeyEcxQueueEvents.OnGoing
+  };
+
+  return params;
+}
+
+export function buildDownloadPropertys(
+  name: string,
+  description?: string,
+  size?: number
+): MonkeyEcxRequestDownload {
+  const params: MonkeyEcxRequestDownload = {
+    item: {
+      name,
+      description,
+      id: `${MonkeyEcxUtils.getRandomString(40)}`,
+      size,
+      createdAt: new Date()
+    },
+    status: Statics.MonkeyEcxQueueEvents.OnGoing
+  };
+
+  return params;
+}
+
+export function buildUploadPropertys(name: string, description?: string): MonkeyEcxRequestUpload {
+  const params: MonkeyEcxRequestUpload = {
+    item: {
+      name,
+      description,
+      id: `${MonkeyEcxUtils.getRandomString(40)}`
+    },
+    status: Statics.MonkeyEcxUploadEvents.OnGoing
+  };
+
+  return params;
+}
+
+export function hasMonkeyEcxServiceAndHandlingProperties(context: any): boolean {
+  return Object.prototype.hasOwnProperty.call(context, 'monkeyecxService');
+}

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

@@ -1,6 +1,8 @@
-import { MonkeyEcxUtils } from './utils';
-import * as ValidateUtils from './validate-utils';
-import * as DecoratorsUtils from './decorators-utils';
-import * as Statics from './statics';
-export { MonkeyEcxUtils, ValidateUtils, DecoratorsUtils, Statics };
-export * from './validators';
+/* eslint-disable object-curly-newline */
+import { MonkeyEcxUtils } from './utils';
+import * as ValidateUtils from './validate-utils';
+import * as DecoratorsUtils from './decorators-utils';
+import * as Statics from './statics';
+
+export { MonkeyEcxUtils, ValidateUtils, DecoratorsUtils, Statics };
+export * from './validators';

package/src/lib/core/utils/statics.ts

@@ -0,0 +1,36 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable no-shadow */
+export enum MonkeyEcxQueueEvents {
+  OnGoing,
+  Finished,
+  FinishedWithError
+}
+
+export enum MonkeyEcxDownloadEvents {
+  OnGoing,
+  Finished,
+  FinishedWithError
+}
+
+export enum MonkeyEcxUploadEvents {
+  OnGoing,
+  Finished,
+  FinishedWithError
+}
+
+// TODO pegar do json de config
+export enum ApiEndPointsTokenNotMandatory {
+  Assets = 'assets/',
+  MonkeyEcx = '/monkeyecx',
+  ViaCep = 'viacep.com.br/'
+}
+
+// TODO pegar do json de config
+export enum ApiEndPointsHeaderNotMandatory {
+  Assets = '/assets',
+  PayablesUpload = 'payables-upload',
+  PictureUser = '/user-pictures',
+  Documents = 'documents/',
+  BuyerTaxFile = '/buyer-tax-file',
+  ViaCep = 'viacep.com.br/'
+}

package/src/lib/core/utils/utils.ts

@@ -0,0 +1,237 @@
+/* eslint-disable comma-dangle */
+/* eslint-disable max-len */
+/* eslint-disable no-useless-escape */
+/* eslint-disable no-plusplus */
+/* eslint-disable no-cond-assign */
+/* eslint-disable eqeqeq */
+/* eslint-disable no-redeclare */
+/* eslint-disable vars-on-top */
+/* eslint-disable no-var */
+/* eslint-disable block-scoped-var */
+export class MonkeyEcxUtils {
+  static persistNullEmptyUndefined(tp: any): boolean {
+    return tp !== null && tp !== undefined && tp !== '';
+  }
+
+  static getDocumentType(doc: string, country?: string) {
+    if (!doc) return '';
+    if (country === 'cl') return 'RUT';
+    return doc.length <= 11 ? 'CPF' : 'CNPJ';
+  }
+
+  static getDocumentMask(type: string) {
+    if (type === 'CPF') return '000.000.000-00';
+    return '00.000.000/0000-00';
+  }
+
+  static formatDocumentWithMask(doc: string, withType?: boolean, country?: string): string {
+    if (!doc) return doc;
+    let formated: string = '';
+    if (country === 'cl') {
+      formated = doc.replace(/^(\d{1,2})(\d{3})(\d{3})(\w{1})$/, '$1.$2.$3-$4');
+      return `${formated}`;
+    }
+    if (doc.length === 14) {
+      formated = doc
+        .replace(/^(\d{2})(\d)/, '$1.$2')
+        .replace(/^(\d{2})\.(\d{3})(\d)/, '$1.$2.$3')
+        .replace(/\.(\d{3})(\d)/, '.$1/$2')
+        .replace(/(\d{4})(\d)/, '$1-$2');
+    } else {
+      formated = doc
+        .replace(/^(\d{3})(\d)/, '$1.$2')
+        .replace(/^(\d{3})\.(\d{3})(\d)/, '$1.$2.$3')
+        .replace(/\.(\d{3})(\d)/, '.$1-$2');
+    }
+
+    return `${withType ? `${this.getDocumentType(doc)}:` : ''} ${formated}`;
+  }
+
+  static cutFirstLastName(value: string, tp: string = 'first') {
+    const split = value?.trim()?.split(' ');
+
+    if (tp === 'first') return split[0];
+    return split?.splice(1, split.length)?.join(' ');
+  }
+
+  static isCPFCNPJValid(document: any): boolean {
+    document = document.replace(/[^\d]/g, '');
+
+    const handled = document.replace(new RegExp(document.charAt(0), 'g'), '');
+    if (!handled) return false;
+
+    if (document.length === 11) {
+      let base = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
+      for (var i = 0, n = 0; i < 9; n += document[i] * base[i++]);
+      if (document[9] != ((n %= 11) <= 1 ? 0 : 11 - n)) {
+        return false;
+      }
+      base = [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
+      for (var i = 0, n = 0; i <= 9; n += document[i] * base[i++]);
+      if (document[10] != ((n %= 11) <= 1 ? 0 : 11 - n)) {
+        return false;
+      }
+      return true;
+    }
+    if (document.length === 14 || /0{14}/.test(document)) {
+      const base = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+      for (var i = 0, n = 0; i < 12; n += document[i] * base[++i]);
+      if (document[12] != ((n %= 11) < 2 ? 0 : 11 - n)) {
+        return false;
+      }
+
+      for (var i = 0, n = 0; i <= 12; n += document[i] * base[i++]);
+      if (document[13] != ((n %= 11) < 2 ? 0 : 11 - n)) {
+        return false;
+      }
+
+      return true;
+    }
+    return false;
+  }
+
+  public static isValidRUT(document: string): boolean {
+    if (!document || document.trim().length < 3) return false;
+    const documentHandled = document.replace(/[^0-9kK]/g, '');
+
+    if (documentHandled.length < 3) return false;
+
+    const calcDv = (rut: string) => {
+      const value: string = `${rut}`;
+      let sum = 0;
+      let mult = 2;
+
+      for (let i = 1; i <= value.length; i++) {
+        const index = mult * Number(value.charAt(value.length - i));
+
+        sum += index;
+
+        if (mult < 7) {
+          mult += 1;
+        } else {
+          mult = 2;
+        }
+      }
+
+      const dvEsperado = 11 - (sum % 11);
+      if (dvEsperado === 10) return 'K';
+      if (dvEsperado === 11) return '0';
+      return `${dvEsperado}`;
+    };
+
+    const num = documentHandled.slice(0, -1);
+    const dgv = documentHandled.slice(-1).toUpperCase();
+
+    const dvCalc = calcDv(num);
+    return dvCalc === dgv;
+  }
+
+  static isValidUrl(txt: string): boolean {
+    const regex = new RegExp(
+      /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)+[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,10}(:[0-9]{1,5})?(\/.*)?$/gm
+    );
+    return regex.test(txt);
+  }
+
+  static isValidZipCode(zipCode: string): boolean {
+    return `${this.handleOnlyNumbers(zipCode)}`.length === 8;
+  }
+
+  static getRandomString(len: number, charSet?: string): string {
+    charSet = charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+    const randomString: string = new Array(len)
+      .fill('1')
+      .map(() => {
+        return charSet?.charAt(Math.floor(Math.random() * charSet?.length));
+      })
+      .join('');
+    return randomString;
+  }
+
+  static handleOnlyNumbers(value: any) {
+    if (!value) return null;
+    return value.replace(new RegExp(/[^0-9]/g), '');
+  }
+
+  static handleOnlyAlphaNumeric(value: any) {
+    if (!value) return '';
+    return value.replace(new RegExp(/[^0-9A-Za-z]/, 'g'), '');
+  }
+
+  static capitalize(value: string) {
+    return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+  }
+
+  static formatZipCode(zipCode: string): string {
+    if (!zipCode) return zipCode;
+    const formated: string = zipCode
+      .replace(/^(\d{5})(\d)/, '$1-$2')
+      .replace(/\.(\d{3})(\d)/, '.$1-$2');
+
+    return `${formated}`;
+  }
+
+  static formatFileSize(size: number): string {
+    const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    let l = 0;
+    while (size >= 1024 && ++l) {
+      size /= 1024;
+    }
+    return `${size.toFixed(size < 10 && l > 0 ? 1 : 0)} ${units[l]}`;
+  }
+
+  static sufflue(data: any[]): any[] {
+    for (let i = data.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * i);
+      const temp = data[i];
+      data[i] = data[j];
+      data[j] = temp;
+    }
+    return data;
+  }
+
+  static handleBlobFile(theBlob: any, fileName: string, fileType: string) {
+    function blobToFile(theBlob: any, fileName: string) {
+      const b = theBlob;
+      b.lastModifiedDate = new Date();
+      b.name = fileName;
+      return b;
+    }
+
+    let file: any;
+    if (!(navigator as any).msSaveBlob) {
+      file = new File([theBlob], fileName, {
+        type: fileType,
+      });
+    } else {
+      file = new Blob([theBlob], {
+        type: fileType,
+      });
+      file = blobToFile(file, fileName);
+    }
+    return file;
+  }
+
+  static truncate(text: string, maxLength: number = 25): string {
+    const midChar = '...';
+    if (!text) return midChar;
+    if (text && text.length <= maxLength) return text;
+
+    const left = Math.ceil(maxLength / 2);
+    const right = text.length - left + 1;
+
+    return `${text.substr(0, left)} ${midChar} ${text.substring(right)}`;
+  }
+
+  static isLocalhost() {
+    const { href } = window?.location;
+    if (!href) return false;
+    return href?.search('localhost') >= 0;
+  }
+
+  static isSameOrigin(frontend: string): boolean {
+    const initialPath: string = window.location.origin;
+    return (initialPath || '') === frontend;
+  }
+}