Middleware no Laravel age como um intermediário que gerencia as solicitações feitas em seu site. Em vez de ir diretamente para onde as coisas acontecem (o controller), a solicitação passa primeiro por esse Middleware. Em termos mais simples, é como uma verificação rápida que acontece antes da sua solicitação chegar ao destino final.

Pense na sua solicitação como um pacote que precisa ser entregue. O Middleware é como um ponto de controle que verifica se o pacote está em conformidade com algumas regras antes de ser processado. Essas regras podem incluir coisas como verificar se você está autenticado, se tem permissão para acessar determinadas áreas e assim por diante.

Como o Middleware se encaixa no fluxo de requisição HTTP:

Quando alguém acessa seu site (faz uma requisição HTTP, como clicar em um link), essa solicitação passa por diversas etapas até chegar ao destino final, que geralmente é um controller no Laravel. O Middleware é como um guarda no meio desse caminho.

A sequência básica de uma requisição HTTP no Laravel é mais ou menos assim:

1. Requisição HTTP:
   • Alguém clica em um link ou faz qualquer tipo de solicitação para o seu site.
2. Middleware:
   • Antes da solicitação chegar ao controller, ela passa por uma série de Middlewares (se configurados).
   • Cada Middleware pode realizar verificações específicas ou adicionar/modificar algo na solicitação.
3. Controller:
   • Após passar pelos Middlewares, a solicitação chega ao controller, que é responsável por processar a solicitação e fornecer uma resposta.
4. Resposta HTTP:
   • O controller gera uma resposta que é enviada de volta ao navegador do usuário.

Você pode checar esse outro post onde eu mostro em mais detalhes esse fluxo. Mas então, o Middleware é essa camada intermédia que tem a oportunidade de verificar ou modificar a solicitação antes que ela atinja o controller. Isso é útil para adicionar medidas de segurança, verificar autenticação, modificar cabeçalhos HTTP, entre outras coisas, dependendo das necessidades do seu aplicativo. Ele se encaixa como um guardião entre a chegada da requisição e o processamento pelo controlador, permitindo a implementação de lógica adicional no fluxo padrão de uma requisição HTTP no Laravel.

Como criar Middleware em Laravel

Passo 1: Criando o Middleware

Ok, existem duas formas de criar o seus middlewares, a primeira é criando a classe manualmente dentro da pasta app/Http/Middleware. A segunda, e bem mais fácil, é criar utilizando o comando artisan, que exatamente o que vamos fazer aqui.

Abra o terminal e digite o seguinte comando para criar um novo Middleware chamado VerificaAssinatura:

php artisan make:middleware VerificaAssinatura

Este comando cria um arquivo chamado VerificaAssinatura.php no diretório app/Http/Middleware.

Passo 2: Personalizando o Middleware

Dentro dessa classe você vai encontrar apenas um método, handle(). Este método é executado antes que a solicitação alcance seu destino. É nessa classe que nós vamos adicionar as verificações que queremos fazer.

Nesse middleware, eu vou verificar se o usuário está logado e se a assinatura desse usuário ainda está ativa, se tudo estiver certo, o requisição segue adiante, caso contrário a gente redireciona o usuário para a tela de renovação de assinatura ou se você estive usando uma API, você pode retornar um erro HTTP com o código 401.

<?php

namespace App\Http\Middleware;

use Closure;

class VerificaAssinatura
{
    public function handle($request, Closure $next)
    {
        // Verifica se o usuário está logado e tem uma assinatura ativa
        if (auth()->check() && !auth()->user()->assinaturaAtiva()) {
            return redirect('/renove-sua-assinatura');
        }

        // Se estiver tudo certo, continua com a solicitação
        return $next($request);
    }
}

Passo 3: Registrando o Middleware

Você precisa manualmente registrar o seu middleware pra você começar utiliza-lo. Pra registrar, é bem simples. Abra o arquivo app/Http/Kernel.php e adicione o seu Middleware ao array $routeMiddleware:

protected $routeMiddleware = [
    // ... outros middlewares ...
    'verifica.assinatura' => \App\Http\Middleware\VerificaAssinatura::class,
];

Passo 4: Aplicando o Middleware em Rotas

Agora, você pode aplicar o Middleware às rotas desejadas. Abra seu arquivo de rotas (web.php geralmente) e adicione o Middleware utilizando o helper ->middleware():

Route::get('/area-restrita', [AreaRestritaController::class,'index'])->middleware('verifica.assinatura');

Isso significa que sempre que alguém tentar acessar a rota /area-restrita, o Middleware VerificaAssinatura será acionado antes de permitir ou negar o acesso.

Tipos de Middleware no Laravel

Middleware Global vs. Middleware de Rota vs. Middleware de Grupo

No Laravel, existem três tipos de middleware: global, de rota e de grupo. Cada um tem uma função diferente, e a escolha do tipo certo depende das necessidades do seu app ou site. Aqui, vou explicar as diferenças entre eles pra te ajudar a escolher o que é melhor pra sua aplicação.

Middleware Global:

No contexto do Laravel, um Middleware Global é como uma verificação geral que ocorre em todas as solicitações antes de chegarem aos controladores.

Por exemplo, um Middleware Global pode ser usado para verificar se o usuário está logado. Se o usuário não estiver logado, o Middleware Global pode redirecionar o usuário para a página de login.

Outro exemplo de Middleware Global é um Middleware que registra todas as solicitações recebidas pelo aplicativo em um Log, esse Middleware pode ser usado para fins de análise de desempenho ou segurança.

Por exemplo vamos criar um Middleware Global que verifica o idioma da aplicação e ajusta dinamicamente o idioma da resposta para o usuário. Suponha que você tenha diferentes traduções disponíveis em sua aplicação e deseja garantir que a resposta seja enviada no idioma correto.

// Em app/Http/Middleware/SetLanguage.php
namespace App\Http\Middleware;

use Closure;

class SetLanguage
{
    public function handle($request, Closure $next)
    {
        // Verificar a preferência de idioma do usuário ou usar um padrão
        $preferredLanguage = $request->getPreferredLanguage(['en', 'es']);

        // Configurar o idioma da aplicação
        app()->setLocale($preferredLanguage);

        // Continuar com a solicitação
        return $next($request);
    }
}

Agora para registrar e aplicar esse middleware globalmente, dentro do arquivo app/Http/Kernel.php você vai registrar esse middleware dentro da variável $middleware:

protected $middleware = [
    // ... outros middlewares ...
    \App\Http\Middleware\SetLanguage::class,
];

Middleware de Rota:

O middleware de Rota já é mais específico. Ele é aplicado apenas às rotas que você escolher.

Se você quiser só verificar se um usuário está autenticado antes de acessar uma determinada rota, você primeiro, claro, vai criar um Middleware, CheckAuthentication por exemplo:

php artisan make:middleware CheckAuthentication

// Em app/Http/Middleware/CheckAuthentication.php
public function handle($request, Closure $next)
{
    if (auth()->guest()) {
        return redirect()->route('login');
    }

    return $next($request);
}

E lembra que você precisa registrar esse novo middleware no app/Http/Kernel.php também, mas diferentemente do middleware global, esse middleware você vai registrar na variável $routeMiddleware:

protected $routeMiddleware = [
    // ... outros middlewares ...
    'auth.check' => \App\Http\Middleware\CheckAuthentication::class,
];

Daí então, você pode aplicar esse Middleware em rotas específicas, utilizando o helper ->middleware():

Route::get('/dashboard', 'DashboardController@index')->middleware('auth.check');

Middleware de Grupo:

O middleware de Grupo no Laravel é um jeito de agrupar verificações que você quer aplicar a várias rotas ao mesmo tempo.

O middleware de Grupo é uma forma de centralizar a lógica de autorização do seu aplicativo. Isso torna seu código mais fácil de manter e entender.

Por exemplo, você pode ter um middleware de Grupo que verifica se o usuário está logado e uma outra que verifica se o usuário é um admin, como já temos um middleware que verifica se o usuário está autenticado, só vamos criar mais um para verificar se o usuário é uma admin.

Pra criar um middleware de grupo, a gente segue o mesmo passo a passo, criando a classe manualmente ou rodando o comando artisan.

php artisan make:middleware CheckAdmin

// Em app/Http/Middleware/CheckAdmin.php
public function handle($request, Closure $next)
{
    if (!auth()->user()->isAdmin()) {
        return abort(403, 'Acesso negado! Você não é um administrador.');
    }

    return $next($request);
}

A diferença fica na hora de registrar esse middleware no app/Http/Kernel.php. Dentro do Kernel, você vai encontrar a variável, $middlewareGroups, nessa variável você provavelmente já vai ter definido alguns middlewares do próprio Laravel.

Aqui você pode tanto criar um novo grupo, ou adicionar o middleware que você acabou de criar em um dos grupos que já existem. Aqui eu criei um novo grupo chamado admin onde vou adicionar os dois middlewares.

