crud-laravel

Como criar um CRUD usando Laravel

Este é o primeiro de uma série de três posts que compõem um tutorial de programação que trata da criação de um CRUD simples usando o framework Laravel.

Normalmente a primeira habilidade que os iniciantes desejam adquirir é como criar uma aplicação CRUD usando o Laravel.

No texto usei uma abordagem gradativa de forma a apresentar aos poucos os diversos conceitos envolvidos nesta atividade.

Assim, o código exemplo que será apresentado aqui será construído e melhorado em etapas sucessivas, evoluindo a cada post até ser concluído no post final.

É um post para iniciantes e apresenta conceitos introdutórios, assim, se você já tem experiência na criação de CRUD e quer apenas um boilerplate, pode ir diretamente para o código finalizado, ele está disponível no repositório:

https://github.com/ewertonvaz/lara-crud

Conheça nosso Novo Curso NUXT.js e TailwindCSS para turbinar a criação de front-ends

Assuntos

Por outro lado, se você é um iniciante em Laravel, irá se beneficiar muito com a leitura dos três posts, pois nesta série de tutorias de programação iremos tratar de vários assuntos, entre eles:

  • Definir rotas e controller Resources no Laravel 8
  • Gerar os models e suas migrations
  • Usar Bootstrap com o Laravel 8
  • Route Model bindig e named routes
  • Usar seed e factory para popular o banco de dados
  • Implementar a paginação usando Bootstrap com Laravel 8
  • Validar os dados de entrada do formulário

Conceitos

O acrônimo CRUD vem do inglês e representa Create Read (ou retrieve) Update e Delete (ou destroy), sendo usado para designar os aplicativos que implementam estas operações em um banco de dados.

É o tipo de aplicativo mais comum na vida de um desenvolvedor e aquele que já pode gerar uma receita financeira mesmo para o iniciante.

Procurei manter nesse texto um procedimento que possa ser usado independentemente da versão do Laravel e que utilize apenas os recursos presentes na instalação padrão do framework, ou seja, sem a necessidade de instalar pacotes adicionais.

Algumas atividades descritas aqui podem ser simplificadas pelo uso de outros pacotes como por exemplo: Bootstrapper, Laravel Collective e outros, e com certeza futuramente você irá usar um destes, porém neste artigo eles não serão abordados.




Etapas do CRUD no Laravel

Estão listadas abaixo as etapas necessárias para criar um CRUD simples usando Laravel:

  1. Configurar o banco de dados
  2. Criar uma rota para os resources
  3. Criar um Resource Controller
  4. Criar uma migration
  5. Criar um model
  6. Criar as views (layouts do Blade)

No decorrer deste texto iremos detalhar cada um destes passos, mostrando os comandos necessários e ilustrando com as telas que surgem durante o processo.

O exemplo que iremos apresentar neste texto é o desenvolvimento de um CRUD para armazenar dados de equipamentos.

Configurar o banco de dados

Para trabalhar com um CRUD o primeiro e indispensável passo é configurar o Laravel para ter acesso a um banco de dados. Esta etapa também será necessária uma vez apenas para cada aplicativo, por estes motivos que a rotulei como ETAPA ZERO.

Executar esta etapa envolve uma alteração no arquivo .env, e caso você ainda não a tenha executado ou não saiba como fazer pode consultar este outro POST onde demonstro como configurar o Laravel para trabalhar com o banco de dados SQLITE.

Criar uma rota para os resources

Em seguida será necessário criar uma rota do tipo resources, para isto edite o arquivo /routes/web.php e inclua no final do mesmo o seguinte trecho de código:

Route::resource('/equipamento', 'EquipamentosController');

Com esta única linha de código o Laravel irá se encarregar de gerar, automaticamente, todas as rotas necessárias ao CRUD.

Resource routes no Laravel 8

Caso já esteja usando a versão Laravel 8, lançada recentemente, será necessário editar o arquivo /app/Providers/RouteServiceProvider.php e fazer as alterações destacadas no trecho de código abaixo:

...
  protected $namespace = 'App\\Http\\Controllers';
