13B2 - Üzenőfal feladat javítás

"Valaki" galád módon bele törölgetett az iskolai üzenőfal frontend és backend kódjaiba. 

Javítsd ki a hibákat, hogy megfelelően működjön az iskolai üzenőfal. 

Források:

https://github.com/latiza/20241105_13B2_megoldando_feladat_uzenofal

13B Űrlap készítés és feldolgozás dolgozat

Feladat: Készíts egy HTML űrlapot a következő adatok megadására:

• Készíts egy új HTML fájlt form.html néven.
• Név (szövegmező)
• Email cím (email mező)
• Tanfolyam választása (legördülő menü: Frontend, Backend, Fullstack)
• ÁSZF elfogadása (checkbox)
• Az űrlap mezői mind kötelezőek, ezért használd a required attribútumot, hogy ne lehessen üresen elküldeni.
• Használj HTML5 elemeket, hogy az űrlap megfelelően validálja a bevitt adatokat.
• Készíts egy CSS fájlt style.css néven, amellyel a minta szerint formázod az űrlapot.
• Az űrlapnak POST metódussal küld el az adatokat egy form_handler.php nevű PHP fájlnak. 
• Ellenőrizd érkezett e post kérés.
• Tisztítsd meg a bevitt adatokat SQL injection és XSS támadások ellen.
• Ellenőrizd a bevitt adatokat, ha hibás adatot küld a felhasználó, figyelmeztető üzenetet kapjon.

Eredmény:

13 B- PHPdoc kommentezés

 A PHPDoc egy dokumentációs szabvány, amely lehetővé teszi a kódolók számára, hogy pontosan kommentálják a PHP kódjukat, így más fejlesztők és maga a fejlesztő is könnyebben megérthesse a kód működését. Ezenkívül az IDE-k (például PHPStorm) és a dokumentációs eszközök automatikusan feldolgozhatják ezeket a kommenteket, hogy hasznos információkat nyújtsanak.

Kommentezés szintaxisa

A PHPDoc kommentek többsora zárójelben történik:

/**

 * Ez a komment leírja, hogy mit csinál a funkció.

 * További részletek is itt jelennek meg.

 */

Főbb PHPDoc annotációk

1.     @var Használat: Egy változó típusát és célját adja meg.
Formátum: @var típus $változónév
Példa:

/** @var int $age A felhasználó életkora. */

public $age;

2.     @param Használat: Egy függvény/módszer paramétereit dokumentálja.
Formátum: @param típus $paraméterLeírás
Példa:

/**

 * Kiszámítja a felhasználó életkorát.

 *

 * @param int $yearOfBirth A születési év.

 * @return int A felhasználó életkora.

 */

public function calculateAge($yearOfBirth) {

    return date('Y') - $yearOfBirth;

}

3.     @return
Használat: Egy függvény visszatérési értékét írja le.
Formátum: @return típus Leírás
Példa:

/**

 * @return string A felhasználó teljes neve.

 */

public function getFullName() {

    return $this->firstName . ' ' . $this->lastName;

}

4.     @method Használat: Egy osztály által dinamikusan elérhető függvényeket dokumentál.
Formátum: @method típus methodName(paramétertípus $paraméterLeírás)
Példa:

/**

 * @method void prepare(string $sql)

 * @method void bind_param(string $types, mixed ...$vars)

 */

5.     @property Használat: Egy osztály olyan tulajdonságait írja le, amelyeket nem közvetlenül definiáltak, de elérhetők dinamikusan.
Formátum: @property típus $tulajdonságLeírás
Példa:

/**

 * @property string $name A felhasználó neve.

 */

6.     @throws Használat: Ha egy függvény kivételt (exception) dobhat, dokumentálja, hogy melyik típusú kivétel dobható.
Formátum: @throws ExceptionTípus Leírás
Példa:

/**

 * @throws InvalidArgumentException Ha a bemeneti adat érvénytelen.

 */

public function setAge($age) {

    if ($age < 0) {

        throw new InvalidArgumentException('Érvénytelen életkor');

    }

}

7.     @deprecated Használat: Jelzi, hogy egy függvény, metódus, vagy tulajdonság elavult, és nem ajánlott a használata.
Formátum: @deprecated Leírás
Példa:

/**

 * @deprecated Ez a metódus elavult. Használja a getNewData() függvényt.

 */

public function getData() {

    // régi logika

}

Gyakran használt PHPDoc annotációk összefoglalása

• @var: Egy változó típusát írja le.
• @param: Függvény vagy metódus paramétereinek leírása.
• @return: A visszatérési érték típusát és célját dokumentálja.
• @method: Dinamikusan elérhető metódusok leírása.
• @property: Olyan osztály tulajdonságait írja le, amelyeket dinamikusan lehet elérni.
• @throws: Kivétel dobásának leírása.
• @deprecated: Elavult kód jelölése.

Gyakorlati feladatok

1.     Annotációk azonosítása és helyes használata:

• Írj egy egyszerű PHP osztályt, amely egy adatbázis csatlakozást és egy select() függvényt tartalmaz.
• Kommentezd az osztályt PHPDoc annotációkkal, például @var, @param, @return és @throws.

