szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[oktatas:web:back-end_framework:laravel|< Laravel]]

====== Laravel bevezetés ======

  * **Szerző:** Sallai András
  * Copyright (c) Sallai András, 2021, 2022, 2023
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC Attribution-Share Alike 4.0 International]]
  * Web: https://szit.hu

===== A Laravel =====

A Laravel egy nyílt forráskódú PHP keretrendszer, ami MVC struktúrát
használ.

A Laravel webhelye:
  * https://laravel.com/

A Laravel alkalmazást mindig a kiszolgált webtárhely gyökérkönyvtárából induljon,
másként érzékeny fájlok válhatnak elérhetővé.


A Laravel weboldalán a 8.x dokumentációtól olvashatjuk: "Laravel The Full Stack Framework". A Full Stack nem azt jelenti, hogy lehet benne monolitikus programot írni, amiben minden egyben benne van.

Lehet benne REST API-t készíteni és ugyanabban a projektben 
lehet REST API klienst is készíteni. Vagyis a Full Stack alatt,
RESTful alkalmazást értünk. A REST API és a kliens között HTTP kommunikáció van. Ettől függetlenül alkalmas "monolit" fejlesztésre is, amiben minden egyben benne van.

Ez a leírás monolit összeállításával kezdődik.


===== VSCode beállítás =====

Bővítmény: 
  * Laravel Snippets


===== Telepítés =====

==== Windowson ====

Szükséges szoftverek:
  * XAMPP - vagy más WAMP szerver - ebből szüksége: PHP, MariaDB 
  * Composer
  * Visual Studo Code, Atom vagy más kódszerkesztő

Lépések:
  * Telepítsük az XAMPP-t
  * Tegyük útvonalba a php.exe fájl útvonalát
  * Telepítsük a Composer-t

A sorrendet tartsuk be. Ha nincs fent az XAMPP és előbb telepítjük a Composer-t, akkor az is felfog tenni egy PHP-t.
==== Linuxon ====

Szükséges szoftverek:
  * PHP
  * Composer
  * Visual Studo Code, Atom vagy más kódszerkesztő



PHP és PHP modulok telepítése:
  apt install php phpunit php-bcmath php-mbstring php-xml

A legújabb composer:

  curl https://getcomposer.org/installer | php
  mv composer.phar /usr/local/bin/composer 


vagy a Linux terjesztés csomagtárolójából:
  apt install composer


==== Ellenőrzés ====

  php --version
  composer --version

PHP modulok ellenőrzése:
  php -m
  php -i


Visual Studio Code ellenőrzése:
  code --version


Atom ellenőrzése:
  atom --version

==== Szükséges PHP beállítás ====

Szerkesszük a php.ini fájlt és keressük meg a következő sort:

  ;extension=fileinfo

Töröljük a ";" karaktert:
  extension=fileinfo

A 8.2 PHP-ban ez alapértelmezetten megjegyzésben van. 

A composer telepítése során felkerült PHP Windowson a következő helyre telepszik:
  c:\tools\php83\

Itt keressük meg a php.ini fájlt.


===== Projekt létrehozása =====

Laravel projekt létrehozható a Laravel installer laravel paranccsával, 
vagy a composer paranccsal. Itt most a composer parancsot használjuk.


Composer segítségével egy Laravel projekt létrehozása:
  composer create-project laravel/laravel projekt01

A composer használatáról bővebb információ:
  * https://getcomposer.org/doc/


==== Előző verziók ====
Ha nem áll rendelkezésre PHP8, akkor Laravel 8 verziója töltődik le.
De  magunk is kérhetünk előző verziót:

  composer create-project laravel/laravel app01 "8.*.*"

==== dist vagy source ====

A Laravel projekt létrehozásakor szokás használni a ''<nowiki>--prefer-dist</nowiki>''
kapcsolót. A kapcsoló megmondja, hogy a Laravel és függőségeit
a terjesztési archívumból szeretnénk letölteni, a verzióval követett,
korábbi verziók nélkül:
<code>
--prefer-dist
</code>


  composer create-project laravel/laravel app01 --prefer-dist
  
Ennek használata gyorsabb letöltést eredményez. A <nowiki>--prefer-dist</nowiki>
az alapértelmezés. 

Ezzel szemben a ''<nowiki>--prefer-source</nowiki>'' a forráskódot, a korábbi
verziókkal egyben tölti le, mint a git clone, parancs.

==== Aktuális könyvtár ====

A (.) pont segítségével, megmondhatjuk, hogy az aktuális
könyvtárban jöjjön létre a Laravel projekt. Ha semmilyen
paramétert nem adunk meg, akkor akkor "laravel" néven
jön létre egy projekt könyvtár.

  composer create-project laravel/laravel .

===== A laravel parancs =====

Felhasználóként kell telepíteni:
  composer global require laravel/installer


Linuxon a következő helyre telepszik:
  ~/.config/composer/vendor/bin

Ezt az útvonalat kell PATH környezeti változóban beállítani.


  laravel new app01

===== Artisan szerver =====

A composer létrehoz egy projekt01 nevű könyvtárat. Lépjünk 
be a könyvtárba. A projekt könyvtár tartalmaz egy artisan nevű fájt, 
PHP függvényekkel, amelynek segítségével Artisan parancsokat
tudunk végrehajtani. Ügyeljünk arra, hogy artisan parancsot csak
egy olyan könyvtárban adhatunk ki, ahol jelen van az artisan nevű
fájl, vagyis a projekt gyökérkönyvtárában. 

