Tutoriais - RibaFS Portal

Crud-generator

2017-06-25T21:08:35-03:00

Gerador de Cruds para o Laravel 5

Depois de muito procurar e testar pacotes para geração de crud, encontrei este, que funciona bem e ajuda muito na criação de CRUDs básicos, já com o Bootstrap, paginação e busca.

https://github.com/appzcoder/crud-generator

Passos para a instalação

composer require appzcoder/crud-generator --dev

Em app/Providers/AppServiceProvider.php:

public function register()
{
if ($this->app->environment() == 'local') {
$this->app->register('Appzcoder\CrudGenerator\CrudGeneratorServiceProvider');
}
}

composer require laravelcollective/html

Add Provider config/app.php

Collective\Html\HtmlServiceProvider::class,

Aliases

'Form' => Collective\Html\FormFacade::class,
'HTML' => Collective\Html\HtmlFacade::class,

composer dump-autoload

Publicar o pacote do vendor:
php artisan vendor:publish --provider="Appzcoder\CrudGenerator\CrudGeneratorServiceProvider"

Está instalado e pronto para usar.

Exemplos de uso:

Posts
php artisan crud:generate Posts --fields="user_id#integer; title#string; description#text;" --view-path="" --controller-namespace="" --route-group=""

Noticias
php artisan crud:generate Noticias --fields="usuario_id#integer; titulo#string; descricao#text;" --view-path="" --controller-namespace="" --route-group=""

Posts
php artisan crud:generate Posts --fields="title#string; content#text; category#select#options=technology,tips,health" --view-path=admin --controller-namespace=Admin --route-group=admin

Comments
php artisan crud:generate Comments --fields="post_id#integer; content#text;" --view-path="" --controller-namespace="" --route-group=""

Criar banco e configurar no .env
php artisan migrate

Clientes
php artisan crud:generate Clientes --fields="nome#string; email#string;" --view-path=admin --controller-namespace=Admin --route-group=admin

php artisan migrate

Funcionarios
php artisan crud:generate Funcionarios --fields="nome#string; email#string;" --view-path="admin" --controller-namespace=Funcionarios --route-group=admin
Master a rota funcionarios/funcionarios, caso contrário não encontra

php artisan migrate

Produtos
php artisan crud:generate Produtos --fields="nome#string; descricao#string; preco#float" --view-path="site" --controller-namespace=Produtos --route-group=site

Criar no raiz (fora de site ou admin)
php artisan crud:generate Pedidos --fields="produto#string; quantidade#integer;" --view-path="" --controller-namespace=Pedidos --route-group=""

Editar a migration, para limitar o tamanho dos campos e outras características como nullable()

Outros comandos (opcionais):
php artisan crud:controller PostsController --crud-name=posts --model-name=Post --view-path="directory" --route-group=admin

For model:
php artisan crud:model Post --fillable="['title', 'body']"

For migration:
php artisan crud:migration posts --schema="title#string; body#text"

For view:
php artisan crud:view posts --fields="title#string; body#text" --view-path="directory" --route-group=admin

php artisan migrate

Adicionando uma rota
Route::resource('posts', 'PostsController');

Supported Field Types

These fields are supported for migration and view's form:
Form Field Types:

text
textarea
password
email
number
date
datetime
time
radio
select
file

Migration Field Types:

string
char
varchar
date
datetime
time
timestamp
text
mediumtext
longtext
json
jsonb
binary
integer
bigint
mediumint
tinyint
smallint
boolean
decimal
double
float
enum

php artisan crud:generate Posts --fields="user_id#integer; title#string; description#text;" --view-path="" --controller-namespace="" --route-group=""

$table->string('name')->unique();
$table->string('slug')->unique();
$table->text('description')->nullable();

Schema::create('posts', function (Blueprint $table) {
$table->increments('id');

$table->integer('user_id')->unsigned();
$table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');

$table->string('title');
$table->text('description');

$table->timestamps();

});

Model
php artisan crud:model Post --fillable="['title', 'body']"

Migration
php artisan crud:migration posts --schema="title#string; body#text"

View
php artisan crud:view posts --fields="title#string; body#text" --view-path="directory" --route-group=admin

Migrations no Laravel

2017-06-25T21:08:35-03:00

Migrations é um recurso que cria a estrutura das tabelas em código e após um comando ele cria as tabelas no banco.

Também permite remover as tabelas do banco e recriar com grande flexibilidade.

No Laravel 5 as migrations ficam no diretório
/database/migrations

Detalhes:
https://laravel.com/docs/5.4/migrations

Criar a migrate já com a estrutura básica
php artisan make:migration create_users_table --create=users