...
    public function boot()
    {
        $this->configureRateLimiting();

        $this->routes(function () {
            Route::prefix('api')
                ->middleware('api')
                ->namespace($this->namespace)
                ->group(base_path('routes/api.php'));

            Route::middleware('web')
                ->namespace($this->namespace)
                ->group(base_path('routes/web.php'));
        });
    }

Note que, a depender da versão, este código poderá estar quase todo pronto e a única alteração necessária será tirar o comentário da linha 2.

Após fazer as alterações descritas acima, para verificar se foram bem sucedidas, vamos listar as rotas usando o comando abaixo:

php artisan route:list

Observe que, conforme a tela ilustrada abaixo, já existem as rotas correspondentes às operações store, index, create, update, show, destroy e edit, todas elas relacionadas ao CRUD.

Omitindo rotas

Na tela acima foi possível verificar que usando uma rota do tipo resource automaticamente foram criadas rotas para os procedimentos relacionados ao CRUD.

Porém, nem sempre todas estas rotas são utilizadas, de forma que, até por razões de segurança, às vezes é desejável que algumas destas rotas não sejam geradas automaticamente.

Assim, como exemplo, vamos usar o método except para omitir algumas das rotas acima. Desta forma altere o código da linha anterior para que fique igual ao abaixo:

Route::resource('/equipamento', 'EquipamentosController')->except([
    'show', 'edit'
]);

Após esta alteração execute novamente o comando para listar as rotas e deverá obter uma tela semelhante a abaixo:

Observe na ilustração que agora foram omitidas as rotas show e edit.

Nota: este é só um exemplo de como omitir as rotas predefinidas, não se trata de uma recomendação, boa prática ou padrão. Agora que você já sabe como fazer fica a seu critério definir no resources quais rotas serão criadas e quais serão omitidas.

Criar um Resource Controller

O conceito de Resource Controller, em uma tradução livre da documentação do Laravel, é o seguinte:

“As rotas do tipo recurso (resources) do Laravel atribuem as rotas “CRUD” típicas para um controlador com uma única linha de código. O seu respectivo controlador (Resource Controller) conterá um método para cada uma das operações de recursos disponíveis nas rotas.”

Em outras palavras, uma rota do tipo recurso irá, automaticamente, criar uma rota para cada operação do CRUD (create, edit, update, destroy etc.) e o respectivo Resource Controller conterá os códigos necessários para implementar estas operações.

Para consultar a página do manual no Laravel docs referente aos Resource Controller acesse o link abaixo:

https://laravel.com/docs/7.x/controllers#resource-controllers

Na prática, que é nosso foco neste tutorial, o framework Laravel é capaz de gerar os códigos iniciais de um Resource Controller. Assim, prosseguindo nosso exemplo, para gerar um controller referente aos Equipamentos digite o comando abaixo:

php artisan make:controller EquipamentosController --resource

Este comando fará com que seja gerado o arquivo app\Http\Controllers\EquipamentosController.php, correspondente a um esqueleto de código, também chamado de boilerplate, que servirá de ponto de partida para o projeto que estamos desenvolvendo neste texto.

Caso queira poderá acessar o arquivo EquipamentosController.php, criado acima, e verificar que ele já contém o código base para cada uma das rotas criadas no tópico anterior.




Criar uma migration

No Laravel a criação das tabelas no banco de dados é feita por meio das migrations. Em nosso exemplo iremos criar uma tabela simples para armazenar informações sobre equipamentos, ela conterá os seguintes campos:

  • id : número de identificação interno ao sistema, gerado automaticamente por auto incremento;
  • tipo: string de 50 caracteres contendo o tipo do equipamento, como por exemplo: impressora, notebook, microcomputador etc.
  • modelo: string de 15 caracteres que armazenará o modelo do equipamento;
  • fabricante: string de 30 caracteres que armazenará o modelo do equipamento

Para os fins de nosso CRUD exemplo isto é o suficiente, não iremos definir relacionamento com outras tabelas, fica para um outro post.

Gerando a migration

Aproveitando o gerador de códigos do Laravel vamos agora criar um boilerplate de nossa migration.