2.     Dokumentáció generálása:

• Használj eszközt (pl. phpDocumentor), hogy automatikusan generálj dokumentációt a kommentjeid alapján.

<?php

 

/**

 * Adatbázis kapcsolatot kezelő osztály.

 *

 * Ez az osztály kapcsolatot létesít egy MySQL adatbázissal,

 * és lehetővé teszi az SQL utasítások végrehajtását.

 */

class DatabaseConnection {

    /**

     * @var mysqli $connection A MySQL adatbázis kapcsolat objektuma.

     */

    private $connection;

 

    /**

     * Létrehozza az adatbázis kapcsolatot.

     *

     * @param string $host Az adatbázis kiszolgáló neve.

     * @param string $user Az adatbázis felhasználóneve.

     * @param string $password Az adatbázis felhasználó jelszava.

     * @param string $database Az adatbázis neve.

     *

     * @throws Exception Ha nem sikerül a kapcsolat létrehozása.

     */

    public function __construct($host, $user, $password, $database) {

        $this->connection = new mysqli($host, $user, $password, $database);

 

        if ($this->connection->connect_error) {

            throw new Exception('Kapcsolódási hiba: ' . $this->connection->connect_error);

        }

    }

 

    /**

     * Végrehajt egy SELECT lekérdezést és visszaadja az eredményt.

     *

     * @param string $sql A végrehajtandó SQL lekérdezés.

     * @param int $id A lekérdezésben használt azonosító.

     *

     * @return array A lekérdezés eredménye tömbként.

     */

    public function select($sql, $id) {

        $stmt = $this->connection->prepare($sql);

        $stmt->bind_param('i', $id);

        $stmt->execute();

        $result = $stmt->get_result();

 

        return $result->fetch_all(MYSQLI_ASSOC);

    }

    /**

     * Bezárja az adatbázis kapcsolatot.

     */

    public function close() {

        $this->connection->close();

    }

}

?>

2. PHPDoc dokumentáció generálása

Ehhez a kódhoz használhatod a phpDocumentor nevű eszközt, amely automatikusan feldolgozza a PHPDoc stílusú kommenteket, és HTML alapú dokumentációt készít belőlük.

• Telepítsd a phpDocumentor eszközt:

composer require --dev phpdocumentor/phpdocumentor

• Futtasd a phpDocumentor-t a projekt könyvtárában:

./vendor/bin/phpdoc

Ez generál egy HTML fájlt, ahol a fenti kód dokumentációját szépen formázva megtekintheted.

13. B 14. A REST API alkalmazás fő követelményei

Az eddigiekben számos megoldással ismerkedtünk, hogyan hajthatunk végre különféle műveleteket. A záródolgozat kimeneti követelménye, hogy az alkalmazásnak meg kell felelnie a RESTful API követelményeinek. A következőkben megnézzük, hogy melyek ezek a követelmények, melyet később a gyakorlatba is átültetünk.

1. Kliens-szerver architektúra

A REST API egyértelműen elválasztja a klienst (például egy böngésző, mobilalkalmazás vagy más API-felhasználó) és a szervert. A szerver nem tárol kliens oldali állapotokat (stateless), csak válaszokat küld a kliens által küldött kérésekre. Ez a felépítés biztosítja a feladatok tiszta szétválasztását.

2. Stateless (Állapotmentesség)

A RESTful API-k stateless-ek, ami azt jelenti, hogy minden egyes kérésnek teljesnek kell lennie önmagában. A szerver nem tárolhat kliens oldali adatokat egyik kéréstől a másikig. Minden kérésnek tartalmaznia kell minden szükséges információt (pl. hitelesítési adatok, kliens állapot), hogy a szerver megfelelően válaszolhasson.

3. HTTP protokoll használata

A REST API-k az HTTP-t használják, és kihasználják az HTTP-szabvány által biztosított metódusokat, például:

• GET: Adatok lekérdezésére használjuk.
• POST: Új erőforrás létrehozására.
• PUT: Meglévő erőforrás frissítésére vagy felülírására.
• PATCH: Egy meglévő erőforrás részleges frissítésére.
• DELETE: Erőforrás törlésére.
• OPTIONS: Lekérdezés a szerver által támogatott műveletekről.

4. Erőforrás-alapú URL struktúra

A RESTful API-kban minden erőforráshoz egy egyedi URL társul. Az URL-eket úgy kell megtervezni, hogy könnyen érthetők és logikailag szervezettek legyenek. Például:

• GET /contacts: Az összes névjegy lekérdezése.
• GET /contacts/1: Az 1-es azonosítójú névjegy lekérdezése.
• POST /contacts: Új névjegy létrehozása.
• PUT /contacts/1: Az 1-es névjegy frissítése.
• DELETE /contacts/1: Az 1-es névjegy törlése.

Az URL-eknek az erőforrásokra kell utalniuk (pl. contacts, users, orders), és azonosítókkal lehet konkrét erőforrásokra hivatkozni.

