Laravel je jednoduchý rámec pre jazyk PHP, ktorý je založený na vzore MVC (Model-View-Controller). V tomto článku si vysvetlíme základnú štruktúru aplikácie založenej na tomto rámci a ukážeme si ju na jednoduchom príklade.
Laravel patri medzi najpopulárnejšie rámce pre PHP a má rozsiahly ekosystém rozšírení a pomocných nástrojov. Existuje mnoho zmenšených verzií alebo rozšírení Laravel-u ako napríklad Lumen, Statmatic, Spark, Mix a iné, ktoré sú určené na konkrétne úlohy ako napríklad tvorba API, špecializácia na tvorbu front-end-u a podobne.
Projekt Laravel open-source zverejnený pod licenciou MIT a jeho zdrojové kódy sú zverejnené na serveri GitHub.
Inštalácia
V prvom rade je potrebné mať nainštalovaný Composer. Postup inštalácie sa nachádza na webe tohto nástroja. Inštalácia rámca Laravel potom prebieha vykonaním príkazu:
composer global require "laravel/installer"
Je možné, že bude potrebné ešte aktualizovať systémovú premennú $PATH na hodnotu $HOME/.composer/vendor/bin, aby systém vedel nájsť spustiteľnú aplikáciu.
Vytvorenie projektu
Nový projekt vytvoríme príkazom:
laravel new nazov_aplikacie
Laravel sa postará o stiahnutie potrebných balíčkov a knižníc, vytvorenie súborovej štruktúry a pripravenie projektu na vývoj.
V adresári, kde sme spustili príkaz, vznikol nový priečinok s názvom nazov_aplikacie. V našom tutoriáli používame priečinok (a zároveň názov) tutorial. Tento adresár je možné otvoriť ako projekt v nejakom IDE, napríklad PhpStorm, ktorý má pre študentov bezplatnú licenciu po registrácii študentským e-mailom.
Spustenie projektu
Samotnú aplikáciu spustíme príkazom v konzolovom okne (pričom je potrebné byť v adresári projektu):
php artisan serve
Na výstup sa vypíše adresa na ktorej je spustená naša Laravel aplikácia. Štandardne je to na http://localhost:8000/. Ak chceme aby sa naša aplikácia spúšťala na inom porte, je potrebné spustiť projekt nasledujúcim príkazom:
php artisan serve --port="2017"
Toto je výhodné najmä ak spúšťame viacero projektov naraz.
Pripojenie na databázu
Ak sa v aplikácii potrebujeme pripojiť na databázu, je potrebné upraviť súbor .env v priečinku projektu. V tomto súbore sa nachádzajú všetky premenné, ktoré projekt potrebuje a v prípade zmeny prostredia alebo, napríklad, zmeny databázového servera, je potrebné len aktualizovať tieto premenné:
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=tutorial
DB_USERNAME=root
DB_PASSWORD=KPIistheB3$T
Prvá aplikácia
Tvorba jednoduchej aplikácie v tomto frameworku je veľmi jednoduchá a ak už máme všetko pripravené vieme ju vytvoriť. Ako som spomínal na začiatku, Laravel využíva návrhový vzor MVC. Preto budeme postupovať presne podľa neho.
Na začiatok si vytvoríme aplikáciu obsahujúcu zoznam študentov a následne ju trochu rozšírime.
Model
Model je v tomto prípade databázova tabuľka, ktorá bude obsahovať dáta o študentoch. Keďže frameworky používame nato, aby nám uľahčili prácu, všetko čo potrebujeme k vytvoreniu základnej kostry modelu je príkaz:
php artisan make:model People/Student --migration
pričom People je názov adresára, do ktorého sa trieda uloží a Student je názov triedy. V logoch sa nám objavili dva nové záznamy:
Model created successfully.
Created Migration: 2016_12_20_163955_create_students_table
A v súborovej štruktúre pribudli app/Student.php a database/migrations/[timestamp]_create_students_table.php, pričom [timestamp] je čas a dátum vytvorenia tohto modelu.
Triedu Model.php zatiaľ ponecháme prázdnu. Laravel automaticky prepojí túto triedu s tabuľkou students v databáze. Neskôr ju však môžme využiť na rôzne metódy, preddefinované alebo parametrické dopyty alebo definovanie väzieb.
<?php
namespace AppPeople;
use IlluminateDatabaseEloquentModel;
class Student extends Model
{
//
}
Prepínač --migration spôsobil vytvorenie druhého súboru — migrácie. Migrácia definuje vytváranie alebo zmazanie tabuľky, jej atribútov a kľúčov. Vďaka použitiu migrácii dokážeme verziovať zmeny v databáze a pomocou jedného príkazu znovu vytvoriť celú databázu alebo aktualizovať jej štruktúru.
Generovaný súbor vyzerá nasledovne:
<?php
use IlluminateSupportFacadesSchema;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateDatabaseMigrationsMigration;
class CreateStudentsTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('students', function (Blueprint $table) {
$table->increments('id');
$table->timestamps();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('students');
}
}
Pre potreby tohto tutoriálu si ale spomínanú tabuľku (čiže funkciu up()) upravíme nasledovne:
public function up()
{
Schema::create('students', function (Blueprint $table) {
$table->increments('id');
$table->string('first_name');
$table->string('last_name');
$table->date('birth_day');
$table->timestamps();
});
}
Nakoniec na vykonanie migrácie je potrebné spustiť príkaz:
php artisan migrate
čo zabezpečí aj vytvorenie tabuľky students, ktorú očakávame. Popri tom ale vytvorí aj vopred definované tabuľky na autentifikáciu používateľa, ktoré využijeme neskôr.
Controller
Controller (čiže ovládač), je v našom prípade spôsob komunikácie medzi front-endom a back-endom, zabezpečený webovou službou typu REST a jeho HTTP operáciami GET, POST, PUT a DELETE.
Tvorba controllera ako takého je jednoduchá, pretože pozostáva znovu z jedného príkazu:
php artisan make:controller StudentController
Ten vytvorí app/Http/Controllers/StudentController.php, ktorý bude pre nás zabezpečovať celú komunikáciu pre správu študentov. Okrem toho potrebujeme definovať ako bude tento ovládač komunikovať, je potrebné definovať Route, čiže linku, skrze ktorú budeme komunikovať.
V súbore routes/web.php, ktorý má nasledovnú štandardnú podobu
<?php
Route::get('/', function () {
return view('welcome');
});
je potrebné na koniec pridať
Route::resource('student', 'StudentController');
čo zabezpečí, aby pri požiadaní o adresu localhost:8000/student, resp. jej varianty, ktoré si vysvetlíme neskôr, bude aplikácia komunikovať cez StudentController.
Ďalšou úlohou je vytvoriť samotnú funkcionalitu ovládača. Keďže komunikujeme cez REST, ktorého operácie sú GET, POST, PUT a DELETE, Laravel poskytuje možnosť využiť všetky. Zvyčajne operácia GET má za úlohu vrátiť žiadané hodnoty, pričom GET je zvyčajne využívaný prehliadačom na získanie webovej stránky zo servera. Operácia POST odosiela hodnoty na server. Keďže operácie PUT a DELETE nie sú podporované v HTML formulároch, tieto operácie uvádzam ale nebudeme sa im venovať.
Laravel poskytuje vytvorenie 7 funkcií pre využívanie operácií servisu. Každá z nich sa vykoná zavolaním požiadavky na danej ceste podľa tabuľky nižšie.
| Požiadavka | Cesta | Funkcia |
|---|---|---|
| GET | /student |
index |
| GET | /student/create |
create |
| POST | /student |
store |
| GET | /student/{id} |
show |
| GET | /student/{id}/edit |
edit |
| PUT | /student/{id} |
update |
| DELETE | /student/{id} |
destroy |
Pre účely tohto tutoriálu vložíme do databázy nasledovné hodnoty:
INSERT INTO `students` VALUES
(1,'Peter','Technicky','1994-01-01',NULL,NULL),
(2,'Jana','Informaticka','1996-05-08',NULL,NULL),
(3,'Filip','Programovy','1993-12-04',NULL,NULL);
Vytvoríme si funkcie index(), show(), store() a delete(). Ostatné funkcie nám budú vracať návratový kód 403 Forbidden. Čiže obsah ovládača bude zatiaľ nasledovný:
<?php
namespace AppHttpControllers;
use IlluminateHttpRequest;
use AppPeopleStudent as Student;
class StudentController extends Controller
{
public function index() {
//
}
public function create() {
return response('Forbidden', 403)->header('Content-Type', 'text/plain');
}
public function store() {
//
}
public function show($id) {
//
}
public function edit($id) {
return response('Forbidden', 403)->header('Content-Type', 'text/plain');
}
public function update($id) {
return response('Forbidden', 403)->header('Content-Type', 'text/plain');
}
public function destroy($id) {
return response('Forbidden', 403)->header('Content-Type', 'text/plain');
}
}
Funkcia index()
Funkciou, ktorá nám bude vracať zoznam všetkých študentov, je funkcia index(). Je potrebné vyjadriť, že má z databázy vytiahnuť všetky záznamy z tabuľky students. To môžeme urobiť dvomi spôsobmi a to pomocou objektu alebo statickej metódy.
Staticky táto funkcia bude vyzerať nasledovne:
public function index() {
return Student::all();
}
alebo pomocou objektov:
public function index() {
$s = new Student();
return $s::all();
}
Obe tieto variácie funkcie index() vrátia pole JSON objektov, z ktorých každý reprezentuje jeden záznam v databáze. Čiže vrátia nasledovné JSON pole.
[{"id":1,"first_name":"Peter","last_name":"Technicky","birth_day":"1994-01-01","created_at":null,"updated_at":null},
{"id":2,"first_name":"Jana","last_name":"Informaticka","birth_day":"1996-05-08","created_at":null,"updated_at":null},
{"id":3,"first_name":"Filip","last_name":"Programovy","birth_day":"1993-12-04","created_at":null,"updated_at":null}]
V prípade, že by sme nechceli, aby sa z databázy čítali všetky hodnoty, je potrebné funkcii all() vložiť názvy stĺpcov ako parametre. Napríklad: all('id','first_name','last_name').
Funkcia show()
Funkcia show() je volaná na linke /student/{id}, kde {id} je nejaký parameter, v našom prípade číselný. Takže ak by sme chceli zobraziť informácie o študentovi s hodnotou id = 2, tak by sme pristúpili k linke /student/2, resp. celá adresa by vyzerala http://localhost:8000/student/2.
V tomto prípade, je oveľa výhodnejšie pracovať s objektovým prístupom, keďže funkcia where() je trochu problematická v prípade statického použitia. Táto funkcia má tri parametre. Prvý je názov porovnávaného poľa, druhý je operátor a tretí je hodnota. V takomto prípade by sa funkcia where('id','=',$id) preložila do SQL ako where id = $id, resp. za $id by sa dosadila jeho aktuálna reálna hodnota, čiže v našom prípade 2 a celá časť by vyzerala ako where id = 2.
Keďže ale funkcia where() vracia nespracovaný vstup je potrebné za ňou zreťaziť funkciu get(), ktorá môže byť bez parametrov, alebo jej parametre budú ako pri funkcii all() názvy stĺpcov.
Funkcia show() bude potom vyzerať nasledovne:
public function show($id) {
$s = new Student();
return $s->where('id','=',$id)->get();
}
pričom navrátená hodnota je znova pole JSON objektov, pretože ak by sme použii iný operátor, alebo nekľúčový atribút, mohli by sa nám vrátiť aj viaceré hodnoty. Ak nebude nájdený žiaden záznam, vráti sa prázdne pole.
Funkcia store()
Funkcia store() sa volá, keď pošleme pomocou metódy POST požiadavku s hodnotami, ktoré chceme vložiť do databázy. V našom prípade si neskôr pripravíme formulár ktorým vložíme a odošleme hodnoty. Je potrebné si všimnúť, že sme pridali parameter funkcii, ktorý obsahuje samotnú poslanú požiadavku.
Táto funkcia funguje spôsobom, že si vytvoríme novú inštanciu modelu, do nej vložíme hodnoty a uložíme ju. Následne si môžeme zvoliť, ktorý pohľad sa má vrátiť, resp. aké dáta sa majú zobraziť.
Funkcia bude vyzerať následovne:
public function store(Request $request) {
$s = new Student();
$s->first_name = $request->first_name;
$s->last_name = $request->last_name;
$s->birth_day = $request->birth_day;
$s->save();
return $s::all();
}
Ak by sme potrebovali, môžme pridať aj kontrolu, či sú všetky hodnoty vyplnené, prípadne v správnom formáte. Správnosť fungovania si overíme neskôr, keď si vytovríme formulár a pokúsime sa do neho vložiť nové hodnoty.
View
Ako poslednú časť základného rámca MVC si doplníme view, alebo pohľad. Úlohou pohľadov je zobraziť stránku, resp. získané dáta. V prípade, že našim cieľom bolo vytvoriť WEB API, zvyčajne nie je potrebné vytvárať pohľady, aby bolo možné získané JSONy spracovať aj strojovo. Ak chceme ale vytvoriť používateľsky priateľskú aplikáciu, je výhodné doplniť získané dáta aj nejakým ľahko čitateĺným zobrazením.
V tomto tutoriále si ukážeme veľmi primitívne zobrazenie, s použitím kaskádového štýlu Bootstrap. Použijeme iba jednoduché HTML a PHP aby sme si demonštrovali funkčnosť.
Využijeme zároveň nástroj pomúkaný Laravel-om na zjednodušenie práce s PHP a to šablónový systém Blade. Jeho úlohou je urobiť syntax prehľadnejšou a zároveň do natívnej syntaxe PHP zasahovať čo najmenej.
Šablóny Blade
Keďže je veľmi pravdepodobné, že v aplikácia sa bude skladať z viacerých obrazoviek a na každej z nich bude rovnaká hlavička, navigácia, prihlasovanie a iné náležitosti potrebné pre chod aplikácie, je vhodné si rozdeliť view na dve časti: univerzálnu, ktorá bude pre všetky (alebo aspoň pre niektoré) spoločná a konkrétnu pre danú obrazovku.
Najprv si vytvoríme ten spoločný pohľad. V priečinku resources/views si vytvoríme súbor s názvom common.blade.php. Prípona .php nám jasne hovorí, že pôjde o PHP súbor a prípona .blade, ktorá je o úroveň vyššie, hovorí o tom, že súbor je šablónou a je potrebné ho spracovať.
Šablóna bude obsahovať základné rozloženie stránky s prípadnými navigáciami, defionovanými kaskádovými štýlmi a podobne. V našom prípade bude mať len základné rozloženie:
<!DOCTYPE html>
<html>
<head>
<title>TUTORIAL</title>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
</head>
<body>
<div class="container">
<div class="col-xs-12" style="text-align: center">
<h1>Aplikácia</h1>
<div>Toto je ta najpeckovejšia apka pre zoznam študentov.</div>
<h2>Obsah pohľadu</h2>
</div>
<div class="col-xs-4">
Tu by mohlo byt menu alebo nejaky popis,
ktory sa jednoducho meni na jednom mieste
</div>
<div class="col-xs-8">
@yield('content')
</div>
</div>
</body>
</html>
Pričom obsahuje aj direktívu @yield, ktorá hovorí o tom, ktorá časť z konkrétnej šablóny sa má na danom mieste zobraziť. V našom prípade je to content.
Teraz si potrebujeme vytvoriť samotný obsah. Ten vytovríme znova v priečinku resources/views/ ale doplníme ho v podadresári main/students.blade.php, aby sme v nich mali poriadok. Tento obsah bude obsahovať okrem zoznamu študentov aj tlačidlo na ich odstránenie a formulár na pridanie, aby sme si overili a ukázali funkčnosť funkcií create() a destroy().
Základná kostra tejto šablóny bude:
@extends('common')
@section('content')
<div>
</div>
@endsection
Kde direktíva @extends hovorí o tom, ktorý pohľad použiť ako nadradený, čo umožňuje vytvoriť aj viacero zobrazení a rozložení pre rôzne stránky. Direktívy @section a @endsection deklarujú, ktorá časť je zobrazená a ku ktorej direktíve @yield v nadradenom pohľade ju má priradiť.
Začneme so zobrazením tabuľky študentov. Do šablóny pridáme základnú kostru tabuľky s tým, že riadky sa budú zobrazovať v cykle.
@extends('common')
@section('content')
<div class="col-xs-12">
<h3>Zoznam študentov</h3>
<table border="stoke">
<tr style="background-color: #cccccc">
<td>Meno</td>
<td>Priezvisko</td>
<td>Dátum narodenia</td>
</tr>
@foreach ($students as $student)
<tr>
<td>{{$student->first_name}}</td>
<td>{{$student->last_name}}</td>
<td>{{$student->birth_day}}</td>
</tr>
@endforeach
</table>
</div>
@endsection
Narozdiel od klasického PHP, v ktorom by sme museli používať príkazy echo na vypísanie riadkov, alebo celé konštrukcie tagov, v tomto prípade na výpis premennej používamé zložené zátvorky {{}} v ktorých zavoláme premennú, v našom prípade (čo si ukážeme o chvíľu), pošleme hodnoty načítané z databázy ako premennú s názvom students. Preto stĺpec s názvom first_name získame ako prvok daného objektu $students->first_name.
Aby sme dokázali iterovať nad poľom objektov, využijeme direktívy, ktoré Blade preloží do PHP. Direktívy @foreach a @endforeach hovoria o tom, že všetko medzi nimi zopakuj pre každý prvok poľa $students a používaj ho ako $student.
Aby sme aj videli, čo vlastne robíme, je potrebné zmeniť návratovú hodnotu v ovládači StudentController pre funkciu index() (a aby sme nemuseli meniť neskôr ešte raz, tak rovno spravme tú istú zmenu aj vo funkcii store()). Potrebujeme povedať aplikácii, že je potrebné vrátiť pohľad students, ktorý sa nachádza v priečinku main a ako parameter mu vložíme všetky výsledky z databázy a nazveme to students. Čiže celý návratový príkaz bude vyzerať
return view('main.students', array('students' => $s::all()));
V tomto prípade nahradíme lomítka v ceste bodkou a vynecháme prípony, čiže cestu main/students.blade.php zapíšeme ako main.students. A vložíme mu parameter pole kde prvý prvok bude výsledok výberu.
Doplníme ešte formulár na pridávanie nových študentov. Ten bude pomocou metódy POST posielať dáta na linku /student. Ten bude aktuálne obsahovať tri polia pre tri hodnoty, ktoré vkladáme a jeden technický skrytý parameter, ktorým je token potrebný pre autorizáciu.
<div class="col-xs-12">
<h3>Pridaj nového študenta</h3>
<form method="post" action="/student">
<input type="hidden" name="_token" value="{{ csrf_token() }}">
<label for="first_name">Krstné meno:</label><input name="first_name"/><br/>
<label for="last_name">Priezvisko:</label><input name="last_name"/><br/>
<label for="birth_day">Dátum narodenia:</label><input name="birth_day"/><br/>
<button type="submit">Pridaj</button>
</form>
</div>
Po vyplnení formulára a stlačení tlačidla, sa zobrazí znovu stránka s novou hodnotou už v tabuľke. Je to preto, lebo vo funkcii store() sme si povedali, že sa má zobrazovať daný pohľad.
Po vložení niekoľkých záznamov vyzerá naša aplikácia takto:
Ďalšie možnosti
Týmto je základná aplikácia hotová, ukážeme si ešte ale nejaké ďalšie drobné možnosti, ako napríklad mazanie záznamov, doplnenie stĺpcov v databáze a nahliadneme k autentifikácii.
Mazanie záznamov
Keďže prehliadače v súčasnosti nepodporujú operácie PUT a DELETE v rámci formulárov, je potrebné to trochu obísť. Použijeme na to operáciu POST na vlastnej linke, ktorá bude mazať nami zvolené záznamy.
Potrebujeme ale urobiť tri kroky:
- Vytvoriť novú linku
/student/delete/{id}. - Vtvoriť funkciu
delete($id), ktorá spracuje požiadavku. - Pridať tlačidlo do pohľadu, ktoré bude odosielať požiadavku.
V routes/web.php je potrebné doplniť cestu, v tomto prípade hovoríme, že potrebujeme len POST na spomínanej linke a spracovávať to bude funkcia delete() v ovládači StudentController.
Route::post('student/delete/{id}', 'StudentController@delete');
Doplníme si aj funkciu, ktorá je veľmi jednoduchá a maže záznamy, ktoré splnili podmienku a vráti znovu pohľad, ktorý zobrazuje všetkých študentov.
public function delete($id) {
$s = new Student();
$s->where('id','=',$id)->delete();
return view('main.students', array('students' => $s::all()));
}
Nakoniec je potrebné pridať tlačidlá. Takže celá tabuľka bude vyzerať nasledovne:
<table border="stoke">
<tr style="background-color: #cccccc" align="center">
<td>Meno</td>
<td>Priezvisko</td>
<td>Dátum narodenia</td>
<td>Zmazať?</td>
</tr>
@foreach ($students as $student)
<tr align="center">
<td>{{$student->first_name}}</td>
<td>{{$student->last_name}}</td>
<td>{{$student->birth_day}}</td>
<td>
<form method="post" action="/student/delete/{{$student->id}}">
<input type="hidden" name="_token" value="{{ csrf_token() }}">
<button type="submit" name="action">Zmaž</button>
</form>
</td>
</tr>
@endforeach
</table>
Po stlačení tlačidla „Zmaž“ sa zmaže daný študent z databázy a načíta sa stránka nanovo.
Doplnenie stĺpcov
Pokiaľ nemáme funkčnú aplikáciu alebo nemáme žiadne dáta v databáze, postačuje nám, aby sme doplnili do migračného súboru nové stĺpce, zhodili databázu a nainštalovali nanovo. Pokiaľ ale to spraviť nemôžme, je potrebné vytvoriť nový migračný súbor a doplniť tam nové stĺpce. Nový migračný súbor vytovríme nasledovným príkazom.
php artisan make:migration add_new_columns_students --table=students
Príkaz nám zároveň predpripraví dve funkcie up() a down(), kde up() sa spustí pri vytváraní a down() v prípade potrebného návratu databázy do predchádzajúceho stavu. Povedzme, že chceme vytvoriť nový záznam a to adresu študentov, čiže ulicu, číslo a mesto. Do funkcie up() pridáme
Schema::table('students', function (Blueprint $table) {
$table->string('street');
$table->integer('number');
$table->string('city');
});
a do funkcie down() pridáme opak, čiže zmazanie stĺpcov
Schema::table('students', function (Blueprint $table) {
$table->dropColumn('street');
$table->dropColumn('number');
$table->dropColumn('city');
});
Následne použijeme príkaz, ktorý zmeny aplikuje
php artisan migrate
Následne je možné doplniť tabuľku a formulár v pohľade aby bolo možné zobraziť a pridávať nové informácie.
Autentifikácia
Pridávanie autentifikácie nebolo nikdy jednoduchšie. V Laraveli, pokiaľ chceme zabezpečiť autentifikáciu, je potrebné spustiť jeden príkaz, ktorý pridá všetky potrebné súbory. Ak ešte nebola spustená migrácia, je potrebné spustiť aj ju, aby sa nám vytvorili tabuľky pre používateľov a na ukladanie hesiel.
php artisan make:auth
Tento príkaz pridá do projektu aj pripravené šablóny Laravelu s panelom pre prihlasovanie a základnú registráciu. Ak ich chceme použiť, môžeme v našom pohľade main.students nahradiť prvý riadok za nový:
@extends('layouts.app')
Na koniec je potrebné predefinovať hlavnú stránku aplikácie, keďže sa nám stále bude zobrazovať štandardná stránka rámca. V routes/web.php je potrebné zmeniť
Route::get('/', function () {
return view('welcome');
});
na
Route::get('/', 'StudentController@index');
aby sme mali náš pohľad students.blade.php ako hlavnú stránku.
Následne si môžme upraviť ten pohľad tak, aby mazať a pridávať nových študentov mohol len prihlásený používateľ. Využijeme na to direktívy @if, @else a @endif, pričom to či je používateľ prihlásený alebo nie nám povie Auth::guest(). Ak bude prihlásený vráti hodnotu false, ak bude iba ako návštevník vráti to hodnotu true. Funkcia Auth::check() vráti hotnoty opačne.
Preto náš pohľad môže vyzerať po úprave aj takto:
@extends('layouts.app')
@section('content')
<div class="col-xs-12">
<h3>Zoznam študentov</h3>
<table border="stoke">
<tr style="background-color: #cccccc" align="center">
<td>Meno</td>
<td>Priezvisko</td>
<td>Dátum narodenia</td>
<td>Zmazať?</td>
</tr>
@foreach ($students as $student)
<tr align="center">
<td>{{$student->first_name}}</td>
<td>{{$student->last_name}}</td>
<td>{{$student->birth_day}}</td>
<td>
<form method="post" action="/student/delete/{{$student->id}}">
<input type="hidden" name="_token" value="{{ csrf_token() }}">
<button type="submit"
@if (Auth::guest())
disabled="disabled"
@endif
name="action">Zmaž</button>
</form>
</td>
</tr>
@endforeach
</table>
</div>
@if (Auth::guest())
<div>
Prepáčte, ale nemôžte pridávať nového používateľa.
</div>
@else
<div class="col-xs-12">
<h3>Pridaj nového študenta</h3>
<form method="post" action="/student">
<input type="hidden" name="_token" value="{{ csrf_token() }}">
<label for="first_name">Krstné meno:</label><input name="first_name"/><br/>
<label for="last_name">Priezvisko:</label><input name="last_name"/><br/>
<label for="birth_day">Dátum narodenia:</label><input name="birth_day"/><br/>
<button type="submit">Pridaj</button>
</form>
</div>
@endif
@endsection
A celá aplikácia bude mať takýto vzhľad pokiaľ používateľ nie je prihlásený:
a po prihlásení.
Záver
Vysvetlili sme si základné informácie a poznatky fungovania Laravelu a vytvorili sme si jednoduchú aplikáciu. Okrem tohto čo sme si povedali je stále čo študovať a v prípade väčšieho záujmu je najlepšie nazrieť do oficiálnej dokumentácie, kde sú veľmi podrobne popísané všetky funkcie a možnosti rámca aj s príkladmi. Mne už ostáva popriať len veľa úspechov pri práci s Laravel-om a pri tvorbe webových aplikácií.