ngx-sp-infra 0.0.0

package/projects/ngx-sp-infra/src/lib/message/message.service.ts

@@ -0,0 +1,169 @@
+import { Injectable, TemplateRef } from '@angular/core';
+import { take } from 'rxjs/operators';
+
+import { Observable } from 'rxjs';
+
+import { BsModalRef, BsModalService, ModalOptions } from 'ngx-bootstrap/modal';
+
+import { alertIds, alertTypes } from './message-enum';
+import { AlertComponent } from './alert/alert.component';
+import { ConfirmComponent } from './confirm/confirm.component';
+import { SaveComponent } from './save/save.component';
+
+@Injectable(
+  { providedIn: 'root' }
+)
+export class MessageService {
+  constructor(private bsModalService: BsModalService) { }
+
+  // Exibe uma mesagem conforme o tipo (privado)
+  private showAlert(
+    message: string,
+    type: alertTypes,
+    dismissTimeout?: number,
+    id?: number | undefined
+  ) {
+    const initialState: any = {
+      message: message,
+      type: type,
+    };
+
+    const bsModalRef: BsModalRef = this.bsModalService.show(AlertComponent, {
+      initialState, class: 'modal-md', id: id
+    });
+
+    if (dismissTimeout) {
+      setTimeout(() => bsModalRef.hide(), dismissTimeout);
+    }
+  }
+
+  // Exibe uma mensagem do tipo danger
+  showAlertDanger(message: string) {
+    this.showAlert(message, alertTypes.DANGER, 0, alertIds.DANGER);
+  }
+
+  // Exibe uma mesagem do tipo success
+  showAlertSuccess(message: string) {
+    this.showAlert(message, alertTypes.SUCCESS, 3000, alertIds.SUCCESS);
+  }
+
+  // Exibe uma mesagem do tipo info
+  showAlertInfo(message: string) {
+    this.showAlert(message, alertTypes.INFO, 3000, alertIds.INFO);
+  }
+  // Exibe uma mesagem do tipo primary(
+  showAlertPrimary(message: string) {
+    this.showAlert(message, alertTypes.PRIMARY, 3000, alertIds.PRIMARY);
+  }
+
+  // Exibe uma mesagem do tipo secondary(
+  showAlertSecondary(message: string) {
+    this.showAlert(message, alertTypes.SECONDARY, 3000, alertIds.SECONDARY);
+  }
+  // Exibe uma mesagem do tipo warning
+  showAlertWarning(message: string) {
+    this.showAlert(message, alertTypes.WARNING, 0, alertIds.WARNING);
+  }
+
+  // Exibe uma mesagem do tipo light
+  showAlertLight(message: string) {
+    this.showAlert(message, alertTypes.LIGHT, 0, alertIds.LIGHT);
+  }
+
+  // Exibe uma mesagem do tipo dark
+  showAlertDark(message: string) {
+    this.showAlert(message, alertTypes.DARK, 0, alertIds.DARK);
+  }
+  // Exibe um modal de inserção no banco
+  showCreate(
+    title: string,
+    message: string,
+    okText: string,
+    cancelText: string,
+    okButton: Function,
+    fields: string[],
+  ): Observable<boolean> {
+    if (!okText) {
+      okText = 'Criar';
+    }
+
+    if (!okButton) {
+    }
+    const initialState: any = {
+      title: title,
+      message: message,
+      fields: fields,
+      okText: okText,
+      cancelText: cancelText,
+      okButton: okButton,
+    };
+    const bsModalRef: BsModalRef = this.bsModalService.show(SaveComponent, {
+      initialState,
+    });
+
+    return (<SaveComponent>bsModalRef.content).confirmResult
+      .asObservable()
+      .pipe(take(1));
+  }
+
+  // Exibe uma mesagem do tipo confirmação
+  showConfirm(
+    title: string,
+    message: string,
+    okText?: string,
+    cancelText?: string,
+    okButton?: Function,
+    paramatroOkButton?: boolean
+  ): Observable<'confirmado' | 'cancelado'> {
+    if (!okText) {
+      okText = 'Sim';
+    }
+
+    if (!cancelText) {
+      cancelText = 'Cancelar';
+    }
+
+    if (!okButton) {
+    }
+
+    const initialState: any = {
+      title: title,
+      message: message,
+      okText: okText,
+      cancelText: cancelText,
+      okButton: okButton,
+      parametroOkButton: paramatroOkButton,
+    };
+
+    const bsModalRef: BsModalRef = this.bsModalService.show(ConfirmComponent, {
+      initialState,
+    });
+
+    return ((<ConfirmComponent>bsModalRef.content)).confirmResult
+      .asObservable()
+      .pipe(take(1));
+  }
+
+  /**
+   * Utilize este método para mostrar na tela um modal que não tem fundo branco, bordas e 
+   * backdrop (no quesito sair do modal)
+   * 
+   * O modal também vai estar centralizado no meio da tela (verticalmente e horizontalmente).
+   * @param elemento Elemento a ser mostrado na tela.
+   * @param id Id especifico a este modal. Opcional.
+   * @returns Referencia ao modal mostrado na tela.
+   */
+  showModalLoading(elemento: TemplateRef<any> | (new (...args: any[]) => unknown), elemID?: string | number, initialState?: Partial<unknown>): BsModalRef {
+
+    let options: ModalOptions = {
+      id: elemID,
+      class: "modal-dialog-centered justify-content-center modal-hide-background",
+      backdrop: true,
+      ignoreBackdropClick: true,
+      animated: false,
+      initialState: initialState
+    } as ModalOptions;
+
+    return this.bsModalService.show(elemento, options);
+  }
+}

