V minulém dílu jsme si připravili naše vývojové prostředí a rozběhli si nový Laravel projekt. V tomto dílu si připravíme základní databázovou strukturu, kterou budeme ze začátku potřebovat. K tomu využijeme modely, migrace, seedery, model factory společně s knihovnou Faker a vysvětlíme si k čemu slouží a jak fungují.

Připojení k databázi

Veškeré nastavení je možné nastavovat pomocí souboru `.env` , ve kterém naleznete i hodnoty pro připojení k MySQL databázi. Konkrétně začínají prefixem `DB_`. Myslím že názvy klíčů jsou výstižné a není problém je upravit podle svých potřeb. Tyto hodnoty se pak využívají v souboru `config/database.php`, ve kterém najdete konfiguraci ohledně připojení k různým databází, je zde i možnost definovat si vlastní připojení k jiné databázi v případě potřeby.

Modely

Laravel nabízí možnost pracovat s databází pomocí ORM a k tomu využívá Eloquent, jednoduchou ActiveRecord implementaci. Každá databázová tabulka má odpovídající "model", který se využívá pro práci právě s jeho tabulkou. Skrze model je možné se dotazovat na potřebnou tabulku či přidávat nové záznamy.

Pro náš projekt budeme prvně potřebovat modely, respektive tabulky, pro kategorie a pro příspěvky. Pomocí příkazové řádky a artisanu si tedy vytvoříme nové modely a rovnou si k nim vytvoříme i migrace (-m), které si popíšeme v další části. Celý příkaz pak vypadá takto:

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

Po spuštění příkazů se nám v adresáři app vytvořily dva nové modely - Category a Post. Ty můžeme aktuálně nechat tak jak jsou, úpravy budeme dělat postupně. Jen dodám, že defaultně se předpokládá, že databázové tabulky budou v množném čísle a budou mít tedy názvy categories a posts . Pokud bychom chtěli mít model pro jinak pojmenovanou tabulku, pak stačí přidat proměnnou $table:

    /**
     * Tabulka spojena s modelem
     *
     * @var string
     */
    protected $table = 'my_categories';

Stejně tak se předpokládá, že primárním klíčem bude sloupec id. Pokud to tak není, stačí nastavit proměnnou $primaryKey.

Migrace

Pro vytváření databázové struktury budeme využívat migrací. Ty nám pomáhají zachovat konzistenci v případě, kdybychom na projektu pracovali ve více lidech a všichni vývojáři by potřebovali mít stejnou strukturu. Toho se těžko dosahuje pokud bychom všechny tabulky či databázové příkazy jako INSERT, UPDATE apod. prováděli ručně. Musíme tedy ostatní vývojáře o této změně nějak informovat a co nejjednodušší cestou jim umožnit, aby si upravili databázovou strukturu stejně jako máme třeba my. A přesně k tomuto účelu slouží migrace.

Migrace najdeme v adresáři database/migrations kde jsou již předpřipravené dvě migrace pro vytvoření tabulky users a password_resets.  Další dvě pro vytvoření kategorií a příspěvků jsme si již vytvořili v předchozí části s modely. Pokud bychom si chtěli vytvořit vlastní migrace pro vytvoření tabulek, pak to lze udělat jednoduše pomocí artisanu:

php artisan make:migration create_categories_table --create=categories

Jako první si upravíme migraci s kategoriemi, kde přidáme název a slug:

    public function up()
    {
        Schema::create('categories', function (Blueprint $table) {
            $table->increments('id');
            $table->string('name');
            $table->string('slug');
            $table->timestamps();
        });
    }

Poté si upravíme migraci s příspěvky podle našich potřeb:

    public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->increments('id');
            $table->integer('user_id')->unsigned();
            $table->integer('category_id')->unsigned();
            $table->string('title');
            $table->string('slug')->unique();
            $table->string('content');
            $table->timestamps();

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

            $table->foreign('category_id')
                  ->references('id')
                  ->on('categories')
                  ->onDelete('restrict')
                  ->onUpdate('cascade');
        });
    }

Není to nic složitého, jen přidáme autora a kategorii článku, jeho název a slug pro url adresu (nechceme přece vidět v odkazu ID článků) a samotný obsah. Nakonec přidáme cizí klíče.

