keevo-api-services-hcm 0.0.32 → 0.0.33

package/src/lib/services/utilitarios/validators.service.ts

@@ -0,0 +1,293 @@
+import {
+  AbstractControl,
+  FormGroup,
+  ValidationErrors
+} from '@angular/forms';
+
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ValidatorsService {
+  constructor() { }
+
+  public datainicio(control: AbstractControl, formControlNameDateFinal: string, required: boolean = false, formControlNameCampoChave: string = ''): ValidationErrors | null {
+
+    const formGroup = control.parent as FormGroup;
+
+    if (control.value === null || control.value === undefined || control.value === '')
+    {
+      if (required)
+        return { erroMessage: "Campo obrigatório" };
+      else {
+        const dataFim = formGroup?.get(formControlNameDateFinal)?.value;
+        if (dataFim)
+          formGroup?.get(formControlNameDateFinal)?.setValue(null);
+        return null;
+      }
+    }
+
+    const inputValue = control.value;
+    const valorChave = formGroup?.get(formControlNameCampoChave)?.value;
+
+    if (!inputValue)
+      return { erroMessage: 'Data inválida' };
+
+    const dataInicio = new Date(inputValue);
+    dataInicio.setHours(0, 0, 0, 0);
+
+    const dataAtual = new Date();
+    dataAtual.setHours(0, 0, 0, 0);
+
+    return valorChave ? null // Se campo chave tem valor, então é uma edição, portanto não valida data inicial
+                      : dataInicio >= dataAtual ? null : { erroMessage: 'Data deve ser maior ou igual à data atual' };
+  }
+
+  public datafim(control: AbstractControl, formControlNameDateInitial: string, required: boolean = false): { [key: string]: any } | null {
+    if (control.value === null || control.value === undefined || control.value === '')
+    {
+      if (required)
+        return { erroMessage: "Campo obrigatório" }; // Retorna erro de required se o campo estiver vazio
+      else
+        return null;
+    }
+
+    const dataFim = new Date(control.value); // Obter a data e hora do controle
+    const formGroup = control.parent as FormGroup;
+    const dataInicio = formGroup?.get(formControlNameDateInitial)?.value;
+
+    if (!dataInicio) {
+      return { erroMessage: 'Data inicial não informada' }; // Se a data de início não estiver definida, não há como comparar, então retornamos null
+    }
+
+    const dataInicioSemHoras = new Date(new Date(dataInicio).setHours(0, 0, 0, 0)); // Remover as horas da data de início
+    const dataFimSemHoras = new Date(new Date(dataFim).setHours(0, 0, 0, 0)); // Remover as horas da data de fim
+
+    if (dataFimSemHoras > dataInicioSemHoras || dataFim > dataInicio) {
+      return null; // Se a data de fim (com ou sem horas) for maior que a data de início (com ou sem horas), então está tudo certo
+    } else {
+      return { erroMessage: 'A data final é menor que a data de início' };
+    }
+  }
+
+
+  public datainIcioFlag(
+    control: AbstractControl,
+    mensagem: string,
+    flag: string
+  ): ValidationErrors | null {
+    const formGroup = control.parent as FormGroup;
+    const controlFlag: boolean = formGroup?.get(flag)?.value;
+
+    if (controlFlag) {
+      if (
+        control.value === null ||
+        control.value === undefined ||
+        control.value === ''
+      ) {
+        return { erroMessage: "Campo obrigatório" };
+      } else {
+        const dataInicio = new Date(control.value);
+        const dataAtual = new Date();
+
+        // Ajuste para comparar apenas ano, mês e dia
+        const inicioSemHoras = new Date(dataInicio.getFullYear(), dataInicio.getMonth(), dataInicio.getDate());
+        const atualSemHoras = new Date(dataAtual.getFullYear(), dataAtual.getMonth(), dataAtual.getDate());
+
+        if (inicioSemHoras >= atualSemHoras) {
+          return null;
+        } else {
+          return { erroMessage: mensagem };
+        }
+      }
+    } else {
+      return null;
+    }
+  }
+
+
+  public dataFimFlag(
+    control: AbstractControl,
+    nomechave: string,
+    mensagem: string,
+    flag: string
+  ): { [key: string]: any } | null {
+    const formGroup = control.parent as FormGroup;
+    const controlFlag: boolean = formGroup?.get(flag)?.value;
+
+    if (controlFlag) {
+      if (
+        control.value === null ||
+        control.value === undefined ||
+        control.value === ''
+      ) {
+        return { erroMessage: "Campo obrigatório" };
+      } else {
+        const dataFim = new Date(control.value);
+        const dataInicio = formGroup?.get(nomechave)?.value;
+        if (dataFim && dataFim.getTime() > dataInicio.getTime()) {
+          return null;
+        } else {
+          return { erroMessage: mensagem };
+        }
+      }
+    } else {
+      return null;
+    }
+  }
+
+  public requiredCustomMessage(
+    control: AbstractControl,
+    mensagem: string
+  ): { [key: string]: any } | null {
+    if (
+      control.value === null ||
+      control.value === undefined ||
+      control.value === ''
+    ) {
+      return { erroMessage: mensagem };
+    }
+    let valorcampo: any = control.value;
+    if (valorcampo) {
+      return null;
+    } else {
+      return { erroMessage: mensagem };
+    }
+  }
+  public requiredDefautMessage(
+    control: AbstractControl,
+  ): { [key: string]: any } | null {
+    if (
+      control.value === null ||
+      control.value === undefined ||
+      control.value === ''
+    ) {
+      return { erroMessage: "Campo obrigatório" };
+    }
+    let valorcampo: any = control.value;
+    if (valorcampo) {
+      return null;
+    } else {
+      return { erroMessage: "Campo obrigatório" };
+    }
+  }
+  public minlenght(valorminimo: number, mensagem: string) {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (control.value === null || control.value === undefined || control.value === '') {
+        return { erroMessage: 'Campo obrigatório' };
+      }
+      const valorcampo: string = control.value;
+      if (valorcampo.length >= valorminimo) {
+        return null;
+      } else {
+        return { erroMessage: mensagem };
+      }
+    };
+  }
+
+  public conditionalRequired(conditionalFormControlName: string[], message: string = 'Campo obrigatório') {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (control.value === null || control.value === undefined || control.value === '') {
+        // Verifica se algum dos controles listados está preenchido
+        if (conditionalFormControlName.some(name => control.parent?.get(name)?.value)) {
+          return { erroMessage: message }; // Retorna o erro se algum controle estiver preenchido
+        } else {
+          return null; // Não retorna erro se nenhum controle estiver preenchido
+        }
+      }
+      return null; // Retorna null se o campo atual estiver preenchido
+    };
+  }
+
+  public conditionalValueRequired(conditionalFormControlName: string[], value: any, message: string = 'Campo obrigatório') {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (!control.parent) {
+        return null; // Retorna null se não houver um formulário pai
+      }
+
+      // Verifica se algum dos controles especificados possui o valor informado
+      const isAnyControlWithValue = conditionalFormControlName.some(name => {
+        const controlToCheck = control.parent?.get(name);
+        return controlToCheck && controlToCheck.value == value;
+      });
+
+      // Se algum controle tiver o valor informado, o controle atual se torna obrigatório
+      if (isAnyControlWithValue) {
+        // Verifica se o controle atual está vazio
+        if (control.value === null || control.value === undefined || control.value === '') {
+          return { erroMessage: message }; // Retorna o erro de campo obrigatório
+        }
+      }
+
+      return null; // Retorna null se o campo atual estiver preenchido ou a condição não for atendida
+    };
+  }
+
+  public conditionalNotValueRequired(conditionalFormControlName: string[], value: any, message: string = 'Campo obrigatório') {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (!control.parent) {
+        return null; // Retorna null se não houver um formulário pai
+      }
+
+      // Verifica se algum dos controles especificados possui o valor informado
+      const isAnyControlWithValue = conditionalFormControlName.some(name => {
+        const controlToCheck = control.parent?.get(name);
+        return controlToCheck && controlToCheck.value != value;
+      });
+
+      // Se algum controle tiver o valor informado, o controle atual se torna obrigatório
+      if (isAnyControlWithValue) {
+        // Verifica se o controle atual está vazio
+        if (control.value === null || control.value === undefined || control.value === '') {
+          return { erroMessage: message }; // Retorna o erro de campo obrigatório
+        }
+      }
+
+      return null; // Retorna null se o campo atual estiver preenchido ou a condição não for atendida
+    };
+  }
+
+
+  public maxlenght(valormaximo: number, mensagem: string) {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (control.value === null || control.value === undefined || control.value === '') {
+        return { erroMessage: 'Campo obrigatório' };
+      }
+      const valorcampo: string = control.value;
+      if (valorcampo.length <= valormaximo) {
+        return null;
+      } else {
+        return { erroMessage: mensagem };
+      }
+    };
+  }
+
+  public validateFileName(control: AbstractControl): ValidationErrors | null {
+    const fileName = control.value;
+
+    // Regras do Windows para nomes de arquivos
+    const invalidCharsRegex = /[\/\\:*?"<>|]/; // Caracteres especiais não permitidos
+    const endsWithInvalidCharRegex = /[.]$/; // Não pode terminar com um ponto
+    const multipleDotsRegex = /(\.\.)/; // Não pode ter múltiplos pontos seguidos
+
+    if (!fileName || fileName.trim() === '') {
+      return { erroMessage: "Campo obrigatório" };
+    }
+
+    if (invalidCharsRegex.test(fileName)) {
+      return { erroMessage: "Nome de arquivo contém caracteres inválidos" };
+    }
+
+    if (endsWithInvalidCharRegex.test(fileName)) {
+      return { erroMessage: "Nome de arquivo não pode terminar com um ponto" };
+    }
+
+    if (multipleDotsRegex.test(fileName)) {
+      return { erroMessage: "Nome de arquivo não pode conter '..'" };
+    }
+
+    return null; // Retorna null se não houver erro
+  }
+
+}