Verifica dados básicos da informação, e manda para verificações mais precisas
@param string $dado
327942
private function getDatePart(string $dado)
    {
        $dado = strip_tags(trim($dado));
        if (!empty($dado)) {

            if (!is_numeric($dado)) {
                $this->checkNameHour((string)$dado);

            } else {
                $this->data[$this->checkValueTime($dado)] = (int)$dado;
            }
        }
    }
437482
protected function assertTodo($todo = NULL) {
    if (func_num_args() == 0) {
      $todo = $this->todo;
    }
    
    if ($todo != NULL && !$this->validateTodo($todo)) {
      throw new InvalidTodoException('Todo: '.Code::varInfo($todo).' ist nicht in der todoMap');
    }
  }
775737
private static function checkUnique(Dicionario $d, Meta $m, string $groupUser)
    {
        if ($m->getUnique()) {
            $where = "WHERE {$m->getColumn()} = '{$m->getValue()}'" . (!empty($groupUser) ? " && {$groupUser}" : "");
            $where .= (!empty($d->search(0)->getValue()) ? " && id != " . $d->search("id")->getValue() : "");
            $read = new Read();
            $read->exeRead($d->getEntity(), $where);
            if ($read->getResult())
                $m->setError("Valor já existe, informe outro");
        }
    }
938917
public static function init(PDO $pdo, $options = [])
    {
        DB::init($pdo);
        self::$initOptions = $options;
    }
1094551
private function validateOperator(string $operator)
    {
        if (!in_array($operator, self::VALID_OPERATORS)) {
            throw new \InvalidArgumentException(sprintf(
                '%s is not a valid operator'
            ), $operator);
        }
    }
514856
public function notFound($fnc)
    {
        if (is_callable($fnc)) {
            if ($fnc instanceof \Closure) {
                $this->notFoundModified = $fnc;
            } else {
                $this->addedExceptions['\InvalidArgumentException'] = 'O callable do metodo notFound deve ser um closure!';
            }
        } else {
            $this->addedExceptions['\InvalidArgumentException'] = 'App::notFound, callable invalido';
        }
    }
218647
function signUp()
    {
        if (isset($_POST['data'])
            && trim($_POST['data']) !== '') {
            //Decodificando RSA
            $private = file_get_contents(_CONFIG.'Key/private.key');
            $key = json_decode($_POST['data']);
            $key = base64_decode($key->enc);

            if (!openssl_private_decrypt($key,
                                        $key,
                                        openssl_pkey_get_private($private)
                                        )) {
                Ajax::send(['error'=>'Confira seu Login ou Senha!']); //exit($key);
            }

            $key = json_decode($key);

            //inicializando o usuário => User Singleton Object
            $user = User::this();
            $user->login($key->login, $key->passw);


            //Verificando se o login foi bem sucedido
            if ($user->get('login')) {
                //Gravando o novo Token no BD
                $user->saveToken($key->token);
                $userdata = json_encode(['name'=>$user->get('name'),
                             'id'=>$user->get('id'),
                             'level'=>$user->get('level')]);

                $resumo = (new Model\Xlog)->resumo($user->get('id'));

                //Encriptando o token
                Aes::size(256);
                $key = Aes::enc(json_encode(
                                     ['user'=>$userdata,
                                      'token'=>$key->token,
                                      'resumo'=>$resumo]),
                                      $key->token);

                //Retorna os dados do usuário
                Ajax::send(['error'=>false, 'key'=>$key]);
            }
        }
        //Em casos contrários, retorna erro.
        Ajax::send(['error'=>'Confira seu Login ou Senha!']);
    }
1029269
private function checkNameMonth(string $dado, int $i)
    {
        foreach ($this->meses as $mes) {
            if (in_array($dado, $mes)) {
                $this->setMes(array_search($dado, $mes) + 1, $i);
                break;
            }
        }
    }