Samotné migrace spustíme pomocí následujícího příkazu, který spustí všechny migrace, vykoná jejich příkazy a v databázi vytvoří novou tabulku migrations, kde si uloží všechny vykonané migrace. Podle toho pak pozná, které migrace již byly vykonány a které ještě ne.

php artisan migrate

Seeds a model factory

Dále budeme potřebovat nějaké testovací data, se kterýma budeme pracovat. Laravel nabízí dvě funkce, které nám s tímto pomohou: první je databázový seeder který databázi naplní daty, a druhá je tzv. "model factory", která nám umožní generovat fiktivní data, která můžeme použít pro testování. Factory pro kategorie si vytvoříme pomocí artisan příkazu: ```php php artisan make:factory CategoryFactory ```

Továrna se nám vytvořila v database/factories. Slouží především jako generátor testovacích dat pomocí knihovny Faker, díky které můžeme definovat jaké data pro každý sloupec chceme vygenerovat. Doporučuji si projít tuto knihovnu a zjistit co všechno nabízí. Továrnu CategoryFactory si nadefinujeme takto:

use App\Category;
use Faker\Generator as Faker;

$factory->define(Category::class, function (Faker $faker) {
    return [
        'name' => substr($faker->sentence(2), 0, -1),
        'slug' => $faker->slug(3),
    ];
});

Pro vygenerování názvu využijeme metody $faker->sentense() a substr pro odstranění tečky na konci věty. Poté si vytvoříme továrnu PostFactory pro příspěvky:

use App\Category;
use App\Post;
use App\User;
use Faker\Generator as Faker;

$factory->define(Post::class, function (Faker $faker) {
    return [
        'title' => substr($faker->sentence(2), 0, -1),
        'slug' => $faker->slug(3),
        'content' => $faker->paragraph,
        'user_id' => function() {
            return factory(User::class)->create()->id;
        },
        'category_id' => function() {
            return factory(Category::class)->create()->id;
        }
    ];
});

Všimněte si zanoření dalších továren pro vygenerování uživatele a kategorie. Pro jednoduchost bude mít každý příspěvek přiřazenou jednu kategorii a všichni uživatelé budou mít jeden článek.

Dalším krokem je vytvoření databázového seederu, který nám naplní tabulky daty. Pro vytvoření nového seederu v database/seeds využijeme opět artisan:

php artisan make:seeder PostsTableSeeder

Ve vytvořené třídě PostsTableSeeder si v metodě run() zavoláme naši továrnu a určíme kolik záznamů se má vytvořit, v našem případě deset:

use Illuminate\Database\Seeder;

class PostsTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        factory(App\Post::class, 10)->create();
    }
}

Abychom PostTableSeeder "aktivovali" tak ho potřebujeme zavolat z hlavní metody run() třídy database/seeds/DatabaseSeeder.php:

use Illuminate\Database\Seeder;

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

Nyní můžeme spouštět migrace a seedy pro vytvoření dat v tabulkách automaticky. Použitím příkazu migrate:fresh můžeme smazat všechny schémata migrací, nahrát je znovu a spustit seedy:

$ php artisan migrate:fresh --seed
Dropped all tables successfully.
Migration table created successfully.
Migrating: 2014_10_12_000000_create_users_table
Migrated:  2014_10_12_000000_create_users_table
Migrating: 2014_10_12_100000_create_password_resets_table
Migrated:  2014_10_12_100000_create_password_resets_table
Migrating: 2018_02_24_103112_create_categories_table
Migrated:  2018_02_24_103112_create_categories_table
Migrating: 2018_02_24_103216_create_posts_table
Migrated:  2018_02_24_103216_create_posts_table
Seeding: PostsTableSeeder

Závěr

Tímto bychom měli vytvořenou základní jednoduchou databázovou strukturu. V dalším díle si vytvoříme základní layout, zobrazíme si všechny články a vysvětlíme si něco o šablonách v Laravel.

Není vám něco jasné, nefunguje nebo mám někde chybu? Napište do komentářů!

Zdrojové kódy pro tento díl naleznete na GitHubu 

Užitečné odkazy: