@sankhyalabs/core 0.0.0-bugfix-dev-KB-6165.0

package/src/utils/StringUtils.ts

@@ -0,0 +1,359 @@
+import { v4 as uuid } from "uuid";
+
+/**
+ * `StringUtils`: Utilizado para manipulação de Strings.
+ */
+export class StringUtils {
+
+    /**
+     * Retorna se a string está vazia.
+     * Valores null e undefined são considerados como vazio.
+     * 
+     * @param value - String para ser validada.
+     * @returns - Verdadeiro caso a string não contenha informação.
+     * 
+    */
+    static isEmpty(value: any): Boolean {
+
+        if (value == undefined || value === null) {
+            return true;
+        }
+
+        value = value.toString();
+        value = value.trim();
+
+        if (value.length === 0) {
+            return true;
+        }
+
+        return false;
+    }
+    
+    /**
+     * Remove acentos de vogais maiúsculas
+     * 
+     * @param text  String para ser transformada.
+     * @example entrada: "ÁÊÇÒ" // retorno: "AECO"
+    */
+    static replaceAccentuatedCharsUpper(text: string): string {
+        return text.replace(/[ÀÁÂÃÄÅÆ]/g, 'A')
+        .replace(/[ÈÉÊË]/g, 'E')
+        .replace(/[ÌÍÎÏ]/g, 'I')
+        .replace(/[ÒÓÔÕÖØ]/g, 'O')
+        .replace(/[ÙÚÛÜ]/g, 'U')
+        .replace(/[ÝŸ]/g, 'Y')
+        .replace(/[Ñ]/g, 'N')
+        .replace(/[Ç]/g, 'C');
+    }
+
+    /**
+     * Converte todas as entidades HTML de um texto
+     * 
+     * @param text  String para ser transformada.
+     * @example entrada: "&lt;Teste&gt;" // retorno: "<Teste>"
+    */
+       static decodeHtmlEntities(text: string): string {
+        if(!text){
+            return text;
+        }
+        const entities = [
+            ['amp', '&'],
+            ['apos', '\''],
+            ['#x27', '\''],
+            ['#x2F', '/'],
+            ['#39', '\''],
+            ['#47', '/'],
+            ['lt', '<'],
+            ['gt', '>'],
+            ['nbsp', ' '],
+            ['quot', '"']
+        ];
+
+        for(let entity of entities) {
+            text = text.replace(new RegExp(`&${entity[0]};`), entity[1]);
+        }
+    
+        return text;
+      }
+
+    /**
+     * Remove acentos de vogais minúsculas.
+     * 
+     * @param text  String para ser transformada.
+     * @example entrada: "áêçò" // retorno: "aeco"
+    */   
+    static replaceAccentuatedCharsLower(text: string): string {
+        return text.replace(/[àáâãäåæ]/g, 'a')
+        .replace(/[èéêë]/g, 'e')
+        .replace(/[ìíîï]/g, 'i')
+        .replace(/[òóôõöø]/g, 'o')
+        .replace(/[ùúûü]/g, 'u')
+        .replace(/[ýÿ]/g, 'y')
+        .replace(/[ñ]/g, 'n')
+        .replace(/[ç]/g, 'c');
+    }
+
+    /**
+     * Remove acentuação de vogais e de caracteres especiais que não sejam letras ou numeral.
+     * 
+     * @param text                  String para ser transformada.
+     * @param removeSpecialChars    Remove outros caracteres especiais que não sejam letras e números.
+     * @example 
+     * entrada: "á@Êç#Ò", false // retorno: "a@Ec#O"
+     * entrada: "á@Êç#Ò", true // retorno: "aEcO"
+    */
+    static replaceAccentuatedChars(text: string, removeSpecialChars: boolean = true): string {              
+        
+        text = StringUtils.replaceAccentuatedCharsLower(text);
+        text = StringUtils.replaceAccentuatedCharsUpper(text);
+
+        if(removeSpecialChars){
+            text = text.replace(/[^a-z0-9]/gi, "");
+        }
+        return text;
+    }
+
+    /**
+    * Remove acentos de vogais, substitui Ç por c e retorna a string em caixa alta mantendo espaços e símbolos.
+    * @param text - Texto para ser transformado.
+    * @returns - Texto sem acentuação e caixa alta, mantendo espaços e símbolos.
+    */
+    static replaceAccentuatedCharsKeepSymbols(text: string): string {
+        return text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toUpperCase();
+    }
+
+    /**
+     * Calcula um código hash para uma string.
+     * @param value String que será gerado o hash code.
+     * @returns - Um hash calculado com base no valor informado.
+     * @example
+     * Informado: '123456' | Retorna: 1450575459
+    */
+    static hashCode(value: string): string {
+        let hash = 0, i, chr;
+        if (value.length === 0) return hash.toString();
+        for (i = 0; i < value.length; i++) {
+            chr = value.charCodeAt(i);
+            hash = ((hash << 5) - hash) + chr;
+            hash |= 0; // Convert to 32bit integer
+        }
+        return hash.toString();
+    }
+
+    /** 
+     * Converte um texto do tipo string para um booleano.
+     * 
+     * @param value Valor a ser convertido.
+     * @param defaultValue Valor padrão.
+     * @returns - Texto convertido.
+     * @example
+     * Informado: 'true'  | Retorna: true
+     * Informado: 'false' | Retorna: false
+    */
+    static getBooleanValue(value:string, defaultValue:boolean = false): boolean {
+        if([true, "true", "S"].includes(value)) {
+            return true;
+
+        } else if([false, "false", "N"].includes(value)) {
+            return false;
+
+        } else {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 
+     * Adiciona caracteres à esquerda caso texto seja menor que o valor do parâmetro len passado.
+     * 
+     * @param str - Texto para ser ajustado.
+     * @param len - Tamanho desejado do texto.
+     * @param pad - Caractere a ser adicionado a esquerda caso o texto menor que o tamanho passado.
+     * @returns - Texto passado se este for maior que o len.
+     * Ou retorna o texto com os caracteres adicionados na esquerda.
+     * 
+     * @example
+     * padStart('SANKHYA', 8,'.') | Retorna: '...SANKHYA'
+     * @example
+     * padStart('SANKHYA', 5,'A') | Retorna: 'SANKHYA'
+     * 
+     * 
+    */
+    static padStart(str: string, len: number, pad: string = " "): string {
+        str = str != undefined ? str : "";
+        while (str.length < len) {
+            str = pad + str;
+        }
+        return str;
+    }
+
+    /**
+     * 
+     * Adiciona caracteres à direita caso texto seja menor que o valor do parâmetro len passado.
+     * 
+     * @param str - Texto para ser ajustado.
+     * @param len - Tamanho desejado do texto.
+     * @param pad - Caractere a ser adicionado a direita caso o texto menor que o tamanho passado.
+     * @returns - Texto passado se este for maior que o len.
+     * Ou retorna o texto com os caracteres adicionados na direita.
+     * 
+     * @example
+     * padStart('SANKHYA', 8,'.') | Retorna: 'SANKHYA...'
+     * @example
+     * padStart('SANKHYA', 5,'A') | Retorna: 'SANKHYA'
+     * 
+     * 
+    */
+    static padEnd(str: string, len: number, pad: string = " "): string {
+        str = str != undefined ? str : "";
+        while (str.length < len) {
+            str = str + pad;
+        }
+        return str;
+    }
+
+
+    /**
+     * Determina a ordem de strings.
+     *
+     * @param a - Primeira string para comparação.
+     * @param b - Segunda string para comparação.
+     * @returns - Um numeral negativo se o primeiro argumento é menor que o segundo, zero se os dois são iguais e um numeral positivo quando o primeiro é maior que o segundo.
+     */
+    static compare(a: string, b: string): number{
+        
+        if(a === undefined){
+            return b === undefined ? 0 : 1;
+        } else if(b === undefined){
+            return -1;
+        }
+
+        if(a === null){
+            return b === null ? 0 : 1;
+        } else if(b === null){
+            return -1;
+        }
+
+        return a.localeCompare(b);
+    }
+  
+    /**
+     * Converte string em camelCase.
+     * Combina palavras compostas ou frases, alterando a inicial de cada uma, a partir da primeira, para maiúscula e unidas sem espaços.
+     * @param value String a ser convertida.
+     * @returns String convertida em camelCase. 
+     * 
+     * @example
+     * toCamelCase('Exemplo de uso') | Retorna: 'exemploDeUso'
+     */
+    static toCamelCase(value: string): string {
+        if(!value) return "";
+        if (value.match(/^[a-z]+[A-Z]/) || value.includes(".")) { 
+            return value;
+        } 
+        return value
+        .toLowerCase()
+        .replace(/^([A-Z])|[\s-_](\w)/g, (_, p1, p2) => p2?.toUpperCase() || p1.toLowerCase());        
+    }
+
+    /**
+     * Converte string para PascalCase.
+     * @param value String a ser convertida.
+     * @returns String convertida em PascalCase.
+     */
+    static toPascalCase(value: string): string{
+        return value
+          .toLowerCase()
+          .replace(/(?:^|\s)\w/g, (match: string) => match.toUpperCase())
+          .replace(/[\s-_]/g,'');
+    }
+
+    /**
+     * Utilitário para converter string em snake_case.
+     * @param value String a ser convertida.
+     * @returns String convertida em snake_case.
+     */
+    static toSnakeCase(value: string): string{
+        return value
+        .toLowerCase()
+        .replace(/[A-Z]/g, (match: string) => `_${match.toLowerCase()}`)
+        .replace(/[\s-]/g, '_')
+        .replace(/^_/, "");
+    }
+
+    /**
+     * Utilitário para converter string em kebab-case.
+     * @param value String a ser convertida.
+     * @returns String convertida em KebabCase.
+     */
+    static toKebabCase(value: string): string{
+        return value.replace(/([a-z])([A-Z])/g, '$1-$2').replace(/[\s_]+/g, '-').toLowerCase();
+    }
+    
+    /**
+     * Utilitário para remover caracteres em branco da string.
+     * @param value String a ser removido os espaços.
+     * @returns String sem espaços em branco.
+     */
+    static replaceBlankCharacters(value: string): string{
+        return (value || "").replace(/ /g, "");
+    }
+
+    /**
+     * Utilitário para formatar bytes em string legível, convertendo para 
+     * múltiplos maiores caso necessário.
+     * @param byte quantidade de bytes a serem representados.
+     * @returns string formatada de acordo com a unidade.
+     */
+    static formatBytes(bytes: number): string {
+        const units = ["B", "KB", "MB", "GB"];
+        let unit: string, value: string, base: number;
+    
+        if (bytes < 1024) {
+          return `${bytes.toString()}B`;
+        }
+        
+        base = Math.log(bytes) / Math.log(1024);
+        const offSet = Math.floor(base);
+        if (offSet >= units.length) {
+          return `${bytes.toString()}B`;
+        }
+    
+        value = this.prettyPrecision(Math.pow(1024, base - offSet).toFixed(2).toString());
+        unit = units[offSet];
+    
+        return `${value}${unit}`;
+      }
+    
+      /**
+     * Método interno. Remove zeros depois da vírgula diminuindo o tamanho
+     * da string.
+     * @param strNumber representação textual do número a ser ajustado.
+     * @returns simplificação do strNumber, sem os zeros à direita depois do ponto.
+     */
+      private static prettyPrecision(strNumber: string): string {
+        const parts = strNumber.split(".");
+        if (parts.length > 1) {
+          const lastPart = parts.length - 1;
+          let lastPartStr = parts[lastPart];
+          while (lastPartStr.length > 0 && lastPartStr[lastPartStr.length - 1] === "0") {
+            lastPartStr = lastPartStr.slice(0, lastPartStr.length - 1);
+          }
+          if (lastPartStr) {
+            parts[lastPart] = lastPartStr;
+          } else {
+            parts.pop();
+          }
+        }
+        return parts.join(".");
+      }
+
+     /**
+     * Método utilizado para gerar IDs únicos.
+     * @returns id único randômico.
+     */
+    static generateUUID():string {
+        return uuid();
+    }
+
+}

package/src/utils/TimeFormatter.ts

@@ -0,0 +1,98 @@
+import { MaskFormatter } from "./MaskFormatter.js";
+
+/**
+ * `TimeFormatter`: Utilizado para formatar horas.
+ */
+export class TimeFormatter {
+
+    static _maskFormatter: MaskFormatter = new MaskFormatter("##:##");
+
+    /**
+    * Converte um texto para o formato de hora.
+    *
+    * @param value - Texto não formatado.
+    * @param showSeconds - Se será validado os segundos. 
+    * @returns - Texto em formato de hora.
+    * 
+    * @Exemples
+    * @"1012"       |       "10:12"
+    * @"10:12"      |       "10:12:00"
+    * @"100112"     |       "10:01:12"
+    */
+    static prepareValue(value: string, showSeconds: boolean): string {
+        if (value && value.length > 0 && value != "NaN") {
+            let validationValue = value.replace(/:/g, "");
+            if (showSeconds) {
+                this._maskFormatter.mask = "##:##:##"
+                if (validationValue.length < 6) {
+                    while (validationValue.length < 6) {
+                        validationValue = "0".concat(validationValue);
+                    }
+                }
+            } else {
+                this._maskFormatter.mask = "##:##";
+                if (validationValue.length < 4) {
+                    while (validationValue.length < 4) {
+                        validationValue = "0".concat(validationValue);
+                    }
+                }
+            }
+            if (this._maskFormatter) {
+                try {
+                    value = this._maskFormatter.format(validationValue);
+                    return value;
+                } catch (e:any) {
+                    throw new Error(e.message);
+                }
+            }
+        }
+        return '';
+    }
+
+    /**
+    * Retorna se o texto está no formato de hora.
+    *
+    * @param value - Texto a ser validado.
+    * @param showSeconds - Se será validado os segundos.
+    * @returns - Verdadeiro para valores no formato de hora e False para formatos diferentes.
+    * 
+    * @Exemples
+    * @"1012"       |       true
+    * @"14e4"       |       false
+    * @"2624"       |       false
+    */
+    static validateTime(value: string, showSeconds: boolean) {
+        let isValid: boolean = true;
+        if (value) {
+            const validationValue = value.replace(/:/g, "");
+            if (showSeconds) {
+                if (!["1", "2", "0"].includes(validationValue[0])) {
+                    isValid = false;
+                }
+                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[2])) {
+                    isValid = false;
+                }
+                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[4])) {
+                    isValid = false;
+                }
+                if (validationValue[0] == "2" && !["0", "1", "2", "3"].includes(validationValue[1])) {
+                    isValid = false;
+                }
+            } else {
+                if (!["1", "2", "0"].includes(validationValue[0])) {
+                    isValid = false;
+                }
+                if (!["0", "1", "2", "3", "4", "5"].includes(validationValue[2])) {
+                    isValid = false;
+                }
+                if (validationValue[0] == "2" && !["0", "1", "2", "3"].includes(validationValue[1])) {
+                    isValid = false;
+                }
+            }
+        }else{
+            isValid = false;
+        }
+        return isValid;
+    }
+
+}

