Quickstart - Introdução ao Framework

Lucas Macedo

@luuckymacedo

github.com/lucassmacedo

Back-End Developer

ADS Unicesumar

O QUE É?

O Laravel é um framework em PHP baseado no conceito de RAD (Rapid Application Development)

Desenvolvido por Taylor Otwell.

Possui código aberto e uma comunidade ativa.

Utiliza o composer, fornecendo todo o poder das demais bibliotecas escritas para PHP.

Server Requirements

PHP >= 7.1.3
OpenSSL PHP Extension
PDO PHP Extension
Mbstring PHP Extension
Tokenizer PHP Extension
XML PHP Extension
Ctype PHP Extension
JSON PHP Extension

Instalação

composer global require "laravel/installer"

laravel new my-app

composer create-project --prefer-dist laravel/laravel blog

php artisan serve

Estrutura

app/
artisan.php
bootstrap/
composer.json
composer.lock
config/
database/
package.json
phpunit.xml
public/
resources/
routes/
server.php
storage/
tests/
vendor/
webpack.mix.js

Lifecycle

O ponto de entrada de todas as requisições para um aplicativo em Laravel é o arquivo public/index.php.

O arquivo index.php carrega o arquivo de autoload gerado pelo Composer, e em seguida, recupera uma instância da aplicação Laravel em bootstrap/app.php

Kernels: HTTP, Console, Handlers

Service Providers

Service providers são responsáveis pela inicialização de vários componentes do Framework, como os componentes de banco de dados, filas, de validação e de roteamento. Uma vez que inicializado, será configurado todos os recursos oferecidos pelo Framework, os service providers são o aspecto mais importante de todo o processo de inicialização do Laravel.

Artisan Console

Artisan é o nome da interface para linha de comando incluida que faz parte do Laravel. Ele provê inúmeros comandos úteis que você pode usar enquanto desenvolve sua aplicacação. Ele é baseado no poderoso componente Symfony Console.


php artisan list


php artisan make:console SendEmails --command=emails:send

<?php namespace App\Console\Commands;

use App\User;
use App\DripEmailer;
use Illuminate\Console\Command;
use Illuminate\Foundation\Inspiring;

class Inspire extends Command
{
    protected $signature = 'email:send {user}';

    protected $description = 'Send drip e-mails to a user';
 
    protected $drip;

    public function __construct(DripEmailer $drip)
    {
        parent::__construct();

        $this->drip = $drip;
    }

    public function handle()
    {
        $this->drip->send(User::find($this->argument('user')));
    }
}

Ponto de entrada: Rotas

As rotas são o ponto de entrada para uma aplicação Laravel. Através das rotas direcionamos as requisições dos nossos usuários para os controllers corretos.

routes/
    api.php
    channels.php
    console.php
    web.php

Route::get('/', function () {
    return view('welcome');
});

Route::get('/posts', 'HomeController@index');

Route::post('/posts', 'HomeController@store');

Route::get('posts/{post}', 'HomeController@show');

Route::put('posts/{post}', 'HomeController@update');

Route::delete('/posts/{post}', 'HomeController@destroy');

Route::domain('{account}.myapp.com')->group(function () {
    Route::get('user/{id}', function ($account, $id) {
        //
    });
});

Route::prefix('admin')->middleware('auth')->group(function () {
    Route::get('users', function () {
        // Matches The "/admin/users" URL
    });
});

Middleware

HTTP middleware fornece um mecanismo conveniente para filtragem das requisições HTTP que entram em sua aplicação. Por exemplo, Laravel inclui um middleware que verifica se o usuário de sua aplicação está autenticado.

php artisan make:middleware RedirectIfAuthenticated

// Within App\Http\Kernel Class...

protected $routeMiddleware = [
     ....
    'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
];

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Support\Facades\Auth;

class RedirectIfAuthenticated
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @param  string|null  $guard
     * @return mixed
     */
    public function handle($request, Closure $next, $guard = null)
    {
        if (Auth::guard($guard)->check()) {
            return redirect('/');
        }

        return $next($request);
    }
}

<?php
# routes/web.php

Route::get('/login', 'AuthController@login')->middleware('guest');

#ou 

Route::middleware('guest')->group(function () {
    Route::get('/login', 'AuthController@login');
    Route::get('/register', 'AuthController@login');
});

Controllers

Controllers são responsáveis por "controlar" a nossa aplicação. Eles recebem a requisição e direcionam para o lugar correto.

php artisan make:controller PostsController
php artisan make:controller PostsController --resource
php artisan make:controller PostsController --resource --model=Post
php artisan make:controller API/PostsController --api

<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PostsController extends Controller
{
    public function index()
    {
        //
    }

    public function store(Request $request)
    {
        //
    }

    public function show($id)
    {
        //
    }

    public function update(Request $request, $id)
    {
        //
    }

    public function destroy($id)
    {
        //
    }
}

Models (Eloquent ORM)

O Eloquent ORM incluido com o Laravel fornece uma bonita, e simples implementação ActiveRecord para trabalhar com o seu banco de dados. Cada trabala do banco de dados tem a um "Modelo" correspondente que é usado para interagir com determinada tabela.

php artisan make:model Post 
php artisan make:model Post -m

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    protected $fillable = ['user_id','title','content'];

    public function user()
    {
        return $this->belongsTo('App\User');
    }

    public function comments()
    {
        return $this->hasMany('App\Comment');
    }
}


...


// get all posts
$comments = App\Post::all();

// find the post with id 23
$comment = App\Post::find(23)

// find all posts with comments
$comments = App\Post::with('comments')->get();

// Not Found Exceptions
$comment = App\Post::where('active', '==', 1)->firstOrFail();

$comments = App\Post::where('active', 1)
               ->orderBy('title', 'desc')
               ->take(10)
               ->get();

// update
$comment = App\Flight::find(1);
$comment->title = 'New Flight Name';
$comment->save();

// delete
$comment->delete();

<?php

namespace App;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{

    protected $casts = [
        'birthday'  => 'date:Y-m-d',
        'joined_at' => 'datetime:Y-m-d H:00',
        'is_admin'  => 'boolean',
        'options'   => 'array'
    ];
}

//

$user = App\User::find(1);

$options = $user->options;

$options['key'] = 'value';

$user->options = $options;

$user->save();

Migrations

Migrations são um tipo de controle de versão para o seu banco de dados. Eles permitem que uma equipe modifique o esquema do banco de dados e fique atualizado no estado do esquema atual.

php artisan make:migration create_posts_table
php artisan migrate
php artisan migrate:reset
php artisan migrate:refresh

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreatePostsTable extends Migration
{
    public function up()
    {
        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', 100);
            $table->string('content');
            $table->boolean('status')->default(true);
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('posts');
    }
}

Collections

A classe Collection prove conveniente wrapper para trabalhar com arrays de dados.

$collection = collect(['taylor', 'abigail', null])->map(function ($name) {
    return strtoupper($name);
})
->reject(function ($name) {
    return empty($name);
});

$collection = collect([
    ['account_id' => 'account-x10', 'product' => 'Chair'],
    ['account_id' => 'account-x10', 'product' => 'Bookcase'],
    ['account_id' => 'account-x11', 'product' => 'Desk'],
]);

$grouped = $collection->groupBy('account_id');
$grouped->toArray(); // or $grouped->toJson();

//

$collection = collect([1, 2, 3]);
$total = $collection->reduce(function ($carry, $item) {
    return $carry + $item;
});

//

$collection = collect([
    ['name' => 'Desk', 'price' => 200],
    ['name' => 'Chair', 'price' => 100],
    ['name' => 'Bookcase', 'price' => 150],
]);

$collection->sortBy('price');

Seed

Laravel inclui um método simples para popular (semear) seu banco de dados com dados de teste usando as classes Seed. Todas as Seeders são armazenadas em database/seeds.

php artisan make:seeder UsersTableSeeder

<?php
use DB;
use Illuminate\Database\Seeder;
use Illuminate\Database\Eloquent\Model;

class DatabaseSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        DB::table('users')->insert([
        	'name' => str_random(10),
        	'email' => str_random(10).'@gmail.com',
        	'password' => bcrypt('secret'),
        ]);
    }
}
...

php artisan db:seed
php artisan db:seed --class=UsersTableSeeder

Using Model Factory

Você pode usar model factories para gerar uma grande quantidade de registros para o banco de dados.

Uma vez definidas as factories, pode usar a função helper factory para inserir registros em seu banco de dados.

php artisan make:factory UserFactory --model=User

<?php

use Faker\Generator as Faker;

/*
|--------------------------------------------------------------------------
| Model Factories
|--------------------------------------------------------------------------
|
| This directory should contain each of the model factory definitions for
| your application. Factories provide a convenient way to generate new
| model instances for testing / seeding your application's database.
|
*/

$factory->define(App\User::class, function (Faker $faker) {
    return [
        'name' => $faker->name,
        'email' => $faker->unique()->safeEmail,
        'password' => bcrypt('secret'),
        'remember_token' => str_random(10),
    ];
});

https://github.com/fzaninotto/Faker

<?php
use DB;
use Illuminate\Database\Seeder;
use Illuminate\Database\Eloquent\Model;

class DatabaseSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        // only users
        factory(App\User::class, 50)->create();

        // users with posts
        factory(App\User::class, 50)->create()->each(function ($u) {
          $u->posts()->saveMany(factory(App\Post::class, 10)->make());
        });
    }
}

API Resources

Ao criar uma API, você pode precisar de uma camada que filtre e formate seus dados em respostas JSON.

php artisan make:resource PostResource
php artisan make:resource Post --collection

<?php
namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\JsonResource;
class PostResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'content' => $this->content,
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }
}

//

use App\User;
use App\Http\Resources\UserResource;

Route::get('/post/{id}', function ($id) {
    return new PostResource(Post::find($id));
});

<?php
namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\ResourceCollection;
class PostCollection extends ResourceCollection
{
    public function toArray($request)
    {
        return [
            'data' => $this->collection,
            'links' => [
                'self' => 'link-value',
            ],
        ];
    }
}
//

use App\User;
use App\Http\Resources\PostCollection;

Route::get('/posts', function () {
    return PostCollection::collection(Post::all());
});

http://jsonapi.org/

A SPECIFICATION FOR BUILDING APIS IN JSON

Browser Tests (Laravel Dusk)

O Laravel Dusk fornece uma API de teste e automação do navegador de expressiva e fácil de usar. Por padrão, o Dusk não exige que você instale JDK ou Selenium em sua máquina. Em vez disso, o Dusk usa uma instalação independente do ChromeDriver .

Text

<?php

namespace Tests\Browser;

use App\User;
use Tests\DuskTestCase;
use Laravel\Dusk\Chrome;
class ExampleTest extends DuskTestCase
{

    public function testBasicExample()
    {
        $user = factory(User::class)->create([
            'email' => 'taylor@laravel.com',
        ]);

        $this->browse(function ($browser) use ($user) {
            $browser->visit('/login')
                    ->type('email', $user->email)
                    ->type('password', 'secret')
                    ->press('Login')
                    ->assertPathIs('/home');
        });
    }
}