protected $middlewareGroups = [
    'web' => [
        // ... outros middlewares ...
    ],

    'admin' => [
        \App\Http\Middleware\CheckAdmin::class,
        \App\Http\Middleware\CheckAuthentication::class,
    ],
];

E então, você aplica esse grupo de Middleware às suas rotas. Aqui você vai usar o helper ->middleware() em junção com o helper group(), que aceita uma método callback, onde dentro desse método, você vai passar todas as rotas ao qual você quer aplicar o seus middlewares.

Route::middleware(['admin])->group(function () {
    //
});

Conclusão

Bora resumir o que a gente viu sobre middleware no Laravel:

• O middleware é um intermediário nas solicitações do seu site. Ele fica entre o início da solicitação e o destino final, dando uma olhadinha rápida antes de passar a solicitação para o controller.
• Existem três tipos de middleware: global, de rota e de grupo.
• O middleware global é aplicado a todas as solicitações. Ele é bom para tarefas que precisam ser executadas em todas as solicitações, como autenticação e autorização.
• O middleware de rota é aplicado a apenas algumas solicitações. Ele é bom para tarefas que precisam ser executadas em rotas específicas, como verificação de integridade ou redirecionamento.
• O middleware de grupo é um conjunto de middlewares que podem ser aplicados a várias rotas ao mesmo tempo. Ele é bom para tarefas que precisam ser executadas em várias rotas, como verificação de autorização.

Além disso, vimos como criar um middleware personalizado. É bem simples:

1. Crie um arquivo com a extensão .php na pasta app/Http/Middleware.
2. Extenda a classe Illuminate\Foundation\Http\Middleware\Middleware.
3. Sobrescreva o método handle().

Entendendo esses conceitos, você estará pronto para implementar estratégias eficazes de controle e personalização no fluxo de requisições HTTP do seu aplicativo Laravel.

Validar dados é uma peça-chave no desenvolvimento de sites e apps, porque é o que garante que as informações dos usuários estejam exatamente como desejamos. Quando se trata do Laravel e das famosas Laravel Form Requests, essa validação é essencial para manter a integridade e a segurança dos dados que o nosso aplicativo recebe.

O Laravel tem um sistema de validação embutido que faz com que a definição de regras, mensagens de erro personalizadas e feedback para o usuário sejam brincadeira de criança. Isso torna o desenvolvimento mais produtivo e amigável.

Neste post, vamos mergulhar de cabeça na validação no Laravel e apresentar exemplos práticos para o seu projeto.

Vamos começar com um olhar geral nas regras de validação disponíveis no Laravel e, em seguida, partir para exemplos reais de como aplicá-las em diferentes situações.

Uso Básico do Laravel Validation

A validação é importante pra garantir que os dados inseridos no seu app sejam confiáveis. O Laravel tem um sistema de validação integrado que facilita essa tarefa. Vamos ver como usar o Laravel Validation com alguns exemplos.

Se você ainda precisa de uma introdução ao uso de validação em Laravel, eu recomendo você começar por esse post ou claro você pode checar a documentação oficial (em Inglês).

Definindo Regras de Validação

Pra começar, você precisa definir as regras de validação pra cada campo do seu formulário. Isso pode ser feito no Controller que processa o formulário.

No exemplo abaixo, estamos validando um formulário de login:

use Illuminate\Support\Facades\Validator;

$validator = Validator::make($request->all(), [
    'email' => 'required|email',
    'password' => 'required|min:6',
]);

Neste exemplo, estamos usando a classe Validator para criar um objeto de validação. Estamos validando dois campos: email e password. A regra required garante que esses campos sejam preenchidos, enquanto email verifica se o campo email contém um endereço de e-mail válido e min:6 garante que a senha tenha pelo menos 6 caracteres.

Verificando Se a Validação Passou

Depois de definir as regras de validação, você deve verificar se a validação foi bem-sucedida ou não. Isso é geralmente feito da seguinte maneira:

if ($validator->fails()) {
    return redirect('login')
        ->withErrors($validator)
        ->withInput();
}

Neste exemplo, estamos verificando se a validação falhou. Se a validação falhar, redirecionamos o usuário de volta para a página de login, com as mensagens de erro e os dados de entrada anteriores, para que o usuário possa ver o que deu errado e corrigir os erros.

Ou se caso você estiver construindo uma API em Laravel, você pode usar esse alternativa:

    if ($validator->fails()) {
        return response()->json(['errors' => $validator->errors()], 400);
    }

O uso básico da validação no Laravel é fácil, e você pode usá-la pra garantir que os dados inseridos no seu app sejam do jeito que você quer. Conforme você vai desenvolvendo, você pode explorar regras de validação e personalizações mais avançadas pra atender às necessidades do seu projeto.

Criando Laravel Form Requests

Em Laravel, Form Requests são uma parte fundamental da validação de dados. Elas são usadas para validar os dados enviados por meio de formulários antes de serem processados pelo controller. O uso de Form Requests ajuda a manter seu código muito mais limpo e organizado, pois centraliza a lógica de validação em classes separadas.

Aqui estão os passos básicos para criar Form Requests no Laravel:

1. Criando uma Form Request:
   Para criar uma Form Request, você pode usar o comando artisan make:request. Abra seu terminal e execute o seguinte comando, substituindo “ExemploRequest” pelo nome que você deseja dar à sua Form Request:

   php artisan make:request ExemploRequest

Isso criará um novo arquivo em app/Http/Requests com o nome ExemploRequest.php. Esta classe será usada para definir as regras de validação para o seu formulário.

2. Definindo regras de validação:
   Abra o arquivo ExemploRequest.php que você acabou de criar. Dentro desta classe, você pode definir as regras de validação no método rules(). Por exemplo, se você estiver criando uma Form Request para validar um formulário de cadastro de usuário, suas regras de validação podem ser assim:

   public function rules()
   {
       return [
           'nome' => 'required|string|max:255',
           'email' => 'required|email|unique:users,email',
           'senha' => 'required|string|min:6|confirmed',
       ];
   }

Neste exemplo, estamos validando se o campo ‘nome’ é obrigatório e uma string com no máximo 255 caracteres, se o campo ’email’ é obrigatório, um endereço de email válido e único na tabela ‘users’, e se o campo ‘senha’ é obrigatório, uma string com no mínimo 6 caracteres e se a confirmação de senha corresponde.

3. Usando a Form Request em seu controller:
   Agora que você criou sua Form Request, você pode usá-la em seu controller para validar os dados de entrada do formulário. Por exemplo:

   public function store(ExemploRequest $request)
   {
       // Se o código chegou até aqui, os dados foram validados com sucesso.
       // Você pode continuar a processar os dados.
   }

O Laravel automaticamente injeta a instância da Form Request (ExemploRequest) e verifica se os dados são válidos antes de executar o método store().

Seguindo essas etapas, você pode criar Form Requests no Laravel para garantir que os dados inseridos em seus formulários sejam verificados de forma fácil e segura. Isso é como ter um guarda-costas para o seu aplicativo, evitando problemas e mantendo sua aplicação firme e confiável.

Customização de Mensagens de Erro de Validação

Personalizar as mensagens de erro de validação no Laravel é uma boa prática pra deixar a experiência do usuário mais informativa e amigável. O Laravel permite personalizar as mensagens de erro pra cada regra de validação, o que facilita comunicar problemas específicos de validação de campos. Aqui estão os passos pra customizar mensagens de erro de validação no Laravel.

1. Definir mensagens de erro personalizadas:
   Você pode definir mensagens de erro personalizadas no método messages() do seu Form Request ou diretamente no controller, caso esteja validando campos em rotas. Dentro desse método, você deve retornar um array associativo onde as chaves representam as regras de validação que deseja personalizar e os valores são as mensagens de erro personalizadas. Por exemplo:

public function messages()
{
    return [
        'nome.required' => 'O campo nome é obrigatório.',
        'email.required' => 'O campo email é obrigatório.',
        'idade.min' => 'A idade mínima permitida é 18 anos.',
    ];
}

Isso substituirá as mensagens de erro padrão fornecidas pelo Laravel para as regras de validação especificadas.

2. Placeholders nas Mensagens:
   Você pode adicionar placeholders às mensagens de erro personalizadas, que serão substituídos pelos valores reais durante a validação. Por exemplo, se você deseja incluir o valor mínimo permitido para a idade em sua mensagem de erro:

public function messages()
{
    return [
        'idade.min' => 'A idade deve ser no mínimo :min anos.',
    ];
}

O :min será substituído pelo valor real definido na regra de validação.

3. Mensagens de erro em várias línguas:
   Laravel suporta localização de mensagens de erro para várias línguas. Você pode definir mensagens de erro personalizadas para diferentes idiomas criando arquivos de tradução específicos. O Laravel usará automaticamente as mensagens corretas com base no idioma definido no aplicativo.
4. Validação em Rotas:
   Se você estiver realizando validação em rotas ou dentro do seu controller, pode personalizar as mensagens de erro diretamente na rota usando a função validate(). Por exemplo:

Route::post('/usuarios', function (Request $request) {
    $regras = [
        'nome' => 'required|string|max:255',
        'email' => 'required|email|unique:usuarios',
    ];

    $mensagens = [
        'nome.required' => 'Por favor, preencha o campo nome.',
        'email.email' => 'Insira um endereço de email válido.',
    ];

    $request->validate($regras, $mensagens);

    // Se a validação passar, continue processando os dados.
});

Personalizar as mensagens de erro no Laravel é uma sacada valiosa, pois faz com que o aplicativo converse com o usuário de forma mais clara e apropriada. Isso não só melhora a experiência do usuário, mas também eleva a qualidade geral do seu aplicativo, tornando mais fácil entender e resolver problemas de validação nos campos. Portanto, fique à vontade para soltar a criatividade e tornar as mensagens mais amigáveis.

Conclusão

Neste post, aprendemos a importância da validação em Laravel para manter nossos dados seguros e garantir que tudo funcione como esperado.

Vimos como definir regras de validação para campos e como verificar se os dados estão corretos. Também exploramos como personalizar as mensagens de erro para tornar a experiência do usuário mais amigável.

Além disso, descobrimos como criar Form Requests, uma maneira organizada de lidar com a validação de dados, mantendo nosso código limpo e seguro.

Personalizar mensagens de erro é uma ótima prática para tornar o aplicativo mais amigável. Isso ajuda os usuários a entender e corrigir erros de forma mais fácil.

Dominar a validação é fundamental para criar aplicativos confiáveis. Use essas dicas para melhorar suas habilidades e criar aplicativos mais sólidos.

Bem-vindo, nesse post, vamos por passar por uma jornada de cinco práticas fundamentais de Laravel Validation. Você será guiado através do Laravel Validation- um dos pilares essenciais para a construção de aplicações web seguras e eficientes.

Uma das primeiras regras do web development é:

Nunca confie cegamente nos dados do usuário.

Validação de dados é como uma espécie de filtro de entrada antes de usar as informações que os usuários enviam através de formulários ou qualquer outro tipo de entrada de dados.

Por exemplo, você pode pedir ao Laravel para checar se um campo de e-mail está no formato correto ou se um número de telefone possui a quantidade exata de dígitos. Essa prática é incrivelmente útil para manter a segurança da sua aplicação, prevenindo que informações fora do padrão causem qualquer tipo de dano.

Essas regras podem se tornar um pouco complexas, mas não se preocupe, vamos simplificar e esclarecer mais adiante para que seja fácil de entender.

Laravel Validation: Por onde começar

Para trabalhar como validações em Laravel você vai precisar de pelo menos um rota e de um controller.

Criando as rotas

Vamos definir nossa rota no arquivo routes/web.php.

use App\Http\Controllers\UserController;

Route::post('/user', [UserController::class, 'store']);

Essa é uma rota do tipo POST para o método store do nosso controller UserController. Esse método é responsável por criar novos usuários para a plataforma.

Criando o Controller

Proximo passo é criar o nosso controller UserController. Vamos começar com um controller bem simples com o método store ainda vazio, e na sequencia vamos implementar os métodos de validação. Sinta-se a vontade para rodar esse comando na hora de criar o controller.

php artisan make:controller UserController

O comando vai gerar um controller completo com vários outros métodos, mas vamos focar apenas no método store.

<?php
 
namespace App\Http\Controllers;
 
use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
 
class PostController extends Controller
{
     /**
     *  Cria um novo usuario
     */
    public function store(Request $request)
    {
        // Validar novo usuario
 
        $user = /** ... */
 
      return true;
    }
}

Processo de Validação, Respostas e Tratamento de Erros no Laravel

Pronto, agora estamos prontos para preencher nosso método store com a lógica para validar o novo usuário. Para fazer isso, usaremos o método validate fornecido pelo objeto Illuminate\Http\Request.

Laravel oferece “de fábrica” uma longa lista de regras de validação integradas pra você utilizar, elas abrangem praticamente todas as necessidades comuns e algumas mais complexas para validação de dados.

Se as regras de validação passarem, seu código continuará executando normalmente; no entanto, se a validação falhar, uma exceção Illuminate\Validation\ValidationException será lançada e a resposta de erro apropriada será automaticamente enviada de volta ao usuário.

Laravel detecta qual o tipo do request, e retorna a reposta adequada para cada um:

• Se a validação falhar durante um pedido HTTP tradicional, será gerada uma resposta de redirecionamento para o URL anterior.
• Se o pedido de entrada for um pedido XHR, será devolvida uma resposta JSON que contém as mensagens de erro de validação.

Vamos comentar sobre o primeiro cenário, mas nosso foco será o segundo.

1. Utilizando as Regras de Validação Integradas do Laravel

Vamos começar com uma validação simples, imagine que o nosso formulário de cadastro tem apenas email, senha e nome. Para validar esses campos faremos o seguinte:

<?php
 
namespace App\Http\Controllers;
 
use App\Http\Controllers\Controller;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Response;
 
class PostController extends Controller
{
     /**
     *  Cria um novo usuario
     */
    public function store(Request $request): JsonResponse {
        $validated = $request->validate([
            'email' => 'required|email|unique:users,email',
            'nome' => 'required|string|max:255',
            'senha' => ['required', Password::min(8)->letters()
                ->mixedCase()
                ->numbers()
                ->symbols()
                ->uncompromised()],
        ]);

        // Dados sao validos
        $user = User::create($validated);

        // Retorna o usuario
        return Response::json($user);
    }
}

Ok, tem bastante coisa acontecendo aqui, vamos explicar tudo com calma.

Para validar os dados nós estamos utilizando o método validate, esse método aceita um array com o campo que você quer validar como chave e as regras de validação como valor dessa chave.

Primeiro entenda que as regras para validação podem ser representadas de duas maneiras, tanto como uma string única separada por “pipes” | essas linhas verticais, ou como um array.

'required|string' ou ['required', 'string']

Na maioria dos casos, a escolha entre uma notação e outra é uma questão de preferência pessoal e não tem impacto significativo. No entanto, existem situações específicas em que a segunda notação é necessária, e vamos explorar esses casos mais adiante.

O primeiro campo que estamos validando é o email do usuário, perceba que estamos utilizando 3 regras. required, email e unique.

'email' => 'required|email|unique:users,email'

• required, indica que esse campo precisa estar na request para que haja a validação, é um campo obrigatório.
• email, indica que o campo deve ser formatado como um endereço email.
• unique, estipula que esse email não deve existir na tabela users no campo email, ou seja o email deve ser único.

O segundo campo sendo validado é o nome do usuário, aqui usamos 3 regras também, required, string e max:255

Para não ficar me repetindo só vou citar as regras que ainda não falamos.

'nome' => 'required|string|max:255'

• max:255, essa regra serve para indicar o campo sob validação deve ser menor ou igual a um valor máximo, nesse caso 255 caracteres.
• string, indica que o campo deve ser uma cadeia de caracteres

Por ultimo, estamos validando a senha do usuário. Aqui estamos 6 regras de validação, em um formato um pouco diferente, mas você já vai entender.

'senha' => ['required', Password::min(8)->letters()->mixedCase()->numbers()->symbols()->uncompromised()];

Password é uma classe do próprio Laravel que ajuda personalizar os requisitos da complexidade da senha para os usuários. Então vamos ver qual é o requisito mínimo para a senha dos nossos novos usuários.

• ->min(8), requer no mínimo 8 caracteres
• ->letters(), requer no mínimo uma letra
• ->mixedCase(), requer pelo menos uma letra maiúscula e uma letra minúscula
• ->numbers(), requer pelo menos um número
• ->symbols(), requer pelo menos um simbolo

Além disso, é possível empregar um método para assegurar que a senha não tenha sido comprometida em algum vazamento de dados, utilizando o seguinte método:

->uncompromised()

para validar apenas 3 campos, foram necessárias várias regras. A complexidade e extensão das regras tendem a crescer conforme o tamanho do seu formulário. É altamente recomendável explorar a documentação em busca de regras que se adequem ao seu caso. Se não encontrar, não se preocupe. Vou orientar sobre como criar suas próprias regras de validação.

2. Crie suas próprias regras de validação

Existe uma vasta variedade de Laravel Validation no entanto, é possível que você queira especificar algumas regras personalizadas para validação. Para registrar suas novas regras, você primeiro precisa gerar uma nova classe que conterá essa nova regra. Você pode fazer isso usando o comando:

php artisan make:rule Estados

Agora, vamos criar uma classe nova para conferir se o estado que o usuário deu como entrada está na lista dos 26 estados brasileiros mais o Distrito Federal. Se você rodou o comando, o Laravel vai jogar essa regra nova na pasta app/Rules. E se essa pasta ainda não existir, relaxa, o Laravel cria ela pra você quando você usar o comando Artisan para criar a sua regra.

Agora que temos a classe criada, é hora de dizer como ela deve agir. Dentro dessa classe, temos um único método chamado validate. Esse método recebe o nome do atributo, o valor dele e uma função de callback. Se algo der errado, essa função de callback é chamada e mostra a mensagem de erro de validação.