package/src/utils/UserAgentUtils/index.ts

@@ -0,0 +1,62 @@
+import AGENT_LIST from "./navigatorAgentList.js"
+import { NumberUtils } from "../NumberUtils.js";
+
+/**
+ * `UserAgentUtils`: Utilitario para tratativas relacionadas ao navegador.
+ */
+export class UserAgentUtils {
+    
+    /**
+     * Obtém se o navegador do usuário é o firefox.
+     * @returns Verdadeiro se o navegador do usuário for o firefox.
+     */
+    public static isFirefox() {
+        const browser = this.getBrowserInfo();
+        return !!browser.firefox;
+    }
+
+    /**
+     * Obtém nome e versão do navegador que está sendo utilizado.
+     * @returns Objeto com o nome e versão do navegador.
+     */
+    public static getBrowserInfo(): any {
+        const userAgent = window.navigator.userAgent;
+        let browser = { name: '', version: '' } as any;
+        let result: RegExpExecArray | null;
+
+        AGENT_LIST.every(({ name, type, regexp, simpleVersionRegExp }) => {
+            let hasFound = false;
+
+            regexp.every((reg) => {
+                if (reg.test(userAgent)) {
+                    hasFound = true;
+                    result = reg.exec(userAgent);
+                    let simpleVersion = 0;
+
+                    try {
+                        if (simpleVersionRegExp && simpleVersionRegExp.test(userAgent)) {
+                            const simpleExec = simpleVersionRegExp.exec(userAgent);
+                            simpleVersion = NumberUtils.stringToNumber(simpleExec?.[1] || "0")
+                        }
+                    } catch (e) {
+                        //ignored
+                    }
+
+                    browser = {
+                        ...browser,
+                        name,
+                        version: result?.[1] || "",
+                        simpleVersion,
+                        ...(Array.isArray(type) ? type.reduce((acc, val) => ({ ...acc, [val]: true}), {}) : { [type]: true })
+                    }
+
+                    return !hasFound;
+                }
+            })
+
+            return !hasFound;
+        })
+
+        return browser;
+    }
+}