Para isto digite a linha de código abaixo:

php artisan make:migration CreateEquipamentosTable

Pelo comando acima o Laravel entenderá que desejamos gerar o código para uma migration de criação da tabela Equipamentos e irá gerar o arquivo correspondente.

Verifique na saída da linha de comando o nome do arquivo que foi gerado pelo Laravel, conforme a tela abaixo:

Em nosso exemplo foi gerado o arquivo 2020_08_15_154251_create_equipamentos_table.php que se encontra na pasta database\migrations\.

Complementando a migration

Prosseguindo vamos agora complementar o arquivo citado acima para que ele possa criar a tabela conforme a definição de campos do início deste tópico. Assim, altere a função up no código do arquivo para que fique da seguinte forma:

public function up()
{
        Schema::create('equipamentos', function (Blueprint $table)
{
            $table->increments('id');
            $table->string('tipo', 50);
            $table->string('modelo', 15)->nullable();
            $table->string('fabricante', 30)->nullable();
            $table->timestamps();
            $table->index(['tipo','modelo']);
        });
    }

Examinando o boilerplate de código podemos observar que o campo id, do tipo auto incremento já havia sido definido e, além disso,  que está sendo utilizado o método $table->timestamps(), este é responsável pela criação dos campos created_at e updated_at, respectivamente para armazenar o tempo de criação e de atualização do registro.

As alterações que fizemos estão destacadas, e o que elas fazem é definir, nas linhas de 6 a 8, os campos da tabela e, na linha 10, criar um índice composto pelo tipo e pelo nome do equipamento.

Usando o método nullable definimos que um determinado campo pode conter um valor nulo, caso não façamos isto o preenchimento deste campo será obrigatório.

Para saber mais sobre a definição dos campos consulte a documentação do Laravel no link:

https://laravel.com/docs/7.x/migrations#creating-tables

Executando a migration

Para criar a tabela será necessário agora executar as migrations. Para isto basta digitar o comando abaixo:

php artisan migrate

Nota: Este é um comando potencialmente destrutivo que pode facilmente apagar todos os dados das tabelas de seu sistema.




Criar um model

No que diz respeito a manipulação de bancos de dados o Laravel utiliza o Eloquent ORM que consiste em uma implementação do padrão de projeto ActiveRecord, o qual, em linhas gerais, preconiza que cada objeto representa uma linha de uma tabela de seu banco de dados, ou seja, cada registro  deverá corresponder a um objeto, instância de uma classe, que, por sua vez, deverá possuir um método para cada atributo na tabela correspondente.

Além disso cada tabela do banco de dados corresponderá a um Model e, através dele, serão feitas as consultas, inserções e remoções nas respectivas tabelas. Assim, o Eloquent cuida de todas as operações relacionados com criação das tabelas, definição de chaves, relacionamentos, inserção e remoção de registros e outras mais, de forma que você não precisará escrever nenhuma query SQL.

Assim, agora que temos a tabela criada pela migration vamos criar um Model para associar com esta tabela.

Para criar o model correspondente a tabela equipamentos digite o seguinte comando:

php artisan make:model Equipamento

Models no Laravel 8

Até a versão Laravel 7 os models gerados com o comando acima eram criados na pasta /app, porém a partir da versão Laravel 8, atendendo a uma solicitação antiga da comunidade de desenvolvedores, os models passaram a ser criados na pasta /app/Models.

Atenção! Caso não exista a pasta /app/Models, os models serão criados na pasta /app como de costume. Para novos projetos do Laravel esta pasta é criada durante a instalação do framework. Assim, no caso de atualização de versões anteriores para o Laravel 8, a pasta /app/Models deverá ser criada manualmente.

Ao acompanhar este tutorial tenha em mente que o model Equipamento, dependendo de como fez sua instalação do Laravel, poderá ser encontrado nas patas /app ou na pasta /app/Models.

Atenção ! Em virtude do que foi descrito acima, ao referenciar o model Equipamentos você deverá usar uma das duas formas:
use App\Equipamento; ou
use App\Models\Equipamento;
A depender da pasta em que estiver localizado o model, então durante a leitura faça as adaptações necessárias no código.