Az artsian fájl, valójában PHP függvényeket tartalmaz, amelyek
segítik a Larvel keretrendszerrel való munkát.

Az Artisan parancsokhoz segítség:
  php artisan list
és itt:
  * https://laravel.com/docs/8.x/artisan


Az artisan egy fejlesztői szervert is biztosít számunkra. 

Lépjünk be a projekt könyvtárába, ha még nem tettük meg,
majd indítsuk el a fejlesztői webszervert:

  cd projekt01
  php artisan serve

A PHP fejlesztő szerver a 8000-s porton indul el, de megadhatunk más portot is:
  php artisan serve --port=8081

Ha távolról is szeretnénk elérni, használjuk a <nowiki>--host</nowiki> kapcsolót.
  php artisan serve --host=0.0.0.0 --port=8080


===== Könyvtárstruktúra =====

A gyökér könyvtár tartalma:

  * app - az alkalmazás alapvető kódjai
  * bootstrap - a keretrendszert indító fájlok
  * config - összes konfiguráció
  * database - adatbázishoz tartozó fájlok
  * public - az alkalmazás belépési pontja
  * resources - nézetek, le nem fordított CSS és JavaScript állományok
  * routes - útvonal-meghatározások helye
  * storage - naplók, Blade sablonok, a keretrendszer állományai
  * tests - automatizált tesztek helye
  * vendor - a composer függőségeit tartalmazza


Az app könyvtár tartalma:
  * Broadcasting
    * csatornaosztályok helye
    * alapértelmezetten nem létezik
  * Console - egyedi kézzel írt parancsok (make:parancs)
  * Events
    * alapértelmezetten nem létezik
    * az event:generate és a make:event parancsok hozzák létre
    * eseményosztályok helye
  * Exceptions - kivételkezelők helye
  * Http - vezérlők, köztes szoftverek és űrlapkérések helye
  * Jobs
    * alapértelmezés szerint nem létezik
    * make:job Artisan parancs hozza létre
    * sorba állítható feladatok helye
  * Listeners
    * alapértelmezés szerint nem létezik
    * event:generate vagy a make:listener hozza létre
    * Eseményeket kezelő osztályok helye
  * Mail
    * alapértelmezetten nem létezik
    * a make:mail parancs hozza létre
    * az alkalmazás által küldött e-mail osztályainak helye
  * Models - Eloquent ((Objektum-relációs leképező rendszer (ORM), amely megkönnyíti az
adatbázissal való kapcsolatunkat. Minden tábla rendelkezik egy modellel,
ami az adott táblához való hozzáférést segíti.)) modellosztályok helye
  * Notifications
    * alapértelmezetten nem létezik
    * make:notification Artisan parancs hozza létre
    * az alkalmazás által küldött értesítések helye
  * Policies
    * alapértelmezés szerint nem létezik
    * a make:policy Artisan parancs hozza létre
    * az alkalmazás engedélyezési házirendjének helye
  * Providers - szolgáltatások helye
  * Rules
    * alapértelmezés szerint nem létezik
    * a make:rule Artisan parancs hozza létre

Forrás:
  * https://laravel.com/docs/8.x/structure (2021)


===== Nézetek =====

A nézetek a következő helyen találhatók:
  * resources/views


Nézet úgy hozható létre, ha létrehozunk egy fájlt **.blade.php** kiterjesztéssel.

Az alapértelmezett welcom.blade.php helyett készítsünk egy home.blade.php
fájlt, ami a webhely főoldala lesz. 


  resources/views/home.blade.php

Tartalma egy h1 elem legyen:
<code html resources/views/home.blade.php>
<h1>Tennivalók</h1>
</code>


A létrehozott nézetet be kell jegyeznünk az útválasztóba.
Ezt a következő helyen tehetjük meg:
  * routes/web.php

A welcome helyére írjuk a home szót:

<code php>
Route::get('/', function () {
    return view('home');
});
</code>

Nézzük meg a weboldalt böngészőben:
  localhost:8000
Ügyeljünk arra, hogy fusson az Artisan webszerver. Ha valamiért leállítottuk, indítsuk újra:
  php artisan serve

===== Artisan parancsok =====

Az Artisan parancsokat **''php artisan''** szavakkal kezdjük,
majd megmondjuk mit szeretnénk. Ne felejtsük el, hogy a 
csak projekt gyökérkönyvtárában fognak működni.

Az Artisan parancsok listáját ''php artisan list'' parancs listázza 
számunkra egy rövid leírással:
  php artisan list



Most nézzük meg útvonalak listáját egy Artisan paranccsal:
  php artisan route:list

A kimenet ehhez hasonló:
<code>
+--------+----------+----------+------+---------+------------+
| Domain | Method   | URI      | Name | Action  | Middleware |
+--------+----------+----------+------+---------+------------+
|        | GET|HEAD | /        |      | Closure | web        |
|        | GET|HEAD | api/user |      | Closure | api        |
|        |          |          |      |         | auth:api   |
+--------+----------+----------+------+---------+------------+
</code>

Van egy api/user útvonal is, amit a Laravel projektünk automatikusan tartalmaz.