package/src/utils/UserAgentUtils/navigatorAgentList.ts

@@ -0,0 +1,39 @@
+export default [
+    {
+        name: "Electron",
+        type: "electron",
+        regexp: [ new RegExp('Electron\\/([0-9\\.]*)') ]
+    }, {
+        name: "Internet Explorer",
+        type: "ie",
+        regexp: [
+            new RegExp('MSIE.([0-9\\.]*)'),
+            new RegExp('Trident.([0-9\\.]*)')
+        ]
+    }, {
+        name: "Edge",
+        type: "edge",
+        regexp: [ new RegExp('Edge.([0-9\\.]*)') ]
+    }, {
+        name: "Chrome",
+        type: "chrome",
+        regexp: [ new RegExp('Chrome\\/([0-9\\.]*)') ]
+    }, {
+        name: "Safari",
+        type: "safari",
+        regexp: [ new RegExp('safari\\/([\\d\\.]*)') ]
+    }, {
+        name: "Apple Web Kit",
+        type: "safari",
+        regexp: [ new RegExp('AppleWebKit\\/([\\d\\.]*)') ],
+        simpleVersionRegExp: new RegExp('Version\\/([\\d]*)')
+    }, {
+        name: "Firefox",
+        type: ["firefox", "mozilla"],
+        regexp: [ new RegExp('Fire[Ff]ox.([0-9\\.]*)') ]
+    }, {
+        name: "",
+        type: "mozilla",
+        regexp: [ new RegExp('gecko') ]
+    }
+]