<?php

namespace App\Rules;

use Closure;
use Illuminate\Contracts\Validation\ValidationRule;

class Estados implements ValidationRule
{
    /**
     * Run the validation rule.
     */
    public function validate(string $attribute, mixed $value, Closure $fail) : void
    {
        // Valida se é um estado brasileiro
    }
}

Agora é só desenvolver o corpo do nosso método. Basicamente precisamos da lista de todos os estados brasileiros em um array, e vamos usar o método in_array para verificar se o $value (o valor vindo do usuário) está dentro do array.

<?php

namespace App\Rules;

use Closure;
use Illuminate\Contracts\Validation\ValidationRule;

class Estados implements ValidationRule
{
    /**
     * Run the validation rule.
     */
    public function validate(string $attribute, mixed $value, Closure $fail) : void
    {
        $estadosBrasileiros = [
            'AC' => 'Acre',
            'AL' => 'Alagoas',
            'AP' => 'Amapá',
            'AM' => 'Amazonas',
            'BA' => 'Bahia',
            'CE' => 'Ceará',
            'DF' => 'Distrito Federal',
            'ES' => 'Espírito Santo',
            'GO' => 'Goiás',
            'MA' => 'Maranhão',
            'MT' => 'Mato Grosso',
            'MS' => 'Mato Grosso do Sul',
            'MG' => 'Minas Gerais',
            'PA' => 'Pará',
            'PB' => 'Paraíba',
            'PR' => 'Paraná',
            'PE' => 'Pernambuco',
            'PI' => 'Piauí',
            'RJ' => 'Rio de Janeiro',
            'RN' => 'Rio Grande do Norte',
            'RS' => 'Rio Grande do Sul',
            'RO' => 'Rondônia',
            'RR' => 'Roraima',
            'SC' => 'Santa Catarina',
            'SP' => 'São Paulo',
            'SE' => 'Sergipe',
            'TO' => 'Tocantins'
        ];

        // Valida se é um estado brasileiro
        if(!in_array($value, $estadosBrasileiros)){
            $fail('O estado fornecido nao e um estado brasileiro valido');
        }
    }
}

Ok, agora com a nossa nova regra criada, precisamos utiliza-la em algum lugar, então nós vamos incluir “estado” como um novo campo para o cadastro do usuário, nosso método store vai ficar assim:

     /**
     *  Cria um novo usuario
     */
    public function store(Request $request): JsonResponse {
        $validated = $request->validate([
            'email' => 'required|email|unique:users,email',
            'nome' => 'required|string|max:255',
            'estado' => ['string', new Estados],
            'senha' => ['required', Password::min(8)->letters()
                ->mixedCase()
                ->numbers()
                ->symbols()
                ->uncompromised()],
        ]);

        // Dados sao validos
        $user = User::create($validated);

        // Retorna o usuario
        return Response::json($user);
    }

Bem simples de usar, basta incluir o novo campo e adicionar regra recém criada com a palavra-chave new, para criar uma nova instância dessa regra. Não se esqueça de importar a classe.

'estado' => ['string', new Estados]

As possibilidades aqui são infinitas, você pode criar regras customizadas para qualquer coisa que a sua plataforma exija.

3. Utilize Form Requests

Até agora estávamos fazendo a validação e adicionando as novas regras dentro do nosso Controller. Mas com mais e mais regras isso começa a ficar impraticável. O método dentro do controller não deveria ser responsável por lidar com todas essas regras e validações. Pensando nisso, Laravel tem uma classe especial chamada FormRequest.

Form Requests são classes personalizadas que encapsulam a sua própria lógica de validação e autorização.

Para criar uma nova Form Request, você pode rodar o comando abaixo:

php artisan make:request StoreUserRequest

A classe gerada será colocada no diretório app/Http/Requests. Se este diretório não existir, ele será criado quando você executar o comando make:request. Cada Form Request gerada pelo Laravel tem dois métodos: authorize e rules.

O método authorize é responsável por determinar se o usuário autenticado pode executar a ação, (mas no nosso caso como ainda estamos tentando cadastrar o usuário vamos apenas retornar true nessa função) enquanto o método rules devolve as regras de validação que devem ser aplicadas ao campos da request:

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class StoreUserRequest extends FormRequest
{

    /**
     * Determina se o usuario esta autorizado
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    /**
     * Regras de validacao
     *
     * @return array
     */
    public function rules()
    {
        // Regras de validacao
    }

}

O que nós vamos fazer agora é mover todas as regras de validação do nosso usuário para essa classe, ficando assim:

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class StoreUserRequest extends FormRequest
{

    /**
     * Determina se o usuario esta autorizado
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    /**
     * Regras de validacao
     *
     * @return array
     */
    public function rules()
    {
        return [
            'email' => 'required|email|unique:users,email',
            'nome' => 'required|string|max:255',
            'estado' => ['string', new Estados],
            'senha' => ['required', Password::min(8)->letters()
                ->mixedCase()
                ->numbers()
                ->symbols()
                ->uncompromised()],
        ];
    }
}

Já o nosso controller, podemos remover toda a parte de validação, como você pode ver o método store ficou bem mais limpo e fácil de ler.

    /**
     *  Cria um novo usuario
     */
    public function store(StoreUserRequest $request) : JsonResponse
    {
        $validated = $request->validated();

        // Dados sao validos
        $user = User::create($validated);

        // Retorna o usuario
        return Response::json($user);
    }

Duas mudanças importantes foram feitas aqui. Primeiro, trocamos a classe Request pelo StoreUserRequest no parâmetro do método store. StoreUserRequest é a nova classe que acabamos de criar.

A segunda mudança foi na forma como lidamos com a validação. Antes, tínhamos várias regras de validação, mas agora usamos o método ->validated(). Esse método nos dá todos os dados que foram validados no formato de um array.

Se algo der errado na validação (ou seja, os dados não são válidos) e a requisição veio de um XHR (uma requisição AJAX), enviamos de volta uma resposta HTTP com o código de estado 422. Além disso, incluímos uma representação em JSON dos erros de validação para que o usuário saiba o que precisa ser corrigido.

4. Filtre apenas o necessário

Você viu que ao utilizar Form Requests torna a vida do nosso controller muito mais simples? Além de manter nosso código mais organizado, transferindo toda a lógica de validação para fora do controller, as Form Requests oferecem uma série de outras vantagens que vamos explorar a seguir.

Por exemplo, você já viu que podemos usar o método ->validated() para acessar todos os dados validos. E se você tiver dados opcionais ou não precisar de todos os campos? O Laravel pensou em tudo isso e muito mais.

A nossa primeira alternativa, é poder chamar o método safe() em um Form Request. Este método devolve uma instância de Illuminate\Support\ValidatedInput. Este objeto expõe os métodos only, except e all para obter um subconjunto ou todo o array dos dados validos:

$validated = $request->safe()->only(['name', 'email']);
 
$validated = $request->safe()->except(['name', 'email']);
 
$validated = $request->safe()->all();

Além disso, a instância Illuminate\Support\ValidatedInput pode ser iterada como uma array:

// Os dados validos podem ser iterados...
foreach ($request->safe() as $key => $value) {
    // ...
}
 
// Os dados validos podem ser acessados como uma array...
$validated = $request->safe();
 
$email = $validated['email'];

Se você precisa incluir algum dado no array, talvez algum dado baseado na rota ou localização do usuário por exemplo, você pode usar o método merge().

$validated = $request->safe()->merge(['user_acquisition' => 'Google']);

5. Utilize mensagens de erro customizadas

Validar os dados é só uma parte da história. A outra parte é dar mensagens de erro que façam sentido e ajudem os usuários a entender e consertar o que deu errado.

O Laravel simplifica consideravelmente o processo de personalização dessas mensagens de erro de validação.

Você pode personalizar as mensagens de erro utilizadas pelo Form Request substituindo/adicionando o método messages(). Este método deve devolver um conjunto de pares atributo/regra com as mensagens de erro correspondentes:

    /**
     * Cria mensagens de erro customizadas
     *
     * @return array<string, string>
     */
    public function messages() : array
    {
        return [
            'email.required' => 'O email é necessário',
            'nome.required' => 'O seu nome é necessário',
            'senha.required' => 'A senha é necessária',
        ];
    }

No exemplo acima estamos alterando a mensagem da validação required dos campos email, nome e senha. Mas você pode (e deve) alterar todas as mensagens. O formato é bem simples, basta usar o nome do campo e o tipo da validação separado por .. Mais um exemplo, você também pode incluir:

'email.unique' => 'O endereço de email precisa ser único'

Se você precisa traduzir as mensagens de erro, aqui é o lugar certo. Mas se caso a sua plataforma tenha necessidade de utilizar mais de uma lingua, de uma olhada nessa outra feature do Laravel.

Conclusão