5. Állapotkódok használata

A RESTful API-k használják a HTTP válaszokban megadott állapotkódokat annak jelzésére, hogy egy kérés sikeres volt-e, vagy hibába ütközött. Példák:

• 200 OK: Sikeres kérés.
• 201 Created: Erőforrás sikeresen létrehozva (pl. új felhasználó hozzáadása).
• 400 Bad Request: Rosszul formázott kérés.
• 401 Unauthorized: Jogosultság hiánya a kéréshez.
• 403 Forbidden: Tiltott hozzáférés.
• 404 Not Found: Erőforrás nem található.
• 500 Internal Server Error: Szerveroldali hiba.

6. HATEOAS (Hypermedia as the Engine of Application State)

A RESTful API ideális esetben követi a HATEOAS elvet, ami azt jelenti, hogy a válaszok tartalmaznak további hivatkozásokat más releváns erőforrásokra. Például egy felhasználó lekérdezésére adott válasz tartalmazhat hivatkozásokat a felhasználó névjegyeire vagy rendeléseire:

{

    "id": 1,

    "name": "John Doe",

    "links": [

        { "rel": "self", "href": "/users/1" },

        { "rel": "contacts", "href": "/users/1/contacts" }

    ]

}

7. JSON használata (vagy más formátum)

A RESTful API-k általában JSON formátumban adnak vissza adatokat, mivel ez egy könnyen olvasható és platformfüggetlen formátum. Azonban XML, YAML vagy más formátumok is használhatók, attól függően, hogy mi szükséges az alkalmazás szempontjából. A válaszok JSON formátuma például:

{

    "id": 1,

    "name": "John Doe",

    "email": "john.doe@example.com"

}

8. Biztonság (HTTPS, Hitelesítés)

A RESTful API-k védelméhez HTTPS használata szükséges az adatok titkosítása érdekében. Az API-k hozzáféréséhez szükség lehet hitelesítésre, amelyet különféle módszerekkel lehet megvalósítani, például:

• OAuth: Token-alapú hitelesítés.
• API kulcsok: Minden kérésnél egy kulcs átadása, amely hitelesíti a klienst.
• JWT (JSON Web Token): Kriptografikusan aláírt token, amely tartalmazza a felhasználó adatait.

9. Cache-elhetőség

A RESTful API-kban a válaszok cache-elhetők, ha az erőforrások nem változnak gyakran. A megfelelő HTTP cache fejlécek használata biztosítja, hogy a kliens (pl. böngésző) helyi gyorsítótárából használhatja az adatokat, ami javítja a teljesítményt és csökkenti a szerver terhelését. Például a Cache-Control fejléc:

Cache-Control: max-age=3600

10. Verziózás

Az API-k folyamatos fejlesztése miatt fontos az API-k verziózása, hogy az új fejlesztések ne törjék meg a régi implementációkat. Ez többféleképpen valósítható meg, például az URL-ben:

/v1/contacts

/v2/contacts

11. Idempotencia

A RESTful API-kban az idempotens műveletek olyan műveletek, amelyek többszöri végrehajtása ugyanazt az eredményt adja. Például a GET és DELETE műveletek idempotensek, mert bármennyiszer hajtjuk végre őket, ugyanaz lesz az eredmény.

Összegzés

Egy REST API-nak tehát a következő elveket kell követnie:

1. Kliens-szerver architektúra.
2. Állapotmentesség (stateless).
3. HTTP metódusok használata (GET, POST, PUT, DELETE, stb.).
4. Erőforrás-alapú URL-ek.
5. Megfelelő állapotkódok használata.
6. HATEOAS támogatás (opcionális, de ajánlott).
7. JSON vagy más formátumú válaszok.
8. Biztonság és hitelesítés (HTTPS, OAuth, API kulcsok stb.).
9. Cache-elhetőség a megfelelő HTTP fejlécekkel.
10. Verziózás.
11. Idempotencia a megfelelő műveleteknél.

Ha egy alkalmazás megfelel ezeknek a követelményeknek, akkor REST API-nak tekinthető.

13 B - Whitelist

 

A fehér lista (angolul: whitelist) egy biztonsági koncepció, amelyben előre meghatározol egy olyan listát, amely csak engedélyezett elemeket tartalmaz. Csak azok az elemek, amelyek szerepelnek a listán, használhatók vagy hozzáférhetők egy adott művelethez.

Példák:

1. Adatbázis lekérdezésekben: Mint az előző példában is láttad, a fehér lista egy olyan oszlopnevek listája, amelyek közül a felhasználó választhat, hogy melyik szerint szeretné rendezni az adatokat. Csak ezek az oszlopok vannak megengedve.

A mi jelenlegi példánkban így nézne ki: 

$validColumns = ['nev', 'cegnev', 'mobil', 'email']; // Fehér lista 

$rendez = in_array($rendez, $validColumns) ? $rendez : 'nev'; // Csak ezek engedélyezettek

1. gy webalkalmazás esetében a fehér lista tartalmazhat olyan fájlokat, URL-eket vagy IP-címeket, amelyekhez hozzáférést adsz, míg minden más alapértelmezés szerint blokkolva van.

