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_rest_api|< Laravel API]]

====== Laravel API kezdés ======

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

===== Projekt =====

Hozzuk létre a projektet:
  composer create-project laravel/laravel emp

Lépjünk be könyvtárba, majd indítsuk el a szervert:
  cd emp
  php artisan serve

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

Használhatunk többféle adatbázis, itt most SQLite-t fogunk használni.


A database könyvtárban **hozzuk létre** az SQLite adatbázist, **database.sqlite** néven,
egy üres fájl formájában:

  * database/database.sqlite


**Szerkesszük** a **.env** fájlt, írjuk bele milyen adatbázist használunk. 

<code ini .env>
DB_CONNECTION=sqlite
</code>

A MySQL-ra vonatkozó beállításokat tegyük megjegyzésbe.

===== Routes =====

A routes vagy magyarul útválasztásban határozzuk meg, milyen végpontokat érhetünk el, és a végpontokat elérve, mi kell történjen.

Szerkesszük a routes/api.php fájlt:

<code php routes/api.php>
<?php

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;

/*
|--------------------------------------------------------------------------
| API Routes
|--------------------------------------------------------------------------
|
| Here is where you can register API routes for your application. These
| routes are loaded by the RouteServiceProvider and all of them will
| be assigned to the "api" middleware group. Make something great!
|
*/

Route::middleware('auth:sanctum')->get('/user', function (Request $request) {
    return $request->user();
});
</code>

A két use kezdetű sor lehetővé teszik hogy használjuk a Request és a Route osztályokat. 

A Route::middleware() függvényhívással kezdődő sor egy útválasztási bejegyzés.
Töröljük, vagy tegyük megjegyzésbe.

Vegyünk fel egy saját útválasztó bejegyzést, GET metódussal:

<code php routes/api.php>
//...
Route::get('/employees', function(){
    return 'employees';
});

</code>

A /employees végpontot határoztuk meg és egy névtelen függvényben, az 'employees' szóval térünk vissza.

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

Használjuk egy HTTP klienst a teszteléshez. Lehet egy böngésző, az Insomnia, vagy a curl parancssoros program. 

Készítsünk egy GET kérést a következő címre:
  http://localhost:8000/api/employees

<note tip>
Ügyeljünk arra, hogy fusson a szerver. Ha valamiért leállítottuk, akkor nem kapunk eredményt.
</note>

==== Gyakorlat ====

  * Készítsünk legalább három másik végpontot, GET metódussal, különféle üzenetekkel.
===== Dolgozók modell és tábla =====

Hozzuk létre a dolgozók táblát gyártó PHP osztályt:
  php artisan make:model Employee --migration

A <nowiki>--migration</nowiki> kapcsoló, létrehozza a migrációs fájlokat,
amiből leképezhető az adatbázis tábla. A Laravel alapértelmezetten tartalmaz
néhány migrációs táblát, ezek szükségesek a működéshez.

A migrációs fájlok a **database/migrations** könyvtárban vannak.