===== Névjegy =====

Hozzunk létre egy névjegy oldalt (nézetet). Ehhez készítsünk a resources/views könyvtárban 
egy about.blade.php nevű fájlt:
  resources/views/about.blade.php

Tartalma most két sor legyen:
<code html resources/views/about.blade.php>
<h1>Tennivalók</h1>
<p>Nagy János</p>
</code>

Készítsünk számára egy új útvonal-információt. Írjuk az
új bejegyzést a fájl végére:
<code php>
...
Route::get('/about', function () {
    return view('about');
});
</code>


Most így néz ki a routes/web.php fájl:
<code php>
<?php

use Illuminate\Support\Facades\Route;

/*
|--------------------------------------------------------------------------
| Web Routes
|--------------------------------------------------------------------------
|
| Here is where you can register web routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| contains the "web" middleware group. Now create something great!
|
*/

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

Route::get('/about', function () {
    return view('about');
});
</code>

Nézzük meg a böngészőben:
  localhost:8000/about

===== Komponensek =====

Nézzük meg a két weblapunk forráskódját. 
A blade.php állományok jelenleg nem generálnak szabályos weblapokat.
Ezért, írjunk számukra fejrészt és lábrészt.
Ezeket **komponensek** formájában hozzuk létre, Artisan paranccsal.

Hozzuk létre a Header nevű komponenst: 

  php artisan make:component Header

Létrejön egy **components** könyvtár **resources/views** könyvtáron belül.
Ezen belül létrejön egy **header.blade.php** fájl.

Írjuk bele a weblap fejrészét:

<code html header.blade.php>
<!DOCTYPE html>
<html lang="hu">
<head>
    <meta charset="utf-8">
    <title>satodo</title>
</head>
<body>

</code>

Vegyük észre, hogy HTML oldal záró body és html tagét nem írtuk a fájlba.


Hozzuk létre a lábrészt is:

  php artisan make:component Footer

Létrejön a **footer.blade.php** fájl. Írjuk bele lábrészt:

<code html footer.blade.php>

</body>
</html>
</code>

Most javítsuk a resources/views könyvtárban a **home.blade.php**
és az **about.blade.php** fájlokat:


<code html resources/views/home.blade.php>
<x-header />

<h1>Tennivalók</h1>

<x-footer />
</code>


<code html resources/views/about.blade.php>
<x-header />

<h1>Tennivalók</h1>
<p>Nagy János</p>

<x-footer />
</code>



Az <x-header /> automatikusan beszúrja a header nevű komponenst a beírás helyére.
Az <x-footer /> pedig a footer komponens tartalmát szúrja be. 

<note important>

Az x-header és x-footer után kötelező a / karakter!

<x-header />

<x-footer />

A szóköz elhagyható.

</note>

Ügyeljünk arra, hogy legyen elindítva az Artisan szerver, majd nézzük meg a böngészőben:
  * localhost:8000
  * localhost:8000/about

Nézzük meg a weboldalak forráskódját is.


Ötlet: Külön tehetjük a weblap head elemet és tartalmát, és külön a weboldal felső részt:
  * head.blade.php
  * header.blade.php
  * fotter.blade.php
===== A Blade sablon =====

Szeretnék a Blade nézeteket sablonként (template) használni,
vagyis értéket szeretnénk beírni bizonyos helyekre programból,
futási időben. 

Készítünk egy listát tartalmazó weblapot, amelyen 
szerepelhetnek a teendőink. Legyen a neve **list**.

A fájl tartalma:

<code html resources/views/list.blade.php>
<x-header />

<h1>Tennivalók</h1>
<h2>Tennivalók listája</h2>

<ul>
  <li>{{ $todo1 }}</li>
  <li>{{ $todo2 }}</li>
  <li>{{ $todo3 }}</li>
</ul>

<x-footer />
</code>


A x-header és x-footer elemek behelyettesítik a fejrészt és a lábrészt. 
A <nowiki>{{ $todo1 }}</nowiki> bejegyzés a másik két hasonló bejegyzéssel, változónak foghatók fel, ahova futási időben egy értéket fogunk beírni. 



Ha elkészült a Blade sablon, jegyezzük be az útvonalak közzé:

<code php routes/web.app>
...

Route::get('/list', function () {
    return view('list');
});
</code>



Az útválasztó **web.app** fájlban hozzuk létre egy asszociatív tömböt,
ahol a kulcsok neve megegyezik a nézetben megadott változónevekkel:

<code php routes/web.app>
...

Route::get('/list', function () {
    $todos['todo1'] = 'PHP tanulás';
    $todos['todo2'] = 'composer megismerése';
    $todos['todo3'] = 'Laravel tanulása';

    return view('list', $todos);
});
</code>

A Route::get() függvény paramétereként egy névtelen függvényt hívunk, amelyben
létrehozunk egy tömböt, amiben a három tennivaló van. A névtelen függvény
ez meghívja a view() függvényt, ami megjeleníti a **list** nézetet, amelynek
átadja a <nowiki>$todos</nowiki> tömböt. 

Most nézzük meg böngészőben:
  localhost:8000/list

Nézzük meg újra a beállított útvonalakat:
  php artisan route:list


===== Kontroller létrehozása =====