package/src/utils/VersionUtils.ts

@@ -0,0 +1,37 @@
+import { StringUtils } from "./StringUtils.js";
+
+export default class VersionUtils {    
+    /**
+     * Verifica se a versão do backend (SankhyaOM) é maior ou igual a uma determinada versão.
+     * @param executionCtx - Contexto de execução da inserção do dado no DataUnit.
+    */
+    public static isRequiredVersion(currentVersion: string, requiredVersion:string): boolean {
+    
+        if(StringUtils.isEmpty(requiredVersion) || StringUtils.isEmpty(currentVersion)){
+          return true
+        }
+    
+          const regexNumericPart = /\d+/g;
+    
+          const currentVersionParts = currentVersion.match(regexNumericPart)?.map(Number) || [];
+          const requiredVersionParts = requiredVersion.match(regexNumericPart)?.map(Number) || [];
+    
+          const maxParts = Math.max(currentVersionParts.length, requiredVersionParts.length);
+    
+          for (let i = 0; i < maxParts; i++) {
+            const currentPart = currentVersionParts[i] || 0;
+            const requiredPart = requiredVersionParts[i] || 0;
+    
+            if (currentPart < requiredPart) return false;
+          }
+    
+          if (requiredVersion.includes('b')) {
+            const alphaPartCurrent = currentVersion.replace(regexNumericPart, '');
+            const alphaPartRequired = requiredVersion.replace(regexNumericPart, '');
+    
+            if (alphaPartCurrent < alphaPartRequired) return false;
+          }
+    
+          return true;
+      }    
+}