2. Biztonság: A fehér lista fontos a biztonság szempontjából, mert segítségével korlátozhatod, hogy csak azokat az elemeket használhassa a felhasználó, amelyeket kifejezetten biztonságosnak ítéltél. Így kizárhatod a nem engedélyezett vagy veszélyes elemeket.

Miért használjuk?

A fehér lista használata azt jelenti, hogy minden más alapértelmezés szerint tiltva van, kivéve azokat az elemeket, amelyek kifejezetten engedélyezve vannak. Ez biztonságosabb megközelítés, mint a fekete lista, ahol csak a tiltott elemeket határozod meg, mert mindig előfordulhatnak nem várt elemek, amelyeket a fekete lista nem fed le.

13 B - Elvis helyett használjuk a Ninja operátort

 

Miért Ninja? A dupla kérdőjel (??) olyan, mintha egy "ninja" gyorsan előbukkanna a semmiből, hogy egy alapértelmezett értéket helyettesítsen, ha valami nincs ott, vagyis "rejtve" marad. A ninja elnevezés egyfajta rejtett, gyors helyettesítésre utal. :-) persze adhattok neki jobb nevet is.

Szóval a lényeg, amit már mutattam órán, a ??. A nullás egyesítési operátor (??) (angolul: null coalescing operator) a PHP 7.0 verziójában került bevezetésre, amely 2015. december 3-án jelent meg. Az operátor célja az volt, hogy egyszerűbbé és rövidebbé tegye a kódot, különösen akkor, amikor egy változót ellenőrizni kell, hogy létezik-e vagy null-e, és ha nem, akkor egy alapértelmezett értéket ad vissza.

Ez az operátor azzal a céllal jött létre, hogy egyszerűbbé tegye a változók ellenőrzését és alapértelmezett értékadását, amikor egy változó nem létezik, vagy null értékkel rendelkezik.

Nézzük hol használhatjuk Elvis helyett:

$rendez = isset($_GET['rendez']) ? $_GET['rendez'] : "nev"; 

$kifejezes = isset($_POST['kifejezes']) ? $_POST['kifejezes'] : "";

Az isset() itt azt ellenőrzi, hogy a $_GET['rendez'] és $_POST['kifejezes'] változók léteznek-e, és nem null értékűek. Ha léteznek, akkor az értéküket használja, ha nem, akkor az alapértelmezett értéket ("nev" vagy "") adja vissza. Ez a klasszikus ternáris, bocs Elvis operátor helyes használata.

Ninja operátorral: 

$rendez = $_GET['rendez'] ?? "nev"; 

$kifejezes = $_POST['kifejezes'] ?? "";

A "??" operátor az ún. nullás egyesítési operátor, ami csak akkor működik jól, ha az adott változó valóban null vagy undefined. Az "isset()" függvény azonban ellenőrzi, hogy a változó létezik-e, és értékkel rendelkezik-e. Azonban az "isset()" függvényt és a "??" operátort nem kell együtt használni, mert a "??" magában is megoldja azt, amit az "isset()" tesz. 

13 B - egyedi számok létrehozása

 A date("U") egy PHP függvény, amely az aktuális dátumot és időt Unix időbélyeg formájában adja vissza.

Mit jelent a Unix időbélyeg?

A Unix időbélyeg (más néven Unix timestamp) az az idő, amely a 1970. január 1. 00:00:00 (UTC) időpont óta eltelt másodpercek számát jelenti. Ez egy egyszerű egész szám, amely folyamatosan növekszik minden másodperccel. Például, ha most meghívod a date("U") függvényt, az visszaadja, hogy hány másodperc telt el 1970. január 1. óta.

Mikor használjuk?

A Unix időbélyeg nagyon hasznos, amikor egyedi fájlneveket, időbélyegeket vagy időszámításokat kell kezelni. Azért használjuk, mert egy egyedi, egyszerű számot generál, amely jól alkalmazható például fájlok elnevezésénél, hogy elkerüljük az ütközéseket, vagy időszámításokban, amikor másodpercekben kell kifejezni az időt.

Példa:

echo date("U"); // Például: 1707158419

Ez a szám az aktuális másodpercben eltelt idő 1970. január 1. óta.

A uniqid() is kiválóan alkalmas arra, hogy egyedi fájlneveket hozz létre. A uniqid() függvény egy egyedi azonosítót generál a jelenlegi időpont alapján, ami garantálja, hogy minden híváskor egyedi értéket ad vissza.

A különbség a date("U") és a uniqid() között:

• date("U"): Ez egy egyszerű Unix időbélyeg, amely az aktuális időt másodpercekben adja vissza. Ez az érték minden másodpercben ugyanaz marad, így ha ugyanazon a másodpercen belül több fájlt generálsz, azok azonos nevet kaphatnak.

• uniqid(): Ez egy egyedi azonosító, amely nemcsak az aktuális időn alapszik, hanem nagyobb precizitással működik (mikroszekundumokban mérve). Ezért, ha ugyanabban a másodpercben több fájlt generálsz, azok egyedi neveket fognak kapni.