Adotar as práticas discutidas neste post não apenas aprimora a segurança e integridade do seu aplicativo Laravel, mas também eleva a qualidade e a eficiência do seu código. Utilizar as regras de validação integradas, criar validações personalizadas, aproveitar as Form Requests e outras estratégias oferece uma base sólida para o desenvolvimento de aplicativos robustos e escaláveis.

Ao entender e aplicar essas técnicas, você estará não apenas otimizando o fluxo de trabalho de desenvolvimento, mas também proporcionando uma melhor experiência para os usuários do seu aplicativo. Mantenha-se atualizado com as novidades e atualizações do Laravel para continuar aprimorando suas habilidades e construindo aplicativos de alta qualidade. Happy coding!

O que é um controller?

Em termos simples, um controller é um arquivo PHP que controla o fluxo da aplicação. Ele recebe as solicitações do usuário, processa-as e retorna uma resposta. O controller é responsável por gerenciar a lógica do negócio e a interação com o modelo de dados.

No Laravel, os controllers são armazenados na pasta app/Http/Controllers. Cada controller é uma classe que estende a classe base do Laravel App\Http\Controllers\Controller. Essa classe base fornece alguns métodos comuns que podem ser usados ​​para processar solicitações e retornar respostas.

Criando controllers no Laravel

Para criar um novo controller no Laravel, basta executar o comando:

php artisan make:controller NomeDoController

Isso criará um novo arquivo NomeDoController.php na pasta app/Http/Controllers.

Certifique-se de que seu controller seja bem organizado e modular, dividindo sua lógica em métodos separados que realizam tarefas específicas. Além disso, é importante adotar as melhores práticas do Laravel, como usar a injeção de dependência em vez de instanciar objetos diretamente em seus métodos.

Por exemplo, se quisermos criar um controller chamado ProdutoController, podemos executar o comando:

php artisan make:controller ProdutoController.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ProdutoController extends Controller
{
    //
}

Este controller não faz nada ainda, mas podemos começar a adicionar métodos para lidar com as solicitações do usuário.

Métodos de um controller

Os controllers do Laravel podem ter vários métodos que são executados para lidar com solicitações específicas do usuário. Por exemplo, podemos ter um método para exibir uma lista de produtos, outro método para exibir um formulário de criação de produto e um terceiro método para processar a criação do produto, e nos métodos de criação e atualização sempre que possível de atenção a validação dos dados.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Produto;

class ProdutoController extends Controller
{
    public function index()
    {
        $produtos = Produto::all();
        return view('produtos.index', compact('produtos'));
    }

    public function create()
    {
        return view('produtos.create');
    }

    public function store(Request $request)
    {
        Produto::create($request->all()); //Sempre valide dados do usuario
        return redirect()->route('produtos.index');
    }
}

O método index retorna uma lista de produtos para a página produtos.index. O método create retorna uma página de formulário para criar um novo produto. O método store processa o formulário enviado pelo usuário e cria um novo produto no banco de dados.

Rotas para o controller

Para direcionar solicitações para um controller específico, podemos definir rotas em nosso arquivo routes/web.php. Por exemplo, podemos definir uma rota para o método index do ProdutoController da seguinte maneira:

Route::get('/produtos', [ProdutoController::class, 'index'])->name('produtos.index');

Isso direcionará as solicitações GET para /produtos para o método index do ProdutoController.

Outra maneira de simplificar o código do controller no Laravel é usando o resource routing. Com o resource routing, o Laravel pode gerar automaticamente as rotas CRUD (Create, Read, Update, Delete) para o seu controller. Tudo o que você precisa fazer é especificar o nome do controller e a rota do resource no arquivo de rotas.

Por exemplo, suponha que você tenha um model Post e deseja criar um controller para gerenciar as operações CRUD. Você pode usar o comando abaixo para gerar um controller com métodos para cada operação CRUD e com um modelo definido.

php artisan make:controller PostController --resource --model=Post

<?php

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function index()
    {
        $posts = Post::all();
        return view('posts.index', compact('posts'));
    }

    public function create()
    {
        return view('posts.create');
    }

    public function store(Request $request)
    {
        $post = new Post;
        $post->title = $request->title;
        $post->body = $request->body;
        $post->save();

        return redirect()->route('posts.index');
    }

    public function show(Post $post)
    {
        return view('posts.show', compact('post'));
    }

    public function edit(Post $post)
    {
        return view('posts.edit', compact('post'));
    }

    public function update(Request $request, Post $post)
    {
        $post->title = $request->title;
        $post->body = $request->body;
        $post->save();

        return redirect()->route('posts.index');
    }

    public function destroy(Post $post)
    {
        $post->delete();

        return redirect()->route('posts.index');
    }
}

Observe que o parâmetro $post do método show, edit, update e destroy é um objeto da classe Post, que é passado automaticamente pelo Laravel com base no valor do parâmetro {post} da rota. Esse recurso é conhecido como route model binding.

No arquivo de rotas, você pode definir as rotas do resource usando a função resource:

Route::resource('posts', PostController::class);

O Laravel gerará automaticamente as rotas CRUD correspondentes:

Com o resource routing, você pode criar rotas CRUD rapidamente e facilmente. No entanto, lembre-se de que o resource routing pode não ser adequado para todos os casos, especialmente se você precisar de rotas personalizadas ou controllers para lidar com casos específicos.

Conclusão

Em resumo, os controllers do Laravel são uma parte fundamental de qualquer aplicação Laravel e são responsáveis por controlar a lógica de sua aplicação. Para tornar seus controllers mais organizados e modulares, é importante dividir sua lógica em métodos separados e adotar as melhores práticas do Laravel, como a injeção de dependência. Com essas práticas recomendadas em mente, você pode criar controllers que são fáceis de entender, manter e estender.

Os modelos são uma abstração da camada de acesso a dados da aplicação. Eles representam as tabelas do banco de dados e fornecem uma interface orientada a objetos para realizar operações de criação, leitura, atualização e exclusão de dados. Com os modelos, é possível manipular os dados da aplicação de forma mais simples e organizada, além de permitir a criação de relacionamentos entre as tabelas.

No Laravel, os modelos são implementados utilizando o Eloquent ORM, que é um dos recursos mais poderosos do framework. Com o Eloquent, é possível definir os modelos de forma muito simples, utilizando uma sintaxe fluente e intuitiva. Além disso, o Eloquent oferece diversas funcionalidades avançadas, como a criação de relacionamentos entre tabelas, a validação de dados e a criação de consultas complexas.

Para ilustrar o uso dos modelos no Laravel, vamos considerar um exemplo de uma aplicação que gerencia produtos e categorias. Nessa aplicação, cada produto pertence a uma categoria e cada categoria pode ter vários produtos associados. Para implementar essa funcionalidade, vamos criar dois modelos: um para a tabela de produtos e outro para a tabela de categorias.

O primeiro passo é criar as tabelas no banco de dados. Para isso, podemos utilizar o recurso de migrações do Laravel, que permite criar e alterar tabelas de forma programática. Para criar a tabela de produtos, podemos criar uma migração com o seguinte código:

Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->text('description');
    $table->foreignId('category_id');
    $table->timestamps();
});

Nesse código, estamos criando uma tabela chamada “products” com os campos “id”, “name”, “description”, “category_id” e “timestamps”. O campo “id” é uma chave primária autoincrementável, enquanto o campo “category_id” é uma chave estrangeira que será usada para relacionar os produtos com as categorias.

Em seguida, podemos criar uma migração para a tabela de categorias:

Schema::create('categories', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->timestamps();
});

Com as tabelas criadas, podemos definir os modelos correspondentes no Laravel. Para isso, basta criar dois arquivos no diretório app/Models: Product.php e Category.php. O modelo do Produto pode ser definido da seguinte forma:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    protected $fillable = ['name', 'description', 'category_id'];

    public function category()
    {
        return $this->belongsTo(Category::class);
    }
}

Nesse código, estamos definindo o modelo de produto, que estende a classe Model do Eloquent. O modelo tem três campos preenchíveis (“name”, “description” e “category_id”) e um relacionamento com a tabela de categorias, por meio do método belongsTo(). Esse método indica que cada produto pertence a uma categoria e define o relacionamento entre as tabelas.

O modelo de categoria pode ser definido de forma similar:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Category extends Model
{
    protected $fillable = ['name'];

    public function products()
    {
        return $this->hasMany(Product::class);
    }
}

Acima, estamos definindo o modelo de categoria, que também estende a classe Model do Eloquent. O modelo tem um campo preenchível (“name”) e um relacionamento com a tabela de produtos, por meio do método hasMany(). Esse método indica que cada categoria pode ter vários produtos associados.

Com os modelos definidos, podemos utilizar diversas funcionalidades do Eloquent para manipular os dados da aplicação. Por exemplo, podemos criar um novo produto associado a uma categoria da seguinte forma:

$category = Category::find(1);
$product = new Product([
    'name' => 'Produto 1',
    'description' => 'Descrição do produto 1',
]);
$category->products()->save($product);

Nesse código, estamos buscando a categoria com id igual a 1 e criando um novo produto associado a essa categoria. Para isso, estamos utilizando o método save() do relacionamento entre as tabelas de produtos e categorias.