package/test/http/HttpProvider.spec.ts

@@ -0,0 +1,35 @@
+/*"Este utilitário deverá ser uma abstração do XMLHttpRequest, deverá ter como métodos publicos (construtor, get, post, put, delete).
+-> Promisse<JSON> get(url);
+-> Promisse<JSON> post(url, JSON);
+-> Promisse<JSON> put(url, JSON);
+-> Promisse<JSON> delete(url);
+Em vários casos pode ser necessário fazer algumas mudanças no comportamento padrão do provider, para isso podemos utilizar o principio do OCP(Open Closed Principle) 
+através da criação de uma interface (IHttpProviderDecorator) que pode ser passada como argumento no construtor de HttpProvider, quando esse objeto existir o HttpProvider 
+irá chama-lo em alguns momentos do cliclo de vida do objeto alguns métodos que podem existir na interface (beforeSend(HttpRequest), afterSend(HttpRequest), onStatateChange(Enum.STATE), resolveBaseUrl() ).
+A ideia é que esse utilitário seja agnostico ao backend, posteriormente podemos criar factory's para cada aplicação, por exemplo, HttpSnkOmFactory, esse factory já entregaria um
+HttpProvider com o IHttpProviderDecorator registrado especificico para o SankhyaOm."*/
+
+// import { HttpProvider } from '../../src/http/HttpProvider';
+// import '../../mock/http/XMLHttpRequest-mock.js'
+
+describe('HttpProvider', () => {
+
+  it('Metodo GET', (async () => {
+
+    // const compareTo = {
+    //   "data": { "A": "B" },
+    //   "dataAsString": "{\"A\":\"B\"}",
+    //   "status": 200,
+    //   "statusText": "OK"
+    // };
+
+    // HttpProvider.get('get')
+    // expect(HttpProvider.get("get")).resolves.toEqual(compareTo);
+    // expect(HttpProvider.post("post", { "AB": "CD" })).resolves.toEqual(expect.objectContaining({ ...compareTo, data: { "AB": "CD" }, dataAsString: "{\"AB\":\"CD\"}" }));
+
+    // /*expect(HttpProvider.put("put")).resolves.toEqual(expect.objectContaining(compareTo));
+
+    // expect(HttpProvider.delete("delete")).resolves.toEqual(expect.objectContaining(compareTo));*/
+
+  }));
+});