Nome da tabela

O Laravel irá deduzir o nome a tabela correspondente através da convenção Snake Case, que, em resumo, preconiza que o nome da tabela será o nome do model no plural, ou seja, adicionado um “s” no final.

Desta forma, sem que precisemos digitar nenhuma linha de código, o Laravel será capaz de entender que este model estará associado à tabela equipamentos criada no tópico anterior no qual definimos a migration.

Segundo a documentação do Laravel, um Model pode ser entendido como um poderoso construtor de consultas (Query Builder) pelo qual poderemos inserir, recuperar e destruir registro em uma tabela, porém sem a necessidade de digitar os comandos da linguagem SQL.

Desta forma, todas as operações na tabela serão feitas por intermédio do Model correspondente.

Prosseguindo em nosso exemplo, complemente o arquivo do model gerado pelo Laravel que está na pasta app\Equipamento.php digitando o seguinte código:

class Equipamento extends Model
{
    //
     protected $fillable = [
    	'tipo',
     	'modelo',
     	'fabricante'
	];
}

Fillable

Por padrão os atributos de um Model são protegidos de uma vulnerabilidade que consiste na possibilidade de, indevidamente, uma requisição HTTP enviar um parâmetro não esperado que, por sua vez, consegue alterar um valor de um campo na tabela do banco de dados.

Um exemplo, dado na própria documentação do Laravel, seria o caso de um usuário mal-intencionado enviar um parâmetro is_admin por meio de uma solicitação HTTP, que seria então passada para o método de criação do Model, permitindo ao usuário escalar a si mesmo como um administrador.

Por este motivo é necessário informar o campo fillable que conterá um array com o nome dos atributos (campos) que podem ser preenchidos diretamente nas operações mass assignment, como a produzida por uma requisição http, ou pelo uso da operação create para, em uma única linha, criar, salvar e retornar uma instância de um Model.

Se quiser saber mais sobre os models consulte a seguinte página do manual:

https://laravel.com/docs/7.x/eloquent#defining-models

Criar as views (templates do Blade)

A última etapa, e mais trabalhosa, é a criação dos views, ou seja, dos templates Blade que irão fornecer a interface para nosso CRUD.

Laravel 8 e Bootstrap

Este tutorial foi escrito originalmente tendo como base o Laravel 7, e nessa versão o Bootstrap era o framework CCS/Javascript utilizado como padrão pelo Laravel.

Contudo, a partir da versão 8, o Laravel passou a adotar o framework TailwindCSS como padrão.

Por este motivo, faremos uma adaptação neste tutorial para utilizar o Bootstrap e para que os códigos continuem a funcionar no Laravel 8.

Template App (Bootstrap)

Para utilizar o Bootstrap em nosso CRUD iremos criar a pasta /app/resources/views/layouts e nela criar o arquivo app.blade.php.

Neste arquivo (app.blade.php) copie e cole o código abaixo:

<!DOCTYPE html>
<html lang="{{ app()->getLocale() }}">
    <head>
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1">

        <meta name="csrf-token" content="{{ csrf_token() }}">

        <title>{{ config('app.name', 'Laravel') }}</title>

        <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css" integrity="sha384-HSMxcRTRxnN+Bdg0JdbxYKrThecOKuH5zCYotlSAcp1+c8xmyTe9GYg1l9a69psu" crossorigin="anonymous">
    </head>
    <body>
        <div id="app">
            <nav class="navbar navbar-default navbar-static-top">
                <div class="navbar-header">
                    <a href="http://localhost:8000" class="navbar-brand">
                    {{ config('app.name', 'Laravel') }}
                    </a>
                </div> 
            </nav>
            @yield('content')
        </div>
        <script src="https://code.jquery.com/jquery-1.12.4.min.js" integrity="sha384-nvAa0+6Qg9clwYCGGPpDQLVpLNn0fRaROjHqs13t4Ggj3Ez50XnGQqc/r8MhnRDZ" crossorigin="anonymous"></script>
        <script src="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/js/bootstrap.min.js" integrity="sha384-aJ21OjlMXNL5UyIl/XNwTMqvzeRMZH2w8c5cRVpzpU8Y5bApTppSuUkhZXN0VxHd" crossorigin="anonymous"></script>
    </body>
