crud-laravel

Como criar um CRUD Laravel (conclusão)

Para concluir este tutorial de programação onde aprendemos a construir um CRUD usando Laravel iremos ver como gerar dados de teste usando as model factory e as seeders.

Além disso, veremos como fazer validações dos dados usando o Laravel form request.

Por último iremos refatorar o código de nossos template Blade de forma a reutilizar o mesmo formulário para as operações de Incluir, Editar e Deletar.




Populando

Durante o desenvolvimento de uma aplicação é muito útil que possamos gerar dados de teste para verificar o funcionamento do aplicativo.

O Laravel fornece recursos que podem ser utilizados para automatizar esta tarefa e gerar dados experimentais para uso em nosso aplicativo CRUD.

Para isto o framework faz uso das classes Seeder e Model Factory e nos próximos tópicos veremos como utilizá-las para criar dados de teste para uso com o nosso CRUD.

Criar um Seeder

Uma classe Seeder é um recurso disponível no Laravel o qual permite que sejam gerados de forma automática dados que irão popular o banco de dados.

Esta classe poderá receber qualquer nome que desejarmos, porém faz mais sentido que elas recebam um nome relacionado ao model para o qual irão gerar dados.

Assim, prosseguindo em nosso tutorial de Laravel, iremos agora criar um Seeder, para isto digite o comando:

php artisan make:seeder EquipamentosTableSeeder

Isto fará com que seja criado o arquivo database\seeds\EquipamentosTableSeeder.php

Para implementar o seeder do CRUD em que estamos trabalhando inclua neste arquivo o seguinte código:

<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use App\Models\Equipamento;

class EquipamentosTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        //
        Equipamento::factory()
            ->count(50)
            ->create();
    }
}

Observe que no início do código foi incluída uma referência ao model Equipamento, sendo que as linhas seguintes implementam o método run da seeder. O que ele faz é criar, usando o factory do model Equipamento, 50 objetos desta classe.

Como já deve ter percebido, será necessário implementar este método factory para a classe Equipamento e faremos isto em breve.

DatabaseSeeder

O framework Laravel por padrão já conta com uma classe seeder predefinida com o nome de DatabaseSeeder.

Para que a seeder que criamos seja executada é necessário que ela seja incluída no método run desta DatabaseSeeder.

Para isto precisaremos editar o arquivo database\seeds\DatabaseSeeder.php e incluir a linha destacada abaixo:

...     
   class DatabaseSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
         $this->call([
            EquipamentosTableSeeder::class
         ]);
    }
}

Criar um Model Factory

Antes de prosseguirmos vale dizer que o uso de uma Model Factory não é obrigatório, pois é possível incluir o código de geração dos dados de teste no arquivo da própria seed.




Contudo, é uma boa prática utilizar uma factory separada da seeder para fins de melhor organização dos papéis de cada classe em nosso aplicativo, e para permitir que criemos um código mais elaborado para gerar os dados fictícios.

Assim, em nosso tutorial de Laravel iremos criar um model factory que será usada em conjunto com a seeder. Para fazer isto, na linha de comando, digite o comando abaixo:

php artisan make:factory --model=Equipamento EquipamentoFactory

Este comando, make:factory, irá criar, baseado no model Equipamento, uma factory com o nome de EquipamentoFactory que será armazenada na pasta app\database\factories.

Complementando a criação da factory digite no arquivo app\database\factories\EquipamentoFactory.php o código abaixo:

<?php

namespace Database\Factories;
use App\Models\Equipamento;
use Illuminate\Database\Eloquent\Factories\Factory;

class EquipamentoFactory extends Factory
{
    /**
     * The name of the factory's corresponding model.
     *
     * @var string
     */
    protected $model = Equipamento::class;

