-
-
Save Clayder/509898d99fe9fa3ff4b0710c7b714c52 to your computer and use it in GitHub Desktop.
Definir o valor da APP_KEY
php artisan key:generate
Criar um controlador
php artisan make:controller Nome_controller
Criar controlador com métodos (index, create, store, show, edit, update e destroy)
php artisan make:controller Nome_controller –resource
Obs: Para inserir as rotas de todos os métodos, no arquivo route, utilizar:
route::resource('clients', 'Admin\ClientsController');
Exibir as rotas da aplicação
php artisan route:list
Listar todas as rotas do sistema
artisan route:list
Grupos
Route::group([
'prefix' => 'admin',
'namespace' => 'Admin'
], function(){
Route::resource('clients', 'ClientsController');
});
Utilizando o namespace, todas as rotas vão possuir o caminho Admin\ ...
$clients = \App\Client::all();
// Retornar a view no controlador
return view('admin.clients.index', compact('clients'));
A partir do Laravel 5.5 foi criado o comando php artisan make:factory. Esse comando é usado para criar as fábricas que vão gerar os nossos dados.
Obs:
php artisan make:factory --help
Para criar uma factory, é só inserir o nome do model junto com factory ex: Em relação ao model Clients, utilizar:
php artisan make:factory ClientsFactory
Utilizamos o método $factory ->state(), para criar uma variação de fakes.
Ex: Na nossa aplicação nós temos uma tabela cliente, sendo que podem existir clientes físicos e jurídicos. Podemos utilizar o método $factory->define(), para gerar dados em comum ao cliente físico e jurídico (ex: Os dois tipos de clientes tem nome e e-mail) e criar uma chamada ao método state, para gerar dados do cliente físico e uma outra chamada para criar dados do cliente jurídico.
// Carrego uma lista com cpfs e cnpjs falsos
require_once __DIR__ . '/../faker_data/document_number.php';
$factory->define(\App\Models\Clients::class, function (Faker $faker) {
return [
'name' => $faker->name,
'email' => $faker->email,
'phone' => $faker->phoneNumber,
'defaulter' => rand(0, 1)
];
});
$factory->state(\App\Models\Clients::class, \App\Models\Clients::TYPE_INDIVIDUAL, function (Faker $faker) {
$cpfs = cpfs();
return [
'document_number' => $cpfs[array_rand($cpfs, 1)],
'date_birth' => $faker->date(),
'sex' => rand(1, 10) % 2 == 0 ? 'm' : 'f',
'marital_status' => rand(1, 3),
'physical_disability' => rand(1, 10) % 2 == 0 ? $faker->word : null,
'client_type' => \App\Models\Clients::TYPE_INDIVIDUAL
];
});
$factory->state(\App\Models\Clients::class, \App\Models\Clients::TYPE_LEGAL, function (Faker $faker) {
$cnpj = cnpjs();
return [
'document_number' => $cnpj[array_rand($cnpj, 1)],
'company_name' => $faker->company,
'client_type' => \App\Models\Clients::TYPE_LEGAL
];
});
Para executar a factory via tinker utilizamos o comando:
factory(\App\Models\SoccerTeam::class)->create();
No caso do Client nós utilizamos o método states. Gerando fakes do tipo cliente físico ( individual):
$client = factory(\App\Models\Clients::class)→states(\App\Models\Clients::TYPE_INDIVIDUAL ) ->make();
$client->save();
Cria um seeder
php artisan make:seeder ClientTableSeeder
Configurar a seeder
-
Criar e implementar a factory.
-
Criar a seeder :
php artisan make:seeder ClientTableSeeder -
Acessar a seeder dentro da pasta database/seeds.
-
Implementar a seeder. Ex: Vamos criar 100 times.
public function run() { factory(\App\Models\SoccerTeam::class, 100)->create(); } -
Registrar essa seeder na class database/seeds/DatabaseSeeder.php dentro do método
run()public function run() { $this->call(SoccerTeamsTableSeeder::class); }
Configurar seeder ( chave estrangeira )
Vamos configurar a seeder ClientTableSeeder, a tabela clients possui uma associação com a tabela soccer_teams, então toda vez que um cliente for criado, vamos ter que associar um time.
public function run()
{
// Retorno os times
$soccers = \App\Models\SoccerTeam::all();
/**
* Recebo uma coleção de clientes ( 10 ) do tipo físico
*/
$collectionIndividual = factory(\App\Models\Clients::class, 10)
->states(\App\Models\Clients::TYPE_INDIVIDUAL)->make();
/**
* É realizado uma estrutura de repetição, onde cada cliente
* é associado a um time aleatório.
*/
$collectionIndividual->each(function ($client) use ($soccers) {
// Atribuo um id aleatório
$client->soccer_team_id = $soccers->random()->id;
$client->save();
});
$collectionLegal = factory(\App\Models\Clients::class, 10)
->states(\App\Models\Clients::TYPE_LEGAL)->make();
$collectionLegal->each(function ($client) use ($soccers) {
$client->soccer_team_id = $soccers->random()->id;
$client->save();
});
}
Nós temos que registrar essa seeder na class database/seeds/DatabaseSeeder.php dentro do método run().
Executa a seeder
php artisan db:seed
Executa as migrações e seeder
php artisan migrate:refresh --seed
Obs: Se apresentar algum erro. Executar:
php artisan migrate:fresh –seed ( ????? )
Obs: Se alterar o nome do arquivo de uma migração, executar
composer dumpautoload
Reverter migração
php artisan migrate:rollback
Realiza uma migração de alteração na tabela clients
php artisan make:migration nome_migration --table=clients
Obs1: Para realizar alteração de um campo da tabela, temos que utilizar o método
change()
ex:
public function up()
{
Schema::table('clients', function (Blueprint $table) {
$table->string('document_number')->unique()->change();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::table('clients', function (Blueprint $table) {
$table->dropUnique('clients_document_number_unique');
});
}
Obs2: Para realizar uma migração de alteração, tem que ser instalado o doctrine/dbal. Para realizar a instalação via composer, execute:
composer require doctrine/dbal
Obs3: Erro
[Doctrine\DBAL\DBALException] Unknown database type enum requested,
Doctrine\DBAL\Platforms\MySQL57Platform may not support it.
Solução: Dentro do método boot() da classe app\Providers\AppServiceProvider.php inserir:
$platform = Schema::getConnection()→getDoctrineSchemaManager()→getDatabasePlatform();
// Quando um campo for enum, vai ser utilizado string
$platform->registerDoctrineTypeMapping('enum', 'string');
// Retorna todos os clientes
$clients = \App\Client::all();
Client::create([‘nome’] => ‘Fulano’, [‘idade’] => 40);
Obs: Para utilizar o método create, todos os campos têm que estar habilitados no model.
Protected $fillable = [
‘nome’, ‘idade’
];
ex: Dentro da migration da tabela Clients, criei uma chave estrangeira para a tabela soccer_teams.
public function up()
{
Schema::create('clients', function (Blueprint $table) {
// …….
// Criar o campo
$table->integer('soccer_team_id')->unsigned();
//Insere a referência da chave primária
$table>foreign('soccer_team_id')
->references('id')->on('soccer_teams');
// …….
});
}
ex: Dentro do model Clients, criei um método que faz a associação com a tabela soccer_team.
// Cria um relacionamento de muitos para um
public function soccerTeam(){
return $this->belongsTo(SoccerTeam::class);
}
>>> $client = \App\Models\Clients::find(1);
=> App\Models\Clients {#758
id: "1",
name: "Sonya Schaefer",
document_number: "22104836115",
email: "[email protected]",
phone: "637.682.8665 x44701",
defaulter: "1",
date_birth: "1996-05-19",
sex: "f",
marital_status: "3",
physical_disability: "eum",
company_name: null,
client_type: "individual",
soccer_team_id: "1",
created_at: "2017-12-17 22:24:47",
updated_at: "2017-12-17 22:24:47",
}
Para retornar os dados do time (id = 1), temos que acessar o atributo soccerTeam.
>>> $client->soccerTeam
=> App\Models\SoccerTeam {#734
id: "1",
name: "Feeney Trail",
created_at: "2017-12-17 22:26:58",
updated_at: "2017-12-17 22:26:58",
}
$client -> soccerTeam, retorna o objeto com os dados, do time ( id = 1 ).
Para realizar alguma modificação, como por exemplo, mudar o nome do time:
$client->soccerTeam->name = “Novo nome”;
$client->soccerTeam->save();
Utilizando o nosso exemplo, criei o método clients() dentro da class SoccerTeam, que tem como objetivo retorna os clientes de um determinado time.
/**
* Retorna todos os clientes relacionado a um time
* @return \Illuminate\Database\Eloquent\Relations\HasMany
*/
public function clients(){
return $this->hasMany(Clients::class);
}
Para acessar os clientes do time (id = 1), é só acessar o atributo clients.
>>> $soccer = \App\Models\SoccerTeam::find(1);
=> App\Models\SoccerTeam {#752
id: "1",
name: "Novo nome",
created_at: "2017-12-17 22:26:58",
updated_at: "2017-12-17 22:51:12",
}
>>> $soccer ->clients
=> Illuminate\Database\Eloquent\Collection {#732
all: [
App\Models\Clients {#746
id: "1",
name: "Sonya Schaefer",
document_number: "22104836115",
email: "[email protected]",
phone: "637.682.8665 x44701",
defaulter: "1",
date_birth: "1996-05-19",
sex: "f",
marital_status: "3",
physical_disability: "eum",
company_name: null,
client_type: "individual",
soccer_team_id: "1",
created_at: "2017-12-17 22:24:47",
updated_at: "2017-12-17 22:24:47",
},
],
}
Cadastrar um cliente em um time
>>> $client = \App\Models\Clients::find(2);
>>> $data = $client->toArray();
>>> $soccer = \App\Models\SoccerTeam::find(1);
>>> $soccer->clients()->create($data);
>>> $soccer->clients
=> Illuminate\Database\Eloquent\Collection {#746
all: [
App\Models\Clients {#751
id: "1",
name: "Sonya Schaefer",
document_number: "22104836115",
email: "[email protected]",
phone: "637.682.8665 x44701",
defaulter: "1",
date_birth: "1996-05-19",
sex: "f",
marital_status: "3",
physical_disability: "eum",
company_name: null,
client_type: "individual",
soccer_team_id: "1",
created_at: "2017-12-17 22:24:47",
updated_at: "2017-12-17 22:24:47",
},
App\Models\Clients {#748
id: "2",
name: "Ms. Delphine Funk",
document_number: "33957983134",
email: "[email protected]",
phone: "+15809683872",
defaulter: "1",
date_birth: "1988-03-13",
sex: "f",
marital_status: "3",
physical_disability: null,
company_name: null,
client_type: "individual",
soccer_team_id: "1",
created_at: "2017-12-18 00:08:25",
updated_at: "2017-12-18 00:08:25",
},
],
}
No nosso exemplo, nós temos a tabela clients e a tabela clientProfile.
Um profile está associado a um cliente, ou seja, a tabela clientProfile possui uma chave estrangeira (client_id) para a tabela clients.
Na classe, clientProfile, eu crio o método client(), dessa forma através de um clientProfile eu consigo encontrar o cliente associado.
/**
* Relacionamento One-to-many
* @return \Illuminate\Database\Eloquent\Relations\BelongsTo
*/
public function client()
{
return $this->belongsTo(Clients::class);
}
Para listar o cliente associado ao clientProfile (id = 2).
>>> $profile = \App\Models\ClientProfile::find(2);
=> App\Models\ClientProfile {#752
id: "2",
field: "teste2",
client_id: "2",
created_at: "2017-12-18 21:59:53",
updated_at: "2017-12-18 21:59:53",
}
Listar o cliente
>>> $profile->client;
=> App\Models\Clients {#751
id: "2",
name: "Ms. Delphine Funk",
document_number: "33957983134",
email: "[email protected]",
phone: "+15809683872",
defaulter: "1",
date_birth: "1988-03-13",
sex: "f",
marital_status: "3",
physical_disability: null,
company_name: null,
client_type: "individual",
soccer_team_id: "1",
created_at: "2017-12-18 00:08:25",
updated_at: "2017-12-18 00:08:25",
}
Dessa forma nós conseguimos listar o cliente através do seu perfil. Agora vamos fazer da forma inversa, listar o perfil através do cliente.
Na classe Clients temos que criar um método clientProfile()
/**
* Retorna o perfil que está associado a um cliente específico.
* @return \Illuminate\Database\Eloquent\Relations\HasOne
*/
public function clientProfile()
{
return $this->hasOne(ClientProfile::class);
}
Agora precisamos buscar o cliente desejado ( id = 1).
>>> $client = \App\Models\Clients::find(1);
=> App\Models\Clients {#750
id: "1",
name: "Sonya Schaefer",
document_number: "22104836115",
email: "[email protected]",
phone: "637.682.8665 x44701",
defaulter: "1",
date_birth: "1996-05-19",
sex: "f",
marital_status: "3",
physical_disability: "eum",
company_name: null,
client_type: "individual",
soccer_team_id: "1",
created_at: "2017-12-17 22:24:47",
updated_at: "2017-12-17 22:24:47",
}
Buscar os dados do perfil da cliente Sonya Schaefer
>>> $client->clientProfile;
=> App\Models\ClientProfile {#735
id: "1",
field: "teste",
clients_id: "1",
created_at: "2017-12-18 23:47:42",
updated_at: "2017-12-18 23:47:42",
}
Vamos inserir o cliente ( id = 2 ), em um perfil que ainda não existe.
Primeiro vamos buscar os dados desse cliente.
>>> $client2 = \App\Models\Clients::find(2);
Vamos criar o novo perfil e automaticamente associar ele com o cliente ( id = 2).
>>> $client2->clientProfile()->create(['field' => 'novo perfil']);
=> App\Models\ClientProfile {#762
field: "novo perfil",
clients_id: 2,
updated_at: "2017-12-18 23:57:51",
created_at: "2017-12-18 23:57:51",
id: 2,
}
Para realizar a atualização do campo field através do cliente
>>> $client2->clientProfile->field = "teste update";
>>> $client2→clientProfile→save();
>>> $client2→clientProfile;
=> App\Models\ClientProfile {#732
id: "2",
field: "teste update",
clients_id: "2",
created_at: "2017-12-18 23:57:51",
updated_at: "2017-12-19 00:07:30",
}
Para trabalhar com o relacionamento many-to-many, nós temos que criar uma tabela intermediária, por padrão o Laravel não cria essa tabela.
No nosso exemplo, nós vamos realizar um relacionamento com as tabelas, categoria (categories) e produto (products).
Essa tabela intermediária, tem que seguir um nome padrão ( tab1Singular_tab2Singular), sendo que os nomes são colocados em ordem alfabética ( category_product ).
Vamos criar essa tabela:
php artisan make:migration create_category_product_table –create=category_product
Nós temos que inserir as chaves estrangeiras das duas tabelas (categories e products), na tabela category_product.
public function up()
{
Schema::create('category_product', function (Blueprint $table) {
$table->increments('id');
$table->foreign('category_id')->references('id')->on('categories');
$table->integer('product_id')->unsigned();
$table->foreign('product_id')->references('id')->on('products');
$table->timestamps();
});
}
Agora vamos, criar um produto fake:
>>> $product = factory(\App\Models\Product::class) ->create();
=> App\Models\Product {#774
name: "Dr. Cayla Bogan II",
updated_at: "2017-12-19 16:09:54",
created_at: "2017-12-19 16:09:54",
id: 1,
}
Na classe product, inserimos o método categories():
/**
* Realizo o relacionamento many-to-many com a tabela categories.
* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
*/
public function categories()
{
return $this->belongsToMany(Category::class);
}
Cadastrar uma categoria a partir do produto ( id = 1 )
>>> $product->categories()->create(['name' => 'categoria 1']);
=> App\Models\Category {#770
name: "categoria 1",
updated_at: "2017-12-19 16:26:05",
created_at: "2017-12-19 16:26:05",
id: 1,
}
Listar os dados da categoria cadastrada
>>> $product ->categories;
=> Illuminate\Database\Eloquent\Collection {#784
all: [
App\Models\Category {#738
id: "1",
name: "categoria 1",
created_at: "2017-12-19 16:26:05",
updated_at: "2017-12-19 16:26:05",
pivot: Illuminate\Database\Eloquent\Relations\Pivot {#787
product_id: "1",
category_id: "1",
},
},
],
}
Relacionar categorias 1 e 2 (já estão cadastradas) com o produto (id = 4).
>>> $product = \App\Models\Product::find(4);
>>> $product->categories()->attach([1,2]);
Obs: Todos os métodos de relacionamento ( hasOne, belongsTo, hasMany e etc), podem possuir um segundo parâmetro, nesse parâmetro é passado a chave estrangeira. Nos exemplos eu não precisei utilizar esse parâmetro, por causa do nome do método.
Ex: Temos uma tabela soccer_teams e uma tabela clients. A tabela clients possui uma chave estrangeira ( soccer_team_id ) para a tabela soccer_teams.
Na classe SoccerTeam eu tenho o método client, que é utilizado para retornar os clientes de um time específico. O nome da tabela dos clientes é clients.
Como eu coloquei o nome do método, igual ( singular ) ao nome da tabela (clients) do banco de dados.
O eloquent já reconhece a chave estrangeira ( soccer_team_id ) que está na tabela clients. Por isso que eu não precisei passar o segundo parâmetro.
public function client()
{
return $this->belongsTo(Clients::class);
}
Para retornar os clientes do time (id = 2) :
>>> $time = \App\Models\SoccerTeam::find(2);
>>> $time->clients
=> Illuminate\Database\Eloquent\Collection {#796
all: [
App\Models\Clients {#809
id: "1",
name: "Mr. Grover Morissette PhD",
document_number: "11523107120",
email: "[email protected]",
phone: "+1-513-717-6698",
defaulter: "1",
date_birth: "1977-10-19",
sex: "f",
marital_status: "3",
physical_disability: null,
company_name: null,
client_type: "individual",
soccer_team_id: "2",
created_at: "2017-12-19 15:15:26",
updated_at: "2017-12-19 15:15:26",
},
],
}
Se o nome do método fosse buscarClientes, teríamos que passar um segundo parâmetro, com o nome da chave estrangeira:
public function buscarCliente()
{
return $this->hasMany(Clients::class, 'soccer_team_id');
}
Para retornar os clientes do time (id = 2) :
>>> $time = \App\Models\SoccerTeam::find(2);
>>> $time ->buscarCliente
=> Illuminate\Database\Eloquent\Collection {#732
all: [
App\Models\Clients {#746
id: "1",
name: "Mr. Grover Morissette PhD",
document_number: "11523107120",
email: "[email protected]",
phone: "+1-513-717-6698",
defaulter: "1",
date_birth: "1977-10-19",
sex: "f",
marital_status: "3",
physical_disability: null,
company_name: null,
client_type: "individual",
soccer_team_id: "2",
created_at: "2017-12-19 15:15:26",
updated_at: "2017-12-19 15:15:26",
},
],
}