</html>

Este código será responsável pelo layout padrão do CRUD e por instalar o Bootstrap 3.4.1 usando uma CDN para isto.

Template index Equipamentos

Prosseguindo, vamos criar o template inicial de nosso CRUD, para isto crie na pasta resources\views uma subpasta chamada equipamentos e dentro dela o arquivo index.blade.php.

Neste arquivo digite o seguinte código:

@extends('layouts.app')
@section('content')
<div class="container">
	<div class="row">
		<div class="col-md-4">
			<h3>Listagem de Equipamentos</h3>
		</div>
		<div class="col-md-8">
			<a href="" class="btn btn-primary">Incluir Equipamento</a>
		</div>
	</div>
    <div class="row">
    	<table class="table table-striped">
    		<thead>
    			<tr>
    				<th>Id</th>
    				<th>Tipo</th>
    				<th>Modelo</th>
					<th>Fabricante</th>
    				<th>Ações</th>
    			</tr>
    		</thead>
    		<tbody>
    		@foreach($equipamentos as $equipamento)
    			<tr>
    				<td>{{ $equipamento->id }}</td>
    				<td>{{ $equipamento->tipo }}</td>
    				<td>{{ $equipamento->modelo }}</td>
					<td>{{ $equipamento->fabricante }}</td>
    				<td>
    					<ul class="list-inline">
    						<li>
    						<a href="">Editar</a>
    						</li>
    						<li>
    						<a href="">Deletar</a>
							</li>
    					</ul>
    				</td>
    			</tr>
    		@endforeach
    		</tbody>
    	</table>
    </div>
</div>
@endsection

Este código implementa o layout responsável por listar todos os equipamentos cadastrados. Ele será acionado pelo método index() do EquipamentoController.

Desta forma, em seguida vamos implementar este método, para isto devemos alterar o arquivo app\Http\Controllers\EquipamentosController.php e digitar na função index() o seguinte código:

public function index()
{
        $equipamentos = Equipamento::all();
        return view('equipamentos.index', compact('equipamentos') );
 }

Ainda neste arquivo EquipamentosController insira no início, na cláusula use, uma referência para o model Equipamento digitando o seguinte código:

use App\Equipamento;

Vamos examinar o código do método index acima. Primeiro, através do método estático all do Model Equipamento, ele recupera todos os registros da respectiva tabela e os armazena como uma Collection na variável $equipamentos.

Em seguida, retorna a view equipamentos.index (ou seja o arquivo index.blade.php que está na pasta equipamentos) .

Observe que será passado um parâmetro do tipo array, este foi obtido utilizando a função compact do PHP para transformar em um array a Collection que foi armazenada em $equipamentos .

Consulte este POST se quiser saber um pouco mais sobre a passagem de parâmetros para os layouts do Blade.

Vale dizer mais uma vez que esta é um texto no qual procuramos utilizar somente os recursos fornecidos em uma instalação padrão do Laravel.

Assim, este procedimento assume que não temos nenhum pacote adicional, como o Collective Forms ou o Bootstrap, que sirva para simplificar a criação dos layouts.

Neste ponto vamos fazer um teste de como está ficando a interface do crud, para isso digite no browser a url: http://localhost:8000/equipamento e, caso tudo tenha corrido bem, deverá ver uma tela semelhante a abaixo:

Criando o formulário

Prosseguindo vamos agora codificar o formulário de inclusão de equipamentos. Para isto crie na pasta resources\views\equipamentos o arquivo _form.blade.php e nele digite o seguinte código:

<form action={{route('equipamento.store')}} method="post">
    @csrf
    <input type="hidden" id="redirect_to" name="redirect_to" value={{URL::previous()}}>
    <div>
        <label for="tipo">Tipo Equipamento</label>
        <input type="text" id="tipo" name="tipo">
    </div>
    <div>
        <label for="modelo">Modelo Equipamento</label>
        <input type="text" id="modelo" name="modelo">
    </div>
    <div>
        <label for="fabricante">Fabricante Equipamento</label>
        <input type="text" id="fabricante" name="fabricante">
    </div>