    /**
     * Define the model's default state.
     *
     * @return array
     */
    public function definition()
    {
        $fabricantes = ['Asus', 'Itautec', 'Lenovo', 'Epson', 'HP'];
        $tipos = ['Computador', 'Impressora', 'Scanner', 'Notebook'];
        $fabricante = $fabricantes[rand(0, count($fabricantes)-1)];
        $tipo = $tipos[rand(0, count($tipos)-1)];
        $modelo = strtoupper($this->faker->bothify('??-###?'));
        return [
          'tipo' => $tipo,
     	  'modelo' => $modelo,
     	  'fabricante' => $fabricante
        ];
    }
}

O método definition() desta classe é responsável pela criação dos dados fictícios que corresponderão aos atributos de nosso objeto Equipamento.

Ele é ativado pelo run() da seed, que em nosso exemplo é a classe EquipamentosTableSeeder, e, graças a sintaxe fluente do Laravel, será executado 50 vezes.

O método retornará um array contendo os valores de cada atributo os quais foram gerados no corpo da função conforme descrito a seguir.

Iniciamos definindo os dois arrays: $fabricantes e $tipos, contendo, respectivamente, valores de string com os nomes de fabricantes e os tipos de equipamento.

Em seguida, atribuímos para as variáveis $fabricante e $tipo um dos valores contidos nos arrays. Este valores são escolhidos de forma aleatória usando a função rand() para gerar um número de índice.

Como esta estende a classe Illuminate\Database\Eloquent\Factories\Factory; ela já possui acesso a uma instância do faker, que é um gerador de valores fictícios muito utilizado pela comunidade PHP e Laravel.

Assim, o valor de $modelo é gerado pela linha:

$modelo = strtoupper($this->faker->bothify('??-###?'));