Szerkesszük a database/migrations/*create_employees_table.php fájlt.
A * helyén az aktuális dátum szerepel.

<code php database/migrations/*create_employees_table.php>
//...

    public function up()
    {
        Schema::create('employees', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('city');
            $table->decimal('salary', 5, 2);
            $table->timestamps();
        });
    }

//...
</code>

Ezt követően a táblák elkészíthetők

Hozzuk létre a táblákat:
  php artisan migrate



További lehetőségek a migrációs fájlokban:
<code php>
$table->increments('id');
$table->boolean('done');
$table->tinyInteger('status')->default('1');
</code>

==== Tábla frissítése ====

Ha szeretnénk javítani a migrációs állományt, szükség van a migráció újabb futtatására. Ez a :refresh utótaggal tehetjük meg.

<note important>Ez a művelet törli a tábla tartalmát.</note>

  php artisan migrate:refresh

===== Útválasztás javítása =====

Vegyük használatba az útválasztóban az Employee osztályt:

<code php routes/api.php>
use App\Models\Employee;

//...

Route::get('/employees', function(){
    return Employee::all();
});
</code>

Ellenőrizzük Insomnia-ban:
  * Metódus: GET
  * URL: http://localhost:8000/api/employees

A tábla üres, de 200-s kódot kell kapjunk.


===== A post metódus =====

Szeretnénk új dolgozót felvenni. Ehhez engedélyezzük a **name**, **city** és **salary** mezők
megadását:

<code php app/Models/Employee.php>
//...
class Employee extends Model
{
    use HasFactory;
    
    protected $fillable = [
        'name',
        'city',
        'salary'
    ];
}
</code>

A routingban beállítunk egy dolgozót:

<code php routes/api.php>
//...

Route::post('/employees', function(){
    return Employee::create([
        'name' => 'Rágó Ferenc',
        'city' => 'Szolnok',
        'salary' => 2873000
    ]);
});
</code>

Ellenőrizzük egy POST kéréssel az Insomnia-ban.
Nézzük meg az adatbázisban az új dolgozót.

Így most, mindig ezt a felhasználót fogja felvenni. 
A következő fejezetben megoldjuk, hogy a bejövő
HTTP kérésből vegyük a dolgozó adatait.



===== A dolgozó kontroller =====

Hozzunk létre egy Employee nevű kontrollert:

  php artisan make:controller EmployeeController --resource --api

Kapcsolók:
  * A <nowiki>--resource</nowiki> hatására létrejönnek az alapértelmezett metódusok. 
  * A <nowiki>--api</nowiki> hatására nem jön létre create és edit metódus.

A create és edit metódusok nem szükségesek REST API készítése során.

Szerkesszük az EmployeeController.php fájlt. Szükség van az Employee modellre, vegyük azt használatba:

<code php app/Http/Controller/EmployeeController.php>
//...

use App\Models\Employee;

</code>


Az index függvényben kérjük le az összes dolgozó adatait:

<code php>
    public function index()
    {
        return Employee::all();
    }
</code>

Állítsuk be az útválasztás:

<code php routes/api.php>
use App\Http\Controllers\EmployeeController;

//...

Route::get('/employees', [EmployeeController::class, 'index']);
</code>

A [EmployeeController::class, 'index'], azt jelenti, az EmployeeController osztályon belül 
szeretnénk az index metódust hívni, ha valaki a /employees végpontra hivatkozik.



Ellenőrizzük API klienssel.


Ha szeretnénk dolgozót tárolni egy store() nevű metódust hozunk létre. 

Írjuk meg a store függvényt:
<code php app/Http/Controller/EmployeeController.php>
//...

    public function store(Request $request)
    {
        return Employee::create($request->all());        
    }
</code>

Írjunk hozzá útválasztást:

<code php routes/api.php>
use App\Http\Controllers\EmployeeController;

//...

Route::get('/products', [EmployeeController::class, 'index']);

Route::post('/employees', [EmployeeController::class, 'store']);

</code>

Teszteljük API klienssel.
JSON tartalmat küldünk. Insomnia esetén figyeljük meg a "Header" fülön, hogy 
beállításra kerül a "Content-Type" "application/json" fejléc adat.

==== Válaszkód küldése ====


<code php app/Http/Controller/EmployeeController.php>
//...

    public function store(Request $request)
    {
        $employees = Employee::create($request->all());
        return response($employees, 201);
    }
</code>

A sikeres létrehozást 201-s válaszkóddal jelezzük.


==== Validáció beállítása ====


<code php app/Http/Controller/EmployeeController.php>
//...

    public function store(Request $request)
    {
        $request->validate([
            'name' => 'required',
            'salary' => 'required'
        ]);
        $employees = Employee::create($request->all());
        return response($employees, 201);     
    }
</code>

===== Egyetlen dolgozó lekérdezése =====

<code php app/Http/Controller/EmployeeController.php>
//...

    public function show($id)
    {
        return Employee::find($id);
    }
</code>

Írjunk hozzá útválasztást:
<code php routes/api.php>
Route::get('/products/{id}', [EmployeeController::class, 'show']);
</code>

A végpont után írt {id} az show() metódusban elérhető paraméterként a kontrollerben.



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

<code php app/Http/Controller/EmployeeController.php>
//...

    public function update(Request $request, $id)
    {
        $employee = Employee::find($id);
        $employee->update($request->all());
        return $employee;
    }
</code>

Írjunk hozzá útválasztást:
<code php routes/api.php>
//...
Route::put('/employees/{id}', [EmployeeController::class, 'update']);
</code>


Ellenőrizzük API klienssel.

===== Dolgozó törlése =====

<code php app/Http/Controller/EmployeeController.php>
//...

    public function destroy($id)
    {
        return Employee::destroy($id);
    }
</code>


Írjunk hozzá útávlasztást:

<code php routes/api.php>
//...
Route::delete('/employees/{id}', [EmployeeController::class, 'destroy']);
</code>

Ellenőrizzük API klienssel.

Siker esetén 1-el tér vissza.

===== Összes erőforrás =====

Az összes CRUD műveletet egyetlen útválasztó bejegyzéssel megoldhatjuk:

<code php routes/api.php>
use App\Http\Controllers\EmployeeController;

//...

Route::resource('/employees', EmployeeController::class);

/*
Route::get('/products', [EmployeeController::class, 'index']);
Route::post('/employees', [EmployeeController::class, 'store']);
Route::get('/products/{id}', [EmployeeController::class, 'show']);
Route::put('/employees/{id}', [EmployeeController::class, 'update']);
Route::delete('/employees/{id}', [EmployeeController::class, 'destroy']);
*/
</code>

Ellenőrizzük, milyen router információk vannak:
  php artisan route:list

Ellenőrizzük API klienssel. Cím:
  http://localhost:8000/api/employees/2

===== Keresés =====