Criar a primeira tabela
php artisan make:migration create_produto_table

php artisan migrate:reset - apagar todas as tabelas

php artisan migrate:refresh - recriar e popular todas as tabelas

php artisan migrate:rollback --step-1

Após o comando mirgation, edite o arquivo gerado em database/migrations e adicione os campos da tabela.
Abrir o arquivo e criar os campos no método up:

Schema::create('produto', function(Blueprint $table){
$table->increments('id');
$table->string('name', 100);
$table->integer('number');
$table->boolean('active');
$table->string('image', 200)->nullable();
$table->enum('category', ['eletronicos', 'moveis', 'limpeza', 'banho']);
$table->text('description');
$table->timestamps();
$table->softDeletes(); //só marca para deleção
});

Campos date usar nullable();

Método down()

Schema::drop('produto');

Criar migration e mudar nome
php artisan miration create_telefones_table --create telefones

Criar as tabelas no banco a partir da migration
php artisan migrate

Após efetuar alterações na estrutura da tabela da migration executar:
php artisan migrate:refresh (apaga tudo e recria)

Seeds - popular banco de dados

Estes populam as tabelas com dados de teste e ficam no diretório:
database/seeds

Detalhes:
https://laravel.com/docs/5.4/seeding

Sintaxe:
php artisan make:seeder UserTableSeeder

use App\User;

public function run(){
User::create([
'name' => 'Carlos Ferreira',
'email' => 'carlos@carlos.com',
'password' => bcrypt('123456')
])
}

Editar o arquivo
seeds/DatabaseSeeder.php

E mudar a linha:
$this->call(UserTableSeeder::class);

Criar o seed (popula todas as tabelas criadas):
php artisan db:seed

Criar o model e a migration, já com parte do método up
php artisan make:model Produtos -m

php artisan help make:migration

Para apagar as tabelas criadas
php artisan migrate:reset

Criar as tabelas novamente
php artisan migrate:refresh

public function up()
{
Schema::create('livros', function(Blueprint $table) {
$table->increments('id');
$table->string('isbn',20);
$table->integer('autore_id')->unsigned();
$table->string('titulo',40);
$table->timestamps();
$table->foreign('autore_id')->references('id')->on('autores')->onDelete('cascade')->onUpdate('cascade');
});
}

Seed somente para uma tabela/classe
php artisan db:seed --class=UserTableSeeder

Ao deletar um autor deleta todos os livros relacionados a ele (onDelete('cascade')).

$table->foreign('user_id')->references('id')->on('users')
->onUpdate('cascade')
->onDelete('cascade');

$table->foreign('classroom_id')->references('id')->on('classrooms')
->onUpdate('cascade')
->onDelete('set null');

class CreateRolesPermissionsTables extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('roles', function (Blueprint $table) {
$table->increments('id');
$table->string('name');
$table->string('label')->nullable();
$table->timestamps();
});

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

Schema::create('permission_role', function (Blueprint $table) {
$table->integer('permission_id')->unsigned();
$table->integer('role_id')->unsigned();

$table->foreign('permission_id')
->references('id')
->on('permissions')
->onDelete('cascade');

$table->foreign('role_id')
->references('id')
->on('roles')
->onDelete('cascade');

$table->primary(['permission_id', 'role_id']);
});

Schema::create('role_user', function (Blueprint $table) {
$table->integer('role_id')->unsigned();
$table->integer('user_id')->unsigned();

$table->foreign('role_id')
->references('id')
->on('roles')
->onDelete('cascade');

$table->foreign('user_id')
->references('id')
->on('users')
->onDelete('cascade');

$table->primary(['role_id', 'user_id']);
});
}

/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::drop('permission_role');
Schema::drop('role_user');
Schema::drop('roles');
Schema::drop('permissions');
}
}

Laravel - Controller

2017-06-25T21:08:35-03:00

Controllers - Têm a responsabilidade de controlar o fluxo das informações, para as views e models.

Métodos padrões de um controller, quando criado com a opção --resource

index - lista todos os registros disponíveis
create - chama a view create, que é um form (create.blade.php) para adicionar um registro
store - armazena no banco o registro do form em create, antes validando seus campos
show - mosra um único registro através da view show.blade.php
edit - chama o form na view edit.blade.php para editar um registro
update - Sua função é armazenar no banco o registro alterado na view acima
destroy - permite excluir um registro

Criar um controller numa pasta específica
php artisan make:controller Painel\\PainelController

Criar controller com esqueleto de métodos default
php artisan make:controller SiteController --resource