Példa uniqid() használatára:

$unique_name = uniqid();
echo $unique_name; // Például: 652ebe5c7c6db

Ez a generált érték garantáltan egyedi lesz minden egyes híváskor, még akkor is, ha nagyon gyors egymásutánban hívod meg a függvényt.

uniqid() előnyei fájlfeltöltéskor:

• Biztosítja az egyedi fájlneveket: Még akkor is, ha egy másik felhasználó ugyanabban a másodpercben töltene fel egy fájlt, a nevek különbözni fognak.
• Egyszerű és gyors használat: Nem kell bonyolult beállításokkal vagy paraméterekkel foglalkozni, mivel alapértelmezetten a jelenlegi időt használja a generáláshoz.

Ha biztosra akarsz menni az egyedi fájlnevek létrehozásában, akkor a uniqid() egy nagyon jó megoldás.

13 B - Mit jelent a mime típus?

 A MIME-típusok (Multipurpose Internet Mail Extensions) a fájlformátumok azonosítására szolgálnak, különösen, amikor fájlokat küldünk vagy fogadunk a weben keresztül, például amikor egy szerver adatokat küld a böngészőnek vagy fájlt töltünk fel egy szerverre.

Minden fájlnak van egy MIME-típusa, ami egy kéttagú azonosító, és azt mondja meg, hogy a fájl milyen típusú adatot tartalmaz, illetve hogyan kell kezelni. Ez lehetővé teszi a szerver és a kliens számára, hogy megfelelően kezeljék és értelmezzék a fájlt.

A MIME-típus két részből áll:

• Első rész: az adott fájltípus fő kategóriáját jelzi (például "image", "text", "application").
• Második rész: a fájl pontosabb típusát jelzi (például "jpeg", "png", "html", "pdf").

Néhány gyakori MIME-típus:

• Képekhez:
  • image/jpeg: JPEG formátumú kép
  • image/png: PNG formátumú kép
  • image/gif: GIF formátumú kép
• Szöveges fájlokhoz:
  • text/html: HTML fájl
  • text/plain: Egyszerű szövegfájl
• Alkalmazásokhoz:
  • application/pdf: PDF fájl
  • application/json: JSON adatfájl

Miért fontos a MIME-típusok ellenőrzése fájlfeltöltéskor?

Amikor fájlokat töltünk fel egy szerverre, a MIME-típus ellenőrzésével biztosíthatjuk, hogy csak a megengedett fájltípusokat fogadjuk el. Például, ha a rendszer csak képfájlokat szeretne elfogadni, ellenőrizhetjük, hogy a feltöltött fájl MIME-típusa image/jpeg, image/png vagy más megengedett képformátum. Ez biztonsági szempontból is fontos, mert segít megelőzni, hogy a felhasználók olyan fájlokat töltsenek fel, amelyek kártékonyak lehetnek (például futtatható fájlokat).

A te kódodban a MIME-típusok ellenőrzése segít abban, hogy csak JPEG, PNG vagy GIF formátumú képeket fogadj el fájlfeltöltéskor.

13 B - PHP fájlkezelés haladó technikák: Fájlok és könyvtárak manipulálása, jogosultságok kezelése

 A PHP fájlkezelés haladó technikái lehetővé teszik a fájlok és könyvtárak különféle műveleteinek végrehajtását, beleértve a létrehozást, olvasást, írást, törlést és jogosultságok kezelését. A fájlkezelés elengedhetetlen számos alkalmazás számára, például fájlok feltöltésénél, adatnaplózásnál vagy akár teljes fájlrendszer-adminisztrációs feladatok végrehajtásánál.

1. Fájlok kezelése:

A fájlkezelés során olyan műveleteket végezhetünk, mint a fájlok létrehozása, olvasása, írása, módosítása és törlése. PHP-ben ezekhez számos beépített függvény áll rendelkezésre.

a. Fájlok olvasása:

·        file_get_contents(): Egy fájl tartalmának egy lépésben történő beolvasására használható, és az eredményt egy stringben adja vissza.

$fileContent = file_get_contents('path/to/file.txt');

echo $fileContent;

·        fopen() és fread(): Ezek a függvények részletesebb kontrollt biztosítanak a fájlkezelés felett, és lehetővé teszik a fájlok olvasását bájtonként vagy karakterenként.

$file = fopen('path/to/file.txt', 'r');

while (!feof($file)) {

    echo fgets($file); // Egy sor beolvasása

}

fclose($file);

b. Fájlok írása:

·        file_put_contents(): Lehetővé teszi, hogy egy lépésben adatokat írjunk egy fájlba.

$data = "Ez egy új fájl tartalma.";

file_put_contents('path/to/file.txt', $data);

·        fwrite(): Több kontrollt biztosít az írás felett, például a fájl megnyitását különböző módokban (pl. írásra, hozzáfűzésre).

$file = fopen('path/to/file.txt', 'a'); // Hozzáfűzési mód

fwrite($file, "Új tartalom a fájl végén.");