Este formulário poderá ser reaproveitado nas telas de incluir, editar e deletar.

Note também que não foi incluída a tag de fechamento do formulário, ou seja, </form>, ela será incluída em outra parte do código.




CSRF Field

Por questões de segurança no Laravel sempre que definirmos um formulário HTML também devemos incluir um campo de token CSRF. Este campo deverá ser oculto no formulário e será usado pelo middleware de proteção CSRF para validar a solicitação.

Nas versões mais novas do Laravel você pode usar a diretiva @csrf Blade para gerar este campo de token. Nas mais antigas era usado o campo {{ csrf_field() }}.

Assim, caso esteja trabalhando com uma versão mais antiga do framework e tenha problemas com o código acima usando o @csrf basta substitui-lo pelo {{ csrf_field() }}.

Alterando o layout.app

No arquivo resources\views\layouts\app.blade.php inserir logo após a tag de abertura <body> o código abaixo:

@if(Session::has('message'))
   <div class="alert alert-sucess alert-dismissible show" role="alert">
        <strong> {!! session()->get('message') !!}</strong>
        <button type="button" class="close" data-dismiss="alert" aria-label="Close">
           <span aria-hidden="true">×</span>
        </button>
   </div>
@endif

Este código servirá para exibir o resultado das operações feitas no model, para isto fará uso do recurso session, que consiste em um helper disponível globalmente nos aplicativos Laravel,  e cujo método get irá recuperar o valor do campo message que foi passado como parâmetro.

Veremos um pouco mais sobre o helper session , em especial como incluir valores na seção que podem ser recuperados depois, em outros tópicos deste texto.

Incluir

Agora vamos criar o layout Blade responsável pela inclusão de equipamentos, para isto crie o arquivo resources\views\equipamentos\create.blade.php e nele digite o código abaixo:

@extends('layouts.app')

@section('content')
<div class="container">
	<div class="row">
		<h3>Novo Equipamento</h3>
		@include('equipamentos._form')
		<div class="form-group">
			<input type="submit" name="save_eqp" value="Salvar equipamento">
			<input type="submit" name="cancel" value="Cancelar">
		</div>
	</div>
	</form>
</div>
@endsection

Neste código temos a destacar que ele herda o layout app.blade.php localizado na pasta layouts, cujo código alteramos no início deste tópico.

Além disso, por meio da diretiva include, utiliza o código de formulário (_form.blade.php) que criamos anteriormente.

Em seguida o código cria dois botões do tipo submit, um com o nome de save_eqp e outro com o nome cancel.

Utilizando estes nomes vai ser possível identificar em outra parte do código qual dos botões foi acionado no formulário.

Note também que a tag <form> que foi aberta no layout _form, é fechada neste novo código.

Volte agora ao arquivo resources\views\equipamentos\index.blade.php e faça a alteração abaixo no código original:

....
<div class="col-md-4">
<h3>Listagem de Equipamentos</h3>
</div>
<div class="col-md-8">
<a href="{{route('equipamento.create')}}" class="btn btn-primary">Incluir Equipamento</a>
</div>
...

Esta alteração é necessária para que o botão “Incluir Equipamento” funcione de forma a exibir o formulário de inclusão.

Create e Store

Precisamos agora fazer as alterações nas funções create e store que estão no arquivo app\Http\Controllers\EquipamentosController.php.

Assim, prosseguindo nosso exemplo, no EquipamentosController.php digite o código abaixo:

public function create()
{
    //
    return view('equipamentos.create', ['action'=>route('equipamento.store'), 'method'=>'post']);
}

O que esta linha de código faz é acionar o layout create.blade.php que fica na pasta equipamentos, além de passar dois parâmetros para este layout.

Este layout Blade implementa um formulário HTML, sendo que o parâmetro action conterá a ação executada quando o referido formulário for submetido.

Quanto ao outro parâmetro, o method, ele contém o método HTTP que neste caso será o post.

