Tartalomjegyzék

< Laravel

Laravel bevezetés

A Laravel

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

A Laravel webhelye:

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:

Telepítés

Windowson

Szükséges szoftverek:

Lépések:

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

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:

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:

Az app könyvtár tartalma:

Forrás:

Nézetek

A nézetek a következő helyen találhatók:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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ó

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:

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

laravel new app01

Linkek

1)
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.