fclose($file);

c. Fájlok törlése:

• unlink(): Ezzel a függvénnyel fájlokat lehet törölni.

php

Kód másolása

unlink('path/to/file.txt');

2. Könyvtárak kezelése:

A fájlok mellett a könyvtárak kezelése is fontos lehet, például amikor fájlokat másolunk, mozgatunk vagy létrehozunk új könyvtárakat.

a. Könyvtárak létrehozása:

• mkdir(): Ez a függvény új könyvtárat hoz létre.

mkdir('path/to/new_directory', 0755, true); // Jogosultságok beállítása (0755), és az összes szükséges szülő könyvtár létrehozása

b. Könyvtárak olvasása:

• scandir(): A könyvtár tartalmát listázhatjuk ezzel a függvénnyel.

php

Kód másolása

$files = scandir('path/to/directory');

foreach ($files as $file) {

    echo $file . "<br>";

}

c. Könyvtárak törlése:

• rmdir(): Ez a függvény egy üres könyvtárat töröl.

rmdir('path/to/directory');

Ha a könyvtár nem üres, akkor rekurzívan törölhetjük az összes benne lévő fájlt és könyvtárat egy egyéni funkcióval.

3. Fájlok és könyvtárak jogosultságainak kezelése:

A fájlok és könyvtárak jogosultságai kritikusak lehetnek a biztonság szempontjából, különösen olyan webhelyeken, ahol több felhasználó hozzáférhet a rendszerhez.

a. Jogosultságok beállítása:

• chmod(): Ezzel a függvénnyel fájlok és könyvtárak jogosultságait módosíthatjuk.

chmod('path/to/file.txt', 0644); // Fájl jogosultságainak beállítása

Az értékek bináris alapon értelmezhetők (pl. 0644 jelenti, hogy a tulajdonos olvashatja és írhatja a fájlt, míg a csoport és a többiek csak olvashatják).

b. Jogosultságok ellenőrzése:

• fileperms(): Ezzel a függvénnyel lekérdezhetjük egy fájl vagy könyvtár jogosultságait.

$permissions = fileperms('path/to/file.txt');

echo decoct($permissions & 0777); // A jogosultságok bináris formátumban

4. Fájlok feltöltése PHP-ben:

A fájlfeltöltések gyakoriak a webes alkalmazásokban, például profilképek, dokumentumok vagy más típusú fájlok feltöltésénél. A PHP beépített támogatást nyújt fájlok feltöltésére az űrlapokon keresztül.

Példa egy fájl feltöltésére PHP-ben:

HTML űrlap:

<form action="upload.php" method="POST" enctype="multipart/form-data">

    Válassz fájlt: <input type="file" name="fileToUpload">

    <input type="submit" value="Feltöltés">

</form>

PHP feldolgozás:

<?php

$target_dir = "uploads/";

$target_file = $target_dir . basename($_FILES["fileToUpload"]["name"]);

$uploadOk = 1;

// Ellenőrizzük, hogy a fájl már létezik-e

if (file_exists($target_file)) {

    echo "A fájl már létezik.";

    $uploadOk = 0;

}

// Fájl feltöltése, ha nincs hiba

if ($uploadOk == 1) {

    if (move_uploaded_file($_FILES["fileToUpload"]["tmp_name"], $target_file)) {

        echo "A fájl feltöltése sikerült: " . basename($_FILES["fileToUpload"]["name"]);

    } else {

        echo "Hiba történt a fájl feltöltésekor.";

    }

}

?>

5. Haladó fájlműveletek:

a. Fájlok másolása, mozgatása és átnevezése:

·        copy(): Egy fájl másolása egyik helyről a másikra.

copy('path/to/source.txt', 'path/to/destination.txt');

·        rename(): Egy fájl vagy könyvtár átnevezése vagy áthelyezése.

rename('path/to/old_name.txt', 'path/to/new_name.txt');

b. Fájlméret és létrehozás dátumának lekérdezése:

·        filesize(): Egy fájl méretének lekérdezése bájtokban.

echo filesize('path/to/file.txt') . " bájt";

·        filemtime(): Egy fájl utolsó módosítási időpontjának lekérdezése.

echo "Utolsó módosítás: " . date("F d Y H:i:s.", filemtime('path/to/file.txt'));

6. Biztonsági megfontolások:

A fájlkezelés során különösen fontos a biztonság:

• Fájlnevek ellenőrzése: Soha ne fogadjuk el közvetlenül a felhasználótól kapott fájlneveket, mindig ellenőrizzük azokat.
• Könyvtárfeltörés megakadályozása: Használjunk relatív útvonalakat és ellenőrizzük, hogy a felhasználó nem próbál meg könyvtárszintet ugrani (pl. ../ karakterekkel).
• Fájlméret és típus ellenőrzése: Fájlok feltöltésekor korlátozzuk a fájlok méretét és típusát, hogy elkerüljük a rosszindulatú fájlok feltöltését.

6. Biztonsági megfontolások:

·        Fájlméret és típus ellenőrzése: Amikor fájlokat töltünk fel, mindig érdemes korlátozni a fájlok maximális méretét és ellenőrizni a fájl típusát, hogy csak megengedett típusokat fogadjunk el (például képeket, dokumentumokat). Ezt a következőképpen lehet megvalósítani:

// Ellenőrizzük a fájlméretet (max 2 MB)

if ($_FILES['fileToUpload']['size'] > 2000000) {

    echo "A fájl túl nagy.";

    $uploadOk = 0;

}

// Ellenőrizzük a fájltípust (csak képek)

$fileType = strtolower(pathinfo($target_file, PATHINFO_EXTENSION));

if (!in_array($fileType, ['jpg', 'png', 'jpeg', 'gif'])) {

    echo "Csak JPG, JPEG, PNG és GIF fájlok engedélyezettek.";

    $uploadOk = 0;

}

·        Fájlnév szűrése: Mindig biztonságos fájlneveket használjunk, és szűrjük a fájlneveket, hogy elkerüljük a könyvtárszint ugrásokat vagy rosszindulatú fájlok feltöltését. Például, ha a fájl tartalmaz tiltott karaktereket (pl. ../), azt cserélhetjük biztonságos alternatívára.

·        Jogosultságok kezelése: Győződj meg arról, hogy a fájlokhoz és könyvtárakhoz megfelelő jogosultságok vannak beállítva, hogy csak az engedélyezett felhasználók férjenek hozzá az adatokhoz. Például a feltöltött fájlokat be lehet állítani, hogy csak olvashatók legyenek a nyilvánosság számára, de ne legyenek írhatók:

chmod('uploads/somefile.txt', 0644); // Csak olvasható jogosultság a felhasználók számára

Összefoglalás:

A PHP fájlkezelés haladó technikái számos eszközt kínálnak a fájlok és könyvtárak kezelésére, beleértve az olvasást, írást, törlést, másolást és áthelyezést. Az ilyen műveletek során különösen fontos a jogosultságok megfelelő kezelése és a biztonságos fájlműveletek végrehajtása, például a fájlok feltöltésekor. A megfelelő biztonsági intézkedések és jogosultságkezelés segít elkerülni a lehetséges támadásokat, mint például a fájlbeillesztési támadások vagy a rosszindulatú fájlok feltöltése.

Ha egy PHP alapú rendszerben fájlokat és könyvtárakat kezelsz, ezek a technikák segíthetnek a hatékony és biztonságos működés biztosításában.

13 B - 12. PHP és AJAX: Aszinkron adatküldés és fogadás PHP és JavaScript használatával

 A PHP és AJAX (Asynchronous JavaScript and XML) egy hatékony módszer az aszinkron adatküldésre és -fogadásra, amely lehetővé teszi a weboldalak számára, hogy frissítsék az adatokat anélkül, hogy a teljes oldalt újra kellene tölteni. Ez javítja a felhasználói élményt, mivel a felhasználó valós időben kap visszajelzést, és gyorsabb adatfeldolgozás történik. Az AJAX használatával JavaScript segítségével küldhetsz adatokat egy szerverre (általában PHP-vel), majd a szerver visszaküldi a feldolgozott adatokat anélkül, hogy újratöltené az oldalt.

1. Az AJAX működése:

Az AJAX aszinkron adatküldést és fogadást tesz lehetővé a következő lépések szerint:

1. A JavaScript egy aszinkron kérést indít a szerver felé (pl. PHP script).
2. A PHP script feldolgozza a kérést (adatok mentése, lekérdezése, stb.), majd válaszol.
3. A JavaScript fogadja a PHP-től érkező választ, és frissíti a weboldalon az adatokat, anélkül, hogy újratöltődne az oldal.

2. AJAX használata JavaScript-ben:

Az AJAX lekérések megvalósítása JavaScript-ben többféle módon történhet. A két legnépszerűbb módszer a XMLHttpRequest objektum és a modern fetch() API használata.

a. XMLHttpRequest használata:

Példa egy egyszerű AJAX kérésre XMLHttpRequest-tel:

// Új XMLHttpRequest objektum létrehozása

let xhr = new XMLHttpRequest();

// A kérés konfigurálása

xhr.open('POST', 'backend.php', true);

xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');

// A kérés elküldése a szerver felé

xhr.send('name=John&email=john@example.com');

// A válasz kezelése

xhr.onreadystatechange = function() {

    if (xhr.readyState === 4 && xhr.status === 200) {

        // A válasz sikeresen megérkezett

        document.getElementById('result').innerHTML = xhr.responseText;

    }

};

Ebben a példában a JavaScript küld egy POST kérést a backend.php felé, amely adatokat dolgoz fel, majd visszaküldi az eredményt, amely megjelenik az oldalon egy result ID-jú elemen.

b. fetch() API használata:

A fetch() API egy modernebb és egyszerűbb módszer az aszinkron kérésekhez.

// fetch() API használata POST kérés küldéséhez

fetch('backend.php', {

    method: 'POST',

    headers: {

        'Content-Type': 'application/x-www-form-urlencoded',

    },

    body: 'name=John&email=john@example.com'

})

