222 lines
8.2 KiB
PHP
222 lines
8.2 KiB
PHP
<?php
|
|
namespace Workbloom\Helpers;
|
|
|
|
class DataValidator {
|
|
private array $inputs;
|
|
private array $errors = [];
|
|
|
|
public function __construct(array $inputs) {
|
|
$this->inputs = $inputs;
|
|
}
|
|
|
|
/**
|
|
* Valida um campo usando uma regra específica.
|
|
*/
|
|
public function validate(string $field, callable|string $rule, string $message = '', array $additionalParams = []): static {
|
|
$value = $this->inputs[$field] ?? null;
|
|
|
|
// Se for string, monta callable usando a própria classe
|
|
if (is_string(value: $rule) && method_exists(object_or_class: self::class, method: $rule)) {
|
|
$rule = [self::class, $rule];
|
|
}
|
|
|
|
$params = array_merge([$value], $additionalParams);
|
|
|
|
$result = call_user_func_array(callback: $rule, args: $params);
|
|
|
|
// Caso seja validação de senha (retorna array)
|
|
if (is_array(value: $result) && isset($result['valid'])) {
|
|
if (!$result['valid']) {
|
|
$this->errors[$field] = [
|
|
'status' => 'is_invalid',
|
|
'message' => $result['errors']
|
|
];
|
|
}
|
|
}
|
|
// Para outras validações booleanas
|
|
elseif ($result === false) {
|
|
$this->errors[$field] = [
|
|
'status' => 'is_invalid',
|
|
'message' => $message
|
|
];
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getErrors(): array {
|
|
return $this->errors;
|
|
}
|
|
|
|
public function passes(): bool {
|
|
return empty($this->errors);
|
|
}
|
|
|
|
// ---------- Regras comuns ----------
|
|
|
|
public static function validateEmail(string $value): bool {
|
|
return (bool) filter_var(value: $value, filter: FILTER_VALIDATE_EMAIL);
|
|
}
|
|
|
|
public static function validatePhone(string $value, int $minLength = 10, int $maxLength = 13): bool {
|
|
$digits = preg_replace(pattern: '/\D+/', replacement: '', subject: $value);
|
|
$len = strlen(string: $digits);
|
|
return $len >= $minLength && $len <= $maxLength;
|
|
}
|
|
|
|
public static function validateCpf(string $value): bool {
|
|
$cpf = preg_replace(pattern: '/\D+/', replacement: '', subject: $value);
|
|
|
|
if (strlen(string: $cpf) !== 11 || preg_match(pattern: '/(\d)\1{10}/', subject: $cpf)) {
|
|
return false;
|
|
}
|
|
|
|
for ($t = 9; $t < 11; $t++) {
|
|
$d = 0;
|
|
for ($c = 0; $c < $t; $c++) {
|
|
$d += $cpf[$c] * (($t + 1) - $c);
|
|
}
|
|
$d = ((10 * $d) % 11) % 10;
|
|
if ($cpf[$c] != $d) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static function validateCnpj(string $value): bool {
|
|
// Remove qualquer máscara (pontos, barras, hífens)
|
|
$cleanedValue = preg_replace(pattern: '/[.\-\/]/', replacement: '', subject: $value);
|
|
|
|
// O CNPJ sem máscara deve ter 14 caracteres (12 alfanuméricos + 2 dígitos)
|
|
if (strlen(string: $cleanedValue) !== 14) {
|
|
return false;
|
|
}
|
|
|
|
$cnpjBase = strtoupper(string: substr(string: $cleanedValue, offset: 0, length: 12)); // Os 12 caracteres alfanuméricos
|
|
$dvRecebidos = substr(string: $cleanedValue, offset: 12, length: 2); // Os 2 dígitos verificadores
|
|
|
|
// Verifica se os dois últimos caracteres são realmente dígitos
|
|
if (!ctype_digit(text: $dvRecebidos)) {
|
|
return false;
|
|
}
|
|
|
|
// Mapeamento de Valor para cálculo do DV (do documento) [cite: 19]
|
|
$mapaValores = [
|
|
'0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9,
|
|
'A' => 17, 'B' => 18, 'C' => 19, 'D' => 20, 'E' => 21, 'F' => 22, 'G' => 23, 'H' => 24, 'I' => 25,
|
|
'J' => 26, 'K' => 27, 'L' => 28, 'M' => 29, 'N' => 30, 'O' => 31, 'P' => 32, 'Q' => 33, 'R' => 34,
|
|
'S' => 35, 'T' => 36, 'U' => 37, 'V' => 38, 'W' => 39, 'X' => 40, 'Y' => 41, 'Z' => 42
|
|
];
|
|
|
|
// Array de pesos de 2 a 9 (repetidos da direita para a esquerda, recomeçando depois do 8º caracter) [cite: 26, 27]
|
|
// O documento usa [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] para o 1º DV no exemplo de 12 caracteres [cite: 27]
|
|
$pesos1Dv = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
|
|
|
|
// Para o 2º DV, são 13 caracteres (os 12 de base + o 1º DV), e a contagem de pesos recomeça (2 a 9)
|
|
// O documento usa [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] para 13 caracteres no exemplo [cite: 40]
|
|
$pesos2Dv = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
|
|
|
|
$cnpjParaCalculo = $cnpjBase;
|
|
|
|
for ($i = 0; $i < 2; $i++) {
|
|
$soma = 0;
|
|
$pesos = ($i === 0) ? $pesos1Dv : $pesos2Dv;
|
|
$tamanho = strlen(string: $cnpjParaCalculo);
|
|
|
|
// O documento usa os pesos na ordem da esquerda para a direita no cálculo [cite: 27, 40]
|
|
for ($j = 0; $j < $tamanho; $j++) {
|
|
$caractere = $cnpjParaCalculo[$j];
|
|
$valor = $mapaValores[$caractere] ?? null;
|
|
|
|
// Se o caractere não for um dos mapeados (ex: um caractere especial ou minúsculo que não foi maiusculizado)
|
|
if ($valor === null) {
|
|
return false;
|
|
}
|
|
|
|
$peso = $pesos[$j];
|
|
$soma += $valor * $peso;
|
|
}
|
|
|
|
// Obter o resto da divisão do somatório por 11 [cite: 31]
|
|
$resto = $soma % 11;
|
|
|
|
// Se o resto da divisão for igual a 1 ou 0, o primeiro dígito será igual a 0 (zero)[cite: 32].
|
|
// Senão, o primeiro dígito será igual ao resultado de 11 - resto[cite: 33].
|
|
$digitoCalculado = ($resto < 2) ? 0 : 11 - $resto;
|
|
|
|
$dvRecebido = (int) $dvRecebidos[$i];
|
|
|
|
if ($dvRecebido !== $digitoCalculado) {
|
|
return false;
|
|
}
|
|
|
|
// Para o cálculo do segundo DV, acrescentar o primeiro DV (calculado) ao final do CNPJ base [cite: 38]
|
|
if ($i === 0) {
|
|
$cnpjParaCalculo .= $digitoCalculado;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function notEmpty(mixed $value): bool {
|
|
if (is_array(value: $value)) {
|
|
return !empty(array_filter(array: $value, callback: fn($v) => $v !== null && $v !== ''));
|
|
}
|
|
return !empty(trim(string: (string) $value));
|
|
}
|
|
|
|
public static function validatePassword(string $password, array $rules = []): array {
|
|
$errors = [];
|
|
|
|
$minLength = $rules['minLength'] ?? 8;
|
|
$maxLength = $rules['maxLength'] ?? 64;
|
|
$requireUpper = $rules['upper'] ?? true;
|
|
$requireLower = $rules['lower'] ?? true;
|
|
$requireDigit = $rules['digit'] ?? true;
|
|
$requireSymbol = $rules['symbol'] ?? true;
|
|
|
|
if (strlen(string: $password) < $minLength) {
|
|
$errors[] = "Senha deve ter no mínimo {$minLength} caracteres.";
|
|
}
|
|
|
|
if (strlen(string: $password) > $maxLength) {
|
|
$errors[] = "Senha deve ter no máximo {$maxLength} caracteres.";
|
|
}
|
|
|
|
if ($requireUpper && !preg_match(pattern: '/[A-Z]/', subject: $password)) {
|
|
$errors[] = "Senha deve conter pelo menos uma letra maiúscula.";
|
|
}
|
|
|
|
if ($requireLower && !preg_match(pattern: '/[a-z]/', subject: $password)) {
|
|
$errors[] = "Senha deve conter pelo menos uma letra minúscula.";
|
|
}
|
|
|
|
if ($requireDigit && !preg_match(pattern: '/\d/', subject: $password)) {
|
|
$errors[] = "Senha deve conter pelo menos um número.";
|
|
}
|
|
|
|
if ($requireSymbol && !preg_match(pattern: '/[\W_]/', subject: $password)) {
|
|
$errors[] = "Senha deve conter pelo menos um símbolo.";
|
|
}
|
|
|
|
return [
|
|
'valid' => empty($errors),
|
|
'errors' => $errors
|
|
];
|
|
}
|
|
|
|
public static function validateList(mixed $value, array $validOptions): bool {
|
|
if (is_array(value: $value)) {
|
|
foreach ($value as $item) {
|
|
if (!in_array(needle: $item, haystack: $validOptions, strict: true)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return in_array(needle: $value, haystack: $validOptions, strict: true);
|
|
}
|
|
} |