Exemplos:
Route::get('/', 'SiteController@index');

public function index()(
{
return 'Home page do site';
}

Route::get('contato', 'SiteController@contato');

public function contato()(
{
return 'Home page de contato';
}

public function index(Request $request)
{
return view('tarefas.index');
}

Criar controle e também um método
php artisan make:controller PhotoController --resource --model=Photo

Route::resource('photo', 'PhotoController', ['only' => [
'index', 'show'
]]);

Route::resource('photo', 'PhotoController', ['except' => [
'create', 'store', 'update', 'destroy'
]]);

Route::put('user/{id}', 'UserController@update');

Criar um controller SiteController

Criar um método index() que chama a view:

public function index()
{
return view('welcome')
}

Alterar o route

Route::get('/', 'SiteController@index');

Controller com Model

<?php

namespace App\Http\Controllers;
use DB;
use App\Carro;

class ProdutosController extends Controller
{
public function index()
{
// Retornar todos os registros da tabela carros
$carros = Carro->get();
return view('index', ['carros' => $carros]);
}

}

namespace App\Http\Controllers;
use DB;

class ProdutosController extends Controller
{
public function index()
{
// Retornar todos os registros da tabela carros
$carros = DB::table('carros')->get();
return view('index', ['carros' => $carros]);
}

}

//Adicionando novo registro
public function store(Request $request)
{
$this->validate($request, [
'name' => 'required|max:255',
]);

// Create The Task...
}

public function store(Request $request)
{
$this->validate($request, [
'name' => 'required|max:255',
]);

$request->user()->tasks()->create([
'name' => $request->name,
]);

return redirect('/tasks');
}

Criando uma pasta para controllers e movendo para ela um controller

Http
Painel
Site
SiteController.php

Mudar o namespace do controller

namespace App\Http\Controllers\Site;

use App\Http\Controllers\Controller;

Mudar o namespace nas rotas

Route::get('/', 'Site\SiteController@index');

Ou criar uma rota de grupo com o novo namespace

Route::group(['namespace' => 'site'], function(){
Route::get('/', 'SiteController@index');
Route::get('contato', 'SiteController@contato')->middleware('auth');
});

Assim todos os métodos/rotas exigem autenticação
public function __construct()
{
$this->middleware('auth');
}

Ou
Somente alguns métodos/rotas exigirão autenticação
$this->middleware('auth')
->only([
'contato',
'categoria'
]);

Ou filtrando com except
$this->middleware('auth')
->except([
'contato',
'index'
]);

Adicionar outro controller, adicionando seu namespace
public function store(Request $request, \App\User $user)
{

}

public function index()
{
$teste = 123;
$teste2 = 132;
$teste3 = 321;
return view('teste', compact('teste', 'teste2', 'teste3'));
}

Ao criar as views, criar pastas correspondentes às dos controllers:

painel
site

return view('site.teste', compact('teste', 'teste2', 'teste3'));

Criar formulário de cadastro

Criar nova rota (mudar para que esta seja a primeira rota)

Route::get('produtos/testes', 'Produtos\ProdutoController@testes');

Editar o controller e adicionar o método testes()

Adicionar use do Model no controller:
use App\Models\Produto;

Adicionar construtor

private $produto;

public function __construct(Produto $produto)
{
$this->produto = $produto;
}

O index muda para:

public function index()
{
$produtos = $this->produto->all();
return view('produtos.index');
}

Criar método teste

public function testes()
{
$prod = $this->produto;
$prod->nome = 'Nome do produto';
$prod->number = 123432;
$prod->active = true;
$prod->category = 'eletronicos';
$prod->description = 'Descrição do produto';
$insert = $prod->save();

if ($insert)
return 'Inserido com sucesso';
else
return 'Falha ao inserir';
}

Outra forma:

$this->produto->insert([
'nome' => 'Nome do produto',
'number' =>
...
])

Existem vários métodos assim: create(),

O create é importante pois obriga a existência de uma relação de colunas a adicionar ao banco
A relação de campos a serem preenchidos fica no model, assim:

protected $fillable = [
'nome', 'number', 'active', 'categoty', 'description'
];

Update do registro 5

$prod = $this->produto->find(5);

Debugar

dd($prod); // Não precisa de exit

dd($prod->nome);

$prod = $this->produto->find(5);
$prod->nome = 'Nome Update';
$prod->number = 123432;
$prod->active = true;
$prod->category = 'eletronicos';
$prod->description = 'Descrição do produto';
$update = $prod->save();

if ($update)
return 'Atualizado com sucesso';
else
return 'Falha ao atualizar';

Usamos o método save() também para atualizar

Outra forma é usando o método update() (requer lista de campos)

$prod = $this->produto->find(6);
$prod->update([
'nome' => 'Nome do produto6',
'number'
...
]);

Outro método útil para retornar por outro campo:

$prod = $this->produto
->where('nome', 'João Brito')
->where('number', 123543);

Delete

$prod = $this->produto->find(3)->delete();
ou
$prod = $this->produto->find(6);
$delete = $prod->delete();

ou

$prod = $this->produto->find(6);
$delete = $prod->destroy();

ou
$prod = $this->produto->destroy(3);
ou
$prod = $this->produto->destroy([3,5,8]);

ou
$delete = $this->produto->where('number', 123654)->delete();

Melhorar CSS

Criar paste template em views/produtos
Criar nesta pasta o arquivo template.blade.php, contendo

<table>
<head>
<title>{{$title or 'Curso de Laravel 5.3'}}</title>
</head>
<body>
@yield('content')

</body>
</html>

Em views/produtos criar
index.blade.php, contendo

@extends('produtos.templates.template')

@section('content')
<table>
<tr>
<th>Nome</th>
<th>Descrição</th>
</tr>
@foreach($produtos as $produto)
<tr>
<td>{{$produto->nome}}</td>
<td>{{$produto->descricao}}</td>
</r>
@endforeach
</table>

@endsection

No método index do controller podemos adicionar um título para a página:
$title = 'Listagem de produtos';
return view('produtos.index', compact('produtos', 'title'));

No controller, método create criar uma variável categoria, com um array com as categorias

No método create criar também a variável $title

<form class="form" mathod="post" action="{{route('produtos.store')}}">
<input type="hidden" name="_token" value="{{csrf_token}}">
<input type="text" name="nome" placeholder="Nome:" class="form-control">
<label>
<input type="checkbox" name="active"><br>
Ativo?
</label>
<input type="text" name="number" placeholder="Número:" class="form-control">
<select name="categoria" class="form-control">
<option value="">Escolha a categoria</option>
@foreach($categorias as $categoria)
<option>{{$categoria}}</opton>
@endforeach
</select>
<textarea name="descricao" placeholder="Descricao" class="form-control"></textarea>
</form>

No Laravel Todo form precisa de um campo com o token

ou substituir o campo por
{!! csrf_field() !!}

O método store

public function store(Request $request)
{
// Recupera todos os campos do form - $request->all();
}

Para recuperar apenas alguns campos:

$request->only(['nome', 'number']);

Recupererar todos, exceto alguns:

$request->except(['_token', 'categoria']);

Recuperar apenas um campo
$request->input('nome');

Recuperar campo pelo seu nome
$request->name;

Cadastrar os dados do form na tabela

public function store(Request $request)
{
// Pega todos os campos do form
$dataForm = $request->except('_token');

// Faz o cadastro
$insert = $this->product->insert($dataForm);

if($insert)
return redirect()->route('produtos.index');
else
return redirect()->back(); // Volta para onde veio
//ou
// return redirect()->route('produtos.create'); // Volta para onde veio
}

Para o avtive, que é requerido

if($dataForm['active'] == '')
$dataForm['active'] = 0;
else
$dataForm['active'] =1;
ou
$active['dataForm'] = (!isset($dataForm['active'])) ? 0 : 1;

Validação dos dados antes de submeter o form

Validar no método store antes de inserir no banco

As regras de validação devem ficar no model e não no controller

Editemos o model produto e adicionemos uma variável public (também pode ser um mátodo)

public $rules = [
'nome' => 'required|min:5|max:100',
'number' => 'required|numeric',
'categoria' => 'required',
'descricao' => 'min:3|max:1000'
];

Adicionar ao método store, antes de inserir:

$this->validate($request, $this->produto->rules);

Mostrar as mensagens de erro da validação na view create
Logo no início do form, abaixo da tag form

@if(isset($errors) && count($errors) >0)
<div class="alert alert-danger">
@foreach($errors->all(() as $error)
<p>{{$error}}</p>
@endforeach
</div>
@endif

Como manter os valores digitados nos campos do form após o submit?

Em cada campo
... value="{{old('nome')}}"

No método store, na validação podemos passar uma variável com as mensagens de erro

$this->validate($request, $this->produto->rules, $messages);

Personalizando as mensagens:

$mensagens = [
'nome.required' => 'Nome obrigatório',
'nome.min' => "Nome com pelo menos 3 caracteres',
'number.numric' => 'Number precisa ser numérico'
];

https://www.youtube.com/watch?v=fPs-PlQIWaw&index=6&list=PLVSNL1PHDWvR3PeLXz6nvBkDhv1IQk4wP

Laravel - Model

2017-06-25T21:08:35-03:00

Models - lidam com código que manipula bancos de dados

No Laravel 5 ficam na pasta \app

Cada tabela tem um model correspondente, que é usado para interagir com a tabela. Models permitem consultar a tabela e também inserir registros na mesma.

Ficam em app soltos, mas podemos criar dentro de outras pastas, tendo o cuidado de alterar seu namespace

Todo model Eloquent extend a classe
Illuminate\Database\Eloquent\Model

https://www.youtube.com/watch?v=eFuhNCFrR2E&index=12&list=PLVSNL1PHDWvTQnUQjhBEzY2ZSzJTR9zcZ

Criar uma model com o artisan
php artisan make:model Carro

ou para criar juntamente com a migration:
php artisan make:model Carro -m

Para o laravel uma tabela carros é representada por um model carro.

O comando acima cria uma classe vazia de Model, mas é suficiente.

Agora basta alterar o Controller, passando este model.

Podemos criar um diretório para os models dentro de app

Então passamos este diretório no namespace do model que criamos e de outros que criarmos.

php artisan make:model Produto

Criar uma pasta para os models:

app/Models

Criar o mesmo model em app/Models (já cria com o namespace correto em models)
php artisan make:model Models\\Produto

Para uma tabela chamada produtos um model Produto.

Criar também a migration:
php artisan make:model Models\\Produto -m

No controller adicionar:

use App\Models\Produto;

public function index(Produto $produto){
$produtos = $produto->all();

return view('produtos.index', compact('produtos'));
}

Criar a view index em views/produtos/index.blade.php

<h1>Listagem de Produtos</h1>

<table>
<tr>
<th>Nome</th>
<th>Descrição</th>
</tr>
@foreach($produtos as $produto)
<tr>
<td>{{$produto->nome}}</td>
<td>{{$produto->descricao}}</td>
</r>
@endforeach
</table>

Criar uma rota para produtos

Route::resource('produtos', 'Produtos\ProdutoController');

Laravel - View

2017-06-25T21:08:35-03:00

Views - camada de apresentação, que mostra os dados para o usuário, geralmente como HTML

Para usar facade de Forms e HTML no laravel 5 execute:

composer require Collective\Html

Adicionar ao require do composer.json:
"laravelcollective/html": "5.4.6"

composer update

Adicionar na seção provider de config/app.php a linha

Collective\Html\HtmlServiceProvider::class,

E na seção aliases de config/app.php:

'Form' => Collective\Html\FormFacade::class,
'Html' => Collective\Html\HtmlFacade::class,

Depois disso podemos criar forms assim:

{!! Form::open([
'route' => 'tasks.store'
]) !!}

<div class="form-group">
{!! Form::label('title', 'Title:', ['class' => 'control-label']) !!}
{!! Form::text('title', null, ['class' => 'form-control']) !!}
</div>

<div class="form-group">
{!! Form::label('description', 'Description:', ['class' => 'control-label']) !!}
{!! Form::textarea('description', null, ['class' => 'form-control']) !!}
</div>

{!! Form::submit('Create New Task', ['class' => 'btn btn-primary']) !!}
{!! Form::close() !!}

if(view()->exists('clientes.store')){

}

{{ $nome or 'Valor Default'}}

Dados sem caracteres de scape

Olá, {!! $nome !!}

Formato de data

echo with($var)->format('d/m/Y H:i');

Relacionamentos

2017-06-25T21:08:35-03:00

Relacionamento entre tabelas e entre models no Laravel 5

Para relacionar tabelas usar a convenção

inserir um campo chamado
tabela_id int not null

Relacionar users com groups:

groups
id

users
id
group_id

Relacionar os Models Task com User

class Task extends Model {
public function user()
{
return $this->belongsTo('User');
}
}

class User extends Model {
public function tasks()
{
return $this->hasMany('Task');
}
}

Relacionamento entre posts e comments
Um para muitos

namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
/**
* Get the comments for the blog post.
*/
public function comments()
{
return $this->hasMany('App\Comment'); // Passamos aqui a chave estrangeira, mas somente quando diferente
}
}

Comments
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
/**
* Get the post that owns the comment.
*/
public function post()
{
return $this->belongsTo('App\Post');
}
}

Ou usamos App\Post
ou fazemos o importe no começo e usamos apenas Post

Usando o tinker para trazer um produto e suas avaliações

php artisan tinker

use Loja\Produto;
$p->Prpduto::find(5);

$p->avaliacoes;