.then(response => response.text()) // A válasz feldolgozása textként

.then(data => {

    document.getElementById('result').innerHTML = data;

})

.catch(error => console.error('Hiba:', error));

A fetch() egyszerűbbé és olvashatóbbá teszi az aszinkron kéréseket, és támogatja az ígéretek (promises) használatát is.

3. PHP oldal kezelése:

A szerveroldali feldolgozáshoz általában PHP-t használunk. A PHP fogadja a JavaScript által küldött adatokat (GET vagy POST kérés), majd feldolgozza azokat (például adatbázisba mentés, adatlekérdezés), és visszaad egy választ a JavaScript számára.

Egyszerű PHP script a JavaScript által küldött POST adat fogadásához:

<?php

// Adatok fogadása

if ($_SERVER['REQUEST_METHOD'] == 'POST') {

    $name = $_POST['name'];

    $email = $_POST['email'];

    // Adatfeldolgozás (pl. adatbázisba mentés)

    // ...

    // Válasz küldése a kliens felé

    echo "Az Ön neve: $name, email címe: $email";

}

?>

Ez a PHP kód fogadja a JavaScript által küldött name és email adatokat, majd visszaküldi a feldolgozott eredményt a kliens oldal felé.

4. Gyakorlati példa PHP és AJAX integrációjára:

HTML űrlap:

<form id="ajaxForm">

    <label for="name">Név:</label>

    <input type="text" id="name" name="name" required>

    <label for="email">Email:</label>

    <input type="email" id="email" name="email" required>

    <button type="submit">Beküldés</button>

</form>

<div id="result"></div>

<script src="app.js"></script>

JavaScript az űrlap adatok aszinkron küldéséhez:

document.getElementById('ajaxForm').addEventListener('submit', function(e) {

    e.preventDefault(); // Megakadályozza az űrlap hagyományos elküldését

    // Az űrlap adatainak összegyűjtése

    const formData = new FormData(this);

    // Aszinkron kérés küldése

    fetch('backend.php', {

        method: 'POST',

        body: formData

    })

    .then(response => response.text())

    .then(data => {

        // Az eredmény megjelenítése

        document.getElementById('result').innerHTML = data;

    })

    .catch(error => console.error('Hiba:', error));

});

Ez a JavaScript kód megakadályozza az űrlap hagyományos beküldését, majd AJAX kérést küld a PHP szervernek az űrlap adataival, és megjeleníti az eredményt.

PHP az adatok feldolgozásához:

<?php

if ($_SERVER['REQUEST_METHOD'] == 'POST') {

    $name = htmlspecialchars($_POST['name']);

    $email = htmlspecialchars($_POST['email']);

    // Feldolgozás (pl. adatbázisba mentés)

    echo "Beküldött név: $name<br>";

    echo "Beküldött email: $email";

}

?>

Ebben a példában a PHP fogadja a JavaScript által beküldött adatokat, és megjeleníti azokat a böngészőben.

5. Hibakezelés AJAX kérések esetén:

Az AJAX kérések során fontos a hibakezelés is. A PHP hibás válaszai esetén a JavaScript-ben fel kell készülni a hibák kezelésére, és megfelelő üzeneteket kell megjeleníteni a felhasználónak.

Például a fetch() API-ban a hibák kezelésére használhatjuk a .catch() blokkot, amelyben a hálózati hibákat és más problémákat kezelhetjük:

fetch('backend.php', { method: 'POST', body: formData })

.then(response => {

    if (!response.ok) {

        throw new Error('Hálózati hiba történt');

    }

    return response.text();

})

.then(data => {

    document.getElementById('result').innerHTML = data;

})

.catch(error => {

    console.error('Hiba:', error);

    document.getElementById('result').innerHTML = 'Hiba történt az adatok beküldésekor.';

});

6. Biztonság AJAX használatakor:

Mivel az AJAX lehetővé teszi az adatokat aszinkron módon, ügyelni kell az adatok biztonságos kezelésére:

• Adat validáció a szerveroldalon: Mindig ellenőrizzük és szűrjük a beérkező adatokat a PHP oldalon, hogy elkerüljük a XSS és SQL injection támadásokat.
• CSRF védelem: Különösen formok esetében érdemes CSRF tokent használni, hogy megakadályozzuk a jogosulatlan adatküldést.
• HTTPS használata: Biztosítsuk, hogy a kérés titkosított csatornán (HTTPS) keresztül történjen, így a küldött adatok biztonságban vannak.

Összefoglalás:

Az AJAX segítségével könnyen küldhetünk és fogadhatunk adatokat PHP szerverrel anélkül, hogy újratöltenénk az oldalt. Ez a technika javítja a felhasználói élményt és hatékonyabb adatfeldolgozást tesz lehetővé. A modern böngészők támogatják az XMLHttpRequest objektumot és a fetch() API-t is, amelyekkel egyszerűen küldhetünk és fogadhatunk adatokat. Fontos azonban a megfelelő biztonsági intézkedések bevezetése a PHP oldalon.