336349
protected function loadKey($key)
    {
        // Pegar soh o primeiro key
        $parts = explode('.', $key);
        $first = $parts[0];

        // Verificar se item já foi adicionado
        if (array_key_exists($first, $this->items)) {
            return;
        }

        if (array_key_exists($first, $this->finded)) {
            return;
        }

        $file = config_path(sprintf('%s.php', $first));
        if (file_exists($file)) {
            $this->set($first, require $file);
        }

        $this->finded[$first] = true;
    }
350929
private function execute()
    {
        $this->connect();
        try {
            $this->create->execute($this->dados);
            $this->result = $this->conn->lastInsertId();
        } catch (\PDOException $e) {
            $this->result = null;
            $this->erro = "<b>Erro ao cadastrar: ({$this->tabela})</b> {$e->getMessage()}";
        }

        parent::setDefault();
    }
517803
public function isObfuscatedFile(string $obfuscated_file) : bool
    {
        $contents = \file_get_contents($obfuscated_file);
        if ($contents === false) {
            // não foi possível ler o arquivo
            return false;
        }

        if (empty(preg_match('#<\?php#', $contents)) == false
         && empty(preg_match('#x28#', $contents)) == false
         && empty(preg_match('#x29#', $contents)) == false
         && empty(preg_match('#eval#', $contents)) == false
        ) {
            return true;
        }

        return false;
    }
898368
public function anunciar($mensaje, $tipo = 'error')
    {
        $this->requerirInicio();

        $this->datos['__anuncio']['mensaje'] = $mensaje;
        $this->datos['__anuncio']['tipo'] = $tipo;
    }
1348894
protected function checkMethod(string $method) : string
    {
        $method = mb_strtoupper($method);

        // Verifica se o "method" informado é válido.
        if (!in_array($method, $this->validMethod)) {
            throw new \InvalidArgumentException("Invalid HTTP method [ \"" . $method . "\" ].");
        }

        return $method;
    }
606694
public static function all() : array
    {
        try {

            self::instance();

            $tableStatic = static::$table;

            $stmt        = self::$db->query("SELECT * FROM {$tableStatic}");

            return $stmt->fetchAll(\PDO::FETCH_ASSOC);

        } catch (PDOException $e) {

            $error = new Error();
            $error->errorMessage("Error: não foi possível encontrar os dados. Verifique se os dados estão do banco estão corretos. ".$e->getMessage());

        }
    }
873605
public function validarCpf($cpf)
    {
        $cpf = $this->filtrarSomenteNumeros($cpf);

        // Valida tamanho e caracteres repetidos 00000000000, 11111111111, ..., 99999999999
        if ((strlen($cpf) != 11) || (preg_match('/(\d)\1{10}/', $cpf))) {
            return false;
        }
        
        // Calcula os DVs para verificar se o CPF é verdadeiro
        for ($i = 9; $i < 11; $i++) {
            $j = 0;
            for ($k = 0; $k < $i; $k++) {
                $j += $cpf{$k} * (($i + 1) - $k);
            }
            $j = ((10 * $j) % 11) % 10;
            if ($cpf{$k} != $j) {
                return false;
            }
        }

        return true;
    }