Prosseguindo, continue a alterar este arquivo agora a function store, nela digite o código abaixo:

    public function store(Request $request)
    {
        //
        $url = $request->get('redirect_to', route('equipamento.index'));
        if (! $request->has('cancel') ){
            $dados = $request->all();
            Equipamento::create($dados);
            $request->session()->flash('message', 'Equipamento cadastrado com sucesso');
        }
        else
        { 
            $request->session()->flash('message', 'Operação cancelada pelo usuário'); 
        }
        return redirect()->to($url);
    }

Examinando o código acima podemos observar que várias vezes ele faz uso do objeto $request, o qual contém as informações da requisição encaminhada pela submissão do formulário.

Primeiro, na linha 4, usa o método get para obter o valor de redirect_to e armazenar na variável $url de forma a que o aplicativo registre e possa voltar à página de onde foi originalmente chamado o formulário.

Este método, get, recebe dois parâmetros, o primeiro é a chave cujo valor se deseja encontrar e o segundo é um valor padrão que será retornado caso esta chave não exista na $request.

Em seguida, usando novamente $request e seu método has, o código verifica se não foi pressionado o botão cancel, este valor corresponde ao atributo name do botão conforme definimos no respectivo formulário.

O método $request->has(input), irá retornar false caso o parâmetro input não exista ou contenha um valor nulo.

Assim, caso não tenha sido pressionado o botão Cancelar, será executada a primeira parte do if cujo código, usando o método all() de $request, armazenará na variável $dados os valores que foram informados no formulário de inclusão.

E em seguida usará os valores contidos em $dados para criar, pelo uso do método estático Equipamentos::create um objeto do tipo model Equipamentos.

Neste caso, o método create irá em uma única linha criar e salvar um equipamento. Porém, para que isto seja possível devem ser informados no Model os campos passíveis de serem preenchidos. Como fizemos previamente usando o atributo $fillable de Equipamentos, conforme explicado no tópico anterior: Criar um model.

A última linha deste bloco irá usar outro método de $request desta vez o flash para definir a chave message e seu valor ‘Equipamento cadastrado com sucesso’.

O valor de message incluído usando este método flash estará disponível apenas para a requisição seguinte, e será recuperado pelo código $session()->get('message') que incluímos em resources\views\layouts\app.blade.php.

O bloco correspondente ao else acima será executado se o botão cancelar tiver sido acionado e tudo o que ele faz é definir uma chave message com o valor ‘Operação cancelada pelo usuário’.

Conforme já mencionamos, a alteração que fizemos no layout Blade app.blade.php serve para que seja recuperado o valor de message e exibida a respectiva mensagem na tela da requisição seguinte.

Se quiser aprender mais sobre as Requests pode consultar a seguinte página da documentação do Laravel:

https://laravel.com/docs/7.x/requests

Testando a inclusão

Concluídas as  alterações e examinado o código, agora recarregue a url http://localhost:8000/equipamento e clique no botão “Incluir Equipamento” e caso tudo tenha corrido bem será exibida uma tela semelhante a ilustrada abaixo:

Preencha todos os dados do formulário e clique em “Salvar equipamento” o que fará com que o equipamento seja incluído na tabela e que o sistema volte para a tela anterior conforme a ilustração abaixo:

Note que é exibida no topo uma mensagem informando que o equipamento foi cadastrado com sucesso.

Faça mais alguns testes, inclusive cancelando a inclusão, caso em que a mensagem acima deverá mudar para “Operação cancelada pelo usuário”.

Por enquanto não trataremos de validação dos dados do formulário, nem de tratamento de erros.

Assim, nos testes que fizer certifique-se de preencher todos os campos e informar valores válidos.

Para que o post não fique muito extenso vamos fazer uma pausa e voltamos no próximo com as operações de Excluir e Editar. Até lá!

Leia também

Como criar um CRUD usando Laravel (parte 2)

Como criar um CRUD Laravel (conclusão)

Referências

https://laravel.com/docs/7.x/controllers#resource-controllers

https://laravel.com/docs/7.x/migrations#creating-tables

https://laravel.com/docs/7.x/eloquent#defining-models