package/test/http/SkwHttpProvider.ts.spec.ts

@@ -0,0 +1,34 @@
+/*"Este utilitário deverá ser uma abstração do XMLHttpRequest, deverá ter como métodos publicos (construtor, get, post, put, delete).
+-> Promisse<JSON> get(url);
+-> Promisse<JSON> post(url, JSON);
+-> Promisse<JSON> put(url, JSON);
+-> Promisse<JSON> delete(url);
+Em vários casos pode ser necessário fazer algumas mudanças no comportamento padrão do provider, para isso podemos utilizar o principio do OCP(Open Closed Principle) 
+através da criação de uma interface (IHttpProviderDecorator) que pode ser passada como argumento no construtor de HttpProvider, quando esse objeto existir o HttpProvider 
+irá chama-lo em alguns momentos do cliclo de vida do objeto alguns métodos que podem existir na interface (beforeSend(HttpRequest), afterSend(HttpRequest), onStatateChange(Enum.STATE), resolveBaseUrl() ).
+A ideia é que esse utilitário seja agnostico ao backend, posteriormente podemos criar factory's para cada aplicação, por exemplo, HttpSnkOmFactory, esse factory já entregaria um
+HttpProvider com o IHttpProviderDecorator registrado especificico para o SankhyaOm."*/
+
+// import { HttpProvider } from '../../src/http/HttpProvider';
+
+describe('HttpProvider', () => {
+
+  it('Metodo POST', (async () => {
+
+    // const compareTo = {
+    //   "data": { "A": "B" },
+    //   "dataAsString": "{\"A\":\"B\"}",
+    //   "status": 200,
+    //   "statusText": "OK"
+    // };
+
+    // HttpProvider.get('get')
+    // expect(HttpProvider.get("get")).resolves.toEqual(compareTo);
+    // expect(HttpProvider.post("post", { "AB": "CD" })).resolves.toEqual(expect.objectContaining({ ...compareTo, data: { "AB": "CD" }, dataAsString: "{\"AB\":\"CD\"}" }));
+
+    // /*expect(HttpProvider.put("put")).resolves.toEqual(expect.objectContaining(compareTo));
+
+    // expect(HttpProvider.delete("delete")).resolves.toEqual(expect.objectContaining(compareTo));*/
+
+  }));
+});