Além disso, o Eloquent oferece diversas funcionalidades para consultas complexas, como o uso de cláusulas where, orWhere, whereIn e outras. Por exemplo, podemos buscar todos os produtos associados a uma categoria específica da seguinte forma:

$category = Category::find(1);
$products = $category->products()->where('name', 'like', '%produto%')->get();

Nesse código, estamos buscando a categoria com id igual a 1 e buscando todos os produtos associados a essa categoria cujo nome contenha a palavra “produto”.

Em resumo, os modelos são um recurso poderoso do Laravel que permitem gerenciar os dados da aplicação de maneira eficiente e escalável. Com o Eloquent ORM, é possível definir modelos de forma simples e intuitiva e utilizar diversas funcionalidades avançadas para manipular os dados da aplicação. Com o exemplo apresentado, é possível entender como os modelos podem ser utilizados para gerenciar relacionamentos entre tabelas e realizar consultas complexas de forma simples e organizada.

Segue um exemplo simples de como utilizar o array_pop() em PHP para remover o último elemento de um array:

<?php
$array = array("maçã", "banana", "laranja", "abacaxi");
$ultimo_elemento = array_pop($array);
echo "O último elemento removido foi: " . $ultimo_elemento;
print_r($array);
?>

Neste exemplo, o array_pop() é usado para remover o último elemento do array $array, que é “abacaxi”. Em seguida, a mensagem “O último elemento removido foi: abacaxi” é exibida no navegador e o resultado atualizado do array é impresso com o print_r($array).

É importante ter cuidado ao utilizar o array_pop() em um array vazio, pois isso pode gerar um erro no PHP. Para evitar esse problema, é possível verificar se o array não está vazio antes de chamar o método.

Espero ter ajudado!

O que são coleções?

As coleções são uma forma avançada de trabalhar com arrays no PHP. Elas permitem que você manipule dados de forma poderosa e flexível, com uma variedade de métodos úteis que podem ser encadeados em conjunto para executar operações sofisticadas de filtragem, ordenação, mapeamento e redução.

Por que usar coleções?

Existem muitas razões para usar coleções no Laravel, incluindo:

• Maior clareza e legibilidade do código
• Melhor desempenho para operações em grandes conjuntos de dados
• Funcionalidades mais poderosas do que as funções padrão do PHP

Como criar coleções

No Laravel, você pode criar uma coleção de várias maneiras diferentes. Por exemplo, você pode converter um array em uma coleção usando o método collect().

$array = [1, 2, 3];
$collection = collect($array);

As coleções do Laravel permitem realizar muitas operações sofisticadas em conjuntos de dados, como filtrar, classificar e mapear, tudo com uma sintaxe elegante e fácil de entender. Vamos dar uma olhada em alguns dos métodos mais úteis das coleções do Laravel.

1. map()

O método map() é usado para transformar uma coleção em uma nova coleção com valores modificados. Isso pode ser útil quando você deseja fazer alterações em uma coleção sem alterar a coleção original.

Exemplo:

$collection = collect([1, 2, 3]);
$mapped = $collection->map(function ($item) {
    return $item * 2;
});

// [2, 4, 6]

2. filter()

O método filter() é usado para filtrar uma coleção para selecionar apenas valores que satisfazem uma condição específica. Ele retorna uma nova coleção com os valores que passam na condição.

Exemplo:

$collection = collect([1, 2, 3, 4, 5]);
$filtered = $collection->filter(function ($item) {
    return $item > 2;
});

// [3, 4, 5]

3. countBy()

O método countBy() é usado para fazer uma contagem dos itens repetidos em uma coleção. Ele retorna uma nova coleção com as contagens de cada item.

Exemplo:

$collection = collect(['maçã', 'banana', 'maçã', 'abacaxi', 'uva', 'banana']);
$counted = $collection->countBy();

// ['maçã' => 2, 'banana' => 2, 'abacaxi' => 1, 'uva' => 1]

4. unique()

O método unique() é usado para selecionar apenas os valores únicos em uma coleção. Ele retorna uma nova coleção com os valores únicos.

Exemplo:

$collection = collect([1, 2, 2, 3, 4, 4, 5]);
$unique = $collection->unique();

// [1, 2, 3, 4, 5]

5. sortBy()

O método sortBy() é usado para ordenar uma coleção com base em um campo específico em cada item. Ele retorna uma nova coleção com os itens ordenados com base no valor desse campo.

Exemplo:

$collection = collect([
    ['name' => 'João', 'age' => 25],
    ['name' => 'Ana', 'age' => 20],
    ['name' => 'Maria', 'age' => 30],
]);

$sorted = $collection->sortBy('age');

/*
[
    ['name' => 'Ana', 'age' => 20],
    ['name' => 'João', 'age' => 25],
    ['name' => 'Maria', 'age' => 30],
]
*/

Além desses métodos, existem muitos outros que podem ser usados para manipular e transformar coleções no Laravel, incluindo concat(), merge(), reduce(), min(), max(), e muitos mais. É recomendável explorar a documentação oficial do Laravel para ver todos os métodos disponíveis.

Conclusão

As coleções são uma das características mais poderosas do Laravel. Elas permitem que você trabalhe com dados de uma maneira mais limpa, elegante e eficiente. Embora tenhamos mencionado apenas alguns dos métodos mais úteis, há muitos outros disponíveis que podem ser usados para manipular e transformar dados em suas coleções.

Usar coleções é uma das maneiras mais fáceis de tornar seu código mais limpo e conciso. Se você está trabalhando com PHP e Laravel, vale a pena aprender como usar coleções para aproveitar todos os seus recursos.

Neste guia, você aprenderá como implementar a validação no Laravel, incluindo exemplos práticos de como validar diferentes tipos de dados.

O que é validação no Laravel?

Laravel Validation é uma forma de garantir que os dados enviados para o servidor sejam válidos e atendam requisitos definidos. Laravel fornece uma série de regras de validação predefinidas, bem como a capacidade de criar regras personalizadas para atender às necessidades específicas da sua aplicação.

Como implementar a validação no Laravel

A validação no Laravel pode ser implementada de várias maneiras, incluindo:

• Form Request Validation: para garantir que os dados enviados por meio de formulários HTML sejam válidos;
• API Request Validation: para garantir que os dados enviados por meio de solicitações API sejam válidos;
• Database Data Validation: para garantir que os dados salvos em um banco de dados sejam válidos.

Independentemente da área em que a validação é necessária, o Laravel usa um processo de três etapas para validar dados:

1. Definir as regras de validação: você define as regras de validação que os dados devem atender. As regras podem ser predefinidas ou personalizadas, dependendo das suas necessidades específicas.
2. Validar os dados: o Laravel valida os dados de acordo com as regras definidas. Se houver algum problema com os dados, o Laravel retornará uma mensagem de erro.
3. Tratar os dados: se os dados forem válidos, o Laravel permitirá que você trabalhe com eles normalmente. Se houver algum problema com os dados, o Laravel impedirá que o processo continue e exibirá uma mensagem de erro.

Laravel fornece várias funções que ajudam de validação e que podem ser utilizadas para validar os dados de uma request.

Por onde começar

Ok, para os próximos exemplos, você vai precisar de um controller. Se caso o seu controller ainda não tiver criado um ainda, você pode criar um facilmente utilizando o comando abaixo:

php artisan make:controller PostController --api

O que deve gerar algo parecido com isso:

class PostController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return JsonResponse
     * @throws AuthorizationException
     */
    public function index()
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param Request $request
     * @return Response
     */
    public function store(Request $request)
    {
        //
    }

    /**
     * Display the specified resource.
     *
     * @param int $id
     * @return Response
     */
    public function show($id)
    {
        //
    }

    /**
     * Update the specified resource in storage.
     *
     * @param Request $request
     * @param int $id
     * @return Response
     */
    public function update(Request $request, $id)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param int $id
     * @return Response
     */
    public function destroy($id)
    {
        //
    }
}

Ok, próximo passo, rotas. Você precisa garantir que sua aplicação tenha rotas que vão direcionar para esse controller. Faremos assim, abra o arquivo routes/api.php do seu projeto Laravel e adicione uma nova linha:

Route::apiResource('posts', PostController::class);

Isso é tudo o que você precisa para acessar os métodos do nosso controller. Laravel automaticamente mapeia as rotas com métodos equivalentes:

Método 1: Usando Validation Helper Functions

Agora que seu controller foi criado e suas rotas já foram criadas, vamos focar no método store do nosso PostController, que será responsável por armazenar um novo Post.

A primeira alternativa que nós temos para validar as entradas do usuário é utilizando o método validate()diretamente na variável $request do seu controller. Aqui está um exemplo de como utilizar a função para validar e armazenar um novo post.

/**
 * Store a new blog post.
 */