Este código utiliza o método bothify do faker cuja função é receber uma string contendo um padrão e devolver uma outra string na qual todas as interrogações (?) foram substituídas por letras aleatórias e todos os símbolos de hashtags (#) por números aleatórios.

O gerador faker pode gerar vários dados, entre eles nomes, sobrenome e números de CPF e CGC.

Para saber mais acesso o repositório do projeto no github usando o link abaixo:

https://github.com/fakerphp/faker

Executando a seed

Depois de criar a seed e a respectiva factory resta apenas executá-las para gerar os dados fictícios que serão usados em nosso CRUD.

Para isto execute em seu terminal o comando abaixo:

php artisan db:seed

O comando acima preserva os dados que já existem no banco de dados, assim, se você já tiver cadastro algum equipamento os respectivos dados continuarão a existir.

Caso queira reiniciar os bancos de dados com nova informações a melhor opção é executar o comando abaixo:

php artisan migrate:fresh --seed

ATENÇÃO! Este comando irá executar novamente as migrations e recriar todas as tabelas do sistema apagando TODOS os dados que estiverem armazenados, assim tenha muito cuidado ao executá-lo.




Mass assignment x fillable

Vale lembrar que no Laravel os Model são protegidos contra o mass assignment ou object injection, que consiste em uma vulnerabilidade presente em alguns sistemas web, descrita com detalhes no link abaixo:

https://cheatsheetseries.owasp.org/cheatsheets/Mass_Assignment_Cheat_Sheet.html

Para proteger contra este tipo de ataques o Laravel utiliza o atributo fillable em seus model.

Um exemplo que usamos em nosso CRUD foi o model Equipamento cujo trecho de código reproduzo abaixo:

protected $fillable = [
    	'tipo',
     	'modelo',
     	'fabricante'
	];

Quando definimos um array $fillable em nossos models informamos ao Laravel quais atributos/campos são passíveis de receber valores através de operações de entrada de dados executadas pelos usuários.

Desta forma o framework protege nossa aplicação de ataques de injeção pelos quais um usuário consegue, por exemplo, elevar seus privilégios alterando um atributo isAdmin.

Uma outra forma de implementar esta proteção é o uso do atributo $guarded que funciona de maneira semelhante, porém contém os atributos protegidos em vez dos liberados.

Assim, se em nosso model definirmos apenas um array conforme abaixo:

protected $guarded = ['isAdmin', 'roles'];

Estaremos protegendo os atributos isAdmin e roles e deixando livres os demais atributos.

O padrão adotado pelo Laravel para o atributo $guarded é o * (asterisco) significando que todos os atributos estão protegidos.

Implementar a paginação

Agora que temos pelo menos 50 equipamentos em nosso banco precisamos alterar a página que exibe estes dados para que ela passe a usar o recurso de paginação presente no Laravel.

Assim, para implementar um paginator nesta página altere o arquivo app\Http\Controllers\EquipamentosController.php para que fique da seguinte forma:

public function index()
    {
        //
        $equipamentos = Equipamento::paginate(10);
        return view('equipamentos.index', ['equipamentos' => $equipamentos] );
    }

A alteração que fizemos no código acima faz com que agora seja passado ao template equipamentos.index um objeto do tipo paginator contendo, entre outras informações, os dados dos equipamentos que foram recuperados pelo método paginate.

O método paginate recebe como parâmetro a quantidade de itens que desejamos exibir em cada página, que em nosso exemplo foi de 10.

A quantidade padrão de elementos por página é 15, assim é esta quantidade de itens que serão exibidos em cada página caso não seja passado o parâmetro.

Template equipamentos.index

Para que os dados sejam exibidos de forma correta falta agora alterar o arquivo resources\views\equipamentos\index.blade.php para que fique da forma abaixo:

...   
 		</tbody>
        </table>
        {{$equipamentos->links()}}
    </div>
</div>
@endsection

Esta linha de código fará com que seja incluído ao final da página uma barra que permite navegar entre os dados de equipamentos registrado em nosso CRUD.

A barra de navegação será gerada usando os dados do parâmetro $equipamentos que foi passado pelo controller.

Se preferir poderá incluir este elemento no topo, para isto basta inserir a linha antes da definição da tag <table class=”table table-striped”> no código original.

Laravel 8 como usar o Bootstrap

A partir da versão Laravel 8 o paginator gera código que, por padrão, é compatível com o TailWind CSS, porém é possível configurar o Laravel para que o código gerado seja compatível com o Bootstrap.

Para isso você deverá editar o arquivo app\Providers\AppServiceProvider.php e incluir as linhas de código abaixo:

use Illuminate\Pagination\Paginator;

public function boot()
{
    Paginator::useBootstrap();
}

Feita esta última alteração, para visualizar o resultado acesse aURL http://localhost:8000/equipamento

e deverá ver uma tela semelhante a ilustrada abaixo:

Note que na parte inferior foi incluída a barra de navegação que nos permite navegar entre os equipamentos fictícios que foram gerados pela seed.




Validação dos dados

Até agora em nosso CRUD exemplo não fizemos nenhuma validação dos dados digitados pelos usuários, assim, ainda é possível ao usuário enviar, por exemplo, um formulário em branco.

Para implementar a validação em nosso CRUD o Laravel disponibiliza recursos e técnicas muito úteis.

A validação de dados no Laravel é feita levando em conta que os dados a serem validados fazem parte de uma requisição HTTP. Normalmente é este o caso, pois o cenário mais comum é o preenchimento de um formulário que é submetido por meio de um POST ou GET.

Assim, a validação no Laravel é feita usando como base os métodos da classe tipo Illuminate\Http\Request.

Observando o código dos controllers que produzimos em nosso CRDU podemos ver que esta classe já foi referenciada quando este código foi gerado pelo framework.

Além disso, existem algumas abordagens que podem ser usadas para validar os dados, uma delas é incluir o código de validação no próprio controller.

Outra, que considero mais adequada, e por isso é a que utilizaremos em nosso CRUD, é criar uma classe própria de Form Request.

Criar uma Form Request Validation

Para criar uma classe de form request você deverá executar o comando:

php artisan make:request EquipamentoFormRequest

Após a execução do comando será criado o arquivo app\Http\Requests\EquipamentoFormRequest.php, examinando as primeiras linhas deste arquivo podemos ver que ele cria uma classe que estende a classe do tipo FormRequest que, por sua vez, estende a classe Request citada acima.

A primeira coisa a fazer é alterar o método authorize e nele digitar o código abaixo:

public function authorize()
    {
        return true;
    }

Este método serve para implementar controle de autorização, como em nosso CRUD exemplo não fazemos este controle, podemos apenas retornar true.

Em seguida vamos definir as regras de validação, para isto digite o código do método rules conforme abaixo:

public function rules()
    {
        if ($this->request->has("cancel")){ return [];}
        return [
            'tipo' => 'required',
            'modelo' => 'required|max:15',
            'fabricante' => 'required',
        ];
    }

O funcionamento deste método é retornar um array contendo as regras que deverão ser respeitadas pelos dados contidos na requisição HTTP.

Caso os parâmetros passados na requisição não estejam de acordo com as regras, o Laravel irá automaticamente redirecionar o usuário de volta para sua localização anterior, ou seja, de volta ao preenchimento do formulário.

Por este motivo, a primeira linha do código acima serve para detectar se o usuário acionou o botão cancelar e, neste caso retorna uma array vazio com as regras.

Caso isto não fosse implementado, o usuário teria que preencher os dados antes de cancelar.

Prosseguindo, caso não tenha sido pressionado o Cancelar, será devolvido o array contendo as regras de validação.

Neste exemplo elas são: o tipo não pode ser vazio; o modelo não pode ser vazio e pode ter no máximo 15 caracteres; e o fabricante não pode ser vazio.

Apesar deste exemplo simples, as regras de validação do Laravel podem ser muito complexas, inclusive com validação no próprio banco de dados. Para saber de mais detalhes a respeito das regras de validação consulte a documentação no link abaixo:

https://laravel.com/docs/8.x/validation#available-validation-rules

Para finalizar o código de nossa form request vamos agora definir algumas mensagens customizadas inserindo no final do arquivo o método messages, conforme abaixo:

public function messages(){
    	return [
           'tipo.required' => 'O TIPO do Equipamento deve ser preenchido',
            'modelo.required' => 'O MODELO do Equipamento deve ser preenchido',
            'modelo.max' => 'O campo MODELO pode conter no máximo 15 caracteres',
            'fabricante.required' => 'O FABRICANTE do Equipamento deve ser preenchido',
    	];
    }

Com isto definimos uma mensagem personalizada para cada regra e que será exibida no caso de os dados não estarem adequados a elas.

Refatorando

Para testar o funcionamento das alterações no código que fizemos até aqui necessitaremos fazer alterações em vários arquivos de nosso CRUD.

Assim, vamos aproveitar para refatorar o código de forma a torná-lo mais limpo e mais reutilizável.

Unificando o formulário

O primeiro código que iremos alterar é a do _form.blade.php para que possamos utilizar o mesmo formulário em todas as operações do CRUD (create, update e delete).

Desta forma, insira no início do arquivo o código abaixo:

@php
    $form_mode = !isset($form_mode) ? 'default' : $form_mode;
    switch ($form_mode) {
        case "delete":
            $action=route('equipamento.destroy', ['equipamento' => $eqp->id]);
            $bot_label="Deletar equipamento";
            break;
        case "edit":
            $action=route('equipamento.update', ['equipamento' => $eqp]); 
            $bot_label="Atualizar equipamento";
            break;
        default:
            $action=route("equipamento.store");
            $bot_label="Salvar equipamento";
            break;
    }
@endphp

Este trecho de código utiliza a diretiva @php para executar código em PHP dentro do template Blade. O que ele faz é definir três variáveis: $form_mode, $action e $bot_label, as quais correspondem, respectivamente, ao modo do formulário; a action que será executada pelo submit; e ao label do botão que irá disparar a ação.

Observe que as variáveis acima estarão acessíveis para o restante do código do template. Além disso, dentro da diretiva @php é possível executar, além de código PHP puro, os métodos e helpers disponíveis no Laravel, como é caso do route que foi usado para definir o valor da variável $action.

A ideia aqui é que quando o formulário for acionado será passado o parâmetro em $form_mode indicando em qual modo está o formulário: create, edit ou delete, sendo o padrão o create.

Prosseguindo com as alterações edite o código da tag de abertura do formulário de forma a que fica conforme abaixo:

<form action={{$action}} method="post">

Neste trecho a action será definida de acordo com o modo do formulário e a variável $action como descrevemos acima. Agora, logo após a linha @crsf, inclua o código abaixo:

    @if ($form_mode == "delete")
        @method('DELETE')
    @endif
    @if ($form_mode == "edit")
        @method('PUT')
    @endif

Prosseguindo, EXCLUA a linha abaixo, pois a mesma não será mais usada por este formulário:

<input type="hidden" id="redirect_to" name="redirect_to" value={{URL::previous()}}>

Esta linha servia para criar um campo escondido onde ficava armazenada a URL da página anterior. Iremos usar outra técnica para fazer isto, de forma que esta linha pode ser removida.

Campos do formulário

Em seguida temos quatro <div></div>, cada uma representando um campo do formulário. Iremos substituir o código de cada uma delas pelos respectivos códigos fornecidos abaixo. Para o campo Tipo de Equipamento o código deverá ser o seguinte:

    <div>
        <label for="tipo">Tipo Equipamento</label>
        <input type="text" id="tipo" name="tipo" value="{{isset($eqp) ? $eqp->tipo : old('tipo')}}" {{$form_mode == "delete" ? "disabled" : ""}}>
        @error('tipo')
            <div class="alert alert-danger">{{ $message }}</div>
        @enderror
    </div>

Uma alteração significativa foi no input, pois agora o código verifica se foi passado um equipamento, trecho isset($eqp), e em caso positivo define o value com o valor correspondente.

Ainda, nesta mesma linha o código verifica qual o modo do formulário e no caso de ser delete, desabilita a edição do campo definindo o input como disabled

Caso contrário, podemos assumir que o modo é edit ou create, e permitir que os campos input fiquem habilitados para edição.

Vale mencionar aqui uma diretiva do Blade de que ainda não havíamos tratado ainda, é a @error destacada no código acima.

É assim, usando a diretiva @error, que serão exibidas as mensagens de erro causadas por falhas na validação dos formulários.




Quando os dados não estiverem de acordo com as regras o Laravel irá se encarregar de criar a variável $error e nela armazenar os erros da sessão correspondentes às regras de validação que falharam.

Em seguida esta diretiva @error procura na sessão atual se existe alguma mensagem de erro e em caso afirmativo exibe a respectiva mensagem armazenada em $message.

Prosseguindo com as alterações, substitua o código da div correspondente ao campo Modelo Equipamento pelo código abaixo:

    <div>
        <label for="modelo">Modelo Equipamento</label>
        <input type="text" id="modelo" name="modelo" value="{{isset($eqp) ? $eqp->modelo : old('modelo')}}" {{$form_mode == "delete" ? "disabled" : ""}}>
        @error('modelo')
            <div class="alert alert-danger">{{ $message }}</div>
        @enderror
    </div>

Este código é semelhante ao anterior e não introduz nenhum conceito novo. Finalizando a implementação dos campos do formulário, substitua a div que implementa o código do Fabricante Equipamento pelo trecho abaixo:

    <div>
        <label for="fabricante">Fabricante Equipamento</label>
        <input type="text" id="fabricante" name="fabricante" value="{{isset($eqp) ? $eqp->fabricante : old('fabricante')}}" {{$form_mode == "delete" ? "disabled" : ""}}>
        @error('fabricante')
            <div class="alert alert-danger">{{ $message }}</div>
        @enderror
    </div>

Para concluir a alteração no código do formulário insira o seguinte código:

    @if ($form_mode == "delete")
        <div class="alert alert-danger" role="alert">Esta operação não poderá ser desfeita! Confirma a exclusão do equipamento?</div>
    @endif
    <div>
    	<div class="form-group">
			<input type="submit" name="save_eqp" value="{{$bot_label}}">
			<input type="submit" name="cancel" value="Cancelar">
		</div>
	</div>
</form>

Examinado o código vemos que ele inicia com uma diretiva @if que fará com que a mensagem de advertência seja exibida apenas se o formulário estiver no modo delete.

Em seguida são definidos os dois botões de submit, um deles o Cancelar, que será comum a todos os modos e fará com que seja interrompida a operação.

O outro botão irá ter sua label definida conforme o valor da variável $bot_label e será responsável por acionar a action que foi definida anteriormente.

Finalizando, observe que agora incluímos a tag </form> fechando a definição do formulário.

URL anterior

Como já havia mencionado antes, precisamos alterar a forma com que o CRUD irá saber para onde retornar após uma operação, ou seja, a página anterior ao acionamento do formulário.

Em nosso código inicial utilizávamos a o trecho URL::previous() e um campo escondido no formulário para guardar o local de retorno.

No entanto, esta técnica não funciona mais devido a termos introduzido a validação, pois sempre que a validação falha o Laravel redireciona para a tela correspondente ao formulário e a URL::previous irá apontar parar o endereço desta mesma tela.

Isto pode ocasionar uma situação na qual mesmo após termos concluído uma operação e inclusão ou edição nosso CRUD permanece na tela do formulário de entrada de dados.

Por este motivo iremos alterar nosso código para que passe a armazenar na sessão a variável $redirect_to que conterá o valor da URL prévia, ou seja, da página para a qual desejamos retornar ao final da operação.

Iremos agora alterar o código de app\Http\Controllers\EquipamentosController.php, sendo a primeira alteração a referência ao form request validator que criamos.

Assim, inclua no início deste arquivo a linha:

use App\Http\Requests\EquipamentoFormRequest;

Continuando, no mesmo arquivo altere o método create para que fique da seguinte forma:

public function create()
    {
        if(!session()->has('redirect_to'))
        {
           session(['redirect_to' => url()->previous()]);
        }
        return view('equipamentos.create', ['action'=>route('equipamento.store'), 'method'=>'post']);
    }

Este código verifica se não foi definida na sessão um valor para redirect_to e neste caso define seu valor usando url()->previous() e o armazena na sessão.

Será para esta página que o aplicativo retornará após a operação de inclusão.

Neste mesmo arquivo altere agora o código do método store, para que fique da seguinte forma:

public function store(EquipamentoFormRequest $request)
    {
        //
        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(session()->pull('redirect_to'));
    }

Os pontos a destacar são a definição do método que agora utiliza a request do tipo EquipamentoFormRequest que criamos para validar os dados do formulário.

Além disso, foi excluída a linha que antes definia a variável $url e, por consequencia, o return agora obtém da sessão a variável redirect_to que conterá o valor da página anterior conforme já mencionamos antes.




Testando a Inclusão (create)

Para realizar um teste de funcionamento do que foi feito até agora precisamos fazer mais uma alteração em nosso código. Altere o arquivo resources\views\equipamentos\create.blade.php para que fique da seguinte forma:

@extends('layouts.app')
@section('content')
	<div class="container">
		<div class="row">
			<h3>Novo Equipamento</h3>
			@include('equipamentos._form')
		</div>
	</div>
@endsection

Observe que retiramos os botões e a tag de fechamento do formulário e que com isso o código ficou bem menor.

Após esta alteração já podemos testar o funcionamento da operação de Inclusão (create), para isto acesse a página de equipamentos na URL:

http://localhost:8000/equipamento


Tente agora incluir um equipamento e deixar todos os campos em branco, deverá obter uma tela semelhante a ilustrada abaixo:

Observe que agora a validação está implementada e não é mais possível incluir equipamentos com informações em branco.

Ajustando as rotas

Com isto concluímos a operação de Create (inclusão), para as demais operações do CRUD será necessário alterações nas rotas.

Assim, vamos editar agora o arquivo routes\web.php e fazer as seguintes alterações:

Route::get('/equipamento/delete/{equipamento}', function (App\Models\Equipamento $equipamento) {
    if(!session()->has('redirect_to'))
    {
        session(['redirect_to' => url()->previous()]);
    }
	return view('equipamentos.destroy', ['eqp' => $equipamento]);
})->name('equipamento.delete');

Route::get('/equipamento/edit/{equipamento}', function (App\Models\Equipamento $equipamento) {
    if(!session()->has('redirect_to'))
    {
        session(['redirect_to' => url()->previous()]);
    }
	return view('equipamentos.edit', ['eqp' => $equipamento]);
})->name('equipamento.edit');

O código acima foi alterado de forma a implementar a nova forma de guardar o endereço da página anterior, agra em uma variável de sessão.

Alterar o Controller Equipamentos

Para concluir o código do CRUD é necessário fazer algumas alterações no arquivo app\Http\Controllers\EquipamentosController.php.

Vale mencionar que com a criação do FormRequest personalizada esta request será processada antes de qualquer código no Controller.

Iniciamos alterando o código do método update para que fique da seguinte forma:

public function update(Equipamento $equipamento, EquipamentoFormRequest $request)
        {   
        if (! $request->has('cancel') ){
            $equipamento->tipo = $request->input('tipo');
            $equipamento->modelo = $request->input('modelo');
            $equipamento->fabricante = $request->input('fabricante');
            $equipamento->update();
            $request->session()->flash('message', 'Equipamento atualizado com sucesso !');
        }
        else
        { 
            $request->session()->flash('message', 'Operação cancelada pelo usuário'); 
        }
        return redirect()->to(session()->pull('redirect_to'));
    }

Os pontos de atenção são o parâmetro $request que agora é do tipo EquipamentoFormRequest e o valor da página de retorno que agora é obtido da sessão por meio da variável redirect_to.

Observe que para recuperar o valor desta variável estamos usando no lugar do get o método pull, pois este recupera a variável e a exclui da sessão. Para concluir as alterações e este tutorial de programação, vamos agora alterar o método destroy de forma a que ele fique assim:

public function destroy(Equipamento $equipamento, Request $request)
    {
        if (! $request->has('cancel') ){
            $strEqp = $equipamento->tipo . ', modelo: ' . $equipamento->modelo . ', fabricante:' . $equipamento->fabricante . '}';
            $equipamento->delete();
            $request->session()->flash('message', '{equipamento: ' . $strEqp . ' excluído com sucesso !');
        }
        else
        { 
            $request->session()->flash('message', 'Operação cancelada pelo usuário'); 
        }
        return redirect()->to(session()->pull('redirect_to'));
    }

Com este última alteração finalizamos este post e já temos um CRUD totalmente funcional.

Código no GitHub

Escrevi este post em três partes, procurando apresentar de forma progressiva alguns conceitos e técnicas relacionadas a implementação do CRUD no Laravel.

O código finalizado está disponível no repositório:

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

Conclusão

Nesta série de três posts criamos um CRUD básico e apresentamos alguns conceitos essenciais do Laravel.
Veja abaixo os outros tutorias de Laravel que fazem parte desta série e o que foi tratado em cada um deles:

Como criar um CRUD usando Laravel

  • Definir rotas e controller Resources no Laravel 8
  • Gerar os models e suas migrations
  • Usar Bootstrap com o Laravel 8
  • Create ou Inclusão


Como criar um CRUD usando Laravel (parte 2)

  • Route Model bindig e named routes
  • Método Delete
  • Update e o PUT

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

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

https://laravel.com/docs/8.x/database-testing#writing-factories

https://github.com/fzaninotto/Faker