package/projects/ngx-sp-infra/src/lib/message/save/save.component.html

@@ -0,0 +1,35 @@
+<div class="modal-content ">
+  <div class="modal-header">
+      <h4 class="modal-title">{{ title }}</h4>
+      <button type="button" class="close" data-bs-dismiss="modal" aria-label="Close" (click)="closeConfirm()">
+          <span aria-hidden="true">&times;</span>
+      </button>
+  </div>
+  <div class="modal-body">
+      <h4>{{ message }}</h4>
+
+    <div class="body-config ">
+      <form>
+        <fieldset>
+          <legend> dados </legend>
+
+          <div class="input-config" *ngFor="let field of fields ; let i = index" >
+            <form>
+              <div class="input-group">
+                <input type="text" required>
+                <span class="highlight"></span>
+                <span class="bar"></span>
+                <label>{{field}}</label>
+              </div>
+            </form>
+          </div>
+        </fieldset>
+      </form>
+    </div>
+
+  </div>
+  <div class="modal-footer">
+      <button type="button" class="btn btn-primary" (click)="confirm()">{{okText}}</button>
+      <button type="button" class="btn btn-secondary" data-bs-dismiss="modal" (click)="closeConfirm()">{{ cancelText }}</button>
+  </div>
+</div>

package/projects/ngx-sp-infra/src/lib/message/save/save.component.scss

