Tartalomjegyzék

Laravel bevezetés

Laravel bevezetés

Szerző: Sallai András
Copyright © Sallai András, 2021, 2022, 2023
Licenc: 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 --prefer-dist 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:

--prefer-dist

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

Ennek használata gyorsabb letöltést eredményez. A --prefer-dist az alapértelmezés.

Ezzel szemben a --prefer-source 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 --host 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 ¹⁾ 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:

resources/views/home.blade.php

<h1>Tennivalók</h1>

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:

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

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ó:

+--------+----------+----------+------+---------+------------+
| Domain | Method   | URI      | Name | Action  | Middleware |
+--------+----------+----------+------+---------+------------+
|        | GET|HEAD | /        |      | Closure | web        |
|        | GET|HEAD | api/user |      | Closure | api        |
|        |          |          |      |         | auth:api   |
+--------+----------+----------+------+---------+------------+

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:

resources/views/about.blade.php

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

Készítsünk számára egy új útvonal-információt. Írjuk az új bejegyzést a fájl végére:

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

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

<?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');
});

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:

header.blade.php

<!DOCTYPE html>
<html lang="hu">
<head>
    <meta charset="utf-8">
    <title>satodo</title>
</head>
<body>

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:

footer.blade.php

</body>
</html>

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

resources/views/home.blade.php

<x-header />
 
<h1>Tennivalók</h1>
 
<x-footer />

resources/views/about.blade.php

<x-header />
 
<h1>Tennivalók</h1>
<p>Nagy János</p>
 
<x-footer />

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.

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

<x-header />

<x-footer />

A szóköz elhagyható.

Ü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:

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 />

A x-header és x-footer elemek behelyettesítik a fejrészt és a lábrészt. A {{ $todo1 }} 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é:

routes/web.app

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

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:

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);
});

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 $todos 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:

app/Http/Controllers/TodoController.php

<?php
 
namespace App\Http\Controllers;
 
use Illuminate\Http\Request;
 
class TodoController extends Controller
{
    //
}

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

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

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:

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);
    }
}

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:

use App\Http\Controllers\TodoController;

Majd javítsuk a /list hivatkozást így:

Route::get('/list', [TodoController::class, 'list']);

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:

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);
    }
}

A nézetben javítsuk:

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

A teljes kód:

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 />

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:

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

A teljes kód:

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);
    }
}

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:

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

A teljes kód most így néz ki:

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 />

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:

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

Legyen egy új feladat is:

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

A teljes kód:

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
        ]);
    }
}

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:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=

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

Például:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=mytodo
DB_USERNAME=mytodo
DB_PASSWORD=titok

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:

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');
    }
}

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.

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

A \$table->id(); arra utasítja a migrációs parancsot, hogy hozzon létre egy id nevű mezőt a táblában. A $table->timestamps(); 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:

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

A \$table->increments('id'); sor egy elsődleges kulcsmezőt hoz létre, egész típussal, amit automatikusan növel, és a neve „id”. A $table->string('task'); 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 típusok ezen a helyen.

Néhány példa mezők létrehozására, illetve változtatásra:

$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();

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:

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()
    {
        //
    }
}

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:

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

A teljes kód:

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'
        ]);
    }
}

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:

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

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:

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;
}

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:

class Todos extends Model
{
    use HasFactory;
    public $timestamps = false;
}

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:

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

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:

{"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}

Végül javítsunk a nézetfájlon:

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 />

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:

<td><a href={{"delete/".$todo['id']}}>Törlés</a></td>

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:

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

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:

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

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:

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

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:

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 />

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:

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 />

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

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

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

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

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

Route::post('edit', [TodoController::class, 'update']);

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

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

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.

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 />

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

app/Http/Controllers/TodoController.php

    function addTodo(Request $req) {
      $todo = new Todos;
      $todo->task = $req->task;
      $todo->done = 0;
      $todo->save();
      return redirect('list');
    }

Jegyezzük be az útválasztóba:

Route::view('add', 'addtodo');
Route::post('add', [TodoController::class, 'addTodo']);

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:

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

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

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

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:

public const HOME = '/dashboard';

Javítsuk így:

public const HOME = '/list';

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:

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

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:

use App\Http\Controllers\Auth\AuthenticatedSessionController;

Majd vegyük fel egy új útvonalat:

Route::get('/logout', [AuthenticatedSessionController::class, 'destroy']);;

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

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

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

apt install curl docker-compose

Projekt létrehozása

Az egy-app nevű projekt létrehozása:

curl -s https://laravel.build/egy-app | bash

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

Sail

Indítsuk el a Laravel Sail-t.

cd egy-app
./vendor/bin/sail up

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:

  ports:
    - '${APP_PORT:-8000}:80'

Cseréljük erre:

  ports:
    - 8000:80

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:

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

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 --prefer-dist kapcsolót. Ez nem szükséges, mert ez az alapértelmezés. Ugyanakkor két „ellentétes” lehetőségünk van:

--prefer-dist
--prefer-source

A source hatására forrásból telepíti a projektet. A --prefer-source kapcsoló egyenértékű ezzel: ---prefer-install=source. A --prefer-dist 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

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

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

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)

¹⁾

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.

szit

Felhasználói eszközök

Eszközök a webhelyen

Tartalomjegyzék

Laravel bevezetés

A Laravel

VSCode beállítás

Telepítés

Windowson

Linuxon

Ellenőrzés

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

Projekt létrehozása

Előző verziók

dist vagy source

Aktuális könyvtár

A laravel parancs

Artisan szerver

Könyvtárstruktúra

Nézetek

Artisan parancsok

Névjegy

Komponensek

A Blade sablon

Kontroller létrehozása

A with használata

A tömb újratervezése

Egy változó bejárása

Az adatok view()-ban

Adatbázis

Elérés

Tábla létrehozása

Adatok feltöltése

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

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

Modell használata

Tennivaló törlése

Tennivaló módosítása

Tennivaló hozzáadása

Laravel Breeze azonosítás

Alapértelmezett útvonal

Kilépés

Form használata

Írjunk GET kérést

Függelék

Alternatív projekt készítés

Szükséges

Projekt létrehozása

Sail

Kezdeti konfiguráció

Alkönyvtárak a kontrollerben

composer create-project

Debian GNU/Linux 11 - PHP8.1

Laravel parancs

Linkek

Eszközök az oldalon