public function store(Request $request)
{
    $validated = $request->validate([
      'title' => 'required|unique:posts|max:255',
      'body' => 'required',
    ]);

    // Os dados da request são válidos...

    // Cria um novo post...
    Post::create($validated);

    return Response::json([
      'errors' => false,
      'message' => 'Post created',
    ], 200);
}

Assim que uma requisição POST é feita para o endpoint /posts o método store é executado, isso inicia o processo de validação dos dados.

Como você pode ver, as regras da validação são passadas para o método validate(). Todas as regras de validação disponíveis você pode encontrar aqui.

Nossa validação aqui consiste de duas regras, uma para o titulo e outra para o body. Os dois são marcados com required, mas o title deve ser único, e dever ter no máximo 255 caracteres. Você pode ser bem mais efetivo com a sua validação, e nunca confie 100% nos dados vindos do usuário.

A melhor parte é, que se a validação falhar, a resposta com o erro será automaticamente gerada. Se a validação passar, o método continuará a executar normalmente.

Método 2: Usando Form Request Validation

Para cenários onde a validação é mais complexa e/ou tem muitos campos, Laravel fornece uma funcionalidade nativa chamada Form Request Validation, que lhe permite criar uma classe separada para as regras de validação. Para criar FormRequest você pode usar o comando:

php artisan make:request StorePostRequest

A classe é utilizada para validar os dados de uma request antes de ser passada para o método do controller. Um exemplo de como utilizar o Form Request para o mesmo post do exemplo anterior:

class StorePostRequest extends FormRequest
{
    public function authorize()
    {
        return true;
    }

    public function rules()
    {
        return [
          'title' => 'required|unique:posts|max:255',
          'body' => 'required|min:10',
          'cover' => 'dimensions:min_width=100,min_height=200',
          'author' => 'required|unique:authors',
        ];
    }
}

A classe tem dois métodos, o método authorize é responsável por determinar se o usuário logado pode ou não executar a ação, enquanto o método de rules devolve as regras para a validação que devem ser aplicadas aos dados na request.

Então, como acessar os dados depois da validação? Tudo o que precisa de fazer é inserir o FormRequest nesse caso a nossa classe StorePostRequest como parâmetro da sua função store no controller. A request é validada antes do método no seu controller ser executado, o que significa que você não precisa acrescentar nenhuma lógica de validação no seu controller.

/**
 * Store a new blog post.
 */
public function store(StorePostRequest $request)
{
    // A request é valida

    // Acessa todos os dados validados...
    $validated = $request->validated();

    // Acessa apenas uma parte dos dados validados...
    $validated = $request->safe()->only(['name', 'email']);
    $validated = $request->safe()->except(['name', 'email']);

    // Cria um novo post...
    Post::create($validated);
    
    return Response::json([
      'errors' => false,
      'message' => 'Post created',
    ], 200);
}

Método 3: Criando Validators manualmente

Se você não quiser utilizar o método validate na sua request você pode criar um validator manualmente utilizando o Validator Facade.

class PostController extends Controller
{
    /**
     * Store a new blog post.
     *
     * @param  Request  $request
     * @return Response
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
          'title' => 'required|unique:posts|max:255',
          'body' => 'required',
        ]);

        if ($validator->fails()) {
            return Response::json([
              'errors' => true,
              'message' => 'Dados incompletos ou errados, por favor verifique',
            ], 422);
        }
        
        // A request é valida
        
        // Acessa todos os dados validados...
        $validated = $validator->validated();

        // Acessa apenas uma parte dos dados validados...
        $validated = $validator->safe()->only(['name', 'email']);
        $validated = $validator->safe()->except(['name', 'email']);

        // Store the blog post...
        return Response::json([
          'errors' => false,
          'message' => 'Post created',
        ], 200);
    }
}

O primeiro argumento passado para o método make() são os dados para a validação. O segundo argumento é um conjunto de regras de validação que devem ser aplicadas aos dados.

Após determinar se a validação falhou ou não, você pode decidir qual mensagem retornar para o usuário, ao invés da mensagem auto gerada pelo framework, isso de da um pouco mais de flexibilidade trabalhando com a validação dos dados.

Conclusão

A validação é uma parte importante de qualquer aplicação web, pois ajuda a garantir que os dados enviados pelos usuários sejam válidos e seguros. O Laravel torna a implementação da validação fácil e intuitiva, permitindo que você defina suas próprias regras de validação personalizadas e oferecendo uma série de regras predefinidas para atender a diferentes necessidades.

Neste guia, aprendemos como implementar a validação no Laravel e vimos alguns exemplos práticos de como validar diferentes tipos de dados. Esperamos que isso ajude você a tornar suas aplicações Laravel mais seguras e eficientes!

Alguns sites e até mesmo a própria documentação oficial costumar chamar as Collections de “Arrays com esteroides” e nesse artigo você vai saber o porque.

Porque usar Collections?

Um Array é uma estrutura de dados simples que contém um ou mais elementos em uma única variável. Os arrays em PHP no entanto têm um grande problema, eles não são Orientados a Objetos.

Collections por sua vez é um poderoso recurso Orientado a Objetos que expande as possibilidades quando se trabalha com arrays em Laravel. Além disso, Collections nos permite escrever códigos mais eficientes de forma mais fácil.

Como criar Collections

O método helper collect() retorna uma novo instancia da classe Illuminate\Support\Collection. Portanto, criar uma coleção é tão simples quanto:

$collection = collect([1, 2, 3]);
$collection = collect(['produto' => 'Mesa', 'preco' => 200]);

Laravel Collections – where()

O método where() filtra uma Collection por um determinado par chave/valor. Esse método pode receber até três parâmetros, sendo o primeiro a chave que você quer buscar, o operador (=, <>, >=) e o terceiro parâmetro é o valor que você quer comparar.

Digamos que temos uma loja virtual, e o usuário quer filtrar os produtos por preço, utilizando esse método sua vida fica muito mais simples.

No exemplo abaixo, estamos filtrando todos os produtos com preço igual a R$100.

$colecao = collect([
    ['produto' => 'Mesa', 'preco' => 200],
    ['produto' => 'Cadeira', 'preco' => 100],
    ['produto' => 'Estante', 'preco' => 150],
    ['produto' => 'Armario', 'preco' => 100],
]);
 
$filtrado = $colecao->where('preco', 100);
 
$filtrado->all();
 
/*
    [
        ['produto' => 'Cadeira', 'preco' => 100],
        ['produto' => 'Armario', 'preco' => 100],
    ]
*/

Lembrando que o segundo parâmetro da função é o operador se o terceiro parâmetro for omitido, o operador padrão é o = então você pode mudar para o operador que você precisar, “maior ou igual (>=) R$100″ por exemplo.

O código abaixo retorna exatamente o mesmo resultado:

$colecao = collect([
    ['produto' => 'Mesa', 'preco' => 200],
    ['produto' => 'Cadeira', 'preco' => 100],
    ['produto' => 'Estante', 'preco' => 150],
    ['produto' => 'Armario', 'preco' => 100],
]);
 
$filtrado = $colecao->where('preco', 100);
$filtrado = $colecao->where('preco', '=', 100);

Laravel Collections – pluck()

O método pluck() retorna todos os valores a partir de uma determinada chave. Vou te mostrar o como isso pode ser extremamente útil, considere o mesmo exemplo acima, agora imagine que você precisa de um array contendo apenas o nome de todos os produtos, como você faria? Exatamente, usando pluck().

$colecao = collect([
    ['produto' => 'Mesa', 'preco' => 200],
    ['produto' => 'Cadeira', 'preco' => 100],
    ['produto' => 'Estante', 'preco' => 150],
    ['produto' => 'Armario', 'preco' => 100],
]);
 
$filtrado = $colecao->pluck('produto');
 
$filtrado->all();
 
/*
   ['Mesa', 'Cadeira', 'Estante', 'Armario'],
*/

Com esse método você também pode definir qual a chave do valor na resposta, como no exemplo acima só temos duas propriedades em cada item do array, a chave teria que ser preco.

$colecao = collect([
    ['produto' => 'Mesa', 'preco' => 200],
    ['produto' => 'Cadeira', 'preco' => 100],
    ['produto' => 'Estante', 'preco' => 150],
    ['produto' => 'Armario', 'preco' => 100],
]);
 
$filtrado = $colecao->pluck('produto', 'preco');
 
$filtrado->all();
 
/*
   [200 => 'Mesa', 100 => 'Cadeira', 150 => 'Estante', 100 => 'Armario'],
*/

Outro fato muito importante desse método que preciso mencionar é que se você tiver um objeto com propriedades aninhadas, você pode usar a notação “dot” para acessar esse valores. Eu explico o que eu quero dizer com o exemplo abaixo:

$colecao = collect([
    [
        'palestrantes' => [
            'primeiro_dia' => ['Rosa', 'Alberto'],
            'segundo_dia' => ['Angela', 'Monica'],
        ],
    ],
]);
 
$filtrado = $colecao->pluck('palestrantes.primeiro_dia');
 
$filtrado->all();
 
/*
   ['Rosa', 'Alberto']
*/

Não sei quanto a vocês, mas acho que esse método extremamente útil para diversas situações.

Laravel Collection – contains()

O método contains() determina se a coleção contém um determinado item. Você pode passar um função para o método, que vai determinar se existe um elemento na coleção que corresponda a uma determinada condição. Essa é a função mais básica desse método.

$colecao = collect([1, 2, 3, 4, 5]);
 
$colecao->contains(function ($valor, $chave) {
    return $valor > 5;
});

// false

Mais uma vez, vamos usar como exemplo a nossa coleção de produtos. Vamos pensar na situação onde precisamos verificar se temos um determinado produto em nossa loja, poderíamos utilizar esse método, que vai retornar true ou false, caso o produto exista na loja ou não.

$colecao = collect([
    ['produto' => 'Mesa', 'preco' => 200],
    ['produto' => 'Cadeira', 'preco' => 100],
    ['produto' => 'Estante', 'preco' => 150],
    ['produto' => 'Armario', 'preco' => 100],
]);

$colecao->contains('produto', 'Cadeira');

// true

Laravel Collections – duplicates()

Outro método que pode ser muito útil é o duplicates(). Ele recupera e devolve valores duplicados da coleção. Nesse primeiro exemplo, um situação bem simples, mas você já entende como o método funciona.

A coleção abaixo contém 5 elementos, sendo que 2 tem repetições (a, b), o método então retorna um novo array com onde a chave se refere a posição do elemento repetido no array original

$colecao = collect(['a', 'b', 'a', 'c', 'b']);
 
$colecao->duplicates();
 
// [2 => 'a', 4 => 'b']

Por exemplo, temos duas letras ‘a’ na coleção, então o método nos retorna [2 => 'a', 4 => 'b'] indicando que temos uma repetição da letra ‘a’ na posição 2 da coleção e repetição da letra ‘b’ na posição 4.

Agora um exemplo mais realístico. Digamos que fizemos cadastro de alguns usuários, mas a validação de email único não estava funcionando perfeitamente e por conta disso temos agora emails duplicados no nosso sistema e precisamos encontrar essas duplicatas, com o método duplicates() isso se torna um tarefa muito simples:

$usuarios = collect([
    ['email' => 'rosa@example.com', 'profissao' => 'Gerente de projetos'],
    ['email' => 'alberto@example.com', 'profissao' => 'Desenvolvedor'],
    ['email' => 'angela@example.com', 'profissao' => 'Analista de projetos'],
    ['email' => 'alberto@example.com', 'profissao' => 'Desenvolvedor'],
    ['email' => 'monica@example.com', 'profissao' => 'Design gráfico'],
    ['email' => 'alberto@example.com', 'profissao' => 'Desenvolvedor N2'],
]);

$usuarios->duplicates('email');

// [3 => 'alberto@example.com', 5 => 'alberto@example.com']

Laravel Collection – firstWhere()

O método firstWhere() retorna o primeiro elemento da coleção com o par chave/valor que corresponde a um valor dado. Nós ja vimos o método where(), e parece que esse método não faz muito, mas você precisaria de um loop, um if e talvez um break, só para conseguir reproduzir o que esse método faz.

O exemplo abaixo, muito parecido com o exemplo do método where(), mas ao invés de retornar dois valores, ele nos retorna apenas um, a primeira ocorrência de um produto com valor igual a R$100.

$colecao = collect([
    ['produto' => 'Mesa', 'preco' => 200],
    ['produto' => 'Cadeira', 'preco' => 100],
    ['produto' => 'Estante', 'preco' => 150],
    ['produto' => 'Armario', 'preco' => 100],
]);
 
$colecao->firstWhere('preco', 100);
 
// ['produto' => 'Cadeira', 'preco' => 100]

(Bônus) Laravel Collection – groupBy()

E o nosso último método da lista o groupBy(), geralmente é um operação feita diretamente usando SQL no banco de dados, mas nem sempre os dados que queremos manipular vem diretamente de lá, nesse caso podemos utilizar desse método para resolver um problema similar, vejamos como utilizar:

$usuarios = collect([
    ['nome' => 'Rosa Silva', 'equipe' => 'Back-end'],
    ['nome' => 'Alberto Junior', 'equipe' => 'Back-end'],
    ['nome' => 'Angela Maria', 'equipe' => 'Front-end'],
    ['nome' => 'Tomas Costa', 'equipe' => 'Back-end'],
    ['nome' => 'Monica Silveira', 'equipe' => 'Front-end'],
    ['nome' => 'Lucia Oliveira', 'equipe' => 'Front-end'],
]);

$grupos = $usuarios->groupBy('equipe');

//    {
//        {
//          "Back-end": [
//            { "nome": "Rosa Silva", "equipe": "Back-end" },
//            { "nome": "Alberto Junior", "equipe": "Back-end" },
//            { "nome": "Tomas Costa", "equipe": "Back-end" 
//          ],
//          "Front-end": [
//            { "nome": "Angela Maria", "equipe": "Front-end" },
//            { "nome": "Monica Silveira", "equipe": "Front-end" },
//            { "nome": "Lucia Oliveira", "equipe": "Front-end" }
//          ]
//        }
//    }

Como resultado do groupBy() nessa coleção, agora temos dos arrays, cada um contendo 3 elementos, que corresponde exatamente aos desenvolvedores que fazem parte da equipe do front-end e o no outro array os desenvolvedores do time back-end, como você pode ver, esse método definitivamente da uma ajuda na hora de organizar o seus arrays.

Para o exemplo do artigo anterior, validar dentro do controller é ok, pois o formulário tem poucos campos e não fica complexo de ler ou de ajustar as regras se necessário.

Mas as vezes a validação é bem mais complexa ou o seu formulário tem muitos campos, nesse caso, usar o Form Request faz bem mais sentido.

As Form Request são classes de requests personalizadas que encapsulam sua própria lógica de validação e autorização.

Ok, um pouco complexo, mas o exemplo abaixo vai ajudar a entender melhor.

Digamos que tenhamos essas regras de validação:

        $validated = request()->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|email|max:80',
            'mobile' => 'required|digits:11',
            'address1' => 'required|email|max:80',
            'postcode' => 'required|digits:11',
            'state' => 'required|string|in:ES,RJ,SP,MG',
            'street' => 'required|string|max:80',
            'suburb' => 'required|string|max:80',
            'apt_number' => 'string|numeric|required_if:house_number,null',
            'house_number' => 'string|numeric|required_if:apt_number,null',
        ]);

Como criar um Form Request

Como você pode ver, são regras mais complexas que no exemplo anterior. Nesse caso, o controller talvez já não seja mais o lugar ideal para essa validação.

Vamos criar o nosso Form Request para armazenar essas regaras. Vamos utilizar o comando make:request do artisan para isso.

php artisan make:request StoreUserRequest

Agora, se você olhar na pasta App/Http/Requests você vai ver a nossa nova classe que deve ser parecida com essa abaixo:

<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class StoreProjectRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return false;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        return [ ];
    }
}

Ok, a primeira coisa que precisamos fazer, é mudar o return do método authorize() de false para true, esse método verifica se o usuário tem autorização para executar essa request, mas não vamos trabalhar com isso agora, vamos apenas validar os campos do usuário.

O próximo passo então é colocar todas aquelas regras dentro do método rules().

<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class StoreUserRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        return [ 
            'name' => 'required|string|max:255',
            'email' => 'required|email|max:80',
            'mobile' => 'required|digits:11',
            'address1' => 'required|email|max:80',
            'postcode' => 'required|digits:11',
            'state' => 'required|string|in:ES,RJ,SP,MG',
            'street' => 'required|string|max:80',
            'suburb' => 'required|string|max:80',
            'apt_number' => 'string|numeric|required_if:house_number,null',
            'house_number' => 'string|numeric|required_if:apt_number,null',
         ];
    }
}

Como utilizar Form Request

Ok, ja criamos o nosso Form Request, mas ele não começa a validar nossas requests magicamente sem fazermos nada.

Precisamos incluir a instancia dessa classe no nosso controller, mais especificamente no nosso método store().

<?php

namespace App\Http\Controllers;

use App\Htpp\Requests;

class UserController extends Controller
{
    public function create()
    {
        return view('user.create');
    }

    // Registra o usuario no banco de dados
    public function store(StoreUserRequest $request)
    {
        // Os valores dentro da request já estão validados nesse ponto
        $validated_with_role = array_merge($request->validated(), ['role' => 'user']);
        User::create($validated_with_role);
    }
}

Service Container do Laravel toma conta de instanciar a classe e nos retornar esse objeto que resolvi chamar de $request mas você pode chamar do jeito que você quiser.

Esse objeto inclui varias funções bem uteis. Mas à que estamos interessados agora é o método validated() esse método retorna um array como todos os valores que passaram na validação do nosso Form Request.

Desse ponto, você já tem seus dados validados, e só precisamos incluir o role ou qualquer outro campo necessário que não venha a partir do usuário.

Por fim, basta criar o novo usuário com o método User::create().