Az adatokat nem az útválasztóban szokás létrehozni, azokat 
egy kontroller kéri el valamilyen modelltől. De most, 
maradjunk csak a kontrollernél. 

Hozzunk létre egy TodoController nevű kontrollert. Használjuk hozzá Artisan parancsot:

  php artisan make:controller TodoController


A következő állomány generálódik:
  * app/Http/Controllers/TodoController.php


A létrehozott kontroller a következőt tartalmazza:

<code php app/Http/Controllers/TodoController.php>
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class TodoController extends Controller
{
    //
}
</code>



Készítsünk egy függvényt a TodoController osztályon belül,
amit írhatunk a <nowiki>//</nowiki> tartalmazó sort követően:

<code php>
    public function list() {
        $todos['todo1'] = 'JavaScript tanulás';
        $todos['todo2'] = 'Composer megismerése';
        $todos['todo3'] = 'Laravel tanulása';
        return view('list', $todos);
    }
</code>

A view() függvényt, most itt hívjuk a kontrollerben és nem 
az útválasztóban. 
Első paramétere a megjelenítendő nézet, a második paraméter
egy asszociatív tömb, amely tartalmazza a szükséges adatokat 
a nézet számára. Ahogy az útválasztóban is tettük, a tömb
minden kulcsszava a nézetben egy változó neve.

A **TodoController.php** teljes tartalma most:

<code php app/Http/Controllers/TodoController.php>
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class TodoController extends Controller
{
    //
    public function list() {
        $todos['todo1'] = 'JavaScript tanulás';
        $todos['todo2'] = 'Composer megismerése';
        $todos['todo3'] = 'Laravel tanulása';
        return view('list', $todos);
    }
}
</code>


Most be kell jegyeznünk az útválasztóban a kontrollert.



Szerkesszük újra a routes/web.php fájlt.
Az állomány elején mondjuk meg, hogy szeretnénk használni a
TodoController osztályt:

<code php>
use App\Http\Controllers\TodoController;  
</code>


Majd javítsuk a /list hivatkozást így:
<code php>
Route::get('/list', [TodoController::class, 'list']);
</code>

Az első paraméter megmondja, hogy ha /list hivatkozás érkezik, akkor a 
második paraméterben megadott TodoController osztály list() függvényét futtassuk.

Nézzük meg újra az eredményt, bár látványos változást nem fogunk látni.
Esetleg javítsuk ki az egyik tennivaló szövegét, hogy lássuk a változást,
majd böngészőben:
  localhost:8000/list

===== A with használata =====

Az előző fejezetben, a TodoController osztályban az adatokat,
a view() függvény második paraméterében adtuk át. Most lássuk 
hogyan adhatjuk át egy másik módszerrel, a with() függvény
használatával. 

A TodoController.php fájlban javítsuk a view() függvényünket így:
  return view('list')->with('todos', $todos);

A teljes kód:

<code php TodoController.php>
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class TodoController extends Controller
{
    //
    public function list() {
        $todos['todo1'] = 'JavaScript tanulás';
        $todos['todo2'] = 'Composer megismerése';
        $todos['todo3'] = 'Laravel tanulása';

        // return view('list', $todos);
        return view('list')->with('todos', $todos);
    }
}
</code>



A nézetben javítsuk:

<code html>
  <li>{{ $todos['todo1'] }}</li>
  <li>{{ $todos['todo2'] }}</li>
  <li>{{ $todos['todo3'] }}</li>
</code>

A teljes kód:
<code html resources/views/list.blade.php>
<x-header />

<h1>Tennivalók</h1>
<h2>Tennivalók listája</h2>

<ul>
  <li>{{ $todos['todo1'] }}</li>
  <li>{{ $todos['todo2'] }}</li>
  <li>{{ $todos['todo3'] }}</li>
</ul>

<x-footer />
</code>

Nézzük meg az eredményt böngészőben:
  localhost:8000/list

==== A tömb újratervezése ====

Most tervezzük újra a tömbünket:

<code php>
        $todos = [
            'todo1' => 'TypeScript tanulás',
            'todo2' => 'Composer megismerése',
            'todo3' => 'Laravel tanulása'
        ];
</code>


A teljes kód:

<code php TodoController.php>
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class TodoController extends Controller
{
    //
    public function list() {
        $todos = [
            'todo1' => 'TypeScript tanulás',
            'todo2' => 'Composer megismerése',
            'todo3' => 'Laravel tanulása'
        ];

        return view('list')->with('todos', $todos);
    }
}

</code>

Az első feladatot is átírtam, hogy látszódjon a változás a böngészőben.
Mentsünk és nézzük meg újra a böngészőben:
  localhost:8000/list




===== Egy változó bejárása =====

Tervezzük újra a list.blade.php fájlban a listaelemek kiírását.
Jelenleg 3 darab feladatot tud fogadni a list.blade.php sablonunk. 
Ha az teendők adatbázisból jönnek, nem tudjuk hány teendő lesz.
Olyan megoldásra van szükségünk, amely iterációval végig megy a 
teendők listáján, és legyártja a li elemeket. 

Ehhez @foreach utasítás használjuk, amit a @endforeach kulcsszó zár:

<code html>
@foreach($todos as $item)
    <li>{{ $item }}</li>
@endforeach
</code>

A teljes kód most így néz ki:
<code html resources/views/list.blade.php>
<x-header />