<code php app/Http/Controller/EmployeeController.php>
//...

    public function search($name)
    {
        return Employee::where('name', 'like', '%'.$name.'%')->get();
    }
</code>

Routing szerkesztése:

<code php routes/api.php>
use App\Http\Controllers\EmployeeController;

//...



Route::get('/employees/search/{name}', [EmployeeController::class, 'search']);

</code>

Ellenőrizzük API klienssel.

Például:
  http://localhost:8000/api/employees/search/László

===== Sanctum =====
A csomagok (package) között található a Sanctum:
  * https://laravel.com/docs/8.x/sanctum





<code php routes/api.php>
use App\Http\Controllers\EmployeeController;

//...

Route::resource('/employees', EmployeeController::class);
// Route::get('/employees/search/{name}', [EmployeeController::class, 'search']);
// Route::get('/employees', [EmployeeController::class, 'index']);
// Route::post('/employees', [EmployeeController::class, 'store']);


Route::group(['middleware' => ['auth:sanctum']], function () {
    Route::get('/employees/search/{name}', [EmployeeController::class, 'search']);
});

Route::middleware('auth:sanctum')->get('/user', function (Request $request) {
    return $request->user();
});

</code>

Ellenőrizzük:
  http://localhost:8000/api/employees/search/László

A következő hibát kapjuk:
  Route [login] not defined.


Állítsuk be fejlécben -> "Header" fülön:
  Accept application/json

A következő választ kapjuk:
<code>
{
  "message": "Unauthenticated."
}
</code>

==== Auth kontroller ====

  php artisan make:controller AuthController


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

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use App\Models\User;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\facades\Auth;

class AuthController extends Controller
{
    public function register(Request $request) {
        $fields = $request->validate([
            'name' => 'required|string',
            'email' => 'required|string|unique:users,email',
            'password' => 'required|string|confirmed'
        ]);
        $user = User::create([
            'name' => $fields['name'],
            'email' => $fields['email'],
            'password' => bcrypt($fields['password'])
        ]);
        $token = $user->createToken('sajatToken')->plainTextToken;
        $response = [
            'user' => $user,
            'token' => $token
        ];
        return response($response, 201);
    }
    public function login(Request $request) {
        if( Auth::attempt([ "name" => $request->name, "password" => $request->password ])) {

            $authUser = Auth::user();
            $success[ "token" ] = $authUser->createToken( "myapptoken" )->plainTextToken;
            $success[ "name" ] = $authUser->name;

            return response( $success);

        }else {

            return response( "Hiba! A bejelentkezés sikertelen", [ "error" => "Hibás adatok" ]);
        }
    }
    public function logout( Request $request ) {        
        auth( "sanctum" )->user()->currentAccessToken()->delete();
        return response()->json('Kijelentkezve');
    }    
}

</code>

Az AuthController tartalmát, akár be is másolhatjuk, de van egy hivatkozás User osztályra, ezért ne felejtsük el használatba vennei:

<code php>
use App\Models\User;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\facades\Auth;
//...
</code>


Regisztrációnál a jelszó elkérhető kétszer:
<code javascript>
        $validator = Validator::make( $request->all() , [
            "name" => "required",
            "email" => "required",
            "password" => "required",
            "confirm_password" => "required|same:password",
        ]);
</code>

==== Regisztráció ====
Az api számára is fel kell vennünk felhasználókat az azonosításhoz. 
Használhatunk hozzá egy REST API klienst, például Insomnia.

Fejléc:
  Accept application/json

Ezt küldjük:

<code>
{
	"name": "mari",
	"email": "mair@zold.lan",
	"password": "titok",
	"password_confirmation": "titok"
}
</code>


Eredmény:
<code>
{
  "user": {
    "name": "mari",
    "email": "mari@zold.lan",
    "updated_at": "2021-11-24T19:57:43.000000Z",
    "created_at": "2021-11-24T19:57:43.000000Z",
    "id": 3
  },
  "token": "3|7eBr5iAUPgqQz3lxIFgC72Yh3ERO76g1MyuHNOGD"
}
</code>


==== Keresés azonosítással ====

Insomnia-ban:
  * Auth fül
  * Kiválasztjuk: Bearer
  * Token: 3|7eBr5iAUPgqQz3lxIFgC72Yh3ERO76g1MyuHNOGD

  * [Send]

==== Útválasztás ====

<code php>
Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);
</code>



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

<code php app/Http/Controllers/AuthController.php>
//...

    public function logout(Request $request) {
        auth()->user()->tokens()->delete();
        return [
            'message' => 'Logged out'
        ];
    }
</code>

Útválasztás:
<code php routes/api.php>
Route::group(['middleware' => ['auth:sanctum']], function () {
    Route::get('/employees/search/{name}', [EmployeeController::class, 'search']);
    Route::post('/logout', [AuthController::class, 'logout']);
});
</code>


Teszteléshez:
  http://localhost:8000/api/logout