Já falamos sobre a criação da estrutura do banco com as migrations e sobre a criação de respostas RESTful através dos resources. Agora, chegou a hora de desenvolver a lógica da aplicação com os controllers.

O controller faz parte do design pattern MVC. A função dos Controllers é organizar e agrupar requests relacionadas, manipulando sua lógica em uma única classe.

Criando seu primeiro controller

Para iniciar o trabalho, primeiramente temos que criar o Controller que iremos trabalhar.

Voltando ao nosso exemplo prático, vou montar o Controller para criar os endpoints dos nossos produtos. Para isto utilizarei o php artisan.

php artisan make:controller ProductsController

Se tudo der certo, você terá o seguinte arquivo dentro da sua pasta Http/Controllers:

<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class ProductsController extends Controller
{
//
}

O controller sempre estende a classe Controller padrão do Laravel. Assim, você já terá convenientemente métodos comuns como, por exemplo, o middleware.

Criando os métodos do Controller

Para todo CRUD básico, nós teremos até sete funções que resolverão em sete rotas diferentes. Criarei elas aqui dentro do padrão do Laravel com os nomes:

• index – Lista os dados da tabela
• show – Mostra um item específico
• create – Retorna a View para criar um item da tabela
• store – Salva o novo item na tabela
• edit – Retorna a View para edição do dado
• update – Salva a atualização do dado
• destroy – Remove o dado

No meu caso, serão seis, pois coloquei a adição de produtos junto com a listagem. Assim, nosso controller ficará como abaixo:

<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Product;
use App\Product_line;
class ProductsController extends Controller
{
public function index(){
return view('products');
}
public function show(Product $product){
return view('the_product');
}
public function store(){
//
}
public function edit(Product $product){
return view('product_edit');
}
public function update(Product $product, Request $request){
//
}
public function destroy(Product $product){
//
}
}

Nos métodosshow(), edit(), update() e delete() você pode ver que temos parâmetros vinculados para repassarmos paras as views ou para salvar no banco de dados. O $product irá injetar a instância de Product com o dado que será passado na rota (GET) ou POST.

Para entender melhor, vamos seguir e registar as rotas para este controller.

Registrando as rotas

Agora que as funções estão estruturadas, é hora de montar os endpoints. Para isto, utilizarei o arquivo web.php que está na pasta routes. Este arquivo é responsável por rotear o caminho da request para a função correta no controller e retornar o resultado. Abaixo, segue o meu exemplo.

Route::get('products','ProductsController@index');
Route::post('products','ProductsController@store');
Route::get('products/{product}','ProductsController@show');
Route::get('products/{product}/edit','ProductsController@edit');
Route::patch('products/{product}','ProductsController@update');
Route::delete('products/{product}','ProductsController@destroy');

Utilizei quatro tipos de request para executar cada ação. GET e POST que são os mais comuns, e PATCH e DELETE que são respectivamente para atualização e remoção de dados.

Você também vai reparar que nas quatro últimas rotas temos a palavra { product }.

A instância de Product será o model referente ao id do produto que você passar nesta rota. Assim, se você quiser deletar o produto de id 1, basta passar pela URI  ‘products/1’, com o método delete, e implementar a deleção no controller.

public function destroy(Product $product){
$product->delete();
return redirect('products');
}

A instância já possui todas as referências do model do produto 1. Assim, é só executar o comando delete do Eloquent que ele faz o resto sozinho.

Implementando os métodos de CRUD no controller

Já que configuramos as rotas para cada método do controller e já até implementamos o método DELETE, vamos aos próximos métodos. Começarei pelos métodos de Visualização. Eles são simples métodos que vão receber os dados dos models e repassar para as suas respectivas Views.

public function index() {
$products = Product::all();
return view('products',compact('products','product_lines'));
}
public function show(Product $product){
return view('the_product',compact('product'));
}
public function edit(Product $product){
$product_lines = Product_line::all();
return view('product_edit',compact('product','product_lines'));
}

Vejam que, em edit, eu fiz também uma busca dentro da model Product_lines. Isto porque eu vou precisar de todas as linhas de produto, caso eu queira mudar este produto de linha.

Por fim, vamos aos  métodos de escrita, store e update.

public function store(){
$data = [
'product_line_id' => request('product_line_id'),
'description' => request('description'),
'expiration_time' => request('expiration_time'),
'price' => request('price')
];
Product::create($data);
return redirect('product');
}
public function update(Product $product, Request $request){
$product->product_line_id = $request->product_line_id;
$product->description = $request->description;
$product->expiration_time = $request->expiration_time;
$product->price = $request->price;
$product->save();
return redirect('product');
}

Na função store(), eu fiz o mass assignment e na função update setei cada dado enviado pela Request na instância do model Product e, então, utilizei o save() para efetivar a mudança no banco de dados.

Concluindo

O controller é onde manipulamos a lógica das Requests, recebendo os dados do model e transmitindo-os para a view. O controller abstrai a complexidade da rota que, como já diz o nome, apenas roteará a Request feita para sua devida lógica.