<h1>Tennivalók</h1>
<h2>Tennivalók listája</h2>

<ul>
  @foreach($todos as $item)
  <li>{{ $item }}</li>

  @endforeach
</ul>

<x-footer />

</code>



Az egyik teendőn is változtathatunk, hogy lássuk a változást. 

  'todo1' => 'Angular tanulás',


Nézzük meg az eredményt a böngészőben:
  localhost:8000/list


===== Az adatok view()-ban =====

Újra elővesszük az adatok átadását a view() függvényben. 
Az előző fejezetek egyikben egy $todos nevű tömböt adtunk át
a list.blade.php nézetnek. A nézetben ennek megfelelően ilyen
változó kellett szerepeljen: {{ $todos['todo1'] }}.
Vagyis meg kell egyezzen a tömb neve mindkét helyen.

Ha szeretnénk megőrizni a list.blade.php fájlban a $todos 
változónevet, de a kontrollerben az adatok egy $data nevű
változóban vannak, akkor írjuk a következőt:

<code php>
return view('list', [
    'todos' => $data
]);
</code>

Legyen egy új feladat is:
  'todo1' => 'Vue tanulás',

A teljes kód:

<code php app/Http/Controllers/TodoController.php>
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class TodoController extends Controller
{
    //
    public function list() {
        $data = [
            'todo1' => 'Vue tanulás',
            'todo2' => 'Composer megismerése',
            'todo3' => 'Laravel tanulása'
        ];

        return view('list', [
          'todos' => $data
        ]);
    }
}

</code>

Nézzük meg a böngészőben:
  localhost:8000/list

===== Adatbázis =====

==== Elérés ====

Az adatok általában adatbázisból jönnek, ezért adatbáziselérést fogunk beállítani.

Vegyük fel az adatbázist, és egy hozzátartozó felhasználót.
A táblákat nem szükséges létrehozni, azokat a Laravel migration
nevű szolgáltatásával hozzuk létre. 

Adatbázis hozzáférés beállítására két lehetőség van:
  * config/database.php
  * .env

A database.php fájlban az alkalmazás végleges helyén megadott 
hozzáférést szoktuk beállítani. A fejlesztéshez használjuk 
a .env állományt. 

Keressük meg a .env fájlban a következő részt:
<code php>
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=
</code>

Állítsuk be az adatbázisunk hozzáférési adatait. 

Például:

<code php>
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=mytodo
DB_USERNAME=mytodo
DB_PASSWORD=titok
</code>



==== Tábla létrehozása ====

A migrációk a következő helyen találhatók:
  * database/migrations

Hozzuk létre a saját migrációs osztályunkat a todos tábla elkészítéséhez:

  php artisan make:migration create_todos_table

Az elkészült fájl nevében benne lesz az aktuális dátum is.
Egy ilyen fájl jött számomra létre:
  * 2021_08_03_205737_create_todos_table.php

A fájl tartalmazni fog egy **up()** és egy **down()** függvényt. 

Az up() függvény átírásával kialakítjuk a táblánkat.


A **create_todos_table.php** végződésű állomány tartalma:

<code php database/migrations/2021_08_03_205737_create_todos_table.php>
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateTodosTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('todos', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('todos');
    }
}

</code>


A Schema::create() függvény fogja elkészíteni a táblát. 
Az első paraméter az elkészítendő tábla neve. 
A következő egy névtelen függvény, amely a Blueprint típusú
objektumot vár paraméterként, ami maga a tábla.

<code php>
        Schema::create('todos', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
        });
</code>

A <nowiki>\$table->id();</nowiki> arra utasítja a migrációs parancsot, hogy hozzon létre egy
id nevű mezőt a táblában. A <nowiki>$table->timestamps();</nowiki> sor, megmondja, hogy
egy időbélyegek számára is jöjjön létre két mező, automatikusan,
ahol a rekord létrehozása és változtatása lehet feljegyezve. 

Ez nekünk kevés, ezért kiegészítjük, átírjuk a mezőmeghatározásokat:

<code php>
public function up() {
    Schema::create('todos', function (Blueprint $table) {
        $table->increments('id');
        $table->string('task');
        $table->boolean('done');
        $table->timestamps();
    }
}

</code>

A <nowiki>\$table->increments('id');</nowiki> sor egy elsődleges kulcsmezőt hoz létre, egész típussal, amit
automatikusan növel, és a neve "id". A <nowiki>$table->string('task');</nowiki> egy "task" nevű mezőt hoz létre,
ami string típusú. A következő done nevű mező, boolean típussal. Az utolsó timestamps() 
mezők létrehozását meghagytuk. 

Futtassuk a következő migrációs utasítást:
  php artisan migrate

A parancs hatására, létrejön az adatbázisban a tábla. Ellenőrizzük PhpMyAdmin vagy
mysql kliensen keresztül.


Néhány fontosabb típus, amit megadhatunk függvényként:

  * id
  * char
  * year
  * double
  * float
  * integer
  * date
  * string
  * text
  * time
  * timestamp
  * tinyText
  * boolean
  * dateTime
  * tinyInteger

További [[https://laravel.com/docs/8.x/migrations#available-column-types|típusok ezen a helyen]].


Néhány példa mezők létrehozására, illetve változtatásra:
<code php>
$table->string('name', 50)->nullable()->change();
$table->increments('id')->first();
$table->dropColumn('valami1');
$table->renameColumn('valami1', 'valami2');
$table->integer('valami_id')->unsigned()->nullable()->change();
$table->unsignedInteger('valami_id')->nullable(false)->change();
</code>

==== Adatok feltöltése ====

Az adatokat a **Seeder** nevű szolgáltatással fogjuk feltölteni.
Egy Seeder egy osztályként fog létrejönni.

Hozzunk létre egy feltöltőt:
  php artisan make:seeder TodoSeeder

A seeder a következő helyen tárolódik:
  * database/seeders/

A fenti Artisan parancs után létrejön egy **TodoSeeder.php** állomány. 
Tartalma:

<code php database/seeders/TodoSeeder.php>
<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class TodoSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        //
    }
}

</code>


Szükségünk lesz a DB osztályra, vegyük használatba, írjuk az utolsó use után:
  use Illuminate\Support\Facades\DB;




Írjuk meg a run() függvényt:

<code php>
public function run() {
    DB::table('todos')->insert([
        'task' => 'Linux tanulás',
        'done' => '0'
    ]);
}
</code>


A teljes kód:

<code php database/seeders/TodoSeeder.php>
<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;

class TodoSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        //

        DB::table('todos')->insert([
            'task' => 'Linux tanulás',
            'done' => '0'
        ]);
    }
}

</code>

Most futtatnunk kell a feltöltőt. Ha több feltöltőnk is van már, akkor
a következő utasítás hatására mind elindul, és feltöltéseket végez:
  php artisan db:seed

Ha csak egyetlen feltöltőt akarunk működtetni, adjuk meg az osztálya nevét:
  php artisan db:seed --class=TodoSeeder


Ha két rekordot szeretnénk feltölteni, akkor felvehetjük újra:

<code php>
    public function run()
    {
        //
        DB::table('todos')->insert([
            'task' => 'Linux tanulás',
            'done' => '0'
        ]);
        DB::table('todos')->insert([
            'task' => 'Bootstrap tanulás',
            'done' => '0'
        ]);
    }
</code>


==== Kész táblák frissítése ====

  php artisan migrate:refresh

A parancs törli a meglévő adatokat.

==== Kész táblák frissítése adatvesztés nélkül ====

Új migrációs fájl létrehozása:
  php artisan make:migration add_premium_column_to_employee_table --table=employee

Beállítom az oszlop adatait.

Futtatjuk a migrációt:
  php artisan migrate

Ha az indexekkel probléma van:
  * https://laravel.com/docs/8.x/migrations#indexes (2021)
===== Modell használata =====

Most már van adatbázisunk egy **todos** táblával,
amiben fel van véve néhány feladat is.
A kontroller az adatokat egy modelltől fogja megkapni.

Egy **Todos** nevű modellt kell létrehozni. **A modell neve
meg kell egyezzen a tábla nevével, de a modell neve
legyen nagybetűs.**

  php artisan make:model Todos

Létrejön egy **Todos.php** fájl.

Tartalma:
<code php app/Models/Todos.php>
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Todos extends Model
{
    use HasFactory;
}

</code>


Ha a tábla létrehozásakor nem hagytuk meg az időbélyeg mezők
létrehozását, tudassuk a modellel a következő sorral:
  public $timestamps = false;

Teljes osztály, ezek után:
<code php>
class Todos extends Model
{
    use HasFactory;
    public $timestamps = false;
}
</code>

A modellfájlban nincs is más teendőnk.

Most kérjük el a kontrollerben az összes tennivalót.
Nyissuk meg a **TodoController.php** fájlt.

Vegyük használatba a modellt, írjuk az utolsó use után:
  use App\Models\Todos;

Hozzunk létre egy új függvényt **getTodos()** néven, a **TodoController** osztályon belül:

<code php>
    function getTodos() {
      $data = Todos::all();
      return view('list', ['todos' => $data]);
    }
</code>

Az útválasztóban javítsuk a meghívandó függvény nevét 'list'-ről 'getTodos'-ra:
  Route::get('/list', [TodoController::class, 'getTodos']);

Nézzük meg az eredményt böngészőben:
  localhost:8000/list

Ehhez hasonlót látunk:
<code>
{"id":1,"task":"Linux tanul\u00e1s","done":0,"created_at":null,"updated_at":null}
{"id":2,"task":"Linux tanul\u00e1s","done":0,"created_at":null,"updated_at":null}
{"id":3,"task":"Linux tanul\u00e1s","done":0,"created_at":null,"updated_at":null}
{"id":4,"task":"Linux tanul\u00e1s","done":0,"created_at":null,"updated_at":null}
{"id":5,"task":"Bootstrap tanul\u00e1s","done":0,"created_at":null,"updated_at":null}
</code>


Végül javítsunk a nézetfájlon:
<code php resources/views/list.blade.php>
<x-header />

<h1>Tennivalók</h1>
<h2>Tennivalók listája</h2>

<table>
  @foreach($todos as $todo)
  <tr>
    <td>{{ $todo['task'] }}</td>
  </tr>
  @endforeach
</table>

<x-footer />
</code>

Nézzük meg az eredményt:
  localhost:8000/list

Innentől a tennivalók adatbázisból jönnek.

===== Tennivaló törlése =====

A nézetfájlban vegyünk fel egy új cellát a táblázatban:
<code html>
<td><a href={{"delete/".$todo['id']}}>Törlés</a></td>
</code>

Beleírtunk egy linket, ami delet/ útvonalat tartalmazza és egy azonosítót. 

Tulajdonképpen egy ilyen üzenet megy át, ha azonosító például 3:
  delete/3


A $todo['id'] rész segítségével a törlendő tevékenység azonosító számát adjuk át.


A TodoController osztályban vegyünk fel egy új függvényt deleteTodo() néven:

<code php>
    function deleteTodo($id) {
      $data = Todos::find($id);
      $data->delete();
      return redirect('list');
    }
</code>

A függvény megkeresi a megadott azonosítójú feladatot, majd törli, végül átirányít a list
nézetre. 



Az útválasztóban vegyünk fel egy új útvonalat, amely delete/{id} hatására
meghívja a törlő metódust:

<code php>
Route::get('delete/{id}', [TodoController::class, 'deleteTodo']);
</code>

A {id} szövegben nem lehet szóköz.

Ellenőrizzük a böngészőben és próbáljuk ki a törlést.
  localhost:8000/list

===== Tennivaló módosítása =====


Most, tegyük lehetővé adott feladat módosítását. 
Ehhez vegyük fel a list.blade.php fájlban egy új cellát,
benne egy új linket:

<code html>
<td><a href={{"edit/".$todo['id']}}>Szerkesztés</a></td>
</code>


A módosítófelület létrehozásához szükséges egy új nézet.
Legyen a neve edit.blade.php, a következő tartalommal:

<code html resources/views/edit.blade.php>
<x-header />

    <h2>Módosítás</h2>

    <form action="/edit" method="post">
      @csrf
      <input type="hidden" name="id" value="{{$data['id']}}">
      <input type="text" name="task" value="{{$data['task']}}"><br>
      <button type="submit">Módosít</button>
    </form>


<x-footer />
</code>


Szükségünk van egy nézetre, ahol szerkeszthetjük a kívánt feladatot. 

Hozzuk létre a szerkesztő felületet edit.balde.php néven:

<code html resources/views/edit.blade.php>
<x-header />

    <h2>Módosítás</h2>

    <form action="/edit" method="post">
      @csrf
      <input type="hidden" name="id" value="{{$data['id']}}">
      <input type="text" name="task" value="{{$data['task']}}"><br>
      <button type="submit">Módosít</button>
    </form>


<x-footer />
</code>

Hozzuk létre a kontrollerben egy showTodo() nevű függvényt, 
amely kiírja a módosítandó adatokat.

<code php>
    function showTodo($id) {
      $data = Todos::find($id);
      return view('edit', ['data' => $data]);
    }
</code>



Most mondjuk meg az útválasztóban, ha valaki hivatkozik egy edit/2
formában, az kapja meg a edit nevű nézetet.

<code php>
Route::get('edit/{id}', [TodoController::class, 'showTodo']);
</code>

Vegyünk fel egy újabb bejegyzést az útválasztóba, amely meghívja a szerkesztőt:

<code php>
Route::post('edit', [TodoController::class, 'update']);
</code>

Majd a hivatkozott update() függvényt hozzuk létre a TodoController-ben is:

<code php>
    function update(Request $req) {
      $data = Todos::find($req->id);
      $data->task = $req->task;
      $data->save();
      return redirect('list');
    }
</code>

A task a mező neve a táblában.

Próbáljuk ki a listaelem módosítását.

  localhost:8000/list

===== Tennivaló hozzáadása =====

Tennivaló hozzáadásához szükségünk van egy új nézetre. 

<code html resources/views/addtod.blade.php>
<x-header />

    <h2>Feladat hozzáadása</h2>
    <form  action="add" method="post">
      @csrf
      <input type="text" name="task">

      <button type="submit">Hozzáad</button>
    </form>

<x-footer />
</code>


A TodoController osztályban hozzunk létre egy addTodo() nevű függvényt:

<code php app/Http/Controllers/TodoController.php>
    function addTodo(Request $req) {
      $todo = new Todos;
      $todo->task = $req->task;
      $todo->done = 0;
      $todo->save();
      return redirect('list');
    }
</code>

Jegyezzük be az útválasztóba:
<code php>
Route::view('add', 'addtodo');
Route::post('add', [TodoController::class, 'addTodo']);
</code>


===== Laravel Breeze azonosítás =====

A tennivalóinkat szeretnék védeni, és csak azonosítás után szeretnénk
az elérést engedélyezni. Ehhez a Laravel Breeze egyszerű azonosító 
rendszert fogjuk használni. 

Telepítés:
  composer require laravel/breeze --dev


Egyszerű scaffolding azonosítás készítése:
  php artisan breeze:install

Függőségek rendezése:
  npm install && npm run dev



Készítsük el az adatbázis tábláit:
  php artisan migrate

Most lesz egy /register és egy /login útvonalunk. 


A regisztrációs felületen (/register),  vegyünk fel egy felhasználót. 

Például:
  * Name: janos
  * Email: janos@tatami
  * Password: 12345678
  * Confirm: Password: 12345678

Szeretnénk védeni a /list nézetünket. 
Ehhez, keressük meg a routes/web.php fájlban a /list-re vonatkozó részt:

<code php>
//...

Route::get('/list', function () {
    return view('list');
});
</code>



Kössünk a végéhez egy azonosítást:

<code php>
//...

Route::get('/list', function () {
    return view('list');
})->middleware('auth');
</code>

Ellenőrizzük. 

==== Alapértelmezett útvonal  ====

Bejelentkezés után a /list útvonalat szeretnénk
látni a dashboard helyett. 


Ehhez szerkesszük az app/Providers/RouteServiceProvider.php állományt.

Ott keressük meg a következő sort:

<code php>
public const HOME = '/dashboard';
</code>

Javítsuk így:
<code php>
public const HOME = '/list';
</code>


===== Kilépés =====

Két lehetőségünk van:
  * A blade sablon fájlban form elemet használok.
  * Írok egy útvonalat, ami képes GET kérést kezelni.


==== Form használata ====

A kilépési lehetőséghez készítsük el a formot:

<code html>
<form action="{{ route('logout') }}" method="POST">
    @csrf
    <button type="submit">
        {{ __('Logout') }}
    </button>
</form>
</code>

Próbáljuk ki.
==== Írjunk GET kérést ====

Használjuk az App\Http\Controllers\Auth\AuthenticatedSessionController-t kontrollert:

Az útválasztáshoz adjunk hozzá új bejegyzést. 

Az útválasztóban vegyük használatba az elkészült kontrollert:
<code php>
use App\Http\Controllers\Auth\AuthenticatedSessionController;
</code>



Majd vegyük fel egy új útvonalat:
<code php>
Route::get('/logout', [AuthenticatedSessionController::class, 'destroy']);;
</code>


Ezek után a list.blade.php nézetfájlban:

<code html>
<a href="{{ url('/logout') }}">Kilépés</a>
</code>


A Kilépésre kattintva működik. Próbáljuk ki.




===== Függelék =====
==== Alternatív projekt készítés ====

=== Szükséges ===

<code>
apt install curl docker-compose
</code>


=== Projekt létrehozása ===


Az egy-app nevű projekt létrehozása:
<code>
curl -s https://laravel.build/egy-app | bash
</code>

Létrejön egy **egy-app** nevű könyvtár, benne a laravel alkalmazással.

=== Sail ===

Indítsuk el a Laravel Sail-t.


<code>
cd egy-app
./vendor/bin/sail up
</code>

Az első indítás eltarthat egy ideig. 


Ha megállt az üzenetek továbbítása, a böngészőbe írjuk be:
  localhost/


Ügyeljünk arra, hogy a 80-s port szabad legyen, vagy állítsunk be
egy másik portot, a **docker-compose.yml** fájlban:

Keressük meg a portbeállításokat:

<code>
  ports:
    - '${APP_PORT:-8000}:80'
</code>

Cseréljük erre:
<code>
  ports:
    - 8000:80
</code>


==== Kezdeti konfiguráció ====


Kezdeti konfigurációhoz tanulmányozzuk a **config/app.php** állományt. 


==== Alkönyvtárak a kontrollerben ====


Előfordul, hogy a resources/views/ könyvtárban egy újabb könyvtárat 
hozunk létre, és abban hozok létre egy nézetfájlt, valahogy így:
  resources/views/products/index.blade.php

Ilyen esetben a kontrollerben így hivatkozok a nézetre:

<code php>
    ...
    public function getData() {
      $msg = "vmi";
      return view('products.index', compact('msg'));
    }
    ...
</code>

Vegyük észre a products után pontot írtam a perjel helyett. 


==== composer create-project ====

A composer create-project parancsának sok helyen megadják a <nowiki>--prefer-dist</nowiki>
kapcsolót. Ez nem szükséges, mert ez az alapértelmezés. 
Ugyanakkor két "ellentétes" lehetőségünk van:
  * <nowiki>--prefer-dist</nowiki>
  * <nowiki>--prefer-source</nowiki>

A source hatására forrásból telepíti a projektet. 
A <nowiki>--prefer-source</nowiki> kapcsoló egyenértékű ezzel: -<nowiki>--prefer-install=source</nowiki>.
A <nowiki>--prefer-dist</nowiki> hatására gyorsabb lehet a telepítés.


Több információ
  * https://getcomposer.org/doc/03-cli.md#create-project

==== Debian GNU/Linux 11 - PHP8.1 ====

  apt update

<code>
apt -y install lsb-release apt-transport-https ca-certificates 
wget -O /etc/apt/trusted.gpg.d/php.gpg https://packages.sury.org/php/apt.gpg
</code>

<code>
echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" | tee /etc/apt/sources.list.d/php.list
</code>

  apt update

  apt install php8.1
  reboot

  php --version

  apt install php8.1-mysql
  apt install php8.1-xml
  apt install php8.1-curl


==== Laravel parancs ====

Composer telepítése:
  choco install composer -y

A laravel parancs telepítése:
  composer global require laravel/installer

A parancs a következő helyen telepszik:
  * c:\Users\janos\AppData\Roaming\Composer\


Ezek után, projekt készítése:
  laravel new app01


===== Linkek =====

  * https://www.youtube.com/watch?v=376vZ1wNYPA (2021; Laravel 8 angolul)
  * https://laravel.com/docs/8.x/controllers (2022; Kontrollerek)