@@ -0,0 +1,110 @@
+.input-config{
+padding: 10px;
+}
+.body-config{
+padding-top: 15px;
+padding-bottom: 20px ;
+
+}
+
+.input-group {
+    position: relative;
+    margin: 40px 0 20px;
+  }
+
+  input {
+    font-size: 18px;
+    padding: 10px 10px 10px 5px;
+    display: block;
+    width: 300px;
+    border: none;
+    border-bottom: 1px solid #757575;
+  }
+
+  input:focus {
+    outline: none;
+  }
+
+  label {
+    color: #999;
+    font-size: 18px;
+    font-weight: normal;
+    position: absolute;
+    pointer-events: none;
+    left: 5px;
+    top: 10px;
+    transition: 0.2s ease all;
+    -moz-transition: 0.2s ease all;
+    -webkit-transition: 0.2s ease all;
+  }
+
+  input:focus ~ label,
+  input:valid ~ label {
+    top: -20px;
+    font-size: 14px;
+    color: #5B7CFD;
+  }
+
+  .bar {
+    position: relative;
+    display:block;
+    width:315px;
+  }
+
+  .bar:before,
+  .bar:after {
+    content: '';
+    height: 2px;
+    width: 0;
+    bottom: 0;
+    position: absolute;
+    background: #5B7CFD;
+    transition: 0.2s ease all;
+    -moz-transition: 0.2s ease all;
+    -webkit-transition: 0.2s ease all;
+  }
+
+  .bar:before {
+    left: 50%;
+  }
+
+  .bar:after {
+    right: 50%;
+  }
+
+  input:focus ~ .bar:before,
+  input:focus ~ .bar:after {
+    width: 50%;
+  }
+
+  .highlight {
+    position: absolute;
+    height: 60%;
+    width: 100px;
+    top: 25%;
+    left: 0;
+    pointer-events: none;
+    opacity: 0.5;
+  }
+
+  input:focus ~ .highlight {
+    -webkit-animation: inputHighlighter 0.3s ease;
+    -moz-animation: inputHighlighter 0.3s ease;
+    animation: inputHighlighter 0.3s ease;
+  }
+
+  /* animations */
+  @-webkit-keyframes inputHighlighter {
+    from { background: #4285f4; }
+    to   { width: 0; background: transparent; }
+  }
+  @-moz-keyframes inputHighlighter {
+    from { background: #4285f4; }
+    to   { width: 0; background: transparent; }
+  }
+  @keyframes inputHighlighter {
+    from { background: #4285f4; }
+    to   { width: 0; background: transparent; }
+  }
+
+  

package/projects/ngx-sp-infra/src/lib/message/save/save.component.ts

@@ -0,0 +1,44 @@
+import { Component, Input, OnInit } from '@angular/core';
+
+import { Subject } from 'rxjs';
+
+import { BsModalRef } from 'ngx-bootstrap/modal';
+
+@Component({
+  selector: 'app-save',
+  templateUrl: './save.component.html',
+  styleUrls: ['./save.component.scss'],
+})
+export class SaveComponent implements OnInit {
+  @Input() title: string;
+  @Input() message: string;
+  @Input() cancelText: string = 'Cancelar';
+  @Input() okText: string = 'Sim';
+  @Input() okButton: Function;
+  @Input() fields: string[];
+
+  confirmResult: Subject<boolean>;
+
+  constructor(public bsModalRef: BsModalRef) {}
+
+  ngOnInit(): void {
+    this.confirmResult = new Subject();
+  }
+
+  confirm() {
+  
+
+    this.okButton({Id: 15});
+    this.confirmAndClose(true);
+  }
+
+  closeConfirm() {
+    this.confirmAndClose(false);
+  }
+
+  private confirmAndClose(value: boolean) {
+    this.confirmResult.next(value);
+
+    this.bsModalRef.hide();
+  }
+}

package/projects/ngx-sp-infra/src/lib/models/DownloadArquivos.ts

@@ -0,0 +1,12 @@
+export class DownloadArquivos{
+    Error: boolean;
+    ErrorMessage: string;
+    FileName: string;
+    File: string;
+}
+
+export interface DownloadArq{
+    Error: boolean;
+    ErrorMessage: string;
+    DownloadArquivos: DownloadArquivos;
+}

package/projects/ngx-sp-infra/src/lib/models/email-model.ts

@@ -0,0 +1,33 @@
+/**
+ * Modelo de dados para envio de e-mails
+ */
+export class EmailModel {
+  public tipoEmail: number = 0;
+  public moduloID: number = 0;
+  public moduloNome: string = "";
+  public adressFrom: string = "";
+  public remetenteNome: string = "";
+  public adressTo: string = "";
+  public adressesCC: string = "";
+  public assuntoEmail: string = "";
+  public tituloEmail: string = "";
+  public corpoEmail: string = "";
+  public htmlLinks: string | null = "";
+  public anexosList: EmailAnexoRecord[] = [];
+  public estabelecimentoID: string | null = "";
+  public emailHomologacao: string | null = "";
+}
+
+/**
+ * Modelo de dados para anexos de e-mail
+ */
+export class EmailAnexoRecord {
+  /** Base64 do arquivo */
+  public File: string = "";
+
+  /** Nome do arquivo com sua extensão */
+  public FileName: string = "";
+
+  /** Tipo do conteúdo do arquivo */
+  public ContentType: string = "";
+}

package/projects/ngx-sp-infra/src/lib/models/ierror.ts

@@ -0,0 +1,4 @@
+export interface IError {
+    Error: boolean,
+    ErrorMessage: string
+}

package/projects/ngx-sp-infra/src/lib/models/ipagination.ts

@@ -0,0 +1,5 @@
+export interface IPagination {
+    Page: number,
+    ElemsPerPage: number,
+    TotalPages: number,
+}

package/projects/ngx-sp-infra/src/lib/models/report-file.ts

@@ -0,0 +1,4 @@
+export class ReportFile {
+    ReportName: string = '';
+    ReportBase64: string = '';
+}

package/projects/ngx-sp-infra/src/lib/models/ret-error.ts

@@ -0,0 +1,6 @@
+import { IError } from "./ierror";
+
+export class RetError implements IError {
+    Error: boolean;
+    ErrorMessage: string;
+}

package/projects/ngx-sp-infra/src/lib/models/ret-feedback-message.ts

@@ -0,0 +1,8 @@
+import { IError } from "./ierror";
+
+/** Usada para um retorno simples que possua apenas uma mensagem de feedback */
+export class RetFeedbackMessage implements IError {
+  Error: boolean;
+  ErrorMessage: string;
+  FeedbackMessage: string = "";
+}

package/projects/ngx-sp-infra/src/lib/models/ret-report-file.ts

@@ -0,0 +1,8 @@
+import { IError } from "./ierror";
+import { ReportFile } from "./report-file";
+
+export class RetReportFile implements IError {
+    Error: boolean;
+    ErrorMessage: string;
+    ReportFile: ReportFile;
+}

package/projects/ngx-sp-infra/src/lib/pipes/cpf-cnpj.pipe.ts

@@ -0,0 +1,21 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'cpfCnpj'
+})
+export class CpfCnpjPipe implements PipeTransform {
+
+  public transform(value: string): string {
+    
+    if (value.length == 11) {
+      return `${value.substring(0, 3)}.${value.substring(3, 6)}.${value.substring(6, 9)}-${value.substring(9)}`;
+    }
+
+    else if (value.length == 14) {
+      return `${value.substring(0, 2)}.${value.substring(2, 5)}.${value.substring(5, 8)}/${value.substring(8, 12)}-${value.substring(12)}`;
+    }
+
+    else return value;
+  }
+
+}

package/projects/ngx-sp-infra/src/lib/pipes/currency.pipe.ts

@@ -0,0 +1,13 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'currencyBRL'
+})
+export class CurrencyPipe implements PipeTransform {
+
+  public transform(value: number): string {
+    
+    return `R$ ${value.toFixed(2).toString().replace('.', ',')}`;
+  }
+
+}

package/projects/ngx-sp-infra/src/lib/pipes/to-url.pipe.ts

@@ -0,0 +1,33 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
+
+/**
+ * @description
+ * Transforma um Blob ou MediaSource em uma URL para ser utilizada em imagens.
+ * 
+ * Ela aceita valors não definidos em casos onde o valor vai ser trazido em outro momento.
+ */
+@Pipe(
+  { name: 'toUrl' }
+)
+export class ToUrlPipe implements PipeTransform {
+
+  constructor(
+    private sanitizer: DomSanitizer
+  ) {}
+
+  transform(value: Blob | MediaSource | undefined, ...args: unknown[]): SafeUrl {
+
+    if (value) {
+      let url: string = URL.createObjectURL(value);
+      // Devemos dizer que a URL passada é segura e pode ser usada.
+      // Se não limpada a url vai estar da seguinte forma: [unsafe][blob] ao invés de [blob]
+      let safeUrl: SafeUrl = this.sanitizer.bypassSecurityTrustUrl(url);
+      return safeUrl;
+    }
+
+    // Se não estiver definida, retorna nada.
+    return "";
+  }
+
+}

package/projects/ngx-sp-infra/src/lib/utils/check-url-and-method.service.ts

@@ -0,0 +1,84 @@
+import { Injectable } from '@angular/core';
+
+/**
+ * @description
+ *
+ * Auxilia na injeção de dados de autenticação em endpoints que necessitam de tal ação.
+ */
+@Injectable(
+  { providedIn: 'root' }
+)
+export class CheckUrlAndMethodService {
+
+  constructor() { }
+
+  /**
+   * @description
+   *
+   * Verifica se a url da requisição precisa ou não ser autenticada.
+   *
+   * É utilizado REGEX para a formatação.
+   *
+   * @param url URL da requisição que está sendo enviada ou que foi recebida.
+   * @param method Método da requisição.
+   * @param urls Urls e métodos atrelados aos endpoints.
+   * @returns Verdadeiro se deve ser autenticado e falso se não deve.
+   */
+  needsAuthRequest(url: string, method: string, urls: Map<string, string[]>): boolean {
+    // Adiciona a URL uma barra no final para fazer match.
+    let urlToBeVerified = url;
+    
+    // TODO: Remover redundância de / nas URLs.
+    let lastUrlChar = urlToBeVerified.charAt(urlToBeVerified.length - 1);
+
+    if (lastUrlChar !== "/") {
+      urlToBeVerified += "/";
+    }
+
+    let urlsToVerify: IterableIterator<string> = urls.keys();
+
+    for(let urlToVerify of urlsToVerify) {
+      let regexString: string = `${ this.sanitizeForRegex(urlToVerify) }`;
+
+      // Faz com que o caractere * fique com um ponto para pegar qualquer caractere no regex.
+      regexString = regexString.replace("*", ".*");
+
+      let regexMatch: RegExpMatchArray | null =  urlToBeVerified.match(regexString);
+
+      // Verifica se a url da match no regex construído a partir da url a ser autenticada.
+      if (regexMatch && regexMatch.length === 1) {
+
+        // Verifica se o método da ação necessita de autenticação.
+        for(let methodAux of urls.get(urlToVerify)!) {
+          methodAux = methodAux.replace("*", ".*");
+
+          let regexMatchedMethod: RegExpMatchArray | null = method.match(methodAux);
+
+          if (regexMatchedMethod && regexMatchedMethod.length === 1) {
+            return true;
+          }
+
+        }
+
+      }
+
+    }
+
+    return false;
+  }
+
+  /**
+   * @description
+   *
+   * Insere caracteres de escape em palavras chaves de um regex.
+   *
+   * pego de https://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex
+   *
+   * @param unsanitizedString String a ser "limpada".
+   * @returns String limpa para uso em regex.
+   */
+  private sanitizeForRegex(unsanitizedString: string): string {
+    return unsanitizedString.replace(/[.+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+  }
+
+}

package/projects/ngx-sp-infra/src/lib/utils/form-utils.ts

@@ -0,0 +1,50 @@
+import { AbstractControl, NgControl, UntypedFormGroup, UntypedFormArray } from '@angular/forms';
+
+export class FormUtils {
+
+  // Verifica se um campo é inválido (Template Driven)
+  static isInvalidFieldTemplate(control: NgControl): boolean {
+    const ret: any = !control.valid && (control.dirty || control.touched);
+  
+    return (ret ? ret : false)
+  }
+  
+  // Verifica se um campo é inválido (Data Driven)
+  static isInvalidField(control: AbstractControl | null): boolean {
+    return (control ? !control.valid && (control.dirty || control.touched) : false);
+  }
+
+  // Valida todos os campos do formulário
+  static validateFields(formGroup: UntypedFormGroup | UntypedFormArray): void {
+    Object.keys(formGroup.controls).forEach(field => {
+      const control = formGroup.get(field);
+  
+      control?.markAsDirty();
+      control?.markAsTouched();
+      
+      if (control instanceof UntypedFormGroup || control instanceof UntypedFormArray) {
+        this.validateFields(control);
+      }
+  
+    });
+  
+  }     
+      
+  // Obtém a mensagem de erro conforme o validador utilizado
+  static getErrorMessage(fieldName: string, validatorName: string, validatorValue?: any): string {
+            
+    const config : any = {
+      'required': `${fieldName} é obrigatório.`,
+      'minlength': `${fieldName} precisa ter no mínimo ${validatorValue.requiredLength} caracteres.`,
+      'maxlength': `${fieldName} precisa ter no máximo ${validatorValue.requiredLength} caracteres.`,
+      'min': `${fieldName} precisam ser no mínimo ${validatorValue.min}.`,
+      'max': `${fieldName} podem ser no máximo ${validatorValue.max}.`,
+      'cpcnpjInvalid': `${fieldName} é inválido.`,
+      'cpcnpjInvalidDigit': `${fieldName} com digito inválido.`,
+      'incorrect': `O valor de ${fieldName} é inválido.`,
+    };
+
+    return (config[validatorName] ? config[validatorName] : `${validatorName} não implementado`);
+  }
+
+}

package/projects/ngx-sp-infra/src/lib/utils/ip-service.service.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+
+import { take } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class IpServiceService {
+
+  constructor( private _httpClient: HttpClient ) { }
+
+  getIPAddress(): any 
+  {  
+    return this._httpClient.get("http://api.ipify.org/?format=json")
+      .pipe(
+        take(1)
+      );
+
+  }
+
+}