# Verificando se o E-mail já existe na base de dados:
O código abaixo é um método, pertencente a classe Usuário, que no contexto em que
foi construída, se tratava de uma classe para gerenciar a lógica de login, cadastro
e conteúdo gerado pelo usuário.
O método buscar faz uma consulta no banco de dados, em que ele coletará todos os
dados da tabela usuario, se o E-mail foi igual ao parâmetro nomeado :email
```php
// Método que tem como objetivo verificar se o email informado existe na base de
dados
public function buscar() {
$sql = "SELECT * FROM usuario WHERE email = :email";
try {
$consulta = $this->conexao->prepare($sql);
$consulta->bindParam(":email", $this->email, PDO::PARAM_STR);
$consulta->execute();
$resultado = $consulta->fetch(PDO::FETCH_ASSOC);
} catch (Exception $erro) {
die("Erro: ". $erro->getMessage());
return $resultado;
}
```
Como podemos implementar esse método de busca de um E-mail existente para um
sistema de login ou cadastro?
Abaixo, um código de exemplo:
Nesse código, estamos instaciando uma classe Usuario, e adicionando através de
métodos Setters, os valores coletados do formulário de cadastro, para adicioná-los
aos atributos da classe.
Logo após os setters, existe uma variável $dados, em que está recebendo o método
buscar. Como esse método espera um parâmetro, abaixo, passamos um if validando se:
$dados[’email’] - nesse caso, o email coletado do formulário está sendo passado ao
método buscar para que ele execute a busca condicionada. Caso exista um cadastro
com o mesmo E-mail que o coletado pelo POST, ele fará um redirecionamento com o
informativo de que o email existe, impedindo que haja um novo cadastro. Caso não
exista, ele continuará prosseguindo com o cadastro:
```php
$usuario = new Usuario;
$usuario->setNome($_POST['nome']);
$usuario->setEmail($_POST['email']);
$dados = $usuario->buscar();
if($dados['email'] === $_POST['email']) {
header('location:[Link]?email_existente');
} else {
$verificaSenha = Utilitarios::senhaValida($_POST['senha']);
if($verificaSenha) {
$usuario->setSenha($usuario->codificaSenha($_POST['senha']) );
$usuario->cadastrar();
header('location:.php?email=' . $_POST['email']);
} else if (!$verificaSenha) {
header('location:[Link]?formato_de_senha_inválido');
}
```
Perceba que existe um tratamento especial no valor de senha que é adicionado na
variável verificaSenha. Isso ocorre porque ela passa por um método senhaValida, que
faz parte de uma classe Abstrata chamada Utilitarios. Esse método senhaValida,
possui o objetivo de verificar se a senha está nos padrões corretos definidos. E,
se sim, ela retornará um valor true. Se não, retornará um valor false.
---
o Código que verifica a validade da senha no método senhaValida é um Regexp.
```php
public static function senhaValida($senha) {
return preg_match('/[a-z]/', $senha) // tem pelo menos uma letra minúscula
&& preg_match('/[A-Z]/', $senha) // tem pelo menos uma letra maiúscula
&& preg_match('/[0-9]/', $senha) // tem pelo menos um número
&& preg_match('/^[\w$@#%&!]{8,}$/', $senha); // tem ou mais caracteres
}
```
---
Se o resultado de $verificaSenha for igual a true, o valor de senha será adicionado
no setter senha:
`$usuario->setSenha($usuario->codificaSenha($_POST['senha']) );`
Perceba que, não estamos adicionando o valor de Senha diretamente ao setter, mas
sim, um método codificaSenha. Esse método será responsável por criptografar a senha
coletada do formulário e, apenas depois de criptografada, será adicionada ao
atributo pelo setter.
Como foi construído o método de codificaSenha dentro da classe usuario:
O método abaixo usa uma função pronta do PHP, para criptografia. O password_hash
cria um hash de aproximadamente 64 caracteres, dinâmicos. Por isso, é o mais
recomendável atualmente para criptografia de senha no PHP.
``
```php
public function codificaSenha(string $senha):string {
return password_hash($senha, PASSWORD_DEFAULT);
}
```
Se todos os requisitos forem atendidos, os atributos serão cadastrados na base de
dados com a linha: $usuario→cadastrar(); do segundo exemplo.
O código do método cadastrar que está presente na classe Usuarío é o seguinte:
```php
//método para cadastro de usuários no banco
public function cadastrar():void {
$sql = "INSERT INTO usuario(nome, email, senha)
VALUES(:nome, :email, :senha)";
try {
$consulta = $this->conexao->prepare($sql);
$consulta->bindParam(":nome", $this->nome, PDO::PARAM_STR);
$consulta->bindParam(":email", $this->email, PDO::PARAM_STR);
$consulta->bindParam(":senha", $this->senha, PDO::PARAM_STR);
$consulta->execute();
} catch (Exception $erro) {
die("Erro: ". $erro->getMessage());
}
```
---
# Limpeza de dados:
É uma boa prática realizar a limpeza de dados. No código acima, foi passado
diretamente para os setters de E-mail, Nome e Senha, o array superglobal POST, com
os dados da forma que foram inseridos pelo formulário.
O processo de limpeza, deixamos que seja feito internamente aos métodos setters.
Exemplo:
A função especial filter_var, possui a responsabilidade de garantir, que seja
enviado um tipo de dado correto para os atributos email, senha e nome nesse
contexto.
passamos internamente a função, o parâmetro que será analisado e, o tipo de limpeza
que gostariámos de garantir.
*SPECIAL_CHARS é utilizado para garantirmos que o valor enviado seja uma STRING.
Nesse caso, mesmo que o usuário tente injetar um script, esse script será
convertido em uma STRING.
```php
public function setEmail($email)
$this->email = filter_var($email, FILTER_SANITIZE_EMAIL);
public function setSenha($senha)
$this->senha = filter_var($senha, FILTER_SANITIZE_SPECIAL_CHARS);
public function setNome($nome)
$this->nome = filter_var($nome, FILTER_SANITIZE_SPECIAL_CHARS);
}
```
---