502033
public function configure(PDOInterface $pdo): void
    {
        $sslMode = $pdo->getAttribute(PDO::CRATE_ATTR_SSL_MODE);

        $protocol = $sslMode === PDO::CRATE_ATTR_SSL_MODE_DISABLED ? 'http' : 'https';

        $options = [
            RequestOptions::TIMEOUT         => $pdo->getAttribute(PDO::ATTR_TIMEOUT),
            RequestOptions::CONNECT_TIMEOUT => $pdo->getAttribute(PDO::ATTR_TIMEOUT),
            RequestOptions::AUTH            => $pdo->getAttribute(PDO::CRATE_ATTR_HTTP_BASIC_AUTH) ?: null,
            RequestOptions::HEADERS         => [
                'Default-Schema' => $pdo->getAttribute(PDO::CRATE_ATTR_DEFAULT_SCHEMA),
            ],
        ];

        if ($sslMode === PDO::CRATE_ATTR_SSL_MODE_ENABLED_BUT_WITHOUT_HOST_VERIFICATION) {
            $options['verify'] = false;
        }

        $ca         = $pdo->getAttribute(PDO::CRATE_ATTR_SSL_CA_PATH);
        $caPassword = $pdo->getAttribute(PDO::CRATE_ATTR_SSL_CA_PASSWORD);

        if ($ca) {
            if ($caPassword) {
                $options[RequestOptions::VERIFY] = [$ca, $caPassword];
            } else {
                $options[RequestOptions::VERIFY] = $ca;
            }
        }

        $cert         = $pdo->getAttribute(PDO::CRATE_ATTR_SSL_CERT_PATH);
        $certPassword = $pdo->getAttribute(PDO::CRATE_ATTR_SSL_CERT_PASSWORD);

        if ($cert) {
            if ($certPassword) {
                $options[RequestOptions::CERT] = [$cert, $certPassword];
            } else {
                $options[RequestOptions::CERT] = $cert;
            }
        }

        $key         = $pdo->getAttribute(PDO::CRATE_ATTR_SSL_KEY_PATH);
        $keyPassword = $pdo->getAttribute(PDO::CRATE_ATTR_SSL_KEY_PASSWORD);

        if ($key) {
            if ($keyPassword) {
                $options[RequestOptions::SSL_KEY] = [$key, $keyPassword];
            } else {
                $options[RequestOptions::SSL_KEY] = $key;
            }
        }

        $this->protocol    = $protocol;
        $this->httpOptions = $options;
    }
446344
private function obfuscateDirectoryDeep(string $path_plain, string $path_obfuscated) : bool
    {
        // Lista os arquivos do diretório
        $list = scandir($path_plain);
        if (count($list) == 2) { // '.', '..'
            // se não houverem arquivos, ignora o diretório
            return true;
        }

        // Cria o mesmo diretório para os arquivos ofuscados
        if ($this->makeDir($path_obfuscated) == false) {
            return false;
        }

        foreach ($list as $item) {

            if (in_array($item, ['.', '..']) ) {
                continue;
            }

            $iterate_current_item    = $path_plain . DIRECTORY_SEPARATOR . $item;
            $iterate_obfuscated_item = $path_obfuscated . DIRECTORY_SEPARATOR . $item;

            if (is_link($iterate_current_item)) {

                // LINKS
                // TODO: recriar os links
                $link = readlink($iterate_current_item);
                $this->links[$iterate_current_item] = $link;
                continue;

            } elseif (is_file($iterate_current_item) == true) {

                if ($this->isPhpFilename($iterate_current_item) == true
                 && $this->isNotObfuscateFile($iterate_current_item) == false
                ) {

                    // Arquivos PHP são ofuscados
                    if($this->obfuscateFile($iterate_current_item) == false) {
                        $this->addErrorMessage("Ocorreu um erro ao tentar ofuscar o arquivo: {$iterate_current_item}");
                        return false;
                    }

                    // Salva o arquivo sem a opção de 'auto-contido',
                    // ou seja, ele não pode ser revertido sem os outros arquivos do diretório
                    if ($this->save($iterate_obfuscated_item, false) == false) {
                        $this->addErrorMessage("Ocorreu um erro ao tentar salvar o arquivo ofuscado: {$iterate_obfuscated_item}");
                        return false;
                    }

                } else {

                    // Arquivos "não-PHP" ou arquivos marcados para "não-ofuscar"
                    // são simplesmente copiados
                    if (copy($iterate_current_item, $iterate_obfuscated_item) === false) {
                        $this->addErrorMessage("Arquivo " . $iterate_current_item . " não pôde ser copiado");
                        return false;
                    }
                }

            } elseif (is_dir($iterate_current_item) ) {

                if ($this->obfuscateDirectoryDeep($iterate_current_item, $iterate_obfuscated_item) == false) {
                    return false;
                }
            }
        }

        return true;
    }